node *CTfunbody(node *arg_node, info *arg_info){
DBUG_ENTER("CTfunbody");
FUNBODY_VARDEC(arg_node) = TRAVopt(FUNBODY_VARDEC(arg_node), arg_info);
FUNBODY_LOCALFUNDEFS(arg_node) = TRAVopt(FUNBODY_LOCALFUNDEFS(arg_node), arg_info);
FUNBODY_STATEMENT(arg_node) = TRAVopt(FUNBODY_STATEMENT(arg_node), arg_info);
DBUG_RETURN(arg_node);
}
node* CALCCONSTmonop(node *arg_node, info *arg_info){
DBUG_ENTER ("CALCCONSTmonop");
node * ret;
MONOP_EXPR( arg_node) = TRAVopt( MONOP_EXPR( arg_node), NULL);
nodetype nt = NODE_TYPE(MONOP_EXPR( arg_node));
if(MONOP_OP(arg_node) == MO_not && nt == N_bool){
ret = TBmakeBool(! BOOL_VALUE(MONOP_EXPR( arg_node)));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret);
}else if(MONOP_OP(arg_node) == MO_neg){
if(nt == N_int){
ret = TBmakeInt(-INT_VALUE(MONOP_EXPR( arg_node)));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret);
}else if(nt == N_float){
ret = TBmakeFloat(-FLOAT_VALUE(MONOP_EXPR( arg_node)));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret);
}else{
DBUG_RETURN (arg_node);
}
}else{
DBUG_RETURN (arg_node);
}
}
node *
PRTerror (node * arg_node, info * arg_info)
{
bool first_error;
DBUG_ENTER ("PRTerror");
if (NODE_ERROR (arg_node) != NULL) {
NODE_ERROR (arg_node) = TRAVdo (NODE_ERROR (arg_node), arg_info);
}
first_error = INFO_FIRSTERROR( arg_info);
if( (global.outfile != NULL)
&& (ERROR_ANYPHASE( arg_node) == global.compiler_anyphase)) {
if ( first_error) {
printf ( "\n/******* BEGIN TREE CORRUPTION ********\n");
INFO_FIRSTERROR( arg_info) = FALSE;
}
printf ( "%s\n", ERROR_MESSAGE( arg_node));
if (ERROR_NEXT (arg_node) != NULL) {
TRAVopt (ERROR_NEXT (arg_node), arg_info);
}
if ( first_error) {
printf ( "******** END TREE CORRUPTION *******/\n");
INFO_FIRSTERROR( arg_info) = TRUE;
}
}
DBUG_RETURN (arg_node);
}
node *LVARfunheader(node *arg_node, info *arg_info)
{
DBUG_ENTER("LVARfunheader");
FUNHEADER_PARAMS(arg_node) = TRAVopt(FUNHEADER_PARAMS(arg_node), arg_info);
DBUG_RETURN( arg_node);
}
node *LVARfundef( node *arg_node, info *arg_info)
{
DBUG_ENTER("LVARfundef");
arg_info->nest_level++;
FUNDEF_HEADER(arg_node) = TRAVopt( FUNDEF_HEADER( arg_node), arg_info);
FUNDEF_BODY(arg_node) = TRAVopt( FUNDEF_BODY( arg_node), arg_info);
/* empty hashmap of local variables */
hashmap_empty(arg_info->local);
arg_info->nest_level--;
DBUG_RETURN( arg_node);
}
node *LVARfuncall( node *arg_node, info *arg_info)
{
DBUG_ENTER("LVARfuncall");
/* traverse aguments of function call */
FUNCALL_ARGUMENTS(arg_node) = TRAVopt(FUNCALL_ARGUMENTS(arg_node), arg_info);
DBUG_RETURN( arg_node);
}
node *
PRTinstrs (node * arg_node, info * arg_info)
{
DBUG_ENTER ("PRTinstrs");
INSTRS_INSTR( arg_node) = TRAVdo( INSTRS_INSTR( arg_node), arg_info);
INSTRS_NEXT( arg_node) = TRAVopt( INSTRS_NEXT( arg_node), arg_info);
DBUG_RETURN (arg_node);
}
//check type of return of function against function type
node *CTfundef(node *arg_node, info *arg_info){
DBUG_ENTER("CTfundef");
INFO_HASRETURN(arg_info) = 0;
INFO_FUNTYPE(arg_info) = 999;
FUNDEF_FUNBODY(arg_node) = TRAVopt(FUNDEF_FUNBODY(arg_node), arg_info);
if(INFO_HASRETURN(arg_info) == 0){
INFO_FUNTYPE(arg_info) = T_unknown;
}
if(FUNDEF_TYPE(arg_node) != INFO_FUNTYPE(arg_info) && FUNDEF_EXTERN(arg_node) == FALSE){
CTIerrorLine(NODE_LINE(arg_node), "Return type does not match function type fun: %d ret: %d", FUNDEF_TYPE(arg_node), INFO_TYPE(arg_info));
}
DBUG_RETURN(arg_node);
}
//check vardec type with initialisation
node *CTvardec(node *arg_node, info *arg_info){
DBUG_ENTER("CTvardec");
//only check if there is a initialisation
if(VARDEC_INIT(arg_node)!= NULL){
VARDEC_INIT(arg_node) = TRAVdo(VARDEC_INIT(arg_node), arg_info);
type vartype = INFO_TYPE(arg_info);
if(vartype != VARDEC_TYPE(arg_node)){
CTIerrorLine(NODE_LINE(arg_node), "Initialisation value does not match the type of the declared variable");
}
}
//ga verder met traversal
VARDEC_NEXT(arg_node) = TRAVopt(VARDEC_NEXT(arg_node), arg_info);
DBUG_RETURN(arg_node);
}
node* CALCCONSTbinop(node *arg_node, info *arg_info){
DBUG_ENTER ("CALCCONSTbinop");
node * ret;
BINOP_LEFT( arg_node) = TRAVopt( BINOP_LEFT( arg_node), NULL);
BINOP_RIGHT( arg_node) = TRAVopt( BINOP_RIGHT( arg_node), NULL);
nodetype ntr = NODE_TYPE(BINOP_RIGHT( arg_node));
nodetype ntl = NODE_TYPE(BINOP_LEFT( arg_node));
if(ntr!= ntl || !(ntl==N_int || ntl==N_bool || ntl==N_float ))
DBUG_RETURN (arg_node);
if(ntl == N_bool){
bool l = BOOL_VALUE(BINOP_LEFT( arg_node));
bool r = BOOL_VALUE(BINOP_RIGHT( arg_node));
switch(BINOP_OP(arg_node)){
case BO_and:
DBISNS(TBmakeBool(r&&l));
break;
case BO_or:
DBISNS(TBmakeBool(r||l));
break;
case BO_ne:
DBISNS(TBmakeBool(r != l));
break;
case BO_eq:
DBISNS(TBmakeBool(r==l));
break;
case BO_add:
DBISNS(TBmakeBool(r | l));
break;
case BO_mul:
DBISNS(TBmakeBool(r & l));
break;
default:
DBUG_RETURN(arg_node);
break;
}
}else if(ntl == N_int){
int l = INT_VALUE(BINOP_LEFT( arg_node));
int r = INT_VALUE(BINOP_RIGHT( arg_node));
switch(BINOP_OP(arg_node)){
case BO_add:
DBISNS(TBmakeInt(r+l));
break;
case BO_sub:
DBISNS(TBmakeInt(r-l));
break;
case BO_mul:
DBISNS(TBmakeInt(r*l));
break;
case BO_div:
if (r != 0)
{
DBISNS(TBmakeInt(l/r));
}
break;
case BO_mod:
DBISNS(TBmakeInt(l % r));
break;
case BO_lt:
DBISNS(TBmakeBool(l < r));
break;
case BO_le:
DBISNS(TBmakeBool(l<=r));
break;
case BO_gt:
DBISNS(TBmakeBool(l>r));
break;
case BO_ge:
DBISNS(TBmakeBool(l>=r));
break;
case BO_eq:
DBISNS(TBmakeBool(l==r));
break;
case BO_ne:
DBISNS(TBmakeBool(l != r));
break;
default:
DBUG_RETURN (arg_node);
break;
}
}else if(ntl == N_float){
float l = FLOAT_VALUE(BINOP_LEFT( arg_node));
float r = FLOAT_VALUE(BINOP_RIGHT( arg_node));
switch(BINOP_OP(arg_node)){
case BO_add:
DBISNS(TBmakeFloat(r+l));
break;
case BO_sub:
DBISNS(TBmakeFloat(r-l));
break;
case BO_mul:
DBISNS(TBmakeFloat(r*l));
break;
case BO_div:
if (r != 0.0f)
{
DBISNS(TBmakeFloat(l/r));
}
break;
case BO_lt:
DBISNS(TBmakeBool(l < r));
break;
case BO_le:
DBISNS(TBmakeBool(l<=r));
break;
case BO_gt:
DBISNS(TBmakeBool(l>r));
break;
case BO_ge:
DBISNS(TBmakeBool(l>=r));
break;
case BO_eq:
DBISNS(TBmakeBool(l==r));
break;
case BO_ne:
DBISNS(TBmakeBool(l != r));
break;
default:
DBUG_RETURN (arg_node);
break;
}
}
DBUG_RETURN (arg_node);
}
node* CALCCONSTcast(node *arg_node, info *arg_info){
DBUG_ENTER ("CALCCONSTcast");
CAST_EXPR( arg_node) = TRAVopt( CAST_EXPR( arg_node), NULL);
node * ret;
switch(NODE_TYPE(CAST_EXPR( arg_node))){
case N_bool:
switch(CAST_TYPE(arg_node)){
case VT_bool:
//no cast needed
ret = CAST_EXPR( arg_node);
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
case VT_int:
//FREEcast(arg_node);
ret = TBmakeInt((int)BOOL_VALUE(CAST_EXPR( arg_node)));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
case VT_float:
//FREEcast(arg_node);
ret = TBmakeFloat((float)BOOL_VALUE(CAST_EXPR( arg_node)));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
default:
DBUG_RETURN(arg_node);
}
break;
case N_int:
switch(CAST_TYPE(arg_node)){
case VT_bool:
ret =TBmakeBool(INT_VALUE(CAST_EXPR( arg_node)));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
case VT_int:
//no cast needed
ret = CAST_EXPR( arg_node);
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
case VT_float:
ret =TBmakeFloat((float)INT_VALUE(CAST_EXPR( arg_node) ));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
default:
DBUG_RETURN(arg_node);
}
break;
case N_float:
switch(CAST_TYPE(arg_node)){
case VT_bool:
ret =TBmakeBool(FLOAT_VALUE(CAST_EXPR( arg_node)));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
case VT_int:
ret =TBmakeInt(FLOAT_VALUE(CAST_EXPR( arg_node)));
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
case VT_float:
//no cast needed
ret = CAST_EXPR( arg_node);
FREEdoFreeNode(arg_node);
DBUG_RETURN(ret );
break;
default:
DBUG_RETURN(arg_node);
}
break;
default:
DBUG_RETURN(arg_node);
}
}
