val initCIL : unit -> unit
val cilVersion : string
val cilVersionMajor : int
val cilVersionMinor : int
val cilVersionRevision : int
type file =
  Cil.file = {
  mutable fileName : string;
  mutable globals : global list;
  mutable globinit : fundec option;
  mutable globinitcalled : bool;
}
and comment = location * string
and global =
  Cil.global =
    GType of typeinfo * location
  | GCompTag of compinfo * location
  | GCompTagDecl of compinfo * location
  | GEnumTag of enuminfo * location
  | GEnumTagDecl of enuminfo * location
  | GVarDecl of varinfo * location
  | GVar of varinfo * initinfo * location
  | GFun of fundec * location
  | GAsm of string * location
  | GPragma of attribute * location
  | GText of string
and typ =
  Cil.typ =
    TVoid of attributes
  | TInt of ikind * attributes
  | TFloat of fkind * attributes
  | TPtr of typ * attributes
  | TArray of typ * exp option * attributes
  | TFun of typ * (string * typ * attributes) list option * bool * attributes
  | TNamed of typeinfo * attributes
  | TComp of compinfo * attributes
  | TEnum of enuminfo * attributes
  | TBuiltin_va_list of attributes
and ikind =
  Cil.ikind =
    IChar
  | ISChar
  | IUChar
  | IInt
  | IUInt
  | IShort
  | IUShort
  | ILong
  | IULong
  | ILongLong
  | IULongLong
and fkind = Cil.fkind = FFloat | FDouble | FLongDouble
and attribute = Cil.attribute = Attr of string * attrparam list
and attributes = attribute list
and attrparam =
  Cil.attrparam =
    AInt of int
  | AStr of string
  | ACons of string * attrparam list
  | ASizeOf of typ
  | ASizeOfE of attrparam
  | ASizeOfS of typsig
  | AAlignOf of typ
  | AAlignOfE of attrparam
  | AAlignOfS of typsig
  | AUnOp of unop * attrparam
  | ABinOp of binop * attrparam * attrparam
  | ADot of attrparam * string
  | AStar of attrparam
  | AAddrOf of attrparam
  | AIndex of attrparam * attrparam
  | AQuestion of attrparam * attrparam * attrparam
and compinfo =
  Cil.compinfo = {
  mutable cstruct : bool;
  mutable cname : string;
  mutable ckey : int;
  mutable cfields : fieldinfo list;
  mutable cattr : attributes;
  mutable cdefined : bool;
  mutable creferenced : bool;
}
and fieldinfo =
  Cil.fieldinfo = {
  mutable fcomp : compinfo;
  mutable fname : string;
  mutable ftype : typ;
  mutable fbitfield : int option;
  mutable fattr : attributes;
  mutable floc : location;
}
and enuminfo =
  Cil.enuminfo = {
  mutable ename : string;
  mutable eitems : (string * exp * location) list;
  mutable eattr : attributes;
  mutable ereferenced : bool;
}
and typeinfo =
  Cil.typeinfo = {
  mutable tname : string;
  mutable ttype : typ;
  mutable treferenced : bool;
}
and varinfo =
  Cil.varinfo = {
  mutable vname : string;
  mutable vtype : typ;
  mutable vattr : attributes;
  mutable vstorage : storage;
  mutable vglob : bool;
  mutable vinline : bool;
  mutable vdecl : location;
  mutable vid : int;
  mutable vaddrof : bool;
  mutable vreferenced : bool;
  mutable vdescr : Pretty.doc;
  mutable vdescrpure : bool;
}
and storage = Cil.storage = NoStorage | Static | Register | Extern
and exp =
  Cil.exp =
    Const of constant
  | Lval of lval
  | SizeOf of typ
  | SizeOfE of exp
  | SizeOfStr of string
  | AlignOf of typ
  | AlignOfE of exp
  | UnOp of unop * exp * typ
  | BinOp of binop * exp * exp * typ
  | CastE of typ * exp
  | AddrOf of lval
  | StartOf of lval
and constant =
  Cil.constant =
    CInt64 of int64 * ikind * string option
  | CStr of string
  | CWStr of int64 list
  | CChr of char
  | CReal of float * fkind * string option
  | CEnum of exp * string * enuminfo
and unop = Cil.unop = Neg | BNot | LNot
and binop =
  Cil.binop =
    PlusA
  | PlusPI
  | IndexPI
  | MinusA
  | MinusPI
  | MinusPP
  | Mult
  | Div
  | Mod
  | Shiftlt
  | Shiftrt
  | Lt
  | Gt
  | Le
  | Ge
  | Eq
  | Ne
  | BAnd
  | BXor
  | BOr
  | LAnd
  | LOr
and lval = lhost * offset
and lhost = Cil.lhost = Var of varinfo | Mem of exp
and offset =
  Cil.offset =
    NoOffset
  | Field of fieldinfo * offset
  | Index of exp * offset
and init =
  Cil.init =
    SingleInit of exp
  | CompoundInit of typ * (offset * init) list
and initinfo = Cil.initinfo = { mutable init : init option; }
and fundec =
  Cil.fundec = {
  mutable svar : varinfo;
  mutable sformals : varinfo list;
  mutable slocals : varinfo list;
  mutable smaxid : int;
  mutable sbody : block;
  mutable smaxstmtid : int option;
  mutable sallstmts : stmt list;
}
and block =
  Cil.block = {
  mutable battrs : attributes;
  mutable bstmts : stmt list;
}
and stmt =
  Cil.stmt = {
  mutable labels : label list;
  mutable skind : stmtkind;
  mutable sid : int;
  mutable succs : stmt list;
  mutable preds : stmt list;
}
and label =
  Cil.label =
    Label of string * location * bool
  | Case of exp * location
  | Default of location
and stmtkind =
  Cil.stmtkind =
    Instr of instr list
  | Return of exp option * location
  | Goto of stmt ref * location
  | Break of location
  | Continue of location
  | If of exp * block * block * location
  | Switch of exp * block * stmt list * location
  | Loop of block * location * stmt option * stmt option
  | Block of block
  | TryFinally of block * block * location
  | TryExcept of block * (instr list * exp) * block * location
and instr =
  Cil.instr =
    Set of lval * exp * location
  | Call of lval option * exp * exp list * location
  | Asm of attributes * string list * (string option * string * lval) list *
      (string option * string * exp) list * string list * location
and location = Cil.location = { line : int; file : string; byte : int; }
and typsig =
  Cil.typsig =
    TSArray of typsig * int64 option * attribute list
  | TSPtr of typsig * attribute list
  | TSComp of bool * string * attribute list
  | TSFun of typsig * typsig list * bool * attribute list
  | TSEnum of string * attribute list
  | TSBase of typ
val lowerConstants : bool ref
val insertImplicitCasts : bool ref
type featureDescr =
  Cil.featureDescr = {
  fd_enabled : bool ref;
  fd_name : string;
  fd_description : string;
  fd_extraopt : (string * Arg.spec * string) list;
  fd_doit : file -> unit;
  fd_post_check : bool;
}
val compareLoc : location -> location -> int
val emptyFunction : string -> fundec
val setFormals : fundec -> varinfo list -> unit
val setFunctionType : fundec -> typ -> unit
val setFunctionTypeMakeFormals : fundec -> typ -> unit
val setMaxId : fundec -> unit
val dummyFunDec : fundec
val dummyFile : file
val saveBinaryFile : file -> string -> unit
val saveBinaryFileChannel : file -> out_channel -> unit
val loadBinaryFile : string -> file
val getGlobInit : ?main_name:string -> file -> fundec
val iterGlobals : file -> (global -> unit) -> unit
val foldGlobals : file -> ('a -> global -> 'a) -> 'a -> 'a
val mapGlobals : file -> (global -> global) -> unit
val findOrCreateFunc : file -> string -> typ -> varinfo
val new_sid : unit -> int
val prepareCFG : fundec -> unit
val computeCFGInfo : fundec -> bool -> unit
val copyFunction : fundec -> string -> fundec
val pushGlobal :
  global -> types:global list ref -> variables:global list ref -> unit
val invalidStmt : stmt
val builtinFunctions : (string, typ * typ list * bool) Hashtbl.t
val gccBuiltins : (string, typ * typ list * bool) Hashtbl.t
val msvcBuiltins : (string, typ * typ list * bool) Hashtbl.t
val builtinLoc : location
val makeZeroInit : typ -> init
val foldLeftCompound :
  implicit:bool ->
  doinit:(offset -> init -> typ -> 'a -> 'a) ->
  ct:typ -> initl:(offset * init) list -> acc:'a -> 'a
val voidType : typ
val isVoidType : typ -> bool
val isVoidPtrType : typ -> bool
val intType : typ
val uintType : typ
val longType : typ
val ulongType : typ
val charType : typ
val charPtrType : typ
val wcharKind : ikind ref
val wcharType : typ ref
val charConstPtrType : typ
val voidPtrType : typ
val intPtrType : typ
val uintPtrType : typ
val doubleType : typ
val upointType : typ ref
val typeOfSizeOf : typ ref
val kindOfSizeOf : ikind ref
val isSigned : ikind -> bool
val mkCompInfo :
  bool ->
  string ->
  (compinfo -> (string * typ * int option * attributes * location) list) ->
  attributes -> compinfo
val copyCompInfo : compinfo -> string -> compinfo
val missingFieldName : string
val compFullName : compinfo -> string
val isCompleteType : typ -> bool
val unrollType : typ -> typ
val unrollTypeDeep : typ -> typ
val separateStorageModifiers :
  attribute list -> attribute list * attribute list
val isIntegralType : typ -> bool
val isArithmeticType : typ -> bool
val isPointerType : typ -> bool
val isFunctionType : typ -> bool
val argsToList :
  (string * typ * attributes) list option -> (string * typ * attributes) list
val isArrayType : typ -> bool
exception LenOfArray
val lenOfArray : exp option -> int
val getCompField :