/*****************************************************
* recognize switch statement *
*****************************************************/
void CompField::VisitSwitch(StmtSwitch *swStmt)
{
nbASSERT(swStmt != NULL, "StmtSwitch cannot be NULL");
#ifdef DEBUG_COMPACT_FIELDS
PrintNode(swStmt->Forest,"Debug_List_of_Switch_nodes.asm",0);
#endif
if(checkingloop>0)
ExtractFieldsFromExpr(swStmt->Forest,&m_symboltemp);
VisitTree(swStmt->Forest); //Visit SWITCH Condition
VisitCode(swStmt->Cases); //Visit Cases
StartCheck(NULL);
if (swStmt->Default)
VisitCase(swStmt->Default, true); //Visit Default
StartCheck(NULL);
}
void CompField::VisitStatement(StmtBase *stmt)
{
nbASSERT(stmt != NULL , "stmt cannot be NULL");
//Start STATEMENT CHECK:
//if this statement it's not GEN -> means that can't be a DEFFLD! -> we must "close" compattable-fixed-field-list!!!!
if(stmt->Kind!=STMT_GEN)
StartCheck(NULL);
//End of STATEMENT CHECK
switch(stmt->Kind)
{
case STMT_GEN: //here we recognize FIELD DEFINITIONS -> DEFFLD
{
#ifdef DEBUG_COMPACT_FIELDS
PrintStmt(stmt,"Debug_Statement_Gen.txt");
#endif
VisitTree(stmt->Forest);
}break;
case STMT_JUMP:
case STMT_JUMP_FIELD:
{
VisitJump((StmtJump*)stmt);
}break;
case STMT_CASE: //Gettin inside a Case! New "Context"
{
VisitCase((StmtCase*)stmt, false);
}break;
case STMT_SWITCH: //Gettin inside a SWITCH! New "Context"
{
VisitSwitch((StmtSwitch*)stmt);
}break;
case STMT_IF: //Gettin inside an IF! New "Context"
{
VisitIf((StmtIf*)stmt);
}break;
case STMT_LOOP: //only <loop type="times2repeat">
{
VisitLoop((StmtLoop*)stmt);
}break;
case STMT_WHILE: //LOOP SIZE -> (CONVERTED) -> STATEMENT WHILE -> i'll convert loop in one variable FIELD (if can)
{
//if this is Loop-Size (converted in pdlparser to stmtWhile!) -> try compatting, otherwise not! only visit
if(((StmtWhile*)stmt)->isLoopSize==true)
{
checkingloop++; //Integer USED TO IDENTIFY if This LOOP is the first one or it's an Inner-Loop
m_loopcomp=1;
if(checkingloop>1) //fields used inside LOOP expression-> If InnerLoop ->need to check it - Otherwise not!
UpdateMapField((StmtWhile*)stmt); //ADD field-expr to Local-MAP of Used fields
VisitWhileDo((StmtWhile*)stmt); //Visit inside this WHILE
if(AllCompattable((StmtWhile*)stmt))//check if the validity of these fields end here or if at least one is also referentiated later
{
#ifdef DEBUG_COMPACT_FIELDS
PrintFieldsMap(&m_DefUseLocal,"Debug_List_of_Fields_Used_insideLoop_Compattable.txt");
#endif
/****TRANSFORM LOOP IN A VARIABLE-FIELD****/
TransformLoop((StmtWhile*)stmt);
}
CleanTempMap(&m_symboltemp); //Clean Used Fields of this loop
CleanTempMap(&m_DefUseLocal); //Clean Used Fields Defined inside this loop
checkingloop--;
}
else
{
VisitWhileDo((StmtWhile*)stmt); //Visit inside this WHILE
}
}break;
case STMT_DO_WHILE: //Gettin inside a WHILE! New "Context"
{
VisitDoWhile((StmtWhile*)stmt);
}break;
case STMT_BLOCK: //Gettin inside a Block! New "Context"
{
VisitBlock((StmtBlock*)stmt);
}break;
case STMT_BREAK:
case STMT_CONTINUE: //If Break or Continue (Inside Loops) -> Can't Compact this!! Don't know Total Size!! (Offset)
{
//TEMP!! THIS loop must be added to NeverLOOP LIST!!?
//AddNeverCompattableLoop(actualoop,&m_symboltemp);
m_loopcomp=0;
}break;
case STMT_LABEL:
case STMT_FINFOST:
case STMT_COMMENT:
{
//Do nothing
}break;
default:
nbASSERT(false, "COMPACT_STMT: CANNOT BE HERE!");
break;
}
}
void Visitor::Visit(Element const& element)
{
bool isElement = false;
switch(element.Type())
{
// Constant Tokens
case Types::NIL: VisitNil(); break;
case Types::TRUE_: VisitTrue(); break;
case Types::FALSE_: VisitFalse(); break;
case Types::STRING:
{
String S = CastToString(element, isElement);
VisitString(S);
}
break;
case Types::SUPERSTRING:
{
SuperString S = CastToSuperString(element, isElement);
VisitSuperString(S);
}
break;
case Types::NUMBER:
{
Number N = CastToNumber(element, isElement);
VisitNumber(N);
}
break;
case Types::CONTAINER:
{
Container C = CastToContainer(element, isElement);
VisitContainer(C);
}
break;
case Types::BUILTIN:
{
Builtin B = CastToBuiltin(element, isElement);
VisitBuiltin(B);
}
break;
case Types::CALL:
{
Funcall F = CastToFuncall(element, isElement);
VisitCall(F);
}
break;
case Types::FUNCTION:
{
Function F = CastToFunction(element, isElement);
VisitFunction(F);
}
break;
case Types::IF:
{
If F = CastToIf(element, isElement);
VisitIf(F);
}
break;
case Types::SET:
{
Set F = CastToSet(element, isElement);
VisitSet(F);
}
break;
case Types::IMPERATIVE:
{
Imperative F = CastToImperative(element, isElement);
VisitImperative(F);
}
case Types::CASE:
{
Case C = CastToCase(element, isElement);
VisitCase(C);
}
break;
};
}
