lab3.tab.c

c—语言的句法分析器。读入一个C--语言程序

           char *p = InsertFun(yyvsp[-3].id, yyvsp[-4].value);
           if (0 == p) {
               printf("line %3d error: %s :function redefinition\n", lineno, yyvsp[-3].id);
               right = 0;
               free(argtemp.temp);
           }
           level++;
           typecount = 0;
           if (0 == (argtemp.temp = (int *)malloc(50 * sizeof(int)))) {
               printf("malloc for argument list buffer error\n");
               exit(1);
           }
           argtemp.size = 50;
           if (debug) {
               printf("fun_tag => type_specifer ID\n");
           }
       ;
    break;}
case 18:
#line 244 "lab3.y"
{/*
           if (debug) {
               printf("params => param_list\n");
           }*/
       ;
    break;}
case 19:
#line 250 "lab3.y"
{
           if (typecount + 1 > argtemp.size) {
               argtemp.temp = (int *)realloc(argtemp.temp,(argtemp.size + BUFFINCREMENT) * sizeof(int));
               if (0 == argtemp.temp) {
                   printf("realloc for argument list buffer error\n");
                   exit(1);
               }
               argtemp.size += BUFFINCREMENT;
           }
           argtemp.temp[typecount++] = VOID;
           if (debug) {
               printf("params => VOID\n");
           }
       ;
    break;}
case 20:
#line 267 "lab3.y"
{/*
           if (debug) {
               printf("param_list => param_list , param\n");
           }*/
       ;
    break;}
case 21:
#line 273 "lab3.y"
{/*
           if (debug) {
               printf("param_list => param\n");
           }*/
       ;
    break;}
case 22:
#line 281 "lab3.y"
{
           struct table *tp = symboltable[tablelen-1];
           symbol *p;

           level++;
           p = InsertSym(yyvsp[0].id, tp);
           if (0 == p) {
               printf("line %3d error: %s :redefinition\n", lineno, yyvsp[0].id);
               right = 0;
           } else {
               p->type = yyvsp[-1].value;
           }
           level--;
           if (typecount + 1 > argtemp.size) {
               argtemp.temp = (int *)realloc(argtemp.temp,(argtemp.size + BUFFINCREMENT) * sizeof(int));
               if (0 == argtemp.temp) {
                   printf("realloc for argument list buffer error\n");
                   exit(1);
               }
               argtemp.size += BUFFINCREMENT;
           }
           argtemp.temp[typecount++] = yyvsp[-1].value;
           if (debug) {
               printf("param => type_specifer ID\n");
           }
       ;
    break;}
case 23:
#line 308 "lab3.y"
{
           struct table *tp = symboltable[tablelen-1];
           symbol *p;

           level++;
           p = InsertSym(yyvsp[0].id, tp);
           if (0 == p) {
               printf("line %3d error: %s :redefinition\n", lineno, yyvsp[0].id);
               right = 0;
           } else {
               p->type = yyvsp[-2].value + 100;
           }
           level--;
           if (typecount + 1 > argtemp.size) {
               argtemp.temp = (int *)realloc(argtemp.temp,(argtemp.size + BUFFINCREMENT) * sizeof(int));
               if (0 == argtemp.temp) {
                   printf("realloc for argument list buffer error\n");
                   exit(1);
               }
               argtemp.size += BUFFINCREMENT;
           }
           argtemp.temp[typecount++] = yyvsp[-2].value + 100;
           if (debug) {
               printf("param => type_specifer * ID\n");
           }
       ;
    break;}
case 24:
#line 335 "lab3.y"
{
           struct table *tp = symboltable[tablelen-1];
           symbol *p;

           level++;
           p = InsertSym(yyvsp[-2].id, tp);
           if (0 == p) {
               printf("line %3d error: %s :redefinition\n", lineno, yyvsp[-2].id);
               right = 0;
           } else {
               p->type = yyvsp[-3].value;
           }
           level--;
           if (typecount + 1 > argtemp.size) {
               argtemp.temp = (int *)realloc(argtemp.temp,(argtemp.size + BUFFINCREMENT) * sizeof(int));
               if (0 == argtemp.temp) {
                   printf("realloc for argument list buffer error\n");
                   exit(1);
               }
               argtemp.size += BUFFINCREMENT;
           }
           argtemp.temp[typecount++] = yyvsp[-3].value;
           if (debug) {
               printf("param => type_specifer ID [ ]\n");
           }
       ;
    break;}
case 25:
#line 362 "lab3.y"
{
           if (typecount + 1 > argtemp.size) {
               argtemp.temp = (int *)realloc(argtemp.temp,(argtemp.size + BUFFINCREMENT) * sizeof(int));
               if (0 == argtemp.temp) {
                   printf("realloc for argument list buffer error\n");
                   exit(1);
               }
               argtemp.size += BUFFINCREMENT;
           }
           argtemp.temp[typecount++] = ELLIPSIS;
           if (debug) {
               printf("param => ELLIPSIS\n");
           }
       ;
    break;}
case 26:
#line 379 "lab3.y"
{/*
           if (debug) {
               printf("compound_stmt => { local_declarations statement_list }\n");
           }*/
       ;
    break;}
case 27:
#line 387 "lab3.y"
{/*
           if (debug) {
               printf("local_declarations =>local_declarations var_declaration\n");
           }*/
       ;
    break;}
case 29:
#line 396 "lab3.y"
{/*
           if (debug) {
               printf("statement_list => statement_list statement\n");
           }*/
       ;
    break;}
case 31:
#line 405 "lab3.y"
{/*
           if (debug) {
               printf("statement => expression_stmt\n");
           }*/
       ;
    break;}
case 32:
#line 411 "lab3.y"
{/*
           if (debug) {
               printf("statement => compound_stmt\n");
           }*/
       ;
    break;}
case 33:
#line 417 "lab3.y"
{/*
           if (debug) {
               printf("statement => if_stmt\n");
           }*/
       ;
    break;}
case 34:
#line 423 "lab3.y"
{/*
           if (debug) {
               printf("statement => while_stmt\n");
           }*/
       ;
    break;}
case 35:
#line 429 "lab3.y"
{/*
           if (debug) {
               printf("statement => return_stmt\n");
           }*/
       ;
    break;}
case 36:
#line 437 "lab3.y"
{
           if (debug) {
               printf("expression_stmt => expression ;\n");
           }
       ;
    break;}
case 37:
#line 443 "lab3.y"
{
           if (debug) {
               printf("expression_stmt => ;\n");
           }
       ;
    break;}
case 38:
#line 451 "lab3.y"
{
           if (debug) {
               printf("if_stmt => IF ( expression ) statement\n");
           }
       ;
    break;}
case 39:
#line 457 "lab3.y"
{
           if (debug) {
               printf("if_stmt => IF ( expression ) statement ELSE statement\n");
           }
       ;
    break;}
case 40:
#line 465 "lab3.y"
{
           if (debug) {
               printf("while_stmt => WHILE ( expression ) statement\n");
           }
       ;
    break;}
case 41:
#line 473 "lab3.y"
{
           if (debug) {
               printf("return_stmt => RETURN ;\n");
           }
       ;
    break;}
case 42:
#line 479 "lab3.y"
{
           if (debug) {
               printf("return_stmt => RETURN expression ;\n");
           }
       ;
    break;}
case 43:
#line 487 "lab3.y"
{
           if (yyvsp[-2].sign != 0) {
               if (yyvsp[-2].sign->type != yyvsp[0].expn.type) {
                   printf("line %3d error: = :the left and the right type does not match\n", lineno, yyvsp[-2].sign);
                   right = 0;
               }
               yyval.expn.type = yyvsp[-2].sign->type;
           }
           if (debug) {
               printf("expression => var = expression\n");
           }
       ;
    break;}
case 44:
#line 500 "lab3.y"
{
           yyval.expn.type = yyvsp[0].expn.type;
       /*    if (debug) {
               printf("expression => simple_expression\n");
           }*/
       ;
    break;}
case 45:
#line 509 "lab3.y"
{
           yyval.sign = LookUp(yyvsp[0].id, symboltable[tablelen-1]);
           if (0 == yyval.sign) {
               printf("line %3d error: %s :undeclared identifier\n", lineno, yyvsp[0].id);
               right = 0;
           }
           if (debug) {
               printf("var => ID\n");
           }
       ;
    break;}
case 46:
#line 520 "lab3.y"
{
           yyval.sign = LookUp(yyvsp[-3].id, symboltable[tablelen-1]);
           if (0 == yyval.sign) {
               printf("line %3d error: %s :undeclared identifier\n", lineno, yyvsp[-3].id);
               right = 0;
           }
           if (debug) {
               printf("var => ID [ expression ]\n");
           }
       ;
    break;}
case 47:
#line 533 "lab3.y"
{
           yyval.expn.type = INT;
           if ((yyvsp[-2].expn.type == INT || yyvsp[-2].expn.type == CHAR) && (yyvsp[0].expn.type == INT || yyvsp[0].expn.type == CHAR)) {
               if (0 == strcmp(yyvsp[-1].op, "<")) {
                   if (yyvsp[-2].expn.value < yyvsp[0].expn.value) {
                       yyval.expn.value = 1;
                   } else {
                       yyval.expn.value = 0;
                   }
               } else if (0 == strcmp(yyvsp[-1].op, "<=")) {
                   if (yyvsp[-2].expn.value <= yyvsp[0].expn.value) {
                       yyval.expn.value = 1;
                   } else {
                       yyval.expn.value = 0;
                   }
               } else if (0 == strcmp(yyvsp[-1].op, ">")) {
                   if (yyvsp[-2].expn.value > yyvsp[0].expn.value) {
                       yyval.expn.value = 1;
                   } else {
                       yyval.expn.value = 0;
                   }
               } else if (0 == strcmp(yyvsp[-1].op, ">=")) {
                   if (yyvsp[-2].expn.value >= yyvsp[0].expn.value) {
                       yyval.expn.value = 1;
                   } else {
                       yyval.expn.value = 0;
                   }
               } else if (0 == strcmp(yyvsp[-1].op, "==")) {
                   if (yyvsp[-2].expn.value == yyvsp[0].expn.value) {
                       yyval.expn.value = 1;
                   } else {
                       yyval.expn.value = 0;
                   }
               } else {
                   if (yyvsp[-2].expn.value != yyvsp[0].expn.value) {
                       yyval.expn.value = 1;
                   } else {
                       yyval.expn.value = 0;
                   }
               }
           }
           if (yyvsp[-2].expn.type != INT && yyvsp[-2].expn.type != CHAR) {
               printf("line %3d error: %s :illegal, left operand is not constant or character\n", lineno, yyvsp[-1].op);
               right = 0;
           }
           if (yyvsp[0].expn.type != INT && yyvsp[0].expn.type != CHAR) {
               printf("line %3d error: %s :illegal, right operand is not constant or character\n", lineno, yyvsp[-1].op);
               right = 0;
           }
           if (debug) {
               printf("simple_expression => additive_expression relop additive_expression\n");
           }
       ;
    break;}
case 48:
#line 587 "lab3.y"
{
           yyval.expn.type = yyvsp[0].expn.type;
       /*    if (debug) {
               printf("simple_expression => additive_expression\n");
           }*/
       ;
    break;}
case 49:
#line 596 "lab3.y"
{
           if (debug) {
               printf("relop => LE\n");
           }
       ;
    break;}
case 50:
#line 602 "lab3.y"
{
           if (debug) {
               printf("relop => LT\n");
           }
       ;
    break;}
case 51:
#line 608 "lab3.y"
{
           if (debug) {
               printf("relop => GT\n");
           }
       ;
    break;}
case 52:
#line 614 "lab3.y"
{
           if (debug) {
               printf("relop => GE\n");
           }
       ;
    break;}
case 53:
#line 620 "lab3.y"
{
           if (debug) {
               printf("relop => EQ\n");
           }
       ;
    break;}
case 54:
#line 626 "lab3.y"
{
           if (debug) {
               printf("relop => NE\n");
           }
       ;
    break;}
case 55:
#line 634 "lab3.y"
{
           yyval.expn.type = INT;
           if (yyvsp[-2].expn.type == INT && yyvsp[0].expn.type == INT) {
               if (yyvsp[-1].op[0] == '+') {
                   yyval.expn.value = yyvsp[-2].expn.value + yyvsp[0].expn.value;
               } else {
                   yyval.expn.value = yyvsp[-2].expn.value - yyvsp[0].expn.value;   
               }
           }
           if (yyvsp[-2].expn.type != INT) {
               printf("line %3d error: %c :illegal, left operand is not constant\n", lineno, yyvsp[-1].op[0]);
               right = 0;
           }
           if (yyvsp[0].expn.type != INT) {
               printf("line %3d error: %c :illegal, right operand is not constant\n", lineno, yyvsp[-1].op[0]);
               right = 0;
           }
           if (debug) {
               printf("additive_expression => additive_expression ADDOP term\n");
           }
       ;
    break;}
case 56:
#line 656 "lab3.y"
{
           yyval.expn.type = yyvsp[0].expn.type;
       /*    if (debug) {
               printf("additive_expression => term\n");
           }*/
       ;
    break;}
case 57:
#line 665 "lab3.y"
{
           yyval.expn.type = INT;
           if (yyvsp[-2].expn.type == INT && yyvsp[0].expn.type == INT) {
               if (yyvsp[-1].op[0] == '*') {
                   yyval.expn.value = yyvsp[-2].expn.value * yyvsp[0].expn.value;
               } else if (yyvsp[-1].op[0] == '/') {
                   yyval.expn.value = yyvsp[-2].expn.value / yyvsp[0].expn.value;   
               } else {
                   yyval.expn.value = yyvsp[-2].expn.value % yyvsp[0].expn.value; 
               }
           }
           if (yyvsp[-2].expn.type != INT) {
               printf("line %3d error: %c :illegal, left operand is not constant\n", lineno, yyvsp[-1].op[0]);
               right = 0;
           }
           if (yyvsp[0].expn.type != INT) {
               printf("line %3d error: %c :illegal, right operand is not constant\n", lineno, yyvsp[-1].op[0]);
               right = 0;
           }
           if (debug) {
               printf("term => term mulop unary_expression\n");
           }
       ;
    break;}