编译原理实现一个简单的计算器程序

《编译原理》实验报告

专业：

学号：

班级：

姓名：

实验题目：设计，实现一个简单的计算器程序实验时间：

指导教师：实验成绩：

1实验目的

1.1实现一个简单计算器

2实验要求

2.1单词的构词规则有明确的定义；

2.2编写的分析程序能够正确识别源程序中的语法符号；

2.3计算器源程序的以.c格式输出

2.4对于源程序中的词法错误，能够做出简单的错误处理，给出简单的错误

提示，保证顺利完成整个源程序的词法分析，语法分析；

2.5计算器能够实现加，减，乘，除，混合运算，多项式运算。

3实验环境

3.1Windows XP

3.2Flex词法分析工具

3.3Visual Studio C++ 6.0

4实验原理

4.1多项式计算器的实现，采用后缀表达式来对输入的计算表达式进行计算

4.2对后缀表达式进行符号识别，词法分析，语法分析

4.3编写计算器的源程序，使用Flex工具生成计算器的C语言程序

4.4对生成的程序进行相应的修改，再进行编译，连接，运行，测试得到可以用于进行

多项式运算的源程序。

5软件设计与编程

5.1程序源代码：

5.2新建文件夹

5.3将Flex工具复制到该文件夹下

5.4在DOS环境学生成目标源程序

5.5在Visual Studio C++

6.0环境下进行相应的修改，添加main方法和打开文件的方

法

6程序测试结果

6.1编写源代码

6.2使用Flex生成C代码：

6.3 在V isual Studio C++6.0上运行生成的”.c”文件

文件：y.ta.h

#ifndef YYTOKENT YPE

# define YYT OKENT YPE

enum yytokentype {

CLEAR = 258,

EXIT = 259,

LIST = 260,

ERASE = 261,

DEC = 262,

HEX = 263,

OCT = 264,

HELP = 265,

NUM = 266,

REG = 267,

ADD = 268,

SUB = 269,

MUL = 270,

DIV = 271,

MOD = 272,

LSHIFT = 273,

RSHIFT = 274,

AND = 275,

OR = 276,

NOT = 277,

LESS = 278,

MORE = 279,

BIT AND = 280,

BITOR = 281,

BITXOR = 282,

BITREV = 283,

SIN = 284,

COS = 285,

T AN = 286,

ABS = 287,

SQRT = 288,

LOG = 289,

RMINUS = 290

};

//前面定义过，此处省略宏定义

#if ! defined (YYST YPE) && ! defined

(YYSTYPE_IS_DECLARED) typedef int YYST YPE;

# define yystype YYSTYPE /* obsolescent; will be withdrawn */

# define YYSTYPE_IS_DECLARED 1

# define YYSTYPE_IS_TRIVIAL 1 #endif

extern YYST YPE yylval;

文件：calc.l 核心程序

%{

#define YYSTYPE double

#define BIGINT long

#include

#include "y.tab.h"

%}

digit [0-9]

xdigit [0-9a-fA-F]

odigit [0-7]

decnum

(0(\.{digit}+)?)|([1-9]{digit} *(\.{digit}+)?)

octnum0{odigit}+

hexnum 0(x|X){xdigit}+ reg [a-zA-Z]

opt1

"+"|"-"|"*"|"/"|"&"|"|"|" %"|"^"|"~"|"!"|"<"|">"

opt2

(&&)|(\|\|)|(\<\<)|(\>\>)

exit

((E|e)(X|x)(I|i)(T|t))|((Q|q)( U|u)(I|i)(T|t))

clear

(C|c)(L|l)(E|e)(A|a)(R|r) list (L|l)(I|i)(S|s)(T|t) erase

(E|e)(R|r)(A|a)(S|s)(E|e)

hex (H|h)(E|e)(X|x)

oct (O|o)(C|c)(T|t)

dec (D|d)(E|e)(C|c) help (H|h)(E|e)(L|l)(P|p) sin

(S|s)(I|i)(N|n) cos

(C|c)(O|o)(S|s)

log

(L|l)(O|o)(G|g)

tan

(T|t)(A|a)(N|n)

abs

(A|a)(B|b)(S|s)

sqrt

(S|s)(Q|q)(R|r)(T|t)

%%

int i ;

BIGINT val;

[" "; \t]{ }

{decnum}

{sscanf(yytext,"%lf",&yyl

val);return(NUM); }

{octnum} {

i=1;v al=0;

while(i

{

val=(val<<3)+yytext[i]-'0';

i++;

}

yylval=val;

return(NUM);

}

{hexnum} {

i=2;v al=0;

while(i

{

if(islower(yytext[i]))

val=(val<<4)+yytext[i]-'a'+10;

else

if(isupper(yytext[i]))

val=(val<<4)+yytext[i]-'A'+10;

else

val=(val<<4)+yytext[i]-'0';

i++;

}

yylval=val;

return(NUM);

}

{reg} {

if(islower(yytext[0]))yylval

=yytext[0]-'a';

else

yylval=yytext[0]-'A';

return(REG);

}

{opt1} {

switch(yytext[0])

{

case

'+':

return ADD;

break;

case

'-':

return SUB;

break;

case

'*':

return MUL;

break;

case

'/':

return DIV;

break;

case

'%':

return MOD;

break;

case

'^':

return BITXOR;

break;

case

'&':

return BITAND;

break;

case

'|':

return BITOR;

break;

case

'<':

return LESS;

break;

case

'>':

return MORE;

break;

case

'!':

return NOT;

break;

case

'~':

return BITREV;

break;

}

}

{opt2} {

switch(yytext[0])

{

case

'&':

return AND;

break;

case

'|':

return OR;

break;

case

'<':

return LSHIFT;

break;

case

'>':

return RSHIFT;

break;

}

}

{sin} {return (SIN);}

{cos} {return (COS);}

{tan} {return (TAN);}

{log} {return (LOG);}

{abs} {return (ABS);}

{sqrt} {return (SQRT);}

{clear} {return(CLEAR);}

{exit} {return(EXIT);}

{list} {return(LIST);}

{erase} {return(ERASE);}

{hex} {return(HEX);}

{oct} {return(OCT);}

{dec} {return(DEC);}

{help} {return(HELP);}

.|\n {return(yytex t[0]);}

文件：y.tab.c

部分代码：

#define YYBISON 1

/* Skeleton name. */

#define YYSKELETON_NAME

"yacc.c"

/* Pure parsers. */

#define YYPURE 0

/* Using locations. */

#define YYLSP_NEEDED 0

/* T okens. */

#ifndef YYTOKENT YPE

# define YYT OKENT YPE

/* Put the tokens into the symbol

table, so that GDB and other

debuggers

know about them. */

enum yytokentype {

前面定义过，此处省略

};

/* Copy the first part of user

declarations. */

#line 1 "calc.y"

//前面定义过，此处省略宏定义

#include

#include

#include

#include

#include "lex.yy.c" //这是词法分

析器生成的文件，必须包含！

YYSTYPE reg[26]={0};

BIGINT ival;

enum Display{DEC_ON, HEX_ON,

OCT_ON};

enum Display dflag=DEC_ON;

int i;

/* Enabling traces. */

#ifndef YYDEBUG

# define YYDEBUG 0

#endif

/* Enabling verbose error messages.

*/

#ifdef YYERROR_VERBOSE

# undef YYERROR_V ERBOSE

# define YYERROR_V ERBOSE 1

#else

# define YYERROR_V ERBOSE 0

#endif

#if ! defined (YYST YPE) && !

defined

(YYSTYPE_IS_DECLARED)

typedef int YYST YPE;

# define yystype YYSTYPE /*

obsolescent; will be withdrawn */

# define

YYSTYPE_IS_DECLARED 1

# define YYSTYPE_IS_TRIVIAL 1

#endif

/* Copy the second part of user

declarations. */

/* Line 214 of yacc.c. */

#line 173 "y.tab.c"

#if ! defined (yyoverflow) ||

YYERROR_V ERBOSE

/* The parser invokes alloca or

malloc; define the necessary

symbols. */

# if YYST ACK_USE_ALLOCA

# define YYST ACK_ALLOC

alloca

# else

# ifndef

YYST ACK_USE_ALLOCA

# if defined (alloca) || defined (_ALLOCA_H)

# define YYST ACK_ALLOC alloca

# else

# ifdef __GNUC__

# define YYST ACK_ALLOC __builtin_alloca

# endif

# endif

# endif

# endif

# ifdef YYST ACK_ALLOC

/* Pacify GCC's `empty if-body' warning. */

# define YYST ACK_FREE(Ptr) do { /* empty */; } while (0)

# else

# if defined (__STDC__) || defined (__cplusplus)

# include /* INFRINGES ON USER NAME SPACE */

# define YYSIZE_T size_t

# endif

# define YYST ACK_ALLOC malloc

# define YYST ACK_FREE free # endif

#endif /* ! defined (yyoverflow) || YYERROR_V ERBOSE */

#if (! defined (yyoverflow) \

&& (! defined (__cplusplus) \

||

(YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member. */

union yyalloc

{

short yyss;

YYSTYPE yyvs;

};

/* T he size of the maximum gap between one aligned stack and the next. */

# define YYST ACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with N elements. */

# define YYST ACK_BYT ES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE))

\

+

YYST ACK_GAP_MAXIMUM)

/* Copy COUNT objects from FROM to T O. T he source and destination do

not overlap. */

# ifndef YYCOPY

# if 1 < __GNUC__

# define YYCOPY(T o, From, Count) \

__builtin_memcpy (T o, From, (Count) * sizeof (*(From))) # else

# define YYCOPY(T o, From, Count) \

do

\

{

\

register YYSIZ E_T yyi;

\

for (yyi = 0; yyi < (Count); yyi++) \

(T o)[yyi] = (From)[yyi];

\

}

\

while (0)

# endif

# endif /* Relocate ST ACK from its old

location to the new one. The

local variables YYSIZE and

YYST ACKSIZE give the old and

new number of

elements in the stack, and

YYPT R gives the new location of

the

stack. Advance YYPTR to a

properly aligned location for the

next

stack. */

# define

YYST ACK_RELOCATE(Stack)

\

do

{

\

YYSIZE_T yynewbytes;

YYCOPY (&yyptr->Stack,

Stack, yysize);

Stack = &yyptr->Stack;

\

yynewbytes = yystacksize *

sizeof (*Stack) +

YYST ACK_GAP_MAXIMUM; \

yyptr += yynewbytes /

sizeof (*yyptr);

\

}

\

while (0)

#endif

#if defined (__ST DC__) || defined

(__cplusplus)

typedef signed char

yysigned_char;

#else

typedef short yysigned_char;

#endif

/* YYFINAL -- State number of the

termination state. */

#define YYFINAL 2

/* YYLAST -- Last index in

YYT ABLE. */

#define YYLAST 188

/* YYNTOKENS -- Number of

terminals. */

#define YYNT OKENS 40

/* YYNNTS -- Number of

nonterminals. */

#define YYNNTS 5

/* YYNRULES -- Number of rules.

*/

#define YYNRULES 42

/* YYNRULES -- Number of states.

*/

#define YYNST ATES 73

/* YYTRANSLATE(YYLEX) --

Bison symbol number

corresponding to YYLEX. */

#define YYUNDEFTOK 2

#define YYMAXUT OK 290

#define YYTRANSLAT E(YYX)

\

((unsigned int) (YYX) <=

YYMAXUT OK ?

yytranslate[YYX] :

YYUNDEFTOK)

/* YYTRANSLATE[YYLEX] --

Bison symbol number

corresponding to YYLEX. */

static const unsigned char

yytranslate[] =

{

省略数据信息

};

/* YYRHS -- A `-1'-separated list of

the rules' RHS. */

static const yysigned_char yyrhs[] =

{

省略数据信息

};

/* YYRLINE[YYN] -- source line

where rule number YYN was

defined. */

static const unsigned char yyrline[]

=

{省略数据信息

};

#endif

#if YYDEBUG ||

YYERROR_V ERBOSE

/* YYT NME[SYMBOL-NUM] --

String name of the symbol

SYMBOL-NUM.

First, the terminals, then,

starting at YYNT OKENS,

nonterminals. */

static const char *const yytname[] =

{

"$end", "error", "$undefined",

"CLEAR", "EXIT", "LIST",

"ERASE", "DEC",

"HEX", "OCT", "HELP", "NUM",

"REG", "ADD", "SUB", "MUL",

"DIV", "MOD",

"LSHIFT", "RSHIFT", "AND",

"OR", "NOT", "LESS", "MORE",

"BIT AND",

"BITOR", "BITXOR",

"BITREV", "SIN", "COS", "T AN",

"ABS", "SQRT", "LOG",

"RMINUS", "'\\n'", "'='", "'('", "')'",

"$accept", "lines", "statement",

"expr", "cmdline", 0

};

#endif

# ifdef YYPRINT

/* YYT OKNUM[YYLEX-NUM] --

Internal token number

corresponding to

token YYLEX-NUM. */

static const unsigned short

yytoknum[] =

{

省略数据信息

};

# endif

/* YYR1[YYN] -- Symbol number

of symbol that rule YYN derives.

*/

static const unsigned char yyr1[] =

{

省略数据信息

};

/* YYDEF ACT[ST ATE-NAME] --

Default rule to reduce with in state

ST ATE-NUM when YYT ABLE

doesn't specify something else to do.

Zero

means the default is an error.

*/

static const unsigned char yydefact[]

=

{ 省略数据信息

};

/* YYDEFGOT O[NT ERM-NUM].

*/

static const yysigned_char

yydefgoto[] =

{省略数据};

/* YYPACT[ST AT E-NUM] -- Index

in YYT ABLE of the portion

describing

ST ATE-NUM. */

#define YYPACT_NINF -28

static const short yypact[] =

{

省略数据信息

};

/* YYPGOTO[NTERM-NUM]. */

static const yysigned_char yypgoto[]

=

{省略数据信息

};

/*

YYT ABLE[YYPACT[ST ATE-NU

M]]. What to do in state

ST ATE-NUM. If

positive, shift that token. If

negative, reduce the rule which

number is the opposite. If zero,

do what YYDEF ACT says.

If YYT ABLE_NINF, syntax

error. */

#define YYT ABLE_NINF -1

static const unsigned char yytable[]

=

{

省略数据信息

};

#if ! defined (YYSIZ E_T) &&

defined (__SIZE_TYPE__)

# define YYSIZ E_T

__SIZE_TYPE__

#endif

#if ! defined (YYSIZ E_T) &&

defined (size_t)

# define YYSIZE_T size_t

#endif

#if ! defined (YYSIZE_T)

# if defined (__STDC__) || defined

(__cplusplus)

# include /*

INFRINGES ON USER NAME

SPACE */

# define YYSIZ E_T size_t

# endif

#endif

#if ! defined (YYSIZE_T)

# define YYSIZE_T unsigned int

#endif

#define yyerrok (yyerrstatus

= 0)

#define yyclearin (yychar =

YYEMPT Y)

#define YYEMPTY (-2)

#define YYEOF 0

#define YYACCEPT goto

yyacceptlab

#define YYABORT goto

yyabortlab

#define YYERROR goto

yyerrlab1

/* Like YYERROR except do call

yyerror. T his remains here

temporarily

to ease the transition to the new

meaning of YYERROR, for GCC.

Once GCC version 2 has

supplanted version 1, this can go.

*/

#define YYFAIL goto

yyerrlab

#define YYRECOVERING()

(!!yyerrstatus)

#define YYBACKUP(T oken, V alue)

\

do

\

if (yychar == YYEMPT Y &&

yylen == 1)

\

{

\

yychar = (T oken);

\

yylval = (V alue);

\

yytoken = YYTRANSLATE

(yychar);

\

YYPOPST ACK;

\

goto yybackup;

\ }

\ else \

{ \

yyerror ("syntax error: cannot back up");\

YYERROR;

}

\ while (0)

#define YYTERROR 1

#define YYERRCODE 256

/* YYLLOC_DEF AULT -- Compute the default location (before the actions

are run). */

#ifndef YYLLOC_DEF AULT

# define YYLLOC_DEF AULT(Current, Rhs, N) \

Current.first_line = Rhs[1].first_line; \ Current.first_column = Rhs[1].first_column; \ https://www.360docs.net/doc/a013439927.html,st_line = Rhs[N].last_line; \ https://www.360docs.net/doc/a013439927.html,st_column = Rhs[N].last_column;

#endif

/* YYLEX -- calling `yylex' with the right arguments. */

#ifdef YYLEX_PARAM

# define YYLEX yylex (YYLEX_PARAM)

#else

# define YYLEX yylex ()

#endif

/* Enable debugging if requested. */

#if YYDEBUG

# ifndef YYFPRINTF

# include /* INFRINGES ON USER NAME SPACE */

# define YYFPRINTF fprintf

# endif

# define YYDPRINTF(Args)

\

do {

\

if (yydebug)

\

YYFPRINTF Args;

\

} while (0)

# define YYDSYMPRINT(Args)

\

do {

\

if (yydebug)

\

yysymprint Args;

\

} while (0)

# define YYDSYMPRINTF(T itle, T oken, V alue, Location) \

do {

\

if (yydebug)

\ {

\

YYFPRINTF (stderr, "%s ", Title); \

yysymprint (stderr,

\

T oken, V alue);

\

YYFPRINTF (stderr, "\n");

\

}

\

} while (0)

/*-----------------------------------------

-------------------------.

| yy_stack_print -- Print the state

stack from its BOTTOM up to its |

| TOP (cinluded).

|

`-------------------------------------------

-----------------------*/

#if defined (__ST DC__) || defined

(__cplusplus)

static void

yy_stack_print (short *bottom, short

*top)

#else

static void

yy_stack_print (bottom, top)

short *bottom;

short *top;

#endif

{

YYFPRINTF (stderr, "Stack

now");

for (/* Nothing. */; bottom <= top;

++bottom)

YYFPRINTF (stderr, " %d",

*bottom);

YYFPRINTF (stderr, "\n");

}

# define

YY_ST ACK_PRINT(Bottom, T op)

\

do {

\

if (yydebug)

\

yy_stack_print ((Bottom),

(T op)); \

} while (0)

#if defined (__ST DC__) || defined

(__cplusplus)

static void

yy_reduce_print (int yyrule)

#else

static void

yy_reduce_print (yyrule)

int yyrule;

#endif

{

int yyi;

unsigned int yylno =

yyrline[yyrule];

YYFPRINTF (stderr, "Reducing

stack by rule %d (line %u), ",

yyrule - 1, yylno);

/* Print the symbols being

reduced, and their result. */

for (yyi = yyprhs[yyrule]; 0 <=

yyrhs[yyi]; yyi++)

YYFPRINTF (stderr, "%s ",

yytname [yyrhs[yyi]]);

YYFPRINTF (stderr, "-> %s\n",

yytname [yyr1[yyrule]]);

}

# define

YY_REDUCE_PRINT(Rule)

\

do {

\

if (yydebug)

\

yy_reduce_print (Rule);

\

} while (0)

/* Nonzero means print parse trace.

It is left uninitialized so that

multiple parsers can coexist. */

int yydebug;

#else /* !YYDEBUG */

# define YYDPRINTF(Args)

# define YYDSYMPRINT(Args)

# define YYDSYMPRINTF(T itle,

T oken, V alue, Location)

# define

YY_ST ACK_PRINT(Bottom, T op)

# define

YY_REDUCE_PRINT(Rule)

#endif /* !YYDEBUG */

/* YYINIT DEPTH -- initial size of

the parser's stacks. */

#ifndef YYINIT DEPTH

# define YYINIT DEPTH 200

#endif

/* YYMAX DEPT H -- maximum

size the stacks can grow to

(effective only

if the built-in stack extension

method is used).

Do not make this value too large;

the results are undefined if

SIZE_MAX <

YYST ACK_BYT ES

(YYMAXDEPTH)

evaluated with infinite-precision

integer arithmetic. */

#if YYMAX DEPT H == 0

# undef YYMAX DEPTH

#endif

#ifndef YYMAXDEPTH

# define YYMAX DEPTH 10000

#endif

#if YYERROR_VERBOSE

# ifndef yystrlen

# if defined (__GLIBC__) &&

defined (_STRING_H)

# define yystrlen strlen

# else

/* Return the length of YYSTR. */

static YYSIZE_T

# if defined (__STDC__) ||

defined (__cplusplus)

yystrlen (const char *yystr)

# else

yystrlen (yystr)

const char *yystr;

# endif

{

register const char *yys = yystr;

while (*yys++ != '\0')

continue;

return yys - yystr - 1;

}

# endif

# endif

# ifndef yystpcpy

# if defined (__GLIBC__) &&

defined (_STRING_H) && defined

(_GNU_SOURCE)

# define yystpcpy stpcpy

# else

static char *

# if defined (__STDC__) ||

defined (__cplusplus)

yystpcpy (char *yydest, const char

*yysrc)

# else

yystpcpy (yydest, yysrc)

char *yydest;

const char *yysrc;

# endif

{

register char *yyd = yydest;

register const char *yys = yysrc;

while ((*yyd++ = *yys++) != '\0')

continue;

return yyd - 1;

}

# endif

# endif

#endif /* !YYERROR_VERBOSE

*/

#if YYDEBUG

#if defined (__ST DC__) || defined

(__cplusplus)

static void

yysymprint (FILE *yyoutput, int

yytype, YYSTYPE *yyvaluep)

#else

static void

yysymprint (yyoutput, yytype,

yyvaluep)

FILE *yyoutput;

int yytype;

YYSTYPE *yyvaluep;

#endif

{

/* Pacify ``unused variable''

warnings. */

(void) yyvaluep;

if (yytype < YYNTOKENS)

{

YYFPRINTF (yyoutput,

"token %s (", yytname[yytype]);

# ifdef YYPRINT

YYPRINT (yyoutput,

yytoknum[yytype], *yyvaluep);

# endif

}

else

YYFPRINTF (yyoutput,

"nterm %s (", yytname[yytype]);

switch (yytype)

{

default:

break;

}

YYFPRINTF (yyoutput, ")");

}

#endif /* ! YYDEBUG */

/*-----------------------------------------

------.

| Release the memory associated to

this symbol. |

`-------------------------------------------

----*/

#if defined (__ST DC__) || defined

(__cplusplus)

static void

yydestruct (int yytype, YYSTYPE

*yyvaluep)

#else

static void

yydestruct (yytype, yyvaluep)

int yytype;

YYSTYPE *yyvaluep;

#endif

{

(void) yyvaluep;

switch (yytype)

{

default:

break;

}

}

#ifdef YYPARSE_PARAM

# if defined (__STDC__) || defined

(__cplusplus)

int yyparse (void

*YYPARSE_PARAM);

# else

int yyparse ();

# endif

#else /* ! YYPARSE_PARAM */

#if defined (__ST DC__) || defined

(__cplusplus)

int yyparse (void);

#else

int yyparse ();

#endif

#endif /* ! YYPARSE_PARAM */

/* T he lookahead symbol. */

int yychar;

/* T he semantic value of the

lookahead symbol. */

YYSTYPE yylval;

/* Number of syntax errors so far.

*/

int yynerrs;

/*----------.

| yyparse. |

`----------*/

#ifdef YYPARSE_PARAM

# if defined (__STDC__) || defined (__cplusplus)

int yyparse (void *YYPARSE_PARAM)

# else

int yyparse (YYPARSE_PARAM) void *YYPARSE_PARAM;

# endif

#else /* ! YYPARSE_PARAM */

#if defined (__ST DC__) || defined (__cplusplus)

int

yyparse (void)

#else

int

yyparse ()

#endif

#endif

{

register int yystate;

register int yyn;

int yyresult;

/* Number of tokens to shift before error messages enabled. */ int yyerrstatus;

/* Lookahead token as an internal (translated) token number. */

int yytoken = 0;

/* Three stacks and their tools:

`yyss': related to states,

`yyvs': related to semantic values,

`yyls': related to locations.

Refer to the stacks thru separate pointers, to allow yyoverflow

to reallocate them elsewhere. */

/* The state stack. */

short yyssa[YYINIT DEPT H]; short *yyss = yyssa;

register short *yyssp;

/* The semantic value stack. */ YYSTYPE

yyvsa[YYINIT DEPT H]; YYSTYPE *yyvs = yyvsa; register YYST YPE *yyvsp;

#define YYPOPST ACK (yyvsp--, yyssp--)

YYSIZ E_T yystacksize = YYINIT DEPTH;

/* The variables used to return semantic value and location from the

action routines. */ YYSTYPE yyval;

/* When reducing, the number of symbols on the RHS of the reduced rule. */

int yylen;

YYDPRINTF ((stderr, "Starting parse\n"));

yystate = 0;

yyerrstatus = 0;

yynerrs = 0;

yychar = YYEMPT Y;

yyssp = yyss;

yyvsp = yyvs;

goto yysetstate; yynewstate:

/* In all cases, when you get here,

the value and location stacks

have just been pushed. so

pushing a state here evens the

stacks.

*/

yyssp++;

yysetstate:

*yyssp = yystate;

if (yyss + yystacksize - 1 <=

yyssp)

{

/* Get the current used size

of the three stacks, in elements. */

YYSIZE_T yysize = yyssp -

yyss + 1;

#ifdef yyoverflow

{

/* Give user a chance to

reallocate the stack. Use copies of

these so that the &'s

don't force the real ones into

memory. */

YYSTYPE *yyvs1 = yyvs;

short *yyss1 = yyss;

/* Each stack pointer

address is followed by the size of

the

data in use in that stack,

in bytes. This used to be a

conditional around just

the two extra args, but that might

be undefined if

yyoverflow is a macro. */

yyoverflow ("parser stack

overflow",

&yyss1, yysize

* sizeof (*yyssp),

&yyvs1, yysize

* sizeof (*yyvsp),

&yystacksize);

yyss = yyss1;

yyvs = yyvs1;

}

#else /* no yyoverflow */

# ifndef YYST ACK_RELOCATE

goto yyoverflowlab;

# else

/* Extend the stack our own

way. */

if (YYMAXDEPT H <=

yystacksize)

goto yyoverflowlab;

yystacksize *= 2;

if (YYMAX DEPT H <

yystacksize)

yystacksize =

YYMAXDEPTH;

{

short *yyss1 = yyss;

union yyalloc *yyptr =

(union yyalloc *)

YYST ACK_ALLOC

(YYST ACK_BYT ES

(yystacksize));

if (! yyptr)

goto yyoverflowlab;

YYST ACK_RELOCATE

(yyss);

YYST ACK_RELOCATE

(yyvs);

# undef YYST ACK_RELOCATE

if (yyss1 != yyssa)

YYST ACK_FREE

(yyss1);

}

# endif

#endif /* no yyoverflow */

yyssp = yyss + yysize - 1;

yyvsp = yyvs + yysize - 1;

YYDPRINTF ((stderr,

"Stack size increased to %lu\n",

(unsigned long

int) yystacksize));

if (yyss + yystacksize - 1 <=

yyssp)

YY ABORT;

}

YYDPRINTF ((stderr, "Entering

state %d\n", yystate));

goto yybackup;

yybackup:

/* Do appropriate processing given

the current state. */

/* Read a lookahead token if we

need one and don't already have one.

*/

/* yyresume: */

/* First try to decide what to do

without reference to lookahead

token. */

yyn = yypact[yystate];

if (yyn == YYPACT_NINF)

goto yydefault;

/* Not known => get a lookahead

token if don't already have one. */

/* YYCHAR is either YYEMPT Y

or YYEOF or a valid lookahead

symbol. */

if (yychar == YYEMPT Y)

{

YYDPRINTF ((stderr,

"Reading a token: "));

yychar = YYLEX;

}

if (yychar <= YYEOF)

{

yychar = yytoken = YYEOF;

YYDPRINTF ((stderr, "Now

at end of input.\n"));

}

else

{

yytoken = YYTRANSLATE

(yychar);

YYDSYMPRINTF ("Next

token is", yytoken, &yylval,

&yylloc);

}

/* If the proper action on seeing

token YYT OKEN is to reduce or to

detect an error, take that

action. */

yyn += yytoken;

if (yyn < 0 || YYLAST < yyn ||

yycheck[yyn] != yytoken)

goto yydefault;

yyn = yytable[yyn];

if (yyn <= 0)

{

if (yyn == 0 || yyn ==

YYT ABLE_NINF)

goto yyerrlab;

yyn = -yyn;

goto yyreduce;

}

if (yyn == YYFINAL)

YYACCEPT;

/* Shift the lookahead token. */

YYDPRINTF ((stderr, "Shifting

token %s, ", yytname[yytoken]));

/* Discard the token being shifted

unless it is eof. */

if (yychar != YYEOF)

yychar = YYEMPTY;

*++yyvsp = yylval;

/* Count tokens shifted since

error; after three, turn off error

status. */

if (yyerrstatus)

yyerrstatus--;

yystate = yyn;

goto yynewstate;

/*-----------------------------------------

------------------.

| yydefault -- do the default action

for the current state. |

`-------------------------------------------

----------------*/

yydefault:

yyn = yydefact[yystate];

if (yyn == 0)

goto yyerrlab;

goto yyreduce;

/*-----------------------------.

| yyreduce -- Do a reduction. |

`-----------------------------*/

yyreduce:

/* yyn is the number of a rule to

reduce with. */

yylen = yyr2[yyn];

/* If YYLEN is nonzero,

implement the default value of the

action:

`$$ = $1'.

Otherwise, the following line

sets YYV AL to garbage.

This behavior is

undocumented and Bison

users should not rely upon it.

Assigning to YYV AL

unconditionally makes the

parser a bit smaller, and it avoids a

GCC warning that YYV AL

may be used uninitialized. */

yyval = yyvsp[1-yylen];

YY_REDUCE_PRINT (yyn);

switch (yyn)

{

case 3:

#line 39 "calc.y"

{printf("--> ");}

break;

case 4:

#line 40 "calc.y"

{yyerrok;printf("\n--> ");}

break;

case 7:

#line 45 "calc.y"

{

if(dflag==DEC_ON)printf(

"\t=%g\n--> " , yyvsp[0] );

else

if(dflag==HEX_ON)printf( "\t=0x%

08X\n--> " , (BIGINT)yyvsp[0] );

else

printf( "\t=0%o\n--> " ,

(BIGINT)yyvsp[0] );

}

break;

case 8:

#line 50 "calc.y"

{

i=(int)yyvsp[-2]; reg[i] = yyvsp[0] ;

if(dflag==DEC_ON)

printf( "\t%c=%g\n--> " ,

'a'+i,reg[i] );

else if(dflag==HEX_ON)

printf( "\t%c=0x%08X\n--> " ,

'a'+i,(BIGINT)reg[i] );

else printf( "\t%c=0%o\n--> " ,

'a'+i,(BIGINT)reg[i] );

}

break;

case 9:

#line 58 "calc.y"

{ yyval = yyvsp[-2] + yyvsp[0] ; }

break;

case 10:

#line 59 "calc.y"

{ yyval = yyvsp[-2] - yyvsp[0] ; }

break;

case 11:

#line 60 "calc.y"

{ yyval = yyvsp[-2] * yyvsp[0] ; }

break;

case 12:

#line 61 "calc.y"

{ yyval = yyvsp[-2] / yyvsp[0] ; }

break;

case 13:

#line 62 "calc.y"

{ yyval = (BIGINT)yyvsp[-2] % (BIGINT)yyvsp[0] ; }

break;

case 14:

#line 63 "calc.y"

{ yyval = (BIGINT)yyvsp[-2] & (BIGINT)yyvsp[0] ; }

break;

case 15:

#line 64 "calc.y"

{ yyval = (BIGINT)yyvsp[-2] | (BIGINT)yyvsp[0] ; }

break;

case 16:

#line 65 "calc.y"

{ yyval = (BIGINT)yyvsp[-2] ^ (BIGINT)yyvsp[0] ; }

break;

case 17:

#line 66 "calc.y"

{ yyval = (BIGINT)yyvsp[-2] << (BIGINT)yyvsp[0] ; }

break;

case 18:

#line 67 "calc.y"

{ yyval = (BIGINT)yyvsp[-2] >> (BIGINT)yyvsp[0] ; }

break;

case 19:

#line 68 "calc.y"

{ yyval = (BIGINT)yyvsp[-2] && (BIGINT)yyvsp[0] ; }

break;

case 20:

#line 69 "calc.y"

{ yyval = (BIGINT)yyvsp[-2] || (BIGINT)yyvsp[0] ; }

break;

case 21:

#line 70 "calc.y"

{ yyval = yyvsp[-2]

break;

case 22:

#line 71 "calc.y"

{ yyval = yyvsp[-2]>yyvsp[0]?1:0; }

break;

case 23:

#line 72 "calc.y"

{ yyval = yyvsp[-1] ; }

break;

case 24: #line 73 "calc.y"

{ yyval = -yyvsp[0] ; }

break;

case 25:

#line 74 "calc.y"

{ yyval =

~((BIGINT)yyvsp[0]); }

break;

case 26:

#line 75 "calc.y"

{ yyval

= !( (BIGINT)yyvsp[0] ) ; }

break;

case 27:

#line 76 "calc.y"

{ yyval = yyvsp[0] ; }

break;

case 28:

#line 77 "calc.y"

{ ival=(int)yyvsp[0];yyval =

reg[ival] ; }

break;

case 29:

#line 78 "calc.y"

{ yyval =sin(yyvsp[0]) ; }

break;

case 30:

#line 79 "calc.y"

{ yyval =cos(yyvsp[0]) ; }

break;

case 31:

#line 80 "calc.y"

{ yyval =tan(yyvsp[0]) ; }

break;

case 32:

#line 81 "calc.y"

{ yyval =log(yyvsp[0]) ; }

break;

case 33:

#line 82 "calc.y"

{ yyval =abs(yyvsp[0]) ; }

break;

case 34:

#line 83 "calc.y"

{ yyval =sqrt(yyvsp[0]) ; }

break;

case 35:

#line 86 "calc.y"

{ exit(0); }

break;

case 36:

#line 87 "calc.y"

{ printf("\033[2J\033[1;1H\n-->

"); }

break;

case 37:

#line 88 "calc.y"

{ dflag=HEX_ON; printf(">>

Hex display mod on!\n--> "); }

break;

case 38:

#line 89 "calc.y"

{ dflag=DEC_ON; printf(">>

Dec display mod on!\n--> "); }

break;

case 39:

#line 90 "calc.y"

{ dflag=OCT_ON; printf(">>

Oct display mod on!\n--> "); }

break;

case 40:

#line 91 "calc.y"

{

for(i=0;i<26;i++)

{

if(dflag==DEC_ON)printf("\t%c=%

g\n",'a'+i,reg[i]);

else

if(dflag==HEX_ON)printf("\t%c=0

x%08X\n",'a'+i,(BIGINT)reg[i]);

else

printf("\t%c=0%o\n",'a'+i,(BIGINT)

reg[i]);

}

printf("--> ");

}

break;

case 41:

#line 100 "calc.y"

{ for(i=0;i<26;i++)reg[i]=0;

printf(">>All registers erased!\n-->

");}

break;

case 42:

#line 101 "calc.y"

{

printf(">>

COMMANDS:\n");

printf(">

help: Display this help section.\n");

printf(">

clear: Clear the screen.\n");

printf(">

dec: Decimal mode to display

numbers or registers.\n");

printf(">

hex: Hexadecimal mode to display

numbers or registers.\n");

printf(">

oct: Octal mode to display numbers

or registers.\n");

printf(">

list: List the values in the 26

registers which are ranged from

'a'/'A' to 'z'/'Z'.\n");

printf(">

erase: Reset all registers to 0.\n");

printf(">

exit: Quit this program.\n");

printf("-->

");

}

break;

}

/* Line 999 of yacc.c. */

#line 1349 "y.tab.c"

yyvsp -= yylen;

yyssp -= yylen;

YY_ST ACK_PRINT (yyss,

yyssp);

*++yyvsp = yyval;

/* Now `shift' the result of the

reduction. Determine what state

that goes to, based on the state

we popped back to and the rule

number reduced by. */

yyn = yyr1[yyn];

yystate = yypgoto[yyn -

YYNT OKENS] + *yyssp;

if (0 <= yystate && yystate <=

YYLAST && yycheck[yystate] ==

*yyssp)

yystate = yytable[yystate];

else

yystate = yydefgoto[yyn -

YYNT OKENS];

goto yynewstate;

/*------------------------------------.

| yyerrlab -- here on detecting error |

`------------------------------------*/

yyerrlab:

/* If not already recovering from

an error, report this error. */

if (!yyerrstatus)

{

++yynerrs;

#if YYERROR_VERBOSE

yyn = yypact[yystate];

if (YYPACT_NINF < yyn

&& yyn < YYLAST)

{

YYSIZ E_T yysize = 0;

int yytype =

YYTRANSLAT E (yychar);

const char* yyprefix;

char *yymsg;

int yyx;

/* Start YYX at -YYN if

negative to avoid negative indexes

in

YYCHECK. */

int yyx begin = yyn < 0 ?

-yyn : 0;

/* Stay within bounds of

both yycheck and yytname. */

int yychecklim =

YYLAST - yyn;

int yyxend =yychecklim

< YYNT OKENS ? yychecklim :

YYNT OKENS;

int yycount = 0;

yyprefix = ", expecting ";

for (yyx = yyx begin; yyx

< yyxend; ++yyx)

i f (yycheck[yyx + yyn]

== yyx && yyx != YYTERROR)

{

yysize += yystrlen

(yyprefix) + yystrlen (yytname

[yyx]);

yycount += 1;

if (yycount == 5)

{

yysize = 0;

break;

}

}

yysize += (sizeof ("syntax

error, unexpected ")

+ yystrlen

(yytname[yytype]));

yymsg = (char *)

YYST ACK_ALLOC (yysize);

if (yymsg != 0)

{

char *yyp =

yystpcpy (yymsg, "syntax error,

unex pected ");

yyp = yystpcpy (yyp,

yytname[yytype]);

if (yycount < 5)

{

yyprefix = ",

expecting ";

for (yyx =

yyx begin; yyx < yyxend; ++yyx)

i f

(yycheck[yyx + yyn] == yyx &&

yyx != YYTERROR)

{

yyp =

yystpcpy (yyp, yyprefix);

yyp =

yystpcpy (yyp, yytname[yyx]);

yyprefix = "

or ";

}

}

yyerror (yymsg);

YYST ACK_FREE

(yymsg);

}

else

yyerror ("syntax error;

also virtual memory exhausted");

}

else

#endif /* YYERROR_V ERBOSE */

yyerror ("syntax error");

}

if (yyerrstatus == 3)

{

/* If just tried and failed to reuse lookahead token after an

error, discard it. */

/* Return failure if at end of input. */

if (yychar == YYEOF)

{

/* Pop the error token. */

YYPOPST ACK;

/* Pop the rest of the stack. */

while (yyss < yyssp)

{

YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);

yydestruct (yystos[*yyssp], yyvsp);

YYPOPST ACK;

}

YY ABORT;

}

YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);

yydestruct (yytoken, &yylval);

yychar = YYEMPTY;

}

/* Else will try to reuse lookahead token after shifting the error

token. */

goto yyerrlab1;

/*-----------------------------------------

-----------.

| yyerrlab1 -- error raised explicitly

by an action. |

`-------------------------------------------

---------*/

yyerrlab1:

yyerrstatus = 3; /* Each real

token shifted decrements this. */

for (;;)

{

yyn = yypact[yystate];

if (yyn != YYPACT_NINF)

{

yyn += YYTERROR;

if (0 <= yyn && yyn <=

YYLAST && yycheck[yyn] ==

YYT ERROR)

{

yyn = yytable[yyn];

if (0 < yyn)

break;

}

}

/* Pop the current state

because it cannot handle the error

token. */

if (yyssp == yyss)

YY ABORT;

YYDSYMPRINTF ("Error:

popping", yystos[*yyssp], yyvsp,

yylsp);

yydestruct (yystos[yystate],

yyvsp);

yyvsp--;

yystate = *--yyssp;

YY_ST ACK_PRINT (yyss,

yyssp);

}

if (yyn == YYFINAL)

YYACCEPT;

YYDPRINTF ((stderr, "Shifting

error token, "));

*++yyvsp = yylval;

yystate = yyn;

goto yynewstate;

/*-------------------------------------.

| yyacceptlab -- YY ACCEPT comes

here. |

`-------------------------------------*/

yyacceptlab:

yyresult = 0;

goto yyreturn;

/*-----------------------------------.

| yyabortlab -- YY ABORT comes

here. |

`-----------------------------------*/

yyabortlab:

yyresult = 1;

goto yyreturn;

#ifndef yyoverflow

/*-----------------------------------------

-----.

| yyoverflowlab -- parser overflow

comes here. |

`-------------------------------------------

---*/

yyoverflowlab:

yyerror ("parser stack overflow");

yyresult = 2;

/* Fall through. */

#endif

yyreturn:

#ifndef yyoverflow

if (yyss != yyssa)

YYST ACK_FREE (yyss);

#endif

return yyresult;

}

#line 115 "calc.y"

int yyerror(char *str)

{

fprintf(stderr,"Error: %s\n",str);

return 1;

}

int yywrap()

{

return 1;

}

int main()

{

yyparse();

}

程序运行截图：