zelus 2.2 · OCaml Package

val app : Obc.exp -> Obc.exp list -> Obc.exp

val sequence : Obc.inst -> Obc.inst -> Obc.inst

val kind : Zelus.kind -> Obc.kind

Translation of the kind

val type_expression : Zelus.type_expression -> Obc.type_expression

Translating type expressions.

val type_of_type_decl : Zelus.type_decl_desc Zelus.localized -> Obc.type_decl

val constr_decl : Zelus.constr_decl -> Obc.constr_decl

val is_mutable : Deftypes.typ -> bool

val type_expression_of_typ : Deftypes.typ -> Obc.type_expression

type env = entry Zident.Env.t

and entry = {

e_typ : Deftypes.typ;
e_sort : sort;
e_size : loop_path;

}

and sort =

| In of Obc.exp
| Out of Zident.t * Deftypes.tsort

and loop_path = Zident.t list

type code = {

mem : Obc.mentry Zmisc.State.t;
init : Obc.inst;
instances : Obc.ientry Zmisc.State.t;
reset : Obc.inst;
step : Obc.inst;

}

val fprint : Format.formatter -> entry Zident.Env.t -> unit

val empty_code : code

val seq : code -> code -> code

val empty_path : 'a list

val entry_of : Zident.Env.key -> 'a Zident.Env.t -> 'a

Look for an entry in the environment

val immediate : Deftypes.immediate -> Obc.immediate

Translation of immediate values

val constant : Deftypes.constant -> Obc.exp

val state : bool -> Zident.t -> Deftypes.mkind option -> Obc.left_state_value

val index : Obc.exp -> Zident.t list -> Obc.exp

val left_value_index : Obc.left_value -> Zident.t list -> Obc.left_value

val left_state_value_index : 
  Obc.left_state_value ->
  Zident.t list ->
  Obc.left_state_value

val var : entry -> Obc.exp

val assign : entry -> Obc.exp -> Obc.inst

Make an assignment according to the sort of a variable n

val def : entry -> Obc.exp -> code -> code

Generate the code for a definition

val der : entry -> Obc.exp -> code -> code

Generate the code for der x = e

val ifthen : Obc.exp -> Obc.inst -> Obc.inst -> Obc.inst

Generate an if/then

val for_loop : bool -> Zident.t -> Obc.exp -> Obc.exp -> Obc.inst -> Obc.inst

Generate a for loop

val letpat : Obc.pattern -> Obc.exp -> code -> code

Generate the code for the definition of a value

val letvar : 
  (Zident.t * Obc.is_mutable * Deftypes.typ * Obc.exp option) list ->
  Obc.inst ->
  Obc.inst

Generate the code for initializing shared variables

val pluseq : entry -> Obc.exp -> code -> code

Compile an equation n += e

val out_of : 
  Zident.Env.key ->
  entry Zident.Env.t ->
  Zident.t * Deftypes.typ * Deftypes.tsort * loop_path

val size_of_type : Deftypes.size -> Obc.size

Translate size expressions

val size : Zelus.size -> Obc.size

Translate size expressions

val choose : 'a -> Deftypes.typ -> Obc.exp option

val default : 'a -> Deftypes.typ -> Deftypes.constant option -> Obc.exp option

Computes a default value

val append : 
  loop_path ->
  Deftypes.tentry Zident.Env.t ->
  entry Zident.Env.t ->
  entry Zident.Env.t
  * Obc.mentry Zmisc.State.t
  * (Zident.Env.key * bool * Deftypes.typ * Obc.exp option) list

Extension of an environment

val apply : 
  Deftypes.kind ->
  'a ->
  Zident.t list ->
  Obc.exp ->
  Obc.exp list ->
  code ->
  Obc.exp * code

Translation of a stateful function application f se1 ... sen e

val exp : 
  entry Zident.Env.t ->
  Zident.t list ->
  code ->
  Zelus.exp ->
  Obc.exp * code

Translation of expressions under an environment env

val pattern : Zelus.pattern -> Obc.pattern

Patterns

val equation : entry Zident.Env.t -> loop_path -> Zelus.eq -> code -> code

Equations

val equation_list : 
  entry Zident.Env.t ->
  loop_path ->
  Zelus.eq list ->
  code ->
  code

val match_handlers : 
  entry Zident.Env.t ->
  loop_path ->
  Zelus.eq list Zelus.block Zelus.match_handler list ->
  Obc.inst Obc.match_handler list * code

val local : entry Zident.Env.t -> loop_path -> Zelus.local -> Zelus.exp -> code

val block : 
  entry Zident.Env.t ->
  loop_path ->
  Zelus.eq list Zelus.block ->
  code

val add_mem_vars_to_code : 
  code ->
  Obc.mentry Zmisc.State.t ->
  (Zident.Env.key * Obc.is_mutable * Deftypes.typ * Obc.exp option) list ->
  code

val machine : 
  Obc.name ->
  Zelus.kind ->
  Obc.pattern list ->
  code ->
  Deftypes.typ ->
  Obc.implementation

val expression : entry Zident.Env.t -> Zelus.exp -> code

val implementation : 
  Zelus.implementation_desc Zelus.localized ->
  Obc.implementation

Translation of a declaration

val implementation_list : 
  Zelus.implementation_desc Zelus.localized list ->
  Obc.implementation list

package zelus