package lutin

  1. Overview
  2. Docs

EXPANSION : main

------------------------------------------------------------

L'expansion consiste essentiellement à construire 3 tables globales indexées par des ident target :

  • Table des variables (support) : elle contient les entrées/sorties et les locales (cf. exist) remontées au top via un nommage unique.
  • Table des alias : associe à des idents cible des expressions algébriques. Les idents cible correpondent au instances de macros utilisées dans le corps du node.
  • Table des traces : à chaque trace nommée est associée une expression de trace expansée.
  • Table des fonctions externes utilisees, pour + tard

----------------------------------------------------------

Les paramètres de l'expansion sont : -------------------------------------------------------

  • Le CheckEnv.t qui résulte du type/binding check. Il permet de retrouver le type effectif (sémantique) de toute expression source et l'info associée à toute instance d'identificateur. -------------------------------------------------------
  • Le code source (type Syntaxe.package) -------------------------------------------------------
  • Le node "main" (string) -------------------------------------------------------

Le résultat de l'expansion consiste en 3 tables indexées par des idents cibles (CoIdent.t) :

  • Table des variables (support)
  • Table des alias (d'expressions algébriques)
  1. la liste d'alias
  • Table des traces
type support_scope

Info et table des variables support

type support_nature =
  1. | Input
  2. | Output
  3. | LocalIn
  4. | LocalOut
type support_info = {
  1. si_ident : CoIdent.t;
  2. si_nature : support_nature;
  3. si_type : CkTypeEff.t;
  4. si_ref_exp : CoAlgExp.t;
  5. si_src : CoIdent.src_stack;
  6. si_pre_ref_exp : CoAlgExp.t option;
  7. si_default : CoAlgExp.t option;
  8. si_scope : support_scope option;
  9. si_init : CoAlgExp.t option;
  10. si_range : (CoAlgExp.t * CoAlgExp.t) option;
}
and t
val support_tab : t -> support_info Util.StringMap.t
val support_pres : t -> (CoIdent.t * support_info) list
val input_list : t -> CoIdent.t list
val output_list : t -> CoIdent.t list
val local_in_list : t -> CoIdent.t list
val local_out_list : t -> CoIdent.t list
val ident_space : t -> CoIdent.space
val node_name : t -> string
type alias_info = {
  1. ai_type : CkTypeEff.t;
  2. ai_def_exp : CoAlgExp.t;
  3. ai_ref_exp : CoAlgExp.t;
  4. ai_src : CoIdent.src_stack;
}

Info et table des alias algébriques

val alias_tab : t -> alias_info Util.StringMap.t
val alias_list : t -> CoIdent.t list
val get_run_expanded_code : t -> CoIdent.t -> t

Info et table des alias trace

type tbl = {
  1. arg_opt : MainArg.t;
  2. expanded_code : t;
  3. in_vars : Exp.var list;
  4. out_vars : Exp.var list;
  5. loc_vars : Exp.var list;
  6. init_pres : Value.OfIdent.t;
  7. id2var_tab : Exp.var Util.StringMap.t;
  8. out_var_names : string list;
  9. bool_vars_to_gen : Exp.formula;
  10. num_vars_to_gen : Exp.var list;
  11. snt : Solver.t;
}
and trace_info = {
  1. ti_def_exp : tbl CoTraceExp.t;
  2. ti_src : CoIdent.src_stack;
}
val make : CheckEnv.t -> Syntaxe.package -> string -> t
val trace_tab : t -> trace_info Util.StringMap.t
val get_trace_info : t -> CoIdent.t -> trace_info

Info et table des externes utilisées on garde le CkIdentInfo.t tel quel pour usage ultérieur (génération de code) N.B. le source est un lexeme

type extern_info = {
  1. xi_decl : Syntaxe.let_info;
  2. xi_prof : CkTypeEff.profile;
  3. xi_src : Lexeme.t;
}
val extern_tab : t -> extern_info Util.StringMap.t
val main_trace : t -> CoIdent.t

Identificateur (target) de la trace principale

val dump : t -> unit

DUMP pour debug etc.

val dump_src_ctx : t -> string