Discussion :

[odsen.s]

Bonsoir,

Je me lance dans la réalisation d'un shell de commandes qui servira a effectuer des calculs mathématiques.

Exemple de fonctionnement :

Invite de commandes mathematiques.

> A = 1 saisie utilisateur
> B = 2 saisie utilisateur
> A + B saisie utilisateur
>> 3 un résultat

Et par la suite, je pourrais rajouter en plus de ces simples assignations et opérations de bases, des fonctions arithmétiques et géométrique plus amusantes :p

Voici à quoi ressemble mon main pour l'instant :

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
 
#include <stdio.h>
#include <stdlib.h>
#include "ed/inc/io.h"
 
 
#define TAILLE_MAX_COMMANDE 32
 
int main(int argc, char *argv[])
{
    printf("Invite de commandes mathematiques.\n\n");
 
    char commande[TAILLE_MAX_COMMANDE] = {0};
    int retour = 0;
 
    for(;;)
    {
        // Affichage du promt
        printf("> ");
        fflush(stdout);
 
        // Tant que la saisie ne se fait pas sans erreur
        while ((retour = get_s(commande, sizeof commande)) != IO_OK)
        {
            // Si l'erreur est un dépassement de taille du tableau
            if (retour == IO_ERR_LENGTH)
                printf("La commande est trop longue et ne sera donc pas traitee.\n");
 
            // Sinon, on n'analyse pas le cas par cas (inintéressant ici)
            else printf("Erreur indeterminee. La commande ne sera pas traitee.\n");
 
            // Affichage du promt
            printf("> ");
            fflush(stdout);
        }
 
        // Si la chaine saisie est "quit", on quitte le programme normalement
        if (strcmp(commande, "quit") == NULL)
            return EXIT_SUCCESS;
    }
}

Pour l'instant, il ne fait pas grand chose...

Le premier problème que je me pose : comment reconnaître correctement les commandes saisies ?
En effet, si l'utilisateur entre "A=1", "A= 1", " A = 1", le résultat devra être le même.

J'ai imaginé un début de solution à partir de fonctions que j'ai créées pour un projet précédant :

- lire la saisie
- définir les caractères qui doivent impérativement être "décollés" des autres expressions (ici, c'est =)
- compter le nombre d'espaces manquants, s'il manque des espaces
- allouer dynamiquement une nouvelle chaine avec assez de place pour contenir des espaces en plus
- copier la saisie en rajoutant les espaces manquants

En gros, ce morceau fait ça :
"A=1" devient "A = 1".

Ensuite :
- on peut désormais lire chaque mot indépendamment
- on regarde si ça correspond à un "modèle" (ici LETTRE = VALEUR), et on applique la fonction (je n'ai pas encore mis en place cette partie "reconnaissance de modèle")

Pensez-vous que je parte sur quelque chose de correct ?
Ca me paraît long comme démarche, fastidieux.
Comment feriez-vous pour reconnaître que la saisie appartient à un "modèle" défini ?

Par avance, merci.

[Flow_75]

salut,

pourquoi n'utilise pas tu le scanf ?
tu peux faire par exemple:

Code :

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

scanf("%c %c %f", &var, & operation, &valeur)

[Emmanuel Delahaye]

salut,

pourquoi n'utilise pas tu le scanf ?
tu peux faire par exemple:

Code :

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

scanf("%c %c %f", &var, & operation, &valeur)

scanf(), c'est le Démon !

[Lunixinclar]

Pour un évaluateur d'expressions mathématiques évolué (qui accepte des noms de variables) tu peux commencer par comprendre le mécanisme avec Flex/Lex/Bison
http://www.cs.ucr.edu/~lgao/teaching/bison.html
http://cs.uic.edu/~spopuri/cparser.html
http://cs.wwc.edu/~aabyan/Linux/compiler/index.html
http://www.therobs.com/uman/lexyacc.shtml
http://docs.freebsd.org/info/bison/b...tion_Calc.html
... Et plus tard quand tu seras à l' aise, tout faire à la main en employant une pile ou un arbre. Les sources de certains shells sont disponibles (cf busybox qui en contient plusieurs, tous ayant le souci de rester simples).
http://www.codepedia.com/1/Art_Expressions_p1
http://www.arstdesign.com/articles/e...valuation.html
C'est beaucoup de boulot... Fais chauffer google, vive le C et bonne prog.

[odsen.s]

Merci des conseils et liens.

Quelles sont les différences entre lex/yacc et flex/lex/bison ?

[Emmanuel Delahaye]

Quelles sont les différences entre lex/yacc et flex/bison ?

Pas de différence, à part la licence. Le dernier est GNU, donc FSF.

[Emmanuel Delahaye]

Je me lance dans la réalisation d'un shell de commandes qui servira a effectuer des calculs mathématiques.

Le premier problème que je me pose : comment reconnaître correctement les commandes saisies ?
En effet, si l'utilisateur entre "A=1", "A= 1", " A = 1", le résultat devra être le même.

Tout devient "A=1" : supprimmer les espaces inutiles après la saisie.

Plouf ! Module STR : STR_DelBlanks()

J'ai imaginé un début de solution à partir de fonctions que j'ai créées pour un projet précédant :
<...>
En gros, ce morceau fait ça :
"A=1" devient "A = 1".

Alors ça, c'est autre chose. C'est la 'normalisation'. C'est complexe si il faut agrandir la chaine. Mais ça ne sert à rien. Les séparateurs de tokens sont connus. Ce sont les opérateurs (ici, '='). Avant d'aller plus loin tu dois définir une syntaxe et une grammaire pour toutes les expressions possibles.

Ensuite lex et yacc sont tes amis ou alors tu fais tout à la main.

Attention, un automate d'analyse de syntaxe, c'est pas facile à faire évoluer...

Trop cool :

Invite de commandes mathematiques.

> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
La commande est trop longue et ne sera donc pas traitee.
> ^Z
Erreur indeterminee. La commande ne sera pas traitee.
> quit

Press ENTER to continue.

J'aurais écrit le code comme ça :

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
#include "ed/inc/io.h"
 
#include <stdlib.h>
#include <string.h>
 
int main (void)
{
   int end = 0;
   printf ("Invite de commandes mathematiques.\n\n");
 
   while (!end)
   {
      char commande[32];
      int retour = 0;
      // Affichage du promt
      printf ("> ");
      fflush (stdout);
 
      // Tant que la saisie ne se fait pas sans erreur
      while ((retour = get_s (commande, sizeof commande)) != IO_OK)
      {
         // Si l'erreur est un dépassement de taille du tableau
         if (retour == IO_ERR_LENGTH)
         {
            printf
               ("La commande est trop longue et ne sera donc pas traitee.\n");
         }
         // Sinon, on n'analyse pas le cas par cas (inintéressant ici)
         else
         {
            printf
               ("Erreur indeterminee. La commande ne sera pas traitee.\n");
         }
         // Affichage du promt
         printf ("> ");
         fflush (stdout);
      }
 
      // Si la chaine saisie est "quit", on quitte le programme normalement
      if (strcmp (commande, "quit") == NULL)
      {
         end = 1;
      }
   }
   return EXIT_SUCCESS;
}

[odsen.s]

salut,

pourquoi n'utilise pas tu le scanf ?

Je n'utilise pas (plus) scanf car si on ne s'en sert pas correctement (et c'est assez difficile) on doit s'attendre à des comportements imprévus.

Tout devient "A=1" : supprimmer les espaces inutiles après la saisie.

Plouf ! Module STR : STR_DelBlanks()

Super, je n'avais pas encore regardé str.

Alors ça, c'est autre chose. C'est la 'normalisation'. C'est complexe si il faut agrandir la chaine. Mais ça ne sert à rien. Les séparateurs de tokens sont connus. Ce sont les opérateurs (ici, '='). Avant d'aller plus loin tu dois définir une syntaxe et une grammaire pour toutes les expressions possibles.

Ensuite lex et yacc sont tes amis ou alors tu fais tout à la main.

Attention, un automate d'analyse de syntaxe, c'est pas facile à faire évoluer...

Ok, merci de toutes ces infos Y a plus qu'à !

Trop cool :
Citation:
Invite de commandes mathematiques.

> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
...

N'est-ce pas