def index_constant(self, c: CConstBase) -> int: # TBF if c.is_int(): def f_int(index: int, key: Tuple[str, str]) -> CConstInt: return CConstInt(self, index, c.tags, c.args) return self.constant_table.add(IT.get_key(c.tags, c.args), f_int) if c.is_str(): args = [self.index_string(cast(CConstStr, c).get_string())] def f_str(index: int, key: Tuple[str, str]) -> CConstStr: return CConstStr(self, index, c.tags, args) return self.constant_table.add(IT.get_key(c.tags, c.args), f_str) if c.is_chr(): def f_chr(index: int, key: Tuple[str, str]) -> CConstChr: return CConstChr(self, index, c.tags, c.args) return self.constant_table.add(IT.get_key(c.tags, c.args), f_chr) if c.is_real(): def f_real(index: int, key: Tuple[str, str]) -> CConstReal: return CConstReal(self, index, c.tags, c.args) return self.constant_table.add(IT.get_key(c.tags, c.args), f_real) raise Exception('No case yet for const "' + str(c) + '"')
def index_init(self, init, fid=-1): try: if init.is_single(): tags = ['single'] args = [self.dictionary.index_exp(init.get_exp())] def f(index, key): return CI.CSingleInitInfo(self, index, tags, args) return self.initinfo_table.add(IT.get_key(tags, args), f) if init.is_compound(): tags = ['compound'] gtype = self.dictionary.index_typ(init.get_typ()) oinits = [ self.index_offset_init(x) for x in init.get_offset_initializers() ] args = [gtype] + oinits def f(index, key): return CI.CCompoundInitInfo(self, index, tags, args) return self.initinfo_table.add(IT.get_key(tags, args), f) raise InvalidArgumentError('indexinit: ' + str(init)) except IndexedTableError as e: print('Error in indexing ' + str(init) + ': ' + str(e))
def __init__(self, fdecls): self.fdecls = fdecls self.cfun = self.fdecls.cfun self.cfile = self.cfun.cfile self.xd = CFunXprDictionary(self) self.memory_base_table = IT.IndexedTable("memory-base-table") self.memory_reference_data_table = IT.IndexedTable( "memory-reference-data-table" ) self.constant_value_variable_table = IT.IndexedTable( "constant-value-variable-table" ) self.c_variable_denotation_table = IT.IndexedTable( "c-variable-denotation-table" ) self.tables = [ (self.memory_base_table, self._read_xml_memory_base_table), ( self.memory_reference_data_table, self._read_xml_memory_reference_data_table, ), ( self.constant_value_variable_table, self._read_xml_constant_value_variable_table, ), ( self.c_variable_denotation_table, self._read_xml_c_variable_denotation_table, ), ]
def parse_mathml_api_parameter(self, name: str, pars: Dict[str, int], gvars: List[str] = []) -> int: if (name not in pars) and (name not in gvars): raise Exception("Error in reading user data: " + name + " in file " + self.cfile.name) if name in pars: tags = ["pf"] args = [pars[name]] def f_formal(index: int, key: object) -> AP.APFormal: return AP.APFormal(self, index, tags, args) return self.api_parameter_table.add(IT.get_key(tags, args), f_formal) if name in gvars: tags = ["pg", name] args = [] def f_global(index: int, key: object) -> AP.APGlobal: return AP.APGlobal(self, index, tags, args) return self.api_parameter_table.add(IT.get_key(tags, args), f_global) raise Exception("Api parameter name " + name + " not found in parameters or global variables")
def index_offset(self, o: COffsetBase, fid: int = -1) -> int: if not o.has_offset(): def f_no_offset(index: int, key: Tuple[str, str]) -> CNoOffset: return CNoOffset(self, index, o.tags, o.args) return self.offset_table.add(IT.get_key(o.tags, o.args), f_no_offset) if o.is_field(): ckey = self.convert_ckey(cast(CFieldOffset, o).get_ckey(), cast(Any, o.cd).cfile.index) args = [ckey, self.index_offset(cast(CFieldOffset, o).get_offset(), fid)] def f_field(index: int, key: Tuple[str, str]) -> CFieldOffset: return CFieldOffset(self, index, o.tags, args) return self.offset_table.add(IT.get_key(o.tags, args), f_field) if o.is_index(): args = [ self.index_exp(cast(CIndexOffset, o).get_index_exp()), self.index_offset(cast(CIndexOffset, o).get_offset(), fid), ] def f_index(index: int, key: Tuple[str, str]) -> CIndexOffset: return CIndexOffset(self, index, o.tags, args) return self.offset_table.add(IT.get_key(o.tags, args), f_index) raise UF.CHError("cdict: no case yet for " + str(o))
def parse_mathml_offset(self, tnode): if tnode is None: tags = ['no'] def f(index, key): return ST.STArgNoOffset(self, index, tags, []) return self.s_offset_table.add(IT.get_key(tags, []), f) elif tnode.tag == 'field': offsetnode = tnode[0] if len(tnode) > 0 else None tags = ['fo', tnode.get('name')] args = [self.parse_mathml_offset(offsetnode)] def f(index, key): return ST.STArgFieldOffset(self, index, tags, args) return self.s_offset_table.add(IT.get_key(tags, args), f) elif tnode.tag == 'index': offsetnode = tnode[0] if len(tnode) > 0 else None tags = ['io', tnode.get('i')] args = [self.parse_mathml_offset(offsetnode)] def f(index, key): return ST.STArgIndexOffset(self, index, tags, args) return self.s_offset_table.add(IT.get_key(tags, args), f) else: print('Encountered index offset') exit(1)
def index_s_offset(self, t: SOffset) -> int: if t.is_nooffset(): def f_nooffset(index: int, key: object) -> STArgNoOffset: return STArgNoOffset(self, index, t.tags, t.args) return self.s_offset_table.add(IT.get_key(t.tags, t.args), f_nooffset) if t.is_field_offset(): args = [ self.index_s_offset(cast(STArgFieldOffset, t).get_offset()) ] def f_fieldoffset(index: int, key: object) -> STArgFieldOffset: return STArgFieldOffset(self, index, t.tags, args) return self.s_offset_table.add(IT.get_key(t.tags, args), f_fieldoffset) if t.is_index_offset(): def f_indexoffset(index: int, key: object) -> STArgIndexOffset: return STArgIndexOffset(self, index, t.tags, t.args) return self.s_offset_table.add(IT.get_key(t.tags, t.args), f_indexoffset) raise Exception('Unknown variant of SOffset: "' + str(t) + '"')
def index_xpredicate(self, p, subst={}): def gett(t): return self.dictionary.s_term_to_exp_index(t, subst=subst) if p.is_not_null(): args = [gett(p.get_term())] tags = ['nn'] def f(index, key): return PO.CPONotNull(self, index, tags, args) return self.po_predicate_table.add(IT.get_key(tags, args), f) if p.is_relational_expr(): expsubst = {} for name in subst: expix = self.dictionary.varinfo_to_exp_index(subst[name]) expsubst[name] = self.dictionary.get_exp(expix) expix = self.dictionary.s_term_bool_expr_to_exp_index( p.get_op(), p.get_term1(), p.get_term2(), expsubst) args = [expix] tags = ['vc'] def f(index, key): return PO.CPOValueConstraint(self, index, tags, args) return self.po_predicate_table.add(IT.get_key(tags, args), f) print('Index xpredicate missing: ' + str(p)) exit(1)
def parse_mathml_offset(self, tnode): if tnode is None: tags = ["no"] def f(index, key): return ST.STArgNoOffset(self, index, tags, []) return self.s_offset_table.add(IT.get_key(tags, []), f) elif tnode.tag == "field": offsetnode = tnode[0] if len(tnode) > 0 else None tags = ["fo", tnode.get("name")] args = [self.parse_mathml_offset(offsetnode)] def f(index, key): return ST.STArgFieldOffset(self, index, tags, args) return self.s_offset_table.add(IT.get_key(tags, args), f) elif tnode.tag == "index": offsetnode = tnode[0] if len(tnode) > 0 else None tags = ["io", tnode.get("i")] args = [self.parse_mathml_offset(offsetnode)] def f(index, key): return ST.STArgIndexOffset(self, index, tags, args) return self.s_offset_table.add(IT.get_key(tags, args), f) else: print("Encountered index offset") exit(1)
def index_lhost(self,h,subst={},fid=-1): if h.is_var(): args = [ self.index_varinfo_vid(h.get_vid(),fid) ] def f(index,key): return CH.CLHostVar(self,index,h.tags,args) return self.lhost_table.add(IT.get_key(h.tags,args),f) if h.is_mem(): args = [ self.index_exp(h.get_exp(),subst=subst,fid=fid) ] def f(index,key): return CH.CLHostMem(self,index,h.tags,args) return self.lhost_table.add(IT.get_key(h.tags,args),f)
def __init__(self, cfile): self.cfile = cfile self.nodetable = IT.IndexedTable('nodes') self.cfgtable = IT.IndexedTable('cfg-contexts') self.exptable = IT.IndexedTable('exp-contexts') self.contexttable = IT.IndexedTable('contexts') self.tables = [(self.nodetable, self._read_xml_node_table), (self.cfgtable, self._read_xml_cfg_table), (self.exptable, self._read_xml_exp_table), (self.contexttable, self._read_xml_context_table)] self.initialize()
def __init__(self, cfile): self.cfile = cfile self.declarations = self.cfile.declarations self.dictionary = self.declarations.dictionary self.assignment_table = IT.IndexedTable("assignment-table") self.function_name_table = IT.IndexedTable("function-name-table") self.tables = [ (self.function_name_table, self._read_xml_function_name_table), (self.assignment_table, self._read_xml_assignment_table), ] self.initialize()
def __init__(self, cfun): self.cfun = cfun self.pd = self.cfun.cfile.predicatedictionary self.assumption_type_table = IT.IndexedTable('assumption-table') self.ppo_type_table = IT.IndexedTable('ppo-type-table') self.spo_type_table = IT.IndexedTable('spo-type-table') self.tables = [(self.assumption_type_table, self._read_xml_assumption_type_table), (self.ppo_type_table, self._read_xml_ppo_type_table), (self.spo_type_table, self._read_xml_spo_type_table)] self.initialize()
def index_attrparam(self,a): if a.is_int(): def f(index,key): return CA.CAttrInt(self,index,a.tags,a.args) return self.attrparam_table.add(IT.get_key(a.tags,a.args),f) if a.is_str(): def f(index,key): return CA.CAttrStr(self,index,a.tags,a.args) return self.attrparam_table.add(IT.get_key(a.tags,a.args),f) if a.is_cons(): args = [ self.index_attrparam(p) for p in a.get_params() ] def f(index,key): return CA.CAttrCons(self,index,a.tags,args) return self.attrparam_table.add(IT.get_key(a.tags,a.args),f) print('No case yet for attrparam ' + str(a))
def __init__(self, capp: "CApplication") -> None: # Basic types dictionary CDeclarations.__init__(self, CGlobalDictionary(self)) self.capp = capp # Global definitions and declarations dictionary self.fieldinfo_table: IndexedTable[CFieldInfo] = IndexedTable( "fieldinfo-table") self.compinfo_table: IndexedTable[CCompInfo] = IndexedTable( "compinfo-table") self.varinfo_table: IndexedTable[CVarInfo] = IT.IndexedTable( "varinfo-table") self.initinfo_table: IndexedTable[CInitInfoBase] = IT.IndexedTable( "initinfo-table") self.offset_init_table: IndexedTable[ COffsetInitInfo] = IT.IndexedTable("offset-init-table") self.tables: List[Tuple[IndexedTableSuperclass, Callable[[ET.Element], None]]] = [ (self.fieldinfo_table, self._read_xml_fieldinfo_table), (self.compinfo_table, self._read_xml_compinfo_table), (self.initinfo_table, self._read_xml_initinfo_table), (self.varinfo_table, self._read_xml_varinfo_table), (self.offset_init_table, self._read_xml_offset_init_table), ] # Collect names for compinfo equivalence classes self.compinfo_names: Dict[Any, Any] = {} # gckey -> string set # Collect storage classes for varinfo equivalence classes self.varinfo_storage_classes: Dict[Any, Any] = {} # gvid -> string # Support data structures for linker self.ckey2gckey: Dict[Any, Any] = {} # fid -> ckey -> gckey self.vid2gvid: Dict[Any, Any] = {} # fid -> vid -> gvid self.fieldstrings: Dict[Any, Any] = { } # string of joined fields -> gckey list self.pending: List[Any] = [] self.conjectured: Dict[Any, Any] = {} # ckey -> gckey self.reserved: Dict[Any, Any] = {} # ckey -> gckey self.incompatibles: Dict[Any, Any] = {} # ckey -> gckey set self.default_function_prototypes: List[Any] = [] # (fid,varinfo) list self.globalcontract = self.capp.globalcontract self._initialize() if self.compinfo_table.size() == 0: self.index_opaque_struct()
def index_api_parameter(self, p): if p.is_formal(): def f(index, key): return AP.APFormal(self, index, p.tags, p.args) return self.api_parameter_table.add(IT.get_key(p.tags, p.args), f) if c.is_global(): def f(index, key): return AP.APGlobal(self, index, p.tags, p.args) return self.api_parameter_table.add(IT.get_key(p.tags, p.args), f)
def __init__(self, cfile: "CFile"): self.cfile = cfile self.nodetable: IT.IndexedTable[CContextNode] = IT.IndexedTable("nodes") self.cfgtable: IT.IndexedTable[CfgContext] = IT.IndexedTable("cfg-contexts") self.exptable: IT.IndexedTable[ExpContext] = IT.IndexedTable("exp-contexts") self.contexttable: IT.IndexedTable[CProgramContext] = IT.IndexedTable("contexts") self.tables: List[Tuple[IT.IndexedTableSuperclass, Callable[[ET.Element], None]]] = [ (self.nodetable, self._read_xml_node_table), (self.cfgtable, self._read_xml_cfg_table), (self.exptable, self._read_xml_exp_table), (self.contexttable, self._read_xml_context_table), ] self.initialize()
def __init__(self, vard): self.vard = vard self.cfun = self.vard.cfun self.xd = self.vard.xd self.non_relational_value_table = IT.IndexedTable( 'non-relational-value-table') self.invariant_fact_table = IT.IndexedTable('invariant-fact-table') self.invariant_list_table = IT.IndexedTable('invariant-list-table') self.tables = [(self.non_relational_value_table, self._read_xml_non_relational_value_table), (self.invariant_fact_table, self._read_xml_invariant_fact_table)] self.initialize()
def index_offset(self,o,fid=-1): if not o.has_offset(): def f(index,key): return CO.CNoOffset(self,index,o.tags,o.args) return self.offset_table.add(IT.get_key(o.tags,o.args),f) if o.is_field(): ckey = self.convert_ckey(o.get_ckey(),o.cd.cfile.index) args = [ ckey, self.index_offset(o.get_offset(),fid) ] def f(index,key): return CO.CFieldOffset(self,index,o.tags,args) return self.offset_table.add(IT.get_key(o.tags,args),f) if o.is_index(): args = [ self.index_exp(o.get_index_exp()), self.index_offset(o.get_offset(),fid) ] def f(index,key): return CO.CIndexOffset(self,index,o.tags,args) return self.offset_table.add(IT.get_key(o.tags,args),f)
def __init__(self, cfile: "CFile") -> None: self.cfile = cfile CDeclarations.__init__(self, CFileDictionary(self)) self.cfile = cfile # Basic types dictionary # File definitions and declarations self.gtypes: Dict[Any, Any] = {} # name -> CGType self.gcomptagdefs: Dict[Any, Any] = {} # key -> CGCompTag self.gcomptagdecls: Dict[Any, Any] = {} # key -> CGCompTag self.gvardefs: Dict[int, CGVarDef] = {} # vid -> CGVarDef self.gvardecls: Dict[int, CGVarDecl] = {} # vid -> CGVarDecl self.genumtagdefs: Dict[Any, Any] = {} # ename -> CGEnumTag self.genumtagdecls: Dict[Any, Any] = {} # ename -> CGEnumTag self.gfunctions: Dict[int, CGFunction] = {} # vid -> CGFunction # File definition dictionary self.initinfo_table: IT.IndexedTable[ CI.CInitInfoBase] = IT.IndexedTable("initinfo-table") self.offset_init_table: IT.IndexedTable[ CI.COffsetInitInfo] = IT.IndexedTable("offset-init-table") self.typeinfo_table: IT.IndexedTable[CTypeInfo] = IT.IndexedTable( "typeinfo-table") self.varinfo_table: IT.IndexedTable[CVarInfo] = IT.IndexedTable( "varinfo-table") self.fieldinfo_table: IT.IndexedTable[CFieldInfo] = IT.IndexedTable( "fieldinfo-table") self.compinfo_table: IT.IndexedTable[CCompInfo] = IT.IndexedTable( "compinfo-table") self.enumitem_table: IT.IndexedTable[CEnumItem] = IT.IndexedTable( "enumitem-table") self.enuminfo_table: IT.IndexedTable[CEnumInfo] = IT.IndexedTable( "enuminfo-table") self.location_table: IT.IndexedTable[CLocation] = IT.IndexedTable( "location-table") self.filename_table = SI.StringIndexedTable("filename-table") self.dictionary_tables: List[Tuple[IT.IndexedTableSuperclass, Callable[ [ET.Element], None]]] = [ (self.location_table, self._read_xml_location_table), (self.initinfo_table, self._read_xml_initinfo_table), (self.offset_init_table, self._read_xml_offset_init_table), (self.typeinfo_table, self._read_xml_typeinfo_table), (self.varinfo_table, self._read_xml_varinfo_table), (self.fieldinfo_table, self._read_xml_fieldinfo_table), (self.compinfo_table, self._read_xml_compinfo_table), (self.enumitem_table, self._read_xml_enumitem_table), (self.enuminfo_table, self._read_xml_enuminfo_table), ] self.string_tables: List[Tuple[IT.IndexedTableSuperclass, Callable[[ET.Element], None]]] = [ (self.filename_table, self._read_xml_filename_table) ] self.initialize()
def __init__(self, cfile): self.cfile = cfile self.dictionary = self.cfile.declarations.dictionary self.po_predicate_table = IT.IndexedTable('po-predicate-table') self.tables = [(self.po_predicate_table, self._read_xml_po_predicate_table)] self.initialize()
def index_lhost(self, h: CLHostBase, subst: Dict[Any, Any] = {}, fid: int = -1) -> int: if h.is_var(): args = [self.index_varinfo_vid(cast(CLHostVar, h).get_vid(), fid)] def f_clhostvar(index: int, key: object) -> CLHostVar: return CLHostVar(self, index, h.tags, args) return self.lhost_table.add(IT.get_key(h.tags, args), f_clhostvar) if h.is_mem(): args = [self.index_exp(cast(CLHostMem, h).get_exp(), subst=subst, fid=fid)] def f(index: int, key: object) -> CLHostMem: return CLHostMem(self, index, h.tags, args) return self.lhost_table.add(IT.get_key(h.tags, args), f) raise Exception("Unknown type of lhost: \"" + str(h) + "\"")
def index_attributes(self, aa: CAttributes) -> int: args = [self.index_attribute(a) for a in aa.get_attributes()] def f(index: int, key: Tuple[str, str]) -> CAttributes: return CAttributes(self, index, aa.tags, args) return self.attributes_table.add(IT.get_key(aa.tags, aa.args), f)
def index_attribute(self, a: CAttribute) -> int: args = [self.index_attrparam(p) for p in a.get_params()] def f(index: int, key: Tuple[str, str]) -> CAttribute: return CAttribute(self, index, a.tags, args) return self.attribute_table.add(IT.get_key(a.tags, a.args), f)
def index_exp_context(self, expcontext: ExpContext) -> int: args = [self.index_node(x) for x in expcontext.get_nodes()] def f(index: int, key: object) -> ExpContext: return ExpContext(self, index, [], args) return self.exptable.add(IT.get_key([], args), f)
def index_cfg_context(self, cfgcontext): args = [self.index_node(x) for x in cfgcontext.get_nodes()] def f(index, key): return CCfgContext(self, index, [], args) return self.cfgtable.add(IT.get_key([], args), f)
def index_exp_context(self, expcontext): args = [self.index_node(x) for x in expcontext.get_nodes()] def f(index, key): return CExpContext(self, index, [], args) return self.exptable.add(IT.get_key([], args), f)
def index_cfg_context(self, cfgcontext: CfgContext) -> int: args = [self.index_node(x) for x in cfgcontext.get_nodes()] def f(index: int, key: object) -> CfgContext: return CfgContext(self, index, [], args) return self.cfgtable.add(IT.get_key([], args), f)
def index_lhost_offset(self, lhost, offset): args = [lhost, offset] def f(index, key): return CV.CLval(self, index, [], args) return self.lval_table.add(IT.get_key([], args), f)
def index_constant(self,c): # TBF if c.is_int(): def f(index,key): return CC.CConstInt(self,index,c.tags,c.args) return self.constant_table.add(IT.get_key(c.tags,c.args),f) if c.is_str(): args = [ self.index_string(c.get_string()) ] def f(index,key): return CC.CConstStr(self,index,c.tags,args) return self.constant_table.add(IT.get_key(c.tags,args),f) if c.is_chr(): def f(index,key): return CC.CConstChr(self,index,c.tags,c.args) return self.constant_table.add(IT.get_key(c.tags,c.args),f) if c.is_real(): def f(index,key): return CC.CConstReal(self,index,c.tags,c.args) return self.constant_table.add(IT.get_key(c.tags,c.args),f) else: print('This constant not yet handled ' + str(c))