1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.36
4: Copyright (C) 1989-2025 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, %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, d_REC);
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, %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, d_REC);
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, %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, d_REC);
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 if ((*s_objet_3).type == REC)
1266: {
1267: if ((*s_objet_1).type != CHN)
1268: {
1269: if (variable_partagee == d_vrai)
1270: {
1271: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1272: .pointeur_variable_partagee_courante).mutex)) != 0)
1273: {
1274: (*s_etat_processus).erreur_systeme = d_es_processus;
1275: return;
1276: }
1277: }
1278:
1279: liberation(s_etat_processus, s_objet_1);
1280: liberation(s_etat_processus, s_objet_2);
1281:
1282: (*s_etat_processus).erreur_execution =
1283: d_ex_erreur_type_argument;
1284: return;
1285: }
1286:
1287: s_objet_noms = (*((struct_record *) (*s_objet_3).objet)).noms;
1288:
1289: if ((s_enregistrement = bsearch((unsigned char *)
1290: (*s_objet_1).objet, (*((struct_tableau *)
1291: (*s_objet_noms).objet)).elements,
1292: (size_t) (*((struct_tableau *) (*s_objet_noms).objet))
1293: .nombre_elements, sizeof(struct_objet *),
1294: fonction_comparaison)) == NULL)
1295: {
1296: if (variable_partagee == d_vrai)
1297: {
1298: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1299: .pointeur_variable_partagee_courante).mutex)) != 0)
1300: {
1301: (*s_etat_processus).erreur_systeme = d_es_processus;
1302: return;
1303: }
1304: }
1305:
1306: liberation(s_etat_processus, s_objet_1);
1307: liberation(s_etat_processus, s_objet_2);
1308:
1309: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1310: return;
1311: }
1312:
1313: indice_i = s_enregistrement - (*((struct_tableau *)
1314: (*s_objet_noms).objet)).elements;
1315:
1316: // Récupération de l'objet dans le tableau données
1317:
1318: if ((s_objet_resultat = copie_objet(s_etat_processus,
1319: (*((struct_tableau *) (*(*((struct_record *)
1320: (*s_objet_3).objet)).donnees).objet)).elements[indice_i],
1321: 'P')) == NULL)
1322: {
1323: if (variable_partagee == d_vrai)
1324: {
1325: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1326: .pointeur_variable_partagee_courante).mutex)) != 0)
1327: {
1328: (*s_etat_processus).erreur_systeme = d_es_processus;
1329: return;
1330: }
1331: }
1332:
1333: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1334: return;
1335: }
1336: }
1337: else
1338: {
1339: if (variable_partagee == d_vrai)
1340: {
1341: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1342: .pointeur_variable_partagee_courante).mutex)) != 0)
1343: {
1344: (*s_etat_processus).erreur_systeme = d_es_processus;
1345: return;
1346: }
1347: }
1348:
1349: liberation(s_etat_processus, s_objet_1);
1350: liberation(s_etat_processus, s_objet_2);
1351:
1352: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1353: return;
1354: }
1355:
1356: if (variable_partagee == d_vrai)
1357: {
1358: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1359: .pointeur_variable_partagee_courante).mutex)) != 0)
1360: {
1361: (*s_etat_processus).erreur_systeme = d_es_processus;
1362: return;
1363: }
1364: }
1365: }
1366:
1367: /*
1368: --------------------------------------------------------------------------------
1369: Type incompatible avec la fonction GET
1370: --------------------------------------------------------------------------------
1371: */
1372:
1373: else
1374: {
1375: liberation(s_etat_processus, s_objet_1);
1376: liberation(s_etat_processus, s_objet_2);
1377:
1378: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1379: return;
1380: }
1381:
1382: liberation(s_etat_processus, s_objet_1);
1383: liberation(s_etat_processus, s_objet_2);
1384:
1385: if ((*s_objet_resultat).type == NOM)
1386: {
1387: if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
1388: {
1389: if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
1390: {
1391: return;
1392: }
1393: }
1394: else
1395: {
1396: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1397: s_objet_resultat) == d_erreur)
1398: {
1399: return;
1400: }
1401: }
1402: }
1403: else if ((*s_objet_resultat).type == FCT)
1404: {
1405: registre_test = (*s_etat_processus).test_instruction;
1406: registre_instruction_courante = (*s_etat_processus)
1407: .instruction_courante;
1408: registre_instruction_valide = (*s_etat_processus)
1409: .instruction_valide;
1410:
1411: (*s_etat_processus).test_instruction = 'Y';
1412: (*s_etat_processus).instruction_courante =
1413: (*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;
1414:
1415: analyse(s_etat_processus, NULL);
1416:
1417: (*s_etat_processus).test_instruction = registre_test;
1418: (*s_etat_processus).instruction_courante =
1419: registre_instruction_courante;
1420:
1421: if (((*s_etat_processus).instruction_valide == 'Y') &&
1422: (*s_etat_processus).constante_symbolique == 'Y')
1423: {
1424: if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
1425: {
1426: (*s_etat_processus).instruction_valide =
1427: registre_instruction_valide;
1428: return;
1429: }
1430: }
1431: else
1432: {
1433: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1434: s_objet_resultat) == d_erreur)
1435: {
1436: (*s_etat_processus).instruction_valide =
1437: registre_instruction_valide;
1438: return;
1439: }
1440: }
1441:
1442: (*s_etat_processus).instruction_valide = registre_instruction_valide;
1443: }
1444: else
1445: {
1446: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1447: s_objet_resultat) == d_erreur)
1448: {
1449: return;
1450: }
1451: }
1452:
1453: return;
1454: }
1455:
1456:
1457: /*
1458: ================================================================================
1459: Fonction 'geti'
1460: ================================================================================
1461: Entrées :
1462: --------------------------------------------------------------------------------
1463: Sorties :
1464: --------------------------------------------------------------------------------
1465: Effets de bord : néant
1466: ================================================================================
1467: */
1468:
1469: void
1470: instruction_geti(struct_processus *s_etat_processus)
1471: {
1472: logical1 variable_partagee;
1473:
1474: struct_liste_chainee *l_element_courant;
1475:
1476: struct_objet *s_copie_1;
1477: struct_objet *s_objet_1;
1478: struct_objet *s_objet_2;
1479: struct_objet *s_objet_3;
1480: struct_objet *s_objet_resultat;
1481:
1482: integer8 indice_i;
1483: integer8 indice_j;
1484: integer8 nombre_dimensions;
1485: integer8 nombre_elements;
1486:
1487: unsigned char *registre_instruction_courante;
1488: unsigned char registre_instruction_valide;
1489: unsigned char registre_test;
1490:
1491: (*s_etat_processus).erreur_execution = d_ex;
1492:
1493: if ((*s_etat_processus).affichage_arguments == 'Y')
1494: {
1495: printf("\n GETI ");
1496:
1497: if ((*s_etat_processus).langue == 'F')
1498: {
1499: printf("(prend un élément)\n\n");
1500: }
1501: else
1502: {
1503: printf("(get element)\n\n");
1504: }
1505:
1506: printf(" 2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
1507: printf(" 1: %s\n", d_LST);
1508: printf("-> 3: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
1509: printf(" 2: %s\n", d_LST);
1510: printf(" 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);
1511:
1512: printf(" 2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
1513: printf(" 1: %s\n", d_LST);
1514: printf("-> 3: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
1515: printf(" 2: %s\n", d_LST);
1516: printf(" 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);
1517:
1518: printf(" 2: %s, %s\n", d_LST, d_NOM);
1519: printf(" 1: %s\n", d_INT);
1520: printf("-> 3: %s, %s\n", d_LST, d_NOM);
1521: printf(" 2: %s\n", d_INT);
1522: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
1523: " %s, %s, %s, %s, %s,\n"
1524: " %s, %s, %s, %s, %s,\n"
1525: " %s, %s, %s, %s,\n"
1526: " %s, %s, %s\n",
1527: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
1528: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
1529: d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
1530:
1531: return;
1532: }
1533: else if ((*s_etat_processus).test_instruction == 'Y')
1534: {
1535: (*s_etat_processus).nombre_arguments = -1;
1536: return;
1537: }
1538:
1539: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1540: {
1541: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1542: {
1543: return;
1544: }
1545: }
1546:
1547: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1548: &s_objet_1) == d_erreur)
1549: {
1550: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1551: return;
1552: }
1553:
1554: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1555: &s_objet_2) == d_erreur)
1556: {
1557: liberation(s_etat_processus, s_objet_1);
1558:
1559: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1560: return;
1561: }
1562:
1563: if ((s_copie_1 = copie_objet(s_etat_processus, s_objet_1, 'O')) == NULL)
1564: {
1565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1566: return;
1567: }
1568:
1569: liberation(s_etat_processus, s_objet_1);
1570: s_objet_1 = s_copie_1;
1571:
1572: /*
1573: --------------------------------------------------------------------------------
1574: Traitement des éléments des vecteurs
1575: --------------------------------------------------------------------------------
1576: */
1577:
1578: if (((*s_objet_2).type == VIN) ||
1579: ((*s_objet_2).type == VRL) ||
1580: ((*s_objet_2).type == VCX))
1581: {
1582: if ((*s_objet_1).type != LST)
1583: {
1584: liberation(s_etat_processus, s_objet_1);
1585: liberation(s_etat_processus, s_objet_2);
1586:
1587: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1588: return;
1589: }
1590:
1591: l_element_courant = (*s_objet_1).objet;
1592: nombre_dimensions = 0;
1593:
1594: while(l_element_courant != NULL)
1595: {
1596: nombre_dimensions++;
1597: l_element_courant = (*l_element_courant).suivant;
1598: }
1599:
1600: if (nombre_dimensions != 1)
1601: {
1602: liberation(s_etat_processus, s_objet_1);
1603: liberation(s_etat_processus, s_objet_2);
1604:
1605: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
1606: return;
1607: }
1608:
1609: l_element_courant = (*s_objet_1).objet;
1610:
1611: if ((*(*l_element_courant).donnee).type != INT)
1612: {
1613: liberation(s_etat_processus, s_objet_1);
1614: liberation(s_etat_processus, s_objet_2);
1615:
1616: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1617: return;
1618: }
1619:
1620: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
1621: {
1622: liberation(s_etat_processus, s_objet_1);
1623: liberation(s_etat_processus, s_objet_2);
1624:
1625: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1626: return;
1627: }
1628: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
1629: (integer8) (*((struct_vecteur *) (*s_objet_2).objet)).taille)
1630: {
1631: liberation(s_etat_processus, s_objet_1);
1632: liberation(s_etat_processus, s_objet_2);
1633:
1634: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1635: return;
1636: }
1637:
1638: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
1639:
1640: if ((*s_objet_2).type == VIN)
1641: {
1642: /*
1643: * Vecteur d'entiers
1644: */
1645:
1646: if ((s_objet_resultat = allocation(s_etat_processus, INT))
1647: == NULL)
1648: {
1649: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1650: return;
1651: }
1652:
1653: (*((integer8 *) (*s_objet_resultat).objet)) =
1654: ((integer8 *) (*((struct_vecteur *) (*s_objet_2).objet))
1655: .tableau)[indice_i - 1];
1656: }
1657: else if ((*s_objet_2).type == VRL)
1658: {
1659: /*
1660: * Vecteur de réels
1661: */
1662:
1663: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1664: == NULL)
1665: {
1666: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1667: return;
1668: }
1669:
1670: (*((real8 *) (*s_objet_resultat).objet)) =
1671: ((real8 *) (*((struct_vecteur *) (*s_objet_2).objet))
1672: .tableau)[indice_i - 1];
1673: }
1674: else
1675: {
1676: /*
1677: * Vecteur de complexes
1678: */
1679:
1680: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
1681: == NULL)
1682: {
1683: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1684: return;
1685: }
1686:
1687: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
1688: ((struct_complexe16 *) (*((struct_vecteur *)
1689: (*s_objet_2).objet)).tableau)[indice_i - 1].partie_reelle;
1690: (*((struct_complexe16 *) (*s_objet_resultat).objet))
1691: .partie_imaginaire = ((struct_complexe16 *)
1692: (*((struct_vecteur *) (*s_objet_2).objet)).tableau)
1693: [indice_i - 1].partie_imaginaire;
1694: }
1695:
1696: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
1697: (indice_i % (*((struct_vecteur *) (*s_objet_2).objet)).taille)
1698: + 1;
1699: }
1700:
1701: /*
1702: --------------------------------------------------------------------------------
1703: Traitement des éléments des matrices
1704: --------------------------------------------------------------------------------
1705: */
1706:
1707: else if (((*s_objet_2).type == MIN) ||
1708: ((*s_objet_2).type == MRL) ||
1709: ((*s_objet_2).type == MCX))
1710: {
1711: if ((*s_objet_1).type != LST)
1712: {
1713: liberation(s_etat_processus, s_objet_1);
1714: liberation(s_etat_processus, s_objet_2);
1715:
1716: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1717: return;
1718: }
1719:
1720: l_element_courant = (*s_objet_1).objet;
1721: nombre_dimensions = 0;
1722:
1723: while(l_element_courant != NULL)
1724: {
1725: nombre_dimensions++;
1726: l_element_courant = (*l_element_courant).suivant;
1727: }
1728:
1729: if (nombre_dimensions != 2)
1730: {
1731: liberation(s_etat_processus, s_objet_1);
1732: liberation(s_etat_processus, s_objet_2);
1733:
1734: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
1735: return;
1736: }
1737:
1738: l_element_courant = (*s_objet_1).objet;
1739:
1740: indice_i = 0;
1741: indice_j = 0;
1742:
1743: while(l_element_courant != NULL)
1744: {
1745: if ((*(*l_element_courant).donnee).type != INT)
1746: {
1747: liberation(s_etat_processus, s_objet_1);
1748: liberation(s_etat_processus, s_objet_2);
1749:
1750: (*s_etat_processus).erreur_execution =
1751: d_ex_erreur_type_argument;
1752: return;
1753: }
1754:
1755: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
1756: {
1757: liberation(s_etat_processus, s_objet_1);
1758: liberation(s_etat_processus, s_objet_2);
1759:
1760: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1761: return;
1762: }
1763:
1764: if (indice_i == 0)
1765: {
1766: indice_i = (*((integer8 *)
1767: (*(*l_element_courant).donnee).objet));
1768: }
1769: else
1770: {
1771: indice_j = (*((integer8 *)
1772: (*(*l_element_courant).donnee).objet));
1773: }
1774:
1775: l_element_courant = (*l_element_courant).suivant;
1776: }
1777:
1778: if ((indice_i > (*((struct_matrice *) (*s_objet_2).objet))
1779: .nombre_lignes) || (indice_j > (*((struct_matrice *)
1780: (*s_objet_2).objet)).nombre_colonnes))
1781: {
1782: liberation(s_etat_processus, s_objet_1);
1783: liberation(s_etat_processus, s_objet_2);
1784:
1785: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1786: return;
1787: }
1788:
1789: if ((*s_objet_2).type == MIN)
1790: {
1791: /*
1792: * Matrice d'entiers
1793: */
1794:
1795: if ((s_objet_resultat = allocation(s_etat_processus, INT))
1796: == NULL)
1797: {
1798: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1799: return;
1800: }
1801:
1802: (*((integer8 *) (*s_objet_resultat).objet)) =
1803: ((integer8 **) (*((struct_matrice *) (*s_objet_2).objet))
1804: .tableau)[indice_i - 1][indice_j - 1];
1805: }
1806: else if ((*s_objet_2).type == MRL)
1807: {
1808: /*
1809: * Matrice de réels
1810: */
1811:
1812: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1813: == NULL)
1814: {
1815: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1816: return;
1817: }
1818:
1819: (*((real8 *) (*s_objet_resultat).objet)) =
1820: ((real8 **) (*((struct_matrice *) (*s_objet_2).objet))
1821: .tableau)[indice_i - 1][indice_j - 1];
1822: }
1823: else
1824: {
1825: /*
1826: * Matrices de complexes
1827: */
1828:
1829: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
1830: == NULL)
1831: {
1832: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1833: return;
1834: }
1835:
1836: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
1837: ((struct_complexe16 **) (*((struct_matrice *)
1838: (*s_objet_2).objet)).tableau)[indice_i - 1]
1839: [indice_j - 1].partie_reelle;
1840: (*((struct_complexe16 *) (*s_objet_resultat).objet))
1841: .partie_imaginaire = ((struct_complexe16 **)
1842: (*((struct_matrice *) (*s_objet_2).objet)).tableau)
1843: [indice_i - 1][indice_j - 1].partie_imaginaire;
1844: }
1845:
1846:
1847: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
1848: (*s_objet_1).objet)).suivant).donnee).objet))) >
1849: (integer8) (*((struct_matrice *) (*s_objet_2).objet))
1850: .nombre_colonnes)
1851: {
1852: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_1)
1853: .objet)).suivant).donnee).objet)) = 1;
1854:
1855: if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
1856: (*s_objet_1).objet)).donnee).objet))) >
1857: (integer8) (*((struct_matrice *) (*s_objet_2).objet))
1858: .nombre_lignes)
1859: {
1860: (*((integer8 *) (*(*((struct_liste_chainee *)
1861: (*s_objet_1).objet)).donnee).objet)) = 1;
1862: }
1863: }
1864: }
1865:
1866: /*
1867: --------------------------------------------------------------------------------
1868: Traitement des listes
1869: --------------------------------------------------------------------------------
1870: */
1871:
1872: else if ((*s_objet_2).type == LST)
1873: {
1874: if ((*s_objet_1).type != INT)
1875: {
1876: liberation(s_etat_processus, s_objet_1);
1877: liberation(s_etat_processus, s_objet_2);
1878:
1879: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1880: return;
1881: }
1882:
1883: nombre_elements = 0;
1884: l_element_courant = (*s_objet_2).objet;
1885:
1886: while(l_element_courant != NULL)
1887: {
1888: l_element_courant = (*l_element_courant).suivant;
1889: nombre_elements++;
1890: }
1891:
1892: indice_i = (*((integer8 *) (*s_objet_1).objet));
1893: indice_j = 1;
1894: l_element_courant = (*s_objet_2).objet;
1895:
1896: while((l_element_courant != NULL) && (indice_j != indice_i))
1897: {
1898: l_element_courant = (*l_element_courant).suivant;
1899: indice_j++;
1900: }
1901:
1902: if (l_element_courant != NULL)
1903: {
1904: if ((s_objet_resultat = copie_objet(s_etat_processus,
1905: (*l_element_courant).donnee, 'O')) == NULL)
1906: {
1907: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1908: return;
1909: }
1910: }
1911: else
1912: {
1913: liberation(s_etat_processus, s_objet_1);
1914: liberation(s_etat_processus, s_objet_2);
1915:
1916: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
1917: return;
1918: }
1919:
1920: (*((integer8 *) (*s_objet_1).objet)) =
1921: (indice_i % nombre_elements) + 1;
1922: }
1923:
1924: /*
1925: --------------------------------------------------------------------------------
1926: Traitement des variables
1927: --------------------------------------------------------------------------------
1928: */
1929:
1930: else if ((*s_objet_2).type == NOM)
1931: {
1932: variable_partagee = d_faux;
1933:
1934: if (recherche_variable(s_etat_processus, (*((struct_nom *)
1935: (*s_objet_2).objet)).nom) == d_faux)
1936: {
1937: (*s_etat_processus).erreur_systeme = d_es;
1938: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1939:
1940: liberation(s_etat_processus, s_objet_1);
1941: liberation(s_etat_processus, s_objet_2);
1942:
1943: return;
1944: }
1945:
1946: s_objet_3 = (*(*s_etat_processus).pointeur_variable_courante).objet;
1947:
1948: if (s_objet_3 == NULL)
1949: {
1950: if (recherche_variable_partagee(s_etat_processus,
1951: (*(*s_etat_processus).pointeur_variable_courante).nom,
1952: (*(*s_etat_processus).pointeur_variable_courante)
1953: .variable_partagee, (*(*s_etat_processus)
1954: .pointeur_variable_courante).origine) == NULL)
1955: {
1956: (*s_etat_processus).erreur_systeme = d_es;
1957: (*s_etat_processus).erreur_execution =
1958: d_ex_variable_non_definie;
1959:
1960: liberation(s_etat_processus, s_objet_1);
1961: liberation(s_etat_processus, s_objet_2);
1962:
1963: return;
1964: }
1965:
1966: s_objet_3 = (*(*s_etat_processus)
1967: .pointeur_variable_partagee_courante).objet;
1968: variable_partagee = d_vrai;
1969: }
1970:
1971: if (((*s_objet_3).type == VIN) ||
1972: ((*s_objet_3).type == VRL) ||
1973: ((*s_objet_3).type == VCX))
1974: {
1975: if ((*s_objet_1).type != LST)
1976: {
1977: if (variable_partagee == d_vrai)
1978: {
1979: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1980: .pointeur_variable_partagee_courante).mutex)) != 0)
1981: {
1982: (*s_etat_processus).erreur_systeme = d_es_processus;
1983: return;
1984: }
1985: }
1986:
1987: liberation(s_etat_processus, s_objet_1);
1988: liberation(s_etat_processus, s_objet_2);
1989:
1990: (*s_etat_processus).erreur_execution =
1991: d_ex_erreur_type_argument;
1992: return;
1993: }
1994:
1995: l_element_courant = (*s_objet_1).objet;
1996: nombre_dimensions = 0;
1997:
1998: while(l_element_courant != NULL)
1999: {
2000: nombre_dimensions++;
2001: l_element_courant = (*l_element_courant).suivant;
2002: }
2003:
2004: if (nombre_dimensions != 1)
2005: {
2006: if (variable_partagee == d_vrai)
2007: {
2008: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2009: .pointeur_variable_partagee_courante).mutex)) != 0)
2010: {
2011: (*s_etat_processus).erreur_systeme = d_es_processus;
2012: return;
2013: }
2014: }
2015:
2016: liberation(s_etat_processus, s_objet_1);
2017: liberation(s_etat_processus, s_objet_2);
2018:
2019: (*s_etat_processus).erreur_execution =
2020: d_ex_dimensions_invalides;
2021: return;
2022: }
2023:
2024: l_element_courant = (*s_objet_1).objet;
2025:
2026: if ((*(*l_element_courant).donnee).type != INT)
2027: {
2028: if (variable_partagee == d_vrai)
2029: {
2030: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2031: .pointeur_variable_partagee_courante).mutex)) != 0)
2032: {
2033: (*s_etat_processus).erreur_systeme = d_es_processus;
2034: return;
2035: }
2036: }
2037:
2038: liberation(s_etat_processus, s_objet_1);
2039: liberation(s_etat_processus, s_objet_2);
2040:
2041: (*s_etat_processus).erreur_execution =
2042: d_ex_erreur_type_argument;
2043: return;
2044: }
2045:
2046: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
2047: {
2048: if (variable_partagee == d_vrai)
2049: {
2050: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2051: .pointeur_variable_partagee_courante).mutex)) != 0)
2052: {
2053: (*s_etat_processus).erreur_systeme = d_es_processus;
2054: return;
2055: }
2056: }
2057:
2058: liberation(s_etat_processus, s_objet_1);
2059: liberation(s_etat_processus, s_objet_2);
2060:
2061: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
2062: return;
2063: }
2064: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
2065: (integer8) (*((struct_vecteur *) (*s_objet_3).objet))
2066: .taille)
2067: {
2068: if (variable_partagee == d_vrai)
2069: {
2070: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2071: .pointeur_variable_partagee_courante).mutex)) != 0)
2072: {
2073: (*s_etat_processus).erreur_systeme = d_es_processus;
2074: return;
2075: }
2076: }
2077:
2078: liberation(s_etat_processus, s_objet_1);
2079: liberation(s_etat_processus, s_objet_2);
2080:
2081: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
2082: return;
2083: }
2084:
2085: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
2086:
2087: if ((*s_objet_3).type == VIN)
2088: {
2089: /*
2090: * Vecteur d'entiers
2091: */
2092:
2093: if ((s_objet_resultat = allocation(s_etat_processus, INT))
2094: == NULL)
2095: {
2096: if (variable_partagee == d_vrai)
2097: {
2098: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2099: .pointeur_variable_partagee_courante).mutex))
2100: != 0)
2101: {
2102: (*s_etat_processus).erreur_systeme = d_es_processus;
2103: return;
2104: }
2105: }
2106:
2107: (*s_etat_processus).erreur_systeme
2108: = d_es_allocation_memoire;
2109: return;
2110: }
2111:
2112: (*((integer8 *) (*s_objet_resultat).objet)) =
2113: ((integer8 *) (*((struct_vecteur *)
2114: (*s_objet_3).objet)).tableau)[indice_i - 1];
2115: }
2116: else if ((*s_objet_3).type == VRL)
2117: {
2118: /*
2119: * Vecteur de réels
2120: */
2121:
2122: if ((s_objet_resultat = allocation(s_etat_processus, REL))
2123: == NULL)
2124: {
2125: if (variable_partagee == d_vrai)
2126: {
2127: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2128: .pointeur_variable_partagee_courante).mutex))
2129: != 0)
2130: {
2131: (*s_etat_processus).erreur_systeme = d_es_processus;
2132: return;
2133: }
2134: }
2135:
2136: (*s_etat_processus).erreur_systeme
2137: = d_es_allocation_memoire;
2138: return;
2139: }
2140:
2141: (*((real8 *) (*s_objet_resultat).objet)) =
2142: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
2143: .tableau)[indice_i - 1];
2144: }
2145: else
2146: {
2147: /*
2148: * Vecteur de complexes
2149: */
2150:
2151: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
2152: == NULL)
2153: {
2154: if (variable_partagee == d_vrai)
2155: {
2156: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2157: .pointeur_variable_partagee_courante).mutex))
2158: != 0)
2159: {
2160: (*s_etat_processus).erreur_systeme = d_es_processus;
2161: return;
2162: }
2163: }
2164:
2165: (*s_etat_processus).erreur_systeme
2166: = d_es_allocation_memoire;
2167: return;
2168: }
2169:
2170: (*((struct_complexe16 *) (*s_objet_resultat).objet))
2171: .partie_reelle = ((struct_complexe16 *)
2172: (*((struct_vecteur *) (*s_objet_3).objet))
2173: .tableau)[indice_i - 1].partie_reelle;
2174: (*((struct_complexe16 *) (*s_objet_resultat).objet))
2175: .partie_imaginaire = ((struct_complexe16 *)
2176: (*((struct_vecteur *) (*s_objet_3).objet)).tableau)
2177: [indice_i - 1].partie_imaginaire;
2178: }
2179:
2180: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
2181: (indice_i % (*((struct_vecteur *) (*s_objet_3).objet))
2182: .taille) + 1;
2183: }
2184: else if (((*s_objet_3).type == MIN) ||
2185: ((*s_objet_3).type == MRL) ||
2186: ((*s_objet_3).type == MCX))
2187: {
2188: if ((*s_objet_1).type != LST)
2189: {
2190: if (variable_partagee == d_vrai)
2191: {
2192: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2193: .pointeur_variable_partagee_courante).mutex)) != 0)
2194: {
2195: (*s_etat_processus).erreur_systeme = d_es_processus;
2196: return;
2197: }
2198: }
2199:
2200: liberation(s_etat_processus, s_objet_1);
2201: liberation(s_etat_processus, s_objet_2);
2202:
2203: (*s_etat_processus).erreur_execution =
2204: d_ex_erreur_type_argument;
2205: return;
2206: }
2207:
2208: l_element_courant = (*s_objet_1).objet;
2209: nombre_dimensions = 0;
2210:
2211: while(l_element_courant != NULL)
2212: {
2213: nombre_dimensions++;
2214: l_element_courant = (*l_element_courant).suivant;
2215: }
2216:
2217: if (nombre_dimensions != 2)
2218: {
2219: if (variable_partagee == d_vrai)
2220: {
2221: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2222: .pointeur_variable_partagee_courante).mutex)) != 0)
2223: {
2224: (*s_etat_processus).erreur_systeme = d_es_processus;
2225: return;
2226: }
2227: }
2228:
2229: liberation(s_etat_processus, s_objet_1);
2230: liberation(s_etat_processus, s_objet_2);
2231:
2232: (*s_etat_processus).erreur_execution =
2233: d_ex_dimensions_invalides;
2234: return;
2235: }
2236:
2237: l_element_courant = (*s_objet_1).objet;
2238:
2239: indice_i = 0;
2240: indice_j = 0;
2241:
2242: while(l_element_courant != NULL)
2243: {
2244: if ((*(*l_element_courant).donnee).type != INT)
2245: {
2246: if (variable_partagee == d_vrai)
2247: {
2248: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2249: .pointeur_variable_partagee_courante).mutex))
2250: != 0)
2251: {
2252: (*s_etat_processus).erreur_systeme = d_es_processus;
2253: return;
2254: }
2255: }
2256:
2257: liberation(s_etat_processus, s_objet_1);
2258: liberation(s_etat_processus, s_objet_2);
2259:
2260: (*s_etat_processus).erreur_execution =
2261: d_ex_erreur_type_argument;
2262: return;
2263: }
2264:
2265: if ((*((integer8 *) (*(*l_element_courant)
2266: .donnee).objet)) <= 0)
2267: {
2268: if (variable_partagee == d_vrai)
2269: {
2270: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2271: .pointeur_variable_partagee_courante).mutex))
2272: != 0)
2273: {
2274: (*s_etat_processus).erreur_systeme = d_es_processus;
2275: return;
2276: }
2277: }
2278:
2279: liberation(s_etat_processus, s_objet_1);
2280: liberation(s_etat_processus, s_objet_2);
2281:
2282: (*s_etat_processus).erreur_execution =
2283: d_ex_argument_invalide;
2284: return;
2285: }
2286:
2287: if (indice_i == 0)
2288: {
2289: indice_i = (*((integer8 *)
2290: (*(*l_element_courant).donnee).objet));
2291: }
2292: else
2293: {
2294: indice_j = (*((integer8 *)
2295: (*(*l_element_courant).donnee).objet));
2296: }
2297:
2298: l_element_courant = (*l_element_courant).suivant;
2299: }
2300:
2301: if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet))
2302: .nombre_lignes) || (indice_j > (*((struct_matrice *)
2303: (*s_objet_3).objet)).nombre_colonnes))
2304: {
2305: if (variable_partagee == d_vrai)
2306: {
2307: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2308: .pointeur_variable_partagee_courante).mutex)) != 0)
2309: {
2310: (*s_etat_processus).erreur_systeme = d_es_processus;
2311: return;
2312: }
2313: }
2314:
2315: liberation(s_etat_processus, s_objet_1);
2316: liberation(s_etat_processus, s_objet_2);
2317:
2318: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
2319: return;
2320: }
2321:
2322: if ((*s_objet_3).type == MIN)
2323: {
2324: /*
2325: * Matrice d'entiers
2326: */
2327:
2328: if ((s_objet_resultat = allocation(s_etat_processus, INT))
2329: == NULL)
2330: {
2331: if (variable_partagee == d_vrai)
2332: {
2333: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2334: .pointeur_variable_partagee_courante).mutex))
2335: != 0)
2336: {
2337: (*s_etat_processus).erreur_systeme = d_es_processus;
2338: return;
2339: }
2340: }
2341:
2342: (*s_etat_processus).erreur_systeme =
2343: d_es_allocation_memoire;
2344: return;
2345: }
2346:
2347: (*((integer8 *) (*s_objet_resultat).objet)) =
2348: ((integer8 **) (*((struct_matrice *)
2349: (*s_objet_3).objet))
2350: .tableau)[indice_i - 1][indice_j - 1];
2351: }
2352: else if ((*s_objet_3).type == MRL)
2353: {
2354: /*
2355: * Matrice de réels
2356: */
2357:
2358: if ((s_objet_resultat = allocation(s_etat_processus, REL))
2359: == NULL)
2360: {
2361: if (variable_partagee == d_vrai)
2362: {
2363: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2364: .pointeur_variable_partagee_courante).mutex))
2365: != 0)
2366: {
2367: (*s_etat_processus).erreur_systeme = d_es_processus;
2368: return;
2369: }
2370: }
2371:
2372: (*s_etat_processus).erreur_systeme =
2373: d_es_allocation_memoire;
2374: return;
2375: }
2376:
2377: (*((real8 *) (*s_objet_resultat).objet)) =
2378: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
2379: .tableau)[indice_i - 1][indice_j - 1];
2380: }
2381: else
2382: {
2383: /*
2384: * Matrices de complexes
2385: */
2386:
2387: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
2388: == NULL)
2389: {
2390: if (variable_partagee == d_vrai)
2391: {
2392: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2393: .pointeur_variable_partagee_courante).mutex))
2394: != 0)
2395: {
2396: (*s_etat_processus).erreur_systeme = d_es_processus;
2397: return;
2398: }
2399: }
2400:
2401: (*s_etat_processus).erreur_systeme =
2402: d_es_allocation_memoire;
2403: return;
2404: }
2405:
2406: (*((struct_complexe16 *) (*s_objet_resultat).objet))
2407: .partie_reelle = ((struct_complexe16 **)
2408: (*((struct_matrice *)
2409: (*s_objet_3).objet)).tableau)[indice_i - 1]
2410: [indice_j - 1].partie_reelle;
2411: (*((struct_complexe16 *) (*s_objet_resultat).objet))
2412: .partie_imaginaire = ((struct_complexe16 **)
2413: (*((struct_matrice *) (*s_objet_3).objet)).tableau)
2414: [indice_i - 1][indice_j - 1].partie_imaginaire;
2415: }
2416:
2417: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
2418: (*s_objet_1).objet)).suivant).donnee).objet))) >
2419: (integer8) (*((struct_matrice *) (*s_objet_3).objet))
2420: .nombre_colonnes)
2421: {
2422: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_1)
2423: .objet)).suivant).donnee).objet)) = 1;
2424:
2425: if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
2426: (*s_objet_1).objet)).donnee).objet))) >
2427: (integer8) (*((struct_matrice *) (*s_objet_3).objet))
2428: .nombre_lignes)
2429: {
2430: (*((integer8 *) (*(*((struct_liste_chainee *)
2431: (*s_objet_1).objet)).donnee).objet)) = 1;
2432: }
2433: }
2434: }
2435: else if ((*s_objet_3).type == LST)
2436: {
2437: if ((*s_objet_1).type != INT)
2438: {
2439: if (variable_partagee == d_vrai)
2440: {
2441: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2442: .pointeur_variable_partagee_courante).mutex)) != 0)
2443: {
2444: (*s_etat_processus).erreur_systeme = d_es_processus;
2445: return;
2446: }
2447: }
2448:
2449: liberation(s_etat_processus, s_objet_1);
2450: liberation(s_etat_processus, s_objet_2);
2451:
2452: (*s_etat_processus).erreur_execution =
2453: d_ex_erreur_type_argument;
2454: return;
2455: }
2456:
2457: nombre_elements = 0;
2458: l_element_courant = (*s_objet_3).objet;
2459:
2460: while(l_element_courant != NULL)
2461: {
2462: l_element_courant = (*l_element_courant).suivant;
2463: nombre_elements++;
2464: }
2465:
2466: indice_i = (*((integer8 *) (*s_objet_1).objet));
2467: indice_j = 1;
2468: l_element_courant = (*s_objet_3).objet;
2469:
2470: while((l_element_courant != NULL) && (indice_j != indice_i))
2471: {
2472: l_element_courant = (*l_element_courant).suivant;
2473: indice_j++;
2474: }
2475:
2476: if (l_element_courant != NULL)
2477: {
2478: if ((s_objet_resultat = copie_objet(s_etat_processus,
2479: (*l_element_courant).donnee, 'O')) == NULL)
2480: {
2481: if (variable_partagee == d_vrai)
2482: {
2483: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2484: .pointeur_variable_partagee_courante).mutex))
2485: != 0)
2486: {
2487: (*s_etat_processus).erreur_systeme = d_es_processus;
2488: return;
2489: }
2490: }
2491:
2492: (*s_etat_processus).erreur_systeme =
2493: d_es_allocation_memoire;
2494: return;
2495: }
2496: }
2497: else
2498: {
2499: if (variable_partagee == d_vrai)
2500: {
2501: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2502: .pointeur_variable_partagee_courante).mutex)) != 0)
2503: {
2504: (*s_etat_processus).erreur_systeme = d_es_processus;
2505: return;
2506: }
2507: }
2508:
2509: liberation(s_etat_processus, s_objet_1);
2510: liberation(s_etat_processus, s_objet_2);
2511:
2512: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
2513: return;
2514: }
2515:
2516: (*((integer8 *) (*s_objet_1).objet)) =
2517: (indice_i % nombre_elements) + 1;
2518: }
2519: else
2520: {
2521: if (variable_partagee == d_vrai)
2522: {
2523: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2524: .pointeur_variable_partagee_courante).mutex)) != 0)
2525: {
2526: (*s_etat_processus).erreur_systeme = d_es_processus;
2527: return;
2528: }
2529: }
2530:
2531: liberation(s_etat_processus, s_objet_1);
2532: liberation(s_etat_processus, s_objet_2);
2533:
2534: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2535: return;
2536: }
2537:
2538: if (variable_partagee == d_vrai)
2539: {
2540: if (pthread_mutex_unlock(&((*(*s_etat_processus)
2541: .pointeur_variable_partagee_courante).mutex)) != 0)
2542: {
2543: (*s_etat_processus).erreur_systeme = d_es_processus;
2544: return;
2545: }
2546: }
2547: }
2548:
2549: /*
2550: --------------------------------------------------------------------------------
2551: Type incompatible avec la fonction GETI
2552: --------------------------------------------------------------------------------
2553: */
2554:
2555: else
2556: {
2557: liberation(s_etat_processus, s_objet_1);
2558: liberation(s_etat_processus, s_objet_2);
2559:
2560: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2561: return;
2562: }
2563:
2564: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2565: s_objet_2) == d_erreur)
2566: {
2567: return;
2568: }
2569:
2570: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2571: s_objet_1) == d_erreur)
2572: {
2573: return;
2574: }
2575:
2576: if ((*s_objet_resultat).type == NOM)
2577: {
2578: if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
2579: {
2580: if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
2581: {
2582: return;
2583: }
2584: }
2585: else
2586: {
2587: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2588: s_objet_resultat) == d_erreur)
2589: {
2590: return;
2591: }
2592: }
2593: }
2594: else if ((*s_objet_resultat).type == FCT)
2595: {
2596: registre_test = (*s_etat_processus).test_instruction;
2597: registre_instruction_courante = (*s_etat_processus)
2598: .instruction_courante;
2599: registre_instruction_valide = (*s_etat_processus)
2600: .instruction_valide;
2601:
2602: (*s_etat_processus).test_instruction = 'Y';
2603: (*s_etat_processus).instruction_courante =
2604: (*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;
2605:
2606: analyse(s_etat_processus, NULL);
2607:
2608: (*s_etat_processus).test_instruction = registre_test;
2609: (*s_etat_processus).instruction_courante =
2610: registre_instruction_courante;
2611:
2612: if (((*s_etat_processus).instruction_valide == 'Y') &&
2613: (*s_etat_processus).constante_symbolique == 'Y')
2614: {
2615: if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
2616: {
2617: (*s_etat_processus).instruction_valide =
2618: registre_instruction_valide;
2619: return;
2620: }
2621: }
2622: else
2623: {
2624: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2625: s_objet_resultat) == d_erreur)
2626: {
2627: (*s_etat_processus).instruction_valide =
2628: registre_instruction_valide;
2629: return;
2630: }
2631: }
2632:
2633: (*s_etat_processus).instruction_valide = registre_instruction_valide;
2634: }
2635: else
2636: {
2637: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2638: s_objet_resultat) == d_erreur)
2639: {
2640: return;
2641: }
2642: }
2643:
2644: return;
2645: }
2646:
2647: // 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