131 lines
3.2 KiB
Python
131 lines
3.2 KiB
Python
from base_unit import Token, TokenType
|
|
from collections import deque
|
|
|
|
class Op:
|
|
def __init__(self, left, op, right):
|
|
self.left = left
|
|
self.op = op
|
|
self.right = right
|
|
|
|
def __str__(self):
|
|
return "%s (%s) and (%s)" %(TokenType.get_operator_verb(self.op), self.left, self.right)
|
|
|
|
class Num:
|
|
def __init__(self, token):
|
|
self.value = token.value
|
|
|
|
def __str__(self):
|
|
return self.value
|
|
|
|
class Variable:
|
|
def __init__(self, token):
|
|
self.symbol = token.value
|
|
self.value = None
|
|
|
|
def __str__(self):
|
|
if self.value == None:
|
|
return self.symbol
|
|
else:
|
|
return str(self.value)
|
|
|
|
class Parser:
|
|
def __init__(self, tokens):
|
|
if len(tokens) == 0:
|
|
raise ValueError("Token list can't be empty")
|
|
self.bak = deque()
|
|
self.variables = {}
|
|
self.tokens = tokens
|
|
self.current_token = None
|
|
self.advance_current_token()
|
|
self.ast = self.generate_ast()
|
|
|
|
|
|
def get_tokens(self):
|
|
new_list = []
|
|
|
|
for t in self.bak:
|
|
if t.type == TokenType.variable:
|
|
if t.value in self.variables:
|
|
new_list.append(Token(self.variables[t.value], TokenType.constant))
|
|
else:
|
|
new_list.append(Token(t.value, t.type))
|
|
return new_list
|
|
|
|
def advance_current_token(self):
|
|
|
|
if len(self.tokens) > 0:
|
|
if self.current_token != None: self.bak.append(self.current_token)
|
|
self.current_token = self.tokens.popleft()
|
|
|
|
def factor(self):
|
|
if self.current_token.type == TokenType.constant:
|
|
node = Num(self.current_token)
|
|
self.advance_current_token()
|
|
return node
|
|
elif self.current_token.type == TokenType.variable:
|
|
node = Variable(self.current_token)
|
|
self.variables[self.current_token.value] = node
|
|
self.advance_current_token()
|
|
return node
|
|
elif self.current_token.type == TokenType.exp_start:
|
|
self.advance_current_token() # (
|
|
node = self.topLevel()
|
|
self.advance_current_token() # )
|
|
return node
|
|
|
|
def lowLevel(self):
|
|
node = self.factor()
|
|
|
|
while self.current_token.type == TokenType.power:
|
|
tmp = self.current_token
|
|
self.advance_current_token()
|
|
node = Op(left=node, op=tmp.type, right=self.factor())
|
|
|
|
return node
|
|
|
|
def midLevel(self):
|
|
node = self.lowLevel()
|
|
|
|
while self.current_token.type in (TokenType.multiply, TokenType.divide):
|
|
tmp = self.current_token
|
|
self.advance_current_token()
|
|
node = Op(left=node, op=tmp.type, right=self.lowLevel())
|
|
|
|
return node
|
|
|
|
def topLevel(self):
|
|
node = self.midLevel()
|
|
|
|
while self.current_token.type in (TokenType.add, TokenType.subtract):
|
|
tmp = self.current_token
|
|
self.advance_current_token()
|
|
node = Op(left=node, op=tmp.type, right=self.midLevel())
|
|
|
|
return node
|
|
|
|
def generate_ast(self):
|
|
return self.topLevel()
|
|
|
|
def update_variable(self, symbol, value):
|
|
if symbol in self.variables:
|
|
self.variables[symbol].value = float(value)
|
|
else:
|
|
raise ValueError("Variable value must be a number.", value)
|
|
|
|
def update_variables(self, variables):
|
|
if len(variables) == 0:
|
|
return
|
|
|
|
for symbol in variables:
|
|
if symbol in self.variables:
|
|
self.variables[symbol].value = float(variables[symbol])
|
|
else:
|
|
raise ValueError("Variable value must be a number.")
|
|
|
|
def get_variable_value_pairs(self):
|
|
keys = {}
|
|
|
|
for symbol in self.variables:
|
|
keys[symbol] = self.variables[symbol].value
|
|
return keys
|