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