Advertisement
ZazoTazo

Calc (update 2)

Apr 11th, 2020
439
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 3.40 KB | None | 0 0
  1. ###
  2. ### Zeyad Hesham Nofal 41610028
  3. ###
  4. import ply.lex as lex
  5. import ply.yacc as yacc
  6. import sys
  7.  
  8. tokens = [
  9.  
  10.     'INT',
  11.     'FLOAT',
  12.     'NAME',
  13.     'PLUS',
  14.     'MINUS',
  15.     'DIVIDE',
  16.     'MULTIPLY',
  17.     'EQUALS',
  18.     'COMEXP',
  19.     'IF',
  20.     'OB',
  21.     'CB',
  22.     'BTH',
  23.     'LTH',
  24.     'NEQ',
  25.     'EQ'
  26.  
  27. ]
  28.  
  29. t_PLUS = r'\+'
  30. t_MINUS = r'\-'
  31. t_MULTIPLY = r'\*'
  32. t_DIVIDE = r'\/'
  33. t_EQUALS = r'\='
  34. t_IF = r'IF'
  35. t_OB = r'\('
  36. t_CB = r'\)'
  37. t_BTH = r'\>'
  38. t_LTH = r'\<'
  39. t_EQ = r'\=='
  40. t_NEQ = r'\!='
  41. t_ignore = r' '
  42.  
  43. def t_FLOAT(t):
  44.     r'\d+\.\d+'
  45.     t.value = float(t.value)
  46.     return t
  47.  
  48. def t_INT(t):
  49.     r'\d+'
  50.     t.value = int(t.value)
  51.     return t
  52.  
  53. def t_NAME(t):
  54.     r'[a-zA-Z_][a-zA-Z_0-9]*'
  55.     t.type = 'NAME'
  56.     return t
  57.  
  58. #def t_IF(t):
  59. #    r'IF'
  60. #    return t
  61.  
  62. def t_error(t):
  63.     print("Illegal characters!")
  64.     t.lexer.skip(1)
  65.  
  66. lexer = lex.lex()
  67.  
  68. precedence = (
  69.  
  70.     ('left', 'PLUS', 'MINUS'),
  71.     ('left', 'MULTIPLY', 'DIVIDE')
  72.  
  73. )
  74.  
  75. def p_calc(p):
  76.     '''
  77.    calc : expression
  78.         | var_assign
  79.         | statement
  80.         | empty
  81.    '''
  82.     print(run(p[1]))
  83.  
  84. def p_var_assign(p):
  85.     '''
  86.    var_assign : NAME EQUALS expression
  87.    '''
  88.     p[0] = ('=', p[1], p[3])
  89.  
  90. def p_expression(p):
  91.     '''
  92.  
  93.    statement : IF OB COMEXP CB
  94.    
  95.    expression : expression MULTIPLY expression
  96.               | expression DIVIDE expression
  97.               | expression PLUS expression
  98.               | expression MINUS expression
  99.    '''
  100.     p[0] = (p[2], p[1], p[3])
  101.  
  102. def p_COMEXP(p):
  103.     '''
  104.  
  105.    expression : expression BTH expression
  106.               | expression LTH expression
  107.               | expression EQ expression
  108.               | expression NEQ expression
  109.  
  110.    '''
  111.  
  112. def p_expression_int_float(p):
  113.     '''
  114.    expression : INT
  115.               | FLOAT
  116.    '''
  117.     p[0] = p[1]
  118.  
  119. def p_expression_var(p):
  120.     '''
  121.    expression : NAME
  122.    '''
  123.     p[0] = ('var', p[1])
  124.  
  125. def p_error(p):
  126.     print("Syntax error found!")
  127.  
  128. def p_empty(p):
  129.     '''
  130.    empty :
  131.    '''
  132.     p[0] = None
  133.  
  134.  
  135. parser = yacc.yacc()
  136. env = {}
  137.  
  138. def run(p):
  139.     global env
  140.     if type(p) == tuple:
  141.         if p[0] == '+':
  142.             return run(p[1]) + run(p[2])
  143.         elif p[0] == '-':
  144.             return run(p[1]) - run(p[2])
  145.         elif p[0] == '*':
  146.             return run(p[1]) * run(p[2])
  147.         elif p[0] == '/':
  148.             return run(p[1]) / run(p[2])
  149.         elif p[0] == '<':
  150.             if(run(p[1]) < run(p[2])):
  151.                 return True
  152.             else:
  153.                 return False
  154.         elif p[0] == '>':
  155.             if(run(p[1]) > run(p[2])):
  156.                 return True
  157.             else:
  158.                 return False
  159.         elif p[0] == '==':
  160.             if(run(p[1]) == run(p[2])):
  161.                 return True
  162.             else:
  163.                 return False
  164.         elif p[0] == '!=':
  165.             if(run(p[1]) != run(p[2])):
  166.                 return True
  167.             else:
  168.                 return False
  169.         elif p[0] == '=':
  170.             env[p[1]] = run(p[2])
  171.             #return ''
  172.             print(env)
  173.         elif p[0] == 'var':
  174.             if p[1] not in env:
  175.                 return 'Undeclared variable found!'
  176.             else:
  177.                 return env[p[1]]
  178.     else:
  179.         return p
  180.  
  181. while True:
  182.     try:
  183.         s = input('>> ')
  184.     except EOFError:
  185.         break
  186.     parser.parse(s)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement