Module Lang

module Lang: sig .. end
Logic Language based on Qed

val basename : string -> string -> string
val avoid_leading_backlash : string -> string
val comp_id : Cil_types.compinfo -> string
val field_id : Cil_types.fieldinfo -> string
val type_id : Cil_types.logic_type_info -> string
val logic_id : Cil_types.logic_info -> string
val ctor_id : Cil_types.logic_ctor_info -> string
val lemma_id : string -> string
type theory = string 
type adt = 
| Mtype of mdt (*External type*)
| Mrecord of mdt * fields (*External record-type*)
| Atype of Cil_types.logic_type_info (*Logic Type*)
| Comp of Cil_types.compinfo (*C-code struct or union*)
type mdt = {
   mdt_link :string;
   mdt_theory :theory;
}
type fields = {
   mutable fields :field list;
}
type field = 
| Mfield of mdt * fields * string * tau
| Cfield of Cil_types.fieldinfo
type tau = (field, adt) Qed.Logic.datatype 
val pointer : (Cil_types.typ -> tau) Context.value
type of pointers
val sort_of_object : Ctypes.c_object -> Qed.Logic.sort
val sort_of_ctype : Cil_types.typ -> Qed.Logic.sort
val sort_of_ltype : Cil_types.logic_type -> Qed.Logic.sort
val tau_of_comp : Cil_types.compinfo -> ('a, adt) Qed.Logic.datatype
val array : ('a, 'b) Qed.Logic.datatype -> ('a, 'b) Qed.Logic.datatype
val farray : ('a, 'b) Qed.Logic.datatype ->
('a, 'b) Qed.Logic.datatype -> ('a, 'b) Qed.Logic.datatype
val tau_of_object : Ctypes.c_object -> tau
val tau_of_ctype : Cil_types.typ -> tau
val poly : string list Context.value
polymorphism
val varpoly : int -> string -> string list -> int
val builtins : (string, mdt) Hashtbl.t
val tau_of_ltype : Cil_types.logic_type -> tau
val tau_of_return : Cil_types.logic_info -> tau
module ADT: sig .. end
val atype : Cil_types.logic_type_info -> adt
val builtin : name:string -> link:string -> theory:theory -> unit
val datatype : link:string -> theory:theory -> adt
val record : link:string -> theory:theory -> (string * tau) list -> adt
val field : adt -> string -> field
val comp : Cil_types.compinfo -> adt
val fields_of_tau : ('a, adt) Qed.Logic.datatype -> field list
val fields_of_field : field -> field list
val tau_of_field : field -> tau
val tau_of_record : field -> ('a, adt) Qed.Logic.datatype
module Field: sig .. end
type scope = 
| External of string
| Generated
type lfun = 
| Function of scope * Qed.Engine.link * lfun Qed.Logic.category * Qed.Logic.sort
| Predicate of scope * string * string
| ACSL of Cil_types.logic_info
| CTOR of Cil_types.logic_ctor_info
val tau_of_lfun : lfun -> tau
type balance = 
| Nary
| Left
| Right
val symbolf : scope:scope ->
?balance:balance ->
?category:lfun Qed.Logic.category ->
?sort:Qed.Logic.sort ->
('a, Format.formatter, unit, lfun) Pervasives.format4 -> 'a
val extern_s : theory:string ->
?balance:balance ->
?category:lfun Qed.Logic.category ->
?sort:Qed.Logic.sort -> string -> lfun
val extern_f : theory:string ->
?balance:balance ->
?category:lfun Qed.Logic.category ->
?sort:Qed.Logic.sort ->
('a, Format.formatter, unit, lfun) Pervasives.format4 -> 'a
val extern_p : theory:string -> prop:string -> bool:string -> lfun
val extern_fp : theory:string -> string -> lfun
val generated_f : ?category:lfun Qed.Logic.category ->
?sort:Qed.Logic.sort ->
('a, Format.formatter, unit, lfun) Pervasives.format4 -> 'a
val generated_p : string -> lfun
module Fun: sig .. end
val link : Qed.Engine.cmode -> lfun -> Qed.Engine.link
val theory : lfun -> string
module F: sig .. end
type gamma = {
   mutable hyps :F.pred list;
   mutable vars :F.var list;
}
val cpool : F.pool Context.value
val cgamma : gamma Context.value
val apool : F.pool option -> F.pool
val agamma : gamma option -> gamma
val new_pool : ?copy:F.pool -> unit -> F.pool
val new_gamma : ?copy:gamma -> unit -> gamma
val get_pool : unit -> F.pool
val get_gamma : unit -> gamma
val freshvar : ?basename:string -> F.tau -> F.var
val freshen : F.var -> F.var
val local : ?pool:F.pool -> ?gamma:gamma -> ('a -> 'b) -> 'a -> 'b
val assume : F.term -> unit
val epsilon : ?basename:string -> F.tau -> (F.term -> F.pred) -> F.term
val hypotheses : gamma -> F.pred list
val variables : gamma -> F.var list
val get_hypotheses : unit -> F.pred list
val get_variables : unit -> F.var list
module Alpha: sig .. end