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