e un #endif, v‚rifie s'il est acceptable.         >enregistr : precond_endif precond.c 
dernier commentaire qui a ‚t‚ accumul‚ (oublie ensuite).>ret : token_lastcomment token2.c 
ommentaires sont sautee, mais accumule. le prochain token va : token_skipcomment token2.c 
ourne une position o— on peut accumuler un texte de token.>r : token_alloctxt token4.c 
        >enregistre le mode d'activit‚ du pr‚processeur.     : token_setpreproc token.c 
outes les macros d‚j… enregis>affiche la d‚claration de la t : preproc_dumpmac preproc1.c 
tablie la nouvelle position d'allocation des textes de token : token_settxt token4.c 
btient la position courante d'allocation pour le texte des t : token_getmarktxt token4.c 
istre une nouvelle position d'allocation, lib‚rant une porti : token_setmarktxt token4.c 
stdin comme source du texte … analyser.          >s‚lection  : filesrc_setstdin filesrc.c 
 name comme source du texte … analyser..>s‚lection du fichie : filesrc_open filesrc.c 
 token fait partie de tb[][0] appelle recursivement.>retourn : token_getskip token3.c 
criture de>output d'un chaine arbitraire dans le fichier d'‚ : outsrc_print outsrc.c 
es paramŠtres formels par les arguments.>fait le remplacemen : preproc_expand preproc2.c 
           >retourne le texte ascii associ‚ au token.        : token_txt token4.c 
         >r‚assigne la chaine associ‚ … un mot cl‚.          : token_chgkeyword token1.c 
     >retourne le texte ascii associ‚ au token.              : token_txt token4.c 
tourne le texte ascii associ‚ au token.                  >re : token_txt token4.c 
     >ferme le fichier ouvert avec token_open.               : token_close token.c 
deux token.    >indique si un blanc doit etre inserer entre  : token_needsep token4.c 
urne le nouveau ptl>saute les blancs … partir de ptl et reto : token_skipwhite token.c 
 une ligne.        >saute les blancs et les commentaire dans : precond_skipcom precond.c 
'une ch>extrait une chaine de caractŠre (guillemet double) d : token_copystring token6.c 
'une chaine.      >extrait un caractŠre (guillemet simple) d : token_copyquote token6.c 
le to>reconnait une chaine de caractŠre (string) et compose  : token_string token1.c 
ple et compose l>reconnait un caractŠre entre guillement sim : token_quote token1.c 
le.    >saute d‚finition d'un caractŠre entre guillemet simp : token_skipquote token6.c 
d'identifica>retourne != 0 si caractŠre est un d‚but valide  : token_idok token1.c 
fichier d'input en conservant celui d‚j… ouvert dans une pil : filesrc_pushopen filesrc.c 
     >extrait un nombre d'une chaine.                        : token_copynumber token1.c 
tŠre (guillemet double) d'une chaine.>extrait une chaine de  : token_copystring token6.c 
cture de token … partir d'une chaine.    >initialise la stru : token_make token.c 
tŠre (guillemet simple) d'une chaine.      >extrait un carac : token_copyquote token6.c 
ait un identificateur c d'une chaine.                  >extr : token_copyid token1.c 
ier d'‚criture de>output d'un chaine arbitraire dans le fich : outsrc_print outsrc.c 
                >r‚assigne la chaine associ‚ … un mot cl‚.   : token_chgkeyword token1.c 
 double) d'une ch>extrait une chaine de caractŠre (guillemet : token_copystring token6.c 
t compose le to>reconnait une chaine de caractŠre (string) e : token_string token1.c 
ne la chaine associ‚ … un mot cl‚.                  >r‚assig : token_chgkeyword token1.c 
mpose le tok>reconnait un mot-cl‚ ou un identificateur et co : token_id token1.c 
pas.  >enregistre si les mots cl‚s doivent ˆtre reconnue ou  : token_setchkkey token1.c 
               >initialise la collecte de token.             : token_init token.c 
initialise ou r‚initialise la collecte des textes de tokens. : token_inittxt token4.c 
chier.           >redirige la collecte des tokens dans un fi : token_open token.c 
er.          >s‚lection stdin comme source du texte … analys : filesrc_setstdin filesrc.c 
er.>s‚lection du fichier name comme source du texte … analys : filesrc_open filesrc.c 
     >saute les blancs et les commentaire dans une ligne.    : precond_skipcom precond.c 
 (oublie >retourne le dernier commentaire qui a ‚t‚ accumul‚ : token_lastcomment token2.c 
                     >dernier commentaire reconnue */.       : token_initcomment token2.c 
ne ligne en tenant compte des commentaires.>saute la fin d'u : precond_skipline precond.c 
ermis ou pas.>controle si les commentaires imbriqu‚es sont p : token_setcommode token2.c 
 accumule. le prochain to>les commentaires sont sautee, mais : token_skipcomment token2.c 
      >reconnait un nombre et compose le token.              : token_number token1.c 
re entre guillement simple et compose le token.>reconnait un : token_quote token1.c 
aine de caractŠre (string) et compose le token.>reconnait un : token_string token1.c 
t-cl‚ ou un identificateur et compose le token.>reconnait un : token_id token1.c 
 la fin d'une ligne en tenant compte des commentaires.>saute : precond_skipline precond.c 
                    >remet le compteur d'erreur … 0..        : lexcerr_reset lexcerr.c 
a>ouvre un fichier d'input en conservant celui d‚j… ouvert d : filesrc_pushopen filesrc.c 
mbriqu‚es sont permis ou pas.>controle si les commentaires i : token_setcommode token2.c 
     >retourne nom du fichier couramment en lecture.         : filesrc_curfile filesrc.c 
m‚ro de ligne dans le fichier courant.          >retourne nu : filesrc_curline filesrc.c 
nregistre la ligne et fichier courant pour prochaine erreur. : lexcerr_lockinfo lexcerr.c 
texte des>obtient la position courante d'allocation pour le  : token_getmarktxt token4.c 
gne.    >retourne la position courante d'‚criture dans la li : outsrc_curcol outsrc.c 
              >retourne ligne courante de lecture.           : token_getnoline token.c 
urne != 0 si caractŠre est un d‚but valide d'identificateur. : token_idok token1.c 
        >traite une ligne qui d‚bute par #.                  : preproc_anal preproc.c 
                  >elimine la d‚claration d'un define.       : preproc_undef preproc1.c 
        >enregistrement de la d‚claration d'un define.       : preproc_recdefine preproc1.c 
acros d‚j… enregis>affiche la d‚claration de la toutes les m : preproc_dumpmac preproc1.c 
ur pour expansion de tab. par d‚faut 8.. >enregistre la vale : filesrc_settab filesrc.c 
te le d‚finition d'une macro #define.                   >sau : token_skipmacro token2.c 
rement de la d‚claration d'un define.              >enregist : preproc_recdefine preproc1.c 
 >elimine la d‚claration d'un define.                        : preproc_undef preproc1.c 
ment d'un symbole si c'est un define.      >fait le remplace : preproc_convert preproc1.c 
e guillemet simple.    >saute d‚finition d'un caractŠre entr : token_skipquote token6.c 
                    >saute le d‚finition d'une macro #define : token_skipmacro token2.c 
t pr‚processeu>enregistre une d‚finition pour le remplacemen : token_setdef token2.c 
ation de la toutes les macros d‚j… enregistr‚.>affiche la d‚ : preproc_dumpmac preproc1.c 
r d'input en conservant celui d‚j… ouvert dans une pile.>ouv : filesrc_pushopen filesrc.c 
accumul‚ (oublie >retourne le dernier commentaire qui a ‚t‚  : token_lastcomment token2.c 
/.                           >dernier commentaire reconnue * : token_initcomment token2.c 
              >position de la derniere ecriture */.          : outsrc_open outsrc.c 
.>retourne le nombre d'erreur d‚tect‚es par le pr‚processeur : lexcerr_getnb lexcerr.c 
                             >d‚termine la fin d'une string. : token_skipstring token6.c 
blanc doit etre inserer entre deux token.    >indique si un  : token_needsep token4.c 
ration d'un sou>enregistre la dimension d'un tab pour reg‚n‚ : outsrc_settab outsrc.c 
            >traitement de la directive else.                : precond_else precond.c 
oken.    >indique si un blanc doit etre inserer entre deux t : token_needsep token4.c 
 >enregistre si les mots cl‚s doivent ˆtre reconnue ou pas.  : token_setchkkey token1.c 
haine de caractŠre (guillemet double) d'une chaine.>extrait  : token_copystring token6.c 
     >position de la derniere ecriture */.                   : outsrc_open outsrc.c 
tourne la position courante d'‚criture dans la ligne.    >re : outsrc_curcol outsrc.c 
 arbitraire dans le fichier d'‚criture de source.>output d'u : outsrc_print outsrc.c 
 d'un token dans le fichier d'‚criture de source.    >output : outsrc_prttoken outsrc.c 
n logique pour enonc‚ #if ou #elif.     >evalue un expressio : precond_eval precond1.c 
                  >evalue un #elif.                          : precond_elif precond.c 
fine.                        >elimine la d‚claration d'un de : preproc_undef preproc1.c 
  >traitement de la directive else.                          : precond_else precond.c 
able.         >enregistre un #endif, v‚rifie s'il est accept : precond_endif precond.c 
ue un expression logique pour enonc‚ #if ou #elif.     >eval : precond_eval precond1.c 
 de la toutes les macros d‚j… enregistr‚.>affiche la d‚clara : preproc_dumpmac preproc1.c 
ab pour reg‚n‚ration d'un sou>enregistre la dimension d'un t : outsrc_settab outsrc.c 
 courant pour prochaine erreu>enregistre la ligne et fichier : lexcerr_lockinfo lexcerr.c 
our localisation des fichiers>enregistre la liste des path p : filesrc_setpath filesrc.c 
nsion de tab. par d‚faut 8.. >enregistre la valeur pour expa : filesrc_settab filesrc.c 
du pr‚processeur.            >enregistre le mode d'activit‚  : token_setpreproc token.c 
ivent ˆtre reconnue ou pas.  >enregistre si les mots cl‚s do : token_setchkkey token1.c 
s'il est acceptable.         >enregistre un #endif, v‚rifie  : precond_endif precond.c 
 le remplacement pr‚processeu>enregistre une d‚finition pour : token_setdef token2.c 
 son remplacement.           >enregistre une macro simple et : preproc_putdef preproc1.c 
on d'allocation, lib‚rant une>enregistre une nouvelle positi : token_setmarktxt token4.c 
on d'un define.              >enregistrement de la d‚clarati : preproc_recdefine preproc1.c 
re qui a ‚t‚ accumul‚ (oublie ensuite).>retourne le dernier  : token_lastcomment token2.c 
si un blanc doit etre inserer entre deux token.    >indique  : token_needsep token4.c 
pose l>reconnait un caractŠre entre guillement simple et com : token_quote token1.c 
ute d‚finition d'un caractŠre entre guillemet simple.    >sa : token_skipquote token6.c 
ichier courant pour prochaine erreur.>enregistre la ligne et : lexcerr_lockinfo lexcerr.c 
lie information sur prochaine erreur.                   >oub : lexcerr_unlock lexcerr.c 
         >remet le compteur d'erreur … 0..                   : lexcerr_reset lexcerr.c 
cesseur.>retourne le nombre d'erreur d‚tect‚es par le pr‚pro : lexcerr_getnb lexcerr.c 
     >impression de message d'erreur lexicale.               : lexcerr_bprintf lexcerr.c 
istre un #endif, v‚rifie s'il est acceptable.         >enreg : precond_endif precond.c 
ca>retourne != 0 si caractŠre est un d‚but valide d'identifi : token_idok token1.c 
emplacement d'un symbole si c'est un define.      >fait le r : preproc_convert preproc1.c 
'allocation des textes de tok>etablie la nouvelle position d : token_settxt token4.c 
    >indique si un blanc doit etre inserer entre deux token. : token_needsep token4.c 
                             >evalue un #elif.               : precond_elif precond.c 
                             >evalue un #if.                 : precond_if precond.c 
our enonc‚ #if ou #elif.     >evalue un expression logique p : precond_eval precond1.c 
                             >evalue un ifdef ou un ifndef.  : precond_ifdef precond.c 
.. >enregistre la valeur pour expansion de tab. par d‚faut 8 : filesrc_settab filesrc.c 
 #if ou #elif.     >evalue un expression logique pour enonc‚ : precond_eval precond1.c 
t simple) d'une chaine.      >extrait un caractŠre (guilleme : token_copyquote token6.c 
une chaine.                  >extrait un identificateur c d' : token_copyid token1.c 
                             >extrait un nombre d'une chaine : token_copynumber token1.c 
e (guillemet double) d'une ch>extrait une chaine de caractŠr : token_copystring token6.c 
ole si c'est un define.      >fait le remplacement d'un symb : preproc_convert preproc1.c 
Štres formels par les argumen>fait le remplacement des param : preproc_expand preproc2.c 
etourne un token, si le token fait partie de tb[][0] appelle : token_getskip token3.c 
urce.                        >ferme le fichier d'input du so : filesrc_close filesrc.c 
 de source c.                >ferme le fichier de r‚‚criture : outsrc_close outsrc.c 
oken_open.                   >ferme le fichier ouvert avec t : token_close token.c 
a collecte des tokens dans un fichier.           >redirige l : token_open token.c 
             >retourne nom du fichier couramment en lecture. : filesrc_curfile filesrc.c 
ourne num‚ro de ligne dans le fichier courant.          >ret : filesrc_curline filesrc.c 
 erreu>enregistre la ligne et fichier courant pour prochaine : lexcerr_lockinfo lexcerr.c 
   >output d'un token dans le fichier d'‚criture de source.  : outsrc_prttoken outsrc.c 
'un chaine arbitraire dans le fichier d'‚criture de source.> : outsrc_print outsrc.c 
it une nouvelle ligne dans le fichier d'input.            >l : filesrc_fill filesrc.c 
                    >ferme le fichier d'input du source.     : filesrc_close filesrc.c 
celui d‚j… ouvert da>ouvre un fichier d'input en conservant  : filesrc_pushopen filesrc.c 
e c.                >ferme le fichier de r‚‚criture de sourc : outsrc_close outsrc.c 
exte … analyser.>s‚lection du fichier name comme source du t : filesrc_open filesrc.c 
                    >ferme le fichier ouvert avec token_open : token_close token.c 
es path pour localisation des fichiers d'inclusion.>enregist : filesrc_setpath filesrc.c 
te des commentaires.>saute la fin d'une ligne en tenant comp : precond_skipline precond.c 
                >d‚termine la fin d'une string.              : token_skipstring token6.c 
e remplacement des paramŠtres formels par les arguments.>fai : preproc_expand preproc2.c 
quel niveau d'imbrication, la g‚n‚ration */.             >a  : precond_init precond.c 
 pour ˆtre retrait‚ par token_get().      >retourne un token : token_unget token.c 
>reconnait un caractŠre entre guillement simple et compose l : token_quote token1.c 
rait une chaine de caractŠre (guillemet double) d'une chaine : token_copystring token6.c 
finition d'un caractŠre entre guillemet simple.    >saute d‚ : token_skipquote token6.c 
       >extrait un caractŠre (guillemet simple) d'une chaine : token_copyquote token6.c 
ractŠre est un d‚but valide d'identificateur.>retourne != 0  : token_idok token1.c 
                  >extrait un identificateur c d'une chaine. : token_copyid token1.c 
ok>reconnait un mot-cl‚ ou un identificateur et compose le t : token_id token1.c 
                             >identifie op‚rateur c.         : token_oper token5.c 
         >retourne 1 si token identique, 0 sinon.            : token_egaux token4.c 
                  >evalue un #if.                            : precond_if precond.c 
pression logique pour enonc‚ #if ou #elif.     >evalue un ex : precond_eval precond1.c 
                   >evalue un ifdef ou un ifndef.            : precond_ifdef precond.c 
       >evalue un ifdef ou un ifndef.                        : precond_ifdef precond.c 
             >a quel niveau d'imbrication, la g‚n‚ration */. : precond_init precond.c 
>controle si les commentaires imbriqu‚es sont permis ou pas. : token_setcommode token2.c 
 lexicale.                   >impression de message d'erreur : lexcerr_bprintf lexcerr.c 
r stdout.                    >imprime le texte d'un token su : token_print token4.c 
r localisation des fichiers d'inclusion.>enregistre la liste : filesrc_setpath filesrc.c 
inserer entre deux token.    >indique si un blanc doit etre  : token_needsep token4.c 
ur.                   >oublie information sur prochaine erre : lexcerr_unlock lexcerr.c 
                    >localise information sur un symbole.    : preproc_locate preproc1.c 
n.                           >initialise la collecte de toke : token_init token.c 
en … partir d'une chaine.    >initialise la structure de tok : token_make token.c 
collecte des textes de tokens>initialise ou r‚initialise la  : token_inittxt token4.c 
table de symbole des macros. >initialise ou r‚initialise la  : preproc_init preproc1.c 
velle ligne dans le fichier d'input.            >lit une nou : filesrc_fill filesrc.c 
          >ferme le fichier d'input du source.               : filesrc_close filesrc.c 
 ouvert da>ouvre un fichier d'input en conservant celui d‚j… : filesrc_pushopen filesrc.c 
indique si un blanc doit etre inserer entre deux token.    > : token_needsep token4.c 
  >retourne ligne courante de lecture.                       : token_getnoline token.c 
 nom du fichier couramment en lecture.             >retourne : filesrc_curfile filesrc.c 
mpression de message d'erreur lexicale.                   >i : lexcerr_bprintf lexcerr.c 
uvelle position d'allocation, lib‚rant une portion.>enregist : token_setmarktxt token4.c 
n courante d'‚criture dans la ligne.    >retourne la positio : outsrc_curcol outsrc.c 
s et les commentaire dans une ligne.        >saute les blanc : precond_skipcom precond.c 
                    >retourne ligne courante de lecture.     : token_getnoline token.c 
          >retourne num‚ro de ligne dans le fichier courant. : filesrc_curline filesrc.c 
            >lit une nouvelle ligne dans le fichier d'input. : filesrc_fill filesrc.c 
mentaires.>saute la fin d'une ligne en tenant compte des com : precond_skipline precond.c 
prochaine erreu>enregistre la ligne et fichier courant pour  : lexcerr_lockinfo lexcerr.c 
                  >traite une ligne qui d‚bute par #.        : preproc_anal preproc.c 
on des fichiers>enregistre la liste des path pour localisati : filesrc_setpath filesrc.c 
token valide.                >lit un token et retourne 0 si  : token_get0 token.c 
token valide.                >lit un token et retourne 0 si  : token_get token.c 
 fichier d'input.            >lit une nouvelle ligne dans le : filesrc_fill filesrc.c 
gistre la liste des path pour localisation des fichiers d'in : filesrc_setpath filesrc.c 
mbole.                       >localise information sur un sy : preproc_locate preproc1.c 
if.     >evalue un expression logique pour enonc‚ #if ou #el : precond_eval precond1.c 
   >saute le d‚finition d'une macro #define.                 : token_skipmacro token2.c 
nt.           >enregistre une macro simple et son remplaceme : preproc_putdef preproc1.c 
alise la table de symbole des macros. >initialise ou r‚initi : preproc_init preproc1.c 
 d‚claration de la toutes les macros d‚j… enregistr‚.>affich : preproc_dumpmac preproc1.c 
les commentaires sont sautee, mais accumule. le prochain tok : token_skipcomment token2.c 
               >impression de message d'erreur lexicale.     : lexcerr_bprintf lexcerr.c 
ur.            >enregistre le mode d'activit‚ du pr‚processe : token_setpreproc token.c 
ssigne la chaine associ‚ … un mot cl‚.                  >r‚a : token_chgkeyword token1.c 
t compose le tok>reconnait un mot-cl‚ ou un identificateur e : token_id token1.c 
e ou pas.  >enregistre si les mots cl‚s doivent ˆtre reconnu : token_setchkkey token1.c 
nalyser.>s‚lection du fichier name comme source du texte … a : filesrc_open filesrc.c 
ation */.             >a quel niveau d'imbrication, la g‚n‚r : precond_init precond.c 
ecture.             >retourne nom du fichier couramment en l : filesrc_curfile filesrc.c 
le pr‚processeur.>retourne le nombre d'erreur d‚tect‚es par  : lexcerr_getnb lexcerr.c 
                  >extrait un nombre d'une chaine.           : token_copynumber token1.c 
                >reconnait un nombre et compose le token.    : token_number token1.c 
 partir de ptl et retourne le nouveau ptl.>saute les blancs  : token_skipwhite token.c 
 d'input.            >lit une nouvelle ligne dans le fichier : filesrc_fill filesrc.c 
 des textes de tok>etablie la nouvelle position d'allocation : token_settxt token4.c 
, lib‚rant une>enregistre une nouvelle position d'allocation : token_setmarktxt token4.c 
          >retourne la valeur num‚rique d'un token.          : token_evalnum token1.c 
r courant.          >retourne num‚ro de ligne dans le fichie : filesrc_curline filesrc.c 
'allocation pour le texte des>obtient la position courante d : token_getmarktxt token4.c 
toke>retourne une position o— on peut accumuler un texte de  : token_alloctxt token4.c 
 le fichier ouvert avec token_open.                   >ferme : token_close token.c 
                   >identifie op‚rateur c.                   : token_oper token5.c 
ssion logique pour enonc‚ #if ou #elif.     >evalue un expre : precond_eval precond1.c 
de toke>retourne une position o— on peut accumuler un texte  : token_alloctxt token4.c 
ts cl‚s doivent ˆtre reconnue ou pas.  >enregistre si les mo : token_setchkkey token1.c 
taires imbriqu‚es sont permis ou pas.>controle si les commen : token_setcommode token2.c 
s textes de tokens>initialise ou r‚initialise la collecte de : token_inittxt token4.c 
mbole des macros. >initialise ou r‚initialise la table de sy : preproc_init preproc1.c 
e le tok>reconnait un mot-cl‚ ou un identificateur et compos : token_id token1.c 
             >evalue un ifdef ou un ifndef.                  : precond_ifdef precond.c 
mmentaire qui a ‚t‚ accumul‚ (oublie ensuite).>retourne le d : token_lastcomment token2.c 
ne erreur.                   >oublie information sur prochai : lexcerr_unlock lexcerr.c 
dans le fichier d'‚criture de>output d'un chaine arbitraire  : outsrc_print outsrc.c 
ier d'‚criture de source.    >output d'un token dans le fich : outsrc_prttoken outsrc.c 
            >ferme le fichier ouvert avec token_open.        : token_close token.c 
nput en conservant celui d‚j… ouvert dans une pile.>ouvre un : filesrc_pushopen filesrc.c 
nservant celui d‚j… ouvert da>ouvre un fichier d'input en co : filesrc_pushopen filesrc.c 
umen>fait le remplacement des paramŠtres formels par les arg : preproc_expand preproc2.c 
ne un token, si le token fait partie de tb[][0] appelle recu : token_getskip token3.c 
alise la structure de token … partir d'une chaine.    >initi : token_make token.c 
ouveau ptl>saute les blancs … partir de ptl et retourne le n : token_skipwhite token.c 
cl‚s doivent ˆtre reconnue ou pas.  >enregistre si les mots  : token_setchkkey token1.c 
res imbriqu‚es sont permis ou pas.>controle si les commentai : token_setcommode token2.c 
hiers>enregistre la liste des path pour localisation des fic : filesrc_setpath filesrc.c 
 commentaires imbriqu‚es sont permis ou pas.>controle si les : token_setcommode token2.c 
e>retourne une position o— on peut accumuler un texte de tok : token_alloctxt token4.c 
nt celui d‚j… ouvert dans une pile.>ouvre un fichier d'input : filesrc_pushopen filesrc.c 
on d'allocation, lib‚rant une portion.>enregistre une nouvel : token_setmarktxt token4.c 
 pour le texte des>obtient la position courante d'allocation : token_getmarktxt token4.c 
ans la ligne.    >retourne la position courante d'‚criture d : outsrc_curcol outsrc.c 
es de tok>etablie la nouvelle position d'allocation des text : token_settxt token4.c 
t une>enregistre une nouvelle position d'allocation, lib‚ran : token_setmarktxt token4.c 
re */.                       >position de la derniere ecritu : outsrc_open outsrc.c 
un texte de toke>retourne une position o— on peut accumuler  : token_alloctxt token4.c 
egistre le mode d'activit‚ du pr‚processeur.            >enr : token_setpreproc token.c 
finition pour le remplacement pr‚processeur.>enregistre une  : token_setdef token2.c 
bre d'erreur d‚tect‚es par le pr‚processeur..>retourne le no : lexcerr_getnb lexcerr.c 
ont sautee, mais accumule. le prochain token valide.>les com : token_skipcomment token2.c 
      >oublie information sur prochaine erreur.              : lexcerr_unlock lexcerr.c 
ligne et fichier courant pour prochaine erreur.>enregistre l : lexcerr_lockinfo lexcerr.c 
de ptl et retourne le nouveau ptl.>saute les blancs … partir : token_skipwhite token.c 
>saute les blancs … partir de ptl et retourne le nouveau ptl : token_skipwhite token.c 
g‚n‚ration */.             >a quel niveau d'imbrication, la  : precond_init precond.c 
un mot cl‚.                  >r‚assigne la chaine associ‚ …  : token_chgkeyword token1.c 
uillement simple et compose l>reconnait un caractŠre entre g : token_quote token1.c 
ntificateur et compose le tok>reconnait un mot-cl‚ ou un ide : token_id token1.c 
 le token.                   >reconnait un nombre et compose : token_number token1.c 
Šre (string) et compose le to>reconnait une chaine de caract : token_string token1.c 
         >dernier commentaire reconnue */.                   : token_initcomment token2.c 
si les mots cl‚s doivent ˆtre reconnue ou pas.  >enregistre  : token_setchkkey token1.c 
ait partie de tb[][0] appelle recursivement.>retourne un tok : token_getskip token3.c 
s dans un fichier.           >redirige la collecte des token : token_open token.c 
         >ferme le fichier de r‚‚criture de source c.        : outsrc_close outsrc.c 
re la dimension d'un tab pour reg‚n‚ration d'un source.>enre : outsrc_settab outsrc.c 
extes de tokens>initialise ou r‚initialise la collecte des t : token_inittxt token4.c 
le des macros. >initialise ou r‚initialise la table de symbo : preproc_init preproc1.c 
..                           >remet le compteur d'erreur … 0 : lexcerr_reset lexcerr.c 
istre une macro simple et son remplacement.           >enreg : preproc_putdef preproc1.c 
'est un define.      >fait le remplacement d'un symbole si c : preproc_convert preproc1.c 
rmels par les argumen>fait le remplacement des paramŠtres fo : preproc_expand preproc2.c 
gistre une d‚finition pour le remplacement pr‚processeur.>en : token_setdef token2.c 
 un d‚but valide d'identifica>retourne != 0 si caractŠre est : token_idok token1.c 
             >lit un token et retourne 0 si token valide.    : token_get0 token.c 
             >lit un token et retourne 0 si token valide.    : token_get token.c 
 0 sinon.                    >retourne 1 si token identique, : token_egaux token4.c 
d'‚criture dans la ligne.    >retourne la position courante  : outsrc_curcol outsrc.c 
'un token.                   >retourne la valeur num‚rique d : token_evalnum token1.c 
e qui a ‚t‚ accumul‚ (oublie >retourne le dernier commentair : token_lastcomment token2.c 
tect‚es par le pr‚processeur.>retourne le nombre d'erreur d‚ : lexcerr_getnb lexcerr.c 
les blancs … partir de ptl et retourne le nouveau ptl.>saute : token_skipwhite token.c 
‚ au token.                  >retourne le texte ascii associ : token_txt token4.c 
ture.                        >retourne ligne courante de lec : token_getnoline token.c 
ment en lecture.             >retourne nom du fichier couram : filesrc_curfile filesrc.c 
le fichier courant.          >retourne num‚ro de ligne dans  : filesrc_curline filesrc.c 
trait‚ par token_get().      >retourne un token pour ˆtre re : token_unget token.c 
 fait partie de tb[][0] appel>retourne un token, si le token : token_getskip token3.c 
ut accumuler un texte de toke>retourne une position o— on pe : token_alloctxt token4.c 
 >retourne un token pour ˆtre retrait‚ par token_get().      : token_unget token.c 
e entre guillemet simple.    >saute d‚finition d'un caractŠr : token_skipquote token6.c 
nant compte des commentaires.>saute la fin d'une ligne en te : precond_skipline precond.c 
o #define.                   >saute le d‚finition d'une macr : token_skipmacro token2.c 
tl et retourne le nouveau ptl>saute les blancs … partir de p : token_skipwhite token.c 
taire dans une ligne.        >saute les blancs et les commen : precond_skipcom precond.c 
hain to>les commentaires sont sautee, mais accumule. le proc : token_skipcomment token2.c 
e source du texte … analyser.>s‚lection du fichier name comm : filesrc_open filesrc.c 
u texte … analyser.          >s‚lection stdin comme source d : filesrc_setstdin filesrc.c 
 le remplacement d'un symbole si c'est un define.      >fait : preproc_convert preproc1.c 
de d'identifica>retourne != 0 si caractŠre est un d‚but vali : token_idok token1.c 
][0] appel>retourne un token, si le token fait partie de tb[ : token_getskip token3.c 
 sont permis ou pas.>controle si les commentaires imbriqu‚es : token_setcommode token2.c 
reconnue ou pas.  >enregistre si les mots cl‚s doivent ˆtre  : token_setchkkey token1.c 
                  >retourne 1 si token identique, 0 sinon.   : token_egaux token4.c 
  >lit un token et retourne 0 si token valide.               : token_get0 token.c 
  >lit un token et retourne 0 si token valide.               : token_get token.c 
entre deux token.    >indique si un blanc doit etre inserer  : token_needsep token4.c 
'un caractŠre entre guillemet simple.    >saute d‚finition d : token_skipquote token6.c 
un caractŠre entre guillement simple et compose le token.>re : token_quote token1.c 
        >enregistre une macro simple et son remplacement.    : preproc_putdef preproc1.c 
trait un caractŠre (guillemet simple) d'une chaine.      >ex : token_copyquote token6.c 
ourne 1 si token identique, 0 sinon.                    >ret : token_egaux token4.c 
nregistre une macro simple et son remplacement.           >e : preproc_putdef preproc1.c 
i les commentaires imbriqu‚es sont permis ou pas.>controle s : token_setcommode token2.c 
 prochain to>les commentaires sont sautee, mais accumule. le : token_skipcomment token2.c 
un tab pour reg‚n‚ration d'un source.>enregistre la dimensio : outsrc_settab outsrc.c 
dans le fichier d'‚criture de source.>output d'un chaine arb : outsrc_print outsrc.c 
dans le fichier d'‚criture de source.    >output d'un token  : outsrc_prttoken outsrc.c 
 >ferme le fichier d'input du source.                        : filesrc_close filesrc.c 
e le fichier de r‚‚criture de source c.                >ferm : outsrc_close outsrc.c 
       >s‚lection stdin comme source du texte … analyser.    : filesrc_setstdin filesrc.c 
lection du fichier name comme source du texte … analyser..>s : filesrc_open filesrc.c 
analyser.          >s‚lection stdin comme source du texte …  : filesrc_setstdin filesrc.c 
prime le texte d'un token sur stdout.                    >im : token_print token4.c 
      >d‚termine la fin d'une string.                        : token_skipstring token6.c 
nait une chaine de caractŠre (string) et compose le token.>r : token_string token1.c 
une chaine.    >initialise la structure de token … partir d' : token_make token.c 
          >oublie information sur prochaine erreur.          : lexcerr_unlock lexcerr.c 
 >imprime le texte d'un token sur stdout.                    : token_print token4.c 
        >localise information sur un symbole.                : preproc_locate preproc1.c 
 >localise information sur un symbole.                       : preproc_locate preproc1.c 
e ou r‚initialise la table de symbole des macros. >initialis : preproc_init preproc1.c 
   >fait le remplacement d'un symbole si c'est un define.    : preproc_convert preproc1.c 
>enregistre la dimension d'un tab pour reg‚n‚ration d'un sou : outsrc_settab outsrc.c 
e la valeur pour expansion de tab. par d‚faut 8.. >enregistr : filesrc_settab filesrc.c 
initialise ou r‚initialise la table de symbole des macros. > : preproc_init preproc1.c 
n, si le token fait partie de tb[][0] appelle recursivement. : token_getskip token3.c 
le dernier commentaire qui a ‚t‚ accumul‚ (oublie ensuite).> : token_lastcomment token2.c 
 >saute la fin d'une ligne en tenant compte des commentaires : precond_skipline precond.c 
lection stdin comme source du texte … analyser.          >s‚ : filesrc_setstdin filesrc.c 
 fichier name comme source du texte … analyser..>s‚lection d : filesrc_open filesrc.c 
                 >retourne le texte ascii associ‚ au token.  : token_txt token4.c 
                  >imprime le texte d'un token sur stdout.   : token_print token4.c 
ition o— on peut accumuler un texte de token.>retourne une p : token_alloctxt token4.c 
courante d'allocation pour le texte des token.>obtient la po : token_getmarktxt token4.c 
lle position d'allocation des textes de token.>etablie la no : token_settxt token4.c 
 r‚initialise la collecte des textes de tokens.>initialise o : token_inittxt token4.c 
   >initialise la collecte de token.                         : token_init token.c 
on d'allocation des textes de token.>etablie la nouvelle pos : token_settxt token4.c 
urne la valeur num‚rique d'un token.                   >reto : token_evalnum token1.c 
 doit etre inserer entre deux token.    >indique si un blanc : token_needsep token4.c 
 identificateur et compose le token.>reconnait un mot-cl‚ ou : token_id token1.c 
actŠre (string) et compose le token.>reconnait une chaine de : token_string token1.c 
on peut accumuler un texte de token.>retourne une position o : token_alloctxt token4.c 
'allocation pour le texte des token.>obtient la position cou : token_getmarktxt token4.c 
rne le texte ascii associ‚ au token.                  >retou : token_txt token4.c 
illement simple et compose le token.>reconnait un caractŠre  : token_quote token1.c 
nnait un nombre et compose le token.                   >reco : token_number token1.c 
  >initialise la structure de token … partir d'une chaine.   : token_make token.c 
re de source.    >output d'un token dans le fichier d'‚critu : outsrc_prttoken outsrc.c 
alide.                >lit un token et retourne 0 si token v : token_get0 token.c 
alide.                >lit un token et retourne 0 si token v : token_get token.c 
ppel>retourne un token, si le token fait partie de tb[][0] a : token_getskip token3.c 
               >retourne 1 si token identique, 0 sinon.      : token_egaux token4.c 
oken_get().      >retourne un token pour ˆtre retrait‚ par t : token_unget token.c 
       >imprime le texte d'un token sur stdout.              : token_print token4.c 
lit un token et retourne 0 si token valide.                > : token_get0 token.c 
lit un token et retourne 0 si token valide.                > : token_get token.c 
e, mais accumule. le prochain token valide.>les commentaires : token_skipcomment token2.c 
 de tb[][0] appel>retourne un token, si le token fait partie : token_getskip token3.c 
 token pour ˆtre retrait‚ par token_get().      >retourne un : token_unget token.c 
>ferme le fichier ouvert avec token_open.                    : token_close token.c 
ise la collecte des textes de tokens.>initialise ou r‚initia : token_inittxt token4.c 
    >redirige la collecte des tokens dans un fichier.        : token_open token.c 
>affiche la d‚claration de la toutes les macros d‚j… enregis : preproc_dumpmac preproc1.c 
r #.                         >traite une ligne qui d‚bute pa : preproc_anal preproc.c 
e.                           >traitement de la directive els : precond_else precond.c 
tre si les mots cl‚s doivent ˆtre reconnue ou pas.  >enregis : token_setchkkey token1.c 
     >retourne un token pour ˆtre retrait‚ par token_get().  : token_unget token.c 
                 >retourne la valeur num‚rique d'un token.   : token_evalnum token1.c 
par d‚faut 8.. >enregistre la valeur pour expansion de tab.  : filesrc_settab filesrc.c 
 token et retourne 0 si token valide.                >lit un : token_get0 token.c 
s accumule. le prochain token valide.>les commentaires sont  : token_skipcomment token2.c 
 token et retourne 0 si token valide.                >lit un : token_get token.c 
= 0 si caractŠre est un d‚but valide d'identificateur.>retou : token_idok token1.c 
       >enregistre un #endif, v‚rifie s'il est acceptable.   : precond_endif precond.c