Discussion :

[student_]

Bonjour,

J'ai réalise un petit shell, la 1ere commande s'exécute correctement, mais la 2eme segfault comme si j'essayais de parcourir un char * qui n'existe pas, j'aimerais donc savoir si j'ai bien comprit le fonctionnement des listes chaines avec ces quelques questions fondamentales:

Contexte:
-J'ai une liste chaine "list" initialise a NULL que je n'est pas malloc (je le précise car quand je la malloc ca ne fonctionne plus du tout, c'est d'ailleurs très traumatisant^^).
-J'ai une liste chaine new qui va me permettre d'ajouter des éléments a list.
-J'ai une liste chaine move qui va me permettre de me déplacer, pour ajouter new a la fin de la liste a chaque fois.
-Ces 3 listes ont le meme prototype et contiennent toutes un char **

1) Y a t-il une raison apparente qui expliquerait pourquoi quand je malloc list, le programme ne fonctionne plus du tout ?

2) Je commence par malloc new, ensuite, je malloc son char **, le remplit, je dis que new->next = NULL et vient le placer (le maillon new) a la fin de list (donc sur NULL pour la 1ere etape), dois-je free new avant de re-créer un autre malloc de new pour l'élément suivant ou esceque cela supprimerai le maillon que je viens de créer sur list ?

3) Je me sert de move pour parcourir list, il ne contiendra aucune donnée, doit il vraiment être malloc ? Et une question qui ressemble a celle ci-dessus, faut il free move si on veut free list et recréer une list vierge qui sera traitée de la même manière ?

Merci !

[Pouet_forever]

Dans l'ensemble ça m'a l'air correct, mais sans code je vois mal comment on peut t'aider

Quand tu alloues ton char** tu alloues bien les "2 dimensions" ? Je suppose que tu fais un strcpy après et ton segfault doit venir de là

J'ai pas bien compris l'utilité de ton 'move'. Je pense que tu t'es trompé, ce n'est pas une liste chaînée mais juste un pointeur sur ta liste chaînée.

[student_]

Salut Pouet !

Oui le char ** est alloue correctement, il n'y a pas de probleme pour le "premier tour", je read mon entrée standrad, je stock tout dans un char **, ensuite ma liste est compose de plusieurs maillon et chacun a un char ** dans lesquels je reparties mes arguments et ca fonctionne bien, je gere les commandes et les options et ca fonctionne niquel, ensuite je lui redonne une commande, il remplit bien la liste, mais segfault plus loin quand je veux la parcourir a l'aide d'un autre pointeur sur structure (dans use_path)

Je pose le problème de façon théorique, car le code reel est trop long pour être poster ici mais je vais mettre la partie essentielle, ca risque de piquer un peu les yeux mais avoir une réponse aux questions que je pose dans ordon_data en commentaire serait déjà une bonne avancée^^ le Segfault est dans use_path, dans la fonction my_malloc_path (je ne peux pas parcourir le char** de moove, pourtant au 1er tour je peux). Ca fonctionne bien le 1er coup donc je présume que je ne remalloc pas ou ne free pas un element essentiel, je pense notamment a moove de use_path (Pour le moment je cherche a ce que ca fonctionne en lui envoyant une seule commande a la fois meme si j'ai code le ';' donc les listes contiennent toujours un seul maillon):

.ordon_data.c
.use_path.c
.main.c
.init_values.c
.prototype de ma liste


ICI JE MET LES COMMANDES DANS DES MAILLONS.

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
void            ordon_data(t_data **list, t_args *ptr)
{
  t_data        *moove;
  t_data        *new;

  ptr->fin = 0;
  ptr->debut = 0;
  moove = malloc(sizeof(*moove)); /*Est il utile  malloc moove ? Quand ma liste est complete, je l'envoie plus loin dans le main, puis l'execute, puis la free, et le main reprends au debut, esceque je dois free moove a part ou son espace memoire est il le meme que la liste ?*/
  while (ptr->fin < ptr->len)
    {
      new = malloc(sizeof(*new)); /*Faut il vraiment malloc a chaque fois sans free ?*/
      new->next = NULL;
      if (ptr->args[ptr->fin])
        find_the_next_cmd(&(ptr->fin), ptr->args);
      list_malloc_args_tab(&new, ptr->args, ptr->debut, ptr->fin);
      list_full_args_tab(&new, ptr->args, &(ptr->debut), ptr->fin);
      if (ptr->args[ptr->fin])
        ptr->fin++;
      if (*list == NULL)
        *list = new;
      else if (*list != NULL)
        {
          moove = *list;
          while (moove->next != NULL)
            moove = moove->next;
          moove->next = new;
        }
    }
}

ICI JE TRAITE MA CHAINE, PUIS EXECUTE LA COMMANDE, ET SUPPRIME LE 1ER MAILLON

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
void            use_path(t_data *list, char **envp)
{
  t_path        path;
  t_data        *moove;
  t_data        *epur;
  int           a;
 
  a = 1;
  moove = malloc(sizeof(*moove));
  moove = list;
  while (moove != NULL)
    {
      init_path_values(&path);
      find_path(envp, &path);
      while ((a != 0) && envp)
        {
          my_malloc_path(envp, &path, moove);
          print_path(envp, &path);
          stick_cmd(&path, moove);
          a = access(path.path, F_OK);
          path.fin++;
        }
      execute(envp, path, moove);
      free(path.path);
      epur = moove;
      moove = moove->next;
      free(epur);
    }

}

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
int             main(int ac, char **av, char **envp)
{
  t_data        *list = NULL;
  t_args        args;
 
  (void)ac;
  (void)av;
  while (42)
    {
      /*list = malloc(sizeof(*list));*/ /*Ici je ne comprends pas pourquoi si je malloc ca ne fonctionne plus*/
      my_putstr("->");
      read_args(&args);
      ordon_data(&list, &args);
      free__t_args(&args);
      use_path(list, envp);
      free__list(&list);
    }
}

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
void            free__list(t_data *(*list))
{
  t_data        *epur;
  t_data        *move;
 
  epur = malloc(sizeof(*epur)); /* Meme principe, faut il vraiment malloc ? epur sert a supprimer chaque maillon */
  move = malloc(sizeof(*move)); /* Et move sert a placer epur sur le maillon suivant */
  epur = *list;
  move = epur->next;
  while (move != NULL)
    {
      free(epur);
      epur = move;
      move = move->next;
    }
  free(epur);
}
 
void            free__t_args(t_args *ptr)
{
  int   y;
 
  y = 0;
  while (ptr->args[y])
    {
      free(ptr->args[y]);
      y++;
    }
}

Code :

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

1
2
3
4
5
typedef struct  s_data
{
  char          **cmd;
  struct s_data *next;
}               t_data;

[student_]

JE viens de recevoir l'aide d'une amie, problème résolut ! (je ne reinitialisais pas ma list)