J ai reçu un fichier texte hier que j ai ouvert dans un terminal.
Le problème est que le fichier est a peut prés illisible puisqu'il est remplit de multiples '^H'.
Il se trouve que j ai utilisé un petit scan généré par flex pour découvrir que ces '^H' sont en fait des caractères backspace (code ascii 8) et effectivement si je fait l effort de les interpréter moi même le fichier commence a être a peut prés lisible, seulement il fait quelques centaines de pages. Du coup j aimerai que mon pc fasse l effort pour moi.

J ai donc utilisé un scan flex construit a partir de
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
 
%%
\x08 {printf("");}
c est mieux mais pas top.

J ai donc fait un test et ai compilé un petit programme en c :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
#include <stdio.h>
 
int main()
{printf ("%c",'3') ; printf("%c",'4') ; printf("%c",8);}
Quand je compile et exécute ce dernier programme j obtient bien ce que j espere, c est a dire
Code : Sélectionner tout - Visualiser dans une fenêtre à part
3
plus mon invite collée évidemment puisque j ai pas mis de retour chariot...

j ai donc decide de reprendre le scanner précédent en le modifiant un peu :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
 
%%
\x08 {printf("%c",8);}
Résultat quand je passe mon fichier texte a la moulinette de ce scanner ben j obtient le même fichier que l original... sauf si je l affiche directement sur stdout.

Conclusion, (désolé je pense tout haut...), stdout 'interprète' le caractère backspace.

J aimerais donc faire un scanner qui interprète ce caractère, malheureusement j ai l impression de partir vers un truc bien compliqué et tous les essais que j ai fait jusqu’à présent se soldent par un échec.
Je mets ici le dernier en date, ne soyez pas trop méchants
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
%{
char textbuff[11]="0123456789\0";
int myindex = 0 ; 
int mustAppend = 0;
 
void decIndex() { if (myindex >0) { myindex-- ; mustAppend = 0;} }
 
void incIndex() { myindex++; if (myindex== 10) { mustAppend = 1 ; myindex = 0 ;} }
 
void putBuff( const char c) { if (mustAppend == 1 ) { printf("%s",textbuff); mustAppend = 0; putBuff(c);} 
                                        else {textbuff[myindex] = c ; incIndex();}}
 
void flushBuff() { textbuff[myindex+1]='\0'; printf("%s",textbuff);}
%}
%%
\x08 { decIndex() ;}
 
.      { putBuff(*yytext) ;}
 
<<EOF>> {flushBuff();}
Dans ma tête ce scan devrait pouvoir gerer ce qui se passe pour au maximum dix backspaces successifs, dans les faits, il marche presque, je dis bien presque :

1) il y a un problème manifeste avec les retours chariots.

2) quand je passe mon fichier texte par la moulinette de ce scan... l analyse ne se termine pas, me produit un fichier astronomiquement grand, contenant en son debut l approximation de ce que devrait etre mon fichier final modulo la remarque précédente.

Du coup j ai plusieurs questions :
- J ai l impression qu il n est pas possible de gérer un nombre indéterminé de backspaces successifs en une seul passe, ai-je tord ?
- Y a t il une méthode (une option a passer a vim par exemple...) pour le forcer a interpréter ces satanés backspaces ? (je sens que je vais pleurer mais j voulais quand même essayer avec flex...)
- Est ce que ma méthode vous parait censée ?
- Est ce que vous voyez ce qui cloche dans la définition de mon scanner pour éviter les deux problèmes ?