![[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|
Return to instructions_p2.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.36 ! bertrand 3: RPL/2 (R) version 4.1.9
1.32 bertrand 4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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: {
1.17 bertrand 41: double angle;
42:
1.1 bertrand 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:
1.17 bertrand 141: angle = (*((struct_complexe16 *) (*s_objet_argument).objet))
142: .partie_imaginaire;
143:
1.1 bertrand 144: if (test_cfsf(s_etat_processus, 60) == d_faux)
145: {
1.17 bertrand 146: conversion_degres_vers_radians(&angle);
1.1 bertrand 147: }
148:
149: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
150: (*((struct_complexe16 *) (*s_objet_argument).objet))
1.17 bertrand 151: .partie_reelle * cos(angle);
1.1 bertrand 152: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_imaginaire =
153: (*((struct_complexe16 *) (*s_objet_argument).objet))
1.17 bertrand 154: .partie_reelle * sin(angle);
1.1 bertrand 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:
1.20 bertrand 1441: if ((*(*s_etat_processus).pointeur_variable_courante)
1442: .variable_verrouillee == d_vrai)
1.1 bertrand 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:
1.20 bertrand 1453: s_objet_4 = (*(*s_etat_processus).pointeur_variable_courante).objet;
1.1 bertrand 1454:
1455: if (s_objet_4 == NULL)
1456: {
1457: if (pthread_mutex_lock(&((*(*s_etat_processus)
1458: .s_liste_variables_partagees).mutex)) != 0)
1459: {
1460: (*s_etat_processus).erreur_systeme = d_es_processus;
1461: return;
1462: }
1463:
1464: if (recherche_variable_partagee(s_etat_processus,
1.20 bertrand 1465: (*(*s_etat_processus).pointeur_variable_courante).nom,
1466: (*(*s_etat_processus).pointeur_variable_courante)
1467: .variable_partagee, (*(*s_etat_processus)
1468: .pointeur_variable_courante).origine) == d_faux)
1.1 bertrand 1469: {
1470: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1471: .s_liste_variables_partagees).mutex)) != 0)
1472: {
1473: (*s_etat_processus).erreur_systeme = d_es_processus;
1474: return;
1475: }
1476:
1477: (*s_etat_processus).erreur_systeme = d_es;
1478: (*s_etat_processus).erreur_execution =
1479: d_ex_variable_non_definie;
1480:
1481: liberation(s_etat_processus, s_objet_1);
1482: liberation(s_etat_processus, s_objet_2);
1483: liberation(s_etat_processus, s_objet_3);
1484:
1485: return;
1486: }
1487:
1488: s_objet_4 = (*(*s_etat_processus).s_liste_variables_partagees)
1489: .table[(*(*s_etat_processus).s_liste_variables_partagees)
1490: .position_variable].objet;
1491: variable_partagee = d_vrai;
1492: }
1493:
1494: if (((*s_objet_4).type == VIN) ||
1495: ((*s_objet_4).type == VRL) ||
1496: ((*s_objet_4).type == VCX))
1497: {
1498: if ((*s_objet_2).type != LST)
1499: {
1500: if (variable_partagee == d_vrai)
1501: {
1502: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1503: .s_liste_variables_partagees).mutex)) != 0)
1504: {
1505: (*s_etat_processus).erreur_systeme = d_es_processus;
1506: return;
1507: }
1508: }
1509:
1510: liberation(s_etat_processus, s_objet_1);
1511: liberation(s_etat_processus, s_objet_2);
1512: liberation(s_etat_processus, s_objet_3);
1513:
1514: (*s_etat_processus).erreur_execution =
1515: d_ex_erreur_type_argument;
1516: return;
1517: }
1518:
1519: l_element_courant = (*s_objet_2).objet;
1520: nombre_dimensions = 0;
1521:
1522: while(l_element_courant != NULL)
1523: {
1524: nombre_dimensions++;
1525: l_element_courant = (*l_element_courant).suivant;
1526: }
1527:
1528: if (nombre_dimensions != 1)
1529: {
1530: if (variable_partagee == d_vrai)
1531: {
1532: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1533: .s_liste_variables_partagees).mutex)) != 0)
1534: {
1535: (*s_etat_processus).erreur_systeme = d_es_processus;
1536: return;
1537: }
1538: }
1539:
1540: liberation(s_etat_processus, s_objet_1);
1541: liberation(s_etat_processus, s_objet_2);
1542: liberation(s_etat_processus, s_objet_3);
1543:
1544: (*s_etat_processus).erreur_execution =
1545: d_ex_dimensions_invalides;
1546: return;
1547: }
1548:
1549: l_element_courant = (*s_objet_2).objet;
1550:
1551: if ((*(*l_element_courant).donnee).type != INT)
1552: {
1553: if (variable_partagee == d_vrai)
1554: {
1555: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1556: .s_liste_variables_partagees).mutex)) != 0)
1557: {
1558: (*s_etat_processus).erreur_systeme = d_es_processus;
1559: return;
1560: }
1561: }
1562:
1563: liberation(s_etat_processus, s_objet_1);
1564: liberation(s_etat_processus, s_objet_2);
1565: liberation(s_etat_processus, s_objet_3);
1566:
1567: (*s_etat_processus).erreur_execution =
1568: d_ex_erreur_type_argument;
1569: return;
1570: }
1571:
1572: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
1573: {
1574: if (variable_partagee == d_vrai)
1575: {
1576: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1577: .s_liste_variables_partagees).mutex)) != 0)
1578: {
1579: (*s_etat_processus).erreur_systeme = d_es_processus;
1580: return;
1581: }
1582: }
1583:
1584: liberation(s_etat_processus, s_objet_1);
1585: liberation(s_etat_processus, s_objet_2);
1586: liberation(s_etat_processus, s_objet_3);
1587:
1588: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1589: return;
1590: }
1591: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
1592: (integer8) (*((struct_vecteur *) (*s_objet_4).objet))
1593: .taille)
1594: {
1595: if (variable_partagee == d_vrai)
1596: {
1597: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1598: .s_liste_variables_partagees).mutex)) != 0)
1599: {
1600: (*s_etat_processus).erreur_systeme = d_es_processus;
1601: return;
1602: }
1603: }
1604:
1605: liberation(s_etat_processus, s_objet_1);
1606: liberation(s_etat_processus, s_objet_2);
1607: liberation(s_etat_processus, s_objet_3);
1608:
1609: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1610: return;
1611: }
1612:
1613: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
1614:
1615: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q'))
1616: == NULL)
1617: {
1618: if (variable_partagee == d_vrai)
1619: {
1620: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1621: .s_liste_variables_partagees).mutex)) != 0)
1622: {
1623: (*s_etat_processus).erreur_systeme = d_es_processus;
1624: return;
1625: }
1626: }
1627:
1628: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1629: return;
1630: }
1631:
1632: liberation(s_etat_processus, s_objet_4);
1633: s_objet_4 = s_copie_4;
1634:
1635: if ((*s_objet_4).type == VIN)
1636: {
1637: /*
1638: * Vecteur d'entiers
1639: */
1640:
1641: if ((*s_objet_1).type == INT)
1642: {
1643: /*
1644: * Aucune conversion de type
1645: */
1646:
1647: ((integer8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1648: .tableau)[indice_i - 1] = (*((integer8 *)
1649: (*s_objet_1).objet));
1650: }
1651: else if ((*s_objet_1).type == REL)
1652: {
1653: /*
1654: * Conversion du vecteur en vecteur réel
1655: */
1656:
1657: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
1658: (*s_objet_4).objet)).tableau);
1659:
1660: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'R';
1661: (*s_objet_4).type = VRL;
1662:
1663: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
1664: = malloc((*((struct_vecteur *)
1665: (*s_objet_4).objet)).taille * sizeof(real8)))
1666: == NULL)
1667: {
1668: if (variable_partagee == d_vrai)
1669: {
1670: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1671: .s_liste_variables_partagees).mutex)) != 0)
1672: {
1673: (*s_etat_processus).erreur_systeme =
1674: d_es_processus;
1675: return;
1676: }
1677: }
1678:
1679: (*s_etat_processus).erreur_systeme =
1680: d_es_allocation_memoire;
1681: return;
1682: }
1683:
1684: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
1685: .taille; i++)
1686: {
1687: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1688: .tableau)[i] = (real8) (((integer8 *)
1689: tampon)[i]);
1690: }
1691:
1692: free((integer8 *) tampon);
1693:
1694: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1695: .tableau)[indice_i - 1] = (*((real8 *)
1696: (*s_objet_1).objet));
1697: }
1698: else if ((*s_objet_1).type == CPL)
1699: {
1700: /*
1701: * Conversion du vecteur en vecteur complexe
1702: */
1703:
1704: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
1705: (*s_objet_4).objet)).tableau);
1706:
1707: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C';
1708: (*s_objet_4).type = VCX;
1709:
1710: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
1711: = malloc((*((struct_vecteur *)
1712: (*s_objet_4).objet)).taille *
1713: sizeof(struct_complexe16))) == NULL)
1714: {
1715: if (variable_partagee == d_vrai)
1716: {
1717: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1718: .s_liste_variables_partagees).mutex)) != 0)
1719: {
1720: (*s_etat_processus).erreur_systeme =
1721: d_es_processus;
1722: return;
1723: }
1724: }
1725:
1726: (*s_etat_processus).erreur_systeme =
1727: d_es_allocation_memoire;
1728: return;
1729: }
1730:
1731: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
1732: .taille; i++)
1733: {
1734: ((struct_complexe16 *) (*((struct_vecteur *)
1735: (*s_objet_4).objet)).tableau)[i].partie_reelle =
1736: (real8) (((integer8 *) tampon)[i]);
1737: ((struct_complexe16 *) (*((struct_vecteur *)
1738: (*s_objet_4).objet)).tableau)[i]
1739: .partie_imaginaire = (real8) 0;
1740: }
1741:
1742: free((integer8 *) tampon);
1743:
1744: ((struct_complexe16 *) (*((struct_vecteur *)
1745: (*s_objet_4).objet)).tableau)[indice_i - 1]
1746: .partie_reelle = (*((struct_complexe16 *)
1747: (*s_objet_1).objet)).partie_reelle;
1748: ((struct_complexe16 *) (*((struct_vecteur *)
1749: (*s_objet_4).objet)).tableau)[indice_i - 1]
1750: .partie_imaginaire = (*((struct_complexe16 *)
1751: (*s_objet_1).objet)).partie_imaginaire;
1752: }
1753: else
1754: {
1755: if (variable_partagee == d_vrai)
1756: {
1757: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1758: .s_liste_variables_partagees).mutex)) != 0)
1759: {
1760: (*s_etat_processus).erreur_systeme =
1761: d_es_processus;
1762: return;
1763: }
1764: }
1765:
1766: liberation(s_etat_processus, s_objet_1);
1767: liberation(s_etat_processus, s_objet_2);
1768: liberation(s_etat_processus, s_objet_3);
1769:
1770: (*s_etat_processus).erreur_execution =
1771: d_ex_erreur_type_argument;
1772: return;
1773: }
1774: }
1775: else if ((*s_objet_4).type == VRL)
1776: {
1777: /*
1778: * Vecteur de réels
1779: */
1780:
1781: if ((*s_objet_1).type == INT)
1782: {
1783: /*
1784: * Conversion de l'élément à insérer en réel
1785: */
1786:
1787: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1788: .tableau)[indice_i - 1] = (real8) (*((integer8 *)
1789: (*s_objet_1).objet));
1790: }
1791: else if ((*s_objet_1).type == REL)
1792: {
1793: /*
1794: * Aucune conversion de type
1795: */
1796:
1797: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
1798: .tableau)[indice_i - 1] = (*((real8 *)
1799: (*s_objet_1).objet));
1800: }
1801: else if ((*s_objet_1).type == CPL)
1802: {
1803: /*
1804: * Conversion du vecteur en vecteur complexe
1805: */
1806:
1807: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
1808: (*s_objet_4).objet)).tableau);
1809:
1810: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C';
1811: (*s_objet_4).type = VCX;
1812:
1813: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
1814: = malloc((*((struct_vecteur *)
1815: (*s_objet_4).objet)).taille *
1816: sizeof(struct_complexe16))) == NULL)
1817: {
1818: if (variable_partagee == d_vrai)
1819: {
1820: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1821: .s_liste_variables_partagees).mutex)) != 0)
1822: {
1823: (*s_etat_processus).erreur_systeme =
1824: d_es_processus;
1825: return;
1826: }
1827: }
1828:
1829: (*s_etat_processus).erreur_systeme =
1830: d_es_allocation_memoire;
1831: return;
1832: }
1833:
1834: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
1835: .taille; i++)
1836: {
1837: ((struct_complexe16 *) (*((struct_vecteur *)
1838: (*s_objet_4).objet)).tableau)[i].partie_reelle =
1839: ((real8 *) tampon)[i];
1840: ((struct_complexe16 *) (*((struct_vecteur *)
1841: (*s_objet_4).objet)).tableau)[i]
1842: .partie_imaginaire = (real8) 0;
1843: }
1844:
1845: free((real8 *) tampon);
1846:
1847: ((struct_complexe16 *) (*((struct_vecteur *)
1848: (*s_objet_4).objet)).tableau)[indice_i - 1]
1849: .partie_reelle = (*((struct_complexe16 *)
1850: (*s_objet_1).objet)).partie_reelle;
1851: ((struct_complexe16 *) (*((struct_vecteur *)
1852: (*s_objet_4).objet)).tableau)[indice_i - 1]
1853: .partie_imaginaire = (*((struct_complexe16 *)
1854: (*s_objet_1).objet)).partie_imaginaire;
1855: }
1856: else
1857: {
1858: if (variable_partagee == d_vrai)
1859: {
1860: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1861: .s_liste_variables_partagees).mutex)) != 0)
1862: {
1863: (*s_etat_processus).erreur_systeme =
1864: d_es_processus;
1865: return;
1866: }
1867: }
1868:
1869: liberation(s_etat_processus, s_objet_1);
1870: liberation(s_etat_processus, s_objet_2);
1871: liberation(s_etat_processus, s_objet_3);
1872:
1873: (*s_etat_processus).erreur_execution =
1874: d_ex_erreur_type_argument;
1875: return;
1876: }
1877: }
1878: else
1879: {
1880: /*
1881: * Vecteur de complexes
1882: */
1883:
1884: if ((*s_objet_1).type == INT)
1885: {
1886: /*
1887: * Conversion de l'élément à insérer en complexe
1888: */
1889:
1890: ((struct_complexe16 *) (*((struct_vecteur *)
1891: (*s_objet_4).objet)).tableau)[indice_i - 1]
1892: .partie_reelle = (real8) (*((integer8 *)
1893: (*s_objet_1).objet));
1894: ((struct_complexe16 *) (*((struct_vecteur *)
1895: (*s_objet_4).objet)).tableau)[indice_i - 1]
1896: .partie_imaginaire = (real8) 0;
1897: }
1898: else if ((*s_objet_1).type == REL)
1899: {
1900: /*
1901: * Conversion de l'élément à insérer en complexe
1902: */
1903:
1904: ((struct_complexe16 *) (*((struct_vecteur *)
1905: (*s_objet_4).objet)).tableau)[indice_i - 1]
1906: .partie_reelle = (*((real8 *) (*s_objet_1).objet));
1907: ((struct_complexe16 *) (*((struct_vecteur *)
1908: (*s_objet_4).objet)).tableau)[indice_i - 1]
1909: .partie_imaginaire = (real8) 0;
1910: }
1911: else if ((*s_objet_1).type == CPL)
1912: {
1913: /*
1914: * Aucune conversion de type
1915: */
1916:
1917: ((struct_complexe16 *) (*((struct_vecteur *)
1918: (*s_objet_4).objet)).tableau)[indice_i - 1]
1919: .partie_reelle = (*((struct_complexe16 *)
1920: (*s_objet_1).objet)).partie_reelle;
1921: ((struct_complexe16 *) (*((struct_vecteur *)
1922: (*s_objet_4).objet)).tableau)[indice_i - 1]
1923: .partie_imaginaire = (*((struct_complexe16 *)
1924: (*s_objet_1).objet)).partie_imaginaire;
1925: }
1926: else
1927: {
1928: if (variable_partagee == d_vrai)
1929: {
1930: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1931: .s_liste_variables_partagees).mutex)) != 0)
1932: {
1933: (*s_etat_processus).erreur_systeme =
1934: d_es_processus;
1935: return;
1936: }
1937: }
1938:
1939: liberation(s_etat_processus, s_objet_1);
1940: liberation(s_etat_processus, s_objet_2);
1941: liberation(s_etat_processus, s_objet_3);
1942:
1943: (*s_etat_processus).erreur_execution =
1944: d_ex_erreur_type_argument;
1945: return;
1946: }
1947: }
1948:
1949: if (variable_partagee == d_faux)
1950: {
1.20 bertrand 1951: (*(*s_etat_processus).pointeur_variable_courante).objet =
1952: s_objet_4;
1.1 bertrand 1953: }
1954: else
1955: {
1.20 bertrand 1956: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1.1 bertrand 1957: (*(*s_etat_processus).s_liste_variables_partagees).table
1958: [(*(*s_etat_processus).s_liste_variables_partagees)
1959: .position_variable].objet = s_objet_4;
1960:
1961: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1962: .s_liste_variables_partagees).mutex)) != 0)
1963: {
1964: (*s_etat_processus).erreur_systeme = d_es_processus;
1965: return;
1966: }
1967: }
1968:
1969: liberation(s_etat_processus, s_objet_1);
1970: liberation(s_etat_processus, s_objet_2);
1971: liberation(s_etat_processus, s_objet_3);
1972: }
1973: else if (((*s_objet_4).type == MIN) ||
1974: ((*s_objet_4).type == MRL) ||
1975: ((*s_objet_4).type == MCX))
1976: {
1977: if ((*s_objet_2).type != LST)
1978: {
1979: if (variable_partagee == d_vrai)
1980: {
1981: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1982: .s_liste_variables_partagees).mutex)) != 0)
1983: {
1984: (*s_etat_processus).erreur_systeme = d_es_processus;
1985: return;
1986: }
1987: }
1988:
1989: liberation(s_etat_processus, s_objet_1);
1990: liberation(s_etat_processus, s_objet_2);
1991: liberation(s_etat_processus, s_objet_3);
1992:
1993: (*s_etat_processus).erreur_execution =
1994: d_ex_erreur_type_argument;
1995: return;
1996: }
1997:
1998: l_element_courant = (*s_objet_2).objet;
1999: nombre_dimensions = 0;
2000:
2001: while(l_element_courant != NULL)
2002: {
2003: nombre_dimensions++;
2004: l_element_courant = (*l_element_courant).suivant;
2005: }
2006:
2007: if (nombre_dimensions != 2)
2008: {
2009: if (variable_partagee == d_vrai)
2010: {
2011: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2012: .s_liste_variables_partagees).mutex)) != 0)
2013: {
2014: (*s_etat_processus).erreur_systeme = d_es_processus;
2015: return;
2016: }
2017: }
2018:
2019: liberation(s_etat_processus, s_objet_1);
2020: liberation(s_etat_processus, s_objet_2);
2021: liberation(s_etat_processus, s_objet_3);
2022:
2023: (*s_etat_processus).erreur_execution =
2024: d_ex_dimensions_invalides;
2025: return;
2026: }
2027:
2028: l_element_courant = (*s_objet_2).objet;
2029:
2030: indice_i = 0;
2031: indice_j = 0;
2032:
2033: while(l_element_courant != NULL)
2034: {
2035: if ((*(*l_element_courant).donnee).type != INT)
2036: {
2037: if (variable_partagee == d_vrai)
2038: {
2039: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2040: .s_liste_variables_partagees).mutex)) != 0)
2041: {
2042: (*s_etat_processus).erreur_systeme = d_es_processus;
2043: return;
2044: }
2045: }
2046:
2047: liberation(s_etat_processus, s_objet_1);
2048: liberation(s_etat_processus, s_objet_2);
2049: liberation(s_etat_processus, s_objet_3);
2050:
2051: (*s_etat_processus).erreur_execution =
2052: d_ex_erreur_type_argument;
2053: return;
2054: }
2055:
2056: if ((*((integer8 *) (*(*l_element_courant).donnee).objet))
2057: <= 0)
2058: {
2059: if (variable_partagee == d_vrai)
2060: {
2061: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2062: .s_liste_variables_partagees).mutex)) != 0)
2063: {
2064: (*s_etat_processus).erreur_systeme = d_es_processus;
2065: return;
2066: }
2067: }
2068:
2069: liberation(s_etat_processus, s_objet_1);
2070: liberation(s_etat_processus, s_objet_2);
2071: liberation(s_etat_processus, s_objet_3);
2072:
2073: (*s_etat_processus).erreur_execution =
2074: d_ex_argument_invalide;
2075: return;
2076: }
2077:
2078: if (indice_i == 0)
2079: {
2080: indice_i = (*((integer8 *)
2081: (*(*l_element_courant).donnee).objet));
2082: }
2083: else
2084: {
2085: indice_j = (*((integer8 *)
2086: (*(*l_element_courant).donnee).objet));
2087: }
2088:
2089: l_element_courant = (*l_element_courant).suivant;
2090: }
2091:
2092: if ((indice_i > (*((struct_matrice *) (*s_objet_4).objet))
2093: .nombre_lignes) || (indice_j > (*((struct_matrice *)
2094: (*s_objet_4).objet)).nombre_colonnes))
2095: {
2096: if (variable_partagee == d_vrai)
2097: {
2098: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2099: .s_liste_variables_partagees).mutex)) != 0)
2100: {
2101: (*s_etat_processus).erreur_systeme = d_es_processus;
2102: return;
2103: }
2104: }
2105:
2106: liberation(s_etat_processus, s_objet_1);
2107: liberation(s_etat_processus, s_objet_2);
2108: liberation(s_etat_processus, s_objet_3);
2109:
2110: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
2111: return;
2112: }
2113:
2114: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q'))
2115: == NULL)
2116: {
2117: if (variable_partagee == d_vrai)
2118: {
2119: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2120: .s_liste_variables_partagees).mutex)) != 0)
2121: {
2122: (*s_etat_processus).erreur_systeme = d_es_processus;
2123: return;
2124: }
2125: }
2126:
2127: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2128: return;
2129: }
2130:
2131: liberation(s_etat_processus, s_objet_4);
2132: s_objet_4 = s_copie_4;
2133:
2134: if ((*s_objet_4).type == MIN)
2135: {
2136: /*
2137: * Matrice d'entiers
2138: */
2139:
2140: if ((*s_objet_1).type == INT)
2141: {
2142: /*
2143: * Aucune conversion de type
2144: */
2145:
2146: ((integer8 **) (*((struct_matrice *) (*s_objet_4).objet))
2147: .tableau)[indice_i - 1][indice_j - 1] =
2148: (*((integer8 *) (*s_objet_1).objet));
2149: }
2150: else if ((*s_objet_1).type == REL)
2151: {
2152: /*
2153: * Conversion de la matrice en matrice réelle
2154: */
2155:
2156: tampon = (void *) ((integer8 **) (*((struct_matrice *)
2157: (*s_objet_4).objet)).tableau);
2158:
2159: (*((struct_matrice *) (*s_objet_4).objet)).type = 'R';
2160: (*s_objet_4).type = MRL;
2161:
2162: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
2163: = malloc((*((struct_matrice *)
2164: (*s_objet_4).objet)).nombre_lignes *
2165: sizeof(real8 *))) == NULL)
2166: {
2167: if (variable_partagee == d_vrai)
2168: {
2169: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2170: .s_liste_variables_partagees).mutex)) != 0)
2171: {
2172: (*s_etat_processus).erreur_systeme =
2173: d_es_processus;
2174: return;
2175: }
2176: }
2177:
2178: (*s_etat_processus).erreur_systeme =
2179: d_es_allocation_memoire;
2180: return;
2181: }
2182:
2183: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
2184: .nombre_lignes; i++)
2185: {
2186: if ((((real8 **) (*((struct_matrice *)
2187: (*s_objet_4).objet)).tableau)[i]
2188: = malloc((*((struct_matrice *)
2189: (*s_objet_4).objet)).nombre_colonnes *
2190: sizeof(real8))) == NULL)
2191: {
2192: if (variable_partagee == d_vrai)
2193: {
2194: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2195: .s_liste_variables_partagees).mutex))
2196: != 0)
2197: {
2198: (*s_etat_processus).erreur_systeme =
2199: d_es_processus;
2200: return;
2201: }
2202: }
2203:
2204: (*s_etat_processus).erreur_systeme =
2205: d_es_allocation_memoire;
2206: return;
2207: }
2208:
2209: for(j = 0; j < (*((struct_matrice *)
2210: (*s_objet_4).objet)).nombre_colonnes; j++)
2211: {
2212: ((real8 **) (*((struct_matrice *) (*s_objet_4)
2213: .objet)).tableau)[i][j] = (real8)
2214: (((integer8 **) tampon)[i][j]);
2215: }
2216:
2217: free(((integer8 **) tampon)[i]);
2218: }
2219:
2220: free((integer8 **) tampon);
2221:
2222: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
2223: .tableau)[indice_i - 1][indice_j - 1] =
2224: (*((real8 *) (*s_objet_1).objet));
2225: }
2226: else if ((*s_objet_1).type == CPL)
2227: {
2228: /*
2229: * Conversion de la matrice en matrice complexe
2230: */
2231:
2232: tampon = (void *) ((integer8 **) (*((struct_matrice *)
2233: (*s_objet_4).objet)).tableau);
2234:
2235: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C';
2236: (*s_objet_4).type = MCX;
2237:
2238: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
2239: = malloc((*((struct_matrice *)
2240: (*s_objet_4).objet)).nombre_lignes *
2241: sizeof(struct_complexe16 *))) == NULL)
2242: {
2243: if (variable_partagee == d_vrai)
2244: {
2245: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2246: .s_liste_variables_partagees).mutex)) != 0)
2247: {
2248: (*s_etat_processus).erreur_systeme =
2249: d_es_processus;
2250: return;
2251: }
2252: }
2253:
2254: (*s_etat_processus).erreur_systeme =
2255: d_es_allocation_memoire;
2256: return;
2257: }
2258:
2259: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
2260: .nombre_lignes; i++)
2261: {
2262: if ((((struct_complexe16 **) (*((struct_matrice *)
2263: (*s_objet_4).objet)).tableau)[i]
2264: = malloc((*((struct_matrice *)
2265: (*s_objet_4).objet)).nombre_colonnes *
2266: sizeof(struct_complexe16))) == NULL)
2267: {
2268: if (variable_partagee == d_vrai)
2269: {
2270: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2271: .s_liste_variables_partagees).mutex))
2272: != 0)
2273: {
2274: (*s_etat_processus).erreur_systeme =
2275: d_es_processus;
2276: return;
2277: }
2278: }
2279:
2280: (*s_etat_processus).erreur_systeme =
2281: d_es_allocation_memoire;
2282: return;
2283: }
2284:
2285: for(j = 0; j < (*((struct_matrice *)
2286: (*s_objet_4).objet)).nombre_colonnes; j++)
2287: {
2288: ((struct_complexe16 **) (*((struct_matrice *)
2289: (*s_objet_4).objet)).tableau)[i][j]
2290: .partie_reelle = (real8) (((integer8 **)
2291: tampon)[i][j]);
2292: ((struct_complexe16 **) (*((struct_matrice *)
2293: (*s_objet_4).objet)).tableau)[i][j]
2294: .partie_imaginaire = (real8) 0;
2295: }
2296:
2297: free(((integer8 **) tampon)[i]);
2298: }
2299:
2300: free((integer8 **) tampon);
2301:
2302: ((struct_complexe16 **) (*((struct_matrice *)
2303: (*s_objet_4).objet)).tableau)[indice_i - 1]
2304: [indice_j - 1].partie_reelle =
2305: (*((struct_complexe16 *)
2306: (*s_objet_1).objet)).partie_reelle;
2307: ((struct_complexe16 **) (*((struct_matrice *)
2308: (*s_objet_4).objet)).tableau)[indice_i - 1]
2309: [indice_j - 1].partie_imaginaire =
2310: (*((struct_complexe16 *)
2311: (*s_objet_1).objet)).partie_imaginaire;
2312: }
2313: else
2314: {
2315: if (variable_partagee == d_vrai)
2316: {
2317: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2318: .s_liste_variables_partagees).mutex)) != 0)
2319: {
2320: (*s_etat_processus).erreur_systeme =
2321: d_es_processus;
2322: return;
2323: }
2324: }
2325:
2326: liberation(s_etat_processus, s_objet_1);
2327: liberation(s_etat_processus, s_objet_2);
2328: liberation(s_etat_processus, s_objet_3);
2329:
2330: (*s_etat_processus).erreur_execution =
2331: d_ex_erreur_type_argument;
2332: return;
2333: }
2334: }
2335: else if ((*s_objet_4).type == MRL)
2336: {
2337: /*
2338: * Matrice de réels
2339: */
2340:
2341: if ((*s_objet_1).type == INT)
2342: {
2343: /*
2344: * Conversion de l'élément à insérer en réel
2345: */
2346:
2347: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
2348: .tableau)[indice_i - 1][indice_j - 1] =
2349: (real8) (*((integer8 *) (*s_objet_1).objet));
2350: }
2351: else if ((*s_objet_1).type == REL)
2352: {
2353: /*
2354: * Aucune conversion de type
2355: */
2356:
2357: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
2358: .tableau)[indice_i - 1][indice_j - 1] =
2359: (*((real8 *) (*s_objet_1).objet));
2360: }
2361: else if ((*s_objet_1).type == CPL)
2362: {
2363: /*
2364: * Conversion de la matrice en matrice complexe
2365: */
2366:
2367: tampon = (void *) ((real8 **) (*((struct_matrice *)
2368: (*s_objet_4).objet)).tableau);
2369:
2370: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C';
2371: (*s_objet_4).type = MCX;
2372:
2373: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
2374: = malloc((*((struct_matrice *)
2375: (*s_objet_4).objet)).nombre_lignes *
2376: sizeof(struct_complexe16 *))) == NULL)
2377: {
2378: if (variable_partagee == d_vrai)
2379: {
2380: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2381: .s_liste_variables_partagees).mutex))
2382: != 0)
2383: {
2384: (*s_etat_processus).erreur_systeme =
2385: d_es_processus;
2386: return;
2387: }
2388: }
2389:
2390: (*s_etat_processus).erreur_systeme =
2391: d_es_allocation_memoire;
2392: return;
2393: }
2394:
2395: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
2396: .nombre_lignes; i++)
2397: {
2398: if ((((struct_complexe16 **) (*((struct_matrice *)
2399: (*s_objet_4).objet)).tableau)[i]
2400: = malloc((*((struct_matrice *)
2401: (*s_objet_4).objet)).nombre_colonnes *
2402: sizeof(struct_complexe16))) == NULL)
2403: {
2404: if (variable_partagee == d_vrai)
2405: {
2406: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2407: .s_liste_variables_partagees).mutex))
2408: != 0)
2409: {
2410: (*s_etat_processus).erreur_systeme =
2411: d_es_processus;
2412: return;
2413: }
2414: }
2415:
2416: (*s_etat_processus).erreur_systeme =
2417: d_es_allocation_memoire;
2418: return;
2419: }
2420:
2421: for(j = 0; j < (*((struct_matrice *)
2422: (*s_objet_4).objet)).nombre_colonnes; j++)
2423: {
2424: ((struct_complexe16 **) (*((struct_matrice *)
2425: (*s_objet_4).objet)).tableau)[i][j]
2426: .partie_reelle = (((real8 **)
2427: tampon)[i][j]);
2428: ((struct_complexe16 **) (*((struct_matrice *)
2429: (*s_objet_4).objet)).tableau)[i][j]
2430: .partie_imaginaire = (real8) 0;
2431: }
2432:
2433: free(((integer8 **) tampon)[i]);
2434: }
2435:
2436: free((integer8 **) tampon);
2437:
2438: ((struct_complexe16 **) (*((struct_matrice *)
2439: (*s_objet_4).objet)).tableau)[indice_i - 1]
2440: [indice_j - 1].partie_reelle =
2441: (*((struct_complexe16 *)
2442: (*s_objet_1).objet)).partie_reelle;
2443: ((struct_complexe16 **) (*((struct_matrice *)
2444: (*s_objet_4).objet)).tableau)[indice_i - 1]
2445: [indice_j - 1].partie_imaginaire =
2446: (*((struct_complexe16 *)
2447: (*s_objet_1).objet)).partie_imaginaire;
2448: }
2449: else
2450: {
2451: if (variable_partagee == d_vrai)
2452: {
2453: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2454: .s_liste_variables_partagees).mutex)) != 0)
2455: {
2456: (*s_etat_processus).erreur_systeme =
2457: d_es_processus;
2458: return;
2459: }
2460: }
2461:
2462: liberation(s_etat_processus, s_objet_1);
2463: liberation(s_etat_processus, s_objet_2);
2464: liberation(s_etat_processus, s_objet_3);
2465:
2466: (*s_etat_processus).erreur_execution =
2467: d_ex_erreur_type_argument;
2468: return;
2469: }
2470: }
2471: else
2472: {
2473: /*
2474: * Matrice de complexes
2475: */
2476:
2477: if ((*s_objet_1).type == INT)
2478: {
2479: /*
2480: * Conversion de l'élément à insérer en complexe
2481: */
2482:
2483: ((struct_complexe16 **) (*((struct_matrice *)
2484: (*s_objet_4).objet)).tableau)[indice_i - 1]
2485: [indice_j - 1].partie_reelle = (real8)
2486: (*((integer8 *) (*s_objet_1).objet));
2487: ((struct_complexe16 **) (*((struct_matrice *)
2488: (*s_objet_4).objet)).tableau)[indice_i - 1]
2489: [indice_j - 1].partie_imaginaire = (real8) 0;
2490: }
2491: else if ((*s_objet_1).type == REL)
2492: {
2493: /*
2494: * Conversion de l'élément à insérer en complexe
2495: */
2496:
2497: ((struct_complexe16 **) (*((struct_matrice *)
2498: (*s_objet_4).objet)).tableau)[indice_i - 1]
2499: [indice_j - 1].partie_reelle =
2500: (*((real8 *) (*s_objet_1).objet));
2501: ((struct_complexe16 **) (*((struct_matrice *)
2502: (*s_objet_4).objet)).tableau)[indice_i - 1]
2503: [indice_j - 1].partie_imaginaire = (real8) 0;
2504: }
2505: else if ((*s_objet_1).type == CPL)
2506: {
2507: /*
2508: * Aucune conversion de type
2509: */
2510:
2511: ((struct_complexe16 **) (*((struct_matrice *)
2512: (*s_objet_4).objet)).tableau)[indice_i - 1]
2513: [indice_j - 1].partie_reelle =
2514: (*((struct_complexe16 *)
2515: (*s_objet_1).objet)).partie_reelle;
2516: ((struct_complexe16 **) (*((struct_matrice *)
2517: (*s_objet_4).objet)).tableau)[indice_i - 1]
2518: [indice_j - 1].partie_imaginaire =
2519: (*((struct_complexe16 *)
2520: (*s_objet_1).objet)).partie_imaginaire;
2521: }
2522: else
2523: {
2524: if (variable_partagee == d_vrai)
2525: {
2526: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2527: .s_liste_variables_partagees).mutex)) != 0)
2528: {
2529: (*s_etat_processus).erreur_systeme =
2530: d_es_processus;
2531: return;
2532: }
2533: }
2534:
2535: liberation(s_etat_processus, s_objet_1);
2536: liberation(s_etat_processus, s_objet_2);
2537: liberation(s_etat_processus, s_objet_3);
2538:
2539: (*s_etat_processus).erreur_execution =
2540: d_ex_erreur_type_argument;
2541: return;
2542: }
2543: }
2544:
2545: if (variable_partagee == d_faux)
2546: {
1.20 bertrand 2547: (*(*s_etat_processus).pointeur_variable_courante).objet =
2548: s_objet_4;
1.1 bertrand 2549: }
2550: else
2551: {
1.20 bertrand 2552: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1.1 bertrand 2553: (*(*s_etat_processus).s_liste_variables_partagees).table
2554: [(*(*s_etat_processus).s_liste_variables_partagees)
2555: .position_variable].objet = s_objet_4;
2556:
2557: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2558: .s_liste_variables_partagees).mutex))
2559: != 0)
2560: {
2561: (*s_etat_processus).erreur_systeme =
2562: d_es_processus;
2563: return;
2564: }
2565: }
2566:
2567: liberation(s_etat_processus, s_objet_1);
2568: liberation(s_etat_processus, s_objet_2);
2569: liberation(s_etat_processus, s_objet_3);
2570: }
2571: else if ((*s_objet_4).type == LST)
2572: {
2573: if ((*s_objet_2).type != INT)
2574: {
2575: if (variable_partagee == d_vrai)
2576: {
2577: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2578: .s_liste_variables_partagees).mutex))
2579: != 0)
2580: {
2581: (*s_etat_processus).erreur_systeme =
2582: d_es_processus;
2583: return;
2584: }
2585: }
2586:
2587: liberation(s_etat_processus, s_objet_1);
2588: liberation(s_etat_processus, s_objet_2);
2589: liberation(s_etat_processus, s_objet_3);
2590:
2591: (*s_etat_processus).erreur_execution =
2592: d_ex_erreur_type_argument;
2593: return;
2594: }
2595:
2596: indice_i = (*((integer8 *) (*s_objet_2).objet));
2597: indice_j = 1;
2598:
2599: if ((*s_objet_4).nombre_occurrences > 1)
2600: {
2601: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N'))
2602: == NULL)
2603: {
2604: if (variable_partagee == d_vrai)
2605: {
2606: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2607: .s_liste_variables_partagees).mutex))
2608: != 0)
2609: {
2610: (*s_etat_processus).erreur_systeme =
2611: d_es_processus;
2612: return;
2613: }
2614: }
2615:
2616: (*s_etat_processus).erreur_systeme =
2617: d_es_allocation_memoire;
2618: return;
2619: }
2620:
2621: liberation(s_etat_processus, s_objet_4);
2622: s_objet_4 = s_copie_4;
2623: }
2624:
2625: l_element_courant = (*s_objet_4).objet;
2626:
2627: while((l_element_courant != NULL) && (indice_j != indice_i))
2628: {
2629: l_element_courant = (*l_element_courant).suivant;
2630: indice_j++;
2631: }
2632:
2633: if (l_element_courant != NULL)
2634: {
2635: liberation(s_etat_processus, (*l_element_courant).donnee);
2636: (*l_element_courant).donnee = s_objet_1;
2637: }
2638: else
2639: {
2640: if (variable_partagee == d_vrai)
2641: {
2642: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2643: .s_liste_variables_partagees).mutex)) != 0)
2644: {
2645: (*s_etat_processus).erreur_systeme =
2646: d_es_processus;
2647: return;
2648: }
2649: }
2650:
2651: liberation(s_etat_processus, s_objet_1);
2652: liberation(s_etat_processus, s_objet_2);
2653: liberation(s_etat_processus, s_objet_3);
2654:
2655: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
2656: return;
2657: }
2658:
2659: if (variable_partagee == d_faux)
2660: {
1.20 bertrand 2661: (*(*s_etat_processus).pointeur_variable_courante).objet =
2662: s_objet_4;
1.1 bertrand 2663: }
2664: else
2665: {
1.20 bertrand 2666: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1.1 bertrand 2667: (*(*s_etat_processus).s_liste_variables_partagees).table
2668: [(*(*s_etat_processus).s_liste_variables_partagees)
2669: .position_variable].objet = s_objet_4;
2670:
2671: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2672: .s_liste_variables_partagees).mutex)) != 0)
2673: {
2674: (*s_etat_processus).erreur_systeme =
2675: d_es_processus;
2676: return;
2677: }
2678: }
2679:
2680: liberation(s_etat_processus, s_objet_2);
2681: liberation(s_etat_processus, s_objet_3);
2682: }
2683: else if ((*s_objet_4).type == TBL)
2684: {
2685: if ((*s_objet_2).type != LST)
2686: {
2687: if (variable_partagee == d_vrai)
2688: {
2689: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2690: .s_liste_variables_partagees).mutex)) != 0)
2691: {
2692: (*s_etat_processus).erreur_systeme =
2693: d_es_processus;
2694: return;
2695: }
2696: }
2697:
2698: liberation(s_etat_processus, s_objet_1);
2699: liberation(s_etat_processus, s_objet_2);
2700: liberation(s_etat_processus, s_objet_3);
2701:
2702: (*s_etat_processus).erreur_execution =
2703: d_ex_erreur_type_argument;
2704: return;
2705: }
2706:
2707: if ((*s_objet_4).nombre_occurrences > 1)
2708: {
2709: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N'))
2710: == NULL)
2711: {
2712: if (variable_partagee == d_vrai)
2713: {
2714: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2715: .s_liste_variables_partagees).mutex)) != 0)
2716: {
2717: (*s_etat_processus).erreur_systeme =
2718: d_es_processus;
2719: return;
2720: }
2721: }
2722:
2723: (*s_etat_processus).erreur_systeme =
2724: d_es_allocation_memoire;
2725: return;
2726: }
2727:
2728: liberation(s_etat_processus, s_objet_4);
2729: s_objet_4 = s_copie_4;
2730: }
2731:
2732: s_objet_element = s_objet_4;
2733: l_element_courant = (*s_objet_2).objet;
2734: indice_i = 0;
2735:
2736: while(l_element_courant != NULL)
2737: {
2738: if ((*(*l_element_courant).donnee).type != INT)
2739: {
2740: if (variable_partagee == d_vrai)
2741: {
2742: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2743: .s_liste_variables_partagees).mutex)) != 0)
2744: {
2745: (*s_etat_processus).erreur_systeme =
2746: d_es_processus;
2747: return;
2748: }
2749: }
2750:
2751: liberation(s_etat_processus, s_objet_1);
2752: liberation(s_etat_processus, s_objet_2);
2753: liberation(s_etat_processus, s_objet_3);
2754:
2755: (*s_etat_processus).erreur_execution =
2756: d_ex_erreur_type_argument;
2757: return;
2758: }
2759:
2760: if ((*s_objet_element).type != TBL)
2761: {
2762: if (variable_partagee == d_vrai)
2763: {
2764: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2765: .s_liste_variables_partagees).mutex)) != 0)
2766: {
2767: (*s_etat_processus).erreur_systeme =
2768: d_es_processus;
2769: return;
2770: }
2771: }
2772:
2773: liberation(s_etat_processus, s_objet_1);
2774: liberation(s_etat_processus, s_objet_2);
2775: liberation(s_etat_processus, s_objet_3);
2776:
2777: (*s_etat_processus).erreur_execution =
2778: d_ex_element_inexistant;
2779: return;
2780: }
2781:
2782: indice_i = (*((integer8 *) (*(*l_element_courant)
2783: .donnee).objet));
2784:
2785: if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
2786: (*s_objet_element).objet)).nombre_elements))
2787: {
2788: if (variable_partagee == d_vrai)
2789: {
2790: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2791: .s_liste_variables_partagees).mutex)) != 0)
2792: {
2793: (*s_etat_processus).erreur_systeme =
2794: d_es_processus;
2795: return;
2796: }
2797: }
2798:
2799: liberation(s_etat_processus, s_objet_1);
2800: liberation(s_etat_processus, s_objet_2);
2801: liberation(s_etat_processus, s_objet_3);
2802:
2803: (*s_etat_processus).erreur_execution =
2804: d_ex_element_inexistant;
2805: return;
2806: }
2807:
2808: if ((*l_element_courant).suivant != NULL)
2809: {
2810: s_objet_element = (*((struct_tableau *) (*s_objet_element)
2811: .objet)).elements[indice_i - 1];
2812: }
2813:
2814: l_element_courant = (*l_element_courant).suivant;
2815: }
2816:
2817: liberation(s_etat_processus, (*((struct_tableau *)
2818: (*s_objet_element).objet)).elements[indice_i - 1]);
2819: (*((struct_tableau *) (*s_objet_element).objet)).elements
2820: [indice_i - 1] = s_objet_1;
2821:
2822: if (variable_partagee == d_faux)
2823: {
1.20 bertrand 2824: (*(*s_etat_processus).pointeur_variable_courante).objet =
2825: s_objet_4;
1.1 bertrand 2826: }
2827: else
2828: {
1.20 bertrand 2829: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1.1 bertrand 2830: (*(*s_etat_processus).s_liste_variables_partagees).table
2831: [(*(*s_etat_processus).s_liste_variables_partagees)
2832: .position_variable].objet = s_objet_4;
2833:
2834: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2835: .s_liste_variables_partagees).mutex)) != 0)
2836: {
2837: (*s_etat_processus).erreur_systeme =
2838: d_es_processus;
2839: return;
2840: }
2841: }
2842:
2843: liberation(s_etat_processus, s_objet_2);
2844: }
2845: else
2846: {
2847: if (variable_partagee == d_vrai)
2848: {
2849: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2850: .s_liste_variables_partagees).mutex)) != 0)
2851: {
2852: (*s_etat_processus).erreur_systeme =
2853: d_es_processus;
2854: return;
2855: }
2856: }
2857:
2858: liberation(s_etat_processus, s_objet_1);
2859: liberation(s_etat_processus, s_objet_2);
2860: liberation(s_etat_processus, s_objet_3);
2861:
2862: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2863: return;
2864: }
2865: }
2866:
2867: /*
2868: --------------------------------------------------------------------------------
2869: Arguments incompatibles
2870: --------------------------------------------------------------------------------
2871: */
2872:
2873: else
2874: {
2875: liberation(s_etat_processus, s_objet_1);
2876: liberation(s_etat_processus, s_objet_2);
2877: liberation(s_etat_processus, s_objet_3);
2878:
2879: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2880: return;
2881: }
2882:
2883: return;
2884: }
2885:
2886:
2887: /*
2888: ================================================================================
2889: Fonction 'puti'
2890: ================================================================================
2891: Entrées : pointeur sur une structure struct_processus
2892: --------------------------------------------------------------------------------
2893: Sorties :
2894: --------------------------------------------------------------------------------
2895: Effets de bord : néant
2896: ================================================================================
2897: */
2898:
2899: void
2900: instruction_puti(struct_processus *s_etat_processus)
2901: {
2902: logical1 variable_partagee;
2903:
2904: struct_liste_chainee *l_element_courant;
2905:
2906: struct_objet *s_copie_2;
2907: struct_objet *s_copie_3;
2908: struct_objet *s_copie_4;
2909: struct_objet *s_objet_1;
2910: struct_objet *s_objet_2;
2911: struct_objet *s_objet_3;
2912: struct_objet *s_objet_4;
2913:
2914: unsigned long i;
2915: unsigned long indice_i;
2916: unsigned long indice_j;
2917: unsigned long j;
2918: unsigned long nombre_dimensions;
2919: unsigned long nombre_elements;
2920:
2921: void *tampon;
2922:
2923: (*s_etat_processus).erreur_execution = d_ex;
2924:
2925: if ((*s_etat_processus).affichage_arguments == 'Y')
2926: {
2927: printf("\n PUTI ");
2928:
2929: if ((*s_etat_processus).langue == 'F')
2930: {
2931: printf("(change un élément)\n\n");
2932: }
2933: else
2934: {
2935: printf("(change element)\n\n");
2936: }
2937:
2938: printf(" 3: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
2939: printf(" 2: %s\n", d_LST);
2940: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
2941: printf("-> 2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
2942: printf(" 1: %s\n\n", d_LST);
2943:
2944: printf(" 3: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
2945: printf(" 2: %s\n", d_LST);
2946: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
2947: printf("-> 2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
2948: printf(" 1: %s\n\n", d_LST);
2949:
2950: printf(" 3: %s, %s\n", d_LST, d_NOM);
2951: printf(" 2: %s\n", d_INT);
2952: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
2953: " %s, %s, %s, %s, %s,\n"
2954: " %s, %s, %s, %s, %s,\n"
2955: " %s, %s, %s, %s,\n"
2956: " %s, %s\n",
2957: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
2958: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
2959: d_SQL, d_SLB, d_PRC, d_MTX);
2960: printf("-> 2: %s, %s\n", d_LST, d_NOM);
2961: printf(" 1: %s\n", d_INT);
2962:
2963: return;
2964: }
2965: else if ((*s_etat_processus).test_instruction == 'Y')
2966: {
2967: (*s_etat_processus).nombre_arguments = -1;
2968: return;
2969: }
2970:
2971: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2972: {
2973: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
2974: {
2975: return;
2976: }
2977: }
2978:
2979: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2980: &s_objet_1) == d_erreur)
2981: {
2982: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2983: return;
2984: }
2985:
2986: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2987: &s_objet_2) == d_erreur)
2988: {
2989: liberation(s_etat_processus, s_objet_1);
2990:
2991: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2992: return;
2993: }
2994:
2995: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2996: &s_objet_3) == d_erreur)
2997: {
2998: liberation(s_etat_processus, s_objet_1);
2999: liberation(s_etat_processus, s_objet_2);
3000:
3001: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
3002: return;
3003: }
3004:
3005: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O')) == NULL)
3006: {
3007: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3008: return;
3009: }
3010:
3011: liberation(s_etat_processus, s_objet_2);
3012: s_objet_2 = s_copie_2;
3013:
3014: /*
3015: --------------------------------------------------------------------------------
3016: Traitement des éléments des vecteurs
3017: --------------------------------------------------------------------------------
3018: */
3019:
3020: if (((*s_objet_3).type == VIN) ||
3021: ((*s_objet_3).type == VRL) ||
3022: ((*s_objet_3).type == VCX))
3023: {
3024: if ((*s_objet_2).type != LST)
3025: {
3026: liberation(s_etat_processus, s_objet_1);
3027: liberation(s_etat_processus, s_objet_2);
3028: liberation(s_etat_processus, s_objet_3);
3029:
3030: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3031: return;
3032: }
3033:
3034: l_element_courant = (*s_objet_2).objet;
3035: nombre_dimensions = 0;
3036:
3037: while(l_element_courant != NULL)
3038: {
3039: nombre_dimensions++;
3040: l_element_courant = (*l_element_courant).suivant;
3041: }
3042:
3043: if (nombre_dimensions != 1)
3044: {
3045: liberation(s_etat_processus, s_objet_1);
3046: liberation(s_etat_processus, s_objet_2);
3047: liberation(s_etat_processus, s_objet_3);
3048:
3049: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
3050: return;
3051: }
3052:
3053: l_element_courant = (*s_objet_2).objet;
3054:
3055: if ((*(*l_element_courant).donnee).type != INT)
3056: {
3057: liberation(s_etat_processus, s_objet_1);
3058: liberation(s_etat_processus, s_objet_2);
3059: liberation(s_etat_processus, s_objet_3);
3060:
3061: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3062: return;
3063: }
3064:
3065: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
3066: {
3067: liberation(s_etat_processus, s_objet_1);
3068: liberation(s_etat_processus, s_objet_2);
3069: liberation(s_etat_processus, s_objet_3);
3070:
3071: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
3072: return;
3073: }
3074: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
3075: (integer8) (*((struct_vecteur *) (*s_objet_3).objet)).taille)
3076: {
3077: liberation(s_etat_processus, s_objet_1);
3078: liberation(s_etat_processus, s_objet_2);
3079: liberation(s_etat_processus, s_objet_3);
3080:
3081: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
3082: return;
3083: }
3084:
3085: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
3086:
3087: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL)
3088: {
3089: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3090: return;
3091: }
3092:
3093: liberation(s_etat_processus, s_objet_3);
3094: s_objet_3 = s_copie_3;
3095:
3096: if ((*s_objet_3).type == VIN)
3097: {
3098: /*
3099: * Vecteur d'entiers
3100: */
3101:
3102: if ((*s_objet_1).type == INT)
3103: {
3104: /*
3105: * Aucune conversion de type
3106: */
3107:
3108: ((integer8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3109: .tableau)[indice_i - 1] = (*((integer8 *)
3110: (*s_objet_1).objet));
3111: }
3112: else if ((*s_objet_1).type == REL)
3113: {
3114: /*
3115: * Conversion du vecteur en vecteur réel
3116: */
3117:
3118: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
3119: (*s_objet_3).objet)).tableau);
3120:
3121: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'R';
3122: (*s_objet_3).type = VRL;
3123:
3124: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
3125: = malloc((*((struct_vecteur *)
3126: (*s_objet_3).objet)).taille * sizeof(real8)))
3127: == NULL)
3128: {
3129: (*s_etat_processus).erreur_systeme =
3130: d_es_allocation_memoire;
3131: return;
3132: }
3133:
3134: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
3135: .taille; i++)
3136: {
3137: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3138: .tableau)[i] = (real8) (((integer8 *) tampon)[i]);
3139: }
3140:
3141: free((integer8 *) tampon);
3142:
3143: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3144: .tableau)[indice_i - 1] = (*((real8 *)
3145: (*s_objet_1).objet));
3146: }
3147: else if ((*s_objet_1).type == CPL)
3148: {
3149: /*
3150: * Conversion du vecteur en vecteur complexe
3151: */
3152:
3153: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
3154: (*s_objet_3).objet)).tableau);
3155:
3156: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C';
3157: (*s_objet_3).type = VCX;
3158:
3159: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
3160: = malloc((*((struct_vecteur *)
3161: (*s_objet_3).objet)).taille *
3162: sizeof(struct_complexe16))) == NULL)
3163: {
3164: (*s_etat_processus).erreur_systeme =
3165: d_es_allocation_memoire;
3166: return;
3167: }
3168:
3169: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
3170: .taille; i++)
3171: {
3172: ((struct_complexe16 *) (*((struct_vecteur *)
3173: (*s_objet_3).objet)).tableau)[i].partie_reelle =
3174: (real8) (((integer8 *) tampon)[i]);
3175: ((struct_complexe16 *) (*((struct_vecteur *)
3176: (*s_objet_3).objet)).tableau)[i]
3177: .partie_imaginaire = (real8) 0;
3178: }
3179:
3180: free((integer8 *) tampon);
3181:
3182: ((struct_complexe16 *) (*((struct_vecteur *)
3183: (*s_objet_3).objet)).tableau)[indice_i - 1]
3184: .partie_reelle = (*((struct_complexe16 *)
3185: (*s_objet_1).objet)).partie_reelle;
3186: ((struct_complexe16 *) (*((struct_vecteur *)
3187: (*s_objet_3).objet)).tableau)[indice_i - 1]
3188: .partie_imaginaire = (*((struct_complexe16 *)
3189: (*s_objet_1).objet)).partie_imaginaire;
3190: }
3191: else
3192: {
3193: liberation(s_etat_processus, s_objet_1);
3194: liberation(s_etat_processus, s_objet_2);
3195: liberation(s_etat_processus, s_objet_3);
3196:
3197: (*s_etat_processus).erreur_execution =
3198: d_ex_erreur_type_argument;
3199: return;
3200: }
3201: }
3202: else if ((*s_objet_3).type == VRL)
3203: {
3204: /*
3205: * Vecteur de réels
3206: */
3207:
3208: if ((*s_objet_1).type == INT)
3209: {
3210: /*
3211: * Conversion de l'élément à insérer en réel
3212: */
3213:
3214: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3215: .tableau)[indice_i - 1] = (real8) (*((integer8 *)
3216: (*s_objet_1).objet));
3217: }
3218: else if ((*s_objet_1).type == REL)
3219: {
3220: /*
3221: * Aucune conversion de type
3222: */
3223:
3224: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
3225: .tableau)[indice_i - 1] = (*((real8 *)
3226: (*s_objet_1).objet));
3227: }
3228: else if ((*s_objet_1).type == CPL)
3229: {
3230: /*
3231: * Conversion du vecteur en vecteur complexe
3232: */
3233:
3234: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
3235: (*s_objet_3).objet)).tableau);
3236:
3237: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C';
3238: (*s_objet_3).type = VCX;
3239:
3240: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau
3241: = malloc((*((struct_vecteur *)
3242: (*s_objet_3).objet)).taille *
3243: sizeof(struct_complexe16))) == NULL)
3244: {
3245: (*s_etat_processus).erreur_systeme =
3246: d_es_allocation_memoire;
3247: return;
3248: }
3249:
3250: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet))
3251: .taille; i++)
3252: {
3253: ((struct_complexe16 *) (*((struct_vecteur *)
3254: (*s_objet_3).objet)).tableau)[i].partie_reelle =
3255: ((real8 *) tampon)[i];
3256: ((struct_complexe16 *) (*((struct_vecteur *)
3257: (*s_objet_3).objet)).tableau)[i]
3258: .partie_imaginaire = (real8) 0;
3259: }
3260:
3261: free((real8 *) tampon);
3262:
3263: ((struct_complexe16 *) (*((struct_vecteur *)
3264: (*s_objet_3).objet)).tableau)[indice_i - 1]
3265: .partie_reelle = (*((struct_complexe16 *)
3266: (*s_objet_1).objet)).partie_reelle;
3267: ((struct_complexe16 *) (*((struct_vecteur *)
3268: (*s_objet_3).objet)).tableau)[indice_i - 1]
3269: .partie_imaginaire = (*((struct_complexe16 *)
3270: (*s_objet_1).objet)).partie_imaginaire;
3271: }
3272: else
3273: {
3274: liberation(s_etat_processus, s_objet_1);
3275: liberation(s_etat_processus, s_objet_2);
3276: liberation(s_etat_processus, s_objet_3);
3277:
3278: (*s_etat_processus).erreur_execution =
3279: d_ex_erreur_type_argument;
3280: return;
3281: }
3282: }
3283: else
3284: {
3285: /*
3286: * Vecteur de complexes
3287: */
3288:
3289: if ((*s_objet_1).type == INT)
3290: {
3291: /*
3292: * Conversion de l'élément à insérer en complexe
3293: */
3294:
3295: ((struct_complexe16 *) (*((struct_vecteur *)
3296: (*s_objet_3).objet)).tableau)[indice_i - 1]
3297: .partie_reelle = (real8) (*((integer8 *)
3298: (*s_objet_1).objet));
3299: ((struct_complexe16 *) (*((struct_vecteur *)
3300: (*s_objet_3).objet)).tableau)[indice_i - 1]
3301: .partie_imaginaire = (real8) 0;
3302: }
3303: else if ((*s_objet_1).type == REL)
3304: {
3305: /*
3306: * Conversion de l'élément à insérer en complexe
3307: */
3308:
3309: ((struct_complexe16 *) (*((struct_vecteur *)
3310: (*s_objet_3).objet)).tableau)[indice_i - 1]
3311: .partie_reelle = (*((real8 *) (*s_objet_1).objet));
3312: ((struct_complexe16 *) (*((struct_vecteur *)
3313: (*s_objet_3).objet)).tableau)[indice_i - 1]
3314: .partie_imaginaire = (real8) 0;
3315: }
3316: else if ((*s_objet_1).type == CPL)
3317: {
3318: /*
3319: * Aucune conversion de type
3320: */
3321:
3322: ((struct_complexe16 *) (*((struct_vecteur *)
3323: (*s_objet_3).objet)).tableau)[indice_i - 1]
3324: .partie_reelle = (*((struct_complexe16 *)
3325: (*s_objet_1).objet)).partie_reelle;
3326: ((struct_complexe16 *) (*((struct_vecteur *)
3327: (*s_objet_3).objet)).tableau)[indice_i - 1]
3328: .partie_imaginaire = (*((struct_complexe16 *)
3329: (*s_objet_1).objet)).partie_imaginaire;
3330: }
3331: else
3332: {
3333: liberation(s_etat_processus, s_objet_1);
3334: liberation(s_etat_processus, s_objet_2);
3335: liberation(s_etat_processus, s_objet_3);
3336:
3337: (*s_etat_processus).erreur_execution =
3338: d_ex_erreur_type_argument;
3339: return;
3340: }
3341: }
3342:
3343: liberation(s_etat_processus, s_objet_1);
3344:
3345: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3346: s_objet_3) == d_erreur)
3347: {
3348: return;
3349: }
3350:
3351: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
3352: (indice_i % (*((struct_vecteur *) (*s_objet_3).objet))
3353: .taille) + 1;
3354:
3355: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3356: s_objet_2) == d_erreur)
3357: {
3358: return;
3359: }
3360: }
3361:
3362: /*
3363: --------------------------------------------------------------------------------
3364: Traitement des éléments des matrices
3365: --------------------------------------------------------------------------------
3366: */
3367:
3368: else if (((*s_objet_3).type == MIN) ||
3369: ((*s_objet_3).type == MRL) ||
3370: ((*s_objet_3).type == MCX))
3371: {
3372: if ((*s_objet_2).type != LST)
3373: {
3374: liberation(s_etat_processus, s_objet_1);
3375: liberation(s_etat_processus, s_objet_2);
3376: liberation(s_etat_processus, s_objet_3);
3377:
3378: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3379: return;
3380: }
3381:
3382: l_element_courant = (*s_objet_2).objet;
3383: nombre_dimensions = 0;
3384:
3385: while(l_element_courant != NULL)
3386: {
3387: nombre_dimensions++;
3388: l_element_courant = (*l_element_courant).suivant;
3389: }
3390:
3391: if (nombre_dimensions != 2)
3392: {
3393: liberation(s_etat_processus, s_objet_1);
3394: liberation(s_etat_processus, s_objet_2);
3395: liberation(s_etat_processus, s_objet_3);
3396:
3397: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
3398: return;
3399: }
3400:
3401: l_element_courant = (*s_objet_2).objet;
3402:
3403: indice_i = 0;
3404: indice_j = 0;
3405:
3406: while(l_element_courant != NULL)
3407: {
3408: if ((*(*l_element_courant).donnee).type != INT)
3409: {
3410: liberation(s_etat_processus, s_objet_1);
3411: liberation(s_etat_processus, s_objet_2);
3412: liberation(s_etat_processus, s_objet_3);
3413:
3414: (*s_etat_processus).erreur_execution =
3415: d_ex_erreur_type_argument;
3416: return;
3417: }
3418:
3419: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
3420: {
3421: liberation(s_etat_processus, s_objet_1);
3422: liberation(s_etat_processus, s_objet_2);
3423: liberation(s_etat_processus, s_objet_3);
3424:
3425: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
3426: return;
3427: }
3428:
3429: if (indice_i == 0)
3430: {
3431: indice_i = (*((integer8 *)
3432: (*(*l_element_courant).donnee).objet));
3433: }
3434: else
3435: {
3436: indice_j = (*((integer8 *)
3437: (*(*l_element_courant).donnee).objet));
3438: }
3439:
3440: l_element_courant = (*l_element_courant).suivant;
3441: }
3442:
3443: if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet))
3444: .nombre_lignes) || (indice_j > (*((struct_matrice *)
3445: (*s_objet_3).objet)).nombre_colonnes))
3446: {
3447: liberation(s_etat_processus, s_objet_1);
3448: liberation(s_etat_processus, s_objet_2);
3449: liberation(s_etat_processus, s_objet_3);
3450:
3451: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
3452: return;
3453: }
3454:
3455: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL)
3456: {
3457: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3458: return;
3459: }
3460:
3461: liberation(s_etat_processus, s_objet_3);
3462: s_objet_3 = s_copie_3;
3463:
3464: if ((*s_objet_3).type == MIN)
3465: {
3466: /*
3467: * Matrice d'entiers
3468: */
3469:
3470: if ((*s_objet_1).type == INT)
3471: {
3472: /*
3473: * Aucune conversion de type
3474: */
3475:
3476: ((integer8 **) (*((struct_matrice *) (*s_objet_3).objet))
3477: .tableau)[indice_i - 1][indice_j - 1] =
3478: (*((integer8 *) (*s_objet_1).objet));
3479: }
3480: else if ((*s_objet_1).type == REL)
3481: {
3482: /*
3483: * Conversion de la matrice en matrice réelle
3484: */
3485:
3486: tampon = (void *) ((integer8 **) (*((struct_matrice *)
3487: (*s_objet_3).objet)).tableau);
3488:
3489: (*((struct_matrice *) (*s_objet_3).objet)).type = 'R';
3490: (*s_objet_3).type = MRL;
3491:
3492: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
3493: = malloc((*((struct_matrice *)
3494: (*s_objet_3).objet)).nombre_lignes * sizeof(real8 *)))
3495: == NULL)
3496: {
3497: (*s_etat_processus).erreur_systeme =
3498: d_es_allocation_memoire;
3499: return;
3500: }
3501:
3502: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
3503: .nombre_lignes; i++)
3504: {
3505: if ((((real8 **) (*((struct_matrice *)
3506: (*s_objet_3).objet)).tableau)[i]
3507: = malloc((*((struct_matrice *)
3508: (*s_objet_3).objet)).nombre_colonnes *
3509: sizeof(real8))) == NULL)
3510: {
3511: (*s_etat_processus).erreur_systeme =
3512: d_es_allocation_memoire;
3513: return;
3514: }
3515:
3516: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
3517: .nombre_colonnes; j++)
3518: {
3519: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
3520: .tableau)[i][j] = (real8) (((integer8 **)
3521: tampon)[i][j]);
3522: }
3523:
3524: free(((integer8 **) tampon)[i]);
3525: }
3526:
3527: free((integer8 **) tampon);
3528:
3529: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
3530: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *)
3531: (*s_objet_1).objet));
3532: }
3533: else if ((*s_objet_1).type == CPL)
3534: {
3535: /*
3536: * Conversion de la matrice en matrice complexe
3537: */
3538:
3539: tampon = (void *) ((integer8 **) (*((struct_matrice *)
3540: (*s_objet_3).objet)).tableau);
3541:
3542: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C';
3543: (*s_objet_3).type = MCX;
3544:
3545: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
3546: = malloc((*((struct_matrice *)
3547: (*s_objet_3).objet)).nombre_lignes *
3548: sizeof(struct_complexe16 *))) == NULL)
3549: {
3550: (*s_etat_processus).erreur_systeme =
3551: d_es_allocation_memoire;
3552: return;
3553: }
3554:
3555: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
3556: .nombre_lignes; i++)
3557: {
3558: if ((((struct_complexe16 **) (*((struct_matrice *)
3559: (*s_objet_3).objet)).tableau)[i]
3560: = malloc((*((struct_matrice *)
3561: (*s_objet_3).objet)).nombre_colonnes *
3562: sizeof(struct_complexe16))) == NULL)
3563: {
3564: (*s_etat_processus).erreur_systeme =
3565: d_es_allocation_memoire;
3566: return;
3567: }
3568:
3569: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
3570: .nombre_colonnes; j++)
3571: {
3572: ((struct_complexe16 **) (*((struct_matrice *)
3573: (*s_objet_3).objet)).tableau)[i][j]
3574: .partie_reelle = (real8) (((integer8 **)
3575: tampon)[i][j]);
3576: ((struct_complexe16 **) (*((struct_matrice *)
3577: (*s_objet_3).objet)).tableau)[i][j]
3578: .partie_imaginaire = (real8) 0;
3579: }
3580:
3581: free(((integer8 **) tampon)[i]);
3582: }
3583:
3584: free((integer8 **) tampon);
3585:
3586: ((struct_complexe16 **) (*((struct_matrice *)
3587: (*s_objet_3).objet)).tableau)[indice_i - 1]
3588: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
3589: (*s_objet_1).objet)).partie_reelle;
3590: ((struct_complexe16 **) (*((struct_matrice *)
3591: (*s_objet_3).objet)).tableau)[indice_i - 1]
3592: [indice_j - 1].partie_imaginaire =
3593: (*((struct_complexe16 *)
3594: (*s_objet_1).objet)).partie_imaginaire;
3595: }
3596: else
3597: {
3598: liberation(s_etat_processus, s_objet_1);
3599: liberation(s_etat_processus, s_objet_2);
3600: liberation(s_etat_processus, s_objet_3);
3601:
3602: (*s_etat_processus).erreur_execution =
3603: d_ex_erreur_type_argument;
3604: return;
3605: }
3606: }
3607: else if ((*s_objet_3).type == MRL)
3608: {
3609: /*
3610: * Matrice de réels
3611: */
3612:
3613: if ((*s_objet_1).type == INT)
3614: {
3615: /*
3616: * Conversion de l'élément à insérer en réel
3617: */
3618:
3619: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
3620: .tableau)[indice_i - 1][indice_j - 1] =
3621: (real8) (*((integer8 *) (*s_objet_1).objet));
3622: }
3623: else if ((*s_objet_1).type == REL)
3624: {
3625: /*
3626: * Aucune conversion de type
3627: */
3628:
3629: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
3630: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *)
3631: (*s_objet_1).objet));
3632: }
3633: else if ((*s_objet_1).type == CPL)
3634: {
3635: /*
3636: * Conversion de la matrice en matrice complexe
3637: */
3638:
3639: tampon = (void *) ((real8 **) (*((struct_matrice *)
3640: (*s_objet_3).objet)).tableau);
3641:
3642: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C';
3643: (*s_objet_3).type = MCX;
3644:
3645: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau
3646: = malloc((*((struct_matrice *)
3647: (*s_objet_3).objet)).nombre_lignes *
3648: sizeof(struct_complexe16 *))) == NULL)
3649: {
3650: (*s_etat_processus).erreur_systeme =
3651: d_es_allocation_memoire;
3652: return;
3653: }
3654:
3655: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet))
3656: .nombre_lignes; i++)
3657: {
3658: if ((((struct_complexe16 **) (*((struct_matrice *)
3659: (*s_objet_3).objet)).tableau)[i]
3660: = malloc((*((struct_matrice *)
3661: (*s_objet_3).objet)).nombre_colonnes *
3662: sizeof(struct_complexe16))) == NULL)
3663: {
3664: (*s_etat_processus).erreur_systeme =
3665: d_es_allocation_memoire;
3666: return;
3667: }
3668:
3669: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet))
3670: .nombre_colonnes; j++)
3671: {
3672: ((struct_complexe16 **) (*((struct_matrice *)
3673: (*s_objet_3).objet)).tableau)[i][j]
3674: .partie_reelle = (((real8 **)
3675: tampon)[i][j]);
3676: ((struct_complexe16 **) (*((struct_matrice *)
3677: (*s_objet_3).objet)).tableau)[i][j]
3678: .partie_imaginaire = (real8) 0;
3679: }
3680:
3681: free(((integer8 **) tampon)[i]);
3682: }
3683:
3684: free((integer8 **) tampon);
3685:
3686: ((struct_complexe16 **) (*((struct_matrice *)
3687: (*s_objet_3).objet)).tableau)[indice_i - 1]
3688: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
3689: (*s_objet_1).objet)).partie_reelle;
3690: ((struct_complexe16 **) (*((struct_matrice *)
3691: (*s_objet_3).objet)).tableau)[indice_i - 1]
3692: [indice_j - 1].partie_imaginaire =
3693: (*((struct_complexe16 *)
3694: (*s_objet_1).objet)).partie_imaginaire;
3695: }
3696: else
3697: {
3698: liberation(s_etat_processus, s_objet_1);
3699: liberation(s_etat_processus, s_objet_2);
3700: liberation(s_etat_processus, s_objet_3);
3701:
3702: (*s_etat_processus).erreur_execution =
3703: d_ex_erreur_type_argument;
3704: return;
3705: }
3706: }
3707: else
3708: {
3709: /*
3710: * Matrice de complexes
3711: */
3712:
3713: if ((*s_objet_1).type == INT)
3714: {
3715: /*
3716: * Conversion de l'élément à insérer en complexe
3717: */
3718:
3719: ((struct_complexe16 **) (*((struct_matrice *)
3720: (*s_objet_3).objet)).tableau)[indice_i - 1]
3721: [indice_j - 1].partie_reelle = (real8) (*((integer8 *)
3722: (*s_objet_1).objet));
3723: ((struct_complexe16 **) (*((struct_matrice *)
3724: (*s_objet_3).objet)).tableau)[indice_i - 1]
3725: [indice_j - 1].partie_imaginaire = (real8) 0;
3726: }
3727: else if ((*s_objet_1).type == REL)
3728: {
3729: /*
3730: * Conversion de l'élément à insérer en complexe
3731: */
3732:
3733: ((struct_complexe16 **) (*((struct_matrice *)
3734: (*s_objet_3).objet)).tableau)[indice_i - 1]
3735: [indice_j - 1].partie_reelle =
3736: (*((real8 *) (*s_objet_1).objet));
3737: ((struct_complexe16 **) (*((struct_matrice *)
3738: (*s_objet_3).objet)).tableau)[indice_i - 1]
3739: [indice_j - 1].partie_imaginaire = (real8) 0;
3740: }
3741: else if ((*s_objet_1).type == CPL)
3742: {
3743: /*
3744: * Aucune conversion de type
3745: */
3746:
3747: ((struct_complexe16 **) (*((struct_matrice *)
3748: (*s_objet_3).objet)).tableau)[indice_i - 1]
3749: [indice_j - 1].partie_reelle = (*((struct_complexe16 *)
3750: (*s_objet_1).objet)).partie_reelle;
3751: ((struct_complexe16 **) (*((struct_matrice *)
3752: (*s_objet_3).objet)).tableau)[indice_i - 1]
3753: [indice_j - 1].partie_imaginaire =
3754: (*((struct_complexe16 *)
3755: (*s_objet_1).objet)).partie_imaginaire;
3756: }
3757: else
3758: {
3759: liberation(s_etat_processus, s_objet_1);
3760: liberation(s_etat_processus, s_objet_2);
3761: liberation(s_etat_processus, s_objet_3);
3762:
3763: (*s_etat_processus).erreur_execution =
3764: d_ex_erreur_type_argument;
3765: return;
3766: }
3767: }
3768:
3769: liberation(s_etat_processus, s_objet_1);
3770:
3771: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3772: s_objet_3) == d_erreur)
3773: {
3774: return;
3775: }
3776:
3777: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
3778: (*s_objet_2).objet)).suivant).donnee).objet))) > (integer8)
3779: (*((struct_matrice *) (*s_objet_3).objet)).nombre_colonnes)
3780: {
3781: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_2)
3782: .objet)).suivant).donnee).objet)) = 1;
3783:
3784: if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
3785: (*s_objet_2).objet)).donnee).objet))) > (integer8)
3786: (*((struct_matrice *) (*s_objet_3).objet)).nombre_lignes)
3787: {
3788: (*((integer8 *) (*(*((struct_liste_chainee *)
3789: (*s_objet_2).objet)).donnee).objet)) = 1;
3790: }
3791: }
3792:
3793: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3794: s_objet_2) == d_erreur)
3795: {
3796: return;
3797: }
3798: }
3799:
3800: /*
3801: --------------------------------------------------------------------------------
3802: Traitement des éléments des listes
3803: --------------------------------------------------------------------------------
3804: */
3805:
3806: else if ((*s_objet_3).type == LST)
3807: {
3808: if ((*s_objet_2).type != INT)
3809: {
3810: liberation(s_etat_processus, s_objet_1);
3811: liberation(s_etat_processus, s_objet_2);
3812: liberation(s_etat_processus, s_objet_3);
3813:
3814: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3815: return;
3816: }
3817:
3818: indice_i = (*((integer8 *) (*s_objet_2).objet));
3819: indice_j = 1;
3820:
3821: if ((*s_objet_3).nombre_occurrences > 1)
3822: {
3823: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'N'))
3824: == NULL)
3825: {
3826: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3827: return;
3828: }
3829:
3830: liberation(s_etat_processus, s_objet_3);
3831: s_objet_3 = s_copie_3;
3832: }
3833:
3834: l_element_courant = (*s_objet_3).objet;
3835: nombre_elements = 0;
3836:
3837: while(l_element_courant != NULL)
3838: {
3839: l_element_courant = (*l_element_courant).suivant;
3840: nombre_elements++;
3841: }
3842:
3843: l_element_courant = (*s_objet_3).objet;
3844:
3845: while((l_element_courant != NULL) && (indice_j != indice_i))
3846: {
3847: l_element_courant = (*l_element_courant).suivant;
3848: indice_j++;
3849: }
3850:
3851: if (l_element_courant != NULL)
3852: {
3853: liberation(s_etat_processus, (*l_element_courant).donnee);
3854: (*l_element_courant).donnee = s_objet_1;
3855: }
3856: else
3857: {
3858: liberation(s_etat_processus, s_objet_1);
3859: liberation(s_etat_processus, s_objet_2);
3860: liberation(s_etat_processus, s_objet_3);
3861:
3862: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
3863: return;
3864: }
3865:
3866: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3867: s_objet_3) == d_erreur)
3868: {
3869: return;
3870: }
3871:
3872: (*((integer8 *) (*s_objet_2).objet)) =
3873: (indice_i % nombre_elements) + 1;
3874:
3875: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3876: s_objet_2) == d_erreur)
3877: {
3878: return;
3879: }
3880: }
3881:
3882: /*
3883: --------------------------------------------------------------------------------
3884: Traitement des noms
3885: --------------------------------------------------------------------------------
3886: */
3887:
3888: else if ((*s_objet_3).type == NOM)
3889: {
3890: variable_partagee = d_faux;
3891:
3892: if (recherche_variable(s_etat_processus, (*((struct_nom *)
3893: (*s_objet_3).objet)).nom) == d_faux)
3894: {
3895: (*s_etat_processus).erreur_systeme = d_es;
3896: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
3897:
3898: liberation(s_etat_processus, s_objet_1);
3899: liberation(s_etat_processus, s_objet_2);
3900: liberation(s_etat_processus, s_objet_3);
3901:
3902: return;
3903: }
3904:
1.20 bertrand 3905: if ((*(*s_etat_processus).pointeur_variable_courante)
3906: .variable_verrouillee == d_vrai)
1.1 bertrand 3907: {
3908: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
3909:
3910: liberation(s_etat_processus, s_objet_1);
3911: liberation(s_etat_processus, s_objet_2);
3912: liberation(s_etat_processus, s_objet_3);
3913:
3914: return;
3915: }
3916:
1.20 bertrand 3917: s_objet_4 = (*(*s_etat_processus).pointeur_variable_courante).objet;
1.1 bertrand 3918:
3919: if (s_objet_4 == NULL)
3920: {
3921: if (pthread_mutex_lock(&((*(*s_etat_processus)
3922: .s_liste_variables_partagees).mutex)) != 0)
3923: {
3924: (*s_etat_processus).erreur_systeme = d_es_processus;
3925: return;
3926: }
3927:
3928: if (recherche_variable_partagee(s_etat_processus,
1.20 bertrand 3929: (*(*s_etat_processus).pointeur_variable_courante).nom,
3930: (*(*s_etat_processus).pointeur_variable_courante)
3931: .variable_partagee, (*(*s_etat_processus)
3932: .pointeur_variable_courante).origine) == d_faux)
1.1 bertrand 3933: {
3934: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3935: .s_liste_variables_partagees).mutex)) != 0)
3936: {
3937: (*s_etat_processus).erreur_systeme = d_es_processus;
3938: return;
3939: }
3940:
3941: (*s_etat_processus).erreur_systeme = d_es;
3942: (*s_etat_processus).erreur_execution =
3943: d_ex_variable_non_definie;
3944:
3945: liberation(s_etat_processus, s_objet_1);
3946: liberation(s_etat_processus, s_objet_2);
3947: liberation(s_etat_processus, s_objet_3);
3948:
3949: return;
3950: }
3951:
3952: s_objet_4 = (*(*s_etat_processus).s_liste_variables_partagees)
3953: .table[(*(*s_etat_processus).s_liste_variables_partagees)
3954: .position_variable].objet;
3955: variable_partagee = d_vrai;
3956: }
3957:
3958: if (((*s_objet_4).type == VIN) ||
3959: ((*s_objet_4).type == VRL) ||
3960: ((*s_objet_4).type == VCX))
3961: {
3962: if ((*s_objet_2).type != LST)
3963: {
3964: if (variable_partagee == d_vrai)
3965: {
3966: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3967: .s_liste_variables_partagees).mutex)) != 0)
3968: {
3969: (*s_etat_processus).erreur_systeme = d_es_processus;
3970: return;
3971: }
3972: }
3973:
3974: liberation(s_etat_processus, s_objet_1);
3975: liberation(s_etat_processus, s_objet_2);
3976: liberation(s_etat_processus, s_objet_3);
3977:
3978: (*s_etat_processus).erreur_execution =
3979: d_ex_erreur_type_argument;
3980: return;
3981: }
3982:
3983: l_element_courant = (*s_objet_2).objet;
3984: nombre_dimensions = 0;
3985:
3986: while(l_element_courant != NULL)
3987: {
3988: nombre_dimensions++;
3989: l_element_courant = (*l_element_courant).suivant;
3990: }
3991:
3992: if (nombre_dimensions != 1)
3993: {
3994: if (variable_partagee == d_vrai)
3995: {
3996: if (pthread_mutex_unlock(&((*(*s_etat_processus)
3997: .s_liste_variables_partagees).mutex)) != 0)
3998: {
3999: (*s_etat_processus).erreur_systeme = d_es_processus;
4000: return;
4001: }
4002: }
4003:
4004: liberation(s_etat_processus, s_objet_1);
4005: liberation(s_etat_processus, s_objet_2);
4006: liberation(s_etat_processus, s_objet_3);
4007:
4008: (*s_etat_processus).erreur_execution =
4009: d_ex_dimensions_invalides;
4010: return;
4011: }
4012:
4013: l_element_courant = (*s_objet_2).objet;
4014:
4015: if ((*(*l_element_courant).donnee).type != INT)
4016: {
4017: if (variable_partagee == d_vrai)
4018: {
4019: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4020: .s_liste_variables_partagees).mutex)) != 0)
4021: {
4022: (*s_etat_processus).erreur_systeme = d_es_processus;
4023: return;
4024: }
4025: }
4026:
4027: liberation(s_etat_processus, s_objet_1);
4028: liberation(s_etat_processus, s_objet_2);
4029: liberation(s_etat_processus, s_objet_3);
4030:
4031: (*s_etat_processus).erreur_execution =
4032: d_ex_erreur_type_argument;
4033: return;
4034: }
4035:
4036: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
4037: {
4038: if (variable_partagee == d_vrai)
4039: {
4040: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4041: .s_liste_variables_partagees).mutex)) != 0)
4042: {
4043: (*s_etat_processus).erreur_systeme = d_es_processus;
4044: return;
4045: }
4046: }
4047:
4048: liberation(s_etat_processus, s_objet_1);
4049: liberation(s_etat_processus, s_objet_2);
4050: liberation(s_etat_processus, s_objet_3);
4051:
4052: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
4053: return;
4054: }
4055: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
4056: (integer8) (*((struct_vecteur *) (*s_objet_4).objet))
4057: .taille)
4058: {
4059: if (variable_partagee == d_vrai)
4060: {
4061: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4062: .s_liste_variables_partagees).mutex)) != 0)
4063: {
4064: (*s_etat_processus).erreur_systeme = d_es_processus;
4065: return;
4066: }
4067: }
4068:
4069: liberation(s_etat_processus, s_objet_1);
4070: liberation(s_etat_processus, s_objet_2);
4071: liberation(s_etat_processus, s_objet_3);
4072:
4073: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
4074: return;
4075: }
4076:
4077: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
4078:
4079: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q'))
4080: == NULL)
4081: {
4082: if (variable_partagee == d_vrai)
4083: {
4084: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4085: .s_liste_variables_partagees).mutex)) != 0)
4086: {
4087: (*s_etat_processus).erreur_systeme = d_es_processus;
4088: return;
4089: }
4090: }
4091:
4092: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4093: return;
4094: }
4095:
4096: liberation(s_etat_processus, s_objet_4);
4097: s_objet_4 = s_copie_4;
4098:
4099: if ((*s_objet_4).type == VIN)
4100: {
4101: /*
4102: * Vecteur d'entiers
4103: */
4104:
4105: if ((*s_objet_1).type == INT)
4106: {
4107: /*
4108: * Aucune conversion de type
4109: */
4110:
4111: ((integer8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4112: .tableau)[indice_i - 1] = (*((integer8 *)
4113: (*s_objet_1).objet));
4114: }
4115: else if ((*s_objet_1).type == REL)
4116: {
4117: /*
4118: * Conversion du vecteur en vecteur réel
4119: */
4120:
4121: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
4122: (*s_objet_4).objet)).tableau);
4123:
4124: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'R';
4125: (*s_objet_4).type = VRL;
4126:
4127: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
4128: = malloc((*((struct_vecteur *)
4129: (*s_objet_4).objet)).taille * sizeof(real8)))
4130: == NULL)
4131: {
4132: if (variable_partagee == d_vrai)
4133: {
4134: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4135: .s_liste_variables_partagees).mutex)) != 0)
4136: {
4137: (*s_etat_processus).erreur_systeme =
4138: d_es_processus;
4139: return;
4140: }
4141: }
4142:
4143: (*s_etat_processus).erreur_systeme =
4144: d_es_allocation_memoire;
4145: return;
4146: }
4147:
4148: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
4149: .taille; i++)
4150: {
4151: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4152: .tableau)[i] = (real8) (((integer8 *)
4153: tampon)[i]);
4154: }
4155:
4156: free((integer8 *) tampon);
4157:
4158: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4159: .tableau)[indice_i - 1] = (*((real8 *)
4160: (*s_objet_1).objet));
4161: }
4162: else if ((*s_objet_1).type == CPL)
4163: {
4164: /*
4165: * Conversion du vecteur en vecteur complexe
4166: */
4167:
4168: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
4169: (*s_objet_4).objet)).tableau);
4170:
4171: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C';
4172: (*s_objet_4).type = VCX;
4173:
4174: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
4175: = malloc((*((struct_vecteur *)
4176: (*s_objet_4).objet)).taille *
4177: sizeof(struct_complexe16))) == NULL)
4178: {
4179: if (variable_partagee == d_vrai)
4180: {
4181: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4182: .s_liste_variables_partagees).mutex)) != 0)
4183: {
4184: (*s_etat_processus).erreur_systeme =
4185: d_es_processus;
4186: return;
4187: }
4188: }
4189:
4190: (*s_etat_processus).erreur_systeme =
4191: d_es_allocation_memoire;
4192: return;
4193: }
4194:
4195: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
4196: .taille; i++)
4197: {
4198: ((struct_complexe16 *) (*((struct_vecteur *)
4199: (*s_objet_4).objet)).tableau)[i].partie_reelle =
4200: (real8) (((integer8 *) tampon)[i]);
4201: ((struct_complexe16 *) (*((struct_vecteur *)
4202: (*s_objet_4).objet)).tableau)[i]
4203: .partie_imaginaire = (real8) 0;
4204: }
4205:
4206: free((integer8 *) tampon);
4207:
4208: ((struct_complexe16 *) (*((struct_vecteur *)
4209: (*s_objet_4).objet)).tableau)[indice_i - 1]
4210: .partie_reelle = (*((struct_complexe16 *)
4211: (*s_objet_1).objet)).partie_reelle;
4212: ((struct_complexe16 *) (*((struct_vecteur *)
4213: (*s_objet_4).objet)).tableau)[indice_i - 1]
4214: .partie_imaginaire = (*((struct_complexe16 *)
4215: (*s_objet_1).objet)).partie_imaginaire;
4216: }
4217: else
4218: {
4219: if (variable_partagee == d_vrai)
4220: {
4221: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4222: .s_liste_variables_partagees).mutex)) != 0)
4223: {
4224: (*s_etat_processus).erreur_systeme =
4225: d_es_processus;
4226: return;
4227: }
4228: }
4229:
4230: liberation(s_etat_processus, s_objet_1);
4231: liberation(s_etat_processus, s_objet_2);
4232: liberation(s_etat_processus, s_objet_3);
4233:
4234: (*s_etat_processus).erreur_execution =
4235: d_ex_erreur_type_argument;
4236: return;
4237: }
4238: }
4239: else if ((*s_objet_4).type == VRL)
4240: {
4241: /*
4242: * Vecteur de réels
4243: */
4244:
4245: if ((*s_objet_1).type == INT)
4246: {
4247: /*
4248: * Conversion de l'élément à insérer en réel
4249: */
4250:
4251: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4252: .tableau)[indice_i - 1] = (real8) (*((integer8 *)
4253: (*s_objet_1).objet));
4254: }
4255: else if ((*s_objet_1).type == REL)
4256: {
4257: /*
4258: * Aucune conversion de type
4259: */
4260:
4261: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet))
4262: .tableau)[indice_i - 1] = (*((real8 *)
4263: (*s_objet_1).objet));
4264: }
4265: else if ((*s_objet_1).type == CPL)
4266: {
4267: /*
4268: * Conversion du vecteur en vecteur complexe
4269: */
4270:
4271: tampon = (void *) ((integer8 *) (*((struct_vecteur *)
4272: (*s_objet_4).objet)).tableau);
4273:
4274: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C';
4275: (*s_objet_4).type = VCX;
4276:
4277: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau
4278: = malloc((*((struct_vecteur *)
4279: (*s_objet_4).objet)).taille *
4280: sizeof(struct_complexe16))) == NULL)
4281: {
4282: if (variable_partagee == d_vrai)
4283: {
4284: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4285: .s_liste_variables_partagees).mutex)) != 0)
4286: {
4287: (*s_etat_processus).erreur_systeme =
4288: d_es_processus;
4289: return;
4290: }
4291: }
4292:
4293: (*s_etat_processus).erreur_systeme =
4294: d_es_allocation_memoire;
4295: return;
4296: }
4297:
4298: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet))
4299: .taille; i++)
4300: {
4301: ((struct_complexe16 *) (*((struct_vecteur *)
4302: (*s_objet_4).objet)).tableau)[i].partie_reelle =
4303: ((real8 *) tampon)[i];
4304: ((struct_complexe16 *) (*((struct_vecteur *)
4305: (*s_objet_4).objet)).tableau)[i]
4306: .partie_imaginaire = (real8) 0;
4307: }
4308:
4309: free((real8 *) tampon);
4310:
4311: ((struct_complexe16 *) (*((struct_vecteur *)
4312: (*s_objet_4).objet)).tableau)[indice_i - 1]
4313: .partie_reelle = (*((struct_complexe16 *)
4314: (*s_objet_1).objet)).partie_reelle;
4315: ((struct_complexe16 *) (*((struct_vecteur *)
4316: (*s_objet_4).objet)).tableau)[indice_i - 1]
4317: .partie_imaginaire = (*((struct_complexe16 *)
4318: (*s_objet_1).objet)).partie_imaginaire;
4319: }
4320: else
4321: {
4322: if (variable_partagee == d_vrai)
4323: {
4324: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4325: .s_liste_variables_partagees).mutex)) != 0)
4326: {
4327: (*s_etat_processus).erreur_systeme =
4328: d_es_processus;
4329: return;
4330: }
4331: }
4332:
4333: liberation(s_etat_processus, s_objet_1);
4334: liberation(s_etat_processus, s_objet_2);
4335: liberation(s_etat_processus, s_objet_3);
4336:
4337: (*s_etat_processus).erreur_execution =
4338: d_ex_erreur_type_argument;
4339: return;
4340: }
4341: }
4342: else
4343: {
4344: /*
4345: * Vecteur de complexes
4346: */
4347:
4348: if ((*s_objet_1).type == INT)
4349: {
4350: /*
4351: * Conversion de l'élément à insérer en complexe
4352: */
4353:
4354: ((struct_complexe16 *) (*((struct_vecteur *)
4355: (*s_objet_4).objet)).tableau)[indice_i - 1]
4356: .partie_reelle = (real8) (*((integer8 *)
4357: (*s_objet_1).objet));
4358: ((struct_complexe16 *) (*((struct_vecteur *)
4359: (*s_objet_4).objet)).tableau)[indice_i - 1]
4360: .partie_imaginaire = (real8) 0;
4361: }
4362: else if ((*s_objet_1).type == REL)
4363: {
4364: /*
4365: * Conversion de l'élément à insérer en complexe
4366: */
4367:
4368: ((struct_complexe16 *) (*((struct_vecteur *)
4369: (*s_objet_4).objet)).tableau)[indice_i - 1]
4370: .partie_reelle = (*((real8 *) (*s_objet_1).objet));
4371: ((struct_complexe16 *) (*((struct_vecteur *)
4372: (*s_objet_4).objet)).tableau)[indice_i - 1]
4373: .partie_imaginaire = (real8) 0;
4374: }
4375: else if ((*s_objet_1).type == CPL)
4376: {
4377: /*
4378: * Aucune conversion de type
4379: */
4380:
4381: ((struct_complexe16 *) (*((struct_vecteur *)
4382: (*s_objet_4).objet)).tableau)[indice_i - 1]
4383: .partie_reelle = (*((struct_complexe16 *)
4384: (*s_objet_1).objet)).partie_reelle;
4385: ((struct_complexe16 *) (*((struct_vecteur *)
4386: (*s_objet_4).objet)).tableau)[indice_i - 1]
4387: .partie_imaginaire = (*((struct_complexe16 *)
4388: (*s_objet_1).objet)).partie_imaginaire;
4389: }
4390: else
4391: {
4392: if (variable_partagee == d_vrai)
4393: {
4394: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4395: .s_liste_variables_partagees).mutex)) != 0)
4396: {
4397: (*s_etat_processus).erreur_systeme =
4398: d_es_processus;
4399: return;
4400: }
4401: }
4402:
4403: liberation(s_etat_processus, s_objet_1);
4404: liberation(s_etat_processus, s_objet_2);
4405: liberation(s_etat_processus, s_objet_3);
4406:
4407: (*s_etat_processus).erreur_execution =
4408: d_ex_erreur_type_argument;
4409: return;
4410: }
4411: }
4412:
4413: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
4414: (indice_i % (*((struct_vecteur *) (*s_objet_4).objet))
4415: .taille) + 1;
4416:
4417: if (variable_partagee == d_faux)
4418: {
1.20 bertrand 4419: (*(*s_etat_processus).pointeur_variable_courante).objet =
4420: s_objet_4;
1.1 bertrand 4421: }
4422: else
4423: {
1.20 bertrand 4424: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1.1 bertrand 4425: (*(*s_etat_processus).s_liste_variables_partagees)
4426: .table[(*(*s_etat_processus)
4427: .s_liste_variables_partagees).position_variable].objet
4428: = s_objet_4;
4429:
4430: if (variable_partagee == d_vrai)
4431: {
4432: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4433: .s_liste_variables_partagees).mutex)) != 0)
4434: {
4435: (*s_etat_processus).erreur_systeme = d_es_processus;
4436: return;
4437: }
4438: }
4439: }
4440:
4441: liberation(s_etat_processus, s_objet_1);
4442: }
4443: else if (((*s_objet_4).type == MIN) ||
4444: ((*s_objet_4).type == MRL) ||
4445: ((*s_objet_4).type == MCX))
4446: {
4447: if ((*s_objet_2).type != LST)
4448: {
4449: if (variable_partagee == d_vrai)
4450: {
4451: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4452: .s_liste_variables_partagees).mutex)) != 0)
4453: {
4454: (*s_etat_processus).erreur_systeme = d_es_processus;
4455: return;
4456: }
4457: }
4458:
4459: liberation(s_etat_processus, s_objet_1);
4460: liberation(s_etat_processus, s_objet_2);
4461: liberation(s_etat_processus, s_objet_3);
4462:
4463: (*s_etat_processus).erreur_execution =
4464: d_ex_erreur_type_argument;
4465: return;
4466: }
4467:
4468: l_element_courant = (*s_objet_2).objet;
4469: nombre_dimensions = 0;
4470:
4471: while(l_element_courant != NULL)
4472: {
4473: nombre_dimensions++;
4474: l_element_courant = (*l_element_courant).suivant;
4475: }
4476:
4477: if (nombre_dimensions != 2)
4478: {
4479: if (variable_partagee == d_vrai)
4480: {
4481: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4482: .s_liste_variables_partagees).mutex)) != 0)
4483: {
4484: (*s_etat_processus).erreur_systeme = d_es_processus;
4485: return;
4486: }
4487: }
4488:
4489: liberation(s_etat_processus, s_objet_1);
4490: liberation(s_etat_processus, s_objet_2);
4491: liberation(s_etat_processus, s_objet_3);
4492:
4493: (*s_etat_processus).erreur_execution =
4494: d_ex_dimensions_invalides;
4495: return;
4496: }
4497:
4498: l_element_courant = (*s_objet_2).objet;
4499:
4500: indice_i = 0;
4501: indice_j = 0;
4502:
4503: while(l_element_courant != NULL)
4504: {
4505: if ((*(*l_element_courant).donnee).type != INT)
4506: {
4507: if (variable_partagee == d_vrai)
4508: {
4509: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4510: .s_liste_variables_partagees).mutex)) != 0)
4511: {
4512: (*s_etat_processus).erreur_systeme = d_es_processus;
4513: return;
4514: }
4515: }
4516:
4517: liberation(s_etat_processus, s_objet_1);
4518: liberation(s_etat_processus, s_objet_2);
4519: liberation(s_etat_processus, s_objet_3);
4520:
4521: (*s_etat_processus).erreur_execution =
4522: d_ex_erreur_type_argument;
4523: return;
4524: }
4525:
4526: if ((*((integer8 *) (*(*l_element_courant).donnee).objet))
4527: <= 0)
4528: {
4529: if (variable_partagee == d_vrai)
4530: {
4531: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4532: .s_liste_variables_partagees).mutex)) != 0)
4533: {
4534: (*s_etat_processus).erreur_systeme = d_es_processus;
4535: return;
4536: }
4537: }
4538:
4539: liberation(s_etat_processus, s_objet_1);
4540: liberation(s_etat_processus, s_objet_2);
4541: liberation(s_etat_processus, s_objet_3);
4542:
4543: (*s_etat_processus).erreur_execution =
4544: d_ex_argument_invalide;
4545: return;
4546: }
4547:
4548: if (indice_i == 0)
4549: {
4550: indice_i = (*((integer8 *)
4551: (*(*l_element_courant).donnee).objet));
4552: }
4553: else
4554: {
4555: indice_j = (*((integer8 *)
4556: (*(*l_element_courant).donnee).objet));
4557: }
4558:
4559: l_element_courant = (*l_element_courant).suivant;
4560: }
4561:
4562: if ((indice_i > (*((struct_matrice *) (*s_objet_4).objet))
4563: .nombre_lignes) || (indice_j > (*((struct_matrice *)
4564: (*s_objet_4).objet)).nombre_colonnes))
4565: {
4566: if (variable_partagee == d_vrai)
4567: {
4568: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4569: .s_liste_variables_partagees).mutex)) != 0)
4570: {
4571: (*s_etat_processus).erreur_systeme = d_es_processus;
4572: return;
4573: }
4574: }
4575:
4576: liberation(s_etat_processus, s_objet_1);
4577: liberation(s_etat_processus, s_objet_2);
4578: liberation(s_etat_processus, s_objet_3);
4579:
4580: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
4581: return;
4582: }
4583:
4584: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q'))
4585: == NULL)
4586: {
4587: if (variable_partagee == d_vrai)
4588: {
4589: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4590: .s_liste_variables_partagees).mutex)) != 0)
4591: {
4592: (*s_etat_processus).erreur_systeme = d_es_processus;
4593: return;
4594: }
4595: }
4596:
4597: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4598: return;
4599: }
4600:
4601: liberation(s_etat_processus, s_objet_4);
4602: s_objet_4 = s_copie_4;
4603:
4604: if ((*s_objet_4).type == MIN)
4605: {
4606: /*
4607: * Matrice d'entiers
4608: */
4609:
4610: if ((*s_objet_1).type == INT)
4611: {
4612: /*
4613: * Aucune conversion de type
4614: */
4615:
4616: ((integer8 **) (*((struct_matrice *) (*s_objet_4).objet))
4617: .tableau)[indice_i - 1][indice_j - 1] =
4618: (*((integer8 *) (*s_objet_1).objet));
4619: }
4620: else if ((*s_objet_1).type == REL)
4621: {
4622: /*
4623: * Conversion de la matrice en matrice réelle
4624: */
4625:
4626: tampon = (void *) ((integer8 **) (*((struct_matrice *)
4627: (*s_objet_4).objet)).tableau);
4628:
4629: (*((struct_matrice *) (*s_objet_4).objet)).type = 'R';
4630: (*s_objet_4).type = MRL;
4631:
4632: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
4633: = malloc((*((struct_matrice *)
4634: (*s_objet_4).objet)).nombre_lignes *
4635: sizeof(real8 *))) == NULL)
4636: {
4637: if (variable_partagee == d_vrai)
4638: {
4639: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4640: .s_liste_variables_partagees).mutex)) != 0)
4641: {
4642: (*s_etat_processus).erreur_systeme =
4643: d_es_processus;
4644: return;
4645: }
4646: }
4647:
4648: (*s_etat_processus).erreur_systeme =
4649: d_es_allocation_memoire;
4650: return;
4651: }
4652:
4653: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
4654: .nombre_lignes; i++)
4655: {
4656: if ((((real8 **) (*((struct_matrice *)
4657: (*s_objet_4).objet)).tableau)[i]
4658: = malloc((*((struct_matrice *)
4659: (*s_objet_4).objet)).nombre_colonnes *
4660: sizeof(real8))) == NULL)
4661: {
4662: if (variable_partagee == d_vrai)
4663: {
4664: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4665: .s_liste_variables_partagees).mutex))
4666: != 0)
4667: {
4668: (*s_etat_processus).erreur_systeme =
4669: d_es_processus;
4670: return;
4671: }
4672: }
4673:
4674: (*s_etat_processus).erreur_systeme =
4675: d_es_allocation_memoire;
4676: return;
4677: }
4678:
4679: for(j = 0; j < (*((struct_matrice *)
4680: (*s_objet_4).objet)).nombre_colonnes; j++)
4681: {
4682: ((real8 **) (*((struct_matrice *) (*s_objet_4)
4683: .objet)).tableau)[i][j] = (real8)
4684: (((integer8 **) tampon)[i][j]);
4685: }
4686:
4687: free(((integer8 **) tampon)[i]);
4688: }
4689:
4690: free((integer8 **) tampon);
4691:
4692: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
4693: .tableau)[indice_i - 1][indice_j - 1] =
4694: (*((real8 *) (*s_objet_1).objet));
4695: }
4696: else if ((*s_objet_1).type == CPL)
4697: {
4698: /*
4699: * Conversion de la matrice en matrice complexe
4700: */
4701:
4702: tampon = (void *) ((integer8 **) (*((struct_matrice *)
4703: (*s_objet_4).objet)).tableau);
4704:
4705: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C';
4706: (*s_objet_4).type = MCX;
4707:
4708: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
4709: = malloc((*((struct_matrice *)
4710: (*s_objet_4).objet)).nombre_lignes *
4711: sizeof(struct_complexe16 *))) == NULL)
4712: {
4713: if (variable_partagee == d_vrai)
4714: {
4715: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4716: .s_liste_variables_partagees).mutex)) != 0)
4717: {
4718: (*s_etat_processus).erreur_systeme =
4719: d_es_processus;
4720: return;
4721: }
4722: }
4723:
4724: (*s_etat_processus).erreur_systeme =
4725: d_es_allocation_memoire;
4726: return;
4727: }
4728:
4729: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
4730: .nombre_lignes; i++)
4731: {
4732: if ((((struct_complexe16 **) (*((struct_matrice *)
4733: (*s_objet_4).objet)).tableau)[i]
4734: = malloc((*((struct_matrice *)
4735: (*s_objet_4).objet)).nombre_colonnes *
4736: sizeof(struct_complexe16))) == NULL)
4737: {
4738: if (variable_partagee == d_vrai)
4739: {
4740: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4741: .s_liste_variables_partagees).mutex))
4742: != 0)
4743: {
4744: (*s_etat_processus).erreur_systeme =
4745: d_es_processus;
4746: return;
4747: }
4748: }
4749:
4750: (*s_etat_processus).erreur_systeme =
4751: d_es_allocation_memoire;
4752: return;
4753: }
4754:
4755: for(j = 0; j < (*((struct_matrice *)
4756: (*s_objet_4).objet)).nombre_colonnes; j++)
4757: {
4758: ((struct_complexe16 **) (*((struct_matrice *)
4759: (*s_objet_4).objet)).tableau)[i][j]
4760: .partie_reelle = (real8) (((integer8 **)
4761: tampon)[i][j]);
4762: ((struct_complexe16 **) (*((struct_matrice *)
4763: (*s_objet_4).objet)).tableau)[i][j]
4764: .partie_imaginaire = (real8) 0;
4765: }
4766:
4767: free(((integer8 **) tampon)[i]);
4768: }
4769:
4770: free((integer8 **) tampon);
4771:
4772: ((struct_complexe16 **) (*((struct_matrice *)
4773: (*s_objet_4).objet)).tableau)[indice_i - 1]
4774: [indice_j - 1].partie_reelle =
4775: (*((struct_complexe16 *)
4776: (*s_objet_1).objet)).partie_reelle;
4777: ((struct_complexe16 **) (*((struct_matrice *)
4778: (*s_objet_4).objet)).tableau)[indice_i - 1]
4779: [indice_j - 1].partie_imaginaire =
4780: (*((struct_complexe16 *)
4781: (*s_objet_1).objet)).partie_imaginaire;
4782: }
4783: else
4784: {
4785: if (variable_partagee == d_vrai)
4786: {
4787: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4788: .s_liste_variables_partagees).mutex)) != 0)
4789: {
4790: (*s_etat_processus).erreur_systeme =
4791: d_es_processus;
4792: return;
4793: }
4794: }
4795:
4796: liberation(s_etat_processus, s_objet_1);
4797: liberation(s_etat_processus, s_objet_2);
4798: liberation(s_etat_processus, s_objet_3);
4799:
4800: (*s_etat_processus).erreur_execution =
4801: d_ex_erreur_type_argument;
4802: return;
4803: }
4804: }
4805: else if ((*s_objet_4).type == MRL)
4806: {
4807: /*
4808: * Matrice de réels
4809: */
4810:
4811: if ((*s_objet_1).type == INT)
4812: {
4813: /*
4814: * Conversion de l'élément à insérer en réel
4815: */
4816:
4817: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
4818: .tableau)[indice_i - 1][indice_j - 1] =
4819: (real8) (*((integer8 *) (*s_objet_1).objet));
4820: }
4821: else if ((*s_objet_1).type == REL)
4822: {
4823: /*
4824: * Aucune conversion de type
4825: */
4826:
4827: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet))
4828: .tableau)[indice_i - 1][indice_j - 1] =
4829: (*((real8 *) (*s_objet_1).objet));
4830: }
4831: else if ((*s_objet_1).type == CPL)
4832: {
4833: /*
4834: * Conversion de la matrice en matrice complexe
4835: */
4836:
4837: tampon = (void *) ((real8 **) (*((struct_matrice *)
4838: (*s_objet_4).objet)).tableau);
4839:
4840: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C';
4841: (*s_objet_4).type = MCX;
4842:
4843: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau
4844: = malloc((*((struct_matrice *)
4845: (*s_objet_4).objet)).nombre_lignes *
4846: sizeof(struct_complexe16 *))) == NULL)
4847: {
4848: if (variable_partagee == d_vrai)
4849: {
4850: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4851: .s_liste_variables_partagees).mutex)) != 0)
4852: {
4853: (*s_etat_processus).erreur_systeme =
4854: d_es_processus;
4855: return;
4856: }
4857: }
4858:
4859: (*s_etat_processus).erreur_systeme =
4860: d_es_allocation_memoire;
4861: return;
4862: }
4863:
4864: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet))
4865: .nombre_lignes; i++)
4866: {
4867: if ((((struct_complexe16 **) (*((struct_matrice *)
4868: (*s_objet_4).objet)).tableau)[i]
4869: = malloc((*((struct_matrice *)
4870: (*s_objet_4).objet)).nombre_colonnes *
4871: sizeof(struct_complexe16))) == NULL)
4872: {
4873: if (variable_partagee == d_vrai)
4874: {
4875: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4876: .s_liste_variables_partagees).mutex))
4877: != 0)
4878: {
4879: (*s_etat_processus).erreur_systeme =
4880: d_es_processus;
4881: return;
4882: }
4883: }
4884:
4885: (*s_etat_processus).erreur_systeme =
4886: d_es_allocation_memoire;
4887: return;
4888: }
4889:
4890: for(j = 0; j < (*((struct_matrice *)
4891: (*s_objet_4).objet)).nombre_colonnes; j++)
4892: {
4893: ((struct_complexe16 **) (*((struct_matrice *)
4894: (*s_objet_4).objet)).tableau)[i][j]
4895: .partie_reelle = (((real8 **)
4896: tampon)[i][j]);
4897: ((struct_complexe16 **) (*((struct_matrice *)
4898: (*s_objet_4).objet)).tableau)[i][j]
4899: .partie_imaginaire = (real8) 0;
4900: }
4901:
4902: free(((integer8 **) tampon)[i]);
4903: }
4904:
4905: free((integer8 **) tampon);
4906:
4907: ((struct_complexe16 **) (*((struct_matrice *)
4908: (*s_objet_4).objet)).tableau)[indice_i - 1]
4909: [indice_j - 1].partie_reelle =
4910: (*((struct_complexe16 *)
4911: (*s_objet_1).objet)).partie_reelle;
4912: ((struct_complexe16 **) (*((struct_matrice *)
4913: (*s_objet_4).objet)).tableau)[indice_i - 1]
4914: [indice_j - 1].partie_imaginaire =
4915: (*((struct_complexe16 *)
4916: (*s_objet_1).objet)).partie_imaginaire;
4917: }
4918: else
4919: {
4920: if (variable_partagee == d_vrai)
4921: {
4922: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4923: .s_liste_variables_partagees).mutex))
4924: != 0)
4925: {
4926: (*s_etat_processus).erreur_systeme =
4927: d_es_processus;
4928: return;
4929: }
4930: }
4931:
4932: liberation(s_etat_processus, s_objet_1);
4933: liberation(s_etat_processus, s_objet_2);
4934: liberation(s_etat_processus, s_objet_3);
4935:
4936: (*s_etat_processus).erreur_execution =
4937: d_ex_erreur_type_argument;
4938: return;
4939: }
4940: }
4941: else
4942: {
4943: /*
4944: * Matrice de complexes
4945: */
4946:
4947: if ((*s_objet_1).type == INT)
4948: {
4949: /*
4950: * Conversion de l'élément à insérer en complexe
4951: */
4952:
4953: ((struct_complexe16 **) (*((struct_matrice *)
4954: (*s_objet_4).objet)).tableau)[indice_i - 1]
4955: [indice_j - 1].partie_reelle = (real8)
4956: (*((integer8 *) (*s_objet_1).objet));
4957: ((struct_complexe16 **) (*((struct_matrice *)
4958: (*s_objet_4).objet)).tableau)[indice_i - 1]
4959: [indice_j - 1].partie_imaginaire = (real8) 0;
4960: }
4961: else if ((*s_objet_1).type == REL)
4962: {
4963: /*
4964: * Conversion de l'élément à insérer en complexe
4965: */
4966:
4967: ((struct_complexe16 **) (*((struct_matrice *)
4968: (*s_objet_4).objet)).tableau)[indice_i - 1]
4969: [indice_j - 1].partie_reelle =
4970: (*((real8 *) (*s_objet_1).objet));
4971: ((struct_complexe16 **) (*((struct_matrice *)
4972: (*s_objet_4).objet)).tableau)[indice_i - 1]
4973: [indice_j - 1].partie_imaginaire = (real8) 0;
4974: }
4975: else if ((*s_objet_1).type == CPL)
4976: {
4977: /*
4978: * Aucune conversion de type
4979: */
4980:
4981: ((struct_complexe16 **) (*((struct_matrice *)
4982: (*s_objet_4).objet)).tableau)[indice_i - 1]
4983: [indice_j - 1].partie_reelle =
4984: (*((struct_complexe16 *)
4985: (*s_objet_1).objet)).partie_reelle;
4986: ((struct_complexe16 **) (*((struct_matrice *)
4987: (*s_objet_4).objet)).tableau)[indice_i - 1]
4988: [indice_j - 1].partie_imaginaire =
4989: (*((struct_complexe16 *)
4990: (*s_objet_1).objet)).partie_imaginaire;
4991: }
4992: else
4993: {
4994: if (variable_partagee == d_vrai)
4995: {
4996: if (pthread_mutex_unlock(&((*(*s_etat_processus)
4997: .s_liste_variables_partagees).mutex))
4998: != 0)
4999: {
5000: (*s_etat_processus).erreur_systeme =
5001: d_es_processus;
5002: return;
5003: }
5004: }
5005:
5006: liberation(s_etat_processus, s_objet_1);
5007: liberation(s_etat_processus, s_objet_2);
5008: liberation(s_etat_processus, s_objet_3);
5009:
5010: (*s_etat_processus).erreur_execution =
5011: d_ex_erreur_type_argument;
5012: return;
5013: }
5014: }
5015:
5016: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
5017: (*s_objet_2).objet)).suivant).donnee).objet))) > (integer8)
5018: (*((struct_matrice *) (*s_objet_4).objet)).nombre_colonnes)
5019: {
5020: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_2)
5021: .objet)).suivant).donnee).objet)) = 1;
5022:
5023: if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
5024: (*s_objet_2).objet)).donnee).objet))) > (integer8)
5025: (*((struct_matrice *) (*s_objet_4).objet))
5026: .nombre_lignes)
5027: {
5028: (*((integer8 *) (*(*((struct_liste_chainee *)
5029: (*s_objet_2).objet)).donnee).objet)) = 1;
5030: }
5031: }
5032:
5033: if (variable_partagee == d_faux)
5034: {
1.20 bertrand 5035: (*(*s_etat_processus).pointeur_variable_courante).objet =
5036: s_objet_4;
1.1 bertrand 5037: }
5038: else
5039: {
1.20 bertrand 5040: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1.1 bertrand 5041: (*(*s_etat_processus).s_liste_variables_partagees).table
5042: [(*(*s_etat_processus).s_liste_variables_partagees)
5043: .position_variable].objet = s_objet_4;
5044:
5045: if (variable_partagee == d_vrai)
5046: {
5047: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5048: .s_liste_variables_partagees).mutex)) != 0)
5049: {
5050: (*s_etat_processus).erreur_systeme =
5051: d_es_processus;
5052: return;
5053: }
5054: }
5055: }
5056:
5057: liberation(s_etat_processus, s_objet_1);
5058: }
5059: else if ((*s_objet_4).type == LST)
5060: {
5061: if ((*s_objet_2).type != INT)
5062: {
5063: if (variable_partagee == d_vrai)
5064: {
5065: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5066: .s_liste_variables_partagees).mutex)) != 0)
5067: {
5068: (*s_etat_processus).erreur_systeme =
5069: d_es_processus;
5070: return;
5071: }
5072: }
5073:
5074: liberation(s_etat_processus, s_objet_1);
5075: liberation(s_etat_processus, s_objet_2);
5076: liberation(s_etat_processus, s_objet_3);
5077:
5078: (*s_etat_processus).erreur_execution =
5079: d_ex_erreur_type_argument;
5080: return;
5081: }
5082:
5083: indice_i = (*((integer8 *) (*s_objet_2).objet));
5084: indice_j = 1;
5085:
5086: if ((*s_objet_4).nombre_occurrences > 1)
5087: {
5088: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N'))
5089: == NULL)
5090: {
5091: if (variable_partagee == d_vrai)
5092: {
5093: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5094: .s_liste_variables_partagees).mutex)) != 0)
5095: {
5096: (*s_etat_processus).erreur_systeme =
5097: d_es_processus;
5098: return;
5099: }
5100: }
5101:
5102: (*s_etat_processus).erreur_systeme =
5103: d_es_allocation_memoire;
5104: return;
5105: }
5106:
5107: liberation(s_etat_processus, s_objet_4);
5108: s_objet_4 = s_copie_4;
5109: }
5110:
5111: l_element_courant = (*s_objet_4).objet;
5112: nombre_elements = 0;
5113:
5114: while(l_element_courant != NULL)
5115: {
5116: l_element_courant = (*l_element_courant).suivant;
5117: nombre_elements++;
5118: }
5119:
5120: l_element_courant = (*s_objet_4).objet;
5121:
5122: while((l_element_courant != NULL) && (indice_j != indice_i))
5123: {
5124: l_element_courant = (*l_element_courant).suivant;
5125: indice_j++;
5126: }
5127:
5128: if (l_element_courant != NULL)
5129: {
5130: liberation(s_etat_processus, (*l_element_courant).donnee);
5131: (*l_element_courant).donnee = s_objet_1;
5132: }
5133: else
5134: {
5135: if (variable_partagee == d_vrai)
5136: {
5137: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5138: .s_liste_variables_partagees).mutex)) != 0)
5139: {
5140: (*s_etat_processus).erreur_systeme =
5141: d_es_processus;
5142: return;
5143: }
5144: }
5145:
5146: liberation(s_etat_processus, s_objet_1);
5147: liberation(s_etat_processus, s_objet_2);
5148: liberation(s_etat_processus, s_objet_3);
5149:
5150: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
5151: return;
5152: }
5153:
5154: (*((integer8 *) (*s_objet_2).objet)) =
5155: (indice_i % nombre_elements) + 1;
5156:
5157: if (variable_partagee == d_faux)
5158: {
1.20 bertrand 5159: (*(*s_etat_processus).pointeur_variable_courante).objet =
5160: s_objet_4;
1.1 bertrand 5161: }
5162: else
5163: {
1.20 bertrand 5164: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
1.1 bertrand 5165: (*(*s_etat_processus).s_liste_variables_partagees).table
5166: [(*(*s_etat_processus).s_liste_variables_partagees)
5167: .position_variable].objet = s_objet_4;
5168:
5169: if (variable_partagee == d_vrai)
5170: {
5171: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5172: .s_liste_variables_partagees).mutex)) != 0)
5173: {
5174: (*s_etat_processus).erreur_systeme =
5175: d_es_processus;
5176: return;
5177: }
5178: }
5179: }
5180: }
5181: else
5182: {
5183: if (variable_partagee == d_vrai)
5184: {
5185: if (pthread_mutex_unlock(&((*(*s_etat_processus)
5186: .s_liste_variables_partagees).mutex)) != 0)
5187: {
5188: (*s_etat_processus).erreur_systeme =
5189: d_es_processus;
5190: return;
5191: }
5192: }
5193:
5194: liberation(s_etat_processus, s_objet_1);
5195: liberation(s_etat_processus, s_objet_2);
5196: liberation(s_etat_processus, s_objet_3);
5197:
5198: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
5199: return;
5200: }
5201:
5202: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5203: s_objet_3) == d_erreur)
5204: {
5205: return;
5206: }
5207:
5208: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5209: s_objet_2) == d_erreur)
5210: {
5211: return;
5212: }
5213: }
5214:
5215: /*
5216: --------------------------------------------------------------------------------
5217: Arguments incompatibles
5218: --------------------------------------------------------------------------------
5219: */
5220:
5221: else
5222: {
5223: liberation(s_etat_processus, s_objet_1);
5224: liberation(s_etat_processus, s_objet_2);
5225: liberation(s_etat_processus, s_objet_3);
5226:
5227: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
5228: return;
5229: }
5230:
5231: return;
5232: }
5233:
5234: // vim: ts=4