generate multiple parsings for each line

phrase.py

import fileinput
import re


class Expression(object):
    def addexpression(self, expression):
        return expression


class Empty(Expression):
    def addexpression(self, expression):
        return expression

    def __repr__(self):
        return "Empty()"


class Is(Expression):
    def __init__(self, left):
        self.left = left
        self.right = Empty()

    def addexpression(self, expression):
        self.right = expression
        return self

    def __repr__(self):
        return "Is(%s, %s)" % (repr(self.left), repr(self.right))


class Symbol(Expression):
    def __init__(self, name):
        self.name = name

    def addexpression(self, expression):
        return self

    def __repr__(self):
        return "Symbol(%s)" % self.name


class Operation(Expression):
    def __init__(self, left, operator):
        self.left = left
        self.operator = operator
        self.right = Empty()

    def addexpression(self, expression):
        self.right = expression
        return self

    def __repr__(self):
        return "Operation(%s, %s, %s)" % (repr(self.left), self.operator, repr(self.right))


class FunctionCall(Expression):
    def __init__(self, functionname):
        self.functionname = functionname
        self.arguments = []

    def addexpression(self, expression):
        self.arguments.append(expression)
        return self

    def __repr__(self):
        return "FunctionCall(%s, %s)" % (self.functionname, ", ".join([repr(argument) for argument in self.arguments]))


def lefttoright(words):
    expressionssofar = [Empty()]
    for word in words:
        newexpressions = []
        if word == 'is':
            for expression in expressionssofar:
                newexpressions.append(Is(expression))
        else:
            for expression in expressionssofar:
                newexpressions.append(Operation(expression, word))
                newexpressions.append(expression.addexpression(FunctionCall(word)))
                newexpressions.append(expression.addexpression(Symbol(word)))
        expressionssofar = newexpressions
    return expressionssofar


def main():
    whitespacere = re.compile("\s+")
    for line in fileinput.input():
        stripped = line.strip()
        words = whitespacere.split(stripped)
        expressions = lefttoright(words)
        print stripped
        print "---"
        for expression in expressions:
            print repr(expression)
        print


if __name__ == '__main__':
    main()