cmmyacc.c

简单C编译器生成的目标代码是8086的汇编代码（16位）

#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[5];
			yyinitdebug(yya, 5);
#endif
			{
#line 378 ".\\cmmyacc.y"

		yyval = newStmtNode(AssignK);
		yyval->child[0] = yyattribute(4 - 4);
		yyval->lineno = tempno[top];
		yyval->attr.name = tempToken[top--];
	
#line 691 "cmmyacc.c"
			}
		}
		break;
	case 18:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[4];
			yyinitdebug(yya, 4);
#endif
			{
#line 387 ".\\cmmyacc.y"

		yyval = yyattribute(2 - 3);
		yyval->child[0] = yyattribute(1 - 3);
		yyval->child[1] = yyattribute(3 - 3);
	
#line 708 "cmmyacc.c"
			}
		}
		break;
	case 19:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 393 ".\\cmmyacc.y"

		yyval = yyattribute(1 - 1);
	
#line 723 "cmmyacc.c"
			}
		}
		break;
	case 20:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 399 ".\\cmmyacc.y"

		yyval = newExpNode(OpK);
		yyval->attr.op = PLUS;
	
#line 739 "cmmyacc.c"
			}
		}
		break;
	case 21:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 404 ".\\cmmyacc.y"

		yyval = newExpNode(OpK);
		yyval->attr.op = MINUS;
	
#line 755 "cmmyacc.c"
			}
		}
		break;
	case 22:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[4];
			yyinitdebug(yya, 4);
#endif
			{
#line 411 ".\\cmmyacc.y"

		yyval = yyattribute(2 - 3);
		yyval->child[0] = yyattribute(1 - 3);
		yyval->child[1] = yyattribute(3 - 3);
	
#line 772 "cmmyacc.c"
			}
		}
		break;
	case 23:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 417 ".\\cmmyacc.y"

		yyval = yyattribute(1 - 1);
	
#line 787 "cmmyacc.c"
			}
		}
		break;
	case 24:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 423 ".\\cmmyacc.y"

		yyval = newExpNode(OpK);
		yyval->attr.op = MULT;
	
#line 803 "cmmyacc.c"
			}
		}
		break;
	case 25:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 428 ".\\cmmyacc.y"

		yyval = newExpNode(OpK);
		yyval->attr.op = DIV;
	
#line 819 "cmmyacc.c"
			}
		}
		break;
	case 26:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 435 ".\\cmmyacc.y"

		yyval = newExpNode(ConstK);
		yyval->attr.val = atoi(tokenString);
	
#line 835 "cmmyacc.c"
			}
		}
		break;
	case 27:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 440 ".\\cmmyacc.y"

		if (lookup(tokenString) == VoidT)
		{
			printf("ERROR %d: Line %d: ID %s is not defined.\n", ++nError, lineno, tokenString);
		}
		yyval = newExpNode(IdK);
		yyval->attr.name = copyString(tokenString);
	
#line 855 "cmmyacc.c"
			}
		}
		break;
	case 28:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[4];
			yyinitdebug(yya, 4);
#endif
			{
#line 449 ".\\cmmyacc.y"

		yyval = yyattribute(2 - 3);
	
#line 870 "cmmyacc.c"
			}
		}
		break;
	case 29:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 453 ".\\cmmyacc.y"

		yyval = yyattribute(1 - 1);
	
#line 885 "cmmyacc.c"
			}
		}
		break;
	case 30:
		{
#ifdef YYDEBUG
			YYSTYPE YYFAR *yya[2];
			yyinitdebug(yya, 2);
#endif
			{
#line 457 ".\\cmmyacc.y"

		yyval = NULL;
	
#line 900 "cmmyacc.c"
			}
		}
		break;
	default:
		yyassert(0);
		break;
	}
}
#ifdef YYDEBUG
YYCONST yysymbol_t YYNEARFAR YYBASED_CODE YYDCDECL yysymbol[] = {
	{ "$end", 0 },
	{ "error", 256 },
	{ "SEMI", 257 },
	{ "SLB", 258 },
	{ "SRB", 259 },
	{ "BLB", 260 },
	{ "BRB", 261 },
	{ "MAIN", 262 },
	{ "RETURN", 263 },
	{ "INT", 264 },
	{ "VOID", 265 },
	{ "INPUT", 266 },
	{ "OUTPUT", 267 },
	{ "PLUS", 268 },
	{ "MINUS", 269 },
	{ "MULT", 270 },
	{ "DIV", 271 },
	{ "ASSIGN", 272 },
	{ "ID", 273 },
	{ "NUM", 274 },
	{ "ERROR", 275 },
	{ NULL, 0 }
};

YYCONST char *YYCONST YYNEARFAR YYBASED_CODE YYDCDECL yyrule[] = {
	"$accept: program",
	"program: main_decl",
	"main_decl: type_spec fun_ID SLB params SRB compound_stmt",
	"type_spec: INT",
	"fun_ID: MAIN",
	"params: VOID",
	"params:",
	"compound_stmt: BLB var_decl_list stmt_list BRB",
	"var_decl_list: var_decl_list var_decl",
	"var_decl_list:",
	"$$1:",
	"var_decl: type_spec ID $$1 SEMI",
	"stmt_list: stmt_list stmt",
	"stmt_list:",
	"stmt: exp_stmt",
	"stmt: I_stmt",
	"stmt: O_stmt",
	"stmt: ret_stmt",
	"exp_stmt: exp SEMI",
	"exp_stmt: SEMI",
	"ret_stmt: RETURN exp SEMI",
	"I_stmt: I_exp SEMI",
	"I_exp: INPUT SLB SRB",
	"O_stmt: OUTPUT SLB exp SRB SEMI",
	"exp: asgn_exp",
	"exp: algo_exp",
	"$$2:",
	"asgn_exp: ID $$2 ASSIGN exp",
	"algo_exp: algo_exp addop term",
	"algo_exp: term",
	"addop: PLUS",
	"addop: MINUS",
	"term: term multop factor",
	"term: factor",
	"multop: MULT",
	"multop: DIV",
	"factor: NUM",
	"factor: ID",
	"factor: SLB exp SRB",
	"factor: I_exp",
	"factor: ERROR"
};
#endif

YYCONST yyreduction_t YYNEARFAR YYBASED_CODE YYDCDECL yyreduction[] = {
	{ 0, 1, -1 },
	{ 1, 1, -1 },
	{ 2, 6, -1 },
	{ 3, 1, -1 },
	{ 4, 1, -1 },
	{ 5, 1, -1 },
	{ 5, 0, -1 },
	{ 6, 4, 0 },
	{ 7, 2, -1 },
	{ 7, 0, -1 },
	{ 9, 0, 1 },
	{ 8, 4, -1 },
	{ 10, 2, 2 },
	{ 10, 0, 3 },
	{ 11, 1, 4 },
	{ 11, 1, 5 },
	{ 11, 1, 6 },
	{ 11, 1, 7 },
	{ 12, 2, 8 },
	{ 12, 1, 9 },
	{ 13, 3, 10 },
	{ 14, 2, 11 },
	{ 15, 3, 12 },
	{ 16, 5, 13 },
	{ 17, 1, 14 },
	{ 17, 1, 15 },
	{ 19, 0, 16 },
	{ 18, 4, 17 },
	{ 20, 3, 18 },
	{ 20, 1, 19 },
	{ 21, 1, 20 },
	{ 21, 1, 21 },
	{ 22, 3, 22 },
	{ 22, 1, 23 },
	{ 23, 1, 24 },
	{ 23, 1, 25 },
	{ 24, 1, 26 },
	{ 24, 1, 27 },
	{ 24, 3, 28 },
	{ 24, 1, 29 },
	{ 24, 1, 30 }
};

int YYNEAR YYDCDECL yytokenaction_size = 37;
YYCONST yytokenaction_t YYNEARFAR YYBASED_CODE YYDCDECL yytokenaction[] = {
	{ 58, YYAT_SHIFT, 19 },
	{ 15, YYAT_SHIFT, 18 },
	{ 60, YYAT_SHIFT, 50 },
	{ 60, YYAT_SHIFT, 51 },
	{ 62, YYAT_SHIFT, 64 },
	{ 15, YYAT_SHIFT, 20 },
	{ 57, YYAT_SHIFT, 62 },
	{ 15, YYAT_SHIFT, 21 },
	{ 58, YYAT_SHIFT, 22 },
	{ 36, YYAT_SHIFT, 50 },
	{ 36, YYAT_SHIFT, 51 },
	{ 15, YYAT_SHIFT, 23 },
	{ 35, YYAT_SHIFT, 47 },
	{ 35, YYAT_SHIFT, 48 },
	{ 52, YYAT_SHIFT, 59 },
	{ 58, YYAT_SHIFT, 24 },
	{ 58, YYAT_SHIFT, 25 },
	{ 58, YYAT_SHIFT, 26 },
	{ 44, YYAT_SHIFT, 58 },
	{ 42, YYAT_SHIFT, 56 },
	{ 41, YYAT_SHIFT, 55 },
	{ 39, YYAT_SHIFT, 54 },
	{ 38, YYAT_SHIFT, 53 },
	{ 33, YYAT_SHIFT, 46 },
	{ 32, YYAT_SHIFT, 45 },
	{ 24, YYAT_REDUCE, 26 },
	{ 23, YYAT_SHIFT, 43 },
	{ 22, YYAT_SHIFT, 42 },
	{ 14, YYAT_SHIFT, 17 },
	{ 13, YYAT_SHIFT, 1 },
	{ 10, YYAT_SHIFT, 11 },
	{ 9, YYAT_SHIFT, 10 },
	{ 7, YYAT_SHIFT, 8 },
	{ 6, YYAT_SHIFT, 7 },
	{ 4, YYAT_SHIFT, 5 },
	{ 2, YYAT_ACCEPT, 0 },
	{ 0, YYAT_SHIFT, 1 }
};

YYCONST yystateaction_t YYNEARFAR YYBASED_CODE YYDCDECL yystateaction[] = {
	{ -228, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_REDUCE, 3 },
	{ 35, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_REDUCE, 1 },
	{ -228, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_REDUCE, 4 },
	{ -225, 1, YYAT_ERROR, 0 },
	{ -233, 1, YYAT_REDUCE, 6 },
	{ 0, 0, YYAT_REDUCE, 5 },
	{ -228, 1, YYAT_ERROR, 0 },
	{ -230, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_REDUCE, 9 },
	{ 0, 0, YYAT_REDUCE, 2 },
	{ -235, 1, YYAT_REDUCE, 13 },
	{ -245, 1, YYAT_ERROR, 0 },
	{ -256, 1, YYAT_DEFAULT, 58 },
	{ 0, 0, YYAT_REDUCE, 8 },
	{ 0, 0, YYAT_REDUCE, 10 },
	{ 0, 0, YYAT_REDUCE, 19 },
	{ 0, 0, YYAT_DEFAULT, 58 },
	{ 0, 0, YYAT_REDUCE, 7 },
	{ 0, 0, YYAT_DEFAULT, 58 },
	{ -231, 1, YYAT_ERROR, 0 },
	{ -232, 1, YYAT_ERROR, 0 },
	{ -247, 1, YYAT_REDUCE, 37 },
	{ 0, 0, YYAT_REDUCE, 36 },
	{ 0, 0, YYAT_REDUCE, 40 },
	{ 0, 0, YYAT_REDUCE, 12 },
	{ 0, 0, YYAT_REDUCE, 14 },
	{ 0, 0, YYAT_REDUCE, 15 },
	{ 0, 0, YYAT_REDUCE, 16 },
	{ 0, 0, YYAT_REDUCE, 17 },
	{ -233, 1, YYAT_ERROR, 0 },
	{ -234, 1, YYAT_REDUCE, 39 },
	{ 0, 0, YYAT_REDUCE, 24 },
	{ -256, 1, YYAT_REDUCE, 25 },
	{ -261, 1, YYAT_REDUCE, 29 },
	{ 0, 0, YYAT_REDUCE, 33 },
	{ -235, 1, YYAT_ERROR, 0 },
	{ -238, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_REDUCE, 39 },
	{ -237, 1, YYAT_ERROR, 0 },
	{ -240, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_DEFAULT, 58 },
	{ -254, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_REDUCE, 18 },
	{ 0, 0, YYAT_REDUCE, 21 },
	{ 0, 0, YYAT_REDUCE, 30 },
	{ 0, 0, YYAT_REDUCE, 31 },
	{ 0, 0, YYAT_DEFAULT, 52 },
	{ 0, 0, YYAT_REDUCE, 34 },
	{ 0, 0, YYAT_REDUCE, 35 },
	{ -259, 1, YYAT_DEFAULT, 58 },
	{ 0, 0, YYAT_REDUCE, 11 },
	{ 0, 0, YYAT_REDUCE, 38 },
	{ 0, 0, YYAT_REDUCE, 20 },
	{ 0, 0, YYAT_REDUCE, 22 },
	{ -253, 1, YYAT_ERROR, 0 },
	{ -258, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_REDUCE, 37 },
	{ -268, 1, YYAT_REDUCE, 28 },
	{ 0, 0, YYAT_REDUCE, 32 },
	{ -253, 1, YYAT_ERROR, 0 },
	{ 0, 0, YYAT_REDUCE, 27 },
	{ 0, 0, YYAT_REDUCE, 23 }
};

int YYNEAR YYDCDECL yynontermgoto_size = 32;

YYCONST yynontermgoto_t YYNEARFAR YYBASED_CODE YYDCDECL yynontermgoto[] = {
	{ 15, 27 },
	{ 15, 28 },
	{ 15, 31 },
	{ 15, 29 },
	{ 15, 33 },
	{ 15, 30 },
	{ 15, 32 },
	{ 58, 63 },
	{ 58, 34 },
	{ 13, 14 },
	{ 58, 35 },
	{ 52, 40 },
	{ 58, 36 },
	{ 49, 60 },
	{ 13, 16 },
	{ 49, 37 },
	{ 13, 15 },
	{ 0, 2 },
	{ 0, 3 },
	{ 0, 4 },
	{ 52, 61 },
	{ 60, 52 },
	{ 43, 57 },
	{ 35, 49 },
	{ 24, 44 },
	{ 21, 41 },
	{ 19, 39 },
	{ 17, 38 },
	{ 11, 13 },
	{ 10, 12 },
	{ 7, 9 },
	{ 4, 6 }
};

YYCONST yystategoto_t YYNEARFAR YYBASED_CODE YYDCDECL yystategoto[] = {
	{ 16, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 27, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 25, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 23, -1 },
	{ 21, -1 },
	{ 0, -1 },
	{ 6, -1 },
	{ 0, -1 },
	{ -11, 58 },
	{ 0, -1 },
	{ 18, -1 },
	{ 0, -1 },
	{ 9, 58 },
	{ 0, -1 },
	{ 8, 58 },
	{ 0, -1 },
	{ 0, -1 },
	{ 5, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 2, -1 },
	{ 0, 60 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 5, 58 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ -9, 52 },
	{ 0, -1 },
	{ 0, -1 },
	{ -4, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ -10, 49 },
	{ 0, -1 },
	{ -2, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 },
	{ 0, -1 }
};

YYCONST yydestructor_t YYNEARFAR *YYNEAR YYDCDECL yydestructorptr = NULL;

YYCONST yytokendest_t YYNEARFAR *YYNEAR YYDCDECL yytokendestptr = NULL;
int YYNEAR YYDCDECL yytokendest_size = 0;

YYCONST yytokendestbase_t YYNEARFAR *YYNEAR YYDCDECL yytokendestbaseptr = NULL;
int YYNEAR YYDCDECL yytokendestbase_size = 0;
#line 462 ".\\cmmyacc.y"


void yyerror(char* message)
{
	printf("ERROR %d: Line %d: Syntax error from yacc.\n", ++nError, lineno);
}

/* 主函数 */
int main(int argc, char** argv)
{
	FILE* pf;
	char fileName[255];
	int i;
	
	fileName[0] = '\0';
	/* 判断传给main函数的参数 */
	if (argc < 2)
	{
		printf("Input the source file:\n");
		scanf("%s", fileName);		
	}
	else
	{
		strcpy(fileName, argv[1]);
	}
	
	yyin = fopen(fileName, "r");
	if (yyin == NULL)
	{
		printf("ERROR: Cannot open file %s.\n", fileName);
		return 1;
	}
	
	/* 用来产生生成文件的文件名 */
	for (i=strlen(fileName)-1; i>=0; i--)
	{
		if (fileName[i] == '.')
		{
			fileName[i] = '\0';
			break;
		}
		if (fileName[i] == '/' || fileName[i] == '\\')
		{
			break;
		}
	}
	
	if (yyparse() == 0)
	{
		fclose(yyin);
		
		if (hasReturn == 0)
		{
			printf("ERROR %d: No return statement.\n", ++nError);
		}
		
		if (nError == 0)
		{
			printf("\nEnd of program, parse successfully.\n");
			printf("Continue to generate code files...\n\n");
		}
		else
		{
			printf("\nParse wrong.\n\n");
			return 0;
		}
		
		strcat(fileName, ".t");	/* 打印符号表和语法树的文件的文件名 */
		pf = fopen(fileName, "w");
		if (pf == NULL)
		{
			printf("ERROR %d: Cannot open file %s.\n", ++nError, fileName);
			printf("Cannot write symbol table and syntax tree to file %s.\n", fileName);
			return 1;
		}
		
		/* 打印符号表和语法树到文件 */
		fprintf(pf, "Symble Table as Below:\n");
		printTable(tableHead, pf);
		fprintf(pf, "\nSyntax Tree as Below:\n");
		printTree(treeHead, pf);
		
		fclose(pf);
		
		fileName[strlen(fileName)-1] = 's';	/* 汇编代码所在的文件名 */
		codeGen(tableHead, treeHead, fileName);	/* 生成汇编代码 */
		
		if (nError == 0)
		{
			printf("End of compile, all successfully.\n");
			fileName[strlen(fileName)-1] = '\0';
			printf("%st and %ss have been generated.\n\n", fileName, fileName);
		}
		else
		{
			/* 删除文件 */
			printf("Generate compiled files wrong.\n\n");
			_unlink(fileName);
			fileName[strlen(fileName)-1] = 't';
			_unlink(fileName);
		}
	}
	else
	{
		printf("\nParse wrong.\n\n");
	}
	return 0;
}