A |
a_fun [WpPropId] |
TODO: it seems that this type is not used anymore...
|
a_kind [WpPropId] |
|
abstract [Formula.S] |
|
abstract [Fol_formula] |
|
alloc [Hoare_mem.Create] |
|
alloc [Store_mem.Create] |
|
allocator [LogicId] |
|
alpha [Formula.S] |
Maping from old var to new var
|
alpha [Fol_formula] |
|
annot_kind [WpStrategy] |
An annotation can be used for different purpose.
|
annots [WpStrategy] |
Some elements can be used as both Hyp and Goal : because of the selection
mecanism, we need to add a boolean as_goal to tell if the element is to be
considered as a goal.
|
annots_tbl [WpStrategy] |
|
array [Formula.S] |
|
array [Fol_formula] |
|
arrayflat [Ctypes] |
Array objects, with both the head view and the flatten view.
|
arrayinfo [Ctypes] |
|
asked_assigns [WpAnnot] |
|
asked_bhv [WpAnnot] |
|
asked_prop [WpAnnot] |
|
assignable [Store_mem.Create] |
|
assigned [Formula.S] |
|
assigned [CfgWeakestPrecondition.Create] |
|
assigned [Fol_formula] |
|
assigns [CfgWeakestPrecondition.Create] |
|
assigns_desc [WpPropId] |
|
assigns_full_info [WpPropId] |
|
assigns_info [WpPropId] |
|
assigns_kind [CfgWeakestPrecondition.Create] |
|
assigns_method [Mcfg] |
|
axiom_info [WpPropId] |
|
axiomlabel [Translate_prop.Create] |
|
B |
binder [LogicPretty] |
|
bindings [Formula.Logic] |
|
bindings [Datalib.Create] |
|
block_type [Cil2cfg] |
Be careful that only Bstmt are real Block statements
|
boolean [Formula.S] |
|
boolean [Fol_formula] |
|
byrefparam [Funvar_mem.Create] |
|
C |
c_float [Ctypes] |
Runtime floats.
|
c_int [Ctypes] |
Runtime integers.
|
c_label [Clabels] |
|
c_object [Ctypes] |
Type of variable, inits, field or assignable values.
|
call_style [LogicPretty] |
|
callenv [CfgWeakestPrecondition.Create] |
|
case [Variables_analysis] |
|
cc [Wp_error] |
|
ccitem [LogicDef.Cofix] |
|
cell [Datalib.Cvalues] |
|
closing [CfgWeakestPrecondition.Create] |
|
closure [Mlogic.S] |
|
closure [Hoare_mem.Create] |
|
closure [Store_mem.Create] |
|
closure [Runtime_mem.Create] |
|
closure [Funvar_mem.Create] |
|
cmp_op [Formula] |
|
cmp_op [LogicLang] |
|
compute_int_mode [Runtime_mem] |
|
computing_methods [Register] |
|
constant [Fol] |
|
context [Formula.Logic] |
Constrained Terms Construction
|
context [Datalib.Create] |
|
cycle [LogicDef.Cofix] |
|
D |
data [Translate_prop.Create] |
|
data [ACSL.Compiler] |
|
data [State_builder.Hashtbl] |
|
data [State_builder.Ref] |
Type of the referenced value.
|
decl [Mwp.Export] |
|
decl [Formula.S] |
|
decl [Mcfg.Export] |
|
decl [Fol_formula] |
|
decl [Fol_coq.ECoq] |
|
decl [Fol_ergo.Make] |
|
decl [Fol_why.EWhy] |
|
decl [Hoare_mem.Create] |
|
decl [Store_mem.Create] |
|
decl [Runtime_mem.Create] |
|
decl [Funvar_mem.Create] |
|
decl [Fol] |
|
declaration [Formula] |
|
declaration [LogicDef] |
|
description [Cfgpropid.Create] |
|
description [LogicDef] |
|
dnode [Cfgpropid] |
|
dzone [Mwp.S] |
|
dzone [Hoare_mem.Create] |
|
dzone [Store_mem.Create] |
|
dzone [Runtime_mem.Create] |
|
dzone [Funvar_mem.Create] |
|
E |
edge [Cil2cfg] |
abstract type of the cfg edges
|
edge_type [Cil2cfg] |
|
effect_assigns [CfgWeakestPrecondition.Create] |
|
elt [Set.S] |
The type of the set elements.
|
env [Translate_prop.Create] |
|
env [Kreal] |
|
exportation [CfgProof.Create] |
|
F |
f_let [Fol_cc] |
|
feature [Register] |
|
field [LogicTau] |
|
field_region [LogicHavoc] |
|
formal [Mlogic.S] |
|
formal [Hoare_mem.Create] |
|
formal [Store_mem.Create] |
|
formal [Runtime_mem.Create] |
|
formal [Funvar_mem.Create] |
|
formal_kind [Variables_analysis] |
|
format [Runtime_mem.Create] |
----- Formats :
|
frame [Translate_prop.Create] |
|
fun_printer [LogicPretty] |
|
G |
graph [Cil2cfg.WeiMaoZouChenInput] |
|
graph [Cil2cfg.LoopInfo] |
|
H |
havoc [Formula.S] |
|
havoc [Fol_formula] |
|
I |
id [LogicId] |
|
index_region [LogicHavoc] |
|
indice [LogicId] |
|
input [Script] |
|
int_op [Formula] |
|
integer [Formula.S] |
|
integer [Fol_formula] |
|
integer_op [LogicLang] |
|
interval [Formula.S] |
Fol data
|
interval [Fol_formula] |
|
item [Formula] |
|
item [LogicDef] |
|
J |
job [Wp_parameters] |
|
K |
key [ACSL.Compiler] |
|
key [Map.S] |
The type of the map keys.
|
key [Hashtbl.S] |
|
key [Wprop.Info] |
|
key [State_builder.Hashtbl] |
|
key [Wprop.Indexed] |
|
key1 [Wprop.Indexed2] |
|
key2 [Wprop.Indexed2] |
|
kind [Formula] |
|
kind [Translate_prop.Create] |
|
L |
label_mapping [NormAtLabels] |
|
language [Wpo] |
|
loc [Mvalues.Model] |
|
loc [Hoare_mem.Create.Model] |
|
loc [Store_mem.Create.Model] |
|
loc [Runtime_mem.Create.Model] |
|
loc [Funvar_mem.Create.Model] |
|
loc [Datalib.Cvalues] |
|
logic_model [LogicDef] |
|
lvar_kind [Translate_prop.Create] |
|
M |
m_abstract [Formula] |
Abstract Data Types (user-defined WHY-types).
|
m_addr [Runtime_mem.Create] |
Phantom types to tag the terms
|
m_alloc [Hoare_mem.Create] |
|
m_alloc [Store_mem.Create] |
|
m_alloc [Runtime_mem.Create] |
|
m_array [Formula] |
type 'a farray array.why
|
m_bits [Runtime_mem.Create] |
|
m_boolean [Formula] |
The set of two elements {true,false} .
|
m_cell [Datalib.Cvalues] |
|
m_dzone [Mwp.S] |
|
m_dzone [Hoare_mem.Create] |
|
m_dzone [Store_mem.Create] |
|
m_dzone [Runtime_mem.Create] |
|
m_dzone [Funvar_mem.Create] |
|
m_format [Runtime_mem.Create] |
|
m_integer [Formula] |
Natural signed integers (Z).
|
m_mbits [Runtime_mem.Create] |
|
m_mem [Runtime_mem.Create] |
|
m_memory [Store_mem.Create] |
|
m_name [Formula] |
type name data_lib.why
|
m_of_mem [Mvalues.Data] |
|
m_of_mem [Store_mem.Create.Data] |
|
m_of_mem [Runtime_mem.Create.Data] |
|
m_offset [Runtime_mem.Create] |
|
m_pointer [Formula] |
type pointer data_lib.why
|
m_pointer [Hoare_mem.Create] |
|
m_real [Formula] |
Real numbers (R).
|
m_record [Formula] |
type record data_lib.why
|
m_set [Formula] |
type 'a set data_lib.why
|
m_size [Runtime_mem.Create] |
|
m_urecord [Formula] |
type urecord data_lib.why
|
m_zone [Formula] |
type of elementary regions
|
m_zone [Runtime_mem.Create] |
|
mark [LogicId] |
|
mem [Mvalues.S] |
|
mem [Hoare_mem.Create] |
|
mem [Store_mem.Create] |
|
mem [Runtime_mem.Create] |
|
mem [Funvar_mem.Create] |
|
mem_alloc [Runtime_mem.Create] |
|
mem_bits [Runtime_mem.Create] |
|
model_kind [Wp_parameters] |
|
N |
name [Formula.S] |
|
name [Fol_formula] |
|
node [Cil2cfg.WeiMaoZouChenInput] |
|
node [Cil2cfg.LoopInfo] |
|
node [Cil2cfg] |
abstract type of the cfg nodes
|
node_id [Cil2cfg] |
|
node_info [Cil2cfg] |
|
node_type [Cil2cfg] |
|
norm [Wp_parameters] |
|
normalized [Fol_norm] |
|
O |
operator [LogicPretty] |
|
P |
p_select [Wp_gui] |
|
param [Hook.S] |
Type of the parameter of the functions registered in the hook.
|
path [Funvar_mem.Create.Lookup] |
|
po [Wpo] |
|
poffset [Funvar_mem.Create.Lookup] |
|
pointer [Hoare_mem.Create] |
|
pool [Formula.S] |
|
pool [LogicLang] |
|
pool [LogicRaw.VAR] |
|
pool [Fol_formula] |
|
pp [Fol_coq] |
|
pp [Fol_ergo] |
|
pp [Fol_pretty] |
|
pp_edge_fun [Cil2cfg] |
type of functions to print things related to edges
|
pp_env [Fol_coq] |
|
pp_env [Fol_ergo] |
|
pp_env [Fol_pretty] |
|
pred [Mwp.Export] |
|
pred [Formula.S] |
|
pred [Mcfg.Splitter] |
|
pred [Mcfg.Export] |
|
pred [LogicLang] |
|
pred [Fol_formula] |
|
pred [Fol_coq.ECoq] |
|
pred [Fol_ergo.Make] |
|
pred [Fol_why.EWhy] |
|
pred [Fol_split] |
|
pred [Fol] |
|
pred_info [WpPropId] |
|
primitive [LogicRaw.TERM] |
|
printer [LogicPretty] |
Suitable for %a formatter
|
printer2 [LogicPretty] |
Non-formatter usage
|
proof [WpAnnot] |
A proof accumulator for a set of related prop_id
|
proofpart [WpAnnot] |
|
prop [Register] |
|
prop_id [WpPropId] |
Property.t information and kind of PO (establishment, preservation, etc)
|
prop_kind [WpPropId] |
|
property [CfgWeakestPrecondition.Create] |
|
property [Wprop] |
|
prover [Wpo] |
Dynamically exported.
|
R |
real [Formula.S] |
|
real [Fol_formula] |
|
real_op [Formula] |
|
real_op [LogicLang] |
|
record [Formula.S] |
|
record [Fol_formula] |
|
region [LogicHavoc] |
|
registered [LogicDef] |
|
relation [LogicRaw.PRED] |
|
result [Hook.S] |
Type of the result of the functions.
|
result [Wpo] |
|
root [Funvar_mem.Create.Lookup] |
|
row [Po_navigator] |
|
S |
scope [Mcfg] |
|
section [Formula] |
|
set [Formula.S] |
|
set [Fol_formula] |
|
sigma [Fol_let] |
|
sign [Kreal] |
|
space [LogicId] |
|
st_loc [Store_mem.Create.Model] |
|
state [LogicDef.Cofix] |
|
state [Kreal] |
|
store [Store_mem.Create] |
|
strategy [Wp_gui] |
|
strategy [WpStrategy] |
|
strategy_call [Wp_gui] |
|
strategy_code [Wp_gui] |
|
strategy_for_froms [WpStrategy] |
|
strategy_info [WpAnnot] |
|
strategy_kind [WpStrategy] |
|
system [Wpo] |
|
T |
t [Formula.S.Identifiable] |
|
t [Formula.S.Registry] |
|
t [Calculus.Cfg.R] |
|
t [LogicRaw.PRED] |
|
t [LogicRaw.TERM] |
|
t [LogicRaw.VAR] |
|
t [LogicId.S] |
|
t [Fol_formula.Registry] |
|
t [Fol_formula.Identifiable] |
|
t [Fol_formula.LTinfoId] |
|
t [Fol_formula.LTinfo] |
|
t [Fol_formula.ArrayDim] |
|
t [Fol_formula.HC_ArrayDim] |
|
t [Fol_formula.Cobject] |
|
t [Fol_formula.HC_object] |
|
t [Fol_formula.Logicvar] |
|
t [Fol_formula.LTypeinfo] |
|
t [Fol_formula.Arrayinfo] |
|
t [Fol_formula.Compinfo] |
|
t [Fol_formula.Fieldinfo] |
|
t [Fol_formula.Varinfo] |
|
t [Fol_formula.DRegister] |
|
t [Runtime_mem.Create.Aint] |
|
t [Fol.Var] |
|
t [Datalib.Collector] |
|
t [Prover.SMT] |
|
t [Prover.Logs] |
|
t [Map.S] |
The type of maps from type key to type 'a .
|
t [Wpo.WPO] |
|
t [Wpo.Results] |
|
t [Hashtbl.S] |
|
t [Wpo] |
|
t [Cil2cfg.HEsig] |
|
t [Cil2cfg.Printer] |
|
t [Cil2cfg.HE] |
|
t [Set.S] |
The type of sets.
|
t [Cil2cfg.EL] |
|
t [Cil2cfg.VL] |
|
t [Cil2cfg] |
The final CFG is composed of the graph, but also :
the function that it represents,
an hashtable to find a CFG node knowing its hashcode,
and the hashcode of the start node
|
t [Ctypes.AinfoComparable] |
|
t [String] |
An alias for the type of strings.
|
t_addr [Runtime_mem.Create] |
Specialized type of F.integer terms
|
t_annots [WpStrategy] |
a set of annotations to be added to a program point.
|
t_axiom [WpPropId] |
|
t_bits [Runtime_mem.Create] |
|
t_env [Mcfg.S] |
|
t_env [CfgWeakestPrecondition.Create] |
|
t_env [Cfgpropid.Create] |
|
t_goal [Cfgpropid.Create] |
|
t_offset [Runtime_mem.Create] |
|
t_prop [Mcfg.S] |
|
t_prop [CfgWeakestPrecondition.Create] |
|
t_prop [Cfgpropid.Create] |
|
t_size [Runtime_mem.Create] |
|
t_zone [Runtime_mem.Create] |
|
tau [Formula] |
|
tau [LogicTau] |
|
tenv [Cil2cfg.WeiMaoZouChenInput] |
|
tenv [Cil2cfg.LoopInfo] |
|
term [Formula.S] |
|
term [LogicLang] |
|
term [Fol_formula] |
|
term [Fol_split] |
|
term [Fol] |
|
test_behav_res [WpAnnot] |
Tells weather the property belonging to the behaviors in bhv_name_list
has to be considered according to config .
|
ti [Cil2cfg.HEsig] |
|
ti [Cil2cfg.HE] |
|
tint [Runtime_mem.Create] |
integer terms with a phantom type to mark what kind of object it is.
|
tk [LogicId] |
|
token [Kreal] |
|
token [Script] |
|
U |
u_printer [LogicPretty] |
Suitable for %t formatter
|
urecord [Formula.S] |
|
urecord [Fol_formula] |
|
usage [Variables_analysis] |
|
user_formal [Translate_prop.Create] |
|
userdef [Translate_prop.Create] |
|
V |
value [Mvalues.Values] |
The internal representation of an ACSL value
|
value [ACSL.Register] |
|
value [Datalib.Cvalues] |
|
var [Formula.S] |
|
var [LogicLang] |
|
var [Fol_formula] |
|
var_info [Funvar_mem.Create] |
|
var_kind [Variables_analysis] |
|
var_type [Variables_analysis] |
|
vars [Funvar_mem.Create] |
|
verdict [Prover] |
|
W |
warning [Wpo] |
|
wp_model [Register] |
|
X |
x_addr [Runtime_mem.Create.Tint] |
|
x_size [Runtime_mem.Create.Tint] |
|
x_zone [Runtime_mem.Create.Tint] |
|