pour soumettre un programme dans la section code sources

**emmesse** · 28/07/2023, 10h25

Bonjour,

je voudrais mettre un code source dans la section "codes sources" du site. Mais avant, je vous le soumet pour savoir si il pourrait être plus performant.
Il s'agit d'une version unix2dos, à la manière d'un compilateur par descente récursive prédictive.

le schéma de traduction dirigé par la syntaxe est le suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
fichier -> {ligne.h=""} ligne {fichierprim.h=ligne_s} fichierprim {fichier.s=fichierprim.s}
fichierprim -> retourligne {ligne.h=""} ligne {fichierprim1.h=fichierprim.h+"\r\n"+ligne.s} fichierprim1 {fichierprim.s=fichierprim1.s}
            -> epsilon {fichierprim.s=fichierprim.h}
ligne -> caractère {ligne1.h=ligne.h+caractère} ligne1 {ligne.s=ligne1.s}
      -> epsilon {ligne.s=ligne.h}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
// main.cpp
#include <iostream>
#include "syntaxique.hpp"
 
int main(int argc, char *argv[]){
  if(argc!=3)
    std::cerr<<"usage:\nuix2dos fichierentrée fichiersortie"<<std::endl;
  else{
    syntaxique objetsyntaxique(argv[1],argv[2]);
    objetsyntaxique.fichier();
  }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
#ifndef TERMINAUX_HPP
#define TERMINAUX_HPP
 
enum terminal{FDF,retourligne,caractere};
 
#endif

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
22
23
#ifndef LEXICAL_HPP
#define LEXICAL_HPP
 
#include <string>
#include <fstream>
 
#include "terminaux.hpp"
 
class lexical{
public:
  lexical(char* fichierentree);
  void analex(terminal &retourvaleur,std::string &retourattribut,int &ligne);
private:
  std::string texte;
  std::ifstream entree;
  size_t enavant,debutlex;
  std::string lexeme;
  std::string readFileIntoString(const char* path);
  bool obtenir_FDF();
  bool obtenir_retourligneoucaractere(int &ligne);
  std::string carsuiv();
};
#endif

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
//lexical.cpp
#include <iostream>
#include <fstream>
#include <string>
 
#include "lexical.hpp"
#include "terminaux.hpp"
 
lexical::lexical(char *fichierentree):enavant(0),debutlex(0){
  entree.open(fichierentree);
  texte = readFileIntoString(fichierentree)+(char)EOF;
  enavant=0;
}
 
std::string lexical::readFileIntoString(const char* path) {
  if (!entree.is_open()){
    std::cerr << "Could not open the file - '" << path << "'" << std::endl;
    exit(1);
  }
  else{
    return std::string((std::istreambuf_iterator<char>(entree)),
		       std::istreambuf_iterator<char>());
  }
}
 
void lexical::analex(terminal &retourvaleur,std::string &retourattribut,int &ligne){
  if(obtenir_FDF())
    retourvaleur=FDF;
  else if(obtenir_retourligneoucaractere(ligne))
    if(lexeme=="\n")
      retourvaleur=retourligne;
    else{
      retourattribut=lexeme;
      retourvaleur=caractere;
    }
}
 
bool lexical::obtenir_FDF(){
  debutlex=enavant;
  int etat=0;
  std::string c;
  while(true)
    switch(etat){
    case 0:
      c=carsuiv();
      if(c[0]==(char)EOF)
	etat=1;
      else{//echec
	enavant=debutlex;
	return false;
      }
      break;
    case 1:
      return true;
    }
}
 
 bool lexical::obtenir_retourligneoucaractere(int &ligne){
   debutlex=enavant;
   int etat=0;
   std::string c;
   while(true){
     switch(etat){
     case 0:
       c=carsuiv();
	 if(c=="\n")
	   ligne++;
       etat=1;
       break;
     case 1:
       lexeme=c;
       return true;
     }
   }
 }
 
 
std::string lexical::carsuiv(){
  int taille;
  if((unsigned char)texte[enavant] >= (unsigned char)0 && texte[enavant] <= (unsigned char)127)
    taille=1;
  else if((unsigned char)texte[enavant] >= (unsigned char)0xC2 && (unsigned char)texte[enavant] <= (unsigned char)0xdf)
    taille=2;
  else if((unsigned char)texte[enavant] >= (unsigned char)0xe0 && (unsigned char)texte[enavant] <= (unsigned char)0xef)
    taille=3;
  else 
    taille=4;
  std::string c=texte.substr(enavant,taille);
  enavant+=taille;
  return c;
}

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
22
23
#ifndef SYNTAXIQUE_HPP
#define SYNTAXIQUE_HPP
#include <string>
#include <vector>
 
#include "lexical.hpp"
#include "terminaux.hpp"
 
class syntaxique{
public:
  syntaxique(char *fichierentree,char *fichiersortie);
  void fichier();
private:
  void consommer(terminal const &attendu);
  std::string ligne(std::string ligne_h);
  std::ofstream sortie;
  std::string nomfichiersortie;
  terminal symbole;
  int numligne;
  lexical objetlexical;
  std::string lexeme;
};
#endif

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
// syntaxique.cpp
#include <string>
#include <iostream>
#include <fstream>
 
#include "terminaux.hpp"
#include "syntaxique.hpp"
#include "lexical.hpp"
 
/*
  fichier -> {ligne.h=""} ligne {fichierprim.h=ligne.s} fichierprim {fichier.s=fichierprim.s}
  fichierprim -> retourligne {ligne.h=fichierprim.h} ligne {fichierprim1.h=fichierprim.h+CR+LF+ligne.s} fichierprim1 {fichierprim.s=fichierprim1.s}
              -> epsilon {fichier.s=fichier.h}
  ligne -> caractere {ligne1.h=ligne.h+caractere.s} ligne1 {ligne.s=ligne1.s}
        -> epsilon {ligne.s=ligne.h}
*/
 
syntaxique::syntaxique(char *fichierentree,char *fichiersortie):nomfichiersortie(fichiersortie),numligne(1),objetlexical(fichierentree){
  objetlexical.analex(symbole,lexeme,numligne);
  nomfichiersortie=fichiersortie;
}
 
void syntaxique::consommer(terminal const &attendu){
  if(symbole==attendu && symbole!=FDF)
    objetlexical.analex(symbole,lexeme,numligne);
}
 
void syntaxique::fichier(){
  std::string ligne_h="";
  std::string fichierprim_h="";
  if(symbole==caractere){
    std::string ligne_s=ligne(ligne_h);
    fichierprim_h=ligne_s;
    while(symbole==retourligne){
      consommer(retourligne);
      ligne_h="";
      ligne_s=ligne(ligne_h);
      fichierprim_h+="\r\n"+ligne_s;
    }
  }
  else{
    while(symbole==retourligne){
      consommer(retourligne);
      ligne_h="";
      std::string ligne_s=ligne(ligne_h);
      fichierprim_h+="\r\n"+ligne_s;
    }
  }
  std::string fichierprim_s=fichierprim_h;
  std::string fichier_s=fichierprim_s;
  sortie.open(nomfichiersortie.c_str());
  sortie<<fichier_s;
}
 
std::string syntaxique::ligne(std::string ligne_h){
  while(symbole==caractere){
    std::string caractere_s=lexeme;
    consommer(caractere);
    ligne_h+=caractere_s;
  }
  std::string ligne_s=ligne_h;
  return ligne_s;
}

je suis ouvert à toute suggestion.

**LittleWhite** · 07/04/2024, 10h34

Bonjour,

Dur de savoir pour la performance, vous n'expliquez pas ce que c'est sensé faire. (Et) Il y a zéro commentaire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
    switch(etat){
    case 0:
      c=carsuiv();
      if(c[0]==(char)EOF)
	etat=1;
      else{//echec
	enavant=debutlex;
	return false;
      }
      break;
    case 1:
      return true;
    }

Pas besoin d'un switch() ici.

**dalfab** · 07/04/2024, 10h48

Bonjour,

L'expression c[0]==(char)EOF met un doute sur la validité de ce code.
EOF a une valeur qui est forcément distincte de tous les caractères possibles. Donc ou bien un caractère n'est jamais géré (par exemple \377 si EOF==-1 et les char sont signés) ou bien la fin n'est pas détectée.

**emmesse** · 09/05/2024, 03h23

Pourtant, ce code fonctionne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ xxd test
00000000: 6466 670a 686a 6b0a 6c6d 0a              dfg.hjk.lm.
$ ./a.out test resultat
$ xxd resultat 
00000000: 6466 670d 0a68 6a6b 0d0a 6c6d 0d0a       dfg..hjk..lm..

comme je l'ai indiqué, c'est une version de unix2dos, à la manière d'un parseur par descente récursive predictive

**kick54** · 09/05/2024, 18h20

Envoyé par emmesse

Pourtant, ce code fonctionne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ xxd test
00000000: 6466 670a 686a 6b0a 6c6d 0a              dfg.hjk.lm.
$ ./a.out test resultat
$ xxd resultat 
00000000: 6466 670d 0a68 6a6b 0d0a 6c6d 0d0a       dfg..hjk..lm..

comme je l'ai indiqué, c'est une version de unix2dos, à la manière d'un parseur par descente récursive predictive

Bonsoir,
ça marche parce que tu appliques la conversion à un fichier ASCII 7 bits
Cordialement

**emmesse** · 09/05/2024, 20h59

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
fichier test:
é
è
ÿ
à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ xxd test
00000000: c3a9 0ac3 a80a c3bf 0ac3 a00a 
$ unix2dos test resultat
$ xxd resultat
00000000: c3a9 0d0a c3a8 0d0a c3bf 0d0a c3a0 0d0a  ................

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 if(c[0]==(char)EOF)

C[0] peut être négatif comme (char)EOF, qui est égal à -1
les char sont codé sur 8 bits et peuvent donc être négatifs, comme (char)EOF, qui est égal à -1 (=FF)
si c[0] vaut FF alors dans ce cas on a bien c[0]==(char)EOF;

**kick54** · 09/05/2024, 21h42

Envoyé par emmesse

fichier test

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
é
è
ÿ
à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$ unix2dos test resultat
$ xxd resultat
00000000: c3a9 0d0a c3a8 0d0a c3bf 0d0a c3a0 0d0a  ................

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 if(c[0]==(char)EOF)

C[0] peut être négatif comme (char)EOF, qui est égal à -1
les char sont codé sur 8 bits et peuvent donc être négatifs, comme (char)EOF, qui est égal à -1 (=FF)
si c[0] vaut FF alors dans ce cas on a bien c[0]==(char)EOF;

EOF = -1 codé dans un int pas dans un char pour pouvoir justement le distinguer du caractère dont le code est 0xff.
Et 0xff n'existe pas dans le code ASCII 7 bits (d'où ma remarque) mais par exemple dans ISO/CEI 8859-1 0xFF est le caractère ÿ

**emmesse** · 09/05/2024, 21h50

FF est utilisé par le système linux comme marqueur de fin de fichier
https://fr.linux-console.net/?p=9700
(il faut cliquer sur les url)

**jo_link_noir** · 10/05/2024, 00h48

Envoyé par emmesse

FF est utilisé par le système linux comme marqueur de fin de fichier

Non, 0xFF ne représente pas la fin de fichier, mais un caractère plus ou moins valide selon l'encodage choisi. EOF vaut généralement 0xFFFFFFFF (en mémoire), simplement réduit à -1 parce que c'est signé.

Si on prend le fichier et l'encodage proposé par kick54:

Code bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
$ cat utf-8.txt
é
è
ÿ
à
$ iconv -f UTF-8 -t ISO-8859-1 -o iso-8859-1.txt utf-8.txt
$ hexdump -C iso-8859-1.txt
00000000  e9 0a e8 0a ff 0a e0 0a  0a                       |.........|
00000009

On voit que le fichier contient un 0xFF. Ton programme ne sera pas capable de lire plus.

**emmesse** · 10/05/2024, 06h15

oui c'est vrai, vous avez raison.
que pensez-vous de ceci:

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
//lexical.cpp
#include <iostream>
#include <fstream>
#include <string>
 
#include "lexical.hpp"
#include "terminaux.hpp"
 
lexical::lexical(char *fichierentree):enavant(0),debutlex(0),findefichier(false){
  entree.open(fichierentree);
  texte = readFileIntoString(fichierentree);
  enavant=0;
}
 
std::string lexical::readFileIntoString(const char* path) {
  if (!entree.is_open()){
    std::cerr << "Could not open the file - '" << path << "'" << std::endl;
    exit(1);
  }
  else{
    return std::string((std::istreambuf_iterator<char>(entree)),
		       std::istreambuf_iterator<char>());
  }
}
 
void lexical::analex(terminal &retourvaleur,std::string &retourattribut,int &ligne){
  if(obtenir_retourligneoucaractere(ligne))
    if(lexeme=="\n")
      retourvaleur=retourligne;
    else{
      retourattribut=lexeme;
      retourvaleur=caractere;
    }
  else if(findefichier)
    retourvaleur=FDF;
}
 
bool lexical::obtenir_retourligneoucaractere(int &ligne){
  debutlex=enavant;
  int etat=0;
  std::string c;
  while(true){
    switch(etat){
    case 0:
      c=carsuiv();
      if(c=="\n"){
	ligne++;
	etat=1;
      }
      else if(!findefichier)
	etat=1;
      else
	etat=2;
      break;
    case 1:
      lexeme=c;
      return true;
    case 2:
      return false;
    }
  }
}
 
 
std::string lexical::carsuiv(){
  int taille;
  if(enavant>=texte.size())
    findefichier=true;
  else if((unsigned char)texte[enavant] >= (unsigned char)0 && texte[enavant] <= (unsigned char)127)
    taille=1;
  else if((unsigned char)texte[enavant] >= (unsigned char)0xC2 && (unsigned char)texte[enavant] <= (unsigned char)0xdf)
    taille=2;
  else if((unsigned char)texte[enavant] >= (unsigned char)0xe0 && (unsigned char)texte[enavant] <= (unsigned char)0xef)
    taille=3;
  else 
    taille=4;
  std::string c=texte.substr(enavant,taille);
  enavant+=taille;
  return c;
}

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
22
23
#ifndef LEXICAL_HPP
#define LEXICAL_HPP
 
#include <string>
#include <fstream>
 
#include "terminaux.hpp"
 
class lexical{
public:
  lexical(char* fichierentree);
  void analex(terminal &retourvaleur,std::string &retourattribut,int &ligne);
private:
  std::string texte;
  std::ifstream entree;
  size_t enavant,debutlex;
  std::string lexeme;
  std::string readFileIntoString(const char* path);
  bool findefichier;
  bool obtenir_retourligneoucaractere(int &ligne);
  std::string carsuiv();
};
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
#ifndef TERMINAUX_HPP
#define TERMINAUX_HPP
 
enum terminal{FDF,retourligne,caractere};
 
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 $ ./a.out iso-8859-1.txt resultat
$ xxd resultat 
00000000: e90d 0ae8 0d0a ff0d 0ae0 0d0a            ............

**emmesse** · 14/05/2024, 22h31

et si on utilisait '\0' comme sentinelle de fin?
d'ailleur, le schéma de traduction dirigé par la syntaxe serait plutôt ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
fichier -> ligne {fichierprim.h = ligne.s} fichierprim {fichier.s=fichierprim.s } FDF
fichierprim -> retourligne ligne {fichierprim1.h=fichierprim.h + "\r\n" + ligne.s} fichierprim1 {fichierprim.s=fichierprim1.s}
            -> epsilon {fichierprim.s = fichierprim.h}
ligne -> caractere {ligneprim.h = caractere.s } ligneprim {ligne.s=ligneprim.s}
      -> epsilon {ligne.s=""}
ligneprim -> caractere {ligneprim1.h = ligneprim.h + caractere.s} ligneprim1 {ligneprim.s = ligneprim1.s}
          -> epsilon { ligneprim.s = ligneprim.h }

retourligne désigne '\n', FDF designe '\0' et caractère désigne [^\0\n]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
#ifndef TERMINAUX_HPP
#define TERMINAUX_HPP
 
enum terminal{FDF,retourligne,caractere};
 
#endif

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
#ifndef LEXICAL_HPP
#define LEXICAL_HPP
 
#include <string>
#include <fstream>
 
#include "terminaux.hpp"
 
class lexical{
public:
  lexical(std::string fichierentree);
  void analex(terminal &retourvaleur,std::string &retourattribut,int &ligne);
private:
  std::string texte;
  std::ifstream entree;
  size_t enavant,debutlex,taille_caractere;
  std::string lexeme;
  std::string readFileIntoString(const char* path);
  std::string carsuiv();
};
#endif

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
//lexical.cpp
#include <iostream>
#include <fstream>
#include <string>
 
#include "lexical.hpp"
#include "terminaux.hpp"
 
lexical::lexical(std::string fichierentree):enavant(0){
  entree.open(fichierentree.c_str());
  texte = readFileIntoString(fichierentree.c_str());
}
 
std::string lexical::readFileIntoString(const char* path) {
  if (!entree.is_open()){
    std::cerr << "Could not open the file - '" << path << "'" << std::endl;
    exit(1);
  }
  else{
    return std::string((std::istreambuf_iterator<char>(entree)),
		       std::istreambuf_iterator<char>());
  }
}
 
void lexical::analex(terminal &retourvaleur,std::string &retourattribut,int &ligne){
  int etat=0;//état courrant du diagramme de transition
  debutlex=enavant;//debutlex est l'indice du premier caractère du lexème suivant
  std::string c;
  bool continuer=true;
  while(continuer)
    switch(etat){
    case 0:
      c=carsuiv();//caractere suivant dans le texte d'entrée
      if(c[0]=='\n'){
	ligne++;
	etat=1;
      }
      else if(c[0]=='\0')
	etat=2;
      else
	etat=3;
      break;
    case 1:
      retourvaleur=retourligne;//unité lexicale retourligne
      continuer=false;
      break;
    case 2:
      retourvaleur=FDF;//unite lexicale FDF
      continuer=false;
      break;
    case 3:
      retourvaleur=caractere; //unité lexicale caractere
      retourattribut=c; //l'attribut de l'unité lexicale caractere
      continuer=false;
    }
}
 
 
 
std::string lexical::carsuiv(){
  if((unsigned char)texte[enavant] >= (unsigned char)0 && texte[enavant] <= (unsigned char)127)
    taille_caractere=1;
  else if((unsigned char)texte[enavant] >= (unsigned char)0xC2 && (unsigned char)texte[enavant] <= (unsigned char)0xdf)
    taille_caractere=2;
  else if((unsigned char)texte[enavant] >= (unsigned char)0xe0 && (unsigned char)texte[enavant] <= (unsigned char)0xef)
    taille_caractere=3;
  else 
    taille_caractere=4;
  std::string c=texte.substr(enavant,taille_caractere);
  enavant+=taille_caractere;
  return c;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
// main.cpp
#include <iostream>
#include "syntaxique.hpp"
 
int main(int argc, char *argv[]){
  if(argc!=3)
    std::cerr<<"usage:\nuix2dos fichierentrée fichiersortie"<<std::endl;
  else{
    syntaxique objetsyntaxique(argv[1],argv[2]);
    objetsyntaxique.fichier();
  }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
#ifndef TERMINAUX_HPP
#define TERMINAUX_HPP
 
enum terminal{FDF,retourligne,caractere};
 
#endif

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
22
23
#ifndef SYNTAXIQUE_HPP
#define SYNTAXIQUE_HPP
#include <string>
#include <vector>
 
#include "lexical.hpp"
#include "terminaux.hpp"
 
class syntaxique{
public:
  syntaxique(char *fichierentree,char *fichiersortie);
  void fichier();
private:
  void consommer(terminal const &attendu);  
  std::string ligne();
  std::ofstream sortie;
  std::string nomfichiersortie;
  terminal symbole;
  int numligne;
  lexical objetlexical;
  std::string lexeme;
};
#endif

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// syntaxique.cpp
#include <string>
#include <iostream>
#include <fstream>
 
#include "terminaux.hpp"
#include "syntaxique.hpp"
#include "lexical.hpp"
 
syntaxique::syntaxique(char *fichierentree,char *fichiersortie):nomfichiersortie(fichiersortie),numligne(1),objetlexical(fichierentree){
  objetlexical.analex(symbole,lexeme,numligne);
}
 
void syntaxique::consommer(terminal const &attendu){
  if(symbole==attendu)
    if(attendu != FDF)
      objetlexical.analex(symbole,lexeme,numligne);
}
 
/*
fichier -> ligne {fichierprim.h = ligne.s} fichierprim {fichier.s=fichierprim.s } FDF
fichierprim -> retourligne ligne {fichierprim1.h=fichierprim.h + "\r\n" + ligne.s} fichierprim1 {fichierprim.s=fichierprim1.s}
            -> epsilon {fichierprim.s = fichierprim.h}
*/
 
void syntaxique::fichier(){
  std::string fichier_s;
  if(symbole==caractere||symbole==retourligne){
    std::string ligne_h="";//attribut hérité du non-terminal ligne
    std::string ligne_s=ligne();//ligne_s est l'attribut synthétisé du non terminal ligne
    std::string fichierprim_h=ligne_s; //fichierprim_h est l'attribut hérité du non-terminal fichierprim
    while(symbole==retourligne){
      consommer(retourligne);
      ligne_s=ligne();
      fichierprim_h+="\r\n"+ligne_s;
    }
    std::string fichierprim_s=fichierprim_h; // fichierprim -> epsilon {fichierprim.s=fichierprim.h}
    fichier_s=fichierprim_s;
  }
  sortie.open(nomfichiersortie.c_str());
  sortie<<fichier_s;
  consommer(FDF);
}
 
/*
ligne -> caractere {ligneprim.h = caractere.s } ligneprim {ligne.s=ligneprim.s}
      -> epsilon {ligne.s=""}
ligneprim -> caractere {ligneprim1.h = ligneprim.h + caractere.s} ligneprim1 {ligneprim.s = ligneprim1.s}
          -> epsilon { ligneprim.s = ligneprim.h }
*/
 
std::string syntaxique::ligne(){
  std::string ligne_s;
  if(symbole==caractere){
    std::string caractere_s=lexeme;
    consommer(caractere);
    std::string ligneprim_h=caractere_s;
    while(symbole==caractere){
      caractere_s=lexeme;
      consommer(caractere);
      ligneprim_h+=caractere_s;
    }
    std::string ligneprim_s=ligneprim_h;
    ligne_s=ligneprim_s;
  }
  else
    ligne_s="";
  return ligne_s;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ xxd iso-8859-1.txt 
00000000: e90a e80a ff0a e00a
$ ./a.out iso-8859-1.txt resultat
$ xxd resultat
00000000: e90d 0ae8 0d0a ff0d 0ae0 0d0a

pour soumettre un programme dans la section code sources

C++

Discussions similaires

Partager

Partager