1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <ctype.h>
5. #define MAXLGHT 50 //taille autorisée pour la saisie
7. int getStr(char []); //enregistre la saisie jusqu'à \n en ignorant les espaces, renvoie le nombre de caractères (sauf \n)
8. double calc(char [], int); //traite la saisie, repère les erreurs de syntaxe, et gère l'exécution du calcul par niveaux avant de renvoyer le résultat final
9. int decp(int); //renvoie 10 puissance argument, utilisée pour lire les nombres dans la saisie
10. double lvlCalc(double*, double*, char*, int*); //renvoie le résultat de calcul sur un niveau de parenthèses en gérant la priorité des opérateurs et d'éventuelles divisions par zéro
12. int main()
13. {
14.     int i, max = MAXLGHT;
15.     char read[MAXLGHT]; //stocke la saisie brute
16.     printf("Calculatrice en notation scientifique.\nLimite de caracteres : %d\n\n",max);
18.     for(;;)
19.     {
20.         i = getStr(read);
22.         if(i <= MAXLGHT)
23.             printf("%f\n\n",calc(read, i)); //appelle calc si la saisie ne dépasse pas la taille autorisée
24.         else
25.             printf("depassement : %d caracteres max\n", MAXLGHT);
26.     }
27.     return 0;
28. }
30. int getStr(char c[])
31. {
32.     char temp;
33.     int i = 0;
35.     for(;;)
36.         if((temp = getchar()) != '\n')
37.             c[(isspace(temp))?i:i++] = temp;
38.         else
39.             break;
41.     c[i] = '\0';
42.     return i;
43. }
45. int decp(int a)
46. {
47.     int i, p = 1;
49.     for (i = 0; i < a; i++)
50.         p = p * 10;
52.     return p;
53. }
55. double calc(char str[], int cSize)
56. {
57.     double result = 0.0; //stocke résultat final
58.     double curNb = 0.0; //variable temp pour lecture des nombres
59.     double calcFormat[cSize]; //stocke la saisie sous sa forme calculable, opérateurs et opérandes uniquement
60.     int lvls[cSize]; //stocke les niveaux de parenthèses de chaque opérateur ou opérande
61.     char type[cSize]; //détermine la nature de chaque élément de calcFormat : 'o' pour opérateur, 'd' pour nombre, 'v' pour à ignorer (déjà pris en compte dans un niveau supérieur)
62.     int zdiv = 0; //division par zéro
63.     int decInd = 0; //variable temp pour calcul des nombres à partie décimale
64.     int curLvl = 1; //niveau de parenthèses en cours de traitement
65.     int topLvl = 1; //plus grand niveau de parenthèses (on commence par là)
66.     int error = 0; //erreur(s)
67.     int i, j, k = 0; //indices
69.     for(i = 0; i < cSize && error == 0; i++) //construit calcFormat[], lvls[], type[], repère les erreurs de syntaxe
70.     {
71.         if(isdigit(str[i])) //calcule les nombres avec leur partie décimale éventuelle
72.         {
73.             if(i > 0 && str[i-1] == ')') //erreur si un nombre suit directement une parenthèse
74.                 ++error;
76.             for(j = 0; isdigit(str[i]) && error == 0; i++, j++)
77.             {
78.                 curNb = 10 * curNb + (str[i] - '0');
80.                 if(str[i+1] == '.') //on rencontre un point de décimal
81.                 {
82.                     if(decInd == 0) //vérifie que c'est le premier rencontré pour le nombre courant
83.                     {
84.                         i++;
85.                         decInd = j + 1; //mémorise sa place dans le nombre courant
86.                     }
87.                     else
88.                         ++error;
89.                 }
90.             }
92.             calcFormat[k] = (decInd > 0 && decInd != j) ? curNb / (decp(j - decInd)) : curNb; //si on a une partie décimale et qu'elle n'est pas vide (au moins un chiffre après le point), diviser le nombre par 10 puissance le nombre de décimales
93.             type[k] = 'd'; //l'élément est un nombre
94.             lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
95.             decInd = 0;
96.             curNb = 0.0;
97.             i--;
98.         }
100.         else if(str[i] == '(') //saute les parenthèses ouvrantes et incrémente le niveau en conséquence, repère d'éventuelles erreurs de syntaxe
101.         {
102.             if(i == 0 || (i > 0 && i < cSize - 1 && str[i-1] != ')' && !isdigit(str[i-1])))
103.             {
104.                 ++curLvl;
105.                 if(curLvl > topLvl) //si le niveau est plus grand que le plus grand rencontré, mettre à jour ce dernier
106.                     topLvl = curLvl;
107.             }
108.             else
109.                 ++error;
110.         }
112.         else if(str[i] == ')') //saute les parenthèses fermantes et décrémente le niveau en conséquence, repère d'éventuelles erreurs de syntaxe
113.         {
114.             if(i > 0 && str[i-1] != '(' && str[i-1] != '+' && str[i-1] != '-' && str[i-1] != '*' && str[i-1] != '/')
115.                 --curLvl;
116.             else
117.                 ++error;
118.         }
120.         else if(str[i] == '+' || str[i] == '*' || str[i] == '/') //les opérateurs +, * et / ont les mêmes règles de syntaxe
121.         {
122.             if(i > 0 && i < cSize - 1 && (isdigit(str[i-1]) || str[i-1] == ')'))
123.             {
124.                 calcFormat[k] = str[i];
125.                 type[k] = 'o'; //l'élément est un opérateur
126.                 lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
127.             }
128.             else
129.                 ++error;
130.         }
132.         else if(str[i] == '-') //règle de syntaxe pour l'opérateur -
133.         {
134.             if((i > 0 && i < cSize - 1 && (isdigit(str[i-1]) || str[i-1] == ')' || str[i-1] == '(')) || (i == 0 && cSize > 1))
135.             {
136.                 calcFormat[k] = str[i];
137.                 type[k] = 'o'; //l'élément est un opérateur
138.                 lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
139.             }
140.             else
141.                 ++error;
142.         }
144.         else //ni un nombre, ni une parenthèse, ni un opérateur
145.             ++error;
146.     }
148.     calcFormat[k] = '\0';
149.     lvls[k] = '\0';
150.     type[k] = '\0';
152.     if(curLvl != 1) //si il n'y a pas autant de '(' que de ')'
153.         ++error;
155.     if(error == 0) //si pas d'erreur
156.     {
157.         int left, right; //champ d'action de lclCalc dans calcFormat[]
159.         for(; topLvl >= 1; topLvl--) //examine chaque niveau du plus élevé à 1
160.         {
161.             for(i = 0; i < k; i++) //repère les parties correspondant au niveau topLvl
162.             {
163.                 for(; lvls[i] < topLvl; ++i) //saute les niveaux inférieurs
164.                     ;
166.                 left = i;
168.                 for(; lvls[i] >= topLvl; ++i)
169.                     ;
171.                 right = i-1;
173.                 result = lvlCalc(&calcFormat[left], &calcFormat[right], &type[left], &zdiv); //calcule le niveau en cours
174.                 calcFormat[left] = result; //stocke le résultat à gauche
175.                 --lvls[left]; //décrémente le niveau de l'élément contenant le résultat afin qu'il soit pris en compte par le niveau suivant
177.                 if(zdiv) //lvlCalc a indiqué une division par zéro
178.                 {
179.                     printf("division par zero !\n" );
180.                     return 0.0;
181.                 }
182.             }
183.         }
184.     }
186.     else
187.         printf("erreur de syntaxe\n" );
188.     return result;
189. }
191. double lvlCalc(double* start, double* end, char* opCheck, int* zdiv)
192. {
193.     double result = 0.0; //résultat pour la plage donnée à calculer
194.     double* stemp = start; //compteur pour la 1ère boucle, pointe sur les éléments de calcFormat[]
195.     double* first = start; //garde en mémoire l'élément de gauche
196.     char* opStart = opCheck; //compteur pour la 1ère boucle, pointe sur les éléments de type[]
197.     int leftSp = 0, rightSp = 0; //variables pour le saut les éléments de type 'v' situés autour des opérateurs * et /
199.     for(; stemp <= end; stemp++, opStart++) //première boucle sur l'étendue indiquée
200.     {
201.         if(*stemp == '*' && *opStart == 'o') //rencontre un opérateur *
202.         {
203.             for(; *(opStart-1-leftSp) == 'v'; leftSp++) //saute les éléments de type 'v' à gauche
204.                 ;
205.             for(; *(opStart+1+rightSp) == 'v'; rightSp++) //saute les éléments de type 'v' à droite
206.                 ;
208.             *(stemp-1-leftSp) = *(stemp-1-leftSp) * *(stemp+1+rightSp); //stocke le résultat dans l'opérande de gauche
209.             *opStart = 'v'; //indique l'opérateur comme déjà utilisé
210.             *(opStart+1+rightSp) = 'v'; //indique l'opérande de droite comme déjà utilisé
211.             opStart += 1+rightSp; //saute la plage qu'on vient de calculer
212.             stemp += 1+rightSp; //pareil avec l'autre indice
213.         }
215.         else if(*stemp == '/' && *opStart == 'o') //rencontre un opérateur / (même méthode que pour *)
216.         {
217.             for(; *(opStart-1-leftSp) == 'v'; leftSp++)
218.                 ;
219.             for(; *(opStart+1+rightSp) == 'v'; rightSp++)
220.                 ;
222.             if(*(stemp+1+rightSp) != 0) //opérande de droite != 0
223.                 *(stemp-1-leftSp) = *(stemp-1-leftSp) / *(stemp+1+rightSp);
225.             else //division par zéro
226.                 {
227.                     *zdiv = 1;
228.                     return 0.0;
229.                 }
231.             *opStart = 'v';
232.             *(opStart+1+rightSp) = 'v';
233.             opStart += 1+rightSp;
234.             stemp += 1+rightSp;
235.         }
236.     } //les opérations prioritaires ont été effectuées, reste que des additions et soustractions dans l'étendue indiquée
238.     if(*opCheck == 'd') //additionne au résultat l'élément tout à gauche si c'est un nombre (ça pourrait être un opérateur -)
239.         result += *start;
241.     for(; start <= end; start++, opCheck++) //seconde boucle sur l'étendue indiquée
242.     {
243.         if(*start == '+' && *opCheck == 'o') //rencontre un opérateur +
244.         {
245.             for(; *(opCheck+1) == 'v'; opCheck++, start++) //saute les éléments déjà utilisés à droite jusqu'à rencontrer un opérande
246.                 ;
248.             result += *(start+1); //additionne l'opérande au résultat
249.             *opCheck = 'v'; //l'opérateur est marqué comme déjà utilisé
250.             *(opCheck+1) = 'v'; //l'opérande est marqué comme déjà utilisé
251.         }
253.         if(*start == '-' && *opCheck == 'o') //même principe pour -
254.         {
255.             for(; *(opCheck+1) == 'v'; opCheck++, start++)
256.                 ;
258.             result -= *(start+1);
259.             *opCheck = (start > first)?'v':'d'; //comme l'opérateur - peut se trouver en premier élément, on veille à le marquer comme nombre pour que le résultat stocké dedans ne soit pas ignoré par les niveaux suivants
260.             *(opCheck+1) = 'v';
261.         }
262.     }
263.     return result;
264. }

int decp(int a)
{
    int i, p;
 
    if (a == 0) return 0;
    for (i=0, p=1; i < a; i++)
        p = p * 10;
    return p;
}

1. int decp(int a)
2. {
3.     int i, p = 1;
4.     for (i = 0; i < a; i++)
5.         p = p * 10;
6.     return p;
7. }

1. if(isdigit(str[i])) //calcule les nombres avec leur partie décimale éventuelle
2.         {
3.             if(i > 0 && str[i-1] == ')') //erreur si un nombre suit directement une parenthèse
4.                 ++error;
5.             for(j = 0; isdigit(str[i]) && error == 0; i++, j++)
6.             {
7.                 curNb = 10 * curNb + (str[i] - '0');
8.                 if(str[i+1] == '.') //on rencontre un point de décimal
9.                 {
10.                     if(decInd == 0) //vérifie que c'est le premier rencontré pour le nombre courant
11.                     {
12.                         i++;
13.                         decInd = j + 1; //mémorise sa place dans le nombre courant
14.                     }
15.                     else
16.                         ++error;
17.                 }
18.             }
19.             calcFormat[k] = (decInd > 0 && decInd != j) ? curNb / (decp(j - decInd)) : curNb; //si on a une partie décimale et qu'elle n'est pas vide (au moins un chiffre après le point), diviser le nombre par 10 puissance le nombre de décimales
20.             type[k] = 'd'; //l'élément est un nombre
21.             lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
22.             decInd = 0;
23.             curNb = 0.0;
24.             i--;
25.         }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <ctype.h>
5. #define MAXLGHT 50 //taille autorisée pour la saisie
7. int getStr(char []); //enregistre la saisie jusqu'à \n en ignorant les espaces, renvoie le nombre de caractères (sauf \n)
8. double calc(char [], int); //traite la saisie, repère les erreurs de syntaxe, et gère l'exécution du calcul par niveaux avant de renvoyer le résultat final
9. int decp(int); //renvoie 10 puissance argument, utilisée pour lire les nombres dans la saisie
10. double lvlCalc(double*, double*, char*, int*); //renvoie le résultat de calcul sur un niveau de parenthèses en gérant la priorité des opérateurs et d'éventuelles divisions par zéro
12. int main()
13. {
14.     int i;
15.     char read[MAXLGHT]; //stocke la saisie brute
16.     printf("Calculatrice en notation scientifique.\nLimite de caracteres : %d\n\n", MAXLGHT);
18.     for(;;)
19.     {
20.         i = getStr(read);
22.         if(i <= MAXLGHT)
23.             printf("%f\n\n",calc(read, i)); //appelle calc si la saisie ne dépasse pas la taille autorisée
24.         else
25.             printf("depassement : %d caracteres max\n\n", MAXLGHT);
26.     }
27.     return 0;
28. }
30. int getStr(char c[])
31. {
32.     char temp;
33.     int i = 0;
35.     for(;;)
36.         if((temp = getchar()) != '\n')
37.             if(i < MAXLGHT)
38.                 c[(isspace(temp)) ? i : i++] = temp;
39.             else
40.                 i++;
41.         else
42.             break;
44.     c[i] = '\0';
45.     return i;
46. }
48. int decp(int a)
49. {
50.     int i, p = 1;
52.     for (i = 0; i < a; i++)
53.         p = p * 10;
55.     return p;
56. }
58. double calc(char str[], int cSize)
59. {
60.     double result = 0.0; //stocke résultat final
61.     double curNb = 0.0; //variable temp pour lecture des nombres
62.     double calcFormat[cSize]; //stocke la saisie sous sa forme calculable, opérateurs et opérandes uniquement
63.     int lvls[cSize]; //stocke les niveaux de parenthèses de chaque opérateur ou opérande
64.     char type[cSize]; //détermine la nature de chaque élément de calcFormat : 'o' pour opérateur, 'd' pour nombre, 'v' pour à ignorer (déjà pris en compte dans un niveau supérieur)
65.     int zdiv = 0; //division par zéro
66.     int decInd = 0; //variable temp pour calcul des nombres à partie décimale
67.     int curLvl = 1; //niveau de parenthèses en cours de traitement
68.     int topLvl = 1; //plus grand niveau de parenthèses (on commence par là)
69.     int error = 0; //erreur(s)
70.     int i, j, k = 0; //indices
72.     for(i = 0; i < cSize && error == 0; i++) //construit calcFormat[], lvls[], type[], repère les erreurs de syntaxe
73.     {
74.         if(isdigit(str[i])) //calcule les nombres avec leur partie décimale éventuelle
75.         {
76.             if(i > 0 && str[i-1] == ')') //erreur si un nombre suit directement une parenthèse
77.                 ++error;
79.             for(j = 0; isdigit(str[i]) && error == 0; i++, j++)
80.             {
81.                 curNb = 10 * curNb + (str[i] - '0');
83.                 if(str[i+1] == '.') //on rencontre un point de décimal
84.                 {
85.                     if(decInd == 0) //vérifie que c'est le premier rencontré pour le nombre courant
86.                     {
87.                         i++;
88.                         decInd = j + 1; //mémorise sa place dans le nombre courant
89.                     }
90.                     else
91.                         ++error;
92.                 }
93.             }
95.             calcFormat[k] = (decInd > 0 && decInd != j) ? curNb / (decp(j - decInd)) : curNb; //si on a une partie décimale et qu'elle n'est pas vide (au moins un chiffre après le point), diviser le nombre par 10 puissance le nombre de décimales
96.             type[k] = 'd'; //l'élément est un nombre
97.             lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
98.             decInd = 0;
99.             curNb = 0.0;
100.             i--;
101.         }
103.         else if(str[i] == '(') //saute les parenthèses ouvrantes et incrémente le niveau en conséquence, repère d'éventuelles erreurs de syntaxe
104.         {
105.             if(i == 0 || (i > 0 && i < cSize - 1 && str[i-1] != ')' && !isdigit(str[i-1])))
106.             {
107.                 ++curLvl;
108.                 if(curLvl > topLvl) //si le niveau est plus grand que le plus grand rencontré, mettre à jour ce dernier
109.                     topLvl = curLvl;
110.             }
111.             else
112.                 ++error;
113.         }
115.         else if(str[i] == ')') //saute les parenthèses fermantes et décrémente le niveau en conséquence, repère d'éventuelles erreurs de syntaxe
116.         {
117.             if(i > 0 && str[i-1] != '(' && str[i-1] != '+' && str[i-1] != '-' && str[i-1] != '*' && str[i-1] != '/')
118.                 --curLvl;
119.             else
120.                 ++error;
121.         }
123.         else if(str[i] == '+' || str[i] == '*' || str[i] == '/') //les opérateurs +, * et / ont les mêmes règles de syntaxe
124.         {
125.             if(i > 0 && i < cSize - 1 && (isdigit(str[i-1]) || str[i-1] == ')'))
126.             {
127.                 calcFormat[k] = str[i];
128.                 type[k] = 'o'; //l'élément est un opérateur
129.                 lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
130.             }
131.             else
132.                 ++error;
133.         }
135.         else if(str[i] == '-') //règle de syntaxe pour l'opérateur -
136.         {
137.             if((i > 0 && i < cSize - 1 && (isdigit(str[i-1]) || str[i-1] == ')' || str[i-1] == '(')) || (i == 0 && cSize > 1))
138.             {
139.                 calcFormat[k] = str[i];
140.                 type[k] = 'o'; //l'élément est un opérateur
141.                 lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
142.             }
143.             else
144.                 ++error;
145.         }
147.         else //ni un nombre, ni une parenthèse, ni un opérateur
148.             ++error;
149.     }
151.     calcFormat[k] = '\0';
152.     lvls[k] = '\0';
153.     type[k] = '\0';
155.     if(curLvl != 1) //si il n'y a pas autant de '(' que de ')'
156.         ++error;
158.     if(error == 0) //si pas d'erreur
159.     {
160.         int left, right; //champ d'action de lclCalc dans calcFormat[]
162.         for(; topLvl >= 1; topLvl--) //examine chaque niveau du plus élevé à 1
163.         {
164.             //printf("\nlevel %d\n",topLvl);
166.             for(i = 0; i < k; i++) //repère les parties correspondant au niveau topLvl
167.             {
168.                 for(; lvls[i] < topLvl; i++) //saute les niveaux inférieurs
169.                     ;
171.                 left = i;
173.                 for(; lvls[i] >= topLvl; i++) //détermine la plage à prendre en compte, qui sera encadrée par left et right
174.                     ;
176.                 right = i-1;
178.                 //printf("left = %d  right = %d\n",left,right);
180.                 result = lvlCalc(&calcFormat[left], &calcFormat[right], &type[left], &zdiv); //calcule le niveau en cours
181.                 calcFormat[left] = result; //stocke le résultat à gauche
182.                 --lvls[left]; //décrémente le niveau de l'élément contenant le résultat afin qu'il soit pris en compte par le niveau suivant
184.                 if(zdiv) //lvlCalc a indiqué une division par zéro
185.                 {
186.                     printf("division par zero !\n" );
187.                     return 0.0;
188.                 }
189.             }
191.             //for(i=0;i<k;i++)
192.                 //printf("val = %f  lvl = %d  type = %c\n",calcFormat[i],lvls[i],type[i]);
193.         }
194.     }
196.     else
197.         printf("erreur de syntaxe\n" );
198.     return result;
199. }
201. double lvlCalc(double* start, double* end, char* opCheck, int* zdiv)
202. {
203.     double result = 0.0; //résultat pour la plage donnée à calculer
204.     double* stemp = start; //compteur pour la 1ère boucle, pointe sur les éléments de calcFormat[]
205.     double* first = start; //garde en mémoire l'élément de gauche
206.     char* opStart = opCheck; //compteur pour la 1ère boucle, pointe sur les éléments de type[]
207.     int leftSp, rightSp; //variables pour le saut les éléments de type 'v' situés autour des opérateurs * et /
209.     for(; stemp <= end; stemp++, opStart++) //première boucle sur l'étendue indiquée
210.     {
211.         if(*stemp == '*' && *opStart == 'o') //rencontre un opérateur *
212.         {
213.             for(leftSp = 0; *(opStart-1-leftSp) == 'v'; leftSp++) //saute les éléments de type 'v' à gauche
214.                 ;
215.             for(rightSp = 0; *(opStart+1+rightSp) == 'v'; rightSp++) //saute les éléments de type 'v' à droite
216.                 ;
218.             *(stemp-1-leftSp) = *(stemp-1-leftSp) * *(stemp+1+rightSp); //stocke le résultat dans l'opérande de gauche
219.             *opStart = 'v'; //indique l'opérateur comme déjà utilisé
220.             *(opStart+1+rightSp) = 'v'; //indique l'opérande de droite comme déjà utilisé
221.             opStart += 1+rightSp; //saute la plage qu'on vient de calculer
222.             stemp += 1+rightSp; //pareil avec l'autre indice
223.         }
225.         else if(*stemp == '/' && *opStart == 'o') //rencontre un opérateur / (même méthode que pour *)
226.         {
227.             for(leftSp = 0; *(opStart-1-leftSp) == 'v'; leftSp++)
228.                 ;
229.             for(rightSp = 0; *(opStart+1+rightSp) == 'v'; rightSp++)
230.                 ;
232.             if(*(stemp+1+rightSp) != 0) //opérande de droite != 0
233.                 *(stemp-1-leftSp) = *(stemp-1-leftSp) / *(stemp+1+rightSp);
235.             else //division par zéro
236.                 {
237.                     *zdiv = 1;
238.                     return 0.0;
239.                 }
241.             *opStart = 'v';
242.             *(opStart+1+rightSp) = 'v';
243.             opStart += 1+rightSp;
244.             stemp += 1+rightSp;
245.         }
246.     } //les opérations prioritaires ont été effectuées, reste que des additions et soustractions dans l'étendue indiquée
248.     if(*opCheck == 'd') //additionne au résultat l'élément tout à gauche si c'est un nombre (ça pourrait être un opérateur -)
249.         result += *start;
251.     for(; start <= end; start++, opCheck++) //seconde boucle sur l'étendue indiquée
252.     {
253.         if(*start == '+' && *opCheck == 'o') //rencontre un opérateur +
254.         {
255.             for(; *(opCheck+1) == 'v'; opCheck++, start++) //saute les éléments déjà utilisés à droite jusqu'à rencontrer un opérande
256.                 ;
258.             result += *(start+1); //additionne l'opérande au résultat
259.             *opCheck = 'v'; //l'opérateur est marqué comme déjà utilisé
260.             *(opCheck+1) = 'v'; //l'opérande est marqué comme déjà utilisé
261.         }
263.         if(*start == '-' && *opCheck == 'o') //même principe pour -
264.         {
265.             for(; *(opCheck+1) == 'v'; opCheck++, start++)
266.                 ;
268.             result -= *(start+1);
269.             *opCheck = (start > first)?'v':'d'; //comme l'opérateur - peut se trouver en premier élément, on veille à le marquer comme nombre pour que le résultat stocké dedans ne soit pas ignoré par les niveaux suivants
270.             *(opCheck+1) = 'v';
271.         }
272.     }
273.     return result;
274. }

1. for(i = 0; i < k; i++) //repère les parties correspondant au niveau topLvl
2.             {
3.                 for(; lvls[i] < topLvl && i < k; i++) //saute les niveaux inférieurs
4.                     ;
5.                 if(i == k)
6.                     break;
7.                 left = i;
8.                 for(; lvls[i] >= topLvl; i++) //détermine la plage à prendre en compte, qui sera encadrée par left et right
9.                     ;
10.                 right = i-1;
11.                 result = lvlCalc(&calcFormat[left], &calcFormat[right], &type[left], &zdiv); //calcule le niveau en cours
12.                 calcFormat[left] = result; //stocke le résultat à gauche
13.                 --lvls[left]; //décrémente le niveau de l'élément contenant le résultat afin qu'il soit pris en compte par le niveau suivant
14.                 if(zdiv) //lvlCalc a indiqué une division par zéro
15.                 {
16.                     printf("division par zero !\n" );
17.                     return 0.0;
18.                 }
19.             }

1. int getStr(char c[])
2. {
3.     char temp;
4.     int i = 0;
5.     for(;;)
6.         if((temp = getchar()) != '\n')
7.             if(i < MAXLGHT)
8.                 c[(isspace(temp)) ? i : i++] = temp;
9.             else
10.                 i++;
11.         else
12.             break;
13.     c[i] = '\0';
14.     return i;
15. }

1. int getStr(char (*c)[MAXLGHT])
2. {
3.     char temp;
4.     int i = 0;
6.     for(;;)
7.         if((temp = getchar()) != '\n')
8.             if(i < sizeof (*c))
9.                 (*c)[(isspace(temp)) ? i : i++] = temp;
10.             else
11.                 i++;
12.         else
13.             break;
14.     (*c)[i] = '\0';
15.     return i;
16. }

1. int getStr(char c[], int maxlen)
2. {
3.     char temp;
4.     int i = 0;
5.     for(;;)
6.         if((temp = getchar()) != '\n')
7.             if(i < maxlen)
8.                 c[(isspace(temp)) ? i : i++] = temp;
9.             else
10.                 i++;
11.         else
12.             break;
13.     c[i] = '\0';
14.     return i;   
15. }

1. int read_input(char *s, int n) {
2.     int last = 0;
4.     if (n > 0) {
5.         char *p;
6.         if ((p = fgets(s, n, stdin))) {
7.             last = strlen(s) - 1;
8.             if (s[last] == '\n') {
9.                 s[last] = '\0';
10.             }
11.             else {
12.                 scanf("%*[^\n]" );
13.                 getchar();
14.                 last = n - 1;
15.             }
16.         }
17.     }
18.     return last;
19. }

1. int read_input(char *s, int n) {
2.     int last = 0;
4.     if (n > 0) {
5.         char *p;
6.         if ((p = fgets(s, n, stdin))) {
7.             last = strlen(s) - 1;
8.             if (s[last] == '\n') {
9.                 s[last] = '\0';
10.             }
11.             else {
12.                 int m = 0;
13.                 scanf("%*[^\n]%n", &m);
14.                 getchar();
15.                 last = n + m - 1;
16.             }
17.         }
18.     }
19.     return last;
20. }