www.pudn.com > Micro.rar > Semantic.cpp

#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); 
}