def __init__(self, jd, xnode):
self.jd = jd
self.symbolic_jterm_constant_table = IT.IndexedTable(
'symbolic-jterm-constant-table')
self.string_table = IT.IndexedTable('string-table')
self.numerical_table = IT.IndexedTable('numerical-table')
self.float_table = IT.IndexedTable('float-table')
self.jterm_table = IT.IndexedTable('jterm-table')
self.relational_expr_table = IT.IndexedTable('relational-expr-table')
self.jterm_list_table = IT.IndexedTable('jterm-list-table')
self.relational_expr_list_table = IT.IndexedTable(
'relational-expr-list-table')
self.jterm_range_table = IT.IndexedTable('jterm-range-table')
self.tables = [
(self.symbolic_jterm_constant_table,
self._read_xml_symbolic_jterm_constant_table),
(self.string_table, self._read_xml_string_table),
(self.numerical_table, self._read_xml_numerical_table),
(self.float_table, self._read_xml_float_table),
(self.jterm_table, self._read_xml_jterm_table),
(self.relational_expr_table, self._read_xml_relational_expr_table),
(self.jterm_list_table, self._read_xml_jterm_list_table),
(self.relational_expr_list_table,
self._read_xml_relational_expr_list_table),
(self.jterm_range_table, self._read_xml_jterm_range_table)
]
self.initialize(xnode)
def __init__(self, jclass, xnode):
self.jclass = jclass # JavaClass
self.jd = jclass.jd # DataDictionary
self.pc_list_table = IT.IndexedTable('pc-list-table')
self.slot_table = IT.IndexedTable('slot-table')
self.slot_list_table = IT.IndexedTable('slot-list-table')
self.opcode_table = IT.IndexedTable('opcode-table')
self.tables = [(self.pc_list_table, self._read_xml_pc_list_table),
(self.slot_table, self._read_xml_slot_table),
(self.slot_list_table, self._read_xml_slot_list_table),
(self.opcode_table, self._read_xml_opcode_table)]
self.initialize(xnode)
def index_float(self, v):
tags = [str(v)]
def f(index, key):
return JT.JTFloat(self, index, tags, [])
return self.float_table.add(IT.get_key(tags, []), f)
def index_numerical(self, v):
tags = [str(v)]
def f(index, key):
return JT.JTNumerical(self, index, tags, [])
return self.numerical_table.add(IT.get_key(tags, []), f)
def __init__(self,jd,xnode):
self.jd = jd
self.target_table = IT.IndexedTable('target-table')
self.tables = [
(self.target_table, self._read_xml_target_table)
]
self.initialize(xnode)
def get_value(node):
rep = IT.get_rep(node)
tag = rep[1][0]
args = (self, ) + rep
if tag in opcode_constructors:
return opcode_constructors[tag](args)
else:
return BC.BcInstruction(*args)
def index_arithmetic_jterm(self, jt1, jt2, op):
tags = ['ar', op]
args = [jt1.index, jt2.index]
def f(index, key):
return JT.JTArithmeticExpr(self, index, tags, args)
return self.jterm_table.add(IT.get_key(tags, args), f)
def index_constant_jterm(self, v):
tags = ['c']
args = [self.index_numerical(v)]
def f(index, key):
return JT.JTConstant(self, index, tags, args)
return self.jterm_table.add(IT.get_key(tags, args), f)
def index_float_constant(self, v):
tags = ['fc']
args = [self.index_float(float(v))]
def f(index, key):
return JT.JTFloatConstant(self, index, tags, args)
return self.jterm_table.add(IT.get_key(tags, args), f)
def __init__(self,jd,xnode):
self.jd = jd # DataDictionary
self.string_table = IT.IndexedTable('string-table')
self.symbol_table = IT.IndexedTable('symbol-table')
self.variable_table = IT.IndexedTable('variable-table')
self.method_target_table = IT.IndexedTable('method-target-table')
self.taint_origin_table = IT.IndexedTable('taint-origin-table')
self.taint_origin_list_table = IT.IndexedTable('taint-origin-list-table')
self.tainted_variable_table = IT.IndexedTable('tainted-variable-table')
self.tainted_variable_ids_table = IT.IndexedTable('tainted-variable-ids-table')
self.taint_node_type_table = IT.IndexedTable('taint-node-type-table')
self.tables = [
(self.string_table, self._read_xml_string_table),
(self.symbol_table, self._read_xml_symbol_table),
(self.variable_table, self._read_xml_variable_table),
(self.method_target_table, self._read_xml_method_target_table),
(self.taint_origin_table, self._read_xml_taint_origin_table),
(self.taint_origin_list_table, self._read_xml_taint_origin_list_table),
(self.tainted_variable_table, self._read_xml_tainted_variable_table),
(self.tainted_variable_ids_table, self._read_xml_tainted_variable_ids_table),
(self.taint_node_type_table, self._read_xml_taint_node_type_table)
]
self.initialize(xnode)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return T.TMethodTarget(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return T.TSymbol(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return T.TVariable(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return JT.JTRelationalExprList(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return T.TStringConstant(*args)
def get_value(node):
rep = IT.get_rep(node)
tag = rep[1][0]
args = (self,) + rep
return taint_node_type_constructors[tag](args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return JT.MethodDescriptor(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return JT.BootstrapMethodData(*args)
def __init__(self,jd,xnode):
self.jd = jd
self.string_table = IT.IndexedTable('string-table')
self.class_name_table = IT.IndexedTable('class-name-table')
self.object_type_table = IT.IndexedTable('object-type-table')
self.value_type_table = IT.IndexedTable('value-type-table')
self.method_descriptor_table = IT.IndexedTable('method-descriptor-table')
self.descriptor_table = IT.IndexedTable('descriptor-table')
self.field_signature_data_table = IT.IndexedTable('field-signature-data-table')
self.method_signature_data_table = IT.IndexedTable('method-signature-data-table')
self.class_field_signature_data_table = IT.IndexedTable('class-field-signature-data-table')
self.class_method_signature_data_table = IT.IndexedTable('class-method-signature-data-table')
self.constant_value_table = IT.IndexedTable('constant-value-table')
self.method_handle_type_table = IT.IndexedTable('method-handle-type-table')
self.constant_table = IT.IndexedTable('constant-table')
self.bootstrap_argument_table = IT.IndexedTable('bootstrap-argument-table')
self.bootstrap_method_data_table = IT.IndexedTable('bootstrap-method-data-table')
self.tables = [
(self.string_table, self._read_xml_string_table),
(self.class_name_table, self._read_xml_class_name_table),
(self.object_type_table, self._read_xml_object_type_table),
(self.value_type_table, self._read_xml_value_type_table),
(self.method_descriptor_table, self._read_xml_method_descriptor_table),
(self.descriptor_table, self._read_xml_descriptor_table),
(self.field_signature_data_table, self._read_xml_field_signature_data_table),
(self.method_signature_data_table, self._read_xml_method_signature_data_table),
(self.class_field_signature_data_table, self._read_xml_class_field_signature_data_table),
(self.class_method_signature_data_table, self._read_xml_class_method_signature_data_table),
(self.constant_value_table, self._read_xml_constant_value_table),
(self.method_handle_type_table, self._read_xml_method_handle_type_table),
(self.constant_table, self._read_xml_constant_table),
(self.bootstrap_argument_table,self._read_xml_bootstrap_argument_table),
(self.bootstrap_method_data_table, self._read_xml_bootstrap_method_data_table) ]
self.initialize(xnode)
def get_cms_index(self,tags,args):
key = IT.get_key(tags,args)
if self.class_method_signature_data_table.has_key(key):
return self.class_method_signature_data_table.get_index(key)
def get_value(node):
rep = IT.get_rep(node)
tag = rep[1][0]
args = (self,) + rep
return bootstrap_argument_constructors[tag](args)
def get_value(node):
rep = IT.get_rep(node)
tag = rep[1][0]
args = (self,) + rep
return descriptor_constructors[tag](args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return ClassMethodSignature(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return FieldSignature(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return T.TaintOriginList(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self, ) + rep
return BC.BcSlotList(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return T.TaintedVariableIds(*args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return JT.JTermRange(*args)
def get_value(node):
rep = IT.get_rep(node)
tag = rep[1][0]
args = (self,) + rep
return method_handle_type_constructors[tag](args)
def get_value(node):
rep = IT.get_rep(node)
args = (self,) + rep
return Classname(*args)
