DataMuseum.dk

Presents historical artifacts from the history of:

CP/M

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about CP/M

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - metrics - download

⟦9cdae384b⟧ TextFile

    Length: 207360 (0x32a00)
    Types: TextFile
    Names: »D99«

Derivation

└─⟦5dbd6b396⟧ Bits:30005867/disk12.imd Dokumenter (RCSL m.m.)
    └─⟦this⟧ »D99« 

TextFile

           zone convert(10,1,stderror); integer array ia(1:20); getzone6
          open(convert,0,<:dummy:',0); 
          repeat 
            write(convert,<<ddd.dd>dd', the number to be converted,false,2); 
            comment the partial word has been forced into the buffer by the 
                  2 null characters; 
            getzone6(convert,ia); 
            ia(12):= 1; ia(14):= ia(19); ia(16):= 40; 
            setzone6(convert,ia); 
          comment Now the record contains the number in character form.
                  record base and partial word are ready for converting the
                  next number; 
            x1:= long convert(1); x2:= long convert(2); ... 
          until ...; 
          comment the zone convert must n_o_t_ be closed; 
           
          E_x_a_m_p_l_e_ _3_:     improved setposition: 
           
                         The procedures getposition, setposition do only
                         enable a device to be positioned at the beginning
                         of a block. You may resume reading from the middle
                         of a block on magnetic tape or backing storage in
                         this way: 
                          
                         begin 
                           zone z(...), z1(...); 
                           integer array  ia(1:20); 
                           integer        pos1, pos2, pos3, pos4, c; 
                           integer field  paritial _word, record _base, used _share,
                                          no _of _shares, base _buf _area, buf _length; 
                          
                         partial _word        := 12*2; 
                         record _base         := 14*2; 
                         used _share          := 17*2; 
                         no _of _shares        := 18*2; 
                         base _buf _area       := 19*2; 
                         buf _length          := 20*2; 
                          \f

               comment generalised getposition;getzone6
               read (z, ...); 
               getposition (z, pos1, pos2); 
               getzone6    (z, ia); 
               pos3:= ia.record _base - ia.base _buf _area - 
                      ia.buf _length*4//ia.no _of _shares * 
                      (ia.used share-1); 
                  <*pos3 is the relative position within the used share*' 
               pos4:= ia.partial _word; 
                                   
               comment generalised setposition, perhaps with the 
                       device connected to another zone; 
                         setposition (z1, pos1, pos2); 
                         readchar (z1, c); 
                              <* now the device is positioned and the first
                                  block is read into the first share     *' 
                         getzone6 (z1, ia); 
                         ia.record _base:= pos3 + ia.base _buf _area; 
                         ia.partial _word:= pos4; 
                         setzone6 (z1, ia); 
                         read (z1, ...); 
                          
                          \f

F_       2_._5_9_ _ _ _ _ _ _g_o_t_o_         2.59 goto 
           
          This delimiter, which is a sequential operator, can be used to
          change the program flow. 
           
               S_y_n_t_a_x_:        goto <designational expression' 
           
          S_e_m_a_n_t_i_c_:      A goto statement interrupts the normal
                         sequence of operations. The next statement to
                         be executed will be the one having this value
                         as its label. 
 
                           A jump (by a goto statement) out of an activity or
                         a disable statement is not allowed. This will give
                         the run time alarm "goto" (alarmcause = -14). 
                          
                         A jump (by a goto statement) into a for-, repeat-,
                         or while- statement is also forbidden. This will
                         give the error message "for label" during the
                         compilation. 
                          
          E_x_a_m_p_l_e_ _1_:     a:= q; 
                         if a ' p then goto lab; 
                            .... 
                         lab: 
                         b:= a + 17; 
                          
                          \f

F_2_._6_0_ _ _ _ _ _ _g_r_e_a_t_e_r_ _t_h_a_n_ _(_'_)_                                             2.60 greater than 
           
          This delimiter, which is a relational operator, yields the value
          true or false. 
           
               S_y_n_t_a_x_:        <operand1'  '  <operand2'  
           
          P_r_i_o_r_i_t_y_:      5 
                          
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer, long, or real. 
           
          R_e_s_u_l_t_ _t_y_p_e_s_:  always boolean. 
           
          S_e_m_a_n_t_i_c_:      The relation takes on the value true whenever the
                         corresponding relation is satisfied for the
                         expressions involved, otherwise false. 
                          
                         In case one of the operands is different from type
                         integer the relation is executed as a subtraction.
                         Thus you must be prepared for overflow, underflow,
                         or spill (see example 3 of monitor). 
           
          E_x_a_m_p_l_e_ _1_:     a:= b ' c; 
                         if d ' q then ... else ...; 
                         while k ' l do ...; 
           
           \f

F_2_._6_1_ _ _ _ _ _ _g_r_e_a_t_e_r_ _t_h_a_n_ _o_r_ _e_q_u_a_l_ _(_'_=_)_                                     2.61 greater than
                                                                              or equal 
          This delimiter, which is a relational operator, yields the value
true or false. 
                
          S_y_n_t_a_x_:        <operand1'  '=  <operand2' 
           
          P_r_i_o_r_i_t_y_:      5 
           
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer, long, or real. 
 
R_e_s_u_l_t_ _t_y_p_e_:   always boolean. 
 
S_e_m_a_n_t_i_c_:      The relation takes on the value true whenever the
               corresponding relation is satisfied for the
               expressions involved, otherwise false. 
                          
                         The relation is always executed as a subtrac-
                         tion. Thus, you must be prepared for overflow,
               underflow, or spill. 
                          
          E_x_a_m_p_l_e_ _1_:     q:= a '= c; 
                         if d '= k then ... else ...; 
                         while x '= y do ...; 
 
 \f

F_       2_._6_2_ _ _ _ _ _ _i_m_p_l_i_c_a_t_i_o_n_ _(_=_'_)_       2.62 implication 
           
          This delimiter, which is a logical operator, yields the logical
          implication of the two operands. 
           
          S_y_n_t_a_x_:        <operand1'  ='  <operand2' 
           
          P_r_i_o_r_i_t_y_:      9 
           
          O_p_e_r_a_n_d_ _t_y_p_e_s_: boolean 
           
          R_e_s_u_l_t_ _t_y_p_e_:   boolean. 
 
S_e_m_a_n_t_i_c_:      The truth value is determined according to the
               following rule: 
           
                              right
                         left       true   false 
                         true       true   false 
                         false      true   true 
 
 \f

F_       2_._6_3_ _ _ _ _ _ _i_n_                                                                    2.63 in 
           
          This standard identifier is a preopened z_o_n_e_ available for input
          on character level. The actual file connected to the zone is
          determined by the file processor command which started the pro-
          gram (see ref. 15). 
           
          The call <program' will let >in> be connected to the current
          input file of the file processor. 
          The call <program' <text file' will let >in> be connected to the
          file <text file', if the program is not translated with the pa-
          rameter connect.no. 
          The call <program' <integer' makes >in> and the file processor
          unavailable (but frees some space in the job area), if the
          program is translated with the parameter fp.no. 
           
          When the program terminates, the latest operation on >in> must
          have been a call of a character reading procedure. 
           
          E_x_a_m_p_l_e_ _1_:     read (in,a,b,c); 
                         readchar (in,char); 
           
          E_x_a_m_p_l_e_ _2_:     prog= algol connect.no ... 
                         prog param   ; the program will n_o_t_ use param 
                                      ; as input text file. 
           
          E_x_a_m_p_l_e_ _3_:     prog= algol fp.no ... 
                         prog 7; in/out fp are removed from the process 
                          
                          \f

F_       2_._6_4_ _ _ _ _ _ _i_n_c_r_e_a_s_e_                                                          2.64 increase
           
          This integer standard procedure is used in connection with a
          variable text as parameter to write, open etc. 
           
          C_a_l_l_:          increase (i) 
           
                         increase    (return value, integer). The
                                     procedure performs: 
                         increase:= i; i:= i + 1; 
                                     but i is only evaluated once. 
                         i           (call and return value, integer).
                          
          E_x_a_m_p_l_e_ _1_:     This procedure could be used in a procedure call,
                         where the formal parameter is a string, but the
                         actual parameter is a real array, when the par-
                         ameter is referenced only once. 
                          
                         The zonerecord in zone z contains a text from
                         element 4. This text can be written out by: 
                          
                         i:= 4; 
                         write (out, string z (increase(i)); 
                          
                          \f

F_       2_._6_5_ _ _ _ _ _ _i_n_i_t_k_e_y_                                                            2.65 initkey 
           
          This standard procedure generates a piece of code for comparison
          of two records in a zone. Succeeding calls of the procedure
          newsort, outsort, and lifesort with the zone as parameter will
          cause this code to be used, provided the second parameter in the
          calls is omitted (see procedure newsort). 
           
          This procedure is the A_L_G_O_L_5_ version of changekey6, and must not
          be used if the sorting was initiated by startsort6. 
           
          C_a_l_l_:             initkey (z, keydescr, n) 
           
                            z         (call and return value, zone). The
                                      name of the zone used for sorting. 
                            keydescr  (call value, array). A real array
                                      holding information about types and
                                      relative locations of the key field
                                      in a record (see below). 
                            n         (call value, integer). Number of key
                                      fields (number of rows in keydescr). 
           
          K_e_y_ _d_e_s_c_r_i_p_t_i_o_n_:  The array keydescr must be declared as: 
                                      array keydescr(1:n, 1:2); 
                            with the restriction: 
                                      1 <= n <= 4 * max. record length 
                            Each row in the array holds a description of a
                            key field in the records to be sorted. The
                            priority of the key decreases with increasing
                            row number of their description, so the highest
                            priority key is described in the first row, and
                            so on. 
                             \f

                  Column one holds information about key field          initkey
                  type and rule of sequencing. For the key field
                  type the following conventions hold: 
                   
                  v_a_l_u_e_     k_e_y_ _f_i_e_l_d_ _t_y_p_e_ 
                  +_1        12-bit integer 
                  +_2        24-bit integer 
                  +_4        48-bit real 
                   
                  A long field or a 12-bit unsigned integer
                  cannot be specified as a key field. 
                   
                  The sign of the type descriptor indicates the
                  rule of sequencing: plus for ascending, minus
                  for descending. 
                   
                  Column two is the relative location of the
                  described field within a record. The meaning of
                  this location is related to the key field type
                  as follows (r stands for record length): 
                   
                  k_e_y_ _f_i_e_l_d_ _t_y_p_e_     p_o_s_s_i_b_l_e_ _r_e_l_a_t_i_v_e_ _l_o_c_a_t_i_o_n_s_ 
                  48-bit real        1,2,3,...,r-1,r 
                  24-bit integer     1,1.5,2,2.5,...,r,r+0.5 
                  12-bit integer     1,1.25,1.5,1.75,2,...,r,r+0.25, 
                                     r+0.5,r+0.75 
                   
                         This means that the relative location of a key
                  field is counted in fractions of reals. 
                   
         Z_o_n_e_ _s_t_a_t_e_:       The zone state must be 9, in sort, i.e.
                  initsort must have been called. The state is
                           not changed by the procedure. 
                   \f

          E_x_a_m_p_l_e_ _1_:        A certain sort key consists of an integer, two       initkey
                            halfwords and a real stored in this order in
                            double words 2 and 3 of a record. The following
                            sequence is wanted: 
                             
                                 1. ascending on the real. 
                                 2. descending on the first halfword. 
                                 3. descending on the integer. 
                                 4. ascending on the second halfword. 
                             
                            The following program will generate a proper
                            code for comparison of two records. 
                             
                                 begin zone z(size, 1, error); 
                                   real array crit(1:4, 1:2); 
                                   crit(1,1):=  4;  crit(1,2):= 3; 
                                   crit(2,1):= -1;  crit(2,2):= 2.5; 
                                   crit(3,1):= -2;  crit(3,2):= 2; 
                                   crit(4,1):=  1;  crit(4,2):= 2.75 
                                   initsort(z, length); initkey(z, crit, 4); 
                                   ..... 
                                 end; \f

F_2_._6_6_ _ _ _ _ _ _i_n_i_t_s_o_r_t_ 2.66 initsort
           
          This standard procedure initiates a sorting process in a zone, so
          that the procedures newsort, outsort, deadsort, and lifesort can
          be used with that zone as a parameter. 
           
          This procedure is the A_L_G_O_L_5_ version of startsort6, and must not
          be used together with changekey6. A call of initsort followed by
          a call of initkey is analoguos to a call of startsort6. 
           
          C_a_l_l_:          initsort (z, length) 
                                 
                         z      (call and return value, zone). The name of
                                the zone used for sorting. 
                         length (call value, integer). Max. length in
                                double words of the records to enter the
                                sorting process. 
                                 
          Z_o_n_e_          A sort zone capable of holding N records at the
          d_e_c_l_a_r_a_t_i_o_n_:   same time must be declared as follows: 
                          
                                 zone z((N+9)*(length+1), 1, error) 
                          
                         where length is max. record length. The
                         declaration has the same form as a zone
                         declaration for input/output use with buffer
                         length = (N+9)*(length+1) and no. of shares = 1. 
                          
                         The error procedure must be supplied by the user,
                         as described in startsort6. 
                          
          Z_o_n_e_ _s_t_a_t_e_:    The zone must be in state 4, after declaration. 
                         The state becomes 9, in sort. 
                          
                          \f

F_       2_._6_7_ _ _ _ _ _ _i_n_i_t_z_o_n_e_s_ 2.67 initzones
           
          This procedure changes the buffersize and number of shares of
          each zone in a zone array. 
           
          C_a_l_l_:          initzones (za, bufsize, shares) 
                          
                         za        (call and return value, zone array). The
                                   buffersize and number of shares are
                                   changed for all zones: 
                                   za(1), za(2), ... za(no. of zones). The
                                   zone states must be 4 (after declara-
                                   tion) for all za(i). 
                         bufsize   (call value, integer array). Bufsize(i)
                                   specifies the number of elements of 4
                                   halfwords each in the bufferarea to be
                                   allocated to the zone za(i). 
                         shares    (call value, integer array). Shares(i)
                                   specifies the number of shares to be
                                   assigned to za(i). 
                                    
          N_o_t_e_:          The sum of all bufsize(i), 1 <= i <= no _of _zones,
                         must not exceed the original total buffer size for
                         the zone array za, as determinated by the declara-
                         tion. Obviously bufsize(i) and shares(i) must be
                         positive integers. 
                          
          Z_o_n_e_ _s_t_a_t_e_:    All zones of the zone array must be in state 4,
                         after declaration. The zone state is not changed
                         by the procedure. 
                          \f

          E_x_a_m_p_l_e_ _1_:  The procedure can be used in a program where a num-   initzones 
                      ber of files are handled by means of a logical file
                      number, but the files use different block lengths: 
                       
                        begin 
                          zone array za(n, total _bufsize//n, shares, stderror);
                          integer array buf, sh(1:n); 
                                                      <* blocklength, no _of _shares*' 
                          buf(1):= 128;   sh(1):= 1;  <*file1:     1      1       *' 
                          buf(2):= 128*2; sh(2):= 2;  <*file2:     1      2       *' 
                          buf(3):= 128*4; sh(3):= 1;  <*file3:     4      1       *' 
                          ... 
                          initzones (za, buf, sh); 
                          ... 
                          open(z(i), ...); 
                          invar(z(i)); <* read from file no. i *' 
                           
                           \f

F_       2_._6_8_ _ _ _ _ _ _i_n_r_e_c_                                                               2.68 inrec 
           
          This integer standard procedure is the A_L_G_O_L_5_ version of inrec6.
          Inrec gets a sequence of elements of 4 halfwords each from a
          document and makes them available as a zone record. 
           
          C_a_l_l_:          inrec (z, length) 
           
                         inrec     (return value, integer). The number of
                                   elements each of 4 halfwords in the
                                   present block for further calls of
                                   inrec. 
                         z         (call and return value, zone). The name
                                   of the record. Determines further the
                                   document, the buffering, and the
                                   position of the document. 
                         length    (call value, integer, long, or real).
                                   The number of elements of 4 halfwords
                                   each in the new record. Length must be
                                   '= 0. 
                                     
                         For further description see inrec6. 
                          
                         Inrec may be used with advantage, if the do-
                         cument is considered to contain reals. 
                          
          E_x_a_m_p_l_e_ _1_:     Records of variable length may be handled in
                         the Algol 5-way by means of inrec and outrec,
                         but you should be careful: For magnetic tapes
                         the record length should be checked in the
                         block procedure to make sure that they match
                         the block length. For backing storage areas
                         the unused elements at the block end must be
                         skipped (outrec clears them). 
                          
                             Suppose the record length is stored as the 
                                  first element of the record. The record may
                         then be fetched in this way for all devices: 
                          \f

                         for remaining:= inrec(z,1) while z(1)<= 0 do               inrec 
                 inrec(z,remaining); 
                                comment unused elements are skipped; 
                         inrec(z, z(1) - 1); 
                               
                              Another solution is to call the block procedure
                         after all normal answers and let it adjust or
                         check the z(1). N_o_t_e_ that the relation z(1) = 0
                         instead of z(1) <= 0 would not work because a
                         backing storage area is filled up with binary
                         zeroes. 
      
      \f

F_       2_._6_9_ _ _ _ _ _ _i_n_r_e_c_6_          2.69 inrec6
           
          This integer standard procedure gets a sequence of halfwords
          from a document and makes them available as a zone record.
          The document may be scanned sequentially by means of inrec6,
          because the next call of inrec6 gets the elements just after
          those got now. 
           
          C_a_l_l_:          inrec6 (z, length) 
                          
                         inrec6    (return value, integer). The number of
                                   halfwords left in the present block for
                                   further calls of inrec6. 
                         z         (call and return value, zone). The name
                                   of the record. Determines further the
                                   document, the buffering, and the position
                                   of the document (see ref. 15). 
               length    (call value, integer, long, or real).
                         The number of halfwords in the new
                         record. Length must be '= 0. If length
                         is odd, 1 is added to the call value. 
           
          Z_o_n_e_ _s_t_a_t_e_:    The zone z must be open and ready for record input
               (state 0 or 5, i.e. the zone must only have been
               used by inrec6, invar or the like since the latest
               call of open or setposition). To make sense, the
               document should be an internal process, a backing
               storage area, a typewriter, a paper tape reader, a
               card reader, or a magnetic tape. In the latter case
               setposition(z,...) must have been called after the
               call of open(z,...). 
                
          B_l_o_c_k_i_n_g_:      Inrec6 must be thought of as transferring the half-
                         words just after the current logical position of
                         the document and changing the logical position to
                         after the last halfword of the record. \f

                                  However, all halfwords of the record are taken     inrec6 
                         from the same block, so if the record cannot be
                         taken from the current block, the block is changed
                         as described in ref. 15. Then the record becomes
                         the first halfwords of that block, but if it still
                         cannot hold the record the run is terminated
                         (empty blocks are completely disregarded). 
                          
                         Records of length 0 need a special explanation: if
                         not even a single word is left in the block, the
                         block is changed and the logical position points
                         to just before the first word of the new block. 
                          
                         At end of document the standard error action will
                         simulate an "end block" containing one word of
                         three end medium characters. So the call b:=
                         inrec6(z,0) will in this case give the result b=2,
                         and the "end block" may be read by inrec6(z,2).
                         (This is not valid for inrec, as inrec cannot read
                         less than 4 halfwords). 
                          
                         Note that inrec6 changes the blocks in such a way
                         that a portion at the end of a block may be skip-
                         ped. So be careful to read a backing storage area
                         with the same share length as that with which is
                         was written, otherwise, wrong portions might be
                         skipped at reading. 
                          
          E_x_a_m_p_l_e_ _1_:     A simple scan of a file on a magnetic tape in dou-
                         ble buffer mode may be programmed in this way (all
                         records are assumed to be of 20 halfwords): 
                          \f

                                begin                                             inrec6 
                                zone file(2*128,2,endfile); 
                                boolean in _file; 
                                integer i; 
                                 
                                procedure endfile(z,s,b); zone z; integer s,b;
                                if s extract 1 = 1 then stderror(z,s,b) else
                                if b ' 0 or s shift (-18) extract 1 = 1 
                                  then in _file:= false; 
                                 
                                open(file,18,<:mt600304:', 
                                     1 shift 18 + 1 shift 16); 
                                setposition (file,1,0); 
                                comment skip the label in file 0, 
                                in _file:= true; 
                                for i:= inrec6 (file, 20) while in _file do 
                                begin 
                                  ... 
                                end; 
                                close(file,true); 
                                 
                                  The scan is terminated by the procedure end-
                         file which is called at tape mark (1 shift
                         16), end of tape (1 shift 18), and all hard
                         errors. After the positioning (but before the
                         first input operation) endfile may be called
                         with tape mark indication. In this case howe-
                         ver, b = 0, while b ' 0 after input of a tape
                         mark. 
                          
                         The same piece of code would work for an area
                         on the backing store if the file was genera-
                         ted with a share length of 128 elements of 4
                         halfwords and if the second and third parame-
                         ter to open were changed. 
                          
          E_x_a_m_p_l_e_ _2_:     Two files of 100 halfwords records on magne-
                         tic tape are arranged in ascending order
                         (sorted with respect to the key indicated by
                         the integer field keyf). They may be merged
                         into one file in this way: 
                          \f

                              begin zone result(2*256,2,stderror);                inrec6 
                                zone array inp(2,2*256,2,endfile); 
                               
                                procedure endfile(z,s,b); zone z; integer s,b; 
                                         if s extract 1 ' 0 then stderror(z,s,b) else 
                                begin  
                                  b:= 100; z.keyf:= large; 
                                  comment the procedure simulates the presence of a
                                       record with a very large key; 
                                end; 
                                 
                                  open(inp(1),...,1 shift 16); open (inp(2),...
                                  setposition ... setposition ... 
                                  large:= (-1) shift (-1); 
                                  inrec6(inp(1),100); inrec6(inp(2),100); 
                                  for k:= if inp(1).keyf < inp(2).keyf then 1 else 2
                                      while inp(k).keyf < large do 
                                  begin 
                                    outrec6(result,100); 
                                    tofrom(result,inp(k),100);
                                    inrec6(inp(k),100); 
                                  end; 
                                  close(result, ...); 
                                     
          E_x_a_m_p_l_e_ _3_:     You may read a magnetic tape file or backing
                         storage area block by block in this way: 
                          
                              for b:= inrec6(z,0) while b ' 2 do 
                              begin 
                                comment b is now the block length in halfwords,
                                  the standard actions simulate one word containing
                                  <:<25'<25'<25':' at end of document; 
                                inrec6(z,b); 
                                comment the block is now available as one record; 
                              ... ; 
                              end; 
                              comment check that the last record is 
                                      the simulated end block; 
                              inrec6(z,2); 
                              if z.firstword <' 
                                 long <:<25'<25'<25':' shift (-24) extract 24 
                              then error; \f

F_       2_._7_0_ _ _ _ _ _ _i_n_t_a_b_l_e_                                                            2.70 intable
           
          This standard procedure exchanges the current input alphabet used
          by all the read procedures on character level. 
           
          C_a_l_l_:     intable (alpha) or 
                    intable (0) 
                     
                    alpha     (call value, integer array of one dimension).
                              Contains the character class and the value of
                              each character in the new input alphabet as
                              described below. 
                    0         (call value, integer). A zero signals that
                              the standard alphabet is to be used. 
                               
          i_n_t_a_b_l_e_ _(_a_l_p_h_a_)_: 
          The actual contents of alpha are used in all calls of read proce-
          dures, until another array or the standard alphabet is selected.
          This means that any change in the contents of alpha may have ef-
          fects on the character reading. If a read procedure is called at
          a place where alpha is undeclared, an undefined alphabet is used.
           
          To each character >c> delivered by the peripheral device is
          associated a C_l_a_s_s_ and a V_a_l_u_e_, determined by the read procedures
          in this way: 
           
              alpha(c+tableindex) = Class shift 12 + Value extract 12  
           
          Class is an integer 0 <= Class <= 4095. Value is an integer,
          -2048 <= Value <= 2047. The character >c> is an integer, 0 <= c <=
           255. The ISO characters utilize only half of this interval. The
          standard integer >tableindex> is normally 0, but you may use it
          to modify the alphabet. 
           
          The class determines how the value corresponding to a character
          is handled: 
           \f

          Class = 0,  blind: The character is skipped by all read proce-         intable 
                      dures. 
          Class = 1,  shift character: The value is assigned to tableindex
                      and the character is looked up again in the alphabet
                      to determine Class and Value. 
          Class = 2,  digits: The character is a decimal digit the value of
                      which is Value - 48. To make sense, 48 <= Value <= 57
                      should be fulfilled. 
          Class = 3,  signs: The character is the sign of a decimal number.
                      Value = 43 means +, Value = 45 means -. 
          Class = 4,  decimal point: The character may be used as a decimal
                      point. 
          Class = 5,  exponent mark: The character may be used as the > of
                      Algol. 
          Class = 6,  letters: The character may be used as part of a text
                      but not as part of a number. 
          Class = 7,  delimiter: The character cannot be part of a text or
                      a number. 
          Class = 8,  terminator: The character is a delimiter as class 7,
                      but it will terminate a call of readall. If value is
                      25, it will immediately terminate a call of read or
                      readstring. 
          Class ' 8,  other delimiters: The character is handled as class 7.
           
          The elements 0:127 of alpha may be initialized with the ISO al-
          phabet by a call of the standard procedure isotable. 
           
          i_n_t_a_b_l_e_ _(_0_)_: 
          The standard alphabet given in ref. 14 is used until a new
          alphabet is selected. The value of tableindex has no influence on
          the alphabet. When the run starts, the standard alphabet is
          selected automatically. 
           
          You should not hesitate to use a special alphabet table: The
          character reading will be speeded up compared to what you could
          do in algol with the standard alphabet, and the input algorithm
          becomes clearer. 
           
          The table takes space, but remember that 2*128 integers
          correspond to one segment of a program (10 to 20 lines), and that
          much is easily saved in the central loop of the input program. \f

                   E_x_a_m_p_l_e_ _1_:     N_u_m_b_e_r_ _v_a_r_i_a_n_t_s_                                         intable 
                          
                         Assume you want to read numbers coded in ISO but
                         with space regarded as blind information and
                         without exponent part. You may then proceed like
                         this: 
                          
                              isotable(table); 
                              table(32):= 0; table(39):= 7 shift 12 + 39; ... 
                              comment define space, apostrophe, and other
                                   special characters; 
                              intable(table); tableindex:= 0; 
                              read(z,...); 
                          
          E_x_a_m_p_l_e_ _2_:     F_l_e_x_o_w_r_i_t_e_r_ _c_o_n_v_e_r_s_i_o_n_  
                          
                         It is possible to use the read procedure for input
                         represented in flexowriter code if the underlining may
                         be disregarded. The shift characters, class 1, may take
                         care of the case shift characters. An alphabet table of
                         2*128 elements is required. One way of initialising the
                         table goes like this: 
                          
                              for i:= 0 step 1 until 255 do table(i):= 
                              (case i+1 of     (0,2,2,2,2, 2,2,2,2,2, 
                                                0,8,8,6,0, 0,2,7,6,6, 
                                                ...) shift 12 + 
                              (case i+1 of     (32,49,50,51,52, 53,54,55,56,57, 
                                                0,12,25,125,0,  0,48,60,115,116,
                                                ...               )); 
 
                         Upper case and Lower case require 
                          
                              table(60):= 1 shift 12 + 128; 
                              table(60 + 128):= 0; 
                              table(58 + 128):= 1 shift 12 + 0; 
                              table(58):= 0; 
                               \f

                         Note, that if the input was flexowriter paper           intable
                         tapes which were read in ISO-mode, the parity hole
                         would not be the flexowriter parity hole, and as a
                         consequence a different alphabet table would be
                         needed. 
                          
          E_x_a_m_p_l_e_ _3_:     begin 
                              .... 
                              begin 
                                   integer array table (0:127); 
                                   <* an alphabet is initialised in table *' 
                                   table (32):= ... 
                                   intable (table); tableindex:= 0; 
                                     .... 
                                   intable (0); 
                                   <* if you forget returning to the standard
                                   alphabet before leaving the block where 
                                   table is declared, an undefined alphabet 
                                   will be used *' 
                              end block; 
                              ... 
                            end program 
           
          E_x_a_m_p_l_e_ _4_:     See example 3 of readall. 
                          
                          \f

F_       2_._7_1_ _ _ _ _ _ _i_n_t_e_g_e_r_                                                           2.71 integer 
           
          This delimiter, which is a declarator, is used in declaration and
          specifications of variables of type integer. 
           
          S_y_n_t_a_x_:        integer <namelist' 
           
          S_e_m_a_n_t_i_c_:      The variables in namelist will all be of type
                         integer, and occupy 24 bits in the storage
                         area. 
                          
                         The value of an integer is in the interval: 
                              -8388608 <= value <= 8388607 
                          
          E_x_a_m_p_l_e_ _1_:     integer     i1;
                         integer     i2, yes, no, price;
                          
                         procedure   pip (a); 
                         integer     a; 
           
           \f

F_       2_._7_2_ _ _ _ _ _ _i_n_t_e_g_e_r_ _d_i_v_i_d_e_ _(_/_/_)_                                         2.72 integer divide 
           
          This delimiter, which is an arithmetic operator, performs an 
          integer division. 
           
          S_y_n_t_a_x_:        <operand1' // <operand2' 
           
          P_r_i_o_r_i_t_y_:      3 
           
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer or long 
           
          R_e_s_u_l_t_ _t_y_p_e_:   When both operands are of type integer the 
                         result is of type integer, otherwise the 
                         result is of type long. 
           
          S_e_m_a_n_t_i_c_:      The result of the operator is defined as  
                         follows: 
                            a//b = sign (a/b)* entier(abs (a/b)) 
           
          E_x_a_m_p_l_e_ _1_:     a:= 35//12; <* a has the value 2 *' 
                         b:= -13//3; <* b has the value -4 *' 
                          
                          \f

F_2_._7_3_ _ _ _ _ _ _i_n_v_a_r_                                                                2.73 invar 
           
          This standard integer procedure together with outvar, changevar,
          and checkvar are intended for easy handling of records of vari-
          able length. Every record must contain its own length in half-
          words in its first word, the l_e_n_g_t_h_ _w_o_r_d_. Invar makes the next
          record written by means of outvar available as a zone record. A
          record checksum in the second word may be checked, and the number
          of records are counted in the so called free parameter in the
          zone descriptor (see getzone6). This procedure may call the block
          procedure with the status 1 shift 11, checksum error, if the
          record length wanted is < 4 or ' remaining halfwords in the block
          or odd or if the checksum is calculated and not equal to the
          value of the second word in the record. 
           
          C_a_l_l_:          invar (z) 
           
                         invar     (return value, integer). The number of
                                   halfwords left in the present block. 
                         z         (call and return value, zone). The name
                                   of the record. Determines the document,
                                   the buffering, and the position of the
                                   document. 
                                    
          Z_o_n_e_ _s_t_a_t_e_:    The zone z must be open and ready for record
                         input (state 0 or 5), i.e. the zone must only 
                         have been used by invar or the like since the
                         latest call of open or setposition.  
           
          F_r_e_e_ _p_a_r_a_m_e_t_e_r_:The free parameter in the zone descriptor is used
                         to count the number of records accepted by invar.
                         The value of this parameter is interpreted as
                         check _wanted shift 23 + record _count where
                         check _wanted = 1 means that a checksum is calcula-
                         ted by invar and checked against the second word
                         in the record. The free parameter could be set in
                         the program by: 
                                   getzone6(z,ia); ia(11):= 1 shift 23; 
                                   setzone6(z,ia); 
                         See below for further details. 
                       \f

                   B_l_o_c_k_i_n_g_:   You may think of invar in the way that the procedure          invar 
                      tests the value of the first word just after the cur-
                      rent logical position of the document. Now invar ex-
                      poses as many halfwords as the length word indicates,
                      including the two halfwords of this word. 
                       
                      However all halfwords must be taken from the same
                      block. If this is not possible, the block procedure
                      of the zone is called. See further on length errors
                      below. 
                       
                      If the length word is null, it is skipped and the
                      next word from the document is tried as length word.
                      When there are no more in a block, the block is
                      changed. This covers skipping of blank block tails
                      that may be generated by outvar when the kind of the
                      document is backing storage (see outvar). 
                       
               L_e_n_g_t_h_ _e_r_r_o_r_s_._ _C_h_e_c_k_s_u_m_: 
                       
                      If the length word is <' 0, it is expected to be 
                      even, '= 4 and <= the number of halfwords remaining
                      in the present block. If not all three conditions are
                      fulfilled, invar will give up and call the block pro-
                      cedure (see below). 
                       
                      When the length word has passed the tests above, the
                      contents of the second word may be tested as a check
                      sum of the record (see example 2 below). If check is
                      wanted (see free parameter above), invar tests if the
                      sum of all words in the record taken modulo 2**24 is
                      equal to -3. If not, invar calls the block procedure.
           
                   B_l_o_c_k_ _p_r_o_c_e_d_u_r_e_,_ _c_a_l_l_ _c_o_n_d_i_t_i_o_n_s_: 
                       
                      Invar may call the block procedure in two diffe-
                      rent situations: 
                       \f

                      a) The length word is not sensible (see above).               invar 
                      b) Record sumcheck is wanted, and the sum is not
                         ok (see above). 
                       
                      The call conditions for the parameters to the
                      block procedure are: 
                       
          z:          The zone state is after record input. The defect
                      record is not counted in the free parameter. The
                      record starts just before the length word and
                      depends on the length word like this: 
                       
                              record _length:= 
                                if length _word < 4 or length _word ' remaining  
                                then remaining else 
                                if record _length is odd then length _word + 1 
                                else length _word. 
                                 
                      Remaining means the number of halfwords remaining
                      in the present block including the length word.
                      The terms zonestate, free parameter, and record
                      length are explained in getzone6. 
                       
          s:          The status word parameter has the value 1 shift 11. 
                       
          b:          The halfwords transferred parameter is equal to the
            record length, described above. 
                       
                      After return from the block procedure, invar re-
                      starts its algorithm by fetching the next logical
                      record. A defect record will thus be skipped if
                      the block procedure simply ignores the call, (see
                      example 2). 
                       \f

                   E_x_a_m_p_l_e_ _1_:  Your block procedure may test whether situation               invar
            a) or situation b) above has caused the block
            procedure to be called. This may be done as follows: 
                              procedure blpr(z,s,b); zone z; integer s,b; 
                              begin 
                                ..... 
                                if s = 1 shift 11 then 
                                begin integer field lengthword; lengthword:= 2; 
                                  if b < 4 then 
                        begin comment end of documment; ... 
                                  end 
                      else 
                        if b <' z.lengthword then 
                                  begin comment length error; ... 
                                  end 
                                else 
                                  begin comment checksum error; ... 
                                  end; 
                                end 
                                ..... 
                              end; 
                       
          E_x_a_m_p_l_e_ _2_:  A_t_t_e_m_p_t_ _t_o_ _r_e_p_a_i_r_ _a_ _d_e_f_e_c_t_ _r_e_c_o_r_d_. 
                       
                      When you read a file from magnetic tape written
                      by means of outvar, you may try to make sense of
                      blocks with parity error and where the standard
                      actions have given up. 
                       
                      This will only be waste of machine power if all
                      records are needed in a run. In such case it is
                      better to give up once status errors occur. It
                      must be recognized, however, that problems exist
                      where it is essential to make as much sense out
                      of a file as possible in one run and then try to
                      pick up the defect records in a later run. 
                       \f

                    A block procedure which counts the number of wrong         invar 
                    >records> and only gives up when this number is too
                    large may look something like this:  
                      
                    procedure after _parity (z,s,b); 
                    zone z; integer s, b; 
                    begin 
                      own integer faults; integer field length; 
                      integer array ia (1:20); 
                      procedure drop; 
                        write (out, <:record dropped, expected::', z.length,
                               <: dropped::', b, <: halfwords<10':'); 
                         
                      length:= 2; 
                      if s shift (-18) extract 1 = 1 or 
                         s shift (-16) extract 1 = 1 then 
                      begin  comment end of document or tapemark, simulate
                             a dummy record and switch off the sum check,
                             in order to prevent invar from calling the
                             block procedure again; 
                        z.length:= b:= min _length; 
                        end _medium:= true; 
                        getzone6(z, ia); ia(11):= ia(11) extract 23; 
                        setzone6(z, ia); 
                      end 
                      else 
                       
                      if s = 1 shift 11 then 
                      begin 
                        faults:= faults + 1; 
                        if faults ' max then stderror (z,s,b); 
                        if b <' z.length then drop 
                        else 
                        begin comment maybe only checksum error; 
                          if b<min _length or b'max _length then drop 
                          else 
                           \f

                          begin                                                     invar 
                            comment now check the contents of the possible
                              record. If it does not seem sensible then drop
                              it, else set a mark that it may be erroneous; 
                             
                            .... 
                            checkvar (z); 
                            changerec6 (z,0); 
                            comment force a new checksum into the record and
                              regret the record so that invar may take it
                              once more; 
                          end; 
                        end; 
                      end s = 1 shift 11 
                      else 
                      if logand (s, -1 - (1 shift 22 <*parity error*'    + 
                                          1 shift 15 <*writing enabled*' + 
                                          1 shift  1 <*normal answer*'   + 
                                          1 shift  0 <*hard error*' )) 
                         <' 0 then stderror (z,s,b); 
                         comment give up if hard error, except in connection
                           with parity error, ring indication, and/or normal
                             answer; 
                      end after _parity; 
                       
                       
                      When the zone with this block procedure is opened,
                      the give up mask should contain the tapemark bit (or
                      end document bit if reading from backing storage), as
                      standard action would simulate a dummy block of 2
                      halfwords, which invar would consider a length error.
                      On the other hand the give up mask should not contain
                      the parity error bit, as the standard action, 5
                      readings, is wanted for parity error. The bit for
                      checksum wanted should be set in the free zone
                      parameter (see getzone6): 
                       \f

                                       open(z,18,<:...:', 1 shift 18 + 1 shift 16);        invar 
                              setposition(z,1,0); 
                              getzone6(z,ia); ia(11):= 1 shift 23; 
                              setzone6(z,ia); 
                              repeat 
                                invar(z); 
                                ..... handle the record, note the error-mark; 
                              until end _medium; 
           
          E_x_a_m_p_l_e_ _3_:  See example of changevar. 
 
 \f

F_       2_._7_4_ _ _ _ _ _ _i_s_o_t_a_b_l_e_                                                          2.74 isotable 
 
          This standard procedure initializes an array with the ISO
          character table for use in intable or outtable. 
           
          C_a_l_l_:          isotable (alpha) 
                          
                         alpha     (return value, integer array of one
                                   dimension). The elements alpha (0:127) 
                         of the array are initialized with 
                                       class shift 12 + value 
                                   of the ISO characters, as 
                                   defined in ref. 14. 
                               
          E_x_a_m_p_l_e_ _1_:     See example 1 of intable. 
                          
                          \f

F_2_._7_5_ _ _ _ _ _ _l_e_s_s_ _t_h_a_n_ _(_<_)_ 2.75 less than
 
          This delimiter, which is a relational operator, yields the value
          true or false. 
           
          S_y_n_t_a_x_:        <operand1'  <  <operand2' 
           
          P_r_i_o_r_i_t_y_:      5 
           
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer, long, or real. 
           
          R_e_s_u_l_t_ _t_y_p_e_:   always boolean 
           
          S_e_m_a_n_t_i_c_:      The relation takes on the value true whenever the
                         corresponding relation is satisfied for the ex-
                         pressions involved, otherwise false. 
           
                         In case one of the operands is different from type
                         integer the relation is executed as a subtraction.
                         Thus, you may be prepared for overflow, underflow,
                         or spill. 
                          
          E_x_a_m_p_l_e_ _1_:     a:= b < c; 
                         if  d < q then .... else ...; 
                         while k < l do ...; 
           
           \f

F_       2_._7_6_ _ _ _ _ _ _l_e_s_s_ _t_h_a_n_ _o_r_ _e_q_u_a_l_ _(_<_=_)_      2.76 less than
           or equal
          This delimiter, which is a relational operator, yields the value
true or false. 
           
          S_y_n_t_a_x_:        <operand1'  <=  <operand2' 
           
          P_r_i_o_r_i_t_y_:      5 
 
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer, long, or real. 
           
          R_e_s_u_l_t_ _t_y_p_e_:   always boolean. 
           
          S_e_m_a_n_t_i_c_:      The relation takes on the value true whenever the
                         corresponding relation is satisfied for the
                         expressions involved, otherwise false. 
                          
                         The relation is always executed as a subtraction.
                         Thus, you may be prepared for overflow, underflow,
                         or spill (see example 3 of monitor). 
           
          E_x_a_m_p_l_e_ _1_:     q:= a <= c; 
                         if  d <= k then ... else ...; 
                         while x <= y do ...; 
           
           \f

F_       2_._7_7_ _ _ _ _ _ _l_i_f_e_s_o_r_t_ 2.77 lifesort
          
          This standard procedure makes available that zone record which is
          to be the next record in a sorted string of records from a zone.
          The winning record is selected among the active and inactive
          records in the zone, and at the same time all inactive records
          are activated. 
           
          The user is supposed to move the record away from the zone before
          next call of any sorting procedure. 
           
          C_a_l_l_:          lifesort (z, key)   or   liftsort (z) 
                          
                         z         (call and return value, zone). The name
                                   of the selected record. 
                         key       (call value, integer procedure or
                                   empty). The name of a procedure for
                                   comparison of two records (see procedure
                                   newsort). 
 
                         The key parameter is omitted if standard  
                         sequencing is used (see procedure startsort6). 
                          
          Z_o_n_e_ _s_t_a_t_e_:    The zone state must be 9, in sort, i.e. startsort6
                         (or initsort) must have been called. The state is
                         not changed by the procedure. 
                          
          E_x_a_m_p_l_e_ _1_:     See example 1 of newsort for a user specified key
                         procedure. 
           
E_x_a_m_p_l_e_ _2_:     See example 2 of deadsort. 
                          
                          \f

F_2_._7_8_ _ _ _ _ _ _l_n_      2.78 ln
           
          This real standard procedure performs the mathematical function
          ln. 
           
          C_a_l_l_:          ln (r) 
           
                         ln   (return value, real). The Napierian
                              logarithm of r. r ' 0. 
                         r    (call value, real, long, or integer). 
           
          A_c_c_u_r_a_c_y_:      r = 1                gives ln = 0 
                         0.5 <= r < 2         gives absolute error below 2.2>-10 
                          
                         0.25 <= r < 0.5 or 
                         2 <= r < 4           gives relative error below 1.8>-10 
                                               
                         r < 0.25 or 4 <= r   gives relative error below 1.2>-10 
                          
          A_l_a_r_m_:         The run is terminated if r <= 0. 
                          
          E_x_a_m_p_l_e_ _1_:     A procedure which gives the decimal logarithm 
                         may look like this: 
                              real procedure log(x); 
                              value x; real x; 
                                log:= ln(x) / ln(10); 
                                 \f

F_2_._7_9_ _ _ _ _ _ _l_o_c_k_                                                                   2.79 lock 
           
          This standard procedure transfers immediately a number of program
          segments to core and locks them: i.e. they are not released later
          on caused by some request for space for other segments. 
                    
M_                 * 
                   C_a_l_l_:        lock (  <pair of parameters'      ) 
P_                                                     1
                    
          <pair of          <label expression',<label expression' 
           parameters' ::=  <integer expression',<integer expression' 
                            <procedure identifier',<integer expression' 
           
                       Each pair of parameters is evaluated, and a locking
                       process is performed depending on the parameter
                       pair: 
                        
          <_l_a_b_e_l_ _e_x_p_r_e_s_s_i_o_n_'_,_<_l_a_b_e_l_ _e_x_p_r_e_s_s_i_o_n_'_ 
           
          The values of the two label expressions define two points in
          the program. All program segments between (and inclusive)
          the two points are locked. 
           
          <_i_n_t_e_g_e_r_ _e_x_p_r_e_s_s_i_o_n_'_,_<_i_n_t_e_g_e_r_ _e_x_p_r_e_s_s_i_o_n_'_ 
           
          The values of the two integer expressions define two segment
          numbers in the program. All segments in the program between
          (and inclusive) those segments are locked. 
           
          Segment numbers of first segment of the main program and all
          external procedures included in the program may be obtained from
          a compilation with survey.yes specified (see ref. 15 and ref.
          10). This parameter pair is intended for locking segments of the
          run time system. The run time system consists of 11 segments: 
                    \f

                   segment 0      :    alarm segment 0, c_a_n_n_o_t_ be locked                     lock 
          segment 1-5    :    resident part of RS, c_a_n_n_o_t_ be locked 
          segment 6      :    long division and multiplication, stderror 
          segment 7      :    alarm segment 1, used by run time alarms
          segment 8      :    declaration of zones, exponentiation: **
          segment 9      :    RS block segment (i.e. inblock, outblock etc.)
          segment 10     :    RS error segment (i.e. special handl. of status)
           
          <_p_r_o_c_e_d_u_r_e_ _i_d_e_n_t_i_f_i_e_r_'_,_<_i_n_t_e_g_e_r_ _e_x_p_r_e_s_s_i_o_n_'_ 
           
          The value of integer expression defines a number of consecutive
          segments - starting with the entry segment of the procedure - to be
          locked. 
           
          E_x_a_m_p_l_e_ _1_:     If we want to lock in primary store segment 6 (long
                         division and multiplication), two segments containing
                         procedure readin, and one or more segments surround-
                         ing label seglock1 to label seglock2, this could be
                         done by the call: 
                          
                              lock(6,6, readin, 2, seglock1, seglock2); 
                               
                               \f

F_2_._8_0_ _ _ _ _ _ _l_o_c_k_e_d_                                                              2.80 locked 
 
          This integer standard procedure transfers the segment numbers
          (0,1,...) of the segments, which are locked for the moment, to an
          integer array parameter. 
           
          C_a_l_l_:          locked (ia) 
           
                         locked (return value, integer). Number of segments
                                locked at the moment. 
                         ia     (return value, integer array). ia(1), ia(2),...
                                ia(locked) is the list of segment numbers
                                for the segments locked at the moment. 
                                 
          E_x_a_m_p_l_e_ _1_:     If the call 
                              locked (ia); 
                         is used after the call shown in example 1 under
                         lock, the results could be: 
                              ia(1) = 6 
                              ia(2) = 24 
                              ia(3) = 25 
                              ia(4) = 32 
                              ia(5) = 33 
                              ia(6) = 34 
                               
                               \f

F_2_._8_1_ _ _ _ _ _ _l_o_g_a_n_d_                                                              2.81 logand 
 
          This long standard procedure performs the function logical and
          (logical multiplication) on two 48 bit entities a and b. If the
          type length of a and/or b is smaller than 48 bits, they are ex-
          tended by repetition of the sign bit. 
           
          C_a_l_l_:          logand (a, b) 
           
                         logand  (return value, long). Bitpattern equal
                                 to (a and b) performed bit by bit after
                                 a possible extension of the parameters a
                                 and b. 
                         a,b     (call values, short string (text portion),
                                 real, long, integer, or boolean). The two
                                 parameters do not have to be of the same
                                 kind. They are - if necessary - extended
                                 and they are handled as described below. 
                               
          H_a_n_d_l_i_n_g_ _o_f_ _a_ _a_n_d_ _b_ _a_c_c_o_r_d_i_n_g_ _t_o_ _k_i_n_d_: 
           
          String:     It is tested that a string parameter describes a
                      text portion or a short string (see ref. 15).
                      This is a 48 bit entity. 
          Real:       A real is represented by 48 bits. No conversion.
          Long:       A long is represented by 48 bits. No conversion.
          Integer:    An integer is extended to a long as if the
                      operator extend had been applied. 
          Boolean:    A boolean is considered as a short integer. The
                      12 bit boolean is extended to a 48 bit long
                      according to the algorithm: 
                       
                              int:= boo extract 12; 
                              if int ' 2047 then int:= int - 4096; 
                              param:= extend int; 
                       \f

                   The rules for extension imply that actual parameters with the          logand 
          values true, -1, and extend (-1) are equivalent. Note that the
          rules also imply that the effect of an integer with the value
          2048 differs from the effect of a boolean with the value false
          add 2048. 
           
          E_x_a_m_p_l_e_ _1_:     See example 2 of invar. 
           
          E_x_a_m_p_l_e_ _2_:     I_n_f_o_r_m_a_t_i_o_n_ _r_e_t_r_i_e_v_a_l_ 
                          
                         Each record is a certain file has an element inf
                         that contains binary information in each binary
                         position (sex, salary on hour basis or not, ...).
                         A statement that writes out the identification for
                         each record that fulfil all the criteria in a
                         read search element, could look like this: 
                          
                         for i:= inrec6 (z, length) while z.ident <' endident
                         do 
                           if logand (searchcrit, z.inf) = searchcrit then 
                             write (out, "nl", 1, z.ident); \f

2_._8_2_ _ _ _ _ _ _l_o_g_o_r_                                                               2.82 logor
           
          This long standard procedure performs logical or (logical addi-
          tion) on two 48 bit entities a and b. If the type length of a
          and/or b is smaller than 48 bits, they are extended by repetition
          of the sign bit. 
           
          C_a_l_l_:          logor (a, b) 
                          
                         logor     (return value, long). Bit pattern equal
                                   to (a or b) performed bit by bit after a
                                   possible extension of the parameters. 
                         a,b       (call values, short string (text
                                   position), real, long, integer, or
                                   boolean). The two parameters do not have
                                   to be of the same kind. They are - if
                                   necessary - extended and they are
                                   handled as described for logand. 
                                    
          E_x_a_m_p_l_e_ _1_:     About the same as example 2 for logand, but you
                         are now searching for records that are not in con-
                         flict with the search criteria i.e. each found
                         record should only contain all, some or none of
                         the information found in the search criteria. 
                         This could be done by replacing logand (searchrit,
                         z.inf) = searchrit by: 
                              logor (searchrit, z.inf) = z.inf 
                               \f

F_       2_._8_3_ _ _ _ _ _ _l_o_n_g_                                                                 2.83 long 
           
          This delimiter, which is a declarator, is used in declarations
          and specifications of variables of type long. 
           
          S_y_n_t_a_x_:       long <namelist' 
           
          S_e_m_a_n_t_i_c_:     The variables in namelist will all be of type
                        long, and occupy 48 bits in the storage area. 
                         
                        The value of a long is in the interval: 
                        -140 737 488 355 328 <= value <= 140 737 488 355 327.
                         
                        All values can be assigned to the variable by use of
                        shift and the like, but if you assign by constants
                        or character reading procedures you are confined to
                        th range: 
                         
                        -140 737 488 355 327 <= value <= 140 737 488 355 327 
                         
          E_x_a_m_p_l_e_ _1_:    long l1; 
                        long l2, yes, no, price; 
                         
                        procedure pip(a); 
                        long a;
           
          E_x_a_m_p_l_e_ _2_:    The greatest possible positive and negative long
                        values can be assigned by the statements: 
                              max _pos:= extend (-1) shift (-1); 
                              max _neg:= extend 1 shift 47; 
           
           \f

2_._8_4_ _ _ _ _ _ _l_o_n_g_                                                                2.84 long
           
          This delimiter, which is a transfer operator, changes the type
          string and real to type long. 
           
          S_y_n_t_a_x_:        long <operand' 
                          
          P_r_i_o_r_i_t_y_:      1 
                          
          O_p_e_r_a_n_d_ _t_y_p_e_:  real or string. 
                          
          R_e_s_u_l_t_ _t_y_p_e_:   long. 
                          
          S_e_m_a_t_i_c_:       Changes the type of a string or a real to type
                         long. The binary pattern of the operand is
                         unchanged. The binary pattern of a string and a
                         real is described in ref. 14. 
                          
          N_o_t_e_:          This use of the delimiter long is totally
                         different from its use in a declaration or
                         specification. 
                          
          E_x_a_m_p_l_e_ _1_:     l:= long <:abcde:' add >f>; 
                          
          E_x_a_m_p_l_e_ _2_:     See the examples in real and replace real with
                         long where real is used as a transfer operator. 
                          
          E_x_a_m_p_l_e_ _3_:     See example 1 of swoprec6. 
                          \f

F_       2_._8_5_ _ _ _ _ _ _m_e_s_s_a_g_e_                                                           2.85 message 
           
          This delimiter, which is a compiler directive, may print a mes-
          sage during the translation of a program. Messages follow the
          same rules as comment. 
           
          S_y_n_s_t_a_x_:    ; message <text no containing ";"' ; 
                                 may replace any ; (semicolon) 
                       
                      begin message <text not containing ";"' ; 
                                 may replace any begin 
                       
          S_e_m_a_n_t_i_c_:   The text between message and semicolon is printed on
                      current output if the program is translated with the
                      parameter message.yes. 
                       
          E_x_a_m_p_l_e_ _1_:  You can spare the listing of a long algol program and
                      still keep track of the line numbers. Put 1 or 2
                      messages on each page of the program (for instance as
                      page head) and translate it with: algol message.yes 
                      (the default value). The messages are then printed
                      with their line numbers attached and you can easily
                      find any other line given its line number. 
                       
                       \f

F_      2_._8_6_ _ _ _ _ _ _m_i_n_u_s_ _(_-_)_                                                           2.86 minus 
           
          This delimiter, which is an arithmetic operator, can be used both
          as a dyadic and as a monadic operator. 
           
          1_._ _D_y_a_d_i_c_: 
           
          S_y_n_t_a_x_:        <operand1'  -  <operand2' 
           
          P_r_i_o_r_i_t_y_:      4 
           
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer, long or real. 
           
           R_e_s_u_l_t_ _t_y_p_e_:   <integer' - <integer'   is of type integer 
                         <integer' - <long'      -  -  -    long 
                         <integer' - <real'      -  -  -    real 
                         <long'    - <integer'   -  -  -    long 
                         <long'    - <long'      -  -  -    long 
                         <long'    - <real'      -  -  -    real 
                         <real'    - <integer'   -  -  -    real 
                         <real'    - <long'      -  -  -    real 
                         <real'    - <real'      -  -  -    real 
                          
          S_e_m_a_n_t_i_c_:      This operator yields the normal arithmetic
                         difference of the expressions involved.
             
          2_._ _M_o_n_a_d_i_c_: 
                          
          S_y_n_t_a_x_:        - <operand' 
           
P_r_i_o_r_i_t_y_:      4 
 
          O_p_e_r_a_n_d_ _t_y_p_e_:  integer, long, or real. 
 
R_e_s_u_l_t_ _t_y_p_e_:   -  <integer'            is of type integer 
                    -  <long'               -  -  -    long 
                         -  <real'               -  -  -    real 
 \f

          S_e_m_a_n_t_i_c_:      This monadic operator yields the "opposite"              minus 
                         value of the operand. 
                          
               E_x_a_m_p_l_e_ _1_:     5-7 
                         a-q 
                         -5-a 
                         s shift (-11) 
                         (-1) shift (-1) 
 
 \f

F_       2_._8_7_ _ _ _ _ _ _m_o_d_                                                                2.87 mod 
           
          This delimiter, which is an arithmetic operator, yields the
          remainder corresponding to an integer division. 
           
          S_y_n_t_a_x_:        <operand1' mod <operand2' 
           
          P_r_i_o_r_i_t_y_:      3 
           
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer or long. 
           
          R_e_s_u_l_t_ _t_y_p_e_:   When both operands are of type integer, the result
                         is of type integer, otherwise the result is of
                         type long. 
                          
          S_e_m_a_n_t_i_c_:      The value of i mod j is defined as 
                              i - i//j*j 
                         The sign of i mod j is the same as the sign
                         of i. 
                          
          E_x_a_m_p_l_e_ _1_:     C_y_c_l_i_c_a_l_ _c_o_u_n_t_i_n_g_ 
                          
                         Counting i = 1,2,3,1,2,3,1,... may be done in this way:
                          
                              i:= i mod 3 + 1; 
                          
                         A longer but slightly faster version is: 
                          
                                       i:= if i = 3 then 1 else i + 1; 
                          
                          \f

F_2_._8_8_ _ _ _ _ _ _m_o_n_i_t_o_r_                                                           2.88 monitor 
           
          This integer standard procedure is the algol equivalent of the
          monitor procedures. You may use it to handle peripheral devices
          in a non-standard way and to program operating systems and exe-
          cutive functions in algol. 
           
          In most cases the algol procedure will only transform the para-
          meters to the form required by the monitor, and the description
          below describes mainly this transformation. You will have to
          consult the Monitor manuals (ref. 1 and 2) for the details and
          the ideas behind each entry. 
           
          Be aware that the monitor tables have halfword addresses. 
           
          C_a_l_l_:     monitor (fnc, z, i, ia) 
           
                    monitor   (return value, integer). In most cases the
                              result of the corresponding call of a monitor
                              procedure, the meaning of which is found in
                              the Monitor manual, part 2 (ref. 2). 
                    fnc       (call value, integer). A function code speci-
                    fying the monitor procedure to be called. 
                    z         (call and return value, zone). The zone des-
                              criptor contains in most cases the name of
                              the process or catalog entry concerned. 
                    i         (call and return value, integer). Used for
                              various purposes, e.g. device number, message
          buffer address. 
                    ia        (call and return value, integer array). Used
                              for various purposes, e.g. tail of catalog
                    entry, contents of answer. Various lengths of
                    ia are required in the various cases. 
                    
          N_o_t_e_:     Fielding has no influence on the addressing of ia as
                    the procedure always uses the array from the first
                    element and on. 

          In most cases only some of the last 3 parameters are actually
          used by the procedure. The value of fnc determines the function\f

          as follows:                                                           monitor 
           
          f_n_c_ _=_ _4_,_ _p_r_o_c_e_s_s_ _d_e_s_c_r_i_p_t_i_o_n_: 
           
          monitor        result, i.e. process description address, 0 if the
                         process does not exist. 
          z              (call value). Contains the process name. 
          i              dummy 
          ia             dummy 
           
          f_n_c_ _=_ _6_,_ _i_n_i_t_i_a_l_i_s_e_ _p_r_o_c_e_s_s_: 
           
          monitor        result, i.e. 0 means process initialised, 1,2,3
                         means not initialised. 
          z              (call value). Contains the process name. 
          i              dummy 
          ia             dummy 
           
          f_n_c_ _=_ _8_,_ _r_e_s_e_r_v_e_ _p_r_o_c_e_s_s_: 
           
          monitor        result, i.e. 0 means process reserved, 1,2,3 
                         means not reserved. 
          z              (call value). Contains the process name. 
          i              dummy 
          ia             dummy 
           
          f_n_c_ _=_ _1_0_,_ _r_e_l_e_a_s_e_ _p_r_o_c_e_s_s_: 
           
          monitor        result dummy
          z              (call value). Contains the process name. 
          i              dummy 
          ia             dummy 
           
          f_n_c_ _=_ _1_2_,_ _i_n_c_l_u_d_e_ _u_s_e_r_: 
           
          monitor        result, i.e. 0 means included, 2,3,4 means not
                         included. 
          z              (call value). Contains the process name. 
          i              (call value). Device number. 
          ia             dummy 
                    \f

          f_n_c_ _=_ _1_4_,_ _e_x_c_l_u_d_e_ _u_s_e_r_:   monitor 
           
          monitor        result, i.e. 0 means excluded, 2,3,4 means not
                         excluded. 
          z              (call value). Contains the process name. 
          i              (call value). Device number. 
          ia             dummy 
                          
          The format of messages and answers used in the following 5
          functions can be found in the Monitor manual, part 2 and 3, (ref.
          2-3) and in the description of getshare6. 
           
          f_n_c_ _=_ _1_6_,_ _s_e_n_d_ _m_e_s_s_a_g_e_: 
                          
          monitor        buffer address, 0 if the buffer claim is
                         exceeded. 
          z              (call value). Contains the process name of the
                         receiving process. 
          i              (call value). The number of a share within z. The
                         share state must at call time be 0 or 1, at return
                         time it is the buffer address. The message sent is
                         given in the share descriptor. (See getshare6).
                         Note that you may change the message in the share
                         by means of the procedure setshare6. 
          ia             dummy. 
                          
                         The value of "current activity no" is used as mes-
                         sage identification. This is stored in the message
                         buffer (buffer address - 2), which later (f.ex. in
                         wait event) may supply the number of the sending
                         activity (see ref. 19, concurrent i/o transfers). 
           \f

          f_n_c_ _=_ _1_8_,_ _w_a_i_t_ _a_n_s_w_e_r_:monitor 
                          
          monitor        result, i.e. 1 means a normal answer, 2,3,4,5
                         means dummy answers. 
          z              (call value). Determines together with >i> the
                         buffer address. 
          i              (call value). The number of a share within z. The
                         share state must be the buffer address at call
                         time, at return time it is 0. 
          ia             (return value, length '= 8). The answer is stored
                         here. 
                          
                         If the program is in activity mode, and the give
                         up mask in the zone includes 1 shift 9, this
                         function will execute an implicit passivate
                         statement just before call of the monitor
                         procedure. 
                          
          f_n_c_ _=_ _2_0_,_ _w_a_i_t_ _m_e_s_s_a_g_e_: 
                          
          monitor        result, i.e. process description address of the
                         sender, positive for a normal message, negative
                         for a message from a removed process, or 0 if the
                         buffer claim is exceeded. 
          z              (return value). The process name is stored here. 
          i              (return value). Buffer address. 
          ia             (return value, length '= 8). The message is stored
                         here. 
                    
          f_n_c_ _=_ _2_2_,_ _s_e_n_d_ _a_n_s_w_e_r_: 
           
          monitor        result dummy 
          z              dummy 
          i              (call value). Buffer address. 
          ia             (call value, length '= 9). The first 8 elements
                         contain the answer, the 9th element contains the
                         result, which is 1 for a normal answer, 2,3,4,5,
                         for a dummy answer. 
           \f

          f_n_c_ _=_ _2_4_,_ _w_a_i_t_ _e_v_e_n_t_:                                                  monitor 
           
          monitor        result, i.e. 0 for a message, 1 for an answer. 
          z              (return value). The name of the sending process is
                         stored here if a message was received. 
          i              (call and return value). Last and next buffer
                         address. 
          ia             (return value, length '= 8). If a message is
                         received, it is stored here. The value of ia(1)
                         which is loaded from the message buffer (buffer
                         address - 2), indicates: 
                          
                         ia(1)'0: the activity number of the activity,
                                  which sent the message 
                         ia(1)=0: the message was sent in monitor or
                                  neutral mode 
                         ia(1)<0: the message was sent in disable mode. 
                          
                         If an answer is received, ia is dummy. In this
                         case the buffer address returned in i corresponds
                         to a message buffer address in the share state of
                         some zone (see getshare6). 
           
          f_n_c_ _=_ _2_6_,_ _g_e_t_ _e_v_e_n_t_: 
                          
          monitor        result dummy 
          z              dummy 
          i              (call value). Buffer address pointing to a
                         message. An answer must not be released in this
                         way - use wait answer (or procedure check) instead.
          ia             dummy 
           
          The format of the catalog entry tails used in the following 3
          functions is described in the File Processor manual, part 1 (ref.
          6). 
           \f

          f_n_c_ _=_ _4_0_,_ _c_r_e_a_t_e_ _e_n_t_r_y_:                                               monitor 
           
          monitor        result, i.e. 0 means entry created, 2,3,4,5,6,7 
                            means entry not created. 
          z              (call value). Contains the entry name. 
          i              dummy 
          ia             (call value, length '= 10). Contains the tail of
                         the entry.  
           
          f_n_c_ _=_ _4_2_,_ _l_o_o_k_u_p_ _e_n_t_r_y_: 
                          
          monitor        result, i.e. 0 means entry looked up, 2,3,6,7
                         means not looked up. 
          z              (call value). Contains the entry name. 
          i              dummy 
          ia             (return value, length '= 10). The tail of the
                         entry is stored here. 
           
          f_n_c_ _=_ _4_4_,_ _c_h_a_n_g_e_ _e_n_t_r_y_: 
                          
          monitor        result, i.e. 0 means changed, 2,3,4,5,6,7 means
                         entry not changed. 
          z              (call value). Contains the entry name. 
          i              dummy 
          ia             (call value, length '= 10). Contains the new tail
                          of the entry. 
                          
          f_n_c_ _=_ _4_6_,_ _r_e_n_a_m_e_ _e_n_t_r_y_: 
                          
          monitor        result, i.e. 0 means entry renamed, 2,3,4,5,6,7
                         means entry not renamed. 
          z              (call value). Contains the present entry name. 
          i              dummy 
          ia             (call value, length '= 4). Contains the new entry
                         name. 
           \f

          f_n_c_ _=_ _4_8_,_ _r_e_m_o_v_e_ _e_n_t_r_y_:                                               monitor 
                    
          monitor        result, i.e. 0 means entry removed, 2,3,4,5,6,7
                         means entry did not exist or entry is not
                         removed. 
          z              (call value). Contains the entry name. 
          i              dummy 
          ia             dummy 
                          
          f_n_c_ _=_ _5_0_,_ _p_e_r_m_a_n_e_n_t_ _e_n_t_r_y_: 
                          
          monitor        result, i.e. 0 means entry made permanent, 2,3,4,
                         5,6,7 means entry not permanent. 
          z              (call value). Contains the entry name. 
          i              (call value). Catalog key. 
          ia             dummy 
                          
          f_n_c_ _=_ _5_2_,_ _c_r_e_a_t_e_ _a_r_e_a_ _p_r_o_c_e_s_s_: 
                          
          monitor        result, i.e. 0 means area process created,
                         1,2,3,4,5,6 means process not created. 
          z              (call value). Contains the process name. 
          i              dummy 
          ia             dummy 
           
          f_n_c_ _=_ _5_4_,_ _c_r_e_a_t_e_ _p_e_r_i_p_h_e_r_a_l_ _p_r_o_c_e_s_s_: 
           
          monitor        result, i.e. 0 means process created, 1,2,3,4,5,6
                         means process not created. 
          z              (call value). Contains the process name. 
          i              (call value). Device number. 
          ia             dummy 
           \f

          f_n_c_ _=_ _5_6_,_ _c_r_e_a_t_e_ _i_n_t_e_r_n_a_l_ _p_r_o_c_e_s_s_:                                     monitor 
           
          monitor        result, i.e. 0 means process created, 1,2,3,6
                         means process not created. 
          z              (call value). Contains the process name. The
                         process will be created in the buffer area of z. 
          i              dummy 
          ia             (call value, length '= 9). Contains the parameters
                         in this way: 
                          
                         ia(1) buffer index for start of process 
                         ia(2) buffer index for last of process 
                         ia(3) buffer claim shift 12 + area claim 
                         ia(4) internal claim shift 12 + function mask 
                         ia(5) priority of the process 
                         ia(6) lower limit of max base 
                         ia(7) upper limit of max base 
                         ia(8) lower limit of std base 
                         ia(9) upper limit of std base 
                               
          f_n_c_ _=_ _5_8_,_ _s_t_a_r_t_ _i_n_t_e_r_n_a_l_ _p_r_o_c_e_s_s_: 
                          
          monitor        result, i.e. 0 means process started, 2,3,6 means
                         process not started. 
          z              (call value). Contains the process name. The
                         process must have been created inside the zone
                         buffer. 
          i              (call value). The number of a share within z. The
                         share state must at call time be 0 or 1, at return
                         time it is - process description address. 
          ia             dummy 
           \f

          f_n_c_ _=_ _6_0_,_ _s_t_o_p_ _i_n_t_e_r_n_a_l_ _p_r_o_c_e_s_s_:                                      monitor 
           
          monitor        result, i.e. 0 means stop initiated, 3,6 means
                         stop not allowed. 
          z              (call value). Determines together with i the
                         process. 
          i              (call value). The number of a share within z. The
                         share state must at call time be - process des-
                         cription address. At return time it is the buffer
                         address. Notice that the process name in z is ir-
                         relevant. 
          ia             dummy 
                          
          f_n_c_ _=_ _6_2_,_ _m_o_d_i_f_y_ _i_n_t_e_r_n_a_l_ _p_r_o_c_e_s_s_: 
                          
          monitor        result, i.e. 0 means process modified, 2,3,6 means
                         modification not allowed. 
          z              (call value). Contains the process name. 
          i              dummy 
          ia             (call value, length '= 6). Contains the modified
                         registers.  
           
          f_n_c_ _=_ _6_4_,_ _r_e_m_o_v_e_ _p_r_o_c_e_s_s_: 
                          
          monitor        result, i.e. 0 means process removed, 1,2,3,5,6
                         means removal not allowed. 
          z              (call value). Contains the process name. 
          i              dummy 
          ia             dummy 
                          
          f_n_c_ _=_ _6_6_,_ _t_e_s_t_ _e_v_e_n_t_: 
           
          monitor        result, i.e. 0 when the first event is a message,
                         1 when the first event is an answer, and -1 when
                         the event queue in the call moment is empty. 
          z              as for fnc= 24, wait event 
          i              -  -   -        -    - 
          ia             -  -   -        -    - 
           \f

                         Works as monitor (24, ...), wait event, except         monitor 
                         that no waiting takes place. 
           
          f_n_c_ _=_ _6_8_,_ _g_e_n_e_r_a_t_e_ _n_a_m_e_: 
                          
          monitor        result, i.e. 0 means name generated, 2 means name
                         not generated. 
          z              (return value). The generated name is stored
                         here. 
          i              dummy 
          ia             dummy 
           
          f_n_c_ _=_ _7_0_,_ _c_o_p_y_ _c_o_r_e_ _a_r_e_a_: 
                          
          monitor        result of the copying, 0 meaning area copied, 2 or
                         3 area not copied. 
          z              (call value). Contains the area to or from which
                         the copying will take place. The limits of the
                         copying are given by the zone parameters record
                         base and last halfword. 
          i              (call value). The buffer address of the input or
                         output message defining sender>s copy area.
          ia             (return value, length '= 9). Contains information
                         about the copying almost ready to be used by send
                         answer (see ref. 3): 
                          
                         ia(1) should then be set by the user 
                         ia(2) if result <' 0 then 0 else halfwords copied 
                         ia(3) if result <' 0 then 0 else chars copied 
                         ia(9) if result = 3 then 3 else 1. 
                               \f

          f_n_c_ _=_ _7_2_,_ _s_e_t_ _c_a_t_a_l_o_g_ _b_a_s_e_:                                            monitor 
                               
          monitor        result, 0 means catalog base set, 2,3,4,6 means
                         catalog bas not set. 
          z              (call value). Contains the name of a child process
                         or a null-name, meaning own process. 
          i              dummy 
          ia             (call value, length '= 2). Contains the base to be
                         set. 
                              ia(1) lower limit of the base 
                              ia(2) upper limit of the base 
           
          f_n_c_ _=_ _7_4_,_ _s_e_t_ _e_n_t_r_y_ _b_a_s_e_: 
                          
          monitor        result, 0 means entry base set, 2,3,4,5,6,7 means
                         entry base not set. 
          z              (call value). Contains the entry name. 
          i              dummy 
          ia             (call value, length '= 2). Contains the entry base
                         to be set, as for the fnc = 72, set catalog base. 
           
          f_n_c_ _=_ _7_6_,_ _l_o_o_k_u_p_ _h_e_a_d_ _a_n_d_ _t_a_i_l_: 
           
          monitor        result, 0 means entry looked up, 2,3,6,7 means
                         entry not look up. 
          z              (call value). Contains the entry name. 
          i              dummy 
          ia             (return value, length '= 17). The head and tail of
                         the entry is stored here. (The format is described
                         in ref. 2). 
           \f

          f_n_c_ _=_ _7_8_,_ _s_e_t_ _b_a_c_k_i_n_g_ _s_t_o_r_a_g_e_ _c_l_a_i_m_s_:                                 monitor 
           
          monitor        result, 0 means claims set, 1,2,3,6 means claims
                         not set. 
          z              (call value). Contains the name of a child
                         process. 
          i              dummy 
          ia             (call value, length '= 4 + 2*no of keys). The
                         first 4 elements contain the name of the bs
                         document 
                              ia(5) entry   claim, key 0 
                              ia(6) segment claim, key 0 
                                ....... 
                              ia(5+2*max key) entry claim, max key 
                              ia(6+2*max key) segment claim, max key 
           
          f_n_c_ _=_ _8_0_,_ _c_r_e_a_t_e_ _p_s_e_u_d_o_ _p_r_o_c_e_s_s_: 
                          
          monitor        result, 0 means pseudo process created, 1,2,3,6
                         means pseudo process not created. 
          z              (call value). Contains the name of the pseudo
                         process. 
          i              dummy 
          ia             dummy 
                          
          f_n_c_ _=_ _8_2_,_ _r_e_g_r_e_t_ _m_e_s_s_a_g_e_: 
                          
          monitor        no result from this operation. Misuse will give
                         break 6. 
          z              (call value). Determines together with >i> the
                         buffer address of the message to be regretted. 
           i              (call value). The number of a share within z. The
                         share state must be the buffer address at call
                          time. At return it is 0. 
           ia             dummy 
           \f

          f_n_c_ _=_ _9_0_,_ _p_e_r_m_a_n_e_n_t_ _e_n_t_r_y_ _i_n_ _a_u_x_i_l_i_a_r_y_ _c_a_t_a_l_o_g_:                        monitor 
              
          monitor        result, 0 means entry made permanent, 2,3,4,5,6,7
                         means entry not made permanent. 
          z              (call value). Contains the entry name. 
          i              (call value). The catalog key. 
          ia             (call value, length '= 4). Contains the name of
                         the bs document. 
                          
          f_n_c_ _=_ _1_0_2_,_ _p_r_e_p_a_r_e_ _b_a_c_k_i_n_g_ _s_t_o_r_a_g_e_ 
           
          monitor        result, i.e. 0 means chaintable allocated,
                         1,2,3,4,5,6,7 means chaintable not allocated. 
          z              (call value), the zone record holds the
                         chainhead. 
          i              dummy 
          ia             dummy 
           
          f_n_c_ _=_ _1_0_4_,_ _i_n_s_e_r_t_ _e_n_t_r_y_ 
           
          monitor        result, i.e. 0 means entry inserted in maincata-
                         log, 1,2,3,4,5,6,7 means entry not inserted in
                         maincatalog. 
          z              (call value), the zone record holds the
                         chainhead. 
          i              dummy 
          ia             (call value, length '= 17), contains head and tail
                         of the entry. 
           
          f_n_c_ _=_ _1_0_6_,_ _i_n_s_e_r_t_ _b_a_c_k_i_n_g_ _s_t_o_r_a_g_e_ 
           
          monitor        result, i.e. 0 means document included, 1,2,4,6
                         means document not included. 
          z              dummy 
          i              dummy 
          ia             (call value, length '= 21), contains the document
                         name in word 18,19,20, and 21. 
           \f

          f_n_c_ _=_ _1_0_8_,_ _d_e_l_e_t_e_ _b_a_c_k_i_n_g_ _s_t_o_r_a_g_e_                                      monitor 
           
          monitor        result, i.e. 0 means document removed, 1,2,4,5,6
                         means document not removed. 
          z              dummy 
          i              dummy 
          ia             (call value, length'=21), contains the document
                         name in word 18,19,20, and 21. 
           
          f_n_c_ _=_ _1_1_0_,_ _d_e_l_e_t_e_ _e_n_t_r_i_e_s_ 
           
          monitor        result, i.e. 0 means entries deleted, 1,2,3,4,6
                         means not deleted. 
          z              dummy 
          i              dummy 
          ia             (call value, length '= 21) contains the document
                         name in word 18,19,20, and 21. 
                          
          f_n_c_ _=_ _1_1_2_,_ _c_o_n_n_e_c_t_ _m_a_i_n_ _c_a_t_a_l_o_g_ 
           
          monitor        result, i.e. 0 means catalog connected,
                         1,2,3,4,5,6,7 means catalog not connected. 
          z              (call value), zone record holds the chainhead. 
          i              dummy 
          ia             (call value, length '= 4), contains the catalog
                         name. 
           
          f_n_c_ _=_ _1_1_4_,_ _r_e_m_o_v_e_ _m_a_i_n_ _c_a_t_a_l_o_g_ 
                          
          monitor        result, i.e. 0 means main catalog removed, 7 means
                         main catalog not removed. 
          z              dummy 
          i              dummy 
          ia             dummy 
           \f

          f_n_c_ _=_ _1_2_0_,_ _c_r_e_a_t_e_ _a_u_x_ _e_n_t_r_y_ _a_n_d_ _a_r_e_a_ _p_r_o_c_e_s_s_                           monitor 
                          
          monitor        result, i.e. 0 means entry and area process
                         created, 1,2,3,4,5,6 means entry and area process
                         not created. 
          z              (call value), contains the area process name. 
          i              dummy 
          ia             (call value), length '= 21), contains head and
                         tail in word 1 to 17, and the document name in
                         word 18 to 21. 
           
          f_n_c_ _=_ _1_2_2_,_ _r_e_m_o_v_e_ _a_u_x_ _e_n_t_r_y_ 
                          
          monitor        result, i.e. 0 means entry removed, 1,2,3,6 means
                         entry not removed. 
          z              dummy 
          i              dummy 
          ia             (call value, length '= 21), contains head and tail
                         in word 1 to 17 and the document name in word 18
                         to 21. 
           
          If the requirements stated above are not fulfilled, or if the
          situation termed >parameter error> in ref. 2 occurs, the run will
          be terminated with an alarm. Values of fnc not mentioned above
          will also terminate the run. 
                               
          E_x_a_m_p_l_e_ _1_:     C_r_e_a_t_e_ _a_ _b_a_c_k_i_n_g_ _s_t_o_r_a_g_e_ _a_r_e_a_ 
                          
                         A backing storage area sldata3 of s segments
                         may be created and then used like this: 
           \f

                         begin zone z(512,1,stderror);                           monitor 
                         integer array tail(1:10); 
                         integer i; 
                         open(z,4,<:sldata3:',0); 
                         <* The zone contains now the document name. The 
                             document is not initialized in case of kind=4*'
                         tail(1):= s;  
                         tail(2):= 1; <*preferably a disc area*' 
                         for i:= 3 step 1 until 10 do tail(i) := 0; 
               tail(6):= systime (7,0, 0.0); <*shortclock*' 
                         if monitor(40<*create _entry*',z,0,tail) ' 0 then
                           error(1); 
                         outrec(z,...); 
                          
          E_x_a_m_p_l_e_ _2_:     S_c_o_p_e_ _u_s_e_r_ _o_f_ _a_n_ _a_r_e_a_: 
                          
                         The scope user function consists of 2 steps. First
                         the area is made permanent with catalog key 3.
                         Now, as key is '= min global key (see ref. 2), the
                         entry base may be set to the user base of the
                         process. 
                         Let the zone z be opened to the area to be
                         scoped. 
                          
                         system(11)bases:(i,ia); 
                         ia(1):= ia(5); ia(2):= ia(6); <* fetch the user base;*'
                         if monitor(50)permanent entry:(z,3,ia) <' 0 then error(1) 
                         else 
                         if monitor(74)set _base:(z,0,ia) <' 0 then error(2)
                         else ... 
           
          E_x_a_m_p_l_e_ _3_:     F_i_n_d_ _s_c_o_p_e_ _o_f_ _a_n_ _e_n_t_r_y_: 
                          
                         As the catalog base of an internal process and of
                         a catalog entry may use almost the full integer
                         range they must be handled as longs when relations
                         of type <= or '= between them are calculated, in
                         order to prevent overflow. 
                          \f

               system(11)bases:(i,bases);                                       monitor 
               monitor(76 <*head _and _tail*', z,0,entry) <' 0 
                    then goto error; 
               case entry(1) extract 3 + 1 of 
               begin 
                
                 <*key 0, maybe temp *' 
                 if entry(2) = bases(3) and 
                    entry(3) = bases(4) 
                 then scope:= 1 <*temp*' 
                 else scope:= 6; <*undef*' 
                     
                 <*key 1 *' 
                 scope:= 6; <*undef*' 
                     
                 <*key 2, maybe login *' 
                 if entry(2) = bases(3) and 
                    entry(3) = bases(4) 
                 then scope:= 2 <*login*' 
                 else scope:= 6; <*undef*' 
                  
                 <*key 3, user, project, or system *' 
                 begin 
                   l1:= entry(2); l2:= entry(3); 
                   if l1 = bases(5) and 
                      l2 = bases(6) then scope:= 3 <*user*' 
                   else 
                   if l1 = bases(7) and 
                      12 = bases(8) then scope:= 4 <*project*' 
                   else 
                   if l1 <= extend bases(7) and 
                      l2 '= extend bases(8) then scope:= 5 <*system*' 
                   else scope:= 6; <*undef*' 
                 end 
                
               end case; 
               write(out,<:the scope is: :',case scope of( 
                   <:temp:',<:login:',<:user:', 
                   <:project:',<:system:',<:***, i.e. undef:')); 
                   \f

          E_x_a_m_p_l_e_ _4_:                                                            monitor 
           
          G_e_t_ _t_h_e_ _c_l_a_i_m_s_ _o_f_ _a_ _p_r_o_c_e_s_s_ _o_n_ _a_ _g_i_v_e_n_ _b_s_-_d_e_v_i_c_e_ 
           
          boolean procedure claimproc 
               (keyno,bsno,bsname,entries,segm,slicelength); 
          value keyno; 
          integer keyno,bsno,entries,segm,slicelength; 
          long array bsname; 
          <* 
          claimproc   (return, boolean) true if bsno'=-1 and bsno <= max _bsno and 
                      keyno is legal else false. If claimproc is false then 
                      all return parameters are zero. 
          keyno       (call, integer)          0=temp 
                                               2=login 
                                               3=user/project 
          bsno        (call/return, integer) if call value is -1 then return 
                      value is main bsdevice number, else bsno is unchanged 
          bsname      (return, long array 1:2) name of called device 
          entries     (return, integer) no. of entries of key=keyno on called device 
          segm        (return, integer) no. of segm. of key=keyno on called device 
          slicelength (return, integer) slicelength on called device 
          *' 
           
          begin 
          integer bsdevices,firstbs,ownadr,mainbs,i; 
          long array field name; 
          integer array core(1:18); 
           
          system(5,92,core); 
          bsdevices:=(core(3)-core(1))//2; 
          firstbs:=core(1); 
          mainbs:= core(4); 
          ownadr:=system(6,i,bsname); 
          if bsno<-1 or bsno'=bsdevices or 
            keyno<'0 and keyno<'2 and keyno<'3 then 
          begin 
           \f

                    claimproc:=false; goto exitclaim                              monitor 
                 end; 
                 claimproc:=true; 
                 begin integer array nametable(1:bsdevices); 
                   name:=18; 
                   system(5,firstbs,nametable); 
                   if bsno= -1 then <*find main device number*' 
                     for bsno:= bsno + 1 while nametable(bsno+1) <' mainbs do; 
                   system(5,nametable(bsno+1)-36,core); <*get chaintable*' 
                   if core(10)=0 then goto exitclaim; 
                   bsname(1):=core.name(1); bsname(2):=core.name(2); 
                   slicelength:=core(15); 
                   system(5,ownadr+core(1),core); <*get process description*' 
                   entries:=core(keyno+1) shift (-12); 
                   segm:=core(keyno+1) extract 12 * slicelength; 
                 end; 
                 if false then 
                 begin 
               exitclaim: 
                   entries:=segm:=slicelength:=0; 
                   bsname(1):=bsname(2):=0; 
                 end; 
                 end claimproc;
                                   
Claims on a specific device are found as follows: 
 
bsno:=-1; 
for bsno:=bsno+1 while 
    claimproc(keyno,bsno,bsname,entries,segm,slicelength) 
    and -,(searchname(1)=bsname(1) and searchname(2)=bsname(2)) do; 
 
Max claims are found as follows: 
 \f

          maxentr:=max:=maxslice:=0;                                             monitor 
            maxbs(1):=maxbs(2):=0; 
          bsno:=-1; 
          for bsno:=bsno+1 while 
              claimproc(keyno,bsno,bsname,entries,segm,slicelength) do 
          if entries'0 and segm'max then 
          begin 
            maxentr:=entries; max:=segm; maxslice:=slicelength; 
            maxbs(1):=bsname(1); maxbs(2):=bsname(2); 
          end; 
                    
                   E_x_a_m_p_l_e_ _5_: R_e_n_a_m_i_n_g_ _a_n_ _e_n_t_r_y_ 
                
          The procedure renames a catalog entry. The procedure works iden-
          tical to the utility program rename, with the extension that a
          work-name may be returned. 
           
          integer procedure renameproc (oldname, newname); 
          long array oldname, newname; 
          <* 
             renameproc  (return integer)     0  ok 
                                              1  new name exists already
                                              2  cat i/o error 
                                                 document not mounted or 
                                                 document not ready 
                                              3  oldname not found 
                                              4  name protected 
                                              5  name in use 
                                              6  name format illegal 
                                              7  catalog inconsistent
                                               
             oldname     (call  long array)   contains old name 
              
             newname     (call  long array)   contains new name or <::'. 
                                              if newname(1)=long<::' then
                                              newname is a return parameter,
                                              containing a wrk-name. 
          '* 
           \f

          begin                                                                  monitor 
            integer i; boolean wrk; 
            long array field laf; 
            zone zhelp(1, 1, stderror); 
            integer array ia(1:20); 
             
            wrk:=newname(1)=long<::'; 
            if wrk then 
            begin 
          generate _next: 
              monitor(68<*generate*', zhelp, 0, ia); 
              getzone6(zhelp, ia); 
              laf:=2; 
              newname(1):=ia.laf(1); newname(2):=ia.laf(2); 
            end; 
             
            laf:=0;
            ia.laf(1):=newname(1); 
            ia.laf(2):=if newname(1) extract 8 = 0 then long<::' 
                       else newname(2); 
            open(zhelp, 0, oldname, 0); 
            renameproc:= i:= monitor(46<*rename*', zhelp, 0, ia); 
            if i=3 then 
            begin <*oldname not found, or newname already exists*' 
              i:=monitor(42<*lookup*', zhelp, 0, ia); 
              if i=0 then 
              begin 
                if wrk then goto generate _next else renameproc:=1 
              end; 
            end 
          end renameproc; 
                    \f

                   E_x_a_m_p_l_e_ _6_: L_i_s_t_i_n_g_ _o_f_ _a_n_ _e_n_t_r_y_ _t_a_i_l_                                   monitor 
           
          Monitor 42, lookup entry, will place the catalog tail in an
          array, which can be listed by the following procedure: 
           
          procedure list _tail (zout, tail); 
          zone zout; integer array tail; 
           
          <*  the procedure lists the contents of array tail as a catalog entry
           
              zout       (return, zone)          zone for output 
           
              tail       (call, integer array)   contains entry tail 
          *' 
           
          begin 
            integer n,i; 
            long array field docname; 
            real r; 
             
            docname:=2; 
            n:=tail(1); 
            if n'=0 then write(zout,<<z',n) else 
              write(zout,<<z',n shift (-12) extract 12,<:.:',n extract 12); 
            n:=tail(2); 
            if n=0 or n=1 then write(zout,n) else 
              write(zout,<: :',tail.docname); 
            n:=tail(9) shift (-12); 
            i:=6; 
            if -,(n=4 or n'=32) and tail(6)<'0 then 
              begin 
                write(out),<:d.:',<<zddddd.dddd', 
                  systime(6, tail(6), r)+r/1000000); 
                i:= 7; 
              end; 
            while i<11 do \f

                     begin                                                               monitor 
              n:=tail(i); 
              if n'= 0 and n<4096 then write(zout,<<z',n) else 
                write(zout,<<z',n shift (-12) extract 12,<:.:',<<z',n extract 12); 
              i:= i + 1; 
            end; 
          end list _tail; 
             
          E_x_a_m_p_l_e_ _7_:  C_r_e_a_t_i_n_g_ _a_ _n_e_w_ _e_n_t_r_y_ 
           
          The procedure creates a new catalog entry with scope temp or
          changes an already existing entry (with scope temp) according to
          the parameters. The procedure works identical to the utility
          program set, with the extension that a work-name may be
          returned. 
           
          integer procedure setproc (name, tail); 
          long array name; integer array tail; 
          <* 
              setproc (return, integer)     0  ok 
                                           1  change kind impossible 
                                           2  bs device unknown 
                                             3  change bs device impossible
                                            4  no resources 
                                            5  in use 
                                            6  name format illegal 
                                            7  catalog inconsistent 
                                              
               name    (call, long array)   contains the entry name. 
                                            If name(1)=long<::' a wrkname is
                                             created and name is returnparameter.
                                             
               tail    (call, integer array) contains the entry tail 
                                             1     size or modekind 
                                             2:5   docname 
                                             6     shortclock, in case shortclock
                                                   is wanted in the entry
                                             7:10  remaining tail 
         *' \f

         begin monitor
           integer i; 
           long array field laf; 
           zone zhelp(1,1,stderror); 
           integer array ia(1:20); 
          
           open(zhelp, 0, name ,0); 
           for i:= 1 step 1 until 10 do ia(i):= tail(i); 
              <*tail could possible be a fielded array. As fielding does
                not work in monitor the contents of tail is moved to the
                non-fielded array ia*' 
              setproc:= i:= monitor(40<*create*',zhelp,0,ia); 
              
              if name(1)=long<::' then 
              begin <*get wrkname*' 
                getzone6(zhelp,ia); 
                laf:=2; 
                name(1):=ia.laf(1); 
                name(2):=ia.laf(2); 
              end; 
    if i=3 then 
    begin <*entry exist*' 
                i:=monitor(42<*lookup*',zhelp,0,ia); 
                if i<'0 then 
      begin  
                  setproc:=7; goto exit _setproc 
                end; 
      if tail(1)<0 or ia(1)<0 then 
      begin 
                  if tail(1)'=0 or ia(1)'=0 then 
        begin  
                    setproc:=1; goto exit _setproc  
                  end; 
        goto change 
                end; 
                if tail(2)=0 or tail(2)=1 then goto change;
      if tail(3) extract 8=0 then tail(4):=tail(5):=0; 
      if tail(2)<'ia(2) or tail(3)<'ia(3) or 
                   tail(4)<'ia(4) or tail(5)<'ia(5) then \f

                begin                                                           monitor 
                  setproc:=3; goto exit _setproc  
                end; 
             
            change: 
                for i:= 1 step 1 until 10 do ia(i):= tail(i); 
                i:=monitor(44<*change*',zhelp,0,ia); 
                if i=6 then i:=4; 
                setproc:=i; 
              end entry exists; 
             
            exit _setproc: 
            end setproc; 
             
            In case an array containing head _and _tail exists, it may be used as
            follows: 
             
                iaf:= 14;  setproc(name,head _and _tail.iaf); 
           \f

          E_x_a_m_p_l_e_ _8_: C_h_a_n_g_i_n_g_ _a_n_ _e_n_t_r_y_                                          monitor 
           
          The procedure changes the specified entry. The procedure works 
          identical to the utility program changeentry. 
                
          integer procedure changeentryproc (name, tail); 
          long array name;    integer array tail; 
          <* 
               changeentryproc (return, integer) 
                               0  ok 
                               1  change kind impossible 
                               2  cat i/o error, doc. not mounted or not ready
                               3  name not found 
                               4  name protected 
                               5  name in use 
                               6  name format illegal 
                               7  catalog inconsistent 
                               8  change bs device impossible 
                               9  claims exceeded 
                                
               name            (call, long array)      contains the entry name 
                
               tail            (call, integer array)   contains new entry tail 
                     
          *' 
          begin 
            integer i; 
            integer array ia(1:10); 
            zone zhelp(1,1,stderror); 
           
            open(zhelp,0,name,0); 
            i:= monitor(42<*lookup*',zhelp,0,ia); 
            if i<'0 then 
            begin 
              changeentryproc:=i; goto exit _changeentryproc  
            end; 
            if tail(1)<0 or ia(1)<0 then 
            begin 
              if tail(1)'=0 or ia(1)'=0 then 
              begin 
                changeentryproc:= 1; goto exit _changentryproc 
              end; 
              goto change; 
            end; \f

                     if tail(2)=0 or tail(2)=1 then goto change;                         monitor
            if tail(3) extract 8=0 then tail(4):=tail(5):=0; 
            if tail(2)<'ia(2) or tail(3)<'ia(3) or 
               tail(4)<'ia(4) or tail(5)<'ia(5) then 
            begin 
              changeentryproc:=8; goto exit _changeentryproc 
            end; 
          change: 
            <*tail could be a fielded array, cf.example 7*' 
            i:=monitor(44<*change*',zhelp,0,ia); 
            if i=6 then i:=9; 
            changeentryproc:=i; 
             
          exit _changeentryproc: 
            end changeentryproc; 
           
          In case the programmer only wants to change shortclock and maybe
          size, it may be done as follows: 
             
            begin 
              integer i; 
              zone z(128,1,stderror); 
              integer array ia(1:10); 
             
              open(z,4,<:pip:',0); 
            ... 
            ... 
              i:=monitor(42<*lookup*',z,0,ia); 
              if i<'0 then 
              begin <* alarm, see lookupproc (ex. 9)*' end; 
              ia(1):=36;  <*new size*' 
              ia(6):= systime (7, 0, 0.0); <*shortclock*' 
              i:=monitor(44<*change*',z,0,ia); 
              if i<'0 then 
              begin <* alarm, as changeentryproc, except 6=claims 
                       exceeded *' 
              end; 
            ... 
               \f

          E_x_a_m_p_l_e_ _9_: L_o_o_k_u_p_ _o_f_ _a_n_ _e_n_t_r_y_                                         monitor 
           
          The procedure performs a lookup of the specified name. 
           
          integer procedure lookupproc (scope, name, tail); 
          long array scope, name; 
          integer array tail; 
          <* 
              lookupproc  (return, integer)
                
                           0  found 
                           1  the call param scope does not contain a legal 
                              scope name 
                           2  cat i/o error 
                           3  not found 
                           6  name format illegal 
               
              scope       (call, long array) 
                            
                           contains the name of a scope or <::'. 
                           If scope(1)=long <::' then scope will 
                           be a return parameter which may be <:***:' 
                            
               name        (call, long array)   contains the name of the entry 
                            
               tail        (return, integer array)  
                           contains tail of the entry: 
                           1     size or modekind 
                           2:5   docname 
                           6     shortclock, in case shortclock is found in the
                                entry 
                          7:10  remaining tail 
          *' 
           \f

               integer procedure lookupproc (scope, name, tail); monitor
               long array scope, name; 
               integer array tail; 
                
               begin 
                 integer scopeno, permkey, i; 
                 long    l1, l2; 
                 zone    zhelp(1, 1, stderror); 
                 integer array bases(1:8), ba(1:2), head _and _tail(1:17); 
                 real array field raf; 
                  
                 procedure return (val); 
                 value val; integer val; 
                 begin 
                   lookupproc:= val; 
                   for i:= 1 step 1 until 10 do tail(i):= 0; 
                   if scopeno <' 6 then reset _base; 
                   goto exit _lookupproc; 
                 end; 
                  
                 procedure reset _base; 
                 begin 
                   close(zhelp,false); 
                   open(zhelp,0,<::',0); 
                   monitor (72<*set bases*', zhelp, 0, bases); 
                 end; 
                  
                 lookupproc:= 0; 
                 l1:= scope(1) shift (-8) shift 8; <*first 5 chars*' 
                 scopeno:= 6; 
                 for i:= 0 step 1 until 5 do 
                   if l1 = long (case i+1 of ( 
                           <::',     <:temp:', <:login:', 
                           <:user:', <:proje:' <:syste:')) 
                   then scopeno:= i; 
                 if scope = 6 then return(1); <*illegal scope specified*' 
                  \f

                          system (11<*catalog bases*', 0, bases);       monitor 
                    if scopeno < 3 then 3 else 
                     if scopeno = 3 then 5 else 7; 
                 ba(1):= bases(i); ba(2):= bases(i+1); 
                 open(zhelp,0,<::',0); 
                 monitor (72<*set cat base*', zhelp,0,ba); 
                 close (zhelp, true); 
                 open (zhelp,0,name,0); 
                 i:= monitor (76<*head _and _tail*', zhelp,0,head _and _tail); 
                 if i<'0 then return(i); 
                  
                 if scopeno'0 and scopeno<5 and 
                   (head _and _tail(2) <' ba(1) or 
                    head _and _tail(3) <' ba(2)) 
                 then return(3); <*entry not found*' 
                  
                 permkey:= head _and _tail(1) extract 3; 
                 if scopeno=1 and permkey<'0 or 
                    scopeno=2 and permkey<'2 or 
                    scopeno'2 and permkey<'3 
                 then return(3); <*entry not found*' 
                  
                 if scopeno=5 then 
                 begin 
                   if -, (head _and _tail(2) < ba(1) or 
                          head _and _tail(3) ' ba(2)) 
                   then return(3); <*entry not found*' 
                 end; 
                  \f

                 <*now the entry has been found, find the scopemonitor 
                   if this was not specified*' 
                 if scopeno = 0 then 
                 begin 
                   l1:= head _and _tail(2); 
                   l2:= head _and _tail(3); 
                   case permkey+1 of 
                   begin 
               <*0*' if l1 = bases(3) and 
                        l2 = bases(4) 
                     then scopeno:= 1 <*temp*' 
                     else scopeno:= 6;<*undef*' 
                      
               <*1*' scopeno:= 6;<*undef*' 
                      
               <*2*' if l1 = bases(3) and 
                        l2 = bases(4) 
                     then scopeno:= 2 <*login*' 
                     else scopeno:= 6;<*undef*' 
                      
               <*3*' if l1 = bases(5) and 
                        l2 = bases(6) then scopeno:= 3 <*user*' 
                     else 
                     if l1 = bases(7) and 
                        l2 = bases(8) then scopeno:= 4 <*project*' 
                     else 
                     if l1 <= extend bases(7) and 
                        l2 '= extend bases(8) then scopeno:= 5 <*system*' 
                     else scopeno:= 6;<*undef*' 
                   end case; 
                    
                   raf:= 0 
                   scope(2):= 0; 
                   movestring (scope.raf, 1, case scopeno of ( 
                               <:temp:', <:login:', <:user:', 
                               <:project:',<:system:',<:***:')); 
                 end scopeno = 0; 
                  \f

                 <*assign the catalog tail to the return parameter*'           monitor 
                 for i:= 1 step 1 until 10 do 
                   tail(i):= head _and _tail(i+7); 
                          reset _base; 
                  
               exit _lookupproc: 
               end lookupproc; 
           
          If the entry of smallest scope should be looked up, this
          procedure is not necessary, as this can be done by the following
          procedure or similar statements: 
           
          integer procedure xlookup (name, tail); 
          long array name; integer array tail; 
          begin 
            zone zhelp(1,1,stderror); 
            integer i; 
            open(zhelp,0, name ,0); 
            xlookup:= i:= monitor(42<*lookup*',zhelp,0,tail); 
            if i<'0 then 
              for i:=1 step 1 until 10 do tail(i):=0; 
          end xlookup 
           
          where xlookup will contain the value corresponding to 
          lookupproc with the exception of the value 1. 
                    
           
          E_x_a_m_p_l_e_ _1_0_: W_a_i_t_ 
           
          The procedure waits as many seconds as specified by the
          parameter. 
           
          procedure pause (time); 
          integer          time ; 
          begin 
            integer array ia(1:20); 
            zone          clock(1,1, stderror); 
             \f

            open (clock, 2, <:clock:', 1 shift 9);                              monitor 
            getshare6(clock, ia, 1); 
            ia(4):= 0; 
            ia(5):= time; 
            setshare6(clock, ia, 1); 
            if monitor (16<*send message*), clock, 1, ia) = 0 then 
              system(9,6,<:<10'break:'); <*buffer claim exceeded*' 
            monitor (18<* wait answer*', clock, 1, ia); 
          end pause; 
           
          E_x_a_m_p_l_e_ _1_1_: See example 4 of system. 
           
           \f

F_       2_._8_9_ _ _ _ _ _ _m_o_v_e_s_t_r_i_n_g_                                                2.89 movestring 
           
          This integer standard procedure is used for moving textstrings 
          of various kind. 
           
          C_a_l_l_:          movestring (ra, i, st); 
           
                         movestring (return value, integer); the number of
                          elements in ra to which a string port-
                          ion has been assigned. It is  negative
                          if the string was too  big for  the
                          array. 
               ra         (return value, real array or zone). The
                          string is stored in ra(i), ra(i+1), and
                          so on. For arrays of more dimensions
                          the lexicographical ordering is used. 
               i          (call value, integer); see ra above. 
               st         (call value, string); layout or text-
                          string terminated by a NULL character. 
                          
               Moves either a layout or a whole textstring until
               a null character is encountered or the array is
               filled. The various string expressions are defined
               in ref. 15. 
 
E_x_a_m_p_l_e_ _1_:     A textstring can be inserted in a long array when
               using a real array field: 
                
               begin 
                 long array la(1:10); 
                 real array field raf; 
                 ... 
                 raf:= 0; 
                 movestring (la.raf, 1, <:some text:'); 
                  
                  \f

         2_._9_0_ _ _ _ _ _ _m_u_l_t_i_p_l_y_ _(_*_)_ 2.90 multiply
           
          This delimiter, which is an arithmetic operator, yields the
product of the two operands. 
           
          S_y_n_t_a_x_:        <operand1' * <operand2' 
           
          P_r_i_o_r_i_t_y_:      3 
                          
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer, long, or real. 
           
          R_e_s_u_l_t_ _t_y_p_e_:   <integer' * <integer' is of type integer 
                         <integer' * <long'    -  -  -    long 
                         <integer' * <real'    -  -  -    real 
                         <long'    * <integer' -  -  -    long 
                         <long'    * <long'    -  -  -    long 
                         <long'    * <real'    -  -  -    real 
                         <real'    * <integer' -  -  -    real 
                         <real'    * <long'    -  -  -    real 
                         <real'    * <real'    -  -  -    real 
                          
          S_e_m_a_n_t_i_c_:      The operation may include a type conversion.
                         Real values are represented with a relative pre-
                         cision of about 3>-11 (cf. ref. 15). This means
                         that real variables holding an integral value is
                         represented exact in the interval -2**35 <= real
                         <= 2**35-1. 
                         As multiplication of long values includes
                         call of subroutines (cf. ref. 15), and cannot
                         be performed by built-in operations, a
                         representation of certain long variables in
                         real variables may be advantageous (cf. ref.
                         15). 
                          
          E_x_a_m_p_l_e_ _1_:     i:= 5*a; 
               j:= i*(b+4); 
               r:= k * z.laf(4) * arr(7*c) 
                
 \f

F_       2_._9_1_ _ _ _ _ _ _n_e_w_a_c_t_i_v_i_t_y_ 2.91 newactivity
           
          This long standard procedure initializes an e_m_p_t_y_ _a_c_t_i_v_i_t_y_ with a
          procedure (a coroutine), and starts the activity. 
           
          C_a_l_l_:     new _activity (actno, virt, proc, params); 
                     
                    new _activity   (return value, long). The value is
                                   composed by two integers: 
                                      activityno shift 24 add cause 
                                   describing the way in which newactivity
                                   returns (see below). 
                    actno          (call value, integer). The identifica-
                                   tion of the activity to be initialized.
                                   The activity must be e_m_p_t_y_. 
                    virt           (call value, integer). Determines
                                   whether or not the designated activity
                                   will share stack area with another
                                   activity: 
                                   virt = 0: The designated activity will
                                   n_o_t_ be virtual, i.e. it will have its
                                   own stack area. 
                                   virt ' 0: must be a legal activity
                                   number. The activity: actno, will be
                                   virtual, i.e. share stack area with the
                                   activity numbered: virt. If virt <'
                                   actno virt must define a non-empty
                                   virtual activity. 
                    proc           (call value, procedure). The activity
                                   actno is initialized with this
                                   procedure, wich is called with the
                                   actual parameters stated in the
                                   parameter list params. 
                    params         (call values). A (possibly empty) list
                                   of parameters in the call of proc. 
                                    
          Storage resources for variables etc. are allocated in the stack,
          the top of which is defined by a running system variable:
          last _used. \f

                   The stack administration is for activity purposes supplied withnewactivity
          another running system variable: max _last _used, defining the
          upper limit for last used. Stack overflow is detected by compari-
          son of these two variables. 
           
          To each activity is allocated a maximal contiguous stack area,
          defined by the pair: (initial _last _used, max _last _used) for the
          activity. The very first call of new _activity for each activity,
          determines the values of the corresponding: (initial _last _used,
          max _last _used). When an activity is entered (by activate), the
          running system uses the stack allocated to the activity. When an
          activity returns to the monitor block (by passivate), the running
          system uses the stack allocated to the monitor block. 
           
          F_u_n_c_t_i_o_n_: new _activity must be called at the m_o_n_i_t_o_r_ _b_l_o_c_k_ level
                    (cf. procedure activity). 
                    The execution of: 
                        result := new _activity (actno, virt, proc, params);
                    now proceeds as follows: 
                     
                    1)  If the block level of the call is not the monitor
                        block level, new _activity terminates with an
                        alarm. 
                     
                    2)  If the program is not in monitor mode, the run is
                        terminated with an alarm. 
                         
                    3)  If actno < 1 or actno ' max _no _of _activities or
                        virt < 0 or virt ' max _no _of _activities, the run is
                        terminated with an alarm. 
                         
                    4)  If the activity actno, is not empty, new _activity
                        returns with the result = actno shift 24 add (-1). 
                         
                    5)  If the stack area is not allocated, the actual
                        value of last _used (monitor last used) defines the
                        stack and initial _last _used for the activity. 
                         \f

                             6)  If the activity is to be virtual, and shared vir-   newactivity
                        tual occupies the stack area, the used part of the
                        stack area is transferred to the virtual storage.
                        If, however, the shared virtual waits for an i/o
                        operation to complete, newactivity returns with the
                        result: 
                             shared _virtual shift 24 add (-2). 
                              
                    7)  The procedure: proc, is called with params as ac-
                        tual parameters, and the program is now in activity
                        mode. It is n_o_t_ _c_h_e_c_k_e_d_, that this parameter list
                        corresponds to the formal specifications in the
                        procedure declaration. The procedure returns: 
                        -    executing a passivate statement or 
                        -    leaving through its final end or 
                        -    because of a runtime alarm. 
                        defining the value of: result. At return, the
                        program is back in monitor mode. 
                         
                    8)  If a stack area was not allocated, when newactivity
                        was called, the following is done at return from
                        newactivity: The maximal last _used appearing during
                        the execution in activity mode is selected to re-
                        present max _last _used of the activity, and at the
                        same time last _used of the monitor block. 
                         
                    9)  If the activity is to be virtual, a record in the
                        virtual storage is reserved to hold the stack area
                        of the activity. 
                        The transfers between stack and virtual storage
                        (swops) are initiated by newactivity or activate,
                        when an activity, not at present occupying the
                        stack area, is to be activated (restarted). The
                        virtual storage is the same as used for context
                        blocks. 
                                  \f

                             If the designated activity is empty, but has been in-newactivity
                    itialized before in a previous call of new _activity,
the stack area is a priori fixed by limits defined in
the very first call of new _activity for the designated
activity. A non-empty activity becomes empty, if it: 
                     
                         -   leaves throuth its final end or 
                         -   terminates with a runtime alarm. 
                          
          R_e_s_u_l_t_ _v_a_l_u_e_s_: The return values activityno shift 24 add cause
                         have the following meaning: 
                          
                         activity _no:   The identification of the activity
                                        causing the return. In case of
                                        cause = -2, the activity waiting
                                        for an i/o operation to complete. 
                                         
                         cause indicate the return cause: 
                          
                         cause = -3:    new _activity returned because of an
                    alarm in a started activity, which
                    is now empty. 
                                         
                         cause = -2:    new _activity returns, because the
                    designated activity is virtual and
                    shares storage with another activi-
                    ty waiting for an i/o operation to
                    complete (see the parameter: virt).
                     
                         cause = -1:    new _activity returns because the
                    designated activity is n_o_t_ empty. 
                                         
                         cause = 0:     new _activity returns because a
                    started activity terminated via its
                    final end. The activity is now
                    empty. 
                                         
                                  cause = 1:     new _activity returns because a
                                        started activity is passivated by a
                                        p_r_o_g_r_a_m_m_e_d_ passivate statement. 
                                         \f

                         cause = 2:     new _activity returns because anewactivity
                                        started activity is passivated by
                                        an implicit passivate statement in
                                        the zone i/o system. 
                                         
          E_x_a_m_p_l_e_ _1_:     If a minimum space is needed in the stack for an
                         activity (for later procedure calls, arrays in
                         inner blocks etc.) this may be assured by calling
                         the following procedure from an activity, during
                         its very first execution (cf. 8 in the description
                         above); 
                              procedure claim (n); value n; integer n; 
                              begin array a (1:n); end; 
                               
                         Example 1 of activity shows the use of the
                         procedure. 
                          
                   E_x_a_m_p_l_e_ _2_:     begin integer i, j; <*monitor block*' 
                          
                         procedure p (n, m); 
                         integer n, m; 
                         begin integer s, t; 
                         ...<*activity mode*' 
                           s:=2; t:=3; 
                           passivate; 
                           ... 
                         end; 
                          
                         procedure q (x, y, z); 
                         value x, y, z; real x, y, z; 
                         begin integer k, l; 
                         ...<*activity mode*' 
                           k:=4; 1:=5; 
                           passivate; 
                           ... 
                         end; 
                          
                           <*neutral mode*' 
                         activity (5);
                           <*monitor mode*' 
                         for i:=1, 2 do 
                         new _activity (i, 0, p, i, j); 
                          
                         for i:= 3, 4, 5 do 
                         new _activity (i, 3, q, 0, 0, 0); 
                         ... 
                          \f

                                   newactivity
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                          
                         In this example, 5 activities are created and
                         initialized. Activity no. 1 and 2 are both started
                         with the procedure p. The virtual activities no.
                         3, 4, and 5 are all started with the procedure q.
                         In the figure above is shown the contents of stack
                         and virtual storage after initialization of
                         activity no. 5. Note that activity no. 1 and 2 via
                         name parameter work on common variables. Note
                         also, that the virtual record of activity no. 5 is
                         empty, because the stack is still in core. 
                          \f

         2_._9_2_ _ _ _ _ _ _n_e_w_s_o_r_t_ 2.92 newsort
           
          This standard procedure creates a zone record in core store which
is to take part in a sorting process. The contents of the record
is initially undefined, but the user is supposed to assign values
to the record variables before next call of any sorting
procedure. The so defined record becomes an active record in the
sorting process (see procedure outsort). 
           
              C_a_l_l_:          newsort (z, key)   or   newsort (z) 
                          
                         z    (call and return value, zone). The name of
                              the record created. 
                         key  (call value, integer procedure or empty). The
                              name of a procedure for comparison of two re-
                              cords (see below). 
                         The key parameter is omitted if standard sequen-
                         cing is used (see procedure startsort6). 
                          
              Z_o_n_e_ _s_t_a_t_e_:    The zone state must be 9, in sort, i.e. startsort6
                         (or initsort) must have been called. The state is
                         not changed by the procedure. 
                          
          S_e_q_u_e_n_c_i_n_g_:    The integer procedure key is supplied by the user,
                         when a non-standard sequencing is wanted. It det-
                         ermines which of two records is to appear first 
                         in a sorted string of records: 
                          
                   C_a_l_l_:     key (record1, record2) 
                
               record1, record2, (call values, arrays). The name
                                           of two records to be compared. 
                         key               (return value, integer). The
                                           result of comparison of record1
                                           and record2. This return value
                                           must adhere to the following
                                           rules. 
                                           record1 before record2: key < 0 
                                 record1 after record2 : key ' 0 
                                 sequence unimportant  : key = 0 
                          \f

          E_x_a_m_p_l_e_ _1_:     This is an example of a key procedure which can be     newsort 
                         used to sort a number of records of length 10 real
                         on ascending number of equal words within a single
                         record. 
                          
                         integer procedure mostequals(v, w); 
                         real array                   v, w ; 
                         begin 
                           integer procedure equals(x); 
                           real array               x ; 
                           begin 
                             integer count, i, j, k; 
                             real z; 
                             count:= 0; 
                             for i:= 1, i+1 while i<= 10 and count < i do 
                             begin 
                               z:= x(i); k:= 1; 
                               for j:= i + 1 step 1 until 10 do 
                                 if z = x(j) then k:= k + 1; 
                               if k  ' count then count := k; 
                             end; 
                             equals:= count 
                           end equals; 
                           mostequals:= equals(v) - equals(w) 
                         end mostequals; 
                          
                         Note that the structure of a record (for instance
                         the record length) is supposed to be known to the
                         procedure as global information (for instance by
                         certain values of certain fields in the record). 
                          
          E_x_a_m_p_l_e_ _2_:     100 records of length 10 double words per record
                         are stored in array B(1:100,1:10). These records
                         are to be sorted on ascending number of equal
                         words within a single record. Therefore, the key
                         procedure of example 1 is used. 
 \f

                         begin                                                   newsort 
                           zone z(1199,1,sorterror); 
                           <*buffer length as required by initsort*' 
                           integer i, j; 
                           initsort(z, 10); 
                           for i:= 1 step 1 until 100 do 
                           begin 
                             newsort(z, mostequals); 
                             for j:= 1 step 1 until 10 do z(j):= B(i, j) 
                           end; 
                           for i:= 1 step 1 until 100 do 
                           begin 
                             outsort(z, mostequals); 
                             for j:= 1 step 1 until 10 do B(i, j):= z(j) 
                           end 
                         end; 
                          
               E_x_a_m_p_l_e_ _3_:     Same as example 2, but now the sorting is on
                         ascending double word one followed by descending
                         double word five (standard sequencing). 
                          
                         begin 
                           zone z(1022,1,sorterror); 
                           <*buffer length as required by startsort6*' 
                           integer i, j; 
                           integer array keys(1:2, 1:2); 
                           keys(1,1):= 4; keys(1,2):= 4; 
                           keys(2,1):=-4; keys(2,2):=20; 
                                       <* definition of sequencing, 
                                               see startsort6*' 
                           startsort6(z, keys, 2, 40); 
                           for i:= 1 step 1 until 100 do 
                           begin 
                             newsort(z); 
                             for j:= 1 step 1 until 10 do z(j):= B(i, j) 
                           end; 
                           for i:= 1 step 1 until 100 do 
           \f

                           begin                                                 newsort 
                             outsort(z); 
                             for j:= 1 step 1 until 10 do B(i,j):= z(j) 
                           end 
                         end; 
                            
                                     \f

F_       2_._9_3_ _ _ _ _ _ _n_o_t_ _(_-_,_)_                                                             2.93 not
           
          This delimiter, which is a monadic logical operator, yields the
          logical negation of the operand. 
           
          S_y_n_t_a_x_:        -, <operand' 
                          
          P_r_i_o_r_i_t_y_:      6 
           
          O_p_e_r_a_n_d_ _t_y_p_e_:  boolean 
           
          R_e_s_u_l_t_ _t_y_p_e_:   boolean 
           
          S_e_m_a_n_t_i_c_:      The negation of a boolean gives the result false
                         if the boolean is true and the result true if the
                         boolean is false.
           
          E_x_a_m_p_l_e_ _1_:     -, b 
                         -, (a=2) 
                         -, (-,p)     is equivalent to p 
                         -, (p and q) is equivalent to -,p or -,q 
                         -, (p or q)  is equivalent to -,p and -,q 
                         -, p or q    is equivalent to p =' q 
           \f

F_       2_._9_4_ _ _ _ _ _ _n_o_t_ _e_q_u_a_l_ _(_<_'_)_                                                  2.94 not equal

          This delimiter, which is a relational operator, gives the value
          true or false. 
           
          S_y_n_t_a_x_:        <operand1'  <'  <operand2' 
                          
          P_r_i_o_r_i_t_y_:      5 
                          
          O_p_e_r_a_n_d_ _t_y_p_e_s_: integer, long, or real. 
           
          R_e_s_u_l_t_ _t_y_p_e_:   always boolean. 
           
          S_e_m_a_n_t_i_c_:      The relation takes on the value true whenever the
                         bitpattern of the two operands are equal,
                         otherwise false. 
                          
                         The relation is performed as a bit by bit compari-
                         son of the two operands (after a possible type
                         conversion whenever the operands are of different
                         types).
           
          E_x_a_m_p_l_e_ _1_:     c:= d <' q; 
                         if m <' idle then ... else ... 
                         while empty <' full do ... \f

F_       2_._9_5_ _ _ _ _ _ _o_p_e_n_                                                                2.95 open 
           
          This standard procedure connects a document to a given zone in
          such a way that the zone may be used for input/output with the
          high level zone procedures. 
           
          C_a_l_l_:     open (z, modekind, doc, giveup) 
                     
                    z           (call and return value, zone). After re-
                                turn, z describes the document. 
                    modekind    (call value, integer). Mode shift 12 +
                                kind. See below. 
                    doc         (call value, string or any type array). A
                                text string or an array containing a text,
                                specifying the name of the document as re-
                                quired by the monitor, i.e. a small letter
                                followed by a maximum of 10 small letters
                                or digits. 
                    giveup      (call value, integer). Used in connection
                                with the checking of a transfer. See
                                below. 
           
          M_o_d_e_k_i_n_d_: Specifies the kind of the document (typewriter,
                    backing storage, magnetic tape,  etc.) and the
                    mode in which it should be operated (even parity,
                    odd parity, etc.). 
                     
                    The kind of the document tells the input/output proce-
                    dures how error conditions are to be handled, how the
                    device should be positioned, etc. This kind has nothing
                    to do with the kind mentioned in ref. 1. As a rule, the
                    procedures do not care for the actual physical kind of
                    the document, but disagreements may give rise to bad
                    answers from the document. If you, for example, open a
                    backing storage area with a kind specifying printer,
                    and later attempt to output via the zone, the backing
                    storage area will reject the message because the docu-
                    ment was initialised as required by  printer. 
 \f

                    Mode and kind must be coded as shown in the table be-open
                    low. If you attempt a mode which does not fit into the
                    table, an alarm occurs. 
                
               Kind: 
               0    i_n_t_e_r_n_a_l_ _p_r_o_c_e_s_s_ 
                     
               4    b_a_c_k_i_n_g_ _s_t_o_r_a_g_e_ _a_r_e_a_ 
                    mode = 0, specifies full error recovery. 
                    mode = 2, specifies suppression of automatic error
                              recovery. 
                    mode = 4, specifies limited error recovery on parity
                              errors occuring at an input operation. 
                     
               8    t_e_r_m_i_n_a_l_s_ 
                    input modes: 
                    mode = 0, intended for conversational operation by means of
                              keyboard. 
                    mode = 2, paper tape input from teleterminal, ISO characters 
                              in even parity. 
                    mode = 4, paper tape input from teleterminal, no parity. 
                     
                    output modes: 
                    mode = 0, normal text mode. 
                    mode = 2, transparent text mode, even parity. 
                    mode = 4, transparent output mode, no parity. 
                
               10   p_a_p_e_r_ _t_a_p_e_ _r_e_a_d_e_r_ 
                    mode = 0, odd parity. 
                    mode = 2, even parity. 
                    mode = 4, no parity. 
                    mode = 6, flexowriter to ISO conversion. 
                     
               12   p_a_p_e_r_ _t_a_p_e_ _p_u_n_c_h_ 
                    mode = 0, odd parity. 
                    mode = 2, even parity. 
                    mode = 4, no parity. 
                    mode = 6, ISO to flexowriter conversion. 
                    mode = 8, even parity (<10' implies <13' <10' <127'). 
                     \f

               14   l_i_n_e_ _p_r_i_n_t_e_r_         open 
                    mode = 0, the answer is returned when the transmitted
                              block has been w_r_i_t_t_e_n_. 
                    mode = 2, the answer is returned when the transmitted
                              block has been r_e_c_e_i_v_e_d_. 
                     
               16   c_a_r_d_ _r_e_a_d_e_r_ 
                    mode =   0, punched binary. 
                    mode =  10, punched decimal with conversion. 
                    mode =  64, mark sense binary. 
                    mode =  74, mark sense decimal with conversion. 
                    mode = 256, basic cards. 
                    See ref. 3 for further information. 
                     
               18   m_a_g_n_e_t_i_c_ _t_a_p_e_: 
                    modekind is defined to be: 
                    T shift 16 + mode shift 12 + 18 
                     
                    9 track tape: 
                    mode = 0, means 1600 bpi MTO 
                    mode = 4, means  800 bpi NRZ 
                    For output 0 <= T < 6 specifies that the last T
                    physical characters in a block should not be output to
                    the tape. 
                    For input T should be 0. 
                     
                    7 track tape: 
                    mode = 4, means  556 bpi NRZ 
                    mode = 6, means  556 bpi NRZE 
                    For the description of T see ref. 3. 
                     
                    For further information see ref. 3. 
                     
                    If you use T <' 0 during output you should set the
                    word defect bit (1 shift 7) and the stopped bit (1 shift
                    8) in your give up mask and after a check of halfwords
                    transferred simply ignore the bit in your block proce-
                    dure. 
                     \f

               18   c_a_s_e_t_t_e_ _t_a_p_e_         open 
                    modekind is defined to be: 
                    SLEW shift 20 + ECMA shift 19 + T shift 16 + mode
                    shift 12 + kind. 
                     
                    ECMA = 1 for ECMA version 1 (read only), 
                         = 0 otherwise. 
                    SLEW = 0, normal 
                         = 1, slew mode 
                     
                    T    see description of 9-track tape. 
                     
                    mode = 4, 800 bpi NRZ 
                     
                    For further information about kind and mode, see
                    relevant manual describing the external processes. 
                     
          I_n_i_t_i_a_l_i_s_a_t_i_o_n_ _o_f_ _a_ _d_o_c_u_m_e_n_t_ 
           
                    Open prepares the later use of the document according
                    to kind: 
           
                    Internal process, backing storage area, typewriter: 
                    Nothing is done. When a transfer is checked later, the
                    necessary initialisation is performed. 
                     
                    Paper tape, card reader: 
                    First, open checks to see whether the reader is reser-
                    ved by another process. If it is, the parent receives
                    the message 
                         wait for <name of document' 
                    and open waits until the reader is free. Second, open
                    initialises the reader and empties it. Third, open
                    initialises the reader again (in order to start reading
                    in lower case), sends a parent message asking for the
                    reader to be loaded, and waits until the first char-
                    acter is available. 
                     \f

                    Paper tape punch, line printer:                                open 
                    Open attempts to reserve the document for the job, but
                    the result of the reservation is neglected. 
                     
                    Magnetic tape: 
                    If the tape is not mounted, a parent message is sent
                    asking for mounting of the tape. The message is sent
                    without wait indication (see ref. 7). 
                     
                    Some of these rules have been introduced to remedy a
                    possible lack of an advanced operating system. 
                     
          G_i_v_e_u_p_:   The parameter giveup is a mask of 24 bits which will be
                    compared to the logical status word (ref. 15) each time
                    a transfer is checked. If the logical status word
                    contains a one in a bit where giveup has a one, the
                    standard action for that error is skipped and the block
                    procedure is called instead (the block procedure is
                    also called if a hard error is detected during the
                    checking). 
                    The bit 1 shift 9 in giveup has a special meaning: If
                    the zone is opened with this bit set to one, and the
                    program is in activity mode, then an implicit passivate
                    statement is executed in the running systems check
                    routine and in monitor (18 ...) making concurrent i/o
                    transfers possible in a program containing coroutines.
                    For further information see ref. 19. 
           
          Z_o_n_e_      The zone must be in state 4, after declaration. The
          s_t_a_t_e_:    state becomes positioned after open (ready for input-
                    /output) except for magnetic tapes, where setposition
                    must be called prior to a call of an input/output
                    procedure. 
                    The entire buffer area of z is divided evenly among the
                    shares and if the document is a backing storage area,
                    the share length is made a multiple of 512 halfwords.
                    If this cannot be done without using a share length of
                    0, the run is terminated. 
                    The logical position becomes just before the first
                    element of block 0, file 0. 
                     \f

               E_x_a_m_p_l_e_ _1_: The normal usage of a tape reader named >reader> goes         open 
                     like this: 
                      
                     begin zone z(25*2,2,stderror); 
                     open(z,2 shift 12+10,<:reader:',0); 
                     read(z,...);... 
                     close(z,true); 
                     end; 
                      
                     
                     If you replaced stderror with the procedure >list>: 
                      
                        procedure list(z,s,b); zone z; integer s,b; 
                        write(out,<:<10':',s,b); 
                      
                     and called open with 1 shift 1 instead of 0, the
                     block procedure would be activated after each tape
                     transfer and you would get a complete log of the
                     actions of the reader. (The procedure >list>
                     should print in a better way to be really useful). 
                      
          E_x_a_m_p_l_e_ _2_: Assume you need two magnetic tapes in a job. Then the
                     best communication with the operating system is obtaine  
                     in this way: 
                
                          open(z1,18,<:mt1706:',0); 
                          open(z2,18,<:mt1712:',0); 
                          setposition(z1,1,0); setposition(z2,1,0); 
                     
                     If none of the tapes are mounted, the operating
                     system may get the messages: 
                     
                     mount mt1706 without wait indication (caused by open(z1,...)) 
                     mount mt1712 without wait indication (caused by open(z2,...)) 
                     mount mt1706 with wait indication (caused by setposition(z1...)) 
                      
                     and the job is stopped by the operating system until
                     the tape waited for has been mounted. 
                      \f

          E_x_a_m_p_l_e_ _3_: Nearly all document names will be supplied as data to        open 
                     the algol program and in many cases the kind and mode
                     are given as data too. A convenient way of doing this
                     is to use the following syntax of the data: 
                         <kind and mode' <document name' <possibly a fileno'
                     Kind and mode are represented as the mnemonic code of
                     the fp-utility program >set>. The algol program may 
                     then look like this: 
                      
                     begin 
                         boolean procedure openvar(z,giveup);  
                     zone z; integer giveup; 
                     begin array text(1:3); integer i,j; 
                       openvar:= true; j:= 0; 
                       readstring(in,text,1); 
                       for i:= 1 step 1 until 17 do 
                                if text(1) = real(case i of 
                                  (<:ip:',<:bs:',<:tw:',<:tro:',<:tre:',...)) 
                         then j:= i; 
                        
                       if readstring(in,text,1) ' 2 or j = 0 then 
                         openvar:= false 
                       else 
                       open(z,case j of(0,4,8,10,2 shift 12 + 10,...), 
                            text, giveup); 
                       if j ' 15 then <*magnetic tape*' 
                       begin read(in,i); 
                         setposition(z,i,0) 
                       end; 
                     end openvar; 
                     ...
                     begin zone master,trans,new(256*2,2,stderror); 
                     if -, (openvar(master,0) and 
                            openvar(trans,0) and 
                            openvar(new,0)) then dataerror 
                     else 
                     begin 
                       inrec6(master,m1); inrec6(trans,t1);... 
                      \f

F_       2_._9_6_ _ _ _ _ _ _o_p_e_n_t_r_a_n_s_                                                       2.96 opentrans
           
          This standard procedure outputs a transaction head of a format
          8000 transaction, and initiates a zone for character writing.
          Opentrans may be regarded as the reverse operation of waittrans.
          Note, that no waiting takes place. 
           
          C_a_l_l_:     opentrans      (z, format, destination, aux1, aux2) 
                     
                    z              (call and return value, zone). Specifies the
                                   document to which transactions are
                                   transferred. 
                    format         (call value, integer). Defines the format of
                                   the transaction to be sent: 
                                   1:  read modified format 
                                   2:  short read format 
                                   3:  write format 
                                   4:  read buffer format 
                    destination    (call value, integer). Designates the
                                   receiver of the transaction, i.e.
                                   display terminal, computer, or RC8000
                                   application. 
                    aux1           (call value, integer). Depending on the
                                   format of the transaction, aux1 speci-
                                   fies the attention type, write command
                                   code, or is not used. 
                    aux2           (call value, integer). Depending on the
                                   format of the transaction, aux2 speci-
                                   fies the cursorposition, write control
                                   character, or is not used. 
                     
                    Note that in communication with display terminals, only
                    format 3 (write format) can be used. Format 1, 2, and 4
                    can only be sent to computers or other RC8000 applica-
                    tions.  
                    For further details about format, aux1, and aux2 see
                    waittrans. 
                     \f

                   Z_o_n_e_ _s_t_a_t_e_:    The zone must be open and ready for opentrans    opentrans 
                         (state 0 or 13), i.e. since the latest call of
                         open, setposition, or closetrans. The state
                         becomes 3, i.e. the zone is ready for character
                         output by means of the procedures writefield,
                         write, outtext, etc. 
                          
          E_x_a_m_p_l_e_ _1_:     The following procedure sends the number of sound
                         alarms specified by the parameter no: 
                          
                         procedure beep (z, dest, no); 
                         zone            z           ; 
                         integer            dest, no ; 
                         begin integer i, state; 
                           getstate (z, state); 
                           if state = 3 then closetrans (z); 
                           for i:= 1 step until no do 
                           begin 
                             opentrans (z, 3<*write format*', dest, 
                                       49<*write*', 1 shift 2 <*sound*'); 
                             closetrans(z); 
                           end; 
                           if state =3 then 
                             opentrans (z, 3<*write format*', dest, 
                                        49<*write*', 1<*reset MDT bits*'); 
                         end beep; 
                          
          E_x_a_m_p_l_e_ _2_:     See example 3 of writefield. 
                          \f

                    
           \f

                                                 i 
           
          T_A_B_L_E_ _O_F_ _C_O_N_T_E_N_T_S_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _P_A_G_E_ 
           
          1.  INTRODUCTION ...........................................   1 
           
          2.  THE FRONT PROCESS ADAPTOR ..............................   2 
           
          3.  FDLC PROTOCOL CHARACTERISTICS ..........................   4 
              3.1  Transmission Elements .............................   4 
              3.2  Error Detection and Correction ....................   4 
              3.3  Transmission Unit Identification ..................   4 
           
          4.  PROTOCOL FORMAT SPECIFICATIONS .........................   5 
              4.1  Startbyte .........................................   5 
              4.2  Statusbyte ........................................   5 
              4.3  Textblocks ........................................   6 
              4.4  Master Clear ......................................   6 
           
          5.  PROTOCOL PROCEDURES SPECIFICATIONS .....................   7 
              5.1  Flow Control ......................................   7 
              5.2  Initialization ....................................   8 
              5.3  Error Detection and Correction ....................   8 
              5.4  Transmission Unit Numbering .......................   9 
              5.5  Standard Operation of the Transmitter .............   9 
              5.6  Error Actions of the Transmitter ..................  10 
              5.7  Standard Operation of the Receiver ................  10 
              5.8  Error Reactions of the Receiver ...................  11 
           
           
          A_P_P_E_N_D_I_X_: 
           
          A.  REFERENCES .............................................  13 
           \f

                                                 ii 
           \f

         1_._ _ _ _ _ _ _ _ _I_N_T_R_O_D_U_C_T_I_O_N_ 1.
           
          This manual describes a communication line protocol, the FDLC-
          protocol (F_PA D_ata L_ink C_ontrol), which is used in CENTERNET to
          connect the RC8000 host with the RC3502 TC. The protocol is a
          subset of the FDLC-protocol described in ref. 5. 
           
          The FPA is a high-speed, 8-bit parallel data communication line.
          When initated, a transfer may proceed with a speed of up to
          600.000 bytes per second. Interfaces exist to FPA-lines on
          RC8000, RC3600 and RC3500 series of computers. 
           
          In the network hierarchy of protocol levels generally used in
          international standards, the FDLC is a level 2 protocol. Thus it
          functionally corresponds to the HDLC or the X25.2 protocol. 
           
          Being a reference manual, this description only defines the for-
          mats and procedures to be followed on the line. Thus this de-
          scription is independent of the computers actually involved.
          However, the presence of an FDLC-handler module in the computers
          is assumed. This module implements the FDLC-protocol on the FPA-
          line and offers a computer-type-dependent interface to user-mo-
          dules. 
           \f

F_       2_._ _ _ _ _ _ _ _ _T_H_E_ _F_R_O_N_T_ _P_R_O_C_E_S_S_ _A_D_A_P_T_O_R_                                        2.
           
          The communication between the computers is carried out using an
                   FPA-connection (Front Process Adaptor). Fig. 1 shows an FPA-con-
          nection seen from a logical point of view. 
           
           
           
           
           
           
           
           
           
           
           
           
           
           
           
           
           
           
           
           
          Figure 1: The logical structure of the FPA-connection. 
           
          The FPA consists of two subdevices - a transmitter and a
          receiver. These two devices are totally independent of each
          other. 
           
          The FPA transmitter can execute the following tasks: 
          - it can transmit a data block of any size to the receiver 
          - it can receive one single byte - normally holding status
            information 
          - it can transfer a reset signal which, in case the receiver is
            waiting for data, will stop the receiver immediately 
           \f

                   - it can transfer an autoload signal, which will activate the
            autoload function of the computer on which the receiving FPA is
            situated. 
             
          The FPA receiver is able to execute the following tasks: 
          - it can be set up for reception of any data block 
          - it can transmit one single byte to the transmitting end of
            line. 
             
          An FPA-connection between two computers can be regarded as a pair
          of independent simplex-lines with a low-volume return channel.
          Both computers have two channels, a transmitter channel and a
          receiver channel. 
           
          A detailed description of the FPA hardware used on RC8000, RC3600
          and RC3500 can be found in ref. 1, 2, 3, 4. 
           
           \f

F_       3_._ _ _ _ _ _ _ _ _F_D_L_C_ _P_R_O_T_O_C_O_L_ _C_H_A_R_A_C_T_E_R_I_S_T_I_C_S_ 3.
           
          This chapter gives an overview of the FDLC-protocol and defines
          the elements of the protocol. Details of formats and procedures
          are found in the following chapter. 
           
           
3_._1_ _ _ _ _ _ _ _T_r_a_n_s_m_i_s_s_i_o_n_ _E_l_e_m_e_n_t_s_                                               3.1
           
          The protocol is based on the exchange of T_r_a_n_s_m_i_s_s_i_o_n_ _U_n_i_t_s_ _(_T_U_)_.
          A TU consists of a s_t_a_r_t_b_y_t_e_ followed by a number (at least one)
          of d_a_t_a_ _b_y_t_e_s_. The receiver of a TU will return a s_t_a_t_u_s_b_y_t_e_
          which specifies the result of the transfer and indicates that the
          receiver is ready for the next transfer. 
           
          The FPA-connection may be regarded as two independent communica-
          tion channels (one for each direction). Each channel is unidirec-
          tional but with a l_o_w_-_v_o_l_u_m_e_ return channel, which is used to re-
          turn the statusbytes. 
           
          The startbyte, databytes and the statusbyte each occupy 8 bits. 
           
           
3_._2_ _ _ _ _ _ _ _E_r_r_o_r_ _D_e_t_e_c_t_i_o_n_ _a_n_d_ _C_o_r_r_e_c_t_i_o_n_ 3.2
           
          Error detection is based on a parity checking mechanism. The FPAs
          will add a parity-bit to each transmitted byte. The parity is
          checked by the receiving FPA and an error will be reported. 
           
          Error correction is based on retransmission of the erroneous TU. 
           
           
3_._3_ _ _ _ _ _ _ _T_r_a_n_s_m_i_s_s_t_i_o_n_ _U_n_i_t_ _I_d_e_n_t_i_f_i_c_a_t_i_o_n_ 3.3
           
          Retransmission of a TU is detected by a TU-number which is added
          to each TU. This number counts modulo 2, which means that only
          one TU may be outstanding waiting for acknowledge. 
           \f

F_       4_._ _ _ _ _ _ _ _ _P_R_O_T_O_C_O_L_ _F_O_R_M_A_T_ _S_P_E_C_I_F_I_C_A_T_I_O_N_S_ 4.
           
          This presents the formats used for the various transmission
          elements. 
           
           
4_._1_ _ _ _ _ _ _ _S_t_a_r_t_b_y_t_e_ 4.1
           
          All Transmission Units are preceded by a startbyte. It contains
          the following information: 
           
                              0  1  2  3  4  5  6  7 
                                       0  0  0  0  0 
                 
                TU _NUMBER 
                TYPE 
           
                TU _NUMBER: is a modulo 2 sequence number as described in
                           section 3.3. 
           
                TYPE     : 0  Text block 
                           1  Not used 
                           2  Master clear 
                           3  Not used 
           
           
4_._2_ _ _ _ _ _ _ _S_t_a_t_u_s_b_y_t_e_ 4.2
           
          A statusbyte is returned, when a TU has been received. It
          indicates whether the TU was received correctly or whether an
          error occured. 
           
          A statusbyte has the following format: 
           
                              0  1  2  3  4  5  6  7 
                              0        0  0  0  0  0 
                 
                PARITY ERROR
      BLOCK SIZE ERROR 
           \f

                   P_a_r_i_t_y_ _e_r_r_o_r_ indicates that the parity checking mechanism
          indicated an error for at least one of the characters received. 
           
          B_l_o_c_k_ _s_i_z_e_ _e_r_r_o_r_ indicates an overflow in the user buffer, in
          which the textblock should be stored. 
           
          The statusbyte should have initial value = 255, see section 5.4. 
           
           
4_._3_ _ _ _ _ _ _ _T_e_x_t_b_l_o_c_k_s_ 4.3
           
          Textblocks are used to exchange information between the users of
          the FDLC-protocol. The datapart of a textblock is solely defined
          by the user and the bytes in the datapart may take any value from
          0 to 255. 
           
           
4_._4_ _ _ _ _ _ _ _M_a_s_t_e_r_ _C_l_e_a_r_ 4.4
           
          A master clear block is used to synchronize the two ends of the
          transmission line. It is used after initial load or after an
          irrecoverable error. The master clear block carries no data and
          consists solely of a startbyte. 
           
          The master clear startbyte will have: 
           
                TU _NUMBER = 0 
                TYPE      = 2 
           
           \f

F_       5_._ _ _ _ _ _ _ _ _P_R_O_T_O_C_O_L_ _P_R_O_C_E_D_U_R_E_S_ _S_P_E_C_I_F_I_C_A_T_I_O_N_S_                                  5.
           
          This chapter presents the procedures that are to be followed by
          the FDLC-handlers. 
           
           
5_._1_ _ _ _ _ _ _ _F_l_o_w_ _C_o_n_t_r_o_l_ 5.1
           
          Due to the characteristics of the line and the intended use of
          the protocol, only a rather simple method of flowcontrol is
          implemented. 
           
          The flowcontrol is based on the assumption that the users of the
          protocol should in general always assure that a buffer is ready
          in which to receive data. If a buffer is not always present, the
          time in which the F_D_L_C_-_h_a_n_d_l_e_r_ is without a buffer should be
          short compared to the time-out period after which retransmission
          will take place. 
           
          The flowcontrol is implemented by means of the statusbytes in the
          following manner: 
           
             A statusbyte is not returned until a buffer is ready for
             reception of a new (or retransmitted) TU. 
           
          This means that if the FDLC-handler receives a textblock into the
          last buffer from the user, it will not return the statusbyte
          until a new buffer is present. 
           
          In case this exceeds the timeout value of the transmitter, a re-
          transmission, will take place. This will, until a buffer is
          ready, terminate immediately because no input operation is pre-
          sent at the receiving end. 
           
           \f

         5_._2_ _ _ _ _ _ _ _I_n_i_t_i_a_l_i_z_a_t_i_o_n_ 5.2
           
          During initialization, the FPA-connection is regarded as a pair
          of totally independant lines, one for each direction. 
           
          The lines are initialized during initial start up or after an
          irrecoverable error. The initiative for initialization always
          rests with the transmitting end of the line. 
           
          If the receive part of an FDLC-handler receives a master clear
          startbyte, it should perform the clean up actions necessary and
          return a statusbyte = 0 (ok), indicating that the receive part is
          ready to operate.  
           
          When the transmit part of an FDLC-handler wants to initialize the
          line, it should transmit a master clear startbyte. If a status-
          byte = 0 has not been received within a certain time interval,
          the master clear startbyte should be retransmitted. Having re-
          ceived the statusbyte (and assuming no error indications) the
          transmit part is ready to operate. 
           
          During initial start up of the two FDLC-handlers, the initial-
          ization described above is performed for both directions. If an
          irrecoverable error has been detected by only one of the FLDC-
          handlers or if one of the FDLC-handlers has been restarted, the
          initialization need only be performed for the direction in-
          volved. 
           
           
5_._3_ _ _ _ _ _ _ _E_r_r_o_r_ _D_e_t_e_c_t_i_o_n_ _a_n_d_ _C_o_r_r_e_c_t_i_o_n_ 5.3
           
          Error detection is based on a parity checking mechanism. For each
          transmitted byte, the FPA will generate a parity bit, which is
          transmitted along with the byte. If the receiving FPA detects a
          parity error, it will indicate this in a hardware status. 
           
          In this case a statusbyte which contains the PARITY ERROR-bit
          should be returned and the TU will be retransmitted. 
           
           \f

         5_._4_ _ _ _ _ _ _ _T_r_a_n_s_m_i_s_s_i_o_n_ _U_n_i_t_ _N_u_m_b_e_r_i_n_g_ 5.4
           
          All TU's are numbered. The TU-number counts modulo 2. The first
          TU transmitted after initalization has a TU-number of 1. 
           
          The transmitter and receiver will each maintain its version of a
          TU-counter. 
           
          The TU-counter in the transmitter holds the number of the next TU
          that is going to be transmitted or is during transmission. The
          TU-counter is increased by 1 (modulo 2) each time a statusbyte
                   without errorindication has been received. When a TU is trans-
          mitted or retransmitted, the current value of the TU-counter is
          inserted as TU-number in the startbyte. 
           
          The TU-counter in the receiver holds the TU-number that is ex-
          pected in the next TU. It is increased by 1 (modulo 2), when a TU
          with this expected TU-number has been received without error. If
          a TU is received with a TU-number different from what is expected
          (and it is not a master clear block), the block is ignored and
          the last statusbyte is transmitted again. 
           
          The statusbyte does not itself include any TU-number because it
          will always refer to the TU just received. However, the initial
          value of statusbyte is used to signal to the transmitting end of
          the line if a TU-number mismatch has occurred at the receiving
          end, due to restart of the local FDLC-handler. Therefore, the
          initial value of statusbyte should be 255. If a statusbyte hold-
          ing this value is received, this indicates that the TU-counter
          should be increased by 1 (modulo 2) before retransmission. 
           
           
5_._5_ _ _ _ _ _ _ _S_t_a_n_d_a_r_d_ _O_p_e_r_a_t_i_o_n_ _o_f_ _t_h_e_ _T_r_a_n_s_m_i_t_t_e_r_ 5.5
           
          The transmitter is the active part in the communication. Its
          normal working cycle consists of a transmission of a TU, headed
          by the startbyte after which the transmitter waits to receive the
          statusbyte. 
           \f

                   Now the transfer is checked by inspecting partly the hardware
          status from the transmission, partly the received statusbyte. If
          no errors are indicated, the TU-counter is increased. 
           
          The operation must terminate within a certain time, if necessary
          by means of a software timer. 
           
          The FPA-connection will very seldom cause errors to be imposed on
          the transmitted data except in case of permanent hardware errors.
          Therefore the timeout value may be rather big and it should be
          set to 5 seconds. 
           
           
5_._6_ _ _ _ _ _ _ _E_r_r_o_r_ _A_c_t_i_o_n_s_ _o_f_ _t_h_e_ _T_r_a_n_s_m_i_t_t_e_r_ 5.6
           
          The standard error action is to retransmit the TU. In order to
          force the receiver into a well defined state, the retransmission
          must be initated by transmission of a reset signal. This will
          terminate a possible input operation at the receiver. After
          transmission of the reset signal, the transmitter must wait at
          least 50 msec. to allow the receiver to prepare a new input
          operation. Then the transmit-operation is repeated. 
           
          The FPA-line must be initialized if the same block has been
          transmitted 5 times without success. 
           
           
5_._7_ _ _ _ _ _ _ _S_t_a_n_d_a_r_d_ _O_p_e_r_a_t_i_o_n_ _o_f_ _t_h_e_ _R_e_c_e_i_v_e_r_ 5.7
           
          The receiver is the passive part in the transmission. Having
          received a TU, the receiver checks the hardware status for parity
          errors or blocklength errors, and generates the appropriate
          statusbyte. Then the statusbyte is returned and a new receive
          operation issued. 
           \f

         5_._8_ _ _ _ _ _ _ _E_r_r_o_r_ _R_e_a_c_t_i_o_n_s_ _o_f_ _t_h_e_ _R_e_c_e_i_v_e_r_ 5.8
           
          Parity error in block received: 
                    set PARITY ERROR in statusbyte 
                    transmit statusbyte - receive new TU 
           
          Wrong TU-number in TU: 
                    ignore block arrived 
                    transmit old statusbyte - receive new TU 
           
          Blocklength error: 
                    Set BLOCK SIZE ERROR in statusbyte 
                    transmit statusbyte - receive new TU 
           
          Master clear received 
                    Initialize the FPA-line 
           
          Any other error situation 
                    Receive new TU 
           
          The receiver should keep on repeating the operation, because the
          decision of whether to give up is placed at the transmitter. 
           
           \f

F_                  
           \f

F_       A_._ _ _ _ _ _ _ _ _R_E_F_E_R_E_N_C_E_S_ A.
           
          1  FPA 801, RC8000 
           
          2  FPA 705, RC3600 
           
          3  FPA 707, RC3600 
           
          4  FPA 100, RC3500 
           
          5  RCSL No 43-GL7810: 
               RCNET, FDLC-FPA Data Line Control  
               Erik Lilholt 
           \f

F_                  
           \f

«eof»