Atlas Autocode ABC Phrase Structure
      All Atlas Autocode statements belong to the class P<SS> as defined


(*)   P<SS> ::=  <unconditional instrn> <separator>!
                 <if or unless><cond> %THEN <unconditional instr><separator>!
(*)              <unconditional instrn><if or unless><cond><separator>!
(*)              %CYCLE <name> <actual paramaters'>=<plus'> <exprn>,<plus'><exprn>,<plus'><exprn><separator>!
                 %REPEAT <separator>!
                 <type><name list><separator>!
                 <type'> %ARRAY <arraylist><separator>!
                 %SWITCH <switchlist><separator>!
(*)              <rt> %SPEC <name><formal parameter defn'><separator>!
(*)              %SPEC <name><formal parameter defn'><separator>!
(*)              <rt><name><formal parameter defn'><separator>!
                 %BEGIN <separator>!
                 %END <separator>!
                 <unsigned integer> :!
(*)              <name> (<plus'><const>) :!
                 %COMPILEQUERIES <separator>!
                 %IGNOREQUERIES <separator>!
                 %COMMENT <comment text><separator>!
                 !<comment text><separator>!
                 %LIST <separator>!
                 %ENDOFLIST <separator>!
                 %MCODE <separator>!
                 %ENDOFMCODE <separator>!
                 *<machine instrn><separator>!
                 %COMPILEARRAYBOUNDCHECKS <separator>!
                 %IGNOREARRAYBOUNDCHECKS <separator>!
                 %ENDOFPERM <separator>!
                 %FAULT <fault list><separator>!
                 <separator>;
(*)   where

      P<unconditional instrn>::= <name><actual parameters>=<plus'><exprn><query'>!
                                 <name><actual parameters>!
                                 -> <unsigned integer>!
                                 -> <name> (<plus'><exprn)!
                                 %CAPTION <caption text>!
                                %RETURN !
                                 %RESULT = <plus'><exprn>!
                                 %STOP !
                                 %MONITORSTOP !
                                 %MONITOR <unsigned integer>;
           and

(*)   P<plus'> ::=                 +!-! <null>;
      P<exprn>::=               <operand><rest of exprn>;
(*)   P<rest of exprn> ::=      <operator><operand><rest of exprn>! <null>;
(*)   P<operand> ::=            <name><actual parameters'>!<const>!(<plus'><exprn>)!   !<plus'><exprn>!;
(*)   P<operator> ::=           **!+!-!*! ! (* *)!  <null>;
(*)   P<actual parameters'> ::= (<plus'><exprn><rest of actual parameters>)! <null>;
(*)   P<rest of actual parameters>::=  ,<plus'><exprn><rest of actual parameters>! <null>;
(*)   P<query'> ::=             ?! <null>;
(*)   P<comma'> ::=             ,! <null>;
(*)   P<if or unless> ::=       %IF ! %UNLESS;
(*)   P<type> ::=               %INTEGER ! %REAL;
(*)   P<type'> ::=              %INTEGER ! %REAL ! <null>;
      P<name list> ::=          <name><rest of name list>;
(*)   P<rest of name list> ::=  ,<name list>! <null>;
      P<array list> ::=         <name list>(<bound pair list>)<rest of array list>;
(*)   P<rest of array list> ::= ,<array list>! <null>;
(*)   P<bound pair list> ::=     <plus'><exprn>:<plus'><exprn><rest of bp list>;
(*)   P<rest of bp list> ::=     ,<bound pair list>! <null>;
(*)   P<switch list> ::=         <name list>(<plus'><const>:<plus'><const>)<rest of switch list>;
(*)   P<rest of switch list> ::= ,<switch list>! <null>;
      P<rt> ::=                  %ROUTINE ! %REALFN ! %INTEGERFN!
                                 %REALMAP ! %INTEGERMAP;
(*)   P<formal parameter defn'> ::= (<fp list>)! <null>;
      P<fp list> ::=                 <fp delimiter><name list><rest of fp list>;
(*)   P<rest of fp list> ::=         <fp list>! <null>;
(*)   P<fp delimeter> ::=            <comma'><rt>!<comma'><type> %NAME!
                                     <comma'><type>!<comma'><type'>%ARRAYNAME !
                                     %ADDR;
      P<cond> ::=                    <simple cond>%AND <and-cond>!
                                     <simple cond>%OR <or-cond>!
                                     <simple cond>;

      P<and-cond> ::=                <simple cond><rest of and cond>;
(*)   P<rest of and cond> ::=        %AND <and-cond>! <null>;
(*)   P<or-cond> ::=                 <simple cond><rest of or-cond>;
(*)   P<rest of or cond> ::=         %OR <or-cond>! <null>;
(*)   P<simple cond> ::=             <plus'><exprn><comparator><plus'><exprn><rest of simple cond>;
(*)   P<rest of simple cond> ::=     <comp><+'><exprn>! <null>;
(*)   P<comp> ::=                    =!#!<=!<!>=!>!=;

      P<fault list> ::=              <unsigned integer><rest of N list> -> <unsigned integer><rest of fault list>;
(*)   P<rest of N list> ::=          ,<unsigned integer>! <null>;
      P<rest of fault list> ::=      ,<fault list>! <null>;

(*)   (P<machine instrn>             See KDF9 programming manual)

      The built in phrases are
(*)-> P<null>
      P<name>
      P<const>
      P<comment text>
      P<caption text>
      P<separator>
      P<unsigned integer>
;