decafcparser.y

decafc的源代码

		  yyless(0);	/* unread "}" */
		  ReportError(ERROR_INVALID_STATEMENT,
			      NULL,
			      currentLineNumber,
			      currentColumnNumber);

		  $$.nodePtr = CreateNode(NODE_TYPE_ERROR, 0);
		}
  ;

Name :
	VariableAccess
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_NAME,
					  1,
					  $1.nodePtr);
		}
  |	VariableAccess TOKEN_OP_DOT Name
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_NAME,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		}
  ;

VariableAccess :
	TOKEN_KW_THIS
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	TOKEN_IDENTIFIER
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	ArrayAccess
		{
		  $$.nodePtr = $1.nodePtr;
		}
  ;

ArrayAccess :
	StartArray Expression TOKEN_OP_RIGHT_SQUARE_BRACKET
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_ARRAY_ACCESS,
					  2,
					  $1.nodePtr,
					  $2.nodePtr);
		}
  |	ArrayAccess
	TOKEN_OP_LEFT_SQUARE_BRACKET
		Expression
	TOKEN_OP_RIGHT_SQUARE_BRACKET
		{
		  $$.nodePtr = MergeSubTrees(NODE_TYPE_ARRAY_ACCESS,
					     2,
					     $1.nodePtr,
					     $3.nodePtr);

		}
  ;

ArgList :
	/* empty production */
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_ARG_LIST,
					  1,
					  NULL);
		}
  |	Expression RemainingArgList
		{
		  ReplaceNode(NODE_TYPE_ARG_LIST, $2.nodePtr);
		  $$.nodePtr = MergeSubTrees(NODE_TYPE_ARG_LIST,
					     2,
					     $1.nodePtr,
					     $2.nodePtr);
		}
  |	error TOKEN_OP_RIGHT_PARENTHESIS
                {
                  yyclearin;
                  yyerrok;
		  yyless(0);	/* unread ")" */
		  ReportError(ERROR_INVALID_ARG_LIST,
			      NULL,
			      currentLineNumber,
			      currentColumnNumber);

		  nodePtr = CreateNode(NODE_TYPE_ERROR, 0);
                  $$.nodePtr = CreateNode(NODE_TYPE_ARG_LIST,
					  1,
                                          nodePtr);
                }
  ;

RemainingArgList :
	/* empty production */
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_R_ARG_LIST,
					  1,
					  NULL);
		}
  |	TOKEN_OP_COMMA Expression RemainingArgList
		{
		  $$.nodePtr = MergeSubTrees(NODE_TYPE_R_ARG_LIST,
					     2,
					     $2.nodePtr,
					     $3.nodePtr);
		}
  ;

ConditionalStatement :
	TOKEN_KW_IF
	TOKEN_OP_LEFT_PARENTHESIS
		Expression
	TOKEN_OP_RIGHT_PARENTHESIS
	Statement %prec LOWER_THAN_ELSE
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_IF_STMT,
					  3, 
					  $3.nodePtr,
					  $5.nodePtr,
					  NULL);
		}
  |	TOKEN_KW_IF
	TOKEN_OP_LEFT_PARENTHESIS Expression TOKEN_OP_RIGHT_PARENTHESIS
		Statement
	TOKEN_KW_ELSE
		Statement
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_IF_STMT,
					  3,
					  $3.nodePtr,
					  $5.nodePtr,
					  $7.nodePtr);
		}
  ;

OptionalExpression :
	/* empty production */
		{
		  $$.nodePtr = NULL;
		}
  |	Expression
		{
		  $$.nodePtr = $1.nodePtr;
		}
  ;

Expression :
	Name
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	TOKEN_NUMBER
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	TOKEN_KW_NULL
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	Name TOKEN_OP_LEFT_PARENTHESIS ArgList TOKEN_OP_RIGHT_PARENTHESIS
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_FUNCTION_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		}
  |	TOKEN_KW_READ TOKEN_OP_LEFT_PARENTHESIS TOKEN_OP_RIGHT_PARENTHESIS
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_READ_EXP, 0);
		}
  |	NewExpression
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	UnaryExpression
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	RelationExpression
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	SumExpression
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	ProductExpression
		{
		  $$.nodePtr = $1.nodePtr;
		}
  |	TOKEN_OP_LEFT_PARENTHESIS Expression TOKEN_OP_RIGHT_PARENTHESIS  
		{
		  $$.nodePtr = $2.nodePtr;
		}
  ;

NewExpression :
	TOKEN_KW_NEW SimpleType
	TOKEN_OP_LEFT_PARENTHESIS ArgList TOKEN_OP_RIGHT_PARENTHESIS
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_NEW_EXP,
					  2,
					  $2.nodePtr,
					  $4.nodePtr);
		}
  |	TOKEN_KW_NEW SimpleType
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_NEW_EXP,
					  3,
					  $2.nodePtr,
					  NULL,
					  NULL);
		}
  |	TOKEN_KW_NEW SimpleType IndexList
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_NEW_EXP,
					  3,
					  $2.nodePtr,
					  $3.nodePtr,
					  NULL);
		}
  |	TOKEN_KW_NEW SimpleType EmptyIndexList
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_NEW_EXP,
					  3,
					  $2.nodePtr,
					  NULL,
					  $3.nodePtr);
		}
  |	TOKEN_KW_NEW SimpleType IndexList EmptyIndexList
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_NEW_EXP,
					  3,
					  $2.nodePtr,
					  $3.nodePtr,
					  $4.nodePtr);
		}
  ;

IndexList :
	Index
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_INDEX_LIST,
					  1,
					  $1.nodePtr);
		}
  |	IndexList Index
		{
		  $$.nodePtr = MergeSubTrees(NODE_TYPE_INDEX_LIST,
					     2,
					     $1.nodePtr,
					     $2.nodePtr);
		}
  ;

Index :
	TOKEN_OP_LEFT_SQUARE_BRACKET Expression TOKEN_OP_RIGHT_SQUARE_BRACKET
		{
		  $$.nodePtr = $2.nodePtr;
		}
  ;

EmptyIndexList :
	EmptyIndex
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EMPTY_INDEX_LIST,
					  1,
					  $1.nodePtr);
		}
  |	EmptyIndexList EmptyIndex
		{
		  $$.nodePtr = MergeSubTrees(NODE_TYPE_EMPTY_INDEX_LIST,
					     2,
					     $1.nodePtr,
					     $2.nodePtr);
		}
  ;

EmptyIndex :
	TOKEN_OP_LEFT_SQUARE_BRACKET TOKEN_OP_RIGHT_SQUARE_BRACKET
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EMPTY_INDEX, 0);
		}
  ;

UnaryExpression :

	/* unary plus has the same precedence as not */

	TOKEN_OP_PLUS Expression %prec TOKEN_OP_NOT
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_UNARY_EXP,
					  1,
					  $2.nodePtr);
		  $$.nodePtr->info.lexeme = strdup($1.nodePtr->info.lexeme);

		  OptimizeUnaryPlusExp(&($$.nodePtr));
		}

	/* unary minus has the same precedence as not */

  |	TOKEN_OP_MINUS Expression %prec TOKEN_OP_NOT
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_UNARY_EXP,
					  1,
					  $2.nodePtr);
		  $$.nodePtr->info.lexeme = strdup($1.nodePtr->info.lexeme);

		  OptimizeUnaryMiusExp(&($$.nodePtr));
		}
  |	TOKEN_OP_NOT Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_UNARY_EXP,
					  1,
					  $2.nodePtr);
		  $$.nodePtr->info.lexeme = strdup($1.nodePtr->info.lexeme);

		  OptimizeNotExp(&($$.nodePtr));
		}
  ;

RelationExpression :
	Expression TOKEN_OP_EQUAL Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeEqualExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_NOT_EQUAL Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeNotEqualExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_LESS_OR_EQUAL Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeLessEqualExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_GREATER_OR_EQUAL Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeGreaterEqualExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_LESS Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeLessExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_GREATER Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeGreaterExp(&($$.nodePtr));
		}
  ;

SumExpression :
	Expression TOKEN_OP_PLUS Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizePlusExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_MINUS Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeMinusExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_OR Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeOrExp(&($$.nodePtr));
		}
  ;

ProductExpression :
	Expression TOKEN_OP_MULTIPLY Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeMultiplyExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_DIVIDE Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeDivideExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_MODULAR Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeModularExp(&($$.nodePtr));
		}
  |	Expression TOKEN_OP_AND Expression
		{
		  $$.nodePtr = CreateNode(NODE_TYPE_EXP,
					  2,
					  $1.nodePtr,
					  $3.nodePtr);
		  $$.nodePtr->info.lexeme =strdup($2.nodePtr->info.lexeme);

		  OptimizeAndExp(&($$.nodePtr));
		}
  ;
%%

main(int	argc,
     char	**argv)
{
	#ifdef YYDEBUG
	yydebug = 1;
	#else
	yydebug = 0;
	#endif

	if (argc != 3) {
		fprintf(stderr,
			"Usage: %s source_file header_file\n",
			argv[0]);
		exit(1);
	}

	CFileFp = fopen(argv[1], "w");

	if (CFileFp == NULL) {
		fprintf(stderr,
			"Can not open file %s\n",
			argv[1]);
		exit(1);
	}

	HFileFp = fopen(argv[2], "w");

	if (HFileFp == NULL) {
		fprintf(stderr,
			"Can not open file %s\n",
			argv[2]);
		exit(1);
	}

	HFileName = strdup(argv[2]);

	typeSymbolTable = NewSymbolTable(SYMBOL_TABLE_SIZE);
	intTypePtr = Insert(typeSymbolTable, "int", 0, NULL);
	voidTypePtr = Insert(typeSymbolTable, "void", 0, NULL);
	refTypePtr = Insert(typeSymbolTable, "*", 0, NULL);
	unknownTypePtr = Insert(typeSymbolTable, "", 0, NULL);

	currentClassSymbolTable = NewSymbolTable(SYMBOL_TABLE_SIZE);
	currentParameterSymbolTable = NewSymbolTable(SYMBOL_TABLE_SIZE);
	currentBlockSymbolTable = NewSymbolTable(SYMBOL_TABLE_SIZE);
	NewSymbolTableStack(symbolTableStackPtr);

	/* get the first line of the source file */

	GetNextLine();

	/* begin the parsing */

	yyparse();

	if (rootNodePtr == NULL) {

		/* the parse tree is not completely built because of errors
		   build an empty tree */

		ReportError(ERROR_INCOMPLETE_FILE,
			    NULL,
			    currentLineNumber,
			    currentColumnNumber);
		nodePtr = CreateNode(NODE_TYPE_ERROR, 0);
		rootNodePtr = CreateNode(NODE_TYPE_PROGRAM,
					 1,
					 nodePtr);
	}
    
	SemanticCheck(rootNodePtr);

	#ifdef DEBUG
	printf("\nType symbol table:\n");
	DisplaySymbolTable(typeSymbolTable);
	#endif

	/* display the parse tree */

	#ifdef DEBUG
	printf("Abstract Syntax Tree:\n");
	DisplayASTree(rootNodePtr);
	#endif

	if (errorNumber == 0) {
		GenerateCode(rootNodePtr);
	}

	fclose(CFileFp);
	fclose(HFileFp);

	/* delete the parse tree to free memory */

	DeleteASTree(rootNodePtr);
}