// Build an interface method declaration. public static void BuildInterfaceMethod(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var method = new MethodDeclaration(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(method); // Build the return type of the interface method. method.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[0].FindTokenAndGetText()); // The name of the interface method. method.Name = currentNode.ChildNodes[0].ChildNodes[1].FindTokenAndGetText(); // Build the list of generic type names. if (currentNode.ChildNodes[1].ChildNodes.Count > 0) { var generics = currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[1]; foreach (string s in IronyParser.InterpretList(generics)) method.GenericTypeNames.Add(parser.CheckAlias(s)); } // Build the arguments of the method if (currentNode.ChildNodes[2].ChildNodes.Count > 0) { foreach (var n in currentNode.ChildNodes[2].ChildNodes) { MethodDeclarationBuilder.BuildArgument(parser, method, n.ChildNodes[0]); } } }
// Build an instantiation expression "new foo()" public static void BuildInstantiation(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var ist = new Instantiation(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(ist); // A non-array instantiation if (currentNode.ChildNodes[1].ChildNodes[0].Term.ToString() == "new_instantiate") { ist.Name = parser.CheckAlias(currentNode.ChildNodes[1].ChildNodes[0].FindTokenAndGetText()); if (currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[1].ChildNodes.Count > 0) foreach (var n in currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[1].ChildNodes) { ist.GenericTypes.Add(parser.CheckAlias(n.FindTokenAndGetText())); } foreach (var n in currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[2].ChildNodes) { parser.ConsumeParseTree(root, ist.Parameters, n); } } else // An array instantiation { ist.IsArray = true; ist.Name = parser.CheckAlias(currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[0].FindTokenAndGetText()); parser.ConsumeParseTree(root, ist.Parameters, currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[2]); } }
public Enum(Expression parentExpression, Token token) : base(parentExpression, token) { Constants = new List<EnumConstant>(); UnqualifiedName = ""; Accessibility = Accessibility.Public; }
// 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]); }
public ExceptionHandler(Expression parentExpression, Token token) : base(parentExpression, token) { Try = new Expression(this, null); CatchClauses = new List<CatchClause>(); Finally = new Expression(this, null); }
// Build a constructor expression. public static void BuildConstructor(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var ctor = new Constructor(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(ctor); // Interpret the declaration modifiers. InterpretModifiers(root, ctor, currentNode.ChildNodes[0]); // Interpret the arguments of the constructor. if (currentNode.ChildNodes[2].ChildNodes.Count > 0) { foreach (var n in currentNode.ChildNodes[2].ChildNodes) { BuildArgument(parser, ctor, n.ChildNodes[0]); } } // Build the "this" or "base" constructors called, if any. if(currentNode.ChildNodes[3].ChildNodes.Count > 0) { if(currentNode.ChildNodes[3].ChildNodes[0].ChildNodes[0].Term.ToString() == "this") { ctor.Sub = true; } foreach (var n in currentNode.ChildNodes[3].ChildNodes[0].ChildNodes[1].ChildNodes) { parser.ConsumeParseTree(root, ctor.SubParameters, n); } } // Build the expressions in the method body of the constructor. parser.ConsumeParseTree(root, ctor, currentNode.ChildNodes[4]); }
public Instantiation(Expression parentExpression, Token token) : base(parentExpression, token) { Parameters = new Expression(null, null); GenericTypes = new List<string>(); IsArray = false; }
// 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 an indexed identifier expression (foo[0]) public static void BuildIndexedIdentifier(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var indexedIdentifier = new IndexedIdentifier(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(indexedIdentifier); indexedIdentifier.Name = currentNode.ChildNodes[0].FindTokenAndGetText(); parser.ConsumeParseTree(root, indexedIdentifier, currentNode.ChildNodes[2]); }
// Build an interface property declaration public static void BuildInterfaceProperty(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var property = new Property(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(property); property.TypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[0].FindTokenAndGetText()); property.Name = currentNode.ChildNodes[0].ChildNodes[1].FindTokenAndGetText(); }
public MethodInvocation(Expression parentExpression, Token token) : base(parentExpression, token) { Prefix = ""; Parameters = new Expression(this, null); GenericTypes = new List<string>(); }
public Expression(Expression parentExpression, Token token) { ChildExpressions = new List<Expression>(); ParentExpression = parentExpression; Token = token; Imports = new List<Import>(); Validated = false; }
// 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; }
void ValidateRecursive(Root root, Expression expression) { if (expression is Class) ClassValidator.Validate(this, root, expression as Class); foreach (var child in expression.ChildExpressions) ValidateRecursive(root, child); }
public Interface(Expression parentExpression, Token token) : base(parentExpression, token) { UnqualifiedName = ""; Accessibility = Accessibility.Public; BaseTypeNames = new List<string>(); GenericTypeNames = new List<string>(); }
public Constructor(Expression parentExpression, Token token) : base(parentExpression, token) { Parameters = new List<Expression>(); SubParameters = new Expression(this, null); Accessibility = Expressions.Accessibility.Public; // Default to no sub constructor. Sub = false; }
void PrepareValidation(Root root, Expression expression, Import import) { if (import != null) { expression.Imports.Add(import); foreach (var c in expression.ChildExpressions) PrepareValidation(root, c, import); } }
// 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(); } }
public DelegateDeclaration(Expression parentExpression, Token token) : base(parentExpression, token) { ReturnTypeName = ""; Name = ""; Accessibility = Expressions.Accessibility.Public; GenericTypeNames = new List<string>(); Parameters = new List<Expression>(); IsShared = false; }
// 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 while loop statement (a for loop with just the conditional) public static void BuildWhileLoop(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var whileLoop = new WhileLoop(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(whileLoop); // Build the conditional expressoin parser.ConsumeParseTree(root, whileLoop.Condition, currentNode.ChildNodes[1]); // Build the statements that make up the body of the while loop parser.ConsumeParseTree(root, whileLoop, currentNode.ChildNodes[2]); }
// Build a case block statement public static void BuildCaseBlock(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var caseBlock = new CaseBlock(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(caseBlock); // Get the expression being tested against parser.ConsumeParseTree(root, caseBlock.Variable, currentNode.ChildNodes[1]); // Build the expressions in the body of the case block foreach (var e in currentNode.ChildNodes[2].ChildNodes) parser.ConsumeParseTree(root, caseBlock, e); }
// Build a switch block statement public static void BuildSwitchBlock(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var s = new SwitchBlock(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(s); // Get the expression being tested parser.ConsumeParseTree(root, s.Variable, currentNode.ChildNodes[1]); // Build each case block if(currentNode.ChildNodes[2].ChildNodes.Count > 0) foreach(var node in currentNode.ChildNodes[2].ChildNodes[0].ChildNodes) BuildCaseBlock(parser, root, s, node); }
public Class(Expression parentExpression, Token token) : base(parentExpression, token) { IsFinal = false; UnqualifiedName = ""; Accessibility = Accessibility.Public; IsModule = false; IsStruct = false; IsPartial = false; IsAbstract = false; BaseTypeNames = new List<string>(); GenericTypeNames = new List<string>(); }
// 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 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); } } }
public MethodDeclaration(Expression parentExpression, Token token) : base(parentExpression, token) { GenericTypeNames = new List<string>(); Parameters = new List<Expression>(); ReturnTypeName = null; Accessibility = Accessibility.Public; if(parentExpression is Class) if ((parentExpression as Class).IsModule) IsShared = true; else IsShared = false; IsOverride = false; IsAbstract = false; IsFinal = false; IsVirtual = false; }
// Build a class variable expression. public static void BuildClassVariable(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { ClassVariable c = new ClassVariable(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(c); // Set default modifiers var p = parentExpression as Class; if (p.IsModule) { c.IsShared = true; } if (p.IsStruct) c.Accessibility = Accessibility.Public; // Interpret declaration modifiers (shared, public, etc). InterpretClassVariableModifiers(root, c, currentNode.ChildNodes[0].ChildNodes[0]); // Treat array type and generic type declarations differently. if (currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].Term.ToString() == "array") { c.TypeName = 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]; c.Name = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText()); c.TypeName = parser.CheckAlias(genericNode.ChildNodes[0].FindTokenAndGetText()) + "<"; for (int n = 0; n < genericNode.ChildNodes[2].ChildNodes.Count; n++) { c.TypeName += parser.CheckAlias(genericNode.ChildNodes[2].ChildNodes[n].FindTokenAndGetText()); if (n < genericNode.ChildNodes[2].ChildNodes.Count - 1) c.TypeName += ","; } c.TypeName += ">"; } else c.TypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].FindTokenAndGetText()); // Get the variable name. c.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText(); }
// Build a delegate declaration expression. public static void BuildDelegate(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var d = new DelegateDeclaration(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(d); // Interpret the declaration modifiers. InterpretModifiers(root, d, currentNode.ChildNodes[0]); // Find the return type of the declaration: check for array and generic types differently. if (currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].Term.ToString() == "array") { d.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].FindTokenAndGetText()) + "[]"; } else if (currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].Term.ToString() == "generic_identifier") { string returnType = currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<"; for(int i = 0; i < currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++) { var genericNode = currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].ChildNodes[2].ChildNodes[i]; returnType += parser.CheckAlias(genericNode.FindTokenAndGetText()); if (i < currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1) returnType += ","; } returnType += ">"; d.ReturnTypeName = returnType; } else d.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[2].ChildNodes[0].FindTokenAndGetText()); d.Name = currentNode.ChildNodes[2].ChildNodes[1].FindTokenAndGetText(); // Build the arguments of the delegate declaration. if (currentNode.ChildNodes[3].ChildNodes.Count > 0) { foreach (var n in currentNode.ChildNodes[3].ChildNodes) { BuildArgument(parser, d, n.ChildNodes[0]); } } }
// 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]); }