



























                         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





                                                                                                