Project Oscar

Previous: Ecriture des grammaires attribuées

Appel des grammaires attribuées

La description du compilateur SIMPROC est terminée, il nous reste à écrire l'appel des grammaires attribuées et de la spécification PPAT, dans le fichier simproc_smp.c, produit par simproc.mkfnc.

#include "simproc.h"	/* Pour inclure éventuellement nos applications	*/

/* La passe sémantique et l'appel du décompilateur d'arbre */
/* ======================================================= */
static VOID simprocsmp ()

{
    /* Pointeurs sur les résultats de nos grammaires attribuées */
    /* ======================================================== */
    struct simproc__check_result *r;  
    struct simproc__term_result *r1;
    
    FILE *sortie, *arbre;
    char lst_name [132];

    /* Cette fonction est definie dans simproc.c
       elle est produite avec  mkfnc2 avec le fichier simproc.mkfnc2 */
    /* ============================================================= */
    init___simproc ();	
    

    /* C'est ici que prend place l'appel de nos grammaires attribuées dans */
    /* ====================================================================*/

    /* 1) La grammaire attribuée procédurale de sémantique statique  */
    /*    - simproc__check est le nom de notre premiere grammaire attribue */
    /*      (simproc-check.olga) */
    /*    - f2atcvar.atc_lv.abstract_tree_root est la racine de l'arbre */
    /*      abstrait issu de l'analyse lexico-syntaxique (SYNTAX) */
    r = simproc__check (f2atcvar.atc_lv.abstract_tree_root);

    /* 2) Si la passe sémantique est correcte, on construit l'arbre abstrait */
    /*    pour la génération du code cible. */
    /*    Dans cette phase, la grammaire attribuée fonctionnelle  */
    /*    simproc-check.olga, est utilisée pour construire l'arbre abstrait */
    /*    décrit par la syntaxe attribuée abstraite simproc-adt.asx. */
    /*    Finalement, on appelle le décompilateur ppat crée a partir de la */
    /*    spécification simproc-ppat.ppat. r1->Program est la racine de */
    /*    l'arbre. La chaîne vide "" indique que la décompilation se fera  */
    /*    sur la sortie standard. Une chaîne non-vide indiquerait un nom de  */
    /*    fichier pour contenir le résultat de le décompilation. 80 indique  */
    /*    la longueur maximale des lignes avant application des règles de  */
    /*    césure (voir la documentation de ppat) */
    if (r -> correct) {
	r1 = simproc__term (f2atcvar.atc_lv.abstract_tree_root);
	ppat___simproc__ppat(r1->Program,80,"");
    }
}

/* Dans le cas de l'exemple simproc, le code ci-dessous n'a pas */
/* a etre modifie par l'utilisateur */
/* ============================================================ */

static VOID simprocfinal ()
{
    FILE	*sortie;
    char	lst_name [132];

}

static simprocopen (tables)
    register struct sxtables *tables;
{
    f2atcvar.atc_lv.node_size = sizeof (NODE) /* size of the olga_node */;
}

VOID simproc_smp (entry,arg)
int  entry;
struct sxtables *arg;
{

    switch (entry) {
    case OPEN:
	simprocopen (arg);
	break;

    case CLOSE:
	break;

    case ACTION:
    case SEMPASS:
	simprocsmp ();
	break;

    case INIT:
	break;

    case FINAL:
	simprocfinal ();
	break;

    default:
	fprintf (sxstderr, "The function \"simprocsmp\"
                 is out of date with respect to its specification.\n");
	break;
    }
    return;
    /* end simprocsmp */
}

Enfin, nous pouvons réaliser l'étape finale avec le script FNC2. Nous choisirons l'option F inal, ce qui aura pour effet de compiler l'ensemble des fichiers CC produits par SYNTAX/FNC-2.

Le résultat de la compilation (le compilateur SIMPROC), se trouve dans le répertoire $HOME/simproc/bin/solaris/simproc (dans le cas d'une utilisation sous machine SOLARIS).

Il ne reste plus qu'à utiliser le compilateur en lui soumettant un programme de test, comme celui-ci par exemple :

	    integer J;
	
	    proc factorial (val I , var F )
		begin
		integer TEMP;
		if I eq 0 then F := 1
			  else 	call factorial(I-1, TEMP);
				F := TEMP * I
		fi	
	    end;
	
	    call factorial (5, J)

En appelant notre compilateur SIMPROC avec comme paramètre le nom d'un fichier contenant le texte ci-dessus, on verra la génération de code cible sur la sortie standard :

Execute
Prog
    Decl
    Intdecl J Prog
    Procdecl factorial I F Prog
        Decl
        Intdecl TEMP factorial
        Stmt
        Condit Designates I 0
        Then Assignint Refersto Refdesignates F 1
        Else Call factorial Difference Designates I 1 Designates TEMP factorial
             Assignint Refersto Refdesignates F Times Designates TEMP Designates I
    EndProddecl
    Stmt
    Call factorial 5 Designates J Prog