public IHolderCil Visit(CondExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
var condValue = Visit(parserRule.ifExpr, cilTree, contextCil);
condValue = GetValue(condValue, cilTree, CilAst.Bool);
var labelElse = cilTree.CreateLabel("else");
cilTree.ThreeDirInses.Add(new IfGoto(condValue, labelElse));
//genero el codigo de elseValue
var elseValue = Visit(parserRule.elseExpr, cilTree, contextCil);
var labelEnd = cilTree.CreateLabel("end");
//El resultado lo almaceno en value
cilTree.ThreeDirInses.Add(new AssigCil(value, elseValue));
//Voy pa la etiquta end
cilTree.ThreeDirInses.Add(new GotoCil(labelEnd));
//Pongo la etiqueta de else
cilTree.ThreeDirInses.Add(new Label(labelElse));
//genero el codigo de thenValue
var thenValue = Visit(parserRule.thenExpr, cilTree, contextCil);
//Asigno el valor a esle value
cilTree.ThreeDirInses.Add(new AssigCil(value, thenValue));
//Pongo la etiqueta end
cilTree.ThreeDirInses.Add(new Label(labelEnd));
//retorno el valor
return(value);
}
public IHolderCil Visit(LetBodyContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var newContextCil = contextCil.CreateAChild();
Visit(parserRule.declaretion, cilTree, newContextCil);
return(Visit(parserRule.body, cilTree, newContextCil));
}
public void Visit(DeclarationContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
contextCil.Define(parserRule.idText);
var Id = new LocalCil(contextCil.variables[parserRule.idText].Name);
cilTree.LocalCils.Add(Id);
IHolderCil value;
if (parserRule.expression != null)
{
value = Visit(parserRule.expression, cilTree, contextCil);
}
else if (parserRule.type.Text == "Int")
{
value = CreateABasicType(cilTree, CilAst.Int);
}
else if (parserRule.type.Text == "String")
{
value = CreateABasicType(cilTree, CilAst.String);
}
else if (parserRule.type.Text == "Bool")
{
value = CreateABasicType(cilTree, CilAst.Bool);
}
else
{
value = Visit_void(cilTree);
}
cilTree.ThreeDirInses.Add(new AssigCil(Id, value));
}
public void Visit(FormalContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
contextCil.Define(parserRule.idText);
var arg = new ArgCil(contextCil.variables[parserRule.idText].Name);
cilTree.ArgCils.Add(arg);
}
public IHolderCil Visit(CaseExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
var expr0 = Visit(parserRule.expresion, cilTree, contextCil);
//is void
var TypeValue = new LocalCil($"_TypeValue{cilTree.LocalCils.Count}");
var not_is_void = new LocalCil($"not_is_void{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(TypeValue);
cilTree.LocalCils.Add(not_is_void);
cilTree.ThreeDirInses.Add(new TypeOf(TypeValue, expr0));
cilTree.ThreeDirInses.Add(new NotEqualCil(not_is_void, TypeValue, CilAst.GetTypeCilByName("void")));
//lanzamos el error
Visit_Runtime_Error_whit_Cond(not_is_void, cilTree, $"\"({parserRule.Start.Line},{parserRule.Start.Column + 1}) - Rutime Error: A case on void\"");
//ejecucion del case
var closestAncestor = new LocalCil($"_closestAncestor{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(closestAncestor);
//Inicializo el valor de numberType en 0 y closestAncestor con object
var isNotConform = new LocalCil($"_isNotConform{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(isNotConform);
var branches = parserRule._branches.Concat(new List <BranchContext>()
{
parserRule.firstBranch
}).OrderBy(t => - (CilAst.GetTypeCilByName(t.typeText).IndexOfPrecedence)).ToArray();
//El tipo de la primera rama
var End = cilTree.CreateLabel("End_");
for (int i = 0; i < branches.Length; i++)
{
var branch = branches[i];
var nextLabel = cilTree.CreateLabel("Case_");
//tipo de la rama
var typeBranch = CilAst.GetTypeCilByName(branch.typeText, typeCil);
cilTree.ThreeDirInses.Add(new IsNotConformCil(isNotConform, TypeValue, typeBranch));
cilTree.ThreeDirInses.Add(new IfGoto(isNotConform, nextLabel));
var valueBranch = new LocalCil(branch.idText);//preguntarle as zahuis
cilTree.LocalCils.Add(valueBranch);
cilTree.ThreeDirInses.Add(new AssigCil(valueBranch, expr0));
var newContextCil = contextCil.CreateAChild();
newContextCil.Define(branch.idText);
var valueExpr = Visit(branch.expression, cilTree, newContextCil);
cilTree.ThreeDirInses.Add(new AssigCil(value, valueExpr));
cilTree.ThreeDirInses.Add(new GotoCil(End));
cilTree.ThreeDirInses.Add(new Label(nextLabel));
}
Visit_Runtime_Error(cilTree, $"\"linea {parserRule.Start.Line} y columna {parserRule.Start.Column + 1} Execution of a case statement without a matching branch\"");
cilTree.ThreeDirInses.Add(new Label(End));
return(value);
}
public IHolderCil Visit(BlockExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
foreach (var expr in parserRule._expresions)
{
Visit(expr, cilTree, contextCil);
}
return(Visit(parserRule.finalExpresion, cilTree, contextCil));
}
public IHolderCil Visit(NegExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
var valueExpr = Visit(parserRule.expresion, cilTree, contextCil);
valueExpr = GetValue(valueExpr, cilTree, CilAst.Int);
cilTree.ThreeDirInses.Add(new NegCil(value, valueExpr));
return(CreateABasicTypeWhitVal(cilTree, CilAst.Int, value));
}
public IHolderCil Visit(NotExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var _valueNum = new LocalCil($"_valueNum{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(_valueNum);
var valueExpr = Visit(parserRule.expresion, cilTree, contextCil);
var BoolCil = CilAst.Bool;
valueExpr = GetValue(valueExpr, cilTree, BoolCil);
cilTree.ThreeDirInses.Add(new RestCil(_valueNum, new HolderCil("1"), valueExpr));
return(CreateABasicTypeWhitVal(cilTree, BoolCil, _valueNum));
}
public IHolderCil Visit(StringExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
var stringCool = parserRule.STRING().GetText();
var varDataString = new VarCil($"s{CilAst.dataStringCils.Count}");
CilAst.dataStringCils.Add(new DataStringCil(varDataString, new StringCil(stringCool)));
cilTree.ThreeDirInses.Add(new LoadCil(value, varDataString));
return(CreateABasicTypeWhitVal(cilTree, CilAst.String, value));
}
public IHolderCil Visit(IsvoidExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
var valueExpr = Visit(parserRule.expresion, cilTree, contextCil);
var TypeValue = new LocalCil($"_TypeValue{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(TypeValue);
cilTree.ThreeDirInses.Add(new TypeOf(TypeValue, valueExpr));
cilTree.ThreeDirInses.Add(new EqualCil(value, TypeValue, CilAst.GetTypeCilByName("void")));
return(CreateABasicTypeWhitVal(cilTree, CilAst.Bool, value));
}
public IHolderCil Visit(LetRuleContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
switch (parserRule)
{
case LetDeclContext rule:
return(Visit(rule, cilTree, contextCil));
case LetBodyContext rule:
return(Visit(rule, cilTree, contextCil));
default:
return(null);
}
}
public IHolderCil Visit(IdExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
//Si no es una variable declarada dentro del metodo entonces es un atributo de la clase (self)
if (!contextCil.variables.ContainsKey(parserRule.id.Text))
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
cilTree.ThreeDirInses.Add(new GetAttrCil(value, cilTree.self, typeCil.GetAttributeCilsByCoolName(parserRule.id.Text)));
return(value);
}
return(contextCil.variables[parserRule.id.Text]);
}
public IHolderCil Visit(CompaExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
var valueLeft = Visit(parserRule.left, cilTree, contextCil);
var valueRight = Visit(parserRule.right, cilTree, contextCil);
if (parserRule.left.computedType == GlobalContext.Int)
{
valueLeft = GetValue(valueLeft, cilTree, CilAst.Int);
valueRight = GetValue(valueRight, cilTree, CilAst.Int);
}
else if (parserRule.left.computedType == GlobalContext.Bool)
{
valueLeft = GetValue(valueLeft, cilTree, CilAst.Bool);
valueRight = GetValue(valueRight, cilTree, CilAst.Bool);
}
else if (parserRule.left.computedType == GlobalContext.String)
{
valueLeft = GetValue(valueLeft, cilTree, CilAst.String);
valueRight = GetValue(valueRight, cilTree, CilAst.String);
}
switch (parserRule.op.Text)
{
case "<":
cilTree.ThreeDirInses.Add(new MinorCil(value, valueLeft, valueRight));
break;
case "<=":
cilTree.ThreeDirInses.Add(new Minor_EqualCil(value, valueLeft, valueRight));
break;
case "=":
if (parserRule.left.computedType == GlobalContext.String)
{
cilTree.ThreeDirInses.Add(new EqualStringCil(value, valueLeft, valueRight));
}
else
{
cilTree.ThreeDirInses.Add(new EqualCil(value, valueLeft, valueRight));
}
break;
default:
break;
}
return(CreateABasicTypeWhitVal(cilTree, CilAst.Bool, value));
}
public void Visit(FeatureContext parserRule, ITypeCil cilTree, IContextCil contextCil)
{
switch (parserRule)
{
case AttributeContext attribute:
Visit(attribute, cilTree);
break;
case MethodContext method:
Visit(method, cilTree);
break;
default:
break;
}
}
public IHolderCil Visit(BoolExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var value = CreateABasicType(cilTree, CilAst.Bool);
switch ([email protected])
{
case "true":
SetValue(value, new HolderCil("1"), cilTree, CilAst.Bool);
break;
case "false":
SetValue(value, new HolderCil("0"), cilTree, CilAst.Bool);
break;
default:
break;
}
return(value);
}
public IHolderCil Visit(AssignExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var valueExpr = Visit(parserRule.expresion, cilTree, contextCil);
if (!contextCil.variables.ContainsKey(parserRule.id.Text))
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
cilTree.ThreeDirInses.Add(new SetAttrCil(cilTree.self, typeCil.GetAttributeCilsByCoolName(parserRule.id.Text), valueExpr));
cilTree.ThreeDirInses.Add(new GetAttrCil(value, cilTree.self, typeCil.GetAttributeCilsByCoolName(parserRule.id.Text)));
return(value);
}
else
{
var value = contextCil.variables[parserRule.id.Text];
cilTree.ThreeDirInses.Add(new AssigCil(value, valueExpr));
return(value);
}
}
public IHolderCil Visit(NewTypeExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
if (parserRule.type.Text == "SELF_TYPE")
{
var varType = new LocalCil($"_Type{cilTree.ThreeDirInses.Count}");
cilTree.LocalCils.Add(varType);
cilTree.ThreeDirInses.Add(new TypeOf(varType, new ValuelCil("self")));
cilTree.ThreeDirInses.Add(new VCallCil(value, varType, new ValuelCil("Init")));
}
else
{
var varType = CilAst.GetTypeCilByName(parserRule.type.Text, typeCil);
cilTree.ThreeDirInses.Add(new CallCil(value, varType.Init.Function));
}
return(value);
}
public IHolderCil Visit(WhileExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var whileElse = cilTree.CreateLabel("while");
//Voy para esa etiqueta para evaluar la cod del while
cilTree.ThreeDirInses.Add(new GotoCil(whileElse));
var loop = cilTree.CreateLabel("loop");
//Esta etiqueta indica evalua el cuerpo de while
cilTree.ThreeDirInses.Add(new Label(loop));
Visit(parserRule.loopExpr, cilTree, contextCil);
//Pongo la etiqueta de while
cilTree.ThreeDirInses.Add(new Label(whileElse));
var condValue = Visit(parserRule.whileExpr, cilTree, contextCil);
condValue = GetValue(condValue, cilTree, CilAst.Bool);
cilTree.ThreeDirInses.Add(new IfGoto(condValue, loop));
//retorno el valor
var value = Visit_void(cilTree);
return(value);
}
public IHolderCil Visit(ArithContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var valueNum = new LocalCil($"_valueNum{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(valueNum);
var valueLeft = Visit(parserRule.left, cilTree, contextCil);
var valueRight = Visit(parserRule.right, cilTree, contextCil);
var valLeft = GetValue(valueLeft, cilTree, CilAst.Int);
var valRigth = GetValue(valueRight, cilTree, CilAst.Int);
switch (parserRule.op.Text)
{
case "/":
var isZero = new LocalCil($"_isZero{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(isZero);
cilTree.ThreeDirInses.Add(new NotEqualCil(isZero, valRigth, new HolderCil("0")));
Visit_Runtime_Error_whit_Cond(isZero, cilTree, $"\"({parserRule.Start.Line},{parserRule.Start.Column+1}) - Rutime Error: Division by zero\"");
cilTree.ThreeDirInses.Add(new DivCil(valueNum, valLeft, valRigth));
break;
case "*":
cilTree.ThreeDirInses.Add(new MultCil(valueNum, valLeft, valRigth));
break;
case "+":
cilTree.ThreeDirInses.Add(new SumCil(valueNum, valLeft, valRigth));
break;
case "-":
cilTree.ThreeDirInses.Add(new RestCil(valueNum, valLeft, valRigth));
break;
default:
break;
}
return(CreateABasicTypeWhitVal(cilTree, CilAst.Int, valueNum));
}
public IHolderCil Visit(ExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
switch (parserRule)
{
case SelfDispatchContext rule:
return(Visit(rule, cilTree, contextCil));
case DispatchContext rule:
return(Visit(rule, cilTree, contextCil));
case CondExprContext rule:
return(Visit(rule, cilTree, contextCil));
case WhileExprContext rule:
return(Visit(rule, cilTree, contextCil));
case BlockExprContext rule:
return(Visit(rule, cilTree, contextCil));
case LetExprContext rule:
return(Visit(rule, cilTree, contextCil));
case CaseExprContext rule:
return(Visit(rule, cilTree, contextCil));
case NewTypeExprContext rule:
return(Visit(rule, cilTree, contextCil));
case AssignExprContext rule:
return(Visit(rule, cilTree, contextCil));
case NotExprContext rule:
return(Visit(rule, cilTree, contextCil));
case CompaExprContext rule:
return(Visit(rule, cilTree, contextCil));
case ArithContext rule:
return(Visit(rule, cilTree, contextCil));
case IsvoidExprContext rule:
return(Visit(rule, cilTree, contextCil));
case NegExprContext rule:
return(Visit(rule, cilTree, contextCil));
case InParenthesisExprContext rule:
return(Visit(rule, cilTree, contextCil));
case IdExprContext rule:
return(Visit(rule, cilTree, contextCil));
case IntegerExprContext rule:
return(Visit(rule, cilTree, contextCil));
case StringExprContext rule:
return(Visit(rule, cilTree, contextCil));
case BoolExprContext rule:
return(Visit(rule, cilTree, contextCil));
default:
return(Visit(cilTree));
}
}
public virtual IHolderCil Visit(SelfDispatchContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var Params = new List <IHolderCil>();
foreach (var expr in parserRule._expresions)
{
//genera el codigo de cada parametro que le paso a los metodos
var param = Visit(expr, cilTree, contextCil);
Params.Add(param);
}
//Averiguo el tipo dinamico de self es decir( el de la clase que esta usando la funcion en ese momento)
var varType = new LocalCil($"_Type{cilTree.ThreeDirInses.Count}");
cilTree.LocalCils.Add(varType);
var self = cilTree.self;
cilTree.ThreeDirInses.Add(new TypeOf(varType, self));
//cada parametro los anado al metodo puede que tenga sentido pasarlos al revez
cilTree.ThreeDirInses.Add(new ArgExprCil(self));
foreach (var param in Params)
{
cilTree.ThreeDirInses.Add(new ArgExprCil(param));
}
//ITypeCil typeCil;
////resuelve el metodo en cil de ese tipo estatico
var functionCil = typeCil.GetFunctionCilsByCoolName(parserRule.id.Text);
////nueva variable donde se almacena el valor que retorna el metodo
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
cilTree.ThreeDirInses.Add(new VCallCil(value, varType, functionCil));
return(value);
}
public IHolderCil Visit(LetExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
return(Visit(parserRule.let, cilTree, contextCil));
}
public virtual IHolderCil Visit(DispatchContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
var Params = new List <IHolderCil>();
var expr0 = Visit(parserRule.expresion, cilTree, contextCil);
foreach (var expr in parserRule._expresions)
{
//genera el codigo de cada parametro que le paso a los metodos
var param = Visit(expr, cilTree, contextCil);
Params.Add(param);
}
//Averiguo el tipo dinamico de self es decir( el de la clase que esta usando la funcion en ese momento)
var varType = new LocalCil($"_Type{cilTree.ThreeDirInses.Count}");
cilTree.LocalCils.Add(varType);
cilTree.ThreeDirInses.Add(new TypeOf(varType, expr0));
//Verifico si el tipo del objeto que le voy hacer el dispatch es void
if (parserRule.id.Text == "substr")
{
VisitString(parserRule, cilTree, new List <IHolderCil>()
{
expr0
}.Concat(Params).ToList());
}
if (cilTree.Name != "entry")
{
var isVoid = new LocalCil($"_isVoid{cilTree.ThreeDirInses.Count}");
cilTree.LocalCils.Add(isVoid);
cilTree.ThreeDirInses.Add(new NotEqualCil(isVoid, varType, CilAst.GetTypeCilByName("void")));
Visit_Runtime_Error_whit_Cond(isVoid, cilTree, $"\"({parserRule.id.Line},{parserRule.id.Column+1}) - Rutime Error: A dispatch on void\"");
cilTree.ThreeDirInses.Add(new ArgExprCil(expr0));
}
//cada parametro los anado al metodo puede que tenga sentido pasarlos al revez
foreach (var param in Params)
{
cilTree.ThreeDirInses.Add(new ArgExprCil(param));
}
////nueva variable donde se almacena el valor que retorna el metodo
var value = new LocalCil($"_value{cilTree.LocalCils.Count}");
cilTree.LocalCils.Add(value);
if (parserRule.type == null)
{
//Se resuleve el tipo de la expr0 a partir de su tipo estatico calculado por el checkeo semantico
var typeExpr0 = CilAst.GetTypeCilByName(parserRule.expresion.computedType.Name, typeCil);
////resuelve el metodo en cil de ese tipo estatico
var functionCil = typeExpr0.GetFunctionCilsByCoolName(parserRule.id.Text);
//como ningun tipo puede redefinir a string entonces llamo directamente al metodo
if (parserRule.expresion.computedType == GlobalContext.String)
{
cilTree.ThreeDirInses.Add(new CallCil(value, functionCil.Function));
}
else
{
cilTree.ThreeDirInses.Add(new VCallCil(value, varType, functionCil));
}
}
else
{
//Se resuelve el tipo de la type
var typeT = CilAst.GetTypeCilByName(parserRule.type.Text, typeCil);
var functionCil = typeT.GetFunctionCilsByCoolName(parserRule.id.Text).Function;
cilTree.ThreeDirInses.Add(new CallCil(value, functionCil));
}
return(value);
}
public IHolderCil Visit(IntegerExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
return(CreateABasicTypeWhitVal(cilTree, CilAst.Int, new HolderCil(parserRule.integer.Text)));
}
public IHolderCil Visit(InParenthesisExprContext parserRule, IFunctionCil cilTree, IContextCil contextCil)
{
return(Visit(parserRule.expresion, cilTree, contextCil));
}
