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