class Assign:
def __init__(self):
self.id = None
self.expr = None
#Simple parsing for Assign
def parse(self):
self.id = Id()
self.id.parse(TokList.getIdOrConst())
TokList.nextToken()
TokList.match('ASSIGN', 'assign')
self.expr = Expr()
self.expr.parse()
TokList.match('SEMICOLON', 'assign')
#Simple printing for Assign
def print(self):
TokList.printIndent()
self.id.print()
print(':=', end='')
self.expr.print()
print(';')
#Executor that determines value of an expression and then sets that value to the respective Id
def exec(self):
val = self.expr.exec()
self.id.setValue(val)
def Vector(*args):
'''Create a Vector expression.'''
# if the input is a numpy array, put it into a ConstantVectorExpr
if len(args)==1:
x = args[0]
else:
x = args
if isinstance(x, ndarray):
order = len(x.shape)
if order != 1:
raise ValueError('Non-vector input [{}] to Vector()'.format(x))
if len(x) <= 1:
raise ValueError('1D input [{}] to Vector()'.format(x))
return ConstantVector(x)
# if the input is a 1D list or tuple:
# (*) Form a ConstantVectorExpr if all the elements are constants
# (*) Form a VectorExpr otherwise
if isinstance(x, (list, tuple, AggExpr)):
allConsts = True
elems = []
if len(x) == 1:
raise ValueError('Impossible to convert a 1D object to a vector')
for x_i in x:
if isinstance(x_i, Number):
elems.append(x_i)
elif isinstance(x_i, Expr):
if not isinstance(x_i.shape(), ScalarShape):
raise ValueError('Vector() element not scalar: [{}]'.format(x_i))
if not x_i.isConstant():
allConsts = False
elems.append(x_i)
else:
elems.append(Expr._convertToExpr(x_i.data()))
else:
raise ValueError('Vector() input neither number nor expr: [{}]'.format(x_i))
if allConsts:
return ConstantVectorExpr(array(elems))
else:
exprElems = []
for e in elems:
exprElems.append(Expr._convertToExpr(e))
return AggedVectorExpr(exprElems)
# If the input is a tensor, this won't work
if isinstance(x, Expr) and isinstance(x.shape(), TensorShape):
raise ValueError('impossible to convert a tensor to a vector')
# If the input is a scalar, this won't work
if isinstance(x, Expr) and isinstance(x.shape(), ScalarShape):
raise ValueError('pointless to convert a scalar to a vector')
# Don't know what this input is
raise ValueError('bad input {} to Vector()')
def __init__(self, name, arg):
assert (Expr._convertibleToExpr(arg))
expr = Expr._convertToExpr(arg)
if not isinstance(expr.shape(), ScalarShape):
raise ValueError(
'UnivariateFuncExpr ctor: non-scalar arg [{}]'.format(expr))
super().__init__(expr, expr.shape())
self._name = name
def parse(self):
self.id = Id()
self.id.parse(TokList.getIdOrConst())
TokList.nextToken()
TokList.match('ASSIGN', 'assign')
self.expr = Expr()
self.expr.parse()
TokList.match('SEMICOLON', 'assign')
def parse(self):
self.const = Const()
self.const.parse(TokList.getIdOrConst())
TokList.nextToken()
if TokList.currentToken() == 'COMMA':
self.constList = ConstList()
self.constList.parse()
TokList.match('COLON', 'case line')
self.expr = Expr()
self.expr.parse()
self.caseLineFollow = CaseLineFollow()
self.caseLineFollow.parse()
def test_AggIter(self):
x = Coordinate(0)
a = np.array([1, 2, 3])
a2 = Expr._convertToExpr(a)
c = 1
c2 = Expr._convertToExpr(c)
L = AggExpr(c, x, a)
tup = (c2, x, a2)
same = True
for e1, e2 in zip(L, tup):
same = same and (e1.sameas(e2))
assert (same)
def parse(self):
TokList.match('CASE','case')
self.id = Id()
self.id.parse(TokList.getIdOrConst())
TokList.nextToken()
TokList.match('OF','case')
self.case_line = CaseLine()
self.case_line.parse()
TokList.match('ELSE','case')
self.expr = Expr()
self.expr.parse()
TokList.match('END','case')
TokList.match('SEMICOLON','case')
def __init__(self, dir, name=None):
super().__init__()
self._dir = dir
if name == None:
self._name = Expr._dirName(dir)
else:
self._name = name
def parse(self):
self.leftExpr = Expr()
self.leftExpr.parse()
if TokList.checkTok('EQUAL'):
self.checkValue = '='
TokList.nextToken()
elif TokList.checkTok('LESSTHAN'):
self.checkValue = '<'
TokList.nextToken()
elif TokList.checkTok('LESSTHANEQUAL'):
self.checkValue = '<='
TokList.nextToken()
else:
print('Error: improper syntax for comparator')
exit()
self.rightExpr = Expr()
self.rightExpr.parse()
def __call__(self, arg):
# Make sure the type makes sense
if not Expr._convertibleToExpr(arg):
raise TypeError('diff op [{}] cannot accept type [{}]'.format(
self, arg))
f = Expr._convertToExpr(arg)
# Make sure the operator and input are consistent
if not self.acceptShape(f.shape()):
raise TypeError('diff op [{}] cannot accept argument [{}]'.format(
self, f))
# Form the diff op expression
if isinstance(f, SymbolicFunctionBase):
return DiffOpOnFunction(self, f)
return DiffOp(self, f)
def init_deklarator(self, inherited_type):
curr_line = self.lines._iter
pprint("# init_deklarator")
pprint(self.lines.get_line())
if self.check_expressions(["<izravni_deklarator>"]):
tmp = self.izravni_deklarator(inherited_type)
if self.terminate: return tmp
expr, num = tmp
if expr.is_const:
return self.parse_error(curr_line)
elif self.check_expressions(["<izravni_deklarator>", "OP_PRIDRUZI", "<inicijalizator>"]):
global currLabel
tmp = self.izravni_deklarator(inherited_type)
if self.terminate: return tmp
expr, num = tmp
self.assert_leaf("OP_PRIDRUZI")
tmp = self.inicijalizator()
outputCode.addCommandToFunction(currFunction, 'LOAD {}, ({})'.format('R' + str(currRegister), currLabel))
currLabel = None
if self.terminate: return tmp
expr2, num2 = tmp
if not expr.is_array and not expr2.is_function:
if not expr == expr2:
return self.parse_error(curr_line)
if not expr.is_array and expr2.is_function:
if not expr == expr2.get_return_type():
return self.parse_error(curr_line)
elif expr.is_array:
if not num >= num2:
return self.parse_error(curr_line)
if type(expr2) is list:
_expr = Expr(expr)
_expr.is_array = False
for e in expr2:
if not e == _expr:
return self.parse_error(curr_line)
else:
if not expr2 == expr:
return self.parse_error(curr_line)
else:
return self.parse_error(curr_line)
class Case:
def __init__(self):
self.case_line = None
self.expr = None
self.id = None
#Simple parse of the case statement
def parse(self):
TokList.match('CASE','case')
self.id = Id()
self.id.parse(TokList.getIdOrConst())
TokList.nextToken()
TokList.match('OF','case')
self.case_line = CaseLine()
self.case_line.parse()
TokList.match('ELSE','case')
self.expr = Expr()
self.expr.parse()
TokList.match('END','case')
TokList.match('SEMICOLON','case')
#Printing with proper indentation manipulation and new line printings
def print(self):
TokList.printIndent()
print('case ', end='')
self.id.print()
print(' of')
TokList.increaseIndent()
TokList.printIndent()
self.case_line.print()
#Necessary for new line printings
print()
TokList.printIndent()
print('else ', end='')
self.expr.print()
print()
TokList.decreaseIndent()
TokList.printIndent()
print('end;')
#Recursive execution based on values in the case line. Id value is passed in to all versions of case
def exec(self):
if not (self.case_line.exec(self.id)):
self.id.setValue(self.expr.exec())
class Out:
def __init__(self):
self.expr = None
#Simple parsing for output statement
def parse(self):
TokList.match('OUTPUT', 'output')
self.expr = Expr()
self.expr.parse()
TokList.match('SEMICOLON', 'output')
#Simple printing
def print(self):
TokList.printIndent()
print('output ', end='')
self.expr.print()
print(';')
#Execution that prints the values returned by the expression evaluation
def exec(self):
print(self.expr.exec())
def init_deklarator(self, inherited_type):
curr_line = self.lines._iter
pprint("# init_deklarator")
pprint(self.lines.get_line())
if self.check_expressions(["<izravni_deklarator>"]):
tmp = self.izravni_deklarator(inherited_type)
if self.terminate: return tmp
expr, num = tmp
if expr.is_const:
return self.parse_error(curr_line)
elif self.check_expressions(["<izravni_deklarator>", "OP_PRIDRUZI", "<inicijalizator>"]):
tmp = self.izravni_deklarator(inherited_type)
if self.terminate: return tmp
expr, num = tmp
self.assert_leaf("OP_PRIDRUZI")
tmp = self.inicijalizator()
if self.terminate: return tmp
expr2, num2 = tmp
if not expr.is_array and not expr2.is_function:
if not expr == expr2:
return self.parse_error(curr_line)
if not expr.is_array and expr2.is_function:
if not expr == expr2.get_return_type():
return self.parse_error(curr_line)
elif expr.is_array:
if not num >= num2:
return self.parse_error(curr_line)
if type(expr2) is list:
_expr = Expr(expr)
_expr.is_array = False
for e in expr2:
if not e == _expr:
return self.parse_error(curr_line)
else:
if not expr2 == expr:
return self.parse_error(curr_line)
else:
return self.parse_error(curr_line)
class TestExpr(unittest.TestCase):
expr = None
expressions = lambda: (
('2 + 3', '5'),
('2 - 3', '-1'),
('2 * 3', '6'),
('4 / 2', '2.0'),
('2 + 3 * 4', '14'),
('2 + 3 * 4 + 5', '19'),
('4 + 2 * 5 / 2 - 6', '3.0'),
('4 / 2 * 2 + 9 - 1', '12.0')
)
def setUp(self):
self.expr = Expr()
def tearDown(self):
self.expr = None
@data_provider(expressions)
def test_expr_eval_string(self, expr, expected):
self.assertEqual(self.expr.eval_string(expr), expected + '\n', 'expr=' + expr)
class CaseLine:
def __init__(self):
self.const = None
self.constList = None
self.expr = None
self.caseLineFollow = None
#Parsing for CaseLine based on the homework
def parse(self):
self.const = Const()
self.const.parse(TokList.getIdOrConst())
TokList.nextToken()
if TokList.currentToken() == 'COMMA':
self.constList = ConstList()
self.constList.parse()
TokList.match('COLON', 'case line')
self.expr = Expr()
self.expr.parse()
self.caseLineFollow = CaseLineFollow()
self.caseLineFollow.parse()
#Simple printing
def print(self):
self.const.print()
if self.constList is not None:
self.constList.print()
print(':', end='')
self.expr.print()
self.caseLineFollow.print()
#Exectuion that returns a boolean based on idValue and constants given
def exec(self, caseId):
if self.const.exec() == caseId.getValue():
caseId.setValue(self.expr.exec())
return True
if self.constList is not None:
if self.constList.exec(caseId):
caseId.setValue(self.expr.exec())
return True
if self.caseLineFollow.exec(caseId):
return True
return False
__author__ = 'srtoosnye'
# -*- coding: utf-8 -*-
from Expr import Expr
from calculate import calculate
import data
import sys
conn = data.link_to_mysql()
cursor = conn.cursor()
data.create_table(cursor)
expr = raw_input('请输入表达式：')
if data.is_used_data(cursor, expr):
sys.exit()
s = Expr(expr)
s.check_value()
s.opt_value()
data.store_result(cursor, calculate(s.get_postfix()), expr)
conn.commit()
conn.close()
def parse(self):
TokList.match('OUTPUT', 'output')
self.expr = Expr()
self.expr.parse()
TokList.match('SEMICOLON', 'output')
def print_ast(self, expression: Expr.Expr):
return expression.accept(self)
def AstPrinter(top_token:Expr.Expr):
display = top_token.accept(PrintVisitor())
print(display)
def evaluate(self, expr: Expr.Expr) -> object:
""" Evaluates the value of an expression """
return expr.accept(self)
def evaluate(self, client: Expr.Expr) -> object:
return client.accept(self)
def evaluate(self, expr : Expr.Expr):
return expr.accept(self)
# License: MIT
import sys
from Expr import Expr
if __name__ == '__main__':
expr = Expr()
if len(sys.argv) > 1:
print(expr.eval_file(sys.argv[1]))
else:
print(expr.eval_string(sys.stdin.readline()))
class Cmpr:
def __init__(self):
self.rightExpr = None
self.leftExpr = None
self.checkValue = None
#Parsing to determine kind of comparator. Checks for middle comparison while returning an error if none are given.
def parse(self):
self.leftExpr = Expr()
self.leftExpr.parse()
if TokList.checkTok('EQUAL'):
self.checkValue = '='
TokList.nextToken()
elif TokList.checkTok('LESSTHAN'):
self.checkValue = '<'
TokList.nextToken()
elif TokList.checkTok('LESSTHANEQUAL'):
self.checkValue = '<='
TokList.nextToken()
else:
print('Error: improper syntax for comparator')
exit()
self.rightExpr = Expr()
self.rightExpr.parse()
#Simple printing
def print(self):
self.leftExpr.print()
print(self.checkValue, end='')
self.rightExpr.print()
#Executor based on results gained while parsing
def exec(self):
if self.checkValue == '=':
return self.leftExpr.exec() == self.rightExpr.exec()
elif self.checkValue == '<':
return self.leftExpr.exec() < self.rightExpr.exec()
elif self.checkValue == '<=':
return self.leftExpr.exec() <= self.rightExpr.exec()
def postfiks_izraz(self):
curr_line = self.lines._iter
pprint("# postfiks_izraz")
pprint(self.lines.get_line())
if self.check_expressions(["<postfiks_izraz>", "L_UGL_ZAGRADA", "<izraz>", "D_UGL_ZAGRADA"]):
expr = self.postfiks_izraz()
_expr = Expr(expr)
if not _expr.is_array:
return self.parse_error(curr_line)
## We are accessing an element of this array so the return type is not array
_expr.is_array = False
self.assert_leaf("L_UGL_ZAGRADA")
if not self.izraz() == Expr("INT"):
return self.parse_error(curr_line)
self.assert_leaf("D_UGL_ZAGRADA")
if _expr.is_const:
return _expr
else:
return _expr.set_to_lexpr()
elif self.check_expressions(["<postfiks_izraz>", "L_ZAGRADA", "D_ZAGRADA"]):
expr = self.postfiks_izraz()
self.assert_leaf("L_ZAGRADA")
self.assert_leaf("D_ZAGRADA")
if not expr.is_function or not expr.is_function_from([Expr("VOID")]):
return self.parse_error(curr_line)
ret = expr.get_return_type()
if len(ret) != 1:
raise Exception("This should not happen")
else:
return ret[0]
elif self.check_expressions(["<postfiks_izraz>", "L_ZAGRADA", "<lista_argumenata>", "D_ZAGRADA"]):
expr = self.postfiks_izraz()
self.assert_leaf("L_ZAGRADA")
expr2 = self.lista_argumenata()
self.assert_leaf("D_ZAGRADA")
if not expr.is_function or not expr.is_function_from(expr2):
return self.parse_error(curr_line)
ret = expr.get_return_type()
if len(ret) != 1:
raise Exception("This should not happen")
else:
return ret[0]
elif self.check_expressions(["<postfiks_izraz>", "OP_INC"]):
expr = self.postfiks_izraz()
self.assert_leaf("OP_INC")
if not expr.is_lexpr or not expr == Expr("INT"):
return self.parse_error(curr_line)
else:
return Expr("INT")
elif self.check_expressions(["<postfiks_izraz>", "OP_DEC"]):
expr = self.postfiks_izraz()
self.assert_leaf("OP_DEC")
if not expr.is_lexpr or not expr == Expr("INT"):
return self.parse_error(curr_line)
else:
return Expr("INT")
elif self.check_expressions(["<primarni_izraz>"]):
return self.primarni_izraz()
else:
return self.parse_error(curr_line)
def setUp(self):
self.expr = Expr()
def __init__(self, name):
Expr.__init__(self, name)
def print(self, expr: Expr.Expr) -> str:
return expr.accept(self)
