示例#1
0
def p_expression_bool_arithmetic(p):
    """numeric_expression : expression LSUM expression
                  | expression LMUL expression
                  | expression XOR expression"""
    if VariableType.can_cast(p[1].type, VariableType.type_float, False) or \
            VariableType.can_cast(p[3].type, VariableType.type_float, False):
        errors.append('Cannot perform logic operations on float values, line {0}'.format(p.lineno(2)))
    p[0] = Node(p, [p[1], Leaf(p, 2), p[3]],
                type=copy.deepcopy(p[1].type) if VariableType.can_cast(p[1].type, VariableType.type_hex) else copy.deepcopy(p[3].type))
    expr_temp_var = bytecode_state.reserve_var()
    p[0].type.var_name = expr_temp_var
    bytecode_state.code += '{0} := {1} {2} {3}\n'.format(expr_temp_var, p[1].type.var_name, p[2],
                                                         p[3].type.var_name)
示例#2
0
def p_if_statement(p):
    """if_statement : IF expression enter_if COLON true_branch false_branch
                    | IF expression enter_if COLON true_branch"""
    if not VariableType.can_cast(VariableType.get_type(p[2], defined_vars), VariableType.type_bool):
        errors.append('Expression must be boolean, line {0}'.format(p.lineno(1)))
    p[0] = Node(p, [Leaf(p, 1), p[2], Leaf(p, 4), p[5]])
    if len(p) == 7:
        p[0].children.append(p[6])
    bytecode_state.code += bytecode_state.condition_stack.pop().label_end + ':\n'
示例#3
0
def p_for_cond(p):
    """for_cond : expression
                | empty"""
    if p.slice[1].type == 'expression':
        if not VariableType.can_cast(p[1].type, VariableType.type_bool):
            errors.append('Conditional part of for statement should be of bool type, line {0}'.format(p.lineno(1)))
    p[0] = Node(p, [p[1]], type=p[1].type)
    bytecode_state.code += 'iffalse {0} goto {1}\n'.format(bytecode_state.last_var(),
                                                           bytecode_state.current_loop().label_end)
示例#4
0
def p_expression_arithmetic_operations(p):
    """numeric_expression : expression PLUS expression
                  | expression MINUS expression
                  | expression MULTIPLY expression
                  | expression DIVIDE expression
                  | MINUS expression %prec UMINUS"""
    expr_temp_var = bytecode_state.reserve_var()
    if len(p) > 3:
        if not (VariableType.can_cast(VariableType.get_type(p[1], defined_vars), VariableType.type_binary)
                and VariableType.can_cast(VariableType.get_type(p[3], defined_vars), VariableType.type_binary)):
            errors.append(
                'Cannot perform \'{0}\' operation for non-numeric types at line {1}'.format(p[2], p.lineno(2)))
        p[0] = Node(p, [p[1], Leaf(p, 2), p[3]], type=copy.deepcopy(VariableType.get_type(p[1], defined_vars)))
        bytecode_state.code += '{0} := {1} {2} {3}\n'.format(expr_temp_var, p[1].type.var_name, p[2],
                                                             p[3].type.var_name)
    else:
        if not (VariableType.can_cast(VariableType.get_type(p[2], defined_vars), VariableType.type_binary)):
            errors.append('Cannot perform unary minus at line {0}'.format(p.lineno(1)))
        p[0] = Node(p, [Leaf(p, 1), p[2]], type=copy.deepcopy(VariableType.get_type(p[1], defined_vars)))
        bytecode_state.code += '{0} := {1}{2}\n'.format(expr_temp_var, p[1], p[2].type.var_name)
    p[0].type.var_name = expr_temp_var
示例#5
0
def p_expression_comparison_operations(p):
    """expression : expression LESS expression
                  | expression GREATER expression
                  | expression GREQUALS expression
                  | expression LSEQUALS expression
                  | expression NOTEQUALS expression
                  | expression EQUALS expression"""
    if not VariableType.can_cast(VariableType.get_type(p[1], defined_vars), VariableType.get_type(p[3], defined_vars)):
        errors.append('Cannot perform \'{0}\' operation on different types at line {1}'.format(p[2], p.lineno(2)))
    p[0] = Node(p, [p[1], Leaf(p, 2), p[3]],
                type=VariableType(VariableType.type_bool, var_name=bytecode_state.reserve_var()))
    bytecode_state.code += '{0} := {1} {2} {3}\n'.format(p[0].type.var_name, p[1].type.var_name, p[2],
                                                         p[3].type.var_name)
示例#6
0
def p_dowhile_statement(p):
    'dowhile_statement : DO loop_enter compound_statement WHILE dowhile_condition loop_leave'
    if not VariableType.can_cast(VariableType.get_type(p[5], defined_vars), VariableType.type_bool):
        errors.append('Expression mus be boolean, line {0}'.format(p.lineno(3)))
    p[0] = Node(p, [Leaf(p, 1), p[3], Leaf(p, 4), p[5]])