def test_boolean_op_or(self):
node = Node(vtype=v.OR, children=[self.int_node_zero, self.int_node_neg_one])
backend.walk_ast(node)
eq_(node.syn_value, True)
node = Node(vtype=v.OR, children=[self.int_node_zero, self.int_node_zero])
backend.walk_ast(node)
eq_(node.syn_value, False)
def test_assignment(self):
x_node = Node(vtype=v.IDENTIFIER, symbol='x')
val_node = self.int_node_two
assignment_node = Node(vtype=v.ASSIGNMENT, children=[x_node, val_node])
backend.walk_ast(assignment_node)
symbol_record = backend.scopes[-1][x_node.symbol]
eq_(symbol_record, val_node)
def test_assignment(self):
x_node = Node(vtype=v.IDENTIFIER, symbol='x')
val_node = self.int_node_two
assignment_node = Node(vtype=v.ASSIGNMENT, children=[x_node, val_node])
backend.walk_ast(assignment_node)
symbol_record = backend.scopes[-1][x_node.symbol]
eq_(symbol_record, val_node)
def main():
if len(sys.argv) != 2:
print 'Invalid number of arguments: <mongoose> <mongoose src code>'
exit(1)
src = open(sys.argv[1])
backend.walk_ast(parser.parse(src.read()))
backend.run()
def main():
if len(sys.argv) != 2:
print 'Invalid number of arguments: <mongoose> <mongoose src code>'
exit(1)
src = open(sys.argv[1])
backend.walk_ast(parser.parse(src.read()))
backend.run()
def test_boolean_op_or(self):
node = Node(vtype=v.OR,
children=[self.int_node_zero, self.int_node_neg_one])
backend.walk_ast(node)
eq_(node.syn_value, True)
node = Node(vtype=v.OR,
children=[self.int_node_zero, self.int_node_zero])
backend.walk_ast(node)
eq_(node.syn_value, False)
def test_int_add(self):
int_node_add = Node(vtype=v.ADD,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_add)
eq_(int_node_add.syn_value, 3)
int_node_neg_two = Node(vtype=v.ADD,
children=[self.int_node_neg_one, self.int_node_neg_one])
int_node_neg_four = Node(vtype=v.ADD,
children=[int_node_neg_two, int_node_neg_two])
int_node_four = Node(vtype=v.ADD,
children=[self.int_node_two, self.int_node_two])
int_node_result = Node(vtype=v.ADD,
children=[int_node_four, int_node_neg_four])
backend.walk_ast(int_node_result)
eq_(int_node_result.syn_value, 0)
def test_int_add(self):
int_node_add = Node(vtype=v.ADD,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_add)
eq_(int_node_add.syn_value, 3)
int_node_neg_two = Node(
vtype=v.ADD,
children=[self.int_node_neg_one, self.int_node_neg_one])
int_node_neg_four = Node(vtype=v.ADD,
children=[int_node_neg_two, int_node_neg_two])
int_node_four = Node(vtype=v.ADD,
children=[self.int_node_two, self.int_node_two])
int_node_result = Node(vtype=v.ADD,
children=[int_node_four, int_node_neg_four])
backend.walk_ast(int_node_result)
eq_(int_node_result.syn_value, 0)
def execute_pif(self, prob=-1):
if prob == -1:
prob = random.uniform(0, 1)
if not self.expression:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
return
if self.expression.syn_value > prob:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
elif self.next_conditional:
self.next_conditional.execute_pif(prob - self.expression.syn_value)
def execute_pif(self, prob=-1):
if prob == -1:
prob = random.uniform(0, 1)
if not self.expression:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
return
if self.expression.syn_value > prob:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
elif self.next_conditional:
self.next_conditional.execute_pif(prob - self.expression.syn_value)
def execute_while(self):
if not self.expression:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
return
backend.walk_ast(self.expression)
expr = self.expression.syn_value
while expr:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
backend.walk_ast(self.expression)
expr = self.expression.syn_value
def execute_while(self):
if not self.expression:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
return
backend.walk_ast(self.expression)
expr = self.expression.syn_value
while expr:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
backend.walk_ast(self.expression)
expr = self.expression.syn_value
def execute_if(self):
if not self.expression:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
return
for child in self.expression.children:
backend.walk_ast(child)
backend.walk_ast(self.expression)
if self.expression.syn_value:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
elif self.next_conditional:
self.next_conditional.execute_if()
def execute_if(self):
if not self.expression:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
return
for child in self.expression.children:
backend.walk_ast(child)
backend.walk_ast(self.expression)
if self.expression.syn_value:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
elif self.next_conditional:
self.next_conditional.execute_if()
def test_boolean_op_not(self):
node = Node(vtype=v.NOT, children=[self.int_node_zero])
backend.walk_ast(node)
eq_(node.syn_value, True)
node = Node(vtype=v.NOT, children=[self.string_node_empty])
backend.walk_ast(node)
eq_(node.syn_value, True)
node = Node(vtype=v.NOT, children=[self.float_node_neg_one])
backend.walk_ast(node)
eq_(node.syn_value, False)
def test_boolean_op_not(self):
node = Node(vtype=v.NOT, children=[self.int_node_zero])
backend.walk_ast(node)
eq_(node.syn_value, True)
node = Node(vtype=v.NOT, children=[self.string_node_empty])
backend.walk_ast(node)
eq_(node.syn_value, True)
node = Node(vtype=v.NOT, children=[self.float_node_neg_one])
backend.walk_ast(node)
eq_(node.syn_value, False)
def execute_repeat(self):
if not self.expression:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
return
backend.walk_ast(self.expression)
if self.expression.syn_vtype != v.INTEGER_VALUE:
raise TypeError, "Expression in repeat statement has to be of type int"
for i in xrange(self.expression.syn_value):
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
def execute_repeat(self):
if not self.expression:
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
return
backend.walk_ast(self.expression)
if self.expression.syn_vtype != v.INTEGER_VALUE:
raise TypeError, "Expression in repeat statement has to be of type int"
for i in xrange(self.expression.syn_value):
backend.scopes.append({})
backend.walk_ast(self.statements)
backend.scopes.pop()
def test_int_subtract(self):
int_node_subtract = Node(
vtype=v.SUBTRACT, children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_subtract)
eq_(int_node_subtract.syn_value, -1)
def test_ints_equal(self):
int_node_equal = Node(vtype=v.EQUAL,
children=[self.int_node_one, self.int_node_one])
backend.walk_ast(int_node_equal)
eq_(int_node_equal.syn_value, True)
def test_int_greater_than_equal(self):
int_node_greater_than_equal = Node(vtype=v.GREATER_THAN_EQUAL,
children=[self.int_node_one, self.int_node_one])
backend.walk_ast(int_node_greater_than_equal)
eq_(int_node_greater_than_equal.syn_value, True)
def test_int_less_than_equal(self):
int_node_less_than_equal = Node(vtype=v.LESS_THAN_EQUAL,
children=[self.int_node_one, self.int_node_one])
backend.walk_ast(int_node_less_than_equal)
eq_(int_node_less_than_equal.syn_value, True)
def test_int_modulus(self):
int_node_modulus = Node(vtype=v.MODULUS,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_modulus)
eq_(int_node_modulus.syn_value, 1)
def test_int_divide(self):
int_node_divide = Node(vtype=v.DIVIDE,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_divide)
eq_(int_node_divide.syn_value, 0)
def test_int_less_than_equal(self):
int_node_less_than_equal = Node(
vtype=v.LESS_THAN_EQUAL,
children=[self.int_node_one, self.int_node_one])
backend.walk_ast(int_node_less_than_equal)
eq_(int_node_less_than_equal.syn_value, True)
def test_int_power(self):
int_node_power = Node(vtype=v.POWER,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_power)
eq_(int_node_power.syn_value, 1)
def test_int_greater_than(self):
int_node_greater_than = Node(
vtype=v.GREATER_THAN,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_greater_than)
eq_(int_node_greater_than.syn_value, False)
def execute(self, *args):
backend.scopes.append(self._bind_params(*args))
backend.walk_ast(self.statements)
r = backend.walk_ast(self.return_value)
backend.scopes.pop()
return r
def test_int_subtract(self):
int_node_subtract = Node(vtype=v.SUBTRACT,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_subtract)
eq_(int_node_subtract.syn_value, -1)
def test_boolean_op_and_no_args(self):
node = Node(vtype=v.AND, children=[])
backend.walk_ast(node)
def test_int_multiply(self):
int_node_multiply = Node(vtype=v.MULTIPLY,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_multiply)
eq_(int_node_multiply.syn_value, 2)
def test_boolean_op_and_no_args(self):
node = Node(vtype=v.AND, children=[])
backend.walk_ast(node)
def test_int_power(self):
int_node_power = Node(vtype=v.POWER,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_power)
eq_(int_node_power.syn_value, 1)
def test_boolean_op_and_one_arg(self):
node = Node(vtype=v.AND, children=[self.float_node_one])
backend.walk_ast(node)
def test_int_less_than(self):
int_node_less_than = Node(vtype=v.LESS_THAN,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_less_than)
eq_(int_node_less_than.syn_value, True)
def test_boolean_op_and_one_arg(self):
node = Node(vtype=v.AND, children=[self.float_node_one])
backend.walk_ast(node)
def test_int_greater_than(self):
int_node_greater_than = Node(vtype=v.GREATER_THAN,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_greater_than)
eq_(int_node_greater_than.syn_value, False)
def test_int_less_than(self):
int_node_less_than = Node(
vtype=v.LESS_THAN, children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_less_than)
eq_(int_node_less_than.syn_value, True)
def test_ints_equal(self):
int_node_equal = Node(vtype=v.EQUAL,
children=[self.int_node_one, self.int_node_one])
backend.walk_ast(int_node_equal)
eq_(int_node_equal.syn_value, True)
def test_int_multiply(self):
int_node_multiply = Node(
vtype=v.MULTIPLY, children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_multiply)
eq_(int_node_multiply.syn_value, 2)
def test_int_divide(self):
int_node_divide = Node(vtype=v.DIVIDE,
children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_divide)
eq_(int_node_divide.syn_value, 0)
def test_int_greater_than_equal(self):
int_node_greater_than_equal = Node(
vtype=v.GREATER_THAN_EQUAL,
children=[self.int_node_one, self.int_node_one])
backend.walk_ast(int_node_greater_than_equal)
eq_(int_node_greater_than_equal.syn_value, True)
def test_float_bool_incomparable_equal(self):
equal_node = Node(vtype=v.EQUAL, children=[self.float_node_one, self.bool_node_true])
backend.walk_ast(equal_node)
def test_int_modulus(self):
int_node_modulus = Node(
vtype=v.MODULUS, children=[self.int_node_one, self.int_node_two])
backend.walk_ast(int_node_modulus)
eq_(int_node_modulus.syn_value, 1)
def execute(self, *args):
backend.scopes.append(self._bind_params(*args))
backend.walk_ast(self.statements)
r = backend.walk_ast(self.return_value)
backend.scopes.pop()
return r
def test_float_bool_incomparable_equal(self):
equal_node = Node(vtype=v.EQUAL,
children=[self.float_node_one, self.bool_node_true])
backend.walk_ast(equal_node)
