package lutin

You can search for identifiers within the package.

in-package search v0.2.0

package lutin

lutin
- Auto2Lucky
- AutoGen
- Bddd
- CheckEnv
- CheckType
- CkIdentInfo
- CkTypeEff
- CoAlgExp
- CoIdent
- CoTraceExp
- Constraint
- Draw
- Exp
- ExpEval
- Expand
- ExprUtil
- FGen
- Formula_to_bdd
- GenOcamlGlue
- Glue
- Gne
- Guard
- Lexeme
- LoopWeights
- Luc2alice
- Luc2c
- LucFGen
- Lucky
- LutErrors
- LutExe
- LutLexer
- LutParser
- LutPredef
- LutProg
- LutinRun
- LutinUtils
- MainArg
- Ne
- Parsers
- Poly_draw
- Polyhedron
- Prevar
- Prog
- Reactive
- Rif
- Sol_nb
- Solver
- Store
- Syntaxe
- SyntaxeDump
- Thickness
- Type
- Util
  - StringMap
- Utils
- Value
- Var
- Verbose
- Version

Legend:
Library
Module
Module type
Parameter
Class
Class type

TYPE/BINDING CHECK : environnement

C'est la structure qui permet :

de r�aliser le type/binding check (cf. CheckType)
de conserver, apr�s ce check, les infos calcul�es/inf�r�es

Toute r�f�rence � un identificateur est identifi�e de mani�re UNIQUE par son ident (string + lexeme).

Au cours du check, on utilise TROIS tables :

une table "dynamique" de scoping "string -> ident_info" qui permet de r�soudre les r�f�rence sous "scope"
une table GLOBALE de binding "ident -> ident_info" remplie au fur et � mesure que les r�f�rences sont r�solue
une table de typage des "val_exp -> CkTypeEff.t" n.b. les val_exp SONT identifi�es de mani�re unique par leur lexeme

N.B. voir sous-module : CkTypeEff CkIdentInfo

N.B. Les identificateurs d'exceptions sont trait�s comme des constantes abstraites de type CkTypeEff.except -------------------------------------------------------------

type t

val create : unit -> t

val copy : t -> t

val add_libs : t -> string list -> t

val get_exp_type : t -> Syntaxe.val_exp -> CkTypeEff.t

val get_binding : t -> Syntaxe.ident -> CkIdentInfo.t

val set_exp_type : t -> Syntaxe.val_exp -> CkTypeEff.t -> unit

type scope_key

val restore : t -> scope_key -> unit

type typed_ids = (Syntaxe.ident * Syntaxe.type_exp) list

type eff_typed_ids = (Syntaxe.ident * CkTypeEff.t) list

val add_formal_params : t -> typed_ids option -> scope_key

val add_support_vars : t -> eff_typed_ids -> scope_key

val add_global_cst : t -> Syntaxe.ident -> CkTypeEff.t -> scope_key

val add_local_cst : t -> Syntaxe.ident -> CkTypeEff.t -> scope_key

val add_support_profile : t -> eff_typed_ids -> eff_typed_ids -> scope_key

val add_let : 
  t ->
  Syntaxe.let_info ->
  CkTypeEff.t ->
  Syntaxe.ident ->
  scope_key

val add_node : 
  t ->
  Syntaxe.node_info ->
  CkTypeEff.profile ->
  Syntaxe.ident ->
  scope_key

val add_extern : 
  t ->
  Syntaxe.let_info ->
  CkTypeEff.t ->
  Syntaxe.ident ->
  scope_key

val add_predef_op : t -> string -> CkTypeEff.profile -> scope_key

val add_predef_cst : t -> string -> CkTypeEff.t -> scope_key

val get_ident_info : t -> Syntaxe.ident -> CkIdentInfo.t

val nature_of_ident : t -> Syntaxe.ident -> CkIdentInfo.nature

val type_of_ident : t -> Syntaxe.ident -> CkTypeEff.t

val dbg_dump : t -> unit