ext/ply/example/newclasscalc/calc.py

   1 #!/usr/bin/env python
   2
   3 # -----------------------------------------------------------------------------
   4 # calc.py
   5 #
   6 # A simple calculator with variables.   This is from O'Reilly's
   7 # "Lex and Yacc", p. 63.
   8 #
   9 # Class-based example contributed to PLY by David McNab.
  10 #
  11 # Modified to use new-style classes.   Test case.
  12 # -----------------------------------------------------------------------------
  13
  14 import sys
  15 sys.path.insert(0,"../..")
  16
  17 import readline
  18 import ply.lex as lex
  19 import ply.yacc as yacc
  20 import os
  21
  22 class Parser(object):
  23     """
  24     Base class for a lexer/parser that has the rules defined as methods
  25     """
  26     tokens = ()
  27     precedence = ()
  28
  29
  30     def __init__(self, **kw):
  31         self.debug = kw.get('debug', 0)
  32         self.names = { }
  33         try:
  34             modname = os.path.split(os.path.splitext(__file__)[0])[1] + "_" + self.__class__.__name__
  35         except:
  36             modname = "parser"+"_"+self.__class__.__name__
  37         self.debugfile = modname + ".dbg"
  38         self.tabmodule = modname + "_" + "parsetab"
  39         #print self.debugfile, self.tabmodule
  40
  41         # Build the lexer and parser
  42         lex.lex(module=self, debug=self.debug)
  43         yacc.yacc(module=self,
  44                   debug=self.debug,
  45                   debugfile=self.debugfile,
  46                   tabmodule=self.tabmodule)
  47
  48     def run(self):
  49         while 1:
  50             try:
  51                 s = raw_input('calc > ')
  52             except EOFError:
  53                 break
  54             if not s: continue
  55             yacc.parse(s)
  56
  57
  58 class Calc(Parser):
  59
  60     tokens = (
  61         'NAME','NUMBER',
  62         'PLUS','MINUS','EXP', 'TIMES','DIVIDE','EQUALS',
  63         'LPAREN','RPAREN',
  64         )
  65
  66     # Tokens
  67
  68     t_PLUS    = r'\+'
  69     t_MINUS   = r'-'
  70     t_EXP     = r'\*\*'
  71     t_TIMES   = r'\*'
  72     t_DIVIDE  = r'/'
  73     t_EQUALS  = r'='
  74     t_LPAREN  = r'\('
  75     t_RPAREN  = r'\)'
  76     t_NAME    = r'[a-zA-Z_][a-zA-Z0-9_]*'
  77
  78     def t_NUMBER(self, t):
  79         r'\d+'
  80         try:
  81             t.value = int(t.value)
  82         except ValueError:
  83             print "Integer value too large", t.value
  84             t.value = 0
  85         #print "parsed number %s" % repr(t.value)
  86         return t
  87
  88     t_ignore = " \t"
  89
  90     def t_newline(self, t):
  91         r'\n+'
  92         t.lexer.lineno += t.value.count("\n")
  93
  94     def t_error(self, t):
  95         print "Illegal character '%s'" % t.value[0]
  96         t.lexer.skip(1)
  97
  98     # Parsing rules
  99
 100     precedence = (
 101         ('left','PLUS','MINUS'),
 102         ('left','TIMES','DIVIDE'),
 103         ('left', 'EXP'),
 104         ('right','UMINUS'),
 105         )
 106
 107     def p_statement_assign(self, p):
 108         'statement : NAME EQUALS expression'
 109         self.names[p[1]] = p[3]
 110
 111     def p_statement_expr(self, p):
 112         'statement : expression'
 113         print p[1]
 114
 115     def p_expression_binop(self, p):
 116         """
 117         expression : expression PLUS expression
 118                   | expression MINUS expression
 119                   | expression TIMES expression
 120                   | expression DIVIDE expression
 121                   | expression EXP expression
 122         """
 123         #print [repr(p[i]) for i in range(0,4)]
 124         if p[2] == '+'  : p[0] = p[1] + p[3]
 125         elif p[2] == '-': p[0] = p[1] - p[3]
 126         elif p[2] == '*': p[0] = p[1] * p[3]
 127         elif p[2] == '/': p[0] = p[1] / p[3]
 128         elif p[2] == '**': p[0] = p[1] ** p[3]
 129
 130     def p_expression_uminus(self, p):
 131         'expression : MINUS expression %prec UMINUS'
 132         p[0] = -p[2]
 133
 134     def p_expression_group(self, p):
 135         'expression : LPAREN expression RPAREN'
 136         p[0] = p[2]
 137
 138     def p_expression_number(self, p):
 139         'expression : NUMBER'
 140         p[0] = p[1]
 141
 142     def p_expression_name(self, p):
 143         'expression : NAME'
 144         try:
 145             p[0] = self.names[p[1]]
 146         except LookupError:
 147             print "Undefined name '%s'" % p[1]
 148             p[0] = 0
 149
 150     def p_error(self, p):
 151         print "Syntax error at '%s'" % p.value
 152
 153 if __name__ == '__main__':
 154     calc = Calc()
 155     calc.run()