Introduction to jBasic BASIC

Introduction
jBasic BASIC is a Business-oriented programming
language designed to work efficiently with the jBasic
environment.

It is easy for a beginning programmer to use yet

powerful enough to meet the needs of an experienced
programmer.

The power of jBasic BASIC comes from statements and

built-in functions that take advantage of the extensive
database management capabilities of jBasic.

These benefits combined with other BASIC extensions

result in a development tool well-suited for a wide range
of applications.
 BASIC Terminology

A BASIC program is a set of statements directing the

computer to perform a series of tasks in a specified order.

Source code is the original form of the program written by

the programmer.

Object code is compiler output, which can be executed by

the jBasic RUN command or called as a subroutine.
 Variable
A variable is a symbolic name assigned to one or more data
values stored in memory. A variable’s value can be numeric or
character string data, the null value, or it can be defined by
the programmer, or it can be the result of operations
performed by the program.

Variable names can be as long as the physical line, but only

the first 64 characters are significant.

Variable names begin with an alphabetic character and can

include alphanumeric characters, periods ( . ), dollar signs
( $ ), and percent signs ( % ).

Upper- and lowercase letters are interpreted as different; i.e.,

REC and Rec are different variables.
 Function

A BASIC intrinsic function performs mathematical or string

manipulations on its arguments.

It is referenced by its keyword name and is followed by the

required arguments enclosed in parentheses.

Functions can be used in expressions; in addition, function

arguments can be expressions that include functions.

jBasic BASIC contains both numeric and string functions.

 Subroutine

A Subroutine is a set of instructions that perform a specific

task.

It is a small program that can be embedded in a program and

accessed with a GOSUB statement, or it can be external to the
program and accessed with a CALL statement.

Common processes are often kept as external subroutines.

This lets the programmer access them from many different
programs without having to rewrite them.

When a GOSUB or CALL statement is encountered, program

control branches to the referenced subroutine.
 SOURCE SYNTAX

A BASIC source line has the following syntax:

 
[ label ] statement [ ; statement … ] <Return

More than one statement can be written on a line by

separating the statements with semicolons. A BASIC
source line can begin with a statement label. It always
ends with a carriage return (Return). It can contain up to
256 characters and can extend over more than one
physical line.
 Statement Types

BASIC statements can be used for any of the

following purposes:

• Input and output control

• Program control
• Assignment (assigning a value to a variable)
• Documentation
 Statement Labels

A statement label is a unique identifier for a program line. A

statement label consists of a string of characters followed
by a colon.

Like variable names, alphanumeric statement labels begin

with an alphabetic character and can include periods ( . ),
dollar signs ( $ ), and percent signs ( % ).

Upper- and lowercase letters are interpreted as different;

i.e., ABC and Abc are different labels.

A statement label can be put either in front of a BASIC

statement or on its own line. The label must be first on the
line - i.e., the label cannot begin with a space.
 Special Characters

The jBasic BASIC character set comprises alphabetic,

numeric, and special characters. The alphabetic
characters are the upper- and lowercase letters of the
alphabet. The numeric characters are the digits 0
through 9. The special characters are as follows.

= + – * ** / ^ (

) # $ ! [ ] , .

’ ; : & < > @ _

 Getting Started
To create and use a BASIC program, follow these steps:

1. Use the CREATE.FILE command to create a type 1 or type 19

jBasic file to store your BASIC program source. The RUN
command uses the filename BP if a filename is not specified, so
many people use BP as the name of their general BASIC program
file.
2. Use the jBasic Editor or some other editor to create the source for
your BASIC program as a record in the file you created in step 1.
3. Once you have created the record containing your BASIC program
source statements, use the BASIC command to compile your
program. The BASIC command creates a file to contain the object
code output by the compiler. You do not have to know the name
of the object file because the program is always referred to by the
source filename.
4. If the BASIC compiler detects any errors, use the Editor to correct
the source code and recompile using the BASIC command.
5. When your program compiles without any errors, you can execute
it using the RUN command.
 Data Types

Although many program languages distinguish

different types of data, the jBasic BASIC compiler
does not.

All data is stored internally as character strings,

and data typing is done contextually at run time.

There are three main types of data:

character string,
numeric, and
unknown (i.e., the null value).
 Character String Data

Character string data is represented internally as a

sequence of ASCII characters.

Character strings can represent either numeric or

nonnumeric data.

Their length is limited only by the amount of

available memory.

Numeric and nonnumeric data can be mixed in the

same character string (for example, in an address).
 Character String Constants
In BASIC source code, character string constants are a
sequence of ASCII characters enclosed in single or
double quotation marks, or backslashes ( \ ). These marks
are not part of the character string value. The length of
character string constants is limited to the length of a
statement.
 
Examples of character string constants:
"Emily Daniels"
'$42,368.99'
'Number of Employees'
"34 Cairo Lane"
\"Fred's Place" isn't open\

The beginning and terminating marks enclosing character

string data must match.
 Character String Constants

The empty string is a special instance of

character
string data.

It is a character string of zero length.

Two adjacent double or single quotation marks,

or
back-slashes, specify an empty string:

' ' or "" or \\

 Numeric Data
All numeric data is represented internally either as floating-point
numbers with the full range of values supported by the system’s
floating-point implementation, or as integers

Numeric constants can be represented in either fixed-point or

floating-point form. Commas and spaces are not allowed in numeric
constants.

Fixed-point constants consists of a sequence of digits, optionally

containing a decimal point and optionally preceded by a plus ( + )
or minus (-- ) sign. Some examples of valid fixed-point constants
are: 12 -132.4 +10428

Floating-point constants consists of a sequence of digits, optionally

preceded by a plus (+) or minus (-) sign representing the mantissa.
The sequence of digits is followed by the letter E and digits,
optionally preceded by a minus sign, representing the power of 10
exponent. Some examples of valid floating-point constants are:
1.2E3 -7.3E42 -1732E-4
 Unknown Data: The Null Value
The null value has a special run-time data type in jBasic BASIC.  

Do not confuse the null value with the empty string. The empty
string is a character string of zero length which is known to have no
value.

Unlike null, whose value is defined as unknown, the value of the

empty string is known. You cannot use the empty string to represent
the null value, nor can you use the null value to represent “no
value.”

Like all other data in jBasic BASIC, the null value is represented
internally as a character string. The string is made up of the single
byte CHAR(128).

jBasic BASIC programs can reference the null value using the system
variable @NULL.

ISNULL and ISNULLS functions are used to test whether a value is

 Unknown Data: The Null Value

Example:
If you concatenate a string value with an empty string, the string
value is returned, but if you concatenate a string value with the null
value, null is returned.
A = @NULL
B = ""
C = "JONES"
X = C:B
Y = C:A

The resulting value of X is "JONES", but the value of Y is the null

value.

When you concatenate known data with unknown data, the result is
unknown.
 Constants

Constants are data that do not change in value, data

type, or length during program execution.

Constants can be character strings or numeric strings

(in either integer or floating-point form).

A character string of no characters - the empty string -

can also be a constant.
 
 Variables
Variables are symbolic names that represent stored data
values. The value of a variable can be:

Unassigned
A string, which can be an alphanumeric character string, a
number, or a dynamic array
A number, which can be fixed-point (an integer) or floating-
point
The null value
A dimensioned array (that is, a vector or matrix)

A subroutine name
A file
A select list
 Array Variables
An array is a variable that represents more than one data value. There
are two types of arrays - Static and dynamic.

Static Arrays:
Each value in an array is called an element of the array. Arrays can be
one or two-dimensional.
 
A one-dimensional array is called a vector. Its elements are arranged
sequentially in memory. The index of the first element is 1.
Examples: A(1), COST(35)

A two-dimensional array is called a matrix. The elements of the first

row are arranged sequentially in memory, followed by the elements of
the second row, and so on.
Examples: PROFIT(4,3), LOSSES(8,5)
 Dynamic Arrays
Dynamic arrays map the structure of jBasic file records to
character string data.

Any character string can be a dynamic array.

A dynamic array is a character string containing elements that

are substrings separated by delimiters.

At the highest level these elements are fields separated by field

marks (F) (ASCII 254). Each field can contain values
separated by value marks (V) (ASCII 253). Each value can
contain subvalues separated by subvalue marks (S) (ASCII
252).
 Dynamic Arrays
Fields, values, and subvalues containing the empty string are
represented by two consecutive field marks, value marks, or subvalue
marks, respectively.
 
The following character string is a dynamic array with two fields:

TOMSDICKSHARRYVBETTYSSUESMARYFJONESVSMITH 
 
The two fields are:
 
  TOMSDICKSHARRYVBETTYSSUESMARY
and:
 
JONESVSMITH
 Dynamic Arrays

Conceptually, this dynamic array has an infinite number of fields,

all of which are empty except the first two. References made to
the third or fourth field, for example, return an empty string.
 
The first field has two values:
 
TOMSDICKSHARRY and  BETTYSSUESMARY

The first value has three subvalues: TOM, DICK, and HARRY. The
second value also has three subvalues: BETTY, SUE, and MARY.

The second field has two values:

JONES and SMITH

Each value has one subvalue:

JONES and SMITH

 Dynamic Arrays

The following character string:

 
NAME AND ADDRESS 

can be considered a dynamic array containing one field, which

has one value, which has one subvalue, all of which are: NAME
AND ADDRESS.
 
The following character string can be considered a dynamic
array containing two fields:
 
JONESVSMITHVBROWNF$1.23VV$2.75

The first field has three values: JONES, SMITH, and BROWN. The
second field has three values: $1.23, an empty string, and $2.75.
 Dynamic Arrays
We can create a dynamic array in two ways: by treating it as a
concatenation of its fields, values, and subvalues; or by
enclosing the elements of the dynamic array in angle brackets,
using the syntax:
array.name < field# , value# , subvalue# >
 
For example, to create the dynamic array A as:
  JONESVSMITHF1.23S20V2.50S10
We can say:
A="JONES":@VM:"SMITH":@FM:1.23:@SM:20:@VM:2.50:@SM:10
 
or we can say:
A = ""
A<1,1> = "JONES"
A<1,2> = "SMITH"
A<2,1,1> = 1.23
A<2,1,2> = 20
A<2,2,1> = 2.50
A<2,2,2> = 10
 Operators

Operators perform mathematical, string, and logical

operations on values. Operands are expressions on which
operations are performed.

BASIC operators are divided into the following categories:

Arithmetic,
String,
Relational,
Pattern matching,
IF operator,
Logical,
Assignment and
Dynamic array
 String Operators
The concatenation operator (: or CAT) links string expressions to
form compound string expressions, as follows:
'HELLO. ' : 'MY NAME IS ' : X : ". WHAT'S YOURS?"
or
'HELLO. ' CAT 'MY NAME IS ' CAT X CAT ". WHAT'S YOURS?"
 
If, for instance, the current value of X is JANE, these string
expressions both have the following value:
"HELLO. MY NAME IS JANE. WHAT'S YOURS?"
 
Multiple concatenation operations are performed from left to right.
With the exception of the null value, all operands in concatenated
expressions are considered to be string values, regardless of
whether they are string or numeric expressions. However, the
precedence of arithmetic operators is higher than the
concatenation operator. For example:
"THERE ARE " : "2" + "2" : "3" : " WINDOWS."
has the value:
"THERE ARE 43 WINDOWS."
 Relational Operators

Operator Relation Example

 
EQ or = Equality X=Y
NE or # Inequality X#Y
>< or <> Inequality X <> Y
LT or < Less than X<Y
GT or > Greater than X>Y
LE or <= or Less than or equal to X <= Y
=< or #>
GE or >= or Greater than or equal to X >= Y
=> or #<
 Pattern Matching Operators

The pattern matching operator, MATCH, and its synonym,

MATCHES, compare a string expression to a pattern. The
syntax for a pattern match expression is:
 
string MATCH [ES] pattern
 
The pattern is a general description of the format of the string. It
can consist of text or the special characters X, A, and N preceded by
an integer used as a repeating factor. X stands for any characters, A
stands for any alphabetic characters, and N stands for any numeric
characters.

For example, 3N is the pattern for character strings made up of three

numeric characters. If the repeating factor is zero, any number of
characters will match the string. For example, 0A is the pattern for
any number of alphabetic characters, including none.
 IF Operator

The IF operator lets you indicate a value conditional upon

the truth of another value. The IF operator has the following
syntax:

variable = IF expression THEN expression ELSE expression

 
variable is assigned the value of the THEN expression if the
IF expression is true, otherwise it is assigned the value of
the ELSE expression.

The IF operator is similar to the IF statement, but it can

sometimes be more efficient
 Logical Operators
Numeric data, string data, and the null value can function as
logical data. Numeric and string data can have a logical value
of true or false. The numeric value 0 (zero), is false; all other
numeric values are true. Character string data other than an
empty string is true; an empty string is false. The SQL null
value is neither true nor false. It has the special logical value
of null.
Logical operators perform tests on logical expressions.
Logical expressions that evaluate to zero or an empty string
are false. Logical expressions that evaluate to null are null.
Expressions that evaluate to any other value are true.
 
The logical operators in jBasic BASIC are:
        AND (or the equivalent &)
        OR (or the equivalent !)
        NOT
 Assignment Operators
Operator Syntax Description
 
= variable = expression Assigns the value of expression
to variable without any other
operation specified.
+= variable += expression Adds the value of expression to
the previous value of variable
and assigns sum to variable
-= variable -= expression Subtracts the value of
expression from the previous
value of variable and
assigns the difference to
variable.
:= variable := expression Concatenates the previous
value of variable and the value
of expression to form a new
value for variable.
 Dynamic Array Operations
Vector functions process lists of data rather than single
values. By using the VEC.MATH (or V) option of the
$OPTIONS statement, the arithmetic operators (+, -, *, /) can
also operate on dynamic arrays as lists of data.

The operations performed by vector functions or operators

are essentially the same as those performed by some
standard functions or operators. The difference is that
standard functions process all variables as single-valued
variables, treating delimiter characters as part of the data.
On the other hand, vector functions recognize delimiter
characters and process each field, value, and subvalue
individually. Vector functions process single-valued
variables as if they were dynamic arrays with only the first
value defined.
 Dynamic Array Operations

Example:

A = 123V456S7890S2468V10F3691V33S12

B = 13V57S912F1234V8

$OPTIONS VEC.MATH

X=A+B
 Dynamic Array Operations
the result is:
X <1, 1, 1> = 136
X <1, 2, 1> = 513
X <1, 2, 2> = 8802
X <1, 2, 3> = 2468
X <1, 3, 1> = 10
X <2, 1, 1> = 4925
X <2, 2, 1> = 41
X <1, 2, 2> = 12
 
These elements are put into the resultant dynamic array, separated by
the delimiter mark corresponding to the highest levels that are
different (for example, X<1,1,1> and X<1,2,1> have different value
levels, so they are separated by a value mark). This yields the
following:

X = 136V513S8802S2468V10F4925V41S12