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 = WW
Remarques
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 parentPdfsTraversalOn 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>