package lutin

  1. Overview
  2. Docs

COMPILATION/EXPANSION : idents et retour au source

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

Identificateurs et remontée au source

C'est un peu du luxe, mais on distingue :

  • les ident source, Syntaxe.ident (sous-entendu avec src_info, donc UNIQUES),
  • les ident target (de simple string, mais uniques par construction).

N.B. ça a beau être de simple string, on en fait quand même un type abstrait, au cas où ...

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

type space

remet le module a zero ...

val new_space : unit -> space
type t = string

Ident dans target, unique par nommage

val to_string : t -> string
val list_to_string : t list -> string -> string
val get_fresh : space -> string -> t

L'unicité des idents target est garantie par la fonction suivante, qui prend un préfixe en paramètre

val get : string -> t

Si on est sûr qu'il n'y aurra pas de problème, on peut forcer un nom

val of_cpt : int -> t
val from_string : string -> t

Si le nom doit rester tel quel

REMONTÉE AU SOURCE DANS LE PROGRAMME EXPANSÉ

type src_stack = (Lexeme.t * Lexeme.t * Syntaxe.val_exp option) list

Remontée au source d'un "target" depuis le code expansé

type scope_stack = Lexeme.t * src_stack

Remontée au source d'un scope depuis le code expansé

val main_scope : Lexeme.t -> scope_stack

Scope de base

val get_scope : Lexeme.t -> src_stack -> scope_stack
val base_stack : unit -> src_stack
val get_src_stack : Lexeme.t -> scope_stack -> Syntaxe.val_exp option -> src_stack

Avec un scope_stack et une instance de Syntaxe.ident, on fabrique un src_stack complet

val print_src_stack : src_stack -> unit
val string_of_src_stack : src_stack -> string
val head_of_src_stack : src_stack -> Lexeme.t