Calculator tutorial

A tutorial for parsing and evaluation of arithmetic expressions.

In this tutorial we will make a parser and evaluator for simple arithmetic expression (numbers and operations - addition, subtraction, multiplication and division). The parser will be able to recognize and evaluate following expressions:


Evaluation will be done using support for semantic analysis.

Parsing infix expression has additional constraints related to operator precedence. Arpeggio is recursive-descent parser, parsing the input from left to right and doing a leftmost derivation. There is a simple technique that will enable proper evaluation in the context of a different operator precedence.

Let's start with grammar definition.

The grammar

  • Each calc file consists of one or more expressions.
def calc():       return OneOrMore(expression), EOF
  • Each expression is a sum or subtraction of terms.
def expression(): return term, ZeroOrMore(["+", "-"], term)
  • Each term is a multiplication or division of factors.
def term():       return factor, ZeroOrMore(["*","/"], factor)


Notice that the order of precendence is from lower to upper. The deeper is the grammar rule, the tighter is the bonding.

  • Each factor is either a number or an expression inside brackets. The prefix sign is optional. This is a support for unary minus.
def factor():     return Optional(["+","-"]), [number, ("(", expression, ")")]


Notice indirect recursion here to expression. It is not left since the opening bracket must be found.

  • And finally we define number using regular expression as
def number():     return _(r'\d*\.\d*|\d+')

The parser

Using above grammar specified in Python notation we instantiate the parser using ParserPython class.

  parser = ParserPython(calc)

This parser is able to parse arithmetic expression like this


and produce parse tree like this


All tree images in this documentation are produced by running the parser in debug mode and using visualization support.

The parsing is done like this:

input_expr = "-(4-1)*5+(2+4.67)+5.89/(.2+7)"
parse_tree = parser.parse(input_expr)

By ordering operation in the grammar form lower to upper precendence we have got the parse tree where the priority is retained. This will help us to easier make an expression evaluation.

Evaluating parse tree

To implement evaluation we shall use Arpeggio's support for semantic analysis using visitor patter.

Visitor is an object with methods named visit_<rule> which gets called for each node of parse tree produced with the given rule. The processing of the tree nodes is done bottom-up.

class CalcVisitor(PTNodeVisitor):

    def visit_number(self, node, children):
        Converts node value to float.
        return float(node.value)


Visit method for the number rule will do the conversion of the matched text to float type. This nodes will always be the terminal nodes and will be evaluated first.

    def visit_factor(self, node, children):
        Applies a sign to the expression or number.
        if len(children) == 1:
            return children[0]
        sign = -1 if children[0] == '-' else 1
        return sign * children[-1]

Factor will have an optional sign as the first child and whatever matches first from the ordered choice of number and expression. We take the last element. It must be the result of number or expression evaluation and apply an optional sing on it.


Note that the constant string matches will be removed by the Arpeggio, thus you will never get a constant string match in the children list.

    def visit_term(self, node, children):
        Divides or multiplies factors.
        Factor nodes will be already evaluated.
        term = children[0]
        for i in range(2, len(children), 2):
            if children[i-1] == "*":
                term *= children[i]
                term /= children[i]
        return term

term consist of multiplication or divisions. Both operations are left associative so we shall run from left to right. Each even element will be evaluated factor while each odd element will be an operation to perform. At the end we return the evaluated term.

    def visit_expression(self, node, children):
        Adds or substracts terms.
        Term nodes will be already evaluated.
        expr = 0
        start = 0
        # Check for unary + or - operator
        if text(children[0]) in "+-":
            start = 1

        for i in range(start, len(children), 2):
            if i and children[i - 1] == "-":
                expr -= children[i]
                expr += children[i]

        return expr

And finally the whole expression consists of additions and subtractions of terms. A minor glitch here is a support for unary minus and plus sign.

Let's apply this visitor to our parse tree.

result = visit_parse_tree(parse_tree, CalcVisitor(debug=debug))

The result will be a float which represent the value of the given expression.

The grammar in PEG

As a final note, the same grammar can be specified in textual PEG syntax.

Either a clean PEG variant:

number = r'\d*\.\d*|\d+'
factor = ("+" / "-")?
          (number / "(" expression ")")
term = factor (( "*" / "/") factor)*
expression = term (("+" / "-") term)*
calc = expression+ EOF

or traditional PEG variant:

number <- r'\d*\.\d*|\d+';
factor <- ("+" / "-")?
          (number / "(" expression ")");
term <- factor (( "*" / "/") factor)*;
expression <- term (("+" / "-") term)*;
calc <- expression+ EOF;

The grammar for textual PEG is parsed using Arpeggio itself and this shows the flexibility of the Arpeggio parser.

The code for both parser can be found in the Calc example.