Les modifications non locales sur la forme évaluée

1. Position du problème

2. Syntaxe complétée

3. Exemple

3. Exemple

On définit le schéma :

(def procedure
   ((def defcla ()
       ((NOM) ":" (TYP)" ";" "^M")))
    ("PROCEDURE " (EN-TETE) ";" "^M"
     (pos-accu DECL
        ("VAR " (decla) (lst-accu "    " (decla))))
     "BEGIN" "^M"
     "   " (CORPS)
     "END;" "^M"))

Il est paramétré par :

• EN-TETE (l'en-tête), CORPS (le corps),
• DECL : le nom d'un « point d'accumulation ».

Il fournit le schéma de décompilation du « point d'accumulation » ; sous la forme de listes, on écrirait :

(lst-init DECL
   ("VAR " (decla) (lst "    " (decla))))

qui se lit :

• la première déclaration est introduite par le mot-clé "VAR",
• les déclarations qui suivent sont placées simplement (avec une tabulation de 4 blancs).
  
  
• Si la procédure ne "reçoit" aucune déclaration (par use-accu), il ne s'affiche rien.
• Si elle en "reçoit" une, elle l'affiche, précédée de "VAR".
• Si elle en "reçoit" plusieurs, elle les affiche, la première sur le premier schéma et les autres sur le second.

Une utilisation de procedure :

(def traitement
   ((def EN-TETE ...)
    (def-accu DECL
       ((ref-accu bloc-decla)))
    (def-accu bloc-decla
       ((accu)))
    (def CORPS ()
       (...
        (use-accu bloc-decla
           ((def NOM () ("x"))
            (def TYP () ("integer"))))
        ...
        (use-accu bloc-decla
           ((def NOM () ("y"))
            (def TYP () ("real"))))
        ...)))
   ((procedure)))

Le traitement définit :

• l'en-tête,
• le paramètre du « point d'accumulation » DECL, par référence (ref-accu) au « point d'accumulation » local au texte bloc-decla,
• le « point d'accumulation » local bloc-decla,
• le corps : les textes du corps utilisent le « point d'accumulation » local bloc-decla pour placer de nouvelles déclarations de variables.

Note :
Ces opérateurs présentent certaines limitations :

• il faut avoir déjà évalué la position du « point d'accumulation » pos-accu avant de l'utiliser par use-accu : on pourrait prévoir un système retardé qui range les utilisations use-accu tant que pos-accu n'a pas été évalué ;
• il n'est fait aucun contrôle sur la liste des éléments fournis au « point d'accumulation » : dans l'exemple précédent, si l'on déclare deux fois une variable "N" de type "integer" (parce qu'elle apparaît dans deux « textes » distincts en tant que variable auxiliaire), on retrouvera deux fois la déclaration « textuelle » de "N" dans la forme évaluée.