TAC* generateCode(TREE* node)
{
int i;
TAC *code[MAX_CHILDREN], *generatedCode;
if (!node)
return NULL;
for (i=0; i<MAX_CHILDREN; i++) {
if (node->children[i])
code[i] = generateCode(node->children[i]);
else
code[i] = 0;
}
switch (node->type) {
case TREE_SYMBOL:
return tacCreate(TAC_SYMBOL, node->symbol, 0, 0);
case TREE_VAL_TRUE:
return tacCreate(TAC_SYMBOL, gbl_value_true, 0, 0);
case TREE_VAL_FALSE:
return tacCreate(TAC_SYMBOL, gbl_value_false, 0, 0);
case TREE_DECL_FUNC:
return tacJoin3(
tacCreate(TAC_BEGINFUN, 0, node->children[1]?node->children[1]->symbol:0, 0),
code[3],
tacCreate(TAC_ENDFUN, 0, node->children[1]?node->children[1]->symbol:0, 0)
);
case TREE_COMM_NOP:
return tacCreate(TAC_NOP, 0, 0, 0);
case TREE_COMM_IN:
generatedCode = makeParameters(node, TAC_READ); // The code of the expressions in the parameters
return generatedCode;
case TREE_COMM_OUT:
generatedCode = makeParameters(node, TAC_PRINT);
return generatedCode; // The code of the expressions in the parameters
case TREE_COMM_ASSIG:
return tacJoin(code[1],
tacCreate(TAC_MOVE, code[0]?code[0]->res:0, code[1]?code[1]->res:0, 0)
);
case TREE_COMM_ASSIG_VEC:
return tacJoin3(code[1],
code[2],
tacCreate(TAC_STRIDX, code[0]?code[0]->res:0, code[1]?code[1]->res:0, code[2]?code[2]->res:0)
);
case TREE_COMM_IF_ELSE:
return makeIfThenElse(code[0], code[1], code[2]);
case TREE_COMM_WHILE:
return makeWhile(code[0], code[1]);
case TREE_COMM_RETURN:
return tacJoin(code[0],
tacCreate(TAC_RET, 0, code[0]?code[0]->res:0, 0));
case TREE_EXPR_ARIT_FUNCALL:
return tacJoin(makeParameters(node, TAC_ARG), // The code of the expressions in the parameters
tacCreate(TAC_CALL, hash_make_temp(), code[0]?code[0]->res:0, 0));
case TREE_EXPR_ARIT_VEC_READ:
return tacJoin(code[1],
tacCreate(TAC_LOADIDX, hash_make_temp(), code[0]?code[0]->res:0, code[1]?code[1]->res:0)
);
break;
case TREE_EXPR_ARIT_ADD:
return makeBinOp(TAC_ADD, code[0], code[1]);
case TREE_EXPR_ARIT_SUB:
return makeBinOp(TAC_SUB, code[0], code[1]);
case TREE_EXPR_ARIT_MUL:
return makeBinOp(TAC_MUL, code[0], code[1]);
case TREE_EXPR_ARIT_DIV:
return makeBinOp(TAC_DIV, code[0], code[1]);
case TREE_EXPR_BOOL_LT:
return makeLogicOp(TAC_LTZ, code[0], code[1]);
case TREE_EXPR_BOOL_GT:
return makeLogicOp(TAC_GTZ, code[0], code[1]);
case TREE_EXPR_BOOL_LE:
return makeLogicOp(TAC_LEZ, code[0], code[1]);
case TREE_EXPR_BOOL_GE:
return makeLogicOp(TAC_GEZ, code[0], code[1]);
case TREE_EXPR_BOOL_EQ:
return makeLogicOp(TAC_EQZ, code[0], code[1]);
case TREE_EXPR_BOOL_NE:
return makeLogicOp(TAC_ANEG, code[0],code[1]);
case TREE_EXPR_BOOL_AND:
return makeLogicOp(TAC_AND, code[0], code[1]);
case TREE_EXPR_BOOL_OR:
return makeLogicOp(TAC_OR, code[0], code[1]);
default:
break;
}
return tacJoin4(code[0], code[1], code[2], code[3]);
}
/** Parse with one token worth of look-ahead, return the expression object representing
the syntax parsed.
@param tok next token from the input.
@param fp file subsequent tokens are being read from.
@return the expression object constructed from the input.
*/
Expr *parse( char *tok, FILE *fp )
{
// Create a literal token for anything that looks like a number.
{
long dummy;
int pos;
// See if the whole token parses as a long int.
if ( sscanf( tok, "%ld%n", &dummy, &pos ) == 1 &&
pos == strlen( tok ) ) {
// Copy the literal to a dynamically allocated string, since makeLiteral wants
// a string it can keep.
char *str = (char *) malloc( strlen( tok ) + 1 );
return makeLiteral( strcpy( str, tok ) );
}
}
// Create a literal token for a quoted string, without the quotes.
if ( tok[ 0 ] == '"' ) {
// Same as above, make a dynamically allocated copy of the token that the literal
// expression can keep as long as at wants to.
int len = strlen( tok );
char *str = (char *) malloc( len - 1 );
strncpy( str, tok + 1, len - 2 );
str[ len - 2 ] = '\0';
return makeLiteral( str );
}
// Handle compound statements
if ( strcmp( tok, "{" ) == 0 ) {
int len = 0;
int cap = INITIAL_CAPACITY;
Expr **eList = (Expr **) malloc( cap * sizeof( Expr * ) );
// Keep parsing subexpressions until we hit the closing curly bracket.
while ( strcmp( expectToken( tok, fp ), "}" ) != 0 ) {
if ( len >= cap )
eList = (Expr **) realloc( eList, ( cap *= 2 ) * sizeof( Expr * ) );
eList[ len++ ] = parse( tok, fp );
}
return makeCompound( eList, len );
}
// Handle language operators (reserved words)
if ( strcmp( tok, "print" ) == 0 ) {
// Parse the one argument to print, and create a print expression.
Expr *arg = parse( expectToken( tok, fp ), fp );
return makePrint( arg );
}
if ( strcmp( tok, "set" ) == 0 ) {
// Parse the two operands, then make a set expression with them.
char *str = expectToken( tok, fp );
int len = strlen( str );
char *name = (char *) malloc( len + 1 );
strcpy( name, str );
name[ len ] = '\0';
if ( !isalpha(name[0]) || strlen( name ) > MAX_VAR || strchr( name, LEFT_BRACKET ) || strchr( name, RIGHT_BRACKET ) || strchr( name, POUND ) ) {
// Complain if we can't make sense of the variable.
fprintf( stderr, "line %d: invalid variable name \"%s\"\n", linesRead(), name );
exit( EXIT_FAILURE );
}
Expr *expr = parse( expectToken( tok, fp ), fp );
Expr *set = makeSet
( name, expr );
free(name);
return set;
}
if ( strcmp( tok, "add" ) == 0 ) {
// Parse the two operands, then make an add expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeAdd( op1, op2 );
}
if ( strcmp( tok, "sub" ) == 0 ) {
// Parse the two operands, then make a sub expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeSub( op1, op2 );
}
if ( strcmp( tok, "mul" ) == 0 ) {
// Parse the two operands, then make a mul expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeMul( op1, op2 );
}
if ( strcmp( tok, "div" ) == 0 ) {
// Parse the two operands, then make a div expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeDiv
( op1, op2 );
}
if ( strcmp( tok, "equal" ) == 0 ) {
// Parse the two operands, then make an equal expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeEqual
( op1, op2 );
}
if ( strcmp( tok, "less" ) == 0 ) {
// Parse the two operands, then make a less expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeLess
( op1, op2 );
}
if ( strcmp( tok, "not" ) == 0 ) {
// Parse the operand, then make a not expression with it.
Expr *op = parse( expectToken( tok, fp ), fp );
return makeNot
( op );
}
if ( strcmp( tok, "and" ) == 0 ) {
// Parse the two operands, then make an and expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeAnd
( op1, op2 );
}
if ( strcmp( tok, "or" ) == 0 ) {
// Parse the two operands, then make an or expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeOr
( op1, op2 );
}
if ( strcmp( tok, "if" ) == 0 ) {
// Parse the two operands, then make an if expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeIf
( op1, op2 );
}
if ( strcmp( tok, "while" ) == 0 ) {
// Parse the two operands, then make a while expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeWhile
( op1, op2 );
}
if ( strcmp( tok, "concat" ) == 0 ) {
// Parse the two operands, then make a concatenation expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
return makeConcat
( op1, op2 );
}
if ( strcmp( tok, "substr" ) == 0 ) {
// Parse the three operands, then make a substring expression with them.
Expr *op1 = parse( expectToken( tok, fp ), fp );
Expr *op2 = parse( expectToken( tok, fp ), fp );
Expr *op3 = parse( expectToken( tok, fp ), fp );
return makeSubstr
( op1, op2, op3 );
}
// Handle variables
if ( isalpha(tok[0]) && strlen( tok ) <= MAX_VAR && !strchr( tok, LEFT_BRACKET ) && !strchr( tok, RIGHT_BRACKET ) && !strchr( tok, POUND ) ) {
// Parse the variable name and make a variable expression.
char *str = tok;
int len = strlen( str );
char *name = (char *) malloc( len + 1 );
strcpy( name, str );
name[ len ] = '\0';
Expr *var = makeVariable( name );
free(name);
return var;
}
// Complain if we can't make sense of the token.
fprintf( stderr, "line %d: invalid token \"%s\"\n", linesRead(), tok );
exit( EXIT_FAILURE );
// Never reached.
return NULL;
}
