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 __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.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 __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]])
