void Interpret(char expr[])
{
SetIntSignal(True);
if(commandline(expr))
;
else if(seterror()==0)
{
initstack();
restoretemplates();
CloseAllIOFiles();
interrupted = False;
if(parseinput(expr))
checkexpression(top(), True);
else
{
checkexpression(top(), False);
settop(modify_expression(top()));
starttiming();
toplevel();
stoptiming();
}
}
SetIntSignal(False);
initstack();
restoretemplates();
CloseAllIOFiles();
interrupted = False;
Write("\n");
}
void checkexpression( Expression * expr, SymbolTable * table ,HashTable *Htable)//changed
{
IdName c;
if(expr->leftOperand == NULL && expr->rightOperand == NULL){
switch(expr->v.type){
case Identifier:
//c = expr->v.val.id;
strcpy(c, expr->v.val.id);
printf("identifier : %s\n",c);
expr->type = lookup_table(table, c,Htable);
break;
case IntConst:
printf("constant : int\n");
expr->type = Int;
break;
case FloatConst:
printf("constant : float\n");
expr->type = Float;
break;
//case PlusNode: case MinusNode: case MulNode: case DivNode:
default:
break;
}
}
else{
Expression *left = expr->leftOperand;
Expression *right = expr->rightOperand;
checkexpression(left, table,Htable);
checkexpression(right, table,Htable);
DataType type = generalize(left, right);
convertType(left, type);//left->type = type;//converto
convertType(right, type);//right->type = type;//converto
expr->type = type;
}
}
void checkexpression( Expression * expr, SymbolTable * table )
{
char name[256];
if(expr->leftOperand == NULL && expr->rightOperand == NULL){
switch(expr->v.type){
case Identifier:
strcpy(name, expr->v.val.id);
expr->v.val.regId = variableToRegister(table, name);
printf("identifier : %s(%c)\n", name, expr->v.val.regId);
expr->type = lookup_table(table, name);
break;
case IntConst:
printf("constant : int\n");
expr->type = Int;
break;
case FloatConst:
printf("constant : float\n");
expr->type = Float;
break;
//case PlusNode: case MinusNode: case MulNode: case DivNode:
default:
break;
}
}
else{
Expression *left = expr->leftOperand;
Expression *right = expr->rightOperand;
checkexpression(left, table);
checkexpression(right, table);
DataType type = generalize(left, right);
convertType(left, type);//left->type = type;//converto
convertType(right, type);//right->type = type;//converto
expr->type = type;
}
}
void checkstmt( Statement *stmt, SymbolTable * table, HashTable *Htable)//changed
{
if(stmt->type == Assignment){
AssignmentStatement assign = stmt->stmt.assign;
printf("assignment : %s \n",assign.id);//changed
checkexpression(assign.expr, table,Htable);
stmt->stmt.assign.type = lookup_table(table, assign.id,Htable);
if (assign.expr->type == Float && stmt->stmt.assign.type == Int) {
printf("error : can't convert float to integer\n");
} else {
convertType(assign.expr, stmt->stmt.assign.type);
}
}
else if (stmt->type == Print){
printf("print : %s \n",stmt->stmt.variable);//changed
lookup_table(table, stmt->stmt.variable, Htable);
}
else printf("error : statement error\n");//error
}
void checkexpression( Expression * expr, SymbolTable * table )
{
char *c;
if(expr->leftOperand == NULL && expr->rightOperand == NULL){
switch(expr->v.type){
case Identifier:
c = expr->v.val.id;
printf("identifier : %s\n",c);
expr->type = lookup_table(table, c);
break;
case IntConst:
printf("constant : int\n");
expr->type = Int;
break;
case FloatConst:
printf("constant : float\n");
expr->type = Float;
break;
//case PlusNode: case MinusNode: case MulNode: case DivNode:
default:
break;
}
}
else if (expr->rightOperand == NULL){
checkexpression(expr->leftOperand, table);
expr->type = expr->leftOperand->type;
}
else{
Expression *left = expr->leftOperand;
Expression *right = expr->rightOperand;
checkexpression(left, table);
checkexpression(right, table);
DataType type = generalize(left, right);
convertType(left, type);//left->type = type;//converto
convertType(right, type);//right->type = type;//converto
expr->type = type;
// constant folding
switch (expr->v.type) {
case PlusNode: case MinusNode: case MulNode: case DivNode:
if (type == Int && left->v.type == IntConst && right->v.type == IntConst) {
int *a = &left->v.val.ivalue;
int *b = &right->v.val.ivalue;
int *c = &expr->v.val.ivalue;
char op;
// c = a <op> b
switch (expr->v.type) {
case PlusNode:
*c = *a + *b;
op = '+';
break;
case MinusNode:
*c = *a - *b;
op = '-';
break;
case MulNode:
*c = *a * *b;
op = '*';
break;
case DivNode:
*c = *a / *b;
op = '/';
break;
default:
break;
}
expr->v.type = IntConst;
expr->leftOperand = expr->rightOperand = NULL;
printf("After constant folding: %d %c %d = %d\n", *a, op, *b, *c);
}
else if (type == Float && left->v.type == FloatConst && right->v.type == FloatConst) {
float *a = &left->v.val.fvalue;
float *b = &right->v.val.fvalue; // c = a <op> b
float *c = &expr->v.val.fvalue;
char op;
switch (expr->v.type) {
case PlusNode:
*c = *a + *b;
op = '+';
break;
case MinusNode:
*c = *a - *b;
op = '-';
break;
case MulNode:
*c = *a * *b;
op = '*';
break;
case DivNode:
*c = *a / *b;
op = '/';
break;
default:
break;
}
expr->v.type = FloatConst;
expr->leftOperand = expr->rightOperand = NULL;
printf("After constant folding: %f %c %f = %f\n", *a, op, *b, *c);
}
break;
default:
break;
}
}
}
