lex yacc - Page 1

c est encore moi apres caml je suis passé a lex et yacc!
mais j avance pas bien vite existe t il des doc en francais de preferences sur ces 2 outils et y a t il un moyen de compiler les fichiers lex et yacc sous windows?

enfin comment creer une liste chainée de caractere ajouter des elements et faire une recherche dans cette chaine?

Help me please

cicdrek
: enfin comment creer une liste chainée de caractere ajouter des elements et faire une recherche dans cette chaine?

tu définis ca :

struct listeC {
  struct listeC * lc_suivante;
  struct listeC * lc_precedente;  //celle la c'est pas obligé
  char caracter;
}

creer : l=malloc(sizeof(struct listeC));
l->lc_suivante=NULL;

ajouter : boucle sur la liste pour arriver au dernier et faire un créer

rechercher : boucle à partir du premier

hibOu
:

cicdrek
: enfin comment creer une liste chainée de caractere ajouter des elements et faire une recherche dans cette chaine?

tu définis ca :

struct listeC {
  struct listeC * lc_suivante;
  struct listeC * lc_precedente;  //celle la c'est pas obligé
  char caracter;
}

creer : l=malloc(sizeof(struct listeC));
l->lc_suivante=NULL;

ajouter : boucle sur la liste pour arriver au dernier et faire un créer
rechercher : boucle à partir du premier

merci de ton aide hibou

j ai un autre probleme voila en fait je veut gerer 2 piles avec yacc et lex
et en prenant un nombre en entrée j arrive pas a empiler sur la pile principale il empile systematiquement 0....

voila mon code enfin la partie qui t interesse

%{
#include <stdio.h>
#include <ctype.h>
#define MAX_PILE 200
#define YYSTYPE double

typedef struct
{
int tab_elts[MAX_PILE];
int nb_elts;
} T_Pile;

T_Pile pile_prim;

void empiler_prim(int val);
%}

%token NOMBRE add

%%

ligne : ligne expr '\n' { printf("%d\n",$2); }
| ligne '\n'
|
;


expr : add { empiler_prim( depiler_prim() + depiler_prim()); }

| NOMBRE { empiler_prim(atof(yytext)); }
| resul {printf("Voici le resultat : %d\n",depiler_prim());}
;


void pilevide_prim()
{
pile_prim.nb_elts = 0;
}

void pilevide_seco()
{
pile_seco.nb_elts = 0;
}




void empiler_prim(int val)
{
if (pile_prim.nb_elts == MAX_PILE)
yyerror("Pile principale est pleine...");
else
{
printf("j'empile : %d \n",val);
pile_prim.tab_elts[pile_prim.nb_elts++]=val;
}
}


int main()
{
pilevide_seco();
pilevide_prim();
yyparse();
}








et mon lex ressemble a ca:


%{
#include <stdlib.h>
#include "y.tab.h"
%}

chiffre [0-9]
nombre {chiffre}+(\.{chiffre}+)?

%%

{nombre} {atoi(yytext); return NOMBRE; }
"+" {return add;}
%%


je comprend pas ce 0 quoi que je fasse mais je sais qu il empile des 0 et non le nombre que je rentre au clavier mais il empile...

je pas vu de pb

Et d'apres ce que j'ai compris, tu fais des calculs en notation polonaise :
2
3
+
renvoie 5

sinon, faut débugger => faut mettre des printf(...) pour savoir d'ou viennent ces zeros

PS : pour mettre des sources et qu'elle s'affiche bien (ca me permet de lire plus facilement), met la balise pre comme dans ce post. Et tu pourrais mettre un peu de ponctuation dans tes phrases : pareil, j'irai plus vite. merci.

hibOu :
je pas vu de pb

Et d'apres ce que j'ai compris, tu fais des calculs en notation polonaise :
2
3
+
renvoie 5

sinon, faut débugger => faut mettre des printf(...) pour savoir d'ou viennent ces zeros
PS : pour mettre des sources et qu'elle s'affiche bien (ca me permet de lire plus facilement), met la balise pre comme dans ce post. Et tu pourrais mettre un peu de ponctuation dans tes phrases : pareil, j'irai plus vite. merci.

ok merci g trouvé la solution a ce probleme maintenant g un autre petit souci avec une fonction que je voudrais réaliser:

en fait j essaie de faire un sous language de forth a l aide de yacc et lex c est ca le but. J'arrive pas a stocker de nouveau mots clefs qui seraient défini de la facon suivante:

:motcefs

instructions

;
comment faire en sorte qu il reconnaisse mon expression?

voici mon essai:

expr:depoin ident expr resul {empiler_prim(motclef($2,$3));}




g essayer de réaliser les fonctions suivantes:



YACC:

 char motclef(char nommo, char def)
 {
 if(tablo1.nb_elts_tabl==tableau)
 yyerror("plus de place pour stocker de nouveaux mots clefs");
 else{
 	strcpy(tablo1.tabl[i][0],nommo);
	strcpy(tablo1.tabl[i][1],def);
	i++;
	nb_elts_tabl=i;
	printf("nouveau mot clef:%s stocké\n",nommo);
	return def;
}




char lister()
{
    for(a=0; a<i; a++)
	{
        	printf("mots clefs %d %s:\n",a,tablo1[a][0]);
	}

    return 0;

}

comment faire en sorte qu il reconnaisse mon expression?



LEX:
je ne sais pas comment definir un motclef dans mon lex j'ai donc essayé ceci:

mot {lettres}+("-")?("_")?{lettres}+

la question également est que doit retourner {mot} {return???}

Je ne connais pas le langage forth, c quoi, ca ressemble à quoi ?
Si tu me montres, je saurais un peu plus ce que tu veux.

cicdrek :
:motcefs

instructions

;
comment faire en sorte qu il reconnaisse mon expression?

voici mon essai:

expr:depoin ident expr resul {empiler_prim(motclef($2,$3));}

Si tu ajoute ca à ta derniere regle de production de expr, la ca va faire des truc drolement bizarre : tu pourra enchainer des definitions de mot clefs avec au plus une instruction (add ou nombre)

Aussi, une truc qui est bien pour la syntaxe est de mettre en majuscule tous les terminaux, c'est plus lisible

pour un IDENT, souvent c'est comme ceci :
chiffre ([0-9])
alpha ([a-zA-Z])
alphanum ([a-zA-Z_0-9])
(_|{alpha})(_|{alphanum})* {return IDENT;}
et pour un entier ou un flottant :
(\+|\-)?({chiffre}+) {return ENTIER;}
(\+|\-)?({chiffre}+\.{chiffre}*|{chiffre}*\.{chiffre}+)((e|E)(\+|\-)?{chiffre}+)? {return FLOTTANT;}

hibOu :
Je ne connais pas le langage forth, c quoi, ca ressemble à quoi ?
Si tu me montres, je saurais un peu plus ce que tu veux.

cicdrek :
:motcefs

instructions

;
comment faire en sorte qu il reconnaisse mon expression?

voici mon essai:

expr:depoin ident expr resul {empiler_prim(motclef($2,$3));}

Si tu ajoute ca à ta derniere regle de production de expr, la ca va faire des truc drolement bizarre : tu pourra enchainer des definitions de mot clefs avec au plus une instruction (add ou nombre)

Aussi, une truc qui est bien pour la syntaxe est de mettre en majuscule tous les terminaux, c'est plus lisible

pour un IDENT, souvent c'est comme ceci :
chiffre ([0-9])
alpha ([a-zA-Z])
alphanum ([a-zA-Z_0-9])
(_|{alpha})(_|{alphanum})* {return IDENT;}
et pour un entier ou un flottant :
(\+|\-)?({chiffre}+) {return ENTIER;} (\+|\-)?({chiffre}+\.{chiffre}*|{chiffre}*\.{chiffre}+)((e|E)(\+|\-)?{chiffre}+)? {return FLOTTANT;}

le fait que ca doive faire un sous ensemble du forth n'est pa important

ce que j aimerai c'est que mon interpreteur reconnaisse une fonction du type

: IDENT

instruction

;

c'est a dire qu un morceau de code du type:

: fibonnacci
dup 0 = if return endif
dup 1 = if return endif
dup 2 - fibonnacci
swap
1-fibonnacci
+
;

devrait me ranger dans un tableau a 2 dimension

nomfonction: fonction:

fibonnacci dup 0 = if return endif
dup 1 = if return endif
dup 2 - fibonnacci
swap
1-fibonnacci
+
;

comme ca a chaque fois que je ve faire a fibonnacci je n'ai plus qu a taper:
5 fibonnacci . cr
par exemple c'est ca que je voulais faire avec :

expr:depoin ident expr resul {empiler_prim(motclef($2,$3));}

Alors moi je dirais plutot:

Lignes  :  Lignes  Ligne  FINLIGNE
        |  Lignes FINLIGNE
        ;

Ligne  :  Exprs
       |  Fonction
       ;

Fonction  :  DEUXPTS  IDENT  Exprs  PTV
          ;

Exprs  :  Exprs Expr
       |  Expr
       ;

Expr  :  Oper
      |  ENTIER
      |  FLOTTANT
      ;

Oper  :  PLUS
      |  IDENT
      ;

Par contre y'aura aucun typage, donc ca peut faire vraiment n'importe quoi.
Par exemple un appel :
fibonnacci . cr
va faire des choses bizarres au niveau de la pile ...