symbolMgt
permettant de gérer une table de symboles.
L'interface publique de ce module est la suivante :
/* symbolMgt.h */ extern int insertInSymbolTable( char * symbolName, int type ); extern int isInSymbolTable( char * symbolName); extern void printSymbolTable(); extern int TREE_NODE, TREE_STRUCT; extern void * getRefForSymbolInTable( char * symbolName ); extern int setRefForSymbolInTable( char * symbolName , void * ref); extern char * firstTreeStructSymbolName( );
Un symbole est représenté par un nom, un type et un champ pouvant contenir une adresse.
insertInSymbolTable
permet d'enregistrer, dans la table de symboles, le symbole de nom symbolName
et de type type
passés en paramètres. Le type pourra prendre deux valeurs différentes : TREE_NODE
et TREE_STRUCT
. Si un symbole de nom identique est déjà présent, l'insertion n'a pas lieu, un message de contrôle de la forme « symbolName already present
» s'affiche et la valeur de retour sera égale à EXIT_FAILURE
. Lors d'une insertion, un message de contrôle s'affiche de la forme « symbolName inserted
» et la valeur de retour sera égale à EXIT_SUCCESS
.isInSymbolTable
renvoie 1
si le symbole de nom symbolName
se trouve dans la table de symboles, 0
sinon;printSymbolTable
affiche le contenu de la table de symboles, c'est-à-dire affiche pour chaque symbole son nom, son type et l'adresse associée;TREE_NODE
, TREE_STRUCT
sont deux entiers définis par symbolMgt.c
utilisés pour repérer les deux types possibles de symboles.getRefForSymbolInTable
retourne l'adresse du symbole de nom symbolName
;
setRefForSymbolInTable
permet d'enregistrer l'adresse ref
du symbole de nom symbolName
;
firstTreeStructSymbolName
retourne le nom du premier symbole de type TREE_STRUCT
trouvé dans la table de symbole. Notez que pour un fonctionnement général, une fonction nextTreeStructSymbolName
est nécessaire pour accéder aux symboles suivants.#include <stdio.h> #include <stdlib.h> #include "symbolMgt.h" int main( int argc, char *argv[] ) { int p; char *treeName; p = isInSymbolTable("AA"); if (p == 0) { fprintf(stderr, "AA not found\n"); } else { fprintf(stderr, "AA found\n"); } insertInSymbolTable( "YY", TREE_NODE ); insertInSymbolTable( "VV", TREE_NODE ); insertInSymbolTable( "WW", TREE_STRUCT ); insertInSymbolTable( "XX", TREE_NODE ); insertInSymbolTable( "ZZ", TREE_NODE ); insertInSymbolTable( "VV", TREE_NODE ); p = isInSymbolTable("XX"); if (p == 0) { fprintf(stderr, "XX not found\n"); } else { fprintf(stderr, "XX found\n"); } fprintf( stderr, "------------ symbolTable :\n"); printSymbolTable( ); fprintf( stderr, "\n" ); treeName = firstTreeStructSymbolName( ); fprintf( stderr, "treeName = %s\n", treeName); return EXIT_SUCCESS; }Le résultat attendu est le suivant:
AA not found YY inserted VV inserted WW inserted XX inserted ZZ inserted VV already at 0 XX found ------------ symbolTable : VV TREE_NODE (nil) WW TREE_STRUCT (nil) XX TREE_NODE (nil) YY TREE_NODE (nil) ZZ TREE_NODE (nil) treeName = WWRemarques
symbolMgt
ne donne pas d'accès direct à la table de symboles.#include <stdio.h> #include <stdlib.h> #include "symbolMgt.h" int main( int argc, char *argv[] ) { int *ref1, *ref2; insertInSymbolTable( "AA", TREE_NODE ); insertInSymbolTable( "BB", TREE_NODE ); insertInSymbolTable( "WW", TREE_STRUCT ); ref1 = malloc(sizeof(int)); ref2 = malloc(sizeof(int)); fprintf(stderr, "ref1 = %p\n", ref1); fprintf(stderr, "ref2 = %p\n", ref2); setRefForSymbolInTable("AA", ref1); setRefForSymbolInTable("BB", ref2); setRefForSymbolInTable("CC", ref2); /* incorrect but should not crash */ fprintf( stderr, "------------ symbolTable :\n"); printSymbolTable( ); fprintf( stderr, "\n" ); fprintf(stderr, "AA ref1 = %p\n", getRefForSymbolInTable("AA")); fprintf(stderr, "BB ref2 = %p\n", getRefForSymbolInTable("BB")); fprintf(stderr, "WW ref3 = %p\n", getRefForSymbolInTable("WW")); /* incorrect but should not crash */ return EXIT_SUCCESS; }Le résultat attendu est le suivant:
AA inserted BB inserted WW inserted ref1 = 0x100100110 ref2 = 0x100100120 ------------ symbolTable : AA TREE_NODE 0x11530d0 BB TREE_NODE 0x11530f0 WW TREE_STRUCT (nil) AA ref1 = 0x11530d0 BB ref2 = 0x11530f0 WW ref3 = (nil)
treeMgt
permettant de gérer un arbre.
L'interface publique de ce module est la suivante :
/* treeMgt.h */ + les definitions des types Tree et TreeNode extern Tree * newTree( TreeNode * tnP ); extern TreeNode * newTreeNode( char * label ); extern void dfsTraversalOn(TreeNode * tnP); extern void addChildToParentNode( TreeNode * parentP, TreeNode * childP ); extern TreeNode * getNodeFromRoot(Tree *t);
TreeNode
contient une étiquette sous forme d'une chaîne de caractères et une liste de noeuds enfants.Tree
contient un pointeur vers un noeud de type TreeNode
, véritable noeud racine.newTreeNode
crée une structure TreeNode
avec l'étiquette initialisée à label
passé en paramètre.newTree
crée une structure Tree
en initialisant le pointeur à tnP
passé en paramètre.addChildToParentNode
ajoute childP
à la liste des enfants du noeud parentP
dfsTraversalOn
effectue un parcours en profondeur d'abord à partir du noeud tnP
passé en paramètre. Ce parcours affiche l'étiquette de chaque noeud rencontré dans l'ordre du parcours.getNodeFromRoot
retourne le pointeur de type noeud contenu dans le noeud racine t
passé en paramètre.
#include <stdio.h> #include <stdlib.h> #include <assert.h> #include "treeMgt.h" int main( int argc, char *argv[] ) { TreeNode * tnRoot; TreeNode * r = newTreeNode( "Root" ); Tree * t = newTree(r); TreeNode * tnP1 = newTreeNode( "P1" ); TreeNode * tnP2 = newTreeNode( "P2" ); TreeNode * tnP3 = newTreeNode( "C1" ); TreeNode * tnP4 = newTreeNode( "C2" ); fprintf( stderr, "nodes created\n" ); addChildToParentNode(r, tnP1); addChildToParentNode(r, tnP2); addChildToParentNode(r, tnP3); addChildToParentNode(r, tnP4); fprintf( stderr, "4th child added\n" ); tnRoot = getNodeFromRoot(t); assert(tnRoot == r); fprintf(stderr, "DFS traversal :\n"); dfsTraversalOn( tnRoot ); fprintf(stderr, "\n"); }Le résultat attendu est:
nodes created 4th child added DFS traversal : P1 P2 C1 C2 <li> Root <ul> <li> P1 <li> P2 <li> C1 <li> C2 </ul> </li>