Statement *ParseStatement()
{
Statement *snp;
switch( lastst ) {
case semicolon:
NextToken();
snp = NULL;
break;
case begin:
NextToken();
snp = ParseCompoundStatement();
return snp;
case kw_if: snp = ParseIfStatement(); break;
case kw_while: snp = ParseWhileStatement(); break;
case kw_until: snp = ParseUntilStatement(); break;
case kw_for: snp = ParseForStatement(); break;
case kw_forever: snp = ParseForeverStatement(); break;
case kw_firstcall: snp = ParseFirstcallStatement(); break;
case kw_return: snp = ParseReturnStatement(); break;
case kw_break: snp = ParseBreakStatement(); break;
case kw_goto: snp = ParseGotoStatement(); break;
case kw_continue: snp = ParseContinueStatement(); break;
case kw_do:
case kw_loop: snp = ParseDoStatement(); break;
case kw_switch: snp = ParseSwitchStatement(); break;
case kw_try: snp = ParseTryStatement(); break;
case kw_throw: snp = ParseThrowStatement(); break;
case kw_vortex:
snp = vortex_stmt();
break;
case kw_intoff: snp = ParseIntoffStatement(); break;
case kw_inton: snp = ParseIntonStatement(); break;
case kw_stop: snp = ParseStopStatement(); break;
case kw_asm:
snp = ParseAsmStatement(); break;
case kw_critical: snp = ParseCriticalStatement(); break;
case kw_spinlock: snp = ParseSpinlockStatement(); break;
case kw_spinunlock: snp = ParseSpinunlockStatement(); break;
case id:
SkipSpaces();
if( lastch == ':' )
return ParseLabelStatement();
// else fall through to parse expression
default:
snp = ParseExpressionStatement();
break;
}
if( snp != NULL )
snp->next = NULL;
return snp;
}
Sentencia* Sintactico::ParseStructuredStatement()
{
//Utilizamos Primeros
if ( proximo_token.GetTipo() == kw_begin )
{
return ParseCompoundStatement();
}
else if ( proximo_token.GetTipo() == kw_while || proximo_token.GetTipo() == kw_for || proximo_token.GetTipo() == kw_repeat )
{
return ParseIterationStatement();
}
else if ( proximo_token.GetTipo() == kw_if || proximo_token.GetTipo() == kw_case )
{
return ParseSelectionStatement();
}
else
throw SyntaxException("Error de sentencia",analizador_lexico->GetLineaActual());
}
void ParseFunctionBody(SYM *sp)
{
char lbl[200];
needpunc(begin);
ParseAutoDeclarations();
cseg();
if (sp->storage_class == sc_static)
{
strcpy(lbl,GetNamespace());
strcat(lbl,"_");
strcat(lbl,sp->name);
gen_strlab(lbl);
}
// put_label((unsigned int) sp->value.i);
else
gen_strlab(sp->name);
currentFn = sp;
currentFn->IsLeaf = TRUE;
currentFn->DoesThrow = FALSE;
GenerateFunction(sp, ParseCompoundStatement());
// if (optimize)
flush_peep();
}
static Statement *ParseFunctionBody(SYM *sp)
{
std::string lbl;
char *p;
Statement *stmt;
Statement *plg;
Statement *eplg;
dfs.printf("<Parse function body>:%s|\n", (char *)sp->name->c_str());
lbl[0] = 0;
needpunc(begin,47);
tmpReset();
//ParseAutoDeclarations();
cseg();
if (sp->storage_class == sc_static)
{
//strcpy(lbl,GetNamespace());
//strcat(lbl,"_");
// strcpy(lbl,sp->name);
lbl = *sp->mangledName;
//gen_strlab(lbl);
}
// put_label((unsigned int) sp->value.i);
else {
if (sp->storage_class == sc_global)
lbl = "public code ";
// strcat(lbl,sp->name);
lbl += *sp->mangledName;
//gen_strlab(lbl);
}
dfs.printf("B");
p = my_strdup((char *)lbl.c_str());
dfs.printf("b");
GenerateMonadic(op_fnname,0,make_string(p));
currentFn = sp;
currentFn->IsLeaf = TRUE;
currentFn->DoesThrow = FALSE;
currentFn->UsesPredicate = FALSE;
regmask = 0;
bregmask = 0;
currentStmt = (Statement *)NULL;
dfs.printf("C");
stmt = ParseCompoundStatement();
dfs.printf("D");
// stmt->stype = st_funcbody;
if (isThor)
GenerateFunction(sp, stmt);
else if (isTable888)
GenerateTable888Function(sp, stmt);
else if (isRaptor64)
GenerateRaptor64Function(sp, stmt);
else if (is816)
Generate816Function(sp, stmt);
else if (isFISA64)
GenerateFISA64Function(sp, stmt);
dfs.putch('E');
flush_peep();
if (sp->storage_class == sc_global) {
ofs.printf("endpublic\r\n\r\n");
}
ofs.printf("%sSTKSIZE_ EQU %d\r\n", (char *)sp->mangledName->c_str(), tmpVarSpace() + lc_auto);
isFuncBody = false;
dfs.printf("</ParseFunctionBody>\n");
return stmt;
}
DeclaracionFuncion* Sintactico::ParseFunctionDeclaration()
{
if ( proximo_token.GetTipo() == kw_procedimiento )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == id )
{
string nom_procedimiento = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
InformacionSemantica::GetInstance()->SetContexto(nom_procedimiento);
InformacionInterpretacion::GetInstance()->SetContexto(nom_procedimiento);
list<Parametro*> lista_params = ParseProcedureParam();
ListaVariables* lista_vars = ParseVariableDeclarations();
Sentencia* cuerpo_funcion = ParseCompoundStatement();
//PENDIENTE: Verificar si es correcto
list<Parametro*>::iterator it = lista_params.begin();
for ( ; it != lista_params.end() ; it++ )
{
lista_vars->insert((*it)->GetNombre(),(*it)->GetTipo() );
}
InformacionInterpretacion::GetInstance()->InicializarVariables(nom_procedimiento,lista_vars);
return new DeclaracionFuncion(nom_procedimiento,lista_params,cuerpo_funcion,NULL);
}
else
throw SyntaxException("No se encontro un id valido",analizador_lexico->GetLineaActual());
}
else if ( proximo_token.GetTipo() == kw_funcion )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == id )
{
string nom_funcion = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
list<Parametro*>lista_params = ParseFunctionParam();
Tipo* t = ParseType();
if ( proximo_token.GetTipo() == punt_puntocoma )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
InformacionSemantica::GetInstance()->SetContexto( nom_funcion );
InformacionInterpretacion::GetInstance()->SetContexto(nom_funcion);
ListaVariables* lista_vars = ParseVariableDeclarations();
Sentencia* cuerpo_funcion = ParseCompoundStatement();
list<Parametro*>::iterator it = lista_params.begin();
for ( ; it != lista_params.end() ; it++ )
{
lista_vars->insert((*it)->GetNombre(),(*it)->GetTipo() );
}
InformacionSemantica::GetInstance()->InsertarVarEnContexto(nom_funcion,nom_funcion,t);
//lista_vars->insert(nom_funcion,t);
InformacionInterpretacion::GetInstance()->InicializarVariables(nom_funcion,lista_vars);
return new DeclaracionFuncion(nom_funcion,lista_params,cuerpo_funcion,t);
}
else
throw SyntaxException("Falta un punto y coma",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("Falta el id",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("Se esperaba una declaracion de funcion o procedimiento",analizador_lexico->GetLineaActual());
//InformacionInterpretacion::GetInstance()->SetContexto("@GLOBAL");
}
