list<Parametro*> Sintactico::ParseProcedureParam()
{
list<Parametro*> lista_params;
if ( proximo_token.GetTipo() == punt_puntocoma )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
return lista_params;
}
else if ( proximo_token.GetTipo() == punt_parentizq )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
lista_params = ParseParameterList();
if ( proximo_token.GetTipo() == punt_parentder )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == punt_puntocoma )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
return lista_params;
}
else
throw SyntaxException("Falta un punto y coma",analizador_lexico->GetLineaActual());
}
else{
throw SyntaxException("Falta un parentesis derecho",analizador_lexico->GetLineaActual());
}
}else
throw SyntaxException("Parametro de procedimiento incorrecto",analizador_lexico->GetLineaActual());
}
list<Parametro*> Sintactico::ParseFunctionParam()
{
list<Parametro*> lista_params;
if ( proximo_token.GetTipo() == punt_colon )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
return lista_params; //Lista de parametros vacia
}
else if ( proximo_token.GetTipo() == punt_parentizq )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
lista_params = ParseParameterList();
if (proximo_token.GetTipo() == punt_parentder)
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == punt_colon )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
return lista_params;
}
else
throw SyntaxException("Falta un token de colon" ,analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("Falta un parentesis derecho",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("Token invalido",analizador_lexico->GetLineaActual());
}
list<LimitesRango*> Sintactico::ParseDimensionList()
{
if ( proximo_token.GetTipo() == lit_int )
{
int inf = atoi(proximo_token.GetLexema().c_str());
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == punt_doblepunto )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == lit_int )
{
int sup = atoi( proximo_token.GetLexema().c_str() );
if ( inf > sup )
throw SemanticException("El indice inferior del arreglo debe ser menor o igual al superior");
proximo_token = analizador_lexico->ObtenerSiguienteToken();
list<LimitesRango*> lista_dim = _ParseDimensionList();
list<LimitesRango*>::iterator it = lista_dim.begin();
lista_dim.insert(it,new LimitesRango(inf,sup) );
return lista_dim;
}
else
throw SyntaxException("No se encontro una constante entera",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("No se encontro el token de doble punto",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("No se encontro una constante entera",analizador_lexico->GetLineaActual());
}
Sentencia* Sintactico::ParseReadStatement()
{
if ( proximo_token.GetTipo() == kw_read )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == id )
{
string nom_id = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
list<Qualifier*>lista_qualifiers = ParseQualifiers();
if ( proximo_token.GetTipo() == punt_puntocoma )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("Se esperaba un punto y coma",analizador_lexico->GetLineaActual() );
Identificador* id = new Identificador(nom_id,lista_qualifiers);
return new SentenciaRead(id);
}
else
throw SyntaxException("Se esperaba un id valido",analizador_lexico->GetLineaActual() );
}
else throw SyntaxException("Se esperaraba la palabra read",analizador_lexico->GetLineaActual() );
}
Sentencia* Sintactico::ParseSimpleStatement()
{
if ( proximo_token.GetTipo() == id )
{
string identificador = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == punt_puntocoma || proximo_token.GetTipo() == punt_parentizq )
{
return ParseProcedureStatement(identificador);
}
else if ( proximo_token.GetTipo() == op_asignacion || proximo_token.GetTipo() == punt_punto ||
proximo_token.GetTipo() == punt_corchizq )
{
return ParseAssignmentStatement(identificador);
}
else
throw SyntaxException("Token no valido",analizador_lexico->GetLineaActual() );
}
else if (proximo_token.GetTipo() == kw_write)
{
return ParseWriteStatement();
}
else if (proximo_token.GetTipo() == kw_read )
{
return ParseReadStatement();
}
else
throw SyntaxException("Sentencia invalida",analizador_lexico->GetLineaActual());
}
void Sintactico::ParseTypeDefinition()
{
if ( proximo_token.GetTipo() == id )
{
string nom_id = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == op_igual )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Tipo* t = ParseType();
if ( proximo_token.GetTipo() == punt_puntocoma )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("No se encontro el token de punto y coma",analizador_lexico->GetLineaActual() );
InformacionSemantica::GetInstance()->InsertarEnTablaTipos(nom_id,t);
}
else
throw SyntaxException("No se encontro el token de operador de asignacion",analizador_lexico->GetLineaActual() );
}
else
throw SyntaxException("No se encontro un id valido",analizador_lexico->GetLineaActual());
}
Sentencia* Sintactico::ParseRepeatStatement()
{
if ( proximo_token.GetTipo() == kw_repeat )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Sentencia* stmt = ParseStatementList();
if ( proximo_token.GetTipo() == kw_until )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Expresion* expr = ParseExpression();
if ( proximo_token.GetTipo() == punt_puntocoma )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("Falta un punto y coma, sentencia repeat",analizador_lexico->GetLineaActual() );
return new SentenciaRepeat(stmt,expr);
}
else
throw SyntaxException("Falta la kw until: produccion RepeatStatement",analizador_lexico->GetLineaActual());
}
else
throw SyntaxException("Falta la kw repeat: produccion Repeat Statement",analizador_lexico->GetLineaActual());
}
bool Glob::match(TextIterator& itp, const TextIterator& endp, TextIterator& its, const TextIterator& ends)
{
while (itp != endp)
{
if (its == ends)
{
while (itp != endp && *itp == '*') ++itp;
break;
}
switch (*itp)
{
case '?':
++itp; ++its;
break;
case '*':
if (++itp != endp)
{
while (its != ends && !matchAfterAsterisk(itp, endp, its, ends)) ++its;
return its != ends;
}
return true;
case '[':
if (++itp != endp)
{
bool invert = *itp == '!';
if (invert) ++itp;
if (itp != endp)
{
bool mtch = matchSet(itp, endp, *its++);
if ((invert && mtch) || (!invert && !mtch)) return false;
break;
}
}
throw SyntaxException("bad range syntax in glob pattern");
case '\\':
if (++itp == endp) throw SyntaxException("backslash must be followed by character in glob pattern");
// fallthrough
default:
if (_options & GLOB_CASELESS)
{
if (Unicode::toLower(*itp) != Unicode::toLower(*its)) return false;
}
else
{
if (*itp != *its) return false;
}
++itp; ++its;
}
}
return itp == endp && its == ends;
}
Expresion* Sintactico::ParseFactor()
{
if ( proximo_token.GetTipo() == punt_parentizq )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Expresion* expr = ParseExpression();
if ( proximo_token.GetTipo() == punt_parentder )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
}
else
throw SyntaxException("Falta un parentesis derecho: produccion Factor",analizador_lexico->GetLineaActual());
return expr;
}
else if ( proximo_token.GetTipo() == lit_int || proximo_token.GetTipo() == lit_float || proximo_token.GetTipo() == lit_string || proximo_token.GetTipo() == lit_boolean || proximo_token.GetTipo() == lit_caracter )
{
return ParseLiteralConstant();
}
else if ( proximo_token.GetTipo() == op_suma || proximo_token.GetTipo() == op_resta || proximo_token.GetTipo() == kw_not )
{
//Utilizamos Primeros ( unary-expression )
return ParseUnaryExpression();
}
else if ( proximo_token.GetTipo() == id )
{
string identificador = proximo_token.GetLexema();
proximo_token = analizador_lexico->ObtenerSiguienteToken();
if ( proximo_token.GetTipo() == punt_parentizq )
{
list<Expresion*>args = ParseFunctionCall();
FunctionCall* func = new FunctionCall(identificador,args);
return func;
}
else
{
list<Qualifier*> qualifier_list = ParseQualifiers();
Identificador* id = new Identificador(identificador,qualifier_list);
return id;
}
}
else
throw SyntaxException("No se encontro un token correcto...factor",analizador_lexico->GetLineaActual() );
}
bool Glob::matchSet(TextIterator& itp, const TextIterator& endp, int c)
{
if (_options & GLOB_CASELESS)
c = Unicode::toLower(c);
while (itp != endp)
{
switch (*itp)
{
case ']':
++itp;
return false;
case '\\':
if (++itp == endp) throw SyntaxException("backslash must be followed by character in glob pattern");
}
int first = *itp;
int last = first;
if (++itp != endp && *itp == '-')
{
if (++itp != endp)
last = *itp++;
else
throw SyntaxException("bad range syntax in glob pattern");
}
if (_options & GLOB_CASELESS)
{
first = Unicode::toLower(first);
last = Unicode::toLower(last);
}
if (first <= c && c <= last)
{
while (itp != endp)
{
switch (*itp)
{
case ']':
++itp;
return true;
case '\\':
if (++itp == endp) break;
default:
++itp;
}
}
throw SyntaxException("range must be terminated by closing bracket in glob pattern");
}
}
return false;
}
void Sintactico::ParseProgramHeader()
{
if ( proximo_token.GetTipo() == punt_delimpascalizq )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
ParseTypeDefinitions();
ListaVariables* lista_vars = ParseVariableDeclarations();
InformacionInterpretacion::GetInstance()->InicializarVariables("@GLOBAL",lista_vars);
list<DeclaracionFuncion*> lista_funcs = ParseFunctionDeclarations();
list<DeclaracionFuncion*>::iterator it = lista_funcs.begin();
for ( ; it != lista_funcs.end() ; it++ )
{
InformacionSemantica::GetInstance()->InsertarEnTablaDeFunciones( (*it)->GetNombre() , (*it) );
(*it)->ValidarSemantica();
}
InformacionSemantica::GetInstance()->SetContexto("@GLOBAL");
InformacionInterpretacion::GetInstance()->SetContexto("@GLOBAL");
if ( proximo_token.GetTipo() == punt_delimpascalder )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("No se encontro el token delimitador %>",analizador_lexico->GetLineaActual());
}
}
Sentencia* Sintactico::ParseProgramContent()
{
if ( proximo_token.GetTipo() == html )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
return ParseProgramContent();
}
else if ( proximo_token.GetTipo() == punt_delimpascalizq )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Sentencia* stmt = ParseStatementList();
//Sentencia* stmt = ParseStatement();
if (proximo_token.GetTipo() == punt_delimpascalder )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Sentencia* p_content = ParseProgramContent();
stmt->SetSiguiente( p_content );
return stmt;
}
else
throw SyntaxException("Falta el delimitador %>",analizador_lexico->GetLineaActual());
}
else
return 0;
}
list<ClausulaCase*> Sintactico::ParseCaseClauseList()
{
list<ClausulaCase*>lista_clausulas;
//Utilizamos Primero
if ( proximo_token.GetTipo() == lit_int || proximo_token.GetTipo()== lit_float || proximo_token.GetTipo()== lit_string || proximo_token.GetTipo()==lit_caracter )
{
ConstanteLiteral* lit_const =(ConstanteLiteral*) ParseLiteralConstant();
if ( proximo_token.GetTipo() == punt_colon )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Sentencia* stmt = ParseStatement();
ClausulaCase* clausula = new ClausulaCase(lit_const,stmt);
lista_clausulas = _ParseCaseClauseList();
list<ClausulaCase*>::iterator it = lista_clausulas.begin();
lista_clausulas.insert(it,clausula);
return lista_clausulas;
}
else throw SyntaxException("Se esperaba un token de dos puntos",analizador_lexico->GetLineaActual() );
}
return lista_clausulas;
}
void URI::parse(const std::string& uri)
{
std::string::const_iterator it = uri.begin();
std::string::const_iterator end = uri.end();
if (it == end) return;
if (*it != '/' && *it != '.' && *it != '?' && *it != '#')
{
std::string scheme;
while (it != end && *it != ':' && *it != '?' && *it != '#' && *it != '/') scheme += *it++;
if (it != end && *it == ':')
{
++it;
if (it == end) throw SyntaxException("URI scheme must be followed by authority or path", uri);
setScheme(scheme);
if (*it == '/')
{
++it;
if (it != end && *it == '/')
{
++it;
parseAuthority(it, end);
}
else --it;
}
parsePathEtc(it, end);
}
else
{
it = uri.begin();
parsePathEtc(it, end);
}
}
else parsePathEtc(it, end);
}
int DateTimeParser::parseAMPM(std::string::const_iterator& it, const std::string::const_iterator& end, int hour)
{
std::string ampm;
while ((it != end && std::isspace(*it)) || std::ispunct(*it)) ++it;
while (it != end && std::isalpha(*it))
{
char ch = (*it++);
ampm += std::toupper(ch);
}
if (ampm == "AM")
{
if (hour == 12)
return 0;
else
return hour;
}
else if (ampm == "PM")
{
if (hour < 12)
return hour + 12;
else
return hour;
}
else throw SyntaxException("Not a valid AM/PM designator", ampm);
}
list<ClausulaCase*> Sintactico::_ParseCaseClauseList()
{
list<ClausulaCase*> lista_clausulas;
if ( proximo_token.GetTipo() == punt_puntocoma )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
ConstanteLiteral* const_lit = (ConstanteLiteral*)ParseLiteralConstant();
if ( proximo_token.GetTipo() == punt_colon)
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Sentencia* stmt = ParseStatement();
ClausulaCase* clausula = new ClausulaCase(const_lit,stmt);
lista_clausulas = _ParseCaseClauseList();
list<ClausulaCase*>::iterator it = lista_clausulas.begin();
lista_clausulas.insert(it,clausula);
return lista_clausulas;
}
else throw SyntaxException("Se espera un token de dos puntos",analizador_lexico->GetLineaActual() );
}
return lista_clausulas;
}
Sentencia* Sintactico::ParseCompoundStatement()
{
if (proximo_token.GetTipo() == kw_begin )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Sentencia* stmt = ParseStatementList();
if ( proximo_token.GetTipo() == kw_end )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("Error falta la palabra clave END",analizador_lexico->GetLineaActual());
return stmt;
}
else
throw SyntaxException("Falta la palabra clave begin",analizador_lexico->GetLineaActual());
}
eOperandType Chipset::checkNumber(const std::string &val)
{
bool foundValue = false;
size_t i;
std::string type_only;
size_t nb_begin;
size_t nb_end;
nb_end = val.find(")");
nb_begin = val.find("(");
if (nb_begin == val.npos || nb_end == val.npos || nb_end != (val.size() - 1)
|| nb_end - nb_begin < 2)
raiseException(SyntaxException());
type_only = val.substr(0, nb_begin);
for (i = 0; i < _valuesVect.size(); i++)
{
if (type_only == _valuesVect[i].name)
{
foundValue = true;
break;
}
}
if (foundValue == false)
raiseException(SyntaxException());
std::string nb;
nb = val.substr(nb_begin + 1, (nb_end - nb_begin) - 1);
NumberType nbType = findNumberType(nb);
if (nbType == UNKNOWN)
raiseException(SyntaxException());
if (nbType == ENTIER)
{
if (_valuesVect[i].opeType >= 3)
raiseException(SyntaxException());
}
else
{
if (_valuesVect[i].opeType <= 2)
raiseException(SyntaxException());
}
return (_valuesVect[i].opeType);
}
DateTime DateTimeParser::parse(const std::string& str, int& timeZoneDifferential)
{
DateTime result;
if (tryParse(str, result, timeZoneDifferential))
return result;
else
throw SyntaxException("Unsupported or invalid date/time format");
}
unsigned NumberParser::parseOct(const std::string& s)
{
unsigned result;
if (tryParseOct(s, result))
return result;
else
throw SyntaxException("Not a valid hexadecimal integer", s);
}
unsigned NumberParser::parseUnsigned(const std::string& s, char thSep)
{
unsigned result;
if (tryParseUnsigned(s, result, thSep))
return result;
else
throw SyntaxException("Not a valid unsigned integer", s);
}
int NumberParser::parse(const std::string& s, char thSep)
{
int result;
if (tryParse(s, result, thSep))
return result;
else
throw SyntaxException("Not a valid integer", s);
}
bool NumberParser::parseBool(const std::string& s)
{
bool result;
if (tryParseBool(s, result))
return result;
else
throw SyntaxException("Not a valid bool number", s);
}
double NumberParser::parseFloat(const std::string& s, char decSep, char thSep)
{
double result;
if (tryParseFloat(s, result, decSep, thSep))
return result;
else
throw SyntaxException("Not a valid floating-point number", s);
}
UInt64 NumberParser::parseHex64(const std::string& s)
{
UInt64 result;
if (tryParseHex64(s, result))
return result;
else
throw SyntaxException("Not a valid hexadecimal integer", s);
}
Sentencia* Sintactico::ParseS()
{
Sentencia* stmt = ParseProgram();
if( proximo_token.GetTipo() !=eof )
throw SyntaxException("se esperaba fin de archivo",analizador_lexico->GetLineaActual() );
return stmt;
}
list<Expresion*> Sintactico::ParseFunctionCall()
{
if ( proximo_token.GetTipo() == punt_parentizq )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
list<Expresion*> argument_list = ParseArgumentList();
if( proximo_token.GetTipo() == punt_parentder )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("Falta un parentesis derecho, produccion Params",analizador_lexico->GetLineaActual());
return argument_list;
}
else
throw SyntaxException("Se esperaba un token de parentesis izquierdo",analizador_lexico->GetLineaActual());
}
Qualifier* Sintactico::ParseIndex()
{
if ( proximo_token.GetTipo() == punt_corchizq )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
list<Expresion*>expression_list = ParseIndexList();
if ( proximo_token.GetTipo() == punt_corchder )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("Falta corchete derecho: produccion Index",analizador_lexico->GetLineaActual());
return new Indexacion(expression_list);
}
else
throw SyntaxException("Falta un corchete izq: producccion Index",analizador_lexico->GetLineaActual());
}
Sentencia* Sintactico::ParseWriteStatement()
{
if ( proximo_token.GetTipo() == kw_write )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Expresion* expr = ParseExpression();
if ( proximo_token.GetTipo() == punt_puntocoma )
proximo_token = analizador_lexico->ObtenerSiguienteToken();
else
throw SyntaxException("Falta un punto y coma", analizador_lexico->GetLineaActual() );
return new SentenciaWrite(expr);
}
else
throw SyntaxException("Se esperaba la palabra write",analizador_lexico->GetLineaActual() );
}
bool Glob::match(std::string::const_iterator& itp, const std::string::const_iterator& endp, std::string::const_iterator& its, const std::string::const_iterator& ends)
{
while (itp != endp)
{
if (its == ends)
{
while (itp != endp && *itp == '*') ++itp;
break;
}
switch (*itp)
{
case '?':
++itp; ++its;
break;
case '*':
if (++itp != endp)
{
while (its != ends && !matchAfterAsterisk(itp, endp, its, ends)) ++its;
return its != ends;
}
return true;
case '[':
if (++itp != endp)
{
bool invert = *itp == '!';
if (invert) ++itp;
if (itp != endp)
{
bool mtch = matchSet(itp, endp, *its++);
if (invert && mtch || !invert && !mtch) return false;
break;
}
}
throw SyntaxException("bad range syntax in glob pattern");
case '\\':
if (++itp == endp) throw SyntaxException("backslash must be followed by character in glob pattern");
// fallthrough
default:
if (*itp != *its) return false;
++itp; ++its;
}
}
return itp == endp && its == ends;
}
