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