B<stropped> = 0;
B<sqstring> = 1;
B<dqstring> = 2;
B<NL> = 3;
B<char> = 4;
B<EOF> = 5;

C<immediate> = {
#define INCLUDE_AST_DEBUG "show_ast.c"
int kw(int AST_op, int idx, int ap)
{
  int data[4];

  int i;

  char *k = keyword(idx);

  data[1] =  idx;

  data[2] = A[ap+3]; // index of c[] array element
  data[3] = strlen(k);

  return mktuple(AST_op, 1, 3, data);

}
// variables used in line_reconstruction() moved here so they are available to semantic code in grammar.
#define STROPPED_KEYWORDS 1  /* alters behaviour of parse() */
int at_startofstatement = TRUE;

int saved = TRUE;

int at_startofline = TRUE;

int in_const_initialiser_list = FALSE;

int in_keyword = FALSE;

int in_alphanumeric = FALSE;

};

P<LABEL-COLON> =
   ':';

P<SS> =
   <EOF>,
   <S> <SS>,
   <Percent-IU> <CONDITION> <THEN-S> <SS>,
   "else" <Percent-IU> <CONDITION> <Opt-start> <S> <SS>,
   "else" <Opt-start> <S> <SS>,
   "finish" <Opt-ELSE-S> <SS>,
   "begin" <S> <SS>,
   "end" "of" "perm" <S> <SS>,
   "end" "of" "prim" <S> <SS>,
   "end" "of" "file" <S> <SS>,
   "end" "of" <program> <S> <SS>,
   "end" "of" "list" <S> <SS>,
   "end" "of" "mcode" <S> <SS>,
   "end" <S> <SS>,
   <Percent-SEX> <RT> <spec> <NAME> <Opt-ALIAS> <FPP> <S> <SS>,
   <Percent-SEX> <RT> <NAME> <Opt-ALIAS> <FPP> <S> <SS>,
   <OPT-68K> <Percent-SEX> <RT> <NAME> <Opt-ALIAS> <FPP> <S> <SS>,
   <OPT-68K> <XOWN> <XTYPE> <OWNDEC> <S> <SS>,
   <OPT-68K> <XTYPE> <DECLN> <S> <SS>,
   <OPT-68K> <OPT-XOWN> "record" "array" <RADEC> <REST-OF-RADEC> <S> <SS>,
   <OPT-68K> <OPT-XOWN> "record" <RDEC> <REST-OF-RDEC> <S> <SS>,
   "const" "char" <NAME> '=' 'C' 'H' 'A' 'R' '<' <INT-CONST> '>' <S> <SS>,
   "register" <NAME> '(' <INT-CONST> ')' <S> <SS>,
   "record" "format" <RECFMT-spec-OR-BODY> <S> <SS>,
   "switch" <ONE-SWITCH-DECL> <REST-OF-SWLIST> <S> <SS>,
   "include" <STR-CONST> <S> <SS>,
   "option" <STR-CONST> <S> <SS>,
   "from" <NAME> "include" <NAME> <Opt-NAME-LIST> <S> <SS>,
   "list" <S> <SS>,
   "mcode" <S> <SS>,
   "trusted" "program" <S> <SS>,
   "main" "ep" <NAME> <S> <SS>,
   "control" <INT-CONST> <S> <SS>,
   "diagnose" <INT-CONST> <S> <SS>,
   "reals" "long" <S> <SS>,
   "reals" "normal" <S> <SS>,
   <COMMENT> <SS>,
   '?' '?' <CEXPR> <S> <SS>,
   '?' <EXPR> <S> <SS>,
   '?' <LVALUE> '=' '=' <EXPR> <S> <SS>,
   '?' <LVALUE> '=' <EXPR> <S> <SS>,
   <LABEL-DEFINITION> <SS>,
   <UI> <REST-OF-SS1> <SS>,
   '*' <UCI> <SS>,
   "cycle" <Opt-CYCPARM> <S> <SS>,
   "repeat" <Opt-UNTIL> <S> <SS>,
   <Percent-WUF> "cycle" <S> <SS>,
   <Percent-WU> "then" "cycle" <S> <SS>,
   <Percent-WU> "then" <UI> <SS>,
   "fault" <FAULT-ACTION> <MORE-FAULTS> <S> <SS>,
   "on" <OPT-event> <EVENT-LIST> <REST-OF-EVENT-LIST> "start" <S> <SS>,
   "spec" <NAME> <FPP> <S> <SS>,
   "short" "routine" <S> <SS>,
   <!any2char> <char> <SS>;

P<letter> =
   'A',
   'B',
   'C',
   'D',
   'E',
   'F',
   'G',
   'H',
   'I',
   'J',
   'K',
   'L',
   'M',
   'N',
   'O',
   'P',
   'Q',
   'R',
   'S',
   'T',
   'U',
   'V',
   'W',
   'X',
   'Y',
   'Z';

P<digit> =
   '0',
   '1',
   '2',
   '3',
   '4',
   '5',
   '6',
   '7',
   '8',
   '9';

P<alphanumeric> =
   <letter>,
   <digit>;

P<opt-letter-or-digit-seq> =
   <letter> <opt-letter-or-digit-seq>,
   <digit> <opt-letter-or-digit-seq>,
  ;

P<program> =
   "programme",
   "program";

P<outer-level-end> =
   "end" "of" <program>,
   "end";

P<any2char> =
   <immediate: c[cp].t = B_char; return FALSE;>;

P<OPT-68K> =
   '@' <68K-stuff>,
  ;

P<68K-stuff> =
   '-' <INT-CONST> '(' <NAME> ')',
   <INT-CONST> '(' <NAME> ')',
   <INT-CONST> '-' <INT-CONST>,
   <INT-CONST>,
   '#' <NAME>;

P<spec> =
   "specalias",
   "spec" <Opt-68K-code-address>;

P<Opt-68K-code-address> =
   '(' <INT-CONST> ')',
  ;

P<OPT-spec> =
   <spec>,
  ;

P<LABEL-DEFINITION> =
   <NAME> '(' <CEXPR> ')' <LABEL-COLON>,
   <NAME> '(' '*' ')' <LABEL-COLON>,
   <NAME> <LABEL-COLON>,
   <DIGIT-SEQ> <LABEL-COLON>;

P<FAULT-LIST> =
   <DIGIT-SEQ> <MORE-NUMBERS>;

P<MORE-NUMBERS> =
   ',' <DIGIT-SEQ> <MORE-NUMBERS>,
  ;

P<FAULT-ACTION> =
   <FAULT-LIST> '-' '>' <LABEL>;

P<MORE-FAULTS> =
   ',' <FAULT-ACTION> <MORE-FAULTS>,
  ;

P<AUI> =
   "and" <UI>,
  ;

P<OPT-ASSIGN> =
   '-' '>' <STRING-RESOLUTION-EXPR>,
   <ASSOP-EXPR>,
  ;

P<UI> =
   <LVALUE> <OPT-ASSIGN> <AUI>,
   "print" "text" <sqstring> <AUI>,
   '-' '>' <LABEL>,
   "return",
   "true",
   "false",
   "result" <ASSOP-EXPR>,
   "monitorstop",
   "monitor" <DIGIT-SEQ> <AUI>,
   "monitor" <AUI>,
   "stop",
   "signal" <OPT-event> <CEXPR> <OPEXPR2>,
   "exit",
   "continue";

P<LABEL> =
   <NAME> '(' <EXPR> ')',
   <NAME>,
   <DIGIT-SEQ>;

P<OPT-XOWN> =
   <XOWN>,
  ;

P<RADEC> =
   <NAME> <Opt-NAME-LIST> <BPAIR> '(' <RECFMT-REF> ')';

P<REST-OF-RADEC> =
   ',' <RADEC>,
  ;

P<RDEC> =
   <NAME> <Opt-NAME-LIST> '(' <RECFMT-REF> ')';

P<REST-OF-RDEC> =
   ',' <RDEC> <REST-OF-RDEC>,
  ;

P<EVENT-LIST> =
   '*',
   <CEXPR>;

P<Opt-start> =
   "start",
  ;

P<Opt-ELSE-S> =
   "else" "start" <S>,
   "else" <Percent-IU> <CONDITION> <THEN-S>,
   "else" <UI> <S>,
   <S>;

P<THEN-S> =
   <OPT-then> "start" <S>,
   "then" <UI> <Opt-ELSE-S>;

P<OPT-then> =
   "then",
  ;

P<S> =
   <NL>,
   ';';

P<COMMENT> =
   "comment" <Parsed-OldStyle-Comment>,
   '!' <Parsed-OldStyle-Comment>;

P<Parsed-OldStyle-Comment> =
   <char> <Parsed-OldStyle-Comment>,
   <dqstring> <Parsed-OldStyle-Comment>,
   <sqstring> <Parsed-OldStyle-Comment>,
   <letter> <Parsed-OldStyle-Comment>,
   <digit> <Parsed-OldStyle-Comment>,
   <stropped> <Parsed-OldStyle-Comment>,
   <NL>;

P<semi> =
   ';';

P<INT-CONST> =
   <SAVED-INT-CONST>;

P<SAVED-INT-CONST> =
   <DIGIT-SEQ> '_' <alphanumeric-SEQ>,
   <DIGIT-SEQ>,
   <OLDSTYLE-BASE>,
   <sqstring>;

P<alphanumeric-SEQ> =
   <alphanumeric> <Opt-alphanumeric-SEQ>;

P<Opt-alphanumeric-SEQ> =
   <alphanumeric> <Opt-alphanumeric-SEQ>,
  ;

P<STR-CONST> =
   <SAVED-STR-CONST>;

P<SAVED-STR-CONST> =
   <OPT-DQ-LETTER> <dqstring>,
   <sqstring>;

P<OPT-DQ-LETTER> =
   'E',
  ;

P<NUMERIC-CONST> =
   <INT-CONST>,
   <REAL-CONST>;

P<CONST> =
   <INT-CONST>,
   <REAL-CONST>,
   <STR-CONST>;

P<OLDSTYLE-BASE> =
   <letter> <sqstring>;

P<REAL-CONST> =
   <SAVED-REAL-CONST>;

P<DOT> =
   '.';

P<OPT-DOT> =
   <DOT>,
  ;

P<SAVED-REAL-CONST> =
   <DIGIT-SEQ> <OPT-DOT> <EXPONENT>,
   <rest-of-number> <FRACPT> <OPT-EXPONENT>,
   <DIGIT-SEQ> '.' <OPT-EXPONENT>;

P<FRACPT> =
   '.' <DIGIT-SEQ>;

P<OPT-FRACPT> =
   <FRACPT>,
  ;

P<OPT-Plus-Minus> =
   '+',
   '-',
  ;

P<EXPONENT> =
   '@' <OPT-Plus-Minus> <DIGIT-SEQ>;

P<OPT-EXPONENT> =
   <EXPONENT>,
  ;

P<DIGIT-SEQ> =
   <digit> <rest-of-number>;

P<rest-of-number> =
   <DIGIT-SEQ>,
  ;

P<NAME> =
   <letter> <!SQUO-STRING> <opt-letter-or-digit-seq>;

P<SQUO-STRING> =
   <sqstring>;

P<UCI> =
   <S>,
   <char> <UCI>,
   <dqstring> <UCI>,
   <sqstring> <UCI>,
   <stropped> <UCI>;

P<REST-OF-COND> =
   "and" <SC> <REST-OF-ANDC>,
   "or" <SC> <REST-OF-ORC>,
  ;

P<REST-OF-ANDC> =
   "and" <SC> <REST-OF-ANDC>,
  ;

P<REST-OF-ORC> =
   "or" <SC> <REST-OF-ORC>,
  ;

P<CONDITION> =
   <SC> <REST-OF-COND>;

P<SC> =
   <STRING-RESOLUTION>,
   <EXPR> <COMP> <EXPR> <OPT-DOUBLE-SIDED>,
   <NAME> <OPT-ACTUAL-PARAMETERS>,
   '(' <CONDITION> ')',
   "not" <SC>;

P<OPT-DOUBLE-SIDED> =
   <COMP> <EXPR>,
  ;

P<STRING-RESOLUTION> =
   <LVALUE> '-' '>' <STRING-RESOLUTION-EXPR>;

P<STRING-RESOLUTION-EXPR> =
   <STR-MATCH> <OPT-STR-ASSIGN>,
   <STR-ASSIGN> <OPT-STR-MATCH>;

P<STRING-LVALUE> =
   <LVALUE>;

P<STRING-RVALUE> =
   <STRING-LVALUE>,
   <STR-CONST>,
   '(' <STRING-EXPR> ')';

P<STRING-EXPR> =
   <STRING-RVALUE> <REST-OF-STRING-EXPR>;

P<DOTTED-STRING-EXPR> =
   <STRING-RVALUE> <?DOT> <REST-OF-STRING-EXPR>;

P<REST-OF-STRING-EXPR> =
   '.' <STRING-RVALUE> <REST-OF-STRING-EXPR>,
  ;

P<STR-MATCH> =
   '(' <STRING-EXPR> ')';

P<STR-ASSIGN> =
   <STRING-LVALUE>;

P<OPT-STR-ASSIGN> =
   '.' <STR-ASSIGN> <OPT-STR-MATCH>,
  ;

P<OPT-STR-MATCH> =
   '.' <STR-MATCH> <OPT-STR-ASSIGN>,
  ;

P<COMP> =
   '=' '=',
   '=',
   <NOT-EQUALS-ADDRESS>,
   <NOT-EQUALS>,
   '<' '=',
   '<',
   '>' '=',
   '>';

P<NOT-EQUALS> =
   '#',
   '\\' '=',
   '<' '>';

P<NOT-EQUALS-ADDRESS> =
   '#' '#',
   '\\' '=' '=';

P<OPT-ACTUAL-PARAMETERS> =
   <immediate:return !in_const_initialiser_list;> '(' <EXPR> <REST-OF-ACTUAL-PARAMETERS> ')',
  ;

P<REST-OF-ACTUAL-PARAMETERS> =
   ',' <EXPR> <REST-OF-ACTUAL-PARAMETERS>,
  ;

P<CEXPR> =
   <immediate:in_const_initialiser_list = TRUE; return TRUE;> <EXPR> <immediate:in_const_initialiser_list = FALSE; return TRUE;>,
   <immediate:in_const_initialiser_list = FALSE; return FALSE;>;

P<EXPR> =
   <DOTTED-STRING-EXPR>,
   <MEDIUMPREC-EXPR> <REST-OF-EXPR>;

P<REST-OF-EXPR> =
   <OP-LOW> <MEDIUMPREC-EXPR> <REST-OF-EXPR>,
  ;

P<MEDIUMPREC-EXPR> =
   <HIGHPREC-EXPR> <REST-OF-MEDIUMPREC-EXPR>;

P<REST-OF-MEDIUMPREC-EXPR> =
   <OP-MED> <HIGHPREC-EXPR> <REST-OF-MEDIUMPREC-EXPR>,
  ;

P<HIGHPREC-EXPR> =
   <RIGHT-ASSOC-EXPR> <REST-OF-HIGHPREC-EXPR>;

P<REST-OF-HIGHPREC-EXPR> =
   <OP-HIGH-LEFTASSOC> <RIGHT-ASSOC-EXPR> <REST-OF-HIGHPREC-EXPR>,
  ;

P<RIGHT-ASSOC-EXPR> =
   <REST-OF-RIGHTASSOC-EXPR> <UNARY-EXPR>;

P<REST-OF-RIGHTASSOC-EXPR> =
   <RIGHTASSOC-EXPR-with-OP> <REST-OF-RIGHTASSOC-EXPR>,
  ;

P<RIGHTASSOC-EXPR-with-OP> =
   <UNARY-EXPR> <OP-HIGH-RIGHTASSOC>;

P<UNARY-EXPR> =
   <Opt-UNARY-OP> <OPERAND>;

P<Opt-PARAMETERS-OR-POINTERINDEX> =
   <immediate:return !in_const_initialiser_list;> '[' <EXPR> ']',
   <immediate:return !in_const_initialiser_list;> '+' '+' <EXPR>,
   <immediate:return !in_const_initialiser_list;> '-' '-' <EXPR>,
   <OPT-ACTUAL-PARAMETERS>;

P<Opt-RECORDFIELD> =
   <immediate:return !in_const_initialiser_list;> '_' <LVALUE>,
  ;

P<OPERAND> =
   <REAL-CONST>,
   <INT-CONST>,
   <STR-CONST>,
   <LVALUE>,
   '(' <EXPR> ')',
   '|' <EXPR> '|',
   '!' <EXPR> '!';

P<OP-HIGH-LEFTASSOC> =
   '<' '<',
   '>' '>';

P<OP-HIGH-RIGHTASSOC> =
   <INTEGER-EXP>,
   <REAL-EXP>;

P<INTEGER-EXP> =
   '*' '*' '*' '*',
   '\\' '\\',
   '^' '^';

P<eq> =
   '=';

P<REAL-EXP> =
   '*' '*',
   '\\' <!eq>,
   '^';

P<OP-MED> =
   '*',
   '/' '/',
   '/',
   '&';

P<OP-LOW> =
   '+',
   '-',
   '!' '!',
   '!';

P<Opt-UNARY-OP> =
   '+',
   '-',
   <UNARY-NOT>,
  ;

P<UNARY-NOT> =
   '\\',
   '~';

P<Percent-IU> =
   "if",
   "unless";

P<ONE-SWITCH-DECL> =
   <NAME> <Opt-NAME-LIST> '(' <CEXPR> ':' <CEXPR> ')';

P<REST-OF-SWLIST> =
   ',' <ONE-SWITCH-DECL> <REST-OF-SWLIST>,
  ;

P<Opt-NAME-LIST> =
   ',' <NAME> <Opt-NAME-LIST>,
  ;

P<REST-OF-EVENT-LIST> =
   ',' <CEXPR> <REST-OF-EVENT-LIST>,
  ;

P<OPT-event> =
   "event",
  ;

P<FPP> =
   '(' <FORMAL-PARAMETER-DECLARATION> <REST-OF-FORMAL-PARAMETER-LIST> ')',
  ;

P<REST-OF-FORMAL-PARAMETER-LIST> =
   <Opt-Comma> <FORMAL-PARAMETER-DECLARATION> <REST-OF-FORMAL-PARAMETER-LIST>,
  ;

P<FORMAL-PARAMETER-DECLARATION> =
   <XTYPE> <OPT-arrayname> <NAME> <OPT-68K-Bounds> <Opt-NAME-LIST>,
   <RT> <OPT-name> <NAME> <Opt-NAME-LIST> <FPP>,
   "name" <Opt-68K-reg> <NAME> <Opt-NAME-LIST>;

P<Opt-68K-reg> =
   '(' <NAME> ')',
  ;

P<OPT-name> =
   "name",
  ;

P<RT> =
   "routine",
   "predicate",
   <XTYPE> <FN-MAP>;

P<FN-MAP> =
   <FN>,
   "map";

P<FN> =
   "fn",
   "function";

P<longlong> =
   "long" "long",
   "long";

P<BASE-XTYPE> =
   "integer",
   "real",
   "label",
   <longlong> <Opt-BTYPE>,
   "byte" <Opt-INTEGER>,
   "mite" <Opt-INTEGER>,
   "short" <Opt-INTEGER>,
   "half" <Opt-INTEGER>,
   "string" <Opt-STRLEN>,
   "record" <Opt-RFREF>;

P<XTYPE> =
   <OPT-68K-qualifier> <BASE-XTYPE> <OPT-name>;

P<68K-memptr> =
   "read" "only" <68K-memptr>,
   "write" "only" <68K-memptr>,
   "volatile" <68K-memptr>,
  ;

P<OPT-68K-qualifier> =
   <68K-register>,
   <68K-memptr>,
  ;

P<68K-register> =
   "register" '(' <NAME> ')';

P<Opt-RFREF> =
   '(' <RECFMT-REF> ')',
   '(' '*' ')',
  ;

P<RECFMT-REF> =
   <NAME>,
   <RECFMT-DEC> <REST-OF-RECFMT-DEC> <ALT-RECFMT-DEC>;

P<ALT-RECFMT-DEC> =
   "or" <RECFMT-DEC> <REST-OF-RECFMT-DEC> <ALT-RECFMT-DEC>,
  ;

P<REST-OF-RECFMT-DEC> =
   ',' <RECFMT-DEC> <REST-OF-RECFMT-DEC>,
  ;

P<RECFMT-DEC> =
   <XTYPE> <RECFMT-ELMNT>,
   '(' <RECFMT-DEC> <REST-OF-RECFMT-DEC> <ALT-RECFMT-DEC> ')';

P<RECFMT-ELMNT> =
   <OPT-arrayname> <NAME> <Opt-NAME-LIST>,
   "array" <ADECLN-in-record>;

P<ADECLN-in-record> =
   <NAME> <Opt-NAME-LIST> <BPAIR> <REST-OF-ARLIST-in-record>;

P<REST-OF-ARLIST-in-record> =
   ',' <ADECLN-in-record>,
  ;

P<LOWERBOUND> =
   <EXPR>,
   <BASE-XTYPE> <NAME>;

P<UPPERBOUND> =
   '*',
   <EXPR>,
   <BASE-XTYPE> <NAME>;

P<BPAIR> =
   '(' <LOWERBOUND> ':' <UPPERBOUND> <REST-OF-BPLIST> ')';

P<BPAIR68K> =
   '(' <LOWERBOUND> ':' <UPPERBOUND> <REST-OF-BPLIST68K> ')';

P<REST-OF-BPLIST> =
   ',' <EXPR> ':' <EXPR> <REST-OF-BPLIST>,
  ;

P<REST-OF-BPLIST68K> =
   ',' <LOWERBOUND> ':' <UPPERBOUND> <REST-OF-BPLIST68K>,
  ;

P<OPT-arrayname> =
   "array" <Opt-DIMENSIONS> "name",
   "array" <OPT-68K-Bounds> "name",
  ;

P<Opt-DIMENSIONS> =
   '(' <INT-CONST> ')',
  ;

P<Opt-INTEGER> =
   "integer",
  ;

P<Opt-STRLEN> =
   '(' <Opt-STAROREXPR> ')',
  ;

P<REPEATS> =
   '(' <Opt-STAROREXPR> ')',
  ;

P<Opt-STAROREXPR> =
   <STAROREXPR>,
  ;

P<STAROREXPR> =
   <CEXPR>,
   '*';

P<Opt-BTYPE> =
   "real",
   "integer",
   "long" "real",
  ;

P<Opt-Comma> =
   ',',
  ;

P<Opt-ALIAS> =
   "alias" <TEXTTEXT>,
  ;

P<TEXTTEXT> =
   <dqstring>;

P<Percent-SEX> =
   "system",
   "external",
   "dynamic",
   "prim",
   "perm",
  ;

P<RECFMT-spec-OR-BODY> =
   "spec" <NAME>,
   <NAME> '(' <RECFMT-DEC> <REST-OF-RECFMT-DEC> <ALT-RECFMT-DEC> ')';

P<DECLN> =
   <OPT-arrayname> <OPT-spec> <NAME-or-STAR-68K> <OPT-68K-Bounds> <Opt-Init-assign> <Opt-Assign-NAME-LIST>,
   "array" <OPT-spec> <OPT-format> <NAME> <Opt-NAME-LIST> <BPAIR> <REST-OF-ARLIST>,
   "array" <BPAIR> <OPT-spec> <OPT-format> <NAME> <Opt-NAME-LIST> <REST-OF-ARLIST-68K>;

P<OWNDEC> =
   <OPT-arrayname> <OPT-spec> <SINGLE-OWNDEC> <REST-OF-OWNDEC>,
   "array" <OPT-format> <OPT-spec> <BPAIR> <NAME> <Opt-Init-assign-array>,
   "array" <OPT-format> <OPT-spec> <NAME> <BPAIR> <Opt-Init-assign-array>;

P<REST-OF-ARLIST> =
   ',' <NAME> <Opt-NAME-LIST> <BPAIR> <REST-OF-ARLIST>,
  ;

P<REST-OF-ARLIST-68K> =
   ',' <NAME> <Opt-NAME-LIST> <REST-OF-ARLIST-68K>,
  ;

P<OPT-68K-Bounds> =
   <BPAIR68K>,
  ;

P<OPT-format> =
   "format",
  ;

P<NAME-or-STAR-68K> =
   '*',
   <NAME>;

P<Opt-Assign-NAME-LIST> =
   ',' '*' <Opt-Assign-NAME-LIST>,
   ',' <NAME> <Opt-Init-assign> <Opt-Assign-NAME-LIST>,
  ;

P<Opt-Init-assign> =
   <ASSOP-EXPR>,
  ;

P<ASSOP> =
   '=' '=',
   <SCALAR-ASSIGN>;

P<ASSOP-EXPR> =
   '=' '=' <LVALUE>,
   <SCALAR-ASSIGN> <EXPR>;

P<LVALUE> =
   <NAME> <Opt-PARAMETERS-OR-POINTERINDEX> <Opt-RECORDFIELD>;

P<Opt-Init-assign-array> =
   <ASSOP> <stupid> <ARRAY-INITIALISER> <ROCL>,
  ;

P<Percent-WU> =
   "while" <CONDITION>,
   "until" <CONDITION>;

P<Percent-WUF> =
   "while" <CONDITION>,
   "until" <CONDITION>,
   "for" <NAME> <SCALAR-ASSIGN> <EXPR> ',' <EXPR> ',' <EXPR>;

P<SCALAR-ASSIGN> =
   '=',
   '<' '-';

P<Opt-UNTIL> =
   "until" <CONDITION>,
  ;

P<Opt-CYCPARM> =
   <NAME> <SCALAR-ASSIGN> <EXPR> ',' <EXPR> ',' <EXPR>,
  ;

P<OPEXPR2> =
   ',' <OPT-EXPR> <OPEXPR>,
  ;

P<OPT-EXPR> =
   <EXPR>,
  ;

P<OPEXPR> =
   ',' <OPT-EXPR> <OPSTRING>,
  ;

P<OPSTRING> =
   ',' <STRING-EXPR>,
  ;

P<REST-OF-SS1> =
   <Percent-IU> <CONDITION> <S>,
   <Percent-WUF> <S>,
   <S>,
  ;

P<REST-OF-OWNDEC> =
   ',' <SINGLE-OWNDEC> <REST-OF-OWNDEC>,
  ;

P<SINGLE-OWNDEC> =
   <NAME> <Opt-ALIAS> <Opt-Init-assign>;

P<ROCL> =
   ',' <stupid> <ARRAY-INITIALISER> <ROCL>,
  ;

P<ARRAY-INITIALISER> =
   <CEXPR> <REPEATS>;

P<stupid> =
   <COMMENT>,
  ;

P<XOWN> =
   "own",
   "external",
   "extrinsic",
   "constant",
   "const";

E