Annexe : la syntaxe initiale

phylum des environnements : meta-ENV

(def meta-ENV
   ((ref decl-env)
    (def imptt ()
       ("()"))))

opérateur d'environnement : meta-env

(def decl-env
   ((def meta-env
       ((def imptt ()
           ("(env"
            (lst-init ((LST-TRM))
               (imptt ((meta-TRM))))
            ")"))))))

phylum des termes : meta-TRM

(def meta-TRM
   ((ref decl-ENV)
    (ref decl-LSP)
    (ref meta-def)
    (ref meta-ref)
    (def imptt ()
       ((imptt ((meta-ref)))))))

opérateur de définition : meta-def

(def decl-def
   ((def meta-def
       ((def imptt ()
           ("(def" (NOM)
            (imptt
               ((ENV)
                (meta-ENV)))
            (imptt
               ((REP)
                (meta-REP)))
            ")"))))))

opérateur de référence : meta-ref

(def decl-ref
   ((def meta-ref
       ((def imptt ()
           ("(ref" (NOM)
            (imptt
               ((ENV)
                (meta-ENV)))
            ")"))))))

phylum des représentations : meta-REP

(def meta-REP
   ((ref decl-rep)
    (def imptt ()
       ("()"))))

opérateur de représentation : meta-rep

(def decl-rep
   ((def meta-rep
       ((def imptt ()
           ("(rep"
            (lst-init ((LST-ATM))
               (imptt ((meta-ATM))))
            ")"))))))

phylum des atomes : meta-ATM

(def meta-ATM
   ((ref decl-REP)
    (ref decl-LSP)
    (ref meta-stg)
    (ref meta-use)
    (ref meta-STRING)
    (def imptt ()
       ((imptt ((meta-use)))))))

opérateur de string : meta-stg

(def decl-stg
   ((def meta-stg
       ((def imptt ()
           ("(stg" (NOM)
            ")"))))))

opérateur d'utilisation : meta-use

(def decl-use
   ((def meta-use
       ((def imptt ()
           ("(use" (NOM)
            (imptt
               ((ENV)
                (meta-ENV)))
            ")"))))))

phylum des expressions Lisp : meta-LSP

(def meta-LSP
   ((ref decl-lsp)
    (def imptt ()
       ("()"))))

opérateur d'expression Lisp : meta-lsp

(def decl-lsp
   ((def meta-lsp
       ((def imptt ()
           ("(lsp"
            (lst-init ((LST-SEX))
               (imptt ((meta-SEX))))
            ")"))))))

phylum des S-expressions : meta-SEX

(def meta-SEX
   ((ref decl-TRM)
    (ref decl-ATM)
    (ref meta-ATOME)
    (ref meta-LISTE)
    (def imptt ()
       ("()"))))

phyla prédéfinis : meta-STRING meta-ATOME meta-LISTE

(def meta-STRING
   ((def imptt ()
       ("""" (STRING) """"))))

(def meta-ATOME
   ((def imptt ()
       ((ATOME)))))

(def meta-LISTE
   ((def imptt ()
       ((LISTE)))))

Exemple de texte

On définit le texte :

(def txt
   ((def a () ("A")))
   ("X:=" (use a) ";"))

On le représente par :

(def meta-txt
   ((ref meta-def)
    (def NOM () ("txt"))
    (def ENV
       ((ref meta-env)
        (def LST-TRM
           (lst-env
              ((ref meta-def)
               (def NOM () ("a"))
               (def ENV
                  ((ref meta-env)
                   (def LST-TRM
                      (lst-env))))
               (def REP
                  ((ref meta-rep)
                   (def LST-ATM
                      (lst-env
                         ((ref meta-stg)
                          (def NOM () ("A")))))))))))
    (def REP
       ((ref meta-rep)
        (def LST-ATM
           (lst-env
              ((ref meta-stg)
               (def NOM () ("X:=")))
              ((ref meta-use)
               (def NOM () ("a"))
               (def ENV
                  ((ref meta-env)
                   (def LST-TRM
                      (lst-env)))))
              ((ref meta-stg)
               (def NOM () (";")))))))))

On utilise la propriété imptt en se plaçant dans le phylum meta-TRM :

(imptt
   ((meta-txt)
    (meta-TRM)))

qui fournit :

("(def" "txt"
   "(env"
      "(def" "a"  "(env" ")"  "(rep" """A""" ")" ")"
   ")"
   "(rep"
      """X:="""  "(use" "a" "(env" ")" ")"  """;"""
   ")"
")")

qui s'affiche sous la forme simplifiée :

(def txt
   (env
      (def a  (env)  (rep "A") )
   )
   (rep
      "X:="  (use a (env) )  ";"
   )
)