public static void Evaluator_EvaluateExpression()
{
string text = "4 + (1 + 2) * 3";
var syntaxTree = SyntaxTree.Parse(text);
var binder = new Binder();
var boundExpression = binder.BindExpression(syntaxTree.Root);
var diagnostics = syntaxTree.Diagnostics.Concat(binder.Diagnostitcs).ToArray();
StringBuilder expectedResult = new StringBuilder().AppendLine("13");
StringBuilder receivedResult = new StringBuilder();
if (diagnostics.Any())
{
foreach (var diagnostic in diagnostics)
{
receivedResult.AppendLine(diagnostic);
}
}
else
{
var evaluator = new Evaluator(boundExpression);
var result = evaluator.Evaluate();
receivedResult.AppendLine(result.ToString());
}
UnitTest.Assert.AreEqual(expectedResult.ToString(), receivedResult.ToString());
}
protected override TypeSymbol InferTypeOfVarVariable(DiagnosticBag diagnostics)
{
switch (_nodeToBind.Kind())
{
case SyntaxKind.ArgumentList:
var invocation = (ConstructorInitializerSyntax)_nodeToBind.Parent;
_nodeBinder.BindConstructorInitializer(invocation.ArgumentList, (MethodSymbol)ContainingSymbol, diagnostics);
break;
case SyntaxKind.CasePatternSwitchLabel:
_nodeBinder.BindPatternSwitchLabelForInference((CasePatternSwitchLabelSyntax)_nodeToBind, diagnostics);
break;
case SyntaxKind.VariableDeclarator:
// This occurs, for example, in
// int x, y[out var Z, 1 is int I];
// for (int x, y[out var Z, 1 is int I]; ;) {}
_nodeBinder.BindDeclaratorArguments((VariableDeclaratorSyntax)_nodeToBind, diagnostics);
break;
default:
_nodeBinder.BindExpression((ExpressionSyntax)_nodeToBind, diagnostics);
break;
}
if ((object)this._type == null)
{
Debug.Assert(this.DeclarationKind == LocalDeclarationKind.DeclarationExpressionVariable);
SetType(_nodeBinder.CreateErrorType("var"));
}
return(this._type);
}
private static void Main()
{
var showTree = false;
while (true)
{
Console.Write("> ");
var line = Console.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
return;
}
if (line == "#showTree")
{
showTree = !showTree;
Console.WriteLine(showTree ? "Showing parse trees." : "Not showing parse trees");
continue;
}
else if (line == "#cls")
{
Console.Clear();
continue;
}
var syntaxTree = SyntaxTree.Parse(line);
var binder = new Binder();
var boundExpression = binder.BindExpression(syntaxTree.Root);
var diagnostics = syntaxTree.Diagnostics.Concat(binder.Diagnostics).ToArray();
if (showTree)
{
Console.ForegroundColor = ConsoleColor.DarkGray;
PrettyPrint(syntaxTree.Root);
Console.ResetColor();
}
if (!diagnostics.Any())
{
var e = new Evaluator(boundExpression);
var result = e.Evaluate();
Console.WriteLine(result);
}
else
{
Console.ForegroundColor = ConsoleColor.DarkRed;
foreach (var diagnostic in diagnostics)
{
Console.WriteLine(diagnostic);
}
Console.ResetColor();
}
}
}
protected override TypeSymbol InferTypeOfVarVariable(DiagnosticBag diagnostics)
{
switch (_nodeToBind.Kind())
{
case SyntaxKind.ArgumentList:
var invocation = (ConstructorInitializerSyntax)_nodeToBind.Parent;
_nodeBinder.BindConstructorInitializer(invocation.ArgumentList, (MethodSymbol)ContainingSymbol, diagnostics);
break;
case SyntaxKind.CasePatternSwitchLabel:
_nodeBinder.BindPatternSwitchLabelForInference((CasePatternSwitchLabelSyntax)_nodeToBind, diagnostics);
break;
case SyntaxKind.VariableDeclarator:
// This occurs, for example, in
// int x, y[out var Z, 1 is int I];
// for (int x, y[out var Z, 1 is int I]; ;) {}
var declarator = (VariableDeclaratorSyntax)_nodeToBind;
if (declarator.ArgumentList != null)
{
foreach (var arg in declarator.ArgumentList.Arguments)
{
var expression = arg.Expression;
if (expression.Kind() == SyntaxKind.DeclarationExpression)
{
this.SetType(_nodeBinder.CreateErrorType("var"));
// no error is necessary, as they would be dropped on the floor by the caller
}
else
{
_nodeBinder.BindExpression(expression, diagnostics);
}
}
}
break;
default:
_nodeBinder.BindExpression((ExpressionSyntax)_nodeToBind, diagnostics);
break;
}
Debug.Assert((object)this._type != null);
return(this._type);
}
private BoundExpression Expression(string input)
{
var tree = SyntaxTree.Parse(input);
Assert.Empty(tree.Diagnostics);
var expr = Assert.IsAssignableFrom <ExpressionSyntax>(tree.Root);
var bound = _binder.BindExpression(expr);
Assert.Empty(_binder.Diagnostics);
return(bound);
}
void OnGUI()
{
Event e = Event.current;
if (e.type == EventType.KeyDown)
{
if (e.keyCode == KeyCode.Return)
{
string[] inputLines = _inputField.text.Split('\n');
_stringBuilder.Clear();
if (inputLines[inputLines.Length - 1].ToLower() == "clear")
{
StartCoroutine(InvokeOnNextFrame(() => { _inputField.text = ""; _consoleField.text = ""; }));
}
else if (inputLines[inputLines.Length - 1].ToLower() == "showtree")
{
_shouldShowTree = !_shouldShowTree;
}
else
{
foreach (var input in inputLines)
{
var syntaxTree = SyntaxTree.Parse(input);
var binder = new Binder();
var boundExpression = binder.BindExpression(syntaxTree.Root);
var diagnostics = syntaxTree.Diagnostics.Concat(binder.Diagnostitcs).ToArray();
if (diagnostics.Any())
{
foreach (var diagnostic in diagnostics)
{
_stringBuilder.AppendLine(diagnostic);
}
}
else
{
var evaluator = new Evaluator(boundExpression);
var result = evaluator.Evaluate();
_stringBuilder.AppendLine(result.ToString());
if (_shouldShowTree)
{
_stringBuilder.AppendLine(Parser.PrettifySyntaxTree(syntaxTree.Root));
}
}
}
_consoleField.text = _stringBuilder.ToString();
}
}
}
}
protected override TypeWithAnnotations InferTypeOfVarVariable(DiagnosticBag diagnostics)
{
switch (_nodeToBind.Kind())
{
case SyntaxKind.ThisConstructorInitializer:
case SyntaxKind.BaseConstructorInitializer:
var initializer = (ConstructorInitializerSyntax)_nodeToBind;
_nodeBinder.BindConstructorInitializer(initializer, diagnostics);
break;
case SyntaxKind.SimpleBaseType:
_nodeBinder.BindConstructorInitializer((SimpleBaseTypeSyntax)_nodeToBind, diagnostics);
break;
case SyntaxKind.ArgumentList:
var invocation = (ConstructorInitializerSyntax)_nodeToBind.Parent;
_nodeBinder.BindConstructorInitializer(invocation, diagnostics);
break;
case SyntaxKind.CasePatternSwitchLabel:
_nodeBinder.BindPatternSwitchLabelForInference((CasePatternSwitchLabelSyntax)_nodeToBind, diagnostics);
break;
case SyntaxKind.VariableDeclarator:
// This occurs, for example, in
// int x, y[out var Z, 1 is int I];
// for (int x, y[out var Z, 1 is int I]; ;) {}
_nodeBinder.BindDeclaratorArguments((VariableDeclaratorSyntax)_nodeToBind, diagnostics);
break;
case SyntaxKind.SwitchExpressionArm:
var arm = (SwitchExpressionArmSyntax)_nodeToBind;
var armBinder = (SwitchExpressionArmBinder)_nodeBinder;
armBinder.BindSwitchExpressionArm(arm, diagnostics);
break;
case SyntaxKind.GotoCaseStatement:
_nodeBinder.BindStatement((GotoStatementSyntax)_nodeToBind, diagnostics);
break;
default:
_nodeBinder.BindExpression((ExpressionSyntax)_nodeToBind, diagnostics);
break;
}
if (this._type == null)
{
Debug.Assert(this.DeclarationKind == LocalDeclarationKind.DeclarationExpressionVariable);
SetTypeWithAnnotations(TypeWithAnnotations.Create(_nodeBinder.CreateErrorType("var")));
}
return(_type.Value);
}
public EvaluationResult Evaluate()
{
Binder binder = new Binder(symbolTable);
BoundExpression boundExpression = binder.BindExpression(expressionTree.Root.Expression);
Evaluator evaluator = new Evaluator(boundExpression, symbolTable);
object result = evaluator.Evaluate();
return(new EvaluationResult(binder.Diagnostics, result));
}
private object?EvaluateString(string input)
{
var syntaxTree = SyntaxTree.Parse(input);
Warn.If(syntaxTree.Diagnostics, Is.Not.Empty);
var binder = new Binder();
var boundExpression = binder.BindExpression(syntaxTree.Root.Expression);
Warn.If(binder.Diagnostics, Is.Not.Empty);
var evaluator = new Evaluator(boundExpression);
return(evaluator.Evaluate());
}
public EvaluateResult evaluate(Dictionary <string, object> variables)
{
var binder = new Binder(variables);
var boundExpression = binder.BindExpression(SyntaxTree.Root);
var diagnostics = SyntaxTree.Diagnostics.Concat(binder.Diagnostics).ToArray();
if (diagnostics.Any())
{
return(new EvaluateResult(diagnostics, null));
}
var value = new Evaluator(boundExpression, variables).Evaluate();
return(new EvaluateResult(Array.Empty <Diagnostic>(), value));
}
public EvaluationResult Evaluate(Dictionary <VariableSymbol, object> variables)
{
var binder = new Binder(variables);
var boundExpression = binder.BindExpression(Syntax.Root);
var diagnostics = Syntax.Diagnostics.Concat(binder.Diagnostics).ToImmutableArray();
if (diagnostics.Any())
{
return(new EvaluationResult(diagnostics, null));
}
var evalutor = new Evaluator(boundExpression, variables);
return(new EvaluationResult(ImmutableArray <Diagnostic> .Empty, evalutor.Evaluate()));
}
private static void Main()
{
var showTree = false;
while (true)
{
Console.Write(">");
var line = Console.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
return;
}
if ("#showTree".Equals(line, StringComparison.OrdinalIgnoreCase))
{
showTree = !showTree;
Console.WriteLine(showTree ? "Showing parse trees" : "Not showing parse trees");
continue;
}
else if ("#cls".Equals(line, StringComparison.OrdinalIgnoreCase))
{
Console.Clear();
continue;
}
var syntaxTree = SyntaxTree.Parse(line);
var binder = new Binder();
var boundExpression = binder.BindExpression(syntaxTree.Root);
var diagnostics = syntaxTree.Diagnostics.Concat(binder.Diagnostics);
if (showTree)
{
PrintSyntaxTree(syntaxTree);
}
if (!diagnostics.Any())
{
var e = new Evaluator(boundExpression);
var result = e.Evaluate();
Console.WriteLine(result);
}
else
{
PrintDiagnostics(diagnostics);
}
}
}
public EvaluationResult Evaluate()
{
var binder = new Binder();
var boundExpression = binder.BindExpression(Syntax.Root);
var diagnostics = Syntax.Diagnostics.Concat(binder.Diagnostics).ToArray();
if (diagnostics.Any())
{
return(new EvaluationResult(diagnostics, null));
}
var evaluator = new Evaluator(boundExpression);
var value = evaluator.Evaluate();
return(new EvaluationResult(Array.Empty <Diagnostic>(), value));
}
public EvaluationResult Evaluate()
{
var binder = new Binder();
var boundExpression = binder.BindExpression(SyntaxTree.Root.Expression);
var diagnostics = SyntaxTree.Diagnostics.Concat(binder.Diagnostics).ToImmutableArray();
if (diagnostics.Any())
{
return(new EvaluationResult(diagnostics));
}
var evaluator = new Evaluator(boundExpression);
var value = evaluator.Evaluate();
return(new EvaluationResult(ImmutableArray <Diagnostic> .Empty, value));
}
static void Main(string[] args)
{
var showTree = true;
while (true)
{
Console.WriteLine(">");
var line = Console.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
return;
}
if (Commands(line, ref showTree))
{
continue;
}
var syntaxTree = SyntaxTree.Parse(line);
var binder = new Binder();
var boundExpression = binder.BindExpression(syntaxTree.Root);
var diagnostics = syntaxTree.Diagnostics.Concat(binder.Diagnostics);
if (showTree)
{
Console.ForegroundColor = ConsoleColor.DarkGray;
PrettyPrint(syntaxTree.Root);
Console.ResetColor();
}
if (!diagnostics.Any())
{
var evaluator = new Evaluator.Evaluator(boundExpression);
var result = evaluator.Evaluate();
Console.WriteLine(result);
continue;
}
PrintErrors(syntaxTree);
}
}
public EvaluationResult Evaluate(Dictionary <Variable, object> variables)
{
// Get the expression
var binder = new Binder(variables);
var expression = binder.BindExpression(SyntaxTree.Root);
// Get the errors from the syntax tree and from binding
var Errors = SyntaxTree.Errors.Concat(binder.Errors);
// Evaluate the expression
var evaluator = new Evaluator(expression, variables);
var value = evaluator.Evaluate();
if (Errors.Any())
{
return(new EvaluationResult(Errors, null));
}
// Return the value or errors if there are any
return(new EvaluationResult(Array.Empty <Error>(), value));
}
private void HandleStatementAsync(string statement)
{
var tree = SyntaxTree.Parse(statement);
if (_printTree)
{
using (new OutputColor(foreground: ConsoleColor.DarkGreen)) {
Console.WriteLine(SyntaxTreePrinter.PrintTree(tree));
}
}
var binder = new Binder();
var bound = binder.BindExpression((ExpressionSyntax)tree.Root);
var diagnostics = Enumerable.Concat(tree.Diagnostics, binder.Diagnostics).ToArray();
if (diagnostics.Length > 0)
{
using (new OutputColor(foreground: ConsoleColor.Red)) {
foreach (var diag in diagnostics)
{
Console.WriteLine($"Error at position {diag.Location}: {diag.Message}");
}
return;
}
}
try {
var result = _evaluator.Evaluate(bound);
Console.WriteLine(result);
} catch (Exception e) {
using (new OutputColor(foreground: ConsoleColor.Red)) {
Console.WriteLine(e.Message);
}
}
}
