private Expression Insert(Expression hash, SyntaxNode node) { var element = node.Accept(Compiler); var type = node.Token.Type; return(type == TokenType.kDSTAR ? MergeHash(hash, element) : MergeAssoc(hash, element)); }
private InvocationArgument CreateInvocationArgument(SyntaxNode argument) { var kind = argument.Token.Type.GetArgumentKind(); var expression = argument.Accept(Compiler); return(new InvocationArgument(kind, expression)); }
public virtual SyntaxNode Visit(SyntaxNode node) { if (node != null) { return(node.Accept(this)); } return(null); }
public virtual TResult Visit(SyntaxNode node) { if (node != null) { return(node.Accept(this)); } return(default(TResult)); }
private void BindNode(SyntaxNode node) { _binder._cancellationToken.ThrowIfCancellationRequested(); // use NodeBinder to determine semantic info for this node. var info = node.Accept(_nodeBinder); // remember semantic info _binder.SetSemanticInfo(node, info); }
private void button1_Click(object sender, EventArgs e) { lstLog.Items.Clear(); DoParse(); if (_program != null) { //richInputBox.Text = ""; _program.Accept(new ContextVisitor()); //_program.Accept(new SemanticCheckVisitor()); //_program.Accept(new ScopeCheckVisitor()); //_program.Accept(new TypeCheckVisitor()); /*richInputBox.Text = (string)*/// _program.Accept(new CodeGenVisitor()); } //richInputBox.Text = "Test"; }
public override void Visit(SyntaxNode node) { if (node != null) { _recursionDepth++; StackGuard.EnsureSufficientExecutionStack(_recursionDepth); node.Accept(this); _recursionDepth--; } }
public Expression Compile(SyntaxNode node) { var scope = CurrentScope; var body = node.Accept(this); body = scope.CompileBody(body); return(Block( CallFrame.Expressions.Push(scope.CallFrame), TryFinally( body, CallFrame.Expressions.Pop() ) )); }
protected override void DefaultVisit(SyntaxNode node) { // if you can, ask your parent instead for (var parent = node.Parent; parent != null; parent = parent.Parent) { if (parent is SyntaxNode parentNode) { parentNode.Accept(this); break; // okay, done now } } // reached the top? Look for as-operators too if (node.Parent == null) { node.Accept(_asBuilder); } }
private void VisitInScope(SyntaxNode node, ScopeKind kind) { if (node == null) { return; } var oldScopeKind = _binder._scopeKind; _binder._scopeKind = kind; try { node.Accept(this); } finally { _binder._scopeKind = oldScopeKind; } }
public virtual void Visit(SyntaxNode?node) { node?.Accept(this); }
protected override void DefaultVisit(SyntaxNode node) { // if we get here, fall back to normal expression binding. node.Accept(_treeBinder); }
public virtual T Visit(SyntaxNode syntaxNode) { return(syntaxNode != null?syntaxNode.Accept(this) : default(T)); }
public virtual void Visit(SyntaxNode node) => node.Accept(this);
void HandleExpr(SyntaxNode n) { n.Accept(new ExprBuilder(this)); }
public void Visit(SyntaxNode node) { Debug.Assert(node != null, "null"); node.Accept(this); }
public virtual void Visit(SyntaxNode node) { if (node != null) node.Accept(this); }
public override void Visit(SyntaxNode node) { node?.Accept(this); }
public LiteValue Eval(SyntaxNode Node) { var V = new EvalVisitor(); return(Node.Accept(V, Env_)); }
private BoundExpression BuildExpression(SyntaxNode syntax) { return (BoundExpression)syntax.Accept(this); }
public void Visit(SyntaxNode node) { node.Accept(this); }