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