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; }