def __init__(self): VariableType.__init__(self) # self.oci_type = None self.initialize_proc = None self.finalize_proc = None # self.pre_define_proc = self.pre_define self.post_define_proc = None self.pre_fetch_proc = None self.is_null_proc = None self.set_value_proc = self.set_value self.get_value_proc = self.get_value self.get_buffer_size_proc = None self.can_be_copied = True self.can_be_in_array = True # not standard variable type self.mapping_python_type_to_method = { long: self.set_value_from_long, bool: self.set_value_from_boolean, float: self.set_value_from_float, Decimal: self.set_value_from_decimal, } if not python3_or_better(): self.mapping_python_type_to_method[int] = self.set_value_from_integer
def __init__(self): VariableType.__init__(self) #self.oci_type = None self.initialize_proc = None self.finalize_proc = None #self.pre_define_proc = self.pre_define self.post_define_proc = None self.pre_fetch_proc = None self.is_null_proc = None self.set_value_proc = self.set_value self.get_value_proc = self.get_value self.get_buffer_size_proc = None self.can_be_copied = True self.can_be_in_array = True # not standard variable type self.mapping_python_type_to_method = { long: self.set_value_from_long, bool: self.set_value_from_boolean, float: self.set_value_from_float, Decimal: self.set_value_from_decimal, } if not python3_or_better(): self.mapping_python_type_to_method[ int] = self.set_value_from_integer
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'
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)
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)
def __init__(self): VariableType.__init__(self) self.initialize_proc = None self.finalize_proc = None self.pre_define_proc = None self.post_define_proc = None self.pre_fetch_proc = None self.is_null_proc = None self.set_value_proc = self.set_value self.get_value_proc = self.get_value self.get_buffer_size_proc = self.get_buffer_size self.charset_form = oci.SQLCS_IMPLICIT self.size = 128 * 1024 self.is_variable_length = True self.can_be_copied = True self.can_be_in_array = False
def __init__(self): VariableType.__init__(self) self.initialize_proc = self.initialize self.finalize_proc = None self.pre_define_proc = None #self.post_define_proc = None self.pre_fetch_proc = None self.is_null_proc = None self.set_value_proc = self.set_value self.get_value_proc = self.get_value #self.get_buffer_size_proc = None #self.is_character_data = None #self.is_variable_length = None self.can_be_copied = True self.can_be_in_array = True
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)
def p_literals_expression(p): """letters : HCONST | BCONST | FCONST""" p[0] = Node(p, leaf=Leaf(p, 1), type=VariableType.get_type(p.slice[1].type, defined_vars)) if p.slice[1].type == 'BCONST': p[0].type.var_name = str(int(p[1], 2)) elif p.slice[1].type == 'HCONST': p[0].type.var_name = str(int(p[1], 16)) else: p[0].type.var_name = p[1]
def __init__(self): VariableType.__init__(self) self.oci_type = oci.POINTER(oci.OCIStmt) #self.initialize_proc = None #self.finalize_proc = None self.pre_define_proc = None self.post_define_proc = None self.pre_fetch_proc = None self.is_null_proc = None #self.set_value_proc = None #self.get_value_proc = None self.get_buffer_size_proc = None self.python_type = CURSOR self.oracle_type = oci.SQLT_RSET self.charset_form = oci.SQLCS_IMPLICIT self.size = ctypes.sizeof(self.oci_type) self.is_character_data = False self.is_variable_length = False self.can_be_copied = False self.can_be_in_array = False
def __init__(self): VariableType.__init__(self) self.oci_type = oci.POINTER(oci.OCIInterval) #self.initialize_proc = None #self.finalize_proc = None self.pre_define_proc = None self.post_define_proc = None self.pre_fetch_proc = None self.is_null_proc = None #self.set_value_proc = None #self.get_value_proc = None self.get_buffer_size_proc = None self.python_type = INTERVAL self.oracle_type = oci.SQLT_INTERVAL_DS self.charset_form = oci.SQLCS_IMPLICIT self.size = ctypes.sizeof(self.oci_type) self.is_character_data = False self.is_variable_length = False self.can_be_copied = True self.can_be_in_array = True self.descriptor_manager = DescriptorManager()
def __init__(self): VariableType.__init__(self) self.oci_type = oci.POINTER(oci.OCILobLocator) self.initialize_proc = self.initialize self.finalize_proc = self.finalize self.pre_define_proc = None self.post_define_proc = None self.pre_fetch_proc = self.pre_fetch self.is_null_proc = None self.set_value_proc = self.set_value self.get_value_proc = self.get_value self.get_buffer_size_proc = None #self.python_type = None #self.oracle_type = None #self.charset_form = None self.size = ctypes.sizeof(self.oci_type) #self.is_character_data = None self.is_variable_length = False self.can_be_copied = False self.can_be_in_array = False self.descriptor_manager = DescriptorManager()
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
def p_statement_assign(p): 'assign_statement : id_expression array_indexes ASSIGN expression' id_type = copy.deepcopy(p[1].type) if len(p[2].children) > (len(id_type.array_dimensions) if id_type.array_dimensions else 0): errors.append('Attempt to access too deep into array, line {0}'.format(p.lineno(3))) elif p[2].children: id_type.array_dimensions = id_type.array_dimensions[len(p[2].children):] if not id_type.can_cast(VariableType.get_type(p[4], defined_vars)): errors.append('Cannot perform \'{0}\' operation on different types at line {1}'.format(p[3], p.lineno(3))) p[0] = Node(p, [p[1], p[2], Leaf(p, 3), p[4]]) if p[2].children: array_index = calculate_index(p[2].children, p[1].type.array_dimensions) if p[4].type.array_dimensions: def get_array_elements(el): if el.expr == 'array_declare': elements = [] for c in el.children: cur_el = get_array_elements(c) if isinstance(cur_el, list): elements.extend(cur_el) else: elements.append(cur_el) return elements return el.type.var_name els = get_array_elements(p[4].children[0]) else: els = [p[4].type.var_name] for id, element in enumerate(els): bytecode_state.code += '{0}[{1}] := {2}\n'.format(p[1].type.var_name, array_index, element) if id < len(els) - 1: next_array_index = bytecode_state.reserve_var() bytecode_state.code += '{0} := {1} + 1\n'.format(next_array_index, array_index) array_index = next_array_index else: bytecode_state.code += '{0} := {1}\n'.format(p[1].type.var_name, p[4].type.var_name)
def p_id_expression(p): 'id_expression : ID' if p.slice[1].value not in defined_vars: errors.append('Attempt to use undefined variable \'{0}\' at line {1}'.format(p[1], p.lineno(1))) p[0] = Node(p, leaf=Leaf(p, 1), type=VariableType.get_type(p[1], defined_vars))
from stringvar import STRING, FIXED_CHAR, ROWID, BINARY from longvar import LONG_STRING, LONG_BINARY from datetimevar import DATETIME from lobvar import NCLOB, CLOB, BLOB, BFILE from timestampvar import TIMESTAMP from intervalvar import INTERVAL from cursorvar import CURSOR if not python3_or_better(): from stringvar import UNICODE, FIXED_UNICODE from variable_type import VariableType from custom_exceptions import NotSupportedError # TODO: Not implemented yet vt_Object = VariableType() vt_NativeFloat = VariableType() # this dict is only for debugging purposes. vt_to_name = { vt_DateTime: 'vt_DateTime', vt_Timestamp: 'vt_Timestamp', vt_Interval: 'vt_Interval', vt_BLOB :'vt_BLOB', vt_BFILE :'vt_BFILE', vt_Cursor :'vt_Cursor', vt_Object :'vt_Object', vt_NativeFloat :'vt_NativeFloat', vt_NCLOB :'vt_NCLOB', vt_CLOB: 'vt_CLOB',
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]])