home *** CD-ROM | disk | FTP | other *** search
/ Big Green CD 8 / BGCD_8_Dev.iso / NEXTSTEP / UNIX / Programming / GDBbundle-1.0-MIS / src / TextEdit / GdbBundle.bproj / GdbValueParser.m < prev    next >
Encoding:
Text File  |  1997-05-10  |  25.5 KB  |  1,451 lines
  1. /*
  2.  * A n t l r  T r a n s l a t i o n  H e a d e r
  3.  *
  4.  * Terence Parr, Will Cohen, and Hank Dietz: 1989-1994
  5.  * Purdue University Electrical Engineering
  6.  * With AHPCRC, University of Minnesota
  7.  * ANTLR Version 1.33
  8.  */
  9. #include <stdio.h>
  10. #define ANTLR_VERSION    133
  11.  
  12. #import <Foundation/NSString.h>
  13.  
  14. #ifndef __Attrib_def__
  15. #define __Attrib_def__
  16. typedef id Attrib;
  17. #endif
  18.  
  19. #define USER_ZZSYN
  20. void zzcr_attr(Attrib* attr, int token, char* text);
  21. #define LL_K 2
  22. #define zzSET_SIZE 8
  23. #include "antlr.h"
  24. #include "tokens.h"
  25. #include "dlgdef.h"
  26. #include "mode.h"
  27. #ifndef PURIFY
  28. #define PURIFY(r,s)
  29. #endif
  30. ANTLR_INFO
  31.  
  32. #import <Foundation/NSArray.h>
  33. #import <Foundation/NSAutoreleasePool.h>
  34. #import <Foundation/NSValue.h>
  35. #import "Variable.h"
  36.  
  37. @implementation Variable (Parser)
  38.  
  39. // Class variables
  40. NSMutableString* gdbParserErrors;
  41. static const unsigned char* scannedString;
  42. static int length, position;
  43.  
  44. static int nextchar (void)
  45. {
  46.     if (position < length)
  47.     return scannedString[position++];
  48.     else
  49.     return -1;
  50. }
  51.  
  52. + (NSMutableArray*)variablesFromDescription:(NSString*)string
  53. {
  54.     id pool = [NSAutoreleasePool new];
  55.     id vars;
  56.     
  57.   gdbParserErrors = [NSMutableString new];
  58.     
  59.   scannedString = [string cString];
  60.     length = [string length];
  61.     position = 0;
  62.     ANTLRf(vars = variables(), nextchar);
  63.     
  64.   if([gdbParserErrors length]) {
  65.         NSLog (@"Errors were encountered during parsing of gdb output! Please "
  66.         @"submit this output as bug report:\nString to parse:\n%@\n\nError "
  67.         @"message:\n%@", string, gdbParserErrors);
  68.         [pool release];
  69.         return nil;
  70.     }
  71.     
  72.   [vars retain];
  73.     [pool release];
  74.     [gdbParserErrors autorelease];
  75.     [vars autorelease];
  76.     
  77. //  NSLog (@"variables = %@", vars);
  78.     return vars;
  79. }
  80.  
  81. @end
  82.  
  83. void zzcr_attr(Attrib* attr, int token, char* text)
  84. {
  85.     switch (token) {
  86.         case STRING:
  87.         case IDENTIFIER:
  88.         case FUNCTION_NAME:
  89.         case CHARACTER:
  90.         case OCTALINT:
  91.         case DECIMALINT:
  92.         case HEXADECIMALINT:
  93.         case FLOATONE:
  94.         case FLOATTWO:
  95.         case FLOATTHREE:
  96.         *attr = [NSString stringWithCString:text];
  97.         break;
  98.         default:
  99.         break;
  100.     }
  101. }
  102.  
  103. void zzsyn(char* text, int tok, char* egroup,
  104. SetWordType* eset, int etok, int k, char*bad_text)
  105. {
  106.     extern id gdbParserErrors;
  107.     
  108.   [gdbParserErrors appendFormat:
  109.     @"line %d: syntax error at \"%s\"",
  110.     zzline, (tok == zzEOF_TOKEN) ? "EOF" : bad_text];
  111.     if(!etok && !eset) {
  112.         [gdbParserErrors appendString:@"\n"];
  113.         return;
  114.     }
  115.     if (k==1)
  116.     [gdbParserErrors appendString:@" missing"];
  117.     else {
  118.         [gdbParserErrors
  119.         appendFormat:@"; \"%s\" not", bad_text];
  120.         if(zzset_deg(eset) > 1)
  121.         [gdbParserErrors appendString:@" in"];
  122.     }
  123.     if(zzset_deg(eset) > 0)
  124.     [gdbParserErrors appendString:zzedecode(eset)];
  125.     else
  126.     [gdbParserErrors appendFormat:@" %s", zztokens[etok]];
  127.     if(strlen(egroup) > 0)
  128.     [gdbParserErrors appendFormat:@" in %s", egroup];
  129.     [gdbParserErrors appendString:@"\n"];
  130. }
  131.  
  132.  id  
  133. #ifdef __STDC__
  134. variables(void)
  135. #else
  136. variables()
  137. #endif
  138. {
  139.      id       _retv;
  140.     PURIFY(_retv,sizeof( id      ))
  141.     zzRULE;
  142.     zzBLOCK(zztasp1);
  143.     zzMake0;
  144.     {
  145.     id var; _retv = [NSMutableArray array];  
  146.     {
  147.         zzBLOCK(zztasp2);
  148.         zzMake0;
  149.         {
  150.         if ( (LA(1)==NO_ARGUMENTS) ) {
  151.             zzmatch(NO_ARGUMENTS); zzCONSUME;
  152.         }
  153.         zzEXIT(zztasp2);
  154.         }
  155.     }
  156.     {
  157.         zzBLOCK(zztasp2);
  158.         zzMake0;
  159.         {
  160.         if ( (LA(1)==NO_LOCALS) ) {
  161.             zzmatch(NO_LOCALS); zzCONSUME;
  162.         }
  163.         zzEXIT(zztasp2);
  164.         }
  165.     }
  166.     {
  167.         zzBLOCK(zztasp2);
  168.         zzMake0;
  169.         {
  170.         while ( (LA(1)==NO_SYMBOL_TABLE) ) {
  171.             zzmatch(NO_SYMBOL_TABLE); zzCONSUME;
  172.             zzLOOP(zztasp2);
  173.         }
  174.         zzEXIT(zztasp2);
  175.         }
  176.     }
  177.     {
  178.         zzBLOCK(zztasp2);
  179.         zzMake0;
  180.         {
  181.         while ( (setwd1[LA(1)]&0x1) ) {
  182.              var  = variable();
  183.  
  184.             [_retv addObject:var];  
  185.             zzLOOP(zztasp2);
  186.         }
  187.         zzEXIT(zztasp2);
  188.         }
  189.     }
  190.     zzEXIT(zztasp1);
  191.     return _retv;
  192. fail:
  193.     zzEXIT(zztasp1);
  194.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  195.     zzresynch(setwd1, 0x2);
  196.     return _retv;
  197.     }
  198. }
  199.  
  200.  id  
  201. #ifdef __STDC__
  202. variable(void)
  203. #else
  204. variable()
  205. #endif
  206. {
  207.      id       _retv;
  208.     PURIFY(_retv,sizeof( id      ))
  209.     zzRULE;
  210.     Attrib name, class_id;
  211.     zzBLOCK(zztasp1);
  212.     zzMake0;
  213.     {
  214.     id value; _retv = [[Variable new] autorelease];  
  215.     {
  216.         zzBLOCK(zztasp2);
  217.         zzMake0;
  218.         {
  219.         if ( (LA(1)==IDENTIFIER)
  220.  ) {
  221.             zzmatch(IDENTIFIER);
  222.             name = zzaCur;
  223.  
  224.             [_retv setName: name];  
  225.  zzCONSUME;
  226.  
  227.         }
  228.         else {
  229.             if ( (LA(1)==CLASS) ) {
  230.                 zzmatch(CLASS);
  231.                 class_id = zzaCur;
  232.  
  233.                 [_retv setName:@"class"];  
  234.  zzCONSUME;
  235.  
  236.             }
  237.             else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  238.         }
  239.         zzEXIT(zztasp2);
  240.         }
  241.     }
  242.     zzmatch(EQUAL); zzCONSUME;
  243.      value  = typed_value();
  244.  
  245.     [_retv setValue:value];  
  246.     zzEXIT(zztasp1);
  247.     return _retv;
  248. fail:
  249.     zzEXIT(zztasp1);
  250.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  251.     zzresynch(setwd1, 0x4);
  252.     return _retv;
  253.     }
  254. }
  255.  
  256.  id  
  257. #ifdef __STDC__
  258. typed_value(void)
  259. #else
  260. typed_value()
  261. #endif
  262. {
  263.      id       _retv;
  264.     PURIFY(_retv,sizeof( id      ))
  265.     zzRULE;
  266.     zzBLOCK(zztasp1);
  267.     zzMake0;
  268.     {
  269.     id t; _retv = nil;  
  270.     zzmatch(LPARENTHESIS); zzCONSUME;
  271.      t  = type();
  272.  
  273.     zzmatch(RPARENTHESIS); zzCONSUME;
  274.      _retv  = value( t );
  275.  
  276.     [_retv setType:t];  
  277.     zzEXIT(zztasp1);
  278.     return _retv;
  279. fail:
  280.     zzEXIT(zztasp1);
  281.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  282.     zzresynch(setwd1, 0x8);
  283.     return _retv;
  284.     }
  285. }
  286.  
  287.  id  
  288. #ifdef __STDC__
  289. type(void)
  290. #else
  291. type()
  292. #endif
  293. {
  294.      id       _retv;
  295.     PURIFY(_retv,sizeof( id      ))
  296.     zzRULE;
  297.     zzBLOCK(zztasp1);
  298.     zzMake0;
  299.     {
  300.     _retv = nil;  
  301.      _retv  = ptype();
  302.  
  303.     {
  304.         zzBLOCK(zztasp2);
  305.         zzMake0;
  306.         {
  307.         if ( (LA(1)==DOUBLECOLON) ) {
  308.             zzmatch(DOUBLECOLON); zzCONSUME;
  309.             zzmatch(STAR);
  310.             [[_retv typeName] appendString:@"::* "];  
  311.  zzCONSUME;
  312.  
  313.         }
  314.         zzEXIT(zztasp2);
  315.         }
  316.     }
  317.     zzEXIT(zztasp1);
  318.     return _retv;
  319. fail:
  320.     zzEXIT(zztasp1);
  321.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  322.     zzresynch(setwd1, 0x10);
  323.     return _retv;
  324.     }
  325. }
  326.  
  327.  id  
  328. #ifdef __STDC__
  329. ptype(void)
  330. #else
  331. ptype()
  332. #endif
  333. {
  334.      id       _retv;
  335.     PURIFY(_retv,sizeof( id      ))
  336.     zzRULE;
  337.     zzBLOCK(zztasp1);
  338.     zzMake0;
  339.     {
  340.     _retv = nil;  
  341.      _retv  = typebase();
  342.  
  343.     {
  344.         zzBLOCK(zztasp2);
  345.         zzMake0;
  346.         {
  347.         if ( (setwd1[LA(1)]&0x20) ) {
  348.             {
  349.                 zzBLOCK(zztasp3);
  350.                 zzMake0;
  351.                 {
  352.                 if ( (LA(1)==CONST) ) {
  353.                     zzmatch(CONST);
  354.                     [[_retv typeName] appendString:@"const "];  
  355.  zzCONSUME;
  356.  
  357.                 }
  358.                 else {
  359.                     if ( (LA(1)==VOLATILE)
  360.  ) {
  361.                         zzmatch(VOLATILE);
  362.                         [[_retv typeName] appendString:@"volatile "];  
  363.  zzCONSUME;
  364.  
  365.                     }
  366.                 }
  367.                 zzEXIT(zztasp3);
  368.                 }
  369.             }
  370.             abs_decl( _retv );
  371.         }
  372.         zzEXIT(zztasp2);
  373.         }
  374.     }
  375.     zzEXIT(zztasp1);
  376.     return _retv;
  377. fail:
  378.     zzEXIT(zztasp1);
  379.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  380.     zzresynch(setwd1, 0x40);
  381.     return _retv;
  382.     }
  383. }
  384.  
  385. void
  386. #ifdef __STDC__
  387. abs_decl( id type )
  388. #else
  389. abs_decl(type)
  390.  id type ;
  391. #endif
  392. {
  393.     zzRULE;
  394.     zzBLOCK(zztasp1);
  395.     zzMake0;
  396.     {
  397.     if ( (setwd1[LA(1)]&0x80) ) {
  398.         {
  399.             zzBLOCK(zztasp2);
  400.             zzMake0;
  401.             {
  402.             if ( (LA(1)==STAR) ) {
  403.                 zzmatch(STAR);
  404.                 [[ type typeName] appendString:@"*"];
  405.                 [ type setTypeKind:kPointer];
  406.  zzCONSUME;
  407.  
  408.             }
  409.             else {
  410.                 if ( (LA(1)==AMPERSAND) ) {
  411.                     zzmatch(AMPERSAND);
  412.                     [[ type typeName] appendString:@"&"];
  413.                     [ type setTypeKind:kPointer];
  414.  zzCONSUME;
  415.  
  416.                 }
  417.                 else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  418.             }
  419.             zzEXIT(zztasp2);
  420.             }
  421.         }
  422.         {
  423.             zzBLOCK(zztasp2);
  424.             zzMake0;
  425.             {
  426.             if ( (setwd2[LA(1)]&0x1) ) {
  427.                 abs_decl(  type );
  428.             }
  429.             zzEXIT(zztasp2);
  430.             }
  431.         }
  432.     }
  433.     else {
  434.         if ( (setwd2[LA(1)]&0x2)
  435.  ) {
  436.             direct_abs_decl(  type );
  437.         }
  438.         else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  439.     }
  440.     zzEXIT(zztasp1);
  441.     return;
  442. fail:
  443.     zzEXIT(zztasp1);
  444.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  445.     zzresynch(setwd2, 0x4);
  446.     }
  447. }
  448.  
  449. void
  450. #ifdef __STDC__
  451. direct_abs_decl( id type )
  452. #else
  453. direct_abs_decl(type)
  454.  id type ;
  455. #endif
  456. {
  457.     zzRULE;
  458.     zzBLOCK(zztasp1);
  459.     zzMake0;
  460.     {
  461.     if ( (LA(1)==LPARENTHESIS) && (setwd2[LA(2)]&0x8) ) {
  462.         zzmatch(LPARENTHESIS);
  463.         [[ type typeName] appendString:@"("];  
  464.  zzCONSUME;
  465.  
  466.         abs_decl(  type );
  467.         zzmatch(RPARENTHESIS);
  468.         [[ type typeName] appendString:@")"];  
  469.  zzCONSUME;
  470.  
  471.         rest_of_direct_abs_decl(  type );
  472.     }
  473.     else {
  474.         if ( (LA(1)==LSQUAREBRACKET) ) {
  475.             array_mod(  type );
  476.             rest_of_direct_abs_decl(  type );
  477.         }
  478.         else {
  479.             if ( (LA(1)==LPARENTHESIS) && (setwd2[LA(2)]&0x10) ) {
  480.                 func_mod(  type );
  481.                 rest_of_direct_abs_decl(  type );
  482.             }
  483.             else {zzFAIL(2,zzerr4,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  484.         }
  485.     }
  486.     zzEXIT(zztasp1);
  487.     return;
  488. fail:
  489.     zzEXIT(zztasp1);
  490.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  491.     zzresynch(setwd2, 0x20);
  492.     }
  493. }
  494.  
  495. void
  496. #ifdef __STDC__
  497. rest_of_direct_abs_decl( id type )
  498. #else
  499. rest_of_direct_abs_decl(type)
  500.  id type ;
  501. #endif
  502. {
  503.     zzRULE;
  504.     zzBLOCK(zztasp1);
  505.     zzMake0;
  506.     {
  507.     if ( (setwd2[LA(1)]&0x40) ) {
  508.         direct_abs_decl(  type );
  509.     }
  510.     else {
  511.         if ( (setwd2[LA(1)]&0x80)
  512.  ) {
  513.         }
  514.         else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  515.     }
  516.     zzEXIT(zztasp1);
  517.     return;
  518. fail:
  519.     zzEXIT(zztasp1);
  520.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  521.     zzresynch(setwd3, 0x1);
  522.     }
  523. }
  524.  
  525. void
  526. #ifdef __STDC__
  527. array_mod( id type )
  528. #else
  529. array_mod(type)
  530.  id type ;
  531. #endif
  532. {
  533.     zzRULE;
  534.     zzBLOCK(zztasp1);
  535.     zzMake0;
  536.     {
  537.     id num;  
  538.     zzmatch(LSQUAREBRACKET);
  539.     [[ type typeName] appendString:@"["];  
  540.  zzCONSUME;
  541.  
  542.     {
  543.         zzBLOCK(zztasp2);
  544.         zzMake0;
  545.         {
  546.         if ( (setwd3[LA(1)]&0x2) ) {
  547.              num  = int_number(  type );
  548.  
  549.             [[ type typeName] appendString:[num stringValue]];  
  550.         }
  551.         zzEXIT(zztasp2);
  552.         }
  553.     }
  554.     zzmatch(RSQUAREBRACKET);
  555.     [[ type typeName] appendString:@"]"];  
  556.  zzCONSUME;
  557.  
  558.     [ type setTypeKind:kArray];  
  559.     zzEXIT(zztasp1);
  560.     return;
  561. fail:
  562.     zzEXIT(zztasp1);
  563.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  564.     zzresynch(setwd3, 0x4);
  565.     }
  566. }
  567.  
  568. void
  569. #ifdef __STDC__
  570. func_mod( id typeObj )
  571. #else
  572. func_mod(typeObj)
  573.  id typeObj ;
  574. #endif
  575. {
  576.     zzRULE;
  577.     zzBLOCK(zztasp1);
  578.     zzMake0;
  579.     {
  580.     id funcType;  
  581.     zzmatch(LPARENTHESIS); zzCONSUME;
  582.     {
  583.         zzBLOCK(zztasp2);
  584.         zzMake0;
  585.         {
  586.         if ( (setwd3[LA(1)]&0x8) ) {
  587.              funcType  = type();
  588.  
  589.             [[ typeObj typeName] appendString:[funcType typeName]];  
  590.             {
  591.                 zzBLOCK(zztasp3);
  592.                 zzMake0;
  593.                 {
  594.                 while ( (LA(1)==COMMA) ) {
  595.                     zzmatch(COMMA); zzCONSUME;
  596.                      funcType  = type();
  597.  
  598.                     [[ typeObj typeName] appendString:[funcType typeName]];  
  599.                     zzLOOP(zztasp3);
  600.                 }
  601.                 zzEXIT(zztasp3);
  602.                 }
  603.             }
  604.         }
  605.         zzEXIT(zztasp2);
  606.         }
  607.     }
  608.     zzmatch(RPARENTHESIS); zzCONSUME;
  609.     zzEXIT(zztasp1);
  610.     return;
  611. fail:
  612.     zzEXIT(zztasp1);
  613.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  614.     zzresynch(setwd3, 0x10);
  615.     }
  616. }
  617.  
  618.  id  
  619. #ifdef __STDC__
  620. typebase(void)
  621. #else
  622. typebase()
  623. #endif
  624. {
  625.      id       _retv;
  626.     PURIFY(_retv,sizeof( id      ))
  627.     zzRULE;
  628.     zzBLOCK(zztasp1);
  629.     zzMake0;
  630.     {
  631.     id string = [NSMutableString string];
  632.     id synType;
  633.     _retv = [[Type new] autorelease];
  634.     [_retv setTypeName:string];
  635.     if ( (setwd3[LA(1)]&0x20) ) {
  636.         {
  637.             zzBLOCK(zztasp2);
  638.             zzMake0;
  639.             {
  640.             if ( (LA(1)==UNSIGNED)
  641.  ) {
  642.                 zzmatch(UNSIGNED);
  643.                 [string appendString:@"unsigned "];  
  644.  zzCONSUME;
  645.  
  646.             }
  647.             zzEXIT(zztasp2);
  648.             }
  649.         }
  650.         {
  651.             zzBLOCK(zztasp2);
  652.             zzMake0;
  653.             {
  654.             if ( (LA(1)==LONG) ) {
  655.                 {
  656.                     zzBLOCK(zztasp3);
  657.                     zzMake0;
  658.                     {
  659.                     zzmatch(LONG);
  660.                     [string appendString:@"long "];
  661.                     [_retv setScalarTypeKind:kLong];
  662.  zzCONSUME;
  663.  
  664.                     {
  665.                         zzBLOCK(zztasp4);
  666.                         zzMake0;
  667.                         {
  668.                         if ( (LA(1)==UNSIGNED) ) {
  669.                             zzmatch(UNSIGNED);
  670.                             [string appendString:@"unsigned "];  
  671.  zzCONSUME;
  672.  
  673.                         }
  674.                         zzEXIT(zztasp4);
  675.                         }
  676.                     }
  677.                     {
  678.                         zzBLOCK(zztasp4);
  679.                         zzMake0;
  680.                         {
  681.                         if ( (LA(1)==INT) ) {
  682.                             zzmatch(INT);
  683.                             [string appendString:@"int "];
  684.                             [_retv setScalarTypeKind:kInt];
  685.  zzCONSUME;
  686.  
  687.                         }
  688.                         else {
  689.                             if ( (LA(1)==LONG) ) {
  690.                                 {
  691.                                     zzBLOCK(zztasp5);
  692.                                     zzMake0;
  693.                                     {
  694.                                     zzmatch(LONG);
  695.                                     [string appendString:@"long "];
  696.                                     [_retv setScalarTypeKind:kLong];
  697.  zzCONSUME;
  698.  
  699.                                     {
  700.                                         zzBLOCK(zztasp6);
  701.                                         zzMake0;
  702.                                         {
  703.                                         if ( (LA(1)==INT)
  704.  ) {
  705.                                             zzmatch(INT);
  706.                                             [string appendString:@"int "];  
  707.  zzCONSUME;
  708.  
  709.                                         }
  710.                                         zzEXIT(zztasp6);
  711.                                         }
  712.                                     }
  713.                                     zzEXIT(zztasp5);
  714.                                     }
  715.                                 }
  716.                             }
  717.                         }
  718.                         zzEXIT(zztasp4);
  719.                         }
  720.                     }
  721.                     zzEXIT(zztasp3);
  722.                     }
  723.                 }
  724.             }
  725.             else {
  726.                 if ( (LA(1)==INT) ) {
  727.                     zzmatch(INT);
  728.                     [string appendString:@"int "];
  729.                     [_retv setScalarTypeKind:kInt];
  730.  zzCONSUME;
  731.  
  732.                 }
  733.                 else {
  734.                     if ( (LA(1)==SHORT) ) {
  735.                         {
  736.                             zzBLOCK(zztasp3);
  737.                             zzMake0;
  738.                             {
  739.                             zzmatch(SHORT);
  740.                             [string appendString:@"short "];
  741.                             [_retv setScalarTypeKind:kShort];
  742.  zzCONSUME;
  743.  
  744.                             {
  745.                                 zzBLOCK(zztasp4);
  746.                                 zzMake0;
  747.                                 {
  748.                                 if ( (LA(1)==UNSIGNED) ) {
  749.                                     zzmatch(UNSIGNED);
  750.                                     [string appendString:@"unsigned "];  
  751.  zzCONSUME;
  752.  
  753.                                 }
  754.                                 zzEXIT(zztasp4);
  755.                                 }
  756.                             }
  757.                             {
  758.                                 zzBLOCK(zztasp4);
  759.                                 zzMake0;
  760.                                 {
  761.                                 if ( (LA(1)==INT) ) {
  762.                                     zzmatch(INT);
  763.                                     [string appendString:@"int "];  
  764.  zzCONSUME;
  765.  
  766.                                 }
  767.                                 zzEXIT(zztasp4);
  768.                                 }
  769.                             }
  770.                             zzEXIT(zztasp3);
  771.                             }
  772.                         }
  773.                     }
  774.                     else {
  775.                         if ( (LA(1)==CHAR)
  776.  ) {
  777.                             zzmatch(CHAR);
  778.                             [string appendString:@"char "];
  779.                             [_retv setScalarTypeKind:kChar];
  780.  zzCONSUME;
  781.  
  782.                         }
  783.                         else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  784.                     }
  785.                 }
  786.             }
  787.             zzEXIT(zztasp2);
  788.             }
  789.         }
  790.         [_retv setTypeKind:kScalar];  
  791.     }
  792.     else {
  793.         if ( (LA(1)==FLOAT) ) {
  794.             zzmatch(FLOAT);
  795.             [string appendString:@"float "];
  796.             [_retv setTypeKind:kScalar]; [_retv setScalarTypeKind:kFloat];
  797.  zzCONSUME;
  798.  
  799.         }
  800.         else {
  801.             if ( (LA(1)==DOUBLE) ) {
  802.                 zzmatch(DOUBLE);
  803.                 [string appendString:@"double "];
  804.                 [_retv setTypeKind:kScalar]; [_retv setScalarTypeKind:kDouble];
  805.  zzCONSUME;
  806.  
  807.             }
  808.             else {
  809.                 if ( (LA(1)==STRUCT) ) {
  810.                     zzmatch(STRUCT);
  811.                     [string appendString:@"struct "];  
  812.  zzCONSUME;
  813.  
  814.                     {
  815.                         zzBLOCK(zztasp2);
  816.                         zzMake0;
  817.                         {
  818.                         if ( (setwd3[LA(1)]&0x40) ) {
  819.                              synType  = identifier();
  820.  
  821.                             [string appendString:synType];  
  822.                         }
  823.                         else {
  824.                             if ( (LA(1)==LCURLYBRACE)
  825.  ) {
  826.                                 zzmatch(LCURLYBRACE);
  827.                                 [string appendString:@"{ "];  
  828.  zzCONSUME;
  829.  
  830.                                 {
  831.                                     zzBLOCK(zztasp3);
  832.                                     int zzcnt=1;
  833.                                     zzMake0;
  834.                                     {
  835.                                     do {
  836.                                          synType  = type();
  837.  
  838.                                         [string appendString:[synType typeName]];  
  839.                                          synType  = identifier();
  840.  
  841.                                         [string appendString:synType];  
  842.                                         {
  843.                                             zzBLOCK(zztasp4);
  844.                                             zzMake0;
  845.                                             {
  846.                                             if ( (LA(1)==LSQUAREBRACKET) ) {
  847.                                                 array_mod( _retv );
  848.                                             }
  849.                                             zzEXIT(zztasp4);
  850.                                             }
  851.                                         }
  852.                                         zzmatch(SEMICOLON);
  853.                                         [string appendString:@"; "];  
  854.  zzCONSUME;
  855.  
  856.                                         zzLOOP(zztasp3);
  857.                                     } while ( (setwd3[LA(1)]&0x80) );
  858.                                     zzEXIT(zztasp3);
  859.                                     }
  860.                                 }
  861.                                 zzmatch(RCURLYBRACE);
  862.                                 [string appendString:@"}"];  
  863.  zzCONSUME;
  864.  
  865.                             }
  866.                             else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  867.                         }
  868.                         zzEXIT(zztasp2);
  869.                         }
  870.                     }
  871.                     [_retv setTypeKind:kStructure];  
  872.                 }
  873.                 else {
  874.                     if ( (LA(1)==CLASS) ) {
  875.                         zzmatch(CLASS); zzCONSUME;
  876.                          synType  = identifier();
  877.  
  878.                         [string appendString:@"struct "];
  879.                         [string appendString:synType];
  880.                         [_retv setTypeKind:kClass];
  881.                     }
  882.                     else {
  883.                         if ( (LA(1)==UNION) ) {
  884.                             zzmatch(UNION);
  885.                             [string appendString:@"union "];  
  886.  zzCONSUME;
  887.  
  888.                             {
  889.                                 zzBLOCK(zztasp2);
  890.                                 zzMake0;
  891.                                 {
  892.                                 if ( (setwd4[LA(1)]&0x1)
  893.  ) {
  894.                                      synType  = identifier();
  895.  
  896.                                     [string appendString:synType];  
  897.                                 }
  898.                                 else {
  899.                                     if ( (LA(1)==LCURLYBRACE) ) {
  900.                                         zzmatch(LCURLYBRACE);
  901.                                         [string appendString:@"{ "];  
  902.  zzCONSUME;
  903.  
  904.                                         {
  905.                                             zzBLOCK(zztasp3);
  906.                                             int zzcnt=1;
  907.                                             zzMake0;
  908.                                             {
  909.                                             do {
  910.                                                  synType  = type();
  911.  
  912.                                                 [string appendString:[synType typeName]];  
  913.                                                  synType  = identifier();
  914.  
  915.                                                 [string appendString:synType];  
  916.                                                 {
  917.                                                     zzBLOCK(zztasp4);
  918.                                                     zzMake0;
  919.                                                     {
  920.                                                     if ( (LA(1)==LSQUAREBRACKET) ) {
  921.                                                         array_mod( _retv );
  922.                                                     }
  923.                                                     zzEXIT(zztasp4);
  924.                                                     }
  925.                                                 }
  926.                                                 zzmatch(SEMICOLON);
  927.                                                 [string appendString:@"; "];  
  928.  zzCONSUME;
  929.  
  930.                                                 zzLOOP(zztasp3);
  931.                                             } while ( (setwd4[LA(1)]&0x2) );
  932.                                             zzEXIT(zztasp3);
  933.                                             }
  934.                                         }
  935.                                         zzmatch(RCURLYBRACE);
  936.                                         [string appendString:@"}"];  
  937.  zzCONSUME;
  938.  
  939.                                     }
  940.                                     else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  941.                                 }
  942.                                 zzEXIT(zztasp2);
  943.                                 }
  944.                             }
  945.                             [_retv setTypeKind:kUnion];  
  946.                         }
  947.                         else {
  948.                             if ( (LA(1)==ENUM) ) {
  949.                                 zzmatch(ENUM);
  950.                                 [string appendString:@"enum "];  
  951.  zzCONSUME;
  952.  
  953.                                 {
  954.                                     zzBLOCK(zztasp2);
  955.                                     zzMake0;
  956.                                     {
  957.                                     if ( (setwd4[LA(1)]&0x4)
  958.  ) {
  959.                                          synType  = identifier();
  960.  
  961.                                         [string appendString:synType];  
  962.                                     }
  963.                                     else {
  964.                                         if ( (LA(1)==LCURLYBRACE) ) {
  965.                                             zzmatch(LCURLYBRACE);
  966.                                             [string appendString:@"{ "];  
  967.  zzCONSUME;
  968.  
  969.                                              synType  = identifier();
  970.  
  971.                                             [string appendString:synType];  
  972.                                             {
  973.                                                 zzBLOCK(zztasp3);
  974.                                                 zzMake0;
  975.                                                 {
  976.                                                 while ( (LA(1)==COMMA) ) {
  977.                                                     zzmatch(COMMA);
  978.                                                     [string appendString:@", "];  
  979.  zzCONSUME;
  980.  
  981.                                                      synType  = identifier();
  982.  
  983.                                                     [string appendString:synType];  
  984.                                                     zzLOOP(zztasp3);
  985.                                                 }
  986.                                                 zzEXIT(zztasp3);
  987.                                                 }
  988.                                             }
  989.                                             zzmatch(RCURLYBRACE);
  990.                                             [string appendString:@"}"];  
  991.  zzCONSUME;
  992.  
  993.                                         }
  994.                                         else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  995.                                     }
  996.                                     zzEXIT(zztasp2);
  997.                                     }
  998.                                 }
  999.                                 [_retv setTypeKind:kEnum];  
  1000.                             }
  1001.                             else {
  1002.                                 if ( (setwd4[LA(1)]&0x8) ) {
  1003.                                     {
  1004.                                         zzBLOCK(zztasp2);
  1005.                                         zzMake0;
  1006.                                         {
  1007.                                         if ( (LA(1)==CONST) ) {
  1008.                                             zzmatch(CONST);
  1009.                                             [string appendString:@"const "];  
  1010.  zzCONSUME;
  1011.  
  1012.                                         }
  1013.                                         else {
  1014.                                             if ( (LA(1)==VOLATILE)
  1015.  ) {
  1016.                                                 zzmatch(VOLATILE);
  1017.                                                 [string appendString:@"volatile "];  
  1018.  zzCONSUME;
  1019.  
  1020.                                             }
  1021.                                             else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1022.                                         }
  1023.                                         zzEXIT(zztasp2);
  1024.                                         }
  1025.                                     }
  1026.                                      synType  = typebase();
  1027.  
  1028.                                     [string appendString:[synType typeName]];
  1029.                                     [synType setTypeName:string];
  1030.                                     _retv = synType;
  1031.                                 }
  1032.                                 else {
  1033.                                     if ( (LA(1)==VOID) ) {
  1034.                                         zzmatch(VOID);
  1035.                                         [string appendString:@"void "]; [_retv setTypeKind:kVoid];  
  1036.  zzCONSUME;
  1037.  
  1038.                                     }
  1039.                                     else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1040.                                 }
  1041.                             }
  1042.                         }
  1043.                     }
  1044.                 }
  1045.             }
  1046.         }
  1047.     }
  1048.     zzEXIT(zztasp1);
  1049.     return _retv;
  1050. fail:
  1051.     zzEXIT(zztasp1);
  1052.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1053.     zzresynch(setwd4, 0x10);
  1054.     return _retv;
  1055.     }
  1056. }
  1057.  
  1058.  id  
  1059. #ifdef __STDC__
  1060. value( id type )
  1061. #else
  1062. value(type)
  1063.  id type ;
  1064. #endif
  1065. {
  1066.      id       _retv;
  1067.     PURIFY(_retv,sizeof( id      ))
  1068.     zzRULE;
  1069.     zzBLOCK(zztasp1);
  1070.     zzMake0;
  1071.     {
  1072.     id num, string, synType; _retv = nil;  
  1073.     if ( (setwd4[LA(1)]&0x20) ) {
  1074.          num  = number(  type );
  1075.  
  1076.         _retv = num;  
  1077.         {
  1078.             zzBLOCK(zztasp2);
  1079.             zzMake0;
  1080.             {
  1081.             if ( (setwd4[LA(1)]&0x40) ) {
  1082.                  string  = descriptive_value();
  1083.  
  1084.                 [_retv setDescription:string];  
  1085.             }
  1086.             zzEXIT(zztasp2);
  1087.             }
  1088.         }
  1089.     }
  1090.     else {
  1091.         if ( (setwd4[LA(1)]&0x80) ) {
  1092.              synType  = identifier();
  1093.  
  1094.             _retv = [[[ type valueClass] new] autorelease];
  1095.             [_retv setStringValue:synType];
  1096.         }
  1097.         else {
  1098.             if ( (LA(1)==LCURLYBRACE)
  1099.  ) {
  1100.                 NSMutableArray* array = [NSMutableArray array];
  1101.                 _retv = [[[ type valueClass] new] autorelease];
  1102.                 compound_value( array );
  1103.                 [_retv setArrayValue:array];  
  1104.             }
  1105.             else {zzFAIL(1,zzerr13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1106.         }
  1107.     }
  1108.     zzEXIT(zztasp1);
  1109.     return _retv;
  1110. fail:
  1111.     zzEXIT(zztasp1);
  1112.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1113.     zzresynch(setwd5, 0x1);
  1114.     return _retv;
  1115.     }
  1116. }
  1117.  
  1118.  id  
  1119. #ifdef __STDC__
  1120. descriptive_value(void)
  1121. #else
  1122. descriptive_value()
  1123. #endif
  1124. {
  1125.      id       _retv;
  1126.     PURIFY(_retv,sizeof( id      ))
  1127.     zzRULE;
  1128.     Attrib d1, d2, d3;
  1129.     zzBLOCK(zztasp1);
  1130.     zzMake0;
  1131.     {
  1132.     _retv = nil;  
  1133.     if ( (LA(1)==CHARACTER) ) {
  1134.         zzmatch(CHARACTER);
  1135.         d1 = zzaCur;
  1136.  
  1137.         _retv =  d1;  
  1138.  zzCONSUME;
  1139.  
  1140.     }
  1141.     else {
  1142.         if ( (LA(1)==STRING) ) {
  1143.             zzmatch(STRING);
  1144.             d2 = zzaCur;
  1145.  
  1146.             _retv =  d2;  
  1147.  zzCONSUME;
  1148.  
  1149.         }
  1150.         else {
  1151.             if ( (LA(1)==FUNCTION_NAME) ) {
  1152.                 zzmatch(FUNCTION_NAME);
  1153.                 d3 = zzaCur;
  1154.  
  1155.                 _retv =  d3;  
  1156.  zzCONSUME;
  1157.  
  1158.             }
  1159.             else {zzFAIL(1,zzerr14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1160.         }
  1161.     }
  1162.     zzEXIT(zztasp1);
  1163.     return _retv;
  1164. fail:
  1165.     zzEXIT(zztasp1);
  1166.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1167.     zzresynch(setwd5, 0x2);
  1168.     return _retv;
  1169.     }
  1170. }
  1171.  
  1172.  id  
  1173. #ifdef __STDC__
  1174. number( id type )
  1175. #else
  1176. number(type)
  1177.  id type ;
  1178. #endif
  1179. {
  1180.      id       _retv;
  1181.     PURIFY(_retv,sizeof( id      ))
  1182.     zzRULE;
  1183.     Attrib n1, n2, n3, n4;
  1184.     zzBLOCK(zztasp1);
  1185.     zzMake0;
  1186.     {
  1187.     _retv = nil;  
  1188.     if ( (LA(1)==FLOATONE) ) {
  1189.         zzmatch(FLOATONE);
  1190.         n1 = zzaCur;
  1191.  
  1192.         _retv = [SimpleValue numberWithString: n1];  
  1193.  zzCONSUME;
  1194.  
  1195.     }
  1196.     else {
  1197.         if ( (LA(1)==FLOATTWO)
  1198.  ) {
  1199.             zzmatch(FLOATTWO);
  1200.             n2 = zzaCur;
  1201.  
  1202.             _retv = [SimpleValue numberWithString: n2];  
  1203.  zzCONSUME;
  1204.  
  1205.         }
  1206.         else {
  1207.             if ( (LA(1)==FLOATTHREE) ) {
  1208.                 zzmatch(FLOATTHREE);
  1209.                 n3 = zzaCur;
  1210.  
  1211.                 _retv = [SimpleValue numberWithString: n3];  
  1212.  zzCONSUME;
  1213.  
  1214.             }
  1215.             else {
  1216.                 if ( (LA(1)==STRING) ) {
  1217.                     zzmatch(STRING);
  1218.                     n4 = zzaCur;
  1219.  
  1220.                     _retv = [SimpleValue numberWithString: n4];  
  1221.  zzCONSUME;
  1222.  
  1223.                 }
  1224.                 else {
  1225.                     if ( (setwd5[LA(1)]&0x4) ) {
  1226.                          _retv  = int_number(  type );
  1227.  
  1228.                     }
  1229.                     else {zzFAIL(1,zzerr15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1230.                 }
  1231.             }
  1232.         }
  1233.     }
  1234.     zzEXIT(zztasp1);
  1235.     return _retv;
  1236. fail:
  1237.     zzEXIT(zztasp1);
  1238.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1239.     zzresynch(setwd5, 0x8);
  1240.     return _retv;
  1241.     }
  1242. }
  1243.  
  1244.  id  
  1245. #ifdef __STDC__
  1246. int_number( id type )
  1247. #else
  1248. int_number(type)
  1249.  id type ;
  1250. #endif
  1251. {
  1252.      id       _retv;
  1253.     PURIFY(_retv,sizeof( id      ))
  1254.     zzRULE;
  1255.     Attrib n1, n2, n3;
  1256.     zzBLOCK(zztasp1);
  1257.     zzMake0;
  1258.     {
  1259.     id numberString; _retv = nil;  
  1260.     {
  1261.         zzBLOCK(zztasp2);
  1262.         zzMake0;
  1263.         {
  1264.         if ( (LA(1)==OCTALINT) ) {
  1265.             zzmatch(OCTALINT);
  1266.             n1 = zzaCur;
  1267.  
  1268.             numberString =  n1;  
  1269.  zzCONSUME;
  1270.  
  1271.         }
  1272.         else {
  1273.             if ( (LA(1)==DECIMALINT)
  1274.  ) {
  1275.                 zzmatch(DECIMALINT);
  1276.                 n2 = zzaCur;
  1277.  
  1278.                 numberString =  n2;  
  1279.  zzCONSUME;
  1280.  
  1281.             }
  1282.             else {
  1283.                 if ( (LA(1)==HEXADECIMALINT) ) {
  1284.                     zzmatch(HEXADECIMALINT);
  1285.                     n3 = zzaCur;
  1286.  
  1287.                     numberString =  n3;  
  1288.  zzCONSUME;
  1289.  
  1290.                 }
  1291.                 else {zzFAIL(1,zzerr16,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1292.             }
  1293.         }
  1294.         zzEXIT(zztasp2);
  1295.         }
  1296.     }
  1297.     if ([type typeKind] == kPointer)
  1298.     _retv = [PointerValue pointerWithAddress:numberString];
  1299.     else
  1300.     _retv = [SimpleValue numberWithString:numberString];
  1301.     zzEXIT(zztasp1);
  1302.     return _retv;
  1303. fail:
  1304.     zzEXIT(zztasp1);
  1305.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1306.     zzresynch(setwd5, 0x10);
  1307.     return _retv;
  1308.     }
  1309. }
  1310.  
  1311. void
  1312. #ifdef __STDC__
  1313. compound_value( id components )
  1314. #else
  1315. compound_value(components)
  1316.  id components ;
  1317. #endif
  1318. {
  1319.     zzRULE;
  1320.     zzBLOCK(zztasp1);
  1321.     zzMake0;
  1322.     {
  1323.     id val;  
  1324.     zzmatch(LCURLYBRACE); zzCONSUME;
  1325.     {
  1326.         zzBLOCK(zztasp2);
  1327.         zzMake0;
  1328.         {
  1329.         if ( (setwd5[LA(1)]&0x20) ) {
  1330.             {
  1331.                 zzBLOCK(zztasp3);
  1332.                 zzMake0;
  1333.                 {
  1334.                  val  = variable_or_typed_value();
  1335.  
  1336.                 [ components addObject:val];  
  1337.                 {
  1338.                     zzBLOCK(zztasp4);
  1339.                     zzMake0;
  1340.                     {
  1341.                     while ( (LA(1)==COMMA) ) {
  1342.                         zzmatch(COMMA); zzCONSUME;
  1343.                          val  = variable_or_typed_value();
  1344.  
  1345.                         [ components addObject:val];  
  1346.                         zzLOOP(zztasp4);
  1347.                     }
  1348.                     zzEXIT(zztasp4);
  1349.                     }
  1350.                 }
  1351.                 zzEXIT(zztasp3);
  1352.                 }
  1353.             }
  1354.         }
  1355.         else {
  1356.             if ( (LA(1)==DOTS) ) {
  1357.                 zzmatch(DOTS); zzCONSUME;
  1358.             }
  1359.         }
  1360.         zzEXIT(zztasp2);
  1361.         }
  1362.     }
  1363.     zzmatch(RCURLYBRACE); zzCONSUME;
  1364.     zzEXIT(zztasp1);
  1365.     return;
  1366. fail:
  1367.     zzEXIT(zztasp1);
  1368.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1369.     zzresynch(setwd5, 0x40);
  1370.     }
  1371. }
  1372.  
  1373.  id  
  1374. #ifdef __STDC__
  1375. variable_or_typed_value(void)
  1376. #else
  1377. variable_or_typed_value()
  1378. #endif
  1379. {
  1380.      id       _retv;
  1381.     PURIFY(_retv,sizeof( id      ))
  1382.     zzRULE;
  1383.     zzBLOCK(zztasp1);
  1384.     zzMake0;
  1385.     {
  1386.     _retv = nil;  
  1387.     if ( (setwd5[LA(1)]&0x80)
  1388.  ) {
  1389.          _retv  = variable();
  1390.  
  1391.     }
  1392.     else {
  1393.         if ( (LA(1)==LPARENTHESIS) ) {
  1394.              _retv  = typed_value();
  1395.  
  1396.         }
  1397.         else {zzFAIL(1,zzerr17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1398.     }
  1399.     zzEXIT(zztasp1);
  1400.     return _retv;
  1401. fail:
  1402.     zzEXIT(zztasp1);
  1403.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1404.     zzresynch(setwd6, 0x1);
  1405.     return _retv;
  1406.     }
  1407. }
  1408.  
  1409.  id  
  1410. #ifdef __STDC__
  1411. identifier(void)
  1412. #else
  1413. identifier()
  1414. #endif
  1415. {
  1416.      id       _retv;
  1417.     PURIFY(_retv,sizeof( id      ))
  1418.     zzRULE;
  1419.     Attrib name1, name2;
  1420.     zzBLOCK(zztasp1);
  1421.     zzMake0;
  1422.     {
  1423.     if ( (LA(1)==IDENTIFIER) ) {
  1424.         zzmatch(IDENTIFIER);
  1425.         name1 = zzaCur;
  1426.  
  1427.         _retv= name1;  
  1428.  zzCONSUME;
  1429.  
  1430.     }
  1431.     else {
  1432.         if ( (LA(1)==CLASS) ) {
  1433.             zzmatch(CLASS);
  1434.             name2 = zzaCur;
  1435.  
  1436.             _retv= name2;  
  1437.  zzCONSUME;
  1438.  
  1439.         }
  1440.         else {zzFAIL(1,zzerr18,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1441.     }
  1442.     zzEXIT(zztasp1);
  1443.     return _retv;
  1444. fail:
  1445.     zzEXIT(zztasp1);
  1446.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1447.     zzresynch(setwd6, 0x2);
  1448.     return _retv;
  1449.     }
  1450. }
  1451.