# note - use python3
# note - example from https://github.com/dabeaz/sly
# note - type ctrl-d as the end of input.

# notes on lexer
# - tokens are compiled with re.verbose flag
#   (comments with #, gets rid of white space).
#   If you need to match # use \#
# - tokens matched in order in your file.
#   If you want to use == and =, put the rule for == first.
# - sometimes there is more than one way to do something in the
#   lexer.  for example, can have a separate rule for each keyword
#   or catch them under a generic "ID" or "NAME" rule and use "token remapping"

# -----------------------------------------------------------------------------
# calc.py
# -----------------------------------------------------------------------------

# package isn't installed at the moment, so add the path so python can find it
import sys
slyPath = "/u1/h0/jkinne/public_html/cs420-s2019/code/sly-0.4"
sys.path.append(slyPath)


from sly import Lexer, Parser

class CalcLexer(Lexer):
    tokens = { NAME, NUMBER, PLUS, TIMES, MINUS, DIVIDE, ASSIGN, LPAREN, RPAREN, MOD, EQUALS, EXPONENT,
               INC, # IF, THEN, # note - if-then will be in sly-calc2.py
               PROMPT_FLIP}
    ignore = ' \t'

    # Tokens
    EXPONENT = r'\*\*'
    EQUALS = r'=='
    
    MOD = r'%'
    
    NAME = r'[a-zA-Z_][a-zA-Z0-9_]*'
    NUMBER = r'\d+'

    NAME['inc'] = INC 
    #NAME['if'] = IF # note - if-then will be in sly-calc2.py
    #NAME['then'] = THEN
    NAME['prompt_flip'] = PROMPT_FLIP

    # Special symbols
    PLUS = r'\+'
    MINUS = r'-'
    TIMES = r'\*'
    DIVIDE = r'/'
    ASSIGN = r'='
    LPAREN = r'\('
    RPAREN = r'\)'
    
    # Ignored pattern
    ignore_newline = r'\n+'

    # Extra action for newlines
    def ignore_newline(self, t):
        self.lineno += t.value.count('\n')

    def error(self, t):
        print("Illegal character '%s'" % t.value[0])
        self.index += 1

class CalcParser(Parser):
    tokens = CalcLexer.tokens

    precedence = (
        # ('left', IF, THEN), # note - if-then will be in sly-calc2.py
        ('left', EQUALS),
        ('left', PLUS, MINUS),
        ('left', TIMES, DIVIDE, MOD),
        ('right', UMINUS),
        ('right', EXPONENT)
        )

    def __init__(self):
        self.names = { }
        self.prompt = True
        self.debug = False

    @_('expr')
    def statement(self, p):
        print(p.expr)

    @_('PROMPT_FLIP')
    def statement(self, p):
        self.prompt = not self.prompt

    @_('INC NAME')
    def statement(self, p):
        try:
            self.names[p.NAME] += 1
        except LookupError:
            print(f'Undefined name {p.NAME!r}')
        
    @_('NAME ASSIGN expr')
    def statement(self, p):
        self.names[p.NAME] = p.expr

    # note - if-then will be in sly-calc2.py
    #@_('IF expr THEN statement')
    #def statement(self, p):
    #    if p.expr:
    #        self.statement(p.statement)
            #NOTE - this will be fixed in like 15 minutes.
            # still working on it...
            # actually, needs a bit of reworking of things.  so doing that...

    @_('expr EXPONENT expr')
    def expr(self, p):
        return p.expr0 ** p.expr1
    
    @_('expr PLUS expr')
    def expr(self, p):
        return p.expr0 + p.expr1

    @_('expr MINUS expr')
    def expr(self, p):
        return p.expr0 - p.expr1

    @_('expr TIMES expr')
    def expr(self, p):
        return p.expr0 * p.expr1

    @_('expr DIVIDE expr')
    def expr(self, p):
        return p.expr0 / p.expr1

    @_('expr MOD expr')
    def expr(self, p):
        return p.expr0 % p.expr1

    @_('expr EQUALS expr')
    def expr(self, p):
        return p.expr0 == p.expr1

    @_('MINUS expr %prec UMINUS')
    def expr(self, p):
        return -p.expr

    @_('LPAREN expr RPAREN')
    def expr(self, p):
        return p.expr

    @_('NUMBER')
    def expr(self, p):
        return int(p.NUMBER)

    @_('NAME')
    def expr(self, p):
        try:
            return self.names[p.NAME]
        except LookupError:
            print(f'Undefined name {p.NAME!r}')
            return 0
        

if __name__ == '__main__':
    lexer = CalcLexer()
    parser = CalcParser()
    while True:
        try:
            if parser.prompt:
                text = input('calc > ')
            else:
                text = input('')
        except EOFError:
            break
        if text:
            if parser.debug:
                print("text is - " + text)
                x = list(lexer.tokenize(text))
                print(x)
                x = iter(x)
                parser.parse(x)
            else:
                parser.parse(lexer.tokenize(text))