Pml (p.goblint.1.1.1.doc.goblint.lib.Pml)

type 'a e = 'a * string

type _ t =

| Enum : 'a * ('a -> string) -> 'a t
| Chan : 'a chan -> 'a chan t
| Bool : bool -> bool t
| Byte : int -> int t
| Short : int -> int t
| Int : int -> int t
| String : string -> string t
| Void : unit t

and 'a chan = {

capacity : int e;
mutable content : 'a list;
content_type : 'a t;

}

val enums : (string, string) BatteriesExceptionless.Hashtbl.t

val of_enums : (string, int -> string option) BatteriesExceptionless.Hashtbl.t

val enum : (int -> 'a option) -> ('a -> string) -> string -> unit * string

val enum_type : string -> string option

val is_enum : string -> bool

val is_declared : 'a. 'a t -> bool

val unbox : 'a. 'a t -> string * ('a -> string) * 'a

type _ var =

| Var : {
1. name : string;
2. init : 'a t;
3. value : 'a BatteriesExceptionless.ref;
4. show : 'a -> string;
} -> ('a e * 'a e * ('a e -> unit e) * unit e) var
| Arr : {
1. name : string;
2. init : 'a t;
3. value : 'a array;
4. show : 'a -> string;
5. show_all : 'a array -> string;
6. length : int;
} -> ('a e * (int e -> 'a e) * ((int e * 'a e) -> unit e) * (int e -> unit e)) var

val var : 
  'a t ->
  string ->
  ('a e * 'a e * ('a e -> unit e) * unit e) var * string

val arr : 
  (int * string) ->
  'a t ->
  string ->
  ('a e * (int e -> 'a e) * ((int e * 'a e) -> unit e) * (int e -> unit e)) var
  * string

val var_name : 'x. 'x var -> string

val get : 'c 'g 's 'm. ('c * 'g * 's * 'm) var -> 'g

val set : 'c 'g 's 'm. ('c * 'g * 's * 'm) var -> 's

val (!) : ('a * 'b * 'c * 'd) var -> 'b

val (:=) : ('a * 'b * 'c * 'd) var -> 'c

val (@=) : ('a * 'b * 'c * 'd) var -> 'c

val _assert : (bool * string) -> unit * string

val println : ('a * string) -> unit * string

val _true : bool * string

val _false : bool * string

val wait : (bool * string) -> unit * string

val break : unit * string

val skip : unit * string

val nop : unit * string

module Chan : sig ... end

val (>>) : ('a * string) -> ('b * string) -> 'b * string

val bind : ('a * string) -> ('a -> 'b * string) -> 'b * string

val (>>=) : ('a * string) -> ('a -> 'b * string) -> 'b * string

val return : 'a -> 'a

val indent : string -> string

val surround : string -> string -> ('a * string) -> 'a * string

val _match : (('a * string) * ('b * string)) list -> unit * string

val _do : (('a * string) * ('b * string)) list -> unit * string

val _if : (('a * string) * ('b * string)) list -> unit * string

val _ifte : (bool * string) -> ('a * string) -> ('a * string) -> unit * string

val _ift : (bool * string) -> (unit * string) -> unit * string

val _for : 
  ('a e * 'a e * ('a e -> unit e) * unit e) var ->
  ('b e * (int e -> 'b e) * ((int e * 'b e) -> unit e) * (int e -> unit e)) var ->
  ('c * string) ->
  'c * string

val _foreach : 
  ('a e * (int e -> 'a e) * ((int e * 'a e) -> unit e) * (int e -> unit e)) var ->
  (int e -> 'a e -> 'b * string) ->
  'b * string

type ('a, 'b, 'c, 'd, 'e, 'z) args =

| A0 of 'z e
| A1 of 'a * 'a -> 'z e
| A2 of 'a * 'b * 'a -> 'b -> 'z e
| A3 of 'a * 'b * 'c * 'a -> 'b -> 'c -> 'z e
| A4 of 'a * 'b * 'c * 'd * 'a -> 'b -> 'c -> 'd -> 'z e
| A5 of 'a * 'b * 'c * 'd * 'e * 'a -> 'b -> 'c -> 'd -> 'e -> 'z e

module Macro : sig ... end

type eval =

| EvalEnum of int -> string option
| EvalInt
| EvalString
| EvalSkip
| AssignIdOfString of string * int

val pp_eval : 
  Ppx_deriving_runtime.Format.formatter ->
  eval ->
  Ppx_deriving_runtime.unit

val show_eval : eval -> Ppx_deriving_runtime.string

val extract_funs : (string, eval list) BatteriesExceptionless.Hashtbl.t

val special_fun : string -> eval list option

val special_funs : unit -> string list

val extract : 
  ?id:(int * int * string) ->
  string ->
  (('a e * 'a e * ('a e -> unit e) * unit e) var,
    ('b e * 'b e * ('b e -> unit e) * unit e) var,
    ('c e * 'c e * ('c e -> unit e) * unit e) var,
    ('d e * 'd e * ('d e -> unit e) * unit e) var,
    ('e e * 'e e * ('e e -> unit e) * unit e) var,
    'f)
    args ->
  unit * string

val op : 
  ('a -> 'b -> 'c) ->
  string ->
  ('a * string) ->
  ('b * string) ->
  'c * string

val (==) : ('a * string) -> ('a * string) -> bool * string

val (!=) : ('a * string) -> ('a * string) -> bool * string

val (<) : ('a * string) -> ('a * string) -> bool * string

val (>) : ('a * string) -> ('a * string) -> bool * string

val (<=) : ('a * string) -> ('a * string) -> bool * string

val (>=) : ('a * string) -> ('a * string) -> bool * string

val (+) : (int * string) -> (int * string) -> int * string

val (-) : (int * string) -> (int * string) -> int * string

val (/) : (int * string) -> (int * string) -> int * string

val (*) : (int * string) -> (int * string) -> int * string

val (&&) : (bool * string) -> (bool * string) -> bool * string

val (||) : (bool * string) -> (bool * string) -> bool * string

val i : int -> int * string

val s : 'a -> 'a * 'a

val (^) : (string * string) -> (string * string) -> string * string

val fail : (string * string) -> unit * string

val i2s : (int * 'a) -> string * 'a

val e : 'a -> ('a -> 'b) -> 'a * 'b

val e2s : ('a * 'b) -> 'b * 'b

val incr : 'g 's 'm. (int e * 'g * 's * 'm) var -> 'm

val decr : 'g 's 'm. (int e * 'g * 's * 'm) var -> 'm