public override object VisitExpr(Z80AsmParser.ExprContext context) { if (context == null) { return(null); } // --- Extract the expression text var sb = new StringBuilder(400); for (var i = 0; i < context.ChildCount; i++) { var token = context.GetChild(i).GetText(); sb.Append(token); } ExpressionNode expr = null; switch (context) { // --- Primary operators case Z80AsmParser.BuiltInFunctionExprContext ctx: expr = (ExpressionNode)VisitBuiltinFunctionInvocation(ctx.builtinFunctionInvocation()); break; case Z80AsmParser.FunctionInvocationExprContext ctx: expr = new FunctionInvocationNode(ctx.functionInvocation(), this); break; case Z80AsmParser.MacroParamExprContext ctx: expr = new MacroParamNode(ctx.macroParam(), this); break; // --- Unary operators case Z80AsmParser.UnaryPlusExprContext ctx: expr = new UnaryPlusNode(ctx, this); break; case Z80AsmParser.UnaryMinusExprContext ctx: expr = new UnaryMinusNode(ctx, this); break; case Z80AsmParser.BinaryNotExprContext ctx: expr = new UnaryBitwiseNotNode(ctx, this); break; case Z80AsmParser.LogicalNotExprContext ctx: expr = new UnaryLogicalNotNode(ctx, this); break; // --- Bracketed/Parenthesized expressions case Z80AsmParser.BracketedExprContext ctx: expr = (ExpressionNode)VisitExpr(ctx.expr()); break; case Z80AsmParser.ParenthesizedExprContext ctx: expr = (ExpressionNode)VisitExpr(ctx.expr()); break; // --- Literals case Z80AsmParser.LiteralExprContext ctx: expr = (ExpressionNode)VisitLiteral(ctx.literal()); break; case Z80AsmParser.SymbolExprContext ctx: if (ctx.ChildCount != 0 && ctx.symbol()?.IDENTIFIER() != null) { AddIdentifier(ctx); expr = new IdentifierNode(ctx.symbol()); } break; // --- Min/Max operators case Z80AsmParser.MinMaxExprContext ctx: switch (ctx.op?.Text) { case "<?": expr = new MinOperationNode(ctx, this); break; default: expr = new MaxOperationNode(ctx, this); break; } break; // --- Multiplication operators case Z80AsmParser.MultExprContext ctx: switch (ctx.op?.Text) { case "*": expr = new MultiplyOperationNode(ctx, this); break; case "/": expr = new DivideOperationNode(ctx, this); break; default: expr = new ModuloOperationNode(ctx, this); break; } break; // --- Addition operators case Z80AsmParser.AddExprContext ctx: switch (ctx.op?.Text) { case "+": expr = new AddOperationNode(ctx, this); break; default: expr = new SubtractOperationNode(ctx, this); break; } break; // --- Shift operators case Z80AsmParser.ShiftExprContext ctx: switch (ctx.op?.Text) { case "<<": expr = new ShiftLeftOperationNode(ctx, this); break; default: expr = new ShiftRightOperationNode(ctx, this); break; } break; // --- Relational operators case Z80AsmParser.RelExprContext ctx: switch (ctx.op?.Text) { case "<": expr = new LessThanOperationNode(ctx, this); break; case "<=": expr = new LessThanOrEqualOperationNode(ctx, this); break; case ">": expr = new GreaterThanOperationNode(ctx, this); break; default: expr = new GreaterThanOrEqualOperationNode(ctx, this); break; } break; // --- Equality operators case Z80AsmParser.EquExprContext ctx: switch (ctx.op?.Text) { case "==": expr = new EqualOperationNode(ctx, this); break; case "===": expr = new CaseInsensitiveEqualOperationNode(ctx, this); break; case "!=": expr = new NotEqualOperationNode(ctx, this); break; default: expr = new CaseInsensitiveNotEqualOperationNode(ctx, this); break; } break; // --- Bitwise operators case Z80AsmParser.AndExprContext ctx: expr = new BitwiseAndOperationNode(ctx, this); break; case Z80AsmParser.XorExprContext ctx: expr = new BitwiseXorOperationNode(ctx, this); break; case Z80AsmParser.OrExprContext ctx: expr = new BitwiseOrOperationNode(ctx, this); break; // --- Ternary operator case Z80AsmParser.TernaryExprContext ctx: expr = new ConditionalExpressionNode(ctx, this); break; } if (expr != null) { expr.SourceText = sb.ToString(); } return(expr); }
protected SyntaxNode buildSyntaxTree(List <ISyntaxUnit> postfixForm) { Queue <ISyntaxUnit> inputQueue = new Queue <ISyntaxUnit>(postfixForm); Stack <SyntaxNode> operandStack = new Stack <SyntaxNode>(); while (inputQueue.Count > 0) { ISyntaxUnit input = inputQueue.Dequeue(); if (input is Lexeme) { Lexeme token = input as Lexeme; Lexeme.LexemeType ttype = token.Type; if (properties.IsVariable(token.Value)) { VariableIdentifierNode variable = new VariableIdentifierNode(token.Value); operandStack.Push(variable); } else if (properties.IsConstant(token.Value)) { double constantValue = properties.getConstantValue(token.Value); ConstantIdentifierNode constant = new ConstantIdentifierNode(token.Value, constantValue); operandStack.Push(constant); } else if (properties.IsFunctionName(token.Value)) { int nArguments = properties.getFunctionArgumentsCount(token.Value); FunctionApplyNode.FunctionBody funcBody = properties.getFunctionDefinition(token.Value); ArgumentListNode argumentList = new ArgumentListNode(); try { for (int i = 0; i < nArguments; i++) { argumentList.addArgument(operandStack.Pop()); } } catch (InvalidOperationException ex) { throw new ParseException("Not enough operands on operand stack for function call."); } FunctionApplyNode functionCall = new FunctionApplyNode(argumentList, funcBody, token.Value); operandStack.Push(functionCall); } else if (ttype == Lexeme.LexemeType.REAL_VALUE) { double value; if (!double.TryParse(token.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out value)) { throw new ParseException("Couldn't parse literal value: " + token.Value); } LiteralNode literal = new LiteralNode(value); operandStack.Push(literal); } else if (ttype == Lexeme.LexemeType.OP_PLUS) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); AdditionNode addition = new AdditionNode(left, right); operandStack.Push(addition); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for addition."); } } else if (ttype == Lexeme.LexemeType.OP_MINUS) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); SubtractionNode subtraction = new SubtractionNode(left, right); operandStack.Push(subtraction); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for subtraction."); } } else if (ttype == Lexeme.LexemeType.OP_MUL) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); MultiplicationNode multiplication = new MultiplicationNode(left, right); operandStack.Push(multiplication); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for multiplication."); } } else if (ttype == Lexeme.LexemeType.OP_DIV) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); DivisionNode division = new DivisionNode(left, right); operandStack.Push(division); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for division."); } } else if (ttype == Lexeme.LexemeType.OP_POW) { try { SyntaxNode exponent = operandStack.Pop(); SyntaxNode baseNode = operandStack.Pop(); PowerNode power = new PowerNode(baseNode, exponent); operandStack.Push(power); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for exponentiation."); } } else if (ttype == Lexeme.LexemeType.EQ_SIGN) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); EqualsNode eqNode = new EqualsNode(left, right); operandStack.Push(eqNode); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for assignment."); } } else if (ttype == Lexeme.LexemeType.OP_PLUS_UNARY) { try { SyntaxNode child = operandStack.Pop(); UnaryPlusNode unaryPlus = new UnaryPlusNode(child); operandStack.Push(unaryPlus); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand for unary plus."); } } else if (ttype == Lexeme.LexemeType.OP_MINUS_UNARY) { try { SyntaxNode child = operandStack.Pop(); UnaryMinusNode unaryMinus = new UnaryMinusNode(child); operandStack.Push(unaryMinus); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand for unary minus."); } } else { throw new ParseException("Unexpected token in postfix expression: " + token.simpleRepresentation()); } } else if (input is SyntaxNode) { operandStack.Push(input as SyntaxNode); } else { throw new ParseException("Unexpected object type in postfix expression."); } } if (operandStack.Count == 1) { return(operandStack.Pop()); } else { throw new ParseException("Too many operands in postfix expression."); } }