public Parser(string path)
{
lex = new Lexer(path);
entornoTipos = new EnvTypes(null);
entornoValores = new EnvValues(null);
pilaValores = new Stack<EnvValues>();
pilaValores.Push(new EnvValues(null));
}
void enum_initializer_listP(List<VariableDeclarator> vars, EnvValues savedEnvValues, EnvTypes savedEnvTypes)
{
if (peek(","))
{
match(",");
VariableDeclarator varDec = enum_constant_expression(savedEnvValues, savedEnvTypes);
vars.Add(varDec);
enum_initializer_listP(vars, savedEnvValues, savedEnvTypes);
}
//null
}
List<VariableDeclarator> enum_initializer_list(EnvValues savedEnvValues, EnvTypes savedEnvTypes)
{
List<VariableDeclarator> varDecList = new List<VariableDeclarator>();
VariableDeclarator varDec = enum_constant_expression(savedEnvValues, savedEnvTypes);
varDecList.Add(varDec);
enum_initializer_listP(varDecList, savedEnvValues, savedEnvTypes);
return varDecList;
}
Sentence enum_initializer(string enumName)
{
if (peek("{"))
{
EnvTypes savedEnvTypes = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
EnvValues savedEnvValues = entornoValores;
entornoValores = new EnvValues(null);
match("{");
List<VariableDeclarator> varsDec = enum_initializer_list(savedEnvValues, savedEnvTypes);
match("}");
EnumerationDeclaration enumDeclaration = new EnumerationDeclaration(enumName, varsDec, savedEnvValues);
ValorEnumeracion valEnum = new ValorEnumeracion();
Enumeracion varEnum = new Enumeracion(entornoTipos);
valEnum.valor = entornoValores;
entornoTipos = savedEnvTypes;
entornoTipos.put(enumName, varEnum);
entornoValores = savedEnvValues;
entornoValores.put(enumName, valEnum);
return enumDeclaration;
}
else
{
Tipo varEnum = entornoTipos.get(enumName);
Valor valEnum = entornoValores.get(enumName);
string enumVarName = currentToken.Lexema;
match(TokenType.ID);
EnumerationVariableDeclaration enumVarDeclaration = new EnumerationVariableDeclaration(enumName, enumVarName, varEnum, valEnum);
entornoTipos.put(enumVarName, varEnum);
return enumVarDeclaration;
}
}
VariableDeclarator enum_constant_expression(EnvValues savedEnvValues, EnvTypes savedEnvTypes)
{
string varName = variable_name();
EnvValues savedEnvValues2 = entornoValores;
entornoValores = savedEnvValues;
VariableInitializer varInit = enum_constant_expressionP();
entornoValores = savedEnvValues2;
VariableSubDeclarator varSubDec = new VariableSubDeclarator(new Entero(), varName);
entornoTipos.put(varName, new Entero());
savedEnvTypes.put(varName, new Entero());
VariableDeclarator varDeclarator = new VariableDeclarator(varSubDec, varInit);
return varDeclarator;
}
Sentence if_statement()
{
EnvTypes savedEnvTypes = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
Sentence savedFunction = funcionActual;
match("if");
match("(");
Expr expresion = expr();
match(")");
Sentence trueBlock = if_compound_statement();
entornoTipos = savedEnvTypes;
if (peek("else"))
{
match("else");
if (peek("if"))
{
EnvTypes savedEnvTypes2 = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
Sentence falseBlock = if_statement();
entornoTipos = savedEnvTypes2;
return new IfElseStatement(expresion, trueBlock, falseBlock);
}
else
{
EnvTypes savedEnvTypes3 = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
Sentence falseBLock = if_compound_statement();
entornoTipos = savedEnvTypes3;
return new IfElseStatement(expresion, trueBlock, falseBLock);
}
}
else
return new IfElseStatement(expresion, trueBlock, null);
}
public Expr()
{
entornoTiposActual = Parser.entornoTipos;
enclosing = Parser.funcionActual;
}
Sentence variable_declaration_list(EnvTypes savedEnvTypes, EnvValues savedEnvValues)
{
switch (currentToken.Tipo)
{
case TokenType.STRING:
case TokenType.BOOL:
case TokenType.CHAR:
case TokenType.FLOAT:
case TokenType.INT:
Tipo tipoVariables = variable_type();
string idVariable = direct_variable_declarator();
Tipo tipoVariable = variable_array(tipoVariables);
match(";");
VariableSubDeclarator primerVariable = new VariableSubDeclarator(tipoVariable, idVariable);
VariableDeclarator primerDeclaracionVariable = new VariableDeclarator(primerVariable, null);
entornoTipos.put(idVariable, tipoVariable);
return variable_declaration_listP(primerDeclaracionVariable, savedEnvTypes, savedEnvValues);
case TokenType.STRUCT:
string structName = struct_declarator();
Tipo varRecord = savedEnvTypes.get(structName);
Valor valRecord = savedEnvValues.get(structName);
string structVarName = variable_name();
match(";");
StructVariableDeclaration strVarDec = new StructVariableDeclaration(structName, structVarName, varRecord,valRecord);
entornoTipos.put(structVarName, varRecord);
return variable_declaration_listP(strVarDec, savedEnvTypes, savedEnvValues);
case TokenType.ENUM:
string enumName = enum_declarator();
Tipo varEnum = savedEnvTypes.get(enumName);
Valor valEnum = savedEnvValues.get(enumName);
string enumVarName = currentToken.Lexema;
match(TokenType.ID);
entornoTipos.put(enumName, varEnum);
EnumerationVariableDeclaration enumVarDec = new EnumerationVariableDeclaration(enumName, enumVarName, varEnum, valEnum);
return variable_declaration_listP(enumVarDec, savedEnvTypes, savedEnvValues);
default:
throw new Exception("Error en la declaracion de variables de struct linea: " + Lexer.line + " columna: " + Lexer.column + " currenttoken = " + currentToken.Lexema);
}
}
Sentence variable_declaration_listP(Sentence primerDeclaracionVariable, EnvTypes savedEnvTypes, EnvValues savedEnvValues)
{
switch (currentToken.Tipo)
{
case TokenType.STRING:
case TokenType.BOOL:
case TokenType.CHAR:
case TokenType.FLOAT:
case TokenType.INT:
Tipo tipoVariables = variable_type();
string idVariable = direct_variable_declarator();
Tipo tipoVariable = variable_array(tipoVariables);
match(";");
VariableSubDeclarator segundaVariable = new VariableSubDeclarator(tipoVariable, idVariable);
VariableDeclarator segundaDeclaracionVariable = new VariableDeclarator(segundaVariable, null);
SentenceSenquence stSeq = new SentenceSenquence(primerDeclaracionVariable, segundaDeclaracionVariable);
entornoTipos.put(idVariable, tipoVariable);
return variable_declaration_listP(stSeq, savedEnvTypes, savedEnvValues);
case TokenType.STRUCT:
string structName = struct_declarator();
Tipo varRecord = savedEnvTypes.get(structName);
Valor valRecord = savedEnvValues.get(structName);
string structVarName = variable_name();
match(";");
StructVariableDeclaration strVarDec = new StructVariableDeclaration(structName, structVarName, varRecord, valRecord);
SentenceSenquence stSeq2 = new SentenceSenquence(primerDeclaracionVariable, strVarDec);
entornoTipos.put(structVarName, varRecord);
return variable_declaration_listP(stSeq2, savedEnvTypes, savedEnvValues);
case TokenType.ENUM:
string enumName = enum_declarator();
Tipo varEnum = savedEnvTypes.get(enumName);
Valor valEnum = savedEnvValues.get(enumName);
string enumVarName = currentToken.Lexema;
match(TokenType.ID);
entornoTipos.put(enumName, varEnum);
EnumerationVariableDeclaration enumVarDec = new EnumerationVariableDeclaration(enumName, enumVarName, varEnum, valEnum);
SentenceSenquence stSeq3 = new SentenceSenquence(primerDeclaracionVariable, enumVarDec);
return variable_declaration_listP(stSeq3, savedEnvTypes, savedEnvValues);
default:
return primerDeclaracionVariable;//null
}
}
public Registro(EnvTypes entornoTipos)
{
entornoTiposStruct = entornoTipos;
}
Sentence struct_declarationP(string structName)
{
if (peek("{"))
{
match("{");
EnvTypes savedEnvTypes = entornoTipos;
entornoTipos = new EnvTypes(null);
EnvValues savedEnvValues = entornoValores;
entornoValores = new EnvValues(null);
Sentence strVarDecs = variable_declaration_list(savedEnvTypes, savedEnvValues);
match("}");
Registro record = new Registro(entornoTipos);
ValorRegistro Valrec = new ValorRegistro();
Valrec.valor = entornoValores;
entornoTipos = savedEnvTypes;
entornoTipos.put(structName, record);
entornoValores = savedEnvValues;
entornoValores.put(structName, Valrec);
return strVarDecs;
}
else
{
Tipo varRecord = entornoTipos.get(structName);
Valor valRecord = entornoValores.get(structName);
string strVarName = variable_name();
entornoTipos.put(strVarName, varRecord);
//entornoValores.put(strVarName, valRecord);
return new StructVariableDeclaration(structName, strVarName, varRecord, valRecord);
}
}
public void init(string nombreFuncion, Tipo ret, Sentence cpStmnt)
{
idFuncion = nombreFuncion;
Tiporetorno = ret;
compoundStatement = cpStmnt;
entornoTiposLocal = Parser.entornoTipos;
}
public FunctionDefinition()
{
entornoTiposLocal = Parser.entornoTipos;
entornoValoresLocal = Parser.pilaValores.Peek();
ValorRetorno = null;
returned = false;
}
public FunctionDefinition(string nombreFuncion, Tipo ret, Sentence cpStmnt)
{
idFuncion = nombreFuncion;
Tiporetorno = ret;
compoundStatement = cpStmnt;
entornoTiposLocal = Parser.entornoTipos;
entornoValoresLocal = Parser.entornoValores;
ValorRetorno = null;
returned = false;
}
Sentence for_statement()
{
EnvTypes savedEnvTypes = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
EnvValues savedEnvValues = ((FunctionDefinition)funcionActual).entornoValoresLocal;
((FunctionDefinition)funcionActual).entornoValoresLocal = new EnvValues(((FunctionDefinition)funcionActual).entornoValoresLocal);
ForStatement forStmnt = new ForStatement();
Sentence cicloAnterior = cicloActual;
cicloActual = forStmnt;
match("for");
match("(");
Sentence forInitialization = for_initialization();
match(";");
Sentence forControl = for_control();
match(";");
Sentence forIteration = for_iteration();
match(")");
EnvValues savedEnvValues2 = ((FunctionDefinition)funcionActual).entornoValoresLocal;
((FunctionDefinition)funcionActual).entornoValoresLocal = new EnvValues(((FunctionDefinition)funcionActual).entornoValoresLocal);
Sentence compoundStatement = if_compound_statement();
((FunctionDefinition)funcionActual).entornoValoresLocal = savedEnvValues2;
forStmnt.ForInit(forInitialization, forControl, forIteration, compoundStatement);
cicloActual = cicloAnterior;
entornoTipos = savedEnvTypes;
((FunctionDefinition)funcionActual).entornoValoresLocal = savedEnvValues;
return forStmnt;
}
Sentence while_statement()
{
EnvTypes savedEnvTypes = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
WhileStatement whileStmnt = new WhileStatement();
Sentence cicloAnterior = cicloActual;
cicloActual = whileStmnt;
match("while");
match("(");
Expr expresion = expr();
match(")");
Sentence ifCpStmnt = if_compound_statement();
whileStmnt.WhileInit(expresion, ifCpStmnt);
cicloActual = cicloAnterior;
entornoTipos = savedEnvTypes;
return whileStmnt;
}
Sentence function_declaration(Tipo retorno, string id)
{
EnvTypes savedEnvTypes = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
//EnvValues savedEnvValues = entornoValores;
//entornoValores = new EnvValues(entornoValores);
EnvValues savedEnvValues = Parser.pilaValores.Peek();
Parser.pilaValores.Push(new EnvValues(Parser.pilaValores.Peek()));
match("(");
Dictionary<string,Tipo> paramsTypeList = parameter_type_list();
match(")");
FunctionDefinition funcDefinition = new FunctionDefinition();
funcionActual = funcDefinition;
Sentence compoundStmnt = function_definition();
funcDefinition.init(id, retorno, compoundStmnt);
entornoTipos = savedEnvTypes;
entornoValores = savedEnvValues;
Parser.pilaValores.Pop();
Funcion funcion = new Funcion(retorno, paramsTypeList);
entornoTipos.put(id, funcion);
ValorFuncion funcionVal = new ValorFuncion(funcDefinition);
//entornoValores.put(id, funcionVal);
Parser.pilaValores.Peek().put(id, funcionVal);
funcionActual = null;
if (id == "main")
{
main = funcDefinition;
}
return funcDefinition;
}
Sentence do_while()
{
EnvTypes savedEnvTypes = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
EnvValues savedEnvValues = entornoValores;
entornoValores = new EnvValues(entornoValores);
DoWhileStatement doWhileStmnt = new DoWhileStatement();
Sentence cicloAnterior = cicloActual;
cicloActual = doWhileStmnt;
match("do");
Sentence stmnt = compound_statement();
match("while");
match("(");
Expr expresion = expr();
match(")");
match(";");
doWhileStmnt.DoWhileInit(expresion, stmnt);
cicloActual = cicloAnterior;
entornoTipos = savedEnvTypes;
entornoValores = savedEnvValues;
return doWhileStmnt;
}
public EnvTypes(EnvTypes entornoTipos)
{
tablaSimbolos = new Dictionary<string, Tipo>();
previo = entornoTipos;
pila = new Stack<EnvTypes>();
}
public Enumeracion(EnvTypes entornoTipos)
{
entornoTiposEnum = entornoTipos;
}
