parser.c

这是一个Linux下的集成开发环境

{   0,    0}, {   0,    0}, {   5,   23}, {   5,   10}, {   5,   11}, 
{  10,   68}, {  12,   76}, {  12,   13}, {  12,   14}, {  12,   93}, 
{  17,   32}, {   2,  108}, {   2,   19}, {   2,   20}, {   5,   16}, 
{   1,    9}, {   1,   66}, {   6,   96}, {   6,   15}, {  27,   38}, 
{  27,   74}, {   8,   26}, {   8,   12}, {  29,   39}, {   4,   22}, 
{  31,   40}, {   3,   21}, {  34,   41}, {  24,   37}, {   7,   25}, 
{  36,   42}, {  16,   69}, {  26,   71}, {  28,   94}, {  15,  100}, 
{  30,   97}, {  11,   70}, {   0,    0}, {   0,    0}, {   0,    0}, 
{   0,    0}, {   0,    0}, {   0,    0}, {   0,    0}, 
};
static	yytComb *	yyTBasePtr	[yyLastReadState + 1] = { 0,
& yyTComb [ 279], & yyTComb [ 135], & yyTComb [ 258], & yyTComb [ 251], 
& yyTComb [   0], & yyTComb [ 234], & yyTComb [ 238], & yyTComb [ 210], 
& yyTComb [   0], & yyTComb [   0], & yyTComb [   0], & yyTComb [ 276], 
& yyTComb [ 120], & yyTComb [ 105], & yyTComb [ 222], & yyTComb [   0], 
& yyTComb [ 269], & yyTComb [  45], & yyTComb [  30], & yyTComb [   0], 
& yyTComb [  15], & yyTComb [  15], & yyTComb [  26], & yyTComb [ 247], 
& yyTComb [  90], & yyTComb [ 286], & yyTComb [   0], & yyTComb [ 228], 
& yyTComb [ 283], & yyTComb [ 216], & yyTComb [ 262], & yyTComb [  15], 
& yyTComb [  60], & yyTComb [ 255], & yyTComb [  75], & yyTComb [ 242], 
& yyTComb [ 150], & yyTComb [ 273], & yyTComb [  15], & yyTComb [ 195], 
& yyTComb [ 180], & yyTComb [ 165], 
};
static	yytNComb *	yyNBasePtr	[yyLastReadState + 1] = { 0,
& yyNComb [  -2], & yyNComb [ -16], & yyNComb [   8], & yyNComb [   6], 
& yyNComb [ -16], & yyNComb [  -8], & yyNComb [   7], & yyNComb [   1], 
& yyNComb [ -16], & yyNComb [ -13], & yyNComb [   6], & yyNComb [ -16], 
& yyNComb [ -16], & yyNComb [ -16], & yyNComb [   9], & yyNComb [  13], 
& yyNComb [  -8], & yyNComb [ -16], & yyNComb [ -16], & yyNComb [ -16], 
& yyNComb [ -16], & yyNComb [ -16], & yyNComb [ -16], & yyNComb [   6], 
& yyNComb [ -16], & yyNComb [   2], & yyNComb [  -2], & yyNComb [   8], 
& yyNComb [   1], & yyNComb [  10], & yyNComb [   3], & yyNComb [ -16], 
& yyNComb [ -16], & yyNComb [   5], & yyNComb [ -16], & yyNComb [   8], 
& yyNComb [ -16], & yyNComb [ -16], & yyNComb [ -16], & yyNComb [ -16], 
& yyNComb [ -16], & yyNComb [ -16], 
};
#ifdef YYTDefault
static	unsigned short	yyTDefault	[yyLastReadState + 1] = { 0,
    8,     0,     8,     8,    17,     7,    38,     0,     0,     1, 
   26,    38,     0,     0,     6,    10,     8,     0,     0,     0, 
    0,     0,     0,     7,     0,     0,     8,     6,     7,     6, 
    7,     0,     0,     7,     0,     7,     0,     8,     0,     0, 
    0,     0, 
};
#endif
#ifdef YYNDefault
static	unsigned short	yyNDefault	[yyLastReadState + 1] = { 0,
    5,     0,     5,     5,     8,     0,    29,    27,     0,     5, 
    0,     6,     0,     0,     6,     5,     5,     0,     0,     0, 
    0,     0,     0,    29,     0,     0,    29,     6,    12,     6, 
   29,     0,     0,    29,     0,    29,     0,    12,     0,     0, 
    0,     0, 
};
#endif
#if ! defined NO_RECOVER | defined YYDEC_TABLE
static	unsigned char	yyLength	[yyLastReduceState - yyFirstReduceState
							+ 1] = {
    2,     1,     0,     2,     2,     2,     3,     1,     3,     1, 
    1,     2,     2,     1,     2,     3,     4,     1,     2,     3, 
    4,     1,     2,     3,     4,     1,     2,     3,     1,     3, 
    2,     2,     3,     2,     1,     2,     1,     1,     1,     3, 
    3,     3,     4,     2,     2,     1,     2,     3,     4,     1, 
    2,     3,     4,     1,     3,     2,     2,     3,     2,     1, 
    2,     1,     2, 
};
static	yytNonterminal	yyLeftHandSide	[yyLastReduceState - yyFirstReduceState
							+ 1] = {
yyNT0_intern,
yyNTprogram,
yyNTstatements,
yyNTstatements,
yyNTstatements,
yyNTstatement,
yyNTstatement,
yyNTwords,
yyNTwords,
yyNTword,
yyNTword,
yyNTword,
yyNTword,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTqualification,
yyNTlocal_qualification,
yyNTlocal_qualification,
yyNTlocal_qualification,
yyNTglobal_qualification,
yyNTglobal_qualification,
yyNTglobal_qualification,
yyNTfragments,
yyNTfragments,
yyNTfragment,
yyNTfragment,
yyNTfragment,
yyNTfragment,
yyNTfragment,
yyNTfragment,
yyNTfragment,
yyNTfragment,
yyNTfragment,
yyNTvariable,
yyNTvariable,
yyNTvariable,
yyNTvariable,
yyNTvariable,
yyNTvariable,
yyNTvariable,
yyNTvariable,
yyNTsimple_local_qual,
yyNTsimple_local_qual,
yyNTsimple_local_qual,
yyNTsimple_global_qual,
yyNTsimple_global_qual,
yyNTsimple_global_qual,
yyNTend,
yyNTend,
yyNTend,
yyNTend,
};
#endif
#ifndef NO_RECOVER
static	yySymbolRange	yyContinuation	[yyLastReadState + 1] = { 0,
    0,     2,     5,     7,     9,    10,    12,    14,     0,     0, 
   14,    13,     1,     1,    10,     0,     9,     2,     1,     1, 
    5,     7,     9,    12,     1,    14,     3,    10,    12,    10, 
   12,     9,     2,    12,     2,    12,     1,    13,     1,     1, 
    1,     1, 
};
static	unsigned short	yyCondition	[yyLastState - yyLastReduceState + 1] =
{ 0,
};
#endif
static	unsigned short	yyFinalToProd	[yyLastReadReduceState -
						yyFirstReadReduceState + 2] = {
   75,    77,    81,    85,    89,    92,   102,   103,   104,   105, 
  106,   107,   113,   117,   118,   119,   121,   122,   124,   125, 
  126,   127, 
0
};
static	unsigned short	yyStartLine	[yyLastStopState - yyFirstReduceState
							+ 2] = { 0,
198,
};
#ifdef YYaccDefault

static	unsigned long *	yyDefaultLook	[yyLastReadState + 1] = { 0,
};
#endif

static	int	yyParse			ARGS ((yyStateRange yyStartSymbol,
				yySymbolRange yyToken, int yyLine));

#ifndef NO_RECOVER
static	yyStateRange yyNext		ARGS ((yyStateRange yyState,
				yySymbolRange yySymbol));
static	void	yyErrorRecovery		ARGS ((yySymbolRange * yyTerminal,
				yyStateRange * yyStateStack, short yyStackPtr));
static	void	yyComputeContinuation	ARGS ((yyStateRange * yyStack,
				short yyStackPtr, tSet * yyContinueSet, rbool));
static	rbool	yyIsContinuation	ARGS ((yySymbolRange yyTerminal,
				yyStateRange * yyStateStack, short yyStackPtr,
				rbool));
static	void	yyComputeRestartPoints	ARGS ((yyStateRange * yyStateStack,
				short yyStackPtr, tSet * yyRestartSet));
#endif

#if defined YYTrialParse | defined YYReParse | defined YYGetLook

#ifndef yyInitBufferSize
#define yyInitBufferSize 100
#endif
#ifndef TOKENOP
#define TOKENOP
#endif
#ifndef BEFORE_TRIAL
#define BEFORE_TRIAL
#endif
#ifndef AFTER_TRIAL
#define AFTER_TRIAL
#endif

typedef struct { yySymbolRange	yyToken;
		 tScanAttribute	yyAttribute;
#ifdef YYMemoParse
		 short		yyStart;
#endif
	       } yytBuffer;

static yytBuffer *	yyBuffer	;
static unsigned long	yyBufferSize	= yyInitBufferSize;
static long		yyBufferNext	= 1;
static long		yyBufferLast	= 1;
static rbool		yyBufferClear	= rtrue;
static unsigned short	yyParseLevel	= 0;

static void yyBufferSet
#if defined __STDC__ | defined __cplusplus
   (yySymbolRange yyToken)
#else
   (yyToken) yySymbolRange yyToken;
#endif
{
   if (yyBufferNext == yyBufferLast) {
      if (yyBufferClear) yyBufferLast = 0;
      if (++ yyBufferLast >= (long) yyBufferSize) {
	 ExtendArray ((char * *) & yyBuffer, & yyBufferSize,
			  (unsigned long) sizeof (yytBuffer));
#ifdef YYDEBUG
	 if (Parser_Debug) {
	    yyPrintState (0);
	    (void) fprintf (yyTrace, "extend  token buffer from %ld to %ld",
		yyBufferSize / 2, yyBufferSize); yyNl ();
	 }
#endif
      }
      yyBuffer [yyBufferLast].yyToken	= yyToken;
      yyBuffer [yyBufferLast].yyAttribute= Attribute;
#ifdef YYMemoParse
      yyBuffer [yyBufferLast].yyStart	= 0;
#endif
      yyBufferNext = yyBufferLast;
   }
}

static int yyGetToken ARGS ((void))
{
   register yySymbolRange yyToken;

   if (yyBufferNext < yyBufferLast) {
      yyToken = yyBuffer [++ yyBufferNext].yyToken;
      Attribute = yyBuffer [yyBufferNext].yyAttribute;
   } else {
      yyToken = GetToken ();
      if ((yytrial | yybuffer) & yyControl.yyMode) {
	 if (++ yyBufferLast >= (long) yyBufferSize) {
	    ExtendArray ((char * *) & yyBuffer, & yyBufferSize,
			     (unsigned long) sizeof (yytBuffer));
#ifdef YYDEBUG
	    if (Parser_Debug) {
	       yyPrintState (0);
	       (void) fprintf (yyTrace, "extend  token buffer from %ld to %ld",
		  yyBufferSize / 2, yyBufferSize); yyNl ();
	    }
#endif
	 }
	 yyBuffer [yyBufferLast].yyToken = yyToken;
	 yyBuffer [yyBufferLast].yyAttribute = Attribute;
#ifdef YYMemoParse
	 yyBuffer [yyBufferLast].yyStart = 0;
#endif
	 yyBufferNext = yyBufferLast;
      }
   }
   TOKENOP
   return yyToken;
}

#else
#define yyGetToken GetToken
#endif

#ifdef YYGetLook

static int yyGetLookahead
#if defined __STDC__ | defined __cplusplus
   (int yyk, yySymbolRange yyToken)
#else
   (yyk, yyToken) int yyk; yySymbolRange yyToken;
#endif
{
   if (yyk == 0) return yyToken;
   if (yyControl.yyMode == yystandard) yyBufferSet (yyToken);
   while (yyBufferNext + yyk > yyBufferLast) {
      if (yyBuffer [yyBufferLast].yyToken == EofToken) return EofToken;
      if (++ yyBufferLast >= (long) yyBufferSize) {
	 ExtendArray ((char * *) & yyBuffer, & yyBufferSize,
			  (unsigned long) sizeof (yytBuffer));
#ifdef YYDEBUG
	 if (Parser_Debug) {
	    yyPrintState (0);
	    (void) fprintf (yyTrace, "extend  token buffer from %ld to %ld",
	       yyBufferSize / 2, yyBufferSize); yyNl ();
	 }
#endif
      }
      yyBuffer [yyBufferLast].yyToken = GetToken ();
      yyBuffer [yyBufferLast].yyAttribute = Attribute;
#ifdef YYMemoParse
      yyBuffer [yyBufferLast].yyStart = 0;
#endif
   }
   Attribute = yyBuffer [yyBufferNext].yyAttribute;
   return yyBuffer [yyBufferNext + yyk].yyToken;
}

static void xxGetAttribute
#if defined __STDC__ | defined __cplusplus
   (int yyk, yySymbolRange yyToken, tScanAttribute * yyAttribute)
#else
   (yyk, yyToken, yyAttribute)
   int yyk; yySymbolRange yyToken; tScanAttribute * yyAttribute;
#endif
{
   if (yyk == 0) * yyAttribute = Attribute;
   else {
      (void) yyGetLookahead (yyk, yyToken);
      * yyAttribute =
	 yyBuffer [Min (yyBufferNext + yyk, yyBufferLast)].yyAttribute;
   }
}

#endif

#ifdef YYReParse

#define BufferOn(Actions, Messages) yyBufferOn (Actions, Messages, yyTerminal)
#define BufferPosition	yyBufferNext

static yytControl yyPrevControl;

static long yyBufferOn
#if defined __STDC__ | defined __cplusplus
   (rbool yyActions, rbool yyMessages, yySymbolRange yyToken)
#else
   (yyActions, yyMessages, yyToken)
   rbool yyActions, yyMessages; yySymbolRange yyToken;
#endif
{
   if (yyControl.yyMode == yystandard) {
      yyPrevControl		= yyControl;
      yyControl.yyMode		= yybuffer;
      yyControl.yyActions	= yyActions;
      yyControl.yyMessages	= yyMessages;
      yyBufferSet (yyToken);
      yyBufferClear		= rfalse;
   }
   return yyBufferNext;
}

static long BufferOff ARGS ((void))
{
   if (yyControl.yyMode == yybuffer) yyControl = yyPrevControl;
   return yyBufferNext;
}

static void BufferClear ARGS ((void))
{
   yyBufferClear = rtrue;
}

#endif

#if defined YYDEBUG | defined YYDCRP

static void yyNl ARGS ((void))
{ (void) putc ('\n', yyTrace); (void) fflush (yyTrace); }

#endif

#ifdef YYDEBUG

static void yyPrintState
#if defined __STDC__ | defined __cplusplus
   (yyStateRange yyState)
#else
   (yyState) yyStateRange yyState;
#endif
{
   (void) fprintf (yyTrace, "%4ld:", ++ yyCount);
   WritePosition  (yyTrace, Attribute.Position);
   (void) fprintf (yyTrace, ":%5d  %c  ", yyState,
      " ST-B---R" [yyControl.yyMode]);
#if defined YYTrialParse | defined YYReParse
   if (yyParseLevel > 0) {
      register int yyi = yyParseLevel;
      (void) fprintf (yyTrace, "%2d  ", yyi);
      do (void) fputs ("  ", yyTrace); while (-- yyi);
   } else
#endif
   (void) fputs ("    ", yyTrace);
}

static rbool yyPrintResult
#if defined __STDC__ | defined __cplusplus
   (yyStateRange yyState, int yyLine, rbool yyCondition)
#else
   (yyState, yyLine, yyCondition)
   yyStateRange	yyState;
   int		yyLine;
   rbool	yyCondition;
#endif
{
   if (Parser_Debug) {
      yyPrintState (yyState);
      (void) fprintf (yyTrace, "check   predicate in line %d, result = %d",
	 yyLine, yyCondition); yyNl ();
   }
   return yyCondition;
}

#else