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