This section means to define Basmark QuickBASIC as a computer programming language in a formal sense. Programs, modules, data, variables, expressions, flow of control and the like are considered as academic knowledge. The details of statements and their run-time behavior is delegated to the Statements, Functions and Variables section of this manual.
The character set of BASIC consists of the white space characters: space, tab and newline (octal 40, 11 and 12) and the all the printable ASCII characters (octal 41-176) except at sign, grave accent, square brackets, curly brackets, vertical line and tilde (octal 100, 140, 133, 135, 173, 175, 174 and 176).
In addition every other character (except the null character) is a member of the set but only within string literals, DATA statements and remarks.
A word is represented by a sequence of one to forty characters. The first character is alphabetic. The remaining characters are alphanumeric or the decimal point (octal 56). Both upper and lower case alphabetics are allowed and are distinguished.
Blanks and tabs may appear anywhere except within words without affecting compilation. At least one blank or tab must appear between adjacent words.
A dollar word is a word optionally followed by a dollar sign (octal 44). Thus dollar words include the category of words. A dollar word with a dollar sign is distinguished from a dollar word without a dollar sign.
Words and dollar words are used in various contexts to identify various objects. Words spelled the same and used in the same context refer to the same object. Words spelled differently or used in different contexts refer to different objects. Some dollar words have predefined meanings and may only be used for their prescribed purposes. See the Reserved Words section below for a complete list of these dollar words.
The data types are four. Integers are 16 bit 2’s complement values. Single-precision values are 32 bit floating point values. Double-precision values are 64 bit floating point values. The integer, single-precision and double-precision types are collectively referred to as the numeric types. The single-precision and double-precision types are collectively referred to as the floating point types. Strings are sequences of zero or more characters (bytes). The lengths of strings vary dynamically.
Integers are limited to the range -32768 to 32767. The limits on floating point values are implementation dependent but certainly zero is a value and all others have a sign. Strings are limited to a maximum of 32767 characters.
The following table summarizes the limits on floating point values for the
ANSI/IEEE Standard 754-1985:
| Single | Double | |
| Exponent field width | 8 | 11 |
| Mantissa field width | 23 | 52 |
| Exponent maximum | 38.5 | 308.3 |
| Exponent minimum | -37.9 | -307.7 |
| Mantissa maximum | 7.2 | 16.0 |
| Denormalized exp. min. | -44.9 | -323.3 |
Field widths are the number of bits available internally to represent a value. Exponent extrema are the limits of representable powers of ten. Mantissa maximum is the limit of representable base ten digits. Exponents below the minimum are representable by effectively trading off (one for one) mantissa for exponent. At the denormalized exponent minimum, the mantissa consists of only a final binary one.
The decimal representations of integer, single-precision and double-precision constants are similar. For some representations, the definitions of numeric constants (given below) are not sufficient to identify the type of the constant. In this case, the type of the constant is the simplest type sufficient to represent the constant. In the following, lower-case characters may be used in place of upper-case.
Integer constants may be represented in decimal, octal or hexadecimal. The decimal form is a series of one or more digits. Constants of this form may be followed by a percent sign (octal 45) to explicitly identify them as integers. The octal form is a series one or more octal digits (0-7) prefixed with “&” or “&O” (letter O). The hexadecimal form is a series of one or more hexadecimal digits (0-9 and A-F) prefixed with “&H”. The value given by the representation can not exceed the range of the integer type.
A floating point constant is represented as a series of one or more digits optionally including a decimal point (octal 56) and optionally followed by either an exponent specification or a type marker. The exponent specification consists of the letter D or E optionally followed by a sign character (octal 53 or 55) followed by one or more digits. The exponent specification indicates the power of ten by which the mantissa is scaled. The type markers are exclamation point (octal 41) to explicitly identify single-precision or pound sign (octal 43) to identify double-precision.
For a single-precision constant, the value given by the representation can exceed neither the range nor the precision of the single-precision type. For a double-precision constant, the value given by the representation can exceed neither the range nor the precision of the double-precision type.
A string constant (also known as a string literal) is represented as a series of zero or more characters enclosed in double quotes (octal 42). A double quote marks the end of the literal. The constant consists of the characters within the double quotes with no special interpretation. A string literal may not extend across lines. If the ending double quote is omitted, the string constant ends at the end of the line. Since no special mechanism exists to encode a double quote or newline (octal 12) within a string literal, it is not possible to specify a string literal which includes these characters.
An identifier is a word optionally followed by an explicit type marker. The type markers are: percent sign (octal 45) for integer; exclamation point (octal 41) for single-precision, pound sign (octal 43) for double-precision and dollar sign (octal 44) for string. If no type marker is present, the type of the identifier is given by the first character of the word according to the DEFtype statements (if any). If the first character of the identifier is not specified in any DEFtype statements, the type of the identifier is single-precision. An identifier is used to identify a variable or function.
Variables are scalars and arrays collectively. A scalar and array with the same identifier and type are distinct. Variables are identified by the word “Var” and string variables are identified by the word “StrVar” under the synopsis heading in the Statements, Functions and Variables section of this manual.
A scalar reference is an identifier. Scalars with the same identifier but different types are distinct.
An array reference is an identifier followed by a comma separated series of one or more subscripts enclosed in parentheses (octal 50 and 51). A subscript is an integer expression (see the Expressions section below). An array is a rectangular list with one or more dimensions. The number of elements in each dimension is given by a DIM statement. If there is no appropriate DIM statement, the number of elements in each dimension is ten. An additional zero element exists in each dimension unless explicitly declared to the contrary by the OPTION BASE statement. Each combination of subscripts refers to a distinct variable equivalent to a scalar.
An expression is a constant representation or a variable reference or a function reference (see the Function Evaluation section below). In addition the expression has several recursive definitions. An expression is an expression enclosed in parentheses (octal 50 and 51). An expression is a unary operator followed by an expression. An expression is an expression followed by a binary operator followed by an expression. An expression has a type (see the Mixed-Mode Expressions section below). Expressions are identified by the word “Expr”, numeric expressions are identified by the word “NumExpr” and string expressions are identified by the word “StrExpr” under the synopsis heading in the Statements, Functions and Variables section of this manual.
The classes of operators are three: arithmetic, relational and logical. The plus sign (octal 53) is also allowed as a unary operator and does nothing.
All arithmetic operations, except string concatenation (see the Concatenation section below), require numeric operands and produce numeric results.
Exponentiation is a binary operation which requires two double-precision operands and produces a double-precision result. The exponentiation operator is the caret mark (octal 136). The result represents the first operand raised to the power of the second operand.
Arithmetic negation is a unary operation which requires one numeric operand and produces a numeric result. The arithmetic negation operator is the minus sign (octal 55). The result represents the additive inverse of the operand.
Multiplication is a binary operation which requires two numeric operands and produces a numeric result. The multiplication operator is the asterisk (octal 52). The result represents the first operand times the second operand.
Division is a binary operation which requires two floating point operands and produces a floating point result. The division operator is the slash (octal 57). The result represents the first operand divided by the second operand.
Integer division is a binary operation which requires two integer operands and produces an integer result. The integer division operator is the backslash (octal 134). The result represents the first operand divided by the second operand. The result has no fractional part, i.e., the result is truncated.
Modulus is a binary operation which requires two integer operands and produces an integer result. The modulus operator is the word “mod”. The result represents the remainder from the division of the first operand by the second operand.
Addition is a binary operation which requires two numeric operands and produces a numeric result. The addition operator is the plus sign (octal 53). The result represents the first operand plus the second operand.
Concatenation is a binary operation which requires two string operands and produces a string result. The concatenation operator is the plus sign (octal 53). The text of the result represents the text of the first operand followed by the text of the second operand.
Subtraction is a binary operation which requires two numeric operands and produces a numeric result. The subtraction operator is the minus sign (octal 55). The result represents the first operand minus the second operand.
A relational operation is a binary operation which requires either two numeric operands or two string operands and produces an integer result. The relational operators are: less than “<” (octal 74), equal to “=” (octal 75), greater than “>” (octal 76), not equal to “<>” or “><”, less than or equal to “<=” or “=<” and greater than or equal to “>=” or “=>”. The result represents the comparison of the first operand and the second operand. The result is -1 if the comparison is true and zero if the comparison is false. String comparison is legal because strings can be sorted in lexicographic order based on their ASCII representations.
A logical operation requires one or two integer operands and produces an integer
result. Logical negation is a unary operation. The other logical operations
are binary operations. Logical operations are performed “bit-wise”,
i.e. the operation is performed independently on each bit or
pair of bits from the operand(s). The following table illustrates the
logical operations as they are performed for each bit:
| A | B | not A | A and B | A or B | A xor B | A eqv B | A imp B |
| 1 | 1 | 0 | 1 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 0 | 1 | 1 | 0 | 0 |
| 0 | 1 | 1 | 0 | 1 | 1 | 0 | 1 |
| 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 |
The logical negation operator is the word “not”. The result is the logical inverse of the operand. For each bit, the result is one if the operand is zero. Otherwise the result is zero.
The conjunction operator is the word “and”. The result is the conjunction of the operands. For each bit, the result is one if both operands are one. Otherwise the result is zero.
The disjunction operator is the word “or”. The result is the disjunction of the operands. For each bit, the result is one if either operand is one. Otherwise the result is zero.
The exclusive disjunction operator is the word “xor”. The result is the exclusive disjunction of the operands. For each bit, the result is one if the either but not both of the operands is one. Otherwise the result is zero.
The equivalence operator is the word “eqv”. The result is the equivalence of the operands. For each bit, the result is one if the operands are equal. Otherwise the result is zero.
The implication operator is the word “imp”. The result is the implication by the first operand of the second operand. For each bit, the result is one if the first operand is zero or the second operand is one. Otherwise the result is zero.
An expression composed of binary operations is represented as an operator-separated sequence of operands. Such an expression may be complicated further by unary operations. The order in which these operations are performed affects the legality and meaning of the expression. This section describes the manner in which an expression is evaluated as it affects the legality and meaning of the expression. Other details of the order of evaluation are intentionally not defined.
The contents of a parenthetical expression are evaluated before the result is used. This is the most important device for removing ambiguity in the order of evaluation.
Except as defined by higher level constructions, a schedule of operator
precedence further defines order of evaluation. Where an operand lies
between operators, the precedence of the operators are compared. The
operation with the higher precedence is performed first. This reduces
the complexity of the expression. The other operation is performed later
as the rules of expression evaluation are applied to the reduced expression.
The schedule of operator precedence is defined by the following table.
Operators higher in the table have higher precedence.
| Precedence of Operators | |
| ^ | Exponentiation |
| - | Arithmetic Negation |
| * / | Multiplication, Division |
| \ | Integer Division |
| mod | Modulus |
| + - | Addition, Concatenation, Subtraction |
| not | Logical Negation |
| and | Conjunction |
| or | Disjunction |
| xor | Exclusive Disjunction |
| eqv | Equivalence |
| imp | Implication |
Where an operand lies between operators of equal precedence, the operation to the left is performed first. Left-to-right associativity is the final and least important rule of the order of evaluation.
A function reference consists of an identifier optionally followed by a comma separated series of one or more arguments enclosed in parentheses (octal 50 and 51). An argument is an expression the type of which is given by the definition of the function. A function reference is distinguished from a variable reference by the identifier: function names are reserved words.
Function arguments are evaluated before the function is executed. Upon returning from the function, the result is available. The result has a type defined by the function.
Operands, array subscripts and function arguments are required to be of a particular type or set of types. Where strings are required, no flexibility exists. But where numeric types (or some subset of the numeric types) are required, any numeric type is allowed: type conversion is performed as required.
Many operations are defined as having numeric results with more than one type. The type of the result (which is the type under which the operation is actually performed) is determined by the type(s) of the operand(s). The result (and the operation) is double-precision if any of the operands are double-precision. Otherwise the result (and the operation) is single-precision if any of the operands are single-precision. Otherwise the operands are integers so the result (and the operation) is integer with one exception. The result (and the operation) of division is single-precision for integer operands. The operands are converted to the appropriate type before the operation is performed. Note that the group of operations discussed in this paragraph exclude those defined as having integer results only: these integer operations require integer operands (converted if necessary) as defined in the preceding paragraph.
Variables are assigned values with the LET statement. The form of the statement is the word “let” (which is optional) followed by a variable reference followed by the equal sign (octal 75) followed by an expression. If the type of the variable is string, the only type of expression allowed is string. If the type of the variable is numeric, the type of the expression may be any numeric type. The result of the expression is converted to the type of the variable if necessary.
It is important to note that there is a relationship between the sequence of characters in a source file and the sequence of execution of the operations that the characters represent. This is intuitively obvious to experienced programmers, however, the reasons for these rules are ultimately arbitrary. These fundamental rules are that the statement that appears first in a source file is executed first and that the grouping constructs with a separate beginning and ending statement may be nested, like parentheses. That is, when two or more beginning statements are followed, in the source file, by an equal number of ending statements, the last beginning statement corresponds to the first ending statement.
When a BASIC program is executed, control is transferred to (the executable code corresponding to) the first executable statement in the program. Execution ceases if the last statement in the program completes execution and control is defined to transfer to the next statement, i.e. control “falls off the end” of the program. Execution also ceases if the END, STOP or SYSTEM statements are executed or if a run-time error is detected and not trapped (see the Error Handling section below). Of course execution may also terminate for reasons beyond the scope of this manual. The BASIC statements are described in detail in the Statements, Functions and Variables section of this manual.
A line number has the form of an integer constant in the range one to 65535; however, no operation may be performed on a line number so it functions as a numeric identifier. A line label is a dollar word (see the Words section above). Line number and label references are used to redirect the flow of control to the line with the corresponding line number or label definition. These references are identified by the words “LineNum” and “LineLab” under the synopsis heading in the Statements, Functions and Variables section of this manual. Line number and label references may be used interchangeably except after the words THEN, ELSE and RUN where line number but not label references are allowed.
Except as described in this Flow of Control section, all executable BASIC statements are simple statements. After execution, control is transferred to the next executable statement in the program.
The varieties of conditional statements are three: IF statements, including the block IF statement; ON condition statements which include ON-GOTO and ON-GOSUB; and the SELECT CASE statements. In all cases, an expression is evaluated and upon the value of the expression rests the decision of which of several paths through the code is taken.
The conditional statement is the IF statement. The conditional expression is evaluated. If the result is non-zero, control is transferred to the THEN or GOTO clause. Otherwise if the statement includes an ELSE clause, control is transferred to this clause. If the result is zero and no ELSE clause is given, control is transferred to the next executable statement in the program. If the THEN or ELSE clause is selected, upon completion of the clause control is transferred to the next executable statement in the program.
The IF statement may also extend across lines as a block IF statement. The conditional expression is evaluated. If the result is non-zero, control is transferred to the following statement. If the result is zero and the block IF statement contains an ELSEIF statement, control is transferred to the ELSEIF statement where its conditional expression is evaluated. If the result is non-zero, control is transferred to the following statement. If the result is zero and the block IF statement contains another ELSEIF statement, control is transferred to the ELSEIF statement and each succeeding ELSEIF statement until a non-zero result occurs or the set of ELSEIF statements is exhausted. If all the conditionals evaluate to zero and the block IF statement contains an ELSE statement, control is transferred to the ELSE statement. If all conditionals evaluate to zero and the block IF statement contains no ELSE statement, control is transferred to the next executable statement after the block IF statement’s END IF statement. If any statements are selected within the block IF statement, upon completion of the selected statements (that is, when the next ELSEIF, ELSE or END IF statement is encountered), control is transferred to the next executable statement after the block IF statement’s END IF statement.
When a SELECT CASE statement is executed, the selection expression is evaluated and control is transferred to first following CASE or CASE ELSE statement and this selection value is used for comparison with the case list of the CASE statement (if any). If the case list matches, control is transferred to the statement following the CASE statement. If the case does not match and the SELECT CASE statement block contains another CASE statement, then control is transferred to the CASE statement and each succeeding CASE statement until a match of the selection value with the case list is found or the set of CASE statements is exhausted. If none of the case lists match and the SELECT CASE statement block contains a CASE ELSE statement, control is transferred to the statement following the CASE ELSE statement. If none of the case lists match and there is no CASE ELSE statement, then an error occurs. If any statements are selected within the SELECT CASE statement block, upon completion of the selected statements (that is, when the next CASE, CASE ELSE or END SELECT statement is encountered), control is transferred to the next executable statement after the SELECT CASE statement block’s END SELECT statement.
A case list is a comma separated list. If any of the the comma separated items in a list matches, then the case list itself matches. These items have three forms. In the first form, the selection value is compared with the value of a simple expression and a match occurs if the values are equal. In the second form, the selection value is compared with the values of two expressions, separated by the word TO, which represent the bounds of an inclusive range and a match occurs if the selection value is within this range. In the third and final form, the word IS is followed by a relational operator followed by a simple expression and a match occurs if the relational operation, constructed by replacing the word IS with the selection expression, is true.
The switching statements are the ON-GOTO and ON-GOSUB statements. The expression is evaluated and used as an index into a list of line numbers and/or labels. Control is transferred to the statement with the line number or label identified. Control is restored to the ON-GOSUB statement in the same manner as the ordinary GOSUB statement (see the Functions and Subroutines section above).
The iteration statement pairs are the DO and LOOP statement, the WHILE and WEND statements and the FOR and NEXT statements.
The WHILE-WEND pair is logically equivalent to a DO-LOOP pair in which the DO statement contains the word WHILE and the conditional expression.
The DO-LOOP has a degenerate form in which neither the DO nor LOOP statement contains a conditional expression. When the LOOP statement is executed, control is transferred to the DO statement.
If the DO (but not the LOOP) statement contains a conditional expression, when the DO statement is executed, the conditional expression is evaluated and tested. If the test is non-zero and the WHILE word appears, or the test is zero and the UNTIL word appears, control is transferred to the first executable statement after the DO statement. Otherwise control is transferred to the first executable statement after the LOOP statement. In any case, when the LOOP statement is executed control is transferred to the DO statement, the expression is evaluated. The test is performed and control is transferred as described above.
If the LOOP (but not the DO) statement contains a conditional expression, when the LOOP statement is executed, the conditional expression is evaluated. The test is performed and control is transferred as described above.
When the WHILE statement is executed, the expression is evaluated and tested. If the test is non-zero, control is transferred to the first executable statement after the WHILE statement. Otherwise control is transferred to the first executable statement after the WEND statement. When the WEND statement is executed, the expression is evaluated. The test is performed and control is transferred as described above.
When the FOR statement is executed, the initialization, limit and increment expressions are evaluated and the FOR variable is assigned the value of the initialization expression. The FOR variable is then tested. If the increment is positive and the FOR variable is greater than the limit or if the increment is negative and the FOR variable is less than the limit, control is transferred to the first executable statement after the NEXT statement. Otherwise control is transferred to the first executable statement after the FOR statement. When the NEXT statement is executed, the increment is added to the FOR variable. The test is performed and control is transferred as described above.
Functions and the GOSUB and CALL statements transfer control to functions and subroutines. Upon completion, control is restored to the calling statement. For functions, expression evaluation continues. For the GOSUB and CALL statements, control transfers to the next executable statement in the program.
When the GOSUB statement is executed, control is transferred to the statement with the line number or label given. When a RETURN statement is executed, control is restored to the last GOSUB statement executed. Subroutine calls may be nested. A special case of RETURN allows control to be transferred to the statement with the line number or label given instead of the last GOSUB statement vis-a-vis the GOTO statement (see below).
The branching statement is the GOTO statement. Control is transferred to the statement with the line number or label given.
The RUN statement with no line number or file name transfers control to the first executable statement in the program. The RUN statement with a line number transfers control to the statement with the line number given.
When a run-time error is detected or an ERROR statement is executed, error handling begins. If no ON ERROR GOTO statement has been executed, execution ceases. Otherwise, control is transferred to the statement with the line number or label given in the last ON ERROR GOTO statement executed. When a RESUME statement is executed, control is restored and error handling ends. The simple form of the RESUME statement restores control to the statement where the error was detected and the statement is re-executed. The RESUME NEXT form restores control to the statement after the statement where the error was detected. A special case of RESUME allows control to be transferred to the statement with the line number or label given instead of the statement where the error was detected vis-a-vis the GOTO statement (see above). Error handling may not be nested. If a run-time error is detected or an ERROR statement is executed during error handling, execution ceases.
The statements that transfer control to other programs are the CHAIN statement and (one form of) the RUN statement. When one of these statements is executed, control is transferred to the (executable) file with the file name given. Control is completely relinquished by the original program and the state (of control) of the program is lost.
A line consists of an optional line number definition followed by an optional line label definition followed by an optional colon (octal 72) separated series of (non-remark) statements followed by an optional remark. If a DATA statement appears, it must be the last statement on the line and may not be followed by a remark. A line number definition is a line number. A line label definition is a line label followed by a colon (octal 72). A line number or label definition marks a location to which the flow of control is transferred in the appropriate context. A statement’s line number or label must be unique, i.e. the same line number or label can not be used to mark another statement. Line numbers do not indicate order of execution.
Except within a DATA statement, remark, or string literal, an underscore (octal 137) may be used so that the next physical line is regarded as an extension of the current line. All characters from the underscore to the end of the current physical line are ignored. Also the underscore is regarded as a blank, thus words, constants, etc. may not be broken across lines with an embedded underscore.
A subprogram definition begins with a SUB statement and ends with an END SUB statement. A multi-line user-defined function definition begins with a DEF statement and ends with an END DEF statement. Subprogram and function definitions may not be nested. A subprogram or function definition is a domain unto itself: variable references within it are governed by scope rules and no flow of control construct may defeat its structure.
A variable has a “scope” or extent of meaning with respect to a subprogram or function definition. A variable that is a formal parameter to a subprogram or function definition is different from a variable with the same name and type outside that subprogram or function definition. A variable that is declared as “static” that appears within a subprogram or function definition is different from a variable with the same name and type outside that subprogram or function definition. A formal parameter or variable declared as “shared” may be redeclared as “static” giving the variable name new meaning. This redeclaration may occur at any point within a subprogram or function definition, the new variable is different from a variable with the same name and type prior to the redeclaration. A variable that is not declared as “shared” that appears within a subprogram definition is different from a variable with the same name and type outside that subprogram definition and is equivalent to declaring the variable as “static”.
A subprogram or function is executed only as the result of a CALL statement or reference within an expression (see the Function Evaluation section above). No other entry to a subprogram or function is permitted. If control is transferred to a SUB or DEF statement, control is transferred to the statement following the (corresponding) END SUB or END DEF statement.
Upon execution of a subprogram or function, the values of the formal parameters are assigned and control is transferred to (the executable code corresponding to) the first executable statement following the SUB statement. The return value of a subprogram or function may be assigned by an assignment to the subprogram or function name (see the Assignment section above). Execution of a subprogram ceases and control is restored upon encountering an EXIT SUB or END SUB statement. Execution of a function ceases and control is restored upon encountering an EXIT DEF or END DEF statement. No other exit from a subprogram or function is permitted.
An error handling routine may not appear within a subprogram or function definition. An ON ERROR GOTO statement may appear within a subprogram or function definition but the statement’s line number or label must refer to a location outside any subprogram or function definition. Similarly, a RESUME statement in the error handling routine must refer to a location within the appropriate subprogram or function definition (although this can not be enforced).
A module is physically equivalent to a file and is the largest unit considered by the compiler. Modules are collected by a link editor into a program. The link editor is beyond the scope of this manual. Data is communicated across modules only by common blocks. A module’s DATA statements are private to the module. The flow of control is transferred across modules only by subprogram calls. A module’s error handling routines are private to the module.
A common block is an ordered list of data elements. A data element may belong to at most one common block. One common block is unnamed; every other has a name which is a word (see the Words section above). One or more modules share a common block with the same name (or lack of a name). The order and attributes (but not the names) of the data elements in a common block must be the same in each module (although this can not be enforced).
The main module is the module where the execution of the program begins. One module is designated the main module by the meta-command $MAIN or by another method. Each program has exactly one main module.
The following dollar words (see the Words section above) are reserved for use by BASIC. They may not be used to identify program variables, labels, common blocks, etc. Words beginning with “fn” and “usr” are reserved for user function names (with and without dollar signs).
| abs | defsng | is | open | shell | |||||||
| and | defstr | key | option | sin | |||||||
| append | delete | kill | or | sound | |||||||
| as | dim | lbound | out | space$ | |||||||
| asc | do | lcase | output | spc | |||||||
| atn | draw | left$ | paint | sqr | |||||||
| auto | edit | len | peek | static | |||||||
| base | else | let | pen | step | |||||||
| beep | elseif | line | play | stick | |||||||
| bload | end | list | point | stop | |||||||
| bsave | environ | llist | poke | str$ | |||||||
| call | environ$ | load | pos | strig | |||||||
| case | eof | loc | preset | string$ | |||||||
| cdbl | eqv | locate | sub | ||||||||
| chain | erase | lock | pset | swap | |||||||
| chdir | erl | lof | put | system | |||||||
| chr$ | err | log | random | tab | |||||||
| cint | error | loop | randomize | tan | |||||||
| circle | exit | lpos | read | then | |||||||
| clear | exp | lprint | redim | time$ | |||||||
| close | field | lset | rem | timer | |||||||
| cls | files | ltrim | renum | to | |||||||
| color | fix | merge | reset | troff | |||||||
| com | fnxxxxx | mid$ | restore | tron | |||||||
| command$ | for | mkd$ | resume | ubound | |||||||
| common | fre | mkdir | return | ucase | |||||||
| cont | get | mkdmbf | right$ | unlock | |||||||
| cos | go | mki$ | rmdir | until | |||||||
| csng | gosub | mks$ | rnd | using | |||||||
| csrlin | goto | mksmbf | rset | usrxxxxx | |||||||
| cvd | hex$ | mod | rtrim | val | |||||||
| cvdmbf | if | motor | run | varptr | |||||||
| cvi | imp | name | sadd | varptr$ | |||||||
| cvs | inkey$ | new | save | wait | |||||||
| cvsmbf | inp | next | screen | wend | |||||||
| data | input | not | seg | while | |||||||
| date$ | input$ | oct$ | select | width | |||||||
| def | instr | off | sgn | write | |||||||
| defdbl | int | on | shared | xor | |||||||
| defint |
from The Basmark QuickBASIC Programmer’s Manual by Lawrence Leinweber