Les fichiers terminfo sont habituellement situés dans les chemins suivants : /usr/lib/terminfo /usr/share/terminfo /etc/terminfo La dernière localisation est plus rare et ne se rencontre que sur des systèmes plus anciens.

Pour faciliter la recherche, chaque fichier compilé décrivant les capacités de traitement d'un terminal est placé dans un sous-répertoire du répertoire terminfo. Le nom de ce sous répertoire est constitué de la première lettre du terminal géré. Le fichier lui-même porte le nom du terminal suivi de différentes lettres qui indiquent les multiples déclinaisons du terminal en question.Ainsi si vous tapez la commande : locate xterm Vous verrez défiler à l'écran toutes les variantes du terminal xterm qui est le terminal habituellemnt émulé sous X Window.

Tous ces fichiers sont regroupés dans le répertoire : /usr/share/terminfo/x

En ce qui concerne le fichier source, il peut très bien manquer à votre distribution. En tout état de cause vous pourrez le télécharger aux adresses :

Il existe un utilitaire qui permet de visualiser le contenu d'un fichier terminfo décrivant les capacités d'un terminal déterminé. Cet utilitaire est infocmp. Ainsi, si sous le shell vous validez la commande suivante : infocmp xterm Vous obtiendrez l'affichage suivant qui, évidemment, éclairera immédiatement, pour vous, les capacités de traitement d'un terminal xterm! [pierre@localhost pierre]$ infocmp xterm # Reconstructed via infocmp from file: /usr/share/terminfo/x/xterm xterm|xterm terminal emulator (X Window System), am, km, mir, msgr, xenl, cols#80, it#8, lines#24, acsc=``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~, bel=^G, bold=\E[1m, clear=\E[H\E[2J, cr=^M, csr=\E[%i%p1%d;%p2%dr, cub=\E[%p1%dD, cub1=^H, cud=\E[%p1%dB, cud1=^J, cuf=\E[%p1%dC, cuf1=\E[C, cup=\E[%i%p1%d;%p2%dH, cuu=\E[%p1%dA, cuu1=\E[A, dch=\E[%p1%dP, dch1=\E[P, dl=\E[%p1%dM, dl1=\E[M, ed=\E[J, el=\E[K, enacs=\E)0, home=\E[H, ht=^I, il=\E[%p1%dL, il1=\E[L, ind=^J, is2=\E7\E[r\E[m\E[?7h\E[?1;3;4;6l\E[4l\E8\E>, kbs=^H, kcub1=\EOD, kcud1=\EOB, kcuf1=\EOC, kcuu1=\EOA, kdch1=\E[3~, kf1=\EOP, kf10=\E[21~, kf11=\E[23~, kf12=\E[24~, kf13=\E[25~, kf14=\E[26~, kf15=\E[28~, kf16=\E[29~, kf17=\E[31~, kf18=\E[32~, kf19=\E[33~, kf2=\EOQ, kf20=\E[34~, kf3=\EOR, kf4=\EOS, kf5=\E[15~, kf6=\E[17~, kf7=\E[18~, kf8=\E[19~, kf9=\E[20~, kfnd=\E[1~, kich1=\E[2~, kmous=\E[M, knp=\E[6~, kpp=\E[5~, kslt=\E[4~, rc=\E8, rev=\E[7m, ri=\EM, rmacs=^O, rmcup=\E[2J\E[?47l\E8, rmir=\E[4l, rmkx=\E[?1l\E>, rmso=\E[m, rmul=\E[m, rs2=\E7\E[r\E[m\E[?7h\E[?1;3;4;6l\E[4l\E8\E>, sc=\E7, sgr0=\E[m, smacs=^N, smcup=\E7\E[?47h, smir=\E[4h, smkx=\E[?1h\E=, smso=\E[7m, smul=\E[4m, tbc=\E[3g, u6=\E[%i%d;%dR, u7=\E[6n, u8=\E[?1;2c, u9=\E[c,

Nous comprenons tout de même que passée la première ligne qui rappelle les différents noms du terminal nous trouvons une série d'identificateurs. Chaque identificateur désigne une capacité de traitement du terminal ; pour cette raison ils sont souvent appelés capname.

Nous constatons que chaque identificateur de capacité du terminal est séparé du suivant par une virgule. Il est clair également que nous pouvons distinguer trois types différents d'identificateur : Les premiers sont immédiatement suivis d'une virgule et sont de type booléen. Les deuxièmes sont suivis d'un dièse, lui-même suivi d'une valeur numérique. Ils sont de type numérique. Les troisièmes sont suivis du signe =, lui-même suivi d'un ensemble de caractères. Ils sont de type chaîne de caractères. Cette première approche nous a permis de débroussailler le terrain. Nous allons tenter d'utiliser les outils mis à la disposition du programmeur pour accéder proprement aux différentes capacités d'un terminal.

La première idée qui vient à l'esprit quand on veut se familiariser avec la gestion des terminaux, c'est d'avoir la possibilité de décider du terminal actif, et de savoir s'il existe une base de données terminfo décrivant les capacités de tel terminal. Pour cela il existe une fonction dont le prototype est le suivant : int setupterm(const char * term, int fildes, int errret);

Fin connaisseur de votre système, vous vous précipitez sur les pages du manuel d'aide, pour connaître le cahier des charges de cette fonction en tapant : man setupterm ... et vous obtenez la réponse décevante suivante : No manual entry for setupterm En effet, cette fonction est incluse dans la bibliothèque ncurses et vous devrez procéder en deux temps pour accéder au manuel d'aide de la fonction setupterm. D'abord invoquer l'aide général de ncurses : man ncurses Ensuite, repérer dans cette aide la fonction setupterm et le sous-ensemble dans lequel elle est située. Il s'agit de curs_terminfo. Donc en utilisant la commande man curs_terminfo, vous obtiendrez les renseignements voulus sur la fonction setupterm.

Je me contenterai de fournir une traduction du passage de la page du manuel qui décrit la fonction setupterm. int setupterm(const char * term, int fildes, int errret);

La fonction setupterm lit dans la base de données terminfo, les structures terminfo sont ainsi initialisées...Le type de terminal est la chaîne de caractères term ; si term vaut NULL, la variable d'environnement TERM est utilisée.Toutes les sorties sont envoyées sur le descripteur de fichier fildes qui doit être initialisé en écriture. Si errret ne vaut pas NULL, la fonction setupterm renvoie OK ou ERR et charge la valeur du statut d'erreur dans l'entier pointé par errret. Les valeurs possibles de errret sont : 1 : tout est normal, 0 : le terminal appelé n'a pas été trouvé, -1 : la base de données terminfo n'a pas été trouvée. Si errret vaut NULL, setupterm affiche un message d'erreur correspondant à l'erreur décelée et interrompt le programme.Ainsi l'appel le plus simple est : setupterm((char *)0,1,(int *)0); qui utilise toutes les valeurs par défaut et envoie les sorties sur stdout .

Vous pourriez tester et mettre en oeuvre un programme qui ressemblerait à celui-ci : #include <stdio.h> #include <term.h> #include <ncurses.h> int main(int argc, char * argv[]) { int r; int erreur; if (argc>2) r=setupterm(NULL, fileno(stdout),&erreur); else r=setupterm(argv[1], fileno(stdout),&erreur); if (r==OK) printf("Traitement correct\n"); else switch(erreur){ case 0 : printf("Le terminal %s est inconnu.\n",argv[1]); break; case -1 : printf("Aucune base de données pour le terminal %s.\n",argv[1]); break; } return 0; }

J'espère ne vexer personne par l'édition d'un programme aussi trivial. Il n'est là que pour rappeler : Les fichiers d'en-tête à inclure : stdio.h pour les fonctions d'entrée-sortie, dont la fonction fileno, term.h pour les fonctions de gestion de terminfo, ncurses.h pour les constantes OK et ERR définis dans cette librairie. La ligne de commande à utiliser pour compiler ce programme : gcc prog.c -o prog -lncurses

Cette dernière ligne n'a pas d'autres ambitions que de permettre à l'éditeur de liens de retrouver la bibliothèque ncurses dont il a besoin pour le code de certaines fonctions : d'où -lncurses.

Vous trouverez, dans ce paragraphe et dans les suivants, des tableaux dont la compréhension est assez évidente. La première colonne, sous le titre Signification contient le nom significatif de la capacité, la deuxième colonne, sous le titre Nom de capacité contient le nom de la capacité telle qu'elle apparaît dans une base de données terminfo, enfin, la troisième colonne, sous le titre Utilisation contient une brève explication de la fonctionnalité de la capacité.

Encore une fonctionnalité primordiale pour la gestion des sorties sur un terminal, les capacités qui gèrent l'effacement de l'écran : en voici quatre... Signification Nom de capacité Utilisation clear_screen clear Efface l'écran et curseur en 0,0 clr_bol el1 Efface jusqu'au début de la ligne clr_eol el Efface jusqu'à la fin de la ligne clr_eos ed Efface jusqu'à la fin de l'écran

Signification Nom de capacité Utilisation scroll-forward ind Déplace le texte vers le haut scroll-reverse ri Déplace le texte vers le bas

Il existe trois fonctions qui permettent d'accéder aux valeurs des capacités définies dans une base de données d'un terminal déterminé : int tigetflag(const char * capname); qui renvoie la valeur des capacités de type booléen. int tigetnum(const char * capname); qui renvoie la valeur des capacités de type numérique. char *tigetstr(const char * capname); qui renvoie la valeur des capacités de type chaîne de caractères.

Les fonctions tigetflag, tigetnum et tigetstr renvoient la valeur de la capacité correspondant dans terminfo à l'argument capname, qui leur a été transmis.

La fonction tigetflag renvoie la valeur -1 si capname n'est pas une capacité de type booléen, ou 0 si cette capacité est, soit effacée, soit absente dans la base de données du terminal.

La fonction tigetnum renvoie la valeur -2 si capname n'est pas une capacité de type numérique, ou -1 si cette capacité est, soit effacée, soit absente dans la base de données du terminal.

La fonction tigetstr renvoie la valeur (char *)-1 si capname n'est pas une capacité de type chaîne de caractères, ou 0 si cette capacité est, soit effacée, soit absente dans la base de données du terminal.

Notez : les quatre phrases ci-dessus ne sont que la traduction du manuel d'aide que vous pouvez consulter en tapant la commande : man curs_terminfo

Vous pourriez tester le programme suivant... /#include <stdio.h> #include <term.h> #include <ncurses.h> int main(int argc, char * argv[]) { int r,rb; int erreur; if (argc<2){ printf("Entrez les noms d'un terminal et d'une capacité séparés par un espace\n"); exit(1); } else r=setupterm(argv[1], fileno(stdout),&erreur);//Terminal de la ligne de commande if (r==OK){ printf("Traitement correct\n"); rb=tigetflag(argv[2]); switch(rb){ case -1 : printf("%s n'est pas une capacité booléenne\n",argv[2]); break; case 0 : printf("La capacité %s n'est pas supportée par le terminal %s\n",argv[2],argv[1]); break; default : printf("La capacité %s est supportée par le terminal %s\n",argv[2],argv[1]); break; } } else switch(erreur){ case 0 : printf("Le terminal %s est inconnu.\n",argv[1]); break; case -1 : printf("Aucune base de données pour le terminal %s.\n",argv[1]); break; } return 0; } Voici un exemple d'appels et de réponses successifs au programme ci dessus : [pierre@localhost terminfo]$ ./testcapb xterm km Traitement correct La capacité km est supportée par le terminal xterm [pierre@localhost terminfo]$ ./testcapb linux km Traitement correct La capacité km n'est pas supportée par le terminal linux [pierre@localhost terminfo]$ ./testcapb linux bce Traitement correct La capacité bce est supportée par le terminal linux [pierre@localhost terminfo]$ ./testcapb xterm bce Traitement correct La capacité bce n'est pas supportée par le terminal xterm

Je vous laisse le soin d'imaginer les modifications à apporter au programme précédent pour tester, cette fois, des capacités de type numérique à l'aide de la fonction tigetnum.

Je me contenterai de reproduire quelques exemples de tests de ces capacités de type numérique sur mon système.Si nous nous intéressons, par exemple, aux capacités de traitement des couleurs, nous pouvons interroger trois bases de données, d'un terminal, respectivement linux, xterm, nxterm. L'interrogation porte sur le support de la capacité colors. Nous obtenons : [pierre@localhost terminfo]$ ./testcapn linux colors Traitement correct La capacité colors est supportée par le terminal linux Valeur de colors : 8

La capacité colors est gérée par le terminal linux. Huit couleurs sont reconnues. [pierre@localhost terminfo]$ ./testcapn xterm colors Traitement correct La capacité colors n'est pas supportée par le terminal xterm

Petite surprise tout de même les couleurs ne semblent pas être reconnues par la base de données du terminal xterm. Vous pouvez le vérifier en faisant afficher cette base de données par l'utilitaire infocmp ; or ce terminal est celui qui est habituellement émulé sous X Window. [pierre@localhost terminfo]$ ./testcapn nxterm colors Traitement correct La capacité colors est supportée par le terminal nxterm Valeur de colors : 8 Autre surprise, le terminal nxterm, cousin issu de germain du terminal xterm, lui supporte la capacité colors.

Nous pourrons appliquer des modifications semblables aux précédentes à notre programme pour tester, cette fois, la fonction tigetstr.Parmi les capacités de type chaîne de caractères, une d'entre elles nous a semblé importante, celle qui permet de rendre le curseur invisible : civis. Testons donc cette capacité sur nos terminaux habituels : [pierre@localhost terminfo]$ ./testcapc linux civis Traitement correct La capacité civis est supportée par le terminal linux Valeur de civis : \E[?25l\E[?1c [pierre@localhost terminfo]$ ./testcapc xterm civis Traitement correct La capacité civis n'est pas supportée par le terminal xterm

Le lecteur voudra bien me pardonner ce fastidieux affichage, il n'est là que pour souligner la diversité du contenu des fichiers terminfo. Ainsi, une fois de plus, et sur une capacité aussi usuelle et utile que l'effacement du curseur, force est de constater que pour un terminal linux, la capacité est supportée et qu'elle ne l'est pas sur un terminal de type xterm.Nous examinerons les conséquences de tout cela dans le chapitre 7 intitulé Pallier les insuffisances d'une base de données.

L'utilisation de la fonction tigetstr avec la capacité clear donne les messages suivants : [pierre@localhost terminfo]$ ./testcapc xterm clear Traitement correct La capacité clear est supportée par le terminal xterm Valeur de clear : \E[H\E[2J [pierre@localhost terminfo]$ ./testcapc linux clear Traitement correct La capacité clear est supportée par le terminal linux Valeur de clear : \E[H\E[J

Deux arguments sont attendus pour cette capacité : le premier repésente la ligne où doit être affichée le curseur, le deuxième représente la colonne.

Une fois obtenue la séquence de codes d'échappement à l'aide de la fonction tparm, reste à expédier le tout au terminal. Vous pouvez bien entendu envoyer la séquence de codes à l'aide de la fonction printf. Nous pouvons cependant préférer l'utilisation de la fonction putp qui appartient à la bibliothèque que nous avons utilisée. Le prototype de cette fonction est le suivant : int putp(const char * str); De sorte que dans l'exemple précédent nous aurions pu invoquer directement la fonction putp ainsi : putp(tparm(resu,15,30)); pour obtenir le déplacement du curseur en ligne 15, colonne 30.

La première solution qui vient à l'esprit est tout simplement de réécrire un fichier source et de le faire compiler par le programme tic. Pour cela, partez d'un fichier existant pour la famille du terminal que vous utilisez et ajoutez-y les capacités manquantes qui vous semblent importantes, en les retrouvant dans d'autres bases de données dans lesquelles elles sont présentes.

Ainsi vous avez pu constater, dans les chapitres précédents que les capacités de gestion de la visibilté du curseur, étaient absentes de la bases de données du terminal xterm. Reprenez le fichier source terminfo, recopiez la base de données de xterm, renommez la monxterm, ajoutez les capacités civis,cnorm,cvvis, telles que vous pouvez les trouver dans la base de données du terminal linux. Recompilez le fichier source à l'aide du programme tic.

Vous trouverez dans le manuel d'aide de votre distribution tous les renseignements nécessaires pour mettre en oeuvre cette compilation à l'aide du programme tic. Entrez la commande : man tic

Certains penseront qu'il serait plus simple d'utiliser les fonctions disponibles dans la bibliothèque ncurses. Il existe certes une fonction de la bibliothèque ncurses. Il existe bien entendu une fonction, curs_set qui gère la visibilité du curseur. Mais cette fonction teste les capacités du terminal utilisé et ne fonctionne pas si la capacité civis n'est pas définies pour le terminal utilisé. Donc,... retour à la case départ.

Encore un qui réinvente la roue ! penseront certains. Peut-être. Mais c'est une question qui revient souvent chez certains jeunes programmeurs qui ont commencé avec des outils sous DOS, dont le portage des outils GNU. On y trouve des fonctions rassemblées dans le fichier d'en-tête conio.h qui efface l'écran ou rendent le curseur invisible etc...

On pourra ainsi, sans problème récupérer un ensemble de valeurs de capacités à l'aide des fonctions de lecture que nous avons vues précédemment. L'on pourra alors définir une liste de valeurs de capacités. Nous pourrons créer,par exemple les constantes suivantes : const char * sansCurseur = "\033[?25l\E[?1c"; const char * deplace Curseur = "\033[%i%p1%d;%p2%dH"; const char * effaceEcran="\033[H\E[2J"; Il suffit ensuite de faire produire la séquence de code d'échappement par la fonction tparm

Il me paraît utile de lever une ambigüité qui pourrait subsister dans l'esprit de certains lecteurs.Les exemples d'utilisation que nous avons proposés jusqu'à présent pourraient laisser penser que la fonction tparm est associée à l'activation d'un terminal qui contiendrait dans sa base de données terminfo, la valeur de capacité traitée par tparm.

Il n'en est rien la fonction tparm interprète bien la chaîne de caractères transmise en argument suivant la grammaire, la syntaxe, le lexique des chaînes de caractères définies pour les fichiers terminfo.

Ainsi, si vous mettez en oeuvre le petit programme suivant quel que soit le terminal dans lequel vous exécuterez ce programme, vous obtiendrez le même résultat, semblable à celui que nous avions obtenu précédemment, alors que nous avions utilisé la fonction setupterm. #include <stdio.h> #include <term.h> #include <ncurses.h> void affiche(char * m) { int i; for(i=0; i<strlen(m);i++) if (m[i]==27) printf("\\E"); else printf("%c",m[i]); } int main(int argc, char * argv[]) { char * deplaceCurseur = "\033[%i%p1%d;%p2%dH"; char * esc_seq; printf("Valeur de la capacité : "); affiche(deplaceCurseur); printf("\n"); esc_seq=tparm(deplaceCurseur,0,0); printf("Chaîne à envoyer : "); affiche(esc_seq); printf(" au terminal\n"); return 0; } L'exécution de ce programme donnera le résultat suivant : [pierre@localhost terminfo]$ ./tesparm Valeur de la capacité : \E[%i%p1%d;%p2%dH Chaîne à envoyer : \E[1;1H au terminal conforme à ce que nous attendions.

Une structure minimale définirait dans le fichier d'en tête les valeurs des capacités J'en donne neuf exemples et ceux qui sont intéressés par la question pourront en rechercher et imaginer d'autres.