semantic.cpp

现代编译原理C语言实现中的第二章的编译器实现。并在书中的基础上有所改变。包括词法语法分析及汇编代码生成。

#include "StdAfx.h"
#include ".\semantic.h"

#include "SymbolTable.h"

#define  DEBUG true

Semantic::Semantic(void)
{
}

Semantic::~Semantic(void)
{
}
// Lex
extern token current_token;
extern Word  g_token;
// Symboltable
extern void  init_global_symboltable();
extern void  init_local_symboltable();
extern Symbol *	lookup(cstr s);
extern void		enter(cstr s, token t);
extern char * extract(expr_rec & s);
extern char * extract(op_rec   & op);
extern bool   out2file;
//////////////////////////////////////////////////////////////////
Level  curLevel; // GLOBAL  LOCAL


// Generate the tempary var name
char * get_temp(void) {
	static int  max_temp = 0;
	static char tempname[WORD_LEN];

	max_temp++;
	sprintf(tempname, "Temp&%d", max_temp);
	check_id(tempname);
	return tempname;
}
void   check_id(cstr s) {
	if( ! lookup(s) ) {
		enter( s, ID );
		generate("Declare", s, "Integer", "");
	}
}
void   check_intliteral(int v) {
	if( ! lookup(v) ) {
		enter( v );
	}
}
/*
void   check_func_def(cstr s) {
	if( ! lookup(s) ) {
		enter( s, FUNCTION );
	}
}*/
void  start(void) {
	init_global_symboltable();
	init_local_symboltable();
}
void  finish(void) {
	// Generate code to finish program
	generate("Halt", "", "", "");
}
void  assign(expr_rec target, expr_rec source) {
	generate("Store", extract(source), target.name, "");
}
op_rec  process_op(void) {
	op_rec  o;
	if( current_token == PLUSOP ) {
		o.operType = PLUS;
	}
	else if( current_token == MINUSOP ) {
		o.operType = MINUS;
	}
	else if( current_token == MULOP ) {
		o.operType = MUL;
	}
	else if( current_token == DIVOP ) {
		o.operType = DIV;
	} else {
		fprintf(stderr, "cur_token:%d\n", current_token);
		error("Unexpected operator");
	}
	return o;
}
expr_rec  process_id(void) {
	expr_rec t;
	check_id(g_token.buf);//check_id(token_buffer);
	t.kind  =  IDEXPR;
	strcpy(t.name, g_token.buf);//strcpy(t.name, token_buffer);
	return t;
}
expr_rec  process_literal(void) {
	expr_rec  t;
	t.kind = LITERALEXPR;
	sscanf(g_token.buf, "%d", & t.val);//sscanf(token_buffer, "%d", & t.val);
	check_intliteral(t.val); //  added by me
	return t;
}
void		gen_func_name(expr_rec & fdef) { // new added
	if( lookup( fdef.name ) ) {
		char buf[100];
		sprintf(buf, "name:%s has defined", fdef.name);
		semantic_error(&buf[0]);
	}
	strcpy( fdef.name, g_token.buf );
	enter( fdef.name, FUNCTION );// add to the symbol table
	generate("Declare", fdef.name, "function", "");
}
void		process_func_call(void) { // new added
}
void        process_param() { // new added
}
void		process_argu() { // new added
}

expr_rec  gen_infix(expr_rec & e1, op_rec & op, expr_rec & e2) {
	expr_rec  e_rec;
	e_rec.kind = TEMPEXPR;
	strcpy(e_rec.name, get_temp());
	generate( extract(op), extract(e1), extract(e2), e_rec.name);
	return e_rec;
}

void  read_id(expr_rec & in_var) {
	generate("Read", in_var.name, "Integer", "");
}
void  write_expr(expr_rec & out_expr) {
	generate("Write", extract(out_expr), "Integer", "");
}
void   generate(char * op, char * A, char * B, char * C) {
	if(strlen(C) > 0) {
		printf("%s\t%s,\t%s,\t%s\n", op, A, B, C);
		if( out2file )
			fprintf(stderr, "[ Gen ] %s\t%s,\t%s,\t%s\n", op, A, B, C);
	}
	else {
		if( strlen(B) > 0) {
			printf("%s\t%s,\t%s\n", op, A, B);
			if( out2file )
				fprintf(stderr, "[ Gen ] %s\t%s,\t%s\n", op, A, B);
		}
		else {
			printf("%s\t%s\n", op, A);
			if( out2file )
				fprintf(stderr, "[ Gen ] %s\n", op, A, B);
		}
	}
}

void		semantic_error(char * s) {
	fprintf(stderr, "[ Semantic Error ] - text:%s\n", s);
	exit(5);
}