coding utf-8 import sys reload sys sys setdefaultencoding utf-8 import

# -*- coding: utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8')

import copy

from grammar import Symbol
from grammar import Rule


class Parser():
    def __init__(self, lexer):
        self.lexer = lexer

    def parse(self):
        '''
            Ident = ([A-Z]) ([A-Z]p)
            Oper =  (+)(*)
            ω = ("*" Ident θ) (Ident θ)
            θ = ("(" Ident Ident ")" ω) ("(" Oper Ident Ident ")" ω) ("(" \"(\" Ident \")\" ")" ω) ("(" ")"ω)
        '''

        def w_parse():
            rul = Rule()
            def start_parse(ax):
                if lexer.cur_token_is_ident():
                    rul = Rule()
                    head = Symbol(sym=lexer.cur_token()[1], type='noterm')
                    rul.head = head
                    rul.is_axiom = ax
                    lexer.next_token()
                    o_parse(rul, f=1)
                else:
                    raise Exception("parse error on token %s" % lexer.cur_token()[1])

            if lexer.cur_token_is_star():
                lexer.next_token()
                start_parse(True)
            else:
                start_parse(False)

        def o_parse(rul, f = 0):
            if lexer.cur_token_is_oper_left():
                lexer.next_token()
                if lexer.cur_token_is_ident():
                    st.append(lexer.cur_token())
                    lexer.next_token()
                    if lexer.cur_token_is_ident():
                        st.append(lexer.cur_token())
                        lexer.next_token()
                        if lexer.cur_token_is_oper_right():
                            lexer.next_token()
                            if rul.body != None:
                                rul = copy.copy(rul)
                            rul.body = st[-2:]
                            rules.append(rul)
                            o_parse(rul)
                        else:
                            raise Exception("parse error on token %s" % lexer.cur_token()[1])
                    else:
                        raise Exception("parse error on token %s" % lexer.cur_token()[1])
                elif lexer.cur_token_is_text():
                    st.append(lexer.cur_token())
                    lexer.next_token()
                    if lexer.cur_token_is_ident():
                        st.append(lexer.cur_token())
                        lexer.next_token()
                        if lexer.cur_token_is_text():
                            st.append(lexer.cur_token())
                            lexer.next_token()
                            if lexer.cur_token_is_oper_right():
                                lexer.next_token()
                                if rul.body != None:
                                    rul = copy.copy(rul)
                                rul.body = st[-3:]
                                rules.append(rul)
                                o_parse(rul)
                        elif lexer.cur_token_is_ident():
                            st.append(lexer.cur_token())
                            lexer.next_token()
                            if lexer.cur_token_is_oper_right():
                                lexer.next_token()
                                if rul.body != None:
                                    rul = copy.copy(rul)
                                rul.body = st[-3:]
                                rules.append(rul)
                                o_parse(rul)
                            else:
                                raise Exception("parse error on token %s" % lexer.cur_token()[1])
                        elif lexer.cur_token_is_oper_right():
                            lexer.next_token()
                            if rul.body != None:
                                rul = copy.copy(rul)
                            rul.body = st[-3:]
                            rules.append(rul)
                            o_parse(rul)
                    elif lexer.cur_token_is_oper_right():
                        lexer.next_token()
                        if rul.body != None:
                            rul = copy.copy(rul)
                        rul.body=st[-1:]
                        rules.append(rul)
                        o_parse(rul)
                    else:
                        raise Exception("parse error on token %s" % lexer.cur_token()[1])
                elif lexer.cur_token_is_oper_right():
                    lexer.next_token()
                    if rul.body != None:
                        rul = copy.copy(rul)
                    rul.body = []
                    rules.append(rul)
                    o_parse(rul)

            elif f:
                raise Exception("parse error on token %s" % lexer.cur_token()[1])

        rules, st = [], []
        lexer = self.lexer
        while lexer.cur_token():
            w_parse()
        return rules