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