1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.36
4: Copyright (C) 1989-2025 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'crmtx'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_crmtx(struct_processus *s_etat_processus)
40: {
41: pthread_mutexattr_t attributs_mutex;
42:
43: struct_liste_chainee *s_mutex;
44:
45: struct_objet *s_objet;
46:
47: (*s_etat_processus).erreur_execution = d_ex;
48:
49: if ((*s_etat_processus).affichage_arguments == 'Y')
50: {
51: printf("\n CRMTX ");
52:
53: if ((*s_etat_processus).langue == 'F')
54: {
55: printf("(création d'un mutex)\n\n");
56: printf(" Aucun argument\n");
57: }
58: else
59: {
60: printf("(create mutex)\n\n");
61: printf(" No argument\n");
62: }
63:
64: return;
65: }
66: else if ((*s_etat_processus).test_instruction == 'Y')
67: {
68: (*s_etat_processus).nombre_arguments = -1;
69: return;
70: }
71:
72: if (test_cfsf(s_etat_processus, 31) == d_vrai)
73: {
74: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
75: {
76: return;
77: }
78: }
79:
80: if ((s_mutex = allocation_maillon(s_etat_processus)) == NULL)
81: {
82: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
83: return;
84: }
85:
86: if ((s_objet = allocation(s_etat_processus, MTX)) == NULL)
87: {
88: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
89: return;
90: }
91:
92: pthread_mutexattr_init(&attributs_mutex);
93: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
94: pthread_mutex_init(&((*((struct_mutex *) (*s_objet).objet)).mutex),
95: &attributs_mutex);
96: pthread_mutexattr_destroy(&attributs_mutex);
97:
98: if (((*s_mutex).donnee = copie_objet(s_etat_processus, s_objet, 'P'))
99: == NULL)
100: {
101: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
102: return;
103: }
104:
105: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
106: s_objet) == d_erreur)
107: {
108: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
109: return;
110: }
111:
112: if (pthread_mutex_lock(&((*s_etat_processus).protection_liste_mutexes))
113: != 0)
114: {
115: (*s_etat_processus).erreur_systeme = d_es_processus;
116: return;
117: }
118:
119: (*s_mutex).suivant = (*s_etat_processus).liste_mutexes;
120: (*s_etat_processus).liste_mutexes = s_mutex;
121:
122: if (pthread_mutex_unlock(&((*s_etat_processus).protection_liste_mutexes))
123: != 0)
124: {
125: (*s_etat_processus).erreur_systeme = d_es_processus;
126: return;
127: }
128:
129: return;
130: }
131:
132:
133: /*
134: ================================================================================
135: Fonction 'clrmtx'
136: ================================================================================
137: Entrées :
138: --------------------------------------------------------------------------------
139: Sorties :
140: --------------------------------------------------------------------------------
141: Effets de bord : néant
142: ================================================================================
143: */
144:
145: void
146: instruction_clrmtx(struct_processus *s_etat_processus)
147: {
148: struct_liste_chainee *l_element_courant;
149: struct_liste_chainee *l_element_precedent;
150:
151: struct_objet *s_objet;
152:
153: (*s_etat_processus).erreur_execution = d_ex;
154:
155: if ((*s_etat_processus).affichage_arguments == 'Y')
156: {
157: printf("\n CLRMTX ");
158:
159: if ((*s_etat_processus).langue == 'F')
160: {
161: printf("(destruction d'un mutex)\n\n");
162: }
163: else
164: {
165: printf("(clear mutex)\n\n");
166: }
167:
168: printf(" 1: %s\n", d_MTX);
169:
170: return;
171: }
172: else if ((*s_etat_processus).test_instruction == 'Y')
173: {
174: (*s_etat_processus).nombre_arguments = -1;
175: return;
176: }
177:
178: if (test_cfsf(s_etat_processus, 31) == d_vrai)
179: {
180: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
181: {
182: return;
183: }
184: }
185:
186: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
187: &s_objet) == d_erreur)
188: {
189: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
190: return;
191: }
192:
193: if ((*s_objet).type == MTX)
194: {
195: l_element_precedent = NULL;
196: l_element_courant = (*s_etat_processus).liste_mutexes;
197:
198: while(l_element_courant != NULL)
199: {
200: if (&((*((struct_mutex *) (*s_objet).objet)).mutex) ==
201: &((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
202: .mutex))
203: {
204: if (l_element_precedent == NULL)
205: {
206: (*s_etat_processus).liste_mutexes =
207: (*l_element_courant).suivant;
208: }
209: else if ((*l_element_courant).suivant == NULL)
210: {
211: (*l_element_precedent).suivant = NULL;
212: }
213: else
214: {
215: (*l_element_precedent).suivant =
216: (*l_element_courant).suivant;
217: }
218:
219: liberation(s_etat_processus, (*l_element_courant).donnee);
220: free(l_element_courant);
221:
222: break;
223: }
224:
225: l_element_precedent = l_element_courant;
226: l_element_courant = (*l_element_courant).suivant;
227: }
228:
229: if (l_element_courant == NULL)
230: {
231: liberation(s_etat_processus, s_objet);
232:
233: (*s_etat_processus).erreur_execution = d_ex_mutex;
234: return;
235: }
236: }
237: else
238: {
239: liberation(s_etat_processus, s_objet);
240:
241: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
242: return;
243: }
244:
245: liberation(s_etat_processus, s_objet);
246:
247: return;
248: }
249:
250:
251: /*
252: ================================================================================
253: Fonction 'copy'
254: ================================================================================
255: Entrées : structure processus
256: --------------------------------------------------------------------------------
257: Sorties :
258: --------------------------------------------------------------------------------
259: Effets de bord : néant
260: ================================================================================
261: */
262:
263: void
264: instruction_copy(struct_processus *s_etat_processus)
265: {
266: struct_objet *s_objet_argument;
267: struct_objet *s_objet_resultat;
268:
269: (*s_etat_processus).erreur_execution = d_ex;
270:
271: if ((*s_etat_processus).affichage_arguments == 'Y')
272: {
273: printf("\n COPY ");
274:
275: if ((*s_etat_processus).langue == 'F')
276: {
277: printf("(création d'une nouvelle instance d'un objet)\n\n");
278: }
279: else
280: {
281: printf("(create new object instance)\n\n");
282: }
283:
284: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
285: " %s, %s, %s, %s, %s,\n"
286: " %s, %s, %s, %s, %s,\n"
287: " %s, %s, %s, %s,\n"
288: " %s, %s, %s\n",
289: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
290: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
291: d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
292: printf("-> 1: %s, %s, %s, %s, %s, %s,\n"
293: " %s, %s, %s, %s, %s,\n"
294: " %s, %s, %s, %s, %s,\n"
295: " %s, %s, %s, %s,\n"
296: " %s, %s, %s\n",
297: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
298: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
299: d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
300:
301: return;
302: }
303: else if ((*s_etat_processus).test_instruction == 'Y')
304: {
305: (*s_etat_processus).nombre_arguments = -1;
306: return;
307: }
308:
309: if (test_cfsf(s_etat_processus, 31) == d_vrai)
310: {
311: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
312: {
313: return;
314: }
315: }
316:
317: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
318: &s_objet_argument) == d_erreur)
319: {
320: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
321: return;
322: }
323:
324: s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'O');
325: liberation(s_etat_processus, s_objet_argument);
326:
327: if (s_objet_resultat == NULL)
328: {
329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
330: return;
331: }
332:
333: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
334: s_objet_resultat) == d_erreur)
335: {
336: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
337: return;
338: }
339:
340: return;
341: }
342:
343:
344: /*
345: ================================================================================
346: Fonction 'crsmphr'
347: ================================================================================
348: Entrées :
349: --------------------------------------------------------------------------------
350: Sorties :
351: --------------------------------------------------------------------------------
352: Effets de bord : néant
353: ================================================================================
354: */
355:
356: void
357: instruction_crsmphr(struct_processus *s_etat_processus)
358: {
359: sem_t *semaphore;
360:
361: struct_objet *s_objet_argument_1;
362: struct_objet *s_objet_argument_2;
363:
364: (*s_etat_processus).erreur_execution = d_ex;
365:
366: if ((*s_etat_processus).affichage_arguments == 'Y')
367: {
368: printf("\n CRSMPHR ");
369:
370: if ((*s_etat_processus).langue == 'F')
371: {
372: printf("(création d'un sémaphore nommé)\n\n");
373: }
374: else
375: {
376: printf("(create named semaphore)\n\n");
377: }
378:
379: printf(" 2: %s\n", d_INT);
380: printf(" 1: %s\n", d_CHN);
381: return;
382: }
383: else if ((*s_etat_processus).test_instruction == 'Y')
384: {
385: (*s_etat_processus).nombre_arguments = -1;
386: return;
387: }
388:
389: if (test_cfsf(s_etat_processus, 31) == d_vrai)
390: {
391: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
392: {
393: return;
394: }
395: }
396:
397: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
398: &s_objet_argument_1) == d_erreur)
399: {
400: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
401: return;
402: }
403:
404: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
405: &s_objet_argument_2) == d_erreur)
406: {
407: liberation(s_etat_processus, s_objet_argument_1);
408:
409: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
410: return;
411: }
412:
413: if (((*s_objet_argument_1).type == CHN) &&
414: ((*s_objet_argument_2).type == INT))
415: {
416: if ((semaphore = sem_open((unsigned char *) (*s_objet_argument_1).objet,
417: O_CREAT | O_EXCL, S_IRUSR | S_IWUSR,
418: (int) (*((integer8 *) (*s_objet_argument_2).objet)))) ==
419: SEM_FAILED)
420: {
421: (*s_etat_processus).erreur_execution = d_ex_semaphore;
422:
423: liberation(s_etat_processus, s_objet_argument_1);
424: liberation(s_etat_processus, s_objet_argument_2);
425:
426: return;
427: }
428:
429: if (sem_close(semaphore) != 0)
430: {
431: (*s_etat_processus).erreur_execution = d_ex_semaphore;
432:
433: liberation(s_etat_processus, s_objet_argument_1);
434: liberation(s_etat_processus, s_objet_argument_2);
435:
436: return;
437: }
438: }
439: else
440: {
441: liberation(s_etat_processus, s_objet_argument_1);
442: liberation(s_etat_processus, s_objet_argument_2);
443:
444: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
445: return;
446: }
447:
448: liberation(s_etat_processus, s_objet_argument_1);
449: liberation(s_etat_processus, s_objet_argument_2);
450:
451: return;
452: }
453:
454:
455: /*
456: ================================================================================
457: Fonction 'clrsmphr'
458: ================================================================================
459: Entrées :
460: --------------------------------------------------------------------------------
461: Sorties :
462: --------------------------------------------------------------------------------
463: Effets de bord : néant
464: ================================================================================
465: */
466:
467: void
468: instruction_clrsmphr(struct_processus *s_etat_processus)
469: {
470: struct_objet *s_objet_argument;
471:
472: (*s_etat_processus).erreur_execution = d_ex;
473:
474: if ((*s_etat_processus).affichage_arguments == 'Y')
475: {
476: printf("\n CLRSMPHR ");
477:
478: if ((*s_etat_processus).langue == 'F')
479: {
480: printf("(destruction d'un sémaphore nommé)\n\n");
481: }
482: else
483: {
484: printf("(delete named semaphore)\n\n");
485: }
486:
487: printf(" 1: %s\n", d_CHN);
488: return;
489: }
490: else if ((*s_etat_processus).test_instruction == 'Y')
491: {
492: (*s_etat_processus).nombre_arguments = -1;
493: return;
494: }
495:
496: if (test_cfsf(s_etat_processus, 31) == d_vrai)
497: {
498: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
499: {
500: return;
501: }
502: }
503:
504: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
505: &s_objet_argument) == d_erreur)
506: {
507: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
508: return;
509: }
510:
511: if ((*s_objet_argument).type == CHN)
512: {
513: if (sem_unlink((unsigned char *) (*s_objet_argument).objet) != 0)
514: {
515: (*s_etat_processus).erreur_execution = d_ex_semaphore;
516:
517: liberation(s_etat_processus, s_objet_argument);
518: return;
519: }
520: }
521: else
522: {
523: liberation(s_etat_processus, s_objet_argument);
524:
525: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
526: return;
527: }
528:
529: liberation(s_etat_processus, s_objet_argument);
530:
531: return;
532: }
533:
534:
535: /*
536: ================================================================================
537: Fonction 'cond'
538: ================================================================================
539: Entrées :
540: --------------------------------------------------------------------------------
541: Sorties :
542: --------------------------------------------------------------------------------
543: Effets de bord : néant
544: ================================================================================
545: */
546:
547: void
548: instruction_cond(struct_processus *s_etat_processus)
549: {
550: struct_objet *s_objet_argument;
551: struct_objet *s_objet_resultat;
552:
553: (*s_etat_processus).erreur_execution = d_ex;
554:
555: if ((*s_etat_processus).affichage_arguments == 'Y')
556: {
557: printf("\n COND ");
558:
559: if ((*s_etat_processus).langue == 'F')
560: {
561: printf("(nombre de condition d'une matrice)\n\n");
562: }
563: else
564: {
565: printf("(matrix condition number)\n\n");
566: }
567:
568: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
569: printf("-> 1: %s\n", d_REL);
570: return;
571: }
572: else if ((*s_etat_processus).test_instruction == 'Y')
573: {
574: (*s_etat_processus).nombre_arguments = -1;
575: return;
576: }
577:
578: if (test_cfsf(s_etat_processus, 31) == d_vrai)
579: {
580: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
581: {
582: return;
583: }
584: }
585:
586: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
587: &s_objet_argument) == d_erreur)
588: {
589: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
590: return;
591: }
592:
593: if (((*s_objet_argument).type == MIN) ||
594: ((*s_objet_argument).type == MRL) ||
595: ((*s_objet_argument).type == MCX))
596: {
597: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
598: {
599: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
600: return;
601: }
602:
603: cond(s_etat_processus, (*s_objet_argument).objet,
604: (*s_objet_resultat).objet);
605:
606: if ((*s_etat_processus).erreur_systeme != d_es)
607: {
608: return;
609: }
610:
611: if (((*s_etat_processus).erreur_execution != d_ex) ||
612: ((*s_etat_processus).exception != d_ep))
613: {
614: liberation(s_etat_processus, s_objet_argument);
615: liberation(s_etat_processus, s_objet_resultat);
616: return;
617: }
618: }
619: else
620: {
621: liberation(s_etat_processus, s_objet_argument);
622:
623: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
624: return;
625: }
626:
627: liberation(s_etat_processus, s_objet_argument);
628:
629: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
630: s_objet_resultat) == d_erreur)
631: {
632: return;
633: }
634:
635: return;
636: }
637:
638:
639: /*
640: ================================================================================
641: Fonction 'clrerr'
642: ================================================================================
643: Entrées :
644: --------------------------------------------------------------------------------
645: Sorties :
646: --------------------------------------------------------------------------------
647: Effets de bord : néant
648: ================================================================================
649: */
650:
651: void
652: instruction_clrerr(struct_processus *s_etat_processus)
653: {
654: (*s_etat_processus).erreur_execution = d_ex;
655:
656: if ((*s_etat_processus).affichage_arguments == 'Y')
657: {
658: printf("\n CLRERR ");
659:
660: if ((*s_etat_processus).langue == 'F')
661: {
662: printf("(réinitialisation des erreurs)\n\n");
663: printf(" Aucun argument\n");
664: }
665: else
666: {
667: printf("(error reinitialization)\n\n");
668: printf(" No argument\n");
669: }
670:
671: return;
672: }
673: else if ((*s_etat_processus).test_instruction == 'Y')
674: {
675: (*s_etat_processus).nombre_arguments = -1;
676: return;
677: }
678:
679: if (test_cfsf(s_etat_processus, 31) == d_vrai)
680: {
681: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
682: {
683: return;
684: }
685: }
686:
687: (*s_etat_processus).derniere_exception = d_ep;
688: (*s_etat_processus).derniere_erreur_execution = d_ex;
689: (*s_etat_processus).derniere_erreur_systeme = d_es;
690:
691: return;
692: }
693:
694:
695: /*
696: ================================================================================
697: Fonction 'currenc'
698: ================================================================================
699: Entrées :
700: --------------------------------------------------------------------------------
701: Sorties :
702: --------------------------------------------------------------------------------
703: Effets de bord : néant
704: ================================================================================
705: */
706:
707: void
708: instruction_currenc(struct_processus *s_etat_processus)
709: {
710: struct_objet *s_objet_resultat;
711:
712: (*s_etat_processus).erreur_execution = d_ex;
713:
714: if ((*s_etat_processus).affichage_arguments == 'Y')
715: {
716: printf("\n CURRENC ");
717:
718: if ((*s_etat_processus).langue == 'F')
719: {
720: printf("(encodage interne des chaînes de caractères)\n\n");
721: }
722: else
723: {
724: printf("(internal strings encodage)\n\n");
725: }
726:
727: printf("-> 1: %s\n", d_CHN);
728: return;
729: }
730: else if ((*s_etat_processus).test_instruction == 'Y')
731: {
732: (*s_etat_processus).nombre_arguments = -1;
733: return;
734: }
735:
736: if (test_cfsf(s_etat_processus, 31) == d_vrai)
737: {
738: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
739: {
740: return;
741: }
742: }
743:
744: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
745: {
746: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
747: return;
748: }
749:
750: if (((*s_objet_resultat).objet = malloc((strlen(d_locale) + 1) *
751: sizeof(unsigned char))) == NULL)
752: {
753: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
754: return;
755: }
756:
757: strcpy((unsigned char *) (*s_objet_resultat).objet, d_locale);
758:
759: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
760: s_objet_resultat) == d_erreur)
761: {
762: return;
763: }
764:
765: return;
766: }
767:
768:
769: /*
770: ================================================================================
771: Fonction 'clratexit'
772: ================================================================================
773: Entrées : pointeur sur une structure struct_processus
774: --------------------------------------------------------------------------------
775: Sorties :
776: --------------------------------------------------------------------------------
777: Effets de bord : néant
778: ================================================================================
779: */
780:
781: void
782: instruction_clratexit(struct_processus *s_etat_processus)
783: {
784: (*s_etat_processus).erreur_execution = d_ex;
785:
786: if ((*s_etat_processus).affichage_arguments == 'Y')
787: {
788: printf("\n CLRATEXIT ");
789:
790: if ((*s_etat_processus).langue == 'F')
791: {
792: printf("(suppression de la fonction de terminaison)\n\n");
793: printf(" Aucun argument\n");
794: }
795: else
796: {
797: printf("(delete task terminaison function)\n\n");
798: printf(" No argument\n");
799: }
800:
801: return;
802: }
803: else if ((*s_etat_processus).test_instruction == 'Y')
804: {
805: (*s_etat_processus).nombre_arguments = -1;
806: return;
807: }
808:
809: if (test_cfsf(s_etat_processus, 31) == d_vrai)
810: {
811: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
812: {
813: return;
814: }
815: }
816:
817: liberation(s_etat_processus, (*s_etat_processus).at_exit);
818: (*s_etat_processus).at_exit = NULL;
819:
820: return;
821: }
822:
823:
824: /*
825: ================================================================================
826: Fonction 'clratpoke'
827: ================================================================================
828: Entrées : pointeur sur une structure struct_processus
829: --------------------------------------------------------------------------------
830: Sorties :
831: --------------------------------------------------------------------------------
832: Effets de bord : néant
833: ================================================================================
834: */
835:
836: void
837: instruction_clratpoke(struct_processus *s_etat_processus)
838: {
839: (*s_etat_processus).erreur_execution = d_ex;
840:
841: if ((*s_etat_processus).affichage_arguments == 'Y')
842: {
843: printf("\n CLRATPOKE ");
844:
845: if ((*s_etat_processus).langue == 'F')
846: {
847: printf("(suppression de la fonction de contrôle d'injection)\n\n");
848: printf(" Aucun argument\n");
849: }
850: else
851: {
852: printf("(delete injection controle function)\n\n");
853: printf(" No argument\n");
854: }
855:
856: return;
857: }
858: else if ((*s_etat_processus).test_instruction == 'Y')
859: {
860: (*s_etat_processus).nombre_arguments = -1;
861: return;
862: }
863:
864: if (test_cfsf(s_etat_processus, 31) == d_vrai)
865: {
866: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
867: {
868: return;
869: }
870: }
871:
872: liberation(s_etat_processus, (*s_etat_processus).at_poke);
873: (*s_etat_processus).at_poke = NULL;
874:
875: return;
876: }
877:
878:
879: /*
880: ================================================================================
881: Fonction 'critical'
882: ================================================================================
883: Entrées :
884: --------------------------------------------------------------------------------
885: Sorties :
886: --------------------------------------------------------------------------------
887: Effets de bord : néant
888: ================================================================================
889: */
890:
891: void
892: instruction_critical(struct_processus *s_etat_processus)
893: {
894: (*s_etat_processus).erreur_execution = d_ex;
895:
896: if ((*s_etat_processus).affichage_arguments == 'Y')
897: {
898: printf("\n CRITICAL ");
899:
900: if ((*s_etat_processus).langue == 'F')
901: {
902: printf("(initialisation d'une section critique)\n\n");
903: printf(" Aucun argument\n");
904: }
905: else
906: {
907: printf("(critical section initialization)\n\n");
908: printf(" No argument\n");
909: }
910:
911: return;
912: }
913: else if ((*s_etat_processus).test_instruction == 'Y')
914: {
915: (*s_etat_processus).nombre_arguments = -1;
916: return;
917: }
918:
919: if (test_cfsf(s_etat_processus, 31) == d_vrai)
920: {
921: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
922: {
923: return;
924: }
925: }
926:
927: empilement_pile_systeme(s_etat_processus);
928:
929: if ((*s_etat_processus).erreur_systeme != d_es)
930: {
931: return;
932: }
933:
934: (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'Q';
935:
936: if (pthread_mutex_lock(&mutex_sections_critiques) != 0)
937: {
938: (*s_etat_processus).erreur_systeme = d_es_processus;
939: return;
940: }
941:
942: (*s_etat_processus).sections_critiques++;
943: return;
944: }
945:
946: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_c7.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src