1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.24
4: Copyright (C) 1989-2011 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 'p->r'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_p_vers_r(struct_processus *s_etat_processus)
40: {
41: double angle;
42:
43: struct_liste_chainee *l_element_courant;
44: struct_liste_chainee *l_element_precedent;
45:
46: struct_objet *s_copie_argument;
47: struct_objet *s_objet_argument;
48: struct_objet *s_objet_resultat;
49:
50: (*s_etat_processus).erreur_execution = d_ex;
51:
52: if ((*s_etat_processus).affichage_arguments == 'Y')
53: {
54: printf("\n P->R ");
55:
56: if ((*s_etat_processus).langue == 'F')
57: {
58: printf("(coordonnées polaires vers cartésiennes)\n\n");
59: }
60: else
61: {
62: printf("(polar to cartesian coordinates)\n\n");
63: }
64:
65: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
66: printf("-> 1: %s\n\n", d_CPL);
67:
68: printf(" 1: %s, %s\n", d_NOM, d_ALG);
69: printf("-> 1: %s\n\n", d_ALG);
70:
71: printf(" 1: %s\n", d_RPN);
72: printf("-> 1: %s\n", d_RPN);
73:
74: return;
75: }
76: else if ((*s_etat_processus).test_instruction == 'Y')
77: {
78: (*s_etat_processus).nombre_arguments = -1;
79: return;
80: }
81:
82: if (test_cfsf(s_etat_processus, 31) == d_vrai)
83: {
84: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
85: {
86: return;
87: }
88: }
89:
90: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
91: &s_objet_argument) == d_erreur)
92: {
93: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
94: return;
95: }
96:
97: /*
98: --------------------------------------------------------------------------------
99: Conversion d'un entier ou d'un réel
100: --------------------------------------------------------------------------------
101: */
102:
103: if (((*s_objet_argument).type == INT) ||
104: ((*s_objet_argument).type == REL))
105: {
106: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
107: {
108: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
109: return;
110: }
111:
112: if ((*s_objet_argument).type == INT)
113: {
114: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle
115: = (*((integer8 *) (*s_objet_argument).objet));
116: }
117: else
118: {
119: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle
120: = (*((real8 *) (*s_objet_argument).objet));
121: }
122:
123: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_imaginaire
124: = 0;
125: }
126:
127: /*
128: --------------------------------------------------------------------------------
129: Conversion d'un complexe
130: --------------------------------------------------------------------------------
131: */
132:
133: else if ((*s_objet_argument).type == CPL)
134: {
135: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
136: {
137: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
138: return;
139: }
140:
141: angle = (*((struct_complexe16 *) (*s_objet_argument).objet))
142: .partie_imaginaire;
143:
144: if (test_cfsf(s_etat_processus, 60) == d_faux)
145: {
146: conversion_degres_vers_radians(&angle);
147: }
148:
149: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
150: (*((struct_complexe16 *) (*s_objet_argument).objet))
151: .partie_reelle * cos(angle);
152: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_imaginaire =
153: (*((struct_complexe16 *) (*s_objet_argument).objet))
154: .partie_reelle * sin(angle);
155: }
156:
157: /*
158: --------------------------------------------------------------------------------
159: Conversion d'un nom
160: --------------------------------------------------------------------------------
161: */
162:
163: else if ((*s_objet_argument).type == NOM)
164: {
165: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
166: {
167: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
168: return;
169: }
170:
171: if (((*s_objet_resultat).objet =
172: allocation_maillon(s_etat_processus)) == NULL)
173: {
174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
175: return;
176: }
177:
178: l_element_courant = (*s_objet_resultat).objet;
179:
180: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
181: == NULL)
182: {
183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
184: return;
185: }
186:
187: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
188: .nombre_arguments = 0;
189: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
190: .fonction = instruction_vers_niveau_superieur;
191:
192: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
193: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
194: {
195: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
196: return;
197: }
198:
199: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
200: .nom_fonction, "<<");
201:
202: if (((*l_element_courant).suivant =
203: allocation_maillon(s_etat_processus)) == NULL)
204: {
205: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
206: return;
207: }
208:
209: l_element_courant = (*l_element_courant).suivant;
210: (*l_element_courant).donnee = s_objet_argument;
211:
212: if (((*l_element_courant).suivant =
213: allocation_maillon(s_etat_processus)) == NULL)
214: {
215: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
216: return;
217: }
218:
219: l_element_courant = (*l_element_courant).suivant;
220:
221: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
222: == NULL)
223: {
224: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
225: return;
226: }
227:
228: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
229: .nombre_arguments = 1;
230: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
231: .fonction = instruction_p_vers_r;
232:
233: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
234: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
235: {
236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
237: return;
238: }
239:
240: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
241: .nom_fonction, "P->R");
242:
243: if (((*l_element_courant).suivant =
244: allocation_maillon(s_etat_processus)) == NULL)
245: {
246: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
247: return;
248: }
249:
250: l_element_courant = (*l_element_courant).suivant;
251:
252: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
253: == NULL)
254: {
255: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
256: return;
257: }
258:
259: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
260: .nombre_arguments = 0;
261: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
262: .fonction = instruction_vers_niveau_inferieur;
263:
264: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
265: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
266: {
267: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
268: return;
269: }
270:
271: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
272: .nom_fonction, ">>");
273:
274: (*l_element_courant).suivant = NULL;
275: s_objet_argument = NULL;
276: }
277:
278: /*
279: --------------------------------------------------------------------------------
280: Conversion d'une expression
281: --------------------------------------------------------------------------------
282: */
283:
284: else if (((*s_objet_argument).type == ALG) ||
285: ((*s_objet_argument).type == RPN))
286: {
287: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
288: 'N')) == NULL)
289: {
290: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
291: return;
292: }
293:
294: l_element_courant = (struct_liste_chainee *)
295: (*s_copie_argument).objet;
296: l_element_precedent = l_element_courant;
297:
298: while((*l_element_courant).suivant != NULL)
299: {
300: l_element_precedent = l_element_courant;
301: l_element_courant = (*l_element_courant).suivant;
302: }
303:
304: if (((*l_element_precedent).suivant =
305: allocation_maillon(s_etat_processus)) == NULL)
306: {
307: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
308: return;
309: }
310:
311: if (((*(*l_element_precedent).suivant).donnee =
312: allocation(s_etat_processus, FCT)) == NULL)
313: {
314: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
315: return;
316: }
317:
318: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
319: .donnee).objet)).nombre_arguments = 1;
320: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
321: .donnee).objet)).fonction = instruction_p_vers_r;
322:
323: if (((*((struct_fonction *) (*(*(*l_element_precedent)
324: .suivant).donnee).objet)).nom_fonction =
325: malloc(5 * sizeof(unsigned char))) == NULL)
326: {
327: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
328: return;
329: }
330:
331: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
332: .suivant).donnee).objet)).nom_fonction, "P->R");
333:
334: (*(*l_element_precedent).suivant).suivant = l_element_courant;
335:
336: s_objet_resultat = s_copie_argument;
337: }
338:
339: /*
340: --------------------------------------------------------------------------------
341: Réalisation impossible de la fonction P->R
342: --------------------------------------------------------------------------------
343: */
344:
345: else
346: {
347: liberation(s_etat_processus, s_objet_argument);
348:
349: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
350: return;
351: }
352:
353: liberation(s_etat_processus, s_objet_argument);
354:
355: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
356: s_objet_resultat) == d_erreur)
357: {
358: return;
359: }
360:
361: return;
362: }
363:
364:
365: /*
366: ================================================================================
367: Fonction 'put'
368: ================================================================================
369: Entrées : pointeur sur une structure struct_processus
370: --------------------------------------------------------------------------------
371: Sorties :
372: --------------------------------------------------------------------------------
373: Effets de bord : néant
374: ================================================================================
375: */
376:
377: void
378: instruction_put(struct_processus *s_etat_processus)
379: {
380: logical1 variable_partagee;
381:
382: struct_liste_chainee *l_element_courant;
383:
384: struct_objet *s_copie_3;
385: struct_objet *s_copie_4;
386: struct_objet *s_objet_1;
387: struct_objet *s_objet_2;
388: struct_objet *s_objet_3;
389: struct_objet *s_objet_4;
390: struct_objet *s_objet_element;
391:
392: unsigned long i;
393: unsigned long indice_i;
394: unsigned long indice_j;
395: unsigned long j;
396: unsigned long nombre_dimensions;
397:
398: void *tampon;
399:
400: (*s_etat_processus).erreur_execution = d_ex;
401:
402: if ((*s_etat_processus).affichage_arguments == 'Y')
403: {
404: printf("\n PUT ");
405:
406: if ((*s_etat_processus).langue == 'F')
407: {
408: printf("(change un élément)\n\n");
409: }
410: else
411: {
412: printf("(change element)\n\n");
413: }
414:
415: printf(" 3: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
416: printf(" 2: %s\n", d_LST);
417: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
418: printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX);
419:
420: printf(" 3: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
421: printf(" 2: %s\n", d_LST);
422: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
423: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
424:
425: printf(" 3: %s\n", d_LST);
426: printf(" 2: %s\n", d_INT);
427: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
428: " %s, %s, %s, %s, %s,\n"
429: " %s, %s, %s, %s, %s,\n"
430: " %s, %s, %s, %s,\n"
431: " %s, %s\n",
432: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
433: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
434: d_SQL, d_SLB, d_PRC, d_MTX);
435: printf("-> 1: %s\n\n", d_LST);
436:
437: printf(" 3: %s\n", d_TAB);
438: printf(" 2: %s\n", d_LST);
439: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
440: " %s, %s, %s, %s, %s,\n"
441: " %s, %s, %s, %s, %s,\n"
442: " %s, %s, %s, %s,\n"
443: " %s, %s\n",
444: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
445: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
446: d_SQL, d_SLB, d_PRC, d_MTX);
447: printf("-> 1: %s\n\n", d_TAB);
448:
449: printf(" 3: %s\n", d_NOM);
450: printf(" 2: %s, %s\n", d_LST, d_INT);
451: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
452: " %s, %s, %s, %s, %s,\n"
453: " %s, %s, %s, %s, %s,\n"
454: " %s, %s, %s, %s,\n"
455: " %s, %s\n",
456: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
457: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
458: d_SQL, d_SLB, d_PRC, d_MTX);
459:
460: return;
461: }
462: else if ((*s_etat_processus).test_instruction == 'Y')
463: {
464: (*s_etat_processus).nombre_arguments = -1;
465: return;
466: }
467:
468: if (test_cfsf(s_etat_processus, 31) == d_vrai)
469: {
470: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
471: {
472: return;
473: }
474: }
475:
476: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
477: &s_objet_1) == d_erreur)
478: {
479: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
480: return;
481: }
482:
483: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
484: &s_objet_2) == d_erreur)
485: {
486: liberation(s_etat_processus, s_objet_1);
487:
488: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
489: return;
490: }
491:
492: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
493: &s_objet_3) == d_erreur)
494: {
495: liberation(s_etat_processus, s_objet_1);
496: liberation(s_etat_processus, s_objet_2);
497:
498: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
499: return;
500: }
501:
502: /*
503: --------------------------------------------------------------------------------
504: Traitement des éléments des vecteurs
505: --------------------------------------------------------------------------------
506: */
507:
508: if (((*s_objet_3).type == VIN) ||
509: ((*s_objet_3).type == VRL) ||
510: ((*s_objet_3).type == VCX))
511: {
512: if ((*s_objet_2).type != LST)
513: {
514: liberation(s_etat_processus, s_objet_1);
515: liberation(s_etat_processus, s_objet_2);
516: liberation(s_etat_processus, s_objet_3);
517:
518: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
519: return;
520: }
521:
522: l_element_courant = (*s_objet_2).objet;
523: nombre_dimensions = 0;
524:
525: while(l_element_courant != NULL)
526: {
527: nombre_dimensions++;
528: l_element_courant = (*l_element_courant).suivant;
529: }
530:
531: if (nombre_dimensions != 1)
532: {
533: liberation(s_etat_processus, s_objet_1);
534: liberation(s_etat_processus, s_objet_2);
535: liberation(s_etat_processus, s_objet_3);
536:
537: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
538: return;
539: }
540:
541: l_element_courant = (*s_objet_2).objet;
542:
543: if ((*(*l_element_courant).donnee).type != INT)
544: {
545: liberation(s_etat_processus, s_objet_1);
546: liberation(s_etat_processus, s_objet_2);
547: liberation(s_etat_processus, s_objet_3);
548:
549: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
550: return;
551: }
552:
553: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
554: {
555: liberation(s_etat_processus, s_objet_1);
556: liberation(s_etat_processus, s_objet_2);
557: liberation(s_etat_processus, s_objet_3);
558:
559: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
560: return;
561: }
562: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
563: (integer8) (*((struct_vecteur *) (*s_objet_3).objet)).taille)
564: {
565: liberation(s_etat_processus, s_objet_1);
566: liberation(s_etat_processus, s_objet_2);
567: liberation(s_etat_processus, s_objet_3);
568:
569: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
570: return;
571: }
572:
573: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
574:
575: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL)
576: {
577: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
578: return;
579: }
580:
581: liberation(s_etat_processus, s_objet_3);
582: s_objet_3 = s_copie_3;
583:
584: if ((*s_objet_3).type == VIN)
585: {
586: /*
587: * Vecteur d'entiers
588: */
589:
590: if ((*s_objet_1).type == INT)
591: {
592: /*
593: * Aucune conversion de type
594: */
595:
596: ((integer8 *) (*((struct_vecteur *) (*s_objet_3).objet))
597: .tableau)[indice_i - 1] = (*((integer8 *)
598: (*s_objet_1).objet));
599: }
600: else if ((*s_objet_1).type == REL)
601: {
602: /*
603: * Conversion du vecteur en vecteur réel
604: */
605:
606: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
607: (*s_objet_3).objet)).tableau);
608:
609: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'R';
610: (*s_objet_3).type = VRL;
611:
612: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
613: = malloc((*((struct_vecteur *)
614: (*s_objet_3).objet)).taille * sizeof(real8)))
615: == NULL)
616: {
617: (*s_etat_processus).erreur_systeme =
618: d_es_allocation_memoire;
619: return;
620: }
621:
622: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
623: .taille; i++)
624: {
625: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
626: .tableau)[i] = (real8) (((integer8 *) tampon)[i]);
627: }
628:
629: free((integer8 *) tampon);
630:
631: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
632: .tableau)[indice_i - 1] = (*((real8 *)
633: (*s_objet_1).objet));
634: }
635: else if ((*s_objet_1).type == CPL)
636: {
637: /*
638: * Conversion du vecteur en vecteur complexe
639: */
640:
641: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
642: (*s_objet_3).objet)).tableau);
643:
644: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C';
645: (*s_objet_3).type = VCX;
646:
647: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
648: = malloc((*((struct_vecteur *)
649: (*s_objet_3).objet)).taille *
650: sizeof(struct_complexe16))) == NULL)
651: {
652: (*s_etat_processus).erreur_systeme =
653: d_es_allocation_memoire;
654: return;
655: }
656:
657: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
658: .taille; i++)
659: {
660: ((struct_complexe16 *) (*((struct_vecteur *)
661: (*s_objet_3).objet)).tableau)[i].partie_reelle =
662: (real8) (((integer8 *) tampon)[i]);
663: ((struct_complexe16 *) (*((struct_vecteur *)
664: (*s_objet_3).objet)).tableau)[i]
665: .partie_imaginaire = (real8) 0;
666: }
667:
668: free((integer8 *) tampon);
669:
670: ((struct_complexe16 *) (*((struct_vecteur *)
671: (*s_objet_3).objet)).tableau)[indice_i - 1]
672: .partie_reelle = (*((struct_complexe16 *)
673: (*s_objet_1).objet)).partie_reelle;
674: ((struct_complexe16 *) (*((struct_vecteur *)
675: (*s_objet_3).objet)).tableau)[indice_i - 1]
676: .partie_imaginaire = (*((struct_complexe16 *)
677: (*s_objet_1).objet)).partie_imaginaire;
678: }
679: else
680: {
681: liberation(s_etat_processus, s_objet_1);
682: liberation(s_etat_processus, s_objet_2);
683: liberation(s_etat_processus, s_objet_3);
684:
685: (*s_etat_processus).erreur_execution =
686: d_ex_erreur_type_argument;
687: return;
688: }
689: }
690: else if ((*s_objet_3).type == VRL)
691: {
692: /*
693: * Vecteur de réels
694: */
695:
696: if ((*s_objet_1).type == INT)
697: {
698: /*
699: * Conversion de l'élément à insérer en réel
700: */
701:
702: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
703: .tableau)[indice_i - 1] = (real8) (*((integer8 *)
704: (*s_objet_1).objet));
705: }
706: else if ((*s_objet_1).type == REL)
707: {
708: /*
709: * Aucune conversion de type
710: */
711:
712: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
713: .tableau)[indice_i - 1] = (*((real8 *)
714: (*s_objet_1).objet));
715: }
716: else if ((*s_objet_1).type == CPL)
717: {
718: /*
719: * Conversion du vecteur en vecteur complexe
720: */
721:
722: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
723: (*s_objet_3).objet)).tableau);
724:
725: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C';
726: (*s_objet_3).type = VCX;
727:
728: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
729: = malloc((*((struct_vecteur *)
730: (*s_objet_3).objet)).taille *
731: sizeof(struct_complexe16))) == NULL)
732: {
733: (*s_etat_processus).erreur_systeme =
734: d_es_allocation_memoire;
735: return;
736: }
737:
738: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
739: .taille; i++)
740: {
741: ((struct_complexe16 *) (*((struct_vecteur *)
742: (*s_objet_3).objet)).tableau)[i].partie_reelle =
743: ((real8 *) tampon)[i];
744: ((struct_complexe16 *) (*((struct_vecteur *)
745: (*s_objet_3).objet)).tableau)[i]
746: .partie_imaginaire = (real8) 0;
747: }
748:
749: free((real8 *) tampon);
750:
751: ((struct_complexe16 *) (*((struct_vecteur *)
752: (*s_objet_3).objet)).tableau)[indice_i - 1]
753: .partie_reelle = (*((struct_complexe16 *)
754: (*s_objet_1).objet)).partie_reelle;
755: ((struct_complexe16 *) (*((struct_vecteur *)
756: (*s_objet_3).objet)).tableau)[indice_i - 1]
757: .partie_imaginaire = (*((struct_complexe16 *)
758: (*s_objet_1).objet)).partie_imaginaire;
759: }
760: else
761: {
762: liberation(s_etat_processus, s_objet_1);
763: liberation(s_etat_processus, s_objet_2);
764: liberation(s_etat_processus, s_objet_3);
765:
766: (*s_etat_processus).erreur_execution =
767: d_ex_erreur_type_argument;
768: return;
769: }
770: }
771: else
772: {
773: /*
774: * Vecteur de complexes
775: */
776:
777: if ((*s_objet_1).type == INT)
778: {
779: /*
780: * Conversion de l'élément à insérer en complexe
781: */
782:
783: ((struct_complexe16 *) (*((struct_vecteur *)
784: (*s_objet_3).objet)).tableau)[indice_i - 1]
785: .partie_reelle = (real8) (*((integer8 *)
786: (*s_objet_1).objet));
787: ((struct_complexe16 *) (*((struct_vecteur *)
788: (*s_objet_3).objet)).tableau)[indice_i - 1]
789: .partie_imaginaire = (real8) 0;
790: }
791: else if ((*s_objet_1).type == REL)
792: {
793: /*
794: * Conversion de l'élément à insérer en complexe
795: */
796:
797: ((struct_complexe16 *) (*((struct_vecteur *)
798: (*s_objet_3).objet)).tableau)[indice_i - 1]
799: .partie_reelle = (*((real8 *) (*s_objet_1).objet));
800: ((struct_complexe16 *) (*((struct_vecteur *)
801: (*s_objet_3).objet)).tableau)[indice_i - 1]
802: .partie_imaginaire = (real8) 0;
803: }
804: else if ((*s_objet_1).type == CPL)
805: {
806: /*
807: * Aucune conversion de type
808: */
809:
810: ((struct_complexe16 *) (*((struct_vecteur *)
811: (*s_objet_3).objet)).tableau)[indice_i - 1]
812: .partie_reelle = (*((struct_complexe16 *)
813: (*s_objet_1).objet)).partie_reelle;
814: ((struct_complexe16 *) (*((struct_vecteur *)
815: (*s_objet_3).objet)).tableau)[indice_i - 1]
816: .partie_imaginaire = (*((struct_complexe16 *)
817: (*s_objet_1).objet)).partie_imaginaire;
818: }
819: else
820: {
821: liberation(s_etat_processus, s_objet_1);
822: liberation(s_etat_processus, s_objet_2);
823: liberation(s_etat_processus, s_objet_3);
824:
825: (*s_etat_processus).erreur_execution =
826: d_ex_erreur_type_argument;
827: return;
828: }
829: }
830:
831: liberation(s_etat_processus, s_objet_1);
832: liberation(s_etat_processus, s_objet_2);
833:
834: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
835: s_objet_3) == d_erreur)
836: {
837: return;
838: }
839: }
840:
841: /*
842: --------------------------------------------------------------------------------
843: Traitement des éléments des matrices
844: --------------------------------------------------------------------------------
845: */
846:
847: else if (((*s_objet_3).type == MIN) ||
848: ((*s_objet_3).type == MRL) ||
849: ((*s_objet_3).type == MCX))
850: {
851: if ((*s_objet_2).type != LST)
852: {
853: liberation(s_etat_processus, s_objet_1);
854: liberation(s_etat_processus, s_objet_2);
855: liberation(s_etat_processus, s_objet_3);
856:
857: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
858: return;
859: }
860:
861: l_element_courant = (*s_objet_2).objet;
862: nombre_dimensions = 0;
863:
864: while(l_element_courant != NULL)
865: {
866: nombre_dimensions++;
867: l_element_courant = (*l_element_courant).suivant;
868: }
869:
870: if (nombre_dimensions != 2)
871: {
872: liberation(s_etat_processus, s_objet_1);
873: liberation(s_etat_processus, s_objet_2);
874: liberation(s_etat_processus, s_objet_3);
875:
876: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
877: return;
878: }
879:
880: l_element_courant = (*s_objet_2).objet;
881:
882: indice_i = 0;
883: indice_j = 0;
884:
885: while(l_element_courant != NULL)
886: {
887: if ((*(*l_element_courant).donnee).type != INT)
888: {
889: liberation(s_etat_processus, s_objet_1);
890: liberation(s_etat_processus, s_objet_2);
891: liberation(s_etat_processus, s_objet_3);
892:
893: (*s_etat_processus).erreur_execution =
894: d_ex_erreur_type_argument;
895: return;
896: }
897:
898: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
899: {
900: liberation(s_etat_processus, s_objet_1);
901: liberation(s_etat_processus, s_objet_2);
902: liberation(s_etat_processus, s_objet_3);
903:
904: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
905: return;
906: }
907:
908: if (indice_i == 0)
909: {
910: indice_i = (*((integer8 *)
911: (*(*l_element_courant).donnee).objet));
912: }
913: else
914: {
915: indice_j = (*((integer8 *)
916: (*(*l_element_courant).donnee).objet));
917: }
918:
919: l_element_courant = (*l_element_courant).suivant;
920: }
921:
922: if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet))
923: .nombre_lignes) || (indice_j > (*((struct_matrice *)
924: (*s_objet_3).objet)).nombre_colonnes))
925: {
926: liberation(s_etat_processus, s_objet_1);
927: liberation(s_etat_processus, s_objet_2);
928: liberation(s_etat_processus, s_objet_3);
929:
930: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
931: return;
932: }
933:
934: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL)
935: {
936: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
937: return;
938: }
939:
940: liberation(s_etat_processus, s_objet_3);
941: s_objet_3 = s_copie_3;
942:
943: if ((*s_objet_3).type == MIN)
944: {
945: /*
946: * Matrice d'entiers
947: */
948:
949: if ((*s_objet_1).type == INT)
950: {
951: /*
952: * Aucune conversion de type
953: */
954:
955: ((integer8 **) (*((struct_matrice *) (*s_objet_3).objet))
956: .tableau)[indice_i - 1][indice_j - 1] =
957: (*((integer8 *) (*s_objet_1).objet));
958: }
959: else if ((*s_objet_1).type == REL)
960: {
961: /*
962: * Conversion de la matrice en matrice réelle
963: */
964:
965: tampon = (void *) ((integer8 **) (*((struct_matrice *)
966: (*s_objet_3).objet)).tableau);
967:
968: (*((struct_matrice *) (*s_objet_3).objet)).type = 'R';
969: (*s_objet_3).type = MRL;
970:
971: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
972: = malloc((*((struct_matrice *)
973: (*s_objet_3).objet)).nombre_lignes * sizeof(real8 *)))
974: == NULL)
975: {
976: (*s_etat_processus).erreur_systeme =
977: d_es_allocation_memoire;
978: return;
979: }
980:
981: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
982: .nombre_lignes; i++)
983: {
984: if ((((real8 **) (*((struct_matrice *)
985: (*s_objet_3).objet)).tableau)[i]
986: = malloc((*((struct_matrice *)
987: (*s_objet_3).objet)).nombre_colonnes *
988: sizeof(real8))) == NULL)
989: {
990: (*s_etat_processus).erreur_systeme =
991: d_es_allocation_memoire;
992: return;
993: }
994:
995: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
996: .nombre_colonnes; j++)
997: {
998: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
999: .tableau)[i][j] = (real8) (((integer8 **)
1000: tampon)[i][j]);
1001: }
1002:
1003: free(((integer8 **) tampon)[i]);
1004: }
1005:
1006: free((integer8 **) tampon);
1007:
1008: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
1009: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *)
1010: (*s_objet_1).objet));
1011: }
1012: else if ((*s_objet_1).type == CPL)
1013: {
1014: /*
1015: * Conversion de la matrice en matrice complexe
1016: */
1017:
1018: tampon = (void *) ((integer8 **) (*((struct_matrice *)
1019: (*s_objet_3).objet)).tableau);
1020:
1021: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C';
1022: (*s_objet_3).type = MCX;
1023:
1024: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
1025: = malloc((*((struct_matrice *)
1026: (*s_objet_3).objet)).nombre_lignes *
1027: sizeof(struct_complexe16 *))) == NULL)
1028: {
1029: (*s_etat_processus).erreur_systeme =
1030: d_es_allocation_memoire;
1031: return;
1032: }
1033:
1034: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
1035: .nombre_lignes; i++)
1036: {
1037: if ((((struct_complexe16 **) (*((struct_matrice *)
1038: (*s_objet_3).objet)).tableau)[i]
1039: = malloc((*((struct_matrice *)
1040: (*s_objet_3).objet)).nombre_colonnes *
1041: sizeof(struct_complexe16))) == NULL)
1042: {
1043: (*s_etat_processus).erreur_systeme =
1044: d_es_allocation_memoire;
1045: return;
1046: }
1047:
1048: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
1049: .nombre_colonnes; j++)
1050: {
1051: ((struct_complexe16 **) (*((struct_matrice *)
1052: (*s_objet_3).objet)).tableau)[i][j]
1053: .partie_reelle = (real8) (((integer8 **)
1054: tampon)[i][j]);
1055: ((struct_complexe16 **) (*((struct_matrice *)
1056: (*s_objet_3).objet)).tableau)[i][j]
1057: .partie_imaginaire = (real8) 0;
1058: }
1059:
1060: free(((integer8 **) tampon)[i]);
1061: }
1062:
1063: free((integer8 **) tampon);
1064:
1065: ((struct_complexe16 **) (*((struct_matrice *)
1066: (*s_objet_3).objet)).tableau)[indice_i - 1]
1067: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
1068: (*s_objet_1).objet)).partie_reelle;
1069: ((struct_complexe16 **) (*((struct_matrice *)
1070: (*s_objet_3).objet)).tableau)[indice_i - 1]
1071: [indice_j - 1].partie_imaginaire =
1072: (*((struct_complexe16 *)
1073: (*s_objet_1).objet)).partie_imaginaire;
1074: }
1075: else
1076: {
1077: liberation(s_etat_processus, s_objet_1);
1078: liberation(s_etat_processus, s_objet_2);
1079: liberation(s_etat_processus, s_objet_3);
1080:
1081: (*s_etat_processus).erreur_execution =
1082: d_ex_erreur_type_argument;
1083: return;
1084: }
1085: }
1086: else if ((*s_objet_3).type == MRL)
1087: {
1088: /*
1089: * Matrice de réels
1090: */
1091:
1092: if ((*s_objet_1).type == INT)
1093: {
1094: /*
1095: * Conversion de l'élément à insérer en réel
1096: */
1097:
1098: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
1099: .tableau)[indice_i - 1][indice_j - 1] =
1100: (real8) (*((integer8 *) (*s_objet_1).objet));
1101: }
1102: else if ((*s_objet_1).type == REL)
1103: {
1104: /*
1105: * Aucune conversion de type
1106: */
1107:
1108: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
1109: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *)
1110: (*s_objet_1).objet));
1111: }
1112: else if ((*s_objet_1).type == CPL)
1113: {
1114: /*
1115: * Conversion de la matrice en matrice complexe
1116: */
1117:
1118: tampon = (void *) ((real8 **) (*((struct_matrice *)
1119: (*s_objet_3).objet)).tableau);
1120:
1121: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C';
1122: (*s_objet_3).type = MCX;
1123:
1124: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
1125: = malloc((*((struct_matrice *)
1126: (*s_objet_3).objet)).nombre_lignes *
1127: sizeof(struct_complexe16 *))) == NULL)
1128: {
1129: (*s_etat_processus).erreur_systeme =
1130: d_es_allocation_memoire;
1131: return;
1132: }
1133:
1134: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
1135: .nombre_lignes; i++)
1136: {
1137: if ((((struct_complexe16 **) (*((struct_matrice *)
1138: (*s_objet_3).objet)).tableau)[i]
1139: = malloc((*((struct_matrice *)
1140: (*s_objet_3).objet)).nombre_colonnes *
1141: sizeof(struct_complexe16))) == NULL)
1142: {
1143: (*s_etat_processus).erreur_systeme =
1144: d_es_allocation_memoire;
1145: return;
1146: }
1147:
1148: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
1149: .nombre_colonnes; j++)
1150: {
1151: ((struct_complexe16 **) (*((struct_matrice *)
1152: (*s_objet_3).objet)).tableau)[i][j]
1153: .partie_reelle = (((real8 **)
1154: tampon)[i][j]);
1155: ((struct_complexe16 **) (*((struct_matrice *)
1156: (*s_objet_3).objet)).tableau)[i][j]
1157: .partie_imaginaire = (real8) 0;
1158: }
1159:
1160: free(((integer8 **) tampon)[i]);
1161: }
1162:
1163: free((integer8 **) tampon);
1164:
1165: ((struct_complexe16 **) (*((struct_matrice *)
1166: (*s_objet_3).objet)).tableau)[indice_i - 1]
1167: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
1168: (*s_objet_1).objet)).partie_reelle;
1169: ((struct_complexe16 **) (*((struct_matrice *)
1170: (*s_objet_3).objet)).tableau)[indice_i - 1]
1171: [indice_j - 1].partie_imaginaire =
1172: (*((struct_complexe16 *)
1173: (*s_objet_1).objet)).partie_imaginaire;
1174: }
1175: else
1176: {
1177: liberation(s_etat_processus, s_objet_1);
1178: liberation(s_etat_processus, s_objet_2);
1179: liberation(s_etat_processus, s_objet_3);
1180:
1181: (*s_etat_processus).erreur_execution =
1182: d_ex_erreur_type_argument;
1183: return;
1184: }
1185: }
1186: else
1187: {
1188: /*
1189: * Matrice de complexes
1190: */
1191:
1192: if ((*s_objet_1).type == INT)
1193: {
1194: /*
1195: * Conversion de l'élément à insérer en complexe
1196: */
1197:
1198: ((struct_complexe16 **) (*((struct_matrice *)
1199: (*s_objet_3).objet)).tableau)[indice_i - 1]
1200: [indice_j - 1].partie_reelle = (real8) (*((integer8 *)
1201: (*s_objet_1).objet));
1202: ((struct_complexe16 **) (*((struct_matrice *)
1203: (*s_objet_3).objet)).tableau)[indice_i - 1]
1204: [indice_j - 1].partie_imaginaire = (real8) 0;
1205: }
1206: else if ((*s_objet_1).type == REL)
1207: {
1208: /*
1209: * Conversion de l'élément à insérer en complexe
1210: */
1211:
1212: ((struct_complexe16 **) (*((struct_matrice *)
1213: (*s_objet_3).objet)).tableau)[indice_i - 1]
1214: [indice_j - 1].partie_reelle =
1215: (*((real8 *) (*s_objet_1).objet));
1216: ((struct_complexe16 **) (*((struct_matrice *)
1217: (*s_objet_3).objet)).tableau)[indice_i - 1]
1218: [indice_j - 1].partie_imaginaire = (real8) 0;
1219: }
1220: else if ((*s_objet_1).type == CPL)
1221: {
1222: /*
1223: * Aucune conversion de type
1224: */
1225:
1226: ((struct_complexe16 **) (*((struct_matrice *)
1227: (*s_objet_3).objet)).tableau)[indice_i - 1]
1228: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
1229: (*s_objet_1).objet)).partie_reelle;
1230: ((struct_complexe16 **) (*((struct_matrice *)
1231: (*s_objet_3).objet)).tableau)[indice_i - 1]
1232: [indice_j - 1].partie_imaginaire =
1233: (*((struct_complexe16 *)
1234: (*s_objet_1).objet)).partie_imaginaire;
1235: }
1236: else
1237: {
1238: liberation(s_etat_processus, s_objet_1);
1239: liberation(s_etat_processus, s_objet_2);
1240: liberation(s_etat_processus, s_objet_3);
1241:
1242: (*s_etat_processus).erreur_execution =
1243: d_ex_erreur_type_argument;
1244: return;
1245: }
1246: }
1247:
1248: liberation(s_etat_processus, s_objet_1);
1249: liberation(s_etat_processus, s_objet_2);
1250:
1251: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1252: s_objet_3) == d_erreur)
1253: {
1254: return;
1255: }
1256: }
1257:
1258: /*
1259: --------------------------------------------------------------------------------
1260: Traitement des éléments des listes
1261: --------------------------------------------------------------------------------
1262: */
1263:
1264: else if ((*s_objet_3).type == LST)
1265: {
1266: if ((*s_objet_2).type != INT)
1267: {
1268: liberation(s_etat_processus, s_objet_1);
1269: liberation(s_etat_processus, s_objet_2);
1270: liberation(s_etat_processus, s_objet_3);
1271:
1272: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1273: return;
1274: }
1275:
1276: indice_i = (*((integer8 *) (*s_objet_2).objet));
1277: indice_j = 1;
1278:
1279: if ((*s_objet_3).nombre_occurrences > 1)
1280: {
1281: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'N'))
1282: == NULL)
1283: {
1284: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1285: return;
1286: }
1287:
1288: liberation(s_etat_processus, s_objet_3);
1289: s_objet_3 = s_copie_3;
1290: }
1291:
1292: l_element_courant = (*s_objet_3).objet;
1293:
1294: while((l_element_courant != NULL) && (indice_j != indice_i))
1295: {
1296: l_element_courant = (*l_element_courant).suivant;
1297: indice_j++;
1298: }
1299:
1300: if (l_element_courant != NULL)
1301: {
1302: liberation(s_etat_processus, (*l_element_courant).donnee);
1303: (*l_element_courant).donnee = s_objet_1;
1304: }
1305: else
1306: {
1307: liberation(s_etat_processus, s_objet_1);
1308: liberation(s_etat_processus, s_objet_2);
1309: liberation(s_etat_processus, s_objet_3);
1310:
1311: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1312: return;
1313: }
1314:
1315: liberation(s_etat_processus, s_objet_2);
1316:
1317: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1318: s_objet_3) == d_erreur)
1319: {
1320: return;
1321: }
1322: }
1323:
1324: /*
1325: --------------------------------------------------------------------------------
1326: Traitement des éléments des tables
1327: --------------------------------------------------------------------------------
1328: */
1329:
1330: else if ((*s_objet_3).type == TBL)
1331: {
1332: if ((*s_objet_2).type != LST)
1333: {
1334: liberation(s_etat_processus, s_objet_1);
1335: liberation(s_etat_processus, s_objet_2);
1336: liberation(s_etat_processus, s_objet_3);
1337:
1338: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1339: return;
1340: }
1341:
1342: if ((*s_objet_3).nombre_occurrences > 1)
1343: {
1344: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'N'))
1345: == NULL)
1346: {
1347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1348: return;
1349: }
1350:
1351: liberation(s_etat_processus, s_objet_3);
1352: s_objet_3 = s_copie_3;
1353: }
1354:
1355: s_objet_element = s_objet_3;
1356: l_element_courant = (*s_objet_2).objet;
1357: indice_i = 0;
1358:
1359: while(l_element_courant != NULL)
1360: {
1361: if ((*(*l_element_courant).donnee).type != INT)
1362: {
1363: liberation(s_etat_processus, s_objet_1);
1364: liberation(s_etat_processus, s_objet_2);
1365: liberation(s_etat_processus, s_objet_3);
1366:
1367: (*s_etat_processus).erreur_execution =
1368: d_ex_erreur_type_argument;
1369: return;
1370: }
1371:
1372: if ((*s_objet_element).type != TBL)
1373: {
1374: liberation(s_etat_processus, s_objet_1);
1375: liberation(s_etat_processus, s_objet_2);
1376: liberation(s_etat_processus, s_objet_3);
1377:
1378: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1379: return;
1380: }
1381:
1382: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
1383:
1384: if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
1385: (*s_objet_element).objet)).nombre_elements))
1386: {
1387: liberation(s_etat_processus, s_objet_1);
1388: liberation(s_etat_processus, s_objet_2);
1389: liberation(s_etat_processus, s_objet_3);
1390:
1391: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1392: return;
1393: }
1394:
1395: if ((*l_element_courant).suivant != NULL)
1396: {
1397: s_objet_element = (*((struct_tableau *) (*s_objet_element)
1398: .objet)).elements[indice_i - 1];
1399: }
1400:
1401: l_element_courant = (*l_element_courant).suivant;
1402: }
1403:
1404: liberation(s_etat_processus, (*((struct_tableau *)
1405: (*s_objet_element).objet)).elements[indice_i - 1]);
1406: (*((struct_tableau *) (*s_objet_element).objet)).elements[indice_i - 1]
1407: = s_objet_1;
1408:
1409: liberation(s_etat_processus, s_objet_2);
1410:
1411: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1412: s_objet_3) == d_erreur)
1413: {
1414: return;
1415: }
1416: }
1417:
1418: /*
1419: --------------------------------------------------------------------------------
1420: Traitement des noms
1421: --------------------------------------------------------------------------------
1422: */
1423:
1424: else if ((*s_objet_3).type == NOM)
1425: {
1426: variable_partagee = d_faux;
1427:
1428: if (recherche_variable(s_etat_processus, (*((struct_nom *)
1429: (*s_objet_3).objet)).nom) == d_faux)
1430: {
1431: (*s_etat_processus).erreur_systeme = d_es;
1432: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1433:
1434: liberation(s_etat_processus, s_objet_1);
1435: liberation(s_etat_processus, s_objet_2);
1436: liberation(s_etat_processus, s_objet_3);
1437:
1438: return;
1439: }
1440:
1441: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
1442: .position_variable_courante].variable_verrouillee == d_vrai)
1443: {
1444: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
1445:
1446: liberation(s_etat_processus, s_objet_1);
1447: liberation(s_etat_processus, s_objet_2);
1448: liberation(s_etat_processus, s_objet_3);
1449:
1450: return;
1451: }
1452:
1453: s_objet_4 = (*s_etat_processus).s_liste_variables
1454: [(*s_etat_processus).position_variable_courante].objet;
1455:
1456: if (s_objet_4 == NULL)
1457: {
1458: if (pthread_mutex_lock(&((*(*s_etat_processus)
1459: .s_liste_variables_partagees).mutex)) != 0)
1460: {
1461: (*s_etat_processus).erreur_systeme = d_es_processus;
1462: return;
1463: }
1464:
1465: if (recherche_variable_partagee(s_etat_processus,
1466: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1467: .position_variable_courante].nom,
1468: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1469: .position_variable_courante].variable_partagee,
1470: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1471: .position_variable_courante].origine) == d_faux)
1472: {
1473: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1474: .s_liste_variables_partagees).mutex)) != 0)
1475: {
1476: (*s_etat_processus).erreur_systeme = d_es_processus;
1477: return;
1478: }
1479:
1480: (*s_etat_processus).erreur_systeme = d_es;
1481: (*s_etat_processus).erreur_execution =
1482: d_ex_variable_non_definie;
1483:
1484: liberation(s_etat_processus, s_objet_1);
1485: liberation(s_etat_processus, s_objet_2);
1486: liberation(s_etat_processus, s_objet_3);
1487:
1488: return;
1489: }
1490:
1491: s_objet_4 = (*(*s_etat_processus).s_liste_variables_partagees)
1492: .table[(*(*s_etat_processus).s_liste_variables_partagees)
1493: .position_variable].objet;
1494: variable_partagee = d_vrai;
1495: }
1496:
1497: if (((*s_objet_4).type == VIN) ||
1498: ((*s_objet_4).type == VRL) ||
1499: ((*s_objet_4).type == VCX))
1500: {
1501: if ((*s_objet_2).type != LST)
1502: {
1503: if (variable_partagee == d_vrai)
1504: {
1505: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1506: .s_liste_variables_partagees).mutex)) != 0)
1507: {
1508: (*s_etat_processus).erreur_systeme = d_es_processus;
1509: return;
1510: }
1511: }
1512:
1513: liberation(s_etat_processus, s_objet_1);
1514: liberation(s_etat_processus, s_objet_2);
1515: liberation(s_etat_processus, s_objet_3);
1516:
1517: (*s_etat_processus).erreur_execution =
1518: d_ex_erreur_type_argument;
1519: return;
1520: }
1521:
1522: l_element_courant = (*s_objet_2).objet;
1523: nombre_dimensions = 0;
1524:
1525: while(l_element_courant != NULL)
1526: {
1527: nombre_dimensions++;
1528: l_element_courant = (*l_element_courant).suivant;
1529: }
1530:
1531: if (nombre_dimensions != 1)
1532: {
1533: if (variable_partagee == d_vrai)
1534: {
1535: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1536: .s_liste_variables_partagees).mutex)) != 0)
1537: {
1538: (*s_etat_processus).erreur_systeme = d_es_processus;
1539: return;
1540: }
1541: }
1542:
1543: liberation(s_etat_processus, s_objet_1);
1544: liberation(s_etat_processus, s_objet_2);
1545: liberation(s_etat_processus, s_objet_3);
1546:
1547: (*s_etat_processus).erreur_execution =
1548: d_ex_dimensions_invalides;
1549: return;
1550: }
1551:
1552: l_element_courant = (*s_objet_2).objet;
1553:
1554: if ((*(*l_element_courant).donnee).type != INT)
1555: {
1556: if (variable_partagee == d_vrai)
1557: {
1558: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1559: .s_liste_variables_partagees).mutex)) != 0)
1560: {
1561: (*s_etat_processus).erreur_systeme = d_es_processus;
1562: return;
1563: }
1564: }
1565:
1566: liberation(s_etat_processus, s_objet_1);
1567: liberation(s_etat_processus, s_objet_2);
1568: liberation(s_etat_processus, s_objet_3);
1569:
1570: (*s_etat_processus).erreur_execution =
1571: d_ex_erreur_type_argument;
1572: return;
1573: }
1574:
1575: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
1576: {
1577: if (variable_partagee == d_vrai)
1578: {
1579: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1580: .s_liste_variables_partagees).mutex)) != 0)
1581: {
1582: (*s_etat_processus).erreur_systeme = d_es_processus;
1583: return;
1584: }
1585: }
1586:
1587: liberation(s_etat_processus, s_objet_1);
1588: liberation(s_etat_processus, s_objet_2);
1589: liberation(s_etat_processus, s_objet_3);
1590:
1591: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1592: return;
1593: }
1594: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
1595: (integer8) (*((struct_vecteur *) (*s_objet_4).objet))
1596: .taille)
1597: {
1598: if (variable_partagee == d_vrai)
1599: {
1600: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1601: .s_liste_variables_partagees).mutex)) != 0)
1602: {
1603: (*s_etat_processus).erreur_systeme = d_es_processus;
1604: return;
1605: }
1606: }
1607:
1608: liberation(s_etat_processus, s_objet_1);
1609: liberation(s_etat_processus, s_objet_2);
1610: liberation(s_etat_processus, s_objet_3);
1611:
1612: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1613: return;
1614: }
1615:
1616: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
1617:
1618: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q'))
1619: == NULL)
1620: {
1621: if (variable_partagee == d_vrai)
1622: {
1623: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1624: .s_liste_variables_partagees).mutex)) != 0)
1625: {
1626: (*s_etat_processus).erreur_systeme = d_es_processus;
1627: return;
1628: }
1629: }
1630:
1631: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1632: return;
1633: }
1634:
1635: liberation(s_etat_processus, s_objet_4);
1636: s_objet_4 = s_copie_4;
1637:
1638: if ((*s_objet_4).type == VIN)
1639: {
1640: /*
1641: * Vecteur d'entiers
1642: */
1643:
1644: if ((*s_objet_1).type == INT)
1645: {
1646: /*
1647: * Aucune conversion de type
1648: */
1649:
1650: ((integer8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1651: .tableau)[indice_i - 1] = (*((integer8 *)
1652: (*s_objet_1).objet));
1653: }
1654: else if ((*s_objet_1).type == REL)
1655: {
1656: /*
1657: * Conversion du vecteur en vecteur réel
1658: */
1659:
1660: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
1661: (*s_objet_4).objet)).tableau);
1662:
1663: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'R';
1664: (*s_objet_4).type = VRL;
1665:
1666: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
1667: = malloc((*((struct_vecteur *)
1668: (*s_objet_4).objet)).taille * sizeof(real8)))
1669: == NULL)
1670: {
1671: if (variable_partagee == d_vrai)
1672: {
1673: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1674: .s_liste_variables_partagees).mutex)) != 0)
1675: {
1676: (*s_etat_processus).erreur_systeme =
1677: d_es_processus;
1678: return;
1679: }
1680: }
1681:
1682: (*s_etat_processus).erreur_systeme =
1683: d_es_allocation_memoire;
1684: return;
1685: }
1686:
1687: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
1688: .taille; i++)
1689: {
1690: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1691: .tableau)[i] = (real8) (((integer8 *)
1692: tampon)[i]);
1693: }
1694:
1695: free((integer8 *) tampon);
1696:
1697: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1698: .tableau)[indice_i - 1] = (*((real8 *)
1699: (*s_objet_1).objet));
1700: }
1701: else if ((*s_objet_1).type == CPL)
1702: {
1703: /*
1704: * Conversion du vecteur en vecteur complexe
1705: */
1706:
1707: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
1708: (*s_objet_4).objet)).tableau);
1709:
1710: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C';
1711: (*s_objet_4).type = VCX;
1712:
1713: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
1714: = malloc((*((struct_vecteur *)
1715: (*s_objet_4).objet)).taille *
1716: sizeof(struct_complexe16))) == NULL)
1717: {
1718: if (variable_partagee == d_vrai)
1719: {
1720: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1721: .s_liste_variables_partagees).mutex)) != 0)
1722: {
1723: (*s_etat_processus).erreur_systeme =
1724: d_es_processus;
1725: return;
1726: }
1727: }
1728:
1729: (*s_etat_processus).erreur_systeme =
1730: d_es_allocation_memoire;
1731: return;
1732: }
1733:
1734: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
1735: .taille; i++)
1736: {
1737: ((struct_complexe16 *) (*((struct_vecteur *)
1738: (*s_objet_4).objet)).tableau)[i].partie_reelle =
1739: (real8) (((integer8 *) tampon)[i]);
1740: ((struct_complexe16 *) (*((struct_vecteur *)
1741: (*s_objet_4).objet)).tableau)[i]
1742: .partie_imaginaire = (real8) 0;
1743: }
1744:
1745: free((integer8 *) tampon);
1746:
1747: ((struct_complexe16 *) (*((struct_vecteur *)
1748: (*s_objet_4).objet)).tableau)[indice_i - 1]
1749: .partie_reelle = (*((struct_complexe16 *)
1750: (*s_objet_1).objet)).partie_reelle;
1751: ((struct_complexe16 *) (*((struct_vecteur *)
1752: (*s_objet_4).objet)).tableau)[indice_i - 1]
1753: .partie_imaginaire = (*((struct_complexe16 *)
1754: (*s_objet_1).objet)).partie_imaginaire;
1755: }
1756: else
1757: {
1758: if (variable_partagee == d_vrai)
1759: {
1760: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1761: .s_liste_variables_partagees).mutex)) != 0)
1762: {
1763: (*s_etat_processus).erreur_systeme =
1764: d_es_processus;
1765: return;
1766: }
1767: }
1768:
1769: liberation(s_etat_processus, s_objet_1);
1770: liberation(s_etat_processus, s_objet_2);
1771: liberation(s_etat_processus, s_objet_3);
1772:
1773: (*s_etat_processus).erreur_execution =
1774: d_ex_erreur_type_argument;
1775: return;
1776: }
1777: }
1778: else if ((*s_objet_4).type == VRL)
1779: {
1780: /*
1781: * Vecteur de réels
1782: */
1783:
1784: if ((*s_objet_1).type == INT)
1785: {
1786: /*
1787: * Conversion de l'élément à insérer en réel
1788: */
1789:
1790: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1791: .tableau)[indice_i - 1] = (real8) (*((integer8 *)
1792: (*s_objet_1).objet));
1793: }
1794: else if ((*s_objet_1).type == REL)
1795: {
1796: /*
1797: * Aucune conversion de type
1798: */
1799:
1800: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1801: .tableau)[indice_i - 1] = (*((real8 *)
1802: (*s_objet_1).objet));
1803: }
1804: else if ((*s_objet_1).type == CPL)
1805: {
1806: /*
1807: * Conversion du vecteur en vecteur complexe
1808: */
1809:
1810: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
1811: (*s_objet_4).objet)).tableau);
1812:
1813: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C';
1814: (*s_objet_4).type = VCX;
1815:
1816: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
1817: = malloc((*((struct_vecteur *)
1818: (*s_objet_4).objet)).taille *
1819: sizeof(struct_complexe16))) == NULL)
1820: {
1821: if (variable_partagee == d_vrai)
1822: {
1823: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1824: .s_liste_variables_partagees).mutex)) != 0)
1825: {
1826: (*s_etat_processus).erreur_systeme =
1827: d_es_processus;
1828: return;
1829: }
1830: }
1831:
1832: (*s_etat_processus).erreur_systeme =
1833: d_es_allocation_memoire;
1834: return;
1835: }
1836:
1837: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
1838: .taille; i++)
1839: {
1840: ((struct_complexe16 *) (*((struct_vecteur *)
1841: (*s_objet_4).objet)).tableau)[i].partie_reelle =
1842: ((real8 *) tampon)[i];
1843: ((struct_complexe16 *) (*((struct_vecteur *)
1844: (*s_objet_4).objet)).tableau)[i]
1845: .partie_imaginaire = (real8) 0;
1846: }
1847:
1848: free((real8 *) tampon);
1849:
1850: ((struct_complexe16 *) (*((struct_vecteur *)
1851: (*s_objet_4).objet)).tableau)[indice_i - 1]
1852: .partie_reelle = (*((struct_complexe16 *)
1853: (*s_objet_1).objet)).partie_reelle;
1854: ((struct_complexe16 *) (*((struct_vecteur *)
1855: (*s_objet_4).objet)).tableau)[indice_i - 1]
1856: .partie_imaginaire = (*((struct_complexe16 *)
1857: (*s_objet_1).objet)).partie_imaginaire;
1858: }
1859: else
1860: {
1861: if (variable_partagee == d_vrai)
1862: {
1863: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1864: .s_liste_variables_partagees).mutex)) != 0)
1865: {
1866: (*s_etat_processus).erreur_systeme =
1867: d_es_processus;
1868: return;
1869: }
1870: }
1871:
1872: liberation(s_etat_processus, s_objet_1);
1873: liberation(s_etat_processus, s_objet_2);
1874: liberation(s_etat_processus, s_objet_3);
1875:
1876: (*s_etat_processus).erreur_execution =
1877: d_ex_erreur_type_argument;
1878: return;
1879: }
1880: }
1881: else
1882: {
1883: /*
1884: * Vecteur de complexes
1885: */
1886:
1887: if ((*s_objet_1).type == INT)
1888: {
1889: /*
1890: * Conversion de l'élément à insérer en complexe
1891: */
1892:
1893: ((struct_complexe16 *) (*((struct_vecteur *)
1894: (*s_objet_4).objet)).tableau)[indice_i - 1]
1895: .partie_reelle = (real8) (*((integer8 *)
1896: (*s_objet_1).objet));
1897: ((struct_complexe16 *) (*((struct_vecteur *)
1898: (*s_objet_4).objet)).tableau)[indice_i - 1]
1899: .partie_imaginaire = (real8) 0;
1900: }
1901: else if ((*s_objet_1).type == REL)
1902: {
1903: /*
1904: * Conversion de l'élément à insérer en complexe
1905: */
1906:
1907: ((struct_complexe16 *) (*((struct_vecteur *)
1908: (*s_objet_4).objet)).tableau)[indice_i - 1]
1909: .partie_reelle = (*((real8 *) (*s_objet_1).objet));
1910: ((struct_complexe16 *) (*((struct_vecteur *)
1911: (*s_objet_4).objet)).tableau)[indice_i - 1]
1912: .partie_imaginaire = (real8) 0;
1913: }
1914: else if ((*s_objet_1).type == CPL)
1915: {
1916: /*
1917: * Aucune conversion de type
1918: */
1919:
1920: ((struct_complexe16 *) (*((struct_vecteur *)
1921: (*s_objet_4).objet)).tableau)[indice_i - 1]
1922: .partie_reelle = (*((struct_complexe16 *)
1923: (*s_objet_1).objet)).partie_reelle;
1924: ((struct_complexe16 *) (*((struct_vecteur *)
1925: (*s_objet_4).objet)).tableau)[indice_i - 1]
1926: .partie_imaginaire = (*((struct_complexe16 *)
1927: (*s_objet_1).objet)).partie_imaginaire;
1928: }
1929: else
1930: {
1931: if (variable_partagee == d_vrai)
1932: {
1933: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1934: .s_liste_variables_partagees).mutex)) != 0)
1935: {
1936: (*s_etat_processus).erreur_systeme =
1937: d_es_processus;
1938: return;
1939: }
1940: }
1941:
1942: liberation(s_etat_processus, s_objet_1);
1943: liberation(s_etat_processus, s_objet_2);
1944: liberation(s_etat_processus, s_objet_3);
1945:
1946: (*s_etat_processus).erreur_execution =
1947: d_ex_erreur_type_argument;
1948: return;
1949: }
1950: }
1951:
1952: if (variable_partagee == d_faux)
1953: {
1954: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1955: .position_variable_courante].objet = s_objet_4;
1956: }
1957: else
1958: {
1959: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1960: .position_variable_courante].objet = NULL;
1961: (*(*s_etat_processus).s_liste_variables_partagees).table
1962: [(*(*s_etat_processus).s_liste_variables_partagees)
1963: .position_variable].objet = s_objet_4;
1964:
1965: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1966: .s_liste_variables_partagees).mutex)) != 0)
1967: {
1968: (*s_etat_processus).erreur_systeme = d_es_processus;
1969: return;
1970: }
1971: }
1972:
1973: liberation(s_etat_processus, s_objet_1);
1974: liberation(s_etat_processus, s_objet_2);
1975: liberation(s_etat_processus, s_objet_3);
1976: }
1977: else if (((*s_objet_4).type == MIN) ||
1978: ((*s_objet_4).type == MRL) ||
1979: ((*s_objet_4).type == MCX))
1980: {
1981: if ((*s_objet_2).type != LST)
1982: {
1983: if (variable_partagee == d_vrai)
1984: {
1985: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1986: .s_liste_variables_partagees).mutex)) != 0)
1987: {
1988: (*s_etat_processus).erreur_systeme = d_es_processus;
1989: return;
1990: }
1991: }
1992:
1993: liberation(s_etat_processus, s_objet_1);
1994: liberation(s_etat_processus, s_objet_2);
1995: liberation(s_etat_processus, s_objet_3);
1996:
1997: (*s_etat_processus).erreur_execution =
1998: d_ex_erreur_type_argument;
1999: return;
2000: }
2001:
2002: l_element_courant = (*s_objet_2).objet;
2003: nombre_dimensions = 0;
2004:
2005: while(l_element_courant != NULL)
2006: {
2007: nombre_dimensions++;
2008: l_element_courant = (*l_element_courant).suivant;
2009: }
2010:
2011: if (nombre_dimensions != 2)
2012: {
2013: if (variable_partagee == d_vrai)
2014: {
2015: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2016: .s_liste_variables_partagees).mutex)) != 0)
2017: {
2018: (*s_etat_processus).erreur_systeme = d_es_processus;
2019: return;
2020: }
2021: }
2022:
2023: liberation(s_etat_processus, s_objet_1);
2024: liberation(s_etat_processus, s_objet_2);
2025: liberation(s_etat_processus, s_objet_3);
2026:
2027: (*s_etat_processus).erreur_execution =
2028: d_ex_dimensions_invalides;
2029: return;
2030: }
2031:
2032: l_element_courant = (*s_objet_2).objet;
2033:
2034: indice_i = 0;
2035: indice_j = 0;
2036:
2037: while(l_element_courant != NULL)
2038: {
2039: if ((*(*l_element_courant).donnee).type != INT)
2040: {
2041: if (variable_partagee == d_vrai)
2042: {
2043: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2044: .s_liste_variables_partagees).mutex)) != 0)
2045: {
2046: (*s_etat_processus).erreur_systeme = d_es_processus;
2047: return;
2048: }
2049: }
2050:
2051: liberation(s_etat_processus, s_objet_1);
2052: liberation(s_etat_processus, s_objet_2);
2053: liberation(s_etat_processus, s_objet_3);
2054:
2055: (*s_etat_processus).erreur_execution =
2056: d_ex_erreur_type_argument;
2057: return;
2058: }
2059:
2060: if ((*((integer8 *) (*(*l_element_courant).donnee).objet))
2061: <= 0)
2062: {
2063: if (variable_partagee == d_vrai)
2064: {
2065: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2066: .s_liste_variables_partagees).mutex)) != 0)
2067: {
2068: (*s_etat_processus).erreur_systeme = d_es_processus;
2069: return;
2070: }
2071: }
2072:
2073: liberation(s_etat_processus, s_objet_1);
2074: liberation(s_etat_processus, s_objet_2);
2075: liberation(s_etat_processus, s_objet_3);
2076:
2077: (*s_etat_processus).erreur_execution =
2078: d_ex_argument_invalide;
2079: return;
2080: }
2081:
2082: if (indice_i == 0)
2083: {
2084: indice_i = (*((integer8 *)
2085: (*(*l_element_courant).donnee).objet));
2086: }
2087: else
2088: {
2089: indice_j = (*((integer8 *)
2090: (*(*l_element_courant).donnee).objet));
2091: }
2092:
2093: l_element_courant = (*l_element_courant).suivant;
2094: }
2095:
2096: if ((indice_i > (*((struct_matrice *) (*s_objet_4).objet))
2097: .nombre_lignes) || (indice_j > (*((struct_matrice *)
2098: (*s_objet_4).objet)).nombre_colonnes))
2099: {
2100: if (variable_partagee == d_vrai)
2101: {
2102: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2103: .s_liste_variables_partagees).mutex)) != 0)
2104: {
2105: (*s_etat_processus).erreur_systeme = d_es_processus;
2106: return;
2107: }
2108: }
2109:
2110: liberation(s_etat_processus, s_objet_1);
2111: liberation(s_etat_processus, s_objet_2);
2112: liberation(s_etat_processus, s_objet_3);
2113:
2114: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
2115: return;
2116: }
2117:
2118: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q'))
2119: == NULL)
2120: {
2121: if (variable_partagee == d_vrai)
2122: {
2123: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2124: .s_liste_variables_partagees).mutex)) != 0)
2125: {
2126: (*s_etat_processus).erreur_systeme = d_es_processus;
2127: return;
2128: }
2129: }
2130:
2131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2132: return;
2133: }
2134:
2135: liberation(s_etat_processus, s_objet_4);
2136: s_objet_4 = s_copie_4;
2137:
2138: if ((*s_objet_4).type == MIN)
2139: {
2140: /*
2141: * Matrice d'entiers
2142: */
2143:
2144: if ((*s_objet_1).type == INT)
2145: {
2146: /*
2147: * Aucune conversion de type
2148: */
2149:
2150: ((integer8 **) (*((struct_matrice *) (*s_objet_4).objet))
2151: .tableau)[indice_i - 1][indice_j - 1] =
2152: (*((integer8 *) (*s_objet_1).objet));
2153: }
2154: else if ((*s_objet_1).type == REL)
2155: {
2156: /*
2157: * Conversion de la matrice en matrice réelle
2158: */
2159:
2160: tampon = (void *) ((integer8 **) (*((struct_matrice *)
2161: (*s_objet_4).objet)).tableau);
2162:
2163: (*((struct_matrice *) (*s_objet_4).objet)).type = 'R';
2164: (*s_objet_4).type = MRL;
2165:
2166: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
2167: = malloc((*((struct_matrice *)
2168: (*s_objet_4).objet)).nombre_lignes *
2169: sizeof(real8 *))) == NULL)
2170: {
2171: if (variable_partagee == d_vrai)
2172: {
2173: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2174: .s_liste_variables_partagees).mutex)) != 0)
2175: {
2176: (*s_etat_processus).erreur_systeme =
2177: d_es_processus;
2178: return;
2179: }
2180: }
2181:
2182: (*s_etat_processus).erreur_systeme =
2183: d_es_allocation_memoire;
2184: return;
2185: }
2186:
2187: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
2188: .nombre_lignes; i++)
2189: {
2190: if ((((real8 **) (*((struct_matrice *)
2191: (*s_objet_4).objet)).tableau)[i]
2192: = malloc((*((struct_matrice *)
2193: (*s_objet_4).objet)).nombre_colonnes *
2194: sizeof(real8))) == NULL)
2195: {
2196: if (variable_partagee == d_vrai)
2197: {
2198: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2199: .s_liste_variables_partagees).mutex))
2200: != 0)
2201: {
2202: (*s_etat_processus).erreur_systeme =
2203: d_es_processus;
2204: return;
2205: }
2206: }
2207:
2208: (*s_etat_processus).erreur_systeme =
2209: d_es_allocation_memoire;
2210: return;
2211: }
2212:
2213: for(j = 0; j < (*((struct_matrice *)
2214: (*s_objet_4).objet)).nombre_colonnes; j++)
2215: {
2216: ((real8 **) (*((struct_matrice *) (*s_objet_4)
2217: .objet)).tableau)[i][j] = (real8)
2218: (((integer8 **) tampon)[i][j]);
2219: }
2220:
2221: free(((integer8 **) tampon)[i]);
2222: }
2223:
2224: free((integer8 **) tampon);
2225:
2226: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
2227: .tableau)[indice_i - 1][indice_j - 1] =
2228: (*((real8 *) (*s_objet_1).objet));
2229: }
2230: else if ((*s_objet_1).type == CPL)
2231: {
2232: /*
2233: * Conversion de la matrice en matrice complexe
2234: */
2235:
2236: tampon = (void *) ((integer8 **) (*((struct_matrice *)
2237: (*s_objet_4).objet)).tableau);
2238:
2239: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C';
2240: (*s_objet_4).type = MCX;
2241:
2242: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
2243: = malloc((*((struct_matrice *)
2244: (*s_objet_4).objet)).nombre_lignes *
2245: sizeof(struct_complexe16 *))) == NULL)
2246: {
2247: if (variable_partagee == d_vrai)
2248: {
2249: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2250: .s_liste_variables_partagees).mutex)) != 0)
2251: {
2252: (*s_etat_processus).erreur_systeme =
2253: d_es_processus;
2254: return;
2255: }
2256: }
2257:
2258: (*s_etat_processus).erreur_systeme =
2259: d_es_allocation_memoire;
2260: return;
2261: }
2262:
2263: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
2264: .nombre_lignes; i++)
2265: {
2266: if ((((struct_complexe16 **) (*((struct_matrice *)
2267: (*s_objet_4).objet)).tableau)[i]
2268: = malloc((*((struct_matrice *)
2269: (*s_objet_4).objet)).nombre_colonnes *
2270: sizeof(struct_complexe16))) == NULL)
2271: {
2272: if (variable_partagee == d_vrai)
2273: {
2274: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2275: .s_liste_variables_partagees).mutex))
2276: != 0)
2277: {
2278: (*s_etat_processus).erreur_systeme =
2279: d_es_processus;
2280: return;
2281: }
2282: }
2283:
2284: (*s_etat_processus).erreur_systeme =
2285: d_es_allocation_memoire;
2286: return;
2287: }
2288:
2289: for(j = 0; j < (*((struct_matrice *)
2290: (*s_objet_4).objet)).nombre_colonnes; j++)
2291: {
2292: ((struct_complexe16 **) (*((struct_matrice *)
2293: (*s_objet_4).objet)).tableau)[i][j]
2294: .partie_reelle = (real8) (((integer8 **)
2295: tampon)[i][j]);
2296: ((struct_complexe16 **) (*((struct_matrice *)
2297: (*s_objet_4).objet)).tableau)[i][j]
2298: .partie_imaginaire = (real8) 0;
2299: }
2300:
2301: free(((integer8 **) tampon)[i]);
2302: }
2303:
2304: free((integer8 **) tampon);
2305:
2306: ((struct_complexe16 **) (*((struct_matrice *)
2307: (*s_objet_4).objet)).tableau)[indice_i - 1]
2308: [indice_j - 1].partie_reelle =
2309: (*((struct_complexe16 *)
2310: (*s_objet_1).objet)).partie_reelle;
2311: ((struct_complexe16 **) (*((struct_matrice *)
2312: (*s_objet_4).objet)).tableau)[indice_i - 1]
2313: [indice_j - 1].partie_imaginaire =
2314: (*((struct_complexe16 *)
2315: (*s_objet_1).objet)).partie_imaginaire;
2316: }
2317: else
2318: {
2319: if (variable_partagee == d_vrai)
2320: {
2321: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2322: .s_liste_variables_partagees).mutex)) != 0)
2323: {
2324: (*s_etat_processus).erreur_systeme =
2325: d_es_processus;
2326: return;
2327: }
2328: }
2329:
2330: liberation(s_etat_processus, s_objet_1);
2331: liberation(s_etat_processus, s_objet_2);
2332: liberation(s_etat_processus, s_objet_3);
2333:
2334: (*s_etat_processus).erreur_execution =
2335: d_ex_erreur_type_argument;
2336: return;
2337: }
2338: }
2339: else if ((*s_objet_4).type == MRL)
2340: {
2341: /*
2342: * Matrice de réels
2343: */
2344:
2345: if ((*s_objet_1).type == INT)
2346: {
2347: /*
2348: * Conversion de l'élément à insérer en réel
2349: */
2350:
2351: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
2352: .tableau)[indice_i - 1][indice_j - 1] =
2353: (real8) (*((integer8 *) (*s_objet_1).objet));
2354: }
2355: else if ((*s_objet_1).type == REL)
2356: {
2357: /*
2358: * Aucune conversion de type
2359: */
2360:
2361: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
2362: .tableau)[indice_i - 1][indice_j - 1] =
2363: (*((real8 *) (*s_objet_1).objet));
2364: }
2365: else if ((*s_objet_1).type == CPL)
2366: {
2367: /*
2368: * Conversion de la matrice en matrice complexe
2369: */
2370:
2371: tampon = (void *) ((real8 **) (*((struct_matrice *)
2372: (*s_objet_4).objet)).tableau);
2373:
2374: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C';
2375: (*s_objet_4).type = MCX;
2376:
2377: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
2378: = malloc((*((struct_matrice *)
2379: (*s_objet_4).objet)).nombre_lignes *
2380: sizeof(struct_complexe16 *))) == NULL)
2381: {
2382: if (variable_partagee == d_vrai)
2383: {
2384: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2385: .s_liste_variables_partagees).mutex))
2386: != 0)
2387: {
2388: (*s_etat_processus).erreur_systeme =
2389: d_es_processus;
2390: return;
2391: }
2392: }
2393:
2394: (*s_etat_processus).erreur_systeme =
2395: d_es_allocation_memoire;
2396: return;
2397: }
2398:
2399: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
2400: .nombre_lignes; i++)
2401: {
2402: if ((((struct_complexe16 **) (*((struct_matrice *)
2403: (*s_objet_4).objet)).tableau)[i]
2404: = malloc((*((struct_matrice *)
2405: (*s_objet_4).objet)).nombre_colonnes *
2406: sizeof(struct_complexe16))) == NULL)
2407: {
2408: if (variable_partagee == d_vrai)
2409: {
2410: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2411: .s_liste_variables_partagees).mutex))
2412: != 0)
2413: {
2414: (*s_etat_processus).erreur_systeme =
2415: d_es_processus;
2416: return;
2417: }
2418: }
2419:
2420: (*s_etat_processus).erreur_systeme =
2421: d_es_allocation_memoire;
2422: return;
2423: }
2424:
2425: for(j = 0; j < (*((struct_matrice *)
2426: (*s_objet_4).objet)).nombre_colonnes; j++)
2427: {
2428: ((struct_complexe16 **) (*((struct_matrice *)
2429: (*s_objet_4).objet)).tableau)[i][j]
2430: .partie_reelle = (((real8 **)
2431: tampon)[i][j]);
2432: ((struct_complexe16 **) (*((struct_matrice *)
2433: (*s_objet_4).objet)).tableau)[i][j]
2434: .partie_imaginaire = (real8) 0;
2435: }
2436:
2437: free(((integer8 **) tampon)[i]);
2438: }
2439:
2440: free((integer8 **) tampon);
2441:
2442: ((struct_complexe16 **) (*((struct_matrice *)
2443: (*s_objet_4).objet)).tableau)[indice_i - 1]
2444: [indice_j - 1].partie_reelle =
2445: (*((struct_complexe16 *)
2446: (*s_objet_1).objet)).partie_reelle;
2447: ((struct_complexe16 **) (*((struct_matrice *)
2448: (*s_objet_4).objet)).tableau)[indice_i - 1]
2449: [indice_j - 1].partie_imaginaire =
2450: (*((struct_complexe16 *)
2451: (*s_objet_1).objet)).partie_imaginaire;
2452: }
2453: else
2454: {
2455: if (variable_partagee == d_vrai)
2456: {
2457: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2458: .s_liste_variables_partagees).mutex)) != 0)
2459: {
2460: (*s_etat_processus).erreur_systeme =
2461: d_es_processus;
2462: return;
2463: }
2464: }
2465:
2466: liberation(s_etat_processus, s_objet_1);
2467: liberation(s_etat_processus, s_objet_2);
2468: liberation(s_etat_processus, s_objet_3);
2469:
2470: (*s_etat_processus).erreur_execution =
2471: d_ex_erreur_type_argument;
2472: return;
2473: }
2474: }
2475: else
2476: {
2477: /*
2478: * Matrice de complexes
2479: */
2480:
2481: if ((*s_objet_1).type == INT)
2482: {
2483: /*
2484: * Conversion de l'élément à insérer en complexe
2485: */
2486:
2487: ((struct_complexe16 **) (*((struct_matrice *)
2488: (*s_objet_4).objet)).tableau)[indice_i - 1]
2489: [indice_j - 1].partie_reelle = (real8)
2490: (*((integer8 *) (*s_objet_1).objet));
2491: ((struct_complexe16 **) (*((struct_matrice *)
2492: (*s_objet_4).objet)).tableau)[indice_i - 1]
2493: [indice_j - 1].partie_imaginaire = (real8) 0;
2494: }
2495: else if ((*s_objet_1).type == REL)
2496: {
2497: /*
2498: * Conversion de l'élément à insérer en complexe
2499: */
2500:
2501: ((struct_complexe16 **) (*((struct_matrice *)
2502: (*s_objet_4).objet)).tableau)[indice_i - 1]
2503: [indice_j - 1].partie_reelle =
2504: (*((real8 *) (*s_objet_1).objet));
2505: ((struct_complexe16 **) (*((struct_matrice *)
2506: (*s_objet_4).objet)).tableau)[indice_i - 1]
2507: [indice_j - 1].partie_imaginaire = (real8) 0;
2508: }
2509: else if ((*s_objet_1).type == CPL)
2510: {
2511: /*
2512: * Aucune conversion de type
2513: */
2514:
2515: ((struct_complexe16 **) (*((struct_matrice *)
2516: (*s_objet_4).objet)).tableau)[indice_i - 1]
2517: [indice_j - 1].partie_reelle =
2518: (*((struct_complexe16 *)
2519: (*s_objet_1).objet)).partie_reelle;
2520: ((struct_complexe16 **) (*((struct_matrice *)
2521: (*s_objet_4).objet)).tableau)[indice_i - 1]
2522: [indice_j - 1].partie_imaginaire =
2523: (*((struct_complexe16 *)
2524: (*s_objet_1).objet)).partie_imaginaire;
2525: }
2526: else
2527: {
2528: if (variable_partagee == d_vrai)
2529: {
2530: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2531: .s_liste_variables_partagees).mutex)) != 0)
2532: {
2533: (*s_etat_processus).erreur_systeme =
2534: d_es_processus;
2535: return;
2536: }
2537: }
2538:
2539: liberation(s_etat_processus, s_objet_1);
2540: liberation(s_etat_processus, s_objet_2);
2541: liberation(s_etat_processus, s_objet_3);
2542:
2543: (*s_etat_processus).erreur_execution =
2544: d_ex_erreur_type_argument;
2545: return;
2546: }
2547: }
2548:
2549: if (variable_partagee == d_faux)
2550: {
2551: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
2552: .position_variable_courante].objet = s_objet_4;
2553: }
2554: else
2555: {
2556: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
2557: .position_variable_courante].objet = NULL;
2558: (*(*s_etat_processus).s_liste_variables_partagees).table
2559: [(*(*s_etat_processus).s_liste_variables_partagees)
2560: .position_variable].objet = s_objet_4;
2561:
2562: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2563: .s_liste_variables_partagees).mutex))
2564: != 0)
2565: {
2566: (*s_etat_processus).erreur_systeme =
2567: d_es_processus;
2568: return;
2569: }
2570: }
2571:
2572: liberation(s_etat_processus, s_objet_1);
2573: liberation(s_etat_processus, s_objet_2);
2574: liberation(s_etat_processus, s_objet_3);
2575: }
2576: else if ((*s_objet_4).type == LST)
2577: {
2578: if ((*s_objet_2).type != INT)
2579: {
2580: if (variable_partagee == d_vrai)
2581: {
2582: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2583: .s_liste_variables_partagees).mutex))
2584: != 0)
2585: {
2586: (*s_etat_processus).erreur_systeme =
2587: d_es_processus;
2588: return;
2589: }
2590: }
2591:
2592: liberation(s_etat_processus, s_objet_1);
2593: liberation(s_etat_processus, s_objet_2);
2594: liberation(s_etat_processus, s_objet_3);
2595:
2596: (*s_etat_processus).erreur_execution =
2597: d_ex_erreur_type_argument;
2598: return;
2599: }
2600:
2601: indice_i = (*((integer8 *) (*s_objet_2).objet));
2602: indice_j = 1;
2603:
2604: if ((*s_objet_4).nombre_occurrences > 1)
2605: {
2606: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N'))
2607: == NULL)
2608: {
2609: if (variable_partagee == d_vrai)
2610: {
2611: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2612: .s_liste_variables_partagees).mutex))
2613: != 0)
2614: {
2615: (*s_etat_processus).erreur_systeme =
2616: d_es_processus;
2617: return;
2618: }
2619: }
2620:
2621: (*s_etat_processus).erreur_systeme =
2622: d_es_allocation_memoire;
2623: return;
2624: }
2625:
2626: liberation(s_etat_processus, s_objet_4);
2627: s_objet_4 = s_copie_4;
2628: }
2629:
2630: l_element_courant = (*s_objet_4).objet;
2631:
2632: while((l_element_courant != NULL) && (indice_j != indice_i))
2633: {
2634: l_element_courant = (*l_element_courant).suivant;
2635: indice_j++;
2636: }
2637:
2638: if (l_element_courant != NULL)
2639: {
2640: liberation(s_etat_processus, (*l_element_courant).donnee);
2641: (*l_element_courant).donnee = s_objet_1;
2642: }
2643: else
2644: {
2645: if (variable_partagee == d_vrai)
2646: {
2647: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2648: .s_liste_variables_partagees).mutex)) != 0)
2649: {
2650: (*s_etat_processus).erreur_systeme =
2651: d_es_processus;
2652: return;
2653: }
2654: }
2655:
2656: liberation(s_etat_processus, s_objet_1);
2657: liberation(s_etat_processus, s_objet_2);
2658: liberation(s_etat_processus, s_objet_3);
2659:
2660: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
2661: return;
2662: }
2663:
2664: if (variable_partagee == d_faux)
2665: {
2666: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
2667: .position_variable_courante].objet = s_objet_4;
2668: }
2669: else
2670: {
2671: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
2672: .position_variable_courante].objet = NULL;
2673: (*(*s_etat_processus).s_liste_variables_partagees).table
2674: [(*(*s_etat_processus).s_liste_variables_partagees)
2675: .position_variable].objet = s_objet_4;
2676:
2677: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2678: .s_liste_variables_partagees).mutex)) != 0)
2679: {
2680: (*s_etat_processus).erreur_systeme =
2681: d_es_processus;
2682: return;
2683: }
2684: }
2685:
2686: liberation(s_etat_processus, s_objet_2);
2687: liberation(s_etat_processus, s_objet_3);
2688: }
2689: else if ((*s_objet_4).type == TBL)
2690: {
2691: if ((*s_objet_2).type != LST)
2692: {
2693: if (variable_partagee == d_vrai)
2694: {
2695: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2696: .s_liste_variables_partagees).mutex)) != 0)
2697: {
2698: (*s_etat_processus).erreur_systeme =
2699: d_es_processus;
2700: return;
2701: }
2702: }
2703:
2704: liberation(s_etat_processus, s_objet_1);
2705: liberation(s_etat_processus, s_objet_2);
2706: liberation(s_etat_processus, s_objet_3);
2707:
2708: (*s_etat_processus).erreur_execution =
2709: d_ex_erreur_type_argument;
2710: return;
2711: }
2712:
2713: if ((*s_objet_4).nombre_occurrences > 1)
2714: {
2715: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N'))
2716: == NULL)
2717: {
2718: if (variable_partagee == d_vrai)
2719: {
2720: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2721: .s_liste_variables_partagees).mutex)) != 0)
2722: {
2723: (*s_etat_processus).erreur_systeme =
2724: d_es_processus;
2725: return;
2726: }
2727: }
2728:
2729: (*s_etat_processus).erreur_systeme =
2730: d_es_allocation_memoire;
2731: return;
2732: }
2733:
2734: liberation(s_etat_processus, s_objet_4);
2735: s_objet_4 = s_copie_4;
2736: }
2737:
2738: s_objet_element = s_objet_4;
2739: l_element_courant = (*s_objet_2).objet;
2740: indice_i = 0;
2741:
2742: while(l_element_courant != NULL)
2743: {
2744: if ((*(*l_element_courant).donnee).type != INT)
2745: {
2746: if (variable_partagee == d_vrai)
2747: {
2748: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2749: .s_liste_variables_partagees).mutex)) != 0)
2750: {
2751: (*s_etat_processus).erreur_systeme =
2752: d_es_processus;
2753: return;
2754: }
2755: }
2756:
2757: liberation(s_etat_processus, s_objet_1);
2758: liberation(s_etat_processus, s_objet_2);
2759: liberation(s_etat_processus, s_objet_3);
2760:
2761: (*s_etat_processus).erreur_execution =
2762: d_ex_erreur_type_argument;
2763: return;
2764: }
2765:
2766: if ((*s_objet_element).type != TBL)
2767: {
2768: if (variable_partagee == d_vrai)
2769: {
2770: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2771: .s_liste_variables_partagees).mutex)) != 0)
2772: {
2773: (*s_etat_processus).erreur_systeme =
2774: d_es_processus;
2775: return;
2776: }
2777: }
2778:
2779: liberation(s_etat_processus, s_objet_1);
2780: liberation(s_etat_processus, s_objet_2);
2781: liberation(s_etat_processus, s_objet_3);
2782:
2783: (*s_etat_processus).erreur_execution =
2784: d_ex_element_inexistant;
2785: return;
2786: }
2787:
2788: indice_i = (*((integer8 *) (*(*l_element_courant)
2789: .donnee).objet));
2790:
2791: if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
2792: (*s_objet_element).objet)).nombre_elements))
2793: {
2794: if (variable_partagee == d_vrai)
2795: {
2796: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2797: .s_liste_variables_partagees).mutex)) != 0)
2798: {
2799: (*s_etat_processus).erreur_systeme =
2800: d_es_processus;
2801: return;
2802: }
2803: }
2804:
2805: liberation(s_etat_processus, s_objet_1);
2806: liberation(s_etat_processus, s_objet_2);
2807: liberation(s_etat_processus, s_objet_3);
2808:
2809: (*s_etat_processus).erreur_execution =
2810: d_ex_element_inexistant;
2811: return;
2812: }
2813:
2814: if ((*l_element_courant).suivant != NULL)
2815: {
2816: s_objet_element = (*((struct_tableau *) (*s_objet_element)
2817: .objet)).elements[indice_i - 1];
2818: }
2819:
2820: l_element_courant = (*l_element_courant).suivant;
2821: }
2822:
2823: liberation(s_etat_processus, (*((struct_tableau *)
2824: (*s_objet_element).objet)).elements[indice_i - 1]);
2825: (*((struct_tableau *) (*s_objet_element).objet)).elements
2826: [indice_i - 1] = s_objet_1;
2827:
2828: if (variable_partagee == d_faux)
2829: {
2830: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
2831: .position_variable_courante].objet = s_objet_4;
2832: }
2833: else
2834: {
2835: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
2836: .position_variable_courante].objet = NULL;
2837: (*(*s_etat_processus).s_liste_variables_partagees).table
2838: [(*(*s_etat_processus).s_liste_variables_partagees)
2839: .position_variable].objet = s_objet_4;
2840:
2841: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2842: .s_liste_variables_partagees).mutex)) != 0)
2843: {
2844: (*s_etat_processus).erreur_systeme =
2845: d_es_processus;
2846: return;
2847: }
2848: }
2849:
2850: liberation(s_etat_processus, s_objet_2);
2851: }
2852: else
2853: {
2854: if (variable_partagee == d_vrai)
2855: {
2856: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2857: .s_liste_variables_partagees).mutex)) != 0)
2858: {
2859: (*s_etat_processus).erreur_systeme =
2860: d_es_processus;
2861: return;
2862: }
2863: }
2864:
2865: liberation(s_etat_processus, s_objet_1);
2866: liberation(s_etat_processus, s_objet_2);
2867: liberation(s_etat_processus, s_objet_3);
2868:
2869: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2870: return;
2871: }
2872: }
2873:
2874: /*
2875: --------------------------------------------------------------------------------
2876: Arguments incompatibles
2877: --------------------------------------------------------------------------------
2878: */
2879:
2880: else
2881: {
2882: liberation(s_etat_processus, s_objet_1);
2883: liberation(s_etat_processus, s_objet_2);
2884: liberation(s_etat_processus, s_objet_3);
2885:
2886: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2887: return;
2888: }
2889:
2890: return;
2891: }
2892:
2893:
2894: /*
2895: ================================================================================
2896: Fonction 'puti'
2897: ================================================================================
2898: Entrées : pointeur sur une structure struct_processus
2899: --------------------------------------------------------------------------------
2900: Sorties :
2901: --------------------------------------------------------------------------------
2902: Effets de bord : néant
2903: ================================================================================
2904: */
2905:
2906: void
2907: instruction_puti(struct_processus *s_etat_processus)
2908: {
2909: logical1 variable_partagee;
2910:
2911: struct_liste_chainee *l_element_courant;
2912:
2913: struct_objet *s_copie_2;
2914: struct_objet *s_copie_3;
2915: struct_objet *s_copie_4;
2916: struct_objet *s_objet_1;
2917: struct_objet *s_objet_2;
2918: struct_objet *s_objet_3;
2919: struct_objet *s_objet_4;
2920:
2921: unsigned long i;
2922: unsigned long indice_i;
2923: unsigned long indice_j;
2924: unsigned long j;
2925: unsigned long nombre_dimensions;
2926: unsigned long nombre_elements;
2927:
2928: void *tampon;
2929:
2930: (*s_etat_processus).erreur_execution = d_ex;
2931:
2932: if ((*s_etat_processus).affichage_arguments == 'Y')
2933: {
2934: printf("\n PUTI ");
2935:
2936: if ((*s_etat_processus).langue == 'F')
2937: {
2938: printf("(change un élément)\n\n");
2939: }
2940: else
2941: {
2942: printf("(change element)\n\n");
2943: }
2944:
2945: printf(" 3: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
2946: printf(" 2: %s\n", d_LST);
2947: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
2948: printf("-> 2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
2949: printf(" 1: %s\n\n", d_LST);
2950:
2951: printf(" 3: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
2952: printf(" 2: %s\n", d_LST);
2953: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
2954: printf("-> 2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
2955: printf(" 1: %s\n\n", d_LST);
2956:
2957: printf(" 3: %s, %s\n", d_LST, d_NOM);
2958: printf(" 2: %s\n", d_INT);
2959: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
2960: " %s, %s, %s, %s, %s,\n"
2961: " %s, %s, %s, %s, %s,\n"
2962: " %s, %s, %s, %s,\n"
2963: " %s, %s\n",
2964: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
2965: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
2966: d_SQL, d_SLB, d_PRC, d_MTX);
2967: printf("-> 2: %s, %s\n", d_LST, d_NOM);
2968: printf(" 1: %s\n", d_INT);
2969:
2970: return;
2971: }
2972: else if ((*s_etat_processus).test_instruction == 'Y')
2973: {
2974: (*s_etat_processus).nombre_arguments = -1;
2975: return;
2976: }
2977:
2978: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2979: {
2980: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
2981: {
2982: return;
2983: }
2984: }
2985:
2986: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2987: &s_objet_1) == d_erreur)
2988: {
2989: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2990: return;
2991: }
2992:
2993: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2994: &s_objet_2) == d_erreur)
2995: {
2996: liberation(s_etat_processus, s_objet_1);
2997:
2998: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2999: return;
3000: }
3001:
3002: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3003: &s_objet_3) == d_erreur)
3004: {
3005: liberation(s_etat_processus, s_objet_1);
3006: liberation(s_etat_processus, s_objet_2);
3007:
3008: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
3009: return;
3010: }
3011:
3012: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O')) == NULL)
3013: {
3014: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3015: return;
3016: }
3017:
3018: liberation(s_etat_processus, s_objet_2);
3019: s_objet_2 = s_copie_2;
3020:
3021: /*
3022: --------------------------------------------------------------------------------
3023: Traitement des éléments des vecteurs
3024: --------------------------------------------------------------------------------
3025: */
3026:
3027: if (((*s_objet_3).type == VIN) ||
3028: ((*s_objet_3).type == VRL) ||
3029: ((*s_objet_3).type == VCX))
3030: {
3031: if ((*s_objet_2).type != LST)
3032: {
3033: liberation(s_etat_processus, s_objet_1);
3034: liberation(s_etat_processus, s_objet_2);
3035: liberation(s_etat_processus, s_objet_3);
3036:
3037: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3038: return;
3039: }
3040:
3041: l_element_courant = (*s_objet_2).objet;
3042: nombre_dimensions = 0;
3043:
3044: while(l_element_courant != NULL)
3045: {
3046: nombre_dimensions++;
3047: l_element_courant = (*l_element_courant).suivant;
3048: }
3049:
3050: if (nombre_dimensions != 1)
3051: {
3052: liberation(s_etat_processus, s_objet_1);
3053: liberation(s_etat_processus, s_objet_2);
3054: liberation(s_etat_processus, s_objet_3);
3055:
3056: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
3057: return;
3058: }
3059:
3060: l_element_courant = (*s_objet_2).objet;
3061:
3062: if ((*(*l_element_courant).donnee).type != INT)
3063: {
3064: liberation(s_etat_processus, s_objet_1);
3065: liberation(s_etat_processus, s_objet_2);
3066: liberation(s_etat_processus, s_objet_3);
3067:
3068: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3069: return;
3070: }
3071:
3072: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
3073: {
3074: liberation(s_etat_processus, s_objet_1);
3075: liberation(s_etat_processus, s_objet_2);
3076: liberation(s_etat_processus, s_objet_3);
3077:
3078: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
3079: return;
3080: }
3081: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
3082: (integer8) (*((struct_vecteur *) (*s_objet_3).objet)).taille)
3083: {
3084: liberation(s_etat_processus, s_objet_1);
3085: liberation(s_etat_processus, s_objet_2);
3086: liberation(s_etat_processus, s_objet_3);
3087:
3088: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
3089: return;
3090: }
3091:
3092: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
3093:
3094: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL)
3095: {
3096: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3097: return;
3098: }
3099:
3100: liberation(s_etat_processus, s_objet_3);
3101: s_objet_3 = s_copie_3;
3102:
3103: if ((*s_objet_3).type == VIN)
3104: {
3105: /*
3106: * Vecteur d'entiers
3107: */
3108:
3109: if ((*s_objet_1).type == INT)
3110: {
3111: /*
3112: * Aucune conversion de type
3113: */
3114:
3115: ((integer8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3116: .tableau)[indice_i - 1] = (*((integer8 *)
3117: (*s_objet_1).objet));
3118: }
3119: else if ((*s_objet_1).type == REL)
3120: {
3121: /*
3122: * Conversion du vecteur en vecteur réel
3123: */
3124:
3125: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
3126: (*s_objet_3).objet)).tableau);
3127:
3128: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'R';
3129: (*s_objet_3).type = VRL;
3130:
3131: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
3132: = malloc((*((struct_vecteur *)
3133: (*s_objet_3).objet)).taille * sizeof(real8)))
3134: == NULL)
3135: {
3136: (*s_etat_processus).erreur_systeme =
3137: d_es_allocation_memoire;
3138: return;
3139: }
3140:
3141: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
3142: .taille; i++)
3143: {
3144: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3145: .tableau)[i] = (real8) (((integer8 *) tampon)[i]);
3146: }
3147:
3148: free((integer8 *) tampon);
3149:
3150: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3151: .tableau)[indice_i - 1] = (*((real8 *)
3152: (*s_objet_1).objet));
3153: }
3154: else if ((*s_objet_1).type == CPL)
3155: {
3156: /*
3157: * Conversion du vecteur en vecteur complexe
3158: */
3159:
3160: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
3161: (*s_objet_3).objet)).tableau);
3162:
3163: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C';
3164: (*s_objet_3).type = VCX;
3165:
3166: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
3167: = malloc((*((struct_vecteur *)
3168: (*s_objet_3).objet)).taille *
3169: sizeof(struct_complexe16))) == NULL)
3170: {
3171: (*s_etat_processus).erreur_systeme =
3172: d_es_allocation_memoire;
3173: return;
3174: }
3175:
3176: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
3177: .taille; i++)
3178: {
3179: ((struct_complexe16 *) (*((struct_vecteur *)
3180: (*s_objet_3).objet)).tableau)[i].partie_reelle =
3181: (real8) (((integer8 *) tampon)[i]);
3182: ((struct_complexe16 *) (*((struct_vecteur *)
3183: (*s_objet_3).objet)).tableau)[i]
3184: .partie_imaginaire = (real8) 0;
3185: }
3186:
3187: free((integer8 *) tampon);
3188:
3189: ((struct_complexe16 *) (*((struct_vecteur *)
3190: (*s_objet_3).objet)).tableau)[indice_i - 1]
3191: .partie_reelle = (*((struct_complexe16 *)
3192: (*s_objet_1).objet)).partie_reelle;
3193: ((struct_complexe16 *) (*((struct_vecteur *)
3194: (*s_objet_3).objet)).tableau)[indice_i - 1]
3195: .partie_imaginaire = (*((struct_complexe16 *)
3196: (*s_objet_1).objet)).partie_imaginaire;
3197: }
3198: else
3199: {
3200: liberation(s_etat_processus, s_objet_1);
3201: liberation(s_etat_processus, s_objet_2);
3202: liberation(s_etat_processus, s_objet_3);
3203:
3204: (*s_etat_processus).erreur_execution =
3205: d_ex_erreur_type_argument;
3206: return;
3207: }
3208: }
3209: else if ((*s_objet_3).type == VRL)
3210: {
3211: /*
3212: * Vecteur de réels
3213: */
3214:
3215: if ((*s_objet_1).type == INT)
3216: {
3217: /*
3218: * Conversion de l'élément à insérer en réel
3219: */
3220:
3221: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3222: .tableau)[indice_i - 1] = (real8) (*((integer8 *)
3223: (*s_objet_1).objet));
3224: }
3225: else if ((*s_objet_1).type == REL)
3226: {
3227: /*
3228: * Aucune conversion de type
3229: */
3230:
3231: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3232: .tableau)[indice_i - 1] = (*((real8 *)
3233: (*s_objet_1).objet));
3234: }
3235: else if ((*s_objet_1).type == CPL)
3236: {
3237: /*
3238: * Conversion du vecteur en vecteur complexe
3239: */
3240:
3241: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
3242: (*s_objet_3).objet)).tableau);
3243:
3244: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C';
3245: (*s_objet_3).type = VCX;
3246:
3247: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
3248: = malloc((*((struct_vecteur *)
3249: (*s_objet_3).objet)).taille *
3250: sizeof(struct_complexe16))) == NULL)
3251: {
3252: (*s_etat_processus).erreur_systeme =
3253: d_es_allocation_memoire;
3254: return;
3255: }
3256:
3257: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
3258: .taille; i++)
3259: {
3260: ((struct_complexe16 *) (*((struct_vecteur *)
3261: (*s_objet_3).objet)).tableau)[i].partie_reelle =
3262: ((real8 *) tampon)[i];
3263: ((struct_complexe16 *) (*((struct_vecteur *)
3264: (*s_objet_3).objet)).tableau)[i]
3265: .partie_imaginaire = (real8) 0;
3266: }
3267:
3268: free((real8 *) tampon);
3269:
3270: ((struct_complexe16 *) (*((struct_vecteur *)
3271: (*s_objet_3).objet)).tableau)[indice_i - 1]
3272: .partie_reelle = (*((struct_complexe16 *)
3273: (*s_objet_1).objet)).partie_reelle;
3274: ((struct_complexe16 *) (*((struct_vecteur *)
3275: (*s_objet_3).objet)).tableau)[indice_i - 1]
3276: .partie_imaginaire = (*((struct_complexe16 *)
3277: (*s_objet_1).objet)).partie_imaginaire;
3278: }
3279: else
3280: {
3281: liberation(s_etat_processus, s_objet_1);
3282: liberation(s_etat_processus, s_objet_2);
3283: liberation(s_etat_processus, s_objet_3);
3284:
3285: (*s_etat_processus).erreur_execution =
3286: d_ex_erreur_type_argument;
3287: return;
3288: }
3289: }
3290: else
3291: {
3292: /*
3293: * Vecteur de complexes
3294: */
3295:
3296: if ((*s_objet_1).type == INT)
3297: {
3298: /*
3299: * Conversion de l'élément à insérer en complexe
3300: */
3301:
3302: ((struct_complexe16 *) (*((struct_vecteur *)
3303: (*s_objet_3).objet)).tableau)[indice_i - 1]
3304: .partie_reelle = (real8) (*((integer8 *)
3305: (*s_objet_1).objet));
3306: ((struct_complexe16 *) (*((struct_vecteur *)
3307: (*s_objet_3).objet)).tableau)[indice_i - 1]
3308: .partie_imaginaire = (real8) 0;
3309: }
3310: else if ((*s_objet_1).type == REL)
3311: {
3312: /*
3313: * Conversion de l'élément à insérer en complexe
3314: */
3315:
3316: ((struct_complexe16 *) (*((struct_vecteur *)
3317: (*s_objet_3).objet)).tableau)[indice_i - 1]
3318: .partie_reelle = (*((real8 *) (*s_objet_1).objet));
3319: ((struct_complexe16 *) (*((struct_vecteur *)
3320: (*s_objet_3).objet)).tableau)[indice_i - 1]
3321: .partie_imaginaire = (real8) 0;
3322: }
3323: else if ((*s_objet_1).type == CPL)
3324: {
3325: /*
3326: * Aucune conversion de type
3327: */
3328:
3329: ((struct_complexe16 *) (*((struct_vecteur *)
3330: (*s_objet_3).objet)).tableau)[indice_i - 1]
3331: .partie_reelle = (*((struct_complexe16 *)
3332: (*s_objet_1).objet)).partie_reelle;
3333: ((struct_complexe16 *) (*((struct_vecteur *)
3334: (*s_objet_3).objet)).tableau)[indice_i - 1]
3335: .partie_imaginaire = (*((struct_complexe16 *)
3336: (*s_objet_1).objet)).partie_imaginaire;
3337: }
3338: else
3339: {
3340: liberation(s_etat_processus, s_objet_1);
3341: liberation(s_etat_processus, s_objet_2);
3342: liberation(s_etat_processus, s_objet_3);
3343:
3344: (*s_etat_processus).erreur_execution =
3345: d_ex_erreur_type_argument;
3346: return;
3347: }
3348: }
3349:
3350: liberation(s_etat_processus, s_objet_1);
3351:
3352: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3353: s_objet_3) == d_erreur)
3354: {
3355: return;
3356: }
3357:
3358: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
3359: (indice_i % (*((struct_vecteur *) (*s_objet_3).objet))
3360: .taille) + 1;
3361:
3362: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3363: s_objet_2) == d_erreur)
3364: {
3365: return;
3366: }
3367: }
3368:
3369: /*
3370: --------------------------------------------------------------------------------
3371: Traitement des éléments des matrices
3372: --------------------------------------------------------------------------------
3373: */
3374:
3375: else if (((*s_objet_3).type == MIN) ||
3376: ((*s_objet_3).type == MRL) ||
3377: ((*s_objet_3).type == MCX))
3378: {
3379: if ((*s_objet_2).type != LST)
3380: {
3381: liberation(s_etat_processus, s_objet_1);
3382: liberation(s_etat_processus, s_objet_2);
3383: liberation(s_etat_processus, s_objet_3);
3384:
3385: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3386: return;
3387: }
3388:
3389: l_element_courant = (*s_objet_2).objet;
3390: nombre_dimensions = 0;
3391:
3392: while(l_element_courant != NULL)
3393: {
3394: nombre_dimensions++;
3395: l_element_courant = (*l_element_courant).suivant;
3396: }
3397:
3398: if (nombre_dimensions != 2)
3399: {
3400: liberation(s_etat_processus, s_objet_1);
3401: liberation(s_etat_processus, s_objet_2);
3402: liberation(s_etat_processus, s_objet_3);
3403:
3404: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
3405: return;
3406: }
3407:
3408: l_element_courant = (*s_objet_2).objet;
3409:
3410: indice_i = 0;
3411: indice_j = 0;
3412:
3413: while(l_element_courant != NULL)
3414: {
3415: if ((*(*l_element_courant).donnee).type != INT)
3416: {
3417: liberation(s_etat_processus, s_objet_1);
3418: liberation(s_etat_processus, s_objet_2);
3419: liberation(s_etat_processus, s_objet_3);
3420:
3421: (*s_etat_processus).erreur_execution =
3422: d_ex_erreur_type_argument;
3423: return;
3424: }
3425:
3426: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
3427: {
3428: liberation(s_etat_processus, s_objet_1);
3429: liberation(s_etat_processus, s_objet_2);
3430: liberation(s_etat_processus, s_objet_3);
3431:
3432: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
3433: return;
3434: }
3435:
3436: if (indice_i == 0)
3437: {
3438: indice_i = (*((integer8 *)
3439: (*(*l_element_courant).donnee).objet));
3440: }
3441: else
3442: {
3443: indice_j = (*((integer8 *)
3444: (*(*l_element_courant).donnee).objet));
3445: }
3446:
3447: l_element_courant = (*l_element_courant).suivant;
3448: }
3449:
3450: if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet))
3451: .nombre_lignes) || (indice_j > (*((struct_matrice *)
3452: (*s_objet_3).objet)).nombre_colonnes))
3453: {
3454: liberation(s_etat_processus, s_objet_1);
3455: liberation(s_etat_processus, s_objet_2);
3456: liberation(s_etat_processus, s_objet_3);
3457:
3458: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
3459: return;
3460: }
3461:
3462: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL)
3463: {
3464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3465: return;
3466: }
3467:
3468: liberation(s_etat_processus, s_objet_3);
3469: s_objet_3 = s_copie_3;
3470:
3471: if ((*s_objet_3).type == MIN)
3472: {
3473: /*
3474: * Matrice d'entiers
3475: */
3476:
3477: if ((*s_objet_1).type == INT)
3478: {
3479: /*
3480: * Aucune conversion de type
3481: */
3482:
3483: ((integer8 **) (*((struct_matrice *) (*s_objet_3).objet))
3484: .tableau)[indice_i - 1][indice_j - 1] =
3485: (*((integer8 *) (*s_objet_1).objet));
3486: }
3487: else if ((*s_objet_1).type == REL)
3488: {
3489: /*
3490: * Conversion de la matrice en matrice réelle
3491: */
3492:
3493: tampon = (void *) ((integer8 **) (*((struct_matrice *)
3494: (*s_objet_3).objet)).tableau);
3495:
3496: (*((struct_matrice *) (*s_objet_3).objet)).type = 'R';
3497: (*s_objet_3).type = MRL;
3498:
3499: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
3500: = malloc((*((struct_matrice *)
3501: (*s_objet_3).objet)).nombre_lignes * sizeof(real8 *)))
3502: == NULL)
3503: {
3504: (*s_etat_processus).erreur_systeme =
3505: d_es_allocation_memoire;
3506: return;
3507: }
3508:
3509: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
3510: .nombre_lignes; i++)
3511: {
3512: if ((((real8 **) (*((struct_matrice *)
3513: (*s_objet_3).objet)).tableau)[i]
3514: = malloc((*((struct_matrice *)
3515: (*s_objet_3).objet)).nombre_colonnes *
3516: sizeof(real8))) == NULL)
3517: {
3518: (*s_etat_processus).erreur_systeme =
3519: d_es_allocation_memoire;
3520: return;
3521: }
3522:
3523: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
3524: .nombre_colonnes; j++)
3525: {
3526: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
3527: .tableau)[i][j] = (real8) (((integer8 **)
3528: tampon)[i][j]);
3529: }
3530:
3531: free(((integer8 **) tampon)[i]);
3532: }
3533:
3534: free((integer8 **) tampon);
3535:
3536: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
3537: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *)
3538: (*s_objet_1).objet));
3539: }
3540: else if ((*s_objet_1).type == CPL)
3541: {
3542: /*
3543: * Conversion de la matrice en matrice complexe
3544: */
3545:
3546: tampon = (void *) ((integer8 **) (*((struct_matrice *)
3547: (*s_objet_3).objet)).tableau);
3548:
3549: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C';
3550: (*s_objet_3).type = MCX;
3551:
3552: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
3553: = malloc((*((struct_matrice *)
3554: (*s_objet_3).objet)).nombre_lignes *
3555: sizeof(struct_complexe16 *))) == NULL)
3556: {
3557: (*s_etat_processus).erreur_systeme =
3558: d_es_allocation_memoire;
3559: return;
3560: }
3561:
3562: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
3563: .nombre_lignes; i++)
3564: {
3565: if ((((struct_complexe16 **) (*((struct_matrice *)
3566: (*s_objet_3).objet)).tableau)[i]
3567: = malloc((*((struct_matrice *)
3568: (*s_objet_3).objet)).nombre_colonnes *
3569: sizeof(struct_complexe16))) == NULL)
3570: {
3571: (*s_etat_processus).erreur_systeme =
3572: d_es_allocation_memoire;
3573: return;
3574: }
3575:
3576: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
3577: .nombre_colonnes; j++)
3578: {
3579: ((struct_complexe16 **) (*((struct_matrice *)
3580: (*s_objet_3).objet)).tableau)[i][j]
3581: .partie_reelle = (real8) (((integer8 **)
3582: tampon)[i][j]);
3583: ((struct_complexe16 **) (*((struct_matrice *)
3584: (*s_objet_3).objet)).tableau)[i][j]
3585: .partie_imaginaire = (real8) 0;
3586: }
3587:
3588: free(((integer8 **) tampon)[i]);
3589: }
3590:
3591: free((integer8 **) tampon);
3592:
3593: ((struct_complexe16 **) (*((struct_matrice *)
3594: (*s_objet_3).objet)).tableau)[indice_i - 1]
3595: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
3596: (*s_objet_1).objet)).partie_reelle;
3597: ((struct_complexe16 **) (*((struct_matrice *)
3598: (*s_objet_3).objet)).tableau)[indice_i - 1]
3599: [indice_j - 1].partie_imaginaire =
3600: (*((struct_complexe16 *)
3601: (*s_objet_1).objet)).partie_imaginaire;
3602: }
3603: else
3604: {
3605: liberation(s_etat_processus, s_objet_1);
3606: liberation(s_etat_processus, s_objet_2);
3607: liberation(s_etat_processus, s_objet_3);
3608:
3609: (*s_etat_processus).erreur_execution =
3610: d_ex_erreur_type_argument;
3611: return;
3612: }
3613: }
3614: else if ((*s_objet_3).type == MRL)
3615: {
3616: /*
3617: * Matrice de réels
3618: */
3619:
3620: if ((*s_objet_1).type == INT)
3621: {
3622: /*
3623: * Conversion de l'élément à insérer en réel
3624: */
3625:
3626: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
3627: .tableau)[indice_i - 1][indice_j - 1] =
3628: (real8) (*((integer8 *) (*s_objet_1).objet));
3629: }
3630: else if ((*s_objet_1).type == REL)
3631: {
3632: /*
3633: * Aucune conversion de type
3634: */
3635:
3636: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
3637: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *)
3638: (*s_objet_1).objet));
3639: }
3640: else if ((*s_objet_1).type == CPL)
3641: {
3642: /*
3643: * Conversion de la matrice en matrice complexe
3644: */
3645:
3646: tampon = (void *) ((real8 **) (*((struct_matrice *)
3647: (*s_objet_3).objet)).tableau);
3648:
3649: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C';
3650: (*s_objet_3).type = MCX;
3651:
3652: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
3653: = malloc((*((struct_matrice *)
3654: (*s_objet_3).objet)).nombre_lignes *
3655: sizeof(struct_complexe16 *))) == NULL)
3656: {
3657: (*s_etat_processus).erreur_systeme =
3658: d_es_allocation_memoire;
3659: return;
3660: }
3661:
3662: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
3663: .nombre_lignes; i++)
3664: {
3665: if ((((struct_complexe16 **) (*((struct_matrice *)
3666: (*s_objet_3).objet)).tableau)[i]
3667: = malloc((*((struct_matrice *)
3668: (*s_objet_3).objet)).nombre_colonnes *
3669: sizeof(struct_complexe16))) == NULL)
3670: {
3671: (*s_etat_processus).erreur_systeme =
3672: d_es_allocation_memoire;
3673: return;
3674: }
3675:
3676: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
3677: .nombre_colonnes; j++)
3678: {
3679: ((struct_complexe16 **) (*((struct_matrice *)
3680: (*s_objet_3).objet)).tableau)[i][j]
3681: .partie_reelle = (((real8 **)
3682: tampon)[i][j]);
3683: ((struct_complexe16 **) (*((struct_matrice *)
3684: (*s_objet_3).objet)).tableau)[i][j]
3685: .partie_imaginaire = (real8) 0;
3686: }
3687:
3688: free(((integer8 **) tampon)[i]);
3689: }
3690:
3691: free((integer8 **) tampon);
3692:
3693: ((struct_complexe16 **) (*((struct_matrice *)
3694: (*s_objet_3).objet)).tableau)[indice_i - 1]
3695: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
3696: (*s_objet_1).objet)).partie_reelle;
3697: ((struct_complexe16 **) (*((struct_matrice *)
3698: (*s_objet_3).objet)).tableau)[indice_i - 1]
3699: [indice_j - 1].partie_imaginaire =
3700: (*((struct_complexe16 *)
3701: (*s_objet_1).objet)).partie_imaginaire;
3702: }
3703: else
3704: {
3705: liberation(s_etat_processus, s_objet_1);
3706: liberation(s_etat_processus, s_objet_2);
3707: liberation(s_etat_processus, s_objet_3);
3708:
3709: (*s_etat_processus).erreur_execution =
3710: d_ex_erreur_type_argument;
3711: return;
3712: }
3713: }
3714: else
3715: {
3716: /*
3717: * Matrice de complexes
3718: */
3719:
3720: if ((*s_objet_1).type == INT)
3721: {
3722: /*
3723: * Conversion de l'élément à insérer en complexe
3724: */
3725:
3726: ((struct_complexe16 **) (*((struct_matrice *)
3727: (*s_objet_3).objet)).tableau)[indice_i - 1]
3728: [indice_j - 1].partie_reelle = (real8) (*((integer8 *)
3729: (*s_objet_1).objet));
3730: ((struct_complexe16 **) (*((struct_matrice *)
3731: (*s_objet_3).objet)).tableau)[indice_i - 1]
3732: [indice_j - 1].partie_imaginaire = (real8) 0;
3733: }
3734: else if ((*s_objet_1).type == REL)
3735: {
3736: /*
3737: * Conversion de l'élément à insérer en complexe
3738: */
3739:
3740: ((struct_complexe16 **) (*((struct_matrice *)
3741: (*s_objet_3).objet)).tableau)[indice_i - 1]
3742: [indice_j - 1].partie_reelle =
3743: (*((real8 *) (*s_objet_1).objet));
3744: ((struct_complexe16 **) (*((struct_matrice *)
3745: (*s_objet_3).objet)).tableau)[indice_i - 1]
3746: [indice_j - 1].partie_imaginaire = (real8) 0;
3747: }
3748: else if ((*s_objet_1).type == CPL)
3749: {
3750: /*
3751: * Aucune conversion de type
3752: */
3753:
3754: ((struct_complexe16 **) (*((struct_matrice *)
3755: (*s_objet_3).objet)).tableau)[indice_i - 1]
3756: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
3757: (*s_objet_1).objet)).partie_reelle;
3758: ((struct_complexe16 **) (*((struct_matrice *)
3759: (*s_objet_3).objet)).tableau)[indice_i - 1]
3760: [indice_j - 1].partie_imaginaire =
3761: (*((struct_complexe16 *)
3762: (*s_objet_1).objet)).partie_imaginaire;
3763: }
3764: else
3765: {
3766: liberation(s_etat_processus, s_objet_1);
3767: liberation(s_etat_processus, s_objet_2);
3768: liberation(s_etat_processus, s_objet_3);
3769:
3770: (*s_etat_processus).erreur_execution =
3771: d_ex_erreur_type_argument;
3772: return;
3773: }
3774: }
3775:
3776: liberation(s_etat_processus, s_objet_1);
3777:
3778: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3779: s_objet_3) == d_erreur)
3780: {
3781: return;
3782: }
3783:
3784: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
3785: (*s_objet_2).objet)).suivant).donnee).objet))) > (integer8)
3786: (*((struct_matrice *) (*s_objet_3).objet)).nombre_colonnes)
3787: {
3788: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_2)
3789: .objet)).suivant).donnee).objet)) = 1;
3790:
3791: if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
3792: (*s_objet_2).objet)).donnee).objet))) > (integer8)
3793: (*((struct_matrice *) (*s_objet_3).objet)).nombre_lignes)
3794: {
3795: (*((integer8 *) (*(*((struct_liste_chainee *)
3796: (*s_objet_2).objet)).donnee).objet)) = 1;
3797: }
3798: }
3799:
3800: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3801: s_objet_2) == d_erreur)
3802: {
3803: return;
3804: }
3805: }
3806:
3807: /*
3808: --------------------------------------------------------------------------------
3809: Traitement des éléments des listes
3810: --------------------------------------------------------------------------------
3811: */
3812:
3813: else if ((*s_objet_3).type == LST)
3814: {
3815: if ((*s_objet_2).type != INT)
3816: {
3817: liberation(s_etat_processus, s_objet_1);
3818: liberation(s_etat_processus, s_objet_2);
3819: liberation(s_etat_processus, s_objet_3);
3820:
3821: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3822: return;
3823: }
3824:
3825: indice_i = (*((integer8 *) (*s_objet_2).objet));
3826: indice_j = 1;
3827:
3828: if ((*s_objet_3).nombre_occurrences > 1)
3829: {
3830: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'N'))
3831: == NULL)
3832: {
3833: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3834: return;
3835: }
3836:
3837: liberation(s_etat_processus, s_objet_3);
3838: s_objet_3 = s_copie_3;
3839: }
3840:
3841: l_element_courant = (*s_objet_3).objet;
3842: nombre_elements = 0;
3843:
3844: while(l_element_courant != NULL)
3845: {
3846: l_element_courant = (*l_element_courant).suivant;
3847: nombre_elements++;
3848: }
3849:
3850: l_element_courant = (*s_objet_3).objet;
3851:
3852: while((l_element_courant != NULL) && (indice_j != indice_i))
3853: {
3854: l_element_courant = (*l_element_courant).suivant;
3855: indice_j++;
3856: }
3857:
3858: if (l_element_courant != NULL)
3859: {
3860: liberation(s_etat_processus, (*l_element_courant).donnee);
3861: (*l_element_courant).donnee = s_objet_1;
3862: }
3863: else
3864: {
3865: liberation(s_etat_processus, s_objet_1);
3866: liberation(s_etat_processus, s_objet_2);
3867: liberation(s_etat_processus, s_objet_3);
3868:
3869: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
3870: return;
3871: }
3872:
3873: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3874: s_objet_3) == d_erreur)
3875: {
3876: return;
3877: }
3878:
3879: (*((integer8 *) (*s_objet_2).objet)) =
3880: (indice_i % nombre_elements) + 1;
3881:
3882: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3883: s_objet_2) == d_erreur)
3884: {
3885: return;
3886: }
3887: }
3888:
3889: /*
3890: --------------------------------------------------------------------------------
3891: Traitement des noms
3892: --------------------------------------------------------------------------------
3893: */
3894:
3895: else if ((*s_objet_3).type == NOM)
3896: {
3897: variable_partagee = d_faux;
3898:
3899: if (recherche_variable(s_etat_processus, (*((struct_nom *)
3900: (*s_objet_3).objet)).nom) == d_faux)
3901: {
3902: (*s_etat_processus).erreur_systeme = d_es;
3903: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
3904:
3905: liberation(s_etat_processus, s_objet_1);
3906: liberation(s_etat_processus, s_objet_2);
3907: liberation(s_etat_processus, s_objet_3);
3908:
3909: return;
3910: }
3911:
3912: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
3913: .position_variable_courante].variable_verrouillee == d_vrai)
3914: {
3915: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
3916:
3917: liberation(s_etat_processus, s_objet_1);
3918: liberation(s_etat_processus, s_objet_2);
3919: liberation(s_etat_processus, s_objet_3);
3920:
3921: return;
3922: }
3923:
3924: s_objet_4 = (*s_etat_processus).s_liste_variables[(*s_etat_processus)
3925: .position_variable_courante].objet;
3926:
3927: if (s_objet_4 == NULL)
3928: {
3929: if (pthread_mutex_lock(&((*(*s_etat_processus)
3930: .s_liste_variables_partagees).mutex)) != 0)
3931: {
3932: (*s_etat_processus).erreur_systeme = d_es_processus;
3933: return;
3934: }
3935:
3936: if (recherche_variable_partagee(s_etat_processus,
3937: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
3938: .position_variable_courante].nom,
3939: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
3940: .position_variable_courante].variable_partagee,
3941: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
3942: .position_variable_courante].origine) == d_faux)
3943: {
3944: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3945: .s_liste_variables_partagees).mutex)) != 0)
3946: {
3947: (*s_etat_processus).erreur_systeme = d_es_processus;
3948: return;
3949: }
3950:
3951: (*s_etat_processus).erreur_systeme = d_es;
3952: (*s_etat_processus).erreur_execution =
3953: d_ex_variable_non_definie;
3954:
3955: liberation(s_etat_processus, s_objet_1);
3956: liberation(s_etat_processus, s_objet_2);
3957: liberation(s_etat_processus, s_objet_3);
3958:
3959: return;
3960: }
3961:
3962: s_objet_4 = (*(*s_etat_processus).s_liste_variables_partagees)
3963: .table[(*(*s_etat_processus).s_liste_variables_partagees)
3964: .position_variable].objet;
3965: variable_partagee = d_vrai;
3966: }
3967:
3968: if (((*s_objet_4).type == VIN) ||
3969: ((*s_objet_4).type == VRL) ||
3970: ((*s_objet_4).type == VCX))
3971: {
3972: if ((*s_objet_2).type != LST)
3973: {
3974: if (variable_partagee == d_vrai)
3975: {
3976: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3977: .s_liste_variables_partagees).mutex)) != 0)
3978: {
3979: (*s_etat_processus).erreur_systeme = d_es_processus;
3980: return;
3981: }
3982: }
3983:
3984: liberation(s_etat_processus, s_objet_1);
3985: liberation(s_etat_processus, s_objet_2);
3986: liberation(s_etat_processus, s_objet_3);
3987:
3988: (*s_etat_processus).erreur_execution =
3989: d_ex_erreur_type_argument;
3990: return;
3991: }
3992:
3993: l_element_courant = (*s_objet_2).objet;
3994: nombre_dimensions = 0;
3995:
3996: while(l_element_courant != NULL)
3997: {
3998: nombre_dimensions++;
3999: l_element_courant = (*l_element_courant).suivant;
4000: }
4001:
4002: if (nombre_dimensions != 1)
4003: {
4004: if (variable_partagee == d_vrai)
4005: {
4006: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4007: .s_liste_variables_partagees).mutex)) != 0)
4008: {
4009: (*s_etat_processus).erreur_systeme = d_es_processus;
4010: return;
4011: }
4012: }
4013:
4014: liberation(s_etat_processus, s_objet_1);
4015: liberation(s_etat_processus, s_objet_2);
4016: liberation(s_etat_processus, s_objet_3);
4017:
4018: (*s_etat_processus).erreur_execution =
4019: d_ex_dimensions_invalides;
4020: return;
4021: }
4022:
4023: l_element_courant = (*s_objet_2).objet;
4024:
4025: if ((*(*l_element_courant).donnee).type != INT)
4026: {
4027: if (variable_partagee == d_vrai)
4028: {
4029: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4030: .s_liste_variables_partagees).mutex)) != 0)
4031: {
4032: (*s_etat_processus).erreur_systeme = d_es_processus;
4033: return;
4034: }
4035: }
4036:
4037: liberation(s_etat_processus, s_objet_1);
4038: liberation(s_etat_processus, s_objet_2);
4039: liberation(s_etat_processus, s_objet_3);
4040:
4041: (*s_etat_processus).erreur_execution =
4042: d_ex_erreur_type_argument;
4043: return;
4044: }
4045:
4046: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
4047: {
4048: if (variable_partagee == d_vrai)
4049: {
4050: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4051: .s_liste_variables_partagees).mutex)) != 0)
4052: {
4053: (*s_etat_processus).erreur_systeme = d_es_processus;
4054: return;
4055: }
4056: }
4057:
4058: liberation(s_etat_processus, s_objet_1);
4059: liberation(s_etat_processus, s_objet_2);
4060: liberation(s_etat_processus, s_objet_3);
4061:
4062: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
4063: return;
4064: }
4065: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
4066: (integer8) (*((struct_vecteur *) (*s_objet_4).objet))
4067: .taille)
4068: {
4069: if (variable_partagee == d_vrai)
4070: {
4071: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4072: .s_liste_variables_partagees).mutex)) != 0)
4073: {
4074: (*s_etat_processus).erreur_systeme = d_es_processus;
4075: return;
4076: }
4077: }
4078:
4079: liberation(s_etat_processus, s_objet_1);
4080: liberation(s_etat_processus, s_objet_2);
4081: liberation(s_etat_processus, s_objet_3);
4082:
4083: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
4084: return;
4085: }
4086:
4087: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
4088:
4089: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q'))
4090: == NULL)
4091: {
4092: if (variable_partagee == d_vrai)
4093: {
4094: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4095: .s_liste_variables_partagees).mutex)) != 0)
4096: {
4097: (*s_etat_processus).erreur_systeme = d_es_processus;
4098: return;
4099: }
4100: }
4101:
4102: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4103: return;
4104: }
4105:
4106: liberation(s_etat_processus, s_objet_4);
4107: s_objet_4 = s_copie_4;
4108:
4109: if ((*s_objet_4).type == VIN)
4110: {
4111: /*
4112: * Vecteur d'entiers
4113: */
4114:
4115: if ((*s_objet_1).type == INT)
4116: {
4117: /*
4118: * Aucune conversion de type
4119: */
4120:
4121: ((integer8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4122: .tableau)[indice_i - 1] = (*((integer8 *)
4123: (*s_objet_1).objet));
4124: }
4125: else if ((*s_objet_1).type == REL)
4126: {
4127: /*
4128: * Conversion du vecteur en vecteur réel
4129: */
4130:
4131: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
4132: (*s_objet_4).objet)).tableau);
4133:
4134: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'R';
4135: (*s_objet_4).type = VRL;
4136:
4137: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
4138: = malloc((*((struct_vecteur *)
4139: (*s_objet_4).objet)).taille * sizeof(real8)))
4140: == NULL)
4141: {
4142: if (variable_partagee == d_vrai)
4143: {
4144: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4145: .s_liste_variables_partagees).mutex)) != 0)
4146: {
4147: (*s_etat_processus).erreur_systeme =
4148: d_es_processus;
4149: return;
4150: }
4151: }
4152:
4153: (*s_etat_processus).erreur_systeme =
4154: d_es_allocation_memoire;
4155: return;
4156: }
4157:
4158: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
4159: .taille; i++)
4160: {
4161: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4162: .tableau)[i] = (real8) (((integer8 *)
4163: tampon)[i]);
4164: }
4165:
4166: free((integer8 *) tampon);
4167:
4168: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4169: .tableau)[indice_i - 1] = (*((real8 *)
4170: (*s_objet_1).objet));
4171: }
4172: else if ((*s_objet_1).type == CPL)
4173: {
4174: /*
4175: * Conversion du vecteur en vecteur complexe
4176: */
4177:
4178: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
4179: (*s_objet_4).objet)).tableau);
4180:
4181: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C';
4182: (*s_objet_4).type = VCX;
4183:
4184: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
4185: = malloc((*((struct_vecteur *)
4186: (*s_objet_4).objet)).taille *
4187: sizeof(struct_complexe16))) == NULL)
4188: {
4189: if (variable_partagee == d_vrai)
4190: {
4191: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4192: .s_liste_variables_partagees).mutex)) != 0)
4193: {
4194: (*s_etat_processus).erreur_systeme =
4195: d_es_processus;
4196: return;
4197: }
4198: }
4199:
4200: (*s_etat_processus).erreur_systeme =
4201: d_es_allocation_memoire;
4202: return;
4203: }
4204:
4205: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
4206: .taille; i++)
4207: {
4208: ((struct_complexe16 *) (*((struct_vecteur *)
4209: (*s_objet_4).objet)).tableau)[i].partie_reelle =
4210: (real8) (((integer8 *) tampon)[i]);
4211: ((struct_complexe16 *) (*((struct_vecteur *)
4212: (*s_objet_4).objet)).tableau)[i]
4213: .partie_imaginaire = (real8) 0;
4214: }
4215:
4216: free((integer8 *) tampon);
4217:
4218: ((struct_complexe16 *) (*((struct_vecteur *)
4219: (*s_objet_4).objet)).tableau)[indice_i - 1]
4220: .partie_reelle = (*((struct_complexe16 *)
4221: (*s_objet_1).objet)).partie_reelle;
4222: ((struct_complexe16 *) (*((struct_vecteur *)
4223: (*s_objet_4).objet)).tableau)[indice_i - 1]
4224: .partie_imaginaire = (*((struct_complexe16 *)
4225: (*s_objet_1).objet)).partie_imaginaire;
4226: }
4227: else
4228: {
4229: if (variable_partagee == d_vrai)
4230: {
4231: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4232: .s_liste_variables_partagees).mutex)) != 0)
4233: {
4234: (*s_etat_processus).erreur_systeme =
4235: d_es_processus;
4236: return;
4237: }
4238: }
4239:
4240: liberation(s_etat_processus, s_objet_1);
4241: liberation(s_etat_processus, s_objet_2);
4242: liberation(s_etat_processus, s_objet_3);
4243:
4244: (*s_etat_processus).erreur_execution =
4245: d_ex_erreur_type_argument;
4246: return;
4247: }
4248: }
4249: else if ((*s_objet_4).type == VRL)
4250: {
4251: /*
4252: * Vecteur de réels
4253: */
4254:
4255: if ((*s_objet_1).type == INT)
4256: {
4257: /*
4258: * Conversion de l'élément à insérer en réel
4259: */
4260:
4261: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4262: .tableau)[indice_i - 1] = (real8) (*((integer8 *)
4263: (*s_objet_1).objet));
4264: }
4265: else if ((*s_objet_1).type == REL)
4266: {
4267: /*
4268: * Aucune conversion de type
4269: */
4270:
4271: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4272: .tableau)[indice_i - 1] = (*((real8 *)
4273: (*s_objet_1).objet));
4274: }
4275: else if ((*s_objet_1).type == CPL)
4276: {
4277: /*
4278: * Conversion du vecteur en vecteur complexe
4279: */
4280:
4281: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
4282: (*s_objet_4).objet)).tableau);
4283:
4284: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C';
4285: (*s_objet_4).type = VCX;
4286:
4287: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
4288: = malloc((*((struct_vecteur *)
4289: (*s_objet_4).objet)).taille *
4290: sizeof(struct_complexe16))) == NULL)
4291: {
4292: if (variable_partagee == d_vrai)
4293: {
4294: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4295: .s_liste_variables_partagees).mutex)) != 0)
4296: {
4297: (*s_etat_processus).erreur_systeme =
4298: d_es_processus;
4299: return;
4300: }
4301: }
4302:
4303: (*s_etat_processus).erreur_systeme =
4304: d_es_allocation_memoire;
4305: return;
4306: }
4307:
4308: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
4309: .taille; i++)
4310: {
4311: ((struct_complexe16 *) (*((struct_vecteur *)
4312: (*s_objet_4).objet)).tableau)[i].partie_reelle =
4313: ((real8 *) tampon)[i];
4314: ((struct_complexe16 *) (*((struct_vecteur *)
4315: (*s_objet_4).objet)).tableau)[i]
4316: .partie_imaginaire = (real8) 0;
4317: }
4318:
4319: free((real8 *) tampon);
4320:
4321: ((struct_complexe16 *) (*((struct_vecteur *)
4322: (*s_objet_4).objet)).tableau)[indice_i - 1]
4323: .partie_reelle = (*((struct_complexe16 *)
4324: (*s_objet_1).objet)).partie_reelle;
4325: ((struct_complexe16 *) (*((struct_vecteur *)
4326: (*s_objet_4).objet)).tableau)[indice_i - 1]
4327: .partie_imaginaire = (*((struct_complexe16 *)
4328: (*s_objet_1).objet)).partie_imaginaire;
4329: }
4330: else
4331: {
4332: if (variable_partagee == d_vrai)
4333: {
4334: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4335: .s_liste_variables_partagees).mutex)) != 0)
4336: {
4337: (*s_etat_processus).erreur_systeme =
4338: d_es_processus;
4339: return;
4340: }
4341: }
4342:
4343: liberation(s_etat_processus, s_objet_1);
4344: liberation(s_etat_processus, s_objet_2);
4345: liberation(s_etat_processus, s_objet_3);
4346:
4347: (*s_etat_processus).erreur_execution =
4348: d_ex_erreur_type_argument;
4349: return;
4350: }
4351: }
4352: else
4353: {
4354: /*
4355: * Vecteur de complexes
4356: */
4357:
4358: if ((*s_objet_1).type == INT)
4359: {
4360: /*
4361: * Conversion de l'élément à insérer en complexe
4362: */
4363:
4364: ((struct_complexe16 *) (*((struct_vecteur *)
4365: (*s_objet_4).objet)).tableau)[indice_i - 1]
4366: .partie_reelle = (real8) (*((integer8 *)
4367: (*s_objet_1).objet));
4368: ((struct_complexe16 *) (*((struct_vecteur *)
4369: (*s_objet_4).objet)).tableau)[indice_i - 1]
4370: .partie_imaginaire = (real8) 0;
4371: }
4372: else if ((*s_objet_1).type == REL)
4373: {
4374: /*
4375: * Conversion de l'élément à insérer en complexe
4376: */
4377:
4378: ((struct_complexe16 *) (*((struct_vecteur *)
4379: (*s_objet_4).objet)).tableau)[indice_i - 1]
4380: .partie_reelle = (*((real8 *) (*s_objet_1).objet));
4381: ((struct_complexe16 *) (*((struct_vecteur *)
4382: (*s_objet_4).objet)).tableau)[indice_i - 1]
4383: .partie_imaginaire = (real8) 0;
4384: }
4385: else if ((*s_objet_1).type == CPL)
4386: {
4387: /*
4388: * Aucune conversion de type
4389: */
4390:
4391: ((struct_complexe16 *) (*((struct_vecteur *)
4392: (*s_objet_4).objet)).tableau)[indice_i - 1]
4393: .partie_reelle = (*((struct_complexe16 *)
4394: (*s_objet_1).objet)).partie_reelle;
4395: ((struct_complexe16 *) (*((struct_vecteur *)
4396: (*s_objet_4).objet)).tableau)[indice_i - 1]
4397: .partie_imaginaire = (*((struct_complexe16 *)
4398: (*s_objet_1).objet)).partie_imaginaire;
4399: }
4400: else
4401: {
4402: if (variable_partagee == d_vrai)
4403: {
4404: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4405: .s_liste_variables_partagees).mutex)) != 0)
4406: {
4407: (*s_etat_processus).erreur_systeme =
4408: d_es_processus;
4409: return;
4410: }
4411: }
4412:
4413: liberation(s_etat_processus, s_objet_1);
4414: liberation(s_etat_processus, s_objet_2);
4415: liberation(s_etat_processus, s_objet_3);
4416:
4417: (*s_etat_processus).erreur_execution =
4418: d_ex_erreur_type_argument;
4419: return;
4420: }
4421: }
4422:
4423: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
4424: (indice_i % (*((struct_vecteur *) (*s_objet_4).objet))
4425: .taille) + 1;
4426:
4427: if (variable_partagee == d_faux)
4428: {
4429: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
4430: .position_variable_courante].objet = s_objet_4;
4431: }
4432: else
4433: {
4434: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
4435: .position_variable_courante].objet = NULL;
4436: (*(*s_etat_processus).s_liste_variables_partagees)
4437: .table[(*(*s_etat_processus)
4438: .s_liste_variables_partagees).position_variable].objet
4439: = s_objet_4;
4440:
4441: if (variable_partagee == d_vrai)
4442: {
4443: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4444: .s_liste_variables_partagees).mutex)) != 0)
4445: {
4446: (*s_etat_processus).erreur_systeme = d_es_processus;
4447: return;
4448: }
4449: }
4450: }
4451:
4452: liberation(s_etat_processus, s_objet_1);
4453: }
4454: else if (((*s_objet_4).type == MIN) ||
4455: ((*s_objet_4).type == MRL) ||
4456: ((*s_objet_4).type == MCX))
4457: {
4458: if ((*s_objet_2).type != LST)
4459: {
4460: if (variable_partagee == d_vrai)
4461: {
4462: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4463: .s_liste_variables_partagees).mutex)) != 0)
4464: {
4465: (*s_etat_processus).erreur_systeme = d_es_processus;
4466: return;
4467: }
4468: }
4469:
4470: liberation(s_etat_processus, s_objet_1);
4471: liberation(s_etat_processus, s_objet_2);
4472: liberation(s_etat_processus, s_objet_3);
4473:
4474: (*s_etat_processus).erreur_execution =
4475: d_ex_erreur_type_argument;
4476: return;
4477: }
4478:
4479: l_element_courant = (*s_objet_2).objet;
4480: nombre_dimensions = 0;
4481:
4482: while(l_element_courant != NULL)
4483: {
4484: nombre_dimensions++;
4485: l_element_courant = (*l_element_courant).suivant;
4486: }
4487:
4488: if (nombre_dimensions != 2)
4489: {
4490: if (variable_partagee == d_vrai)
4491: {
4492: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4493: .s_liste_variables_partagees).mutex)) != 0)
4494: {
4495: (*s_etat_processus).erreur_systeme = d_es_processus;
4496: return;
4497: }
4498: }
4499:
4500: liberation(s_etat_processus, s_objet_1);
4501: liberation(s_etat_processus, s_objet_2);
4502: liberation(s_etat_processus, s_objet_3);
4503:
4504: (*s_etat_processus).erreur_execution =
4505: d_ex_dimensions_invalides;
4506: return;
4507: }
4508:
4509: l_element_courant = (*s_objet_2).objet;
4510:
4511: indice_i = 0;
4512: indice_j = 0;
4513:
4514: while(l_element_courant != NULL)
4515: {
4516: if ((*(*l_element_courant).donnee).type != INT)
4517: {
4518: if (variable_partagee == d_vrai)
4519: {
4520: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4521: .s_liste_variables_partagees).mutex)) != 0)
4522: {
4523: (*s_etat_processus).erreur_systeme = d_es_processus;
4524: return;
4525: }
4526: }
4527:
4528: liberation(s_etat_processus, s_objet_1);
4529: liberation(s_etat_processus, s_objet_2);
4530: liberation(s_etat_processus, s_objet_3);
4531:
4532: (*s_etat_processus).erreur_execution =
4533: d_ex_erreur_type_argument;
4534: return;
4535: }
4536:
4537: if ((*((integer8 *) (*(*l_element_courant).donnee).objet))
4538: <= 0)
4539: {
4540: if (variable_partagee == d_vrai)
4541: {
4542: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4543: .s_liste_variables_partagees).mutex)) != 0)
4544: {
4545: (*s_etat_processus).erreur_systeme = d_es_processus;
4546: return;
4547: }
4548: }
4549:
4550: liberation(s_etat_processus, s_objet_1);
4551: liberation(s_etat_processus, s_objet_2);
4552: liberation(s_etat_processus, s_objet_3);
4553:
4554: (*s_etat_processus).erreur_execution =
4555: d_ex_argument_invalide;
4556: return;
4557: }
4558:
4559: if (indice_i == 0)
4560: {
4561: indice_i = (*((integer8 *)
4562: (*(*l_element_courant).donnee).objet));
4563: }
4564: else
4565: {
4566: indice_j = (*((integer8 *)
4567: (*(*l_element_courant).donnee).objet));
4568: }
4569:
4570: l_element_courant = (*l_element_courant).suivant;
4571: }
4572:
4573: if ((indice_i > (*((struct_matrice *) (*s_objet_4).objet))
4574: .nombre_lignes) || (indice_j > (*((struct_matrice *)
4575: (*s_objet_4).objet)).nombre_colonnes))
4576: {
4577: if (variable_partagee == d_vrai)
4578: {
4579: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4580: .s_liste_variables_partagees).mutex)) != 0)
4581: {
4582: (*s_etat_processus).erreur_systeme = d_es_processus;
4583: return;
4584: }
4585: }
4586:
4587: liberation(s_etat_processus, s_objet_1);
4588: liberation(s_etat_processus, s_objet_2);
4589: liberation(s_etat_processus, s_objet_3);
4590:
4591: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
4592: return;
4593: }
4594:
4595: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q'))
4596: == NULL)
4597: {
4598: if (variable_partagee == d_vrai)
4599: {
4600: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4601: .s_liste_variables_partagees).mutex)) != 0)
4602: {
4603: (*s_etat_processus).erreur_systeme = d_es_processus;
4604: return;
4605: }
4606: }
4607:
4608: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4609: return;
4610: }
4611:
4612: liberation(s_etat_processus, s_objet_4);
4613: s_objet_4 = s_copie_4;
4614:
4615: if ((*s_objet_4).type == MIN)
4616: {
4617: /*
4618: * Matrice d'entiers
4619: */
4620:
4621: if ((*s_objet_1).type == INT)
4622: {
4623: /*
4624: * Aucune conversion de type
4625: */
4626:
4627: ((integer8 **) (*((struct_matrice *) (*s_objet_4).objet))
4628: .tableau)[indice_i - 1][indice_j - 1] =
4629: (*((integer8 *) (*s_objet_1).objet));
4630: }
4631: else if ((*s_objet_1).type == REL)
4632: {
4633: /*
4634: * Conversion de la matrice en matrice réelle
4635: */
4636:
4637: tampon = (void *) ((integer8 **) (*((struct_matrice *)
4638: (*s_objet_4).objet)).tableau);
4639:
4640: (*((struct_matrice *) (*s_objet_4).objet)).type = 'R';
4641: (*s_objet_4).type = MRL;
4642:
4643: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
4644: = malloc((*((struct_matrice *)
4645: (*s_objet_4).objet)).nombre_lignes *
4646: sizeof(real8 *))) == NULL)
4647: {
4648: if (variable_partagee == d_vrai)
4649: {
4650: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4651: .s_liste_variables_partagees).mutex)) != 0)
4652: {
4653: (*s_etat_processus).erreur_systeme =
4654: d_es_processus;
4655: return;
4656: }
4657: }
4658:
4659: (*s_etat_processus).erreur_systeme =
4660: d_es_allocation_memoire;
4661: return;
4662: }
4663:
4664: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
4665: .nombre_lignes; i++)
4666: {
4667: if ((((real8 **) (*((struct_matrice *)
4668: (*s_objet_4).objet)).tableau)[i]
4669: = malloc((*((struct_matrice *)
4670: (*s_objet_4).objet)).nombre_colonnes *
4671: sizeof(real8))) == NULL)
4672: {
4673: if (variable_partagee == d_vrai)
4674: {
4675: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4676: .s_liste_variables_partagees).mutex))
4677: != 0)
4678: {
4679: (*s_etat_processus).erreur_systeme =
4680: d_es_processus;
4681: return;
4682: }
4683: }
4684:
4685: (*s_etat_processus).erreur_systeme =
4686: d_es_allocation_memoire;
4687: return;
4688: }
4689:
4690: for(j = 0; j < (*((struct_matrice *)
4691: (*s_objet_4).objet)).nombre_colonnes; j++)
4692: {
4693: ((real8 **) (*((struct_matrice *) (*s_objet_4)
4694: .objet)).tableau)[i][j] = (real8)
4695: (((integer8 **) tampon)[i][j]);
4696: }
4697:
4698: free(((integer8 **) tampon)[i]);
4699: }
4700:
4701: free((integer8 **) tampon);
4702:
4703: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
4704: .tableau)[indice_i - 1][indice_j - 1] =
4705: (*((real8 *) (*s_objet_1).objet));
4706: }
4707: else if ((*s_objet_1).type == CPL)
4708: {
4709: /*
4710: * Conversion de la matrice en matrice complexe
4711: */
4712:
4713: tampon = (void *) ((integer8 **) (*((struct_matrice *)
4714: (*s_objet_4).objet)).tableau);
4715:
4716: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C';
4717: (*s_objet_4).type = MCX;
4718:
4719: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
4720: = malloc((*((struct_matrice *)
4721: (*s_objet_4).objet)).nombre_lignes *
4722: sizeof(struct_complexe16 *))) == NULL)
4723: {
4724: if (variable_partagee == d_vrai)
4725: {
4726: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4727: .s_liste_variables_partagees).mutex)) != 0)
4728: {
4729: (*s_etat_processus).erreur_systeme =
4730: d_es_processus;
4731: return;
4732: }
4733: }
4734:
4735: (*s_etat_processus).erreur_systeme =
4736: d_es_allocation_memoire;
4737: return;
4738: }
4739:
4740: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
4741: .nombre_lignes; i++)
4742: {
4743: if ((((struct_complexe16 **) (*((struct_matrice *)
4744: (*s_objet_4).objet)).tableau)[i]
4745: = malloc((*((struct_matrice *)
4746: (*s_objet_4).objet)).nombre_colonnes *
4747: sizeof(struct_complexe16))) == NULL)
4748: {
4749: if (variable_partagee == d_vrai)
4750: {
4751: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4752: .s_liste_variables_partagees).mutex))
4753: != 0)
4754: {
4755: (*s_etat_processus).erreur_systeme =
4756: d_es_processus;
4757: return;
4758: }
4759: }
4760:
4761: (*s_etat_processus).erreur_systeme =
4762: d_es_allocation_memoire;
4763: return;
4764: }
4765:
4766: for(j = 0; j < (*((struct_matrice *)
4767: (*s_objet_4).objet)).nombre_colonnes; j++)
4768: {
4769: ((struct_complexe16 **) (*((struct_matrice *)
4770: (*s_objet_4).objet)).tableau)[i][j]
4771: .partie_reelle = (real8) (((integer8 **)
4772: tampon)[i][j]);
4773: ((struct_complexe16 **) (*((struct_matrice *)
4774: (*s_objet_4).objet)).tableau)[i][j]
4775: .partie_imaginaire = (real8) 0;
4776: }
4777:
4778: free(((integer8 **) tampon)[i]);
4779: }
4780:
4781: free((integer8 **) tampon);
4782:
4783: ((struct_complexe16 **) (*((struct_matrice *)
4784: (*s_objet_4).objet)).tableau)[indice_i - 1]
4785: [indice_j - 1].partie_reelle =
4786: (*((struct_complexe16 *)
4787: (*s_objet_1).objet)).partie_reelle;
4788: ((struct_complexe16 **) (*((struct_matrice *)
4789: (*s_objet_4).objet)).tableau)[indice_i - 1]
4790: [indice_j - 1].partie_imaginaire =
4791: (*((struct_complexe16 *)
4792: (*s_objet_1).objet)).partie_imaginaire;
4793: }
4794: else
4795: {
4796: if (variable_partagee == d_vrai)
4797: {
4798: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4799: .s_liste_variables_partagees).mutex)) != 0)
4800: {
4801: (*s_etat_processus).erreur_systeme =
4802: d_es_processus;
4803: return;
4804: }
4805: }
4806:
4807: liberation(s_etat_processus, s_objet_1);
4808: liberation(s_etat_processus, s_objet_2);
4809: liberation(s_etat_processus, s_objet_3);
4810:
4811: (*s_etat_processus).erreur_execution =
4812: d_ex_erreur_type_argument;
4813: return;
4814: }
4815: }
4816: else if ((*s_objet_4).type == MRL)
4817: {
4818: /*
4819: * Matrice de réels
4820: */
4821:
4822: if ((*s_objet_1).type == INT)
4823: {
4824: /*
4825: * Conversion de l'élément à insérer en réel
4826: */
4827:
4828: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
4829: .tableau)[indice_i - 1][indice_j - 1] =
4830: (real8) (*((integer8 *) (*s_objet_1).objet));
4831: }
4832: else if ((*s_objet_1).type == REL)
4833: {
4834: /*
4835: * Aucune conversion de type
4836: */
4837:
4838: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
4839: .tableau)[indice_i - 1][indice_j - 1] =
4840: (*((real8 *) (*s_objet_1).objet));
4841: }
4842: else if ((*s_objet_1).type == CPL)
4843: {
4844: /*
4845: * Conversion de la matrice en matrice complexe
4846: */
4847:
4848: tampon = (void *) ((real8 **) (*((struct_matrice *)
4849: (*s_objet_4).objet)).tableau);
4850:
4851: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C';
4852: (*s_objet_4).type = MCX;
4853:
4854: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
4855: = malloc((*((struct_matrice *)
4856: (*s_objet_4).objet)).nombre_lignes *
4857: sizeof(struct_complexe16 *))) == NULL)
4858: {
4859: if (variable_partagee == d_vrai)
4860: {
4861: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4862: .s_liste_variables_partagees).mutex)) != 0)
4863: {
4864: (*s_etat_processus).erreur_systeme =
4865: d_es_processus;
4866: return;
4867: }
4868: }
4869:
4870: (*s_etat_processus).erreur_systeme =
4871: d_es_allocation_memoire;
4872: return;
4873: }
4874:
4875: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
4876: .nombre_lignes; i++)
4877: {
4878: if ((((struct_complexe16 **) (*((struct_matrice *)
4879: (*s_objet_4).objet)).tableau)[i]
4880: = malloc((*((struct_matrice *)
4881: (*s_objet_4).objet)).nombre_colonnes *
4882: sizeof(struct_complexe16))) == NULL)
4883: {
4884: if (variable_partagee == d_vrai)
4885: {
4886: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4887: .s_liste_variables_partagees).mutex))
4888: != 0)
4889: {
4890: (*s_etat_processus).erreur_systeme =
4891: d_es_processus;
4892: return;
4893: }
4894: }
4895:
4896: (*s_etat_processus).erreur_systeme =
4897: d_es_allocation_memoire;
4898: return;
4899: }
4900:
4901: for(j = 0; j < (*((struct_matrice *)
4902: (*s_objet_4).objet)).nombre_colonnes; j++)
4903: {
4904: ((struct_complexe16 **) (*((struct_matrice *)
4905: (*s_objet_4).objet)).tableau)[i][j]
4906: .partie_reelle = (((real8 **)
4907: tampon)[i][j]);
4908: ((struct_complexe16 **) (*((struct_matrice *)
4909: (*s_objet_4).objet)).tableau)[i][j]
4910: .partie_imaginaire = (real8) 0;
4911: }
4912:
4913: free(((integer8 **) tampon)[i]);
4914: }
4915:
4916: free((integer8 **) tampon);
4917:
4918: ((struct_complexe16 **) (*((struct_matrice *)
4919: (*s_objet_4).objet)).tableau)[indice_i - 1]
4920: [indice_j - 1].partie_reelle =
4921: (*((struct_complexe16 *)
4922: (*s_objet_1).objet)).partie_reelle;
4923: ((struct_complexe16 **) (*((struct_matrice *)
4924: (*s_objet_4).objet)).tableau)[indice_i - 1]
4925: [indice_j - 1].partie_imaginaire =
4926: (*((struct_complexe16 *)
4927: (*s_objet_1).objet)).partie_imaginaire;
4928: }
4929: else
4930: {
4931: if (variable_partagee == d_vrai)
4932: {
4933: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4934: .s_liste_variables_partagees).mutex))
4935: != 0)
4936: {
4937: (*s_etat_processus).erreur_systeme =
4938: d_es_processus;
4939: return;
4940: }
4941: }
4942:
4943: liberation(s_etat_processus, s_objet_1);
4944: liberation(s_etat_processus, s_objet_2);
4945: liberation(s_etat_processus, s_objet_3);
4946:
4947: (*s_etat_processus).erreur_execution =
4948: d_ex_erreur_type_argument;
4949: return;
4950: }
4951: }
4952: else
4953: {
4954: /*
4955: * Matrice de complexes
4956: */
4957:
4958: if ((*s_objet_1).type == INT)
4959: {
4960: /*
4961: * Conversion de l'élément à insérer en complexe
4962: */
4963:
4964: ((struct_complexe16 **) (*((struct_matrice *)
4965: (*s_objet_4).objet)).tableau)[indice_i - 1]
4966: [indice_j - 1].partie_reelle = (real8)
4967: (*((integer8 *) (*s_objet_1).objet));
4968: ((struct_complexe16 **) (*((struct_matrice *)
4969: (*s_objet_4).objet)).tableau)[indice_i - 1]
4970: [indice_j - 1].partie_imaginaire = (real8) 0;
4971: }
4972: else if ((*s_objet_1).type == REL)
4973: {
4974: /*
4975: * Conversion de l'élément à insérer en complexe
4976: */
4977:
4978: ((struct_complexe16 **) (*((struct_matrice *)
4979: (*s_objet_4).objet)).tableau)[indice_i - 1]
4980: [indice_j - 1].partie_reelle =
4981: (*((real8 *) (*s_objet_1).objet));
4982: ((struct_complexe16 **) (*((struct_matrice *)
4983: (*s_objet_4).objet)).tableau)[indice_i - 1]
4984: [indice_j - 1].partie_imaginaire = (real8) 0;
4985: }
4986: else if ((*s_objet_1).type == CPL)
4987: {
4988: /*
4989: * Aucune conversion de type
4990: */
4991:
4992: ((struct_complexe16 **) (*((struct_matrice *)
4993: (*s_objet_4).objet)).tableau)[indice_i - 1]
4994: [indice_j - 1].partie_reelle =
4995: (*((struct_complexe16 *)
4996: (*s_objet_1).objet)).partie_reelle;
4997: ((struct_complexe16 **) (*((struct_matrice *)
4998: (*s_objet_4).objet)).tableau)[indice_i - 1]
4999: [indice_j - 1].partie_imaginaire =
5000: (*((struct_complexe16 *)
5001: (*s_objet_1).objet)).partie_imaginaire;
5002: }
5003: else
5004: {
5005: if (variable_partagee == d_vrai)
5006: {
5007: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5008: .s_liste_variables_partagees).mutex))
5009: != 0)
5010: {
5011: (*s_etat_processus).erreur_systeme =
5012: d_es_processus;
5013: return;
5014: }
5015: }
5016:
5017: liberation(s_etat_processus, s_objet_1);
5018: liberation(s_etat_processus, s_objet_2);
5019: liberation(s_etat_processus, s_objet_3);
5020:
5021: (*s_etat_processus).erreur_execution =
5022: d_ex_erreur_type_argument;
5023: return;
5024: }
5025: }
5026:
5027: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
5028: (*s_objet_2).objet)).suivant).donnee).objet))) > (integer8)
5029: (*((struct_matrice *) (*s_objet_4).objet)).nombre_colonnes)
5030: {
5031: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_2)
5032: .objet)).suivant).donnee).objet)) = 1;
5033:
5034: if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
5035: (*s_objet_2).objet)).donnee).objet))) > (integer8)
5036: (*((struct_matrice *) (*s_objet_4).objet))
5037: .nombre_lignes)
5038: {
5039: (*((integer8 *) (*(*((struct_liste_chainee *)
5040: (*s_objet_2).objet)).donnee).objet)) = 1;
5041: }
5042: }
5043:
5044: if (variable_partagee == d_faux)
5045: {
5046: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
5047: .position_variable_courante].objet = s_objet_4;
5048: }
5049: else
5050: {
5051: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
5052: .position_variable_courante].objet = NULL;
5053: (*(*s_etat_processus).s_liste_variables_partagees).table
5054: [(*(*s_etat_processus).s_liste_variables_partagees)
5055: .position_variable].objet = s_objet_4;
5056:
5057: if (variable_partagee == d_vrai)
5058: {
5059: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5060: .s_liste_variables_partagees).mutex)) != 0)
5061: {
5062: (*s_etat_processus).erreur_systeme =
5063: d_es_processus;
5064: return;
5065: }
5066: }
5067: }
5068:
5069: liberation(s_etat_processus, s_objet_1);
5070: }
5071: else if ((*s_objet_4).type == LST)
5072: {
5073: if ((*s_objet_2).type != INT)
5074: {
5075: if (variable_partagee == d_vrai)
5076: {
5077: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5078: .s_liste_variables_partagees).mutex)) != 0)
5079: {
5080: (*s_etat_processus).erreur_systeme =
5081: d_es_processus;
5082: return;
5083: }
5084: }
5085:
5086: liberation(s_etat_processus, s_objet_1);
5087: liberation(s_etat_processus, s_objet_2);
5088: liberation(s_etat_processus, s_objet_3);
5089:
5090: (*s_etat_processus).erreur_execution =
5091: d_ex_erreur_type_argument;
5092: return;
5093: }
5094:
5095: indice_i = (*((integer8 *) (*s_objet_2).objet));
5096: indice_j = 1;
5097:
5098: if ((*s_objet_4).nombre_occurrences > 1)
5099: {
5100: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N'))
5101: == NULL)
5102: {
5103: if (variable_partagee == d_vrai)
5104: {
5105: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5106: .s_liste_variables_partagees).mutex)) != 0)
5107: {
5108: (*s_etat_processus).erreur_systeme =
5109: d_es_processus;
5110: return;
5111: }
5112: }
5113:
5114: (*s_etat_processus).erreur_systeme =
5115: d_es_allocation_memoire;
5116: return;
5117: }
5118:
5119: liberation(s_etat_processus, s_objet_4);
5120: s_objet_4 = s_copie_4;
5121: }
5122:
5123: l_element_courant = (*s_objet_4).objet;
5124: nombre_elements = 0;
5125:
5126: while(l_element_courant != NULL)
5127: {
5128: l_element_courant = (*l_element_courant).suivant;
5129: nombre_elements++;
5130: }
5131:
5132: l_element_courant = (*s_objet_4).objet;
5133:
5134: while((l_element_courant != NULL) && (indice_j != indice_i))
5135: {
5136: l_element_courant = (*l_element_courant).suivant;
5137: indice_j++;
5138: }
5139:
5140: if (l_element_courant != NULL)
5141: {
5142: liberation(s_etat_processus, (*l_element_courant).donnee);
5143: (*l_element_courant).donnee = s_objet_1;
5144: }
5145: else
5146: {
5147: if (variable_partagee == d_vrai)
5148: {
5149: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5150: .s_liste_variables_partagees).mutex)) != 0)
5151: {
5152: (*s_etat_processus).erreur_systeme =
5153: d_es_processus;
5154: return;
5155: }
5156: }
5157:
5158: liberation(s_etat_processus, s_objet_1);
5159: liberation(s_etat_processus, s_objet_2);
5160: liberation(s_etat_processus, s_objet_3);
5161:
5162: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
5163: return;
5164: }
5165:
5166: (*((integer8 *) (*s_objet_2).objet)) =
5167: (indice_i % nombre_elements) + 1;
5168:
5169: if (variable_partagee == d_faux)
5170: {
5171: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
5172: .position_variable_courante].objet = s_objet_4;
5173: }
5174: else
5175: {
5176: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
5177: .position_variable_courante].objet = NULL;
5178: (*(*s_etat_processus).s_liste_variables_partagees).table
5179: [(*(*s_etat_processus).s_liste_variables_partagees)
5180: .position_variable].objet = s_objet_4;
5181:
5182: if (variable_partagee == d_vrai)
5183: {
5184: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5185: .s_liste_variables_partagees).mutex)) != 0)
5186: {
5187: (*s_etat_processus).erreur_systeme =
5188: d_es_processus;
5189: return;
5190: }
5191: }
5192: }
5193: }
5194: else
5195: {
5196: if (variable_partagee == d_vrai)
5197: {
5198: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5199: .s_liste_variables_partagees).mutex)) != 0)
5200: {
5201: (*s_etat_processus).erreur_systeme =
5202: d_es_processus;
5203: return;
5204: }
5205: }
5206:
5207: liberation(s_etat_processus, s_objet_1);
5208: liberation(s_etat_processus, s_objet_2);
5209: liberation(s_etat_processus, s_objet_3);
5210:
5211: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
5212: return;
5213: }
5214:
5215: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5216: s_objet_3) == d_erreur)
5217: {
5218: return;
5219: }
5220:
5221: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5222: s_objet_2) == d_erreur)
5223: {
5224: return;
5225: }
5226: }
5227:
5228: /*
5229: --------------------------------------------------------------------------------
5230: Arguments incompatibles
5231: --------------------------------------------------------------------------------
5232: */
5233:
5234: else
5235: {
5236: liberation(s_etat_processus, s_objet_1);
5237: liberation(s_etat_processus, s_objet_2);
5238: liberation(s_etat_processus, s_objet_3);
5239:
5240: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
5241: return;
5242: }
5243:
5244: return;
5245: }
5246:
5247: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_p2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src