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