salut,

en premier on dit à yacc d'utiliser une structure d'arbre comme YYSTYPE:
#define YYSTYPE tree_t
YYSTYPE c'est la structure (instanciée sous le nom yyval dans le parser) qui permet de sauvegarder des états sémantiques, c'est donc par l'intermédiaire de cette variable que tout ce fait dans un programme utilisant yacc

la structure tree_t est définie dans le .h

ensuite le hack (détournement) de yacc est ici (ligne "hack:" dans la grammaire .y)
on active le mode debug: #define YYDEBUG 1

et on redéfinit la macro YY_SYMBOL_PRINT :
// le hack: on hack une des macros utilisées en mode YYDEBUG pour éxecuter notre action (création de l'arbre) à chaque réduction
#undef YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(A,B,C,D) \
do { \
int n = yyr2[yyn]; \
int i; \
yyval.nb_links = n; \
yyval.links = malloc(sizeof *yyval.links * yyval.nb_links); \
yyval.str = NULL; \
yyval.type = yytname[yyr1[yyn]]; \
for (i = 0; i < n; i++) { \
yyval.links[i] = malloc(sizeof (YYSTYPE)); \
memcpy(yyval.links[i], &yyvsp[(i + 1) - n], sizeof (YYSTYPE)); \
} \
} while (0)

en activant le debug, YY_SYMBOL_PRINT est appelé à chaque réduction, et le YY_SYMBOL_PRINT ainsi redéfini construit l'abre syntaxique (yyval, variable interne de yacc est de type YYSTYPE c'est à dire de type tree_t)

conclusion : j'aurais pu près chaque ligne de la grammaire rajouter un appel à construire_noeud(fils1,fils2,fils3...) et stocker le noeud ainsi créé dans le yyval, mais ici j'ai trouvé un moyen d'éviter ça même si le résultat est le même

salut je l'ai fait sous cygwin avec bison 2.3 et flex 2.5.4

n'hésitez pas à me rendre compte de vos expériences problèmes avec ce parseur

wops c'est

while(!(n%d)) {
     puissance_facteurs_premiers[nb]++;
     n /= d;
}

et pas

while(!(n%d)) {
     puissance_facteurs_premiers[nb]++;
     n /= 2;
}

salut

j'ai recodé ton programme comme je l'aurais fait, à toi de voir si c'est plus clair

#include <stdio.h>

#define MAX 10

void decomposer(int n, int *facteurs_premiers, int *puissance_facteurs_premiers, int *nombre_facteurs_premiers) {
    int nb = 0, d = 3;
    printf("%d = ",n);
    if (!(n%2)) {
        facteurs_premiers[0] = 2;
        puissance_facteurs_premiers[0] = 1;
        n /= 2;
        while(!(n%2)) {
            puissance_facteurs_premiers[0]++;
            n /= 2;
        }
        printf("2^%d * ", puissance_facteurs_premiers[0]);
        nb = 1;
    }
    while(n != 1) {
        if (!(n%d)) {
            facteurs_premiers[nb] = d;
            puissance_facteurs_premiers[nb] = 1;
            n /= d;
            while(!(n%d)) {
                puissance_facteurs_premiers[nb]++;
                n /= 2;
            }
            printf("%d^%d * ", d, puissance_facteurs_premiers[nb]);
            nb++;
        }
        d += 2;
    }
    *nombre_facteurs_premiers = nb;
}

void enumerer_diviseurs(int *facteurs_premiers, int *puissance_facteurs_premiers, int nombre_facteurs_premiers, int diviseur, int *somme_diviseurs) {
   int i;
   if (nombre_facteurs_premiers == 0) { *somme_diviseurs += diviseur; printf("%d\n", diviseur); return; }
   for (i = 0; i <= *puissance_facteurs_premiers; i++) {
      enumerer_diviseurs(facteurs_premiers+1,puissance_facteurs_premiers+1, nombre_facteurs_premiers-1,diviseur,somme_diviseurs);
      diviseur *= *facteurs_premiers;
   }
}

int main(int argc, char* argv[])
{
    int facteurs_premiers[MAX],puissance_facteurs_premiers[MAX],nombre_facteurs_premiers, Nombre, somme_diviseurs;
while(1)
{
printf("Veuillez entrer le nombre a decomposer \n");
scanf("%d",&Nombre);
printf("\n");
decomposer(Nombre,facteurs_premiers, puissance_facteurs_premiers, &nombre_facteurs_premiers);
somme_diviseurs = 0;
printf("\ndiviseurs:\n");
enumerer_diviseurs(facteurs_premiers, puissance_facteurs_premiers, nombre_facteurs_premiers, 1, &somme_diviseurs);
printf("\n\nLa partie Aliquote du nombre est %ld",somme_diviseurs);
printf("\n\n");
}
return 0;
}

la fonction diviseurs()

et s'il y a plus que 7 diviseurs ?

exemple 223092870 = 2*3*5*7*11*13*17*19*23

salut
il y a des trucs un peu bizarres (au niveau algorithmique et clarté) dans ton code!

je suis d'accord avec manta7 il a qu'à se renseigner sur lex avant de poster

salut

pour la recherche dans le dictionnaire: soit le dico est trié est tu fais ta recherche par dichotomie, soit il est trié en arbre si tu as besoin de pouvoir rajouter de nouveaux éléments, dans tous les cas il faut pouvoir faire la recherche en log n si le dico est très grand

salut je peux faire encore plus court

int tab[MAX]; // la factorisation
int factoriser(int n) { // n : le nombre à factoriser
  int i, d;
  i = 0;
  while (!(n & 1)) { tab[i++] = 2; n >>= 1; }
  d = 3;
  while (n != 1) {
     while(!(n % d)) { tab[i++] = d; n /= d; }
     d += 2;
  }
  return i;
}

ha d'accord !
je suis désolé je croyais que tu testais si le (2^n)-1 était premier pardon