public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
ParallelTasks = Convert.ToUInt32(parseNode.ChildNodes[1].Token.Value);
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
AstNode sn=AddChild("from", treeNode.ChildNodes[0]);
AstNode en=AddChild("to", treeNode.ChildNodes[2]);
var dtsn=sn as DateTimeLiteralNode;
var dten=en as DateTimeLiteralNode;
if (dtsn!=null)
{
_StartDate=dtsn.Value;
if (dten!=null)
_EndDate=dten.Value;
else
_EndDate=_StartDate+((DurationLiteralNode)en).Value;
} else
{
_EndDate=dten.Value;
_StartDate=_EndDate-((DurationLiteralNode)sn).Value;
}
AsString="period";
}
private void ParseOptions(ParseTreeNode node, FvSolutionData rawData)
{
foreach (ParseTreeNode rootEntryNode in node.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
switch (identifier)
{
case "nCorrectors":
rawData.Options.nCorrectors = rootEntryNode.GetBasicValInt();
break;
case "nNonOrthogonalCorrectors":
rawData.Options.nNonOrthogonalCorrectors = rootEntryNode.GetBasicValInt();
break;
case "pdRefOn":
rawData.Options.pdRefOn = rootEntryNode.GetBasicValBool();
break;
case "pdRefCell":
rawData.Options.pdRefCell = rootEntryNode.GetBasicValInt();
break;
case "pdRefValue":
rawData.Options.pdRefValue = rootEntryNode.GetBasicValInt();
break;
case "tempEqnOn":
rawData.Options.tempEqnOn = rootEntryNode.GetBasicValBool();
break;
}
}
}
public ScriptBlockAst BuildScriptBlockAst(ParseTreeNode parseTreeNode)
{
VerifyTerm(parseTreeNode, this._grammar.script_block);
ParamBlockAst paramBlockAst = null;
StatementBlockAst statementBlockAst = null;
if (parseTreeNode.ChildNodes.Any())
{
// Note that I used First() and Last() to make it deal with the fact that both are optional
if (parseTreeNode.ChildNodes.First().Term == this._grammar.param_block)
{
paramBlockAst = BuildParamBlockAst(parseTreeNode.ChildNodes.First());
}
if (parseTreeNode.ChildNodes.Last().Term == this._grammar.script_block_body)
{
statementBlockAst = BuildScriptBlockBodyAst(parseTreeNode.ChildNodes.Last());
}
}
return new ScriptBlockAst(
new ScriptExtent(parseTreeNode),
paramBlockAst,
statementBlockAst,
false
);
}
private static MethodInfo PrepareStringInstanceMethodCall(string methodName, ParseTreeNode root, CompilerState state, out Expression value, out Expression pattern)
{
root.RequireChildren(2);
MethodInfo method;
if (0 == StringComparer.OrdinalIgnoreCase.Compare(methodName, "StartsWith"))
{
method = ReflectionHelper.StringStartsWith;
}
else if (0 == StringComparer.OrdinalIgnoreCase.Compare(methodName, "EndsWith"))
{
method = ReflectionHelper.StringEndsWith;
}
else if (0 == StringComparer.OrdinalIgnoreCase.Compare(methodName, "IndexOf"))
{
method = ReflectionHelper.StringIndexOf;
}
else
{
throw new Exception("Could not find method " + methodName);
}
var arg1Node = root.RequireChild(null, 1, 0, 0);
value = state.ParentRuntime.Analyze(arg1Node, state);
value.RequireString(arg1Node);
var arg2Node = root.RequireChild(null, 1, 0, 1);
pattern = state.ParentRuntime.Analyze(arg2Node, state);
pattern.RequireString(arg2Node);
return method;
}
private void AddParseNodeRec(int depth, ParseTreeNode node)
{
if (node == null) return;
BnfTerm term = node.Term;
string txt = node.ToString();
if (term == null) {
txt = "NullTerm";
}
else {
txt = term.GetParseNodeCaption(node);
}
//var t = " "*6;
for (int i = 0; i < depth; i++) Console.Write(" ");
if (node.Token != null) {
Console.WriteLine(node.Token.Value + " " + node.Token.Terminal.ToString());
}
else
Console.WriteLine(node.Term.Name);
// Console.WriteLine(node.ToString());
foreach (var child in node.ChildNodes)
AddParseNodeRec(depth + 1, child);
}
public virtual void BuildAst(ParseTreeNode parseNode)
{
var term = parseNode.Term;
if (term.Flags.IsSet(TermFlags.NoAstNode) || parseNode.AstNode != null) return;
//children first
var processChildren = !parseNode.Term.Flags.IsSet(TermFlags.AstDelayChildren) &&
parseNode.ChildNodes.Count > 0;
if (processChildren)
{
var mappedChildNodes = parseNode.GetMappedChildNodes();
for (var i = 0; i < mappedChildNodes.Count; i++)
BuildAst(mappedChildNodes[i]);
}
//create the node
//We know that either NodeCreator or DefaultNodeCreator is set; VerifyAstData create the DefaultNodeCreator
var config = term.AstConfig;
if (config.NodeCreator != null)
{
config.NodeCreator(Context, parseNode);
// We assume that Node creator method creates node and initializes it, so parser does not need to call
// IAstNodeInit.Init() method on node object. But we do call AstNodeCreated custom event on term.
}
else
{
//Invoke the default creator compiled when we verified the data
parseNode.AstNode = config.DefaultNodeCreator();
//Initialize node
var iInit = parseNode.AstNode as IAstNodeInit;
if (iInit != null)
iInit.Init(Context, parseNode);
}
//Invoke the event on term
term.OnAstNodeCreated(parseNode);
} //method
public static new LiteralValue Create(ParseTreeNode node)
{
if (node.Term.Name != XamlMarkupExtensionGrammar.StringTerm)
return null;
return new LiteralValue(node.Token.Text);
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
ParamType type = ParamType.Value;
Object param = null;
if (HasChildNodes(parseNode))
{
throw new NotImplementedQLException("TODO");
///Das sollte hier jetzt viel einfacher sein, weil die definition einer edge maximal so aussehen kann User(Weighted) oder Set<User (Weighted)>
// throw new NotImplementedQLException("TODO");
// if (GraphDBTypeMapper.IsBasicType(parseNode.ChildNodes[0].Token.ValueString))
// {
// param = GraphDBTypeMapper.GetGraphObjectFromTypeName(parseNode.ChildNodes[0].Token.ValueString);
// type = ParamType.Type;
// }
// else
// {
// param = parseNode.ChildNodes[0].Token.Value;
// type = ParamType.Value;
// }
//}
//EdgeTypeParamDefinition = new EdgeTypeParamDefinition(type, param);
}
}
public void DirectInit(ParsingContext context, ParseTreeNode parseNode)
{
var idChain = ((IDNode)parseNode.ChildNodes[2].AstNode).IDChainDefinition;
var tupleDefinition = ((TupleNode)parseNode.ChildNodes[3].AstNode).TupleDefinition;
var AttrName = parseNode.ChildNodes[2].FirstChild.FirstChild.Token.ValueString;
ToBeRemovedList = new AttributeRemoveList(idChain, AttrName, tupleDefinition);
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
var aSelectNode = (SelectNode)parseNode.ChildNodes[0].AstNode;
SelectDefinition = new SelectDefinition(aSelectNode.TypeList, aSelectNode.SelectedElements, aSelectNode.WhereExpressionDefinition,
aSelectNode.GroupByIDs, aSelectNode.Having, aSelectNode.Limit, aSelectNode.Offset, aSelectNode.OrderByDefinition, aSelectNode.ResolutionDepth);
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
BinExprNode = (BinaryExpressionNode)parseNode.ChildNodes[1].AstNode;
}
}
public override void Init(AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
foreach (var node in parseNode.ChildNodes)
{
if (node.AstNode is Function)
{
AddFunction(node.AstNode as Function);
}
else if (node.AstNode is AuxiliaryNode)
{
var ids = (node.AstNode as AuxiliaryNode).ChildNodes.OfType<IdentifierNode>();
foreach (var id in ids)
{
ExternalFunction ef = new ExternalFunction();
ef.SetSpan(id.Span);
ef.Name = id.Symbol;
AddFunction(ef);
}
}
}
AsString = "Refal-5 program";
}
/// <summary>
/// Converts identifiers to compound symbols (strings in double quotes),
/// expands character strings (in single quotes) to arrays of characters
/// </summary>
public static void InitNode(AstContext context, ParseTreeNode parseNode)
{
foreach (var node in parseNode.ChildNodes)
{
if (node.AstNode is LiteralValueNode)
{
if (node.Term.Name == "Char")
{
var literal = node.AstNode as LiteralValueNode;
literal.Value = literal.Value.ToString().ToCharArray();
}
parseNode.AstNode = node.AstNode;
}
else
{
// identifiers in expressions are treated as strings (True is same as "True")
parseNode.AstNode = new LiteralValueNode()
{
Value = node.FindTokenAndGetText(),
Span = node.Span
};
}
}
}
private static ParseTreeNode ParseString(IDictionary<string, string> dict, string nodeName, string input)
{
var node = new ParseTreeNode {Name = nodeName, Text = input};
if (!dict.ContainsKey(nodeName)) return node;
var pattern = dict[nodeName];
var subPattern = @"\(\?<(?<groupName>\w+)>";
var matches = Regex.Matches(pattern, subPattern);
var groupNames = matches.Cast<Match>().Select(match => match.Groups["groupName"].Value).Distinct();
matches = Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace);
var captures = groupNames
.Select(
name => matches
.Cast<Match>()
.Select(
match => match
.Groups[name]
.Captures
.Cast<Capture>()
.Where(cap => cap.Value.Length > 0)
.Select(cap => ParseString(dict, name, cap.Value))
).Flatten())
.Flatten();
node.Children = captures.ToList();
return node;
}
public override void Init(ParsingContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
foreach (var child in treeNode.ChildNodes) {
AddChild("parameter", child);
}
AsString = "Param list";
}
public override void Init(ParsingContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
TargetRef = AddChild("Target", treeNode.ChildNodes[0]);
_targetName = treeNode.ChildNodes[0].FindTokenAndGetText();
Arguments = AddChild("Args", treeNode.ChildNodes[1]);
AsString = "Call " + _targetName;
}
private static List<Coeffs> GetCoeffs(ref ParseTreeNode dictionary, out string patch)
{
var ret = new List<Coeffs>();
patch = null;
foreach (ParseTreeNode x in dictionary.ChildNodes)
{
var id = x.ChildNodes[0].GetEntryIdentifier();
if (id == "patch")
{
patch = x.ChildNodes[0].GetBasicValString();
}
else
{
var item = new Coeffs();
item.dir = x.ChildNodes[0].ChildNodes[0].Token.Text.ToEnum<DirectionType>();
item.value = new Vertice();
var a = x.ChildNodes[0].ChildNodes[2].ChildNodes[1].GetArrayOfDecimal();
item.value.X = a[0];
item.value.Y = a[1];
item.value.Z = a[2];
ret.Add(item);
}
}
return ret;
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
foreach (var node in treeNode.ChildNodes)
{
// linearize AuxiliaryNode children
if (node.AstNode is AuxiliaryNode)
{
var auxNode = node.AstNode as AuxiliaryNode;
foreach (var n in auxNode.ChildNodes)
ChildNodes.Add(n);
foreach (var n in auxNode.ChildParseNodes)
ChildParseNodes.Add(n);
continue;
}
// copy AstNode nodes
if (node.AstNode is AstNode)
{
ChildNodes.Add(node.AstNode as AstNode);
continue;
}
// otherwise, save parse nodes
ChildParseNodes.Add(node);
}
}
public override Iast Parse(ParseTreeNode src)
{
SetStmt ret = new SetStmt();
ret.VarName = Iterate(src, "identifier");
ret.VarValue = Iterate(src, "value");
return ret;
}
// 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 void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
if (myParseTreeNode.ChildNodes[0].HasChildNodes())
{
if (myParseTreeNode.ChildNodes[0].ChildNodes[0].ChildNodes.Count > 1)
{
_IndexType = ((ATypeNode)myParseTreeNode.ChildNodes[0].ChildNodes[0].ChildNodes[0].AstNode).ReferenceAndType.TypeName;
_IndexAttribute = ((IDNode)myParseTreeNode.ChildNodes[0].ChildNodes[0].ChildNodes[2].AstNode).IDChainDefinition;
}
else
{
//_IndexAttribute = myParseTreeNode.ChildNodes[0].ChildNodes[0].Token.ValueString;
_IndexAttribute = new IDChainDefinition();
_IndexAttribute.AddPart(new ChainPartTypeOrAttributeDefinition(myParseTreeNode.ChildNodes[0].ChildNodes[0].Token.ValueString));
}
}
if (myParseTreeNode.ChildNodes.Count > 1 && myParseTreeNode.ChildNodes[1].HasChildNodes())
{
_OrderDirection = myParseTreeNode.ChildNodes[1].FirstChild.Token.ValueString;
}
else
{
_OrderDirection = String.Empty;
}
IndexAttributeDefinition = new IndexAttributeDefinition(_IndexAttribute, _IndexType, _OrderDirection);
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
//get type
if (parseNode.ChildNodes[1] != null && parseNode.ChildNodes[1].AstNode != null)
{
_Type = ((AstNode)(parseNode.ChildNodes[1].AstNode)).AsString;
}
else
{
throw new NotImplementedQLException("");
}
if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3]))
{
_AttributeAssignList = new List<AAttributeAssignOrUpdate>((parseNode.ChildNodes[3].AstNode as AttributeUpdateOrAssignListNode).ListOfUpdate.Select(e => e as AAttributeAssignOrUpdate));
}
if (parseNode.ChildNodes[4] != null && ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition != null)
{
_WhereExpression = ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition;
}
}
}
// 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]);
}
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
TypesSettingScope? settingType;
if (parseNode.HasChildNodes() && (parseNode.ChildNodes.Count >= 2))
{
switch (parseNode.ChildNodes[1].Token.Text.ToUpper())
{
case "TYPE":
settingType = TypesSettingScope.TYPE;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType, myTypeName: (parseNode.ChildNodes[2].ChildNodes[0].AstNode as ATypeNode).ReferenceAndType.TypeName);
break;
case "ATTRIBUTE":
settingType = TypesSettingScope.ATTRIBUTE;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType, myIDChain: (parseNode.ChildNodes[2].ChildNodes[2].AstNode as IDNode).IDChainDefinition);
break;
case "DB":
settingType = TypesSettingScope.DB;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType);
break;
case "SESSION":
settingType = TypesSettingScope.SESSION;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType);
break;
default:
settingType = null;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType);
break;
}
}
}
public override void Init(ParsingContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
Value = treeNode.Token.Value;
AsString = Value == null ? "null" : Value.ToString();
if (Value is string)
AsString = "\"" + AsString + "\"";
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
_DescrAggrDefinition = new DescribeAggregateDefinition(parseNode.ChildNodes[1].Token.ValueString.ToUpper());
}
}
private void InitImpl(AstContext context, ParseTreeNode parseNode, ParseTreeNode parametersNode, ParseTreeNode bodyNode) {
base.Init(context, parseNode);
Parameters = AddChild("Parameters", parametersNode);
Body = AddChild("Body", bodyNode);
AsString = "Lambda[" + Parameters.ChildNodes.Count + "]";
Body.SetIsTail(); //this will be propagated to the last statement
}
public override void Init(ParsingContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
Test = AddChild("Test", treeNode.ChildNodes[0]);
IfTrue = AddChild("IfTrue", treeNode.ChildNodes[1]);
if (treeNode.ChildNodes.Count > 2)
IfFalse = AddChild("IfFalse", treeNode.ChildNodes[2]);
}
public override void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
#region Get the optional type list
if (parseNode.ChildNodes[1].HasChildNodes())
{
_TypesToDump = ((parseNode.ChildNodes[1].ChildNodes[1].AstNode as TypeListNode).Types).Select(tlnode => tlnode.TypeName).ToList();
}
#endregion
_DumpType = (parseNode.ChildNodes[2].AstNode as DumpTypeNode).DumpType;
_DumpFormat = (parseNode.ChildNodes[3].AstNode as DumpFormatNode).DumpFormat;
_DumpableGrammar = context.Compiler.Language.Grammar as IDumpable;
if (_DumpableGrammar == null)
{
throw new GraphDBException(new Error_NotADumpableGrammar(context.Compiler.Language.Grammar.GetType().ToString()));
}
if (parseNode.ChildNodes[4].HasChildNodes())
{
_DumpDestination = parseNode.ChildNodes[4].ChildNodes[1].Token.ValueString;
}
}
/// <summary>
/// The create indexer expression ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateIndexerExpressionAst(ParsingContext parsingcontext, ParseTreeNode node)
{
var value = Ast <IndexerExpression>(node);
// [0] [1]
// postfix_expression + array_indexer
value.Target = (Expression)node.ChildNodes[0].AstNode;
value.Index = (Expression)node.ChildNodes[1].AstNode;
}
/// <summary>
/// The create variable group raw ast.
/// </summary>
/// <param name="parsingContext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateVariableGroupRawAst(ParsingContext parsingContext, ParseTreeNode node)
{
var var = Ast <Variable>(node);
//// [0] [1]
// declaration_specifiers + variable_declarator_list.Q() + ";";
var declarationSpecifiers = (Tuple <Qualifier, TypeBase>)node.ChildNodes[0].AstNode;
var.Qualifiers = declarationSpecifiers.Item1;
var.Type = declarationSpecifiers.Item2;
var declarators = GetOptional <List <Variable> >(node.ChildNodes[1]);
if (declarators != null)
{
var.SubVariables = declarators;
// Update array type for sub variables
foreach (var subVariable in declarators)
{
if (subVariable.Type is ArrayType)
{
((ArrayType)subVariable.Type).Type = var.Type;
}
else
{
subVariable.Type = var.Type;
}
}
}
// If this is a variable group, check if we can transform it to a single variable declaration.
if (var.IsGroup)
{
// If the variable is a single variable declaration, replace the group
if (var.SubVariables.Count == 1)
{
var subVariable = var.SubVariables[0];
subVariable.MergeFrom(var);
node.AstNode = subVariable;
}
}
else
{
// If variable declarators is 0, check if this is a named struct
var.Type.Qualifiers = var.Qualifiers;
if (var.Type is StructType)
{
node.AstNode = var.Type;
}
else if (var.Type is InterfaceType)
{
node.AstNode = var.Type;
}
else if (var.Type is ClassType)
{
node.AstNode = var.Type;
}
else
{
parsingContext.AddParserError("Expecting identifier for variable declaration [{0}]", var.Type);
}
if (var.Type.Name == null)
{
parsingContext.AddParserError("Cannot declare anonymous type at the top level");
}
}
}
private int FindUniforms(ParseTreeNode node, int level)
{
return(0);
}
public static void generate_error_report(ParseTreeNode root)
{
}
private Expression ParseExpression <T>(ParseTreeNode node, ParameterExpression parameterExpression)
{
switch (node.Term.Name)
{
case "logical-operation":
var leftLogicalOperandNode = node.ChildNodes[0];
var logicalOperatorNode = node.ChildNodes[1];
var rightLogicalOprandNode = node.ChildNodes[2];
switch (logicalOperatorNode.ChildNodes[0].Term.Name)
{
case "AND":
return(Expression.AndAlso(ParseExpression <T>(leftLogicalOperandNode, parameterExpression), ParseExpression <T>(rightLogicalOprandNode, parameterExpression)));
case "OR":
return(Expression.OrElse(ParseExpression <T>(leftLogicalOperandNode, parameterExpression), ParseExpression <T>(rightLogicalOprandNode, parameterExpression)));
}
break;
case "relational-operation":
var leftRelationalOperandNode = node.ChildNodes[0];
var relationalOperatorNode = node.ChildNodes[1];
var rightRelationalOperandNode = node.ChildNodes[2];
var leftExpression = ParseExpression <T>(leftRelationalOperandNode, parameterExpression);
var rightExpression = ParseExpression <T>(rightRelationalOperandNode, parameterExpression);
if (leftExpression.NodeType == ExpressionType.Constant || rightExpression.NodeType == ExpressionType.Constant)
{
FixExpressionType(ref leftExpression, ref rightExpression);
}
switch (relationalOperatorNode.ChildNodes[0].Term.Name)
{
case "EQ":
return(Expression.Equal(leftExpression, rightExpression));
case "NE":
return(Expression.NotEqual(leftExpression, rightExpression));
case "GE":
return(Expression.GreaterThanOrEqual(leftExpression, rightExpression));
case "GT":
return(Expression.GreaterThan(leftExpression, rightExpression));
case "LE":
return(Expression.LessThanOrEqual(leftExpression, rightExpression));
case "LT":
return(Expression.LessThan(leftExpression, rightExpression));
}
break;
case "not-operation":
return(Expression.Not(ParseExpression <T>(node.ChildNodes[1], parameterExpression)));
case "string-operation":
var leftStringFunctionOperandNode = node.ChildNodes[0];
var stringFunctionNode = node.ChildNodes[1];
var rightStringFunctionOperandNode = node.ChildNodes[2];
var leftStringFunctionExpression = ParseExpression <T>(leftStringFunctionOperandNode, parameterExpression);
var rightStringFunctionExpression = ParseExpression <T>(rightStringFunctionOperandNode, parameterExpression);
switch (stringFunctionNode.ChildNodes[0].Term.Name)
{
case "SW":
return(Expression.Call(leftStringFunctionExpression, typeof(string).GetMethod("StartsWith", new[] { typeof(string) }), rightStringFunctionExpression));
case "EW":
return(Expression.Call(leftStringFunctionExpression, typeof(string).GetMethod("EndsWith", new[] { typeof(string) }), rightStringFunctionExpression));
case "CT":
return(Expression.Call(leftStringFunctionExpression, typeof(string).GetMethod("Contains", new[] { typeof(string) }), rightStringFunctionExpression));
}
break;
case "property":
var inferredProperty = ParsingUtils.InferProperty <T>(node.ChildNodes[0].Token.ValueString);
if (inferredProperty == null)
{
throw new ParsingException("Expression parsed failed.", new[] { $"The property that has the name similar to {node.ChildNodes[0].Token.ValueString} does not exist." });
}
var propertyName = ParsingUtils.InferProperty <T>(node.ChildNodes[0].Token.ValueString).Name;
return(Expression.Property(parameterExpression, node.ChildNodes[0].Token.ValueString));
case "string":
return(Expression.Constant(node.Token.Value));
case "number":
var expr = Expression.Constant(node.Token.Value);
return(expr);
}
return(null);
}
public Statement Parse(ParseTreeNode node, ParserContext context)
{
return(new HelperStatement(new ArgumentsExpression(BuildArguments(node)), node.Term.Name));
}
public Resultado ejecutar(ParseTreeNode raiz)
{
Resultado resultado = null;
ParseTreeNode nodoDeclaracion = raiz.ChildNodes[0];
if (!nodoDeclaracion.ChildNodes[1].ChildNodes[0].Token.Text.ToLower().Equals("integer"))
{
//reportar error
return(null);
}
//cambiar ambito
TablaSimbolo aux = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = aux;
ParseTreeNode SENTSPROC = new ParseTreeNode(new NonTerminal("SENTSPROC"), raiz.Span);
SENTSPROC.ChildNodes.Add(nodoDeclaracion);
interprete.ejecutar(SENTSPROC);
opL = new Logica();
Resultado condicion = opL.operar(raiz.ChildNodes[1]);
String operacion = raiz.ChildNodes[2].ChildNodes[0].Token.Text;
ParseTreeNode nodoSentencias = raiz.ChildNodes[3];
if (condicion.valor != null && (condicion.tipo.Equals("integer") || (condicion.tipo.Equals("bool"))))
{
while (condicion.valor.ToString().Equals("1"))
{
TablaSimbolo aux2 = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = aux2;
resultado = interprete.ejecutar(nodoSentencias);
Interprete.tabla = aux2;
if (condicion.valor.ToString().Equals("1"))
{
if (resultado != null)
{
if (resultado.detener)
{
resultado = null;
break;
}
}
Simbolo simbolo = Interprete.tabla.getSimbolo2(nodoDeclaracion.ChildNodes[0].ChildNodes[0].Token.Text.Replace("@", "").ToLower());
if (operacion.Equals("++"))
{
simbolo.valor = Convert.ToInt64(simbolo.valor) + 1;
}
else
{
simbolo.valor = Convert.ToInt64(simbolo.valor) - 1;
}
opL = new Logica();
condicion = opL.operar(raiz.ChildNodes[1]);
}
}
}
else
{
agregarError("Semantico", "La condicion de una sentencia de control solo puede ser tipo Bool o Integer(0|1)", raiz.Span.Location.Line, raiz.Span.Location.Column);
return(null);
}
Interprete.tabla = aux;
return(resultado);
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
InnerExpression = AddChild("Inner", treeNode.ChildNodes[0]);
}
/// <summary>
/// The create unary expression ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateUnaryExpressionAst(ParsingContext parsingcontext, ParseTreeNode node)
{
var value = Ast <UnaryExpression>(node);
//// unary_expression_raw.Rule =
//// [0] [1] [0] [1]
//// incr_or_decr + unary_expression | unary_operator + cast_expression;
value.Operator = UnaryOperatorHelper.FromString(node.ChildNodes[0].Token.Text);
value.Expression = (Expression)node.ChildNodes[1].AstNode;
}
/// <summary>
/// The create array initializer expression ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateArrayInitializerExpressionAst(ParsingContext context, ParseTreeNode node)
{
// [0] [1] [3]
// "{" + initializer_list + "}";
var value = Ast <ArrayInitializerExpression>(node);
value.Items = (List <Expression>)node.ChildNodes[1].AstNode;
}
/// <summary>
/// The create type name from token ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateTypeNameFromTokenAst(ParsingContext parsingcontext, ParseTreeNode node)
{
CreateTypeFromTokenAst <TypeName>(parsingcontext, node);
}
protected static void CreateTypeFromTokenAst <T>(ParsingContext parsingcontext, ParseTreeNode node) where T : TypeBase, new()
{
if (node.ChildNodes.Count == 1 && node.ChildNodes[0].AstNode is T)
{
node.AstNode = node.ChildNodes[0].AstNode;
}
else
{
var value = Ast <T>(node);
var nextNode = node;
while (nextNode.Token == null)
{
nextNode = nextNode.ChildNodes[0];
}
value.Name = new Identifier(nextNode.Token.Text)
{
Span = SpanConverter.Convert(node.Span)
};
}
}
/// <summary>
/// The create rank specifier ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateRankSpecifierAst(ParsingContext parsingcontext, ParseTreeNode node)
{
// [0] [1] [2]
// "[" + expression + "]";
node.AstNode = node.ChildNodes[1].AstNode;
}
/// <summary>
/// The create type name ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateTypeNameAst(ParsingContext parsingcontext, ParseTreeNode node)
{
var value = Ast <TypeName>(node);
value.Name = (Identifier)node.ChildNodes[0].AstNode;
}
/// <summary>
/// The create postfix unary expression ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreatePostfixUnaryExpressionAst(ParsingContext context, ParseTreeNode node)
{
var value = Ast <UnaryExpression>(node);
//// post_incr_decr_expression.Rule =
//// [0] [1]
//// postfix_expression + incr_or_decr;
value.Expression = (Expression)node.ChildNodes[0].AstNode;
var operatorText = node.ChildNodes[1].Token.Text;
value.Operator = (operatorText == "++") ? UnaryOperator.PostIncrement : UnaryOperator.PostDecrement;
}
protected static void CreateQualifiersAst(ParsingContext context, ParseTreeNode node)
{
node.AstNode = CollectQualifiers(node.ChildNodes[0]);
}
/// <summary>
/// The create method invoke expression ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateMethodInvokeExpressionAst(ParsingContext parsingcontext, ParseTreeNode node)
{
var value = Ast <MethodInvocationExpression>(node);
//// method_invoke_expression.Rule
// [0] [1] [2]
// = identifier + "(" + argument_expression_list.Q() + ")";
value.Target = GetExpression(node.ChildNodes[0]);
var arguments = GetOptional <List <Expression> >(node.ChildNodes[2]);
if (arguments != null)
{
value.Arguments = arguments;
}
}
/// <summary>
/// The create parenthesized expression ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateParenthesizedExpressionAst(ParsingContext context, ParseTreeNode node)
{
var value = Ast <ParenthesizedExpression>(node);
// [0] [1] [2]
// "(" + argument_expression_list + ")"
value.Content = (Expression)node.ChildNodes[1].AstNode;
}
/// <summary>
/// The create member reference expression ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateMemberReferenceExpressionAst(ParsingContext parsingcontext, ParseTreeNode node)
{
var value = Ast <MemberReferenceExpression>(node);
// [0] [1] [2]
// postfix_expression + "." + identifier
value.Target = (Expression)node.ChildNodes[0].AstNode;
value.Member = (Identifier)node.ChildNodes[2].AstNode;
}
/// <summary>
/// The create method declaration ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateMethodDeclarationAst(ParsingContext context, ParseTreeNode node)
{
//// method_declaration_raw + ";";
node.AstNode = node.ChildNodes[0].AstNode;
}
private int FindStructsAndAttributes(ParseTreeNode parent, int level)
{
if (parent == null)
{
return(0);
}
if (parent.Term == mLanguage.SingleDeclaration)
{
var node = parent.ChildNodes[0];
if (node.Term == mLanguage.FullySpecifiedType)
{
var specifier = node.ChildNodes.Find(p => p.Term == mLanguage.StructSpecifier);
var typeQualifier = node.ChildNodes.Find(p => p.Term == mLanguage.TypeQualifier);
if (specifier != null)
{
var temp = new StructInfo();
temp.Layout = new LayoutInformation();
ExtractLayout(temp.Layout, typeQualifier);
return(ExtractStructMembers(temp, specifier));
}
var inDirection = typeQualifier.ChildNodes.Find(p => p.Term == mLanguage.InTerm);
var outDirection = typeQualifier.ChildNodes.Find(p => p.Term == mLanguage.OutTerm);
if (inDirection == null && outDirection == null)
{
return(0);
}
var attribute = new InputAttribute();
attribute.Direction = (inDirection != null) ? "in" : ((outDirection != null) ? "out" : null);
attribute.Layout = new LayoutInformation();
ExtractLayout(attribute.Layout, typeQualifier);
var secondNode = node.ChildNodes [1];
if (!mLanguage.TypesTerms.Contains(secondNode.Token.KeyTerm))
{
return(0);
}
attribute.TypeString = secondNode.Token.ValueString;
attribute.ClosestType = mTypeLookup.FindClosestType(attribute.TypeString);
var nameSibiling = parent.ChildNodes [1];
attribute.Name = nameSibiling.Token.ValueString;
// IGNORE
if (!mAttributes.ContainsKey(attribute.Name))
{
mAttributes.Add(attribute.Name, attribute);
return(1);
}
else
{
return(0);
}
}
else
{
return(0);
}
}
else
{
int total = 0;
foreach (ParseTreeNode child in parent.ChildNodes)
{
total += FindStructsAndAttributes(child, level + 1);
}
return(total);
}
}
/// <summary>
/// The create literal expression ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateLiteralExpressionAst(ParsingContext parsingcontext, ParseTreeNode node)
{
var value = Ast <LiteralExpression>(node);
value.Literal = (Literal)node.ChildNodes[0].AstNode;
}
/// <summary>
/// The create binary expression ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateBinaryExpressionAst(ParsingContext parsingcontext, ParseTreeNode node)
{
// [0] [1] [2]
// expression + operator + expression
var value = Ast <BinaryExpression>(node);
value.Left = (Expression)node.ChildNodes[0].AstNode;
value.Operator = BinaryOperatorHelper.FromString(node.ChildNodes[1].Token.Text);
value.Right = (Expression)node.ChildNodes[2].AstNode;
}
/// <summary>
/// The create identifier indexable ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateIdentifierIndexableAst(ParsingContext parsingcontext, ParseTreeNode node)
{
// identifier + rankSpecifier.Star();
var value = Ast <Identifier>(node);
var identifier = (Identifier)node.ChildNodes[0].AstNode;
value.Text = identifier.Text;
value.Indices = new List <Expression>();
FillListFromNodes(node.ChildNodes[1].ChildNodes, value.Indices);
}
/// <summary>
/// The create declaration statement ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateDeclarationStatementAst(ParsingContext context, ParseTreeNode node)
{
var declarationStatement = Ast <DeclarationStatement>(node);
declarationStatement.Content = (Node)node.ChildNodes[0].AstNode;
}
/// <summary>
/// The create identifier list ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateIdentifierListAst(ParsingContext parsingcontext, ParseTreeNode node)
{
var identifiers = Ast <List <Identifier> >(node);
FillListFromNodes(node.ChildNodes, identifiers);
}
/// <summary>
/// The create assignment operator.
/// </summary>
/// <param name="parsingContext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateAssignmentOperator(ParsingContext parsingContext, ParseTreeNode node)
{
node.AstNode = AssignmentOperatorHelper.FromString(node.ChildNodes[0].Token.Text);
}
protected static void CreateEmptyStatementAst(ParsingContext context, ParseTreeNode node)
{
Ast <EmptyStatement>(node);
}
private static void CreateVariableReferenceExpressionAst(ParsingContext context, ParseTreeNode node)
{
//// variable_identifier.Rule = identifier;
var value = Ast <VariableReferenceExpression>(node);
value.Name = (Identifier)node.ChildNodes[0].AstNode;
}
/// <summary>
/// The create conditional expression ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateConditionalExpressionAst(ParsingContext parsingcontext, ParseTreeNode node)
{
var value = Ast <ConditionalExpression>(node);
// [0] [1] [2] [3]
// logical_or_expression + "?" + expression + ":" + conditional_expression;
value.Condition = (Expression)node.ChildNodes[0].AstNode;
value.Left = (Expression)node.ChildNodes[2].AstNode;
value.Right = (Expression)node.ChildNodes[3].AstNode;
}
