home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Big Blue Disk 16
/
bbd16.zip
/
MANUAL
< prev
next >
Wrap
Text File
|
1984-09-14
|
96KB
|
3,763 lines
STRUCTURED PROGRAMMING LANGUAGE
STRUCTURED PROGRAMMING LANGUAGE
STRUCTURED PROGRAMMING LANGUAGE
Copyright by Dennis Baer 1983
25 Miller Road Farmingdale,N.Y. 11735
516-694-5872
This language is dedicated to you, the PROGRAMMER.
1
Structured programming language
A Structured Programming Language processor for the MS-DOS
family of computers. The instructions for running the
processor are on page 51.
The following are the statements that make up the Structured
Programming language: [ See important note on page 7. ]
Statement Page
1. BEGIN 14
2. REAL 16
3. INTEGER 18
4. STRING 19
5. REAL ARRAY 20
6. INTEGER ARRAY 21
7. STRING ARRAY 22
8. PROCEDURE 23
9. COMMENT 25
10. GO 26
11. GO TO 26
12. GOTO 26
13. ONERRGOTO 27
14. RETURN 28
15. INPUT 29
16. LINEIN 30
17. GET [I/O] 31
18. PUT [I/O] 31
19. OUTPUT 32
20. CALL 33
21. FOR 34
22. IF 35
2
Statement Page
23. END 36
24. WHILE 37
25. REPEAT 38
26. ; 39
27. WRITE *Z 10.179-10.180 *I 4-298 4-299
28. CHAIN **Z 10.13-10.14 **I 4-36
29. BEEP *Z 10.5 *I 4-28
30. BLOAD **Z 10.6-10.7 **I 4-29
31. BSAVE **Z 10.8-10.9 **I 4-32
32. CALL [EXTERNAL] *Z 10.10-10.11 *I 4-34
33. CLEAR *Z 10.18 *I 4-44
34. CLOSE **Z 10.19 **I 4-46
35. FILES **Z 10.51 **I 4-97
36. FIELD *Z 10.50 *I 4-94
37. KILL **Z 10.84 **I 4-136
38. NAME **Z 10.108 **I 4-173
39. OPEN **Z 10.115-10.121 **I 4-189,4-194
40. OUT **Z 10.123 **I 4-201
41. DOS 40
42. POKE *Z 10.127 *I 4-214
43. RESET *Z 10.146 *I 4-243
44. RESUME *Z 10.148 *I 4-245
45. RUN **Z 10.152 **I 4-251
46. STOP *Z 10.161 *I 4-270
47. WAIT *Z 10.176 *I 4-290
48. HOME 41
49. DEFSEG 42
3
Statement Page
50. ERROR *Z 10.47-10.48 *I 4-91
51. KEY *Z 10.81-10.83 *I 4-131
52. LSET *Z 10.103 *I 4-163
53. RSET *Z 10.103 *I 4-163
54. RANDOMIZE *Z 10.141 *I 4-236
55. SWAP *Z 10.164 *I 4-277
56. COLOR *Z 10.21-10.22 *I 4-49,4-54
57. DRAW *Z 10.40-10.41 *I 4-79
58. CIRCLE *Z 10.17 *I 4-41
59. GET [GRAPHICS] *Z 10.59-10.61 *I 4-108
60. PUT [GRAPHICS] *Z 10.59-10.61 *I 4-232
61. LINE *Z 10.88-10.89 *I 4-141
62. LOCATE *Z 10.97-10.98 *I 4-155
63. PRESET *Z 10.129 *I 4-228
64. PSET *Z 10.138-10.139 *I 4-228
65. PAINT *Z 10.124 *I 4-203
66. SCREEN *Z 10.155 *I 4-257
67. DATE$ *Z 10.32 *I 4-66
68. TIME$ *Z 10.168-10.169 *I 4-281
69. MID$ *Z 10.106 *I 4-167
70. WIDTH *Z 10.178 *I 4-294
71. COM(N) *Z F.8-F.10 *I 4-56
72. KEY(N) *Z F.8-F.10 *I 4-134
73. ON COM(N) *Z F.8-F.10 *I 4-176
74. ON KEY(N) *Z F.8-F.10 *I 4-182
75. NULL *Z 10.110
76. EOT 43
4
Statement Page
77. Arithmetic assignment 44
78. String assignment 45
79. Labeled statement 46
The following functions are supported in the Structured
Programming Language for MS DOS systems.
Arithmetic Function Page Page
(Z) (I)
1. ABS 10.1 4-21
2. ATN 10.3 4-25
3. CDBL 10.12 4-35
4. CINT 10.16 4-40
5. COS 10.26 4-60
6. CSNG 10.28 4-61
7. EXP 10.49 4-93
8. FIX 10.52 4-99
9. INT 10.80 4-130
10. LOG 10.100 4-159
11. RND 10.151 4-249
12. SGN 10.156 4-260
13. SIN 10.157 4-261
14. SQR 10.160 4-267
15. TAN 10.167 4-280
String function Page Page
(Z) (I)
1. ASC 10.2 4-24
2. CHR$ 10.15 4-38
3. CVI 10.30 4-63
4. CVS 10.30 4-63
5
String Function Page Page
(Z) (I)
5. CVD 10.30 4-63
6. EOF 10.44 4-86
7. FRE 10.57 4-104
8. HEX$ 10.64 4-115
9. INPUT$ 10.78 4-127
10. INSTR 10.79 4-129
11. LEFT$ 10.85 4-137
12. LEN 10.86 4-138
13. LOC 10.96 4-153
14. LOF 10.99 4-158
15. MID$ 10.105 4-167
16. MKI$ 10.107 4-170
17. MKS$ 10.107 4-170
18. MKD$ 10.107 4-170
19. OCT$ 10.111 4-175
20. RIGHT$ 10.150 4-248
21. SPACE$ 10.158 4-265
22. STR$ 10.162 4-272
23. STRING$ 10.163 4-276
24. VAL 10.172 4-285
Special Functions Page Page
(Z) (I)
1. CSRLIN 10.29 4-62
2. FRE 10.57 4-104
3. INP 10.71 4-121
4. LPOS 10.101 4-160
5. PEEK 10.125 4-205
6. POINT 10.126 4-213
6
Special Functions Page Page
(Z) (I)
7. POS 10.128 4-215
8. SCREEN 10.154 4-255
9. SPC 10.159 4-266
10. TAB 10.166 4-279
11. VARPTR 10.173 4-286,4-288
12. WIDTH 10.178 4-294
Special Variables
1. ERR 10.46 4-89
2. ERL 10.46 4-89
3. INKEY$ 10.70 4-119
Additional categories Page
STATEMENT FORMATS 9
ARITHMETIC OPERATORS 47
STRING OPERATORS 47
LOGICAL OPERATORS 47
COMPARISON OPERATORS 47
IMPLEMENTATION RESTRICTIONS 48
REAL,INTEGER,STRING CONSTANTS 49
APPLICATION NOTES 50
RUNNING THE PROCESSOR 51
ERROR MESSAGES 52
INDEX 56
Note: *Z *I means refer to page in computer manufacturers
BASIC manual. **Z **I means refer to page in computer
manufacturers BASIC manual but command is slightly different.
parentheses must be placed after the key word and before the
semicolon. (Z=Zenith,I=IBM) See each statement format from pages
8 through 13. The statement must have variable names that conform
to Structured Programming Language standards. If you don't see
page references for your computer then consult your BASIC manual.
7
Programs written in the Structured Programming Language are
kept in an ASCII text file. Any text editor that can create an
ASCII text file for MS DOS can be used to write Structured
Programming Language programs. It is a free format block and
procedure oriented language that runs in the MS DOS environment.
Each computer's implementation of a computer language has its own
unique characteristics. In this implementation of the Structured
Programming Language, the processor uses the text file of
Structured Programming Language statements as input and
translates this program to BASIC in an ASCII text file for the
particular MS DOS system. The text file can be run by the BASIC
interpreter or be compiled by the BASIC compiler after it is
loaded into the interpreter workspace and then saved in ASCII
format on the users disk drive. This manual is intended to be a
reference manual for the MS DOS version of the Structured
Programming Language and is not meant to be a tutorial. To get an
idea of procedure oriented and block structured languages, you
can read books on the ALGOL and PASCAL languages.
8
The following are the statement formats for the Structured
Programming Language.
1. BEGIN
2. REAL <variable> {,<variable>,..........,<variable>};
3. INTEGER <variable> {,<variable>,..........,<variable>};
4. STRING <variable> {,<variable>,..........,<variable>};
5. REAL ARRAY <array variable>(<bounds>) {,<array variable>
(<bounds>),..........};
6. INTEGER ARRAY <array variable>(<bounds>) {,<array variable>
(<bounds>),..........};
7. STRING ARRAY <array variable>(<bounds>) {,<array variable>
(<bounds>),..........};
8. PROCEDURE <procedure name> { (<parameter list>) };
BEGIN
<statements>
END
9. COMMENT <text>; [Note: <text> should not contain ' char.]
10. GO <label>;
11. GO TO <label>;
12. GOTO <label>;
13. ONERRGOTO <label>;
14. RETURN {<label>};
15. INPUT( {@} {<prompt string>{@|,}} <variable list> );
15a. INPUT( #<file number>,<variable list> );
15b. LINEIN( {@} {<prompt string>{@|,}} <string variable>);
15c. LINEIN( #<file number>,<string variable>);
16. GET #<file number> {,<record number>};
17. PUT #<file number> {,<record number>};
9
18. OUTPUT( {#<file number>,} {USING <string expression>@}
{<output expression list>} );
19. {CALL} <procedure name> {( <argument list> )};
20. FOR <scalar arithmetic variable> := <start arith. expr.>
STEP <increment arithmetic expression>
UNTIL <limit arithmetic expression>
DO BEGIN
<statements>
END
21. IF <logical expression> THEN <statement>
{ ELSE <statement> }
Note: In each of the clauses THEN,ELSE the <statement>
can be replaced with BEGIN <statements> END
The single statement may not be an IF,FOR,REPEAT,REAL,
INTEGER,STRING,PROCEDURE,ON, or WHILE statement. You
must place it between BEGIN and END statements.
22. END
23. WHILE <logical expression> DO
BEGIN
<statements>
END
24. REPEAT <statements>
UNTIL <logical expression>;
25. ;
26. WRITE {#<file number>,} {<expression list>};
27. CHAIN( <file name> );
28. BEEP;
29. BLOAD( <file name> {,<offset>} );
10
30. BSAVE( <file name>,<offset>,<length> );
Note:The offset is added to the current segment address
which gives the address.
31. CALL <variable> {( <argument list> )};
Note:<variable> is an INTEGER variable that has the same
name as a global program name as in PASCAL,ASSEMBLER, or
FORTRAN (by MICROSOFT)
32. CLEAR {{,<highest location>} {,<stack space>}};
33. CLOSE( {#} <file number> {,{#} <file number>,..........} );
34. FILES( { <files> } );
35. FIELD # <file number>,<field width> AS <string variable>,
{ <field width> AS <string variable>,.......... };
36. KILL( <files> );
37. NAME( <file name> AS <new file name> );
38. OPEN( <mode>,{#} <file number>,<file name> {,<record len.>} );
Note:The <mode> in 38. is 'O','I',or 'R'
38a. OPEN( <file name> { FOR <mode> } AS {#} <file number>
{ LEN = <record length> } );
Note:The <mode> in 38a. is INPUT,OUTPUT,or APPEND. RANDOM
is assumed if mode is left out.
38b. OPEN( 'COM1:<speed>,<parity>,<data>,<stop>' AS <file no.> );
39. OUT( <port number>,<data> );
40. DOS;
Note:This statement brings the user back to MS DOS.
41. POKE <machine location offset>,<data>;
42. RESET;
43. RESUME { <label> };
44. RUN( <file name> );
11
45. STOP;
46. WAIT <port address>,<integer expr.>,<integer expr.>;
47. HOME; Note:This statement clears the screen.
48. DEFSEG := <expression>;
49. ERROR <integer expression>;
50. KEY <key number>,<string expression>;
50a. KEY LIST;
50b. KEY ON;
50c. KEY OFF;
51. LSET <string variable> := <string expression>;
52. RSET <string variable> := <string expression>;
53. RANDOMIZE <arithmetic expression>;
54. SWAP <variable>,<variable>;
55. COLOR { <foreground> } {,<background> };
56. DRAW <string expression>;
57. CIRCLE (<x center>,<y center>),<radius> {,<color {,<start>
,<end> {,<aspect ratio>}}};
58. GET (<x1>,<y1>)-(<x2>,<y2>),<array name>;
59. PUT (<x1>,<y1>),<array name> {,<action verb> };
Note: <action verb> is AND,OR,XOR,PSET,or PRESET
60. LINE (<x1>,<y1>)-(<x2>,<y2>) {,{<color>} {,B {F}};
Note:Lower case letters b,f can be used instead of B,F
61. LOCATE {<row>},{<column>} {,{<cursor>}};
62. PRESET (<x>,<y>) {,<color>};
62a. PRESET STEP (<x offset>,<y offset>) {,<color>};
63. PSET (<x>,<y>) {,<color>};
63a. PSET STEP (<x offset>,<y offset>) {,<color>};
64. PAINT (<x start>,<y start>) {,<paint color> {,<border color>}};
12
65. SCREEN {<graphics mode>,} {<reverse video>};
66. DATE$ := <date string expression>;
67. TIME$ := <time string expression>;
68. MID$(<string expr. 1>,<integer expr. 1>{,<integer expr. 2>})
:= <string expression 2>;
69. WIDTH <integer expression>;
70. COM( <arithmetic expression> ) ON
OFF ;
STOP
71. KEY( <arithmetic expression> ) ON
OFF ;
STOP
72. ON COM( <arithmetic expression> ) THEN CALL <procedure name> ;
73. ON KEY( <arithmetic expression> ) THEN CALL <procedure name> ;
Note: For statements 72. and 73. the <procedure name> represents
a procedure without arguments.
74. NULL <integer expression>;
75. <space> EOT <space>
Note:This must be on the last line of the file.
76. <arithmetic variable> := <arithmetic expression>;
77. <string variable> := <string expression>;
78. <label>:.....:<label>:<executable statement>;
Anything in between { } is optional.
Anything between < > means a description of the value and that
the < > are not part of the statement.
Repetition symbol ......... means that an item can be repeated.
13
BEGIN
Format: BEGIN
The BEGIN statement is used to define the start of a
Structured Programming Language program or a start of a new block
in a program. It tells the Structured Programming Language
processor that a new logical unit of declarations of variables
and executable instructions starts. It also creates a new level
of variable storage. The first BEGIN statement does both, defines
the start of a program and the start of a new block. An example
of BEGIN usage.
BEGIN
REAL x,y,fnc;
INPUT(x,y);
fnc:=x*y; OUTPUT(fnc);
END
In the above example, the reserved word BEGIN defines the
start of the program and tells the Structured Programming
Language processor that a new block has started. Reserved words
should not be used as variable names, label names,
procedures,etc. If you do then they will conflict with the
meaning of these words and will not be taken as variables.
Reserved words are Structured Programming Language statement
names, and the various mathematical, string, file functions and
operators. The user shall find reference to these reserved words
in the table of contents. Another example of the usage of BEGIN.
BEGIN
REAL X,Y,FNC;
ask:INPUT(X,Y); FNC:=X*Y;
IF FNC<0 THEN
BEGIN
OUTPUT('The value of FNC is less than zero');
GO ask;
END
END
In the above example, the first BEGIN statement defines the
start of the program and the first level of storage and
executable statements. The second BEGIN statement defines a new
block, but in this case the block will only be entered if the
condition of the clause of the IF statement is true. That is IF
FNC < 0. This second BEGIN block can contain declaration
statements if the user chooses to put them in there. Any BEGIN
block can contain both declaration and executable statements. The
rule however is that the declaration statements must precede the
executable statements. The END statement defines an end to a
logical block of statements and declarations of variables. These
variables when declared in a block will be known in that block
and any block declared inside that block. If the condition FNC <
0 is false, then execution will skip the second BEGIN
14
statement, the OUTPUT statement,the GO statement and the END
statement. Execution then continues with the statement after that
END statement, which is the final END statement in this case.
When execution reaches the final END statement, the program ends
and control goes back to the system. A third example of BEGIN.
BEGIN
REAL a,h,c;
INTEGER i,j,k;
a:=5; h:=25;
Insideblock:
BEGIN
REAL a1,b1,function;
function:=(a+h)^2.; OUTPUT(function); c:=function;
END
IF c>500 THEN
BEGIN
OUTPUT('(a+h)^2. is greater than 500');
END
ELSE
BEGIN
OUTPUT('(a+h)^2. is less than or equal to 500');
END
IF c>800 THEN GO TO Insideblock;
END
In this above example there is the main BEGIN END block that
contains the entire program. In the main block the variables
a,h,c,i,j,k are declared. The block labeled Insideblock is
an inner block that computes the value function and c. A third
block is a THEN clause of the IF statement and is only executed
if the logical expression of the IF statement is true. That is if
c>500. The fourth block is executed only if the logical
expression of the IF statement is false. Now notice the second IF
statement, if c>800 then execution will go to the BEGIN block
labeled Insideblock. In this program there are three blocks
inside the first block, which is the main program.
15
REAL
Format: REAL <variable> {,<variable>,..........,<variable>};
The REAL statement is a nonexecutable declaration statement
which informs the Structured Programming Language processor that
the variables declared are REAL scalar variables. They contain
single precision floating point numbers. The identifier is the
actual name of the variable that is declared and referenced in a
Structured Programming Language program. An identifier is a name
of up to 40 characters which begins with an uppercase or
lowercase alphabetic character. Subsequent characters can be
upper or lower case letters, numbers, dollar sign, or an
underscore. An example of the REAL statement.
BEGIN
REAL X,Y,Z,FUNCTION;
INTEGER percentile;
REAL a1,a2,a3;
X:=Y+Z; FUNCTION:=SQR(X^2.+Y^2.);
BEGIN
a1:=5; a2:=10; a3:=a1^a2; OUTPUT('a3 is:'@ a3);
END
END
The above example is a small program. The first REAL
statement declares that X,Y,Z,FUNCTION are REAL scalar variables
in that block and are known in any block nested in that block
unless the name is reused in a declaration statement in the
nested block. Names declared in a BEGIN block are not known
outside the block. The second REAL statement declares that
a1,a2,a3 are real variables in that block. Note that the
variables a1,a2,a3 referenced in the inside BEGIN block are
actually declared in the outer block,which incidently is the main
program block. Another example of the REAL statement.
BEGIN
REAL a,h;
a:=1; h:=2;
BEGIN
REAL a,c;
a:=3; c:=4; OUTPUT('The product of a and h is:'@ a*h);
IF a+h<4 THEN
BEGIN
REAL c,d;
c:=5; d:=6; OUTPUT('The sum of c and d is:'@ c+d);
END
END
END
In the above example a and h are declared as REAL scalar
variables in the outermost program block. The second REAL
statement declares a and c to be REAL scalar variables. It is
important to note that at the first OUTPUT statement that the
reference to the REAL variable a is the variable a that was
16
declared in the second BEGIN block that is nested in the main
program BEGIN block. a was set to 3 in this inner block and this
variable a is much different from the variable a in the outer
BEGIN block. Each variable a has a location allocated to it to
store one single precision floating point number. However the
REAL variable h referenced in the inner block is the same
variable h that is declared in the outer block because the rule
is that a nested BEGIN block knows all variables outside of it,
except if the same variable name is used in a declaration
statement. But h is not redeclared, so it is known. c is known
because it is declared in the inner second block. Now note the
third BEGIN block. It is only executed if the logical statement
a+h<4 is true. This third block has a REAL statement that
declares c and d to be REAL scalar variables. At the OUTPUT
statement in this third block c is the variable c declared in
this block and d is also the one that is declared in this block.
In addition, variable a if it were to be referenced would be the
variable a declared in the second block and h would be the
variable declared in the first outermost program block. So you
see that depending on what variables are declared and where they
are referenced, the actual storage can vary. In summation the
REAL statement sets up storage that is known for the block and
for any block nested inside of it, except those blocks that
redeclare that name. The storage for the variable is static and
is not lost if you exit the block in which it is declared.
Variable names cannot be any of the various key words that are
defined in the Structured Programming Language. See the table of
contents for the reserved words. They include the statement names
and mathematical,string,and file functions. A REAL variable may
contain a number ranging from 10^-38 to 10^38 or -10^38 to -10^-
38. with 9 digits of precision.
17
INTEGER
Format: INTEGER <variable>{,<variable>,..........,<variable>};
The INTEGER statement is a nonexecutable declaration
statement that informs the Structured Programming Language
processor that the variables named are scalar INTEGER variables.
For an explanation of what an identifier is, see the REAL
statement section. An example.
BEGIN
INTEGER i,j,k;
i:=1; j:=2; k:=3;
BEGIN
INTEGER i,j,m;
m:=i+j+k; OUTPUT(m,i,j,k);
END
END
The first INTEGER statement declares i,j,k as scalar INTEGER
variables in the outermost program block. The i,j that are
declared here will not be known by the second block which is
nested in the first block. The variable k is known in the second
block as an INTEGER scalar variable. The second INTEGER statement
declares that i,j,m are scalar INTEGER variables. Variable m is
not known in the outer block, and the variables i and j declared
in the inner block are different from the variables i and j
declared in the outer block. INTEGER variables can hold a number
between -32767 and 32767. The rule, that has been mentioned in
the REAL section, about what variables are known in what block is
the rule of SCOPE of VARIABLES.
18
STRING
Format: STRING <variable> {,<variable>,..........,<variable>};
The STRING statement is a nonexecutable declaration
statement that informs the Structured Programming Language
processor that the named variables are to be scalar STRING
variables. For an explanation of identifiers and the rule of
SCOPE of VARIABLES see the sections of REAL and INTEGER
variables. An example.
BEGIN
REAL x,y;
STRING Name,Address,Phone;
INPUT(Name,Address,Phone);
OUTPUT(MID$(Name,1,INSTR(Name,' ')),Phone);
END
Name,Address,Phone are declared to be STRING scalar
variables. A STRING scalar variable can hold up to 32767
characters, if you will be using the translated BASIC program to
be compiled with a compiler. If the translated program will run
as an interpreted program then the maximum amount of characters
that a STRING can hold is 255. The least amount of characters is
0 which represents the NULL string. The amount of characters that
a STRING holds varies depending on the length of the string
expression at the time of assignment of the variable.
19
REAL ARRAY
Format: REAL ARRAY <array variable>(<bounds>)
{,<array variable> (<bounds>),..........};
The REAL ARRAY statement is a nonexecutable declaration
statement that informs the Structured Programming Language
processor that the named variables are REAL ARRAY variables.
Static storage is set aside for these arrays. See the section on
REAL variables for an explanation of identifiers and SCOPE of
VARIABLES. An example.
BEGIN
INTEGER intg1,intg2,intg3,count;
REAL zz,aa,bb;
REAL ARRAY y(100,100),x(5,5);
REAL ARRAY Z(4,4,4);
FOR intg1:=1 STEP 1 UNTIL 100 DO
BEGIN
FOR intg2:=1 STEP 1 UNTIL 100 DO
BEGIN
y(intg1,intg2):=0;
END
END
END
In this program three arrays are declared in the block. They
are: y(100,100) x(5,5) and Z(4,4,4). ARRAY bounds in a
ARRAY declaration statement must be unsigned integer constants.
20
INTEGER ARRAY
Format: INTEGER ARRAY <array variable>(<bounds>)
{,<array variable>(<bounds>),..........};
The INTEGER ARRAY statement is a nonexecutable declaration
statement that informs the Structured Programming Language
processor that the named variables are INTEGER ARRAY variables.
Static storage is set up for each INTEGER ARRAY variable. See the
section on REAL variables for details on identifiers and SCOPE OF
VARIABLES. An example.
BEGIN
INTEGER ARRAY N(15,5),PIX(20,3);
INTEGER i,j,min;
min:=-32760;
FOR i:=1 STEP 1 UNTIL 15 DO
BEGIN
FOR j:=1 STEP 1 UNTIL 5 DO
BEGIN
INPUT(N(i,j)); IF N(i,j)<min THEN min:=N(i,j);
END
END
OUTPUT('minimum value is:' @ min);
END
In the above example INTEGER ARRAY variables N(15,5) and
PIX(20,3) are declared. ARRAY bounds in an ARRAY declaration
statement must be unsigned integer constants.
21
STRING ARRAY
Format: STRING ARRAY <array variable>(<bounds>)
{,<array variable>(<bounds>),..........};
The STRING ARRAY statement is a nonexecutable declaration
statement that informs the Structured Programming Language
processor that the named variables are STRING ARRAY variables.
Static storage is set up for the STRING ARRAY variable. See the
section on REAL variables for details of identifiers and SCOPE of
VARIABLES. An example.
BEGIN
STRING ARRAY NAMES_of_STATES(50);
INTEGER i;
FOR i:=1 STEP 1 UNTIL 50 DO
BEGIN
INPUT('Name of state:' @ NAMES_of_STATES(i));
IF NAMES_of_STATES(i)='New York' THEN
BEGIN
OUTPUT('Thats the one:' @ NAMES_of_STATES(i));
OUTPUT('after ' @ i @ ' tries');
STOP;
END
END
END
In the above example the STRING ARRAY variable
NAMES_of_STATES(50) is declared. ARRAY bounds in an ARRAY
declaration statement must be unsigned integer constants.
22
PROCEDURE
Format: PROCEDURE <procedure name> { (<parameter list>) };
BEGIN
<statements>
END
The PROCEDURE statement sets up a group of statements and
associates them with a single name. It informs the Structured
Programming Language processor of this declaration. It is
technically a nonexecutable declaration and must be placed before
executable statements. The statements between its BEGIN and END
block are nonexecutable and executable. The nonexecutable
statements are processed by the Structured Programming Language
processor. The executable statements are also processed but are
not executed until the PROCEDURE is called either by a CALL
statement or by referencing it by its name. An example.
BEGIN
REAL Aa,Bb,Cc; { Declare parameters. }
REAL Root_1,Root_2; { Declare Outputs of PROCEDURE. }
PROCEDURE Quadratic_roots(Aa,Bb,Cc); { Parameter references. }
BEGIN
REAL Factor;
Factor:=Bb*Bb-4.*Aa*Cc;
IF Factor<0 THEN
BEGIN
Root_1:=10^(-10); Root_2:=10^(-10);
RETURN;
END
Root_1:=(-Bb+SQR(Factor))/(2.*Aa);
Root_2:=(-Bb-SQR(Factor))/(2.*Aa);
END { Note: this END statement will execute a RETURN. }
REAL Constant_A,Constant_B,Constant_C;
Ask_for_quadratic_constants:
INPUT('Enter A,B,C:' @ Constant_A,Constant_B,Constant_C);
Quadratic_roots(Constant_A,Constant_B,Constant_C); {Arguments}
OUTPUT(); OUTPUT(Root_1,Root_2); OUTPUT();
GO Ask_for_quadratic_constants;
END
The above example defines a PROCEDURE Quadratic_roots which
has three arguments. This PROCEDURE is used to compute the roots
of a quadratic equation.
Note:Parameters in the PROCEDURE declaration can be
REAL,INTEGER, or STRING scalar variables. These parameters should
be first declared in a block containing the PROCEDURE or outside
it. For documentation purposes they can be declared immediately
before the PROCEDURE. The variable should then be named in the
parameter list for the PROCEDURE. If the variable is not
declared, then the parameter will be assumed to be a STRING
scalar. Corresponding arguments in PROCEDURE calls must match the
type of the parameter. Arguments are passed by value to
corresponding parameters. Signed INTEGER constants or positive
23
fractional numbers less than 1 may be passed to a REAL or
INTEGER. STRING constants can be passed to a STRING.
REAL,INTEGER, and STRING scalar variables can be arguments to a
PROCEDURE but they must match by type exactly. Expressions for
arguments are not allowed.
Note:Since the PROCEDURE statement is a declaration
statement, control of the program passes around the PROCEDURE and
in the above example the labelled INPUT statement is executed
first.
Another example.
BEGIN
STRING Name,Address,Phone,RESULT;
STRING A,H,C; { Declare parameters for the PROCEDURE. }
PROCEDURE FORMAT(A,H,C);
BEGIN
INTEGER I;
RESULT:='';
FOR I:=1 STEP 1 UNTIL 20 DO
BEGIN
IF I>LEN(A) THEN RESULT:=RESULT+' ';
ELSE RESULT:=RESULT+MID$(A,I,1);
END
FOR I:=21 STEP 1 UNTIL 40 DO
BEGIN
IF (I-20)>LEN(H) THEN RESULT:=RESULT+' ';
ELSE RESULT:=RESULT+MID$(H,I-20,1);
END
FOR I:=41 STEP 1 UNTIL 60 DO
BEGIN
IF (I-40)>LEN(C) THEN RESULT:=RESULT+' ';
ELSE RESULT:=RESULT+MID$(C,I-40,1);
END
END
Name := 'John Smith' ; Address := '85 Broadway' ;
Phone := '203-555-2035' ;
FORMAT(Name,Address,Phone); { Call to FORMAT PROCEDURE }
OUTPUT(RESULT);
END
The above example shows a program which has a PROCEDURE
FORMAT which combines the first 20 characters of each of the
three arguments Name,Address,Phone leaving the value in RESULT.
Note:A PROCEDURE may access globally declared variables. For
documentation purposes these variables can be declared just
before the PROCEDURE that uses them.
Note:PROCEDURE's can be called recursively and the RETURN
addresses are saved on the STACK of the runtime system but the
user must save any arguments and variables used in the PROCEDURE
for each level of invoking a PROCEDURE.
24
COMMENT , { }
Format: COMMENT <text>; [Note: <text> should not contain ' ]
or { <text> }
The COMMENT statement is a statement used in a Structured
Programming Language program to insert comments in the program
for documentation purposes. This statement is nonexecutable, but
can be placed almost anywhere in a program. An example.
BEGIN
REAL x,y,z,sumsquare;
OUTPUT('Input x,y,z'); INPUT(x, {anywhere} y,z);
sumsquare := x^2. + y^2. + z^2. ;
COMMENT
sumsquare is equal to the sum of the squares of x,y and z;
OUTPUT('The sum of the squares of');
{ This is another example of a comment and you can embed
a quote ' in the text ,and this comment can appear any
where in the program. The end of the comment is this }
OUTPUT(x @' PLUS ' @ y @' PLUS ' @ z @' IS ' @ sumsquare);
END
The above example shows the COMMENT statement and the text
between COMMENT and the semicolon. It is important to note that
the single quote ' should not be used in the text of a COMMENT
statement. The second method of making a comment is by enclosing
any text between { and } characters. This second type of comment
may have a single quote embedded,and can appear anywhere.
25
GO , GO TO , GOTO
Format: GO <label>; or GO TO <label>; or GOTO <label>;
These statements in the Structured Programming Language
are used to transfer control of the computer to a labeled
Structured Programming Language statement. An example.
BEGIN
INTEGER a,h,c;
a:=-1;
compute: a:=a+1;
INPUT(h);
IF h<0 THEN GO compute;
ELSE OUTPUT(a,' numbers < 0');
END
The above example shows the use of the GO TO statement.
Control passes back to the statement labeled compute if the
variable h < 0. This example counts the number of values input
that are less than zero. Once h >= 0 as entered for input then
control passes to the OUTPUT statement and the program continues
on.
26
ONERRGOTO
Format: ONERRGOTO <label>;
The ONERRGOTO statement allows the user to trap errors and
transfer control of the computer to a labeled statement. See your
BASIC manual for the ERROR codes for your system. You can also
refer to your Disk Operating System manual. An example.
BEGIN
REAL A,H,C;
STRING D,E,F;
OPEN('I',#1,'DATA.FIL');
ONERRGOTO end_of_file;
OUTPUT();
read:LINEIN(#1,D); COMMENT read in a line of data ;
OUTPUT(D); COMMENT output the line to the screen ;
GO read;
end_of_file:RESUME end_of_file1;
end_of_file1:CLOSE(); STOP;
END
The above example shows a use of the ONERRGOTO statement to
trap execution of a program when an end of file is encountered
for a sequential disk file. When the end of file is reached
control is transferred to the labeled statement end_of_file. The
RESUME statement is executed, as required and the program closes
all files and stops.
27
RETURN
Format: RETURN;
The RETURN statement is a statement that ends execution of a
PROCEDURE and returns control to the statement following the call
to the PROCEDURE. There is also a form of this statement that
allows transfer to a labeled statement. An example.
BEGIN
REAL a,h,c;
REAL d,e;
PROCEDURE add(d,e);
BEGIN
c:=d+e;
IF c=0 THEN RETURN zero;
RETURN;
END
zero:INPUT('enter a,h'@ a,h);
add(a,h);
END
The above example shows the two forms of RETURN statement.
If c=0 then the program control goes to the statement labeled
zero. Otherwise control goes normally to the statement following
the call to PROCEDURE add, which is the final END statement of
the program. Execution ends at this point.
Note:The END statement of the PROCEDURE declaration is
equivalent to a RETURN statement. RETURN is made to the statement
after the CALL to the PROCEDURE.
28
INPUT
Format: INPUT( {@} {<prompt string>{@|,}} <variable list> );
INPUT( #<file number>,<variable list> );
The INPUT statement in the Structured Programming Language
is very similar to the INPUT statement in the BASIC language for
your computer. There are some differences. The INPUT statement is
used to get information into storage from an external device into
your Structured Programming Language program. The Structured
Programming Language INPUT statement differs from the BASIC
statement in that the @ (at sign) is used instead of the ;
(semicolon) as a separator. Variable names must conform to
Structured Programming Language standards. The INPUT statement
must have parentheses around the INPUT list. See the format for
the INPUT statement in the statement format section on page 9.
Additional information can be found in your BASIC users manual.
Pages
Zenith BASIC 6.1-6.30 and 10.72-10.77
IBM BASICA 3-33,3-38,3-44,4-122,4-125
An example.
BEGIN
INTEGER A,I;
REAL H;
STRING C;
INTEGER ARRAY SPOTS(10);
INPUT('Enter values for A,H,C' @ A,H,C);
FOR I:=1 STEP 1 UNTIL 10 DO
BEGIN
OUTPUT('Enter value of SPOTS(' @ STR$(I) @ ') :' @);
INPUT(SPOTS(I));
END
OPEN('I',#1,'INFILE.DAT');
READIT:IF EOF(1) THEN
BEGIN
CLOSE(#1); STOP;
END
INPUT(#1,C); OUTPUT(C);
GO READIT;
END
The above example shows the use of the INPUT statement. The
first two INPUT statements are used to get input from the
keyboard and the third is to get input from a disk file named
INFILE.DAT .
29
LINEIN
Format: LINEIN( {@} {<prompt string>{@|,}} <string variable>);
LINEIN( #<file number>,<string variable>);
The LINEIN statement in the Structured Programming Language
is very similar to the LINE INPUT statement in the BASIC language
for your computer. There are some differences. The LINEIN
statement is used to get information into storage from an
external device into your Structured Programming Language
program. The Structured Programming Language LINEIN statement
differs from the BASIC statement in that the @ (at sign) is used
instead of the ; (semicolon) as a separator. Variable names must
conform to Structured Programming Language standards. The LINEIN
statement must have parentheses around the LINEIN input list.
See the format for the LINEIN statement in the statement format
section on page 9. Additional information can be found in your
BASIC users manual.
Pages
Zenith BASIC 6.1-6.30 and 10.90-10.91
IBM BASICA 3-33,3-38,3-44,4-144,4-145
An example.
BEGIN
INTEGER A,I;
REAL H;
STRING C;
OPEN('I',#1,'INFILE.DAT');
READIT:IF EOF(1) THEN
BEGIN
CLOSE(#1); STOP;
END
LINEIN(#1,C); OUTPUT(C);
GO READIT;
END
The above example shows the use of the LINEIN statement. The
LINEIN statement is used to get a line of input from a disk file
named INFILE.DAT.
30
GET , PUT
Format: GET #<file number> {,<record number>};
PUT #<file number> {,<record number>};
The GET and PUT statements in the Structured Programming
Language are used to read and write records from a disk file in
the random access mode. See the statement formats for these
statements on page 9 of this manual. Since these statements are
the same as the BASIC statements for your machine, except that
variables must conform to Structured Programming Language
variable standards, additional information can be found in your
BASIC users manual.
Page
Zenith BASIC 6.16-6.29 and 10.58 and 10.140
IBM BASICA 3-33,3-38,3-44,4-106,4-230
31
OUTPUT
Format: OUTPUT( {#<file number>,} {USING <string expression>@}
{<output expression list>} );
The OUTPUT statement in the Structured Programming Language
is very similar to the PRINT statement in the BASIC language for
your computer. There are some differences. The OUTPUT statement
is used to send information from storage to an external device
from your Structured Programming Language program. The Structured
Programming Language OUTPUT statement differs from the BASIC
statement in that the @ (at sign) is used instead of the ;
(semicolon) as a separator. Variable names must conform to
Structured Programming Language standards. The OUTPUT statement
must have parentheses around the OUTPUT list. See the format for
the OUTPUT statement in the statement format section on page 10.
Additional information can be found in your BASIC users manual.
For each reference of the word PRINT the word OUTPUT shall apply
in the Structured Programming Language.
Pages
Zenith BASIC 6.1-6.30 and 10.130-10.137
IBM BASICA 3-33,3-38,3-44,4-216,4-219,4-225
An example.
BEGIN
INTEGER i; STRING format;
format:='&##&##.#####';
OPEN('OUTFIL.DAT' FOR OUTPUT AS #1);
FOR i:=1 STEP 1 UNTIL 10 DO
BEGIN
OUTPUT( USING format
@ 'The square root of ' @ i @ ' is ' @ SQR(i) );
OUTPUT(#1,USING format
@ 'The square root of ' @ i @ ' is ' @ SQR(i) );
END
END
In the above example a disk file is opened and square roots
are computed and output to the screen and the disk file
OUTFIL.DAT. The USING feature is used to set a format for output.
32
CALL
Format: {CALL} <procedure name> {( <argument list> )};
The CALL statement is used to call a Structured Programming
Language PROCEDURE. The user can call a PROCEDURE by name as well
without CALL. In order for a CALL to be legal the PROCEDURE must
be known. That is, it must be declared in the same BEGIN block as
the call or declared in a BEGIN block outside of the BEGIN block
where the PROCEDURE is referenced. It cannot be declared in a
BEGIN block nested in the current block where the call is made.
An example.
BEGIN
INTEGER A,H,C;
INTEGER IA,IB;
PROCEDURE SUM(IA,IB);
BEGIN
C:=IA+IB;
END
A:=5; H:=6; SUM(A,H); OUTPUT(C);
CALL SUM(10,30); OUTPUT(C);
END
In this example, are the two ways the user can call a
procedure, by either just mentioning its name and arguments, or
by CALL and then its name and arguments.
Note:A PROCEDURE may be called with arguments that are
globally declared variables. For documentation purposes these
variables can be declared just before the PROCEDURE that uses
them.
Note:PROCEDURE's can be called recursively and the RETURN
addresses are saved on the STACK of the runtime system but the
user must save any arguments and veriables used in the PROCEDURE
for each level of invoking a PROCEDURE. An example:
BEGIN
INTEGER N, {Argument.} {Global variable.}
Factorial_result; {Result.} {Global variable.}
PROCEDURE Factorial;
BEGIN
IF N=1 THEN
BEGIN
Factorial_result := 1; RETURN;
END
ELSE
BEGIN
N := N-1; Factorial; N := N+1;
Factorial_result := N * Factorial_result; RETURN;
END
END
N := 5; Factorial; OUTPUT(Factorial_result);
END
33
FOR
Format: FOR <scalar arithmetic variable> := <start arith. expr.>
STEP <increment arithmetic expression>
UNTIL <limit arithmetic expression>
DO BEGIN
<statements>
END
The FOR statement allows the user to do repetitve processes
and use a variable that has a varying value for each repetition.
An example.
BEGIN
REAL ARRAY x(100),y(100);
REAL xvalue,yvalue;
INTEGER i;
i:=1;
FOR xvalue:=.01 STEP .01 UNTIL 1. DO
BEGIN
IF i<=100 THEN
BEGIN
x(i):=xvalue; yvalue:=SIN(xvalue)*EXP(xvalue);
y(i):=yvalue; OUTPUT(x(i),y(i));
END
i:=i+1;
END
END
The above example shows a FOR loop that computes 100 x,y
pairs where the x's vary from .01 to 1 and the corresponding y
value is SIN(x)*EXP(x). This loop will be executed 100 times when
xvalue becomes greater than 1. The arithmetic expression after
the := is the initial value. The arithmetic expression after STEP
is the increment or decrement and finally the arithmetic
expression after UNTIL is the limit. The loop is executed only if
the initial value has not reached the limit, depending on the
magnitude of the STEP value.
34
IF
Format: IF <logical expression> THEN <statement>
{ ELSE <statement> }
Note: In each of the clauses THEN,ELSE the <statement>
can be replaced with the BEGIN <statements> END
The single statement may not be an IF,FOR,REPEAT,REAL,
INTEGER,STRING,PROCEDURE,ON, or WHILE statement. You
must place it between BEGIN and END statements.
The IF statement is used to test logical conditions and
depending on that logical condition the program can take certain
action. If the logical condition is true, actions are taken on
the THEN path or if it is false, actions are taken on the
optional ELSE path or action passes to the next statement after
the extent of the THEN clause. An example.
BEGIN
INTEGER i,j,k;
FOR i:=10 STEP -1 UNTIL 1 DO
BEGIN
INPUT('Enter number:' @ j);
IF j<0 THEN
BEGIN
OUTPUT('The number is less than zero');
k:=k+1;
END
ELSE OUTPUT('The number is greater than equal to zero');
END
OUTPUT('There were ' @ k @ ' negative numbers input');
END
The above example has the user enter 10 numbers and tells
the user if the number was greater than zero or not. It also
computes the total of numbers that were less than zero. The IF
statement tests if j<0. If j<0 the THEN clause is executed and
the message is output that the number is negative or zero, and
the number of negative numbers is incremented by 1. Otherwise the
ELSE clause is executed and the message that the number is
greater than or equal to zero is output.
35
END
Format: END
The END statement defines the end of a BEGIN block for a
normal BEGIN block, for a PROCEDURE BEGIN block, for a FOR loop
BEGIN block, for a THEN clause BEGIN block, for an ELSE clause
BEGIN block or the program BEGIN block. An example.
BEGIN
REAL SQUARE,ROUND;
INTEGER A,H,C;
SQUARE:=2; ROUND:=1;
FOR A:=30 STEP 2 UNTIL 50 DO
BEGIN
SQUARE:=ROUND+A*SQUARE;
END
OUTPUT(SQUARE);
END
In the above example the first END statement ends the FOR
loop BEGIN block. The second END ends the program BEGIN block.
36
WHILE
Format: WHILE <logical expression> DO
BEGIN
<statements>
END
The WHILE statement is used to repeat execution of a set of
statements while a certain logical condition is true. An example.
BEGIN
REAL x;
x:=5;
WHILE x<>0 DO
BEGIN
x:=x-1;
OUTPUT(x^2.);
END
END
In the above example the two statements in the inner BEGIN
block are executed as long as x is not equal to zero. The inner
block will be executed five times and then the program will end.
37
REPEAT
Format: REPEAT <statements>
UNTIL <logical expression>;
The REPEAT statement is used to repeat execution of a set of
statements until a certain logical condition is true. The
difference between the REPEAT statement and the WHILE statement
is that the test is done after execution of the set of statements
with the REPEAT statement and before the set of statements with
the WHILE statement. An example.
BEGIN
REAL x;
x:=5;
REPEAT
x:=x-1;
OUTPUT(x^2.);
UNTIL x=0;
END
Note that there is no BEGIN block involved with the REPEAT
statement. The user may wish to take advantage of that aspect.
The statements between REPEAT and UNTIL will be executed five
times.
38
;
Format: ;
The empty statement is used as a place for a label. A GOTO
statement can then refer to this statement by its label if it is
labeled. An example.
BEGIN
STRING COMMAND;
INTEGER INP,OUTP;
COMMENT INP,OUTP ARE DECLARED AS INTEGERS AND ARE EXTERNAL
PROCEDURES;
LOOP:INPUT('ENTER A COMMAND:' @ COMMAND);
IF COMMAND = 'STOP' THEN GO FINISH;
IF COMMAND = 'INPUT' THEN CALL INP;
IF COMMAND = 'OUTPUT' THEN CALL OUTP;
GO LOOP;
FINISH:;
END
The above example has the empty statement with the label
FINISH. It is a point where the program will end when the
statement GO FINISH is executed. This is because the statement
after the empty statement is the final END statement.
39
DOS
Format: DOS;
The DOS statement causes program execution to return to the
MS DOS system. An example.
BEGIN
REAL I,J;
ask:OUTPUT('Enter upper limit:' @ J);
IF J<=0 THEN DOS;
FOR I:=1 STEP 1 UNTIL J DO
BEGIN
OUTPUT('The square root of ' @ I @ ' is ' @ SQR(I));
OUTPUT('The square of ' @ I ' is ' @ I*I );
END
GO ask;
END
The above example shows the DOS statement and it will be
executed,in this case,if the user enters a number less than or
equal to zero.
40
HOME
Format: HOME;
The HOME statement is used to clear the console screen and
place the cursor at the first column in the first row. An
example.
BEGIN
REAL x,y;
HOME;
FOR x:=.0 STEP .1 UNTIL 2*3.14159 DO
BEGIN
y:=SIN(x); PSET(101.*x,220.-101.*(y+1)),0;
END
busy:GO TO busy;
END
The above example uses HOME to clear the screen and then a
sine graph is plotted on the console screen.
41
DEFSEG
Format: DEFSEG := <expression>;
The DEFSEG statement is the same as the DEF SEG statement
but for the implementation of the Structured Programming Language
the name is one word. An example.
BEGIN
INTEGER A,H,C,D;
DEFSEG := 15.*4096.;
FOR A:=1 STEP 1 UNTIL 16*1024 DO
BEGIN
OUTPUT('Location:'@ A ,' Value:' @ PEEK(A));
END
END
The above example uses the DEFSEG statement to set the base
address for peeks and pokes to the sixteenth 64k segment.
42
EOT
Format: EOT
The EOT statement will have the Structured Programming
Language processor ask the user for a filename for additional
input. This allows the user to have multifile input of source
files to the processor. This allows for user source libraries of
Structured Programming Language procedures and declarations or
other Structured Programming Language source. The user can link
many source files together as long as the BEGIN and END
statements match and that the last END statement will cause the
second pass of the processor to run. It is recommended that the
EOT statement be placed on the last line of the source file by
itself and surrounded with a space on each side. An example.
BEGIN
REAL X,Y,Z;
INTEGER A,H,C;
EOT
This will cause the processor to ask for a new file name by
asking.
ENTER FILE NAME:
Then the user will enter the filename to be used. No
filename extension should be entered. Once the name is
entered, the processor will continue if the file is found. If the
file is not found,the processor will ask for another filename.
43
ARITHMETIC ASSIGNMENT STATEMENT
The Arithmetic assignment statement is used to assign values
by formula to INTEGER and REAL scalar and ARRAY variables defined
in a Structured Programming Language program. An example.
BEGIN
REAL PI,RADIUS,DIAMETER,HEIGHT;
REAL J,AREA,PERIMETER;
REAL ARRAY storage(26);
INTEGER i,k;
PI:=3.14159;
FOR i:=1 STEP 1 UNTIL 26 DO
BEGIN
storage(i):=0;
END
FOR J:=1. STEP .1 UNTIL 100. DO
BEGIN
DIAMETER:=J;
RADIUS:=DIAMETER/2.;
AREA:=PI*(RADIUS)^2.;
PERIMETER:=PI*DIAMETER;
OUTPUT(RADIUS,DIAMETER,AREA,PERIMETER);
END
END
The above example shows various arithmetic assignment
statements in the Structured Programming Language. Note the use
of the := as the assignment operator. The user must use this
form. The symbol = is used in logical expressions.
44
STRING ASSIGNMENT STATEMENT
The String assignment statement is used to assign string
values by formula to STRING scalar and ARRAY variables defined in
a Structured Programming Language program. An example.
BEGIN
STRING ARRAY names(50),phones(50);
STRING record,record1,record2;
INTEGER i;
INPUT(record1,record2);
record:=record1+MID$(record2,1,5); OUTPUT(record);
FOR i:=1 STEP 1 UNTIL 50 DO
BEGIN
INPUT(names(i),phones(i));
record:=names(i)+phones(i);
OUTPUT(record);
END
END
The above example shows various string assignment
statements. The := is the assignment operator. The = sign is used
in logical expressions.
45
LABELED STATEMENT
The labeled statement is any statement that has one or more
labels preceeding it. Some examples of isolated labeled
statements.
compute:X:=X+3.;
GONE:INPUT(x,y,z);
OUT1:putout:output: OUTPUT('Name','Address','Phone');
Finish:STOP;
A GO TO statement,RETURN <label>,RESUME <label> statement
can be used to transfer to a labeled statement. You may note the
use of the label, output. This name is not a keyword. OUTPUT is a
keyword, however.
46
ARITHMETIC OPERATORS
+ Addition
- Subtraction
/ Normal division
\ Integer division
MOD Modulo function
* Multiplication
^ Exponentiation
Refer to pages 5.19-5.26 in the ZBASIC users manual.
3-21 in the IBM BASICA users manual.
STRING OPERATORS
+ String concatenation
Concatenation of two or more strings means to join them together.
LOGICAL OPERATORS
AND Logical AND of two logical quantities.
OR Logical OR of two logical quantities.
NOT Logical NOT of a logical quantity.
XOR Logical exclusive OR of two logical quantities.
IMP Logical Implication of two logical quantities.
EQV Logical Equivalence of two logical quantities.
Refer to pages 5.32-5.45 in the ZBASIC manual.
3-25 in the IBM BASICA manual.
COMPARISON OPERATORS
= Equal to
< Less than
> Greater than
<= Less than or equal to
>= Greater than or equal to
<> Not equal to
Refer to pages 5.27-5.31 in the ZBASIC manual.
3-23 in the IBM BASICA manual.
47
IMPORTANT IMPLEMENTATION RESTRICTIONS AND CONVENTIONS
1. No more than 10 nested blocks may be set up in a Structured
Programming Language program. IF THEN ELSE statements,FOR
loops,WHILE statements,PROCEDUREs all create BEGIN blocks and
must be counted.
2. In Structured Programming Language programs, REAL floating
point constants with E or D are not supported. E.G. .245E5 or
.24556613D5 are illegal, however use .245 * 10^5 , .245566 *
10^5 instead.
3. However for INPUT the user must use the exponential format for
large numbers where the E format and D format are legal.
E.G. .245E5 and .245566D5 are legal input.
4. Arguments to PROCEDURE calls must either be a STRING ,INTEGER,
or REAL scalar variable, STRING constant, signed INTEGER constant
or fractional unsigned number less than one. The type of argument
must match the type of parameter. One exception is that the
numeric constant may be passed to a REAL or INTEGER parameter.
Expressions are not allowed. However arguments to EXTERNAL
PROCEDURES (FORTRAN,PASCAL,MACRO ASSEMBLER) can be any legal
expression. Consult your BASIC manual.
5. Variable names are allowed up to 40 characters,the first must
be alphabetic. Lower case characters are allowed.
6. All variables and PROCEDUREs except LABELS must be declared
before referencing them.
7. No Structured Programming Language reserved word may be used
as a variable name.
8. In Structured Programming Language statements that have either
arithmetic or string expressions, only some positional syntax
checking is done in the arithmetic expression. There is checking
to see if parentheses balance, if an illegal operator follows
another indicating that an operand is missing, if an operator or
punctuation is missing. Checking is done to see that variables
are declared and that operators and special characters are valid.
Reserved word usage is checked also.
9. No checks are made to see if the number of subscripts in a use
of an ARRAY variable match the number of bounds of that declared
ARRAY variable.
10. No checks are made to see if the number of arguments in a
PROCEDURE call match the number of parameters of that declared
PROCEDURE.
48
11. Concerning points 8 and 9,any errors not caught by the
Structured Programming Language processor, will surely be caught
by the BASIC interpreter in its run time system and surely by
your machine's BASIC compiler at compilation stage. The Symbol
table can be of great help in debugging a Structured Programming
Language program.
12. There is a limit of 250 variables that can be declared in a
BEGIN block. Variables can be declared in any BEGIN block, even
if it is a clause of THEN,ELSE,FOR loop,WHILE DO,PROCEDURE,etc.
13. String constants are limited to 250 characters although a
string variable can contain up to 32767 characters,if the
translated BASIC program is compiled.
14. All bounds that are declared in any ARRAY declaration must
be an integer constant. Variable bounds are not legal.
15. Declaration statements i.e. REAL,REAL ARRAY,INTEGER,INTEGER
ARRAY,STRING,STRING ARRAY,PROCEDURE must be placed before
executable statements in a BEGIN END block. An error will be
generated if you place a declaration after an executable
statement in that block.
16. PROCEDURE parameters if not declared are string variables.
They are considered as being declared in the BEGIN block that is
part of the PROCEDURE declaration. The parameter is only known in
that block or blocks nested in the PROCEDURE.
17. Labels are declared implicitly and are considered known in
every block in the program. They are considered as being declared
in the main program block, and therefore they are counted in the
total number of variables declared in the main program block.
REAL CONSTANTS
-1
-.433*10^5 Input form: -.433E5
INTEGER CONSTANTS
3200
-5
32767
STRING CONSTANTS
'ABC'
'This is a string'
'' ,the null string
Note:On entering a string for INPUT it must be between " double
quotes. Although if a string constant is the only constant
entered on INPUT or LINEIN then no " characters need to surround
the string. See your BASIC manual for entering string constants.
49
APPLICATION NOTES
1. All variables in a Structured Programming Language program
are put in COMMON in a certain order. If you wish to CHAIN
Structured Programming Language programs and use COMMON you
should declare the same variables from one module to another, and
they must be in the same order. It would help to use the same
declaration statements. If you don't declare the same variable
names, but you declare the same number of variables, and type of
variables or arrays with the same bounds, you may be able to use
the variables in COMMON. See your BASIC interpreter and/or
compiler manuals for details on COMMON. In addition, the same
procedures, if they use arguments must be declared in all CHAIN
modules. Again they should be in the same order in reference to
other variables.
2. You may wish to use double precision variables in your
program operations. To accomplish this you can modify the
translated BASIC program by placing a DEFDBL A statement before
any other statement in the program. This will change the
precision of all the REAL variables to double precision.
3. You will notice that the LOCATE, COLOR and SCREEN statements
are described in a format for the Zenith Z-100 machine. The
translator will understand those statements for your machine as
well,if you have an IBM PC or other machine. As long as you use
variables that conform to Structured Programming Language
standards, the statements will be translated properly. Of course
your BASIC compiler or interpreter will check for further
possibilities of syntax errors. For additional information you
should also check your machine's Basic language manual. (See
Implementation restrictions points 8 and 9)
50
RUNNING THE STRUCTURED PROGRAMMING LANGUAGE PROCESSOR
Make sure that your diskette contains the execute files
SP.EXE and SPA.EXE. These are the two files that make up the
Structured Programming Language processor. Place the disk with
the Structured Programming Language processor in the default disk
drive and enter SP. The processor will announce its name and ask
for a filename. If at this point you enter a letter followed by a
colon, the processor will display the [.SP] source files on that
disk drive. Enter a filename but not an extension. The processor
will add the extension .SP. All Structured Programming Language
programs must have a file extension .SP. It will ask the user
where scratch files and the final output file will be created. It
will ask if the user wants a symbol table, if the user wants a
listing, and if a listing is desired, then if the listing is to
go to the screen, disk or printer. This is for the first pass
only. If no listing is requested, all error messages will go to
the screen. The second pass messages go to the screen if the
listing is sent to the screen or to a disk file. If the listing
is sent to the printer, then the second pass messages go to the
printer as well. If you don't need a listing then the operation
of the translator is speeded up. The translator may be halted at
anytime during the first pass by pressing the space bar. When the
processor is done a program file <dev>:<filename>.BAS will reside
on the desired drive as an ascii file. This file MUST be loaded
into your BASIC interpreter workspace and SAVED IN THE ASCII
FORMAT,in order for compilation by your machine's BASIC compiler,
or the MICROSOFT BASIC Compiler.
SYMBOL TABLE AND SOURCE LISTING
The symbol table contains a dictionary which tells the user
information about each variable,label,procedure that is declared
in a Structured Programming Language program. The internal name
for a scalar variable is directly used in the translated BASIC
program. The internal names for ARRAY variables are the names
without the subscripts, labels are denoted as !, and PROCEDUREs
are shown as numbers, which is the exact number found for the
PROCEDURE in the translated BASIC program. The filename for the
optional symbol table file is <dev>:<filename>.SYM . The optional
source listing when directed to a disk file is in the file
<dev>:<filename>.LST. In the source listing, the Structured
Programming Language source code line number and the approximate
translated BASIC program line number appear before each
statement. This is supplied for debugging purposes.
LABEL FILE
A label file with the name <filename>.LBL is always created
and is used by the processor for creating a label dictionary. It
is retained so you can use it for debugging purposes. Since it
takes up disk space, you should consider that in operations of
the translator so as not to overflow disk space.
51
TRANSLATOR ERROR MESSAGES
Error messages generated are described in plain english and
go to the desired listing device. If no listing is desired then
the error messages go to the screen. A beep is sounded. The error
messages tell the user what line of the original source file the
error occurred, and the offending word is mentioned in the error
message. You will also find the footing *** ERROR IN LINE xxx
*** below the description. Since error messages are always
generated, and the line number is mentioned, it is a definite
speed advantage not to have a source listing generated. With many
editors you can call up a line by giving its line number and then
change it, so a source listing is not always needed.
Error Messages produced
by the Structured Programming Language Processor
------------------------------------------------------
Section 1 Fatal Internal Errors.
I1. IMPLEMENTATION RESTRICTION,INTERNAL NAME OVERFLOW
TRANSLATION TERMINATED
I2. INTERNAL STACK OVERFLOW,IMPLEMENTATION RESTRICTION: OOO
TRANSLATION TERMINATED.
I3. ERROR # XXX IN LINE NO. XXX {Contact author.}
{Line is in processor.}
Section 2 Auxilliary Error Messages.
M1. *** ERROR IN LINE XXX ***
M2. ERROR: WWW
Section 3 Main Error Messages.
1. MISSING OPERAND: WWW
2. UNBALANCED PARENTHESES
3. MISSING := : WWW
4. VARIABLE NOT DECLARED: WWW
5. VARIABLE IS NOT INTEGER,REAL,OR STRING: WWW
6. DECLARED VARIABLE PPP IS SCALAR,SUBSCRIPTED REFERENCE IS ILLEGAL
52
7. DECLARED VARIABLE PPP
IS AN ARRAY, MISSING LEFT PARENTHESIS,COMMA,OR SEMICOLON
8. MISSING OPERATOR OR PUNCTUATION FOLLOWING AN IDENTIFIER OR
CONSTANT : PPP
9. MISSING BEGIN STATEMENT: WWW
FATAL ERROR,TRANSLATION STOPPED
10. ILLEGAL VARIABLE NAME: WWW
11. ILLEGAL PROCEDURE NAME: WWW
12. MISSING (
13. MISSING DIMENSION: WWW
14. MISSING ) OR , : WWW
15. MISSING , OR ; : WWW
16. ILLEGAL OR MISSING PARAMETER: WWW
17. MISSING ; : WWW
18. ILLEGAL PROCEDURE: WWW
19. MISSING ( : WWW
20. INVALID INPUT LIST: WWW
21. MISSING ) : WWW
22. INVALID OUTPUT LIST: WWW
23. ILLEGAL LOOP VARIABLE: WWW
24. ILLEGAL EXPRESSION: WWW
25. DUPLICATE LABEL: WWW
26. ILLEGAL STATEMENT TYPE: WWW
27. UNDECLARED VARIABLE NAME, OR MISSING COLON : WWW
28. IN THIS INSTANCE WWW STATEMENT MUST BE ENCLOSED WITHIN
A BEGIN END BLOCK,ERROR
29. END STATEMENT IS NOT A LEGAL STATEMENT HERE
30. TOO MANY NESTED BEGIN BLOCKS
TRANSLATION TERMINATED
31. DUPLICATE PROCEDURE NAME: WWW
53
32. OVERFLOW OF SYMBOL TABLE: WWW
33. ATTEMPT TO NEST 11TH LEVEL TRANSLATION TERMINATED
34. DUPLICATE PARAMETER: WWW
35. LIMIT OF 10 PARAMETERS EXCEEDED: WWW
36. DUPLICATE VARIABLE: WWW
37. DUPLICATE ARRAY NAME: WWW
38. SYMBOL TABLE OVERFLOW,TOO MANY VARIABLES: WWW
39. ILLEGAL LABEL: WWW
40. MISSING ; OR ( : WWW
41. ILLEGAL ARGUMENT: WWW
42. MISSING , OR ) : WWW
43. MISSING WORD,STEP : WWW
44. MISSING WORD,UNTIL: WWW
45. MISSING WORD,DO: WWW
46. MISSING WORD,THEN: WWW
47. ERROR,LAST WORD NOT END OR EOT : WWW
48. ERROR,UNTIL WITHOUT REPEAT CLAUSE
49. ILLEGAL USE OF RESERVED WORD
AS STATEMENT,VARIABLE,OR LABEL: WWW
50. ELSE CLAUSE NOT EXPECTED,ERROR
51. ILLEGAL PLACEMENT OF A DECLARATION STATEMENT: WWW
52. MISSING WORD,CALL: WWW
53. WORD IS NOT KEY OR COM: WWW
54. DOUBLE QUOTE ILLEGAL,REPLACED WITH SPACE,USE CHR$(34)
*** ERROR IN LINE XXX ***
54
Legend: XXX Line number.
WWW Offending word in source program.
PPP Word previous to one that caused error.
OOO Line that overflowed internal stack.
55
INDEX of Statements for the Structured Programming Language.
The numbers refer to pages in this manual except in the case
where a Z or an I preceeds it.
; 39
Arithmetic assignment 44
BEEP *Z 10.5 *I 4-28
BEGIN 14
BLOAD **Z 10.6-10.7 **I 4-29
BSAVE **Z 10.8-10.9 **I 4-32
CALL 33
CALL [EXTERNAL] *Z 10.10-10.11 *I 4-34
CHAIN **Z 10.13-10.14 **I 4-36
CIRCLE *Z 10.17 *I 4-41
CLEAR *Z 10.18 *I 4-44
CLOSE **Z 10.19 **I 4-46
COLOR *Z 10.21-10.22 *I 4-49,4-54
COM(N) *Z F.8-F.10 *I 4-56
COMMENT 25
DATE$ *Z 10.32 *I 4-66
DEFSEG 42
DOS 40
DRAW *Z 10.40-10.41 *I 4-79
END 36
EOT 43
ERROR *Z 10.47-10.48 *I 4-91
FIELD *Z 10.50 *I 4-94
FILES **Z 10.51 **I 4-97
FOR 34
GET [GRAPHICS] *Z 10.59-10.61 *I 4-108
GET [I/O] 31
GO 26
GO TO 26
GOTO 26
HOME 41
IF 35
INPUT 29
INTEGER 18
INTEGER ARRAY 21
KEY *Z 10.81-10.83 *I 4-131
KEY(N) *Z F.8-F.10 *I 4-134
KILL **Z 10.84 **I 4-136
Labeled statement 46
LINE *Z 10.88-10.89 *I 4-141
LINEIN 30
LOCATE *Z 10.97-10.98 *I 4-155
LSET *Z 10.103 *I 4-163
MID$ *Z 10.106 *I 4-167
NAME **Z 10.108 **I 4-173
NULL *Z 10.110
ON COM(N) *Z F.8-F.10 *I 4-176
ON KEY(N) *Z F.8-F.10 *I 4-182
ONERRGOTO 27
56
OPEN **Z 10.115-10.121 **I 4-189,4-194
OUT **Z 10.123 **I 4-201
OUTPUT 32
PAINT *Z 10.124 *I 4-203
POKE *Z 10.127 *I 4-214
PRESET *Z 10.129 *I 4-228
PROCEDURE 23
PSET *Z 10.138-10.139 *I 4-228
PUT [GRAPHICS] *Z 10.59-10.61 *I 4-232
PUT [I/O] 31
RANDOMIZE *Z 10.141 *I 4-236
REAL 16
REAL ARRAY 20
REPEAT 38
RESET *Z 10.146 *I 4-243
RESUME *Z 10.148 *I 4-245
RETURN 28
RSET *Z 10.103 *I 4-163
RUN **Z 10.152 **I 4-251
SCREEN *Z 10.155 *I 4-257
STOP *Z 10.161 *I 4-270
STRING 19
STRING ARRAY 22
String assignment 45
SWAP *Z 10.164 *I 4-277
TIME$ *Z 10.168-10.169 *I 4-281
WAIT *Z 10.176 *I 4-290
WHILE 37
WIDTH *Z 10.178 *I 4-294
WRITE *Z 10.179-10.180 *I 4-298 4-299
57
