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_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 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 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_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_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 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 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 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 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 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 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_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_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_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_api_parameter(self, p: ApiParameter) -> int: if p.is_formal(): def f_formal(index: int, key: object) -> APFormal: return APFormal(self, index, p.tags, p.args) return self.api_parameter_table.add(IT.get_key(p.tags, p.args), f_formal) if p.is_global(): def f_global(index: int, key: object) -> APGlobal: return APGlobal(self, index, p.tags, p.args) return self.api_parameter_table.add(IT.get_key(p.tags, p.args), f_global) raise Exception("Unknown variant of ApiParameter")
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))
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_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_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_exp(self,e,subst={},fid=-1): # TBF if e.is_constant(): args = [ self.index_constant(e.get_constant()) ] def f(index,key): return CE.CExpConst(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_sizeof(): args = [ self.index_typ(e.get_type()) ] def f(index,key): return CE.CExpSizeOf(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_sizeofe(): args = [ self.index_exp(e.get_exp(),subst=subst,fid=fid) ] def f(index,key): return CE.CExpSizeOfE(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_sizeofstr(): args = [ self.index_string(e.get_string()) ] def f(index,key): return CE.CExpSizeOfStr(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_unop(): args = [ self.index_exp(e.get_exp(),subst=subst,fid=fid), self.index_typ(e.get_type()) ] def f(index,key): return CE.CExpUnOp(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_binop(): args = [ self.index_exp(e.get_exp1(),subst=subst,fid=fid), self.index_exp(e.get_exp2(),subst=subst,fid=fid), self.index_typ(e.get_type()) ] def f(index,key): return CE.CExpBinOp(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_caste(): args = [ self.index_typ(e.get_type()), self.index_exp(e.get_exp(),subst=subst,fid=fid) ] def f(index,key): return CE.CExpCastE(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_addrof(): args = [ self.index_lval(e.get_lval(),subst=subst,fid=fid) ] def f(index,key): return CE.CExpAddrOf(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_startof(): args = [ self.index_lval(e.get_lval(),subst=subst,fid=fid) ] def f(index,key): return CE.CExpStartOf(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) if e.is_lval(): args = [ self.index_lval(e.get_lval(),subst=subst,fid=fid) ] def f(index,key): return CE.CExpLval(self,index,e.tags,args) return self.exp_table.add(IT.get_key(e.tags,args),f) print('cdict:no case yet for exp ' + str(e)) exit(1)
def index_funarg(self, funarg: CT.CFunArg) -> int: tags = ["arg"] args = [self.index_typ(funarg.get_type())] def f(index: int, key: Tuple[str, str]) -> CT.CFunArg: return CT.CFunArg(self, index, tags, args) return self.funarg_table.add(IT.get_key(tags, args), f)
def mk_lval_exp(self, lval): args = [lval] tags = ['lval'] def f(index, key): return CE.CExpLval(self, index, tags, args) return self.exp_table.add(IT.get_key(tags, args), f)
def index_funarg(self, funarg: CFunArg) -> int: tags: List[str] = [funarg.get_name()] args: List[int] = [self.index_typ(funarg.get_type())] def f(index: int, key: Tuple[str, str]) -> CFunArg: return CFunArg(self, index, tags, args) return self.funarg_table.add(IT.get_key(tags, args), f)
def make_opaque_global_varinfo(self, gvid, gname, gtypeix): tags = [gname, "o_" + str(gvid)] args = [-1, gtypeix, -1, 1, 0, -1, 1, 0] def f(index, key): return CVarInfo(self, index, tags, args) return self.varinfo_table.add(IT.get_key(tags, args), f)
def index_cfg_projection(self, context): args = [ self.index_cfg_context(context.get_cfg_context()), self.index_empty_exp_context() ] def f(index, key): return CProgramContext(self, index, [], args) return self.contexttable.add(IT.get_key([], args), f)
def index_lval(self, lval: CLval, subst: Dict[Any, Any] = {}, fid: int = -1) -> int: args = [ self.index_lhost(lval.get_lhost(), subst=subst, fid=fid), self.index_offset(lval.get_offset()), ] def f(index: int, key: object) -> CLval: return CLval(self, index, [], args) return self.lval_table.add(IT.get_key([], args), f)
def index_funargs_opt(self, opt_funargs: Optional[CFunArgs]) -> Optional[int]: if opt_funargs is None: return None tags: List[str] = [] args = [self.index_funarg(f) for f in opt_funargs.get_args()] def f(index: int, key: Tuple[str, str]) -> CFunArgs: return CFunArgs(self, index, tags, args) return self.funargs_table.add(IT.get_key(tags, args), f)