Vector Basic Interpreter Basic 80 Reference Manual

5IA)iC

intc:tit=tcl:c=t

MIClOSOI"l'

BASIC-88

Rsrision 5.9

RE!'ERENC! MANUPd.

Revision A

January

1, 1988

CopyriC)ht1988 Vector Graphic Inc.

Copyright 1979 Microsoft

Copyright

1980 by

Vector Graphic Inc.

All rights reserved.

Disclaimer
Vector Graphic makes no representations or warranties with respect to the
contents of this manual itself, \1ohetheror not the product it describes is

covered

by

a warranty or repair agreement. Further, Vector Graphic reserves

the right to revise this publication and to makechanges from time to time

in the content hereof without obl igation of Vector Graphic to notify any
person of such revision or changes, except ~en an agreement to the contrary
exists.

Revisions
The date and reV1Slon of each page herein appears at the bottom of each
page. 'I'he revision letter such as A or B changes if the MANUALhas been

improved but the PRODUCTitself has not been significantly ItDdified. 'I'he

date and revision on the Title Page corresponds to that of the page most

recently revised. Whenthe product itself is roodified significantly, the

product will get a new revia ion number, as shownon the manual's title page,
and the manual will revert to revision A, as if it were treating a brand new

product. EAaiMANUALSHOULDONLYBEUSEDWITHTHEPRODUCTIDENTIFIEDONTHE

TITLEPAGE.

'Ibis manualis intended for cemputer

suppliers, or others with at least a
nr::x:1eratetechnical knowledgeof small

canputers and canputer progranming,and the
basic c:p!ration of the Vector Graphic
canputer to be used.

'Ibis manualwill describe the features,
cannands, and syntax of Microsoft BASIC-80,
Revision 5.0, ani explain howit is used
on a Vector Graphiccanputer that uses CP/M

as its c:p!rating system. '!houghit oovers
every aspect of the language, it is not

intended as a training manualfor novice

programners•
Chapter

1

discusses BASIC-80generally.
Chapter 2 contains the syntax and use of
every cxmnandand statenent in BASIC-80,in

alphabetic order. Chapter 3 describes every

intrinsic function in BASIC80, also alpha-

betically. In the appendices, certain

tcpics such as disk I/O, using assembly
languagesubroutines, the relationship to

CP/M,ani the carrpatibility with the BASIC

carpiler, are discussed in greater detail,

and there are lists of error messages,ASCII

codes, mathfunctions, newfeatures in

Revision 5.0, ani sane tips on converting

£ran other BASIC's.

\

This is the reference manual for Vector Graphic's implementation of
Microsoft's BASIC-Se,Revision 5.e, one of the most extensive and .high-speed
BASIC'savailable. It meets the ANSIqualifications for BASIC,as set forth

in document BSRX3.60-l97S. Vector Graphic is proud to offer; the BASIC-S0
interpreter with Vector GraPlic systems.

For readers familiar with earlier versions of Microsoft BASIC,AppendixA
describes the enhancements in Revision 5.0 over earlier releases, including
incanpatibilities with them. If you have software written in one of the
earlier versions, check Appendix A for new features that may affect
execution.

This manual covers a number of upwardcompatible versions of BASIC-Se,

specifically the -SK,- -Extended," an; "Disk- versions. My feature in the

SKand Extended versions is available in the Disk version. The version

available fran Vector Graphic is the Disk version. Therefore, everything
described in this manual is present in the Vector Graphic implementation, no
matter ~at version it is listed under.

Most users will makeuse of the BASIC-aainterpreter. (The interpreter
is a progrClll ~ich allows entry and ed!tiB3 of BASICprograms, and executes
them line by line W1eneverdesired.) For certain specialized applications,
the Microsoft BASICcompiler (BASCOM)is also available through Vector

Graphic. 'lbe canpiler allows ~u to convert a BASIC-S0progrClll,originally
written and debu;ged using the interpreter, into machine language, Wlich can

then be executed at very high speed. \\hen ~u obtain the canpiler, you will
receiver a manual detailing its use, but because it may be relevent to a
user of the BASIC-aeinterpreter, Appendix L discusses the BASICcanpiler in

brief. Note that Appendix L lists several features which are present in the

interpreter but \tbich are absent or different in the canpiler. Programmers
intending to compile BASIC-S0programs must pay attention to these
differences.

In a Vector Graphic canputer, BASIC-Seruns in conjuction with the CP/M
operating system. The name of the BASIC-Seinterpreter file on the disk
supplied by Vector Graphic is -MBASIC.CQtl.- Therefore, in order to call up
the interpreter fran the CP/Mexecutive, do the following: First, if MBASIC

is not already present on the main CP/Mdiskette, mount the BASIC-Sedisk in
drive A. Then, following the A> prompt, type MaASle and then press the
RETURNkey. Optionally, you can enter one or more parameters before
depressil'Xl RETURN,including the name of the BASICprogram you want to

execute, the number of files you want OPENat one time, and the highest
memorylocation you want BASICto use. These options are discussed in
Appendix D. In this manual, the term -initialization" means the above
process, of calling up BASIC-Se,nothil'Xlmore.

Of particular interest is the option to immediately execute a BASIC
program by typiB3 its nane as a paraneter followil'Xl the word MBASIC. This
causes the program to be loaded, and then executed as if a RUNcommandwere

typed. In other words, the system jumps directly into the application
program whenMBASICis called up. Further, if you are using CP/M2, rather
than an earlier version of CP/M,you can configure ~ur system diskette to

bypass the CP/M.executive and instead carry out a particular CP/Mcommandor

utility, su::h as calling up MSASIC. You accomplish this by creating an

"auto" command, which you do

by

running the CONFIGutility present on the
CP/M2 serialized diskette. If your auto camnandcontains "MBASIC"followed
by the name of a BASICprogrClllon the same diskette, optionally followed

by

other parasneters, followed

by

a RETURN,then \lben you boot up the system, it

will bypass all executives and automatically begin executing the BASIC
program. (This assumes MBASIC.CCMand the BASICprogram are on the system
diskette aloD; with CP/M.) This allows creation of an attractive "turn-key"

package.

Appendix 0 explains several other canmandsand aspects of BASIC-aethat

deal specifically with CP/M. Use it as an integral part of this manual.

Please note the followirJ;J points whenusirJ;J this manual:
It is NOTnecessary to create a file tnder the CP/Mexecutive before it

can be used

by

BASIC-aa.

To return to the CP/Mexecutive fran the BASIC-8eexecutive, tyPe SYSTEM

followed

by

the RETURNkey.

Whenusin;r a Vector System B, Memorite II, Vector 3"311l,or other Vector

Graphic system having "memorymappedvideo" and using the option

gv

Extended
Systems M:>nitor, do NOTpress the LF or LINEFEEDkey in order to continue a
BASICline on a second line on the screen. Instead, the video driver will
cause the text to

"wrap

aro\.md"automatically. The same is true for any

serial terminal that has automatic wrap around.

~en listing progran text or output, BASIC-a"assunes it is outputting to

a l32-character widtb printer. If your system's printer is narrower, it

will be able to print lOn;Jlines only if the printer or the printer driver

software in the operating system has the ability to automatically wrap
around at the end of a line. '1bis is dePendent on the particular pr inter
you are using.

References to "printing" in this manual, as in most BASICmanuals, refer

to displaying text on the operator's console, which is usually a video
screen. '!be tem "printing" derives fran the original use of Teletype and
other hard-copy printin;J terminals. '!be manual will refer specifically to

the "line printer" when referring to output intended for the system's output

printer, (sometimes called the "lister"), which is usually a separate
peripheral fran the operator's console. OUtput directed

by

BASIC-Sillto the

"line printer" is sent

by

BASIC-aeto CP/M's logical lister output routine,

which normally saRis the data out via a channel connected electronically to

a printer of some kind. The t"'lOcanmandsthat cause BASIC-a"to send data

in this way to the "line printer" are LLISTand LPRINT.

Reference is made in several places to the console's bell. This is only

relevent if the terminal you are using has a bell. The Vector Graphic
memory-mapPedvideo console at this time has no bell.

APPENDIX C Assembly Language Subroutines
APPENDIX 0 BASIC-SO with the CP/M Operating System
APPENDIX E

APPENDIX I Converting Programs to BASIC-SO
APPENDIX

J

Summary of Error Codes and Error Messages

APPENDIX K Mathematical Functions

CRAPTER 1

GENE~ INFORMATION ABOUT BASIC-SO

The procedure for initialization will vary with different

implementations of BASIC-SO.· Check the appropriate appendix

at the back of this manual to determine how BASIC-SO is

initialized with your operating system.

1.2 MODES

Q!.

OPERATION

When BASIC-80 is initialized, it types the· prompt wOkw•

ftOkftmeans BASIC-SO is at command level, that is, it is

ready to accept commands. At this point, BASIC-SO may be

used in either of two modes: the direct mode or the
indirect mode.

In the direct mode, BASIC commands and statements are not

preceded by line numbers. They are executed as they are

entered. Results of arithmetic and logical operations may

be displayed immediately and stored for later use, but the

instructions themselves are lost after execution. This mode
is useful for debugging and for using BASIC as a

·calculatorWfor quick computations that do not require a
complete program.

The indirect mode is the mode used
Program lines are preceded by line
memory. The program stored in
entering the RUN command.

for entering programs.

numbers and are stored in

memory is executed by

Program.lines in a BASIC program have ~~e following format

(square brackets indicate optional):

nnnnn BASIC statement[:BASIC statement•••l<carriage return>

At the programmerts option, more than one BASIC statement
may be placed on a line, but each statement on·a line must
be separated from.the last by a colon.

A BASIC program line always begins with a line number, ends
with a carriage return, and may contain a maximum of:

72 characters in SK BASIC-SO

255 characters in Extended and Disk BASIC-SO.

In Extended and Disk versions, it is possible to extend a
logical line over more than one physical line by use of the
terminal's <line feed> key. <Line feed> lets you continue
typing a logical line on the next physical line without
entering a <carriage return>. (In the SK version, <line
feed> has no effect.

Every BASIC program line begins with a line number. Line
numbers indicate the order in which the program lines are
stored in memory and are also used as references when

branching and editing. Line numbers must be in the range

a

to 65529. In the Extended and Disk versions, a period (.)

may be used in EDIT, LIST, AUTO and DELETE commands to refer

to the current line.

1•4 CBARACTEll ~

The BASIC-SO character set is comprised of alphabetic
characters, numeric characters and special characters.

The alphabetic characters in BASIC-SO are the upper case and
lower case letters of the alphabet.

The numeric characters in BASIC-SO are the digits 0 through

9.

The following special characters and terminal keys are
recognized by BASIC-SO:

<delete>

<escape>

<line feed>
<carriage

return>

<backspace>

Name

BIaiik

Semicolon

Equal sign or assignment symbol
Plus sign

Minus sign

Asterisk or multiplication symbol

Slash or division symbol

Up arrow or exponentiation symbol

Left parenthesis
Right parenthesis
Percent
Number (or pound) sign

Dollar sign
Exclamation point
Left bracket

Right bracket
Comma
Period or decimal point

Single quotation mark (apostrophe)
Colon
Ampersand
Question mark
Less than
Greater than
Backslash or integer division symbol
At-sign
Underscore
Deletes last character typed.
Escapes Edit Mode subcommands.

See Section 2.16.
Moves print position to next tab stop.
Tab stops are every eight columns.
Moves to next physical line.

Terminates input of a line.

Deletes last character typed, and erases it from screen.

Interrupts program execution and returns to
BASIC-SO command level.

Backspace. Deletes the last character typed.
Tab. Tab stops are every eight columns.

output
second

while

Control-o

execution

restarts

Halts program

continues. A

output.
Retypes the line that is currently being

typed.

Suspends program execution.
Resumes program execution after a Control-S.
Deletes the line that is currently being

typed.

Constants are the actual values BASIC uses during execution.
There are two types of constants: string and numeric.

A string constant is a sequence of up to 255
characters enclosed in double quotation marks •.
string constants:

alphanumeric

Examples of

"HELLO"

"$25,000.00"

"Number of Employees"

Numeric constants are positive or negative numbers. Numeric
constants in BASIC cannot contain commas. There are five
types of numeric constants:

Whole numbers between -32768 and
+32767. Integer constants do not
have decimal points.

2. Fixed Point
constants

Positive or negative real numbers,
i.e., numbers that contain decL~al
points.

3. Floating Point

constants

Positive or negative numbers repre-·

sented in exponential form (similar
to scientific notation). A
floating point constant consists of
an optionally signed integer or
fixed point number (the mantissa)
followed by the letter E and an
optionally signed integer (the
exponent). The exponent must be in
the range -38 to +38.
Examples:

235.988E-7=.0000235988
2359E6 • 2359000000

(Double precision floating point
constants use the letter D instead
of E. S~e Section 1.5.1.)

Hexadecimal numbers with the prefix
&H.Examples:

&H76
&H32!'

Octal numbers with the prefix &0 or
&. Examples:

&0347
&1234

1.5.1 Single ~ Double Precision

!2E!~

Numeric constants

In the SK version of BASIC-SO, all numeric constants are
single precision numbers. They are stored with 7 digits of

precision, and printed with up to 6 digits.

In .the Extended and Disk versions, however, numeric
constants may be either single precision or double prec~s~on
numbers. With double precision, the numbers are stored with

16 digits of precision, and printed with up to 16 digits.

A single

precision constant is

any

numeric

constant

that

has:

1•

seven or fewer digits, or

2.

exponential form using

E,

or

3.

a trailing exclamation point

(1)

A double precision constant is

any numeric

constant

that

has:

1.

eight or more digits, or

2.

exponential form using

0, or

3.

a trailing number sign

(I)

Examples:
Single Precision constants

46.8

-7.09E-06

3489.0

22.51

345692811

-1.094320-06

3489.0+

7654321.1234

V~iables are names used to represent values that are used

in a BASIC program. ~he value of a variable may be assigned
explicitly by the programmer, or it may be assigned as the
result of calculations in the proqram. Before a variable is
assigned a value, its value is assumed to be zero.

BASIC-80 variable names may be any length, however, in the

8K version, only the first two characters are significant•

.In the Extended and Disk versions, up to 40 characters are

significant. ~he characters allowed in a variable name are
letters and numbers, and the decimal point is allowed in
Extended and Disk variable names. The first character must
be a letter. Special type declaration characters are also
allowed -- see below.

A variable name may not be a reserved word. The Extended
and Disk versions allow embedded reserved words; the 8K
version does not. If a variable begins with FN, it is
assumed to be a call to a user-defined function. Reserved

words include all BASIC-80 commands, statements, function

Variables may represent either a numeric value or a .string.

String variable names are written with a dollar sign

($)

as
the last character. For example: A$. nSALES REPORT". The
dollar sign is a variable type declaration character, that
is, it ndeclares· that the variable

will

represent a string.

In the Extended and Disk versions, numeric variable names

may declare inteqer, single or double precision values.

(All numeric values in SX are single precision.) The type

declaration characters for these variable names are as

follows:

, Integer variable

1 Single precision variable

t

Double precision variable

The default type for a numeric variable name is single
precision.

Examples of BASIC-SO variable names follow.

In Extended and Disk versions:

PIt

MINIMUM 1
LIMIT'

declares a double precision value
declares a single precision value
declares an integer value

In SX, Extended and Disk versions:

N$ declares a string value
ABC represents a single precision value

In the Extended and Disk versions of BASIC-SO, there is a
second method by which variable types may be declared. The

BASIC-SO statements DEFINT, DEFSTR, DEFSNG and OEFDSL may be

inclcded in a program to declare the types for certain

variable names. These statements are described in detail in

Section 2.12.

1.6.2 Array Variables

An array is a group or table of values referenced by the

same variable name. Each element in an array is referenced

by an array variable that is subscripted with integers or

integer expressions. An array variable name has as many
subscripts as there are dimensions in the array. For
example V(10) would reference a value in a one-dimensional
array, T(1,4) would reference a value in a two-dimensional
array, and so on.

When necessary, BAS~C will convert a numeric constant from
one type to another. The following rules and examples

should be kept in mind.

1. If a numeric constant of one type is set equal to a
numeric variable of a different type, the number

will be stored as the type declared in the variable

name. (If a string 'variable is set equal to a
numeric value o~ vice versa, a "Type mismatch"
error occurs.)
Example:

10 A% • 23.42

20 PRINT At

RON

23

2. During expression evaluation, all of the operands

in an arithmetic or relational operation are

converted to the same degree of precision, i.e.,
that of the most precise operand. Also, the result
of an arithmetic operation is returned to this
degree of precision.
EXamples:

10

ot •

61/7

The arithmetic was performed
20 PRINT Of in double precision and the
RUN result was returned in Of

.8571428571428571 as a double precision value.

10

0

=-

6#/7

20 PRINT

0

RON

.857143

The arithmetic was performed

in double precision and the

result was returned to 0 (single

precision variable), rounded and

printed as a single precision

value.

3. Logical operators (see Section 1.8.3) convert their
operands to integers and return an integer result.
Operands must be in the range -32768 to 32767 or an

"Overflow" error occurs.

4. When a floating point value is converted to an
integer, the fractional portion is rounded.
EXample:

10 C'l

:II

55.88

20 PRINT C%

RON

56

5. If a double precision variable is assigned a single
precision value,

only

the first seven digits,
rounded, of the converted number will be valid.
This is because

only

seven digits of accuracy

were

supplied with the single precision value. The
absolute value of the difference between the
printed double precision number and the original
single precision value will be less than 6.3E-8
times the original single precision value.
Example:

10 A • 2.04

20 B. • A

30 PRINT A;S#

RON

2.04 2.039999961853027

An expression may be simply a string or numeric constant, or

a variable, or it may combine constants and variables with
operators to produce a single value.

Operators perform mathematical or logical operations on

values. The operators provided by BASIC-SO may be divided

into four categories:

1. Arithmetic

2. Relational

1.8.1 Arithmetic Operators

The arithmetic operators, in order of precedence, are:

Operation
Exponentiation
Negation

Multiplication, Floating

Point Division

X·Y

X/Y

To change the order in which the operations
use parentheses. Operations within
performed first. Inside parentheses, the
operations is maintained.

Here are some sample algebraic expressions and their BASIC
counterparts.

are performed,
parentheses are
usual order of

Algebraic Expression

X+2Y

Y

X--

Z

XY

z-

X+Y

-Z

(X2) Y

y

Z

X

BASIC Expression

X+Y*2
X-y/z
X*Y/Z

(X+Y)/Z
(XA2)AY

XA(YAZ)

X*(-Y)

Two consecutive
operators must
be separated by
parentheses.

1.8.1.1 Integer Division And Modulus Arithmetic -
Two additional operators are-available in Extended and Disk
versions of BASIC-SO: Integer division and modulus
arithmetic.

Integer division is denoted by the
operands are rounded to integers

-32768 to 32767) before the division
quotient is truncated to an integer.

baCks lash (')• The

(must be in the range

is performed, and the

For example:

10\4

:I

2

25.68\6.99 • 3

The precedence of integer division is

multiplication and floating point division.

Modulus arithmetic is denoted by the operator MOD. It gives

the integer value that is the remainder of an integer
division. For example:

10.4 MOO 4

=

2 (10/4=2 with a remaL~der 2)

25.68 MOD 6.99

=

5 (26/7=3 with a remainder 5)

The precedence of modulus arithmetic is just after integer
di~lision.

1.8.1.2 Overflow And Division

!I

Zero -
If, during the evaluation of an exp-riSsion, a division by
zero is encountered, the "Division by zero" error message is

displayed, machine infinity with the sign of the numerator

is supplied as the result of the division, and execution
continues. If the evaluation of an exponentiation results
in zero being raised to a negative power, the "Division by
zero" error message is displayed, positive machine infinity
is ·supplied as the result of the exponentiation, and
execution continues.

If overflow occurs, the "Overflow" error message is

displayed, machine infinity with the algebraically correct

sign is supplied as the result, and execution continues.

1.8.2 Relational Operators

Relational operators are used to compare two values. The
result of the comparison is either "true" (-1) or "false"

(0). This result may then used to make a decision regarding

program flow. (See IF, Section 2.26.)
Operator Relation Tested

Expression

"

-

Equality

X-Y

<> Inequality

x<>y

< Less

than X<Y

>

Greater than

x>y

<-

Less 'thanor

equal to

x<=y

>-

Greater than

or equal to

x>-y

(The equal sign

is also used to assign a value

to a

variable. See LET, Section 2.30.)
When arithmetic and relational operators are combined in one

expression, the arithmetic is always performed first. 'For

example, the expression

is uue if the value of X plus Y is less than the value of

T-1 divided by Z. More examples:

IF SIN(X)<O GOTO 1000
IF I MOOJ<> 0 THEN K=K+1

1.9.3 Loqieal

Opera~ors

Logical opera~ors perform tes~s on multiple relations, bit
manipulation, or Boolean operations. The logical operator
returns a bitwise result which is either "true" (not zero)
or "false" (zero). In an expression, logical operations are
performed after a:ithmetic and relational operations. The
outcome of a logieal operation is de~ermined

as

shown in the

following table. The operators are listed in order of

precedence.

NOT

X

NOT

X

1

0

0

1

AND

X

y

X AND

y

1

1 1

1

0 0

0

1

0

0 0

0

OR

X

Y X OR Y

1

1

1

1

0

1

0

1

1

0 0 0

XOR

X

Y

X

XOR Y

1

1

0

1

0

1

0

1 1

0

0 0

IMP

X

Y X IMP Y

1

1 1

1

0 0

0

1

1

0

0

1

EQV

X

Y

X

EQV

y

1

1

1

1

0 0

0

1

0

a

a

1

Just as the relational operators can be used to make
decisions regarding program flow, logical operators can
connect two or more relations and return a true or false

value to be used in a decision (see IF, Section 2.26). For

IF 0<200 AND F<4 TEEN 80
IF I>10 OR K<O THEN 50
IF NOT P THEN 100

Logical operators work by converting their operands to
sixteen bit, siqned, two

r

S

complement integers in the range

-32768 to +32767. (If the operands are not in this range,
an error results.) If both operands are supplied as 0 or -1,

logical operators return 0 or -1. The given operation is
performed on these integers in bitwise fashion, i.e., each
bit of the result is determined by the corresponding bits in
the two operands.

Thus, it is possible to use logical operators to test bytes

for a particular bit pattern. For instance, the AND
operator maybe used to "mask" all but one of the bits of a

status byte at a machine I/O port. The OR operator may be
used to "merge" two bytes to create a particular binary
value. Tbe following examples will help demonstrate how the

logical operators work.

63 • binary 111111 and 16 • binary
10000, so 63 AND 16 - 16

15 • binary 1111 and 14 - binary 1110,
so 15 AND 14 - 14 (binary 1110)

-1 - binary 1111111111111111 and
8 • binary 1000, so -1 AND 8 • 8

4 • binary 100 and 2 -binary 10,
so 4 OR 2 - 6 (binary 110)

10 - binary 1010, so 1010 OR 1010 •

1010 (10)

-1 • binary 1111111111111111 and

-2 • binary 1111111111111110,
so -1 OR -2 • -1. The bit

complement of sixteen zeros is

sixteen ones, which is the
two's complement representation of -1.

The two's complement of any integer

is t,hebit complement plus one.

1.S.4 Functional Operators

A function is used in an expression to call a predetermined

operation that is to be performed on an operand. BASIC-SO
has "intrinsic" functions that reside in the system, such as
SQR (square root) or SIN, (sine). All of BASIC-SO's
intrinsic functions are described in Chapter 3.

BASIC-SO also allows "user defined" functions that are

written by the programmer. See OEF FN, Section 2.11.

1.S.5 String Operations

Strings may be concatenated using

+.

For example:

10 A$-"FILE" : B$."NAME"
20 PRINT A$+B$
30 PRINT "NEW "+A$

+

B$
RON
FILENAME

NEW FILENAME

Strings may be compared using the same relational operators
that are used with numbers:

String comparisons are made by taking one character at a
time from each string and comparing the ASCII codes. If all
the ASCII codes are the same, the strings are equal. If the
ASCII codes differ, the lower code number precedes· the
higher. If, during string comparison, the end of one string

is reached, the shorter string is said to be smaller.

Leading and trailing blanks are significant. Examples:

"AA"<"AB"
"FILENAME" • "FILENAME"

"X,">"X."

"CL "

>

"CL"

"kg">"KG"

" SMYTH"

<

"SMYTHE·

t

B$

<

"9/12/7S" where B$ • "S/12/7S"

Thus, string comparisons can be used to test string values
or to alphabetize strings. All string constants used in
comparison expressions must be enclosed in quotation marks.

If an incorrect character is entered as a line is being
typed, it can be deleted with the DElete key 'orwith

BAC<SPACE •

DElete surrounds the deleted character (s) with

backslashes, and

~PACE'

has the effect of backspacing
over a character and erasing it. Once a character(s) has
been deleted, simply continue typing the line as desired.

To delete.a line that is in the process of being typed, type
Control-U. A carriage return is executed automatically

after the line is deleted.

To correct program lines for a program that is currently in
memory, simply retype the line using the same line number.
BASIC-SO will automatically replace the old line with the
new line.

More sophisticated editing capabilities are provided in the
Extended and Disk versions of BASIC-SO. See EDIT, Section

2.16.

To delete the entire program that is currently residing in
memory, enter the NEW command. (See Section 2.41.) NEW is
usually used to clear memory prior to entering a new
program.

If BASIC-SO de~ects an error that causes program execution
to terminate, an error message is printed. In the SK

version, only the error code is printed. In the Extended

and Disk versions, the entire error message is printed. For
a complete list of BASIC-SO error codes and error messages,
see Appendix

J.

CRAPTER2

BASIc-eo COMMANDS AND STATE.'1EN'I'S

All of the BASIC-eO commands and statements are described in
this chapter. Each description is formatted as follows:

Shows the correct format for the instruction.
See below for format notation.

Lists the versions of BASIc-eo

in which ~e instruction is available.

Purpose:

Remarks:

Describes in detail how the instruction

is used.
Shows sample programs or program segments

that demonstrate the use of the instruction.

Format Notation
Wherever the format for a statement or command is given, the

following rules apply:

1. Items in capital letters must be input as shown.

2. Items in lower case letters enclosed in angle
brackets

«

»

are to be supplied by the user.

3. Items in square brackets ([

J)

are optional.

4. All punctuation except angle brackets and square

brackets (i.e., commas, parentheses, semicolons,
hyphens, equal signs) must be included where shown.

s.

Items followed by an ellipsis (•••) may be repeated
any number of times (up to the length of the line).

6. Items separated by a vertical bar (,) are mutually
exclusive; choose one.

AUTO [<line number> [,<increment>]]
Extended, Disk
To generate a line number automatically after

every carriaqe return.

ACTO beqins numberinq at <line number> and

increments each subsequent line number by
<increment>. The default for both values is 10.
If <line number> is followed by a comma but
<increment> is not specified, the last increment

specified in an AUTO command is assumed.

If AUTO generates a line number that is already
beinq used, an asterisk is print.edafter the
number to warn the user that any input will
replace the existing line. However, typinq a

carriaqe return immediately after the asterisk
will save the line and qenerate the next line

number.
AUTO is terminated by typinq Control-c. The

line in which Control-c is t.ypedis not saved.
Aft.er Control-C is typed, BASIC returns to

command level.

Generates line numbers 100,

150,200 •••

Generates line numbers 10,
20, 30, 40 •••

Purpose:
Remarks:.

CALL <variable name>[«argument list»]
Ex1:ended,Disk
To call an assembly lanquaqe subroutine.
The CALL statement is one way to transfer

proqram flow to an assembly lanquaqe subroutine.

(See also ~e USR function, Section 3.40)

<variable name> contains an address'that is the

startinq point in memory of ~e subroutine.
<variable name> may not be an array variable
name. <argument list> contains the arquments
that are passed to ~e assembly lanquaqe
subroutine.

The CALL statement qenerates the same callinq
sequence used by Microsoft's FORT~~, COBOL and
BASIC compilers.

110 MYROOT-&HDOOO

120 CALL MYROOT(I,J,X)

~N [MERGE] <filename>[,[<line number exp>]

[,ALL][,DELETE<range>]]
Disk
To ca.lla program and pass variables to it from

the current program.
<filename> is the name of the program that is

called. Example:

CRAIN"PROG1"

<line number exp> is a line number or an

expression that evaluates to a line number in

the called program. It is the starting point

for execution of the called program. If it is
omitted, execution begins at the first line.
Example:

CBAIN"PROG1",1000

<line number exp> is not affected by a RENOM

command.
With the ALL option, every variable in the

current program is passed to the ca~led program.

If the ALL option is omitted, the current
program must contain a COMMON statement to list

the variables that are passed. See Section 2.7.
Example:

If the MERGE option is included, it allows a

subroutine to be brought into the BASIC program

as an overlay. That is, a MERGE operation is
performed with the current program and the

called program. The called program must be an
ASCII file if it is to be MERGEd. Example:

After an overlay is
desirable to delete
be brought in. To
option. Example:

CRAJ:NMERGEl'OVIU.AY2 " , 1000,DELETE 1000-5000

brought in, it is usually
it so that a new overlay may

do this, use the DELETE

The line numbers in <range> are affected by the

BENUM command.

The Microsoft BASIC compiler does not support
the ALL, MERGE, and DELETE options to CRAIN. If
you wish to maintain compatibility with the
BASIC compiler, it is recommended that COMMON be

used to pass variables and that overlays not be

used.

If the MERGE option is omitted, CHAIN does not

preserve variable types or user-defined

functions for use by the chained proqram. That
is, any OEFINT, OEFSNG, OEFDBL, DEFSTR, or DEFFN
statement containing shared variables must be

restated in the chained program.

CLEAR[,[<expression1>] [,<expression2>]1

SK, Extended, Disk
To set all numeric variables to zero and all

string variables to null; and, optionally, to

set the end of memory and the amount of stack

space.

<expression1> is a memory location which, if

specified, sets the hiqhest location available

for use by BASIC-SO.

<expression2> sets aside stack space for BASIC.
The default is 1000 bytes or one-eighth of the

available memory, whichever is smaller.

In previous versions of BASIC-SO, <expression 1>

set the amount of string space and <expression2>

set the end of memory. BASIC-SO, release 5.0

and later, allocates string space dynamically.
An "Out of string space" error occurs only if

there is no free memory left for BASIC to use.

,

..../

\

\

2.5
Intentially left blank.

Purpose:
Remarks:

To conclude I/O to a disk f~le.
<file number> is the number under which the file

was OPENed. A CLOSE with no arguments closes

all open files. \
The association between a particular file and

file number terminates upon execution of a
CLOSE. The file may then be reOPENed using the
same or a different file number; likewise, that
file number may now be reused to OPEN any file.

A CLOSE for a sequential output file writes the

final buffer of output.

The END statement and the NEW command always
CLOSE all disk files automatically. (STOP does
not close disk files.)

See Appendix B.

Purpose:
Remarks:

To pass variables to a CHAINed program.
The COMMON statement is used in conjunction with

the CHAIN statement. COMMON statements may

appear anywhere in a program, though it is
recommended that they appear at the beginning.
The same variable cannot appear in more than one

COMMON statement. Array variables are specified
by appending "()" to the variable name. If all

variables are to be passed, use CRAIN with the
ALL option and omit the COMMON statement.

100 COMMON A,B,C,O(),G$
110 CHAIN "PROG3",10

8K, E~ended, Disk

To con~inue proqram execu~ion af~er a Con~rol-C
has been ~yped, or a STOP or END s~a~emen~ has
been executed.

Execution resumes at the point where the break
occurred. If the break occurred after a promp~

from an INPUT s~a~ement, execution continues

with the reprinting of ~he promp~ (1 or prompt

s~ring).

CONT is usually used in conjunction with STOP

for debugging. When execution is stopped,

intermediate values may be examined and changed
using direct mode statemena. E~ecution may be
resumed with COt~ or a direct mode GOTO, which
resumes execution a~ a specified line number.
With the Extended and Disk versions, CONT may be
used to continue execution after an error.

CONT is invalid if the program has been edited
during the break. In 8K BASIC-80, execution
canno~ be CONTinued if a direct mode error has
occurred during the break.

See example Section 2.61, STOP.

BASIC-SO COMMANDS AND STATEMENTS

2.9

Intentially left blank.

SK, Extended, Disk

To store the numeric 'and string constants that

are accessed by the program's READ statement(s).

(See READ, Section 2.54)

DATA statements are nonexecutable and may be
placed anywhere in the program. A DATA

statement may contain as many constants as will
fit on a line (separated by commas), and any
number of DATA statements may be used in a

program. The READ statements access the DATA

statements in order (by line number) and the

data contained therein may be thought of as one

continuous list of items, regardless of how many
items are on a line or where the lines are

placed in the program.

<list of constants> may QOntain numeric
constants in any format, i.e., fixed point,

floating point or inte~er. (No numeric
expressions are allowed ~n the list.) String
constants in DATA statements must be surrounded

by double quotation marks only if they contain

commas, colons or significant leading or
trailing spaces. Otherwise, quotation marks are
not needed.

The variable type (numeric or string) given in
the READ statement must agree with the
corresponding constant in the DATA statement.

DATA statements may be reread from the beginning
by use of the RESTORE statement (Section 2.57).

See examples in Section 2.54, READ.

DEF FN<name>[«parameter list»]=<function definition>

SK, Extended, Disk

To define and name a function that is written by
theuser.

<name> must be a legal variable name. This

name, preceded by FN, becomes the name of the

function. <parameter list> is comprised of
those variable names in the function definition

that are to be replaced when the function is

called. The items in the list are separated by

commas. <function definition> is an expression

that performs the operation of the function. It
is limited to one line. Variable names that
appear in this expression serve only to define

the function: they do not affect program
variables that have the same name. A variable
name used in a function definition mayor may
not appear in the parameter list. If it does,

the value of the parameter is supplied when the

function is called. Otherwise, the current
value of the variable is used.

The variables in the parameter list represent,

on a one-to-one basis, the argument variables or
values that will be given in the function call.

(Remember, in the SK version only one argument

is allowed in a function call, therefore the DEF

FN statement will contain only one variable.)

In Extended and Disk BASIC-SO, user-defined
functions may be numeric or string: in SK,
user-defined string functions are not allowed.

If a type is specified in the function name, the
value of the expression is forced to that type
before it

is

returned to the calling statement.

If a type is specified in the function name and
the argument type does not match, a "Type

mismatch" error occurs.
A DEF FN statement must be executed before the

function it defines may be called. If a

function is called before it has been defined,
an "Undefined user function" error occurs. DEF
FN is illegal in the direct mode.

410 DEF FNAB(X,Y)=XA3/YA2
420 T-FNAB (I,J)

Line 410 de£ines the function
function is called in line 420.

DEF<type> <range(s) of letters>

where <type> is INT, SNG, DBL,

or

STR

Extended, Disk

To declare variable types as integer, single

precision, double precision, or string.

A OEFtype statement declares that the variable

names beginning with the letter(s) specified

will be that type variable. However, a type

declaration character always takes precedence
over a OEFtype statement in the typing of a
variable.

If no type declaration statements are"
encountered, BASIC-SO assumes

all

variables

without declaration characters are single

precision variables.

10 OEFOBL L-P All variables beginning with

the letters L, M, N,

0,

and P
will be 'doubleprecision
variables.

All variables beginning with

the letter A will be string
variables.

10 DEFINT I-N,W-Z

All variables beginning with
the letters I,

J,

K, L, M,

N, W, X, Y, Z

will

be integer

variables.

To specify the starting address of an assembly

language subroutine.
<digit> may be any digit from 0 to 9. The digit

corresponds to the number of the USR routine

whose address is being specified. If <digit> is

omitted,

OEF

USRO is assumed. The value of
<integer expression> is the starting address of
the USR routine. See Appendix C, Assembly
Language Subroutines.

Any number of OEF USR statements may appear in a

program to redefine subroutine starting
addresses, thus allowing access to as many
subroutines as necessary •

•

200

OEF

USRO-24000

210 X-USRO{YA2/2.89)

Purpose:
Remarks:

To dele~e program lines.
BASIC-SO always re~urns to command level after a

DELETE is execu~ed. If <line number> does not
exis~, an "Illegal func~ion call" error occurs.

DELETE 40
DELETE 40-100

Dele~es lines 40 through

100, inclusive

Deletes all lines up to
and including line 40

D~ <list of subscripted variables>
SK, Extended, Disk

To specify the maximum values for array variable

subscripts and allocate storaqe accordinqly.
If an array variable name is used without a D~

statement, the maximum value of its·subscript(s)
is assumed to be 10. If a subscript is used

that is qreater than the max~um specified, a

•Subscript out of. ranqe· error occurs. The
minimum value for a subscript is always 0,
unless otherwise specified with the OPTION BASE

statement (see Section 2.46).

The D~ statement sets all the elements of the

specified arrays to an initial value of zero.

10 DIM A(20)

20 FOR

I-O

TO 20

30 READ A(I)

40 ~ I

Purpose:

Remarks:

To enter Edit Mode at the specified line.

In Edit Mode, it is possible to edit portions of
a line without retyping the entire line. Upon
entering Edi t Mode, BAS IC-80 types the line
number of the line to be edited, then it types a
space and waits for an Edit Mode subcommand.

Edit Mode subcommands are used to move the

cursor or to insert, delete, replace, or search

for text within a line. The SuDcommands are not
echoed. Most of the Edit Mode subcommands may
be preceded by an integer which causes the
command to be executed that number of times.
When a preceding integer is not specified, it is
assumed to be 1.

Edit Mode suCcommands may be categorized
according to the following functions:

1.

Moving the cursor

2.

Inserting text

3.

Deleting text

4. Finding text

s.

Replacing text

6.

Ending and restarting

Edit Mode

In the descriptions that follow, <ch>
represents any character, <text>
represents a string of characters of
arbitrary length, [i] represents an
optional integer (the default is 1), and

$

represents the Escape

key.

Space Use the space bar to move the cursor to the

right. [ilSpace moves the cursor i spaces to
the.right. Characters are printed as .you space
over them.

Rubout In Edit Mode, [ilDELete moves the cursor i

spaces to the left (backspaces). Characters are
printed as you backspace over them.

2. Inserting Text
I I<text>$ inserts <text> at the current cursor

position. The inserted characters are printed

on the terminal. To terminate insertion, type
Escape. If Carriage Return is typed during an

Insert command, the effect is the same as typing

Escape and then Carriage Return. During an

Insert command, the Delete key on the

terminal may be used to delete characters to the

left of the cursor. If an attempt is made to
insert a character that will make the line
longer than 255 characters, a bell (Control-G)
is typed and the character is not printed.

X The X subcommand is used to extend the line. X

moves the cursor to the end of the line, goes

into insert mode, and allows insertion of text
as if an Insert command had been qiven. When

you are finished extending the line, type Escape
or Carriage Return.

3. Deleting Text
D [i1D deletes i characters to the right of the

cursor. The deleted characters are echoed
between backslashes, and the cursor is
positioned to the right of the last character
deleted. If there are fewer than i characters
to the right of the cursor, iD deletes the
remainder of the line.

B deletes all characters to the

cursor and then automatically
mode. B is useful for replacing
the end of a line.

right of the
enters insert
statements at

4. Finding Text
S The subcommand [i]S<ch> searches for the ith

occurrence of <ch> and positions the cursor
before it. The character at the current cursor
position is not included in the search. If <ch>

is not found, the cursor will stop at the end of

the line. All characters passed over during the
search are printed.

K The subcommand (i]K<ch> is similar to (i]S<ch>,

except all the characters passed over in the
search are deleted. The cursor is positioned
before <ch>, and the deleted characters are
enclosed in backslashes.

C The subcommand C<ch> changes the next character

to <ch>. If you wish to change the next i
characters, use the subcommand iC, followed by i
characters. After the ith new character is
typed, change mode is exited and you will return
to Edit Mode.

Typing Carriage Return prints the remainder of
the line, saves the changes you made and exits
Edit Mode.

The E subcommand has the same effect as Carriage
Return, except the remainder of the line is not
printed.

The

Q

subcommand returns to BASIC-SO command

level, without saving any of the changes that

were made to the line during Edit Mode.

L The L subcommand lists the remainder of the line

(saving any changes made so far) and repositions

the cursor at the beginning of the line, still

in Edit Mode. L is usually used to list the

line when you first enter Edit Mode.

A The A subcommand lets you begin editing a line

over again. It restores the original line and
repositions the cursor at the beginning.

If BASIC-SO receives an unrecognizable
command or illegal character while in

Edit Mode, it prints a bell (Control-G)

and the command or character is ignored.

When a Syntax Error is encountered during

execution of a program, BASIC-SO automatically
enters Edit Mode at the line that caused the

error. ror example:

10 K • 2(4)

RON

?Syntax error in 10

10

When you finish editing the line and type
carriage Return (or the E subcommand), BASIC-SO

reinserts the line, which causes all variable

values to be lost. To preserve the variable

values for examination, first exit Edit Mode

with the Q subcommand. BASIC-SO will return to

command level, and all variable values will be
preserved.

T.oenter Edit Mode on the line you are currently
typing, type Control-A. BASIC-SO responds with
a carriage return, an exclamation point

(1)

and
a space. The cursor will be positioned at the
first character in the line. Proceed by typing
an Edit Mode subcommand.

Remember, if you have just entered a

line and wish to go back and edit it,
the command -EDIT." will enter Edit Mode
at the current line. (The line number

symbol "." always refers to the current

line.)

To terminate program execution, close all fi~es

and return to command level.
END statements may be placed anywhere in the

program to terminate execution. Unlike the STOP
statement, END does not cause a BREAK message to
be printed. An END statement at the end .of a
program is optional.

BASIC-SO

always returns to

command level after an END is executed.

Purpose:
Remarks:

ERASE <list of array variables>

SK, Extended, Disk
To eliminate arrays from a program.
Arrays may be redimensioned after they are

ERASEd, or the previously allocated array space
in memory may be used for other purposes. If an
attempt is made to redimension an array without
first ERASEing it, a ftRedimensioned array· error
occurs.

The Microsoft BASIC compiler does not support
ERASE •

•

450 ERASE A,B

460 DIM B (99)

2. 19

E!! ~ ~

VARIABLES

When an error hand~ing subroutine is entered,

the variable ERR contains the error code for the

error, and the variable ERL contains the line
number of the line in which the error was
detected. The ERR and ERL variables are

usually

used in IF•••THEN statements to direct program

flow in the error trap routine.

If the statement that caused the error was a
direct mode statement, ERL will contain 65535.
To test if an error occurred in a direct

statement, use IF 65535 • ERL THEN •••
Otherwise, use

If the line number is not on the right side of

the relational operator, it cannot be renumbered

by

RENUM. Because ERL and ERR are reserved
variables, neither may appear to the left of the
equal sign in a LET (assignment) statement.
BASIC-80's error codes are listed in Appendix J.

Extended, Disk

1) To simula~e the occurrence of a BASIC-80

error

7

or 2) ~o allow error codes ~o be

defined by the user.
The value of <in~eger expression> mus~ be

greater than 0 and less than 255. If ~he value

of <integer expression> equals an error code

already in use by BASIC-80 (see Appendix

J),

the
ERROR statemen~ will simulate the occurrence of
that error, and the corresponding error message

will be printed. (See Example 1.)

To define your own error code, use a value tha~
is greater than any used by BASIC-80's error
codes. (It is preferable ~o use the highest
available values, so compatibili~y may be

maintained when more error codes are added ~o

BASIC-80.) This user-defined error code may then

be conveniently handled in an error trap

routine. (See Example 2.)
If an ERROR statement specifies a code for which

no error message has been defined, BASIC-80
responds with the message UNPRINTABLE ERROR.

Execution of an ERROR statement for which ~here

is no error trap routine causes an error message
~o be printed and execution to halt.

Example 1: LIST

10 S • 10

20 '1'- 5
30 ERROR S

+

'1'

40 END

Ok

RUN

String ~oo long in line 30

Ok
ERROR 15

String ~oo long

Ok

(you type this line)

(BASIC-80 types this line)

•

110 ON ERROR GOTO 400
120 INPUT "WHAT IS YOUR BET";B

130 IF B

>

5000 THEN ERROR 210

•

400 IF ERR • 210 THEN PRINT "ROOSE LIMIT IS $5000"
410 IF ERL • 130 THEN RESUME 120

FIELD[.]<file number>,<field width> AS <string variable> •••

Disk

To allocate space for variables in a random file
buffer.

To get data out of a random buffer after a GET

or to enter data before a PUT, a FIELD statement

must have been executed.

<file number>

was OPENed.

characters to

For example,

is the number under which the file

<field width> is the number of

be allocated to <string variable>.

FIELD 1, 20 AS N$, 10 AS ID$, 40 AS ADD$

allocates the first 20 positions (bytes) in the
random file buffer to the string variable N$,
the next 10 positions to ID$, and the next 40

pos~tions to ADD$. FIELD does NOT place any

data in the random file buffer. (See LSET/RSET
and GET.)

The total number of bytes allocated in a FIELD

statement must not exceed the record length that
was specified when the file was OPENed.
Otherwise, a "Field overflow" error occurs.

(The default record length is 128.)

Any number of FIELD statements may be executed

for the same file, and all FIELD statements that
have been executed are in' effect at the same

time.

Do not use a FIELDed variable name in an INPUT

or

'LET'Statement. Once a -vir'iiE''le-name is

FIELDed, it points to the correct place in the

random file buffer. If a subsequent INPUT or
LET statement with that variable name is

executed, the variable's pointer is moved to

string space.

SK, Extended, Disk

To

allow

a series of instructions to be

performed in a loop a given number of times.
<variable> is used as a counter. The first

numeric expression (x) is the initial value of
the counter. The second numeric expression

(y)

is the final value of the counter. The program
lines following the FOR statement are executed
until the NEXT statement is encountered. Then

the counter is incremented by the amount
specified by STEP. A check is performed to see
if thevalue of the counter is now greater than
the final value (y). If it is not greater,

BASIC-SO

branches back to the statement after
the FOR statement and the process is repeated.
If it is greater, execution continues with the
statement following the NEXT statement. This is
a FOR•••NEXT loop. If STEP is not specified,
the increment is assumed to be one. If STEP is
negative, the final value of the counter is set
to be less than the initial value. The counter
is decremented each time through the loop, and
the loop is executed until the counter is less
than the final value.

initial

the step

of the

The body of the loop is skipped if the
value of the loop times the sign of
exceeds the final value times the sign

step.

Nested Loops
FOR•••NEXT loops may be nested, that is, a
FOR•••NEXT loop may be placed within the context
of another FOR•••NEXT loop. When loops are
nested, each loop must have a unique variable
name as its counter. The -NEXT statement for the

inside loop must appear before that for the
outside loop. If nested loops have the same end
point, a single NEXT statement may be used for

all

of them.

om tted, in which case the NEXT statement will

match the most recent FOR statement. If a NEX'I'

statement is encountered before its
corresponding FOR statement, a -NEX'I'without

FOR- error message is issued and execution is

terminated.

Example 1: 10

K-10

20

FOR I-1 TO

It

STEP

2

30

PRINT I;

40 K-K+10

50

PRINT

It

60 NEX'I'
RON

1

20
3 30
5

40

7

5-0

9 60

Ok

Example 2: 10 J-O

20 FOR I=1 TO

J

30 PRINT I

40 NEX'I'

I

In this example, the
because the initial
the final value.

loop does not execute

value of the loop exceeds

Example 3:

10

r-s

20

FOR I-1 TO

I+S
30 PRINT I;
40 NEXT

RON

1 2

3 4 5 6 7

S

9

10

Ok
In this example, the loop executes ten times.

The final value for the loop variable is always
set before the initial value is set. (Note:

Previous versions of BASIC-SO set the initial

value of the loop variable before setting the
final value; i.e., the above loop would have
executed six times.>

GET [t]<file number>[,<record number>]
Disk
To read a record from a random disk file into a

random buffer.

<file number> is the number under which the file
was OPENed. If <record number> is omitted, the
next record (after the last GET) is read into

the buffer. The largest possible record number

is

32767.

Purpose:
Remarks:

<line number> is
subroutine.

the first

\

A subroutine may be called any number of times

in a program, and a subroutine may be called
from within another subroutine. Such nesting of
subroutines is limited only by available memory.

The RETURN statement(s) in a subroutine cause
BASIC-SO to branch back to the statement

following the most recent GOSUB statement. A
subroutine may contain more than one RETURN
statement, should loqic dictate a return at

different points in the subroutine. Subroutines

may appear "anywhere in the program, but it is

recommended that the subroutine be readily
distinguishable from the main program. To
prevent inadvertant entry into the subroutine,
it may be preceded by a STOP, END, or GOTO

statement that directs program control around

the subroutine.

10 GOSUB 40

20 PRINT "BACX FROM SUBROOTINE"

30 END

40 PRINT "SUBROUTINE"

1

S'OPRINT " IN";
60 PRINT " PROGRESS"
70 RETtmN
RUN

SUBROOTINE IN PROGRESS
BACK FROM SUBROUTINE
Ok

To branch unconditionally out of the normal
program sequence to a specified line number.

If <line number> is an executable statement,
that statement and those following are executed.
If it is a nonexecutable statement, execution
proceeds at the first executable statement
encountered aftar <line number>.

LIST

10 READ R

20 PRINT "R ·";R,

30

A

a

3.14*RA2

40 PRINT "AREA ."~A

50 GOTO 10

60 DATA 5,7,12
Ok
RUN

R • 5

R • 7

R • 12

?Out of data
Ok

AREA •
AREA

=-

AREA

=-

in

10

78.5

153.86

452.16

IF <expression> THEN <statement(s}> <line number>

[ELSE <statement(s}>

I

<line number>]

IF <expression> GOTO <line number>

[ELSE <statement(s}>

I

<line number>]

SK, Ex~ended, Disk

The ELSE clause is allowed only in Extended' and
Disk versions.

To make a decision regarding program flow based
on the result returned by an expression.

If the result of <expression> is not zero, the

THEN or GOTO clause is executed. THEN may be

followed by either a line number for branching

or one or more statements to be executed. GOTO

is always followed by a line number. If the
result of <expression> is zero, the THEN or GOTO

clause is ignored and the ELSE clause, if
present, is executed. Execution continues with
the nex~ executable statement. (ELSE is allowed
only in Ex~ended and Disk versions.) Extended
and Disk versions allow a comma before THEN.

Nes~inq

2!

B:.

Statements

In the E~ended and Disk versions,

IF •••THEN •••ELSE statements may be nested.
Nes~ing is limited only by the length of the

line. For example

IF X>Y THEN PRINT IIGREATERIIELSE IF Y>X

THEN PRINT llLESS THAN IIELSE PRINT ••EQUAL"

is a legal statement. If the statement does not
contain the same number of ELSE and THEN
clauses, each ELSE is matched with the closest
unmatched THEN. For example

IF A=B THEN IF a=c THEN PRINT IIA-C II

ELSE PRINT IIAOC"
will not print "A<>CIIwhen A<>B.
If an IF •••THEN statement is followed by a

number in the direct mode, an IIUndefined
error results unless a statement with
specified line number had previously
entered in the indirect mode.

line

line II

the

been

When using IF to test equality for a value that
is the result of a floating point computation,
remember that the internal representation.of the
value may not be exact. Therefore, the test
should be against the range over which the
accuracy of the value may vary. For example, to
test a computed variable A against the value

1.0,

use:

This test returns true if the value of A is

1.0

with a relative error of less than 1.0E-6.

Example 1: 200 IF I THEN GETtl,I

This statement GETs record number I if I is not

zero.

Example 2: 100 IF(I<20)*(I>10) THEN OS-1979-1:GOTO 300

110 PRINT "OOT OF RANGE"

In this example, a test determines if I is

greater than 10 and less than 20. If I is in

this range, DB is calculated and execution
branches to line 300. If I is not in this
range, execution continues with line 110.

This statement causes printed output to go

either to the terminal or the line printer,

depending on the value of a variable (IOFLAG).

If IOFLAG is zero, 'output goes to the line

printer, otherwise output goes to the terminal.

INPtJ1r[,l[<"prompt stringJl>,l<listof variables>

8K, Extended, Disk

To allow input from the terminal during program

execution.
When an INPUT statement is encountered, program

execution pauses and a question mark is printed
to indicate the program is waiting for data. If

<"prompt string"> is included, the string is

printed before the question mark. The required

data is then entered at the terminal.

If INPUT is immediately followed by

then the carriage return typed by

input data does not echo a carriage

feed sequence.

The data that is entered is assigned to

variable(s) given in <variable list>.

number of data items supplied must be the

as the number of variables in the list.

items are separated by commas.

a semicolon,
the user to

return/line

the

The

same

Data

The variable names in the list may be numeric or

string variable names (including subscripted

variables). The type of each data item that is

input must agree with the type specified by the

variable name. (Strings input to an INPU'r

statement need not be surrounded by quotation

marks.)

Responding to INPUT with too many or too few

items, or with the wrong type of value (numeric
instead of string, etc.) causes the messsage

"?Redo from start" to be printed. No assignment
of input values is made until an acceptable
response is given.

In the 8K version, INPUT is illegal in the
direct mode.

10 INPUT

20 PRINT

30 END

RUN

?

5

x

X "SQUARED IS"

XI\2

(The 5 was typed in

by

the user

in response to the question mark.)

5 SQUAlmD IS 25

Ok

LIST

10 PI-3.14

20 INPUT "WHAT IS THE RADIUS";R

30 A-PI*RI\2
40 PRINT "THE AREA OF THE CIRCLE IS";A
50 PRINT

60 GaTO 20
Ok
RUN

WHAT IS THE RADIUS? 7.4 (User types 7.4)

THE AREA OF THE CIRCLE IS 171.946
WHAT IS THE RADIUS?

etc.

INPUTt<file number>,<variable list>
Disk
To read data items from a sequential disk file

and assign them to program variables.
<file number> is the number used when the file

was OPENed for input. <variable list> contains
the variable names that will be assigned to the

items in the file. (The variable type must
match the type specified by the variable name.)
With INPUTt, no question mark is printed, as
with INPUT.

The data items in the file should appear just as

they would if data were being typed in response

to an rNPUT statement. With numeric values,

leading spaces, carriage returns and line feeds
are ignored. The first character encountered
that is not a space, carriage return or line

feed is assumed to be the start of a number.
The number terminates on a space, carriage
return, line feed or comma.

If BASIC~80 is scanning the sequential data file

for a string item, leading spaces, carriage
returns and line feeds are also ignored. The

firs~ character encountered that is not a space,

carriage return,

or

line feed is assumed to be
the start of a string item. If this first
character is a quotation mark ("), the string
item will consist of all characters read between
the first quotation mark and the second. Thus,
a quoted string may not contain a quotation mark
as a character. If the first character of the
string is not a quotation mark, the string is an
unquoted string, and will terminate on a comma,
carriage or line feed (or after 255 characters

have been read). If end of file is reached when

a numeric or string itam is being INPUT, the

item is terminated.

Purpose:

Remarks:

If a KILL statement is given for a file that is
currently OPEN, a "File already open" error

occurs.

KILL is used for all types of disk files:
program files, random data files and sequential
data files.

[LET] <variable>-<expression>

SK, Extended, Disk

To assign the value of an expression to a
variable.

Notice the word LET is optional, i.e., the equal

sign is sufficient when assigning an expression
to a variable name.

110 LET 0-12
120 LET E-12A2

130 LET F-12A4

140 LET SUM-D+E+F

110 0-12
120 E-12A2
130 F=-12A4
140 SUM=D+E+F

LINE INPUT[;][<"prompt string">;]<string variable>
Extended, Disk
To input an entire line (up to 254 characters)

to a string variable, without the use of

delimiters.
The 'prompt string is a str~ literal that is

printed at the terminal before input is

accepted. A question mark is not printed unless
it is part of the prompt string. All input from

the end of the prompt to the carriage return is

assigned to <string variable>.
If LINE INPUT is immediately followed by a

semicolon, then the carriage return typed by the

user to end the input line does not echo a

carriage return/line feed sequence at the

terminal.
A LINE INPUT may be escaped by.typing Control-C.

BASIC-SO will return to command level and type

Ok. Typing CONT resumes execution at the LINE

INPUT.

LINE INPUTt<file number>,<string variable>
Disk
To read an entire line (up to 254 characters),

without delimiters, from a sequential disk data

file to a string variable.

<file number> is the number under which the file

was OPENed. <string variable> is the variable

name to which the line will be assigned. LINE
INPUT. reads all characters in the sequential

file up to a carriage return. It then skips
over the carriage return/line feed sequence, and
the next LINE INPUT' reads all characters up to
the next carriage· return. (If a line
feed/carriage return sequence is encountered, it
is preserved.)

LINE INPUT. is especially useful
a data file has been broken into
BASIC-80 program saved in ASCII
read as data by another program.

if each line of
fields, or if a

mode is being

Example:

10 OPEN

"O",1,"LIST"

20

LINE INPUTItCUSTOMER

INFORMATION?

";C$
30 PRINT .1, C$
40

CLOSE 1
50 OPEN "I",1,"LIST"
60

LINE INPUTt1, C$
70 PRINT C$
80 CLOSE 1
RUN
CUSTOMER INFORMATION? LINDA JONES 234,4

ME.'-1PHIS
LINDA JONES 234,4 MEMPHIS
Ok

LIST «line number>[-[<line number>]]]
Extended, Disk
To list all or part of the program currently in

memory at the terminal.

BASIC-80 always returns to command level after a
LIST is executed.

Format 1: If <line number> is omitted, the

proqram is listed beqinning at the lowest line

number. (Listing is terminated either by the

end of the program or by typing Control-C.) If
<line number> is included, the 8X version will
list the program beginning at that liner and
the Extended and Disk versions will list only
the specified line.

Format 2: This format allows the following
options:

1. If only the first number is specified, that
line and all higher-numbered lines are
listed.

2. If only the second number is specified, all
lines from the beginning of the program
through that line are listed.

3. If both numbers are specified, the entire
range is listed.

Lists the program currently

in memory.

In the 8K version, lists
all programs lines from
500 to the end.
In Extended and Disk,
lists line 500.

LIST 150- Lists all lines from 150

to the end.

LIST -1000 Lists all lines from the

lowest number through 1000.

LIST 150-1000 Lists lines 150 through

1000, inclusive.

To list all or part of the program currently in
memory at the line printer.

LLIST assumes a 132-character wide printer.

BASIC-SO always returns to command level after

an LLIST is executed. The options for LLIST are

the same as for LIST, Format 2.

LLIST and LPRINT are not included in

implementations of BASIC-SO.
See the examples for LIST, Format 2.

Purpose:
Remarks:

LOAD <filename>[,R]
Disk
To load a file from disk into memory.
<filename> is the name that was used when the

file was SAVEd. (With CP/M, the default
extension .BAS is supplied.)

LOAD closes all open files and deletes all
variables and proqram lines currently residing
in memory before it loads the designated
program. However, if the "R" option is us7d

with LOAD, the program is RUN after it

J.S

LOADed, and all open data files are kept open.
'l'hus,LOAD with the "R" option may be used to
chain several programs (or segments of the same
program). Information may be passed between the
programs using their disk data files.

LOAD "S'rR'rU",R

LPRINT USING <ftfor.matstringft>~<list of expressions>
Extended, Disk
To print data at the line printer.
Same as PRINT and PRINT USING, except output

goes to the line printer. See Section 2.49 and

Section 2.50.
LPRINT assumes a 132-character-wide printer.
LPRINT and LLIST are not included in

implementations of BASIC-aO.

LSET <string variable> • <string expression>
RSET <string variable> • <string expression>

To move data from memory to a random file buffer

(in preparation for a POT statement).

If <string expression> requires fewer bytes than

were FIELDed to <string variable>, LSET

left-justifies the string in the field, and RSET
right-justifies the string. (Spaces are used to

pad the extra positions.) If the string is too

long for the field, characters are dropped from

the right. Numeric values must be converted to

strings before they are LSET or RSET. See the

MKI$, MKS$, MKD$ functions, Section 3.25.

150 LSET A$-MKS$(AMT)
160 LSET D$-OESC($)

See also Appendix B.

LSET or RSET may also be used with

string variable to left-justify or
a string in a g~ven field. For

program lines

a non-fielded
right-justify
example, the

110 A$-SPACE$(20)
120 RSET A$=N$

right-justify the string N$ in a 20-character
field. This can be very handy for formatting

printed output.

To merge a specified disk file into the program

currently in memory.
<filename> is the name used when the file was

SAVEd. (With CP/M, the default extension .BAS
is supplied.) The file must have been SAVEd in

ASCII format. (If not, a "Bad file mode" error

occurs.)
If any lines in the disk file have the same line

numbers as lines in the program in memory, the

lines from the file on disk will replace the
corresponding lines in memory. (MERGEing may be
thought of as "inserting" the program lines on

disk into the program in memory.)
BASIC-SO always returns to command level after

executing a MERGE command.
MERGE "NUMBRS"

m are integer expressions and

and <string exp2> are string

where n and

<string exp1>
expressions.

Extended, Disk
To replace a portion of one string with another

string.
The characters in <string exp1>, beginning at

position n, are replaced by the characters in
<string exp2>. The optional m refers to the
number of characters from <string exp2> that

will be used in the replacement. If m is

omitted, all of <string exp2~ is used. However,
regardless of whether m is omitted or included,
the replacement of characters never goes beyond
the original length of <string exp1>.

10 A$="KANSAS

CITY,

MO"

20 MID$(A$,14)="KS"

30 PRINT A$

RUN

KANSAS

CITY,

KS

MID$

may also be used as a function that returns

a substring of a given string. See Section

3.24.

PU.rJ?ose:
Remarks :

To change the name of a disk file.
<old filename> must exist and <new filename>

must not exist; otherwise an error will result.
After a NAME command, the file exists on the
same disk, in the same area of disk space, with
the newname.

Ok

NAMEIIACCTS " ASIILEDGER"
Ok

In this example, the file that was

formerly named ACCTS will now be named LEDGER.

To delete the proqram currently in memory and

clear all variables.

NEW is entered at command level to clear memory
before entering a new program. BASIC-SO always

returns to command level after a NEW is
executed.

8K, Extended, Disk

To set "thenumber of nulls to be printed at the

end of each line.

For 10-character-per-second tape punches,

<integer expression> should be

>-3.

When tapes
are not being punched, <integer expression>
should be 0 or 1 for Teletypes and
Teletype-compatible CRTs. <integer expression>
should "be 2 or 3 for 30 cps hard copy printers.

The default value is

o.

Ok

NULL

2

Ok

100

INPUT X

200

IF X<SO

GaTO 800

•

•

•

Two

null

characters

will

be printed after each

line.

Extended, Disk
To enable error trapping and specify the first

line of the error handling subroutine.

Once error trapping has been enabled all errors

detected, including direct mode errors (e.g.,
Syntax errors), will cause a jump to the
specified error handling subroutine. If <line
number> does not exist, an ·Undefined line"
error results. To disable error trapping,
execute an ON EUOR GOTO

o.

Subsequent errors
will print an error message and halt execution.
An ON ERROR GOTO 0 statement that appears in an

error trapping subroutine causes BASIC-SO to
stop.and print the error message for the error
that caused the trap. It is recommended that

all error trapping subroutines execute an ON
ERROR GOTO 0 if an error is encountered for
which there is no recovery action.

If an error occurs during execution of an error

handling subroutine, the BASIC error message is

printed and execution terminates. Error

trapping does not occur within the error

handling subroutine.

10 ON ERROR GOTO 1000

ON <expression> GOTO <list of line numbers>

'ON <expression> GOSUB <list of line numbers>

SX, Extended, Disk

To branch to one of several specified line
numbers, depending on the value returned when an
expression is evaluated.

The value of <expression> determines
number in the list will be used for
For example, if the value is three,
line number in the list will be the
of the branch. (If the value is a
the fractional portion is rounded.)

which line
branching.

the third

destination

non-integer,

In the ON •••GOSUB statement, each line number in
the list must be the first line number of a
subroutine.

If the value of <expression> is negative, zero

or greater than the number of items in the list,

an "Illegal function call" error occurs.

Purpose:
Remarks:

OPEN <mode>, [il<file number>,<filename>,[<reclen>l

Disk

A disk file must be OPENed before any disk
operation can be performed on that f~le.
allocates a buffer for I/O to the file
determines the mode of access that will be

with the buffer.

I/O

OPEN

~d

used

<mode> is a string expression whose
character is one of the following:

o

specifies sequentia~ output mode

I specifies sequential input mode

R specifies random input/output mode

<file number> is an integer expression whose
value is between one and fifteen. The number is

then associated with the file for as long as it

is OPEN and is used to refer other disk I/O

statements to the file.

<filename> is a string expression containing a
name that conforms to your operating system's

rules for disk filenames.

<reclen> is an integer expression which, if

included, sets the record length for r~dom

files. The default record length is 128 bytes.
See also page A-3.

A file can be OPENed for sequential input or

random access on more than one file number at a

time. A file may be OPENed for output, however,

on only one file number at a time.

OPTION BASE

n

where n is 1 or 0
Extended, Disk
To declare the

subscripts.
The default base is O. If the statement

is executed, the lowest value an array subscript
may have is one.

Purpose:
Remarks:

OUT I,J

where:I andJare integer expressions in the
range 0 to 255.

aK,

Extended, Disk
To send a byte to a machine output port.
The integer expression I is the port number, and

the integer expression

J

is the data to be

transmitted.

Purppse:

Remarks:

POKE I,J
where I and J are integer expressions

To write a byte into a memory location.
The integer expression I is the address of the

memory location to be POKEd. The integer

expression J is the data to be POKEd. J must be
in the range 0 to 255. In the 8X version, I

must be less than 32768. In the Extended and

Disk versions, I must be in the range 0 to

65536.

With the 8X version, data may be POKEd into
memory locations above 32768 by supplying a

negative number for I. The value of I is
computed by subtracting 65536 from the desired
address. For example, to POKE data into
location 45000, I • 45000-65536, or -20536.

The complementary funct.ionto POKE is PEEX. The

argument to PEEX is an address from which a byte
is to be read. See Section 3.27.

POKE and PEEX are useful for efficient data
storage, loading assembly language subroutines,
and passing arguments and results to and from
assembly language subroutines.

Purpose:
Remarks:

To output data at the terminal.

If <list of expressions> is omitted, a blank
line is printed. If <list of expressions> is
included, the values of the expressions are

printed at the terminal. The expressions in the

list may be numeric and/or string expressions.

(Strings must be enclosed in quotation marks.)

The position of each printed item is determined

by the punctuation used to separate the items in

the list. BASIC-SO divides the line into print

zones of 14 spaces each. In the list of
expressions, a comma causes the next value to be
printed at the beginning of the next zone. A

semicolon.causes the next value to be printed

immediately after the last value. Typing one or
more spaces between expressions has the same
effect as typing a semicolon.

If a comma or a semicolon terminates the list of

expressions, the next PRINT statement begins
printing on the same line, spacing accordingly.

If the list of expressions terminates without a

comma or a semicolon, a carriage return is

printed at the end of the line. If the printed

line is longer than the terminal width, BASIC-SO

goes to the next physical line and continues

printing.

Printed numbers are always followed by a space.

Positive numbers are preceded by a space.
Negative numbers are preceded by a minus s~gn.

Single precision numbers that can be represented
with 6 or fewer digits in the unsealed format no

less accurately than they can be represented in

the scaled format, are output using the unsealed

format. For example, 10A(-6) is output as

.000001 and 10A(-7) is output as 1E-7. Double

precision numbers that ean be represented with

16 or fewer digits in the unsealed format no
less accurately than they can be represented in

the sealed format, are output using the unsealed

format. For example, 10A(-16) is output as

.0000000000000001 and 10A(-17) is output as
10-17.

A question mark may be used

in

place

of the

word

PRINT in a

PRINT statement.

Example

1: 10 X=S

20

PRINT

X+S,

X-S,

X*(-S},

XJ\S

30

END

RUN

10

0

-2S 312S

Ok

In this example, the commas in the PRINT
statement cause each value to be printed at the

beginninq of the next print zone.

Example 2: LIST

10 INPUT X

20 PRINT X "SQUARED IS"

XJ\2

"AND";

30 PRINT X "COBED IS"

XJ\3

40 PRINT

SO

GOTO

10

Ok

RUN

?

9

9

SQUARED IS

81

AND

9

CUBED IS

729

?

21

21

SQUARED IS

441

AND

21

CUBED IS

9261

In this example, the semicolon at the end of

line 20 causes both PRINT statements to be
printed on the same line, and line 40 causes a
blank line to be printed before the next prompt.

Example

3:

10

FOR

X

:II

1

TO

S
20 J=J+S
30

K=K+10

40

?J;K;

SO

NEXT

X

Ok
RUN

S 10 10 20

1S

30 20 40 2S SO

Ok

In this example, the semicolons in the PRINT

statement cause each value to be printed

immediately after the preceding

value.

(Don't

forget, a number is always followed by a space

and positive numbers are preceded by a space.)

In line 40, a question mark is used instead of
the word PRINT.

Remarks
and

Examples:

PRINT USING <"format string">;<list of expressions>

Extended, Disk
To print.strings or numbers using a specified

format.

<list of expressions> is comprised of the string
expressions or numeric expressions that are to
be printed, separated by semicolons. <"format

string">, enclosed in quotation marks, is
comprised of special formatting characters.
These formatting characters (see below)
determine the field and the format of the
printed strings or numbers.

String Fields

When PRINT USING is used to print strings, one
of three formatting characters may be used to

format the string field:

"!" Spec~fies that only the first character in the

given string is to be printed.

"\n spaces\" Specifies that 2+n characters from the string

are to be printed. If the backslashes are typed

with no spaces, two characters will be printed;

with one space, three characters will be
printed, and so on. If the string is longer

than the field, the extra characters are

ignored. If the field is longer than the

string, the string will be left-justified in the

field and padded with spaces on the right.
Example:

10 A$-"LOOX":B$-"OUT"

30 PRINT USING "!";A$;B$

40 PRINT USING "\ \" ;A$';B$

SO PRINT USING "\ \";A$;B$;"!!"

RON

LO
LOOKOUT

LOOK OUT !!

"&"

Specifies a variable length string field. When
the field is specified with

"&If,

the string is

output exactly as input. Example:

10 A$a"LOOK":B$-"OUT"

20 PRINT USING

"!";A$;

30 PRINT USING "&";B$

RUN

LOUT

When PRINT USING is used to print numbers, the

following special characters may be used to
format the numeric field:

A number sign is used to represent each digit
position. Digit positions are always filled.

If the number to be printed has fewer digits
than positions specified, the number will be
right-justified (preceded by spaces) in the
field.

A decimal point may be inserted at any position

in the field. If the format string specifies
that a digit is to precede the decimal point,
the digit will always be printed (as 0 if
necessary). Numbers are rounded as necessary.

PRINT USING

"#1.+.-;.78

0.78

PRINT USING ".II.tt";987.654

987.65

PRINT USING "ti.it ";10.2,5.3,66.789,.234

10.20 5.30 66.79 0.23

In the last example, three spaces were inserted
at the end of the format string to separate the
printed values on the line.

A plus sign at the beginning or end of the

format string will cause the sign of the number

(plus or minus) to be printed before or after

the number.

A minus sign at the end of the format field will

cause negative numbers to be printed with a
trailing minus sign.

PRINT USING "+tt.ti ";-68.95,2.4,55.6,-.9

-68.95 +2.40 +55.60 -0.90

PRINT USING "tt.ti- ";-68.95,22.449,-7.01

68.95- 22.45 7.01-

A double asterisk at the beginning of the format

string causes leading spaces in the numeric
field to be filled with asterisks. The

**

also

specifies positions for two more digits.

PRINT USING "**i.t ";12.39,-0.9,765.1

*12.4 *-0.9 765.1

$$.

A double dollar sign causes a dollar sign to be

printed to the immediate left of the formatted
number. The

$$

specifies two more digit

positions, one of which is the dollar sign. The

exponential format cannot be used with

$$.

Negative numbers cannot be used unless the minus

sign trails to the right.

PRINT USING "$$llt.#i";456.78

$'456.78

**$ The **$ at the beginning of a format string

combines the effects of the above two symbols.
Leading spaces will be asterisk-filled and a
dollar sign will be printed before the number.

**$

specifies three more digit positions, one of

which is the dollar sign.

PRINT USING "**$#i.#t";2.34

***$2.34
A comma that is to the left of the decimal point

in a for.matting string causes a comma to be
printed to the left of every third digit to the

left of the decimal point. A comma that is at

the end of the format string is printed as part

of the string. A comma specifies another digit
position. The comma has no effect if used with

the exponential

(AAAA)

format.

PRINT USING "itii,.ii";1234.5

1,234.50

PRINT USING "iiii.ii,";1234.5

1234.50,

AAAA Four carats (or up-arrows) may be placed after

the digit position characters to specify
exponential format. The four carats allow space

for E+xx to be printed. Any decimal point
position may be specified. The significant
digits are left-justified, and the exponent is

adjusted. Unless a leading + or trailing + or -

is specified, one digit position

will

be used to
the left of the decimal point to print a space
or a minus sign. .

PRINT USING "tt.tiAAAA";234.S6

2.3SE+02

PRINT USING ".iiitAAAA-";888888

.8889E+06

PRINT USING "+.ttAAAA";123
+.12E+03

An underscore in the format string causes the
next character to be output as a literal
character.

PRINT USING" 1il.##_1";12.34

112.341

The

literal

character itself may be an

underscore by placing "__" in the format string.

If the number to be printed is larger than the

specified numeric field, a percent sign is
printed in front of the number. If rounding
causes the number to exceed the field, a percent
sign

will

be printed in front of the rounded

number.
PRINT USING "#I.ii":111.22

'111.22
PRINT USING ".#''';.999

'1.00

If the number of digits specified exceeds 24, an

"Illegal

function call" error will result.

Purpose:

Remarks:

PRINTi<filenumber>,[USING<"format string">1]<list of exps:
Disk
To write data to a sequential disk file.

<filenumber> is the number used when the file
was OPENed for output. <"format string"> is

comprised of formatting characters as described

in Section 2.50, PRINT USING. The expressions

in <list of expressions> are the numeric and/or

string expressions that will be written to the

file.

PRZNTt does not compress data on the disk. An

image of the data is written to the disk, just
as it would be displayed on the terminal with a
PRINT statement. For this reason, care should

be taken to delimit the data on the disk, so

that it will be input correctly from the disk.

In the list of expressions, numeric
should be delimited by semicolons.

expressions

For example,

(If commas are used as delimiters, the extra
blanks that are inserted between print fields
will also be written to disk.)

String expressions must be separated by
semicolons in the list. To format the string
expressions correctly on the disk, use explicit
delimiters in the list of expressions.

For example, let

A$="CAMERA"

and

5$=-"93604-1".

The statement

would write

CAMERA93604-1

to the disk. Because
there are no delimiters, this could not be input
as two separate strings. To correct the

problem, insert explicit delimiters into the

PRINTi statement as follows:

which can be read back

variables.

If the strings themselves contain

semicolons, significant leading blanks,
returns, or line feeds, write them
surrounded by explicit quotation
CHR$(34).

commas,
carriage
to disk

marks,

For example, let A$-"CAMERA, AUTOMATIC" and
B$-" 93604-1". The statement

would input "CAMERA" to

"AUTOMATIC 93604-1" to B$. To
strings properly on the disk,
quotes to the disk image using
statement

A$ and

separate these

write double

CHR$ (34). 'The

"CAMERA, AUTOMATIC""

and the statement

would input "CAMERA, AUTOMATIC" to

" 93604-1" to B$.

The PRINTt statement may also be used with the

USING option to control the format of the disk

file. For example:

PRINT#1,USING"$$###.##,";J;K;L

PUT [i]<file number>[,<record number>]
Disk
To write a record from a random buffer to a

random disk file.
<file number> is the number under which the file

was OPENed. I"f<record number> is omitted, the

record will have the next avai~able record
number (after the last PUT). The largest

possible record number is 32767.

See Appendix B.

RANDOMIZE «expression>]
Extended, Disk

If <expression> is

program execution
printing

Random Number Seed

(0-65529)?

omitted, BASIC-80 suspends
and asks for a value by

If ~e random number generator is not reseeded,
the RND function returns ~e same sequence of

random numbers each time the program is RUN. To

change the sequence of random numbers every time

the program is RUN, place a RANDOMIZE statement

at the beginning of the program and change the
argument with each RON.

10 Rk'mOMIZE

2.0

FOR I-1 TO 5

30 PRINT

RND

J

40 NEXT I

RON
Random Number Seed (0-65529)? 3 (user types 3)

.88598 .484668 .586328 .119426

.709225

Ok

RUN

Random Number Seed

(0-65529)?

4 (user types 4

for new sequence)

.803506 .162462 .929364 .292443 .322921
Ok
RON

Random Number Seed

(0-65529)?

3 (same sequence

as first RUN)

.88598 .484668 .586328 .119426

.709225

Ok

With the BASIC Compiler, the prompt given by

RANDOMIZE is:

Random Number Seed (-32768 to 32767)?

8K, Extended, Disk

To read values from a DATA statement and assign

them to variables. (See DATA, Section 2.10.)

A READ statement must always be used in

conjunction with a DATA statement. READ
statements assign variables to DATA statement
values on a one-to-one basis. READ statement
variables may be numeric or string, and the
values read must agree with the variable types

specified. If they do not agree, a ~Syntax

error" will result.
A single READ statement may access one or more

DATA statements (they will be accessed in
order), or several~. statements may access

the same DATA statment. If the num}:)erof
variables in <list of variables> exceeds the
numJ::)erof elements in the DATA statement(s), an
OUT OF DATA messaqe is printed. If the number
of variables specified is fewer than the number

of elements in the DATA statement (s), subsequent

READ statements will beqin reading data at the

first unread element. If there are no
subsequent READ statements, the extra data is
ignored.

To reread DATA statements from

the RESTORE statement (see

2.57)

the start, use

RESTORE, Section

•

80 FOR 1=1 TO 10·

90 READ A(I)

100 NEXT I
110 DATA 3.08,5.19,3.12,3.98,4.24
120 DATA 5.08,5.55,4.00,3.16,3.31

Thia proqram.segment READs the values

DATA statements into the array

execution, the value of A(1) will be

so on.

from the

A. After

3.08, and

Example 2: LIST

10 PRINT "CITY", "STATE", " ZIP"
20 READ C$,S$,Z
30 DATA "DENVER,", COLORADO, 80211
40 PRINT C$,S$,Z

Ok

RON '

CITY STATE ZIP
DENVER, COLORADO 80211

Ok

This program READs string and numeric data from
the DATA statement in line 30.

SK, ~ended, Disk

To allow explanatory remarks to be inserted in a

program.

REM statements are not executed but are output
exactly as entered when the program is listed.

REM

statements may be branched into (from a GaTO

or GOSUB statement), and execution will continue

with the first executable statement after the

REM

statement.

In the Extended and Disk versions, remarks may

be added to the end of a line by preceding the

remark with a single quotation mark instead of

:REM•

•

120 REM CALCULATE AVERAGE VELOCITY
130 FOR I-1 TO 20
140 SUM-SUM + VeIl

120 FOR I-1 TO 20
130 SUM-SUM+V (I)
140 NEXT I

Purpose:
Remarks:

RENUM [[<new number>] [,[<old number>] [,<increment>]]]
Extended, Disk
To renumber program lines.

<new number> is the first line number to be used

in the new sequence. The default is 10. <old
number> is the line in the current program where
renumbering is to begin. The default is the

first line of the program. <increment> is the

increment to be used in the new sequence. The
default is 10.

RENCH also changes all line number references

following GOTO, GOSUB, THEN, ON •••GOTO,
ON•••GOSUB and ERL statements to reflect the new

line numbers. If a nonexistent line number

appears after one of these statements, the error
message "Undefined line xxxxx in yyyyy" is
printed. The incorrect line number reference

(xxxxx) is not changed by RENUM, but line number

yyyyy may be .changed.

RENUM cannot be used to change the order of
program lines (for example, RENUM

15,30

when the

program has three lines numbered

10, 20

and

30)

or to create line numbers greater than

65529.

An "Illegal function call" error will result.

Renumbers the entire program.
The first new line number
will be 10. Lines will

increment by 10.

RENUM

30G,,50

Renumbers the entire pro-
gram. The first new line
number will be

300.

Lines

will increment by 50.

RENUM

1000,900,20

Renumbers the lines from

900

up so they start with

line number

1000

and

increment by 20.

8K, Extended, Disk

To

allow

DATA statements to be reread from a

specified point.

After a RESTORE statement is executed, the next

READ statement accesses the first item in the

first DATA statement in the program. If <line
number> is specified, the next READ statement
accesses the first item in the specified DATA
statement.

Example:

10

READ A,B,C

20

RESTOBE

30

READ D,E,F

40

DATA 57,

68,

79

•

•

•