parse.py

import pyren.lex as lex

class Node:
    pass

class Atom:
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return repr(('atom', self.value))

class String:
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return repr(('string', self.value))

class Number:
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return repr(('number', self.value))

class ExprList:
    def __init__(self, items):
        self.items = items

    def __repr__(self):
        return repr(('expr-list', self.items))

class List:
    def __init__(self, items):
        self.items = items

    def __repr__(self):
        return repr(('list', self.items))

class Def:
    def __init__(self, name, args, body):
        self.name = name
        self.args = args
        self.body = body

    def __repr__(self):
        return repr(('def', self.name, self.args, self.body))

class Lambda:
    def __init__(self, args, body):
        self.args = args
        self.body = body

    def __repr__(self):
        return repr(('lambda', self.args, self.body))

def parse(lexer):
    terms = []
    try:
        while True:
            term = parse_term(next(lexer), lexer)
            if term is None:
                raise Exception('Syntax error: expected term.')
            terms.append(term)
    except StopIteration:
        return terms

def parse_term(token, lexer):
    if isinstance(token, lex.LParen):
        return parse_expr_list(lexer)
    elif isinstance(token, lex.LBracket):
        return parse_list(lexer)
    elif isinstance(token, lex.Atom):
        return Atom(token.value)
    elif isinstance(token, lex.String):
        return String(token.value)
    elif isinstance(token, lex.Number):
        return Number(token.value)

def parse_expr_list(lexer):
    token = None
    items = []
    while not isinstance(token, lex.RParen):
        token = next(lexer)
        if not isinstance(token, lex.RParen):
            items.append(parse_term(token, lexer))
    return ExprList(items)

def parse_list(lexer):
    token = None
    items = []
    while not isinstance(token, lex.RBracket):
        token = next(lexer)
        if not isinstance(token, lex.RBracket):
            items.append(parse_term(token, lexer))
    return List(items)