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)
