C++ SyntaxException函数代码示例

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

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

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

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

unsigned NumberParser::parseOct(const std::string& s)
{
	unsigned result;
	if (tryParseOct(s, result))
		return result;
	else
		throw SyntaxException("Not a valid hexadecimal integer", s);
}