y_tab.c

编译原理实验

# line 4 "funcdraw.y"

# include "semantics.h"
extern int yylex (void) ;
extern unsigned char *yytext;
#define YYSTYPE struct ExprNode *		// ??????????????????????????????
double	Parameter=0,					// ????T??????????
		start=0, end=0,	step=0,			// ??????????????????????????????
		Origin_x=0, Origin_y=0,			// ??????????????
		Scale_x=1, 	Scale_y=1, 			// ??????????????
		Rot_angle=0;					// ????????
extern struct Token tokens;				// ????

# define CONST_ID 257
# define FUNC 258
# define FOR 259
# define FROM 260
# define DRAW 261
# define TO 262
# define STEP 263
# define ORIGIN 264
# define SCALE 265
# define ROT 266
# define IS 267
# define T 268
# define ERRTOKEN 269
# define SEMICO 270
# define COMMA 271
# define L_BRACKET 272
# define R_BRACKET 273
# define PLUS 274
# define MINUS 275
# define MUL 276
# define DIV 277
# define UNSUB 278
# define POWER 279
#ifndef YYSTYPE
#define YYSTYPE int
#endif
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
typedef int yytabelem;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256
# line 64 "funcdraw.y"

// ----------------------- ????????
void yyerror (const char *Msg) 
{	char errmsg[200];
	memset(errmsg,0,200);
	sprintf(errmsg, "Line %5d : %s--%s", LineNo, yytext);
	
	MessageBox(NULL, errmsg, Msg, MB_OK); 
}

// ----------------------- ??????????????????????
struct ExprNode * MakeExprNode(enum Token_Type opcode,...)
{	va_list ArgPtr ;
	struct ExprNode *ExprPtr = malloc(sizeof(struct ExprNode));
	ExprPtr->OpCode = opcode;
	va_start (ArgPtr,opcode) ;
	switch(opcode)
	{	case CONST_ID:
			ExprPtr->Content.CaseConst = (double)va_arg(ArgPtr, double);
			break;
		case T:
			ExprPtr->Content.CaseParmPtr = &Parameter;
			break;
		case FUNC:
			ExprPtr->Content.CaseFunc.MathFuncPtr = (FuncPtr)va_arg(ArgPtr, FuncPtr);
			ExprPtr->Content.CaseFunc.Child 
					= (struct ExprNode *) va_arg (ArgPtr,struct ExprNode *);
			break;
		default:
			ExprPtr->Content.CaseOperator.Left
					= (struct ExprNode *)va_arg (ArgPtr,struct ExprNode *);
			ExprPtr->Content.CaseOperator.Right
					= (struct ExprNode *)va_arg (ArgPtr,struct ExprNode *);
			break;
	}
	va_end(ArgPtr);
	return ExprPtr;
}yytabelem yyexca[] = {
-1, 1,
	0, -1,
	-2, 0,
	};
yytabelem yyr1 [] = {
     0,     1,     1,     2,     2,     2,     2,     3,     3,     3,
     3,     3,     3,     3,     3,     3,     3,     3,     3};
yytabelem yyr2 [] = {
     0,     0,     6,    29,    15,    15,     7,     3,     3,     7,
     7,     7,     7,     7,     7,     5,     5,     9,     3};
yytabelem yychk [] = {
 -1000,    -1,    -2,   259,   264,   265,   266,   270,   268,   267,
   267,   267,   260,   272,   272,    -3,   257,   258,   268,   269,
   272,   274,   275,    -3,    -3,    -3,   274,   275,   276,   277,
   279,   272,    -3,    -3,    -3,   262,   271,   271,    -3,    -3,
    -3,    -3,    -3,    -3,   273,    -3,    -3,    -3,   273,   263,
   273,   273,    -3,   261,   272,    -3,   271,    -3,   273};
yytabelem yydef [] = {
     1,    -2,     0,     0,     0,     0,     0,     2,     0,     0,
     0,     0,     0,     0,     0,     6,     8,     0,     7,    18,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,    15,    16,     0,     0,     0,     9,    10,
    11,    12,    13,     0,    14,     0,     0,     0,    17,     0,
     4,     5,     0,     0,     0,     0,     0,     0,     3};
# define YYNPROD 4
# define YYLAST  127
yytabelem yyact [] = {
    15,    23,    24,    25,    28,    29,    30,    30,    54,    32,
    33,    34,    31,    14,    53,    38,    39,    40,    41,    42,
    43,    13,    16,    17,    45,    46,    47,    26,    27,    28,
    29,     7,    30,    18,    19,    35,     8,    20,    52,    21,
    22,    11,    49,    55,    10,    57,     2,    26,    27,    28,
    29,     9,    30,    26,    27,    28,    29,    56,    30,    12,
    26,    27,    28,    29,    37,    30,     1,    26,    27,    28,
    29,    36,    30,     0,    26,    27,    28,    29,     0,    30,
    58,    26,    27,    28,    29,     0,    30,    51,    26,    27,
    28,    29,     0,    30,    50,    26,    27,    28,    29,     0,
    30,    48,    26,    27,    28,    29,     0,    30,    44,    26,
    27,    28,    29,     3,    30,     0,     0,     0,     4,     5,
     6,    26,    27,    28,    29,     0,    30};
yytabelem yypact [] = {
 -1000,  -146,  -239,  -232,  -216,  -223,  -226, -1000,  -201,  -251,
  -259,  -235,  -235,  -235,  -235,  -153, -1000,  -260, -1000, -1000,
  -235,  -235,  -235,  -227,  -200,  -207,  -235,  -235,  -235,  -235,
  -235,  -235,  -165,  -273,  -273,  -235,  -235,  -235,  -272,  -272,
  -273,  -273,  -273,  -172, -1000,  -221,  -179,  -186, -1000,  -235,
 -1000, -1000,  -247,  -264,  -235,  -214,  -235,  -193, -1000};
yytabelem yypgo [] = {
     0,    65,    44,   -12};
typedef struct { char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
#	define YYDEBUG	0	/* don't allow debugging */
#endif

#if YYDEBUG

yytoktype yytoks[] =

{
	{"CONST_ID",	257},
	{"FUNC",	258},
	{"FOR",	259},
	{"FROM",	260},
	{"DRAW",	261},
	{"TO",	262},
	{"STEP",	263},
	{"ORIGIN",	264},
	{"SCALE",	265},
	{"ROT",	266},
	{"IS",	267},
	{"T",	268},
	{"ERRTOKEN",	269},
	{"SEMICO",	270},
	{"COMMA",	271},
	{"L_BRACKET",	272},
	{"R_BRACKET",	273},
	{"PLUS",	274},
	{"MINUS",	275},
	{"MUL",	276},
	{"DIV",	277},
	{"UNSUB",	278},
	{"POWER",	279},
	{"-unknown-",	-1}	/* ends search */
};

char * yyreds[] =
{

	"-no such reduction-",
	"Program : /* empty */",
	"Program : Program Statement SEMICO",
	"Statement : FOR T FROM Expr TO Expr STEP Expr DRAW L_BRACKET Expr COMMA Expr R_BRACKET",
	"Statement : ORIGIN IS L_BRACKET Expr COMMA Expr R_BRACKET",
	"Statement : SCALE IS L_BRACKET Expr COMMA Expr R_BRACKET",
	"Statement : ROT IS Expr",
	"Expr : T",
	"Expr : CONST_ID",
	"Expr : Expr PLUS Expr",
	"Expr : Expr MINUS Expr",
	"Expr : Expr MUL Expr",
	"Expr : Expr DIV Expr",
	"Expr : Expr POWER Expr",
	"Expr : L_BRACKET Expr R_BRACKET",
	"Expr : PLUS Expr",
	"Expr : MINUS Expr",
	"Expr : FUNC L_BRACKET Expr R_BRACKET",
	"Expr : ERRTOKEN",
};

#endif /* YYDEBUG */
# line 1 "C:\DOCUME~1\KYLIN\桌面\YACC_D~1\YACCPAR"
/*                 XD-YACC parser skeleton file

		     Programmar: Qiang.Guo
	    Department of Computer Science,XIDIAN University.

	This parser skeleton is a reuse of SCO xenix V YACC parser.

	yaccpar.src 1.2 88/10/25
	Copyright (C) The Santa Cruz Operation, 1985.
*/

/*
** yacc user known macros and defines
*/
# include <stdio.h>
FILE *file;
#define YYINSERT(token,value) yyinsert(token,value)
#define YYGIVEUPREDUCE  { yyerrflag = 0; yystate = * yyps ; goto yynewstate;}
#define YYERROR         goto yyerrlab
#define YYEXPECT(token) yyexpect(token)
#define YYACCEPT        return(0)
#define YYABORT         return(1)
#define YYBACKUP( newtoken, newvalue )\
{\
	if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
	{\
		yyerror( "syntax error - cannot backup" );\
		goto yyerrlab;\
	}\
	yychar = newtoken;\
	yystate = *yyps;\
	yylval = newvalue;\
	goto yynewstate;\
}
#define YYRECOVERING()  (!!yyerrflag)
#ifndef YYDEBUG
#       define YYDEBUG  1       /* make debugging available */
#endif

/*
** user known globals
*/
int yydebug;                    /* set to 1 to get debugging */

/*
** driver internal defines
*/
#define YYFLAG          (-1000)

/*
** global variables used by the parser
*/
YYSTYPE yyv[ YYMAXDEPTH ];      /* value stack */
int yys[ YYMAXDEPTH ];          /* state stack */

YYSTYPE *yypv;                  /* top of value stack */
int *yyps;                      /* top of state stack */

int yystate;                    /* current state */
int yytmp;                      /* extra var (lasts between blocks) */

int yynerrs;                    /* number of errors */
int yyerrflag;                  /* error recovery flag */
int yychar;                     /* current input token number */

extern int yylex();

/*
** yyparse - return 0 if worked, 1 if syntax error not recovered from
*/
int yyparse()
{
	register YYSTYPE *yypvt;        /* top of value stack for $vars */

	/*
	** Initialize externals - yyparse may be called more than once
	*/
	if (yydebug)
	{
		file = fopen ("debug.inf","w");
		if (file == NULL)
		{
			perror ("open file");
			exit (1);
		}
	}
	yypv = &yyv[-1];
	yyps = &yys[-1];
	yystate = 0;
	yytmp = 0;
	yynerrs = 0;
	yyerrflag = 0;
	yychar = -1;

	goto yystack;
	{
		register YYSTYPE *yy_pv;        /* top of value stack */
		register int *yy_ps;            /* top of state stack */
		register int yy_state;          /* current state */
		register int  yy_n;             /* internal state number info */

		/*
		** get globals into registers.
		** branch to here only if YYBACKUP was called.
		*/
	yynewstate:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;
		goto yy_newstate;

		/*
		** get globals into registers.
		** either we just started, or we just finished a reduction
		*/
	yystack:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;

		/*
		** top of for (;;) loop while no reductions done
		*/
	yy_stack:
		/*
		** put a state and value onto the stacks
		*/
#if YYDEBUG
		/*
		** if debugging, look up token value in list of value vs.
		** name pairs.  0 and negative (-1) are special values.
		** Note: linear search is used since time is not a real
		** consideration while debugging.
		*/
		if ( yydebug )
		{
			register int yy_i;

			fprintf(file, "State %d, token ", yy_state );
			if ( yychar == 0 )
				fprintf(file, "end-of-file\n" );
			else if ( yychar < 0 )
				fprintf(file, "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				fprintf(file, "%s\n", yytoks[yy_i].t_name );
			}
		}
#endif /* YYDEBUG */
		if ( ++yy_ps >= &yys[ YYMAXDEPTH ] )    /* room on stack? */
		{
			yyerror( "yacc stack overflow" );
			YYABORT;
		}
		*yy_ps = yy_state;
		*++yy_pv = yyval;