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))
