def eval(self, node, builder=None):
if builder is None:
builder = self.builder
statement = Node("statement")
node.children.extend([statement, Node(";")])
return self.statement.eval(statement, builder=builder)
def eval(self, node):
expression = Node("expression")
node.children.extend([Node("Not"), expression])
self.value = self.value.eval(expression)
if isinstance(self.value, bool):
return not bool(self.value)
raise LogicError("Cannot 'not' that")
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
expression = Node("expression")
node.children.extend([Node("("), expression, Node(")")])
return self.expression.eval(expression, builder=builder)
def program_statement_program(state, p):
if self.syntax is True:
return [Node("statement_full", p[0]), Node("program", p[1])]
return Program(p[0],
p[1],
state,
builder=self.builder,
module=self.module)
def args_expr(state, p):
if p[0].gettokentype() == 'INT':
if self.syntax is True:
return [Node('INT'), Node("arg", p[1])]
else:
if self.syntax is True:
return [Node('FLT'), Node("arg", p[1])]
return Arg(p[0].getstr(), p[1], state, self.builder, self.module)
def args_expr_args(state, p):
if self.syntax is True:
return [
Node("arg_call", p[0]),
Node(','),
Node("args_call", p[2])
]
return ArgsCall(p[0], p[2], state, self.builder, self.module)
def eval(self, node):
identifier = Node(self.name)
node.children.extend([
Node("FUNCTION"), identifier,
Node("{"),
Node("block"),
Node("}")
])
return self
def expression_absolute(state, p):
if self.syntax is True:
return [
Node("TAN"),
Node("("),
Node("expression", p[2]),
Node(")")
]
return Tan(p[2], state)
def program(state, p):
if self.syntax is True:
return [
Node("PRINT"),
Node("("),
Node("expression", p[2]),
Node(")")
]
return Print(expression=p[2], state=state)
def expression_absolute(state, p):
if self.syntax is True:
return [
Node("ABSOLUTE"),
Node("("),
Node("expression", p[2]),
Node(")")
]
return Absolute(p[2], state)
def program(state, p):
if self.syntax is True:
return [
Node("CONSOLE_INPUT"),
Node("("),
Node("expression", p[2]),
Node(")")
]
return Input(expression=p[2], state=state)
def statement_assignment(state, p):
if self.syntax is True:
return [
Node("LET"),
Node("IDENTIFIER", p[1]),
Node("="),
Node("expression", p[3])
]
return Assignment(Variable(p[1].getstr(), state), p[3], state)
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
expression = Node("expression")
node.children.extend([Node("Not"), expression])
self.value = self.value.eval(expression, builder=builder)
i = builder.not_(self.value)
return i
def eval(self, node):
node.children.extend([Node("PRINT"), Node("(")])
if self.value is None:
print()
else:
expression = Node("expression")
node.children.extend([expression])
print(self.value.eval(expression))
node.children.extend([Node(")")])
def eval(self, node):
identifier = Node("IDENTIFIER")
node.children.extend([identifier])
if dict(self.state.variables).get(self.name) is not None:
self.value = self.state.variables[self.name]
identifier.children.extend([Node(self.name, [Node(self.value)])])
return self.value
identifier.children.extend(
[Node("Variable <%s> is not yet defined" % str(self.name))])
raise LogicError("Variable <%s> is not yet defined" % str(self.name))
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
identifier = Node(self.name + " ( )")
node.children.extend([identifier])
args_eval = self.args.eval(Node('args_call'), builder=builder)
res = builder.call(fnctns[self.name], args_eval)
return res
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
statement = Node('expression', self.statement)
node.children.extend([Node("RETURN"), Node('('), statement, Node(')')])
if self.statement is None:
builder.ret_void()
else:
builder.ret(self.statement.eval(statement, builder=builder))
def eval(self, node):
import re as regex
expression = Node("expression")
node.children.extend([Node("TAN"), Node("("), expression, Node(")")])
self.value = self.expression.eval(expression)
if regex.search('^-?\d+(\.\d+)?$', str(self.value)):
import math
self.value = round(math.tan(self.value), self.roundOffDigits)
return self.value
else:
raise ValueError("Cannot tan() not numerical values !")
def eval(self, node):
for i, statement in enumerate(self.args):
left = Node('arg')
right = Node('args')
if i == len(self.args) - 1:
node.children.extend([left])
else:
node.children.extend([left, right])
node = right
return self.args
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
left = Node("expression")
right = Node("expression")
node.children.extend([left, Node("or"), right])
left_eval = self.left.eval(left, builder=builder)
right_eval = self.right.eval(right, builder=builder)
i = builder.or_(left_eval, right_eval)
return i
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
right = Node("expression")
node.children.extend([Node("-"), right])
eval_right = self.value.eval(right, builder=builder)
if eval_right.type == ir.FloatType():
i = builder.fsub(ir.Constant(ir.FloatType(), 0.0), eval_right)
else:
i = builder.mul(ir.Constant(ir.IntType(32), -1), eval_right)
return i
def statement_return(state, p):
if self.syntax is True:
return [
Node("RETURN", p[0]),
Node('('),
Node('expression', p[2]),
Node(')')
]
return Return(self.builder,
self.module,
statement=p[2],
state=state)
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
expression = Node("expression")
expression2 = Node("expression")
# node.children.extend([Node("CALLSUBF"), Node("("), expression, Node(","), expression2, Node(")")])
self.value = self.expression.eval(expression, builder=builder)
self.value2 = self.expression2.eval(expression2, builder=builder)
res = builder.call(fnctns['subf'], (self.value, self.value2))
return res
def program(state, p):
if self.syntax is True:
return [
Node("PRINT"),
Node("("),
Node("expression", p[2]),
Node(")")
]
return Print(self.builder,
self.module,
self.printf,
expression=p[2],
state=state)
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
left = Node("expression")
right = Node("expression")
node.children.extend([left, Node("<="), right])
eval_left = self.left.eval(left, builder=builder)
eval_right = self.right.eval(right, builder=builder)
if eval_left.type == ir.FloatType():
i = builder.fcmp_ordered('<=', eval_left, eval_right)
else:
i = builder.icmp_signed('<=', eval_left, eval_right)
return i
def eval(self, node, builder=None):
if builder is None:
builder = self.builder
left = Node("expression")
right = Node("expression")
# node.children.extend([left, Node("+"), right])
eval_left = self.left.eval(left, builder=builder)
eval_right = self.right.eval(right, builder=builder)
if eval_left.type == ir.FloatType():
i = builder.fadd(eval_left, eval_right)
else:
i = builder.add(eval_left, eval_right)
return i
def expression_call(state, p):
if p[2] == ')':
if self.syntax is True:
return [
Node("IDENTIFIER", p[0]),
Node("("),
Node("args_call", p[2]),
Node(")")
]
return CallFunction(name=p[0].getstr(),
args=None,
state=state,
builder=self.builder,
module=self.module)
else:
if self.syntax is True:
return [
Node("IDENTIFIER", p[0]),
Node("("),
Node("args_call", p[2]),
Node(")")
]
return CallFunction(name=p[0].getstr(),
args=p[2],
state=state,
builder=self.builder,
module=self.module)
def statement_assignment(state, p):
if self.syntax is True:
return [
Node("IDENTIFIER", p[0]),
Node("="),
Node("expression", p[2])
]
return Assignment(Variable(p[0].getstr(), state, self.builder,
self.module),
p[2],
state,
self.builder,
self.module,
new=False)
def eval(self, node):
node.children.extend([Node("CONSOLE_INPUT"), Node("(")])
if self.value is None:
result = input()
else:
expression = Node("expression")
node.children.extend([expression])
result = input(self.value.eval(expression))
node.children.extend([Node(")")])
import re as regex
if regex.search('^-?\d+(\.\d+)?$', str(result)):
return float(result)
else:
return str(result)
def eval(self, node):
import re as regex
expression = Node("expression")
node.children.extend(
[Node("ABSOLUTE"),
Node("("), expression,
Node(")"),
Node(";")])
self.value = self.expression.eval(expression)
if regex.search('^-?\d+(\.\d+)?$', str(self.value)):
self.value = abs(self.value)
return self.value
else:
raise ValueError("Cannot abs() not numerical values !")
