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