gcc/m2/mc-boot/Gmcp5.cc

   1 /* do not edit automatically generated by mc from mcp5.  */
   2 /* output from mc-5.bnf, automatically generated do not edit.
   3
   4 Copyright (C) 2016-2025 Free Software Foundation, Inc.
   5 Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
   6
   7 This file is part of GNU Modula-2.
   8
   9 GNU Modula-2 is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GNU Modula-2 is distributed in the hope that it will be useful, but
  15 WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU Modula-2; see the file COPYING.  If not,
  21 see <https://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include <stdbool.h>
  26 #   if !defined (PROC_D)
  27 #      define PROC_D
  28        typedef void (*PROC_t) (void);
  29        typedef struct { PROC_t proc; } PROC;
  30 #   endif
  31
  32 #   if !defined (TRUE)
  33 #      define TRUE (1==1)
  34 #   endif
  35
  36 #   if !defined (FALSE)
  37 #      define FALSE (1==0)
  38 #   endif
  39
  40 #if defined(__cplusplus)
  41 #   undef NULL
  42 #   define NULL 0
  43 #endif
  44 #define _mcp5_C
  45
  46 #include "Gmcp5.h"
  47 #   include "GDynamicStrings.h"
  48 #   include "GmcError.h"
  49 #   include "GnameKey.h"
  50 #   include "GmcPrintf.h"
  51 #   include "GmcDebug.h"
  52 #   include "GmcReserved.h"
  53 #   include "GmcComment.h"
  54 #   include "GmcMetaError.h"
  55 #   include "GmcStack.h"
  56 #   include "GmcLexBuf.h"
  57 #   include "Gdecl.h"
  58
  59 #   define Pass1 false
  60 #   define Debugging false
  61 typedef unsigned int mcp5_stop0;
  62
  63 typedef unsigned int mcp5_SetOfStop0;
  64
  65 typedef unsigned int mcp5_stop1;
  66
  67 typedef unsigned int mcp5_SetOfStop1;
  68
  69 typedef unsigned int mcp5_stop2;
  70
  71 typedef unsigned int mcp5_SetOfStop2;
  72
  73 static bool WasNoError;
  74 static nameKey_Name curstring;
  75 static nameKey_Name curident;
  76 static decl_node curproc;
  77 static decl_node frommodule;
  78 static decl_node qualid;
  79 static decl_node typeDes;
  80 static decl_node typeExp;
  81 static decl_node curmodule;
  82 static unsigned int loopNo;
  83 static mcStack_stack loopStk;
  84 static mcStack_stack stmtStk;
  85 static mcStack_stack withStk;
  86 static mcStack_stack stk;
  87
  88 /*
  89    CompilationUnit - returns TRUE if the input was correct enough to parse
  90                      in future passes.
  91 */
  92
  93 extern "C" bool mcp5_CompilationUnit (void);
  94
  95 /*
  96    followNode -
  97 */
  98
  99 static void followNode (decl_node n);
 100
 101 /*
 102    push -
 103 */
 104
 105 static decl_node push (decl_node n);
 106
 107 /*
 108    pop -
 109 */
 110
 111 static decl_node pop (void);
 112
 113 /*
 114    replace -
 115 */
 116
 117 static decl_node replace (decl_node n);
 118
 119 /*
 120    peep - returns the top node on the stack without removing it.
 121 */
 122
 123 static decl_node peep (void);
 124
 125 /*
 126    depth - returns the depth of the stack.
 127 */
 128
 129 static unsigned int depth (void);
 130
 131 /*
 132    checkDuplicate -
 133 */
 134
 135 static void checkDuplicate (bool b);
 136
 137 /*
 138    isQualident - returns TRUE if, n, is a qualident.
 139 */
 140
 141 static bool isQualident (decl_node n);
 142
 143 /*
 144    startWith -
 145 */
 146
 147 static void startWith (decl_node n);
 148
 149 /*
 150    endWith -
 151 */
 152
 153 static void endWith (void);
 154
 155 /*
 156    lookupWithSym -
 157 */
 158
 159 static decl_node lookupWithSym (nameKey_Name i);
 160
 161 /*
 162    pushStmt - push a node, n, to the statement stack and return node, n.
 163 */
 164
 165 static decl_node pushStmt (decl_node n);
 166
 167 /*
 168    popStmt - pop the top node from the statement stack.
 169 */
 170
 171 static decl_node popStmt (void);
 172
 173 /*
 174    peepStmt - return the top node from the statement stack,
 175               but leave the stack unchanged.
 176 */
 177
 178 static decl_node peepStmt (void);
 179
 180 /*
 181    pushLoop - push a node, n, to the loop stack and return node, n.
 182 */
 183
 184 static decl_node pushLoop (decl_node n);
 185
 186 /*
 187    popLoop - pop the top node from the loop stack.
 188 */
 189
 190 static decl_node popLoop (void);
 191
 192 /*
 193    peepLoop - return the top node from the loop stack,
 194               but leave the stack unchanged.
 195 */
 196
 197 static decl_node peepLoop (void);
 198
 199 /*
 200    peepLoop - return the top node from the loop stack,
 201               but leave the stack unchanged.
 202 */
 203
 204 static void ErrorString (DynamicStrings_String s);
 205
 206 /*
 207    peepLoop - return the top node from the loop stack,
 208               but leave the stack unchanged.
 209 */
 210
 211 static void ErrorArray (const char *a_, unsigned int _a_high);
 212
 213 /*
 214    pushNunbounded -
 215 */
 216
 217 static void pushNunbounded (unsigned int c);
 218
 219 /*
 220    makeIndexedArray - builds and returns an array of type, t, with, c, indices.
 221 */
 222
 223 static decl_node makeIndexedArray (unsigned int c, decl_node t);
 224
 225 /*
 226    importInto - from, m, import, name, into module, current.
 227                 It checks to see if curident is an enumeration type
 228                 and if so automatically includes all enumeration fields
 229                 as well.
 230 */
 231
 232 static void importInto (decl_node m, nameKey_Name name, decl_node current);
 233
 234 /*
 235    checkEndName - if module does not have, name, then issue an error containing, desc.
 236 */
 237
 238 static void checkEndName (decl_node module, nameKey_Name name, const char *desc_, unsigned int _desc_high);
 239
 240 /*
 241    DescribeStop - issues a message explaining what tokens were expected
 242 */
 243
 244 static DynamicStrings_String DescribeStop (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 245
 246 /*
 247    DescribeError - issues a message explaining what tokens were expected
 248 */
 249
 250 static void DescribeError (void);
 251
 252 /*
 253    SyntaxError - after a syntax error we skip all tokens up until we reach
 254                  a stop symbol.
 255 */
 256
 257 static void SyntaxError (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 258
 259 /*
 260    SyntaxCheck -
 261 */
 262
 263 static void SyntaxCheck (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 264
 265 /*
 266    WarnMissingToken - generates a warning message about a missing token, t.
 267 */
 268
 269 static void WarnMissingToken (mcReserved_toktype t);
 270
 271 /*
 272    MissingToken - generates a warning message about a missing token, t.
 273 */
 274
 275 static void MissingToken (mcReserved_toktype t);
 276
 277 /*
 278    CheckAndInsert -
 279 */
 280
 281 static bool CheckAndInsert (mcReserved_toktype t, mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 282
 283 /*
 284    InStopSet
 285 */
 286
 287 static bool InStopSet (mcReserved_toktype t, mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 288
 289 /*
 290    PeepToken - peep token checks to see whether the stopset is satisfied by currenttoken
 291                If it is not then it will insert a token providing the token
 292                is one of ; ] ) } . OF END ,
 293
 294                if the stopset contains <identtok> then we do not insert a token
 295 */
 296
 297 static void PeepToken (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 298
 299 /*
 300    Expect -
 301 */
 302
 303 static void Expect (mcReserved_toktype t, mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 304
 305 /*
 306    Ident - error checking varient of Ident
 307 */
 308
 309 static void Ident (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 310
 311 /*
 312    string -
 313 */
 314
 315 static void string (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 316
 317 /*
 318    Integer -
 319 */
 320
 321 static void Integer (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 322
 323 /*
 324    Real -
 325 */
 326
 327 static void Real (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 328
 329 /*
 330    FileUnit := DefinitionModule  |
 331                ImplementationOrProgramModule
 332
 333    first  symbols:implementationtok, moduletok, definitiontok
 334
 335    cannot reachend
 336 */
 337
 338 static void FileUnit (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 339
 340 /*
 341    ProgramModule := 'MODULE' Ident
 342                     % curmodule := lookupModule (curident)  %
 343
 344                     % addCommentBody (curmodule)  %
 345
 346                     % enterScope (curmodule)  %
 347
 348                     % resetConstExpPos (curmodule)  %
 349                     [ Priority  ] ';' { Import  } Block
 350                     Ident
 351                     % checkEndName (curmodule, curident, 'program module')  %
 352
 353                     % leaveScope  %
 354                     '.'
 355
 356    first  symbols:moduletok
 357
 358    cannot reachend
 359 */
 360
 361 static void ProgramModule (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 362
 363 /*
 364    ImplementationModule := 'IMPLEMENTATION' 'MODULE'
 365                            Ident
 366                            % curmodule := lookupImp (curident)  %
 367
 368                            % addCommentBody (curmodule)  %
 369
 370                            % enterScope (lookupDef (curident))  %
 371
 372                            % enterScope (curmodule)  %
 373
 374                            % resetConstExpPos (curmodule)  %
 375                            [ Priority  ] ';' { Import  }
 376                            Block Ident
 377                            % checkEndName (curmodule, curident, 'implementation module')  %
 378
 379                            % leaveScope ; leaveScope  %
 380                            '.'
 381
 382    first  symbols:implementationtok
 383
 384    cannot reachend
 385 */
 386
 387 static void ImplementationModule (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 388
 389 /*
 390    ImplementationOrProgramModule := ImplementationModule  |
 391                                     ProgramModule
 392
 393    first  symbols:moduletok, implementationtok
 394
 395    cannot reachend
 396 */
 397
 398 static void ImplementationOrProgramModule (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 399
 400 /*
 401    ConstInteger := Integer
 402                    % VAR i: node ;  %
 403
 404                    % i := pop ()  %
 405
 406
 407    first  symbols:integertok
 408
 409    cannot reachend
 410 */
 411
 412 static void ConstInteger (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 413
 414 /*
 415    ConstReal := Real
 416                 % VAR r: node ;  %
 417
 418                 % r := pop ()  %
 419
 420
 421    first  symbols:realtok
 422
 423    cannot reachend
 424 */
 425
 426 static void ConstReal (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 427
 428 /*
 429    ConstNumber := ConstInteger  | ConstReal
 430
 431    first  symbols:realtok, integertok
 432
 433    cannot reachend
 434 */
 435
 436 static void ConstNumber (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 437
 438 /*
 439    Number := Integer  | Real
 440
 441    first  symbols:realtok, integertok
 442
 443    cannot reachend
 444 */
 445
 446 static void Number (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 447
 448 /*
 449    Qualident := Ident { '.' Ident  }
 450
 451    first  symbols:identtok
 452
 453    cannot reachend
 454 */
 455
 456 static void Qualident (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 457
 458 /*
 459    ConstantDeclaration := Ident '=' ConstExpressionNop
 460
 461    first  symbols:identtok
 462
 463    cannot reachend
 464 */
 465
 466 static void ConstantDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 467
 468 /*
 469    ConstExpressionNop :=
 470                          % VAR c: node ;  %
 471
 472                          % c := getNextConstExp ()  %
 473                          SimpleConstExpr [ Relation
 474                                            SimpleConstExpr  ]
 475
 476    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
 477
 478    cannot reachend
 479 */
 480
 481 static void ConstExpressionNop (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 482
 483 /*
 484    ConstExpression :=
 485                       % VAR c: node ;  %
 486
 487                       % c := push (getNextConstExp ())  %
 488                       SimpleConstExpr [ Relation SimpleConstExpr  ]
 489
 490    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
 491
 492    cannot reachend
 493 */
 494
 495 static void ConstExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 496
 497 /*
 498    Relation := '='  | '#'  | '<>'  | '<'  | '<='  |
 499                '>'  | '>='  | 'IN'
 500
 501    first  symbols:intok, greaterequaltok, greatertok, lessequaltok, lesstok, lessgreatertok, hashtok, equaltok
 502
 503    cannot reachend
 504 */
 505
 506 static void Relation (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 507
 508 /*
 509    SimpleConstExpr := UnaryOrConstTerm { AddOperator
 510                                          ConstTerm  }
 511
 512    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
 513
 514    cannot reachend
 515 */
 516
 517 static void SimpleConstExpr (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 518
 519 /*
 520    UnaryOrConstTerm := '+' ConstTerm  |
 521                        '-' ConstTerm  |
 522                        ConstTerm
 523
 524    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
 525
 526    cannot reachend
 527 */
 528
 529 static void UnaryOrConstTerm (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 530
 531 /*
 532    AddOperator := '+'  | '-'  | 'OR'
 533
 534    first  symbols:ortok, minustok, plustok
 535
 536    cannot reachend
 537 */
 538
 539 static void AddOperator (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 540
 541 /*
 542    ConstTerm := ConstFactor { MulOperator ConstFactor  }
 543
 544    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok
 545
 546    cannot reachend
 547 */
 548
 549 static void ConstTerm (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 550
 551 /*
 552    MulOperator := '*'  | '/'  | 'DIV'  | 'MOD'  |
 553                   'REM'  | 'AND'  | '&'
 554
 555    first  symbols:ambersandtok, andtok, remtok, modtok, divtok, dividetok, timestok
 556
 557    cannot reachend
 558 */
 559
 560 static void MulOperator (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 561
 562 /*
 563    NotConstFactor := 'NOT' ConstFactor
 564                      % VAR n: node ;  %
 565
 566                      % n := push (makeUnaryTok (nottok, pop ()))  %
 567
 568
 569    first  symbols:nottok
 570
 571    cannot reachend
 572 */
 573
 574 static void NotConstFactor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 575
 576 /*
 577    ConstFactor := ConstNumber  | ConstString  |
 578                   ConstSetOrQualidentOrFunction  |
 579                   '(' ConstExpressionNop ')'  |
 580                   NotConstFactor  |
 581                   ConstAttribute
 582
 583    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok
 584
 585    cannot reachend
 586 */
 587
 588 static void ConstFactor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 589
 590 /*
 591    ConstString := string
 592
 593    first  symbols:stringtok
 594
 595    cannot reachend
 596 */
 597
 598 static void ConstString (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 599
 600 /*
 601    ConstComponentElement := ConstExpressionNop [ '..'
 602                                                  ConstExpressionNop  ]
 603
 604    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
 605
 606    cannot reachend
 607 */
 608
 609 static void ConstComponentElement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 610
 611 /*
 612    ConstComponentValue := ConstComponentElement [ 'BY'
 613                                                   ConstExpressionNop  ]
 614
 615    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
 616
 617    cannot reachend
 618 */
 619
 620 static void ConstComponentValue (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 621
 622 /*
 623    ConstArraySetRecordValue := ConstComponentValue
 624                                { ',' ConstComponentValue  }
 625
 626    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
 627
 628    cannot reachend
 629 */
 630
 631 static void ConstArraySetRecordValue (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 632
 633 /*
 634    ConstConstructor := '{' [ ConstArraySetRecordValue  ]
 635                        '}'
 636
 637    first  symbols:lcbratok
 638
 639    cannot reachend
 640 */
 641
 642 static void ConstConstructor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 643
 644 /*
 645    ConstSetOrQualidentOrFunction := Qualident [ ConstConstructor  |
 646                                                 ConstActualParameters  ]  |
 647                                     ConstConstructor
 648
 649    first  symbols:lcbratok, identtok
 650
 651    cannot reachend
 652 */
 653
 654 static void ConstSetOrQualidentOrFunction (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 655
 656 /*
 657    ConstActualParameters := '(' [ ConstExpList  ] ')'
 658
 659    first  symbols:lparatok
 660
 661    cannot reachend
 662 */
 663
 664 static void ConstActualParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 665
 666 /*
 667    ConstExpList := ConstExpressionNop { ',' ConstExpressionNop  }
 668
 669    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
 670
 671    cannot reachend
 672 */
 673
 674 static void ConstExpList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 675
 676 /*
 677    ConstAttribute := '__ATTRIBUTE__' '__BUILTIN__'
 678                      '(' '(' ConstAttributeExpression
 679                      ')' ')'
 680
 681    first  symbols:attributetok
 682
 683    cannot reachend
 684 */
 685
 686 static void ConstAttribute (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 687
 688 /*
 689    ConstAttributeExpression := Ident  | '<' Qualident
 690                                ',' Ident '>'
 691
 692    first  symbols:lesstok, identtok
 693
 694    cannot reachend
 695 */
 696
 697 static void ConstAttributeExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 698
 699 /*
 700    ByteAlignment := ''
 701
 702    first  symbols:ldirectivetok
 703
 704    cannot reachend
 705 */
 706
 707 static void ByteAlignment (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 708
 709 /*
 710    OptAlignmentExpression := [ AlignmentExpression  ]
 711
 712    first  symbols:lparatok
 713
 714    reachend
 715 */
 716
 717 static void OptAlignmentExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 718
 719 /*
 720    AlignmentExpression := '(' ConstExpressionNop ')'
 721
 722    first  symbols:lparatok
 723
 724    cannot reachend
 725 */
 726
 727 static void AlignmentExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 728
 729 /*
 730    Alignment := [ ByteAlignment  ]
 731
 732    first  symbols:ldirectivetok
 733
 734    reachend
 735 */
 736
 737 static void Alignment (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 738
 739 /*
 740    IdentList := Ident { ',' Ident  }
 741
 742    first  symbols:identtok
 743
 744    cannot reachend
 745 */
 746
 747 static void IdentList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 748
 749 /*
 750    SubrangeType := '[' ConstExpressionNop '..' ConstExpressionNop
 751                    ']'
 752
 753    first  symbols:lsbratok
 754
 755    cannot reachend
 756 */
 757
 758 static void SubrangeType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 759
 760 /*
 761    ArrayType := 'ARRAY' SimpleType { ',' SimpleType  }
 762                 'OF' Type
 763
 764    first  symbols:arraytok
 765
 766    cannot reachend
 767 */
 768
 769 static void ArrayType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 770
 771 /*
 772    RecordType := 'RECORD' [ DefaultRecordAttributes  ]
 773                  FieldListSequence 'END'
 774
 775    first  symbols:recordtok
 776
 777    cannot reachend
 778 */
 779
 780 static void RecordType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 781
 782 /*
 783    DefaultRecordAttributes := ''
 784
 785    first  symbols:ldirectivetok
 786
 787    cannot reachend
 788 */
 789
 790 static void DefaultRecordAttributes (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 791
 792 /*
 793    RecordFieldPragma := [ ''  ]
 794
 795    first  symbols:ldirectivetok
 796
 797    reachend
 798 */
 799
 800 static void RecordFieldPragma (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 801
 802 /*
 803    FieldPragmaExpression := Ident PragmaConstExpression
 804
 805    first  symbols:identtok
 806
 807    cannot reachend
 808 */
 809
 810 static void FieldPragmaExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 811
 812 /*
 813    PragmaConstExpression := [ '(' ConstExpressionNop
 814                               ')'  ]
 815
 816    first  symbols:lparatok
 817
 818    reachend
 819 */
 820
 821 static void PragmaConstExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 822
 823 /*
 824    AttributeExpression := Ident '(' ConstExpressionNop
 825                           ')'
 826
 827    first  symbols:identtok
 828
 829    cannot reachend
 830 */
 831
 832 static void AttributeExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 833
 834 /*
 835    FieldListSequence := FieldListStatement { ';' FieldListStatement  }
 836
 837    first  symbols:casetok, identtok, semicolontok
 838
 839    reachend
 840 */
 841
 842 static void FieldListSequence (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 843
 844 /*
 845    FieldListStatement := [ FieldList  ]
 846
 847    first  symbols:identtok, casetok
 848
 849    reachend
 850 */
 851
 852 static void FieldListStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 853
 854 /*
 855    FieldList := IdentList ':' Type RecordFieldPragma  |
 856                 'CASE' CaseTag 'OF' Varient { '|' Varient  }
 857                 [ 'ELSE' FieldListSequence  ] 'END'
 858
 859    first  symbols:casetok, identtok
 860
 861    cannot reachend
 862 */
 863
 864 static void FieldList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 865
 866 /*
 867    TagIdent := Ident  |
 868                % curident := NulName  %
 869
 870
 871    first  symbols:identtok
 872
 873    reachend
 874 */
 875
 876 static void TagIdent (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 877
 878 /*
 879    CaseTag := TagIdent [ ':' Qualident  ]
 880
 881    first  symbols:colontok, identtok
 882
 883    reachend
 884 */
 885
 886 static void CaseTag (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 887
 888 /*
 889    Varient := [ VarientCaseLabelList ':' FieldListSequence  ]
 890
 891    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
 892
 893    reachend
 894 */
 895
 896 static void Varient (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 897
 898 /*
 899    VarientCaseLabelList := VarientCaseLabels { ','
 900                                                VarientCaseLabels  }
 901
 902    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
 903
 904    cannot reachend
 905 */
 906
 907 static void VarientCaseLabelList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 908
 909 /*
 910    VarientCaseLabels := ConstExpressionNop [ '..' ConstExpressionNop  ]
 911
 912    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
 913
 914    cannot reachend
 915 */
 916
 917 static void VarientCaseLabels (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 918
 919 /*
 920    SetType := ( 'SET'  | 'PACKEDSET'  ) 'OF' SimpleType
 921
 922    first  symbols:oftok, packedsettok, settok
 923
 924    cannot reachend
 925 */
 926
 927 static void SetType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 928
 929 /*
 930    PointerType := 'POINTER' 'TO' Type
 931
 932    first  symbols:pointertok
 933
 934    cannot reachend
 935 */
 936
 937 static void PointerType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 938
 939 /*
 940    ProcedureType := 'PROCEDURE' [ FormalTypeList  ]
 941
 942    first  symbols:proceduretok
 943
 944    cannot reachend
 945 */
 946
 947 static void ProcedureType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 948
 949 /*
 950    FormalTypeList := '(' ( ')' FormalReturn  |
 951                            ProcedureParameters ')'
 952                            FormalReturn  )
 953
 954    first  symbols:lparatok
 955
 956    cannot reachend
 957 */
 958
 959 static void FormalTypeList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 960
 961 /*
 962    FormalReturn := [ ':' OptReturnType  ]
 963
 964    first  symbols:colontok
 965
 966    reachend
 967 */
 968
 969 static void FormalReturn (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 970
 971 /*
 972    OptReturnType := '[' Qualident ']'  |
 973                     Qualident
 974
 975    first  symbols:identtok, lsbratok
 976
 977    cannot reachend
 978 */
 979
 980 static void OptReturnType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 981
 982 /*
 983    ProcedureParameters := ProcedureParameter { ','
 984                                                ProcedureParameter  }
 985
 986    first  symbols:identtok, arraytok, periodperiodperiodtok, vartok
 987
 988    cannot reachend
 989 */
 990
 991 static void ProcedureParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
 992
 993 /*
 994    ProcedureParameter := '...'  | 'VAR' FormalType  |
 995                          FormalType
 996
 997    first  symbols:arraytok, identtok, vartok, periodperiodperiodtok
 998
 999    cannot reachend
1000 */
1001
1002 static void ProcedureParameter (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1003
1004 /*
1005    VarIdent := Ident [ '[' ConstExpressionNop ']'  ]
1006
1007    first  symbols:identtok
1008
1009    cannot reachend
1010 */
1011
1012 static void VarIdent (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1013
1014 /*
1015    VarIdentList := VarIdent { ',' VarIdent  }
1016
1017    first  symbols:identtok
1018
1019    cannot reachend
1020 */
1021
1022 static void VarIdentList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1023
1024 /*
1025    VariableDeclaration := VarIdentList ':' Type Alignment
1026
1027    first  symbols:identtok
1028
1029    cannot reachend
1030 */
1031
1032 static void VariableDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1033
1034 /*
1035    Designator := PushQualident { SubDesignator  }
1036
1037    first  symbols:identtok
1038
1039    cannot reachend
1040 */
1041
1042 static void Designator (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1043
1044 /*
1045    SubDesignator :=
1046                     % VAR n, field, type: node ;  %
1047
1048                     % n := peep ()  %
1049
1050                     % IF n = NIL
1051                       THEN
1052                                                                                              ErrorArray ('no expression found') ;
1053                          flushErrors ;
1054                          RETURN
1055                       END  %
1056
1057                     % type := skipType (getType (n))  %
1058                     ( '.' Ident
1059                       % IF isRecord (type)
1060                         THEN
1061                            field := lookupInScope (type, curident) ;
1062                            IF field = NIL
1063                            THEN
1064                               metaError2 ('field {%1k} cannot be found in record {%2ad}', curident, type)
1065                            ELSE
1066                               n := replace (makeComponentRef (n, field))
1067                            END
1068                         ELSE
1069                            metaError2 ('attempting to access a field {%1k} from {%2ad} which does not have a record type', curident, type)
1070                         END  %
1071                        | '[' ArrayExpList
1072                       % IF isArray (type)
1073                         THEN
1074                            n := replace (makeArrayRef (n, pop ()))
1075                         ELSE
1076                            metaError1 ('attempting to access an array but the expression is not an array but a {%1d}', type)
1077                         END  %
1078                       ']'  | SubPointer  )
1079
1080    first  symbols:uparrowtok, lsbratok, periodtok
1081
1082    cannot reachend
1083 */
1084
1085 static void SubDesignator (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1086
1087 /*
1088    SubPointer :=
1089                  % VAR n, field, type: node ;  %
1090
1091                  % n := peep ()  %
1092
1093                  % type := skipType (getType (n))  %
1094                  '^' ( '.' Ident
1095                        % IF isPointer (type)
1096                          THEN
1097                                                                                                      type := skipType (getType (type)) ;
1098                                                                                                      IF isRecord (type)
1099                             THEN
1100                                field := lookupInScope (type, curident) ;
1101                                IF field = NIL
1102                                THEN
1103                                   metaError2 ('field {%1k} cannot be found in record {%2ad}', curident, type)
1104                                ELSE
1105                                   n := replace (makePointerRef (n, field))
1106                                END
1107                             ELSE
1108                                metaError2 ('attempting to access a field {%1k} from {%2ad} which does not have a record type', curident, type)
1109                             END
1110                          ELSE
1111                             metaError2 ('trying to dereference {%1k} which was not declared as a pointer but a {%2tad}', n, n)
1112                          END  %
1113                         |
1114                        % IF isPointer (type)
1115                          THEN
1116                             n := replace (makeDeRef (n))
1117                          ELSE
1118                             metaError1 ('attempting to dereference a pointer but the expression is not a pointer but a {%1d}', type)
1119                          END  %
1120                         )
1121
1122    first  symbols:uparrowtok
1123
1124    cannot reachend
1125 */
1126
1127 static void SubPointer (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1128
1129 /*
1130    ArrayExpList :=
1131                    % VAR l: node ;  %
1132
1133                    % l := push (makeExpList ())  %
1134                    Expression
1135                    % putExpList (l, pop ())  %
1136
1137                    % assert (isExpList (peep ()))  %
1138                    { ',' Expression
1139                      % putExpList (l, pop ())  %
1140
1141                      % assert (isExpList (peep ()))  %
1142                       }
1143
1144    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
1145
1146    cannot reachend
1147 */
1148
1149 static void ArrayExpList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1150
1151 /*
1152    ExpList :=
1153               % VAR p, n: node ;  %
1154
1155               % p := peep ()  %
1156
1157               % assert (isExpList (p))  %
1158               Expression
1159               % putExpList (p, pop ())  %
1160
1161               % assert (isExpList (peep ()))  %
1162               { ',' Expression
1163                 % putExpList (p, pop ())  %
1164
1165                 % assert (isExpList (peep ()))  %
1166                  }
1167
1168    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
1169
1170    cannot reachend
1171 */
1172
1173 static void ExpList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1174
1175 /*
1176    Expression :=
1177                  % VAR c, l, r: node ; op: toktype ;  %
1178                  SimpleExpression
1179                  % op := currenttoken  %
1180                  [ Relation
1181                    % l := pop ()  %
1182                    SimpleExpression
1183                    % r := pop ()  %
1184
1185                    % r := push (makeBinaryTok (op, l, r))  %
1186                     ]
1187
1188    first  symbols:identtok, lcbratok, nottok, lparatok, stringtok, integertok, realtok, minustok, plustok
1189
1190    cannot reachend
1191 */
1192
1193 static void Expression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1194
1195 /*
1196    SimpleExpression :=
1197                        % VAR op: toktype ; n: node ;  %
1198                        UnaryOrTerm {
1199                                      % op := currenttoken  %
1200
1201                                      % n := pop ()  %
1202                                      AddOperator Term
1203
1204                                      % n := push (makeBinaryTok (op, n, pop ()))  %
1205                                       }
1206
1207    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
1208
1209    cannot reachend
1210 */
1211
1212 static void SimpleExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1213
1214 /*
1215    UnaryOrTerm :=
1216                   % VAR n: node ;  %
1217                   '+' Term
1218                   % n := push (makeUnaryTok (plustok, pop ()))  %
1219                    | '-' Term
1220                   % n := push (makeUnaryTok (minustok, pop ()))  %
1221                    | Term
1222
1223    first  symbols:identtok, lcbratok, nottok, lparatok, stringtok, integertok, realtok, minustok, plustok
1224
1225    cannot reachend
1226 */
1227
1228 static void UnaryOrTerm (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1229
1230 /*
1231    Term :=
1232            % VAR op: toktype ; n: node ;  %
1233            Factor {
1234                     % op := currenttoken  %
1235                     MulOperator
1236                     % n := pop ()  %
1237                     Factor
1238                     % n := push (makeBinaryTok (op, n, pop ()))  %
1239                      }
1240
1241    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok
1242
1243    cannot reachend
1244 */
1245
1246 static void Term (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1247
1248 /*
1249    PushString := string
1250                  % VAR n: node ;  %
1251
1252                  % n := push (makeString (curstring))  %
1253
1254
1255    first  symbols:stringtok
1256
1257    cannot reachend
1258 */
1259
1260 static void PushString (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1261
1262 /*
1263    Factor := Number  | PushString  | SetOrDesignatorOrFunction  |
1264              '(' Expression ')'  |
1265              'NOT' ( Factor
1266                      % VAR n: node ;  %
1267
1268                      % n := push (makeUnaryTok (nottok, pop ()))  %
1269                       | ConstAttribute
1270                      % n := push (makeUnaryTok (nottok, pop ()))  %
1271                       )
1272
1273    first  symbols:identtok, lcbratok, nottok, lparatok, stringtok, integertok, realtok
1274
1275    cannot reachend
1276 */
1277
1278 static void Factor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1279
1280 /*
1281    ComponentElement := Expression
1282                        % VAR l, h, n: node ;  %
1283
1284                        % l := pop ()  %
1285
1286                        % h := NIL  %
1287                        [ '..' Expression
1288                          % h := pop ()  %
1289
1290                          % ErrorArray ('implementation restriction range is not allowed')  %
1291                           ]
1292                        % n := push (includeSetValue (pop (), l, h))  %
1293
1294
1295    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
1296
1297    cannot reachend
1298 */
1299
1300 static void ComponentElement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1301
1302 /*
1303    ComponentValue := ComponentElement [ 'BY'
1304                                         % ErrorArray ('implementation restriction BY not allowed')  %
1305                                         Expression  ]
1306
1307    first  symbols:identtok, lcbratok, nottok, lparatok, stringtok, integertok, realtok, minustok, plustok
1308
1309    cannot reachend
1310 */
1311
1312 static void ComponentValue (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1313
1314 /*
1315    ArraySetRecordValue := ComponentValue { ',' ComponentValue  }
1316
1317    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
1318
1319    cannot reachend
1320 */
1321
1322 static void ArraySetRecordValue (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1323
1324 /*
1325    Constructor := '{'
1326                   % VAR n: node ;  %
1327
1328                   % n := push (makeSetValue ())  %
1329                   [ ArraySetRecordValue  ] '}'
1330
1331    first  symbols:lcbratok
1332
1333    cannot reachend
1334 */
1335
1336 static void Constructor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1337
1338 /*
1339    SetOrDesignatorOrFunction := PushQualident
1340                                 % VAR q, p, n: node ;  %
1341                                 [ Constructor
1342                                   % p := pop ()  %
1343
1344                                   % q := pop ()  %
1345
1346                                   % n := push (putSetValue (p, q))  %
1347                                    | SimpleDes [
1348                                                  % q := pop ()  %
1349                                                  ActualParameters
1350
1351                                                  % p := pop ()  %
1352
1353                                                  % p := push (makeFuncCall (q, p))  %
1354                                                   ]  ]  |
1355                                 Constructor
1356
1357    first  symbols:identtok, lcbratok
1358
1359    cannot reachend
1360 */
1361
1362 static void SetOrDesignatorOrFunction (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1363
1364 /*
1365    SimpleDes := { SubDesignator  }
1366
1367    first  symbols:uparrowtok, periodtok, lsbratok
1368
1369    reachend
1370 */
1371
1372 static void SimpleDes (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1373
1374 /*
1375    ActualParameters := '('
1376                        % VAR n: node ;  %
1377
1378                        % n := push (makeExpList ())  %
1379                        [ ExpList  ] ')'
1380                        % assert (isExpList (peep ()))  %
1381
1382
1383    first  symbols:lparatok
1384
1385    cannot reachend
1386 */
1387
1388 static void ActualParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1389
1390 /*
1391    ExitStatement :=
1392                     % VAR n: node ;  %
1393                     'EXIT'
1394                     % IF loopNo = 0
1395                       THEN
1396                          ErrorArray ('EXIT can only be used inside a LOOP statement')
1397                       ELSE
1398                          n := pushStmt (makeExit (peepLoop (), loopNo))
1399                       END  %
1400
1401
1402    first  symbols:exittok
1403
1404    cannot reachend
1405 */
1406
1407 static void ExitStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1408
1409 /*
1410    ReturnStatement :=
1411                       % VAR n: node ;  %
1412
1413                       % n := pushStmt (makeReturn ())  %
1414                       'RETURN' [ Expression
1415                                  % putReturn (n, pop ())  %
1416                                   ]
1417                       % addCommentBody (peepStmt ())  %
1418
1419                       % addCommentAfter (peepStmt ())  %
1420
1421                       % assert (isReturn (peepStmt ()))  %
1422
1423
1424    first  symbols:returntok
1425
1426    cannot reachend
1427 */
1428
1429 static void ReturnStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1430
1431 /*
1432    Statement := ( AssignmentOrProcedureCall  |
1433                   IfStatement  | CaseStatement  |
1434                   WhileStatement  |
1435                   RepeatStatement  |
1436                   LoopStatement  | ForStatement  |
1437                   WithStatement  | AsmStatement  |
1438                   ExitStatement  | ReturnStatement  |
1439                   RetryStatement  |
1440
1441                   % VAR s: node ;  %
1442
1443                   % s := pushStmt (NIL)  %
1444                    )
1445
1446    first  symbols:identtok, retrytok, asmtok, withtok, fortok, looptok, repeattok, whiletok, casetok, iftok, returntok, exittok
1447
1448    reachend
1449 */
1450
1451 static void Statement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1452
1453 /*
1454    RetryStatement :=
1455                      % VAR s: node ;  %
1456
1457                      % s := pushStmt (makeComment ("retry"))  %
1458                      'RETRY'
1459
1460    first  symbols:retrytok
1461
1462    cannot reachend
1463 */
1464
1465 static void RetryStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1466
1467 /*
1468    AssignmentOrProcedureCall :=
1469                                 % VAR d, a, p: node ;  %
1470                                 Designator
1471                                 % d := pop ()  %
1472                                 ( ':=' Expression
1473                                   % a := pushStmt (makeAssignment (d, pop ()))  %
1474                                    |
1475                                   ActualParameters
1476
1477                                   % a := pushStmt (makeFuncCall (d, pop ()))  %
1478                                    |
1479
1480                                   % a := pushStmt (makeFuncCall (d, NIL))  %
1481                                    )
1482                                 % addCommentBody (peepStmt ())  %
1483
1484                                 % addCommentAfter (peepStmt ())  %
1485
1486
1487    first  symbols:identtok
1488
1489    cannot reachend
1490 */
1491
1492 static void AssignmentOrProcedureCall (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1493
1494 /*
1495    StatementSequence :=
1496                         % VAR s, t: node ;  %
1497
1498                         % s := pushStmt (makeStatementSequence ())  %
1499
1500                         % assert (isStatementSequence (peepStmt ()))  %
1501                         Statement
1502                         % addStatement (s, popStmt ())  %
1503
1504                         % assert (isStatementSequence (peepStmt ()))  %
1505                         { ';' Statement
1506                           % addStatement (s, popStmt ())  %
1507
1508                           % assert (isStatementSequence (peepStmt ()))  %
1509                            }
1510
1511    first  symbols:identtok, iftok, casetok, whiletok, repeattok, looptok, fortok, withtok, asmtok, retrytok, semicolontok, exittok, returntok
1512
1513    reachend
1514 */
1515
1516 static void StatementSequence (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1517
1518 /*
1519    IfStatement :=
1520                   % VAR i, a, b: node ;  %
1521                   'IF'
1522                   % b := makeCommentS (getBodyComment ())  %
1523                   Expression
1524                   % a := makeCommentS (getAfterComment ())  %
1525                   'THEN' StatementSequence
1526                   % i := pushStmt (makeIf (pop (), popStmt ()))  %
1527
1528                   % addIfComments (i, b, a)  %
1529                   { 'ELSIF'
1530                     % b := makeCommentS (getBodyComment ())  %
1531                     Expression
1532                     % a := makeCommentS (getAfterComment ())  %
1533                     'THEN'
1534                     % addElseComments (peepStmt (), b, a)  %
1535                     StatementSequence
1536                     % i := makeElsif (i, pop (), popStmt ())  %
1537                      } [ 'ELSE' StatementSequence
1538                          % putElse (i, popStmt ())  %
1539                           ] 'END'
1540                   % b := makeCommentS (getBodyComment ())  %
1541
1542                   % a := makeCommentS (getAfterComment ())  %
1543
1544                   % assert (isIf (peepStmt ()))  %
1545
1546                   % addIfEndComments (peepStmt (), b, a)  %
1547
1548
1549    first  symbols:iftok
1550
1551    cannot reachend
1552 */
1553
1554 static void IfStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1555
1556 /*
1557    CaseStatement :=
1558                     % VAR s, e: node ;  %
1559
1560                     % s := pushStmt (makeCase ())  %
1561                     'CASE' Expression
1562                     % s := putCaseExpression (s, pop ())  %
1563                     'OF' Case { '|' Case  } CaseEndStatement
1564
1565    first  symbols:casetok
1566
1567    cannot reachend
1568 */
1569
1570 static void CaseStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1571
1572 /*
1573    CaseEndStatement :=
1574                        % VAR c: node ;  %
1575                        'END'  | 'ELSE'
1576                        % c := peepStmt ()  %
1577                        StatementSequence
1578                        % c := putCaseElse (c, popStmt ())  %
1579                        'END'
1580
1581    first  symbols:elsetok, endtok
1582
1583    cannot reachend
1584 */
1585
1586 static void CaseEndStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1587
1588 /*
1589    Case := [ CaseLabelList ':'
1590              % VAR l, c: node ;  %
1591
1592              % l := pop ()  %
1593
1594              % c := peepStmt ()  %
1595              StatementSequence
1596              % c := putCaseStatement (c, l, popStmt ())  %
1597               ]
1598
1599    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
1600
1601    reachend
1602 */
1603
1604 static void Case (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1605
1606 /*
1607    CaseLabelList :=
1608                     % VAR l: node ;  %
1609
1610                     % l := push (makeCaseList ())  %
1611                     CaseLabels { ',' CaseLabels  }
1612
1613    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
1614
1615    cannot reachend
1616 */
1617
1618 static void CaseLabelList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1619
1620 /*
1621    CaseLabels :=
1622                  % VAR lo, hi, l: node ;  %
1623
1624                  % lo := NIL ; hi := NIL  %
1625
1626                  % l := peep ()  %
1627                  ConstExpression
1628                  % lo := pop ()  %
1629                  [ '..' ConstExpression
1630                    % hi := pop ()  %
1631                     ]
1632                  % l := putCaseRange (l, lo, hi)  %
1633
1634
1635    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
1636
1637    cannot reachend
1638 */
1639
1640 static void CaseLabels (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1641
1642 /*
1643    WhileStatement :=
1644                      % VAR s, w, e, a, b: node ;  %
1645
1646                      % w := pushStmt (makeWhile ())  %
1647                      'WHILE' Expression 'DO'
1648                      % b := makeCommentS (getBodyComment ())  %
1649
1650                      % a := makeCommentS (getAfterComment ())  %
1651
1652                      % addWhileDoComment (w, b, a)  %
1653
1654                      % e := pop ()  %
1655                      StatementSequence
1656                      % s := popStmt ()  %
1657                      'END'
1658                      %  assert (isStatementSequence (peepStmt ()))   %
1659
1660                      % putWhile (w, e, s)  %
1661
1662                      % b := makeCommentS (getBodyComment ())  %
1663
1664                      % a := makeCommentS (getAfterComment ())  %
1665
1666                      % addWhileEndComment (w, b, a)  %
1667
1668
1669    first  symbols:whiletok
1670
1671    cannot reachend
1672 */
1673
1674 static void WhileStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1675
1676 /*
1677    RepeatStatement :=
1678                       % VAR r, s, a, b: node ;  %
1679
1680                       % r := pushStmt (makeRepeat ())  %
1681                       'REPEAT'
1682                       % b := makeCommentS (getBodyComment ())  %
1683
1684                       % a := makeCommentS (getAfterComment ())  %
1685
1686                       % addRepeatComment (r, b, a)  %
1687                       StatementSequence
1688                       % s := popStmt ()  %
1689                       'UNTIL' Expression
1690                       % putRepeat (r, s, pop ())  %
1691
1692                       % b := makeCommentS (getBodyComment ())  %
1693
1694                       % a := makeCommentS (getAfterComment ())  %
1695
1696                       % addUntilComment (r, b, a)  %
1697
1698
1699    first  symbols:repeattok
1700
1701    cannot reachend
1702 */
1703
1704 static void RepeatStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1705
1706 /*
1707    ForStatement :=
1708                    % VAR f, i, s, e, b: node ;  %
1709
1710                    % b := NIL  %
1711
1712                    % f := pushStmt (makeFor ())  %
1713                    'FOR' Ident
1714                    % i := lookupWithSym (curident)  %
1715                    ':=' Expression
1716                    % s := pop ()  %
1717                    'TO' Expression
1718                    % e := pop ()  %
1719                    [ 'BY' ConstExpression
1720                      % b := pop ()  %
1721                       ] 'DO' StatementSequence
1722                    % putFor (f, i, s, e, b, popStmt ())  %
1723                    'END'
1724
1725    first  symbols:fortok
1726
1727    cannot reachend
1728 */
1729
1730 static void ForStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1731
1732 /*
1733    LoopStatement :=
1734                     % VAR l, s: node ;  %
1735                     'LOOP'
1736                     % l := pushStmt (pushLoop (makeLoop ()))  %
1737
1738                     % INC (loopNo)  %
1739                     StatementSequence
1740                     % s := popStmt ()  %
1741
1742                     % putLoop (l, s)  %
1743
1744                     % DEC (loopNo)  %
1745                     'END'
1746                     % l := popLoop ()  %
1747
1748                     % assert (isLoop (peepStmt ()))  %
1749
1750
1751    first  symbols:looptok
1752
1753    cannot reachend
1754 */
1755
1756 static void LoopStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1757
1758 /*
1759    WithStatement := 'WITH' Designator 'DO'
1760                     % startWith (pop ())  %
1761                     StatementSequence 'END'
1762                     % endWith  %
1763
1764
1765    first  symbols:withtok
1766
1767    cannot reachend
1768 */
1769
1770 static void WithStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1771
1772 /*
1773    ProcedureDeclaration := ProcedureHeading ';' ProcedureBlock
1774                            Ident
1775                            % leaveScope  %
1776
1777
1778    first  symbols:proceduretok
1779
1780    cannot reachend
1781 */
1782
1783 static void ProcedureDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1784
1785 /*
1786    ProcedureIdent := Ident
1787                      % curproc := lookupSym (curident)  %
1788
1789                      % enterScope (curproc)  %
1790
1791                      % setProcedureComment (lastcomment, curident)  %
1792
1793
1794    first  symbols:identtok
1795
1796    cannot reachend
1797 */
1798
1799 static void ProcedureIdent (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1800
1801 /*
1802    DefProcedureIdent := Ident
1803                         % curproc := lookupSym (curident)  %
1804
1805
1806    first  symbols:identtok
1807
1808    cannot reachend
1809 */
1810
1811 static void DefProcedureIdent (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1812
1813 /*
1814    DefineBuiltinProcedure := [ '__ATTRIBUTE__' '__BUILTIN__'
1815                                '(' '(' Ident ')' ')'  |
1816                                '__INLINE__'  ]
1817
1818    first  symbols:inlinetok, attributetok
1819
1820    reachend
1821 */
1822
1823 static void DefineBuiltinProcedure (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1824
1825 /*
1826    ProcedureHeading := 'PROCEDURE' DefineBuiltinProcedure
1827                        ( ProcedureIdent [ FormalParameters  ]
1828                          AttributeNoReturn  )
1829
1830    first  symbols:proceduretok
1831
1832    cannot reachend
1833 */
1834
1835 static void ProcedureHeading (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1836
1837 /*
1838    Builtin := [ '__BUILTIN__'  | '__INLINE__'  ]
1839
1840    first  symbols:inlinetok, builtintok
1841
1842    reachend
1843 */
1844
1845 static void Builtin (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1846
1847 /*
1848    DefProcedureHeading := 'PROCEDURE' Builtin ( DefProcedureIdent
1849                                                 [ DefFormalParameters  ]
1850                                                 AttributeNoReturn  )
1851
1852    first  symbols:proceduretok
1853
1854    cannot reachend
1855 */
1856
1857 static void DefProcedureHeading (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1858
1859 /*
1860    ProcedureBlock := { Declaration  } [ 'BEGIN' ProcedureBlockBody  ]
1861                      'END'
1862
1863    first  symbols:proceduretok, moduletok, consttok, typetok, vartok, endtok, begintok
1864
1865    cannot reachend
1866 */
1867
1868 static void ProcedureBlock (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1869
1870 /*
1871    Block := { Declaration  } InitialBlock FinalBlock
1872             'END'
1873
1874    first  symbols:proceduretok, moduletok, finallytok, begintok, consttok, typetok, vartok, endtok
1875
1876    cannot reachend
1877 */
1878
1879 static void Block (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1880
1881 /*
1882    InitialBlock := [ 'BEGIN' InitialBlockBody  ]
1883
1884    first  symbols:begintok
1885
1886    reachend
1887 */
1888
1889 static void InitialBlock (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1890
1891 /*
1892    FinalBlock := [ 'FINALLY' FinalBlockBody  ]
1893
1894    first  symbols:finallytok
1895
1896    reachend
1897 */
1898
1899 static void FinalBlock (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1900
1901 /*
1902    InitialBlockBody := NormalPart
1903                        % putBegin (curmodule, popStmt ())  %
1904                        [ 'EXCEPT' ExceptionalPart  ]
1905
1906    first  symbols:identtok, iftok, casetok, whiletok, repeattok, looptok, fortok, withtok, asmtok, retrytok, semicolontok, exittok, returntok, excepttok
1907
1908    reachend
1909 */
1910
1911 static void InitialBlockBody (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1912
1913 /*
1914    FinalBlockBody := NormalPart
1915                      % putFinally (curmodule, popStmt ())  %
1916                      [ 'EXCEPT' ExceptionalPart  ]
1917
1918    first  symbols:identtok, iftok, casetok, whiletok, repeattok, looptok, fortok, withtok, asmtok, retrytok, semicolontok, exittok, returntok, excepttok
1919
1920    reachend
1921 */
1922
1923 static void FinalBlockBody (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1924
1925 /*
1926    ProcedureBlockBody := ProcedureNormalPart [ 'EXCEPT'
1927                                                ExceptionalPart  ]
1928
1929    first  symbols:identtok, iftok, casetok, whiletok, repeattok, looptok, fortok, withtok, asmtok, retrytok, semicolontok, exittok, returntok, excepttok
1930
1931    reachend
1932 */
1933
1934 static void ProcedureBlockBody (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1935
1936 /*
1937    ProcedureNormalPart := StatementSequence
1938                           % putBegin (curproc, popStmt ())  %
1939
1940
1941    first  symbols:identtok, retrytok, asmtok, withtok, fortok, looptok, repeattok, whiletok, casetok, iftok, returntok, exittok, semicolontok
1942
1943    reachend
1944 */
1945
1946 static void ProcedureNormalPart (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1947
1948 /*
1949    NormalPart := StatementSequence
1950
1951    first  symbols:identtok, retrytok, asmtok, withtok, fortok, looptok, repeattok, whiletok, casetok, iftok, returntok, exittok, semicolontok
1952
1953    reachend
1954 */
1955
1956 static void NormalPart (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1957
1958 /*
1959    ExceptionalPart := StatementSequence
1960
1961    first  symbols:identtok, retrytok, asmtok, withtok, fortok, looptok, repeattok, whiletok, casetok, iftok, returntok, exittok, semicolontok
1962
1963    reachend
1964 */
1965
1966 static void ExceptionalPart (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1967
1968 /*
1969    Declaration := 'CONST' { ConstantDeclaration ';'  }  |
1970                   'TYPE' { TypeDeclaration  }  |
1971                   'VAR' { VariableDeclaration ';'  }  |
1972                   ProcedureDeclaration ';'  |
1973                   ModuleDeclaration ';'
1974
1975    first  symbols:moduletok, proceduretok, vartok, typetok, consttok
1976
1977    cannot reachend
1978 */
1979
1980 static void Declaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1981
1982 /*
1983    DefFormalParameters := '('
1984                           % paramEnter (curproc)  %
1985                           [ DefMultiFPSection  ] ')'
1986
1987                           % paramLeave (curproc)  %
1988                           FormalReturn
1989
1990    first  symbols:lparatok
1991
1992    cannot reachend
1993 */
1994
1995 static void DefFormalParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
1996
1997 /*
1998    AttributeNoReturn := [ ''  ]
1999
2000    first  symbols:ldirectivetok
2001
2002    reachend
2003 */
2004
2005 static void AttributeNoReturn (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2006
2007 /*
2008    AttributeUnused := [ ''  ]
2009
2010    first  symbols:ldirectivetok
2011
2012    reachend
2013 */
2014
2015 static void AttributeUnused (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2016
2017 /*
2018    DefMultiFPSection := DefExtendedFP  |
2019                         FPSection [ ';' DefMultiFPSection  ]
2020
2021    first  symbols:identtok, vartok, lsbratok, periodperiodperiodtok
2022
2023    cannot reachend
2024 */
2025
2026 static void DefMultiFPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2027
2028 /*
2029    FormalParameters := '('
2030                        % paramEnter (curproc)  %
2031                        [ MultiFPSection  ] ')'
2032                        % paramLeave (curproc)  %
2033                        FormalReturn
2034
2035    first  symbols:lparatok
2036
2037    cannot reachend
2038 */
2039
2040 static void FormalParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2041
2042 /*
2043    MultiFPSection := ExtendedFP  | FPSection [ ';'
2044                                                MultiFPSection  ]
2045
2046    first  symbols:identtok, vartok, lsbratok, periodperiodperiodtok
2047
2048    cannot reachend
2049 */
2050
2051 static void MultiFPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2052
2053 /*
2054    FPSection := NonVarFPSection  |
2055                 VarFPSection
2056
2057    first  symbols:vartok, identtok
2058
2059    cannot reachend
2060 */
2061
2062 static void FPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2063
2064 /*
2065    DefExtendedFP := DefOptArg  | '...'
2066
2067    first  symbols:lsbratok, periodperiodperiodtok
2068
2069    cannot reachend
2070 */
2071
2072 static void DefExtendedFP (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2073
2074 /*
2075    ExtendedFP := OptArg  | '...'
2076
2077    first  symbols:lsbratok, periodperiodperiodtok
2078
2079    cannot reachend
2080 */
2081
2082 static void ExtendedFP (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2083
2084 /*
2085    VarFPSection := 'VAR' IdentList ':' FormalType [
2086    AttributeUnused  ]
2087
2088    first  symbols:vartok
2089
2090    cannot reachend
2091 */
2092
2093 static void VarFPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2094
2095 /*
2096    NonVarFPSection := IdentList ':' FormalType [ AttributeUnused  ]
2097
2098    first  symbols:identtok
2099
2100    cannot reachend
2101 */
2102
2103 static void NonVarFPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2104
2105 /*
2106    OptArg := '[' Ident ':' FormalType [ '=' ConstExpressionNop  ]
2107              ']'
2108
2109    first  symbols:lsbratok
2110
2111    cannot reachend
2112 */
2113
2114 static void OptArg (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2115
2116 /*
2117    DefOptArg := '[' Ident ':' FormalType '=' ConstExpressionNop
2118                 ']'
2119
2120    first  symbols:lsbratok
2121
2122    cannot reachend
2123 */
2124
2125 static void DefOptArg (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2126
2127 /*
2128    FormalType := { 'ARRAY' 'OF'  } Qualident
2129
2130    first  symbols:identtok, arraytok
2131
2132    cannot reachend
2133 */
2134
2135 static void FormalType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2136
2137 /*
2138    ModuleDeclaration := 'MODULE' Ident [ Priority  ]
2139                         ';' { Import  } [ Export  ]
2140                         Block Ident
2141
2142    first  symbols:moduletok
2143
2144    cannot reachend
2145 */
2146
2147 static void ModuleDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2148
2149 /*
2150    Priority := '[' ConstExpressionNop ']'
2151
2152    first  symbols:lsbratok
2153
2154    cannot reachend
2155 */
2156
2157 static void Priority (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2158
2159 /*
2160    Export := 'EXPORT' ( 'QUALIFIED' IdentList  |
2161                         'UNQUALIFIED' IdentList  |
2162                         IdentList  ) ';'
2163
2164    first  symbols:exporttok
2165
2166    cannot reachend
2167 */
2168
2169 static void Export (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2170
2171 /*
2172    FromIdentList := Ident { ',' Ident  }
2173
2174    first  symbols:identtok
2175
2176    cannot reachend
2177 */
2178
2179 static void FromIdentList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2180
2181 /*
2182    FromImport := 'FROM' Ident 'IMPORT' FromIdentList
2183                  ';'
2184
2185    first  symbols:fromtok
2186
2187    cannot reachend
2188 */
2189
2190 static void FromImport (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2191
2192 /*
2193    ImportModuleList := Ident { ',' Ident  }
2194
2195    first  symbols:identtok
2196
2197    cannot reachend
2198 */
2199
2200 static void ImportModuleList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2201
2202 /*
2203    WithoutFromImport := 'IMPORT' ImportModuleList ';'
2204
2205    first  symbols:importtok
2206
2207    cannot reachend
2208 */
2209
2210 static void WithoutFromImport (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2211
2212 /*
2213    Import := FromImport  | WithoutFromImport
2214
2215    first  symbols:importtok, fromtok
2216
2217    cannot reachend
2218 */
2219
2220 static void Import (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2221
2222 /*
2223    DefinitionModule := 'DEFINITION' 'MODULE' [ 'FOR'
2224                                                string  ]
2225                        Ident ';'
2226                        % curmodule := lookupDef (curident)  %
2227
2228                        % enterScope (curmodule)  %
2229                        { Import  } [ Export  ] { Definition  }
2230                        'END' Ident '.'
2231                        % checkEndName (curmodule, curident, 'definition module')  %
2232
2233                        % leaveScope  %
2234
2235
2236    first  symbols:definitiontok
2237
2238    cannot reachend
2239 */
2240
2241 static void DefinitionModule (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2242
2243 /*
2244    PushQualident :=
2245                     % VAR type, field: node ;  %
2246                     Ident
2247                     % qualid := push (lookupWithSym (curident))  %
2248
2249                     % IF qualid = NIL
2250                                     THEN
2251                                        metaError1 ('the symbol {%1k} is not visible in this scope (or any other nested scope)', curident)
2252                                     END  %
2253                     [ '.'
2254                       % IF NOT isQualident (qualid)
2255                                       THEN
2256                                          ErrorArray ('the first component of this qualident must be a definition module or a parameter/variable/constant which has record type')
2257                                       END  %
2258                       Ident
2259                       % IF isDef (qualid)
2260                                       THEN
2261                                          qualid := replace (lookupInScope (qualid, curident))
2262                                       ELSE
2263                                          type := skipType (getType (qualid)) ;
2264                                          field := lookupInScope (type, curident) ;
2265                                                                                                      IF field = NIL
2266                                          THEN
2267                                             metaError2 ('field {%1k} cannot be found in {%2ad}', curident, qualid)
2268                                          ELSE
2269                                             qualid := replace (makeComponentRef (qualid, field))
2270                                          END
2271                                       END ;
2272                                       IF qualid = NIL
2273                                       THEN
2274                                          metaError1 ('qualified component of the identifier {%1k} cannot be found', curident)
2275                                       END  %
2276                        ]
2277
2278    first  symbols:identtok
2279
2280    cannot reachend
2281 */
2282
2283 static void PushQualident (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2284
2285 /*
2286    OptSubrange := [ SubrangeType  ]
2287
2288    first  symbols:lsbratok
2289
2290    reachend
2291 */
2292
2293 static void OptSubrange (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2294
2295 /*
2296    TypeEquiv := Qualident OptSubrange
2297
2298    first  symbols:identtok
2299
2300    cannot reachend
2301 */
2302
2303 static void TypeEquiv (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2304
2305 /*
2306    EnumIdentList := Ident { ',' Ident  }
2307
2308    first  symbols:identtok
2309
2310    cannot reachend
2311 */
2312
2313 static void EnumIdentList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2314
2315 /*
2316    Enumeration := '(' EnumIdentList ')'
2317
2318    first  symbols:lparatok
2319
2320    cannot reachend
2321 */
2322
2323 static void Enumeration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2324
2325 /*
2326    SimpleType := TypeEquiv  | Enumeration  |
2327                  SubrangeType
2328
2329    first  symbols:lsbratok, lparatok, identtok
2330
2331    cannot reachend
2332 */
2333
2334 static void SimpleType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2335
2336 /*
2337    Type := SimpleType  | ArrayType  | RecordType  |
2338            SetType  | PointerType  | ProcedureType
2339
2340    first  symbols:proceduretok, pointertok, settok, packedsettok, oftok, recordtok, arraytok, identtok, lparatok, lsbratok
2341
2342    cannot reachend
2343 */
2344
2345 static void Type (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2346
2347 /*
2348    TypeDeclaration := { Ident ( ';'  | '=' Type Alignment
2349                                 ';'  )  }
2350
2351    first  symbols:identtok
2352
2353    reachend
2354 */
2355
2356 static void TypeDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2357
2358 /*
2359    Definition := 'CONST' { ConstantDeclaration ';'  }  |
2360                  'TYPE' { TypeDeclaration  }  |
2361                  'VAR' { VariableDeclaration ';'  }  |
2362                  DefProcedureHeading ';'
2363
2364    first  symbols:proceduretok, vartok, typetok, consttok
2365
2366    cannot reachend
2367 */
2368
2369 static void Definition (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2370
2371 /*
2372    AsmStatement :=
2373                    % VAR s: node ;  %
2374
2375                    % s := pushStmt (makeComment ("asm"))  %
2376                    'ASM' [ 'VOLATILE'  ] '(' AsmOperands
2377                    ')'
2378
2379    first  symbols:asmtok
2380
2381    cannot reachend
2382 */
2383
2384 static void AsmStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2385
2386 /*
2387    AsmOperands := string [ AsmOperandSpec  ]
2388
2389    first  symbols:stringtok
2390
2391    cannot reachend
2392 */
2393
2394 static void AsmOperands (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2395
2396 /*
2397    AsmOperandSpec := [ ':' AsmList [ ':' AsmList [
2398    ':' TrashList  ]  ]  ]
2399
2400    first  symbols:colontok
2401
2402    reachend
2403 */
2404
2405 static void AsmOperandSpec (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2406
2407 /*
2408    AsmList := [ AsmElement  ] { ',' AsmElement  }
2409
2410    first  symbols:lsbratok, stringtok, commatok
2411
2412    reachend
2413 */
2414
2415 static void AsmList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2416
2417 /*
2418    NamedOperand := '[' Ident ']'
2419
2420    first  symbols:lsbratok
2421
2422    cannot reachend
2423 */
2424
2425 static void NamedOperand (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2426
2427 /*
2428    AsmOperandName := [ NamedOperand  ]
2429
2430    first  symbols:lsbratok
2431
2432    reachend
2433 */
2434
2435 static void AsmOperandName (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2436
2437 /*
2438    AsmElement := AsmOperandName string '(' Expression
2439                  ')'
2440
2441    first  symbols:stringtok, lsbratok
2442
2443    cannot reachend
2444 */
2445
2446 static void AsmElement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2447
2448 /*
2449    TrashList := [ string  ] { ',' string  }
2450
2451    first  symbols:commatok, stringtok
2452
2453    reachend
2454 */
2455
2456 static void TrashList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2);
2457
2458
2459 /*
2460    followNode -
2461 */
2462
2463 static void followNode (decl_node n)
2464 {
2465   if (decl_isVar (n))
2466     {
2467       mcPrintf_printf0 ((const char *) "variable: ", 10);
2468     }
2469   else if (decl_isParameter (n))
2470     {
2471       /* avoid dangling else.  */
2472       mcPrintf_printf0 ((const char *) "parameter: ", 11);
2473     }
2474   n = decl_skipType (decl_getType (n));
2475   if (decl_isArray (n))
2476     {
2477       mcPrintf_printf0 ((const char *) "array\\n", 7);
2478     }
2479   else if (decl_isPointer (n))
2480     {
2481       /* avoid dangling else.  */
2482       mcPrintf_printf0 ((const char *) "pointer\\n", 9);
2483     }
2484   else if (decl_isRecord (n))
2485     {
2486       /* avoid dangling else.  */
2487       mcPrintf_printf0 ((const char *) "record\\n", 8);
2488     }
2489   else
2490     {
2491       /* avoid dangling else.  */
2492       mcPrintf_printf0 ((const char *) "other\\n", 7);
2493     }
2494 }
2495
2496
2497 /*
2498    push -
2499 */
2500
2501 static decl_node push (decl_node n)
2502 {
2503   return static_cast<decl_node> (mcStack_push (stk, reinterpret_cast <void *> (n)));
2504   /* static analysis guarentees a RETURN statement will be used before here.  */
2505   __builtin_unreachable ();
2506 }
2507
2508
2509 /*
2510    pop -
2511 */
2512
2513 static decl_node pop (void)
2514 {
2515   return static_cast<decl_node> (mcStack_pop (stk));
2516   /* static analysis guarentees a RETURN statement will be used before here.  */
2517   __builtin_unreachable ();
2518 }
2519
2520
2521 /*
2522    replace -
2523 */
2524
2525 static decl_node replace (decl_node n)
2526 {
2527   return static_cast<decl_node> (mcStack_replace (stk, reinterpret_cast <void *> (n)));
2528   /* static analysis guarentees a RETURN statement will be used before here.  */
2529   __builtin_unreachable ();
2530 }
2531
2532
2533 /*
2534    peep - returns the top node on the stack without removing it.
2535 */
2536
2537 static decl_node peep (void)
2538 {
2539   return push (pop ());
2540   /* static analysis guarentees a RETURN statement will be used before here.  */
2541   __builtin_unreachable ();
2542 }
2543
2544
2545 /*
2546    depth - returns the depth of the stack.
2547 */
2548
2549 static unsigned int depth (void)
2550 {
2551   return mcStack_depth (stk);
2552   /* static analysis guarentees a RETURN statement will be used before here.  */
2553   __builtin_unreachable ();
2554 }
2555
2556
2557 /*
2558    checkDuplicate -
2559 */
2560
2561 static void checkDuplicate (bool b)
2562 {
2563 }
2564
2565
2566 /*
2567    isQualident - returns TRUE if, n, is a qualident.
2568 */
2569
2570 static bool isQualident (decl_node n)
2571 {
2572   decl_node type;
2573
2574   if (decl_isDef (n))
2575     {
2576       return true;
2577     }
2578   else
2579     {
2580       type = decl_skipType (decl_getType (n));
2581       return (type != NULL) && (decl_isRecord (type));
2582     }
2583   return false;
2584   /* static analysis guarentees a RETURN statement will be used before here.  */
2585   __builtin_unreachable ();
2586 }
2587
2588
2589 /*
2590    startWith -
2591 */
2592
2593 static void startWith (decl_node n)
2594 {
2595   n = static_cast<decl_node> (mcStack_push (withStk, reinterpret_cast <void *> (n)));
2596 }
2597
2598
2599 /*
2600    endWith -
2601 */
2602
2603 static void endWith (void)
2604 {
2605   decl_node n;
2606
2607   n = static_cast<decl_node> (mcStack_pop (withStk));
2608 }
2609
2610
2611 /*
2612    lookupWithSym -
2613 */
2614
2615 static decl_node lookupWithSym (nameKey_Name i)
2616 {
2617   unsigned int d;
2618   decl_node n;
2619   decl_node m;
2620   decl_node t;
2621
2622   d = mcStack_depth (withStk);
2623   while (d != 0)
2624     {
2625       n = static_cast<decl_node> (mcStack_access (withStk, d));
2626       t = decl_skipType (decl_getType (n));
2627       m = decl_lookupInScope (t, i);
2628       if (m != NULL)
2629         {
2630           n = decl_dupExpr (n);
2631           return decl_makeComponentRef (n, m);
2632         }
2633       d -= 1;
2634     }
2635   return decl_lookupSym (i);
2636   /* static analysis guarentees a RETURN statement will be used before here.  */
2637   __builtin_unreachable ();
2638 }
2639
2640
2641 /*
2642    pushStmt - push a node, n, to the statement stack and return node, n.
2643 */
2644
2645 static decl_node pushStmt (decl_node n)
2646 {
2647   return static_cast<decl_node> (mcStack_push (stmtStk, reinterpret_cast <void *> (n)));
2648   /* static analysis guarentees a RETURN statement will be used before here.  */
2649   __builtin_unreachable ();
2650 }
2651
2652
2653 /*
2654    popStmt - pop the top node from the statement stack.
2655 */
2656
2657 static decl_node popStmt (void)
2658 {
2659   return static_cast<decl_node> (mcStack_pop (stmtStk));
2660   /* static analysis guarentees a RETURN statement will be used before here.  */
2661   __builtin_unreachable ();
2662 }
2663
2664
2665 /*
2666    peepStmt - return the top node from the statement stack,
2667               but leave the stack unchanged.
2668 */
2669
2670 static decl_node peepStmt (void)
2671 {
2672   return pushStmt (popStmt ());
2673   /* static analysis guarentees a RETURN statement will be used before here.  */
2674   __builtin_unreachable ();
2675 }
2676
2677
2678 /*
2679    pushLoop - push a node, n, to the loop stack and return node, n.
2680 */
2681
2682 static decl_node pushLoop (decl_node n)
2683 {
2684   return static_cast<decl_node> (mcStack_push (loopStk, reinterpret_cast <void *> (n)));
2685   /* static analysis guarentees a RETURN statement will be used before here.  */
2686   __builtin_unreachable ();
2687 }
2688
2689
2690 /*
2691    popLoop - pop the top node from the loop stack.
2692 */
2693
2694 static decl_node popLoop (void)
2695 {
2696   return static_cast<decl_node> (mcStack_pop (loopStk));
2697   /* static analysis guarentees a RETURN statement will be used before here.  */
2698   __builtin_unreachable ();
2699 }
2700
2701
2702 /*
2703    peepLoop - return the top node from the loop stack,
2704               but leave the stack unchanged.
2705 */
2706
2707 static decl_node peepLoop (void)
2708 {
2709   return pushLoop (popLoop ());
2710   /* static analysis guarentees a RETURN statement will be used before here.  */
2711   __builtin_unreachable ();
2712 }
2713
2714
2715 /*
2716    peepLoop - return the top node from the loop stack,
2717               but leave the stack unchanged.
2718 */
2719
2720 static void ErrorString (DynamicStrings_String s)
2721 {
2722   mcError_errorStringAt (s, mcLexBuf_getTokenNo ());
2723   WasNoError = false;
2724 }
2725
2726
2727 /*
2728    peepLoop - return the top node from the loop stack,
2729               but leave the stack unchanged.
2730 */
2731
2732 static void ErrorArray (const char *a_, unsigned int _a_high)
2733 {
2734   char a[_a_high+1];
2735
2736   /* make a local copy of each unbounded array.  */
2737   memcpy (a, a_, _a_high+1);
2738
2739   ErrorString (DynamicStrings_InitString ((const char *) a, _a_high));
2740 }
2741
2742
2743 /*
2744    pushNunbounded -
2745 */
2746
2747 static void pushNunbounded (unsigned int c)
2748 {
2749   decl_node type;
2750   decl_node array;
2751   decl_node subrange;
2752
2753   while (c != 0)
2754     {
2755       type = pop ();
2756       subrange = decl_makeSubrange (static_cast<decl_node> (NULL), static_cast<decl_node> (NULL));
2757       decl_putSubrangeType (subrange, decl_getCardinal ());
2758       array = decl_makeArray (subrange, type);
2759       decl_putUnbounded (array);
2760       type = push (array);
2761       c -= 1;
2762     }
2763 }
2764
2765
2766 /*
2767    makeIndexedArray - builds and returns an array of type, t, with, c, indices.
2768 */
2769
2770 static decl_node makeIndexedArray (unsigned int c, decl_node t)
2771 {
2772   decl_node i;
2773
2774   while (c > 0)
2775     {
2776       t = decl_makeArray (pop (), t);
2777       c -= 1;
2778     }
2779   return t;
2780   /* static analysis guarentees a RETURN statement will be used before here.  */
2781   __builtin_unreachable ();
2782 }
2783
2784
2785 /*
2786    importInto - from, m, import, name, into module, current.
2787                 It checks to see if curident is an enumeration type
2788                 and if so automatically includes all enumeration fields
2789                 as well.
2790 */
2791
2792 static void importInto (decl_node m, nameKey_Name name, decl_node current)
2793 {
2794   decl_node s;
2795   decl_node o;
2796
2797   mcDebug_assert (decl_isDef (m));
2798   mcDebug_assert (((decl_isDef (current)) || (decl_isModule (current))) || (decl_isImp (current)));
2799   s = decl_lookupExported (m, name);
2800   if (s == NULL)
2801     {
2802       mcMetaError_metaError2 ((const char *) "{%1k} was not exported from definition module {%2a}", 51, (const unsigned char *) &name, (sizeof (name)-1), (const unsigned char *) &m, (sizeof (m)-1));
2803     }
2804   else
2805     {
2806       o = decl_import (current, s);
2807       if (s != o)
2808         {
2809           mcMetaError_metaError2 ((const char *) "{%1ad} cannot be imported into the current module as it causes a name clash with {%2ad}", 87, (const unsigned char *) &s, (sizeof (s)-1), (const unsigned char *) &o, (sizeof (o)-1));
2810         }
2811     }
2812 }
2813
2814
2815 /*
2816    checkEndName - if module does not have, name, then issue an error containing, desc.
2817 */
2818
2819 static void checkEndName (decl_node module, nameKey_Name name, const char *desc_, unsigned int _desc_high)
2820 {
2821   DynamicStrings_String s;
2822   char desc[_desc_high+1];
2823
2824   /* make a local copy of each unbounded array.  */
2825   memcpy (desc, desc_, _desc_high+1);
2826
2827   if ((decl_getSymName (module)) != name)
2828     {
2829       s = DynamicStrings_InitString ((const char *) "inconsistent module name found with this ", 41);
2830       s = DynamicStrings_ConCat (s, DynamicStrings_Mark (DynamicStrings_InitString ((const char *) desc, _desc_high)));
2831       ErrorString (s);
2832     }
2833 }
2834
2835
2836 /*
2837    DescribeStop - issues a message explaining what tokens were expected
2838 */
2839
2840 static DynamicStrings_String DescribeStop (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
2841 {
2842   unsigned int n;
2843   DynamicStrings_String str;
2844   DynamicStrings_String message;
2845
2846   n = 0;
2847   message = DynamicStrings_InitString ((const char *) "", 0);
2848   if ((((1 << (mcReserved_stringtok-mcReserved_recordtok)) & (stopset2)) != 0))
2849     {
2850       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "string", 6)));
2851       n += 1;
2852     }
2853   if ((((1 << (mcReserved_realtok-mcReserved_recordtok)) & (stopset2)) != 0))
2854     {
2855       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "real number", 11)));
2856       n += 1;
2857     }
2858   if ((((1 << (mcReserved_identtok-mcReserved_recordtok)) & (stopset2)) != 0))
2859     {
2860       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "identifier", 10)));
2861       n += 1;
2862     }
2863   if ((((1 << (mcReserved_integertok-mcReserved_recordtok)) & (stopset2)) != 0))
2864     {
2865       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "integer number", 14)));
2866       n += 1;
2867     }
2868   if ((((1 << (mcReserved_inlinetok-mcReserved_recordtok)) & (stopset2)) != 0))
2869     {
2870       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "__INLINE__", 10)));
2871       n += 1;
2872     }
2873   if ((((1 << (mcReserved_builtintok-mcReserved_recordtok)) & (stopset2)) != 0))
2874     {
2875       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "__BUILTIN__", 11)));
2876       n += 1;
2877     }
2878   if ((((1 << (mcReserved_attributetok-mcReserved_recordtok)) & (stopset2)) != 0))
2879     {
2880       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "__ATTRIBUTE__", 13)));
2881       n += 1;
2882     }
2883   if ((((1 << (mcReserved_filetok-mcReserved_recordtok)) & (stopset2)) != 0))
2884     {
2885       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "__FILE__", 8)));
2886       n += 1;
2887     }
2888   if ((((1 << (mcReserved_linetok-mcReserved_recordtok)) & (stopset2)) != 0))
2889     {
2890       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "__LINE__", 8)));
2891       n += 1;
2892     }
2893   if ((((1 << (mcReserved_datetok-mcReserved_recordtok)) & (stopset2)) != 0))
2894     {
2895       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "__DATE__", 8)));
2896       n += 1;
2897     }
2898   if ((((1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) & (stopset2)) != 0))
2899     {
2900       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "...", 3)));
2901       n += 1;
2902     }
2903   if ((((1 << (mcReserved_volatiletok-mcReserved_recordtok)) & (stopset2)) != 0))
2904     {
2905       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "VOLATILE", 8)));
2906       n += 1;
2907     }
2908   if ((((1 << (mcReserved_asmtok-mcReserved_recordtok)) & (stopset2)) != 0))
2909     {
2910       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "ASM", 3)));
2911       n += 1;
2912     }
2913   if ((((1 << (mcReserved_withtok-mcReserved_recordtok)) & (stopset2)) != 0))
2914     {
2915       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "WITH", 4)));
2916       n += 1;
2917     }
2918   if ((((1 << (mcReserved_whiletok-mcReserved_recordtok)) & (stopset2)) != 0))
2919     {
2920       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "WHILE", 5)));
2921       n += 1;
2922     }
2923   if ((((1 << (mcReserved_vartok-mcReserved_recordtok)) & (stopset2)) != 0))
2924     {
2925       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "VAR", 3)));
2926       n += 1;
2927     }
2928   if ((((1 << (mcReserved_untiltok-mcReserved_recordtok)) & (stopset2)) != 0))
2929     {
2930       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "UNTIL", 5)));
2931       n += 1;
2932     }
2933   if ((((1 << (mcReserved_typetok-mcReserved_recordtok)) & (stopset2)) != 0))
2934     {
2935       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "TYPE", 4)));
2936       n += 1;
2937     }
2938   if ((((1 << (mcReserved_totok-mcReserved_recordtok)) & (stopset2)) != 0))
2939     {
2940       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "TO", 2)));
2941       n += 1;
2942     }
2943   if ((((1 << (mcReserved_thentok-mcReserved_recordtok)) & (stopset2)) != 0))
2944     {
2945       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "THEN", 4)));
2946       n += 1;
2947     }
2948   if ((((1 << (mcReserved_settok-mcReserved_recordtok)) & (stopset2)) != 0))
2949     {
2950       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "SET", 3)));
2951       n += 1;
2952     }
2953   if ((((1 << (mcReserved_returntok-mcReserved_recordtok)) & (stopset2)) != 0))
2954     {
2955       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "RETURN", 6)));
2956       n += 1;
2957     }
2958   if ((((1 << (mcReserved_retrytok-mcReserved_recordtok)) & (stopset2)) != 0))
2959     {
2960       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "RETRY", 5)));
2961       n += 1;
2962     }
2963   if ((((1 << (mcReserved_repeattok-mcReserved_recordtok)) & (stopset2)) != 0))
2964     {
2965       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "REPEAT", 6)));
2966       n += 1;
2967     }
2968   if ((((1 << (mcReserved_remtok-mcReserved_recordtok)) & (stopset2)) != 0))
2969     {
2970       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "REM", 3)));
2971       n += 1;
2972     }
2973   if ((((1 << (mcReserved_recordtok-mcReserved_recordtok)) & (stopset2)) != 0))
2974     {
2975       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "RECORD", 6)));
2976       n += 1;
2977     }
2978   if ((((1 << (mcReserved_unqualifiedtok-mcReserved_arraytok)) & (stopset1)) != 0))
2979     {
2980       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "UNQUALIFIED", 11)));
2981       n += 1;
2982     }
2983   if ((((1 << (mcReserved_qualifiedtok-mcReserved_arraytok)) & (stopset1)) != 0))
2984     {
2985       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "QUALIFIED", 9)));
2986       n += 1;
2987     }
2988   if ((((1 << (mcReserved_proceduretok-mcReserved_arraytok)) & (stopset1)) != 0))
2989     {
2990       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "PROCEDURE", 9)));
2991       n += 1;
2992     }
2993   if ((((1 << (mcReserved_pointertok-mcReserved_arraytok)) & (stopset1)) != 0))
2994     {
2995       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "POINTER", 7)));
2996       n += 1;
2997     }
2998   if ((((1 << (mcReserved_packedsettok-mcReserved_arraytok)) & (stopset1)) != 0))
2999     {
3000       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "PACKEDSET", 9)));
3001       n += 1;
3002     }
3003   if ((((1 << (mcReserved_ortok-mcReserved_arraytok)) & (stopset1)) != 0))
3004     {
3005       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "OR", 2)));
3006       n += 1;
3007     }
3008   if ((((1 << (mcReserved_oftok-mcReserved_arraytok)) & (stopset1)) != 0))
3009     {
3010       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "OF", 2)));
3011       n += 1;
3012     }
3013   if ((((1 << (mcReserved_nottok-mcReserved_arraytok)) & (stopset1)) != 0))
3014     {
3015       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "NOT", 3)));
3016       n += 1;
3017     }
3018   if ((((1 << (mcReserved_moduletok-mcReserved_arraytok)) & (stopset1)) != 0))
3019     {
3020       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "MODULE", 6)));
3021       n += 1;
3022     }
3023   if ((((1 << (mcReserved_modtok-mcReserved_arraytok)) & (stopset1)) != 0))
3024     {
3025       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "MOD", 3)));
3026       n += 1;
3027     }
3028   if ((((1 << (mcReserved_looptok-mcReserved_arraytok)) & (stopset1)) != 0))
3029     {
3030       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "LOOP", 4)));
3031       n += 1;
3032     }
3033   if ((((1 << (mcReserved_intok-mcReserved_arraytok)) & (stopset1)) != 0))
3034     {
3035       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "IN", 2)));
3036       n += 1;
3037     }
3038   if ((((1 << (mcReserved_importtok-mcReserved_arraytok)) & (stopset1)) != 0))
3039     {
3040       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "IMPORT", 6)));
3041       n += 1;
3042     }
3043   if ((((1 << (mcReserved_implementationtok-mcReserved_arraytok)) & (stopset1)) != 0))
3044     {
3045       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "IMPLEMENTATION", 14)));
3046       n += 1;
3047     }
3048   if ((((1 << (mcReserved_iftok-mcReserved_arraytok)) & (stopset1)) != 0))
3049     {
3050       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "IF", 2)));
3051       n += 1;
3052     }
3053   if ((((1 << (mcReserved_fromtok-mcReserved_arraytok)) & (stopset1)) != 0))
3054     {
3055       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "FROM", 4)));
3056       n += 1;
3057     }
3058   if ((((1 << (mcReserved_fortok-mcReserved_arraytok)) & (stopset1)) != 0))
3059     {
3060       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "FOR", 3)));
3061       n += 1;
3062     }
3063   if ((((1 << (mcReserved_finallytok-mcReserved_arraytok)) & (stopset1)) != 0))
3064     {
3065       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "FINALLY", 7)));
3066       n += 1;
3067     }
3068   if ((((1 << (mcReserved_exporttok-mcReserved_arraytok)) & (stopset1)) != 0))
3069     {
3070       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "EXPORT", 6)));
3071       n += 1;
3072     }
3073   if ((((1 << (mcReserved_exittok-mcReserved_arraytok)) & (stopset1)) != 0))
3074     {
3075       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "EXIT", 4)));
3076       n += 1;
3077     }
3078   if ((((1 << (mcReserved_excepttok-mcReserved_arraytok)) & (stopset1)) != 0))
3079     {
3080       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "EXCEPT", 6)));
3081       n += 1;
3082     }
3083   if ((((1 << (mcReserved_endtok-mcReserved_arraytok)) & (stopset1)) != 0))
3084     {
3085       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "END", 3)));
3086       n += 1;
3087     }
3088   if ((((1 << (mcReserved_elsiftok-mcReserved_arraytok)) & (stopset1)) != 0))
3089     {
3090       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "ELSIF", 5)));
3091       n += 1;
3092     }
3093   if ((((1 << (mcReserved_elsetok-mcReserved_arraytok)) & (stopset1)) != 0))
3094     {
3095       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "ELSE", 4)));
3096       n += 1;
3097     }
3098   if ((((1 << (mcReserved_dotok-mcReserved_arraytok)) & (stopset1)) != 0))
3099     {
3100       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "DO", 2)));
3101       n += 1;
3102     }
3103   if ((((1 << (mcReserved_divtok-mcReserved_arraytok)) & (stopset1)) != 0))
3104     {
3105       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "DIV", 3)));
3106       n += 1;
3107     }
3108   if ((((1 << (mcReserved_definitiontok-mcReserved_arraytok)) & (stopset1)) != 0))
3109     {
3110       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "DEFINITION", 10)));
3111       n += 1;
3112     }
3113   if ((((1 << (mcReserved_consttok-mcReserved_arraytok)) & (stopset1)) != 0))
3114     {
3115       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "CONST", 5)));
3116       n += 1;
3117     }
3118   if ((((1 << (mcReserved_casetok-mcReserved_arraytok)) & (stopset1)) != 0))
3119     {
3120       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "CASE", 4)));
3121       n += 1;
3122     }
3123   if ((((1 << (mcReserved_bytok-mcReserved_arraytok)) & (stopset1)) != 0))
3124     {
3125       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "BY", 2)));
3126       n += 1;
3127     }
3128   if ((((1 << (mcReserved_begintok-mcReserved_arraytok)) & (stopset1)) != 0))
3129     {
3130       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "BEGIN", 5)));
3131       n += 1;
3132     }
3133   if ((((1 << (mcReserved_arraytok-mcReserved_arraytok)) & (stopset1)) != 0))
3134     {
3135       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "ARRAY", 5)));
3136       n += 1;
3137     }
3138   if ((((1 << (mcReserved_andtok-mcReserved_eoftok)) & (stopset0)) != 0))
3139     {
3140       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "AND", 3)));
3141       n += 1;
3142     }
3143   if ((((1 << (mcReserved_colontok-mcReserved_eoftok)) & (stopset0)) != 0))
3144     {
3145       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) ":", 1)));
3146       n += 1;
3147     }
3148   if ((((1 << (mcReserved_periodperiodtok-mcReserved_eoftok)) & (stopset0)) != 0))
3149     {
3150       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "..", 2)));
3151       n += 1;
3152     }
3153   if ((((1 << (mcReserved_rdirectivetok-mcReserved_eoftok)) & (stopset0)) != 0))
3154     {
3155       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "*>", 2)));
3156       n += 1;
3157     }
3158   if ((((1 << (mcReserved_ldirectivetok-mcReserved_eoftok)) & (stopset0)) != 0))
3159     {
3160       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "<*", 2)));
3161       n += 1;
3162     }
3163   if ((((1 << (mcReserved_greaterequaltok-mcReserved_eoftok)) & (stopset0)) != 0))
3164     {
3165       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) ">=", 2)));
3166       n += 1;
3167     }
3168   if ((((1 << (mcReserved_lessequaltok-mcReserved_eoftok)) & (stopset0)) != 0))
3169     {
3170       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "<=", 2)));
3171       n += 1;
3172     }
3173   if ((((1 << (mcReserved_lessgreatertok-mcReserved_eoftok)) & (stopset0)) != 0))
3174     {
3175       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "<>", 2)));
3176       n += 1;
3177     }
3178   if ((((1 << (mcReserved_hashtok-mcReserved_eoftok)) & (stopset0)) != 0))
3179     {
3180       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "#", 1)));
3181       n += 1;
3182     }
3183   if ((((1 << (mcReserved_equaltok-mcReserved_eoftok)) & (stopset0)) != 0))
3184     {
3185       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "=", 1)));
3186       n += 1;
3187     }
3188   if ((((1 << (mcReserved_uparrowtok-mcReserved_eoftok)) & (stopset0)) != 0))
3189     {
3190       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "^", 1)));
3191       n += 1;
3192     }
3193   if ((((1 << (mcReserved_semicolontok-mcReserved_eoftok)) & (stopset0)) != 0))
3194     {
3195       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) ";", 1)));
3196       n += 1;
3197     }
3198   if ((((1 << (mcReserved_commatok-mcReserved_eoftok)) & (stopset0)) != 0))
3199     {
3200       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) ",", 1)));
3201       n += 1;
3202     }
3203   if ((((1 << (mcReserved_periodtok-mcReserved_eoftok)) & (stopset0)) != 0))
3204     {
3205       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) ".", 1)));
3206       n += 1;
3207     }
3208   if ((((1 << (mcReserved_ambersandtok-mcReserved_eoftok)) & (stopset0)) != 0))
3209     {
3210       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "&", 1)));
3211       n += 1;
3212     }
3213   if ((((1 << (mcReserved_dividetok-mcReserved_eoftok)) & (stopset0)) != 0))
3214     {
3215       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "/", 1)));
3216       n += 1;
3217     }
3218   if ((((1 << (mcReserved_timestok-mcReserved_eoftok)) & (stopset0)) != 0))
3219     {
3220       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "*", 1)));
3221       n += 1;
3222     }
3223   if ((((1 << (mcReserved_minustok-mcReserved_eoftok)) & (stopset0)) != 0))
3224     {
3225       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "-", 1)));
3226       n += 1;
3227     }
3228   if ((((1 << (mcReserved_plustok-mcReserved_eoftok)) & (stopset0)) != 0))
3229     {
3230       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "+", 1)));
3231       n += 1;
3232     }
3233   if ((((1 << (mcReserved_doublequotestok-mcReserved_eoftok)) & (stopset0)) != 0))
3234     {
3235       message = DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (message, ' '), '`'), '"'), '\''), ',');
3236       n += 1;
3237     }
3238   if ((((1 << (mcReserved_singlequotetok-mcReserved_eoftok)) & (stopset0)) != 0))
3239     {
3240       message = DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (message, ' '), '"'), '\''), '"'), ',');
3241       n += 1;
3242     }
3243   if ((((1 << (mcReserved_greatertok-mcReserved_eoftok)) & (stopset0)) != 0))
3244     {
3245       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) ">", 1)));
3246       n += 1;
3247     }
3248   if ((((1 << (mcReserved_lesstok-mcReserved_eoftok)) & (stopset0)) != 0))
3249     {
3250       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "<", 1)));
3251       n += 1;
3252     }
3253   if ((((1 << (mcReserved_rparatok-mcReserved_eoftok)) & (stopset0)) != 0))
3254     {
3255       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) ")", 1)));
3256       n += 1;
3257     }
3258   if ((((1 << (mcReserved_lparatok-mcReserved_eoftok)) & (stopset0)) != 0))
3259     {
3260       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "(", 1)));
3261       n += 1;
3262     }
3263   if ((((1 << (mcReserved_rcbratok-mcReserved_eoftok)) & (stopset0)) != 0))
3264     {
3265       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "}", 1)));
3266       n += 1;
3267     }
3268   if ((((1 << (mcReserved_lcbratok-mcReserved_eoftok)) & (stopset0)) != 0))
3269     {
3270       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "{", 1)));
3271       n += 1;
3272     }
3273   if ((((1 << (mcReserved_rsbratok-mcReserved_eoftok)) & (stopset0)) != 0))
3274     {
3275       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "]", 1)));
3276       n += 1;
3277     }
3278   if ((((1 << (mcReserved_lsbratok-mcReserved_eoftok)) & (stopset0)) != 0))
3279     {
3280       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "[", 1)));
3281       n += 1;
3282     }
3283   if ((((1 << (mcReserved_bartok-mcReserved_eoftok)) & (stopset0)) != 0))
3284     {
3285       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "|", 1)));
3286       n += 1;
3287     }
3288   if ((((1 << (mcReserved_becomestok-mcReserved_eoftok)) & (stopset0)) != 0))
3289     {
3290       message = DynamicStrings_ConCat (DynamicStrings_ConCatChar (message, ' '), DynamicStrings_Mark (DynamicStrings_InitString ((const char *) ":=", 2)));
3291       n += 1;
3292     }
3293   if ((((1 << (mcReserved_eoftok-mcReserved_eoftok)) & (stopset0)) != 0))
3294     {}  /* empty.  */
3295   /* eoftok has no token name (needed to generate error messages)  */
3296   if (n == 0)
3297     {
3298       str = DynamicStrings_InitString ((const char *) " syntax error", 13);
3299       message = DynamicStrings_KillString (message);
3300     }
3301   else if (n == 1)
3302     {
3303       /* avoid dangling else.  */
3304       str = DynamicStrings_ConCat (message, DynamicStrings_Mark (DynamicStrings_InitString ((const char *) " missing ", 9)));
3305     }
3306   else
3307     {
3308       /* avoid dangling else.  */
3309       str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) " expecting one of", 17), message);
3310       message = DynamicStrings_KillString (message);
3311     }
3312   return str;
3313   /* static analysis guarentees a RETURN statement will be used before here.  */
3314   __builtin_unreachable ();
3315 }
3316
3317
3318 /*
3319    DescribeError - issues a message explaining what tokens were expected
3320 */
3321
3322 static void DescribeError (void)
3323 {
3324   DynamicStrings_String str;
3325
3326   str = DynamicStrings_InitString ((const char *) "", 0);
3327   switch (mcLexBuf_currenttoken)
3328     {
3329       case mcReserved_stringtok:
3330         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found string", 26), DynamicStrings_Mark (str));
3331         break;
3332
3333       case mcReserved_realtok:
3334         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found real number", 31), DynamicStrings_Mark (str));
3335         break;
3336
3337       case mcReserved_identtok:
3338         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found identifier", 30), DynamicStrings_Mark (str));
3339         break;
3340
3341       case mcReserved_integertok:
3342         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found integer number", 34), DynamicStrings_Mark (str));
3343         break;
3344
3345       case mcReserved_inlinetok:
3346         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found __INLINE__", 30), DynamicStrings_Mark (str));
3347         break;
3348
3349       case mcReserved_builtintok:
3350         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found __BUILTIN__", 31), DynamicStrings_Mark (str));
3351         break;
3352
3353       case mcReserved_attributetok:
3354         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found __ATTRIBUTE__", 33), DynamicStrings_Mark (str));
3355         break;
3356
3357       case mcReserved_filetok:
3358         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found __FILE__", 28), DynamicStrings_Mark (str));
3359         break;
3360
3361       case mcReserved_linetok:
3362         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found __LINE__", 28), DynamicStrings_Mark (str));
3363         break;
3364
3365       case mcReserved_datetok:
3366         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found __DATE__", 28), DynamicStrings_Mark (str));
3367         break;
3368
3369       case mcReserved_periodperiodperiodtok:
3370         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ...", 23), DynamicStrings_Mark (str));
3371         break;
3372
3373       case mcReserved_volatiletok:
3374         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found VOLATILE", 28), DynamicStrings_Mark (str));
3375         break;
3376
3377       case mcReserved_asmtok:
3378         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ASM", 23), DynamicStrings_Mark (str));
3379         break;
3380
3381       case mcReserved_withtok:
3382         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found WITH", 24), DynamicStrings_Mark (str));
3383         break;
3384
3385       case mcReserved_whiletok:
3386         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found WHILE", 25), DynamicStrings_Mark (str));
3387         break;
3388
3389       case mcReserved_vartok:
3390         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found VAR", 23), DynamicStrings_Mark (str));
3391         break;
3392
3393       case mcReserved_untiltok:
3394         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found UNTIL", 25), DynamicStrings_Mark (str));
3395         break;
3396
3397       case mcReserved_typetok:
3398         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found TYPE", 24), DynamicStrings_Mark (str));
3399         break;
3400
3401       case mcReserved_totok:
3402         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found TO", 22), DynamicStrings_Mark (str));
3403         break;
3404
3405       case mcReserved_thentok:
3406         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found THEN", 24), DynamicStrings_Mark (str));
3407         break;
3408
3409       case mcReserved_settok:
3410         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found SET", 23), DynamicStrings_Mark (str));
3411         break;
3412
3413       case mcReserved_returntok:
3414         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found RETURN", 26), DynamicStrings_Mark (str));
3415         break;
3416
3417       case mcReserved_retrytok:
3418         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found RETRY", 25), DynamicStrings_Mark (str));
3419         break;
3420
3421       case mcReserved_repeattok:
3422         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found REPEAT", 26), DynamicStrings_Mark (str));
3423         break;
3424
3425       case mcReserved_remtok:
3426         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found REM", 23), DynamicStrings_Mark (str));
3427         break;
3428
3429       case mcReserved_recordtok:
3430         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found RECORD", 26), DynamicStrings_Mark (str));
3431         break;
3432
3433       case mcReserved_unqualifiedtok:
3434         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found UNQUALIFIED", 31), DynamicStrings_Mark (str));
3435         break;
3436
3437       case mcReserved_qualifiedtok:
3438         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found QUALIFIED", 29), DynamicStrings_Mark (str));
3439         break;
3440
3441       case mcReserved_proceduretok:
3442         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found PROCEDURE", 29), DynamicStrings_Mark (str));
3443         break;
3444
3445       case mcReserved_pointertok:
3446         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found POINTER", 27), DynamicStrings_Mark (str));
3447         break;
3448
3449       case mcReserved_packedsettok:
3450         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found PACKEDSET", 29), DynamicStrings_Mark (str));
3451         break;
3452
3453       case mcReserved_ortok:
3454         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found OR", 22), DynamicStrings_Mark (str));
3455         break;
3456
3457       case mcReserved_oftok:
3458         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found OF", 22), DynamicStrings_Mark (str));
3459         break;
3460
3461       case mcReserved_nottok:
3462         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found NOT", 23), DynamicStrings_Mark (str));
3463         break;
3464
3465       case mcReserved_moduletok:
3466         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found MODULE", 26), DynamicStrings_Mark (str));
3467         break;
3468
3469       case mcReserved_modtok:
3470         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found MOD", 23), DynamicStrings_Mark (str));
3471         break;
3472
3473       case mcReserved_looptok:
3474         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found LOOP", 24), DynamicStrings_Mark (str));
3475         break;
3476
3477       case mcReserved_intok:
3478         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found IN", 22), DynamicStrings_Mark (str));
3479         break;
3480
3481       case mcReserved_importtok:
3482         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found IMPORT", 26), DynamicStrings_Mark (str));
3483         break;
3484
3485       case mcReserved_implementationtok:
3486         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found IMPLEMENTATION", 34), DynamicStrings_Mark (str));
3487         break;
3488
3489       case mcReserved_iftok:
3490         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found IF", 22), DynamicStrings_Mark (str));
3491         break;
3492
3493       case mcReserved_fromtok:
3494         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found FROM", 24), DynamicStrings_Mark (str));
3495         break;
3496
3497       case mcReserved_fortok:
3498         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found FOR", 23), DynamicStrings_Mark (str));
3499         break;
3500
3501       case mcReserved_finallytok:
3502         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found FINALLY", 27), DynamicStrings_Mark (str));
3503         break;
3504
3505       case mcReserved_exporttok:
3506         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found EXPORT", 26), DynamicStrings_Mark (str));
3507         break;
3508
3509       case mcReserved_exittok:
3510         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found EXIT", 24), DynamicStrings_Mark (str));
3511         break;
3512
3513       case mcReserved_excepttok:
3514         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found EXCEPT", 26), DynamicStrings_Mark (str));
3515         break;
3516
3517       case mcReserved_endtok:
3518         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found END", 23), DynamicStrings_Mark (str));
3519         break;
3520
3521       case mcReserved_elsiftok:
3522         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ELSIF", 25), DynamicStrings_Mark (str));
3523         break;
3524
3525       case mcReserved_elsetok:
3526         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ELSE", 24), DynamicStrings_Mark (str));
3527         break;
3528
3529       case mcReserved_dotok:
3530         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found DO", 22), DynamicStrings_Mark (str));
3531         break;
3532
3533       case mcReserved_divtok:
3534         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found DIV", 23), DynamicStrings_Mark (str));
3535         break;
3536
3537       case mcReserved_definitiontok:
3538         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found DEFINITION", 30), DynamicStrings_Mark (str));
3539         break;
3540
3541       case mcReserved_consttok:
3542         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found CONST", 25), DynamicStrings_Mark (str));
3543         break;
3544
3545       case mcReserved_casetok:
3546         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found CASE", 24), DynamicStrings_Mark (str));
3547         break;
3548
3549       case mcReserved_bytok:
3550         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found BY", 22), DynamicStrings_Mark (str));
3551         break;
3552
3553       case mcReserved_begintok:
3554         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found BEGIN", 25), DynamicStrings_Mark (str));
3555         break;
3556
3557       case mcReserved_arraytok:
3558         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ARRAY", 25), DynamicStrings_Mark (str));
3559         break;
3560
3561       case mcReserved_andtok:
3562         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found AND", 23), DynamicStrings_Mark (str));
3563         break;
3564
3565       case mcReserved_colontok:
3566         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found :", 21), DynamicStrings_Mark (str));
3567         break;
3568
3569       case mcReserved_periodperiodtok:
3570         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ..", 22), DynamicStrings_Mark (str));
3571         break;
3572
3573       case mcReserved_rdirectivetok:
3574         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found *>", 22), DynamicStrings_Mark (str));
3575         break;
3576
3577       case mcReserved_ldirectivetok:
3578         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found <*", 22), DynamicStrings_Mark (str));
3579         break;
3580
3581       case mcReserved_greaterequaltok:
3582         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found >=", 22), DynamicStrings_Mark (str));
3583         break;
3584
3585       case mcReserved_lessequaltok:
3586         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found <=", 22), DynamicStrings_Mark (str));
3587         break;
3588
3589       case mcReserved_lessgreatertok:
3590         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found <>", 22), DynamicStrings_Mark (str));
3591         break;
3592
3593       case mcReserved_hashtok:
3594         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found #", 21), DynamicStrings_Mark (str));
3595         break;
3596
3597       case mcReserved_equaltok:
3598         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found =", 21), DynamicStrings_Mark (str));
3599         break;
3600
3601       case mcReserved_uparrowtok:
3602         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ^", 21), DynamicStrings_Mark (str));
3603         break;
3604
3605       case mcReserved_semicolontok:
3606         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ;", 21), DynamicStrings_Mark (str));
3607         break;
3608
3609       case mcReserved_commatok:
3610         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ,", 21), DynamicStrings_Mark (str));
3611         break;
3612
3613       case mcReserved_periodtok:
3614         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found .", 21), DynamicStrings_Mark (str));
3615         break;
3616
3617       case mcReserved_ambersandtok:
3618         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found &", 21), DynamicStrings_Mark (str));
3619         break;
3620
3621       case mcReserved_dividetok:
3622         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found /", 21), DynamicStrings_Mark (str));
3623         break;
3624
3625       case mcReserved_timestok:
3626         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found *", 21), DynamicStrings_Mark (str));
3627         break;
3628
3629       case mcReserved_minustok:
3630         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found -", 21), DynamicStrings_Mark (str));
3631         break;
3632
3633       case mcReserved_plustok:
3634         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found +", 21), DynamicStrings_Mark (str));
3635         break;
3636
3637       case mcReserved_doublequotestok:
3638         str = DynamicStrings_ConCat (DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (DynamicStrings_InitString ((const char *) "syntax error, found '", 21), '"'), '\''), DynamicStrings_Mark (str));
3639         break;
3640
3641       case mcReserved_singlequotetok:
3642         str = DynamicStrings_ConCat (DynamicStrings_ConCatChar (DynamicStrings_ConCatChar (DynamicStrings_InitString ((const char *) "syntax error, found \"", 21), '\''), '"'), DynamicStrings_Mark (str));
3643         break;
3644
3645       case mcReserved_greatertok:
3646         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found >", 21), DynamicStrings_Mark (str));
3647         break;
3648
3649       case mcReserved_lesstok:
3650         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found <", 21), DynamicStrings_Mark (str));
3651         break;
3652
3653       case mcReserved_rparatok:
3654         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found )", 21), DynamicStrings_Mark (str));
3655         break;
3656
3657       case mcReserved_lparatok:
3658         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found (", 21), DynamicStrings_Mark (str));
3659         break;
3660
3661       case mcReserved_rcbratok:
3662         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found }", 21), DynamicStrings_Mark (str));
3663         break;
3664
3665       case mcReserved_lcbratok:
3666         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found {", 21), DynamicStrings_Mark (str));
3667         break;
3668
3669       case mcReserved_rsbratok:
3670         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ]", 21), DynamicStrings_Mark (str));
3671         break;
3672
3673       case mcReserved_lsbratok:
3674         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found [", 21), DynamicStrings_Mark (str));
3675         break;
3676
3677       case mcReserved_bartok:
3678         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found |", 21), DynamicStrings_Mark (str));
3679         break;
3680
3681       case mcReserved_becomestok:
3682         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found :=", 22), DynamicStrings_Mark (str));
3683         break;
3684
3685       case mcReserved_eoftok:
3686         str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error, found ", 20), DynamicStrings_Mark (str));
3687         break;
3688
3689
3690       default:
3691         break;
3692     }
3693   ErrorString (str);
3694 }
3695
3696
3697 /*
3698    SyntaxError - after a syntax error we skip all tokens up until we reach
3699                  a stop symbol.
3700 */
3701
3702 static void SyntaxError (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3703 {
3704   DescribeError ();
3705   if (Debugging)
3706     {
3707       mcPrintf_printf0 ((const char *) "\\nskipping token *** ", 21);
3708     }
3709   /*
3710       yes the ORD(currenttoken) looks ugly, but it is *much* safer than
3711       using currenttoken<sometok as a change to the ordering of the
3712       token declarations below would cause this to break. Using ORD() we are
3713       immune from such changes
3714   */
3715   while (! (((( ((unsigned int) (mcLexBuf_currenttoken)) < 32) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & (stopset0)) != 0))) || ((( ((unsigned int) (mcLexBuf_currenttoken)) >= 32) && ( ((unsigned int) (mcLexBuf_currenttoken)) < 64)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & (stopset1)) != 0)))) || (( ((unsigned int) (mcLexBuf_currenttoken)) >= 64) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & (stopset2)) != 0)))))
3716     {
3717       mcLexBuf_getToken ();
3718     }
3719   if (Debugging)
3720     {
3721       mcPrintf_printf0 ((const char *) " ***\\n", 6);
3722     }
3723 }
3724
3725
3726 /*
3727    SyntaxCheck -
3728 */
3729
3730 static void SyntaxCheck (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3731 {
3732   /* and again (see above re: ORD)
3733   */
3734   if (! (((( ((unsigned int) (mcLexBuf_currenttoken)) < 32) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & (stopset0)) != 0))) || ((( ((unsigned int) (mcLexBuf_currenttoken)) >= 32) && ( ((unsigned int) (mcLexBuf_currenttoken)) < 64)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & (stopset1)) != 0)))) || (( ((unsigned int) (mcLexBuf_currenttoken)) >= 64) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & (stopset2)) != 0)))))
3735     {
3736       SyntaxError (stopset0, stopset1, stopset2);
3737     }
3738 }
3739
3740
3741 /*
3742    WarnMissingToken - generates a warning message about a missing token, t.
3743 */
3744
3745 static void WarnMissingToken (mcReserved_toktype t)
3746 {
3747   mcp5_SetOfStop0 s0;
3748   mcp5_SetOfStop1 s1;
3749   mcp5_SetOfStop2 s2;
3750   DynamicStrings_String str;
3751
3752   s0 = (mcp5_SetOfStop0) 0;
3753   s1 = (mcp5_SetOfStop1) 0;
3754   s2 = (mcp5_SetOfStop2) 0;
3755   if ( ((unsigned int) (t)) < 32)
3756     {
3757       s0 = (mcp5_SetOfStop0) ((1 << (t-mcReserved_eoftok)));
3758     }
3759   else if ( ((unsigned int) (t)) < 64)
3760     {
3761       /* avoid dangling else.  */
3762       s1 = (mcp5_SetOfStop1) ((1 << (t-mcReserved_arraytok)));
3763     }
3764   else
3765     {
3766       /* avoid dangling else.  */
3767       s2 = (mcp5_SetOfStop2) ((1 << (t-mcReserved_recordtok)));
3768     }
3769   str = DescribeStop (s0, s1, s2);
3770   str = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "syntax error,", 13), DynamicStrings_Mark (str));
3771   mcError_errorStringAt (str, mcLexBuf_getTokenNo ());
3772 }
3773
3774
3775 /*
3776    MissingToken - generates a warning message about a missing token, t.
3777 */
3778
3779 static void MissingToken (mcReserved_toktype t)
3780 {
3781   WarnMissingToken (t);
3782   if ((((t != mcReserved_identtok) && (t != mcReserved_integertok)) && (t != mcReserved_realtok)) && (t != mcReserved_stringtok))
3783     {
3784       if (Debugging)
3785         {
3786           mcPrintf_printf0 ((const char *) "inserting token\\n", 17);
3787         }
3788       mcLexBuf_insertToken (t);
3789     }
3790 }
3791
3792
3793 /*
3794    CheckAndInsert -
3795 */
3796
3797 static bool CheckAndInsert (mcReserved_toktype t, mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3798 {
3799   if (((( ((unsigned int) (t)) < 32) && ((((1 << (t-mcReserved_eoftok)) & (stopset0)) != 0))) || ((( ((unsigned int) (t)) >= 32) && ( ((unsigned int) (t)) < 64)) && ((((1 << (t-mcReserved_arraytok)) & (stopset1)) != 0)))) || (( ((unsigned int) (t)) >= 64) && ((((1 << (t-mcReserved_recordtok)) & (stopset2)) != 0))))
3800     {
3801       WarnMissingToken (t);
3802       mcLexBuf_insertTokenAndRewind (t);
3803       return true;
3804     }
3805   else
3806     {
3807       return false;
3808     }
3809   /* static analysis guarentees a RETURN statement will be used before here.  */
3810   __builtin_unreachable ();
3811 }
3812
3813
3814 /*
3815    InStopSet
3816 */
3817
3818 static bool InStopSet (mcReserved_toktype t, mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3819 {
3820   if (((( ((unsigned int) (t)) < 32) && ((((1 << (t-mcReserved_eoftok)) & (stopset0)) != 0))) || ((( ((unsigned int) (t)) >= 32) && ( ((unsigned int) (t)) < 64)) && ((((1 << (t-mcReserved_arraytok)) & (stopset1)) != 0)))) || (( ((unsigned int) (t)) >= 64) && ((((1 << (t-mcReserved_recordtok)) & (stopset2)) != 0))))
3821     {
3822       return true;
3823     }
3824   else
3825     {
3826       return false;
3827     }
3828   /* static analysis guarentees a RETURN statement will be used before here.  */
3829   __builtin_unreachable ();
3830 }
3831
3832
3833 /*
3834    PeepToken - peep token checks to see whether the stopset is satisfied by currenttoken
3835                If it is not then it will insert a token providing the token
3836                is one of ; ] ) } . OF END ,
3837
3838                if the stopset contains <identtok> then we do not insert a token
3839 */
3840
3841 static void PeepToken (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3842 {
3843   /* and again (see above re: ORD)
3844   */
3845   if ((! (((( ((unsigned int) (mcLexBuf_currenttoken)) < 32) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & (stopset0)) != 0))) || ((( ((unsigned int) (mcLexBuf_currenttoken)) >= 32) && ( ((unsigned int) (mcLexBuf_currenttoken)) < 64)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & (stopset1)) != 0)))) || (( ((unsigned int) (mcLexBuf_currenttoken)) >= 64) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & (stopset2)) != 0))))) && (! (InStopSet (mcReserved_identtok, stopset0, stopset1, stopset2))))
3846     {
3847       /* SyntaxCheck would fail since currentoken is not part of the stopset
3848          we check to see whether any of currenttoken might be a commonly omitted token  */
3849       if ((((((((CheckAndInsert (mcReserved_semicolontok, stopset0, stopset1, stopset2)) || (CheckAndInsert (mcReserved_rsbratok, stopset0, stopset1, stopset2))) || (CheckAndInsert (mcReserved_rparatok, stopset0, stopset1, stopset2))) || (CheckAndInsert (mcReserved_rcbratok, stopset0, stopset1, stopset2))) || (CheckAndInsert (mcReserved_periodtok, stopset0, stopset1, stopset2))) || (CheckAndInsert (mcReserved_oftok, stopset0, stopset1, stopset2))) || (CheckAndInsert (mcReserved_endtok, stopset0, stopset1, stopset2))) || (CheckAndInsert (mcReserved_commatok, stopset0, stopset1, stopset2)))
3850         {}  /* empty.  */
3851     }
3852 }
3853
3854
3855 /*
3856    Expect -
3857 */
3858
3859 static void Expect (mcReserved_toktype t, mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3860 {
3861   if (mcLexBuf_currenttoken == t)
3862     {
3863       /* avoid dangling else.  */
3864       mcLexBuf_getToken ();
3865       if (Pass1)
3866         {
3867           PeepToken (stopset0, stopset1, stopset2);
3868         }
3869     }
3870   else
3871     {
3872       MissingToken (t);
3873     }
3874   SyntaxCheck (stopset0, stopset1, stopset2);
3875 }
3876
3877
3878 /*
3879    Ident - error checking varient of Ident
3880 */
3881
3882 static void Ident (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3883 {
3884   curident = nameKey_makekey (mcLexBuf_currentstring);
3885   Expect (mcReserved_identtok, stopset0, stopset1, stopset2);
3886 }
3887
3888
3889 /*
3890    string -
3891 */
3892
3893 static void string (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3894 {
3895   curstring = nameKey_makekey (mcLexBuf_currentstring);
3896   Expect (mcReserved_stringtok, stopset0, stopset1, stopset2);
3897 }
3898
3899
3900 /*
3901    Integer -
3902 */
3903
3904 static void Integer (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3905 {
3906   decl_node n;
3907
3908   n = push (decl_makeLiteralInt (nameKey_makekey (mcLexBuf_currentstring)));
3909   Expect (mcReserved_integertok, stopset0, stopset1, stopset2);
3910 }
3911
3912
3913 /*
3914    Real -
3915 */
3916
3917 static void Real (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3918 {
3919   decl_node n;
3920
3921   n = push (decl_makeLiteralReal (nameKey_makekey (mcLexBuf_currentstring)));
3922   Expect (mcReserved_realtok, stopset0, stopset1, stopset2);
3923 }
3924
3925
3926 /*
3927    FileUnit := DefinitionModule  |
3928                ImplementationOrProgramModule
3929
3930    first  symbols:implementationtok, moduletok, definitiontok
3931
3932    cannot reachend
3933 */
3934
3935 static void FileUnit (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3936 {
3937   if (mcLexBuf_currenttoken == mcReserved_definitiontok)
3938     {
3939       DefinitionModule (stopset0, stopset1, stopset2);
3940     }
3941   else if (((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_implementationtok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))))) != 0)))
3942     {
3943       /* avoid dangling else.  */
3944       ImplementationOrProgramModule (stopset0, stopset1, stopset2);
3945     }
3946   else
3947     {
3948       /* avoid dangling else.  */
3949       ErrorArray ((const char *) "expecting one of: IMPLEMENTATION MODULE DEFINITION", 50);
3950     }
3951 }
3952
3953
3954 /*
3955    ProgramModule := 'MODULE' Ident
3956                     % curmodule := lookupModule (curident)  %
3957
3958                     % addCommentBody (curmodule)  %
3959
3960                     % enterScope (curmodule)  %
3961
3962                     % resetConstExpPos (curmodule)  %
3963                     [ Priority  ] ';' { Import  } Block
3964                     Ident
3965                     % checkEndName (curmodule, curident, 'program module')  %
3966
3967                     % leaveScope  %
3968                     '.'
3969
3970    first  symbols:moduletok
3971
3972    cannot reachend
3973 */
3974
3975 static void ProgramModule (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
3976 {
3977   Expect (mcReserved_moduletok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
3978   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2);
3979   curmodule = decl_lookupModule (curident);
3980   decl_addCommentBody (curmodule);
3981   decl_enterScope (curmodule);
3982   decl_resetConstExpPos (curmodule);
3983   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
3984     {
3985       Priority (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
3986     }
3987   Expect (mcReserved_semicolontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_importtok-mcReserved_arraytok)) | (1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
3988   while (((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok))))) != 0)))
3989     {
3990       Import (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_typetok-mcReserved_recordtok))));
3991     }
3992    /* while  */
3993   Block (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
3994   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok))), stopset1, stopset2);
3995   checkEndName (curmodule, curident, (const char *) "program module", 14);
3996   decl_leaveScope ();
3997   Expect (mcReserved_periodtok, stopset0, stopset1, stopset2);
3998 }
3999
4000
4001 /*
4002    ImplementationModule := 'IMPLEMENTATION' 'MODULE'
4003                            Ident
4004                            % curmodule := lookupImp (curident)  %
4005
4006                            % addCommentBody (curmodule)  %
4007
4008                            % enterScope (lookupDef (curident))  %
4009
4010                            % enterScope (curmodule)  %
4011
4012                            % resetConstExpPos (curmodule)  %
4013                            [ Priority  ] ';' { Import  }
4014                            Block Ident
4015                            % checkEndName (curmodule, curident, 'implementation module')  %
4016
4017                            % leaveScope ; leaveScope  %
4018                            '.'
4019
4020    first  symbols:implementationtok
4021
4022    cannot reachend
4023 */
4024
4025 static void ImplementationModule (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4026 {
4027   Expect (mcReserved_implementationtok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_moduletok-mcReserved_arraytok))), stopset2);
4028   Expect (mcReserved_moduletok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4029   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2);
4030   curmodule = decl_lookupImp (curident);
4031   decl_addCommentBody (curmodule);
4032   decl_enterScope (decl_lookupDef (curident));
4033   decl_enterScope (curmodule);
4034   decl_resetConstExpPos (curmodule);
4035   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
4036     {
4037       Priority (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
4038     }
4039   Expect (mcReserved_semicolontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_importtok-mcReserved_arraytok)) | (1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
4040   while (((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok))))) != 0)))
4041     {
4042       Import (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_typetok-mcReserved_recordtok))));
4043     }
4044    /* while  */
4045   Block (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4046   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok))), stopset1, stopset2);
4047   checkEndName (curmodule, curident, (const char *) "implementation module", 21);
4048   decl_leaveScope ();
4049   decl_leaveScope ();
4050   Expect (mcReserved_periodtok, stopset0, stopset1, stopset2);
4051 }
4052
4053
4054 /*
4055    ImplementationOrProgramModule := ImplementationModule  |
4056                                     ProgramModule
4057
4058    first  symbols:moduletok, implementationtok
4059
4060    cannot reachend
4061 */
4062
4063 static void ImplementationOrProgramModule (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4064 {
4065   if (mcLexBuf_currenttoken == mcReserved_implementationtok)
4066     {
4067       ImplementationModule (stopset0, stopset1, stopset2);
4068     }
4069   else if (mcLexBuf_currenttoken == mcReserved_moduletok)
4070     {
4071       /* avoid dangling else.  */
4072       ProgramModule (stopset0, stopset1, stopset2);
4073     }
4074   else
4075     {
4076       /* avoid dangling else.  */
4077       ErrorArray ((const char *) "expecting one of: MODULE IMPLEMENTATION", 39);
4078     }
4079 }
4080
4081
4082 /*
4083    ConstInteger := Integer
4084                    % VAR i: node ;  %
4085
4086                    % i := pop ()  %
4087
4088
4089    first  symbols:integertok
4090
4091    cannot reachend
4092 */
4093
4094 static void ConstInteger (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4095 {
4096   decl_node i;
4097
4098   Integer (stopset0, stopset1, stopset2);
4099   i = pop ();
4100 }
4101
4102
4103 /*
4104    ConstReal := Real
4105                 % VAR r: node ;  %
4106
4107                 % r := pop ()  %
4108
4109
4110    first  symbols:realtok
4111
4112    cannot reachend
4113 */
4114
4115 static void ConstReal (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4116 {
4117   decl_node r;
4118
4119   Real (stopset0, stopset1, stopset2);
4120   r = pop ();
4121 }
4122
4123
4124 /*
4125    ConstNumber := ConstInteger  | ConstReal
4126
4127    first  symbols:realtok, integertok
4128
4129    cannot reachend
4130 */
4131
4132 static void ConstNumber (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4133 {
4134   if (mcLexBuf_currenttoken == mcReserved_integertok)
4135     {
4136       ConstInteger (stopset0, stopset1, stopset2);
4137     }
4138   else if (mcLexBuf_currenttoken == mcReserved_realtok)
4139     {
4140       /* avoid dangling else.  */
4141       ConstReal (stopset0, stopset1, stopset2);
4142     }
4143   else
4144     {
4145       /* avoid dangling else.  */
4146       ErrorArray ((const char *) "expecting one of: real number integer number", 44);
4147     }
4148 }
4149
4150
4151 /*
4152    Number := Integer  | Real
4153
4154    first  symbols:realtok, integertok
4155
4156    cannot reachend
4157 */
4158
4159 static void Number (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4160 {
4161   if (mcLexBuf_currenttoken == mcReserved_integertok)
4162     {
4163       Integer (stopset0, stopset1, stopset2);
4164     }
4165   else if (mcLexBuf_currenttoken == mcReserved_realtok)
4166     {
4167       /* avoid dangling else.  */
4168       Real (stopset0, stopset1, stopset2);
4169     }
4170   else
4171     {
4172       /* avoid dangling else.  */
4173       ErrorArray ((const char *) "expecting one of: real number integer number", 44);
4174     }
4175 }
4176
4177
4178 /*
4179    Qualident := Ident { '.' Ident  }
4180
4181    first  symbols:identtok
4182
4183    cannot reachend
4184 */
4185
4186 static void Qualident (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4187 {
4188   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok))), stopset1, stopset2);
4189   while (mcLexBuf_currenttoken == mcReserved_periodtok)
4190     {
4191       Expect (mcReserved_periodtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4192       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok))), stopset1, stopset2);
4193     }
4194    /* while  */
4195 }
4196
4197
4198 /*
4199    ConstantDeclaration := Ident '=' ConstExpressionNop
4200
4201    first  symbols:identtok
4202
4203    cannot reachend
4204 */
4205
4206 static void ConstantDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4207 {
4208   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_equaltok-mcReserved_eoftok))), stopset1, stopset2);
4209   Expect (mcReserved_equaltok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4210   ConstExpressionNop (stopset0, stopset1, stopset2);
4211 }
4212
4213
4214 /*
4215    ConstExpressionNop :=
4216                          % VAR c: node ;  %
4217
4218                          % c := getNextConstExp ()  %
4219                          SimpleConstExpr [ Relation
4220                                            SimpleConstExpr  ]
4221
4222    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
4223
4224    cannot reachend
4225 */
4226
4227 static void ConstExpressionNop (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4228 {
4229   decl_node c;
4230
4231   c = decl_getNextConstExp ();
4232   SimpleConstExpr (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_greaterequaltok-mcReserved_eoftok)) | (1 << (mcReserved_greatertok-mcReserved_eoftok)) | (1 << (mcReserved_lessequaltok-mcReserved_eoftok)) | (1 << (mcReserved_lesstok-mcReserved_eoftok)) | (1 << (mcReserved_lessgreatertok-mcReserved_eoftok)) | (1 << (mcReserved_hashtok-mcReserved_eoftok)) | (1 << (mcReserved_equaltok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_intok-mcReserved_arraytok))), stopset2);
4233   if (((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_equaltok-mcReserved_eoftok)) | (1 << (mcReserved_hashtok-mcReserved_eoftok)) | (1 << (mcReserved_lessgreatertok-mcReserved_eoftok)) | (1 << (mcReserved_lesstok-mcReserved_eoftok)) | (1 << (mcReserved_lessequaltok-mcReserved_eoftok)) | (1 << (mcReserved_greatertok-mcReserved_eoftok)) | (1 << (mcReserved_greaterequaltok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_intok))
4234     {
4235       Relation (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
4236       SimpleConstExpr (stopset0, stopset1, stopset2);
4237     }
4238 }
4239
4240
4241 /*
4242    ConstExpression :=
4243                       % VAR c: node ;  %
4244
4245                       % c := push (getNextConstExp ())  %
4246                       SimpleConstExpr [ Relation SimpleConstExpr  ]
4247
4248    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
4249
4250    cannot reachend
4251 */
4252
4253 static void ConstExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4254 {
4255   decl_node c;
4256
4257   c = push (decl_getNextConstExp ());
4258   SimpleConstExpr (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_greaterequaltok-mcReserved_eoftok)) | (1 << (mcReserved_greatertok-mcReserved_eoftok)) | (1 << (mcReserved_lessequaltok-mcReserved_eoftok)) | (1 << (mcReserved_lesstok-mcReserved_eoftok)) | (1 << (mcReserved_lessgreatertok-mcReserved_eoftok)) | (1 << (mcReserved_hashtok-mcReserved_eoftok)) | (1 << (mcReserved_equaltok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_intok-mcReserved_arraytok))), stopset2);
4259   if (((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_equaltok-mcReserved_eoftok)) | (1 << (mcReserved_hashtok-mcReserved_eoftok)) | (1 << (mcReserved_lessgreatertok-mcReserved_eoftok)) | (1 << (mcReserved_lesstok-mcReserved_eoftok)) | (1 << (mcReserved_lessequaltok-mcReserved_eoftok)) | (1 << (mcReserved_greatertok-mcReserved_eoftok)) | (1 << (mcReserved_greaterequaltok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_intok))
4260     {
4261       Relation (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
4262       SimpleConstExpr (stopset0, stopset1, stopset2);
4263     }
4264 }
4265
4266
4267 /*
4268    Relation := '='  | '#'  | '<>'  | '<'  | '<='  |
4269                '>'  | '>='  | 'IN'
4270
4271    first  symbols:intok, greaterequaltok, greatertok, lessequaltok, lesstok, lessgreatertok, hashtok, equaltok
4272
4273    cannot reachend
4274 */
4275
4276 static void Relation (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4277 {
4278   if (mcLexBuf_currenttoken == mcReserved_equaltok)
4279     {
4280       Expect (mcReserved_equaltok, stopset0, stopset1, stopset2);
4281     }
4282   else if (mcLexBuf_currenttoken == mcReserved_hashtok)
4283     {
4284       /* avoid dangling else.  */
4285       Expect (mcReserved_hashtok, stopset0, stopset1, stopset2);
4286     }
4287   else if (mcLexBuf_currenttoken == mcReserved_lessgreatertok)
4288     {
4289       /* avoid dangling else.  */
4290       Expect (mcReserved_lessgreatertok, stopset0, stopset1, stopset2);
4291     }
4292   else if (mcLexBuf_currenttoken == mcReserved_lesstok)
4293     {
4294       /* avoid dangling else.  */
4295       Expect (mcReserved_lesstok, stopset0, stopset1, stopset2);
4296     }
4297   else if (mcLexBuf_currenttoken == mcReserved_lessequaltok)
4298     {
4299       /* avoid dangling else.  */
4300       Expect (mcReserved_lessequaltok, stopset0, stopset1, stopset2);
4301     }
4302   else if (mcLexBuf_currenttoken == mcReserved_greatertok)
4303     {
4304       /* avoid dangling else.  */
4305       Expect (mcReserved_greatertok, stopset0, stopset1, stopset2);
4306     }
4307   else if (mcLexBuf_currenttoken == mcReserved_greaterequaltok)
4308     {
4309       /* avoid dangling else.  */
4310       Expect (mcReserved_greaterequaltok, stopset0, stopset1, stopset2);
4311     }
4312   else if (mcLexBuf_currenttoken == mcReserved_intok)
4313     {
4314       /* avoid dangling else.  */
4315       Expect (mcReserved_intok, stopset0, stopset1, stopset2);
4316     }
4317   else
4318     {
4319       /* avoid dangling else.  */
4320       ErrorArray ((const char *) "expecting one of: IN >= > <= < <> # =", 37);
4321     }
4322 }
4323
4324
4325 /*
4326    SimpleConstExpr := UnaryOrConstTerm { AddOperator
4327                                          ConstTerm  }
4328
4329    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
4330
4331    cannot reachend
4332 */
4333
4334 static void SimpleConstExpr (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4335 {
4336   UnaryOrConstTerm (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_ortok-mcReserved_arraytok))), stopset2);
4337   while (((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_ortok))
4338     {
4339       AddOperator (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
4340       ConstTerm (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_ortok-mcReserved_arraytok))), stopset2);
4341     }
4342    /* while  */
4343 }
4344
4345
4346 /*
4347    UnaryOrConstTerm := '+' ConstTerm  |
4348                        '-' ConstTerm  |
4349                        ConstTerm
4350
4351    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
4352
4353    cannot reachend
4354 */
4355
4356 static void UnaryOrConstTerm (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4357 {
4358   if (mcLexBuf_currenttoken == mcReserved_plustok)
4359     {
4360       Expect (mcReserved_plustok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
4361       ConstTerm (stopset0, stopset1, stopset2);
4362     }
4363   else if (mcLexBuf_currenttoken == mcReserved_minustok)
4364     {
4365       /* avoid dangling else.  */
4366       Expect (mcReserved_minustok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
4367       ConstTerm (stopset0, stopset1, stopset2);
4368     }
4369   else if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))))) != 0))))
4370     {
4371       /* avoid dangling else.  */
4372       ConstTerm (stopset0, stopset1, stopset2);
4373     }
4374   else
4375     {
4376       /* avoid dangling else.  */
4377       ErrorArray ((const char *) "expecting one of: NOT ( integer number real number __ATTRIBUTE__ identifier { string - +", 88);
4378     }
4379 }
4380
4381
4382 /*
4383    AddOperator := '+'  | '-'  | 'OR'
4384
4385    first  symbols:ortok, minustok, plustok
4386
4387    cannot reachend
4388 */
4389
4390 static void AddOperator (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4391 {
4392   if (mcLexBuf_currenttoken == mcReserved_plustok)
4393     {
4394       Expect (mcReserved_plustok, stopset0, stopset1, stopset2);
4395     }
4396   else if (mcLexBuf_currenttoken == mcReserved_minustok)
4397     {
4398       /* avoid dangling else.  */
4399       Expect (mcReserved_minustok, stopset0, stopset1, stopset2);
4400     }
4401   else if (mcLexBuf_currenttoken == mcReserved_ortok)
4402     {
4403       /* avoid dangling else.  */
4404       Expect (mcReserved_ortok, stopset0, stopset1, stopset2);
4405     }
4406   else
4407     {
4408       /* avoid dangling else.  */
4409       ErrorArray ((const char *) "expecting one of: OR - +", 24);
4410     }
4411 }
4412
4413
4414 /*
4415    ConstTerm := ConstFactor { MulOperator ConstFactor  }
4416
4417    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok
4418
4419    cannot reachend
4420 */
4421
4422 static void ConstTerm (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4423 {
4424   ConstFactor (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ambersandtok-mcReserved_eoftok)) | (1 << (mcReserved_andtok-mcReserved_eoftok)) | (1 << (mcReserved_dividetok-mcReserved_eoftok)) | (1 << (mcReserved_timestok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_modtok-mcReserved_arraytok)) | (1 << (mcReserved_divtok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_remtok-mcReserved_recordtok))));
4425   while ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_timestok-mcReserved_eoftok)) | (1 << (mcReserved_dividetok-mcReserved_eoftok)) | (1 << (mcReserved_andtok-mcReserved_eoftok)) | (1 << (mcReserved_ambersandtok-mcReserved_eoftok))))) != 0))) || (((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_divtok-mcReserved_arraytok)) | (1 << (mcReserved_modtok-mcReserved_arraytok))))) != 0)))) || (mcLexBuf_currenttoken == mcReserved_remtok))
4426     {
4427       MulOperator (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4428       ConstFactor (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_timestok-mcReserved_eoftok)) | (1 << (mcReserved_dividetok-mcReserved_eoftok)) | (1 << (mcReserved_andtok-mcReserved_eoftok)) | (1 << (mcReserved_ambersandtok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_divtok-mcReserved_arraytok)) | (1 << (mcReserved_modtok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_remtok-mcReserved_recordtok))));
4429     }
4430    /* while  */
4431 }
4432
4433
4434 /*
4435    MulOperator := '*'  | '/'  | 'DIV'  | 'MOD'  |
4436                   'REM'  | 'AND'  | '&'
4437
4438    first  symbols:ambersandtok, andtok, remtok, modtok, divtok, dividetok, timestok
4439
4440    cannot reachend
4441 */
4442
4443 static void MulOperator (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4444 {
4445   if (mcLexBuf_currenttoken == mcReserved_timestok)
4446     {
4447       Expect (mcReserved_timestok, stopset0, stopset1, stopset2);
4448     }
4449   else if (mcLexBuf_currenttoken == mcReserved_dividetok)
4450     {
4451       /* avoid dangling else.  */
4452       Expect (mcReserved_dividetok, stopset0, stopset1, stopset2);
4453     }
4454   else if (mcLexBuf_currenttoken == mcReserved_divtok)
4455     {
4456       /* avoid dangling else.  */
4457       Expect (mcReserved_divtok, stopset0, stopset1, stopset2);
4458     }
4459   else if (mcLexBuf_currenttoken == mcReserved_modtok)
4460     {
4461       /* avoid dangling else.  */
4462       Expect (mcReserved_modtok, stopset0, stopset1, stopset2);
4463     }
4464   else if (mcLexBuf_currenttoken == mcReserved_remtok)
4465     {
4466       /* avoid dangling else.  */
4467       Expect (mcReserved_remtok, stopset0, stopset1, stopset2);
4468     }
4469   else if (mcLexBuf_currenttoken == mcReserved_andtok)
4470     {
4471       /* avoid dangling else.  */
4472       Expect (mcReserved_andtok, stopset0, stopset1, stopset2);
4473     }
4474   else if (mcLexBuf_currenttoken == mcReserved_ambersandtok)
4475     {
4476       /* avoid dangling else.  */
4477       Expect (mcReserved_ambersandtok, stopset0, stopset1, stopset2);
4478     }
4479   else
4480     {
4481       /* avoid dangling else.  */
4482       ErrorArray ((const char *) "expecting one of: & AND REM MOD DIV / *", 39);
4483     }
4484 }
4485
4486
4487 /*
4488    NotConstFactor := 'NOT' ConstFactor
4489                      % VAR n: node ;  %
4490
4491                      % n := push (makeUnaryTok (nottok, pop ()))  %
4492
4493
4494    first  symbols:nottok
4495
4496    cannot reachend
4497 */
4498
4499 static void NotConstFactor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4500 {
4501   decl_node n;
4502
4503   Expect (mcReserved_nottok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4504   ConstFactor (stopset0, stopset1, stopset2);
4505   n = push (decl_makeUnaryTok (mcReserved_nottok, pop ()));
4506 }
4507
4508
4509 /*
4510    ConstFactor := ConstNumber  | ConstString  |
4511                   ConstSetOrQualidentOrFunction  |
4512                   '(' ConstExpressionNop ')'  |
4513                   NotConstFactor  |
4514                   ConstAttribute
4515
4516    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok
4517
4518    cannot reachend
4519 */
4520
4521 static void ConstFactor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4522 {
4523   if ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok))))) != 0)))
4524     {
4525       ConstNumber (stopset0, stopset1, stopset2);
4526     }
4527   else if (mcLexBuf_currenttoken == mcReserved_stringtok)
4528     {
4529       /* avoid dangling else.  */
4530       ConstString (stopset0, stopset1, stopset2);
4531     }
4532   else if ((mcLexBuf_currenttoken == mcReserved_lcbratok) || (mcLexBuf_currenttoken == mcReserved_identtok))
4533     {
4534       /* avoid dangling else.  */
4535       ConstSetOrQualidentOrFunction (stopset0, stopset1, stopset2);
4536     }
4537   else if (mcLexBuf_currenttoken == mcReserved_lparatok)
4538     {
4539       /* avoid dangling else.  */
4540       Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4541       ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
4542       Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
4543     }
4544   else if (mcLexBuf_currenttoken == mcReserved_nottok)
4545     {
4546       /* avoid dangling else.  */
4547       NotConstFactor (stopset0, stopset1, stopset2);
4548     }
4549   else if (mcLexBuf_currenttoken == mcReserved_attributetok)
4550     {
4551       /* avoid dangling else.  */
4552       ConstAttribute (stopset0, stopset1, stopset2);
4553     }
4554   else
4555     {
4556       /* avoid dangling else.  */
4557       ErrorArray ((const char *) "expecting one of: __ATTRIBUTE__ NOT ( identifier { string integer number real number", 84);
4558     }
4559 }
4560
4561
4562 /*
4563    ConstString := string
4564
4565    first  symbols:stringtok
4566
4567    cannot reachend
4568 */
4569
4570 static void ConstString (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4571 {
4572   string (stopset0, stopset1, stopset2);
4573 }
4574
4575
4576 /*
4577    ConstComponentElement := ConstExpressionNop [ '..'
4578                                                  ConstExpressionNop  ]
4579
4580    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
4581
4582    cannot reachend
4583 */
4584
4585 static void ConstComponentElement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4586 {
4587   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodperiodtok-mcReserved_eoftok))), stopset1, stopset2);
4588   if (mcLexBuf_currenttoken == mcReserved_periodperiodtok)
4589     {
4590       Expect (mcReserved_periodperiodtok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4591       ConstExpressionNop (stopset0, stopset1, stopset2);
4592     }
4593 }
4594
4595
4596 /*
4597    ConstComponentValue := ConstComponentElement [ 'BY'
4598                                                   ConstExpressionNop  ]
4599
4600    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
4601
4602    cannot reachend
4603 */
4604
4605 static void ConstComponentValue (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4606 {
4607   ConstComponentElement (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_bytok-mcReserved_arraytok))), stopset2);
4608   if (mcLexBuf_currenttoken == mcReserved_bytok)
4609     {
4610       Expect (mcReserved_bytok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4611       ConstExpressionNop (stopset0, stopset1, stopset2);
4612     }
4613 }
4614
4615
4616 /*
4617    ConstArraySetRecordValue := ConstComponentValue
4618                                { ',' ConstComponentValue  }
4619
4620    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
4621
4622    cannot reachend
4623 */
4624
4625 static void ConstArraySetRecordValue (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4626 {
4627   ConstComponentValue (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
4628   while (mcLexBuf_currenttoken == mcReserved_commatok)
4629     {
4630       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4631       ConstComponentValue (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
4632     }
4633    /* while  */
4634 }
4635
4636
4637 /*
4638    ConstConstructor := '{' [ ConstArraySetRecordValue  ]
4639                        '}'
4640
4641    first  symbols:lcbratok
4642
4643    cannot reachend
4644 */
4645
4646 static void ConstConstructor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4647 {
4648   Expect (mcReserved_lcbratok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rcbratok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
4649   if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))))) != 0))))
4650     {
4651       ConstArraySetRecordValue (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rcbratok-mcReserved_eoftok))), stopset1, stopset2);
4652     }
4653   Expect (mcReserved_rcbratok, stopset0, stopset1, stopset2);
4654 }
4655
4656
4657 /*
4658    ConstSetOrQualidentOrFunction := Qualident [ ConstConstructor  |
4659                                                 ConstActualParameters  ]  |
4660                                     ConstConstructor
4661
4662    first  symbols:lcbratok, identtok
4663
4664    cannot reachend
4665 */
4666
4667 static void ConstSetOrQualidentOrFunction (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4668 {
4669   if (mcLexBuf_currenttoken == mcReserved_identtok)
4670     {
4671       /* avoid dangling else.  */
4672       Qualident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lcbratok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
4673       if ((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0)))
4674         {
4675           /* avoid gcc warning by using compound statement even if not strictly necessary.  */
4676           /* seen optional [ | ] expression  */
4677           if (mcLexBuf_currenttoken == mcReserved_lcbratok)
4678             {
4679               ConstConstructor (stopset0, stopset1, stopset2);
4680             }
4681           else if (mcLexBuf_currenttoken == mcReserved_lparatok)
4682             {
4683               /* avoid dangling else.  */
4684               ConstActualParameters (stopset0, stopset1, stopset2);
4685             }
4686           else
4687             {
4688               /* avoid dangling else.  */
4689               ErrorArray ((const char *) "expecting one of: ( {", 21);
4690             }
4691         }
4692       /* end of optional [ | ] expression  */
4693     }
4694   else if (mcLexBuf_currenttoken == mcReserved_lcbratok)
4695     {
4696       /* avoid dangling else.  */
4697       ConstConstructor (stopset0, stopset1, stopset2);
4698     }
4699   else
4700     {
4701       /* avoid dangling else.  */
4702       ErrorArray ((const char *) "expecting one of: { identifier", 30);
4703     }
4704 }
4705
4706
4707 /*
4708    ConstActualParameters := '(' [ ConstExpList  ] ')'
4709
4710    first  symbols:lparatok
4711
4712    cannot reachend
4713 */
4714
4715 static void ConstActualParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4716 {
4717   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
4718   if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))))) != 0))))
4719     {
4720       ConstExpList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
4721     }
4722   Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
4723 }
4724
4725
4726 /*
4727    ConstExpList := ConstExpressionNop { ',' ConstExpressionNop  }
4728
4729    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
4730
4731    cannot reachend
4732 */
4733
4734 static void ConstExpList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4735 {
4736   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
4737   while (mcLexBuf_currenttoken == mcReserved_commatok)
4738     {
4739       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4740       ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
4741     }
4742    /* while  */
4743 }
4744
4745
4746 /*
4747    ConstAttribute := '__ATTRIBUTE__' '__BUILTIN__'
4748                      '(' '(' ConstAttributeExpression
4749                      ')' ')'
4750
4751    first  symbols:attributetok
4752
4753    cannot reachend
4754 */
4755
4756 static void ConstAttribute (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4757 {
4758   Expect (mcReserved_attributetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_builtintok-mcReserved_recordtok))));
4759   Expect (mcReserved_builtintok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
4760   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
4761   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lesstok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4762   ConstAttributeExpression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
4763   Expect (mcReserved_rparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
4764   Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
4765 }
4766
4767
4768 /*
4769    ConstAttributeExpression := Ident  | '<' Qualident
4770                                ',' Ident '>'
4771
4772    first  symbols:lesstok, identtok
4773
4774    cannot reachend
4775 */
4776
4777 static void ConstAttributeExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4778 {
4779   if (mcLexBuf_currenttoken == mcReserved_identtok)
4780     {
4781       Ident (stopset0, stopset1, stopset2);
4782     }
4783   else if (mcLexBuf_currenttoken == mcReserved_lesstok)
4784     {
4785       /* avoid dangling else.  */
4786       Expect (mcReserved_lesstok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4787       Qualident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
4788       Expect (mcReserved_commatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4789       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_greatertok-mcReserved_eoftok))), stopset1, stopset2);
4790       Expect (mcReserved_greatertok, stopset0, stopset1, stopset2);
4791     }
4792   else
4793     {
4794       /* avoid dangling else.  */
4795       ErrorArray ((const char *) "expecting one of: < identifier", 30);
4796     }
4797 }
4798
4799
4800 /*
4801    ByteAlignment := ''
4802
4803    first  symbols:ldirectivetok
4804
4805    cannot reachend
4806 */
4807
4808 static void ByteAlignment (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4809 {
4810   Expect (mcReserved_ldirectivetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4811   AttributeExpression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rdirectivetok-mcReserved_eoftok))), stopset1, stopset2);
4812   Expect (mcReserved_rdirectivetok, stopset0, stopset1, stopset2);
4813 }
4814
4815
4816 /*
4817    OptAlignmentExpression := [ AlignmentExpression  ]
4818
4819    first  symbols:lparatok
4820
4821    reachend
4822 */
4823
4824 static void OptAlignmentExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4825 {
4826   if (mcLexBuf_currenttoken == mcReserved_lparatok)
4827     {
4828       AlignmentExpression (stopset0, stopset1, stopset2);
4829     }
4830 }
4831
4832
4833 /*
4834    AlignmentExpression := '(' ConstExpressionNop ')'
4835
4836    first  symbols:lparatok
4837
4838    cannot reachend
4839 */
4840
4841 static void AlignmentExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4842 {
4843   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4844   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
4845   Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
4846 }
4847
4848
4849 /*
4850    Alignment := [ ByteAlignment  ]
4851
4852    first  symbols:ldirectivetok
4853
4854    reachend
4855 */
4856
4857 static void Alignment (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4858 {
4859   if (mcLexBuf_currenttoken == mcReserved_ldirectivetok)
4860     {
4861       ByteAlignment (stopset0, stopset1, stopset2);
4862     }
4863 }
4864
4865
4866 /*
4867    IdentList := Ident { ',' Ident  }
4868
4869    first  symbols:identtok
4870
4871    cannot reachend
4872 */
4873
4874 static void IdentList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4875 {
4876   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
4877   while (mcLexBuf_currenttoken == mcReserved_commatok)
4878     {
4879       Expect (mcReserved_commatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4880       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
4881     }
4882    /* while  */
4883 }
4884
4885
4886 /*
4887    SubrangeType := '[' ConstExpressionNop '..' ConstExpressionNop
4888                    ']'
4889
4890    first  symbols:lsbratok
4891
4892    cannot reachend
4893 */
4894
4895 static void SubrangeType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4896 {
4897   Expect (mcReserved_lsbratok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4898   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodperiodtok-mcReserved_eoftok))), stopset1, stopset2);
4899   Expect (mcReserved_periodperiodtok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
4900   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
4901   Expect (mcReserved_rsbratok, stopset0, stopset1, stopset2);
4902 }
4903
4904
4905 /*
4906    ArrayType := 'ARRAY' SimpleType { ',' SimpleType  }
4907                 'OF' Type
4908
4909    first  symbols:arraytok
4910
4911    cannot reachend
4912 */
4913
4914 static void ArrayType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4915 {
4916   Expect (mcReserved_arraytok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4917   SimpleType (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_oftok-mcReserved_arraytok))), stopset2);
4918   while (mcLexBuf_currenttoken == mcReserved_commatok)
4919     {
4920       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4921       SimpleType (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_oftok-mcReserved_arraytok))), stopset2);
4922     }
4923    /* while  */
4924   Expect (mcReserved_oftok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_pointertok-mcReserved_arraytok)) | (1 << (mcReserved_packedsettok-mcReserved_arraytok)) | (1 << (mcReserved_oftok-mcReserved_arraytok)) | (1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_settok-mcReserved_recordtok)) | (1 << (mcReserved_recordtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
4925   Type (stopset0, stopset1, stopset2);
4926 }
4927
4928
4929 /*
4930    RecordType := 'RECORD' [ DefaultRecordAttributes  ]
4931                  FieldListSequence 'END'
4932
4933    first  symbols:recordtok
4934
4935    cannot reachend
4936 */
4937
4938 static void RecordType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4939 {
4940   Expect (mcReserved_recordtok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ldirectivetok-mcReserved_eoftok)) | (1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4941   if (mcLexBuf_currenttoken == mcReserved_ldirectivetok)
4942     {
4943       DefaultRecordAttributes (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4944     }
4945   FieldListSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
4946   Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
4947 }
4948
4949
4950 /*
4951    DefaultRecordAttributes := ''
4952
4953    first  symbols:ldirectivetok
4954
4955    cannot reachend
4956 */
4957
4958 static void DefaultRecordAttributes (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4959 {
4960   Expect (mcReserved_ldirectivetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4961   AttributeExpression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rdirectivetok-mcReserved_eoftok))), stopset1, stopset2);
4962   Expect (mcReserved_rdirectivetok, stopset0, stopset1, stopset2);
4963 }
4964
4965
4966 /*
4967    RecordFieldPragma := [ ''  ]
4968
4969    first  symbols:ldirectivetok
4970
4971    reachend
4972 */
4973
4974 static void RecordFieldPragma (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
4975 {
4976   if (mcLexBuf_currenttoken == mcReserved_ldirectivetok)
4977     {
4978       Expect (mcReserved_ldirectivetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4979       FieldPragmaExpression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok)) | (1 << (mcReserved_rdirectivetok-mcReserved_eoftok))), stopset1, stopset2);
4980       while (mcLexBuf_currenttoken == mcReserved_commatok)
4981         {
4982           Expect (mcReserved_commatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
4983           FieldPragmaExpression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rdirectivetok-mcReserved_eoftok)) | (1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
4984         }
4985        /* while  */
4986       Expect (mcReserved_rdirectivetok, stopset0, stopset1, stopset2);
4987     }
4988 }
4989
4990
4991 /*
4992    FieldPragmaExpression := Ident PragmaConstExpression
4993
4994    first  symbols:identtok
4995
4996    cannot reachend
4997 */
4998
4999 static void FieldPragmaExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5000 {
5001   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
5002   PragmaConstExpression (stopset0, stopset1, stopset2);
5003 }
5004
5005
5006 /*
5007    PragmaConstExpression := [ '(' ConstExpressionNop
5008                               ')'  ]
5009
5010    first  symbols:lparatok
5011
5012    reachend
5013 */
5014
5015 static void PragmaConstExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5016 {
5017   if (mcLexBuf_currenttoken == mcReserved_lparatok)
5018     {
5019       Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
5020       ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
5021       Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
5022     }
5023 }
5024
5025
5026 /*
5027    AttributeExpression := Ident '(' ConstExpressionNop
5028                           ')'
5029
5030    first  symbols:identtok
5031
5032    cannot reachend
5033 */
5034
5035 static void AttributeExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5036 {
5037   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
5038   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
5039   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
5040   Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
5041 }
5042
5043
5044 /*
5045    FieldListSequence := FieldListStatement { ';' FieldListStatement  }
5046
5047    first  symbols:casetok, identtok, semicolontok
5048
5049    reachend
5050 */
5051
5052 static void FieldListSequence (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5053 {
5054   FieldListStatement (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
5055   while (mcLexBuf_currenttoken == mcReserved_semicolontok)
5056     {
5057       Expect (mcReserved_semicolontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_casetok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5058       FieldListStatement (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
5059     }
5060    /* while  */
5061 }
5062
5063
5064 /*
5065    FieldListStatement := [ FieldList  ]
5066
5067    first  symbols:identtok, casetok
5068
5069    reachend
5070 */
5071
5072 static void FieldListStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5073 {
5074   if ((mcLexBuf_currenttoken == mcReserved_casetok) || (mcLexBuf_currenttoken == mcReserved_identtok))
5075     {
5076       FieldList (stopset0, stopset1, stopset2);
5077     }
5078 }
5079
5080
5081 /*
5082    FieldList := IdentList ':' Type RecordFieldPragma  |
5083                 'CASE' CaseTag 'OF' Varient { '|' Varient  }
5084                 [ 'ELSE' FieldListSequence  ] 'END'
5085
5086    first  symbols:casetok, identtok
5087
5088    cannot reachend
5089 */
5090
5091 static void FieldList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5092 {
5093   if (mcLexBuf_currenttoken == mcReserved_identtok)
5094     {
5095       IdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
5096       Expect (mcReserved_colontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_pointertok-mcReserved_arraytok)) | (1 << (mcReserved_packedsettok-mcReserved_arraytok)) | (1 << (mcReserved_oftok-mcReserved_arraytok)) | (1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_settok-mcReserved_recordtok)) | (1 << (mcReserved_recordtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5097       Type (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ldirectivetok-mcReserved_eoftok))), stopset1, stopset2);
5098       RecordFieldPragma (stopset0, stopset1, stopset2);
5099     }
5100   else if (mcLexBuf_currenttoken == mcReserved_casetok)
5101     {
5102       /* avoid dangling else.  */
5103       Expect (mcReserved_casetok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_oftok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5104       CaseTag (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_oftok-mcReserved_arraytok))), stopset2);
5105       Expect (mcReserved_oftok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_bartok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
5106       Varient (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_bartok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
5107       while (mcLexBuf_currenttoken == mcReserved_bartok)
5108         {
5109           Expect (mcReserved_bartok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_bartok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
5110           Varient (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_bartok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_elsetok-mcReserved_arraytok))), stopset2);
5111         }
5112        /* while  */
5113       if (mcLexBuf_currenttoken == mcReserved_elsetok)
5114         {
5115           Expect (mcReserved_elsetok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5116           FieldListSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
5117         }
5118       Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
5119     }
5120   else
5121     {
5122       /* avoid dangling else.  */
5123       ErrorArray ((const char *) "expecting one of: CASE identifier", 33);
5124     }
5125 }
5126
5127
5128 /*
5129    TagIdent := Ident  |
5130                % curident := NulName  %
5131
5132
5133    first  symbols:identtok
5134
5135    reachend
5136 */
5137
5138 static void TagIdent (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5139 {
5140   if (mcLexBuf_currenttoken == mcReserved_identtok)
5141     {
5142       Ident (stopset0, stopset1, stopset2);
5143     }
5144   else
5145     {
5146       curident = nameKey_NulName;
5147     }
5148 }
5149
5150
5151 /*
5152    CaseTag := TagIdent [ ':' Qualident  ]
5153
5154    first  symbols:colontok, identtok
5155
5156    reachend
5157 */
5158
5159 static void CaseTag (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5160 {
5161   TagIdent (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
5162   if (mcLexBuf_currenttoken == mcReserved_colontok)
5163     {
5164       Expect (mcReserved_colontok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5165       Qualident (stopset0, stopset1, stopset2);
5166     }
5167 }
5168
5169
5170 /*
5171    Varient := [ VarientCaseLabelList ':' FieldListSequence  ]
5172
5173    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
5174
5175    reachend
5176 */
5177
5178 static void Varient (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5179 {
5180   if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))))) != 0))))
5181     {
5182       VarientCaseLabelList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
5183       Expect (mcReserved_colontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_casetok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5184       FieldListSequence (stopset0, stopset1, stopset2);
5185     }
5186 }
5187
5188
5189 /*
5190    VarientCaseLabelList := VarientCaseLabels { ','
5191                                                VarientCaseLabels  }
5192
5193    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
5194
5195    cannot reachend
5196 */
5197
5198 static void VarientCaseLabelList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5199 {
5200   VarientCaseLabels (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5201   while (mcLexBuf_currenttoken == mcReserved_commatok)
5202     {
5203       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
5204       VarientCaseLabels (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5205     }
5206    /* while  */
5207 }
5208
5209
5210 /*
5211    VarientCaseLabels := ConstExpressionNop [ '..' ConstExpressionNop  ]
5212
5213    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
5214
5215    cannot reachend
5216 */
5217
5218 static void VarientCaseLabels (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5219 {
5220   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodperiodtok-mcReserved_eoftok))), stopset1, stopset2);
5221   if (mcLexBuf_currenttoken == mcReserved_periodperiodtok)
5222     {
5223       Expect (mcReserved_periodperiodtok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
5224       ConstExpressionNop (stopset0, stopset1, stopset2);
5225     }
5226 }
5227
5228
5229 /*
5230    SetType := ( 'SET'  | 'PACKEDSET'  ) 'OF' SimpleType
5231
5232    first  symbols:oftok, packedsettok, settok
5233
5234    cannot reachend
5235 */
5236
5237 static void SetType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5238 {
5239   if (mcLexBuf_currenttoken == mcReserved_settok)
5240     {
5241       Expect (mcReserved_settok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_oftok-mcReserved_arraytok))), stopset2);
5242     }
5243   else if (mcLexBuf_currenttoken == mcReserved_packedsettok)
5244     {
5245       /* avoid dangling else.  */
5246       Expect (mcReserved_packedsettok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_oftok-mcReserved_arraytok))), stopset2);
5247     }
5248   else
5249     {
5250       /* avoid dangling else.  */
5251       ErrorArray ((const char *) "expecting one of: PACKEDSET SET", 31);
5252     }
5253   Expect (mcReserved_oftok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5254   SimpleType (stopset0, stopset1, stopset2);
5255 }
5256
5257
5258 /*
5259    PointerType := 'POINTER' 'TO' Type
5260
5261    first  symbols:pointertok
5262
5263    cannot reachend
5264 */
5265
5266 static void PointerType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5267 {
5268   Expect (mcReserved_pointertok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_totok-mcReserved_recordtok))));
5269   Expect (mcReserved_totok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_pointertok-mcReserved_arraytok)) | (1 << (mcReserved_packedsettok-mcReserved_arraytok)) | (1 << (mcReserved_oftok-mcReserved_arraytok)) | (1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_settok-mcReserved_recordtok)) | (1 << (mcReserved_recordtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5270   Type (stopset0, stopset1, stopset2);
5271 }
5272
5273
5274 /*
5275    ProcedureType := 'PROCEDURE' [ FormalTypeList  ]
5276
5277    first  symbols:proceduretok
5278
5279    cannot reachend
5280 */
5281
5282 static void ProcedureType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5283 {
5284   Expect (mcReserved_proceduretok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
5285   if (mcLexBuf_currenttoken == mcReserved_lparatok)
5286     {
5287       FormalTypeList (stopset0, stopset1, stopset2);
5288     }
5289 }
5290
5291
5292 /*
5293    FormalTypeList := '(' ( ')' FormalReturn  |
5294                            ProcedureParameters ')'
5295                            FormalReturn  )
5296
5297    first  symbols:lparatok
5298
5299    cannot reachend
5300 */
5301
5302 static void FormalTypeList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5303 {
5304   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5305   if (mcLexBuf_currenttoken == mcReserved_rparatok)
5306     {
5307       Expect (mcReserved_rparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
5308       FormalReturn (stopset0, stopset1, stopset2);
5309     }
5310   else if ((mcLexBuf_currenttoken == mcReserved_arraytok) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))))) != 0))))
5311     {
5312       /* avoid dangling else.  */
5313       ProcedureParameters (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
5314       Expect (mcReserved_rparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
5315       FormalReturn (stopset0, stopset1, stopset2);
5316     }
5317   else
5318     {
5319       /* avoid dangling else.  */
5320       ErrorArray ((const char *) "expecting one of: VAR ... ARRAY identifier )", 44);
5321     }
5322 }
5323
5324
5325 /*
5326    FormalReturn := [ ':' OptReturnType  ]
5327
5328    first  symbols:colontok
5329
5330    reachend
5331 */
5332
5333 static void FormalReturn (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5334 {
5335   if (mcLexBuf_currenttoken == mcReserved_colontok)
5336     {
5337       Expect (mcReserved_colontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5338       OptReturnType (stopset0, stopset1, stopset2);
5339     }
5340 }
5341
5342
5343 /*
5344    OptReturnType := '[' Qualident ']'  |
5345                     Qualident
5346
5347    first  symbols:identtok, lsbratok
5348
5349    cannot reachend
5350 */
5351
5352 static void OptReturnType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5353 {
5354   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
5355     {
5356       Expect (mcReserved_lsbratok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5357       Qualident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
5358       Expect (mcReserved_rsbratok, stopset0, stopset1, stopset2);
5359     }
5360   else if (mcLexBuf_currenttoken == mcReserved_identtok)
5361     {
5362       /* avoid dangling else.  */
5363       Qualident (stopset0, stopset1, stopset2);
5364     }
5365   else
5366     {
5367       /* avoid dangling else.  */
5368       ErrorArray ((const char *) "expecting one of: identifier [", 30);
5369     }
5370 }
5371
5372
5373 /*
5374    ProcedureParameters := ProcedureParameter { ','
5375                                                ProcedureParameter  }
5376
5377    first  symbols:identtok, arraytok, periodperiodperiodtok, vartok
5378
5379    cannot reachend
5380 */
5381
5382 static void ProcedureParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5383 {
5384   ProcedureParameter (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5385   while (mcLexBuf_currenttoken == mcReserved_commatok)
5386     {
5387       Expect (mcReserved_commatok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5388       ProcedureParameter (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5389     }
5390    /* while  */
5391 }
5392
5393
5394 /*
5395    ProcedureParameter := '...'  | 'VAR' FormalType  |
5396                          FormalType
5397
5398    first  symbols:arraytok, identtok, vartok, periodperiodperiodtok
5399
5400    cannot reachend
5401 */
5402
5403 static void ProcedureParameter (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5404 {
5405   if (mcLexBuf_currenttoken == mcReserved_periodperiodperiodtok)
5406     {
5407       Expect (mcReserved_periodperiodperiodtok, stopset0, stopset1, stopset2);
5408     }
5409   else if (mcLexBuf_currenttoken == mcReserved_vartok)
5410     {
5411       /* avoid dangling else.  */
5412       Expect (mcReserved_vartok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5413       FormalType (stopset0, stopset1, stopset2);
5414     }
5415   else if ((mcLexBuf_currenttoken == mcReserved_arraytok) || (mcLexBuf_currenttoken == mcReserved_identtok))
5416     {
5417       /* avoid dangling else.  */
5418       FormalType (stopset0, stopset1, stopset2);
5419     }
5420   else
5421     {
5422       /* avoid dangling else.  */
5423       ErrorArray ((const char *) "expecting one of: ARRAY identifier VAR ...", 42);
5424     }
5425 }
5426
5427
5428 /*
5429    VarIdent := Ident [ '[' ConstExpressionNop ']'  ]
5430
5431    first  symbols:identtok
5432
5433    cannot reachend
5434 */
5435
5436 static void VarIdent (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5437 {
5438   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2);
5439   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
5440     {
5441       Expect (mcReserved_lsbratok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
5442       ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
5443       Expect (mcReserved_rsbratok, stopset0, stopset1, stopset2);
5444     }
5445 }
5446
5447
5448 /*
5449    VarIdentList := VarIdent { ',' VarIdent  }
5450
5451    first  symbols:identtok
5452
5453    cannot reachend
5454 */
5455
5456 static void VarIdentList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5457 {
5458   VarIdent (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5459   while (mcLexBuf_currenttoken == mcReserved_commatok)
5460     {
5461       Expect (mcReserved_commatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5462       VarIdent (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5463     }
5464    /* while  */
5465 }
5466
5467
5468 /*
5469    VariableDeclaration := VarIdentList ':' Type Alignment
5470
5471    first  symbols:identtok
5472
5473    cannot reachend
5474 */
5475
5476 static void VariableDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5477 {
5478   VarIdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
5479   Expect (mcReserved_colontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_pointertok-mcReserved_arraytok)) | (1 << (mcReserved_packedsettok-mcReserved_arraytok)) | (1 << (mcReserved_oftok-mcReserved_arraytok)) | (1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_settok-mcReserved_recordtok)) | (1 << (mcReserved_recordtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5480   Type (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ldirectivetok-mcReserved_eoftok))), stopset1, stopset2);
5481   Alignment (stopset0, stopset1, stopset2);
5482 }
5483
5484
5485 /*
5486    Designator := PushQualident { SubDesignator  }
5487
5488    first  symbols:identtok
5489
5490    cannot reachend
5491 */
5492
5493 static void Designator (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5494 {
5495   PushQualident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_periodtok-mcReserved_eoftok)) | (1 << (mcReserved_uparrowtok-mcReserved_eoftok))), stopset1, stopset2);
5496   while ((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_uparrowtok-mcReserved_eoftok))))) != 0)))
5497     {
5498       SubDesignator (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_uparrowtok-mcReserved_eoftok))), stopset1, stopset2);
5499     }
5500    /* while  */
5501 }
5502
5503
5504 /*
5505    SubDesignator :=
5506                     % VAR n, field, type: node ;  %
5507
5508                     % n := peep ()  %
5509
5510                     % IF n = NIL
5511                       THEN
5512                                                                                              ErrorArray ('no expression found') ;
5513                          flushErrors ;
5514                          RETURN
5515                       END  %
5516
5517                     % type := skipType (getType (n))  %
5518                     ( '.' Ident
5519                       % IF isRecord (type)
5520                         THEN
5521                            field := lookupInScope (type, curident) ;
5522                            IF field = NIL
5523                            THEN
5524                               metaError2 ('field {%1k} cannot be found in record {%2ad}', curident, type)
5525                            ELSE
5526                               n := replace (makeComponentRef (n, field))
5527                            END
5528                         ELSE
5529                            metaError2 ('attempting to access a field {%1k} from {%2ad} which does not have a record type', curident, type)
5530                         END  %
5531                        | '[' ArrayExpList
5532                       % IF isArray (type)
5533                         THEN
5534                            n := replace (makeArrayRef (n, pop ()))
5535                         ELSE
5536                            metaError1 ('attempting to access an array but the expression is not an array but a {%1d}', type)
5537                         END  %
5538                       ']'  | SubPointer  )
5539
5540    first  symbols:uparrowtok, lsbratok, periodtok
5541
5542    cannot reachend
5543 */
5544
5545 static void SubDesignator (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5546 {
5547   decl_node n;
5548   decl_node field;
5549   decl_node type;
5550
5551   n = peep ();
5552   if (n == NULL)
5553     {
5554       ErrorArray ((const char *) "no expression found", 19);
5555       mcError_flushErrors ();
5556       return;
5557     }
5558   type = decl_skipType (decl_getType (n));
5559   if (mcLexBuf_currenttoken == mcReserved_periodtok)
5560     {
5561       Expect (mcReserved_periodtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5562       Ident (stopset0, stopset1, stopset2);
5563       if (decl_isRecord (type))
5564         {
5565           field = decl_lookupInScope (type, curident);
5566           if (field == NULL)
5567             {
5568               mcMetaError_metaError2 ((const char *) "field {%1k} cannot be found in record {%2ad}", 44, (const unsigned char *) &curident, (sizeof (curident)-1), (const unsigned char *) &type, (sizeof (type)-1));
5569             }
5570           else
5571             {
5572               n = replace (decl_makeComponentRef (n, field));
5573             }
5574         }
5575       else
5576         {
5577           mcMetaError_metaError2 ((const char *) "attempting to access a field {%1k} from {%2ad} which does not have a record type", 80, (const unsigned char *) &curident, (sizeof (curident)-1), (const unsigned char *) &type, (sizeof (type)-1));
5578         }
5579     }
5580   else if (mcLexBuf_currenttoken == mcReserved_lsbratok)
5581     {
5582       /* avoid dangling else.  */
5583       Expect (mcReserved_lsbratok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5584       ArrayExpList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
5585       if (decl_isArray (type))
5586         {
5587           n = replace (decl_makeArrayRef (n, pop ()));
5588         }
5589       else
5590         {
5591           mcMetaError_metaError1 ((const char *) "attempting to access an array but the expression is not an array but a {%1d}", 76, (const unsigned char *) &type, (sizeof (type)-1));
5592         }
5593       Expect (mcReserved_rsbratok, stopset0, stopset1, stopset2);
5594     }
5595   else if (mcLexBuf_currenttoken == mcReserved_uparrowtok)
5596     {
5597       /* avoid dangling else.  */
5598       SubPointer (stopset0, stopset1, stopset2);
5599     }
5600   else
5601     {
5602       /* avoid dangling else.  */
5603       ErrorArray ((const char *) "expecting one of: ^ [ .", 23);
5604     }
5605 }
5606
5607
5608 /*
5609    SubPointer :=
5610                  % VAR n, field, type: node ;  %
5611
5612                  % n := peep ()  %
5613
5614                  % type := skipType (getType (n))  %
5615                  '^' ( '.' Ident
5616                        % IF isPointer (type)
5617                          THEN
5618                                                                                                      type := skipType (getType (type)) ;
5619                                                                                                      IF isRecord (type)
5620                             THEN
5621                                field := lookupInScope (type, curident) ;
5622                                IF field = NIL
5623                                THEN
5624                                   metaError2 ('field {%1k} cannot be found in record {%2ad}', curident, type)
5625                                ELSE
5626                                   n := replace (makePointerRef (n, field))
5627                                END
5628                             ELSE
5629                                metaError2 ('attempting to access a field {%1k} from {%2ad} which does not have a record type', curident, type)
5630                             END
5631                          ELSE
5632                             metaError2 ('trying to dereference {%1k} which was not declared as a pointer but a {%2tad}', n, n)
5633                          END  %
5634                         |
5635                        % IF isPointer (type)
5636                          THEN
5637                             n := replace (makeDeRef (n))
5638                          ELSE
5639                             metaError1 ('attempting to dereference a pointer but the expression is not a pointer but a {%1d}', type)
5640                          END  %
5641                         )
5642
5643    first  symbols:uparrowtok
5644
5645    cannot reachend
5646 */
5647
5648 static void SubPointer (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5649 {
5650   decl_node n;
5651   decl_node field;
5652   decl_node type;
5653
5654   n = peep ();
5655   type = decl_skipType (decl_getType (n));
5656   Expect (mcReserved_uparrowtok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok))), stopset1, stopset2);
5657   if (mcLexBuf_currenttoken == mcReserved_periodtok)
5658     {
5659       Expect (mcReserved_periodtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
5660       Ident (stopset0, stopset1, stopset2);
5661       if (decl_isPointer (type))
5662         {
5663           type = decl_skipType (decl_getType (type));
5664           if (decl_isRecord (type))
5665             {
5666               field = decl_lookupInScope (type, curident);
5667               if (field == NULL)
5668                 {
5669                   mcMetaError_metaError2 ((const char *) "field {%1k} cannot be found in record {%2ad}", 44, (const unsigned char *) &curident, (sizeof (curident)-1), (const unsigned char *) &type, (sizeof (type)-1));
5670                 }
5671               else
5672                 {
5673                   n = replace (decl_makePointerRef (n, field));
5674                 }
5675             }
5676           else
5677             {
5678               mcMetaError_metaError2 ((const char *) "attempting to access a field {%1k} from {%2ad} which does not have a record type", 80, (const unsigned char *) &curident, (sizeof (curident)-1), (const unsigned char *) &type, (sizeof (type)-1));
5679             }
5680         }
5681       else
5682         {
5683           mcMetaError_metaError2 ((const char *) "trying to dereference {%1k} which was not declared as a pointer but a {%2tad}", 77, (const unsigned char *) &n, (sizeof (n)-1), (const unsigned char *) &n, (sizeof (n)-1));
5684         }
5685     }
5686   else
5687     {
5688       if (decl_isPointer (type))
5689         {
5690           n = replace (decl_makeDeRef (n));
5691         }
5692       else
5693         {
5694           mcMetaError_metaError1 ((const char *) "attempting to dereference a pointer but the expression is not a pointer but a {%1d}", 83, (const unsigned char *) &type, (sizeof (type)-1));
5695         }
5696     }
5697 }
5698
5699
5700 /*
5701    ArrayExpList :=
5702                    % VAR l: node ;  %
5703
5704                    % l := push (makeExpList ())  %
5705                    Expression
5706                    % putExpList (l, pop ())  %
5707
5708                    % assert (isExpList (peep ()))  %
5709                    { ',' Expression
5710                      % putExpList (l, pop ())  %
5711
5712                      % assert (isExpList (peep ()))  %
5713                       }
5714
5715    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
5716
5717    cannot reachend
5718 */
5719
5720 static void ArrayExpList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5721 {
5722   decl_node l;
5723
5724   l = push (decl_makeExpList ());
5725   Expression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5726   decl_putExpList (l, pop ());
5727   mcDebug_assert (decl_isExpList (peep ()));
5728   while (mcLexBuf_currenttoken == mcReserved_commatok)
5729     {
5730       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5731       Expression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5732       decl_putExpList (l, pop ());
5733       mcDebug_assert (decl_isExpList (peep ()));
5734     }
5735    /* while  */
5736 }
5737
5738
5739 /*
5740    ExpList :=
5741               % VAR p, n: node ;  %
5742
5743               % p := peep ()  %
5744
5745               % assert (isExpList (p))  %
5746               Expression
5747               % putExpList (p, pop ())  %
5748
5749               % assert (isExpList (peep ()))  %
5750               { ',' Expression
5751                 % putExpList (p, pop ())  %
5752
5753                 % assert (isExpList (peep ()))  %
5754                  }
5755
5756    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
5757
5758    cannot reachend
5759 */
5760
5761 static void ExpList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5762 {
5763   decl_node p;
5764   decl_node n;
5765
5766   p = peep ();
5767   mcDebug_assert (decl_isExpList (p));
5768   Expression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5769   decl_putExpList (p, pop ());
5770   mcDebug_assert (decl_isExpList (peep ()));
5771   while (mcLexBuf_currenttoken == mcReserved_commatok)
5772     {
5773       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5774       Expression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
5775       decl_putExpList (p, pop ());
5776       mcDebug_assert (decl_isExpList (peep ()));
5777     }
5778    /* while  */
5779 }
5780
5781
5782 /*
5783    Expression :=
5784                  % VAR c, l, r: node ; op: toktype ;  %
5785                  SimpleExpression
5786                  % op := currenttoken  %
5787                  [ Relation
5788                    % l := pop ()  %
5789                    SimpleExpression
5790                    % r := pop ()  %
5791
5792                    % r := push (makeBinaryTok (op, l, r))  %
5793                     ]
5794
5795    first  symbols:identtok, lcbratok, nottok, lparatok, stringtok, integertok, realtok, minustok, plustok
5796
5797    cannot reachend
5798 */
5799
5800 static void Expression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5801 {
5802   decl_node c;
5803   decl_node l;
5804   decl_node r;
5805   mcReserved_toktype op;
5806
5807   SimpleExpression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_greaterequaltok-mcReserved_eoftok)) | (1 << (mcReserved_greatertok-mcReserved_eoftok)) | (1 << (mcReserved_lessequaltok-mcReserved_eoftok)) | (1 << (mcReserved_lesstok-mcReserved_eoftok)) | (1 << (mcReserved_lessgreatertok-mcReserved_eoftok)) | (1 << (mcReserved_hashtok-mcReserved_eoftok)) | (1 << (mcReserved_equaltok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_intok-mcReserved_arraytok))), stopset2);
5808   op = mcLexBuf_currenttoken;
5809   if (((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_equaltok-mcReserved_eoftok)) | (1 << (mcReserved_hashtok-mcReserved_eoftok)) | (1 << (mcReserved_lessgreatertok-mcReserved_eoftok)) | (1 << (mcReserved_lesstok-mcReserved_eoftok)) | (1 << (mcReserved_lessequaltok-mcReserved_eoftok)) | (1 << (mcReserved_greatertok-mcReserved_eoftok)) | (1 << (mcReserved_greaterequaltok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_intok))
5810     {
5811       Relation (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5812       l = pop ();
5813       SimpleExpression (stopset0, stopset1, stopset2);
5814       r = pop ();
5815       r = push (decl_makeBinaryTok (op, l, r));
5816     }
5817 }
5818
5819
5820 /*
5821    SimpleExpression :=
5822                        % VAR op: toktype ; n: node ;  %
5823                        UnaryOrTerm {
5824                                      % op := currenttoken  %
5825
5826                                      % n := pop ()  %
5827                                      AddOperator Term
5828
5829                                      % n := push (makeBinaryTok (op, n, pop ()))  %
5830                                       }
5831
5832    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
5833
5834    cannot reachend
5835 */
5836
5837 static void SimpleExpression (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5838 {
5839   mcReserved_toktype op;
5840   decl_node n;
5841
5842   UnaryOrTerm (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_ortok-mcReserved_arraytok))), stopset2);
5843   while (((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_ortok))
5844     {
5845       op = mcLexBuf_currenttoken;
5846       n = pop ();
5847       AddOperator (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5848       Term (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_ortok-mcReserved_arraytok))), stopset2);
5849       n = push (decl_makeBinaryTok (op, n, pop ()));
5850     }
5851    /* while  */
5852 }
5853
5854
5855 /*
5856    UnaryOrTerm :=
5857                   % VAR n: node ;  %
5858                   '+' Term
5859                   % n := push (makeUnaryTok (plustok, pop ()))  %
5860                    | '-' Term
5861                   % n := push (makeUnaryTok (minustok, pop ()))  %
5862                    | Term
5863
5864    first  symbols:identtok, lcbratok, nottok, lparatok, stringtok, integertok, realtok, minustok, plustok
5865
5866    cannot reachend
5867 */
5868
5869 static void UnaryOrTerm (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5870 {
5871   decl_node n;
5872
5873   if (mcLexBuf_currenttoken == mcReserved_plustok)
5874     {
5875       Expect (mcReserved_plustok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5876       Term (stopset0, stopset1, stopset2);
5877       n = push (decl_makeUnaryTok (mcReserved_plustok, pop ()));
5878     }
5879   else if (mcLexBuf_currenttoken == mcReserved_minustok)
5880     {
5881       /* avoid dangling else.  */
5882       Expect (mcReserved_minustok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5883       Term (stopset0, stopset1, stopset2);
5884       n = push (decl_makeUnaryTok (mcReserved_minustok, pop ()));
5885     }
5886   else if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))))) != 0))))
5887     {
5888       /* avoid dangling else.  */
5889       Term (stopset0, stopset1, stopset2);
5890     }
5891   else
5892     {
5893       /* avoid dangling else.  */
5894       ErrorArray ((const char *) "expecting one of: NOT ( string integer number real number { identifier - +", 74);
5895     }
5896 }
5897
5898
5899 /*
5900    Term :=
5901            % VAR op: toktype ; n: node ;  %
5902            Factor {
5903                     % op := currenttoken  %
5904                     MulOperator
5905                     % n := pop ()  %
5906                     Factor
5907                     % n := push (makeBinaryTok (op, n, pop ()))  %
5908                      }
5909
5910    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok
5911
5912    cannot reachend
5913 */
5914
5915 static void Term (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5916 {
5917   mcReserved_toktype op;
5918   decl_node n;
5919
5920   Factor (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ambersandtok-mcReserved_eoftok)) | (1 << (mcReserved_andtok-mcReserved_eoftok)) | (1 << (mcReserved_dividetok-mcReserved_eoftok)) | (1 << (mcReserved_timestok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_modtok-mcReserved_arraytok)) | (1 << (mcReserved_divtok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_remtok-mcReserved_recordtok))));
5921   while ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_timestok-mcReserved_eoftok)) | (1 << (mcReserved_dividetok-mcReserved_eoftok)) | (1 << (mcReserved_andtok-mcReserved_eoftok)) | (1 << (mcReserved_ambersandtok-mcReserved_eoftok))))) != 0))) || (((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_divtok-mcReserved_arraytok)) | (1 << (mcReserved_modtok-mcReserved_arraytok))))) != 0)))) || (mcLexBuf_currenttoken == mcReserved_remtok))
5922     {
5923       op = mcLexBuf_currenttoken;
5924       MulOperator (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5925       n = pop ();
5926       Factor (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_timestok-mcReserved_eoftok)) | (1 << (mcReserved_dividetok-mcReserved_eoftok)) | (1 << (mcReserved_andtok-mcReserved_eoftok)) | (1 << (mcReserved_ambersandtok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_divtok-mcReserved_arraytok)) | (1 << (mcReserved_modtok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_remtok-mcReserved_recordtok))));
5927       n = push (decl_makeBinaryTok (op, n, pop ()));
5928     }
5929    /* while  */
5930 }
5931
5932
5933 /*
5934    PushString := string
5935                  % VAR n: node ;  %
5936
5937                  % n := push (makeString (curstring))  %
5938
5939
5940    first  symbols:stringtok
5941
5942    cannot reachend
5943 */
5944
5945 static void PushString (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5946 {
5947   decl_node n;
5948
5949   string (stopset0, stopset1, stopset2);
5950   n = push (decl_makeString (curstring));
5951 }
5952
5953
5954 /*
5955    Factor := Number  | PushString  | SetOrDesignatorOrFunction  |
5956              '(' Expression ')'  |
5957              'NOT' ( Factor
5958                      % VAR n: node ;  %
5959
5960                      % n := push (makeUnaryTok (nottok, pop ()))  %
5961                       | ConstAttribute
5962                      % n := push (makeUnaryTok (nottok, pop ()))  %
5963                       )
5964
5965    first  symbols:identtok, lcbratok, nottok, lparatok, stringtok, integertok, realtok
5966
5967    cannot reachend
5968 */
5969
5970 static void Factor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
5971 {
5972   decl_node n;
5973
5974   if ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok))))) != 0)))
5975     {
5976       Number (stopset0, stopset1, stopset2);
5977     }
5978   else if (mcLexBuf_currenttoken == mcReserved_stringtok)
5979     {
5980       /* avoid dangling else.  */
5981       PushString (stopset0, stopset1, stopset2);
5982     }
5983   else if ((mcLexBuf_currenttoken == mcReserved_lcbratok) || (mcLexBuf_currenttoken == mcReserved_identtok))
5984     {
5985       /* avoid dangling else.  */
5986       SetOrDesignatorOrFunction (stopset0, stopset1, stopset2);
5987     }
5988   else if (mcLexBuf_currenttoken == mcReserved_lparatok)
5989     {
5990       /* avoid dangling else.  */
5991       Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5992       Expression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
5993       Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
5994     }
5995   else if (mcLexBuf_currenttoken == mcReserved_nottok)
5996     {
5997       /* avoid dangling else.  */
5998       Expect (mcReserved_nottok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
5999       if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))))) != 0))))
6000         {
6001           Factor (stopset0, stopset1, stopset2);
6002           n = push (decl_makeUnaryTok (mcReserved_nottok, pop ()));
6003         }
6004       else if (mcLexBuf_currenttoken == mcReserved_attributetok)
6005         {
6006           /* avoid dangling else.  */
6007           ConstAttribute (stopset0, stopset1, stopset2);
6008           n = push (decl_makeUnaryTok (mcReserved_nottok, pop ()));
6009         }
6010       else
6011         {
6012           /* avoid dangling else.  */
6013           ErrorArray ((const char *) "expecting one of: __ATTRIBUTE__ real number integer number string ( NOT { identifier", 84);
6014         }
6015     }
6016   else
6017     {
6018       /* avoid dangling else.  */
6019       ErrorArray ((const char *) "expecting one of: NOT ( { identifier string integer number real number", 70);
6020     }
6021 }
6022
6023
6024 /*
6025    ComponentElement := Expression
6026                        % VAR l, h, n: node ;  %
6027
6028                        % l := pop ()  %
6029
6030                        % h := NIL  %
6031                        [ '..' Expression
6032                          % h := pop ()  %
6033
6034                          % ErrorArray ('implementation restriction range is not allowed')  %
6035                           ]
6036                        % n := push (includeSetValue (pop (), l, h))  %
6037
6038
6039    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
6040
6041    cannot reachend
6042 */
6043
6044 static void ComponentElement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6045 {
6046   decl_node l;
6047   decl_node h;
6048   decl_node n;
6049
6050   Expression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodperiodtok-mcReserved_eoftok))), stopset1, stopset2);
6051   l = pop ();
6052   h = static_cast<decl_node> (NULL);
6053   if (mcLexBuf_currenttoken == mcReserved_periodperiodtok)
6054     {
6055       Expect (mcReserved_periodperiodtok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6056       Expression (stopset0, stopset1, stopset2);
6057       h = pop ();
6058       ErrorArray ((const char *) "implementation restriction range is not allowed", 47);
6059     }
6060   n = push (decl_includeSetValue (pop (), l, h));
6061 }
6062
6063
6064 /*
6065    ComponentValue := ComponentElement [ 'BY'
6066                                         % ErrorArray ('implementation restriction BY not allowed')  %
6067                                         Expression  ]
6068
6069    first  symbols:identtok, lcbratok, nottok, lparatok, stringtok, integertok, realtok, minustok, plustok
6070
6071    cannot reachend
6072 */
6073
6074 static void ComponentValue (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6075 {
6076   ComponentElement (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_bytok-mcReserved_arraytok))), stopset2);
6077   if (mcLexBuf_currenttoken == mcReserved_bytok)
6078     {
6079       Expect (mcReserved_bytok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6080       ErrorArray ((const char *) "implementation restriction BY not allowed", 41);
6081       Expression (stopset0, stopset1, stopset2);
6082     }
6083 }
6084
6085
6086 /*
6087    ArraySetRecordValue := ComponentValue { ',' ComponentValue  }
6088
6089    first  symbols:identtok, lcbratok, realtok, integertok, stringtok, lparatok, nottok, plustok, minustok
6090
6091    cannot reachend
6092 */
6093
6094 static void ArraySetRecordValue (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6095 {
6096   ComponentValue (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
6097   while (mcLexBuf_currenttoken == mcReserved_commatok)
6098     {
6099       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6100       ComponentValue (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
6101     }
6102    /* while  */
6103 }
6104
6105
6106 /*
6107    Constructor := '{'
6108                   % VAR n: node ;  %
6109
6110                   % n := push (makeSetValue ())  %
6111                   [ ArraySetRecordValue  ] '}'
6112
6113    first  symbols:lcbratok
6114
6115    cannot reachend
6116 */
6117
6118 static void Constructor (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6119 {
6120   decl_node n;
6121
6122   Expect (mcReserved_lcbratok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rcbratok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6123   n = push (decl_makeSetValue ());
6124   if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))))) != 0))))
6125     {
6126       ArraySetRecordValue (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rcbratok-mcReserved_eoftok))), stopset1, stopset2);
6127     }
6128   Expect (mcReserved_rcbratok, stopset0, stopset1, stopset2);
6129 }
6130
6131
6132 /*
6133    SetOrDesignatorOrFunction := PushQualident
6134                                 % VAR q, p, n: node ;  %
6135                                 [ Constructor
6136                                   % p := pop ()  %
6137
6138                                   % q := pop ()  %
6139
6140                                   % n := push (putSetValue (p, q))  %
6141                                    | SimpleDes [
6142                                                  % q := pop ()  %
6143                                                  ActualParameters
6144
6145                                                  % p := pop ()  %
6146
6147                                                  % p := push (makeFuncCall (q, p))  %
6148                                                   ]  ]  |
6149                                 Constructor
6150
6151    first  symbols:identtok, lcbratok
6152
6153    cannot reachend
6154 */
6155
6156 static void SetOrDesignatorOrFunction (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6157 {
6158   decl_node q;
6159   decl_node p;
6160   decl_node n;
6161
6162   if (mcLexBuf_currenttoken == mcReserved_identtok)
6163     {
6164       /* avoid dangling else.  */
6165       PushQualident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lcbratok-mcReserved_eoftok)) | (1 << (mcReserved_periodtok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_uparrowtok-mcReserved_eoftok))), stopset1, stopset2);
6166       if ((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_periodtok-mcReserved_eoftok)) | (1 << (mcReserved_uparrowtok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0)))
6167         {
6168           /* avoid gcc warning by using compound statement even if not strictly necessary.  */
6169           /* seen optional [ | ] expression  */
6170           if (mcLexBuf_currenttoken == mcReserved_lcbratok)
6171             {
6172               Constructor (stopset0, stopset1, stopset2);
6173               p = pop ();
6174               q = pop ();
6175               n = push (decl_putSetValue (p, q));
6176             }
6177           else if ((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_periodtok-mcReserved_eoftok)) | (1 << (mcReserved_uparrowtok-mcReserved_eoftok))))) != 0)))
6178             {
6179               /* avoid dangling else.  */
6180               SimpleDes (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
6181               if (mcLexBuf_currenttoken == mcReserved_lparatok)
6182                 {
6183                   q = pop ();
6184                   ActualParameters (stopset0, stopset1, stopset2);
6185                   p = pop ();
6186                   p = push (decl_makeFuncCall (q, p));
6187                 }
6188             }
6189           else
6190             {
6191               /* avoid dangling else.  */
6192               ErrorArray ((const char *) "expecting one of: ( [ . ^ {", 27);
6193             }
6194         }
6195       /* end of optional [ | ] expression  */
6196     }
6197   else if (mcLexBuf_currenttoken == mcReserved_lcbratok)
6198     {
6199       /* avoid dangling else.  */
6200       Constructor (stopset0, stopset1, stopset2);
6201     }
6202   else
6203     {
6204       /* avoid dangling else.  */
6205       ErrorArray ((const char *) "expecting one of: { identifier", 30);
6206     }
6207 }
6208
6209
6210 /*
6211    SimpleDes := { SubDesignator  }
6212
6213    first  symbols:uparrowtok, periodtok, lsbratok
6214
6215    reachend
6216 */
6217
6218 static void SimpleDes (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6219 {
6220   while ((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_uparrowtok-mcReserved_eoftok))))) != 0)))
6221     {
6222       SubDesignator (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok)) | (1 << (mcReserved_uparrowtok-mcReserved_eoftok))), stopset1, stopset2);
6223     }
6224    /* while  */
6225 }
6226
6227
6228 /*
6229    ActualParameters := '('
6230                        % VAR n: node ;  %
6231
6232                        % n := push (makeExpList ())  %
6233                        [ ExpList  ] ')'
6234                        % assert (isExpList (peep ()))  %
6235
6236
6237    first  symbols:lparatok
6238
6239    cannot reachend
6240 */
6241
6242 static void ActualParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6243 {
6244   decl_node n;
6245
6246   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6247   n = push (decl_makeExpList ());
6248   if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))))) != 0))))
6249     {
6250       ExpList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
6251     }
6252   Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
6253   mcDebug_assert (decl_isExpList (peep ()));
6254 }
6255
6256
6257 /*
6258    ExitStatement :=
6259                     % VAR n: node ;  %
6260                     'EXIT'
6261                     % IF loopNo = 0
6262                       THEN
6263                          ErrorArray ('EXIT can only be used inside a LOOP statement')
6264                       ELSE
6265                          n := pushStmt (makeExit (peepLoop (), loopNo))
6266                       END  %
6267
6268
6269    first  symbols:exittok
6270
6271    cannot reachend
6272 */
6273
6274 static void ExitStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6275 {
6276   decl_node n;
6277
6278   Expect (mcReserved_exittok, stopset0, stopset1, stopset2);
6279   if (loopNo == 0)
6280     {
6281       ErrorArray ((const char *) "EXIT can only be used inside a LOOP statement", 45);
6282     }
6283   else
6284     {
6285       n = pushStmt (decl_makeExit (peepLoop (), loopNo));
6286     }
6287 }
6288
6289
6290 /*
6291    ReturnStatement :=
6292                       % VAR n: node ;  %
6293
6294                       % n := pushStmt (makeReturn ())  %
6295                       'RETURN' [ Expression
6296                                  % putReturn (n, pop ())  %
6297                                   ]
6298                       % addCommentBody (peepStmt ())  %
6299
6300                       % addCommentAfter (peepStmt ())  %
6301
6302                       % assert (isReturn (peepStmt ()))  %
6303
6304
6305    first  symbols:returntok
6306
6307    cannot reachend
6308 */
6309
6310 static void ReturnStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6311 {
6312   decl_node n;
6313
6314   n = pushStmt (decl_makeReturn ());
6315   Expect (mcReserved_returntok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6316   if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))))) != 0))))
6317     {
6318       Expression (stopset0, stopset1, stopset2);
6319       decl_putReturn (n, pop ());
6320     }
6321   decl_addCommentBody (peepStmt ());
6322   decl_addCommentAfter (peepStmt ());
6323   mcDebug_assert (decl_isReturn (peepStmt ()));
6324 }
6325
6326
6327 /*
6328    Statement := ( AssignmentOrProcedureCall  |
6329                   IfStatement  | CaseStatement  |
6330                   WhileStatement  |
6331                   RepeatStatement  |
6332                   LoopStatement  | ForStatement  |
6333                   WithStatement  | AsmStatement  |
6334                   ExitStatement  | ReturnStatement  |
6335                   RetryStatement  |
6336
6337                   % VAR s: node ;  %
6338
6339                   % s := pushStmt (NIL)  %
6340                    )
6341
6342    first  symbols:identtok, retrytok, asmtok, withtok, fortok, looptok, repeattok, whiletok, casetok, iftok, returntok, exittok
6343
6344    reachend
6345 */
6346
6347 static void Statement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6348 {
6349   decl_node s;
6350
6351   if (mcLexBuf_currenttoken == mcReserved_identtok)
6352     {
6353       AssignmentOrProcedureCall (stopset0, stopset1, stopset2);
6354     }
6355   else if (mcLexBuf_currenttoken == mcReserved_iftok)
6356     {
6357       /* avoid dangling else.  */
6358       IfStatement (stopset0, stopset1, stopset2);
6359     }
6360   else if (mcLexBuf_currenttoken == mcReserved_casetok)
6361     {
6362       /* avoid dangling else.  */
6363       CaseStatement (stopset0, stopset1, stopset2);
6364     }
6365   else if (mcLexBuf_currenttoken == mcReserved_whiletok)
6366     {
6367       /* avoid dangling else.  */
6368       WhileStatement (stopset0, stopset1, stopset2);
6369     }
6370   else if (mcLexBuf_currenttoken == mcReserved_repeattok)
6371     {
6372       /* avoid dangling else.  */
6373       RepeatStatement (stopset0, stopset1, stopset2);
6374     }
6375   else if (mcLexBuf_currenttoken == mcReserved_looptok)
6376     {
6377       /* avoid dangling else.  */
6378       LoopStatement (stopset0, stopset1, stopset2);
6379     }
6380   else if (mcLexBuf_currenttoken == mcReserved_fortok)
6381     {
6382       /* avoid dangling else.  */
6383       ForStatement (stopset0, stopset1, stopset2);
6384     }
6385   else if (mcLexBuf_currenttoken == mcReserved_withtok)
6386     {
6387       /* avoid dangling else.  */
6388       WithStatement (stopset0, stopset1, stopset2);
6389     }
6390   else if (mcLexBuf_currenttoken == mcReserved_asmtok)
6391     {
6392       /* avoid dangling else.  */
6393       AsmStatement (stopset0, stopset1, stopset2);
6394     }
6395   else if (mcLexBuf_currenttoken == mcReserved_exittok)
6396     {
6397       /* avoid dangling else.  */
6398       ExitStatement (stopset0, stopset1, stopset2);
6399     }
6400   else if (mcLexBuf_currenttoken == mcReserved_returntok)
6401     {
6402       /* avoid dangling else.  */
6403       ReturnStatement (stopset0, stopset1, stopset2);
6404     }
6405   else if (mcLexBuf_currenttoken == mcReserved_retrytok)
6406     {
6407       /* avoid dangling else.  */
6408       RetryStatement (stopset0, stopset1, stopset2);
6409     }
6410   else
6411     {
6412       /* avoid dangling else.  */
6413       s = pushStmt (static_cast<decl_node> (NULL));
6414     }
6415 }
6416
6417
6418 /*
6419    RetryStatement :=
6420                      % VAR s: node ;  %
6421
6422                      % s := pushStmt (makeComment ("retry"))  %
6423                      'RETRY'
6424
6425    first  symbols:retrytok
6426
6427    cannot reachend
6428 */
6429
6430 static void RetryStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6431 {
6432   decl_node s;
6433
6434   s = pushStmt (decl_makeComment ((const char *) "retry", 5));
6435   Expect (mcReserved_retrytok, stopset0, stopset1, stopset2);
6436 }
6437
6438
6439 /*
6440    AssignmentOrProcedureCall :=
6441                                 % VAR d, a, p: node ;  %
6442                                 Designator
6443                                 % d := pop ()  %
6444                                 ( ':=' Expression
6445                                   % a := pushStmt (makeAssignment (d, pop ()))  %
6446                                    |
6447                                   ActualParameters
6448
6449                                   % a := pushStmt (makeFuncCall (d, pop ()))  %
6450                                    |
6451
6452                                   % a := pushStmt (makeFuncCall (d, NIL))  %
6453                                    )
6454                                 % addCommentBody (peepStmt ())  %
6455
6456                                 % addCommentAfter (peepStmt ())  %
6457
6458
6459    first  symbols:identtok
6460
6461    cannot reachend
6462 */
6463
6464 static void AssignmentOrProcedureCall (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6465 {
6466   decl_node d;
6467   decl_node a;
6468   decl_node p;
6469
6470   Designator (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_becomestok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
6471   d = pop ();
6472   if (mcLexBuf_currenttoken == mcReserved_becomestok)
6473     {
6474       Expect (mcReserved_becomestok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6475       Expression (stopset0, stopset1, stopset2);
6476       a = pushStmt (decl_makeAssignment (d, pop ()));
6477     }
6478   else if (mcLexBuf_currenttoken == mcReserved_lparatok)
6479     {
6480       /* avoid dangling else.  */
6481       ActualParameters (stopset0, stopset1, stopset2);
6482       a = pushStmt (decl_makeFuncCall (d, pop ()));
6483     }
6484   else
6485     {
6486       /* avoid dangling else.  */
6487       a = pushStmt (decl_makeFuncCall (d, static_cast<decl_node> (NULL)));
6488     }
6489   decl_addCommentBody (peepStmt ());
6490   decl_addCommentAfter (peepStmt ());
6491 }
6492
6493
6494 /*
6495    StatementSequence :=
6496                         % VAR s, t: node ;  %
6497
6498                         % s := pushStmt (makeStatementSequence ())  %
6499
6500                         % assert (isStatementSequence (peepStmt ()))  %
6501                         Statement
6502                         % addStatement (s, popStmt ())  %
6503
6504                         % assert (isStatementSequence (peepStmt ()))  %
6505                         { ';' Statement
6506                           % addStatement (s, popStmt ())  %
6507
6508                           % assert (isStatementSequence (peepStmt ()))  %
6509                            }
6510
6511    first  symbols:identtok, iftok, casetok, whiletok, repeattok, looptok, fortok, withtok, asmtok, retrytok, semicolontok, exittok, returntok
6512
6513    reachend
6514 */
6515
6516 static void StatementSequence (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6517 {
6518   decl_node s;
6519   decl_node t;
6520
6521   s = pushStmt (decl_makeStatementSequence ());
6522   mcDebug_assert (decl_isStatementSequence (peepStmt ()));
6523   Statement (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
6524   decl_addStatement (s, popStmt ());
6525   mcDebug_assert (decl_isStatementSequence (peepStmt ()));
6526   while (mcLexBuf_currenttoken == mcReserved_semicolontok)
6527     {
6528       Expect (mcReserved_semicolontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6529       Statement (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
6530       decl_addStatement (s, popStmt ());
6531       mcDebug_assert (decl_isStatementSequence (peepStmt ()));
6532     }
6533    /* while  */
6534 }
6535
6536
6537 /*
6538    IfStatement :=
6539                   % VAR i, a, b: node ;  %
6540                   'IF'
6541                   % b := makeCommentS (getBodyComment ())  %
6542                   Expression
6543                   % a := makeCommentS (getAfterComment ())  %
6544                   'THEN' StatementSequence
6545                   % i := pushStmt (makeIf (pop (), popStmt ()))  %
6546
6547                   % addIfComments (i, b, a)  %
6548                   { 'ELSIF'
6549                     % b := makeCommentS (getBodyComment ())  %
6550                     Expression
6551                     % a := makeCommentS (getAfterComment ())  %
6552                     'THEN'
6553                     % addElseComments (peepStmt (), b, a)  %
6554                     StatementSequence
6555                     % i := makeElsif (i, pop (), popStmt ())  %
6556                      } [ 'ELSE' StatementSequence
6557                          % putElse (i, popStmt ())  %
6558                           ] 'END'
6559                   % b := makeCommentS (getBodyComment ())  %
6560
6561                   % a := makeCommentS (getAfterComment ())  %
6562
6563                   % assert (isIf (peepStmt ()))  %
6564
6565                   % addIfEndComments (peepStmt (), b, a)  %
6566
6567
6568    first  symbols:iftok
6569
6570    cannot reachend
6571 */
6572
6573 static void IfStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6574 {
6575   decl_node i;
6576   decl_node a;
6577   decl_node b;
6578
6579   Expect (mcReserved_iftok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6580   b = decl_makeCommentS (mcLexBuf_getBodyComment ());
6581   Expression (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_thentok-mcReserved_recordtok))));
6582   a = decl_makeCommentS (mcLexBuf_getAfterComment ());
6583   Expect (mcReserved_thentok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_elsiftok-mcReserved_arraytok)) | (1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6584   StatementSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_elsiftok-mcReserved_arraytok)) | (1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
6585   i = pushStmt (decl_makeIf (pop (), popStmt ()));
6586   decl_addIfComments (i, b, a);
6587   while (mcLexBuf_currenttoken == mcReserved_elsiftok)
6588     {
6589       Expect (mcReserved_elsiftok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6590       b = decl_makeCommentS (mcLexBuf_getBodyComment ());
6591       Expression (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_thentok-mcReserved_recordtok))));
6592       a = decl_makeCommentS (mcLexBuf_getAfterComment ());
6593       Expect (mcReserved_thentok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_elsiftok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6594       decl_addElseComments (peepStmt (), b, a);
6595       StatementSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_elsiftok-mcReserved_arraytok))), stopset2);
6596       i = decl_makeElsif (i, pop (), popStmt ());
6597     }
6598    /* while  */
6599   if (mcLexBuf_currenttoken == mcReserved_elsetok)
6600     {
6601       Expect (mcReserved_elsetok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6602       StatementSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
6603       decl_putElse (i, popStmt ());
6604     }
6605   Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
6606   b = decl_makeCommentS (mcLexBuf_getBodyComment ());
6607   a = decl_makeCommentS (mcLexBuf_getAfterComment ());
6608   mcDebug_assert (decl_isIf (peepStmt ()));
6609   decl_addIfEndComments (peepStmt (), b, a);
6610 }
6611
6612
6613 /*
6614    CaseStatement :=
6615                     % VAR s, e: node ;  %
6616
6617                     % s := pushStmt (makeCase ())  %
6618                     'CASE' Expression
6619                     % s := putCaseExpression (s, pop ())  %
6620                     'OF' Case { '|' Case  } CaseEndStatement
6621
6622    first  symbols:casetok
6623
6624    cannot reachend
6625 */
6626
6627 static void CaseStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6628 {
6629   decl_node s;
6630   decl_node e;
6631
6632   s = pushStmt (decl_makeCase ());
6633   Expect (mcReserved_casetok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6634   Expression (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_oftok-mcReserved_arraytok))), stopset2);
6635   s = decl_putCaseExpression (s, pop ());
6636   Expect (mcReserved_oftok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_bartok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
6637   Case (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_bartok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
6638   while (mcLexBuf_currenttoken == mcReserved_bartok)
6639     {
6640       Expect (mcReserved_bartok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_bartok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_elsetok-mcReserved_arraytok)) | (1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
6641       Case (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_bartok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_elsetok-mcReserved_arraytok))), stopset2);
6642     }
6643    /* while  */
6644   CaseEndStatement (stopset0, stopset1, stopset2);
6645 }
6646
6647
6648 /*
6649    CaseEndStatement :=
6650                        % VAR c: node ;  %
6651                        'END'  | 'ELSE'
6652                        % c := peepStmt ()  %
6653                        StatementSequence
6654                        % c := putCaseElse (c, popStmt ())  %
6655                        'END'
6656
6657    first  symbols:elsetok, endtok
6658
6659    cannot reachend
6660 */
6661
6662 static void CaseEndStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6663 {
6664   decl_node c;
6665
6666   if (mcLexBuf_currenttoken == mcReserved_endtok)
6667     {
6668       Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
6669     }
6670   else if (mcLexBuf_currenttoken == mcReserved_elsetok)
6671     {
6672       /* avoid dangling else.  */
6673       Expect (mcReserved_elsetok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6674       c = peepStmt ();
6675       StatementSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
6676       c = decl_putCaseElse (c, popStmt ());
6677       Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
6678     }
6679   else
6680     {
6681       /* avoid dangling else.  */
6682       ErrorArray ((const char *) "expecting one of: ELSE END", 26);
6683     }
6684 }
6685
6686
6687 /*
6688    Case := [ CaseLabelList ':'
6689              % VAR l, c: node ;  %
6690
6691              % l := pop ()  %
6692
6693              % c := peepStmt ()  %
6694              StatementSequence
6695              % c := putCaseStatement (c, l, popStmt ())  %
6696               ]
6697
6698    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
6699
6700    reachend
6701 */
6702
6703 static void Case (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6704 {
6705   decl_node l;
6706   decl_node c;
6707
6708   if ((((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_nottok)) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))))) != 0))))
6709     {
6710       CaseLabelList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
6711       Expect (mcReserved_colontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6712       l = pop ();
6713       c = peepStmt ();
6714       StatementSequence (stopset0, stopset1, stopset2);
6715       c = decl_putCaseStatement (c, l, popStmt ());
6716     }
6717 }
6718
6719
6720 /*
6721    CaseLabelList :=
6722                     % VAR l: node ;  %
6723
6724                     % l := push (makeCaseList ())  %
6725                     CaseLabels { ',' CaseLabels  }
6726
6727    first  symbols:attributetok, identtok, lcbratok, stringtok, nottok, lparatok, integertok, realtok, minustok, plustok
6728
6729    cannot reachend
6730 */
6731
6732 static void CaseLabelList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6733 {
6734   decl_node l;
6735
6736   l = push (decl_makeCaseList ());
6737   CaseLabels (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
6738   while (mcLexBuf_currenttoken == mcReserved_commatok)
6739     {
6740       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))));
6741       CaseLabels (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
6742     }
6743    /* while  */
6744 }
6745
6746
6747 /*
6748    CaseLabels :=
6749                  % VAR lo, hi, l: node ;  %
6750
6751                  % lo := NIL ; hi := NIL  %
6752
6753                  % l := peep ()  %
6754                  ConstExpression
6755                  % lo := pop ()  %
6756                  [ '..' ConstExpression
6757                    % hi := pop ()  %
6758                     ]
6759                  % l := putCaseRange (l, lo, hi)  %
6760
6761
6762    first  symbols:stringtok, lcbratok, identtok, attributetok, realtok, integertok, lparatok, nottok, plustok, minustok
6763
6764    cannot reachend
6765 */
6766
6767 static void CaseLabels (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6768 {
6769   decl_node lo;
6770   decl_node hi;
6771   decl_node l;
6772
6773   lo = static_cast<decl_node> (NULL);
6774   hi = static_cast<decl_node> (NULL);
6775   l = peep ();
6776   ConstExpression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodperiodtok-mcReserved_eoftok))), stopset1, stopset2);
6777   lo = pop ();
6778   if (mcLexBuf_currenttoken == mcReserved_periodperiodtok)
6779     {
6780       Expect (mcReserved_periodperiodtok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
6781       ConstExpression (stopset0, stopset1, stopset2);
6782       hi = pop ();
6783     }
6784   l = decl_putCaseRange (l, lo, hi);
6785 }
6786
6787
6788 /*
6789    WhileStatement :=
6790                      % VAR s, w, e, a, b: node ;  %
6791
6792                      % w := pushStmt (makeWhile ())  %
6793                      'WHILE' Expression 'DO'
6794                      % b := makeCommentS (getBodyComment ())  %
6795
6796                      % a := makeCommentS (getAfterComment ())  %
6797
6798                      % addWhileDoComment (w, b, a)  %
6799
6800                      % e := pop ()  %
6801                      StatementSequence
6802                      % s := popStmt ()  %
6803                      'END'
6804                      %  assert (isStatementSequence (peepStmt ()))   %
6805
6806                      % putWhile (w, e, s)  %
6807
6808                      % b := makeCommentS (getBodyComment ())  %
6809
6810                      % a := makeCommentS (getAfterComment ())  %
6811
6812                      % addWhileEndComment (w, b, a)  %
6813
6814
6815    first  symbols:whiletok
6816
6817    cannot reachend
6818 */
6819
6820 static void WhileStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6821 {
6822   decl_node s;
6823   decl_node w;
6824   decl_node e;
6825   decl_node a;
6826   decl_node b;
6827
6828   w = pushStmt (decl_makeWhile ());
6829   Expect (mcReserved_whiletok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6830   Expression (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_dotok-mcReserved_arraytok))), stopset2);
6831   Expect (mcReserved_dotok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6832   b = decl_makeCommentS (mcLexBuf_getBodyComment ());
6833   a = decl_makeCommentS (mcLexBuf_getAfterComment ());
6834   decl_addWhileDoComment (w, b, a);
6835   e = pop ();
6836   StatementSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
6837   s = popStmt ();
6838   Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
6839   /* assert (isStatementSequence (peepStmt ()))  */
6840   decl_putWhile (w, e, s);
6841   b = decl_makeCommentS (mcLexBuf_getBodyComment ());
6842   a = decl_makeCommentS (mcLexBuf_getAfterComment ());
6843   decl_addWhileEndComment (w, b, a);
6844 }
6845
6846
6847 /*
6848    RepeatStatement :=
6849                       % VAR r, s, a, b: node ;  %
6850
6851                       % r := pushStmt (makeRepeat ())  %
6852                       'REPEAT'
6853                       % b := makeCommentS (getBodyComment ())  %
6854
6855                       % a := makeCommentS (getAfterComment ())  %
6856
6857                       % addRepeatComment (r, b, a)  %
6858                       StatementSequence
6859                       % s := popStmt ()  %
6860                       'UNTIL' Expression
6861                       % putRepeat (r, s, pop ())  %
6862
6863                       % b := makeCommentS (getBodyComment ())  %
6864
6865                       % a := makeCommentS (getAfterComment ())  %
6866
6867                       % addUntilComment (r, b, a)  %
6868
6869
6870    first  symbols:repeattok
6871
6872    cannot reachend
6873 */
6874
6875 static void RepeatStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6876 {
6877   decl_node r;
6878   decl_node s;
6879   decl_node a;
6880   decl_node b;
6881
6882   r = pushStmt (decl_makeRepeat ());
6883   Expect (mcReserved_repeattok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_untiltok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6884   b = decl_makeCommentS (mcLexBuf_getBodyComment ());
6885   a = decl_makeCommentS (mcLexBuf_getAfterComment ());
6886   decl_addRepeatComment (r, b, a);
6887   StatementSequence (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_untiltok-mcReserved_recordtok))));
6888   s = popStmt ();
6889   Expect (mcReserved_untiltok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6890   Expression (stopset0, stopset1, stopset2);
6891   decl_putRepeat (r, s, pop ());
6892   b = decl_makeCommentS (mcLexBuf_getBodyComment ());
6893   a = decl_makeCommentS (mcLexBuf_getAfterComment ());
6894   decl_addUntilComment (r, b, a);
6895 }
6896
6897
6898 /*
6899    ForStatement :=
6900                    % VAR f, i, s, e, b: node ;  %
6901
6902                    % b := NIL  %
6903
6904                    % f := pushStmt (makeFor ())  %
6905                    'FOR' Ident
6906                    % i := lookupWithSym (curident)  %
6907                    ':=' Expression
6908                    % s := pop ()  %
6909                    'TO' Expression
6910                    % e := pop ()  %
6911                    [ 'BY' ConstExpression
6912                      % b := pop ()  %
6913                       ] 'DO' StatementSequence
6914                    % putFor (f, i, s, e, b, popStmt ())  %
6915                    'END'
6916
6917    first  symbols:fortok
6918
6919    cannot reachend
6920 */
6921
6922 static void ForStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6923 {
6924   decl_node f;
6925   decl_node i;
6926   decl_node s;
6927   decl_node e;
6928   decl_node b;
6929
6930   b = static_cast<decl_node> (NULL);
6931   f = pushStmt (decl_makeFor ());
6932   Expect (mcReserved_fortok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
6933   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_becomestok-mcReserved_eoftok))), stopset1, stopset2);
6934   i = lookupWithSym (curident);
6935   Expect (mcReserved_becomestok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6936   Expression (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_totok-mcReserved_recordtok))));
6937   s = pop ();
6938   Expect (mcReserved_totok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6939   Expression (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_bytok-mcReserved_arraytok)) | (1 << (mcReserved_dotok-mcReserved_arraytok))), stopset2);
6940   e = pop ();
6941   if (mcLexBuf_currenttoken == mcReserved_bytok)
6942     {
6943       Expect (mcReserved_bytok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
6944       ConstExpression (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_dotok-mcReserved_arraytok))), stopset2);
6945       b = pop ();
6946     }
6947   Expect (mcReserved_dotok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6948   StatementSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
6949   decl_putFor (f, i, s, e, b, popStmt ());
6950   Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
6951 }
6952
6953
6954 /*
6955    LoopStatement :=
6956                     % VAR l, s: node ;  %
6957                     'LOOP'
6958                     % l := pushStmt (pushLoop (makeLoop ()))  %
6959
6960                     % INC (loopNo)  %
6961                     StatementSequence
6962                     % s := popStmt ()  %
6963
6964                     % putLoop (l, s)  %
6965
6966                     % DEC (loopNo)  %
6967                     'END'
6968                     % l := popLoop ()  %
6969
6970                     % assert (isLoop (peepStmt ()))  %
6971
6972
6973    first  symbols:looptok
6974
6975    cannot reachend
6976 */
6977
6978 static void LoopStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
6979 {
6980   decl_node l;
6981   decl_node s;
6982
6983   Expect (mcReserved_looptok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
6984   l = pushStmt (pushLoop (decl_makeLoop ()));
6985   loopNo += 1;
6986   StatementSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
6987   s = popStmt ();
6988   decl_putLoop (l, s);
6989   loopNo -= 1;
6990   Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
6991   l = popLoop ();
6992   mcDebug_assert (decl_isLoop (peepStmt ()));
6993 }
6994
6995
6996 /*
6997    WithStatement := 'WITH' Designator 'DO'
6998                     % startWith (pop ())  %
6999                     StatementSequence 'END'
7000                     % endWith  %
7001
7002
7003    first  symbols:withtok
7004
7005    cannot reachend
7006 */
7007
7008 static void WithStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7009 {
7010   Expect (mcReserved_withtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7011   Designator (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_dotok-mcReserved_arraytok))), stopset2);
7012   Expect (mcReserved_dotok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7013   startWith (pop ());
7014   StatementSequence (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
7015   Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
7016   endWith ();
7017 }
7018
7019
7020 /*
7021    ProcedureDeclaration := ProcedureHeading ';' ProcedureBlock
7022                            Ident
7023                            % leaveScope  %
7024
7025
7026    first  symbols:proceduretok
7027
7028    cannot reachend
7029 */
7030
7031 static void ProcedureDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7032 {
7033   ProcedureHeading (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7034   Expect (mcReserved_semicolontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
7035   ProcedureBlock (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7036   Ident (stopset0, stopset1, stopset2);
7037   decl_leaveScope ();
7038 }
7039
7040
7041 /*
7042    ProcedureIdent := Ident
7043                      % curproc := lookupSym (curident)  %
7044
7045                      % enterScope (curproc)  %
7046
7047                      % setProcedureComment (lastcomment, curident)  %
7048
7049
7050    first  symbols:identtok
7051
7052    cannot reachend
7053 */
7054
7055 static void ProcedureIdent (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7056 {
7057   Ident (stopset0, stopset1, stopset2);
7058   curproc = decl_lookupSym (curident);
7059   decl_enterScope (curproc);
7060   mcComment_setProcedureComment (mcLexBuf_lastcomment, curident);
7061 }
7062
7063
7064 /*
7065    DefProcedureIdent := Ident
7066                         % curproc := lookupSym (curident)  %
7067
7068
7069    first  symbols:identtok
7070
7071    cannot reachend
7072 */
7073
7074 static void DefProcedureIdent (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7075 {
7076   Ident (stopset0, stopset1, stopset2);
7077   curproc = decl_lookupSym (curident);
7078 }
7079
7080
7081 /*
7082    DefineBuiltinProcedure := [ '__ATTRIBUTE__' '__BUILTIN__'
7083                                '(' '(' Ident ')' ')'  |
7084                                '__INLINE__'  ]
7085
7086    first  symbols:inlinetok, attributetok
7087
7088    reachend
7089 */
7090
7091 static void DefineBuiltinProcedure (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7092 {
7093   if ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_inlinetok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok))))) != 0)))
7094     {
7095       /* avoid gcc warning by using compound statement even if not strictly necessary.  */
7096       /* seen optional [ | ] expression  */
7097       if (mcLexBuf_currenttoken == mcReserved_attributetok)
7098         {
7099           Expect (mcReserved_attributetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_builtintok-mcReserved_recordtok))));
7100           Expect (mcReserved_builtintok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
7101           Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
7102           Expect (mcReserved_lparatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7103           Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
7104           Expect (mcReserved_rparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
7105           Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
7106         }
7107       else if (mcLexBuf_currenttoken == mcReserved_inlinetok)
7108         {
7109           /* avoid dangling else.  */
7110           Expect (mcReserved_inlinetok, stopset0, stopset1, stopset2);
7111         }
7112       else
7113         {
7114           /* avoid dangling else.  */
7115           ErrorArray ((const char *) "expecting one of: __INLINE__ __ATTRIBUTE__", 42);
7116         }
7117     }
7118   /* end of optional [ | ] expression  */
7119 }
7120
7121
7122 /*
7123    ProcedureHeading := 'PROCEDURE' DefineBuiltinProcedure
7124                        ( ProcedureIdent [ FormalParameters  ]
7125                          AttributeNoReturn  )
7126
7127    first  symbols:proceduretok
7128
7129    cannot reachend
7130 */
7131
7132 static void ProcedureHeading (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7133 {
7134   Expect (mcReserved_proceduretok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_inlinetok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7135   DefineBuiltinProcedure (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7136   ProcedureIdent (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_ldirectivetok-mcReserved_eoftok))), stopset1, stopset2);
7137   if (mcLexBuf_currenttoken == mcReserved_lparatok)
7138     {
7139       FormalParameters (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ldirectivetok-mcReserved_eoftok))), stopset1, stopset2);
7140     }
7141   AttributeNoReturn (stopset0, stopset1, stopset2);
7142 }
7143
7144
7145 /*
7146    Builtin := [ '__BUILTIN__'  | '__INLINE__'  ]
7147
7148    first  symbols:inlinetok, builtintok
7149
7150    reachend
7151 */
7152
7153 static void Builtin (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7154 {
7155   if ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_inlinetok-mcReserved_recordtok)) | (1 << (mcReserved_builtintok-mcReserved_recordtok))))) != 0)))
7156     {
7157       /* avoid gcc warning by using compound statement even if not strictly necessary.  */
7158       /* seen optional [ | ] expression  */
7159       if (mcLexBuf_currenttoken == mcReserved_builtintok)
7160         {
7161           Expect (mcReserved_builtintok, stopset0, stopset1, stopset2);
7162         }
7163       else if (mcLexBuf_currenttoken == mcReserved_inlinetok)
7164         {
7165           /* avoid dangling else.  */
7166           Expect (mcReserved_inlinetok, stopset0, stopset1, stopset2);
7167         }
7168       else
7169         {
7170           /* avoid dangling else.  */
7171           ErrorArray ((const char *) "expecting one of: __INLINE__ __BUILTIN__", 40);
7172         }
7173     }
7174   /* end of optional [ | ] expression  */
7175 }
7176
7177
7178 /*
7179    DefProcedureHeading := 'PROCEDURE' Builtin ( DefProcedureIdent
7180                                                 [ DefFormalParameters  ]
7181                                                 AttributeNoReturn  )
7182
7183    first  symbols:proceduretok
7184
7185    cannot reachend
7186 */
7187
7188 static void DefProcedureHeading (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7189 {
7190   Expect (mcReserved_proceduretok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_inlinetok-mcReserved_recordtok)) | (1 << (mcReserved_builtintok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7191   Builtin (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7192   DefProcedureIdent (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_ldirectivetok-mcReserved_eoftok))), stopset1, stopset2);
7193   if (mcLexBuf_currenttoken == mcReserved_lparatok)
7194     {
7195       DefFormalParameters (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ldirectivetok-mcReserved_eoftok))), stopset1, stopset2);
7196     }
7197   AttributeNoReturn (stopset0, stopset1, stopset2);
7198 }
7199
7200
7201 /*
7202    ProcedureBlock := { Declaration  } [ 'BEGIN' ProcedureBlockBody  ]
7203                      'END'
7204
7205    first  symbols:proceduretok, moduletok, consttok, typetok, vartok, endtok, begintok
7206
7207    cannot reachend
7208 */
7209
7210 static void ProcedureBlock (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7211 {
7212   while ((((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))))) != 0))) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))))) != 0))))
7213     {
7214       Declaration (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
7215     }
7216    /* while  */
7217   if (mcLexBuf_currenttoken == mcReserved_begintok)
7218     {
7219       Expect (mcReserved_begintok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_excepttok-mcReserved_arraytok)) | (1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7220       ProcedureBlockBody (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
7221     }
7222   Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
7223 }
7224
7225
7226 /*
7227    Block := { Declaration  } InitialBlock FinalBlock
7228             'END'
7229
7230    first  symbols:proceduretok, moduletok, finallytok, begintok, consttok, typetok, vartok, endtok
7231
7232    cannot reachend
7233 */
7234
7235 static void Block (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7236 {
7237   while ((((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))))) != 0))) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))))) != 0))))
7238     {
7239       Declaration (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
7240     }
7241    /* while  */
7242   InitialBlock (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok))), stopset2);
7243   FinalBlock (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok))), stopset2);
7244   Expect (mcReserved_endtok, stopset0, stopset1, stopset2);
7245 }
7246
7247
7248 /*
7249    InitialBlock := [ 'BEGIN' InitialBlockBody  ]
7250
7251    first  symbols:begintok
7252
7253    reachend
7254 */
7255
7256 static void InitialBlock (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7257 {
7258   if (mcLexBuf_currenttoken == mcReserved_begintok)
7259     {
7260       Expect (mcReserved_begintok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_excepttok-mcReserved_arraytok)) | (1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7261       InitialBlockBody (stopset0, stopset1, stopset2);
7262     }
7263 }
7264
7265
7266 /*
7267    FinalBlock := [ 'FINALLY' FinalBlockBody  ]
7268
7269    first  symbols:finallytok
7270
7271    reachend
7272 */
7273
7274 static void FinalBlock (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7275 {
7276   if (mcLexBuf_currenttoken == mcReserved_finallytok)
7277     {
7278       Expect (mcReserved_finallytok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_excepttok-mcReserved_arraytok)) | (1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7279       FinalBlockBody (stopset0, stopset1, stopset2);
7280     }
7281 }
7282
7283
7284 /*
7285    InitialBlockBody := NormalPart
7286                        % putBegin (curmodule, popStmt ())  %
7287                        [ 'EXCEPT' ExceptionalPart  ]
7288
7289    first  symbols:identtok, iftok, casetok, whiletok, repeattok, looptok, fortok, withtok, asmtok, retrytok, semicolontok, exittok, returntok, excepttok
7290
7291    reachend
7292 */
7293
7294 static void InitialBlockBody (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7295 {
7296   NormalPart (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_excepttok-mcReserved_arraytok))), stopset2);
7297   decl_putBegin (curmodule, popStmt ());
7298   if (mcLexBuf_currenttoken == mcReserved_excepttok)
7299     {
7300       Expect (mcReserved_excepttok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7301       ExceptionalPart (stopset0, stopset1, stopset2);
7302     }
7303 }
7304
7305
7306 /*
7307    FinalBlockBody := NormalPart
7308                      % putFinally (curmodule, popStmt ())  %
7309                      [ 'EXCEPT' ExceptionalPart  ]
7310
7311    first  symbols:identtok, iftok, casetok, whiletok, repeattok, looptok, fortok, withtok, asmtok, retrytok, semicolontok, exittok, returntok, excepttok
7312
7313    reachend
7314 */
7315
7316 static void FinalBlockBody (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7317 {
7318   NormalPart (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_excepttok-mcReserved_arraytok))), stopset2);
7319   decl_putFinally (curmodule, popStmt ());
7320   if (mcLexBuf_currenttoken == mcReserved_excepttok)
7321     {
7322       Expect (mcReserved_excepttok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7323       ExceptionalPart (stopset0, stopset1, stopset2);
7324     }
7325 }
7326
7327
7328 /*
7329    ProcedureBlockBody := ProcedureNormalPart [ 'EXCEPT'
7330                                                ExceptionalPart  ]
7331
7332    first  symbols:identtok, iftok, casetok, whiletok, repeattok, looptok, fortok, withtok, asmtok, retrytok, semicolontok, exittok, returntok, excepttok
7333
7334    reachend
7335 */
7336
7337 static void ProcedureBlockBody (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7338 {
7339   ProcedureNormalPart (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_excepttok-mcReserved_arraytok))), stopset2);
7340   if (mcLexBuf_currenttoken == mcReserved_excepttok)
7341     {
7342       Expect (mcReserved_excepttok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_exittok-mcReserved_arraytok)) | (1 << (mcReserved_fortok-mcReserved_arraytok)) | (1 << (mcReserved_looptok-mcReserved_arraytok)) | (1 << (mcReserved_casetok-mcReserved_arraytok)) | (1 << (mcReserved_iftok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_returntok-mcReserved_recordtok)) | (1 << (mcReserved_retrytok-mcReserved_recordtok)) | (1 << (mcReserved_asmtok-mcReserved_recordtok)) | (1 << (mcReserved_withtok-mcReserved_recordtok)) | (1 << (mcReserved_repeattok-mcReserved_recordtok)) | (1 << (mcReserved_whiletok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
7343       ExceptionalPart (stopset0, stopset1, stopset2);
7344     }
7345 }
7346
7347
7348 /*
7349    ProcedureNormalPart := StatementSequence
7350                           % putBegin (curproc, popStmt ())  %
7351
7352
7353    first  symbols:identtok, retrytok, asmtok, withtok, fortok, looptok, repeattok, whiletok, casetok, iftok, returntok, exittok, semicolontok
7354
7355    reachend
7356 */
7357
7358 static void ProcedureNormalPart (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7359 {
7360   StatementSequence (stopset0, stopset1, stopset2);
7361   decl_putBegin (curproc, popStmt ());
7362 }
7363
7364
7365 /*
7366    NormalPart := StatementSequence
7367
7368    first  symbols:identtok, retrytok, asmtok, withtok, fortok, looptok, repeattok, whiletok, casetok, iftok, returntok, exittok, semicolontok
7369
7370    reachend
7371 */
7372
7373 static void NormalPart (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7374 {
7375   StatementSequence (stopset0, stopset1, stopset2);
7376 }
7377
7378
7379 /*
7380    ExceptionalPart := StatementSequence
7381
7382    first  symbols:identtok, retrytok, asmtok, withtok, fortok, looptok, repeattok, whiletok, casetok, iftok, returntok, exittok, semicolontok
7383
7384    reachend
7385 */
7386
7387 static void ExceptionalPart (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7388 {
7389   StatementSequence (stopset0, stopset1, stopset2);
7390 }
7391
7392
7393 /*
7394    Declaration := 'CONST' { ConstantDeclaration ';'  }  |
7395                   'TYPE' { TypeDeclaration  }  |
7396                   'VAR' { VariableDeclaration ';'  }  |
7397                   ProcedureDeclaration ';'  |
7398                   ModuleDeclaration ';'
7399
7400    first  symbols:moduletok, proceduretok, vartok, typetok, consttok
7401
7402    cannot reachend
7403 */
7404
7405 static void Declaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7406 {
7407   if (mcLexBuf_currenttoken == mcReserved_consttok)
7408     {
7409       Expect (mcReserved_consttok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7410       while (mcLexBuf_currenttoken == mcReserved_identtok)
7411         {
7412           ConstantDeclaration (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7413           Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7414         }
7415        /* while  */
7416     }
7417   else if (mcLexBuf_currenttoken == mcReserved_typetok)
7418     {
7419       /* avoid dangling else.  */
7420       Expect (mcReserved_typetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7421       while (mcLexBuf_currenttoken == mcReserved_identtok)
7422         {
7423           TypeDeclaration (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7424         }
7425        /* while  */
7426     }
7427   else if (mcLexBuf_currenttoken == mcReserved_vartok)
7428     {
7429       /* avoid dangling else.  */
7430       Expect (mcReserved_vartok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7431       while (mcLexBuf_currenttoken == mcReserved_identtok)
7432         {
7433           VariableDeclaration (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7434           Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7435         }
7436        /* while  */
7437     }
7438   else if (mcLexBuf_currenttoken == mcReserved_proceduretok)
7439     {
7440       /* avoid dangling else.  */
7441       ProcedureDeclaration (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7442       Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2);
7443     }
7444   else if (mcLexBuf_currenttoken == mcReserved_moduletok)
7445     {
7446       /* avoid dangling else.  */
7447       ModuleDeclaration (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7448       Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2);
7449     }
7450   else
7451     {
7452       /* avoid dangling else.  */
7453       ErrorArray ((const char *) "expecting one of: MODULE PROCEDURE VAR TYPE CONST", 49);
7454     }
7455 }
7456
7457
7458 /*
7459    DefFormalParameters := '('
7460                           % paramEnter (curproc)  %
7461                           [ DefMultiFPSection  ] ')'
7462
7463                           % paramLeave (curproc)  %
7464                           FormalReturn
7465
7466    first  symbols:lparatok
7467
7468    cannot reachend
7469 */
7470
7471 static void DefFormalParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7472 {
7473   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
7474   decl_paramEnter (curproc);
7475   if ((mcLexBuf_currenttoken == mcReserved_lsbratok) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))))) != 0))))
7476     {
7477       DefMultiFPSection (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
7478     }
7479   Expect (mcReserved_rparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
7480   decl_paramLeave (curproc);
7481   FormalReturn (stopset0, stopset1, stopset2);
7482 }
7483
7484
7485 /*
7486    AttributeNoReturn := [ ''  ]
7487
7488    first  symbols:ldirectivetok
7489
7490    reachend
7491 */
7492
7493 static void AttributeNoReturn (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7494 {
7495   if (mcLexBuf_currenttoken == mcReserved_ldirectivetok)
7496     {
7497       Expect (mcReserved_ldirectivetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7498       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rdirectivetok-mcReserved_eoftok))), stopset1, stopset2);
7499       Expect (mcReserved_rdirectivetok, stopset0, stopset1, stopset2);
7500     }
7501 }
7502
7503
7504 /*
7505    AttributeUnused := [ ''  ]
7506
7507    first  symbols:ldirectivetok
7508
7509    reachend
7510 */
7511
7512 static void AttributeUnused (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7513 {
7514   if (mcLexBuf_currenttoken == mcReserved_ldirectivetok)
7515     {
7516       Expect (mcReserved_ldirectivetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7517       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rdirectivetok-mcReserved_eoftok))), stopset1, stopset2);
7518       Expect (mcReserved_rdirectivetok, stopset0, stopset1, stopset2);
7519     }
7520 }
7521
7522
7523 /*
7524    DefMultiFPSection := DefExtendedFP  |
7525                         FPSection [ ';' DefMultiFPSection  ]
7526
7527    first  symbols:identtok, vartok, lsbratok, periodperiodperiodtok
7528
7529    cannot reachend
7530 */
7531
7532 static void DefMultiFPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7533 {
7534   if ((mcLexBuf_currenttoken == mcReserved_lsbratok) || (mcLexBuf_currenttoken == mcReserved_periodperiodperiodtok))
7535     {
7536       DefExtendedFP (stopset0, stopset1, stopset2);
7537     }
7538   else if ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))))) != 0)))
7539     {
7540       /* avoid dangling else.  */
7541       FPSection (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7542       if (mcLexBuf_currenttoken == mcReserved_semicolontok)
7543         {
7544           Expect (mcReserved_semicolontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
7545           DefMultiFPSection (stopset0, stopset1, stopset2);
7546         }
7547     }
7548   else
7549     {
7550       /* avoid dangling else.  */
7551       ErrorArray ((const char *) "expecting one of: identifier VAR ... [", 38);
7552     }
7553 }
7554
7555
7556 /*
7557    FormalParameters := '('
7558                        % paramEnter (curproc)  %
7559                        [ MultiFPSection  ] ')'
7560                        % paramLeave (curproc)  %
7561                        FormalReturn
7562
7563    first  symbols:lparatok
7564
7565    cannot reachend
7566 */
7567
7568 static void FormalParameters (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7569 {
7570   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
7571   decl_paramEnter (curproc);
7572   if ((mcLexBuf_currenttoken == mcReserved_lsbratok) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))))) != 0))))
7573     {
7574       MultiFPSection (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
7575     }
7576   Expect (mcReserved_rparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
7577   decl_paramLeave (curproc);
7578   FormalReturn (stopset0, stopset1, stopset2);
7579 }
7580
7581
7582 /*
7583    MultiFPSection := ExtendedFP  | FPSection [ ';'
7584                                                MultiFPSection  ]
7585
7586    first  symbols:identtok, vartok, lsbratok, periodperiodperiodtok
7587
7588    cannot reachend
7589 */
7590
7591 static void MultiFPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7592 {
7593   if ((mcLexBuf_currenttoken == mcReserved_lsbratok) || (mcLexBuf_currenttoken == mcReserved_periodperiodperiodtok))
7594     {
7595       ExtendedFP (stopset0, stopset1, stopset2);
7596     }
7597   else if ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))))) != 0)))
7598     {
7599       /* avoid dangling else.  */
7600       FPSection (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7601       if (mcLexBuf_currenttoken == mcReserved_semicolontok)
7602         {
7603           Expect (mcReserved_semicolontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_periodperiodperiodtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
7604           MultiFPSection (stopset0, stopset1, stopset2);
7605         }
7606     }
7607   else
7608     {
7609       /* avoid dangling else.  */
7610       ErrorArray ((const char *) "expecting one of: identifier VAR ... [", 38);
7611     }
7612 }
7613
7614
7615 /*
7616    FPSection := NonVarFPSection  |
7617                 VarFPSection
7618
7619    first  symbols:vartok, identtok
7620
7621    cannot reachend
7622 */
7623
7624 static void FPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7625 {
7626   if (mcLexBuf_currenttoken == mcReserved_identtok)
7627     {
7628       NonVarFPSection (stopset0, stopset1, stopset2);
7629     }
7630   else if (mcLexBuf_currenttoken == mcReserved_vartok)
7631     {
7632       /* avoid dangling else.  */
7633       VarFPSection (stopset0, stopset1, stopset2);
7634     }
7635   else
7636     {
7637       /* avoid dangling else.  */
7638       ErrorArray ((const char *) "expecting one of: VAR identifier", 32);
7639     }
7640 }
7641
7642
7643 /*
7644    DefExtendedFP := DefOptArg  | '...'
7645
7646    first  symbols:lsbratok, periodperiodperiodtok
7647
7648    cannot reachend
7649 */
7650
7651 static void DefExtendedFP (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7652 {
7653   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
7654     {
7655       DefOptArg (stopset0, stopset1, stopset2);
7656     }
7657   else if (mcLexBuf_currenttoken == mcReserved_periodperiodperiodtok)
7658     {
7659       /* avoid dangling else.  */
7660       Expect (mcReserved_periodperiodperiodtok, stopset0, stopset1, stopset2);
7661     }
7662   else
7663     {
7664       /* avoid dangling else.  */
7665       ErrorArray ((const char *) "expecting one of: ... [", 23);
7666     }
7667 }
7668
7669
7670 /*
7671    ExtendedFP := OptArg  | '...'
7672
7673    first  symbols:lsbratok, periodperiodperiodtok
7674
7675    cannot reachend
7676 */
7677
7678 static void ExtendedFP (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7679 {
7680   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
7681     {
7682       OptArg (stopset0, stopset1, stopset2);
7683     }
7684   else if (mcLexBuf_currenttoken == mcReserved_periodperiodperiodtok)
7685     {
7686       /* avoid dangling else.  */
7687       Expect (mcReserved_periodperiodperiodtok, stopset0, stopset1, stopset2);
7688     }
7689   else
7690     {
7691       /* avoid dangling else.  */
7692       ErrorArray ((const char *) "expecting one of: ... [", 23);
7693     }
7694 }
7695
7696
7697 /*
7698    VarFPSection := 'VAR' IdentList ':' FormalType [
7699    AttributeUnused  ]
7700
7701    first  symbols:vartok
7702
7703    cannot reachend
7704 */
7705
7706 static void VarFPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7707 {
7708   Expect (mcReserved_vartok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7709   IdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
7710   Expect (mcReserved_colontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7711   FormalType (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ldirectivetok-mcReserved_eoftok))), stopset1, stopset2);
7712   if (mcLexBuf_currenttoken == mcReserved_ldirectivetok)
7713     {
7714       AttributeUnused (stopset0, stopset1, stopset2);
7715     }
7716 }
7717
7718
7719 /*
7720    NonVarFPSection := IdentList ':' FormalType [ AttributeUnused  ]
7721
7722    first  symbols:identtok
7723
7724    cannot reachend
7725 */
7726
7727 static void NonVarFPSection (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7728 {
7729   IdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
7730   Expect (mcReserved_colontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7731   FormalType (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ldirectivetok-mcReserved_eoftok))), stopset1, stopset2);
7732   if (mcLexBuf_currenttoken == mcReserved_ldirectivetok)
7733     {
7734       AttributeUnused (stopset0, stopset1, stopset2);
7735     }
7736 }
7737
7738
7739 /*
7740    OptArg := '[' Ident ':' FormalType [ '=' ConstExpressionNop  ]
7741              ']'
7742
7743    first  symbols:lsbratok
7744
7745    cannot reachend
7746 */
7747
7748 static void OptArg (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7749 {
7750   Expect (mcReserved_lsbratok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7751   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
7752   Expect (mcReserved_colontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7753   FormalType (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_equaltok-mcReserved_eoftok)) | (1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
7754   if (mcLexBuf_currenttoken == mcReserved_equaltok)
7755     {
7756       Expect (mcReserved_equaltok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
7757       ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
7758     }
7759   Expect (mcReserved_rsbratok, stopset0, stopset1, stopset2);
7760 }
7761
7762
7763 /*
7764    DefOptArg := '[' Ident ':' FormalType '=' ConstExpressionNop
7765                 ']'
7766
7767    first  symbols:lsbratok
7768
7769    cannot reachend
7770 */
7771
7772 static void DefOptArg (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7773 {
7774   Expect (mcReserved_lsbratok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7775   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
7776   Expect (mcReserved_colontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7777   FormalType (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_equaltok-mcReserved_eoftok))), stopset1, stopset2);
7778   Expect (mcReserved_equaltok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
7779   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
7780   Expect (mcReserved_rsbratok, stopset0, stopset1, stopset2);
7781 }
7782
7783
7784 /*
7785    FormalType := { 'ARRAY' 'OF'  } Qualident
7786
7787    first  symbols:identtok, arraytok
7788
7789    cannot reachend
7790 */
7791
7792 static void FormalType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7793 {
7794   while (mcLexBuf_currenttoken == mcReserved_arraytok)
7795     {
7796       Expect (mcReserved_arraytok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_oftok-mcReserved_arraytok))), stopset2);
7797       Expect (mcReserved_oftok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7798     }
7799    /* while  */
7800   Qualident (stopset0, stopset1, stopset2);
7801 }
7802
7803
7804 /*
7805    ModuleDeclaration := 'MODULE' Ident [ Priority  ]
7806                         ';' { Import  } [ Export  ]
7807                         Block Ident
7808
7809    first  symbols:moduletok
7810
7811    cannot reachend
7812 */
7813
7814 static void ModuleDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7815 {
7816   Expect (mcReserved_moduletok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7817   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2);
7818   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
7819     {
7820       Priority (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7821     }
7822   Expect (mcReserved_semicolontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok)) | (1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_exporttok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
7823   while (((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok))))) != 0)))
7824     {
7825       Import (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok)) | (1 << (mcReserved_exporttok-mcReserved_arraytok)) | (1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_typetok-mcReserved_recordtok))));
7826     }
7827    /* while  */
7828   if (mcLexBuf_currenttoken == mcReserved_exporttok)
7829     {
7830       Export (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_begintok-mcReserved_arraytok)) | (1 << (mcReserved_finallytok-mcReserved_arraytok)) | (1 << (mcReserved_moduletok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_typetok-mcReserved_recordtok))));
7831     }
7832   Block (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7833   Ident (stopset0, stopset1, stopset2);
7834 }
7835
7836
7837 /*
7838    Priority := '[' ConstExpressionNop ']'
7839
7840    first  symbols:lsbratok
7841
7842    cannot reachend
7843 */
7844
7845 static void Priority (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7846 {
7847   Expect (mcReserved_lsbratok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_attributetok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok)) | (1 << (mcReserved_stringtok-mcReserved_recordtok))));
7848   ConstExpressionNop (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
7849   Expect (mcReserved_rsbratok, stopset0, stopset1, stopset2);
7850 }
7851
7852
7853 /*
7854    Export := 'EXPORT' ( 'QUALIFIED' IdentList  |
7855                         'UNQUALIFIED' IdentList  |
7856                         IdentList  ) ';'
7857
7858    first  symbols:exporttok
7859
7860    cannot reachend
7861 */
7862
7863 static void Export (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7864 {
7865   Expect (mcReserved_exporttok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_qualifiedtok-mcReserved_arraytok)) | (1 << (mcReserved_unqualifiedtok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7866   if (mcLexBuf_currenttoken == mcReserved_qualifiedtok)
7867     {
7868       Expect (mcReserved_qualifiedtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7869       IdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7870     }
7871   else if (mcLexBuf_currenttoken == mcReserved_unqualifiedtok)
7872     {
7873       /* avoid dangling else.  */
7874       Expect (mcReserved_unqualifiedtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7875       IdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7876     }
7877   else if (mcLexBuf_currenttoken == mcReserved_identtok)
7878     {
7879       /* avoid dangling else.  */
7880       IdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7881     }
7882   else
7883     {
7884       /* avoid dangling else.  */
7885       ErrorArray ((const char *) "expecting one of: identifier UNQUALIFIED QUALIFIED", 50);
7886     }
7887   Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2);
7888 }
7889
7890
7891 /*
7892    FromIdentList := Ident { ',' Ident  }
7893
7894    first  symbols:identtok
7895
7896    cannot reachend
7897 */
7898
7899 static void FromIdentList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7900 {
7901   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
7902   while (mcLexBuf_currenttoken == mcReserved_commatok)
7903     {
7904       Expect (mcReserved_commatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7905       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
7906     }
7907    /* while  */
7908 }
7909
7910
7911 /*
7912    FromImport := 'FROM' Ident 'IMPORT' FromIdentList
7913                  ';'
7914
7915    first  symbols:fromtok
7916
7917    cannot reachend
7918 */
7919
7920 static void FromImport (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7921 {
7922   Expect (mcReserved_fromtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7923   Ident (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_importtok-mcReserved_arraytok))), stopset2);
7924   Expect (mcReserved_importtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7925   FromIdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7926   Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2);
7927 }
7928
7929
7930 /*
7931    ImportModuleList := Ident { ',' Ident  }
7932
7933    first  symbols:identtok
7934
7935    cannot reachend
7936 */
7937
7938 static void ImportModuleList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7939 {
7940   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
7941   while (mcLexBuf_currenttoken == mcReserved_commatok)
7942     {
7943       Expect (mcReserved_commatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7944       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
7945     }
7946    /* while  */
7947 }
7948
7949
7950 /*
7951    WithoutFromImport := 'IMPORT' ImportModuleList ';'
7952
7953    first  symbols:importtok
7954
7955    cannot reachend
7956 */
7957
7958 static void WithoutFromImport (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7959 {
7960   Expect (mcReserved_importtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
7961   ImportModuleList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
7962   Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2);
7963 }
7964
7965
7966 /*
7967    Import := FromImport  | WithoutFromImport
7968
7969    first  symbols:importtok, fromtok
7970
7971    cannot reachend
7972 */
7973
7974 static void Import (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
7975 {
7976   if (mcLexBuf_currenttoken == mcReserved_fromtok)
7977     {
7978       FromImport (stopset0, stopset1, stopset2);
7979     }
7980   else if (mcLexBuf_currenttoken == mcReserved_importtok)
7981     {
7982       /* avoid dangling else.  */
7983       WithoutFromImport (stopset0, stopset1, stopset2);
7984     }
7985   else
7986     {
7987       /* avoid dangling else.  */
7988       ErrorArray ((const char *) "expecting one of: IMPORT FROM", 29);
7989     }
7990 }
7991
7992
7993 /*
7994    DefinitionModule := 'DEFINITION' 'MODULE' [ 'FOR'
7995                                                string  ]
7996                        Ident ';'
7997                        % curmodule := lookupDef (curident)  %
7998
7999                        % enterScope (curmodule)  %
8000                        { Import  } [ Export  ] { Definition  }
8001                        'END' Ident '.'
8002                        % checkEndName (curmodule, curident, 'definition module')  %
8003
8004                        % leaveScope  %
8005
8006
8007    first  symbols:definitiontok
8008
8009    cannot reachend
8010 */
8011
8012 static void DefinitionModule (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8013 {
8014   Expect (mcReserved_definitiontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_moduletok-mcReserved_arraytok))), stopset2);
8015   Expect (mcReserved_moduletok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_fortok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8016   if (mcLexBuf_currenttoken == mcReserved_fortok)
8017     {
8018       Expect (mcReserved_fortok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok))));
8019       string (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8020     }
8021   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
8022   Expect (mcReserved_semicolontok, stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_importtok-mcReserved_arraytok)) | (1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_exporttok-mcReserved_arraytok)) | (1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_vartok-mcReserved_recordtok)) | (1 << (mcReserved_typetok-mcReserved_recordtok))));
8023   curmodule = decl_lookupDef (curident);
8024   decl_enterScope (curmodule);
8025   while (((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok))))) != 0)))
8026     {
8027       Import (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_exporttok-mcReserved_arraytok)) | (1 << (mcReserved_fromtok-mcReserved_arraytok)) | (1 << (mcReserved_importtok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
8028     }
8029    /* while  */
8030   if (mcLexBuf_currenttoken == mcReserved_exporttok)
8031     {
8032       Export (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
8033     }
8034   while ((((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok))))) != 0))) || ((mcLexBuf_currenttoken >= mcReserved_recordtok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_recordtok)) & ((mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))))) != 0))))
8035     {
8036       Definition (stopset0, stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_endtok-mcReserved_arraytok)) | (1 << (mcReserved_consttok-mcReserved_arraytok)) | (1 << (mcReserved_proceduretok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_typetok-mcReserved_recordtok)) | (1 << (mcReserved_vartok-mcReserved_recordtok))));
8037     }
8038    /* while  */
8039   Expect (mcReserved_endtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8040   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok))), stopset1, stopset2);
8041   Expect (mcReserved_periodtok, stopset0, stopset1, stopset2);
8042   checkEndName (curmodule, curident, (const char *) "definition module", 17);
8043   decl_leaveScope ();
8044 }
8045
8046
8047 /*
8048    PushQualident :=
8049                     % VAR type, field: node ;  %
8050                     Ident
8051                     % qualid := push (lookupWithSym (curident))  %
8052
8053                     % IF qualid = NIL
8054                                     THEN
8055                                        metaError1 ('the symbol {%1k} is not visible in this scope (or any other nested scope)', curident)
8056                                     END  %
8057                     [ '.'
8058                       % IF NOT isQualident (qualid)
8059                                       THEN
8060                                          ErrorArray ('the first component of this qualident must be a definition module or a parameter/variable/constant which has record type')
8061                                       END  %
8062                       Ident
8063                       % IF isDef (qualid)
8064                                       THEN
8065                                          qualid := replace (lookupInScope (qualid, curident))
8066                                       ELSE
8067                                          type := skipType (getType (qualid)) ;
8068                                          field := lookupInScope (type, curident) ;
8069                                                                                                      IF field = NIL
8070                                          THEN
8071                                             metaError2 ('field {%1k} cannot be found in {%2ad}', curident, qualid)
8072                                          ELSE
8073                                             qualid := replace (makeComponentRef (qualid, field))
8074                                          END
8075                                       END ;
8076                                       IF qualid = NIL
8077                                       THEN
8078                                          metaError1 ('qualified component of the identifier {%1k} cannot be found', curident)
8079                                       END  %
8080                        ]
8081
8082    first  symbols:identtok
8083
8084    cannot reachend
8085 */
8086
8087 static void PushQualident (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8088 {
8089   decl_node type;
8090   decl_node field;
8091
8092   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_periodtok-mcReserved_eoftok))), stopset1, stopset2);
8093   qualid = push (lookupWithSym (curident));
8094   if (qualid == NULL)
8095     {
8096       mcMetaError_metaError1 ((const char *) "the symbol {%1k} is not visible in this scope (or any other nested scope)", 73, (const unsigned char *) &curident, (sizeof (curident)-1));
8097     }
8098   if (mcLexBuf_currenttoken == mcReserved_periodtok)
8099     {
8100       Expect (mcReserved_periodtok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8101       if (! (isQualident (qualid)))
8102         {
8103           ErrorArray ((const char *) "the first component of this qualident must be a definition module or a parameter/variable/constant which has record type", 120);
8104         }
8105       Ident (stopset0, stopset1, stopset2);
8106       if (decl_isDef (qualid))
8107         {
8108           qualid = replace (decl_lookupInScope (qualid, curident));
8109         }
8110       else
8111         {
8112           type = decl_skipType (decl_getType (qualid));
8113           field = decl_lookupInScope (type, curident);
8114           if (field == NULL)
8115             {
8116               mcMetaError_metaError2 ((const char *) "field {%1k} cannot be found in {%2ad}", 37, (const unsigned char *) &curident, (sizeof (curident)-1), (const unsigned char *) &qualid, (sizeof (qualid)-1));
8117             }
8118           else
8119             {
8120               qualid = replace (decl_makeComponentRef (qualid, field));
8121             }
8122         }
8123       if (qualid == NULL)
8124         {
8125           mcMetaError_metaError1 ((const char *) "qualified component of the identifier {%1k} cannot be found", 59, (const unsigned char *) &curident, (sizeof (curident)-1));
8126         }
8127     }
8128 }
8129
8130
8131 /*
8132    OptSubrange := [ SubrangeType  ]
8133
8134    first  symbols:lsbratok
8135
8136    reachend
8137 */
8138
8139 static void OptSubrange (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8140 {
8141   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
8142     {
8143       SubrangeType (stopset0, stopset1, stopset2);
8144     }
8145 }
8146
8147
8148 /*
8149    TypeEquiv := Qualident OptSubrange
8150
8151    first  symbols:identtok
8152
8153    cannot reachend
8154 */
8155
8156 static void TypeEquiv (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8157 {
8158   Qualident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2);
8159   OptSubrange (stopset0, stopset1, stopset2);
8160 }
8161
8162
8163 /*
8164    EnumIdentList := Ident { ',' Ident  }
8165
8166    first  symbols:identtok
8167
8168    cannot reachend
8169 */
8170
8171 static void EnumIdentList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8172 {
8173   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
8174   while (mcLexBuf_currenttoken == mcReserved_commatok)
8175     {
8176       Expect (mcReserved_commatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8177       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
8178     }
8179    /* while  */
8180 }
8181
8182
8183 /*
8184    Enumeration := '(' EnumIdentList ')'
8185
8186    first  symbols:lparatok
8187
8188    cannot reachend
8189 */
8190
8191 static void Enumeration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8192 {
8193   Expect (mcReserved_lparatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8194   EnumIdentList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
8195   Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
8196 }
8197
8198
8199 /*
8200    SimpleType := TypeEquiv  | Enumeration  |
8201                  SubrangeType
8202
8203    first  symbols:lsbratok, lparatok, identtok
8204
8205    cannot reachend
8206 */
8207
8208 static void SimpleType (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8209 {
8210   if (mcLexBuf_currenttoken == mcReserved_identtok)
8211     {
8212       TypeEquiv (stopset0, stopset1, stopset2);
8213     }
8214   else if (mcLexBuf_currenttoken == mcReserved_lparatok)
8215     {
8216       /* avoid dangling else.  */
8217       Enumeration (stopset0, stopset1, stopset2);
8218     }
8219   else if (mcLexBuf_currenttoken == mcReserved_lsbratok)
8220     {
8221       /* avoid dangling else.  */
8222       SubrangeType (stopset0, stopset1, stopset2);
8223     }
8224   else
8225     {
8226       /* avoid dangling else.  */
8227       ErrorArray ((const char *) "expecting one of: [ ( identifier", 32);
8228     }
8229 }
8230
8231
8232 /*
8233    Type := SimpleType  | ArrayType  | RecordType  |
8234            SetType  | PointerType  | ProcedureType
8235
8236    first  symbols:proceduretok, pointertok, settok, packedsettok, oftok, recordtok, arraytok, identtok, lparatok, lsbratok
8237
8238    cannot reachend
8239 */
8240
8241 static void Type (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8242 {
8243   if (((mcLexBuf_currenttoken < mcReserved_arraytok) && ((((1 << (mcLexBuf_currenttoken-mcReserved_eoftok)) & ((mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_identtok))
8244     {
8245       SimpleType (stopset0, stopset1, stopset2);
8246     }
8247   else if (mcLexBuf_currenttoken == mcReserved_arraytok)
8248     {
8249       /* avoid dangling else.  */
8250       ArrayType (stopset0, stopset1, stopset2);
8251     }
8252   else if (mcLexBuf_currenttoken == mcReserved_recordtok)
8253     {
8254       /* avoid dangling else.  */
8255       RecordType (stopset0, stopset1, stopset2);
8256     }
8257   else if ((((mcLexBuf_currenttoken >= mcReserved_arraytok) && (mcLexBuf_currenttoken < mcReserved_recordtok)) && ((((1 << (mcLexBuf_currenttoken-mcReserved_arraytok)) & ((mcp5_SetOfStop1) ((1 << (mcReserved_packedsettok-mcReserved_arraytok)) | (1 << (mcReserved_oftok-mcReserved_arraytok))))) != 0))) || (mcLexBuf_currenttoken == mcReserved_settok))
8258     {
8259       /* avoid dangling else.  */
8260       SetType (stopset0, stopset1, stopset2);
8261     }
8262   else if (mcLexBuf_currenttoken == mcReserved_pointertok)
8263     {
8264       /* avoid dangling else.  */
8265       PointerType (stopset0, stopset1, stopset2);
8266     }
8267   else if (mcLexBuf_currenttoken == mcReserved_proceduretok)
8268     {
8269       /* avoid dangling else.  */
8270       ProcedureType (stopset0, stopset1, stopset2);
8271     }
8272   else
8273     {
8274       /* avoid dangling else.  */
8275       ErrorArray ((const char *) "expecting one of: PROCEDURE POINTER SET PACKEDSET OF RECORD ARRAY identifier ( [", 80);
8276     }
8277 }
8278
8279
8280 /*
8281    TypeDeclaration := { Ident ( ';'  | '=' Type Alignment
8282                                 ';'  )  }
8283
8284    first  symbols:identtok
8285
8286    reachend
8287 */
8288
8289 static void TypeDeclaration (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8290 {
8291   while (mcLexBuf_currenttoken == mcReserved_identtok)
8292     {
8293       Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok)) | (1 << (mcReserved_equaltok-mcReserved_eoftok))), stopset1, stopset2);
8294       if (mcLexBuf_currenttoken == mcReserved_semicolontok)
8295         {
8296           Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8297         }
8298       else if (mcLexBuf_currenttoken == mcReserved_equaltok)
8299         {
8300           /* avoid dangling else.  */
8301           Expect (mcReserved_equaltok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_proceduretok-mcReserved_arraytok)) | (1 << (mcReserved_pointertok-mcReserved_arraytok)) | (1 << (mcReserved_packedsettok-mcReserved_arraytok)) | (1 << (mcReserved_oftok-mcReserved_arraytok)) | (1 << (mcReserved_arraytok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_settok-mcReserved_recordtok)) | (1 << (mcReserved_recordtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
8302           Type (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_ldirectivetok-mcReserved_eoftok)) | (1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
8303           Alignment (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
8304           Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8305         }
8306       else
8307         {
8308           /* avoid dangling else.  */
8309           ErrorArray ((const char *) "expecting one of: = ;", 21);
8310         }
8311     }
8312    /* while  */
8313 }
8314
8315
8316 /*
8317    Definition := 'CONST' { ConstantDeclaration ';'  }  |
8318                  'TYPE' { TypeDeclaration  }  |
8319                  'VAR' { VariableDeclaration ';'  }  |
8320                  DefProcedureHeading ';'
8321
8322    first  symbols:proceduretok, vartok, typetok, consttok
8323
8324    cannot reachend
8325 */
8326
8327 static void Definition (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8328 {
8329   if (mcLexBuf_currenttoken == mcReserved_consttok)
8330     {
8331       Expect (mcReserved_consttok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8332       while (mcLexBuf_currenttoken == mcReserved_identtok)
8333         {
8334           ConstantDeclaration (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
8335           Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8336         }
8337        /* while  */
8338     }
8339   else if (mcLexBuf_currenttoken == mcReserved_typetok)
8340     {
8341       /* avoid dangling else.  */
8342       Expect (mcReserved_typetok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8343       while (mcLexBuf_currenttoken == mcReserved_identtok)
8344         {
8345           TypeDeclaration (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8346         }
8347        /* while  */
8348     }
8349   else if (mcLexBuf_currenttoken == mcReserved_vartok)
8350     {
8351       /* avoid dangling else.  */
8352       Expect (mcReserved_vartok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8353       while (mcLexBuf_currenttoken == mcReserved_identtok)
8354         {
8355           VariableDeclaration (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
8356           Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8357         }
8358        /* while  */
8359     }
8360   else if (mcLexBuf_currenttoken == mcReserved_proceduretok)
8361     {
8362       /* avoid dangling else.  */
8363       DefProcedureHeading (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_semicolontok-mcReserved_eoftok))), stopset1, stopset2);
8364       Expect (mcReserved_semicolontok, stopset0, stopset1, stopset2);
8365     }
8366   else
8367     {
8368       /* avoid dangling else.  */
8369       ErrorArray ((const char *) "expecting one of: PROCEDURE VAR TYPE CONST", 42);
8370     }
8371 }
8372
8373
8374 /*
8375    AsmStatement :=
8376                    % VAR s: node ;  %
8377
8378                    % s := pushStmt (makeComment ("asm"))  %
8379                    'ASM' [ 'VOLATILE'  ] '(' AsmOperands
8380                    ')'
8381
8382    first  symbols:asmtok
8383
8384    cannot reachend
8385 */
8386
8387 static void AsmStatement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8388 {
8389   decl_node s;
8390
8391   s = pushStmt (decl_makeComment ((const char *) "asm", 3));
8392   Expect (mcReserved_asmtok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_volatiletok-mcReserved_recordtok))));
8393   if (mcLexBuf_currenttoken == mcReserved_volatiletok)
8394     {
8395       Expect (mcReserved_volatiletok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
8396     }
8397   Expect (mcReserved_lparatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok))));
8398   AsmOperands (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
8399   Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
8400 }
8401
8402
8403 /*
8404    AsmOperands := string [ AsmOperandSpec  ]
8405
8406    first  symbols:stringtok
8407
8408    cannot reachend
8409 */
8410
8411 static void AsmOperands (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8412 {
8413   string (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
8414   if (mcLexBuf_currenttoken == mcReserved_colontok)
8415     {
8416       AsmOperandSpec (stopset0, stopset1, stopset2);
8417     }
8418 }
8419
8420
8421 /*
8422    AsmOperandSpec := [ ':' AsmList [ ':' AsmList [
8423    ':' TrashList  ]  ]  ]
8424
8425    first  symbols:colontok
8426
8427    reachend
8428 */
8429
8430 static void AsmOperandSpec (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8431 {
8432   if (mcLexBuf_currenttoken == mcReserved_colontok)
8433     {
8434       Expect (mcReserved_colontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok)) | (1 << (mcReserved_commatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok))));
8435       AsmList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
8436       if (mcLexBuf_currenttoken == mcReserved_colontok)
8437         {
8438           Expect (mcReserved_colontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok)) | (1 << (mcReserved_commatok-mcReserved_eoftok)) | (1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok))));
8439           AsmList (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_colontok-mcReserved_eoftok))), stopset1, stopset2);
8440           if (mcLexBuf_currenttoken == mcReserved_colontok)
8441             {
8442               Expect (mcReserved_colontok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok))));
8443               TrashList (stopset0, stopset1, stopset2);
8444             }
8445         }
8446     }
8447 }
8448
8449
8450 /*
8451    AsmList := [ AsmElement  ] { ',' AsmElement  }
8452
8453    first  symbols:lsbratok, stringtok, commatok
8454
8455    reachend
8456 */
8457
8458 static void AsmList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8459 {
8460   if ((mcLexBuf_currenttoken == mcReserved_lsbratok) || (mcLexBuf_currenttoken == mcReserved_stringtok))
8461     {
8462       AsmElement (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
8463     }
8464   while (mcLexBuf_currenttoken == mcReserved_commatok)
8465     {
8466       Expect (mcReserved_commatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lsbratok-mcReserved_eoftok))), stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok))));
8467       AsmElement (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
8468     }
8469    /* while  */
8470 }
8471
8472
8473 /*
8474    NamedOperand := '[' Ident ']'
8475
8476    first  symbols:lsbratok
8477
8478    cannot reachend
8479 */
8480
8481 static void NamedOperand (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8482 {
8483   Expect (mcReserved_lsbratok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_identtok-mcReserved_recordtok))));
8484   Ident (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rsbratok-mcReserved_eoftok))), stopset1, stopset2);
8485   Expect (mcReserved_rsbratok, stopset0, stopset1, stopset2);
8486 }
8487
8488
8489 /*
8490    AsmOperandName := [ NamedOperand  ]
8491
8492    first  symbols:lsbratok
8493
8494    reachend
8495 */
8496
8497 static void AsmOperandName (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8498 {
8499   if (mcLexBuf_currenttoken == mcReserved_lsbratok)
8500     {
8501       NamedOperand (stopset0, stopset1, stopset2);
8502     }
8503 }
8504
8505
8506 /*
8507    AsmElement := AsmOperandName string '(' Expression
8508                  ')'
8509
8510    first  symbols:stringtok, lsbratok
8511
8512    cannot reachend
8513 */
8514
8515 static void AsmElement (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8516 {
8517   AsmOperandName (stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok))));
8518   string (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_lparatok-mcReserved_eoftok))), stopset1, stopset2);
8519   Expect (mcReserved_lparatok, stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_minustok-mcReserved_eoftok)) | (1 << (mcReserved_plustok-mcReserved_eoftok)) | (1 << (mcReserved_lparatok-mcReserved_eoftok)) | (1 << (mcReserved_lcbratok-mcReserved_eoftok))), stopset1|(mcp5_SetOfStop1) ((1 << (mcReserved_nottok-mcReserved_arraytok))), stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok)) | (1 << (mcReserved_integertok-mcReserved_recordtok)) | (1 << (mcReserved_realtok-mcReserved_recordtok)) | (1 << (mcReserved_identtok-mcReserved_recordtok))));
8520   Expression (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_rparatok-mcReserved_eoftok))), stopset1, stopset2);
8521   Expect (mcReserved_rparatok, stopset0, stopset1, stopset2);
8522 }
8523
8524
8525 /*
8526    TrashList := [ string  ] { ',' string  }
8527
8528    first  symbols:commatok, stringtok
8529
8530    reachend
8531 */
8532
8533 static void TrashList (mcp5_SetOfStop0 stopset0, mcp5_SetOfStop1 stopset1, mcp5_SetOfStop2 stopset2)
8534 {
8535   if (mcLexBuf_currenttoken == mcReserved_stringtok)
8536     {
8537       string (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
8538     }
8539   while (mcLexBuf_currenttoken == mcReserved_commatok)
8540     {
8541       Expect (mcReserved_commatok, stopset0, stopset1, stopset2|(mcp5_SetOfStop2) ((1 << (mcReserved_stringtok-mcReserved_recordtok))));
8542       string (stopset0|(mcp5_SetOfStop0) ((1 << (mcReserved_commatok-mcReserved_eoftok))), stopset1, stopset2);
8543     }
8544    /* while  */
8545 }
8546
8547
8548 /*
8549    CompilationUnit - returns TRUE if the input was correct enough to parse
8550                      in future passes.
8551 */
8552
8553 extern "C" bool mcp5_CompilationUnit (void)
8554 {
8555   stk = mcStack_init ();
8556   withStk = mcStack_init ();
8557   stmtStk = mcStack_init ();
8558   loopStk = mcStack_init ();
8559   loopNo = 0;
8560   WasNoError = true;
8561   FileUnit ((mcp5_SetOfStop0) ((1 << (mcReserved_eoftok-mcReserved_eoftok))), (mcp5_SetOfStop1) 0, (mcp5_SetOfStop2) 0);
8562   mcStack_kill (&stk);
8563   mcStack_kill (&withStk);
8564   mcStack_kill (&stmtStk);
8565   mcStack_kill (&loopStk);
8566   return WasNoError;
8567   /* static analysis guarentees a RETURN statement will be used before here.  */
8568   __builtin_unreachable ();
8569 }
8570
8571 extern "C" void _M2_mcp5_init (__attribute__((unused)) int argc, __attribute__((unused)) char *argv[], __attribute__((unused)) char *envp[])
8572 {
8573 }
8574
8575 extern "C" void _M2_mcp5_fini (__attribute__((unused)) int argc, __attribute__((unused)) char *argv[], __attribute__((unused)) char *envp[])
8576 {
8577 }