/*~04/04/90 23.19.56! filesrc_setstdin N */
/*
    S‚lection stdin comme source du texte … analyser
*/
void filesrc_setstdin(
	void)

/*~04/04/90 23.19.56! filesrc_open N */
/*
    S‚lection du fichier name comme source du texte … analyser
*/
int filesrc_open(
	const char *name)

/*~04/04/90 23.19.56! filesrc_setpath N */
/*
    Enregistre la liste des path pour localisation des fichiers d'inclusion
    Peut ˆtre appel‚ plusieurs fois, les path seront ajout‚s.
*/
export void filesrc_setpath(
	const char *pathlst)

/*~04/04/90 23.19.56! filesrc_curfile N */
/*
    Retourne nom du fichier couramment en lecture
*/
export const char *filesrc_curfile(
	void)

/*~04/04/90 23.19.56! filesrc_curline N */
/*
    Retourne num‚ro de ligne dans le fichier courant
*/
export int filesrc_curline(
	void)

/*~04/04/90 23.19.56! filesrc_pushopen N */
/*
    Ouvre un fichier d'input en conservant celui d‚j… ouvert dans une pile
    Cherche le fichier dans les r‚pertoires founis dans le filesrc_setfpath()
*/
void filesrc_pushopen(
	const char *fname,
	int locdir)	/* recherche dans le r‚pertoire local en premier */

/*~04/04/90 23.19.56! filesrc_close N */
/*
    Ferme le fichier d'input du source
*/
void filesrc_close(
	void)

/*~04/04/90 23.19.56! filesrc_fill N */
/*
    Lit une nouvelle ligne dans le fichier d'input
    Traite le caractŠre de continuation \ en concat‚nant la ligne
    suivante. Doit ˆtre le dernier caractŠre de la ligne
    Fait l'expansion des tab.
    Retourne -1 si fin de fichier
    Si aucun fichier n'a ‚t‚ ouvert, retourne -1
*/
int filesrc_fill(
	char *linres)

/*~03/02/90 01.19.04! lexcerr_unlock N */
/*
    Oublie information sur prochaine erreur
*/
void lexcerr_unlock(
	void)

/*~03/02/90 01.19.04! lexcerr_lockinfo N */
/*
    Enregistre la ligne et fichier courant pour prochaine erreur
*/
void lexcerr_lockinfo(
	void)

/*~03/02/90 01.19.04! lexcerr_bprintf N */
/*
    Impression de message d'erreur lexicale
*/
void lexcerr_bprintf(
	const char *ctlf,
	const char *ctla,
	...)

/*~28/02/90 21.09.16! outsrc_open N */
/* position de la derniere ecriture */
/*
    Ouvre un fichier pour la r‚‚criture des tokens
*/
export void outsrc_open(
	char *nomout)

/*~28/02/90 21.09.16! outsrc_close N */
/*
    Ferme le fichier de r‚‚criture de source C
*/
export void outsrc_close(
	void)

/*~28/02/90 21.09.16! outsrc_curcol N */
/*
    Retourne la position courante d'‚criture dans la ligne
*/
export int outsrc_curcol(
	void)

/*~28/02/90 21.09.16! outsrc_print N */
/*
    Output d'un chaine arbitraire dans le fichier d'‚criture de source
    Sans effet si outsrc_open n'a pas ‚t‚ fait
    Retourne le nombre de caractŠre g‚n‚r‚
*/
export int outsrc_print(
	char *ctl,
	...)

/*~28/02/90 21.09.16! outsrc_prttoken N */
/*
    Output d'un token dans le fichier d'‚criture de source
*/
export void outsrc_prttoken(
	TOKEN *tok)

/*~02/03/90 01.02.04! precond_init N */
/* a quel niveau d'imbrication, la g‚n‚ration */
/* sera r‚activ‚ */
/*
    initialise les traitements des constructions conditionnelles
    #if,#else,...
*/
void precond_init(
	void)

/*~02/03/90 01.02.04! precond_else N */
/*
    Traitement de la directive else
    Saute les ‚nonc‚ jusqu'au endif
*/
char *precond_else(
	char *line,
	char *ptl)	/* buffer */

/*~02/03/90 01.02.04! precond_endif N */
/*
    Enregistre un #endif, v‚rifie s'il est acceptable
*/
char *precond_endif(
	char *line,
	char *ptl)

/*~02/03/90 01.02.04! precond_skipcom N */
/*
    Saute les blancs et les commentaire dans une ligne
    Retourne != 0 si encore dans la meme ligne, 0 si sur une ligne suivante
*/
int precond_skipcom(
	char **ppt,
	char *line)

/*~02/03/90 01.02.04! precond_skipline N */
/*
    Saute la fin d'une ligne en tenant compte des commentaires
    Les commentaires peuvent continuer sur plusieurs lignes
    Retourne ptr sur dernier commentaire de la ligne ou sur '\0'
*/
char *precond_skipline(
	char **pptl,
	char *line)

/*~02/03/90 01.02.04! precond_ifdef N */
/*
    Evalue un ifdef ou un ifndef
    Retourne position de traitement dans la ligne
*/
char *precond_ifdef(
	char *line,
	char *ptl,
	int mode)	/* 0 : ifdef, 1 : ifndef */

/*~02/03/90 01.02.04! precond_if N */
/*
    Evalue un #if
    Retourne position de traitement dans la ligne aprŠs l'expression
*/
char *precond_if(
	char *line,
	char *ptl)

/*~02/03/90 01.02.04! precond_elif N */
/*
    Evalue un #elif
    Retourne position de traitement dans la ligne aprŠs l'expression
*/
char *precond_elif(
	char *line,
	char *ptl)

/*~11/01/91 13.35.16! precond_eval N */
/*
    Evalue un expression logique pour enonc‚ #if ou #elif
    Retourne 0 si faux, !=0 si vrai
    Supporte les || et && et ! et defined
    NOTE : Les commentaires sont permis dans les expressions
    Durant l'‚valuation le remplacement macro devient disponible s'il
    ne l'‚tait pas d‚j…
*/
int precond_eval(
	char **pptl,
	char *line)

/*~01/03/90 12.49.04! preproc_anal N */
/*
    Traite une ligne qui d‚bute par #
    Si le pr‚processeur n'est pas actif, seul certaine commandes sont
    trait‚es.
    Cette ligne est:
            un #define
            un #undef
            un conditionnel
            un #include
            ou quelques chose d'inconnu
    Retourne la position de lecture dans la ligne
*/
char *preproc_anal(
	char *line,	/* buffer de ligne */
	int preproc)	/* Indique si preprocesseur est actif */

/*~05/10/90 08.33.26! preproc_init N */
/*
    Initialise ou r‚initialise la table de symbole des macros
*/
void preproc_init(
	void)

/*~05/10/90 08.33.26! preproc_locate N */
/*
    Localise information sur un symbole
    Retourne info ou NULL si trouve pas
*/
DEF_SYM *preproc_locate(
	const char *nomdef)

/*~05/10/90 08.33.26! preproc_putdef N */
/*
    Enregistre une macro simple et son remplacement
*/
void preproc_putdef(
	const char *nomdef,	/* nom de la macro */
	const char *repl,	/* Chaine de remplacement */
	int lenrepl,
	char *tbprm[],	/* ParamŠtres */
	int nbprm,	/* Nombre de paramŠtres */
	int cmdline)	/* provient de la ligne de commande ou pas */

/*~05/10/90 08.33.26! preproc_recdefine N */
/*
    Enregistrement de la d‚claration d'un define
    Retourne position de traitement dans la ligne suivante car peut sauter
    des commentaires
    Le texte de remplacement sera minimalement trait‚. S'il y a des
    commentaires imbriqu‚s dans le texte, il sera conserv‚. La fonction
    preproc_skipline permet de localiser la fin de la ligne avant le
    dernier commentaire (potentiellement ‚tendue sur plusieurs lignes).
    La fonction charge alors une nouvelle ligne dans line, c'est pourquoi
    il faut faire une copie temporaire dans repl. Les valeurs debpt et
    endpt serve uniquement … identifi‚ la partie valide de repl.
*/
char *preproc_recdefine(
	char *line,	/* pointe au d‚but de la ligne #define */
	/* line est aussi le buffer unique de ligne */
	char *pt)

/*~05/10/90 08.33.26! preproc_errundef N */
/* Signale les erreurs de unref */
/*
    Enregistre si on doit signaler des erreurs de unref ou pas
*/
void preproc_errundef(
	int outputerr)

/*~05/10/90 08.33.26! preproc_undef N */
/*
    Elimine la d‚claration d'un define
    Retourne adresse de lecture dans la ligne
*/
char *preproc_undef(
	char *line,	/* pointe au d‚but de la ligne #undef */
	char *ptl)

/*~05/10/90 08.33.26! preproc_convert N */
/*
    Fait le remplacement d'un symbole si c'est un define
    Retourne 1 si le token a ‚t‚ remplac‚, 0 sinon
    Si le token ‚tait un define, la chaine de remplacement a ‚t‚
    copi‚ dans le buffer de traitement (line) en reculant ptl.
    Cela simule un insertion
    V‚rifie l'utilisation r‚cursive d'un symbole
*/
int preproc_convert(
	TOKEN *tok,	/* token … convertir si requis */
	char **ptl,	/* position de lecture dans la ligne */
	char *line)	/* buffer de lecture */

/*~01/03/90 01.36.50! preproc_expand N */
/*
    Fait le remplacement des paramŠtres formels par les arguments
    La chaine de remplacement transform‚e avec les arguments est
    plac‚s dans ptl en le reculant.
*/
void preproc_expand(
	char *line,	/* buffer de lecture */
	char **pptl,	/* pointeur dans le buffer */
	DEF_SYM *ptsym)	/* Definition de la macro */

/*~05/10/90 08.34.52! token_init N */
/*
    Initialise la collecte de token
    Par defaut, la lecture des tokens se fait sur stdin
*/
export void token_init(
	void)

/*~05/10/90 08.34.52! token_setpreproc N */
/*
    Enregistre le mode d'activit‚ du pr‚processeur
    0 : pas actif
    1 : actif   ->  traitement des includes
                    traitement des defines
                    traitement des #if
    Par d‚faut pas actif
    Retourne ancien mode
*/
export int token_setpreproc(
	int mode)

/*~05/10/90 08.34.52! token_open N */
/*
    Redirige la collecte des tokens dans un fichier
    Retourne 0 si -1 si ne peut ouvrir
*/
export int token_open(
	const char *name)

/*~05/10/90 08.34.52! token_close N */
/*
    Ferme le fichier ouvert avec token_open
*/
export void token_close(
	void)

/*~05/10/90 08.34.52! token_getnoline N */
/*
    retourne ligne courante de lecture
*/
export int token_getnoline(
	void)

/*~05/10/90 08.34.52! token_unget N */
/*
    Retourne un token pour ˆtre retrait‚ par token_get()
*/
export void token_unget(
	TOKEN *tok)

/*~05/10/90 08.34.52! token_skipwhite N */
/*
    Saute les blancs … partir de ptl et retourne le nouveau ptl
    Si arrive au bout de la ligne, lit la suivante
    Retourne ptl pointant soit un un caractŠre non blanc, soit sur
    '\0' si fin de fichier
*/
char *token_skipwhite(
	char *ptl,
	char *line)

/*~05/10/90 08.34.52! token_get0 N */
/*
    Lit un token et retourne 0 si token valide
    -1 si plus de token
*/
int token_get0(
	TOKEN *tok,
	char **pptl,
	char *line,
	int actif,	/* !=0 si pas dans une section ‚limin‚e */
	int readl)	/* !=0: lit une ligne quand fin de ligne courante */
	/* ==0: Retourne -1 a la fin de la ligne courante */

/*~05/10/90 08.34.52! token_get N */
/*
    Lit un token et retourne 0 si token valide
    -1 si plus de token
*/
export int token_get(
	TOKEN *tok)

/*~05/10/90 08.34.52! token_make N */
/*
    Initialise la structure de token … partir d'une chaine
*/
export void token_make(
	TOKEN *token,
	char *txt)

/*~26/01/91 09.23.54! token_copyid N */
/*
    extrait un identificateur C d'une chaine
    Retourne position imm‚diatement aprŠs la fin de l'identificateur
*/
char *token_copyid(
	char *ptl,	/* pointe au d‚but du ID */
	char *text)	/* contiendre le ID + '\0' */

/*~26/01/91 09.23.54! token_idok N */
/*
    Retourne != 0 si caractŠre est un d‚but valide d'identificateur
*/
int token_idok(
	char carac)

/*~26/01/91 09.23.54! token_chgkeyword N */
/*
    R‚assigne la chaine associ‚ … un mot cl‚
    str vaut "vieux=nouveau" ou "vieux"; dans ce dernier cas le mot
    cl‚ est annul‚
    Retourne -1 si chaine invalide ou mot-cl‚ inconnue
*/
export int token_chgkeyword(
	const char *str)

/*~26/01/91 09.23.54! token_id N */
/*
    Reconnait un mot-cl‚ ou un identificateur et compose le token
    Retourne l'adresse dans la chaine aprŠs le token
*/
char *token_id(
	TOKEN *tok,	/* token … composer */
	char *ptl)	/* chaine … analyser */
	/* ptl pointe sur le d‚but d'un identificateur */

/*~26/01/91 09.23.54! token_copynumber N */
/*
    Extrait un nombre d'une chaine
    Retourne nouvelle valeur de ptl (saute le token)
    Reconnait uniquement les nombre entier (hexadecimaux aussi)
*/
char *token_copynumber(
	char *text,
	char *ptl)

/*~26/01/91 09.23.54! token_evalnum N */
long token_evalnum(
	TOKEN *tok)

/*~26/01/91 09.23.54! token_number N */
/*
    Reconnait un nombre et compose le token
    Retourne nouvelle valeur de ptl (saute le token)
    Reconnait uniquement le nombre entier
*/
export char *token_number(
	TOKEN *tok,	/* token … composer */
	char *ptl)	/* chaine … analyser */
	/* ptl pointe sur le d‚but d'un nombre */

/*~26/01/91 09.23.54! token_string N */
/*
    Reconnait une chaine de caractŠre (string) et compose le token
    Retourne nouvelle valeur de ptl (saute le token)
    Ne comprend pas la syntaxe de continuation
*/
char *token_string(
	TOKEN *tok,	/* token … composer */
	char *ptl)	/* chaine … analyser */
	/* ptl pointe sur le d‚but d'une chaine */

/*~26/01/91 09.23.54! token_quote N */
/*
    Reconnait un caractŠre entre guillement simple et compose le token
    Retourne nouvelle valeur de ptl (saute le token)
*/
char *token_quote(
	TOKEN *tok,	/* token … composer */
	char *ptl)	/* chaine … analyser */
	/* ptl pointe sur un ' */

/*~13/08/90 22.54.50! token_initcomment N */
/* dernier commentaire reconnue */
/*
    Initialise ou r‚initialise la collecte des commentaire.
    Les commentaires sont accumul‚s dans un tampon.
    Le contenu du tampon est oubli‚.
*/
export void token_initcomment(
	void)

/*~13/08/90 22.54.50! token_setcommode N */
/*
    Controle si les commentaires imbriqu‚es sont permis ou pas
    imbriq != 0, permis, == 0, ignor‚s
    Pas d‚faut, il sont permis
*/
export void token_setcommode(
	int imbriq)

/*~13/08/90 22.54.50! token_skipcomment N */
/*
    Les commentaires sont sautee, mais accumule. Le prochain token valide
    obtiendra le nouveau commentaire
    La routine tente de reconnaitre comme un seul commentaire les commentaires
    qui se suivent
    Si ptl ne pointe pas au d‚but d'un commentaire, retourne sans rien faire
    Donc on peut appeler cette fonction sans v‚rifier qu'il y a un commentaire
    Supporte commentaire C++
    Retourne 1 si un commentaire a ‚t‚ vue, 0 sinon
*/
int token_skipcomment(
	char *line,
	char **pptl,
	int noline,
	int nocar)

/*~13/08/90 22.54.50! token_lastcomment N */
/*
    Retourne le dernier commentaire qui a ‚t‚ accumul‚ (oublie ensuite)
*/
TOKCOM *token_lastcomment(
	void)

/*~13/08/90 22.54.50! token_setdef N */
/*
    Enregistre une d‚finition pour le remplacement pr‚processeur
    La chaine de d‚finition est du type XXX=YYY ou XXX
*/
export void token_setdef(
	const char *def)

/*~13/08/90 22.54.50! token_skipmacro N */
/*
    Saute le d‚finition d'une macro #define
*/
char *token_skipmacro(
	char *line)

/*~28/03/90 23.24.34! token_getskip N */
/*
    retourne un token, si le token fait partie de tb[][0] appelle recursivement
    pour sauter jusqu'au match, au retour tok contient le dernier token lue
    Les tokens sont regenere sur l'output a mesure
    Retourne -1 si plus de token, 0 sinon
*/
export int token_getskip(
	TOKEN *tok,
	TOK_TYPE tb[][2],
	int nbtok)

/*~16/10/90 21.19.00! token_inittxt N */
/*
    Initialise ou r‚initialise la collecte des textes de tokens
    Les tokens (ascii) sont accumul‚ dans un tampon. Lorsqu'on sait
    que les tokens accumul‚s jusqu'… date ne seront plus requis
    cette fonction peut ˆtre appel‚ pour relacher l'espace occup‚.
*/
export void token_inittxt(
	void)

/*~16/10/90 21.19.00! token_alloctxt N */
/*
    Retourne une position o— on peut accumuler un texte de token
    On appelle cette fonction pour obtenir un pointeur, on copie
    le texte dans le pointeur, et on appelle token_settxt() en
    passant l'adresse corrig‚e du pointeur (saute le texte)
*/
char *token_alloctxt(
	void)

/*~16/10/90 21.19.00! token_getmarktxt N */
/*
    Obtient la position courante d'allocation pour le texte des token
    La fonction token_settxt() est utilis‚ pour lib‚rer le texte de tous
    les tokens allou‚s aprŠs cette fonction
*/
export char *token_getmarktxt(
	void)

/*~16/10/90 21.19.00! token_setmarktxt N */
/*
    Enregistre une nouvelle position d'allocation, lib‚rant une portion
    Le pointeur a ‚t‚ obtenue par token_getmarktxt().
*/
export void token_setmarktxt(
	char *mark)

/*~16/10/90 21.19.00! token_settxt N */
/*
    Etablie la nouvelle position d'allocation des textes de token
*/
void token_settxt(
	char *pttxt)

/*~16/10/90 21.19.00! token_txt N */
/*
    Retourne le texte ascii associ‚ au token
*/
export char *token_txt(
	TOKEN *tok)

/*~16/10/90 21.19.00! token_needsep N */
/*
    indique si un blanc doit etre inserer entre deux token
    Par convention tokp est celui qui precede tok1
*/
export int token_needsep(
	TOKEN *tok,
	TOKEN *tokp)

/*~16/10/90 21.19.00! token_print N */
/*
    Imprime le texte d'un token sur stdout
*/
export int token_print(
	TOKEN *tok)

/*~16/10/90 21.19.00! token_egaux N */
/*
    retourne 1 si token identique, 0 sinon
*/
int token_egaux(
	TOKEN *tok1,
	TOKEN *tok2)

/*~08/11/90 22.58.08! token_oper N */
/*
    Identifie op‚rateur C
    Retourne nouvelle position dans buffer d'analyse
    ConsidŠre que c'est forc‚ment un op‚rateur
*/
export char *token_oper(
	TOKEN *tok,
	const char *ptl)	/* Pointe sur d‚but d'op‚rateur */

/*~26/01/91 09.47.22! token_skipstring N */
/*
    D‚termine la fin d'une string
    ptl pointe sur le premier "
    Retourne pointeur sur le " de fermeture ou '\0' si erreur lexicale
*/
export char *token_skipstring(
	const char *ptl)

/*~26/01/91 09.47.22! token_copystring N */
/*
    extrait une chaine de caractŠre (guillemet double) d'une chaine
    Retourne pointeur aprŠs le " ou pointe … la fin de la chaine
    Retourne un pointeur sur n'importe quoi si lenmax est exc‚d‚
*/
export char *token_copystring(
	char *text,	/* destination */
	char *ptl,	/* chaine a lire */
	int lenmax)	/* longuer maximum */

/*~26/01/91 09.47.22! token_skipquote N */
/*
    Saute d‚finition d'un caractŠre entre guillemet simple
    ptl pointe sur le premier '
    Retourne pointeur sur le ' de fermeture ou '\0' si erreur lexicale
*/
export char *token_skipquote(
	const char *ptl)

/*~26/01/91 09.47.22! token_copyquote N */
/*
    extrait un caractŠre (guillemet simple) d'une chaine
    Retourne pointeur aprŠs le ' ou pointe … la fin de la chaine
    Retourne un pointeur sur n'importe quoi si lenmax est exc‚d‚
*/
export char *token_copyquote(
	char *text,	/* destination */
	char *ptl,	/* chaine … lire */
	int lenmax)	/* longueur maximum admissible */

/*~05/12/91 23.30.02! preproc_undef R */
/*
    Elimine la d‚claration d'un define
    Retourne adresse de lecture dans la ligne
*/
char *preproc_undef(
	char *,	/* pointe au d‚but de la ligne #undef */
	char *ptl)

/*~05/12/91 23.28.06! token_evalnum R */
/*
    Retourne la valeur num‚rique d'un token
    Si le token ne repr‚sente pas un nombre, retourne 0
*** Si le token repr‚sente un nombre point flottant, retourne 0
*/
long token_evalnum(
	TOKEN *tok)

/*~18/02/92 23.44.28! filesrc_setstdin R */
/*
    S‚lection stdin comme source du texte … analyser
*/
void filesrc_setstdin(
	void)

/*~18/02/92 23.44.28! filesrc_open R */
/*
    S‚lection du fichier name comme source du texte … analyser.
    Retourne -1 si ne peut pas ouvrir.
*/
int filesrc_open(
	const char *name)

/*~18/02/92 23.44.28! filesrc_setpath R */
/*
    Enregistre la liste des path pour localisation des fichiers d'inclusion
    Peut ˆtre appel‚ plusieurs fois, les path seront ajout‚s.
*/
export void filesrc_setpath(
	const char *pathlst)

/*~18/02/92 23.44.28! filesrc_curfile R */
/*
    Retourne nom du fichier couramment en lecture
*/
export const char *filesrc_curfile(
	void)

/*~18/02/92 23.44.28! filesrc_curline R */
/*
    Retourne num‚ro de ligne dans le fichier courant
*/
export int filesrc_curline(
	void)

/*~18/02/92 23.44.28! filesrc_pushopen R */
/*
    Ouvre un fichier d'input en conservant celui d‚j… ouvert dans une pile
    Cherche le fichier dans les r‚pertoires founis dans le filesrc_setfpath()
    Pr‚serve la position et le contenu de la ligne courante. A la fin de la
    lecture, ces informations permettront de repartir l'analyse
    … la mˆme position dans la ligne.
*/
void filesrc_pushopen(
	const char *fname,
	int locdir,	/* recherche dans le r‚pertoire local en premier */
	const char *ptl,	/* Position de traitement dans la ligne */
	const char *line)	/* Ligne en traitement */

/*~18/02/92 23.44.28! filesrc_close R */
/*
    Ferme le fichier d'input du source
*/
void filesrc_close(
	void)

/*~18/02/92 23.44.28! filesrc_settab N */
/*
    Enregistre la valeur pour expansion de tab. Par d‚faut 8.
    Cela est important pour la reg‚n‚ration des sources.
*/
export void filesrc_settab(
	int tab)

/*~18/02/92 23.44.28! filesrc_fill R */
/*
    Lit une nouvelle ligne dans le fichier d'input
    Traite le caractŠre de continuation \ en concat‚nant la ligne
    suivante. Doit ˆtre le dernier caractŠre de la ligne
    Fait l'expansion des tab.
    Retourne -1 si fin de fichier
    Si aucun fichier n'a ‚t‚ ouvert, retourne -1
*/
int filesrc_fill(
	char *linres)

/*~03/02/90 01.19.04! lexcerr_unlock R */
/*
    Oublie information sur prochaine erreur
*/
void lexcerr_unlock(
	void)

/*~03/02/90 01.19.04! lexcerr_lockinfo R */
/*
    Enregistre la ligne et fichier courant pour prochaine erreur
*/
void lexcerr_lockinfo(
	void)

/*~03/02/90 01.19.04! lexcerr_bprintf R */
/*
    Impression de message d'erreur lexicale
*/
void lexcerr_bprintf(
	const char *ctlf,
	const char *ctla,
	...)

/*~18/02/92 23.56.20! outsrc_open R */
/* position de la derniere ecriture */
/*
        Ouvre un fichier pour la r‚‚criture des tokens
*/
export void outsrc_open(
	char *nomout)

/*~18/02/92 23.56.20! outsrc_close R */
/*
        Ferme le fichier de r‚‚criture de source C
*/
export void outsrc_close(
	void)

/*~18/02/92 23.56.20! outsrc_settab N */
/*
        Enregistre la dimension d'un tab pour reg‚n‚ration d'un source
        Par d‚faut, utilise 8.
*/
export void outsrc_settab(
	int tab)

/*~18/02/92 23.56.20! outsrc_curcol R */
/*
    Retourne la position courante d'‚criture dans la ligne
*/
export int outsrc_curcol(
	void)

/*~18/02/92 23.56.20! outsrc_print R */
/*
    Output d'un chaine arbitraire dans le fichier d'‚criture de source
        Sans effet si outsrc_open n'a pas ‚t‚ fait
        Retourne le nombre de caractŠre g‚n‚r‚
*/
export int outsrc_print(
	char *ctl,
	...)

/*~18/02/92 23.56.20! outsrc_prttoken R */
/*
    Output d'un token dans le fichier d'‚criture de source
*/
export void outsrc_prttoken(
	TOKEN *tok)

/*~02/03/90 01.02.04! precond_init R */
/* a quel niveau d'imbrication, la g‚n‚ration */
/* sera r‚activ‚ */
/*
    initialise les traitements des constructions conditionnelles
    #if,#else,...
*/
void precond_init(
	void)

/*~02/03/90 01.02.04! precond_else R */
/*
    Traitement de la directive else
    Saute les ‚nonc‚ jusqu'au endif
*/
char *precond_else(
	char *line,
	char *ptl)	/* buffer */

/*~02/03/90 01.02.04! precond_endif R */
/*
    Enregistre un #endif, v‚rifie s'il est acceptable
*/
char *precond_endif(
	char *line,
	char *ptl)

/*~02/03/90 01.02.04! precond_skipcom R */
/*
    Saute les blancs et les commentaire dans une ligne
    Retourne != 0 si encore dans la meme ligne, 0 si sur une ligne suivante
*/
int precond_skipcom(
	char **ppt,
	char *line)

/*~02/03/90 01.02.04! precond_skipline R */
/*
    Saute la fin d'une ligne en tenant compte des commentaires
    Les commentaires peuvent continuer sur plusieurs lignes
    Retourne ptr sur dernier commentaire de la ligne ou sur '\0'
*/
char *precond_skipline(
	char **pptl,
	char *line)

/*~02/03/90 01.02.04! precond_ifdef R */
/*
    Evalue un ifdef ou un ifndef
    Retourne position de traitement dans la ligne
*/
char *precond_ifdef(
	char *line,
	char *ptl,
	int mode)	/* 0 : ifdef, 1 : ifndef */

/*~02/03/90 01.02.04! precond_if R */
/*
    Evalue un #if
    Retourne position de traitement dans la ligne aprŠs l'expression
*/
char *precond_if(
	char *line,
	char *ptl)

/*~02/03/90 01.02.04! precond_elif R */
/*
    Evalue un #elif
    Retourne position de traitement dans la ligne aprŠs l'expression
*/
char *precond_elif(
	char *line,
	char *ptl)

/*~05/12/91 23.22.00! precond_eval R */
/*
    Evalue un expression logique pour enonc‚ #if ou #elif
    Retourne 0 si faux, !=0 si vrai
    Supporte les || et && et ! et defined
    NOTE : Les commentaires sont permis dans les expressions
    Durant l'‚valuation le remplacement macro devient disponible s'il
    ne l'‚tait pas d‚j…
*/
int precond_eval(
	char **pptl,
	char *line)

/*~06/02/92 13.37.32! preproc_anal R */
/*
    Traite une ligne qui d‚bute par #
    Si le pr‚processeur n'est pas actif, seul certaine commandes sont
    trait‚es.
    Cette ligne est:
            un #define
            un #undef
            un conditionnel
            un #include
            ou quelques chose d'inconnu
    Retourne la position de lecture dans la ligne
*/
char *preproc_anal(
	char *line,	/* buffer de ligne */
	char *ptl,	/* Pointe apres le # */
	int preproc)	/* Indique si preprocesseur est actif */

/*~28/01/92 15.43.04! preproc_init R */
/*
    Initialise ou r‚initialise la table de symbole des macros
*/
void preproc_init(
	void)

/*~28/01/92 15.43.04! preproc_locate R */
/*
    Localise information sur un symbole
    Retourne info ou NULL si trouve pas
*/
DEF_SYM *preproc_locate(
	const char *nomdef)

/*~28/01/92 15.43.04! preproc_putdef R */
/*
    Enregistre une macro simple et son remplacement
*/
void preproc_putdef(
	const char *nomdef,	/* nom de la macro */
	const char *repl,	/* Chaine de remplacement */
	int lenrepl,
	char *tbprm[],	/* ParamŠtres */
	int nbprm,	/* Nombre de paramŠtres */
	int cmdline)	/* provient de la ligne de commande ou pas */

/*~28/01/92 15.43.04! preproc_recdefine R */
/*
    Enregistrement de la d‚claration d'un define
    Retourne position de traitement dans la ligne suivante car peut sauter
    des commentaires
    Le texte de remplacement sera minimalement trait‚. S'il y a des
    commentaires imbriqu‚s dans le texte, il sera conserv‚. La fonction
    preproc_skipline permet de localiser la fin de la ligne avant le
    dernier commentaire (potentiellement ‚tendue sur plusieurs lignes).
    La fonction charge alors une nouvelle ligne dans line, c'est pourquoi
    il faut faire une copie temporaire dans repl. Les valeurs debpt et
    endpt serve uniquement … identifi‚ la partie valide de repl.
*/
char *preproc_recdefine(
	char *line,	/* pointe au d‚but de la ligne #define */
	/* line est aussi le buffer unique de ligne */
	char *pt)

/*~28/01/92 15.43.04! preproc_undef R */
/*
    Elimine la d‚claration d'un define
    Retourne adresse de lecture dans la ligne
*/
char *preproc_undef(
	char *DUM1,	/* pointe au d‚but de la ligne #undef */
	char *ptl)

/*~28/01/92 15.43.04! preproc_convert R */
/*
    Fait le remplacement d'un symbole si c'est un define
    Retourne 1 si le token a ‚t‚ remplac‚, 0 sinon
    Si le token ‚tait un define, la chaine de remplacement a ‚t‚
    copi‚ dans le buffer de traitement (line) en reculant ptl.
    Cela simule un insertion
    V‚rifie l'utilisation r‚cursive d'un symbole
*/
int preproc_convert(
	TOKEN *tok,	/* token … convertir si requis */
	char **ptl,	/* position de lecture dans la ligne */
	char *line)	/* buffer de lecture */

/*~06/02/92 12.16.50! preproc_expand R */
/*
    Fait le remplacement des paramŠtres formels par les arguments
    La chaine de remplacement transform‚e avec les arguments est
    plac‚s dans ptl en le reculant.
*/
void preproc_expand(
	char *line,	/* buffer de lecture */
	char **pptl,	/* pointeur dans le buffer */
	DEF_SYM *ptsym)	/* Definition de la macro */

/*~06/02/92 14.00.16! token_init R */
/*
    Initialise la collecte de token
    Par defaut, la lecture des tokens se fait sur stdin
*/
export void token_init(
	void)

/*~06/02/92 14.00.16! token_setpreproc R */
/*
    Enregistre le mode d'activit‚ du pr‚processeur
    0 : pas actif
    1 : actif   ->  traitement des includes
                    traitement des defines
                    traitement des #if
    Par d‚faut pas actif
    Retourne ancien mode
*/
export int token_setpreproc(
	int mode)

/*~06/02/92 14.00.16! token_open R */
/*
    Redirige la collecte des tokens dans un fichier
    Retourne 0 si ok, -1 si ne peut ouvrir
*/
export int token_open(
	const char *name)

/*~06/02/92 14.00.16! token_close R */
/*
    Ferme le fichier ouvert avec token_open
*/
export void token_close(
	void)

/*~06/02/92 14.00.16! token_getnoline R */
/*
    retourne ligne courante de lecture
*/
export int token_getnoline(
	void)

/*~06/02/92 14.00.16! token_unget R */
/*
    Retourne un token pour ˆtre retrait‚ par token_get()
*/
export void token_unget(
	TOKEN *tok)

/*~06/02/92 14.00.16! token_skipwhite R */
/*
    Saute les blancs … partir de ptl et retourne le nouveau ptl
    Si arrive au bout de la ligne, lit la suivante
    Retourne ptl pointant soit un un caractŠre non blanc, soit sur
    '\0' si fin de fichier
*/
char *token_skipwhite(
	char *ptl,
	char *line)

/*~06/02/92 14.00.16! token_get0 R */
/*
    Lit un token et retourne 0 si token valide
    -1 si plus de token
*/
int token_get0(
	TOKEN *tok,
	char **pptl,
	char *line,
	int actif,	/* !=0 si pas dans une section ‚limin‚e */
	int readl)	/* !=0: lit une ligne quand fin de ligne courante */
	/* ==0: Retourne -1 a la fin de la ligne courante */

/*~06/02/92 14.00.16! token_get R */
/*
    Lit un token et retourne 0 si token valide
    -1 si plus de token
*/
export int token_get(
	TOKEN *tok)

/*~06/02/92 14.00.16! token_make R */
/*
    Initialise la structure de token … partir d'une chaine
*/
export void token_make(
	TOKEN *token,
	char *txt)

/*~06/02/92 14.05.00! token_copyid R */
/*
    extrait un identificateur C d'une chaine
    Retourne position imm‚diatement aprŠs la fin de l'identificateur
*/
char *token_copyid(
	char *ptl,	/* pointe au d‚but du ID */
	char *text)	/* contiendre le ID + '\0' */

/*~06/02/92 14.05.00! token_idok R */
/*
    Retourne != 0 si caractŠre est un d‚but valide d'identificateur
*/
int token_idok(
	char carac)

/*~06/02/92 14.05.00! token_chgkeyword R */
/*
    R‚assigne la chaine associ‚ … un mot cl‚
    str vaut "vieux=nouveau" ou "vieux"; dans ce dernier cas le mot
    cl‚ est annul‚
    Retourne -1 si chaine invalide ou mot-cl‚ inconnue
*/
export int token_chgkeyword(
	const char *str)

/*~06/02/92 14.05.00! token_setchkkey N */
/*
    Enregistre si les mots cl‚s doivent ˆtre reconnue ou pas
    Les pr‚processeurs n'ont pas besoin de reconnaitres les mots cl‚s.
    Cela optimise le traitement (sp‚cifiquement parce que la recherche
    est s‚quentielle et loin d'ˆtre optimis‚.
*/
export void token_setchkkey(
	int mode)

/*~06/02/92 14.05.00! token_id R */
/*
    Reconnait un mot-cl‚ ou un identificateur et compose le token
    Retourne l'adresse dans la chaine aprŠs le token
*/
char *token_id(
	TOKEN *tok,	/* token … composer */
	char *ptl)	/* chaine … analyser */
	/* ptl pointe sur le d‚but d'un identificateur */

/*~06/02/92 14.05.00! token_copynumber R */
/*
    Extrait un nombre d'une chaine
    Retourne nouvelle valeur de ptl (saute le token)
    Reconnait uniquement les nombre entier (hexadecimaux aussi)
*/
char *token_copynumber(
	char *text,
	char *ptl)

/*~06/02/92 14.05.00! token_evalnum R */
/*
    Retourne la valeur num‚rique d'un token
    Si le token ne repr‚sente pas un nombre, retourne 0
*** Si le token repr‚sente un nombre point flottant, retourne 0
*/
long token_evalnum(
	TOKEN *tok)

/*~06/02/92 14.05.00! token_number R */
/*
    Reconnait un nombre et compose le token
    Retourne nouvelle valeur de ptl (saute le token)
    Reconnait les nombres entiers et point flottant.
*/
export char *token_number(
	TOKEN *tok,	/* token … composer */
	char *ptl)	/* chaine … analyser */
	/* ptl pointe sur le d‚but d'un nombre */

/*~06/02/92 14.05.00! token_string R */
/*
    Reconnait une chaine de caractŠre (string) et compose le token
    Retourne nouvelle valeur de ptl (saute le token)
    Ne comprend pas la syntaxe de continuation
*/
char *token_string(
	TOKEN *tok,	/* token … composer */
	char *ptl)	/* chaine … analyser */
	/* ptl pointe sur le d‚but d'une chaine */

/*~06/02/92 14.05.00! token_quote R */
/*
    Reconnait un caractŠre entre guillement simple et compose le token
    Retourne nouvelle valeur de ptl (saute le token)
*/
char *token_quote(
	TOKEN *tok,	/* token … composer */
	char *ptl)	/* chaine … analyser */
	/* ptl pointe sur un ' */

/*~14/02/92 00.07.18! token_initcomment R */
/* dernier commentaire reconnue */
/*
    Initialise ou r‚initialise la collecte des commentaire.
    Les commentaires sont accumul‚s dans un tampon.
    Le contenu du tampon est oubli‚.
*/
export void token_initcomment(
	void)

/*~14/02/92 00.07.18! token_setcommode R */
/*
    Controle si les commentaires imbriqu‚es sont permis ou pas
    imbriq != 0, permis, == 0, ignor‚s
    Pas d‚faut, il sont permis
*/
export void token_setcommode(
	int imbriq)

/*~14/02/92 00.07.18! token_skipcomment R */
/*
    Les commentaires sont sautee, mais accumule. Le prochain token valide
    obtiendra le nouveau commentaire
    La routine tente de reconnaitre comme un seul commentaire les commentaires
    qui se suivent
    Si ptl ne pointe pas au d‚but d'un commentaire, retourne sans rien faire
    Donc on peut appeler cette fonction sans v‚rifier qu'il y a un commentaire
    Supporte commentaire C++
    Retourne 1 si un commentaire a ‚t‚ vue, 0 sinon
*/
int token_skipcomment(
	char *line,
	char **pptl,
	int noline,
	int nocar)

/*~14/02/92 00.07.18! token_lastcomment R */
/*
    Retourne le dernier commentaire qui a ‚t‚ accumul‚ (oublie ensuite)
*/
TOKCOM *token_lastcomment(
	void)

/*~14/02/92 00.07.18! token_setdef R */
/*
    Enregistre une d‚finition pour le remplacement pr‚processeur
    La chaine de d‚finition est du type XXX=YYY ou XXX
*/
export void token_setdef(
	const char *def)

/*~14/02/92 00.07.18! token_skipmacro R */
/*
    Saute le d‚finition d'une macro #define
*/
char *token_skipmacro(
	char *line)

/*~05/12/91 23.22.58! token_getskip R */
/*
    retourne un token, si le token fait partie de tb[][0] appelle recursivement
    pour sauter jusqu'au match, au retour tok contient le dernier token lue
    Les tokens sont regenere sur l'output a mesure
    Retourne -1 si plus de token, 0 sinon
*/
export int token_getskip(
	TOKEN *tok,
	TOK_TYPE tb[][2],
	int nbtok)

/*~30/11/91 23.03.12! token_inittxt R */
/*
    Initialise ou r‚initialise la collecte des textes de tokens
    Les tokens (ascii) sont accumul‚ dans un tampon. Lorsqu'on sait
    que les tokens accumul‚s jusqu'… date ne seront plus requis
    cette fonction peut ˆtre appel‚ pour relacher l'espace occup‚.
*/
export void token_inittxt(
	void)

/*~30/11/91 23.03.12! token_alloctxt R */
/*
    Retourne une position o— on peut accumuler un texte de token
    On appelle cette fonction pour obtenir un pointeur, on copie
    le texte dans le pointeur, et on appelle token_settxt() en
    passant l'adresse corrig‚e du pointeur (saute le texte)
*/
char *token_alloctxt(
	void)

/*~30/11/91 23.03.12! token_getmarktxt R */
/*
    Obtient la position courante d'allocation pour le texte des token
    La fonction token_settxt() est utilis‚ pour lib‚rer le texte de tous
    les tokens allou‚s aprŠs cette fonction
*/
export char *token_getmarktxt(
	void)

/*~30/11/91 23.03.12! token_setmarktxt R */
/*
    Enregistre une nouvelle position d'allocation, lib‚rant une portion
    Le pointeur a ‚t‚ obtenue par token_getmarktxt().
*/
export void token_setmarktxt(
	char *mark)

/*~30/11/91 23.03.12! token_settxt R */
/*
    Etablie la nouvelle position d'allocation des textes de token
*/
void token_settxt(
	char *pttxt)

/*~30/11/91 23.03.12! token_txt R */
/*
    Retourne le texte ascii associ‚ au token
*/
export char *token_txt(
	TOKEN *tok)

/*~30/11/91 23.03.12! token_needsep R */
/*
    indique si un blanc doit etre inserer entre deux token
    Par convention tokp est celui qui precede tok1
*/
export int token_needsep(
	TOKEN *tok,
	TOKEN *tokp)

/*~30/11/91 23.03.12! token_print R */
/*
    Imprime le texte d'un token sur stdout
*/
export int token_print(
	TOKEN *tok)

/*~30/11/91 23.03.12! token_egaux R */
/*
    retourne 1 si token identique, 0 sinon
*/
int token_egaux(
	TOKEN *tok1,
	TOKEN *tok2)

/*~30/11/91 22.58.22! token_oper R */
/*
    Identifie op‚rateur C
    Retourne nouvelle position dans buffer d'analyse
    ConsidŠre que c'est forc‚ment un op‚rateur
*/
export char *token_oper(
	TOKEN *tok,
	const char *ptl)	/* Pointe sur d‚but d'op‚rateur */

/*~26/01/91 09.47.22! token_skipstring R */
/*
    D‚termine la fin d'une string
    ptl pointe sur le premier "
    Retourne pointeur sur le " de fermeture ou '\0' si erreur lexicale
*/
export char *token_skipstring(
	const char *ptl)

/*~26/01/91 09.47.22! token_copystring R */
/*
    extrait une chaine de caractŠre (guillemet double) d'une chaine
    Retourne pointeur aprŠs le " ou pointe … la fin de la chaine
    Retourne un pointeur sur n'importe quoi si lenmax est exc‚d‚
*/
export char *token_copystring(
	char *text,	/* destination */
	char *ptl,	/* chaine a lire */
	int lenmax)	/* longuer maximum */

/*~26/01/91 09.47.22! token_skipquote R */
/*
    Saute d‚finition d'un caractŠre entre guillemet simple
    ptl pointe sur le premier '
    Retourne pointeur sur le ' de fermeture ou '\0' si erreur lexicale
*/
export char *token_skipquote(
	const char *ptl)

/*~26/01/91 09.47.22! token_copyquote R */
/*
    extrait un caractŠre (guillemet simple) d'une chaine
    Retourne pointeur aprŠs le ' ou pointe … la fin de la chaine
    Retourne un pointeur sur n'importe quoi si lenmax est exc‚d‚
*/
export char *token_copyquote(
	char *text,	/* destination */
	char *ptl,	/* chaine … lire */
	int lenmax)	/* longueur maximum admissible */

/*~??/??/?? ??.??.??: preproc_errundef D */