// Builds an argument for the constructor. public static void BuildArgument(IronyParser parser, Constructor method, ParseTreeNode node) { // Check for a directioned argument (out, ref). if (node.Term.ToString() == "out_parameter") { var a = new DirectionedParameter(null, node.FindToken().Convert()); switch (node.ChildNodes[0].ChildNodes[0].Term.ToString()) { case "ref": a.Direction = ParameterDirection.Ref; break; case "out": a.Direction = ParameterDirection.Out; break; } a.TypeName = parser.CheckAlias(node.ChildNodes[1].FindTokenAndGetText()); a.Name = node.ChildNodes[2].FindTokenAndGetText(); method.Parameters.Add(a); } else { // Build an undirectioned argument. var a = new SimpleParameter(null, node.FindToken().Convert()); a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText()); a.Name = node.ChildNodes[1].FindTokenAndGetText(); method.Parameters.Add(a); } }
// Build property declaration statement public static void BuildProperty(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var property = new Property(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(property); // If the parent is a module, make the property shared var c = parentExpression as Class; if (c.IsModule) { property.IsShared = true; } // Interpret the modifiers for the property declaration InterpretModifiers(root, property, currentNode.ChildNodes[0].ChildNodes[0]); // Check for conflicting/invalid property modifiers if (property.IsShared && (property.IsFinal || property.IsOverride)) { root.CompilerErrors.Add(new IncompatibleModifiersCompilerError("", currentNode.FindToken().Location.Line, currentNode.FindToken().Location.Position)); } // Find the return type for the property: check if it's generic or an array var typeNode = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0]; if (typeNode.ChildNodes[0].Term.ToString() == "array") { property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); property.TypeName = parser.CheckAlias(typeNode.ChildNodes[0].ChildNodes[0].FindTokenAndGetText()) + "[]"; } else if (typeNode.ChildNodes[0].Term.ToString() == "generic_identifier") { property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); property.TypeName = typeNode.ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<"; for (int i = 0; i < typeNode.ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++) { property.TypeName += typeNode.ChildNodes[0].ChildNodes[2].ChildNodes[i].FindTokenAndGetText(); if (i < typeNode.ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1) { property.TypeName += ","; } } property.TypeName += ">"; } else { property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); property.TypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].FindTokenAndGetText()); } // Build the get block for the property parser.ConsumeParseTree(root, property.GetBlock, currentNode.ChildNodes[1]); // Build the set block for the property parser.ConsumeParseTree(root, property.SetBlock, currentNode.ChildNodes[2]); }
// Build property declaration statement public static void BuildProperty(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var property = new Property(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(property); // If the parent is a module, make the property shared var c = parentExpression as Class; if (c.IsModule) { property.IsShared = true; } // Interpret the modifiers for the property declaration InterpretModifiers(root, property, currentNode.ChildNodes[0].ChildNodes[0]); // Check for conflicting/invalid property modifiers if (property.IsShared && (property.IsFinal || property.IsOverride)) root.CompilerErrors.Add(new IncompatibleModifiersCompilerError("", currentNode.FindToken().Location.Line, currentNode.FindToken().Location.Position)); // Find the return type for the property: check if it's generic or an array var typeNode = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0]; if(typeNode.ChildNodes[0].Term.ToString() == "array") { property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); property.TypeName = parser.CheckAlias(typeNode.ChildNodes[0].ChildNodes[0].FindTokenAndGetText()) + "[]"; } else if (typeNode.ChildNodes[0].Term.ToString() == "generic_identifier") { property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); property.TypeName = typeNode.ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<"; for(int i = 0; i < typeNode.ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++) { property.TypeName += typeNode.ChildNodes[0].ChildNodes[2].ChildNodes[i].FindTokenAndGetText(); if (i < typeNode.ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1) property.TypeName += ","; } property.TypeName += ">"; } else { property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); property.TypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].FindTokenAndGetText()); } // Build the get block for the property parser.ConsumeParseTree(root, property.GetBlock, currentNode.ChildNodes[1]); // Build the set block for the property parser.ConsumeParseTree(root, property.SetBlock, currentNode.ChildNodes[2]); }
// Build the arguments of the delegate declaration. public static void BuildArgument(IronyParser parser, DelegateDeclaration method, ParseTreeNode node) { if (node.Term.ToString() == "out_parameter") { var a = new DirectionedParameter(null, node.FindToken().Convert()); switch (node.ChildNodes[0].ChildNodes[0].Term.ToString()) { case "ref": a.Direction = ParameterDirection.Ref; break; case "out": a.Direction = ParameterDirection.Out; break; } a.TypeName = parser.CheckAlias(node.ChildNodes[1].FindTokenAndGetText()); a.Name = node.ChildNodes[2].FindTokenAndGetText(); method.Parameters.Add(a); } else if (node.Term.ToString() == "array_parameter") { var a = new SimpleParameter(null, node.FindToken().Convert()); a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText()) + "[]"; a.Name = node.ChildNodes[3].FindTokenAndGetText(); method.Parameters.Add(a); } else if (node.Term.ToString() == "generic_parameter") { var a = new SimpleParameter(null, node.FindToken().Convert()); string typeName = node.ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<"; for (int i = 0; i < node.ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++) { typeName += parser.CheckAlias(node.ChildNodes[0].ChildNodes[2].ChildNodes[i].FindTokenAndGetText()); if (i < node.ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1) { typeName += ","; } } typeName += ">"; a.TypeName = typeName; a.Name = node.ChildNodes[1].FindTokenAndGetText(); method.Parameters.Add(a); } else { var a = new SimpleParameter(null, node.FindToken().Convert()); a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText()); a.Name = node.ChildNodes[1].FindTokenAndGetText(); method.Parameters.Add(a); } }
// Build the arguments of the delegate declaration. public static void BuildArgument(IronyParser parser, DelegateDeclaration method, ParseTreeNode node) { if (node.Term.ToString() == "out_parameter") { var a = new DirectionedParameter(null, node.FindToken().Convert()); switch (node.ChildNodes[0].ChildNodes[0].Term.ToString()) { case "ref": a.Direction = ParameterDirection.Ref; break; case "out": a.Direction = ParameterDirection.Out; break; } a.TypeName = parser.CheckAlias(node.ChildNodes[1].FindTokenAndGetText()); a.Name = node.ChildNodes[2].FindTokenAndGetText(); method.Parameters.Add(a); } else if (node.Term.ToString() == "array_parameter") { var a = new SimpleParameter(null, node.FindToken().Convert()); a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText()) + "[]"; a.Name = node.ChildNodes[3].FindTokenAndGetText(); method.Parameters.Add(a); } else if(node.Term.ToString() == "generic_parameter") { var a = new SimpleParameter(null, node.FindToken().Convert()); string typeName = node.ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<"; for (int i = 0; i < node.ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++ ) { typeName += parser.CheckAlias(node.ChildNodes[0].ChildNodes[2].ChildNodes[i].FindTokenAndGetText()); if (i < node.ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1) typeName += ","; } typeName += ">"; a.TypeName = typeName; a.Name = node.ChildNodes[1].FindTokenAndGetText(); method.Parameters.Add(a); } else { var a = new SimpleParameter(null, node.FindToken().Convert()); a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText()); a.Name = node.ChildNodes[1].FindTokenAndGetText(); method.Parameters.Add(a); } }
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode) { base.Init(context, parseNode); var valueStr = parseNode.FindToken().Text; Value = valueStr.Equals("true"); }
// Build a simple return statement that does not return a value. void BuildReturn(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { Return e = new Return(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); e.ParentExpression = parentExpression; }
// Builds a "class" expression: really could be a class, struct, or module. public static void BuildClass(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { Class c = new Class(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(c); int i = 0; // Interpret the declaration modifiers (abstract, public, internal, etc). InterpretClassModifiers( root, c, currentNode.ChildNodes[i]); i++; // Determine if it's a class, module, or struct. switch(currentNode.ChildNodes[i].Term.ToString()) { case "module": c.IsModule = true; c.IsFinal = true; c.IsPartial = true; break; case "struct": c.IsStruct = true; c.IsModule = false; break; default: c.IsStruct = false; c.IsModule = false; break; } i++; // Class name c.UnqualifiedName = currentNode.ChildNodes[i].FindTokenAndGetText(); i++; // Get the generic type list. if (currentNode.ChildNodes[i].ChildNodes.Count > 0) { var generics = currentNode.ChildNodes[i].ChildNodes[0].ChildNodes[1]; foreach (string s in IronyParser.InterpretList(generics)) c.GenericTypeNames.Add(s); } i++; // Get the base type list. if (currentNode.ChildNodes[i].ChildNodes.Count > 0) { var baseTypes = currentNode.ChildNodes[i].ChildNodes[0].ChildNodes[0]; foreach (string s in IronyParser.InterpretList(baseTypes)) c.BaseTypeNames.Add(s); } i+=1; // Build the child expressions of the class. parser.ConsumeParseTree(root, c, currentNode.ChildNodes[i]); }
// Build a null literal public static void BuildNullLiteral(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var e = new Literal(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); e.Value = null; }
// Build a method invocation with generic type names public static void BuildGenericMethodInvocation(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var methodInvocation = new MethodInvocation(parentExpression, currentNode.FindToken().Convert()); methodInvocation.Name = currentNode.ChildNodes[0].FindTokenAndGetText(); parentExpression.ChildExpressions.Add(methodInvocation); methodInvocation.ParentExpression = parentExpression; // Interpret the generic type names if (currentNode.ChildNodes[2].ChildNodes.Count > 0) { foreach (var n in currentNode.ChildNodes[2].ChildNodes) { methodInvocation.GenericTypes.Add(n.FindTokenAndGetText()); } } // interpret the expressions that are passed to the invocation as arguments if (currentNode.ChildNodes[4].ChildNodes.Count > 0) { foreach (var n in currentNode.ChildNodes[1].ChildNodes) { parser.ConsumeParseTree(root, methodInvocation.Parameters, n); } } }
// Build a number, string, or character literal: v = 1234 public static void BuildLiteral(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var e = new Literal(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); e.ParentExpression = parentExpression; e.Value = currentNode.Token.Value; }
// Build a namespace expression public static void BuildNamespace(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { Namespace n = new Namespace(parentExpression, currentNode.FindToken().Convert()); n.Name = currentNode.ChildNodes[1].FindTokenAndGetText(); parentExpression.ChildExpressions.Add(n); parser.ConsumeParseTree(root, n, currentNode.ChildNodes[2]); }
// Build a variable reference (the "v" in "v = 1" void BuildVariableReference(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var e = new VariableReference(parentExpression, currentNode.FindToken().Convert()); e.Name = currentNode.FindTokenAndGetText(); e.ParentExpression = parentExpression; parentExpression.ChildExpressions.Add(e); }
// Build a throw expression public static void BuildThrow(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { Throw e = new Throw(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); e.ParentExpression = parentExpression; parser.ConsumeParseTree(root, e, currentNode.ChildNodes[1]); }
private IronyAstObjectCodeLocation(ISourceCodeUnitsContainer codeUnitsContainer, LanguageCodeLocation location, ParseTreeNode node) { CodeUnitsContainer = codeUnitsContainer; CodeLocation = location; CodeToken = node.FindToken(); CodeParseNode = node; SetLocationSpan(); }
// Build an import expression: one for each name imported. public static void BuildImport(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { foreach (var node in currentNode.ChildNodes[1].ChildNodes) { var i = new Import(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(i); i.ParentExpression = parentExpression; i.Name = node.FindTokenAndGetText(); } }
internal LanguageCompilationMessage(ISourceCodeUnitsContainer codeUnitsContainer, LanguageCodeLocation location, ParseTreeNode node, string description) { CodeUnitsContainer = codeUnitsContainer; CodeLocation = location; CodeToken = node.FindToken(); CodeParseNode = node; Description = description; SetLocationSpan(); }
// Build a boolean literal: v = true public static void BuildBoolLiteral(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var e = new Literal(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); e.ParentExpression = parentExpression; if (currentNode.ChildNodes[0].FindTokenAndGetText() == "true") e.Value = true; else e.Value = false; }
string BuildPythonInitializerMemberElement(DsdlType type, string fieldName, ParseTreeNode node) { switch (type) { case PrimitiveDsdlType _: var text = node.GetText(SourceText); switch (text) { case "true": text = "True"; break; case "false": text = "False"; break; case "null": text = "None"; break; } if (text.EndsWith("f", StringComparison.OrdinalIgnoreCase) && node.FindToken()?.Value is float) // Remove float 'f' suffix. { text = text.Substring(0, text.Length - 1); } return(text); case ArrayDsdlType adt when IsString(fieldName, type): return(node.GetText(SourceText)); case ArrayDsdlType adt: var nestesNodes = node.FindChild("members"); if (nestesNodes == null) { return("[]"); } var arrayContent = nestesNodes.ChildNodes.Select(x => BuildPythonInitializerMemberElement(adt.ElementType, fieldName, x)); return($"[{string.Join(", ", arrayContent)}]"); case CompositeDsdlTypeBase cdt: var t = _compoundTypesLookup[cdt]; return($"{t.Namespace}.{t.Name}(" + string.Join(", ", BuildPythonInitializerMembers(cdt.Fields, node.FindChild("members"))) + ")"); default: throw new InvalidOperationException(); } }
void IAstNodeInit.Init(AstContext context, ParseTreeNode parseNode) { NodeName = parseNode.Term == null?GetType().Name : parseNode.Term.Name; var tokens = new List <Token>(); var iToken = parseNode.FindToken(); if (iToken != null) { tokens.Add(new Token(iToken.Location.Column, iToken.Location.Line, iToken.Text, iToken.Value)); } var childNodes = new List <ISqlNode>(); foreach (var childNode in parseNode.ChildNodes) { ISqlNode child; if (childNode.Term is KeyTerm) { var childIToken = childNode.FindToken(); child = new SqlKeyNode(new Token(childIToken.Location.Column, childIToken.Location.Line, childIToken.Text, childIToken.Value)); } else { child = (ISqlNode)childNode.AstNode; } child = OnChildNode(child); if (child != null) { if (child is ISqlChildNode) { (child as ISqlChildNode).SetParent(this); } childNodes.Add(child); tokens.AddRange(child.Tokens); } } ChildNodes = childNodes.ToArray(); Tokens = tokens.ToArray(); CollectDataFromChildren(); CollectAllCommands(); OnNodeInit(); }
// Build a boolean literal: v = true public static void BuildBoolLiteral(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var e = new Literal(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); e.ParentExpression = parentExpression; if (currentNode.ChildNodes[0].FindTokenAndGetText() == "true") { e.Value = true; } else { e.Value = false; } }
// Build a method invocation statement (foo(1)) public static void BuildMethodInvocation(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var methodInvocation = new MethodInvocation(parentExpression, currentNode.FindToken().Convert()); methodInvocation.Name = currentNode.ChildNodes[0].FindTokenAndGetText(); parentExpression.ChildExpressions.Add(methodInvocation); // interpret the expressions that are passed to the invocation as arguments if (currentNode.ChildNodes[1].ChildNodes.Count > 0) { foreach (var n in currentNode.ChildNodes[1].ChildNodes) { parser.ConsumeParseTree(root, methodInvocation.Parameters, n); } } }
internal static void AddError(ParseTreeNode node, String message) { Token token = node.FindToken(); int line = 0; int col = 0; if (token != null) { line = token.Location.Line; col = token.Location.Column; } message = "[" + node.FindTokenAndGetText() + "] " + message; Logs?.Add(new LogMessage(ErrorLevel.Error, new SourceLocation(0, line, col), message, null)); }
// Build an assignment statement: i = 0, i += 1, i |= foo, etc public static void BuildAssignment(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var assignment = new Assignment(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(assignment); // Get the expression being assigned to parser.ConsumeParseTree(root, assignment, currentNode.ChildNodes[0]); // Determine what kind of assignment this is switch (currentNode.ChildNodes[1].FindTokenAndGetText()) { case "=": assignment.AssignmentType = AssignmentType.Equal; break; case "+=": assignment.AssignmentType = AssignmentType.Add; break; case "-=": assignment.AssignmentType = AssignmentType.Subtract; break; case "*=": assignment.AssignmentType = AssignmentType.Multiply; break; case "/=": assignment.AssignmentType = AssignmentType.Divide; break; case "|=": assignment.AssignmentType = AssignmentType.Or; break; case "&=": assignment.AssignmentType = AssignmentType.And; break; } // Get the value being assigned. parser.ConsumeParseTree(root, assignment, currentNode.ChildNodes[2]); }
// Build an if conditional statement. public static void BuildIfBlock(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var i = new IfBlock(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(i); int c = 1; // Build the conditional expression parser.ConsumeParseTree(root, i.Conditional, currentNode.ChildNodes[c]); c++; // Build the true block parser.ConsumeParseTree(root, i.TrueBlock, currentNode.ChildNodes[c]); c++; // Build the false block if one exists. if(currentNode.ChildNodes[c].ChildNodes.Count != 0) parser.ConsumeParseTree(root, i.FalseBlock, currentNode.ChildNodes[c]); }
// Build an assignment statement: i = 0, i += 1, i |= foo, etc public static void BuildAssignment(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var assignment = new Assignment(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(assignment); // Get the expression being assigned to parser.ConsumeParseTree(root, assignment, currentNode.ChildNodes[0]); // Determine what kind of assignment this is switch(currentNode.ChildNodes[1].FindTokenAndGetText()) { case "=": assignment.AssignmentType = AssignmentType.Equal; break; case "+=": assignment.AssignmentType = AssignmentType.Add; break; case "-=": assignment.AssignmentType = AssignmentType.Subtract; break; case "*=": assignment.AssignmentType = AssignmentType.Multiply; break; case "/=": assignment.AssignmentType = AssignmentType.Divide; break; case "|=": assignment.AssignmentType = AssignmentType.Or; break; case "&=": assignment.AssignmentType = AssignmentType.And; break; } // Get the value being assigned. parser.ConsumeParseTree(root, assignment, currentNode.ChildNodes[2]); }
// Build an if conditional statement. public static void BuildIfBlock(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var i = new IfBlock(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(i); int c = 1; // Build the conditional expression parser.ConsumeParseTree(root, i.Conditional, currentNode.ChildNodes[c]); c++; // Build the true block parser.ConsumeParseTree(root, i.TrueBlock, currentNode.ChildNodes[c]); c++; // Build the false block if one exists. if (currentNode.ChildNodes[c].ChildNodes.Count != 0) { parser.ConsumeParseTree(root, i.FalseBlock, currentNode.ChildNodes[c]); } }
private Object resolverExp(ParseTreeNode nodo) { switch (nodo.Term.Name) { case "TERMINO": { return(resolverExp(nodo.ChildNodes[0])); } case ConstantesInterprete.ENTERO: { return(int.Parse(nodo.ChildNodes[0].Token.ValueString)); } case ConstantesInterprete.DECIMAL: { return(double.Parse(nodo.ChildNodes[0].Token.ValueString)); } case "ID": { string id = nodo.ChildNodes[0].Token.ValueString; return(temporales.getValorTemp(id)); } case ConstantesInterprete.NEGATIVO: { Object valn = resolverExp(nodo.ChildNodes[1]); if (valn is int) { return(int.Parse(valn + "") * -1); } if (valn is Double) { return(Double.Parse(valn + "") * -1); } return(""); } case ConstantesInterprete.OPERACION: { #region operaciones Object val1 = resolverExp(nodo.ChildNodes[0]); Object val2 = resolverExp(nodo.ChildNodes[2]); switch (nodo.ChildNodes[1].ChildNodes[0].Term.Name) { case "+": { if ((esInt(val1) || esDouble(val1)) && (esInt(val2) || esDouble(val2))) { if (esInt(val2) && esInt(val2)) { return((int)int.Parse(val1.ToString()) + int.Parse(val2.ToString())); } else { return((Double)double.Parse(val1.ToString()) + double.Parse(val2.ToString())); } } else { ErrorA n = new ErrorA("Semantico", "Tipos no validos para una suma", nodo.FindToken()); Form1.errores.addError(n); return("nulo"); } } case "-": { if ((esInt(val1) || esDouble(val1)) && (esInt(val2) || esDouble(val2))) { if (esInt(val2) && esInt(val2)) { return((int)int.Parse(val1.ToString()) - int.Parse(val2.ToString())); } else { return((Double)double.Parse(val1.ToString()) - double.Parse(val2.ToString())); } } else { ErrorA n = new ErrorA("Semantico", "Tipos no validos para una resta", nodo.FindToken()); Form1.errores.addError(n); return("nulo"); } } case "*": { if ((esInt(val1) || esDouble(val1)) && (esInt(val2) || esDouble(val2))) { if (esInt(val2) && esInt(val2)) { return((int)int.Parse(val1.ToString()) * int.Parse(val2.ToString())); } else { return((Double)double.Parse(val1.ToString()) * double.Parse(val2.ToString())); } } else { ErrorA n = new ErrorA("Semantico", "Tipos no validos para una multiplicacion", nodo.FindToken()); Form1.errores.addError(n); return("nulo"); } } case "/": { if ((esInt(val1) || esDouble(val1)) && (esInt(val2) || esDouble(val2))) { if (int.Parse(val2.ToString()) != 0) { return(double.Parse(val1.ToString()) / double.Parse(val2.ToString())); } else { ErrorA n = new ErrorA("Semantico", "No se puede realizar division por cero", nodo.FindToken()); Form1.errores.addError(n); return("nulo"); } } else { ErrorA n = new ErrorA("Semantico", "Tipos no validos para una division", nodo.FindToken()); Form1.errores.addError(n); return("nulo"); } } case "^": { if ((esInt(val1) || esDouble(val1)) && (esInt(val2) || esDouble(val2))) { if (esInt(val2) && esInt(val2)) { return((int)Math.Pow(int.Parse(val1.ToString()), int.Parse(val2.ToString()))); } else { return((Double)Math.Pow(Double.Parse(val1.ToString()), Double.Parse(val2.ToString()))); } } else { ErrorA n = new ErrorA("Semantico", "Tipos no validos para una potencia", nodo.FindToken()); Form1.errores.addError(n); return("nulo"); } } } //fin switch operaciones #endregion } return("nulo"); } return("nulo"); }
private void heap(ParseTreeNode nodo, int modo) { if (modo == 0) { //asignacionHeap.Rule = identificador + ToTerm("=") + "HEAP" + "[" + EXPRESION + "]" + ";"; string id = nodo.ChildNodes[0].Token.ValueString; Object val = resolverExp(nodo.ChildNodes[1]); if (!esNula(val)) { int indice = (int)val; temporales.agregarTemp(new Temporal(id, Heap[indice])); } else { ErrorA er = new ErrorA("Semantico", "Ocurrio un error a realizar la operacion", nodo.FindToken()); Form1.errores.addError(er); } } else if (modo == 1) {//heap.Rule = ToTerm("HEAP") + "[" + EXPRESION + "]" + "=" + EXPRESION + ";"; object objIndice = resolverExp(nodo.ChildNodes[0]); object valor = resolverExp(nodo.ChildNodes[1]); if (!esNula(objIndice) && !esNula(valor)) { int indice = (int)objIndice; if (valor is Double) { Heap[indice] = (double)valor; } else if (valor is int) { Heap[indice] = (int)valor; } } else { ErrorA er = new ErrorA("Semantico", "Ocurrio un error a realizar la operacion", nodo.FindToken()); Form1.errores.addError(er); } } }
private static T FindTokenAndGetValue <T>(this ParseTreeNode node) { try { return(node.FindToken().ValueString.As <T>()); } catch { throw node.GetException($"Invalid token '{node.FindTokenAndGetText()}'. Expected a token of type {typeof(T)}"); } }
public nodo_expresion extraer_arbol(ParseTreeNode raiz) { String termino = "", token = ""; if (raiz.Term != null) { termino = raiz.Term.ToString(); } if (raiz.Token != null) { token = raiz.Token.Text; } if (termino.Equals("NUMERO") || termino.Equals("CADENA") || termino.Equals("True") || termino.Equals("False") || termino.Equals("ID")) { String tipo = ""; if (termino.Equals("NUMERO")) { tipo = "number"; } else if (termino.Equals("CADENA")) { tipo = "string"; } else if (termino.Equals("True")) { token = "1"; tipo = "bool"; } else if (termino.Equals("False")) { token = "0"; tipo = "bool"; } else { tipo = "id"; } nodo_expresion nuevo = new nodo_expresion(token.Replace("\"", ""), "terminal", tipo, raiz.Token.Location.Line, raiz.Token.Location.Column); return(nuevo); } else if (termino.Equals("llamar_funcion")) { nodo_expresion funcion = new nodo_expresion(raiz.ChildNodes.ElementAt(0).Token.Text, "llamar_funcion", "llamar_funcion", raiz.ChildNodes.ElementAt(0).Token.Location.Line, raiz.ChildNodes.ElementAt(0).Token.Location.Column); List <arbol_expresion> expresiones = new List <arbol_expresion>(); ParseTreeNode lista = raiz.ChildNodes.ElementAt(1); for (int i = 0; i < lista.ChildNodes.Count; i++) { arbol_expresion arbol = new arbol_expresion(); arbol.raiz = extraer_arbol(lista.ChildNodes.ElementAt(i)); expresiones.Add(arbol); } funcion.parametros = expresiones; //METER PARAMETROS AL NODO return(funcion); } else if (termino.Equals("exprecion")) { if (raiz.ChildNodes.Count == 3) { nodo_expresion izq = extraer_arbol(raiz.ChildNodes.ElementAt(0)); nodo_expresion der = extraer_arbol(raiz.ChildNodes.ElementAt(2)); nodo_expresion op = extraer_arbol(raiz.ChildNodes.ElementAt(1)); op.izq = izq; op.der = der; return(op); } else if (raiz.ChildNodes.Count == 2) { nodo_expresion izq = extraer_arbol(raiz.ChildNodes.ElementAt(1)); nodo_expresion op = extraer_arbol(raiz.ChildNodes.ElementAt(0)); op.izq = izq; return(op); } else { nodo_expresion nodo = extraer_arbol(raiz.ChildNodes.ElementAt(0)); return(nodo); } } else if (termino.Equals("relacion")) { nodo_expresion izq = extraer_arbol(raiz.ChildNodes.ElementAt(0)); nodo_expresion der = extraer_arbol(raiz.ChildNodes.ElementAt(2)); nodo_expresion op = extraer_arbol(raiz.ChildNodes.ElementAt(1)); op.izq = izq; op.der = der; return(op); } else if (termino.Equals("condicion")) { if (raiz.ChildNodes.Count == 3) { nodo_expresion izq = extraer_arbol(raiz.ChildNodes.ElementAt(0)); nodo_expresion der = extraer_arbol(raiz.ChildNodes.ElementAt(2)); nodo_expresion op = extraer_arbol(raiz.ChildNodes.ElementAt(1)); op.izq = izq; op.der = der; return(op); } else if (raiz.ChildNodes.Count == 2) { nodo_expresion izq = extraer_arbol(raiz.ChildNodes.ElementAt(1)); nodo_expresion op = extraer_arbol(raiz.ChildNodes.ElementAt(0)); op.izq = izq; return(op); } else { nodo_expresion nodo = extraer_arbol(raiz.ChildNodes.ElementAt(0)); return(nodo); } } else if (!termino.Equals("exprecion")) { nodo_expresion nuevo; try { nuevo = new nodo_expresion(token, "operador", "operador", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } catch (Exception e) { nuevo = new nodo_expresion(token, "operador", "operador", -1, -1); } return(nuevo); } return(null); //Console.WriteLine(termino + " , " + token); }
// Build a variable declaration void BuildExplicitVariableDeclaration(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { ExplicitVariableDeclaration e = new ExplicitVariableDeclaration(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); // "int foo" if(currentNode.ChildNodes[0].ChildNodes[0].Term.ToString() == "simple_explicit_variable_declaration") { e.TypeName = CheckAlias(currentNode.ChildNodes[0].ChildNodes[0].ChildNodes[0].FindTokenAndGetText()); e.Name = currentNode.ChildNodes[0].ChildNodes[0].ChildNodes[1].FindTokenAndGetText(); } // "var foo" if (currentNode.ChildNodes[0].ChildNodes[0].Term.ToString() == "implicit_variable_declaration") { e.TypeName = "var"; e.Name = currentNode.ChildNodes[0].ChildNodes[0].ChildNodes[1].FindTokenAndGetText(); } // int [] foo if (currentNode.ChildNodes[0].ChildNodes[0].Term.ToString() == "array_explicit_variable_declaration") { e.TypeName = parser.CheckAlias(CheckAlias(currentNode.ChildNodes[0].ChildNodes[0].ChildNodes[0].FindTokenAndGetText())) + "[]"; e.Name = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[0].ChildNodes[3].FindTokenAndGetText()); } // List{int} foo if(currentNode.ChildNodes[0].ChildNodes[0].Term.ToString() == "generic_explicit_variable_declaration") { e.TypeName = CheckAlias(currentNode.ChildNodes[0].ChildNodes[0].ChildNodes[0].FindTokenAndGetText()); foreach (ParseTreeNode n in currentNode.ChildNodes[0].ChildNodes[0].ChildNodes[2].ChildNodes) { e.GenericTypes.Add(parser.CheckAlias(n.FindTokenAndGetText())); } e.Name = currentNode.ChildNodes[0].ChildNodes[0].ChildNodes[4].FindTokenAndGetText(); } }
void IAstNodeInit.Init(AstContext context, ParseTreeNode parseNode) { NodeName = parseNode.Term == null ? GetType().Name : parseNode.Term.Name; var tokens = new List<Token>(); var iToken = parseNode.FindToken(); if (iToken != null) { tokens.Add(new Token(iToken.Location.Column, iToken.Location.Line, iToken.Text, iToken.Value)); } var childNodes = new List<ISqlNode>(); foreach (var childNode in parseNode.ChildNodes) { ISqlNode child; if (childNode.Term is KeyTerm) { var childIToken = childNode.FindToken(); child = new SqlKeyNode(new Token(childIToken.Location.Column, childIToken.Location.Line, childIToken.Text, childIToken.Value)); } else { child = (ISqlNode)childNode.AstNode; } child = OnChildNode(child); if (child != null) { if (child is ISqlChildNode) (child as ISqlChildNode).SetParent(this); childNodes.Add(child); tokens.AddRange(child.Tokens); } } ChildNodes = childNodes.ToArray(); Tokens = tokens.ToArray(); OnNodeInit(); }
// Build a return statement that returns a value void BuildReturnValue(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { Return e = new Return(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); e.ParentExpression = parentExpression; ConsumeParseTree(root, e, currentNode.ChildNodes[1]); }
internal static void AddLog(string message, ParseTreeNode log_node) => Logs?.Add(new LogMessage(ErrorLevel.Info, log_node.FindToken().Location, message, null));
public override void Init(AstContext context, ParseTreeNode parseNode) { //throw(new NotImplementedException()); this.Content = parseNode.FindToken().ValueString; }
void recorrer_arbol(ParseTreeNode raiz) { String termino = "", token = ""; if (raiz.Term != null) { termino = raiz.Term.ToString(); } if (raiz.Token != null) { token = raiz.Token.ToString(); } if (termino.Equals("incerteza")) { String numero = raiz.ChildNodes.ElementAt(1).Token.Text; Double incerteza = Double.Parse(numero.Replace('.', ',')); this.interprete.set_incerteza(incerteza); } else if (termino.Equals("ruta")) { String ruta = raiz.ChildNodes.ElementAt(1).Token.Text; this.interprete.set_ruta(ruta); } else if (termino.Equals("incluye")) { String texto = ""; String incluye = raiz.ChildNodes.ElementAt(1).Token.Text; try { String ruta = contenedor.SelectedTab.Name; String[] partes = ruta.Split('\\'); ruta = ""; for (int i = 0; i < partes.Length - 1; i++) { ruta += partes[i] + "\\"; } System.IO.StreamReader file = new System.IO.StreamReader(ruta + incluye); texto = file.ReadToEnd(); file.Close(); analizar(texto); } catch (Exception e) { errores.errores.add_error("Error Semantico", "Archivo " + incluye + " inaccesible", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); return; } /* * String incluye = raiz.ChildNodes.ElementAt(1).Token.Text; * Console.WriteLine("debería de incluir " + incluye); * analizar("Define 666 Define \"nuevo\" Principal () { alo= polisia; }"); */ } else if (termino.Equals("declaracion")) { String tipo = raiz.ChildNodes.ElementAt(0).Token.Text; List <String> ids = new List <string>(); for (int i = 0; i < raiz.ChildNodes.ElementAt(1).ChildNodes.Count; i++) { ids.Add(raiz.ChildNodes.ElementAt(1).ChildNodes.ElementAt(i).Token.Text); } arbol_expresion arbol = new arbol_expresion(); if (raiz.ChildNodes.ElementAt(2).ChildNodes.Count > 0) { arbol.raiz = extraer_arbol(raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(1)); //@const.dibujar_expresion(arbol.raiz, "prueba_expresion"); /*nodo_expresion resultado= arbol.ejecutar_arbol(); * Console.WriteLine("----------------------"); * Console.WriteLine(resultado.valor + " " + resultado.tipo + " " + resultado.rol); * Console.WriteLine("----------------------"); */ } interprete.add_sentencia("declarar", ids, arbol, tipo.ToLower(), raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } else if (termino.Equals("declarar_funcion")) { if (raiz.ChildNodes.ElementAt(0).Token.Text.Equals("Principal")) { interprete.funcion_nueva("Principal", interprete.get_funcion(), "void"); raiz.ChildNodes.ForEach(recorrer_arbol); interprete.set_principal(); return; } else { interprete.funcion_nueva(raiz.ChildNodes.ElementAt(1).Token.Text, interprete.get_funcion(), raiz.ChildNodes.ElementAt(0).Token.Text); raiz.ChildNodes.ForEach(recorrer_arbol); interprete.agregar_nombre(pars); pars = ""; interprete.pop_funcion(); return; } } else if (termino.Equals("parametro")) { String tipo = raiz.ChildNodes.ElementAt(0).Token.Text; String nombre = raiz.ChildNodes.ElementAt(1).Token.Text; interprete.add_parametro(tipo, nombre); pars += "#" + tipo.ToLower(); } else if (termino.Equals("asignacion")) { String id = raiz.ChildNodes.ElementAt(0).Token.Text; List <String> lista = new List <string>(); lista.Add(id); nodo_expresion expresion = extraer_arbol(raiz.ChildNodes.ElementAt(2)); arbol_expresion arbol = new arbol_expresion(); arbol.raiz = expresion; interprete.add_sentencia("asignacion", lista, arbol, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } else if (termino.Equals("retorno_noterminal")) { arbol_expresion arbol = new arbol_expresion(); if (raiz.ChildNodes.Count > 1) { arbol.raiz = extraer_arbol(raiz.ChildNodes.ElementAt(1)); } interprete.add_sentencia("retorno", null, arbol, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } else if (termino.Equals("sentencia_continuar")) { interprete.add_sentencia("continuar", null, new arbol_expresion(), raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } else if (termino.Equals("sentencia_detener")) { interprete.add_sentencia("detener", null, new arbol_expresion(), raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } else if (termino.Equals("call_funcion")) { arbol_expresion arbol = new arbol_expresion(); arbol.raiz = extraer_arbol(raiz.ChildNodes.ElementAt(0)); interprete.add_sentencia("call_funcion", null, arbol, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } else if (termino.Equals("flujo_si")) { List <camino> caminos = new List <camino>(); //extrae la condicion nodo_expresion cond = extraer_arbol(raiz.ChildNodes.ElementAt(0)); //inserta funcion para anidar interprete.funcion_nueva("si", interprete.get_funcion(), "void"); //inserta sentencias recorrer_arbol(raiz.ChildNodes.ElementAt(1)); //obtiene el camino si funcion si = interprete.extraer_funcion(); //agrega primer camino caminos.Add(new camino(cond, si)); //obtener el else if (raiz.ChildNodes.ElementAt(2).ChildNodes.Count > 0) { //si hay else interprete.funcion_nueva("Sino", interprete.get_funcion(), "void"); recorrer_arbol(raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0)); funcion sino = interprete.extraer_funcion(); caminos.Add(new camino(null, sino)); } interprete.add_sentencia("si", new arbol_expresion(), caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); return; } else if (termino.Equals("flujo_selecciona")) { List <camino> caminos = new List <camino>(); //extrae la expresion a comparar nodo_expresion expresion = extraer_arbol(raiz.ChildNodes.ElementAt(0)); ParseTreeNode pares = raiz.ChildNodes.ElementAt(1); int caminos_cant = pares.ChildNodes.Count; for (int i = 0; i < caminos_cant; i++) { ParseTreeNode par = pares.ChildNodes.ElementAt(i); //hacer condicion nodo_expresion condicion = new nodo_expresion("==", "operador", "operador", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); condicion.izq = expresion; //extraer valor nodo_expresion valor = extraer_arbol(par.ChildNodes.ElementAt(0)); condicion.der = valor; //extraer el camino interprete.funcion_nueva("camino", interprete.get_funcion(), "void"); recorrer_arbol(par.ChildNodes.ElementAt(1)); funcion flujo = interprete.extraer_funcion(); //insertar el camino caminos.Add(new camino(condicion, flujo)); } //obtener el Defecto if (raiz.ChildNodes.ElementAt(2).ChildNodes.Count > 0) { //si hay defecto interprete.funcion_nueva("defecto", interprete.get_funcion(), "void"); recorrer_arbol(raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0)); funcion defecto = interprete.extraer_funcion(); caminos.Add(new camino(null, defecto)); } interprete.add_sentencia("selecciona", new arbol_expresion(), caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); return; } else if (termino.Equals("flujo_para")) { //crear sentencia de asignacion inicial List <String> id = new List <string>(); id.Add(raiz.ChildNodes.ElementAt(1).Token.Text); arbol_expresion expresion = new arbol_expresion(); expresion.raiz = extraer_arbol(raiz.ChildNodes.ElementAt(3)); sentencia asignacion_inicial = new sentencia("declarar", id, expresion, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); asignacion_inicial.tipo_dato = "number"; //extraer condicion nodo_expresion condicion = extraer_arbol(raiz.ChildNodes.ElementAt(4)); //sacar flujo List <camino> caminos = new List <camino>(); //inserta funcion para anidar interprete.funcion_nueva("para", interprete.get_funcion(), "void"); //inserta sentencias recorrer_arbol(raiz.ChildNodes.ElementAt(6)); //obtiene el camino funcion para = interprete.extraer_funcion(); //meter paso al flujo nodo_expresion op = new nodo_expresion("", "", "", -1, -1); nodo_expresion var = new nodo_expresion(id.ElementAt(0), "terminal", "id", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); nodo_expresion uno = new nodo_expresion("1", "terminal", "NUMERO", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); if (raiz.ChildNodes.ElementAt(5).Token.Text.Equals("++")) { op = new nodo_expresion("+", "operador", "operador", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } else if (raiz.ChildNodes.ElementAt(5).Token.Text.Equals("--")) { op = new nodo_expresion("-", "operador", "operador", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); } op.izq = var; op.der = uno; arbol_expresion asignacion = new arbol_expresion(); asignacion.raiz = op; sentencia paso = new sentencia("asignacion", id, asignacion, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); para.add_sentencia(paso); //agrega primer camino caminos.Add(new camino(condicion, para)); //meter sentencia interprete.add_sentencia("para", asignacion_inicial, caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); return; } else if (termino.Equals("flujo_hasta")) { //extraer condicion nodo_expresion condicion = extraer_arbol(raiz.ChildNodes.ElementAt(0)); //sacar flujo List <camino> caminos = new List <camino>(); //inserta funcion para anidar interprete.funcion_nueva("hasta", interprete.get_funcion(), "void"); //inserta sentencias recorrer_arbol(raiz.ChildNodes.ElementAt(1)); //obtiene el camino funcion hasta = interprete.extraer_funcion(); //agrega primer camino caminos.Add(new camino(condicion, hasta)); //meter sentencia interprete.add_sentencia("hasta", new arbol_expresion(), caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); return; } else if (termino.Equals("flujo_mientras")) { //extraer condicion nodo_expresion condicion = extraer_arbol(raiz.ChildNodes.ElementAt(0)); //sacar flujo List <camino> caminos = new List <camino>(); //inserta funcion para anidar interprete.funcion_nueva("mientras", interprete.get_funcion(), "void"); //inserta sentencias recorrer_arbol(raiz.ChildNodes.ElementAt(1)); //obtiene el camino funcion mientras = interprete.extraer_funcion(); //agrega primer camino caminos.Add(new camino(condicion, mientras)); //meter sentencia interprete.add_sentencia("mientras", new arbol_expresion(), caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column); return; } //Console.WriteLine("-"+termino+"-"+ token+"-"); raiz.ChildNodes.ForEach(recorrer_arbol); }
// Build a method declaration expression public static void BuildMethodDeclaration(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { MethodDeclaration e = new MethodDeclaration(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); int i = 0; // Set default modifiers var c = parentExpression as Class; if (c.IsModule) // If the parent is a module, set the method to shared. { e.IsShared = true; } // Interpret the modifiers for the method declaration InterpretModifiers(root, e, currentNode.ChildNodes[0].ChildNodes[0]); if (e.IsShared && (e.IsFinal || e.IsOverride)) { root.CompilerErrors.Add(new IncompatibleModifiersCompilerError("", currentNode.FindToken().Location.Line, currentNode.FindToken().Location.Position)); } i += 1; // skip the def // Interpret the return type name: check if it's an array, generic, or simple type name if (currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].Term.ToString() == "array") { e.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); e.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].FindTokenAndGetText()) + "[]"; } else if (currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].Term.ToString() == "generic_identifier") { var genericNode = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0]; e.Name = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText()); e.ReturnTypeName = parser.CheckAlias(genericNode.ChildNodes[0].FindTokenAndGetText()) + "<"; for (int n = 0; n < genericNode.ChildNodes[2].ChildNodes.Count; n++) { e.ReturnTypeName += parser.CheckAlias(genericNode.ChildNodes[2].ChildNodes[n].FindTokenAndGetText()); if (n < genericNode.ChildNodes[2].ChildNodes.Count - 1) { e.ReturnTypeName += ","; } } e.ReturnTypeName += ">"; } else { e.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); e.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].FindTokenAndGetText()); } i++; i++; // Add the generic type names for the method declaration if (currentNode.ChildNodes[1].ChildNodes.Count > 0) { var generics = currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[1]; foreach (string s in IronyParser.InterpretList(generics)) { e.GenericTypeNames.Add(s); } } i += 1; // add the arguments for the method declaration if (currentNode.ChildNodes[2].ChildNodes.Count > 0) { foreach (var n in currentNode.ChildNodes[2].ChildNodes) { BuildArgument(parser, e, n.ChildNodes[0]); } } // Build the body of statements in the method declaration parser.ConsumeParseTree(root, e, currentNode.ChildNodes[3]); }
// Build a method declaration expression public static void BuildMethodDeclaration(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { MethodDeclaration e = new MethodDeclaration(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(e); int i = 0; // Set default modifiers var c = parentExpression as Class; if(c.IsModule) // If the parent is a module, set the method to shared. { e.IsShared = true; } // Interpret the modifiers for the method declaration InterpretModifiers(root, e, currentNode.ChildNodes[0].ChildNodes[0]); if(e.IsShared && (e.IsFinal || e.IsOverride)) root.CompilerErrors.Add(new IncompatibleModifiersCompilerError("", currentNode.FindToken().Location.Line, currentNode.FindToken().Location.Position)); i+=1; // skip the def // Interpret the return type name: check if it's an array, generic, or simple type name if (currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].Term.ToString() == "array") { e.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); e.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].FindTokenAndGetText()) + "[]"; } else if (currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].Term.ToString() == "generic_identifier") { var genericNode = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0]; e.Name = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText()); e.ReturnTypeName = parser.CheckAlias(genericNode.ChildNodes[0].FindTokenAndGetText()) + "<"; for(int n = 0; n < genericNode.ChildNodes[2].ChildNodes.Count; n++) { e.ReturnTypeName += parser.CheckAlias(genericNode.ChildNodes[2].ChildNodes[n].FindTokenAndGetText()); if(n < genericNode.ChildNodes[2].ChildNodes.Count - 1) e.ReturnTypeName += ","; } e.ReturnTypeName += ">"; } else { e.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); e.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].FindTokenAndGetText()); } i++; i++; // Add the generic type names for the method declaration if (currentNode.ChildNodes[1].ChildNodes.Count > 0) { var generics = currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[1]; foreach (string s in IronyParser.InterpretList(generics)) e.GenericTypeNames.Add(s); } i+=1; // add the arguments for the method declaration if (currentNode.ChildNodes[2].ChildNodes.Count > 0) { foreach (var n in currentNode.ChildNodes[2].ChildNodes) { BuildArgument(parser, e, n.ChildNodes[0]); } } // Build the body of statements in the method declaration parser.ConsumeParseTree(root, e, currentNode.ChildNodes[3]); }
// Build a binary operator statement public static void BuildBinaryOperator(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var op = new BinaryOperator(parentExpression, currentNode.FindToken().Convert()); parentExpression.ChildExpressions.Add(op); // Determine which binary operator this is switch (currentNode.ChildNodes[1].Term.ToString()) { case "*": op.OperatorType = BinaryOperatorType.Multiply; break; case "/": op.OperatorType = BinaryOperatorType.Divide; break; case "+": op.OperatorType = BinaryOperatorType.Add; break; case "-": op.OperatorType = BinaryOperatorType.Subtract; break; case "%": op.OperatorType = BinaryOperatorType.Modulo; break; case "<=": op.OperatorType = BinaryOperatorType.LessOrEqual; break; case "<": op.OperatorType = BinaryOperatorType.Less; break; case "==": op.OperatorType = BinaryOperatorType.Equal; break; case "!=": op.OperatorType = BinaryOperatorType.NotEqual; break; case ">=": op.OperatorType = BinaryOperatorType.GreaterOrEqual; break; case ">": op.OperatorType = BinaryOperatorType.Greater; break; case ">>": op.OperatorType = BinaryOperatorType.BitwiseShiftRight; break; case "<<": op.OperatorType = BinaryOperatorType.BitwiseShiftLeft; break; case "&&": op.OperatorType = BinaryOperatorType.LogicalAnd; break; case "||": op.OperatorType = BinaryOperatorType.LogicalOr; break; case "|": op.OperatorType = BinaryOperatorType.BitwiseOr; break; case "&": op.OperatorType = BinaryOperatorType.BitwiseAnd; break; case "^": op.OperatorType = BinaryOperatorType.BitwiseXor; break; case "as": op.OperatorType = BinaryOperatorType.As; break; } // Get the left operand parser.ConsumeParseTree(root, op, currentNode.ChildNodes[0]); // "as" operator is a type case and needs to be handled differently if(op.OperatorType == BinaryOperatorType.As) { var v = new VariableReference(op, null); v.Name = currentNode.ChildNodes[2].ChildNodes[0].FindTokenAndGetText(); op.ChildExpressions.Add(v); } else parser.ConsumeParseTree(root, op, currentNode.ChildNodes[2]); }
private static void ValidateArgumentList(ParseTreeNode args, params string[] validArgs) { if (args != null) { var dups = args.ChildNodes .GroupBy(a => a.FindToken().ValueString.ToLower()) .Select(a => new { Name = a.Key, Count = a.Count() }) .Where(a => a.Count > 1) .FirstOrDefault(); if (dups != null) { throw args.GetException($"Argument {dups.Name} was specified more than once in function {args.FindToken().ValueString}"); } var invalidArgs = args.ChildNodes .Select(a => a.FindToken()) .Where(a => !a.ValueString.ToLower().IsIn(validArgs)); if (invalidArgs.Any()) { var badArg = invalidArgs.First(); throw badArg.GetException($"Invalid argument '{badArg.ValueString}'"); } } }
private void pila(ParseTreeNode nodo, int modo) { if (modo == 0) {// identificador + ToTerm("=") + "STACK" + "[" + EXPRESION + "]" + ";"; string id = nodo.ChildNodes[0].Token.ValueString; Object val = resolverExp(nodo.ChildNodes[1]); int aux = (int)val; if (!val.ToString().Equals("nulo")) { temporales.agregarTemp(new Temporal(id, Pila[aux])); } else { ErrorA er = new ErrorA("Semantico", "Ocurrio un error a realizar la operacion", nodo.FindToken()); Form1.errores.addError(er); } } else if (modo == 1) {// stack.Rule = ToTerm("STACK") + "[" + EXPRESION + "]" + "=" + EXPRESION + ";"; Object indice = resolverExp(nodo.ChildNodes[0]); Object valor = resolverExp(nodo.ChildNodes[1]); if (!valor.ToString().Equals("nulo") && !indice.ToString().Equals("nulo")) { int ind = (int)indice; if (valor is Double) { Pila[ind] = (double)valor; } else if (valor is int) { Pila[ind] = (int)valor; } } else { ErrorA er = new ErrorA("Semantico", "Ocurrio un error a realizar la operacion", nodo.FindToken()); Form1.errores.addError(er); } } }
//Getting exceptions private static InvalidOperationException GetException(this ParseTreeNode node, string message) { return(node.FindToken().GetException(message)); }
public Token FindToken() { return(parseTreeNode.FindToken()); }