public void Visit(VariableExpressionNode node)
{
if (!_variables.Contains(node.Name))
{
_result.AddUnknownVariableError(node.Name, node.Position);
}
}
protected StatementNode GenerateEntryPoint(CompilerNode owner, IEnumerable <MethodNode> methods)
{
var result = new BlockNode(owner);
var opDecl = new DeclarationNode(result);
opDecl.identifier = "operation";
opDecl.type = new TypeNode(opDecl, TypeKind.String);
result.declarations.Add(opDecl);
var assSt = new StackAssignmentNode(result);
assSt.declaration = opDecl;
result.statements.Add(assSt);
foreach (var method in methods)
{
if (method.visibility != Visibility.Public)
{
continue;
}
var ifExpr = new IfNode(result);
var cmpExpr = new BinaryExpressionNode(ifExpr);
var leftExpr = new VariableExpressionNode(cmpExpr);
leftExpr.declaration = opDecl;
var rightExpr = new LiteralExpressionNode(cmpExpr);
rightExpr.kind = LiteralKind.String;
rightExpr.value = method.name;
cmpExpr.left = leftExpr;
cmpExpr.right = rightExpr;
cmpExpr.@operator = OperatorKind.Equals;
var callSt = new CallNode(ifExpr);
callSt.method = method;
ifExpr.expr = cmpExpr;
ifExpr.trueBranch = callSt;
result.statements.Add(ifExpr);
}
result.statements.Add(new ExitNode(result));
return(result);
}
public void Visit(VariableExpressionNode node)
{
_parts[node] = (Func <int>)(() => _variables[node.Name]);
}
protected ExpressionNode ParseExpression(List <Token> tokens, ref int index, CompilerNode owner, int precedence = -1)
{
if (index >= tokens.Count)
{
throw new ParserException(tokens.Last(), ParserException.Kind.EndOfStream);
}
ExpressionNode term;
if (tokens[index].text == "(")
{
index++;
term = ParseExpression(tokens, ref index, owner);
ExpectDelimiter(tokens, ref index, ")");
}
else
if (Lexer.IsLiteral(tokens[index].kind))
{
LiteralKind litKind;
var node = new LiteralExpressionNode(owner);
node.value = ExpectLiteral(tokens, ref index, out litKind);
node.kind = litKind;
term = node;
}
else
if (tokens[index].kind == Token.Kind.Operator)
{
var node = new UnaryExpressionNode(owner);
node.op = tokens[index].text;
index++;
node.term = ParseExpression(tokens, ref index, node);
term = node;
}
else
{
var node = new VariableExpressionNode(owner);
node.identifier = ExpectIdentifier(tokens, ref index, false);
term = node;
}
while (tokens[index].kind == Token.Kind.Operator)
{
var p = GetOperatorPrecedence(tokens[index].text);
if (precedence < 0 || p > precedence)
{
var expr = new BinaryExpressionNode(owner);
expr.left = term;
expr.@operator = ParseOperator(ExpectOperator(tokens, ref index));
expr.right = ParseExpression(tokens, ref index, expr, p);
term = expr;
}
else
{
break;
}
}
return(term);
}
