![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_m2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_m2.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.56 ! bertrand 3: RPL/2 (R) version 4.1.25
! 4: Copyright (C) 1989-2016 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.12 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'max'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_max(struct_processus *s_etat_processus)
40: {
41: real8 max_reel;
42: real8 module;
43:
44: integer8 max_entier;
45:
46: struct_liste_chainee *l_element_courant;
47: struct_liste_chainee *l_element_precedent;
48:
49: struct_objet *s_copie_argument_1;
50: struct_objet *s_copie_argument_2;
51: struct_objet *s_objet_argument_1;
52: struct_objet *s_objet_argument_2;
53: struct_objet *s_objet_position;
54: struct_objet *s_objet_resultat;
55:
1.42 bertrand 56: integer8 i;
57: integer8 j;
58: integer8 nombre_elements;
59: integer8 position_max_i;
60: integer8 position_max_j;
1.1 bertrand 61:
62: (*s_etat_processus).erreur_execution = d_ex;
63:
64: if ((*s_etat_processus).affichage_arguments == 'Y')
65: {
66: printf("\n MAX ");
67:
68: if ((*s_etat_processus).langue == 'F')
69: {
70: printf("(maximum)\n\n");
71: }
72: else
73: {
74: printf("(maximum)\n\n");
75: }
76:
77: printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
78: printf("-> 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
79: printf(" 1: %s\n\n", d_LST);
80:
81: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
82: printf("-> 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
83: printf(" 1: %s\n\n", d_LST);
84:
1.4 bertrand 85: printf(" 2: %s, %s\n", d_INT, d_REL);
86: printf(" 1: %s, %s\n", d_INT, d_REL);
87: printf("-> 1: %s, %s\n\n", d_INT, d_REL);
88:
89: printf(" 2: %s, %s, %s, %s, %s\n",
90: d_INT, d_REL, d_NOM, d_ALG, d_RPN);
91: printf(" 1: %s, %s, %s, %s, %s\n",
92: d_INT, d_REL, d_NOM, d_ALG, d_RPN);
1.1 bertrand 93: printf("-> 1: %s, %s\n", d_ALG, d_RPN);
94:
95: return;
96: }
97: else if ((*s_etat_processus).test_instruction == 'Y')
98: {
99: (*s_etat_processus).nombre_arguments = 2;
100: return;
101: }
102:
103: /*
104: --------------------------------------------------------------------------------
105: MAX portant sur un tableau (un seul argument)
106: --------------------------------------------------------------------------------
107: */
108:
109: if (((*(*(*s_etat_processus).l_base_pile).donnee).type == VIN)
110: || ((*(*(*s_etat_processus).l_base_pile).donnee).type ==
111: VRL) || ((*(*(*s_etat_processus).l_base_pile)
112: .donnee).type == VCX))
113: {
114: if (test_cfsf(s_etat_processus, 31) == d_vrai)
115: {
116: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
117: {
118: return;
119: }
120: }
121:
122: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
123: &s_objet_argument_1) == d_erreur)
124: {
125: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
126: return;
127: }
128:
129: if ((s_objet_position = allocation(s_etat_processus, LST)) == NULL)
130: {
131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
132: return;
133: }
134:
135: /*
136: * Vecteur d'entiers
137: */
138:
139: if ((*s_objet_argument_1).type == VIN)
140: {
141: max_entier = ((integer8 *) (*((struct_vecteur *)
142: (*s_objet_argument_1).objet)).tableau)[0];
143: position_max_i = 0;
144:
145: for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument_1).objet))
146: .taille; i++)
147: {
148: if (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
149: .objet)).tableau)[i] > max_entier)
150: {
151: max_entier = ((integer8 *) (*((struct_vecteur *)
152: (*s_objet_argument_1).objet)).tableau)[i];
153: position_max_i = i;
154: }
155: }
156:
157: if ((s_objet_resultat = allocation(s_etat_processus, INT))
158: == NULL)
159: {
160: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
161: return;
162: }
163:
164: (*((integer8 *) (*s_objet_resultat).objet)) = max_entier;
165:
166: if (((*s_objet_position).objet =
167: allocation_maillon(s_etat_processus)) == NULL)
168: {
169: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
170: return;
171: }
172:
173: l_element_courant = (*s_objet_position).objet;
174: (*l_element_courant).suivant = NULL;
175:
176: if (((*l_element_courant).donnee = allocation(s_etat_processus,
177: INT)) == NULL)
178: {
179: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
180: return;
181: }
182:
183: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
184: position_max_i + 1;
185: }
186:
187: /*
188: * Vecteur de réels
189: */
190:
191: else if ((*s_objet_argument_1).type == VRL)
192: {
193: max_reel = ((real8 *) (*((struct_vecteur *)
194: (*s_objet_argument_1).objet)).tableau)[0];
195: position_max_i = 0;
196:
197: for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument_1).objet))
198: .taille; i++)
199: {
200: if (((real8 *) (*((struct_vecteur *) (*s_objet_argument_1)
201: .objet)).tableau)[i] > max_reel)
202: {
203: max_reel = ((real8 *) (*((struct_vecteur *)
204: (*s_objet_argument_1).objet)).tableau)[i];
205: position_max_i = i;
206: }
207: }
208:
209: if ((s_objet_resultat = allocation(s_etat_processus, REL))
210: == NULL)
211: {
212: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
213: return;
214: }
215:
216: (*((real8 *) (*s_objet_resultat).objet)) = max_reel;
217:
218: if (((*s_objet_position).objet =
219: allocation_maillon(s_etat_processus)) == NULL)
220: {
221: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
222: return;
223: }
224:
225: l_element_courant = (*s_objet_position).objet;
226: (*l_element_courant).suivant = NULL;
227:
228: if (((*l_element_courant).donnee = allocation(s_etat_processus,
229: INT)) == NULL)
230: {
231: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
232: return;
233: }
234:
235: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
236: position_max_i + 1;
237: }
238:
239: /*
240: * Vecteur de complexes
241: */
242:
243: else
244: {
245: f77absc_(&(((struct_complexe16 *) (*((struct_vecteur *)
246: (*s_objet_argument_1).objet)).tableau)[0]), &max_reel);
247:
248: position_max_i = 0;
249:
250: for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument_1).objet))
251: .taille; i++)
252: {
253: f77absc_(&(((struct_complexe16 *) (*((struct_vecteur *)
254: (*s_objet_argument_1).objet)).tableau)[i]), &module);
255:
256: if (module > max_reel)
257: {
258: max_reel = module;
259: position_max_i = i;
260: }
261: }
262:
263: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
264: == NULL)
265: {
266: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
267: return;
268: }
269:
270: (*((struct_complexe16 *) (*s_objet_resultat).objet))
271: .partie_reelle = ((struct_complexe16 *)
272: (*((struct_vecteur *) (*s_objet_argument_1).objet))
273: .tableau)[position_max_i].partie_reelle;
274: (*((struct_complexe16 *) (*s_objet_resultat).objet))
275: .partie_imaginaire = ((struct_complexe16 *)
276: (*((struct_vecteur *) (*s_objet_argument_1).objet))
277: .tableau)[position_max_i].partie_imaginaire;
278:
279: if (((*s_objet_position).objet =
280: allocation_maillon(s_etat_processus)) == NULL)
281: {
282: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
283: return;
284: }
285:
286: l_element_courant = (*s_objet_position).objet;
287: (*l_element_courant).suivant = NULL;
288:
289: if (((*l_element_courant).donnee = allocation(s_etat_processus,
290: INT)) == NULL)
291: {
292: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
293: return;
294: }
295:
296: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
297: position_max_i + 1;
298: }
299:
300: liberation(s_etat_processus, s_objet_argument_1);
301:
302: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
303: s_objet_resultat) == d_erreur)
304: {
305: return;
306: }
307:
308: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
309: s_objet_position) == d_erreur)
310: {
311: return;
312: }
313: }
314: else if (((*(*(*s_etat_processus).l_base_pile).donnee).type ==
315: MIN) || ((*(*(*s_etat_processus).l_base_pile)
316: .donnee).type == MRL) || ((*(*(*s_etat_processus)
317: .l_base_pile).donnee).type == MCX))
318: {
319: if (test_cfsf(s_etat_processus, 31) == d_vrai)
320: {
321: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
322: {
323: return;
324: }
325: }
326:
327: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
328: &s_objet_argument_1) == d_erreur)
329: {
330: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
331: return;
332: }
333:
334: if ((s_objet_position = allocation(s_etat_processus, LST)) == NULL)
335: {
336: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
337: return;
338: }
339:
340: /*
341: * Matrice d'entiers
342: */
343:
344: if ((*s_objet_argument_1).type == MIN)
345: {
346: max_entier = ((integer8 **) (*((struct_matrice *)
347: (*s_objet_argument_1).objet)).tableau)[0][0];
348: position_max_i = 0;
349: position_max_j = 0;
350:
351: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
352: .nombre_lignes; i++)
353: {
354: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
355: .objet)).nombre_colonnes; j++)
356: {
357: if (((integer8 **) (*((struct_matrice *)
358: (*s_objet_argument_1).objet)).tableau)[i][j] >
359: max_entier)
360: {
361: max_entier = ((integer8 **) (*((struct_matrice *)
362: (*s_objet_argument_1).objet)).tableau)[i][j];
363: position_max_i = i;
364: position_max_j = j;
365: }
366: }
367: }
368:
369: if ((s_objet_resultat = allocation(s_etat_processus, INT))
370: == NULL)
371: {
372: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
373: return;
374: }
375:
376: (*((integer8 *) (*s_objet_resultat).objet)) = max_entier;
377:
378: if (((*s_objet_position).objet =
379: allocation_maillon(s_etat_processus)) == NULL)
380: {
381: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
382: return;
383: }
384:
385: l_element_courant = (*s_objet_position).objet;
386:
387: if (((*l_element_courant).donnee = allocation(s_etat_processus,
388: INT)) == NULL)
389: {
390: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
391: return;
392: }
393:
394: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
395: position_max_i + 1;
396:
397: if (((*l_element_courant).suivant =
398: allocation_maillon(s_etat_processus)) == NULL)
399: {
400: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
401: return;
402: }
403:
404: l_element_courant = (*l_element_courant).suivant;
405: (*l_element_courant).suivant = NULL;
406:
407: if (((*l_element_courant).donnee = allocation(s_etat_processus,
408: INT)) == NULL)
409: {
410: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
411: return;
412: }
413:
414: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
415: position_max_j + 1;
416: }
417:
418: /*
419: * Matrice de réels
420: */
421:
422: else if ((*s_objet_argument_1).type == MRL)
423: {
424: max_reel = ((real8 **) (*((struct_matrice *)
425: (*s_objet_argument_1).objet)).tableau)[0][0];
426: position_max_i = 0;
427: position_max_j = 0;
428:
429: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
430: .nombre_lignes; i++)
431: {
432: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
433: .objet)).nombre_colonnes; j++)
434: {
435: if (((real8 **) (*((struct_matrice *)
436: (*s_objet_argument_1).objet)).tableau)[i][j] >
437: max_reel)
438: {
439: max_reel = ((real8 **) (*((struct_matrice *)
440: (*s_objet_argument_1).objet)).tableau)[i][j];
441: position_max_i = i;
442: position_max_j = j;
443: }
444: }
445: }
446:
447: if ((s_objet_resultat = allocation(s_etat_processus, REL))
448: == NULL)
449: {
450: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
451: return;
452: }
453:
454: (*((real8 *) (*s_objet_resultat).objet)) = max_reel;
455:
456: if (((*s_objet_position).objet =
457: allocation_maillon(s_etat_processus)) == NULL)
458: {
459: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
460: return;
461: }
462:
463: l_element_courant = (*s_objet_position).objet;
464:
465: if (((*l_element_courant).donnee = allocation(s_etat_processus,
466: INT)) == NULL)
467: {
468: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
469: return;
470: }
471:
472: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
473: position_max_i + 1;
474:
475: if (((*l_element_courant).suivant =
476: allocation_maillon(s_etat_processus)) == NULL)
477: {
478: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
479: return;
480: }
481:
482: l_element_courant = (*l_element_courant).suivant;
483: (*l_element_courant).suivant = NULL;
484:
485: if (((*l_element_courant).donnee = allocation(s_etat_processus,
486: INT)) == NULL)
487: {
488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
489: return;
490: }
491:
492: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
493: position_max_j + 1;
494: }
495:
496: /*
497: * Matrice de complexes
498: */
499:
500: else
501: {
502: f77absc_(&(((struct_complexe16 **) (*((struct_matrice *)
503: (*s_objet_argument_1).objet)).tableau)[0][0]), &max_reel);
504:
505: position_max_i = 0;
506: position_max_j = 0;
507:
508: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
509: .nombre_lignes; i++)
510: {
511: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
512: .objet)).nombre_colonnes; j++)
513: {
514:
515: f77absc_(&(((struct_complexe16 **) (*((struct_matrice *)
516: (*s_objet_argument_1).objet)).tableau)[i][j]),
517: &module);
518:
519: if (module > max_reel)
520: {
521: max_reel = module;
522: position_max_i = i;
523: position_max_j = j;
524: }
525: }
526: }
527:
528: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
529: == NULL)
530: {
531: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
532: return;
533: }
534:
535: (*((struct_complexe16 *) (*s_objet_resultat).objet))
536: .partie_reelle = ((struct_complexe16 **)
537: (*((struct_matrice *) (*s_objet_argument_1).objet))
538: .tableau)[position_max_i][position_max_j].partie_reelle;
539: (*((struct_complexe16 *) (*s_objet_resultat).objet))
540: .partie_imaginaire = ((struct_complexe16 **)
541: (*((struct_matrice *) (*s_objet_argument_1).objet))
542: .tableau)[position_max_i][position_max_j].partie_imaginaire;
543:
544: if (((*s_objet_position).objet =
545: allocation_maillon(s_etat_processus)) == NULL)
546: {
547: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
548: return;
549: }
550:
551: l_element_courant = (*s_objet_position).objet;
552:
553: if (((*l_element_courant).donnee = allocation(s_etat_processus,
554: INT)) == NULL)
555: {
556: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
557: return;
558: }
559:
560: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
561: position_max_i + 1;
562:
563: if (((*l_element_courant).suivant =
564: allocation_maillon(s_etat_processus)) == NULL)
565: {
566: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
567: return;
568: }
569:
570: l_element_courant = (*l_element_courant).suivant;
571: (*l_element_courant).suivant = NULL;
572:
573: if (((*l_element_courant).donnee = allocation(s_etat_processus,
574: INT)) == NULL)
575: {
576: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
577: return;
578: }
579:
580: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
581: position_max_j + 1;
582: }
583:
584: liberation(s_etat_processus, s_objet_argument_1);
585:
586: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
587: s_objet_resultat) == d_erreur)
588: {
589: return;
590: }
591:
592: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
593: s_objet_position) == d_erreur)
594: {
595: return;
596: }
597: }
598:
599: /*
600: --------------------------------------------------------------------------------
601: MAX portant sur autre chose (deux arguments)
602: --------------------------------------------------------------------------------
603: */
604:
605: else
606: {
607: if (test_cfsf(s_etat_processus, 31) == d_vrai)
608: {
609: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
610: {
611: return;
612: }
613: }
614:
615: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
616: &s_objet_argument_1) == d_erreur)
617: {
618: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
619: return;
620: }
621:
622: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
623: &s_objet_argument_2) == d_erreur)
624: {
625: liberation(s_etat_processus, s_objet_argument_1);
626:
627: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
628: return;
629: }
630:
631: /*
632: --------------------------------------------------------------------------------
633: MAX portant sur des valeurs numériques
634: --------------------------------------------------------------------------------
635: */
636:
637: if ((((*s_objet_argument_1).type == INT) ||
638: ((*s_objet_argument_1).type == REL)) &&
639: (((*s_objet_argument_2).type == INT) ||
640: ((*s_objet_argument_2).type == REL)))
641: {
642: if ((*s_objet_argument_1).type == INT)
643: {
644: if ((*s_objet_argument_2).type == INT)
645: {
646: if ((*((integer8 *) (*s_objet_argument_1).objet)) >=
647: (*((integer8 *) (*s_objet_argument_2).objet)))
648: {
649: s_objet_resultat = s_objet_argument_1;
650: s_objet_argument_1 = NULL;
651: }
652: else
653: {
654: s_objet_resultat = s_objet_argument_2;
655: s_objet_argument_2 = NULL;
656: }
657: }
658: else
659: {
660: if ((*((integer8 *) (*s_objet_argument_1).objet)) >=
661: (*((real8 *) (*s_objet_argument_2).objet)))
662: {
663: s_objet_resultat = s_objet_argument_1;
664: s_objet_argument_1 = NULL;
665: }
666: else
667: {
668: s_objet_resultat = s_objet_argument_2;
669: s_objet_argument_2 = NULL;
670: }
671: }
672: }
673: else
674: {
675: if ((*s_objet_argument_2).type == INT)
676: {
677: if ((*((real8 *) (*s_objet_argument_1).objet)) >=
678: (*((integer8 *) (*s_objet_argument_2).objet)))
679: {
680: s_objet_resultat = s_objet_argument_1;
681: s_objet_argument_1 = NULL;
682: }
683: else
684: {
685: s_objet_resultat = s_objet_argument_2;
686: s_objet_argument_2 = NULL;
687: }
688: }
689: else
690: {
691: if ((*((real8 *) (*s_objet_argument_1).objet)) >=
692: (*((real8 *) (*s_objet_argument_2).objet)))
693: {
694: s_objet_resultat = s_objet_argument_1;
695: s_objet_argument_1 = NULL;
696: }
697: else
698: {
699: s_objet_resultat = s_objet_argument_2;
700: s_objet_argument_2 = NULL;
701: }
702: }
703: }
704: }
705:
706: /*
707: --------------------------------------------------------------------------------
708: MAX entre des arguments complexes
709: --------------------------------------------------------------------------------
710: */
711:
712: /*
713: * Nom ou valeur numérique / Nom ou valeur numérique
714: */
715:
716: else if ((((*s_objet_argument_1).type == NOM) &&
717: (((*s_objet_argument_2).type == NOM) ||
718: ((*s_objet_argument_2).type == INT) ||
719: ((*s_objet_argument_2).type == REL))) ||
720: (((*s_objet_argument_2).type == NOM) &&
721: (((*s_objet_argument_1).type == INT) ||
722: ((*s_objet_argument_1).type == REL))))
723: {
724: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
725: == NULL)
726: {
727: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
728: return;
729: }
730:
731: if (((*s_objet_resultat).objet =
732: allocation_maillon(s_etat_processus)) == NULL)
733: {
734: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
735: return;
736: }
737:
738: l_element_courant = (*s_objet_resultat).objet;
739:
740: if (((*l_element_courant).donnee = allocation(s_etat_processus,
741: FCT)) == NULL)
742: {
743: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
744: return;
745: }
746:
747: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
748: .nombre_arguments = 0;
749: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
750: .fonction = instruction_vers_niveau_superieur;
751:
752: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
753: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
754: {
755: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
756: return;
757: }
758:
759: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
760: .nom_fonction, "<<");
761:
762: if (((*l_element_courant).suivant =
763: allocation_maillon(s_etat_processus)) == NULL)
764: {
765: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
766: return;
767: }
768:
769: l_element_courant = (*l_element_courant).suivant;
770: (*l_element_courant).donnee = s_objet_argument_2;
771:
772: if (((*l_element_courant).suivant =
773: allocation_maillon(s_etat_processus)) == NULL)
774: {
775: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
776: return;
777: }
778:
779: l_element_courant = (*l_element_courant).suivant;
780: (*l_element_courant).donnee = s_objet_argument_1;
781:
782: if (((*l_element_courant).suivant =
783: allocation_maillon(s_etat_processus)) == NULL)
784: {
785: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
786: return;
787: }
788:
789: l_element_courant = (*l_element_courant).suivant;
790:
791: if (((*l_element_courant).donnee = allocation(s_etat_processus,
792: FCT)) == NULL)
793: {
794: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
795: return;
796: }
797:
798: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
799: .nombre_arguments = 2;
800: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
801: .fonction = instruction_max;
802:
803: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
804: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
805: {
806: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
807: return;
808: }
809:
810: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
811: .nom_fonction, "MAX");
812:
813: if (((*l_element_courant).suivant =
814: allocation_maillon(s_etat_processus)) == NULL)
815: {
816: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
817: return;
818: }
819:
820: l_element_courant = (*l_element_courant).suivant;
821:
822: if (((*l_element_courant).donnee = allocation(s_etat_processus,
823: FCT)) == NULL)
824: {
825: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
826: return;
827: }
828:
829: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
830: .nombre_arguments = 0;
831: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
832: .fonction = instruction_vers_niveau_inferieur;
833:
834: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
835: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
836: {
837: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
838: return;
839: }
840:
841: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
842: .nom_fonction, ">>");
843:
844: (*l_element_courant).suivant = NULL;
845:
846: s_objet_argument_1 = NULL;
847: s_objet_argument_2 = NULL;
848: }
849:
850: /*
851: * Nom ou valeur numérique / Expression
852: */
853:
854: else if (((((*s_objet_argument_1).type == ALG) ||
855: ((*s_objet_argument_1).type == RPN))) &&
856: (((*s_objet_argument_2).type == NOM) ||
857: ((*s_objet_argument_2).type == INT) ||
858: ((*s_objet_argument_2).type == REL)))
859: {
860: nombre_elements = 0;
861: l_element_courant = (struct_liste_chainee *)
862: (*s_objet_argument_1).objet;
863:
864: while(l_element_courant != NULL)
865: {
866: nombre_elements++;
867: l_element_courant = (*l_element_courant).suivant;
868: }
869:
870: if (nombre_elements == 2)
871: {
872: liberation(s_etat_processus, s_objet_argument_1);
873: liberation(s_etat_processus, s_objet_argument_2);
874:
875: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
876: return;
877: }
878:
879: if ((s_objet_resultat = copie_objet(s_etat_processus,
880: s_objet_argument_1, 'N')) == NULL)
881: {
882: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
883: return;
884: }
885:
886: l_element_courant = (struct_liste_chainee *)
887: (*s_objet_resultat).objet;
888: l_element_precedent = l_element_courant;
889: l_element_courant = (*l_element_courant).suivant;
890:
891: if (((*l_element_precedent).suivant =
892: allocation_maillon(s_etat_processus)) == NULL)
893: {
894: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
895: return;
896: }
897:
898: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
899: (*(*l_element_precedent).suivant).suivant = l_element_courant;
900:
901: while((*l_element_courant).suivant != NULL)
902: {
903: l_element_precedent = l_element_courant;
904: l_element_courant = (*l_element_courant).suivant;
905: }
906:
907: if (((*l_element_precedent).suivant =
908: allocation_maillon(s_etat_processus)) == NULL)
909: {
910: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
911: return;
912: }
913:
914: if (((*(*l_element_precedent).suivant).donnee =
915: allocation(s_etat_processus, FCT)) == NULL)
916: {
917: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
918: return;
919: }
920:
921: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
922: .donnee).objet)).nombre_arguments = 2;
923: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
924: .donnee).objet)).fonction = instruction_max;
925:
926: if (((*((struct_fonction *) (*(*(*l_element_precedent)
927: .suivant).donnee).objet)).nom_fonction =
928: malloc(4 * sizeof(unsigned char))) == NULL)
929: {
930: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
931: return;
932: }
933:
934: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
935: .suivant).donnee).objet)).nom_fonction, "MAX");
936:
937: (*(*l_element_precedent).suivant).suivant = l_element_courant;
938:
939: s_objet_argument_2 = NULL;
940: }
941:
942: /*
943: * Expression / Nom ou valeur numérique
944: */
945:
946: else if ((((*s_objet_argument_1).type == NOM) ||
947: ((*s_objet_argument_1).type == INT) ||
948: ((*s_objet_argument_1).type == REL)) &&
949: ((((*s_objet_argument_2).type == ALG) ||
950: ((*s_objet_argument_2).type == RPN))))
951: {
952: nombre_elements = 0;
953: l_element_courant = (struct_liste_chainee *)
954: (*s_objet_argument_2).objet;
955:
956: while(l_element_courant != NULL)
957: {
958: nombre_elements++;
959: l_element_courant = (*l_element_courant).suivant;
960: }
961:
962: if (nombre_elements == 2)
963: {
964: liberation(s_etat_processus, s_objet_argument_1);
965: liberation(s_etat_processus, s_objet_argument_2);
966:
967: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
968: return;
969: }
970:
971: if ((s_objet_resultat = copie_objet(s_etat_processus,
972: s_objet_argument_2, 'N')) == NULL)
973: {
974: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
975: return;
976: }
977:
978: l_element_courant = (struct_liste_chainee *)
979: (*s_objet_resultat).objet;
980: l_element_precedent = l_element_courant;
981:
982: while((*l_element_courant).suivant != NULL)
983: {
984: l_element_precedent = l_element_courant;
985: l_element_courant = (*l_element_courant).suivant;
986: }
987:
988: if (((*l_element_precedent).suivant =
989: allocation_maillon(s_etat_processus)) == NULL)
990: {
991: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
992: return;
993: }
994:
995: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
996: l_element_precedent = (*l_element_precedent).suivant;
997:
998: if (((*l_element_precedent).suivant =
999: allocation_maillon(s_etat_processus)) == NULL)
1000: {
1001: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1002: return;
1003: }
1004:
1005: if (((*(*l_element_precedent).suivant).donnee =
1006: allocation(s_etat_processus, FCT)) == NULL)
1007: {
1008: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1009: return;
1010: }
1011:
1012: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1013: .donnee).objet)).nombre_arguments = 2;
1014: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1015: .donnee).objet)).fonction = instruction_max;
1016:
1017: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1018: .suivant).donnee).objet)).nom_fonction =
1019: malloc(4 * sizeof(unsigned char))) == NULL)
1020: {
1021: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1022: return;
1023: }
1024:
1025: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1026: .suivant).donnee).objet)).nom_fonction, "MAX");
1027:
1028: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1029:
1030: s_objet_argument_1 = NULL;
1031: }
1032:
1033: /*
1034: * Expression / Expression
1035: */
1036:
1037: else if ((((*s_objet_argument_1).type == ALG) &&
1038: ((*s_objet_argument_2).type == ALG)) ||
1039: (((*s_objet_argument_1).type == RPN) &&
1040: ((*s_objet_argument_2).type == RPN)))
1041: {
1042: nombre_elements = 0;
1043: l_element_courant = (struct_liste_chainee *)
1044: (*s_objet_argument_1).objet;
1045:
1046: while(l_element_courant != NULL)
1047: {
1048: nombre_elements++;
1049: l_element_courant = (*l_element_courant).suivant;
1050: }
1051:
1052: if (nombre_elements == 2)
1053: {
1054: liberation(s_etat_processus, s_objet_argument_1);
1055: liberation(s_etat_processus, s_objet_argument_2);
1056:
1057: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1058: return;
1059: }
1060:
1061: nombre_elements = 0;
1062: l_element_courant = (struct_liste_chainee *)
1063: (*s_objet_argument_2).objet;
1064:
1065: while(l_element_courant != NULL)
1066: {
1067: nombre_elements++;
1068: l_element_courant = (*l_element_courant).suivant;
1069: }
1070:
1071: if (nombre_elements == 2)
1072: {
1073: liberation(s_etat_processus, s_objet_argument_1);
1074: liberation(s_etat_processus, s_objet_argument_2);
1075:
1076: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1077: return;
1078: }
1079:
1080: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
1081: s_objet_argument_1, 'N')) == NULL)
1082: {
1083: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1084: return;
1085: }
1086:
1087: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
1088: s_objet_argument_2, 'N')) == NULL)
1089: {
1090: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1091: return;
1092: }
1093:
1094: l_element_courant = (struct_liste_chainee *)
1095: (*s_copie_argument_1).objet;
1096: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
1097: (*s_copie_argument_1).objet)).suivant;
1098:
1099: liberation(s_etat_processus, (*l_element_courant).donnee);
1100: free(l_element_courant);
1101:
1102: l_element_courant = (struct_liste_chainee *)
1103: (*s_copie_argument_2).objet;
1104: l_element_precedent = l_element_courant;
1105: s_objet_resultat = s_copie_argument_2;
1106:
1107: while((*l_element_courant).suivant != NULL)
1108: {
1109: l_element_precedent = l_element_courant;
1110: l_element_courant = (*l_element_courant).suivant;
1111: }
1112:
1113: liberation(s_etat_processus, (*l_element_courant).donnee);
1114: free(l_element_courant);
1115:
1116: (*l_element_precedent).suivant = (struct_liste_chainee *)
1117: (*s_copie_argument_1).objet;
1118: free(s_copie_argument_1);
1119:
1120: l_element_courant = (*l_element_precedent).suivant;
1121: while((*l_element_courant).suivant != NULL)
1122: {
1123: l_element_precedent = l_element_courant;
1124: l_element_courant = (*l_element_courant).suivant;
1125: }
1126:
1127: if (((*l_element_precedent).suivant =
1128: allocation_maillon(s_etat_processus)) == NULL)
1129: {
1130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1131: return;
1132: }
1133:
1134: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1135: l_element_courant = (*l_element_precedent).suivant;
1136:
1137: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1138: FCT)) == NULL)
1139: {
1140: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1141: return;
1142: }
1143:
1144: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1145: .nombre_arguments = 2;
1146: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1147: .fonction = instruction_max;
1148:
1149: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1150: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
1151: {
1152: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1153: return;
1154: }
1155:
1156: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1157: .nom_fonction, "MAX");
1158: }
1159:
1160: /*
1161: --------------------------------------------------------------------------------
1162: Arguments incorrects
1163: --------------------------------------------------------------------------------
1164: */
1165:
1166: else
1167: {
1168: liberation(s_etat_processus, s_objet_argument_1);
1169: liberation(s_etat_processus, s_objet_argument_2);
1170:
1171: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1172: return;
1173: }
1174:
1175: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1176: s_objet_resultat) == d_erreur)
1177: {
1178: return;
1179: }
1180:
1181: liberation(s_etat_processus, s_objet_argument_1);
1182: liberation(s_etat_processus, s_objet_argument_2);
1183: }
1184:
1185: return;
1186: }
1187:
1188:
1189: /*
1190: ================================================================================
1191: Fonction 'min'
1192: ================================================================================
1193: Entrées :
1194: --------------------------------------------------------------------------------
1195: Sorties :
1196: --------------------------------------------------------------------------------
1197: Effets de bord : néant
1198: ================================================================================
1199: */
1200:
1201: void
1202: instruction_min(struct_processus *s_etat_processus)
1203: {
1204: real8 min_reel;
1205: real8 module;
1206:
1207: integer8 min_entier;
1208:
1209: struct_liste_chainee *l_element_courant;
1210: struct_liste_chainee *l_element_precedent;
1211:
1212: struct_objet *s_copie_argument_1;
1213: struct_objet *s_copie_argument_2;
1214: struct_objet *s_objet_argument_1;
1215: struct_objet *s_objet_argument_2;
1216: struct_objet *s_objet_position;
1217: struct_objet *s_objet_resultat;
1218:
1.42 bertrand 1219: integer8 i;
1220: integer8 j;
1221: integer8 nombre_elements;
1222: integer8 position_min_i;
1223: integer8 position_min_j;
1.1 bertrand 1224:
1225: (*s_etat_processus).erreur_execution = d_ex;
1226:
1227: if ((*s_etat_processus).affichage_arguments == 'Y')
1228: {
1229: printf("\n MIN ");
1230:
1231: if ((*s_etat_processus).langue == 'F')
1232: {
1233: printf("(minimum)\n\n");
1234: }
1235: else
1236: {
1237: printf("(minimum)\n\n");
1238: }
1239:
1240: printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
1241: printf("-> 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
1242: printf(" 1: %s\n\n", d_LST);
1243:
1244: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1245: printf("-> 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
1246: printf(" 1: %s\n\n", d_LST);
1247:
1.4 bertrand 1248: printf(" 2: %s, %s\n", d_INT, d_REL);
1249: printf(" 1: %s, %s\n", d_INT, d_REL);
1250: printf("-> 1: %s, %s\n\n", d_INT, d_REL);
1251:
1252: printf(" 2: %s, %s, %s, %s, %s\n",
1253: d_INT, d_REL, d_NOM, d_ALG, d_RPN);
1254: printf(" 1: %s, %s, %s, %s, %s\n",
1255: d_INT, d_REL, d_NOM, d_ALG, d_RPN);
1.1 bertrand 1256: printf("-> 1: %s, %s\n", d_ALG, d_RPN);
1257:
1258: return;
1259: }
1260: else if ((*s_etat_processus).test_instruction == 'Y')
1261: {
1262: (*s_etat_processus).nombre_arguments = 2;
1263: return;
1264: }
1265:
1266: /*
1267: --------------------------------------------------------------------------------
1268: MIN portant sur un tableau (un seul argument)
1269: --------------------------------------------------------------------------------
1270: */
1271:
1272: if (((*(*(*s_etat_processus).l_base_pile).donnee).type == VIN)
1273: || ((*(*(*s_etat_processus).l_base_pile).donnee).type ==
1274: VRL) || ((*(*(*s_etat_processus).l_base_pile)
1275: .donnee).type == VCX))
1276: {
1277: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1278: {
1279: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1280: {
1281: return;
1282: }
1283: }
1284:
1285: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1286: &s_objet_argument_1) == d_erreur)
1287: {
1288: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1289: return;
1290: }
1291:
1292: if ((s_objet_position = allocation(s_etat_processus, LST)) == NULL)
1293: {
1294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1295: return;
1296: }
1297:
1298: /*
1299: * Vecteur d'entiers
1300: */
1301:
1302: if ((*s_objet_argument_1).type == VIN)
1303: {
1304: min_entier = ((integer8 *) (*((struct_vecteur *)
1305: (*s_objet_argument_1).objet)).tableau)[0];
1306: position_min_i = 0;
1307:
1308: for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument_1).objet))
1309: .taille; i++)
1310: {
1311: if (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
1312: .objet)).tableau)[i] < min_entier)
1313: {
1314: min_entier = ((integer8 *) (*((struct_vecteur *)
1315: (*s_objet_argument_1).objet)).tableau)[i];
1316: position_min_i = i;
1317: }
1318: }
1319:
1320: if ((s_objet_resultat = allocation(s_etat_processus, INT))
1321: == NULL)
1322: {
1323: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1324: return;
1325: }
1326:
1327: (*((integer8 *) (*s_objet_resultat).objet)) = min_entier;
1328:
1329: if (((*s_objet_position).objet =
1330: allocation_maillon(s_etat_processus)) == NULL)
1331: {
1332: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1333: return;
1334: }
1335:
1336: l_element_courant = (*s_objet_position).objet;
1337: (*l_element_courant).suivant = NULL;
1338:
1339: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1340: INT)) == NULL)
1341: {
1342: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1343: return;
1344: }
1345:
1346: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1347: position_min_i + 1;
1348: }
1349:
1350: /*
1351: * Vecteur de réels
1352: */
1353:
1354: else if ((*s_objet_argument_1).type == VRL)
1355: {
1356: min_reel = ((real8 *) (*((struct_vecteur *)
1357: (*s_objet_argument_1).objet)).tableau)[0];
1358: position_min_i = 0;
1359:
1360: for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument_1).objet))
1361: .taille; i++)
1362: {
1363: if (((real8 *) (*((struct_vecteur *) (*s_objet_argument_1)
1364: .objet)).tableau)[i] < min_reel)
1365: {
1366: min_reel = ((real8 *) (*((struct_vecteur *)
1367: (*s_objet_argument_1).objet)).tableau)[i];
1368: position_min_i = i;
1369: }
1370: }
1371:
1372: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1373: == NULL)
1374: {
1375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1376: return;
1377: }
1378:
1379: (*((real8 *) (*s_objet_resultat).objet)) = min_reel;
1380:
1381: if (((*s_objet_position).objet =
1382: allocation_maillon(s_etat_processus)) == NULL)
1383: {
1384: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1385: return;
1386: }
1387:
1388: l_element_courant = (*s_objet_position).objet;
1389: (*l_element_courant).suivant = NULL;
1390:
1391: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1392: INT)) == NULL)
1393: {
1394: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1395: return;
1396: }
1397:
1398: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1399: position_min_i + 1;
1400: }
1401:
1402: /*
1403: * Vecteur de complexes
1404: */
1405:
1406: else
1407: {
1408: f77absc_(&(((struct_complexe16 *) (*((struct_vecteur *)
1409: (*s_objet_argument_1).objet)).tableau)[0]), &min_reel);
1410:
1411: position_min_i = 0;
1412:
1413: for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument_1).objet))
1414: .taille; i++)
1415: {
1416: f77absc_(&(((struct_complexe16 *) (*((struct_vecteur *)
1417: (*s_objet_argument_1).objet)).tableau)[i]), &module);
1418:
1419: if (module < min_reel)
1420: {
1421: min_reel = module;
1422: position_min_i = i;
1423: }
1424: }
1425:
1426: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
1427: == NULL)
1428: {
1429: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1430: return;
1431: }
1432:
1433: (*((struct_complexe16 *) (*s_objet_resultat).objet))
1434: .partie_reelle = ((struct_complexe16 *)
1435: (*((struct_vecteur *) (*s_objet_argument_1).objet))
1436: .tableau)[position_min_i].partie_reelle;
1437: (*((struct_complexe16 *) (*s_objet_resultat).objet))
1438: .partie_imaginaire = ((struct_complexe16 *)
1439: (*((struct_vecteur *) (*s_objet_argument_1).objet))
1440: .tableau)[position_min_i].partie_imaginaire;
1441:
1442: if (((*s_objet_position).objet =
1443: allocation_maillon(s_etat_processus)) == NULL)
1444: {
1445: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1446: return;
1447: }
1448:
1449: l_element_courant = (*s_objet_position).objet;
1450: (*l_element_courant).suivant = NULL;
1451:
1452: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1453: INT)) == NULL)
1454: {
1455: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1456: return;
1457: }
1458:
1459: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1460: position_min_i + 1;
1461: }
1462:
1463: liberation(s_etat_processus, s_objet_argument_1);
1464:
1465: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1466: s_objet_resultat) == d_erreur)
1467: {
1468: return;
1469: }
1470:
1471: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1472: s_objet_position) == d_erreur)
1473: {
1474: return;
1475: }
1476: }
1477: else if (((*(*(*s_etat_processus).l_base_pile).donnee).type ==
1478: MIN) || ((*(*(*s_etat_processus).l_base_pile)
1479: .donnee).type == MRL) || ((*(*(*s_etat_processus)
1480: .l_base_pile).donnee).type == MCX))
1481: {
1482: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1483: {
1484: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1485: {
1486: return;
1487: }
1488: }
1489:
1490: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1491: &s_objet_argument_1) == d_erreur)
1492: {
1493: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1494: return;
1495: }
1496:
1497: if ((s_objet_position = allocation(s_etat_processus, LST))
1498: == NULL)
1499: {
1500: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1501: return;
1502: }
1503:
1504: /*
1505: * Matrice d'entiers
1506: */
1507:
1508: if ((*s_objet_argument_1).type == MIN)
1509: {
1510: min_entier = ((integer8 **) (*((struct_matrice *)
1511: (*s_objet_argument_1).objet)).tableau)[0][0];
1512: position_min_i = 0;
1513: position_min_j = 0;
1514:
1515: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
1516: .nombre_lignes; i++)
1517: {
1518: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
1519: .objet)).nombre_colonnes; j++)
1520: {
1521: if (((integer8 **) (*((struct_matrice *)
1522: (*s_objet_argument_1).objet)).tableau)[i][j] <
1523: min_entier)
1524: {
1525: min_entier = ((integer8 **) (*((struct_matrice *)
1526: (*s_objet_argument_1).objet)).tableau)[i][j];
1527: position_min_i = i;
1528: position_min_j = j;
1529: }
1530: }
1531: }
1532:
1533: if ((s_objet_resultat = allocation(s_etat_processus, INT))
1534: == NULL)
1535: {
1536: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1537: return;
1538: }
1539:
1540: (*((integer8 *) (*s_objet_resultat).objet)) = min_entier;
1541:
1542: if (((*s_objet_position).objet =
1543: allocation_maillon(s_etat_processus)) == NULL)
1544: {
1545: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1546: return;
1547: }
1548:
1549: l_element_courant = (*s_objet_position).objet;
1550:
1551: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1552: INT)) == NULL)
1553: {
1554: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1555: return;
1556: }
1557:
1558: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1559: position_min_i + 1;
1560:
1561: if (((*l_element_courant).suivant =
1562: allocation_maillon(s_etat_processus)) == NULL)
1563: {
1564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1565: return;
1566: }
1567:
1568: l_element_courant = (*l_element_courant).suivant;
1569: (*l_element_courant).suivant = NULL;
1570:
1571: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1572: INT)) == NULL)
1573: {
1574: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1575: return;
1576: }
1577:
1578: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1579: position_min_j + 1;
1580: }
1581:
1582: /*
1583: * Matrice de réels
1584: */
1585:
1586: else if ((*s_objet_argument_1).type == MRL)
1587: {
1588: min_reel = ((real8 **) (*((struct_matrice *)
1589: (*s_objet_argument_1).objet)).tableau)[0][0];
1590: position_min_i = 0;
1591: position_min_j = 0;
1592:
1593: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
1594: .nombre_lignes; i++)
1595: {
1596: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
1597: .objet)).nombre_colonnes; j++)
1598: {
1599: if (((real8 **) (*((struct_matrice *)
1600: (*s_objet_argument_1).objet)).tableau)[i][j] <
1601: min_reel)
1602: {
1603: min_reel = ((real8 **) (*((struct_matrice *)
1604: (*s_objet_argument_1).objet)).tableau)[i][j];
1605: position_min_i = i;
1606: position_min_j = j;
1607: }
1608: }
1609: }
1610:
1611: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1612: == NULL)
1613: {
1614: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1615: return;
1616: }
1617:
1618: (*((real8 *) (*s_objet_resultat).objet)) = min_reel;
1619:
1620: if (((*s_objet_position).objet =
1621: allocation_maillon(s_etat_processus)) == NULL)
1622: {
1623: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1624: return;
1625: }
1626:
1627: l_element_courant = (*s_objet_position).objet;
1628:
1629: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1630: INT)) == NULL)
1631: {
1632: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1633: return;
1634: }
1635:
1636: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1637: position_min_i + 1;
1638:
1639: if (((*l_element_courant).suivant =
1640: allocation_maillon(s_etat_processus)) == NULL)
1641: {
1642: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1643: return;
1644: }
1645:
1646: l_element_courant = (*l_element_courant).suivant;
1647: (*l_element_courant).suivant = NULL;
1648:
1649: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1650: INT)) == NULL)
1651: {
1652: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1653: return;
1654: }
1655:
1656: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1657: position_min_j + 1;
1658: }
1659:
1660: /*
1661: * Matrice de complexes
1662: */
1663:
1664: else
1665: {
1666: f77absc_(&(((struct_complexe16 **) (*((struct_matrice *)
1667: (*s_objet_argument_1).objet)).tableau)[0][0]), &min_reel);
1668:
1669: position_min_i = 0;
1670: position_min_j = 0;
1671:
1672: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument_1).objet))
1673: .nombre_lignes; i++)
1674: {
1675: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1)
1676: .objet)).nombre_colonnes; j++)
1677: {
1678:
1679: f77absc_(&(((struct_complexe16 **) (*((struct_matrice *)
1680: (*s_objet_argument_1).objet)).tableau)[i][j]),
1681: &module);
1682:
1683: if (module < min_reel)
1684: {
1685: min_reel = module;
1686: position_min_i = i;
1687: position_min_j = j;
1688: }
1689: }
1690: }
1691:
1692: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
1693: == NULL)
1694: {
1695: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1696: return;
1697: }
1698:
1699: (*((struct_complexe16 *) (*s_objet_resultat).objet))
1700: .partie_reelle = ((struct_complexe16 **)
1701: (*((struct_matrice *) (*s_objet_argument_1).objet))
1702: .tableau)[position_min_i][position_min_j].partie_reelle;
1703: (*((struct_complexe16 *) (*s_objet_resultat).objet))
1704: .partie_imaginaire = ((struct_complexe16 **)
1705: (*((struct_matrice *) (*s_objet_argument_1).objet))
1706: .tableau)[position_min_i][position_min_j].partie_imaginaire;
1707:
1708: if (((*s_objet_position).objet =
1709: allocation_maillon(s_etat_processus)) == NULL)
1710: {
1711: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1712: return;
1713: }
1714:
1715: l_element_courant = (*s_objet_position).objet;
1716:
1717: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1718: INT)) == NULL)
1719: {
1720: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1721: return;
1722: }
1723:
1724: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1725: position_min_i + 1;
1726:
1727: if (((*l_element_courant).suivant =
1728: allocation_maillon(s_etat_processus)) == NULL)
1729: {
1730: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1731: return;
1732: }
1733:
1734: l_element_courant = (*l_element_courant).suivant;
1735: (*l_element_courant).suivant = NULL;
1736:
1737: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1738: INT)) == NULL)
1739: {
1740: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1741: return;
1742: }
1743:
1744: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1745: position_min_j + 1;
1746: }
1747:
1748: liberation(s_etat_processus, s_objet_argument_1);
1749:
1750: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1751: s_objet_resultat) == d_erreur)
1752: {
1753: return;
1754: }
1755:
1756: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1757: s_objet_position) == d_erreur)
1758: {
1759: return;
1760: }
1761: }
1762:
1763: /*
1764: --------------------------------------------------------------------------------
1765: MIN portant sur autre chose (deux arguments)
1766: --------------------------------------------------------------------------------
1767: */
1768:
1769: else
1770: {
1771: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1772: {
1773: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1774: {
1775: return;
1776: }
1777: }
1778:
1779: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1780: &s_objet_argument_1) == d_erreur)
1781: {
1782: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1783: return;
1784: }
1785:
1786: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1787: &s_objet_argument_2) == d_erreur)
1788: {
1789: liberation(s_etat_processus, s_objet_argument_1);
1790:
1791: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1792: return;
1793: }
1794:
1795: /*
1796: --------------------------------------------------------------------------------
1797: MIN portant sur des valeurs numériques
1798: --------------------------------------------------------------------------------
1799: */
1800:
1801: if ((((*s_objet_argument_1).type == INT) ||
1802: ((*s_objet_argument_1).type == REL)) &&
1803: (((*s_objet_argument_2).type == INT) ||
1804: ((*s_objet_argument_2).type == REL)))
1805: {
1806: if ((*s_objet_argument_1).type == INT)
1807: {
1808: if ((*s_objet_argument_2).type == INT)
1809: {
1810: if ((*((integer8 *) (*s_objet_argument_1).objet)) <=
1811: (*((integer8 *) (*s_objet_argument_2).objet)))
1812: {
1813: s_objet_resultat = s_objet_argument_1;
1814: s_objet_argument_1 = NULL;
1815: }
1816: else
1817: {
1818: s_objet_resultat = s_objet_argument_2;
1819: s_objet_argument_2 = NULL;
1820: }
1821: }
1822: else
1823: {
1824: if ((*((integer8 *) (*s_objet_argument_1).objet)) <=
1825: (*((real8 *) (*s_objet_argument_2).objet)))
1826: {
1827: s_objet_resultat = s_objet_argument_1;
1828: s_objet_argument_1 = NULL;
1829: }
1830: else
1831: {
1832: s_objet_resultat = s_objet_argument_2;
1833: s_objet_argument_2 = NULL;
1834: }
1835: }
1836: }
1837: else
1838: {
1839: if ((*s_objet_argument_2).type == INT)
1840: {
1841: if ((*((real8 *) (*s_objet_argument_1).objet)) <=
1842: (*((integer8 *) (*s_objet_argument_2).objet)))
1843: {
1844: s_objet_resultat = s_objet_argument_1;
1845: s_objet_argument_1 = NULL;
1846: }
1847: else
1848: {
1849: s_objet_resultat = s_objet_argument_2;
1850: s_objet_argument_2 = NULL;
1851: }
1852: }
1853: else
1854: {
1855: if ((*((real8 *) (*s_objet_argument_1).objet)) <=
1856: (*((real8 *) (*s_objet_argument_2).objet)))
1857: {
1858: s_objet_resultat = s_objet_argument_1;
1859: s_objet_argument_1 = NULL;
1860: }
1861: else
1862: {
1863: s_objet_resultat = s_objet_argument_2;
1864: s_objet_argument_2 = NULL;
1865: }
1866: }
1867: }
1868: }
1869:
1870: /*
1871: --------------------------------------------------------------------------------
1872: MIN entre des arguments complexes
1873: --------------------------------------------------------------------------------
1874: */
1875:
1876: /*
1877: * Nom ou valeur numérique / Nom ou valeur numérique
1878: */
1879:
1880: else if ((((*s_objet_argument_1).type == NOM) &&
1881: (((*s_objet_argument_2).type == NOM) ||
1882: ((*s_objet_argument_2).type == INT) ||
1883: ((*s_objet_argument_2).type == REL))) ||
1884: (((*s_objet_argument_2).type == NOM) &&
1885: (((*s_objet_argument_1).type == INT) ||
1886: ((*s_objet_argument_1).type == REL))))
1887: {
1888: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
1889: == NULL)
1890: {
1891: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1892: return;
1893: }
1894:
1895: if (((*s_objet_resultat).objet =
1896: allocation_maillon(s_etat_processus)) == NULL)
1897: {
1898: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1899: return;
1900: }
1901:
1902: l_element_courant = (*s_objet_resultat).objet;
1903:
1904: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1905: FCT)) == NULL)
1906: {
1907: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1908: return;
1909: }
1910:
1911: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1912: .nombre_arguments = 0;
1913: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1914: .fonction = instruction_vers_niveau_superieur;
1915:
1916: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1917: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1918: {
1919: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1920: return;
1921: }
1922:
1923: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1924: .nom_fonction, "<<");
1925:
1926: if (((*l_element_courant).suivant =
1927: allocation_maillon(s_etat_processus)) == NULL)
1928: {
1929: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1930: return;
1931: }
1932:
1933: l_element_courant = (*l_element_courant).suivant;
1934: (*l_element_courant).donnee = s_objet_argument_2;
1935:
1936: if (((*l_element_courant).suivant =
1937: allocation_maillon(s_etat_processus)) == NULL)
1938: {
1939: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1940: return;
1941: }
1942:
1943: l_element_courant = (*l_element_courant).suivant;
1944: (*l_element_courant).donnee = s_objet_argument_1;
1945:
1946: if (((*l_element_courant).suivant =
1947: allocation_maillon(s_etat_processus)) == NULL)
1948: {
1949: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1950: return;
1951: }
1952:
1953: l_element_courant = (*l_element_courant).suivant;
1954:
1955: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1956: FCT)) == NULL)
1957: {
1958: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1959: return;
1960: }
1961:
1962: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1963: .nombre_arguments = 2;
1964: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1965: .fonction = instruction_min;
1966:
1967: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1968: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
1969: {
1970: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1971: return;
1972: }
1973:
1974: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1975: .nom_fonction, "MIN");
1976:
1977: if (((*l_element_courant).suivant =
1978: allocation_maillon(s_etat_processus)) == NULL)
1979: {
1980: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1981: return;
1982: }
1983:
1984: l_element_courant = (*l_element_courant).suivant;
1985:
1986: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1987: FCT)) == NULL)
1988: {
1989: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1990: return;
1991: }
1992:
1993: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1994: .nombre_arguments = 0;
1995: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1996: .fonction = instruction_vers_niveau_inferieur;
1997:
1998: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1999: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2000: {
2001: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2002: return;
2003: }
2004:
2005: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2006: .nom_fonction, ">>");
2007:
2008: (*l_element_courant).suivant = NULL;
2009:
2010: s_objet_argument_1 = NULL;
2011: s_objet_argument_2 = NULL;
2012: }
2013:
2014: /*
2015: * Nom ou valeur numérique / Expression
2016: */
2017:
2018: else if (((((*s_objet_argument_1).type == ALG) ||
2019: ((*s_objet_argument_1).type == RPN))) &&
2020: (((*s_objet_argument_2).type == NOM) ||
2021: ((*s_objet_argument_2).type == INT) ||
2022: ((*s_objet_argument_2).type == REL)))
2023: {
2024: nombre_elements = 0;
2025: l_element_courant = (struct_liste_chainee *)
2026: (*s_objet_argument_1).objet;
2027:
2028: while(l_element_courant != NULL)
2029: {
2030: nombre_elements++;
2031: l_element_courant = (*l_element_courant).suivant;
2032: }
2033:
2034: if (nombre_elements == 2)
2035: {
2036: liberation(s_etat_processus, s_objet_argument_1);
2037: liberation(s_etat_processus, s_objet_argument_2);
2038:
2039: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
2040: return;
2041: }
2042:
2043: if ((s_objet_resultat = copie_objet(s_etat_processus,
2044: s_objet_argument_1, 'N')) == NULL)
2045: {
2046: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2047: return;
2048: }
2049:
2050: l_element_courant = (struct_liste_chainee *)
2051: (*s_objet_resultat).objet;
2052: l_element_precedent = l_element_courant;
2053: l_element_courant = (*l_element_courant).suivant;
2054:
2055: if (((*l_element_precedent).suivant =
2056: allocation_maillon(s_etat_processus)) == NULL)
2057: {
2058: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2059: return;
2060: }
2061:
2062: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
2063: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2064:
2065: while((*l_element_courant).suivant != NULL)
2066: {
2067: l_element_precedent = l_element_courant;
2068: l_element_courant = (*l_element_courant).suivant;
2069: }
2070:
2071: if (((*l_element_precedent).suivant =
2072: allocation_maillon(s_etat_processus)) == NULL)
2073: {
2074: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2075: return;
2076: }
2077:
2078: if (((*(*l_element_precedent).suivant).donnee =
2079: allocation(s_etat_processus, FCT)) == NULL)
2080: {
2081: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2082: return;
2083: }
2084:
2085: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2086: .donnee).objet)).nombre_arguments = 2;
2087: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2088: .donnee).objet)).fonction = instruction_min;
2089:
2090: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2091: .suivant).donnee).objet)).nom_fonction =
2092: malloc(4 * sizeof(unsigned char))) == NULL)
2093: {
2094: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2095: return;
2096: }
2097:
2098: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2099: .suivant).donnee).objet)).nom_fonction, "MIN");
2100:
2101: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2102:
2103: s_objet_argument_2 = NULL;
2104: }
2105:
2106: /*
2107: * Expression / Nom ou valeur numérique
2108: */
2109:
2110: else if ((((*s_objet_argument_1).type == NOM) ||
2111: ((*s_objet_argument_1).type == INT) ||
2112: ((*s_objet_argument_1).type == REL)) &&
2113: ((((*s_objet_argument_2).type == ALG) ||
2114: ((*s_objet_argument_2).type == RPN))))
2115: {
2116: nombre_elements = 0;
2117: l_element_courant = (struct_liste_chainee *)
2118: (*s_objet_argument_2).objet;
2119:
2120: while(l_element_courant != NULL)
2121: {
2122: nombre_elements++;
2123: l_element_courant = (*l_element_courant).suivant;
2124: }
2125:
2126: if (nombre_elements == 2)
2127: {
2128: liberation(s_etat_processus, s_objet_argument_1);
2129: liberation(s_etat_processus, s_objet_argument_2);
2130:
2131: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
2132: return;
2133: }
2134:
2135: if ((s_objet_resultat = copie_objet(s_etat_processus,
2136: s_objet_argument_2, 'N')) == NULL)
2137: {
2138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2139: return;
2140: }
2141:
2142: l_element_courant = (struct_liste_chainee *)
2143: (*s_objet_resultat).objet;
2144: l_element_precedent = l_element_courant;
2145:
2146: while((*l_element_courant).suivant != NULL)
2147: {
2148: l_element_precedent = l_element_courant;
2149: l_element_courant = (*l_element_courant).suivant;
2150: }
2151:
2152: if (((*l_element_precedent).suivant =
2153: allocation_maillon(s_etat_processus)) == NULL)
2154: {
2155: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2156: return;
2157: }
2158:
2159: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
2160: l_element_precedent = (*l_element_precedent).suivant;
2161:
2162: if (((*l_element_precedent).suivant =
2163: allocation_maillon(s_etat_processus)) == NULL)
2164: {
2165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2166: return;
2167: }
2168:
2169: if (((*(*l_element_precedent).suivant).donnee =
2170: allocation(s_etat_processus, FCT)) == NULL)
2171: {
2172: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2173: return;
2174: }
2175:
2176: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2177: .donnee).objet)).nombre_arguments = 2;
2178: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2179: .donnee).objet)).fonction = instruction_min;
2180:
2181: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2182: .suivant).donnee).objet)).nom_fonction =
2183: malloc(4 * sizeof(unsigned char))) == NULL)
2184: {
2185: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2186: return;
2187: }
2188:
2189: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2190: .suivant).donnee).objet)).nom_fonction, "MIN");
2191:
2192: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2193:
2194: s_objet_argument_1 = NULL;
2195: }
2196:
2197: /*
2198: * Expression / Expression
2199: */
2200:
2201: else if ((((*s_objet_argument_1).type == ALG) &&
2202: ((*s_objet_argument_2).type == ALG)) ||
2203: (((*s_objet_argument_1).type == RPN) &&
2204: ((*s_objet_argument_2).type == RPN)))
2205: {
2206: nombre_elements = 0;
2207: l_element_courant = (struct_liste_chainee *)
2208: (*s_objet_argument_1).objet;
2209:
2210: while(l_element_courant != NULL)
2211: {
2212: nombre_elements++;
2213: l_element_courant = (*l_element_courant).suivant;
2214: }
2215:
2216: if (nombre_elements == 2)
2217: {
2218: liberation(s_etat_processus, s_objet_argument_1);
2219: liberation(s_etat_processus, s_objet_argument_2);
2220:
2221: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
2222: return;
2223: }
2224:
2225: nombre_elements = 0;
2226: l_element_courant = (struct_liste_chainee *)
2227: (*s_objet_argument_2).objet;
2228:
2229: while(l_element_courant != NULL)
2230: {
2231: nombre_elements++;
2232: l_element_courant = (*l_element_courant).suivant;
2233: }
2234:
2235: if (nombre_elements == 2)
2236: {
2237: liberation(s_etat_processus, s_objet_argument_1);
2238: liberation(s_etat_processus, s_objet_argument_2);
2239:
2240: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
2241: return;
2242: }
2243:
2244: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
2245: s_objet_argument_1, 'N')) == NULL)
2246: {
2247: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2248: return;
2249: }
2250:
2251: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
2252: s_objet_argument_2, 'N')) == NULL)
2253: {
2254: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2255: return;
2256: }
2257:
2258: l_element_courant = (struct_liste_chainee *)
2259: (*s_copie_argument_1).objet;
2260: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
2261: (*s_copie_argument_1).objet)).suivant;
2262:
2263: liberation(s_etat_processus, (*l_element_courant).donnee);
2264: free(l_element_courant);
2265:
2266: l_element_courant = (struct_liste_chainee *)
2267: (*s_copie_argument_2).objet;
2268: l_element_precedent = l_element_courant;
2269: s_objet_resultat = s_copie_argument_2;
2270:
2271: while((*l_element_courant).suivant != NULL)
2272: {
2273: l_element_precedent = l_element_courant;
2274: l_element_courant = (*l_element_courant).suivant;
2275: }
2276:
2277: liberation(s_etat_processus, (*l_element_courant).donnee);
2278: free(l_element_courant);
2279:
2280: (*l_element_precedent).suivant = (struct_liste_chainee *)
2281: (*s_copie_argument_1).objet;
2282: free(s_copie_argument_1);
2283:
2284: l_element_courant = (*l_element_precedent).suivant;
2285: while((*l_element_courant).suivant != NULL)
2286: {
2287: l_element_precedent = l_element_courant;
2288: l_element_courant = (*l_element_courant).suivant;
2289: }
2290:
2291: if (((*l_element_precedent).suivant =
2292: allocation_maillon(s_etat_processus)) == NULL)
2293: {
2294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2295: return;
2296: }
2297:
2298: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2299: l_element_courant = (*l_element_precedent).suivant;
2300:
2301: if (((*l_element_courant).donnee = allocation(s_etat_processus,
2302: FCT)) == NULL)
2303: {
2304: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2305: return;
2306: }
2307:
2308: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2309: .nombre_arguments = 2;
2310: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2311: .donnee).objet)).fonction = instruction_min;
2312:
2313: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2314: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
2315: {
2316: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2317: return;
2318: }
2319:
2320: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2321: .nom_fonction, "MIN");
2322: }
2323:
2324: /*
2325: --------------------------------------------------------------------------------
2326: Arguments incorrects
2327: --------------------------------------------------------------------------------
2328: */
2329:
2330: else
2331: {
2332: liberation(s_etat_processus, s_objet_argument_1);
2333: liberation(s_etat_processus, s_objet_argument_2);
2334:
2335: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2336: return;
2337: }
2338:
2339: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2340: s_objet_resultat) == d_erreur)
2341: {
2342: return;
2343: }
2344:
2345: liberation(s_etat_processus, s_objet_argument_1);
2346: liberation(s_etat_processus, s_objet_argument_2);
2347: }
2348:
2349: return;
2350: }
2351:
2352: // vim: ts=4