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