Avantages du strtok :
- on peut mettre une liste de séparateurs, donc c'est plus facile à gérer qu'un while.
- on peut changer la liste de séparateurs entre deux appels.

Gros inconvénients :
- ça utilise une globale pour conserver le pointeur entre 2 appels, donc si une fonction fait une boucle sur un strtok et qu'elle en appelle une autre qui utilise aussi strtok, au retour on a perdu la première boucle (pas réentrant du tout !)
- la chaîne en entrée est modifiée (d'où le strdup de l'exemple fourni je suppose -- il manque d'ailleurs le free correspondant).

Globalement :
 connaître, mais à utiliser avec parcimonie !

_MICHEL : Une idée, comme ça : en ligne 45, ajoute P[6]=P{7]=(unsigned long)0xffffffff;
Il faudrait aussi vérifier que Maxpile > 4 (à toi de voir ...)

_MICHEL : Mets "P = (unsigned long *)malloc((2+2*MAXPILE)*sizeof(unsigned long));" pour l'allocation !
On pourrait avoir un plantage en ligne 62! :((
Je n'ai jamais rencontré ce problème, mais quand n=MAXPILE-1 , on y calcule P[2*MAXPILE+1] et ça fait un peu trop dans la mesure où on alloué 2*MAXPILE ...

Quand même curieux que je n'aie jamais rencontré ce cas !!

Pour _MICHEL : je ne fais que ça depuis bientôt 20 ans ! :(
J'ai repris le source fourni tel quel et je l'ai recompilé : no problem !
Essaie de supprimer les optimisations dans les options de compilation (/Od pour µSoft Visual C++).
En général les optimisations créent plus de problèmes que ça n'en résout !
En ligne 40 tu peux aussi ajouter :
   if (!P)
   {
   printf("Impossible d'allouer %d octets.\n", 2*MAXPILE*sizeof(unsigned long));
   return;
   }
pour le cas où l'allocation aurait raté !
Sinon, tu n'as plus qu'à mettre des "printf", pour voir où tu bloques ...
Tu peux aussi mettre la fonction suivante (modifiée par rapport au source fourni)
void dumpPile(int n)
{
   int i;

   n = 2*n ;
   for (i=n+1; i>=0; i-=2)
printf("%d:%d ", gP[i], gP[i-1]);       /* +grd multiple trouvé : premier */
   printf("\n");
}
et insérer un "dumpPile(n);" avant la ligne 52.
Pour Erat 10, tu dois obtenir :

Liste des 10 premiers nombres premiers
2 - 3 - 5 - 7 14:7 10:5 9:3
14:7 12:3 10:5
- 11 22:11 15:5 14:7 12:3
- 13 26:13 22:11 15:5 15:3 14:7
26:13 22:11 21:7 15:5 15:3
26:13 22:11 21:7 18:3 15:5
- 17 34:17 26:13 22:11 21:7 20:5 18:3
- 19 38:19 34:17 26:13 22:11 21:7 21:3 20:5
38:19 34:17 26:13 25:5 22:11 21:7 21:3
38:19 34:17 26:13 25:5 24:3 22:11 21:7
38:19 34:17 28:7 26:13 25:5 24:3 22:11
- 23 46:23 38:19 34:17 33:11 28:7 26:13 25:5 24:3
46:23 38:19 34:17 33:11 28:7 27:3 26:13 25:5
46:23 38:19 34:17 33:11 30:5 28:7 27:3 26:13
46:23 39:13 38:19 34:17 33:11 30:5 28:7 27:3
46:23 39:13 38:19 34:17 33:11 30:5 30:3 28:7
- 29

Pour KIRUA. Si c'est un crible quand même ! C'est vraiment le même algorithme à la base : on élimine les multiples des nombres premiers trouvés. Simplement au lieu de barrer tous les multiples d'un nombre dans une boucle, on le fait pour tous au fur et à mesure.

_MICHEL : ce n'est pas normal : Sur mon PIV, 2.4Ghz, un "prem 1000" dure moins d'une seconde. Faute de frappe ?

Pour AUDRANCHAR : ce code devait me permettre de faire une version du crible pour une machine à pile.
Pour POLE4 : ce code ne renvoie pas tous les premiers<n mais les n premiers.

Je sais que l'explication qui suit n'est pas simple, mais je ne sais pas comment vous le dire autrement !

Exemple de dump pour expliquer le fonctionnement

Premiers :  2 - 3 - 5 - 7
14-7 10-5 9-3                             Pile initiale
14-7 12-3 10-5                            Multiple de 3 suivant, bien placé (9+3 -> 12-3)
15-5 14-7 12-3                            Multiple de 5 suivant, bien placé (10+5 -> 15-5)
Premier : 11                              10+1 < 12 donc 11 premier
                                          (comparaison "10-5" et "12-3")
22-11 15-5 15-3 14-7                      11 mis dans la liste, avec son premier multiple (22)
Premier : 13                              12+1 < 14 donc 13 est premier  ("12-3" et "14-7")
26-13 22-11 21-7 15-5 15-3                13 est mis dans la liste et le multiple de 7 est placé
26-13 22-11 21-7 18-3 15-5                Multiple de 3 suivant, bien placé (15+3 -> 18-3)
26-13 22-11 21-7 20-5 18-3                Multiple de 5 suivant, bien placé (15+5 -> 20-5)
Premier : 17                              15+1 < 18 donc 17 est premier (impair suivant 15+1=16)
34-17 26-13 22-11 21-7 21-3 20-5          17 est mis dans la liste
Premier : 19                              18+1 < 20 donc 19 est premier
38-19 34-17 26-13 25-5 22-11 21-7 21-3    Multiple de 5 suivant, bien placé (20+5 -> 25-5)
38-19 34-17 26-13 25-5 24-3 22-11 21-7    ...

Une fois qu'on a supprimé tous les pairs, on prend la première valeur non barrée : 3 et on regarde ses multiples.
2*3 = 6 ! On a sauté au-dessus de 5 (impair), donc 5 est premier. On regarde les multiples de 5. 2*5=10.
Entre 5 et 9 (prochain multiple de 3), on a 7, qui est donc premier.
On reprend 3, puisqu'on est arrivé à 9, pour calculer 9+3=12. Entre 10 (dernier multiple de 5 trouvé) et 12, on a un impair : 11. Donc il est premier. etc.

En ligne 52, 'c' contient le premier en cours de traitement, 'b' son dernier multiple calculé et 'a' le multiple suivant.

En ligne 56, on regarde si ce nouveau multiple est plus grand que le dernier multiple calculé du nombre premier suivant dans la liste ! (facile !)

Si oui, on insère la paire (multiple premier) = (a c) à sa place dans la liste (décalage paire par paire, qui aurait pu être un décalage de bloc, mais pas dans un contexte de machine à pile).

En ligne 70, on trouve le nombre impair suivant 'b' : ex : si 'b'=10, alors (('b'+1) | 1) = (11 | 1) = 11; si 'b'=19, alors (('b'+1) | 1) = (20 | 1) = 21.

En ligne 72, 'b' est le dernier multiple calculé du nombre premier qu'on traitera ensuite, et 'c' est le multiple du dernier de la liste (a priori la plus grande valeur trouvée jusque là).

La boucle en ligne 75, énumère les nombres impairs entre le nombre impair suivant calculé précédemment et 'b', les ajoute à la liste (avec leur premier multiple : 2x) et affiche les nombres trouvés.
A priori la boucle doit ête inutile car il me semble qu'on ne peut trouver qu'un nombre à la fois, mais dans le doute ...

Voilà, vous savez tout !
ps. mon avatar, s'il veut bien s'afficher) est la version Piet de ce programme (cf http://www.dangermouse.net/esoteric/piet.html)

Pour nightlord666.
D'accord avec toi pour les include, mais comme le compilateur ne fait pas la différence, je mets une fois l'un, une fois l'autre !
En ce qui concerne la variable en majuscules, au départ c'était une constante, mais j'ai décidé d'en faire un paramètre (grosse flemme, quoi !).
Pas de test des codes retours : en fait au départ j'ai écrit ce programme pour le faire marcher en BrainFuck et en Piet (en gros, sur une machine de Turing), donc mettre en place des tests ce n'était pas vraiment facile, et ensuite je voulais le soumttre à un OCC, donc plus c'est court et abscons et mieux c'est. OK, pour ce post, j'aurais dû faire mieux ! D'ailleurs, tu n'as pas remarqué que je ne libère pas non plus la mémoire allouée ;)
Paramètre en dessous de 6 : ça fonctionne ! Mais en dessous de 4, on affiche toujours 4 valeurs au minimum. Par contre ça plante pour 1 (rappel : aucun test !).

pour Kirua.
Je ne "barre" aucune valeur, c'est ce qui fait la spécificité de cet algo.

Dès que j'ai un peu de temps, je mets un petit texte explicatif.

Merci pour vos commentaires.