1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.31
4: Copyright (C) 1989-2019 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 'protect'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_protect(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_element_courant;
42:
43: struct_objet *s_objet;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n PROTECT ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(verrouille une variable)\n\n");
54: }
55: else
56: {
57: printf("(lock a variable)\n\n");
58: }
59:
60: printf(" 1: %s, %s\n", d_NOM, d_LST);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if ((*s_objet).type == NOM)
86: {
87: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
88: (*s_objet).objet)).nom)) == d_faux)
89: {
90: liberation(s_etat_processus, s_objet);
91:
92: (*s_etat_processus).erreur_systeme = d_es;
93: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
94: return;
95: }
96:
97: (*(*s_etat_processus).pointeur_variable_courante)
98: .variable_verrouillee = d_vrai;
99: }
100: else if ((*s_objet).type == LST)
101: {
102: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
103:
104: while(l_element_courant != NULL)
105: {
106: if ((*(*l_element_courant).donnee).type != NOM)
107: {
108: liberation(s_etat_processus, s_objet);
109:
110: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
111: return;
112: }
113:
114: if (recherche_variable(s_etat_processus, (*((struct_nom *)
115: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
116: {
117: liberation(s_etat_processus, s_objet);
118:
119: (*s_etat_processus).erreur_systeme = d_es;
120: (*s_etat_processus).erreur_execution =
121: d_ex_variable_non_definie;
122: return;
123: }
124:
125: (*(*s_etat_processus).pointeur_variable_courante)
126: .variable_verrouillee = d_vrai;
127:
128: l_element_courant = (*l_element_courant).suivant;
129: }
130: }
131: else
132: {
133: liberation(s_etat_processus, s_objet);
134:
135: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
136: return;
137: }
138:
139: liberation(s_etat_processus, s_objet);
140:
141: return;
142: }
143:
144:
145: /*
146: ================================================================================
147: Fonction 'parameter'
148: ================================================================================
149: Entrées :
150: --------------------------------------------------------------------------------
151: Sorties :
152: --------------------------------------------------------------------------------
153: Effets de bord : néant
154: ================================================================================
155: */
156:
157: void
158: instruction_parameter(struct_processus *s_etat_processus)
159: {
160: struct_liste_chainee *l_element_courant;
161:
162: struct_objet *s_objet;
163:
164: (*s_etat_processus).erreur_execution = d_ex;
165:
166: if ((*s_etat_processus).affichage_arguments == 'Y')
167: {
168: printf("\n PARAMETER ");
169:
170: if ((*s_etat_processus).langue == 'F')
171: {
172: printf("(verrouille une variable globale)\n\n");
173: }
174: else
175: {
176: printf("(lock a global variable)\n\n");
177: }
178:
179: printf(" 1: %s, %s\n", d_NOM, d_LST);
180:
181: return;
182: }
183: else if ((*s_etat_processus).test_instruction == 'Y')
184: {
185: (*s_etat_processus).nombre_arguments = -1;
186: return;
187: }
188:
189: if (test_cfsf(s_etat_processus, 31) == d_vrai)
190: {
191: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
192: {
193: return;
194: }
195: }
196:
197: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
198: &s_objet) == d_erreur)
199: {
200: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
201: return;
202: }
203:
204: if ((*s_objet).type == NOM)
205: {
206: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
207: (*s_objet).objet)).nom)) == d_faux)
208: {
209: liberation(s_etat_processus, s_objet);
210:
211: (*s_etat_processus).erreur_systeme = d_es;
212: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
213: return;
214: }
215:
216: (*(*s_etat_processus).pointeur_variable_courante)
217: .variable_verrouillee = d_vrai;
218: }
219: else if ((*s_objet).type == LST)
220: {
221: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
222:
223: while(l_element_courant != NULL)
224: {
225: if ((*(*l_element_courant).donnee).type != NOM)
226: {
227: liberation(s_etat_processus, s_objet);
228:
229: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
230: return;
231: }
232:
233: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
234: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
235: {
236: liberation(s_etat_processus, s_objet);
237:
238: (*s_etat_processus).erreur_systeme = d_es;
239: (*s_etat_processus).erreur_execution =
240: d_ex_variable_non_definie;
241: return;
242: }
243:
244: (*(*s_etat_processus).pointeur_variable_courante)
245: .variable_verrouillee = d_vrai;
246:
247: l_element_courant = (*l_element_courant).suivant;
248: }
249: }
250: else
251: {
252: liberation(s_etat_processus, s_objet);
253:
254: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
255: return;
256: }
257:
258: liberation(s_etat_processus, s_objet);
259:
260: return;
261: }
262:
263:
264: /*
265: ================================================================================
266: Fonction 'pshcntxt'
267: ================================================================================
268: Entrées :
269: --------------------------------------------------------------------------------
270: Sorties :
271: --------------------------------------------------------------------------------
272: Effets de bord : néant
273: ================================================================================
274: */
275:
276: void
277: instruction_pshcntxt(struct_processus *s_etat_processus)
278: {
279: struct_objet *s_objet;
280:
281: (*s_etat_processus).erreur_execution = d_ex;
282:
283: if ((*s_etat_processus).affichage_arguments == 'Y')
284: {
285: printf("\n PSHCNTXT ");
286:
287: if ((*s_etat_processus).langue == 'F')
288: {
289: printf("(sauvegarde de contexte)\n\n");
290: printf(" Aucun argument\n");
291: }
292: else
293: {
294: printf("(pushes context)\n\n");
295: printf(" No argument\n");
296: }
297:
298: return;
299: }
300: else if ((*s_etat_processus).test_instruction == 'Y')
301: {
302: (*s_etat_processus).nombre_arguments = -1;
303: return;
304: }
305:
306: if (test_cfsf(s_etat_processus, 31) == d_vrai)
307: {
308: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
309: {
310: return;
311: }
312: }
313:
314: if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
315: {
316: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
317: return;
318: }
319:
320: (*s_objet).objet = (*s_etat_processus).l_base_pile;
321:
322: if (empilement(s_etat_processus, &((*s_etat_processus).
323: l_base_pile_contextes), s_objet) == d_erreur)
324: {
325: return;
326: }
327:
328: if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
329: {
330: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
331: return;
332: }
333:
334: (*((integer8 *) (*s_objet).objet)) = (*s_etat_processus)
335: .hauteur_pile_operationnelle;
336:
337: if (empilement(s_etat_processus, &((*s_etat_processus)
338: .l_base_pile_taille_contextes), s_objet) == d_erreur)
339: {
340: return;
341: }
342:
343: /*
344: * Vidage de la pile opérationnelle
345: */
346:
347: (*s_etat_processus).l_base_pile = NULL;
348: (*s_etat_processus).hauteur_pile_operationnelle = 0;
349:
350: return;
351: }
352:
353:
354: /*
355: ================================================================================
356: Fonction 'pulcntxt'
357: ================================================================================
358: Entrées :
359: --------------------------------------------------------------------------------
360: Sorties :
361: --------------------------------------------------------------------------------
362: Effets de bord : néant
363: ================================================================================
364: */
365:
366: void
367: instruction_pulcntxt(struct_processus *s_etat_processus)
368: {
369: struct_objet *s_objet;
370:
371: (*s_etat_processus).erreur_execution = d_ex;
372:
373: if ((*s_etat_processus).affichage_arguments == 'Y')
374: {
375: printf("\n PULCNTXT ");
376:
377: if ((*s_etat_processus).langue == 'F')
378: {
379: printf("(restauration de contexte)\n\n");
380: printf(" Aucun argument\n");
381: }
382: else
383: {
384: printf("(pulls context)\n\n");
385: printf(" No argument\n");
386: }
387:
388: return;
389: }
390: else if ((*s_etat_processus).test_instruction == 'Y')
391: {
392: (*s_etat_processus).nombre_arguments = -1;
393: return;
394: }
395:
396: if (test_cfsf(s_etat_processus, 31) == d_vrai)
397: {
398: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
399: {
400: return;
401: }
402: }
403:
404: if (((*s_etat_processus).l_base_pile_contextes == NULL) ||
405: ((*s_etat_processus).l_base_pile_taille_contextes == NULL))
406: {
407: (*s_etat_processus).erreur_execution = d_ex_contexte;
408: return;
409: }
410:
411: instruction_clear(s_etat_processus);
412:
413: if (depilement(s_etat_processus, &((*s_etat_processus)
414: .l_base_pile_contextes), &s_objet) == d_erreur)
415: {
416: return;
417: }
418:
419: if ((*s_objet).type != LST)
420: {
421: (*s_etat_processus).erreur_systeme = d_es_contexte;
422: return;
423: }
424:
425: (*s_etat_processus).l_base_pile = (*s_objet).objet;
426:
427: BUG((*s_objet).nombre_occurrences != 1,
428: printf("(*s_objet).nombre_occurrences=%ld\n",
429: (*s_objet).nombre_occurrences));
430: free(s_objet);
431:
432: if (depilement(s_etat_processus, &((*s_etat_processus)
433: .l_base_pile_taille_contextes), &s_objet) == d_erreur)
434: {
435: return;
436: }
437:
438: if ((*s_objet).type != INT)
439: {
440: (*s_etat_processus).erreur_systeme = d_es_contexte;
441: return;
442: }
443:
444: if ((*((integer8 *) (*s_objet).objet)) < 0)
445: {
446: (*s_etat_processus).erreur_systeme = d_es_contexte;
447: return;
448: }
449:
450: (*s_etat_processus).hauteur_pile_operationnelle =
451: (*((integer8 *) (*s_objet).objet));
452: liberation(s_etat_processus, s_objet);
453:
454: return;
455: }
456:
457:
458: /*
459: ================================================================================
460: Fonction 'peek'
461: ================================================================================
462: Entrées :
463: --------------------------------------------------------------------------------
464: Sorties :
465: --------------------------------------------------------------------------------
466: Effets de bord : néant
467: ================================================================================
468: */
469:
470: void
471: instruction_peek(struct_processus *s_etat_processus)
472: {
473: sig_atomic_t registre;
474:
475: struct_objet *s_objet;
476: struct_objet *s_objet_drapeau;
477:
478: (*s_etat_processus).erreur_execution = d_ex;
479:
480: if ((*s_etat_processus).affichage_arguments == 'Y')
481: {
482: printf("\n PEEK ");
483:
484: if ((*s_etat_processus).langue == 'F')
485: {
486: printf("(réception de données d'un processus père)\n\n");
487: }
488: else
489: {
490: printf("(data reception from parent process)\n\n");
491: }
492:
493: printf("-> 1: %s (0)\n\n", d_INT);
494:
495: printf("-> 2: %s, %s, %s, %s, %s, %s,\n"
496: " %s, %s, %s, %s, %s,\n"
497: " %s, %s, %s, %s\n",
498: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
499: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN);
500: printf(" 1: %s (-1)\n", d_INT);
501:
502: return;
503: }
504: else if ((*s_etat_processus).test_instruction == 'Y')
505: {
506: (*s_etat_processus).nombre_arguments = -1;
507: return;
508: }
509:
510: if (test_cfsf(s_etat_processus, 31) == d_vrai)
511: {
512: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
513: {
514: return;
515: }
516: }
517:
518: if ((*s_etat_processus).presence_pipes == d_faux)
519: {
520: (*s_etat_processus).erreur_execution =
521: d_ex_absence_processus_pere;
522: return;
523: }
524:
525: if ((s_objet_drapeau = allocation(s_etat_processus, INT)) == NULL)
526: {
527: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
528: return;
529: }
530:
531: if ((*s_etat_processus).nombre_objets_injectes > 0)
532: {
533: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
534: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
535:
536: if ((*s_etat_processus).profilage == d_vrai)
537: {
538: profilage(s_etat_processus, "Interprocess or interthread "
539: "communications (PEEK)");
540:
541: if ((*s_etat_processus).erreur_systeme != d_es)
542: {
543: return;
544: }
545: }
546:
547: if ((s_objet = lecture_pipe(s_etat_processus,
548: (*s_etat_processus).pipe_injections)) == NULL)
549: {
550: if (registre == 0)
551: {
552: if ((*s_etat_processus).var_volatile_traitement_retarde_stop
553: == -1)
554: {
555: (*s_etat_processus).var_volatile_requete_arret = -1;
556: }
557:
558: (*s_etat_processus).var_volatile_traitement_retarde_stop
559: = registre;
560: }
561:
562: if ((*s_etat_processus).profilage == d_vrai)
563: {
564: profilage(s_etat_processus, NULL);
565: }
566:
567: return;
568: }
569:
570: if ((*s_etat_processus).profilage == d_vrai)
571: {
572: profilage(s_etat_processus, NULL);
573: }
574:
575: if (registre == 0)
576: {
577: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
578: {
579: (*s_etat_processus).var_volatile_requete_arret = -1;
580: }
581:
582: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
583: }
584:
585: (*s_etat_processus).nombre_objets_injectes--;
586:
587: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
588: s_objet) == d_erreur)
589: {
590: return;
591: }
592:
593: (*((integer8 *) (*s_objet_drapeau).objet)) = -1;
594: }
595: else
596: {
597: (*((integer8 *) (*s_objet_drapeau).objet)) = 0;
598: }
599:
600: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
601: s_objet_drapeau) == d_erreur)
602: {
603: return;
604: }
605:
606: return;
607: }
608:
609:
610: /*
611: ================================================================================
612: Fonction 'poke'
613: ================================================================================
614: Entrées :
615: --------------------------------------------------------------------------------
616: Sorties :
617: --------------------------------------------------------------------------------
618: Effets de bord : néant
619: ================================================================================
620: */
621:
622: void
623: instruction_poke(struct_processus *s_etat_processus)
624: {
625: sig_atomic_t registre_stop;
626:
627: ssize_t longueur_ecriture;
628:
629: struct sigaction action;
630: struct sigaction registre;
631:
632: struct_liste_chainee *l_element_courant;
633:
634: struct_objet *s_objet_argument_1;
635: struct_objet *s_objet_argument_2;
636:
637: (*s_etat_processus).erreur_execution = d_ex;
638:
639: if ((*s_etat_processus).affichage_arguments == 'Y')
640: {
641: printf("\n POKE ");
642:
643: if ((*s_etat_processus).langue == 'F')
644: {
645: printf("(envoi d'une donnée à un processus fils)\n\n");
646: }
647: else
648: {
649: printf("(send data to child process)\n\n");
650: }
651:
652: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
653: " %s, %s, %s, %s, %s,\n"
654: " %s, %s, %s, %s, %s\n",
655: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
656: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_TAB);
657: printf(" 1: %s\n", d_PRC);
658:
659: return;
660: }
661: else if ((*s_etat_processus).test_instruction == 'Y')
662: {
663: (*s_etat_processus).nombre_arguments = -1;
664: return;
665: }
666:
667: if (test_cfsf(s_etat_processus, 31) == d_vrai)
668: {
669: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
670: {
671: return;
672: }
673: }
674:
675: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
676: &s_objet_argument_1) == d_erreur)
677: {
678: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
679: return;
680: }
681:
682: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
683: &s_objet_argument_2) == d_erreur)
684: {
685: liberation(s_etat_processus, s_objet_argument_1);
686:
687: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
688: return;
689: }
690:
691: if ((*s_objet_argument_1).type == PRC)
692: {
693: /*
694: * Vérification du type de la donnée transmise
695: */
696:
697: if (((*s_objet_argument_2).type != INT) &&
698: ((*s_objet_argument_2).type != REL) &&
699: ((*s_objet_argument_2).type != CPL) &&
700: ((*s_objet_argument_2).type != VIN) &&
701: ((*s_objet_argument_2).type != VRL) &&
702: ((*s_objet_argument_2).type != VCX) &&
703: ((*s_objet_argument_2).type != MIN) &&
704: ((*s_objet_argument_2).type != MRL) &&
705: ((*s_objet_argument_2).type != MCX) &&
706: ((*s_objet_argument_2).type != BIN) &&
707: ((*s_objet_argument_2).type != NOM) &&
708: ((*s_objet_argument_2).type != CHN) &&
709: ((*s_objet_argument_2).type != LST) &&
710: ((*s_objet_argument_2).type != ALG) &&
711: ((*s_objet_argument_2).type != RPN) &&
712: ((*s_objet_argument_2).type != TBL))
713: {
714: liberation(s_etat_processus, s_objet_argument_1);
715: liberation(s_etat_processus, s_objet_argument_2);
716:
717: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
718: return;
719: }
720:
721: if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
722: != 0)
723: {
724: (*s_etat_processus).erreur_systeme = d_es_processus;
725: return;
726: }
727:
728: l_element_courant = (struct_liste_chainee *)
729: (*s_etat_processus).l_base_pile_processus;
730:
731: while(l_element_courant != NULL)
732: {
733: if ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet))
734: .thread).processus_detache == d_vrai)
735: {
736: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
737: .donnee).objet)).thread).processus_detache == d_faux)
738: {
739: l_element_courant = (*l_element_courant).suivant;
740: continue;
741: }
742:
743: if ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet))
744: .thread).pid == (*(*((struct_processus_fils *)
745: (*(*l_element_courant).donnee).objet)).thread).pid)
746: {
747: // Envoi des données
748: // Attention : si le processus n'existe plus, il n'y a plus
749: // de lecteur et on peut se prendre un SIGPIPE dans la
750: // figure !
751:
752: action.sa_handler = SIG_IGN;
753: action.sa_flags = 0;
754:
755: if (sigaction(SIGPIPE, &action, ®istre) != 0)
756: {
757: pthread_mutex_unlock(&((*s_etat_processus)
758: .mutex_pile_processus));
759:
760: (*s_etat_processus).erreur_systeme = d_es_signal;
761: return;
762: }
763:
764: // Validation des données. On envoie un signal pour
765: // débloquer les instructions de type WF* pour les
766: // lectures bloquantes.
767:
768: if (envoi_signal_processus((*(*((struct_processus_fils *)
769: (*(*l_element_courant).donnee).objet))
770: .thread).pid, rpl_siginject, d_faux) != 0)
771: {
772: // Le processus fils peut s'être terminé.
773: break;
774: }
775:
776: registre_stop = (*s_etat_processus)
777: .var_volatile_traitement_retarde_stop;
778: (*s_etat_processus).var_volatile_traitement_retarde_stop
779: = 1;
780:
781: if ((*s_etat_processus).profilage == d_vrai)
782: {
783: profilage(s_etat_processus,
784: "Interprocess communications (POKE)");
785:
786: if ((*s_etat_processus).erreur_systeme != d_es)
787: {
788: pthread_mutex_unlock(&((*s_etat_processus)
789: .mutex_pile_processus));
790: return;
791: }
792: }
793:
794: # ifndef SEMAPHORES_NOMMES
795: if (sem_post(&((*s_etat_processus).semaphore_fork))
796: != 0)
797: # else
798: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
799: # endif
800: {
801: (*s_etat_processus).erreur_systeme = d_es_processus;
802: return;
803: }
804:
805: while((longueur_ecriture = write_atomic(s_etat_processus,
806: (*(*((struct_processus_fils *)
807: (*(*l_element_courant).donnee).objet)).thread)
808: .pipe_nombre_injections[1], "-",
809: sizeof(unsigned char))) != sizeof(unsigned char))
810: {
811: # ifndef SEMAPHORES_NOMMES
812: while(sem_wait(
813: &((*s_etat_processus).semaphore_fork)) != 0)
814: # else
815: while(sem_wait(
816: (*s_etat_processus).semaphore_fork) != 0)
817: # endif
818: {
819: if (errno != EINTR)
820: {
821: (*s_etat_processus).erreur_systeme =
822: d_es_processus;
823: return;
824: }
825: }
826:
827: if (longueur_ecriture == -1)
828: {
829: pthread_mutex_unlock(&((*s_etat_processus)
830: .mutex_pile_processus));
831:
832: liberation(s_etat_processus, s_objet_argument_1);
833: liberation(s_etat_processus, s_objet_argument_2);
834:
835: if (registre_stop == 0)
836: {
837: if ((*s_etat_processus)
838: .var_volatile_traitement_retarde_stop
839: == -1)
840: {
841: (*s_etat_processus)
842: .var_volatile_requete_arret = -1;
843: }
844:
845: (*s_etat_processus)
846: .var_volatile_traitement_retarde_stop
847: = registre_stop;
848: }
849:
850: if ((*s_etat_processus).profilage == d_vrai)
851: {
852: profilage(s_etat_processus, NULL);
853: }
854:
855: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
856: {
857: (*s_etat_processus).erreur_systeme =
858: d_es_signal;
859: return;
860: }
861:
862: return;
863: }
864:
865: # ifndef SEMAPHORES_NOMMES
866: if (sem_post(
867: &((*s_etat_processus).semaphore_fork)) != 0)
868: # else
869: if (sem_post(
870: (*s_etat_processus).semaphore_fork) != 0)
871: # endif
872: {
873: (*s_etat_processus).erreur_systeme = d_es_processus;
874: return;
875: }
876: }
877:
878: if (ecriture_pipe(s_etat_processus,
879: (*(*((struct_processus_fils *)
880: (*(*l_element_courant).donnee).objet)).thread)
881: .pipe_injections[1], s_objet_argument_2)
882: == d_erreur)
883: {
884: // Le processus fils peut s'être terminé.
885:
886: if ((*s_etat_processus).erreur_systeme != d_es)
887: {
888: (*s_etat_processus).erreur_systeme = d_es;
889: }
890: }
891:
892: # ifndef SEMAPHORES_NOMMES
893: while(sem_wait(&((*s_etat_processus).semaphore_fork))
894: != 0)
895: # else
896: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
897: # endif
898: {
899: if (errno != EINTR)
900: {
901: (*s_etat_processus).erreur_systeme = d_es_processus;
902: return;
903: }
904: }
905:
906: if (registre_stop == 0)
907: {
908: if ((*s_etat_processus)
909: .var_volatile_traitement_retarde_stop
910: == -1)
911: {
912: (*s_etat_processus).var_volatile_requete_arret = -1;
913: }
914:
915: (*s_etat_processus).var_volatile_traitement_retarde_stop
916: = registre_stop;
917: }
918:
919: if ((*s_etat_processus).profilage == d_vrai)
920: {
921: profilage(s_etat_processus, NULL);
922: }
923:
924: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
925: {
926: pthread_mutex_unlock(&((*s_etat_processus)
927: .mutex_pile_processus));
928:
929: (*s_etat_processus).erreur_systeme = d_es_signal;
930: return;
931: }
932:
933: break;
934: }
935: }
936: else
937: {
938: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
939: .donnee).objet)).thread).processus_detache == d_vrai)
940: {
941: l_element_courant = (*l_element_courant).suivant;
942: continue;
943: }
944:
945: if (((pthread_equal((*(*((struct_processus_fils *)
946: (*s_objet_argument_1).objet)).thread).tid,
947: (*(*((struct_processus_fils *)
948: (*(*l_element_courant).donnee).objet)).thread).tid)
949: != 0)) && ((*(*((struct_processus_fils *)
950: (*s_objet_argument_1).objet)).thread).pid ==
951: (*(*((struct_processus_fils *)
952: (*(*l_element_courant).donnee).objet)).thread).pid))
953: {
954: // Envoi des données
955: // Attention : si le processus n'existe plus, il n'y a plus
956: // de lecteur et on peut se prendre un SIGPIPE dans la
957: // figure !
958:
959: action.sa_handler = SIG_IGN;
960: action.sa_flags = 0;
961:
962: if (sigaction(SIGPIPE, &action, ®istre) != 0)
963: {
964: pthread_mutex_unlock(&((*s_etat_processus)
965: .mutex_pile_processus));
966:
967: (*s_etat_processus).erreur_systeme = d_es_signal;
968: return;
969: }
970:
971: // Validation des données. On envoie un signal pour
972: // débloquer les instructions de type WF* pour les
973: // lectures bloquantes.
974:
975: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
976: (*(*l_element_courant).donnee).objet)).thread)
977: .mutex)) != 0)
978: {
979: (*s_etat_processus).erreur_systeme = d_es_processus;
980: return;
981: }
982:
983: if ((*(*((struct_processus_fils *)
984: (*(*l_element_courant).donnee).objet)).thread)
985: .thread_actif == d_vrai)
986: {
987: if (envoi_signal_thread(s_etat_processus,
988: (*(*((struct_processus_fils *)
989: (*(*l_element_courant).donnee).objet)).thread)
990: .tid, rpl_siginject) != 0)
991: {
992: // Le processus fils peut s'être terminé.
993:
994: if (pthread_mutex_unlock(
995: &((*(*((struct_processus_fils *)
996: (*(*l_element_courant).donnee).objet))
997: .thread).mutex)) != 0)
998: {
999: (*s_etat_processus).erreur_systeme =
1000: d_es_processus;
1001: return;
1002: }
1003:
1004: break;
1005: }
1006: }
1007: else
1008: {
1009: if (pthread_mutex_unlock(
1010: &((*(*((struct_processus_fils *)
1011: (*(*l_element_courant).donnee).objet))
1012: .thread).mutex)) != 0)
1013: {
1014: (*s_etat_processus).erreur_systeme = d_es_processus;
1015: return;
1016: }
1017:
1018: break;
1019: }
1020:
1021: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1022: (*(*l_element_courant).donnee).objet)).thread)
1023: .mutex)) != 0)
1024: {
1025: (*s_etat_processus).erreur_systeme = d_es_processus;
1026: return;
1027: }
1028:
1029: registre_stop = (*s_etat_processus)
1030: .var_volatile_traitement_retarde_stop;
1031: (*s_etat_processus).var_volatile_traitement_retarde_stop
1032: = 1;
1033:
1034: if ((*s_etat_processus).profilage == d_vrai)
1035: {
1036: profilage(s_etat_processus,
1037: "Interthread communications (POKE)");
1038:
1039: if ((*s_etat_processus).erreur_systeme != d_es)
1040: {
1041: pthread_mutex_unlock(&((*s_etat_processus)
1042: .mutex_pile_processus));
1043: return;
1044: }
1045: }
1046:
1047: # ifndef SEMAPHORES_NOMMES
1048: if (sem_post(
1049: &((*s_etat_processus).semaphore_fork)) != 0)
1050: # else
1051: if (sem_post(
1052: (*s_etat_processus).semaphore_fork) != 0)
1053: # endif
1054: {
1055: (*s_etat_processus).erreur_systeme = d_es_processus;
1056: return;
1057: }
1058:
1059: while((longueur_ecriture = write_atomic(s_etat_processus,
1060: (*(*((struct_processus_fils *)
1061: (*(*l_element_courant).donnee).objet)).thread)
1062: .pipe_nombre_injections[1], "-",
1063: sizeof(unsigned char))) != sizeof(unsigned char))
1064: {
1065: # ifndef SEMAPHORES_NOMMES
1066: while(sem_wait(
1067: &((*s_etat_processus).semaphore_fork)) != 0)
1068: # else
1069: while(sem_wait(
1070: (*s_etat_processus).semaphore_fork) != 0)
1071: # endif
1072: {
1073: if (errno != EINTR)
1074: {
1075: (*s_etat_processus).erreur_systeme =
1076: d_es_processus;
1077: return;
1078: }
1079: }
1080:
1081: if (longueur_ecriture == -1)
1082: {
1083: pthread_mutex_unlock(&((*s_etat_processus)
1084: .mutex_pile_processus));
1085:
1086: liberation(s_etat_processus, s_objet_argument_1);
1087: liberation(s_etat_processus, s_objet_argument_2);
1088:
1089: if (registre_stop == 0)
1090: {
1091: if ((*s_etat_processus)
1092: .var_volatile_traitement_retarde_stop
1093: == -1)
1094: {
1095: (*s_etat_processus)
1096: .var_volatile_requete_arret = -1;
1097: }
1098:
1099: (*s_etat_processus)
1100: .var_volatile_traitement_retarde_stop
1101: = registre_stop;
1102: }
1103:
1104: if ((*s_etat_processus).profilage == d_vrai)
1105: {
1106: profilage(s_etat_processus, NULL);
1107: }
1108:
1109: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1110: {
1111: (*s_etat_processus).erreur_systeme =
1112: d_es_signal;
1113: return;
1114: }
1115:
1116: return;
1117: }
1118:
1119: # ifndef SEMAPHORES_NOMMES
1120: if (sem_post(
1121: &((*s_etat_processus).semaphore_fork)) != 0)
1122: # else
1123: if (sem_post(
1124: (*s_etat_processus).semaphore_fork) != 0)
1125: # endif
1126: {
1127: (*s_etat_processus).erreur_systeme = d_es_processus;
1128: return;
1129: }
1130: }
1131:
1132: if (ecriture_pipe(s_etat_processus,
1133: (*(*((struct_processus_fils *)
1134: (*(*l_element_courant).donnee).objet)).thread)
1135: .pipe_injections[1], s_objet_argument_2)
1136: == d_erreur)
1137: {
1138: // Le processus fils peut s'être terminé.
1139:
1140: if ((*s_etat_processus).erreur_systeme != d_es)
1141: {
1142: (*s_etat_processus).erreur_systeme = d_es;
1143: }
1144: }
1145:
1146: # ifndef SEMAPHORES_NOMMES
1147: while(sem_wait(
1148: &((*s_etat_processus).semaphore_fork)) != 0)
1149: # else
1150: while(sem_wait(
1151: (*s_etat_processus).semaphore_fork) != 0)
1152: # endif
1153: {
1154: if (errno != EINTR)
1155: {
1156: (*s_etat_processus).erreur_systeme = d_es_processus;
1157: return;
1158: }
1159: }
1160:
1161: if (registre_stop == 0)
1162: {
1163: if ((*s_etat_processus)
1164: .var_volatile_traitement_retarde_stop
1165: == -1)
1166: {
1167: (*s_etat_processus).var_volatile_requete_arret = -1;
1168: }
1169:
1170: (*s_etat_processus).var_volatile_traitement_retarde_stop
1171: = registre_stop;
1172: }
1173:
1174: if ((*s_etat_processus).profilage == d_vrai)
1175: {
1176: profilage(s_etat_processus, NULL);
1177: }
1178:
1179: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1180: {
1181: pthread_mutex_unlock(&((*s_etat_processus)
1182: .mutex_pile_processus));
1183:
1184: (*s_etat_processus).erreur_systeme = d_es_signal;
1185: return;
1186: }
1187:
1188: break;
1189: }
1190: }
1191:
1192: l_element_courant = (*l_element_courant).suivant;
1193: }
1194:
1195: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
1196: != 0)
1197: {
1198: (*s_etat_processus).erreur_systeme = d_es_processus;
1199: return;
1200: }
1201:
1202: if (l_element_courant == NULL)
1203: {
1204: liberation(s_etat_processus, s_objet_argument_1);
1205: liberation(s_etat_processus, s_objet_argument_2);
1206:
1207: (*s_etat_processus).erreur_execution = d_ex_processus;
1208: return;
1209: }
1210: }
1211: else
1212: {
1213: liberation(s_etat_processus, s_objet_argument_1);
1214: liberation(s_etat_processus, s_objet_argument_2);
1215:
1216: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1217: return;
1218: }
1219:
1220: liberation(s_etat_processus, s_objet_argument_1);
1221: liberation(s_etat_processus, s_objet_argument_2);
1222:
1223: return;
1224: }
1225:
1226:
1227: /*
1228: ================================================================================
1229: Fonction 'private'
1230: ================================================================================
1231: Entrées :
1232: --------------------------------------------------------------------------------
1233: Sorties :
1234: --------------------------------------------------------------------------------
1235: Effets de bord : néant
1236: ================================================================================
1237: */
1238:
1239: void
1240: instruction_private(struct_processus *s_etat_processus)
1241: {
1242: struct_liste_chainee *l_element_courant;
1243:
1244: struct_objet *s_objet;
1245:
1246: (*s_etat_processus).erreur_execution = d_ex;
1247:
1248: if ((*s_etat_processus).affichage_arguments == 'Y')
1249: {
1250: printf("\n PRIVATE ");
1251:
1252: if ((*s_etat_processus).langue == 'F')
1253: {
1254: printf("(rend privée une variable partagée)\n\n");
1255: }
1256: else
1257: {
1258: printf("(switch a shared variable to private one)\n\n");
1259: }
1260:
1261: printf(" 1: %s, %s\n", d_NOM, d_LST);
1262:
1263: return;
1264: }
1265: else if ((*s_etat_processus).test_instruction == 'Y')
1266: {
1267: (*s_etat_processus).nombre_arguments = -1;
1268: return;
1269: }
1270:
1271: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1272: {
1273: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1274: {
1275: return;
1276: }
1277: }
1278:
1279: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1280: &s_objet) == d_erreur)
1281: {
1282: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1283: return;
1284: }
1285:
1286: if ((*s_objet).type == NOM)
1287: {
1288: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
1289: (*s_objet).objet)).nom)) == d_faux)
1290: {
1291: liberation(s_etat_processus, s_objet);
1292:
1293: (*s_etat_processus).erreur_systeme = d_es;
1294: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1295: return;
1296: }
1297:
1298: if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
1299: (*s_objet).objet)).nom), (*(*s_etat_processus)
1300: .pointeur_variable_courante).variable_partagee,
1301: (*(*s_etat_processus).pointeur_variable_courante).origine)
1302: == NULL)
1303: {
1304: liberation(s_etat_processus, s_objet);
1305:
1306: (*s_etat_processus).erreur_systeme = d_es;
1307: return;
1308: }
1309:
1310: (*(*s_etat_processus).pointeur_variable_courante).objet =
1311: (*(*s_etat_processus).pointeur_variable_partagee_courante)
1312: .objet;
1313: (*(*s_etat_processus).pointeur_variable_partagee_courante).objet = NULL;
1314:
1315: if (retrait_variable_partagee(s_etat_processus,
1316: (*((struct_nom *) (*s_objet).objet)).nom,
1317: (*(*s_etat_processus).pointeur_variable_courante)
1318: .variable_partagee) == d_erreur)
1319: {
1320: liberation(s_etat_processus, s_objet);
1321: return;
1322: }
1323:
1324: if ((*(*s_etat_processus).pointeur_variable_courante).origine == 'P')
1325: {
1326: (*(*s_etat_processus).pointeur_variable_courante)
1327: .variable_partagee.adresse = 0;
1328: }
1329: else
1330: {
1331: (*(*s_etat_processus).pointeur_variable_courante)
1332: .variable_partagee.pointeur = NULL;
1333: }
1334: }
1335: else if ((*s_objet).type == LST)
1336: {
1337: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1338:
1339: while(l_element_courant != NULL)
1340: {
1341: if ((*(*l_element_courant).donnee).type != NOM)
1342: {
1343: liberation(s_etat_processus, s_objet);
1344:
1345: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1346: return;
1347: }
1348:
1349: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
1350: (*s_objet).objet)).nom)) == d_faux)
1351: {
1352: liberation(s_etat_processus, s_objet);
1353:
1354: (*s_etat_processus).erreur_systeme = d_es;
1355: (*s_etat_processus).erreur_execution =
1356: d_ex_variable_non_definie;
1357: return;
1358: }
1359:
1360: if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
1361: (*s_objet).objet)).nom), (*(*s_etat_processus)
1362: .pointeur_variable_courante).variable_partagee,
1363: (*(*s_etat_processus).pointeur_variable_courante).origine)
1364: == NULL)
1365: {
1366: liberation(s_etat_processus, s_objet);
1367:
1368: (*s_etat_processus).erreur_systeme = d_es;
1369: (*s_etat_processus).erreur_execution =
1370: d_ex_variable_non_definie;
1371: return;
1372: }
1373:
1374: (*(*s_etat_processus).pointeur_variable_courante).objet =
1375: (*(*s_etat_processus).pointeur_variable_partagee_courante)
1376: .objet;
1377: (*(*s_etat_processus).pointeur_variable_partagee_courante).objet
1378: = NULL;
1379:
1380: if ((*(*s_etat_processus).pointeur_variable_courante).origine
1381: == 'P')
1382: {
1383: (*(*s_etat_processus).pointeur_variable_courante)
1384: .variable_partagee.adresse = 0;
1385: }
1386: else
1387: {
1388: (*(*s_etat_processus).pointeur_variable_courante)
1389: .variable_partagee.pointeur = NULL;
1390: }
1391:
1392: if (retrait_variable_partagee(s_etat_processus,
1393: (*((struct_nom *) (*s_objet).objet)).nom,
1394: (*(*s_etat_processus).pointeur_variable_courante)
1395: .variable_statique) == d_erreur)
1396: {
1397: liberation(s_etat_processus, s_objet);
1398: return;
1399: }
1400:
1401: l_element_courant = (*l_element_courant).suivant;
1402: }
1403: }
1404: else
1405: {
1406: liberation(s_etat_processus, s_objet);
1407:
1408: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1409: return;
1410: }
1411:
1412: liberation(s_etat_processus, s_objet);
1413:
1414: return;
1415: }
1416:
1417:
1418: /*
1419: ================================================================================
1420: Fonction 'pshprfl'
1421: ================================================================================
1422: Entrées : pointeur sur une structure struct_processus
1423: --------------------------------------------------------------------------------
1424: Sorties :
1425: --------------------------------------------------------------------------------
1426: Effets de bord : néant
1427: ================================================================================
1428: */
1429:
1430: void
1431: instruction_pshprfl(struct_processus *s_etat_processus)
1432: {
1433: struct_objet *s_objet_argument;
1434:
1435: (*s_etat_processus).erreur_execution = d_ex;
1436:
1437: if ((*s_etat_processus).affichage_arguments == 'Y')
1438: {
1439: printf("\n PSHPRFL ");
1440:
1441: if ((*s_etat_processus).langue == 'F')
1442: {
1443: printf("(empilement d'un point de profilage)\n\n");
1444: }
1445: else
1446: {
1447: printf("(push profile data)\n\n");
1448: }
1449:
1450: printf(" 1: %s\n", d_CHN);
1451:
1452: return;
1453: }
1454: else if ((*s_etat_processus).test_instruction == 'Y')
1455: {
1456: (*s_etat_processus).nombre_arguments = -1;
1457: return;
1458: }
1459:
1460: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1461: {
1462: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1463: {
1464: return;
1465: }
1466: }
1467:
1468: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1469: &s_objet_argument) == d_erreur)
1470: {
1471: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1472: return;
1473: }
1474:
1475: if ((*s_objet_argument).type == CHN)
1476: {
1477: if ((*s_etat_processus).profilage == d_vrai)
1478: {
1479: profilage(s_etat_processus, (unsigned char *)
1480: (*s_objet_argument).objet);
1481: }
1482: }
1483: else
1484: {
1485: liberation(s_etat_processus, s_objet_argument);
1486:
1487: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1488: return;
1489: }
1490:
1491: liberation(s_etat_processus, s_objet_argument);
1492:
1493: return;
1494: }
1495:
1496:
1497: /*
1498: ================================================================================
1499: Fonction 'pulprfl'
1500: ================================================================================
1501: Entrées : pointeur sur une structure struct_processus
1502: --------------------------------------------------------------------------------
1503: Sorties :
1504: --------------------------------------------------------------------------------
1505: Effets de bord : néant
1506: ================================================================================
1507: */
1508:
1509: void
1510: instruction_pulprfl(struct_processus *s_etat_processus)
1511: {
1512: (*s_etat_processus).erreur_execution = d_ex;
1513:
1514: if ((*s_etat_processus).affichage_arguments == 'Y')
1515: {
1516: printf("\n PULPRFL ");
1517:
1518: if ((*s_etat_processus).langue == 'F')
1519: {
1520: printf("(dépilement d'un point de profilage)\n\n");
1521: printf(" Aucun argument\n");
1522: }
1523: else
1524: {
1525: printf("(pull profile data)\n\n");
1526: printf(" No argument\n");
1527: }
1528:
1529: return;
1530: }
1531: else if ((*s_etat_processus).test_instruction == 'Y')
1532: {
1533: (*s_etat_processus).nombre_arguments = -1;
1534: return;
1535: }
1536:
1537: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1538: {
1539: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1540: {
1541: return;
1542: }
1543: }
1544:
1545: if ((*s_etat_processus).profilage == d_vrai)
1546: {
1547: profilage(s_etat_processus, NULL);
1548: }
1549:
1550: return;
1551: }
1552:
1553:
1554: /*
1555: ================================================================================
1556: Fonction 'plot'
1557: ================================================================================
1558: Entrées : pointeur sur une structure struct_processus
1559: --------------------------------------------------------------------------------
1560: Sorties :
1561: --------------------------------------------------------------------------------
1562: Effets de bord : néant
1563: ================================================================================
1564: */
1565:
1566: void
1567: instruction_plot(struct_processus *s_etat_processus)
1568: {
1569: (*s_etat_processus).erreur_execution = d_ex;
1570:
1571: if ((*s_etat_processus).affichage_arguments == 'Y')
1572: {
1573: printf("\n PLOT ");
1574:
1575: if ((*s_etat_processus).langue == 'F')
1576: {
1577: printf("(affiche les données graphiques mémorisées)\n\n");
1578: printf(" Aucun argument\n");
1579: }
1580: else
1581: {
1582: printf("(plot buffered graphic)\n\n");
1583: printf(" No argument\n");
1584: }
1585:
1586: return;
1587: }
1588: else if ((*s_etat_processus).test_instruction == 'Y')
1589: {
1590: (*s_etat_processus).nombre_arguments = -1;
1591: return;
1592: }
1593:
1594: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1595: {
1596: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1597: {
1598: return;
1599: }
1600: }
1601:
1602: if ((*s_etat_processus).fichiers_graphiques != NULL)
1603: {
1604: appel_gnuplot(s_etat_processus, 'N');
1605: }
1606:
1607: (*s_etat_processus).mise_a_jour_trace_requise = d_faux;
1608:
1609: return;
1610: }
1611:
1612:
1613: /*
1614: ================================================================================
1615: Fonction 'procid'
1616: ================================================================================
1617: Entrées : pointeur sur une structure struct_processus
1618: --------------------------------------------------------------------------------
1619: Sorties :
1620: --------------------------------------------------------------------------------
1621: Effets de bord : néant
1622: ================================================================================
1623: */
1624:
1625: void
1626: instruction_procid(struct_processus *s_etat_processus)
1627: {
1628: pthread_mutexattr_t attributs_mutex;
1629:
1630: struct_objet *s_objet;
1631:
1632: (*s_etat_processus).erreur_execution = d_ex;
1633:
1634: if ((*s_etat_processus).affichage_arguments == 'Y')
1635: {
1636: printf("\n PROCID ");
1637:
1638: if ((*s_etat_processus).langue == 'F')
1639: {
1640: printf("(identifiant du processus)\n\n");
1641: }
1642: else
1643: {
1644: printf("(process identifier)\n\n");
1645: }
1646:
1647: printf("-> 1: %s\n", d_PRC);
1648:
1649: return;
1650: }
1651: else if ((*s_etat_processus).test_instruction == 'Y')
1652: {
1653: (*s_etat_processus).nombre_arguments = -1;
1654: return;
1655: }
1656:
1657: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1658: {
1659: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1660: {
1661: return;
1662: }
1663: }
1664:
1665: if ((s_objet = allocation(s_etat_processus, PRC)) == NULL)
1666: {
1667: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1668: return;
1669: }
1670:
1671: if (((*((struct_processus_fils *) (*s_objet).objet)).thread =
1672: malloc(sizeof(struct_descripteur_thread))) == NULL)
1673: {
1674: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1675: return;
1676: }
1677:
1678: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1679: .nombre_references = 1;
1680: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1681: .pid = getpid();
1682: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1683: .tid = pthread_self();
1684: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1685: .processus_detache = (*s_etat_processus).processus_detache;
1686: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1687: .argument = NULL;
1688:
1689: pthread_mutexattr_init(&attributs_mutex);
1690: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
1691: pthread_mutex_init(&((*(*((struct_processus_fils *)
1692: (*s_objet).objet)).thread).mutex), &attributs_mutex);
1693: pthread_mutexattr_destroy(&attributs_mutex);
1694:
1695: pthread_mutexattr_init(&attributs_mutex);
1696: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
1697: pthread_mutex_init(&((*(*((struct_processus_fils *)
1698: (*s_objet).objet)).thread).mutex_nombre_references),
1699: &attributs_mutex);
1700: pthread_mutexattr_destroy(&attributs_mutex);
1701:
1702: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1703: s_objet) == d_erreur)
1704: {
1705: return;
1706: }
1707:
1708: return;
1709: }
1710:
1711: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_p7.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src