1: %{
   2: #ifndef lint
   3: static char RCSid[] = "$Header: courier.y,v 2.0 85/11/21 07:21:35 jqj Exp $";
   4: #endif
   5: 
   6: /* $Log:	courier.y,v $
   7:  * Revision 2.0  85/11/21  07:21:35  jqj
   8:  * 4.3BSD standard release
   9:  *
  10:  * Revision 1.1  85/11/20  12:58:22  jqj
  11:  * Initial revision
  12:  *
  13:  * Revision 1.6  85/05/23  06:19:42  jqj
  14:  * Public Beta-test version, released 24 May 1985
  15:  *
  16:  * Revision 1.5  85/05/06  08:13:14  jqj
  17:  * Almost Beta-test version.
  18:  *
  19:  * Revision 1.4  85/03/26  06:09:49  jqj
  20:  * Revised public alpha-test version, released 26 March 1985
  21:  *
  22:  * Revision 1.3  85/03/11  16:39:15  jqj
  23:  * Public alpha-test version, released 11 March 1985
  24:  *
  25:  * Revision 1.2  85/02/21  11:05:07  jqj
  26:  * alpha test version
  27:  *
  28:  * Revision 1.1  85/02/15  13:53:01  jqj
  29:  * Initial revision
  30:  *
  31:  */
  32: 
  33: #include "compiler.h"
  34: 
  35: static char *currentdecl;
  36: static char streamdecl;
  37: %}
  38: 
  39: %token
  40:     identifier  number      string
  41: 
  42: %token
  43:     ARRAY       _BEGIN      BOOLEAN     CARDINAL
  44:     CHOICE      DEPENDS     END     ERROR
  45:     INTEGER     LONG        OF      PROCEDURE
  46:     PROGRAM     RECORD      REPORTS     RETURNS
  47:     SEQUENCE    STRING      TYPE        UNSPECIFIED
  48:     UPON        VERSION     TRUE        FALSE
  49:     _CHOOSES
  50: 
  51: %union {
  52:     struct type *type;
  53:     struct constant *constant;
  54:     list list;
  55:     char *stringvalue;
  56: }
  57: 
  58: %type <type>
  59:     ConstructedType
  60:     DesignatorType
  61:     PredefinedType
  62:     ReferencedType
  63:     Type
  64: 
  65: %type <constant>
  66:     ReferencedConstant
  67:     Constant
  68:     PredefinedConstant
  69:     ConstructedConstant
  70: 
  71: %type <list>
  72:     ArgumentList        Candidate       CandidateList
  73:     Correspondence      CorrespondenceList  Designator
  74:     DesignatorList      ErrorList       Field
  75:     FieldList       NameList        ResultList
  76:     Component       ReferencedProgramList   ElementList
  77:     ComponentList       TypedCandidate      TypedCandidateList
  78:     TypedDesignator     TypedDesignatorList CNameList
  79: 
  80: %type <stringvalue>
  81:     NumericValue        MaximumNumber
  82:     ReferencedProgram   ProgramHeader
  83:     identifier      number          string
  84: 
  85: %start  Program
  86: %%
  87: 
  88: Program :
  89:         ProgramHeader ProgramBody
  90:         {
  91:             wrapup_program($1);
  92:         }
  93:     ;
  94: 
  95: ProgramHeader :
  96:         identifier ':' PROGRAM number VERSION number '='
  97:         {
  98:             program_header($1,$4,$6);
  99:             $$ = $1;
 100:         }
 101:     ;
 102: 
 103: ProgramBody :
 104:         _BEGIN DependencyList DeclarationList END '.'
 105:     ;
 106: 
 107: DependencyList :
 108:         /* empty */
 109:         {
 110:             program_body();
 111:         }
 112:     |   DEPENDS UPON ReferencedProgramList ';'
 113:         {
 114:             program_body();
 115:         }
 116:     ;
 117: 
 118: ReferencedProgramList :
 119:         ReferencedProgram
 120:         {
 121:         }
 122:     |   ReferencedProgramList ',' ReferencedProgram
 123:         {
 124:         }
 125:     ;
 126: 
 127: ReferencedProgram :
 128:         identifier '(' number ')' VERSION number
 129:         {
 130:             /* as a side effect, the program is entered into the */
 131:             /* list of dependencies */
 132:             ref_program($1,$3,$6);
 133:             $$ = $1;
 134:         }
 135:     ;
 136: 
 137: DeclarationList :
 138:         /* empty */
 139:     |   DeclarationList Declaration
 140:     ;
 141: 
 142: Declaration :
 143:         Target TypeDeclaration
 144:     |   Target ConstantDeclaration
 145:     |   error ';'
 146:         {
 147:             fprintf(stderr,"\t\t\tDeclaration skipped\n");
 148:         }
 149:     ;
 150: 
 151: Target :
 152:         identifier ':'
 153:         {
 154:             struct object *symbol;
 155: 
 156:             currentdecl = $1;
 157:             streamdecl = 0; /* not parsing a StreamOf yet */
 158:             if (symbol = check_def(currentdecl, CurrentProgram)) {
 159:                 error(ERROR,
 160:                     "Attempt to redefine ``%s''",
 161:                     name_of(symbol));
 162:                 YYERROR;
 163:             }
 164:         }
 165:     ;
 166: 
 167: TypeDeclaration :
 168:         TYPE '=' Type ';'
 169:         {
 170:             struct object *symbol;
 171: 
 172:             symbol = make_symbol(currentdecl, CurrentProgram);
 173:             define_type(symbol, $3);
 174:         }
 175:     ;
 176: 
 177: ConstantDeclaration :
 178:         Type '=' Constant ';'
 179:         {
 180:             struct object *symbol;
 181: 
 182:             symbol = make_symbol(currentdecl, CurrentProgram);
 183:             if (type_check($1, $3)) {
 184:                 define_constant(symbol, $1, $3);
 185:             } else
 186:                 error(ERROR,
 187:                     "Type clash in declaration of ``%s''",
 188:                     name_of(symbol));
 189:         }
 190:     ;
 191: 
 192: Type :
 193:         PredefinedType
 194:         {
 195:             $$ = $1;
 196:         }
 197:     |   ConstructedType
 198:         {
 199:             $$ = $1;
 200:         }
 201:     |   ReferencedType
 202:         {
 203:             $$ = $1;
 204:         }
 205:     ;
 206: 
 207: Constant :
 208:         PredefinedConstant
 209:         {
 210:             $$ = $1;
 211:         }
 212:     |
 213:         ConstructedConstant
 214:         {
 215:             $$ = $1;
 216:         }
 217:     |
 218:         ReferencedConstant
 219:         {
 220:             $$ = $1;
 221:         }
 222:     ;
 223: 
 224: 
 225: PredefinedType :
 226:         BOOLEAN
 227:         {
 228:             $$ = Boolean_type;
 229:         }
 230:     |   CARDINAL
 231:         {
 232:             $$ = Cardinal_type;
 233:         }
 234:     |   LONG CARDINAL
 235:         {
 236:             $$ = LongCardinal_type;
 237:         }
 238:     |   INTEGER
 239:         {
 240:             $$ = Integer_type;
 241:         }
 242:     |   LONG INTEGER
 243:         {
 244:             $$ = LongInteger_type;
 245:         }
 246:     |   STRING
 247:         {
 248:             $$ = String_type;
 249:         }
 250:     |   UNSPECIFIED
 251:         {
 252:             $$ = Unspecified_type;
 253:         }
 254:     |   LONG UNSPECIFIED
 255:         {
 256:             $$ = LongUnspecified_type;
 257:         }
 258:     ;
 259: 
 260: PredefinedConstant :
 261:         TRUE
 262:         {
 263:             $$ = Boolean_constant("1");
 264:         }
 265:     |
 266:         FALSE
 267:         {
 268:             $$ = Boolean_constant("0");
 269:         }
 270:     |
 271:         number
 272:         {
 273:             $$ = Numeric_constant($1);
 274:         }
 275:     |
 276:         string
 277:         {
 278:             $$ = String_constant($1);
 279:         }
 280:     ;
 281: 
 282: ConstructedConstant :
 283:         /* simple ReferencedConstant */
 284:         identifier
 285:         {
 286:             struct object *sym;
 287: 
 288:             if (sym = check_def($1,(char *)NULL)) {
 289:                 if (class_of(sym) == O_ENUMTAG)
 290:                     $$ = enumeration_constant(sym->o_enum->en_name);
 291:                 else if (class_of(sym) == O_CONSTANT &&
 292:                      sym->o_constant->cn_constr == C_ENUMERATION)
 293:                     $$ = sym->o_constant;
 294:                 else {
 295:                     error(ERROR,
 296:                         "``%s'' is not of appropriate type",
 297:                         name_of(sym));
 298:                     YYERROR;
 299:                 }
 300:             } else if (sym = check_def($1, CurrentProgram)) {
 301:                 if (class_of(sym) == O_CONSTANT)
 302:                     $$ = sym->o_constant;
 303:                 else {
 304:                     error(ERROR,
 305:                         "``%s'' is not of appropriate type",
 306:                         name_of(sym));
 307:                     YYERROR;
 308:                 }
 309:             } else {
 310:                 error(ERROR,"``%s'' is not defined",
 311:                     $1);
 312:                 YYERROR;
 313:             }
 314:         }
 315:     |
 316:         /* SequenceConstant */
 317:         /* ArrayConstant */
 318:         '[' ElementList ']'
 319:         {
 320:             $$ = array_constant($2);
 321:         }
 322:     |
 323:         /* RecordConstant */
 324:         '[' ComponentList ']'
 325:         {
 326:             $$ = record_constant($2);
 327:         }
 328:     |
 329:         /* RecordConstant */
 330:         /* SequenceConstant */
 331:         /* ArrayConstant */
 332:         '[' ']'
 333:         {
 334:             $$ = record_constant(NIL);
 335:         }
 336:     |
 337:         /* ChoiceConstant */
 338:         identifier Constant
 339:         {
 340:             struct object* symbol;
 341: 
 342:             if ((symbol = check_def($1,(char *)NULL)) ||
 343:                 (symbol = check_def($1,CurrentProgram))) {
 344:                 if (class_of(symbol) == O_CONSTANT &&
 345:                     symbol->o_constant->cn_constr == C_ENUMERATION) {
 346:                     $$ = choice_constant(
 347:                         cons((list) symbol->o_constant->cn_value,
 348:                              (list) $2) );
 349:                 }
 350:                 else if (class_of(symbol) == O_ENUMTAG) {
 351:                     $$ = choice_constant(
 352:                         cons((list) symbol->o_enum->en_name,
 353:                              (list) $2) );
 354:                 }
 355:                 else {
 356:                     error(ERROR, "Expected enumeration constant but got ``%s''\n",
 357:                     name_of(symbol));
 358:                     YYERROR;
 359:                 }
 360:             }
 361:             else {
 362:                 error(ERROR, "Designator ``%s'' undefined\n",
 363:                     $1);
 364:                 YYERROR;
 365:             }
 366:         }
 367:     ;
 368: 
 369: 
 370: ElementList :
 371:         Constant
 372:         {
 373:             $$ = cons((list) $1, NIL);
 374: 
 375:         }
 376:     |
 377:         Constant ',' ElementList
 378:         {
 379:             $$ = cons((list)$1, $3);
 380:         }
 381:     ;
 382: 
 383: ComponentList   :
 384:         Component
 385:         {
 386:             $$ = $1;
 387:         }
 388:     |
 389:         Component ',' ComponentList
 390:         {
 391:             /* flatten */
 392:             cdr($1) = $3;
 393:             $$ = $1;
 394:         }
 395:     ;
 396: 
 397: Component   :
 398:         CNameList ':' Constant
 399:         {
 400:             list p;
 401: 
 402:             /* flatten this for simplicity of representation */
 403:             for (p = $1; p != NIL; p = cdr(p))
 404:                 car(p) = cons(car(p),(list)$3);
 405:             $$ = $1;
 406:         }
 407:     ;
 408: 
 409: CNameList :
 410:         identifier
 411:         {
 412:             /* note that CNameList now is a list of strings */
 413:             $$ = cons((list) $1, NIL);
 414:         }
 415:     |   identifier ',' CNameList
 416:         {
 417:             /* note that NameList now is a list of strings */
 418:             $$ = cons(cons((list)$1, NIL), $3);
 419:         }
 420:     ;
 421: 
 422: ConstructedType :
 423:         '{' CorrespondenceList '}'
 424:         {
 425:             $$ = enumeration_type($2);
 426:         }
 427:     |   ARRAY NumericValue OF Type
 428:         {
 429:             $$ = array_type($2, $4);
 430:         }
 431:     |   SEQUENCE MaximumNumber OF Type
 432:         {
 433:             $$ = sequence_type($2, $4);
 434:         }
 435:     |   RECORD ArgumentList
 436:         {
 437:             $$ = record_type($2);
 438:         }
 439:     |   CHOICE DesignatorType OF '{' TypedCandidateList '}'
 440:         {
 441:             $$ = choice_type($2, $5);
 442:         }
 443:     |   CHOICE OF '{' CandidateList '}'
 444:         {
 445:             if (streamdecl > 0) {
 446:                 $$ = choice_type(StreamEnum_type, $4);
 447:             }
 448:             /* as side effect build an anonymous enumerated type */
 449:             else
 450:               $$ = choice_type((struct type *) NIL, $4);
 451:         }
 452:     |   PROCEDURE ArgumentList ResultList ErrorList
 453:         {
 454:             $$ = procedure_type($2, $3, $4);
 455:         }
 456:     |   ERROR ArgumentList
 457:         {
 458:             $$ = error_type( $2);
 459:         }
 460:     ;
 461: 
 462: ReferencedType :
 463:         identifier
 464:         {
 465:             struct object *symbol;
 466: 
 467:             if (symbol = check_def($1,CurrentProgram)) {
 468:                 if (class_of(symbol) == O_TYPE)
 469:                     $$ = symbol->o_type;
 470:                 else {
 471:                     error(ERROR,"``%s'' is not a type",
 472:                     name_of(symbol));
 473:                     YYERROR;
 474:                 }
 475:             }
 476:             else if (streq($1,currentdecl)) {
 477:                 if (strncmp(currentdecl,"StreamOf",8) == 0) {
 478:                     streamdecl++;
 479:                     error(WARNING,
 480:                         "Stream definition of ``%s'';\n\
 481: \t\t\trecursion treated as Nil record",
 482:                         $1);
 483:                     $$ = record_type(NIL);
 484:                 } else {
 485:                     /* fake it */
 486:                     $$ = enumeration_type(NIL);
 487:                     $$->type_name = make_full_name(
 488:                         CurrentProgram, CurrentVersion,
 489:                         currentdecl);
 490:                 }
 491:             }
 492:             else {
 493:                 error(ERROR,"``%s'' is unrecognized", $1);
 494:                 YYERROR;
 495:             }
 496:         }
 497:     |   identifier '.' identifier
 498:         {
 499:             struct object *symbol;
 500: 
 501:             if (check_dependency($1) &&
 502:                 (symbol = check_def($3,$1))) {
 503:                 if (class_of(symbol) == O_TYPE)
 504:                     $$ = symbol->o_type;
 505:                 else {
 506:                     error(ERROR,"``%s'' is not a type",
 507:                     name_of(symbol));
 508:                     YYERROR;
 509:                 }
 510:             }
 511:             else {
 512:                 error(ERROR,"``%s.%s'' is unrecognized",$1,$3);
 513:                 YYERROR;
 514:             }
 515:         }
 516:     ;
 517: 
 518: CorrespondenceList :
 519:         Correspondence
 520:         {
 521:             $$ = cons($1, NIL);
 522:         }
 523:     |   CorrespondenceList ',' Correspondence
 524:         {
 525:             $$ = nconc($1, cons($3, NIL));
 526:         }
 527:     ;
 528: 
 529: Correspondence :
 530:         identifier '(' NumericValue ')'
 531:         {
 532:             struct object *symbol;
 533:             char *newid;
 534: 
 535:             if (!(symbol = check_def($1,(char *)NULL))) {
 536:                 symbol = make_symbol($1,(char *)NULL);
 537:                 define_enumeration_symbol(symbol,$3);
 538:             }
 539:             else if (class_of(symbol) != O_ENUMTAG) {
 540:                 error(ERROR,"``%s'' already defined",
 541:                     name_of(symbol));
 542:                 YYERROR;
 543:                 }
 544:             else if ((streq($1,"nextSegment") &&
 545:                   stringtocard($3) == 0) ||
 546:                  (streq($1,"lastSegment") &&
 547:                   stringtocard($3) == 1)) {
 548:                 /* do nothing */
 549:                     streamdecl++;
 550:             }
 551:             else /*
 552: 			      * if (symbol->o_enum->en_value!=stringtocard($3))
 553: 			      */ {
 554:                 newid = gensym($1);
 555:                 error(WARNING,
 556:                     "Enumerator ``%s'' already declared;\n\
 557: \t\t\tusing name ``%s'' instead",
 558:                     $1,newid);
 559:                 symbol = make_symbol(newid,(char *)NULL);
 560:                 define_enumeration_symbol(symbol,$3);
 561:             }
 562:             $$ = cons((list) symbol, (list) $3);
 563:         }
 564:     ;
 565: 
 566: MaximumNumber :
 567:         NumericValue
 568:         {
 569:             $$ = $1;
 570:         }
 571:     |   /* empty */
 572:         {
 573:             $$ = "65535";       /* maximum Cardinal */
 574:         }
 575:     ;
 576: 
 577: NumericValue :
 578:         number
 579:         {
 580:             $$ = $1;
 581:         }
 582:     |   ReferencedConstant
 583:         {
 584:             if (($1)->cn_constr != C_NUMERIC) {
 585:                 error(ERROR,"Expected numeric constant");
 586:                 YYERROR;
 587:             }
 588:             $$ = ($1)->cn_value;
 589:         }
 590:     ;
 591: 
 592: DesignatorType :
 593:         ReferencedType
 594:         {
 595:             $$ = $1;
 596:         }
 597:     ;
 598: 
 599: TypedCandidateList :
 600:         TypedCandidate
 601:         {
 602:             $$ = cons($1, NIL);
 603:         }
 604:     |   TypedCandidateList ',' TypedCandidate
 605:         {
 606:             $$ = nconc($1, cons($3, NIL));
 607:         }
 608:     ;
 609: 
 610: TypedCandidate :
 611:         TypedDesignatorList _CHOOSES Type
 612:         {
 613:             $$ = cons($1, (list) $3);
 614:         }
 615:     ;
 616: 
 617: TypedDesignatorList :
 618:         TypedDesignator
 619:         {
 620:             $$ = cons($1, NIL);
 621:         }
 622:     |   TypedDesignatorList ',' TypedDesignator
 623:         {
 624:             $$ = nconc($1, cons($3, NIL));
 625:         }
 626:     ;
 627: 
 628: TypedDesignator :
 629:         identifier
 630:         {
 631:             struct object *symbol;
 632: 
 633:             if ((symbol = check_def($1,CurrentProgram)) &&
 634:                  symbol->o_constant->cn_constr == C_ENUMERATION) {
 635:                 $1 = symbol->o_constant->cn_value;
 636:                 }
 637:             if ((symbol = check_def($1,(char *)NULL)) &&
 638:                 class_of(symbol) == O_ENUMTAG)
 639:                 $$ = cons((list) symbol, NIL);
 640:             else {
 641:                 error(ERROR,"Designator ``%s'' is not of appropriate type",
 642:                     $1);
 643:                 YYERROR;
 644:             }
 645:         }
 646:     ;
 647: 
 648: CandidateList :
 649:         Candidate
 650:         {
 651:             $$ = cons($1, NIL);
 652:         }
 653:     |   CandidateList ',' Candidate
 654:         {
 655:             $$ = nconc($1, cons($3, NIL));
 656:         }
 657:     ;
 658: 
 659: Candidate :
 660:         DesignatorList _CHOOSES Type
 661:         {
 662:             $$ = cons($1, (list) $3);
 663:         }
 664:     ;
 665: 
 666: DesignatorList :
 667:         Designator
 668:         {
 669:             $$ = cons($1, NIL);
 670:         }
 671:     |   DesignatorList ',' Designator
 672:         {
 673:             $$ = nconc($1, cons($3, NIL));
 674:         }
 675:     ;
 676: 
 677: Designator :
 678:         Correspondence
 679:         {
 680:             $$ = $1;
 681:         }
 682:     ;
 683: 
 684: ResultList :
 685:         /* empty */
 686:         {
 687:             $$ = NIL;
 688:         }
 689:     |   RETURNS '[' FieldList ']'
 690:         {
 691:             $$ = $3;
 692:         }
 693:     ;
 694: 
 695: ArgumentList :
 696:         /* empty */
 697:         {
 698:             $$ = NIL;
 699:         }
 700:     |   '[' ']'
 701:         {
 702:             $$ = NIL;
 703:         }
 704:     |   '[' FieldList ']'
 705:         {
 706:             $$ = $2;
 707:         }
 708:     ;
 709: 
 710: ErrorList :
 711:         /* empty */
 712:         {
 713:             $$ = NIL;
 714:         }
 715:     |   REPORTS '[' NameList ']'
 716:         {
 717:             $$ = $3;
 718:         }
 719:     ;
 720: 
 721: FieldList :
 722:         Field
 723:         {
 724:             $$ = $1;
 725:         }
 726:     |   FieldList ',' Field
 727:         {
 728:             $$ = nconc($1, $3);
 729:         }
 730:     ;
 731: 
 732: Field :
 733:         NameList ':' Type
 734:         {
 735:             /* flatten representation for simplicity */
 736:             /* note that this could be even simpler, but I */
 737:             /* don't have the patience to change code everywhere */
 738:             list p;
 739: 
 740:             for (p = $1; p != NIL; p = cdr(p))
 741:                 car(p) = cons(cons(car(p),NIL),(list)$3);
 742:             $$ = $1;
 743:         }
 744:     ;
 745: 
 746: ReferencedConstant :
 747:         /* see ConstructedConstant for simple referenced constants */
 748:         identifier '.' identifier
 749:         {
 750:             struct object *symbol;
 751: 
 752:             if (check_dependency($1) && (symbol=check_def($3,$1))) {
 753:                 if (class_of(symbol) != O_CONSTANT) {
 754:                     error(ERROR,"Constant expected, but got ``%s''",
 755:                         name_of(symbol));
 756:                     YYERROR;
 757:                 }
 758:                 $$ = symbol->o_constant;
 759:             } else {
 760:                 error(ERROR,"Unrecognized symbol ``%s.%s''",
 761:                     $1,$3);
 762:             }
 763:         }
 764:     ;
 765: 
 766: NameList :
 767:         identifier
 768:         {
 769:             /* note that NameList now is a list of strings */
 770:             $$ = cons((list) $1, NIL);
 771:         }
 772:     |   NameList ',' identifier
 773:         {
 774:             /* note that NameList now is a list of strings */
 775:             $$ = nconc($1, cons((list) $3, NIL));
 776:         }
 777:     ;
 778: 
 779: 
 780: %%
 781: 
 782: YYSTYPE yyv[];
 783: int yynerrs;
 784: extern int yylineno;
 785: 
 786: struct parser_state {
 787:     YYSTYPE yyv[YYMAXDEPTH];
 788:     YYSTYPE yylval;
 789:     YYSTYPE yyval;
 790:     int yychar;
 791:     int yynerrs;
 792:     short yyerrflag;
 793:     int yylineno;
 794:     int recursive_flag;
 795:     char *CurrentProgram;
 796:     int CurrentVersion;
 797:     int CurrentNumber;
 798:     char yysbuf[200];    /*YYLMAX*/
 799:     char *yysptr;
 800: };
 801: extern char yysbuf[], *yysptr;
 802: 
 803: int *
 804: save_parser_state()
 805: {
 806:     struct parser_state *p;
 807: 
 808:     p = New(struct parser_state);
 809:     bcopy(yyv, p->yyv, YYMAXDEPTH*sizeof(YYSTYPE));
 810:     p->yylval = yylval;
 811:     p->yyval = yyval;
 812:     p->yychar = yychar;
 813:     p->yynerrs = yynerrs;
 814:     p->yyerrflag = yyerrflag;
 815:     p->yylineno = yylineno;
 816:     p->recursive_flag = recursive_flag;
 817:     p->CurrentProgram = CurrentProgram;
 818:     p->CurrentVersion = CurrentVersion;
 819:     p->CurrentNumber = CurrentNumber;
 820:     p->yysptr = yysptr;
 821:     bcopy(yysbuf, p->yysbuf, 200);
 822:     yysptr = yysbuf;
 823:     recursive_flag = 1;
 824:     return ((int*) p);
 825: }
 826: 
 827: restore_parser_state(p)
 828:     struct parser_state *p;
 829: {
 830:     yysptr = p->yysptr;
 831:     bcopy(p->yysbuf, yysbuf, 200);
 832:     CurrentProgram = p->CurrentProgram;
 833:     CurrentVersion = p->CurrentVersion;
 834:     CurrentNumber = p->CurrentNumber;
 835:     recursive_flag = p->recursive_flag;
 836:     yylineno = p->yylineno;
 837:     yyerrflag = p->yyerrflag;
 838:     yynerrs = p->yynerrs;
 839:     yychar = p->yychar;
 840:     yyval = p->yyval;
 841:     yylval = p->yylval;
 842:     bcopy(p->yyv, yyv, YYMAXDEPTH*sizeof(YYSTYPE));
 843:     free((char *) p);
 844: }

Defined functions

_restore_parser_state defined in line 827; used 1 times
_save_parser_state defined in line 803; used 2 times

Defined variables

_ArgumentList defined in line 72; used 3 times
_CNameList defined in line 78; used 2 times
_Candidate defined in line 72; used 2 times
_CandidateList defined in line 72; used 2 times
_Component defined in line 76; used 2 times
_ComponentList defined in line 77; used 2 times
_Correspondence defined in line 73; used 3 times
_CorrespondenceList defined in line 73; used 2 times
_Designator defined in line 73; used 2 times
_DesignatorList defined in line 74; used 2 times
_ElementList defined in line 76; used 2 times
_ErrorList defined in line 74; used 1 times
_Field defined in line 74; used 2 times
_FieldList defined in line 75; used 3 times
_MaximumNumber defined in line 81; used 1 times
_NameList defined in line 75; used 3 times
_NumericValue defined in line 81; used 3 times
_Program defined in line 85; never used
_ProgramBody defined in line 89; never used
_ProgramHeader defined in line 89; never used
_ReferencedProgram defined in line 82; used 2 times
_ReferencedProgramList defined in line 76; used 2 times
_ResultList defined in line 75; used 1 times
_TypedCandidate defined in line 77; used 2 times
_TypedCandidateList defined in line 77; used 2 times
_TypedDesignator defined in line 78; used 2 times
_TypedDesignatorList defined in line 78; used 2 times
_identifier defined in line 83; used 17 times
_number defined in line 83; used 7 times
_start defined in line 85; never used
_string defined in line 83; used 2 times
_stringvalue defined in line 80; used 1 times
  • in line 55
_type defined in line 80; used 5 times
_yynerrs defined in line 783; used 5 times

Defined struct's

parser_state defined in line 786; used 6 times
Last modified: 1986-03-13
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 3202
Valid CSS Valid XHTML 1.0 Strict