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";
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
Text = treeNode.Token.Text;
AsString = "StringValue";
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
foreach (var child in treeNode.ChildNodes)
AddChild(NodeUseType.Parameter, "param", child);
AsString = "param_list[" + ChildNodes.Count + "]";
}
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);
}
}
/// <summary>Initializes the current AST node with the specified <paramref name="context" /> and <paramref name="treeNode" />.</summary>
/// <param name="context">The AST context.</param>
/// <param name="treeNode">The parse tree node associated with the current AST node.</param>
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
AsString=treeNode.ChildNodes[0].Token.Text;
_GeometryType=(GeometryType)Enum.Parse(typeof(GeometryType), AsString, true);
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var term = TerminalFactory.CreateCSharpIdentifier("text");
var tok = new Token(term, Location, "text", System.String.Join("_", treeNode.ChildNodes.Select(cn => cn.Term.Name)));
treeNode.Token = tok;
}
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";
}
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(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
foreach (var child in treeNode.ChildNodes) {
AddChild(NodeUseType.Parameter, "expr", child);
}
AsString = "Expression list";
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var mapped = parseNode.GetMappedChildNodes();
if (mapped.Count > 2)
{
Ident = (IdentifierNode)AddChild("Ident", mapped[1]);
Type = Runtime.StringToTypeInfo(mapped[2].FindTokenAndGetText());
IsParams = true;
IsTypeConstrained = true;
}
else if (mapped.Count > 1)
{
//params or typeConstrained
if (mapped[0].Term.Name == "name")
{
Ident = (IdentifierNode)AddChild("Ident", mapped[0]);
Type = Runtime.StringToTypeInfo(mapped[1].FindTokenAndGetText());
IsTypeConstrained = true;
}
else
{
Ident = (IdentifierNode)AddChild("Ident", mapped[1]);
IsParams = true;
}
}
else
{
Ident = (IdentifierNode)AddChild("Ident", mapped[0]);
}
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
string sVal = treeNode.FindTokenAndGetText();
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
var functionOrProperty = AddChild("FunctionOrId", nodes[0]);
if (functionOrProperty is SelectFunctionNode)
{
_TheFunction = (SelectFunctionNode)functionOrProperty;
}
else if (functionOrProperty is SelectPropertyNode)
{
_PropNode = (SelectPropertyNode)functionOrProperty;
}
else
{
throw new Exception("Unmanaged type in selectmemberaccessnode");
}
if (nodes.Count > 1)
{
var child = AddChild("Queue", nodes[1]);
string sval = nodes[1].FindTokenAndGetText();
if (child is LeftObjectNode)
{
_queue = (LeftObjectNode)child;
}
}
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
Value = treeNode.Token.Value;
AsString = Value == null ? "null" : Value.ToString();
if (Value is string)
AsString = "\"" + AsString + "\"";
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
Target = AddChild(AstNodeType.ValueWrite, "To", nodes[0]);
AssignmentOp = nodes[1].FindTokenAndGetText();
if (string.IsNullOrEmpty(AssignmentOp))
{
AssignmentOp = "=";
}
BinaryExpressionType = ExpressionType.Assign;
Expression = AddChild(AstNodeType.ValueRead, "Expression", nodes[nodes.Count - 1]);
AsString = AssignmentOp + " (assignment)";
IsAugmented = AssignmentOp.Length > 1;
if (IsAugmented)
{
var ctxt = (AstContext)context;
ExpressionType = ctxt.OperationHandler.GetOperatorExpressionType(AssignmentOp);
BinaryExpressionType = ctxt.OperationHandler.GetBinaryOperatorForAugmented(ExpressionType);
Target.NodeType = AstNodeType.ValueReadWrite;
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var node = treeNode.GetMappedChildNodes()[0];
this.Label = node.Token.ValueString;
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var valueStr = parseNode.FindToken().Text;
Value = valueStr.Equals("true");
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
target = GetChildString(parseNode);
AsString = target;
}
public override void Init(AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
foreach (var node in parseNode.ChildNodes)
{
if (node.AstNode is Expression)
{
Expression = (node.AstNode as Expression);
}
else if (node.AstNode is AuxiliaryNode)
{
var nodes = (node.AstNode as AuxiliaryNode).ChildNodes;
Pattern = nodes.OfType<Pattern>().FirstOrDefault();
Block = nodes.OfType<Block>().FirstOrDefault();
MoreConditions = nodes.OfType<Conditions>().FirstOrDefault();
ResultExpression = nodes.OfType<Expression>().FirstOrDefault();
}
foreach (var astNode in new AstNode[] { Expression, Pattern, Block, MoreConditions, ResultExpression })
{
if (astNode != null)
astNode.Parent = this;
}
}
AsString = Block != null ? "with-clause" : "where-clause";
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
_target = AddChild("Target", nodes.First());
_index = AddChild("Index", nodes.Last());
AsString = "[" + _index + "]";
}
/// <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
};
}
}
}
public override void Init(Irony.Ast.AstContext context, Irony.Parsing.ParseTreeNode treeNode)
{
hijos = new List <Arbol>();//inicializamos la lista
base.Init(context, treeNode);
switch ((String)treeNode.Term.Name)
{ // 0 1 2
case "E": // E + E | E - E | E * E | num
if (treeNode.ChildNodes.Count > 1)
{
Name = treeNode.ChildNodes[1].FindTokenAndGetText(); //SIGNO
hijos.Add((Arbol)treeNode.ChildNodes[0].AstNode); // PRIMER VALOR
hijos.Add((Arbol)treeNode.ChildNodes[2].AstNode); // SEGUNDO VALOR
}
else
{
Name = treeNode.ChildNodes[0].FindTokenAndGetText(); //OBTENEMOS EL NUMERO
}
break;
case "number":
Name = treeNode.Token.Text;
break;
default:
break;
}
}
public override void Init(AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
foreach (var node in parseNode.ChildNodes)
{
if (node.AstNode is Pattern)
{
Pattern = node.AstNode as Pattern;
}
else if (node.AstNode is AuxiliaryNode)
{
var nodes = (node.AstNode as AuxiliaryNode).ChildNodes;
Conditions = nodes.OfType<Conditions>().FirstOrDefault();
Expression = nodes.OfType<Expression>().FirstOrDefault();
}
}
foreach (var astNode in new AstNode[] { Pattern, Conditions, Expression })
{
if (astNode != null)
{
astNode.Parent = this;
}
}
AsString = "match";
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
Test = AddChild("Test", nodes[0]);
IfTrue = AddChild("IfTrue", nodes[1]);
if (nodes.Count > 2)
IfFalse = AddChild("IfFalse", nodes[2]);
}
public virtual void BuildAst(LanguageData language, ParseTree parseTree)
{
if (!LanguageFlags.IsSet(LanguageFlags.CreateAst))
return;
var astContext = new AstContext(language);
var astBuilder = new AstBuilder(astContext);
astBuilder.BuildAst(parseTree);
}
public override void Init(AstContext Context, ParseTreeNode ParseNode)
{
IsDefault = (ParseNode.ChildNodes[0].FindTokenAndGetText() == "default");
if (!IsDefault)
{
Value = ParseNode.ChildNodes[1];
}
}
public override void Init(AstContext context, ParseTreeNode parseNode)
{
Debug.Assert("for" == parseNode.ChildNodes[0].FindTokenAndGetText());
InitialSentence = parseNode.ChildNodes[1];
ConditionExpresion = parseNode.ChildNodes[2];
PostSentence = parseNode.ChildNodes[3];
LoopSentence = parseNode.ChildNodes[4];
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
_AttributeName=(AttributeNameNode)AddChild("", treeNode.ChildNodes[0]);
_Negated=treeNode.ChildNodes[1].Term.Name.Contains("NOT");
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
_eventEmitter = AddChild(string.Empty, treeNode.ChildNodes[0]) as AstNode;
_eventName = (treeNode.ChildNodes[1].AstNode as AstNode).AsString;
_listener = AddChild(string.Empty, treeNode.ChildNodes[2]) as AstNode;
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("EN");
base.Init(context, treeNode);
operador = dic[treeNode.ChildNodes[1].FindTokenAndGetText()];
arg1 = ((AstNode) treeNode.ChildNodes[0].AstNode).Evaluate(null);
arg2 = ((AstNode)treeNode.ChildNodes[2].AstNode).Evaluate(null);
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
OpSymbol = nodes[0].FindTokenAndGetText();
Argument = AddChild("Arg", nodes[1]);
base.AsString = OpSymbol + "(unary op)";
var interpContext = (InterpreterAstContext)context;
base.ExpressionType = interpContext.OperatorHandler.GetUnaryOperatorExpressionType(OpSymbol);
}
public override void Init(AstContext context, ParseTreeNode parseNode)
{
Debug.Assert(parseNode.ChildNodes[0].FindTokenAndGetText() == "function");
FunctionName = Php54Utils.NormalizeFunctionName(parseNode.ChildNodes[1].FindTokenAndGetText());
ParametersDeclaration = parseNode.ChildNodes[2];
CodeStatements = (parseNode.ChildNodes[3].AstNode as Node);
//throw(new NotImplementedException());
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
target = AddChild("Target", nodes[0]);
AsString = "import Library";
}
/// <summary>Initializes the current AST node with the specified <paramref name="context" /> and <paramref name="treeNode" />.</summary>
/// <param name="context">The AST context.</param>
/// <param name="treeNode">The parse tree node associated with the current AST node.</param>
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
if (treeNode.ChildNodes.Count>1)
_Point=AddChild("point", treeNode.ChildNodes[1]) as PointNode;
AsString="POINT";
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
target = AddChild("Target", nodes[0]);
index = AddChild("Index", nodes[1]);
AsString = target + "[" + index + "]";
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
TargetRef = AddChild("Target", nodes[0]);
TargetRef.UseType = NodeUseType.CallTarget;
_targetName = nodes[0].FindTokenAndGetText();
Arguments = AddChild("Args", nodes[1]);
AsString = "Call " + _targetName;
}
public void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
var ctx = context as AstContext;
Span = parseNode.Span;
FileName = ctx.FileName;
parseNode.AstNode = this;
Init(ctx, parseNode);
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
if (nodes.Count > 0)
{
propName = nodes[0].FindTokenAndGetText();
}
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
_left = AddChild("Target", nodes[0]);
var right = nodes[nodes.Count - 1];
_memberName = right.FindTokenAndGetText();
ErrorAnchor = right.Span.Location;
AsString = "." + _memberName;
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
string n=treeNode.Term.ToString();
Name=string.Concat(n.Substring(0, 1).ToUpperInvariant(), n.Substring(1).ToLowerInvariant());
AsString=Name;
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
target = AddChild("target", nodes[0]);
alternative = AddChild("target", nodes[1]);
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
Condition = AddChild("Condition", nodes[1]);
Body = AddChild("Body", nodes[0]);
AsString = "Do While Loop";
}
public override void Init(Irony.Ast.AstContext context, Irony.Parsing.ParseTreeNode treeNode)
{
base.Init(context, treeNode);
Identifier = treeNode.ChildNodes[0].AstNode as IdentifierNode;
if (treeNode.ChildNodes.Count > 1)
{
Source = (SourceNode)treeNode.ChildNodes[1].AstNode;
}
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
TargetRef = AddChild("Target", nodes[0]);
targetName = TargetRef.AsString;
Arguments = AddChild("Args", nodes[1]);
AsString = "Call " + targetName;
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
foreach (var child in parseNode.ChildNodes)
{
AddChild(AstNodeType.Parameter, "expr", child);
}
AsString = "Expression List";
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
Target = AddChild("Target", nodes[0]);
memberName = nodes[1].FindTokenAndGetText();
ErrorAnchor = nodes[1].Span.Location;
AsString = "." + memberName;
}
private void InitImpl(Irony.Ast.AstContext context, ParseTreeNode node, ParseTreeNode parameters, ParseTreeNode body)
{
base.Init(context, node);
lock (lockObject)
{
Parameters = AddChild("Parameters", parameters) as ParamListNode;
}
Body = AddChild("Body", body);
AsString = "Lambda[" + Parameters.ChildNodes.Count + "]";
}
private void ParseSegments(Irony.Ast.AstContext context)
{
var exprParser = new Parser(context.Language, templateSettings.ExpressionRoot);
int currentPos = 0;
int exprPosInTokenText = 0;
while (true)
{
var startTagPos = template.IndexOf(templateSettings.StartTag, currentPos);
if (startTagPos < 0)
{
startTagPos = template.Length;
}
var text = template.Substring(currentPos, startTagPos - currentPos);
if (!string.IsNullOrEmpty(text))
{
segments.Add(new TemplateSegment(text, null, 0));
}
if (startTagPos >= template.Length)
{
break;
}
currentPos = startTagPos + templateSettings.StartTag.Length;
var endTagPos = template.IndexOf(templateSettings.EndTag, currentPos);
if (endTagPos < 0)
{
context.AddMessage(Irony.ErrorLevel.Error, Location.SourceLocation, "No endtag in embedded expression found");
return;
}
var exprText = template.Substring(currentPos, endTagPos - currentPos);
if (!string.IsNullOrEmpty(exprText))
{
var exprTree = exprParser.Parse(exprText);
if (exprTree.HasErrors())
{
var baseLocation = Location.SourceLocation + tokenText.IndexOf(exprText);
CopyMessages(exprTree.ParserMessages, context.Messages, baseLocation, "");
return;
}
exprPosInTokenText = tokenText.IndexOf(templateSettings.StartTag, exprPosInTokenText) + templateSettings.StartTag.Length;
var segmNode = exprTree.Root.AstNode as AstNode;
segments.Add(new TemplateSegment(null, segmNode, exprPosInTokenText));
exprPosInTokenText += exprText.Length + templateSettings.EndTag.Length;
}
currentPos = endTagPos + templateSettings.EndTag.Length;
}
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
IterVarBlock = AddChild("IterVar", nodes[0]);
InExpr = AddChild("InExpr", nodes[1]);
Block = AddChild("ForeachBlock", nodes[2]);
AsString = "Forech Loop";
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
target = AddChild("Target", nodes[1]) as IdentifierNode;
parameters = AddChild("Parameters", nodes[2]) as ParamListNode;
isExtension = string.Equals(nodes[3].FindTokenAndGetText(), "extension", StringComparison.CurrentCultureIgnoreCase);
AsString = "<extern " + (isExtension ? "Extension " : "") + "Function " + target.AsString + "[" + parameters.ChildNodes.Count + "]>";
}
public virtual void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
var acon = context as AstContext;
Term = parseNode.Term;
Span = parseNode.Span;
Location = new SourceInfo(Span.Location, acon.FileName);
ErrorAnchor = Location;
parseNode.AstNode = this;
AsString = (Term == null ? GetType().Name : Term.Name);
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
OpSymbol = nodes[0].FindTokenAndGetText();
Argument = AddChild("Arg", nodes[1]);
AsString = OpSymbol + "(unary op)";
var interpContext = (AstContext)context;
ExpressionType = interpContext.OperationHandler.GetUnaryOperatorExpressionType(OpSymbol);
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
if (nodes.Any())
{
Expression = AddChild("Expression", nodes[0]);
}
AsString = "return" + (nodes.Any() ? " Expression" : "");
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
var hasVar = nodes[0].ChildNodes[0].ChildNodes.Count > 0;
if (hasVar)
{
exceptionVar = (IdentifierNode)AddChild("exceptionVar", nodes[0].ChildNodes[0].ChildNodes[0]);
}
block = AddChild("Block", nodes[1]);
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
Condition = AddChild("Condition", nodes[0]);
IfBlock = AddChild("IfBlock", nodes[1]);
if (nodes.Count > 2)
{
ElseBlock = AddChild("ElseBlock", nodes[2]);
}
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
foreach (var child in parseNode.GetMappedChildNodes())
{
if (child != null)
{
AddChild("ArrayItem", child);
}
}
AsString = "Array[" + ChildNodes.Count + "]";
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
from = AddChild("from", nodes[0]);
isInclusive = nodes[1].FindTokenAndGetText().Length == 3;
to = AddChild("to", nodes[2]);
step = nodes[3].ChildNodes.Count > 0 ? AddChild("step", nodes[3].ChildNodes[0]) : null;
AsString = "Range " + from + " " + to + (isInclusive? " (inclusive)" : "") + (step != null ? " " + step : "");
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
name = nodes[0].FindTokenAndGetText();
if (name.StartsWith("\""))
{
name = name.Remove(name.Length - 1, 1).Remove(0, 1);
}
value = AddChild("Value", nodes[2]);
AsString = "[" + name + "] = " + value.AsString;
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
InitBlock = AddChild("Init", nodes[0]);
var t = nodes[1].GetMappedChildNodes();
Condition = t.Count > 0 ? AddChild("Condition", t[0]) : null;
IterBlock = AddChild("Iter", nodes[2]);
Block = AddChild("ForBlock", nodes[3]);
AsString = "For Loop";
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
NameNode = null;
var nodes = parseNode.GetMappedChildNodes();
if (nodes.Count > 2)
{
InitImpl(context, parseNode, nodes[1], nodes[2]);
}
else
{
InitImpl(context, parseNode, nodes[0], nodes[1]);
}
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
if (!parseNode.FindTokenAndGetText().StartsWith("$"))
{
parseNode.AstNode = new LiteralValueNode();
((LiteralValueNode)parseNode.AstNode).Init(context, parseNode);
return;
}
base.Init(context, parseNode);
template = parseNode.Token.ValueString;
tokenText = parseNode.Token.Text;
templateSettings = parseNode.Term.AstConfig.Data as StringTemplateSettings;
ParseSegments(context);
AsString = "\"" + template + "\" (templated string)";
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
FindOpAndDetectPostfix(nodes);
int argIndex = IsPostfix ? 0 : 1;
Argument = AddChild(AstNodeType.ValueReadWrite, "Arg", nodes[argIndex]);
BinaryOpSymbol = Opsymbol[0].ToString();
var interpContext = (AstContext)context;
BinaryOp = interpContext.OperationHandler.GetOperatorExpressionType(BinaryOpSymbol);
AsString = Opsymbol + (IsPostfix ? "(postfix)" : "(prefix)");
}
