1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.3
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 '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)) != 0)
722: {
723: (*s_etat_processus).erreur_systeme = d_es_processus;
724: return;
725: }
726:
727: l_element_courant = (struct_liste_chainee *)
728: (*s_etat_processus).l_base_pile_processus;
729:
730: while(l_element_courant != NULL)
731: {
732: if ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet))
733: .thread).processus_detache == d_vrai)
734: {
735: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
736: .donnee).objet)).thread).processus_detache == d_faux)
737: {
738: l_element_courant = (*l_element_courant).suivant;
739: continue;
740: }
741:
742: if ((*(*((struct_processus_fils *) (*s_objet_argument_1).objet))
743: .thread).pid == (*(*((struct_processus_fils *)
744: (*(*l_element_courant).donnee).objet)).thread).pid)
745: {
746: // Envoi des données
747: // Attention : si le processus n'existe plus, il n'y a plus
748: // de lecteur et on peut se prendre un SIGPIPE dans la
749: // figure !
750:
751: action.sa_handler = SIG_IGN;
752: action.sa_flags = SA_ONSTACK;
753:
754: if (sigaction(SIGPIPE, &action, ®istre) != 0)
755: {
756: pthread_mutex_unlock(&((*s_etat_processus).mutex));
757:
758: (*s_etat_processus).erreur_systeme = d_es_signal;
759: return;
760: }
761:
762: // Validation des données. On envoie un signal pour
763: // débloquer les instructions de type WF* pour les
764: // lectures bloquantes.
765:
766: if (envoi_signal_processus((*(*((struct_processus_fils *)
767: (*(*l_element_courant).donnee).objet))
768: .thread).pid, rpl_siginject) != 0)
769: {
770: // Le processus fils peut s'être terminé.
771: break;
772: }
773:
774: registre_stop = (*s_etat_processus)
775: .var_volatile_traitement_retarde_stop;
776: (*s_etat_processus).var_volatile_traitement_retarde_stop
777: = 1;
778:
779: if ((*s_etat_processus).profilage == d_vrai)
780: {
781: profilage(s_etat_processus,
782: "Interprocess communications (POKE)");
783:
784: if ((*s_etat_processus).erreur_systeme != d_es)
785: {
786: pthread_mutex_unlock(&((*s_etat_processus).mutex));
787: return;
788: }
789: }
790:
791: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
792: {
793: (*s_etat_processus).erreur_systeme = d_es_processus;
794: return;
795: }
796:
797: while((longueur_ecriture = write_atomic(s_etat_processus,
798: (*(*((struct_processus_fils *)
799: (*(*l_element_courant).donnee).objet)).thread)
800: .pipe_nombre_injections[1], "-",
801: sizeof(unsigned char))) != sizeof(unsigned char))
802: {
803: if (sem_wait(
804: &((*s_etat_processus).semaphore_fork)) != 0)
805: {
806: (*s_etat_processus).erreur_systeme = d_es_processus;
807: return;
808: }
809:
810: if (longueur_ecriture == -1)
811: {
812: pthread_mutex_unlock(&((*s_etat_processus).mutex));
813:
814: liberation(s_etat_processus, s_objet_argument_1);
815: liberation(s_etat_processus, s_objet_argument_2);
816:
817: if (registre_stop == 0)
818: {
819: if ((*s_etat_processus)
820: .var_volatile_traitement_retarde_stop
821: == -1)
822: {
823: (*s_etat_processus)
824: .var_volatile_requete_arret = -1;
825: }
826:
827: (*s_etat_processus)
828: .var_volatile_traitement_retarde_stop
829: = registre_stop;
830: }
831:
832: if ((*s_etat_processus).profilage == d_vrai)
833: {
834: profilage(s_etat_processus, NULL);
835: }
836:
837: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
838: {
839: (*s_etat_processus).erreur_systeme =
840: d_es_signal;
841: return;
842: }
843:
844: return;
845: }
846:
847: if (sem_post(
848: &((*s_etat_processus).semaphore_fork)) != 0)
849: {
850: (*s_etat_processus).erreur_systeme = d_es_processus;
851: return;
852: }
853: }
854:
855: if (ecriture_pipe(s_etat_processus,
856: (*(*((struct_processus_fils *)
857: (*(*l_element_courant).donnee).objet)).thread)
858: .pipe_injections[1], s_objet_argument_2)
859: == d_erreur)
860: {
861: // Le processus fils peut s'être terminé.
862:
863: if ((*s_etat_processus).erreur_systeme != d_es)
864: {
865: (*s_etat_processus).erreur_systeme = d_es;
866: }
867: }
868:
869: if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
870: {
871: (*s_etat_processus).erreur_systeme = d_es_processus;
872: return;
873: }
874:
875: if (registre_stop == 0)
876: {
877: if ((*s_etat_processus)
878: .var_volatile_traitement_retarde_stop
879: == -1)
880: {
881: (*s_etat_processus).var_volatile_requete_arret = -1;
882: }
883:
884: (*s_etat_processus).var_volatile_traitement_retarde_stop
885: = registre_stop;
886: }
887:
888: if ((*s_etat_processus).profilage == d_vrai)
889: {
890: profilage(s_etat_processus, NULL);
891: }
892:
893: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
894: {
895: pthread_mutex_unlock(&((*s_etat_processus).mutex));
896:
897: (*s_etat_processus).erreur_systeme = d_es_signal;
898: return;
899: }
900:
901: break;
902: }
903: }
904: else
905: {
906: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
907: .donnee).objet)).thread).processus_detache == d_vrai)
908: {
909: l_element_courant = (*l_element_courant).suivant;
910: continue;
911: }
912:
913: if (((pthread_equal((*(*((struct_processus_fils *)
914: (*s_objet_argument_1).objet)).thread).tid,
915: (*(*((struct_processus_fils *)
916: (*(*l_element_courant).donnee).objet)).thread).tid)
917: != 0)) && ((*(*((struct_processus_fils *)
918: (*s_objet_argument_1).objet)).thread).pid ==
919: (*(*((struct_processus_fils *)
920: (*(*l_element_courant).donnee).objet)).thread).pid))
921: {
922: // Envoi des données
923: // Attention : si le processus n'existe plus, il n'y a plus
924: // de lecteur et on peut se prendre un SIGPIPE dans la
925: // figure !
926:
927: action.sa_handler = SIG_IGN;
928: action.sa_flags = SA_ONSTACK;
929:
930: if (sigaction(SIGPIPE, &action, ®istre) != 0)
931: {
932: pthread_mutex_unlock(&((*s_etat_processus).mutex));
933:
934: (*s_etat_processus).erreur_systeme = d_es_signal;
935: return;
936: }
937:
938: // Validation des données. On envoie un signal pour
939: // débloquer les instructions de type WF* pour les
940: // lectures bloquantes.
941:
942: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
943: (*(*l_element_courant).donnee).objet)).thread)
944: .mutex)) != 0)
945: {
946: (*s_etat_processus).erreur_systeme = d_es_processus;
947: return;
948: }
949:
950: if ((*(*((struct_processus_fils *)
951: (*(*l_element_courant).donnee).objet)).thread)
952: .thread_actif == d_vrai)
953: {
954: if (envoi_signal_thread((*(*((struct_processus_fils *)
955: (*(*l_element_courant).donnee).objet)).thread)
956: .tid, rpl_siginject) != 0)
957: {
958: // Le processus fils peut s'être terminé.
959:
960: if (pthread_mutex_unlock(
961: &((*(*((struct_processus_fils *)
962: (*(*l_element_courant).donnee).objet))
963: .thread).mutex)) != 0)
964: {
965: (*s_etat_processus).erreur_systeme =
966: d_es_processus;
967: return;
968: }
969:
970: break;
971: }
972: }
973: else
974: {
975: if (pthread_mutex_unlock(
976: &((*(*((struct_processus_fils *)
977: (*(*l_element_courant).donnee).objet))
978: .thread).mutex)) != 0)
979: {
980: (*s_etat_processus).erreur_systeme = d_es_processus;
981: return;
982: }
983:
984: break;
985: }
986:
987: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
988: (*(*l_element_courant).donnee).objet)).thread)
989: .mutex)) != 0)
990: {
991: (*s_etat_processus).erreur_systeme = d_es_processus;
992: return;
993: }
994:
995: registre_stop = (*s_etat_processus)
996: .var_volatile_traitement_retarde_stop;
997: (*s_etat_processus).var_volatile_traitement_retarde_stop
998: = 1;
999:
1000: if ((*s_etat_processus).profilage == d_vrai)
1001: {
1002: profilage(s_etat_processus,
1003: "Interthread communications (POKE)");
1004:
1005: if ((*s_etat_processus).erreur_systeme != d_es)
1006: {
1007: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1008: return;
1009: }
1010: }
1011:
1012: if (sem_post(
1013: &((*s_etat_processus).semaphore_fork)) != 0)
1014: {
1015: (*s_etat_processus).erreur_systeme = d_es_processus;
1016: return;
1017: }
1018:
1019: while((longueur_ecriture = write_atomic(s_etat_processus,
1020: (*(*((struct_processus_fils *)
1021: (*(*l_element_courant).donnee).objet)).thread)
1022: .pipe_nombre_injections[1], "-",
1023: sizeof(unsigned char))) != sizeof(unsigned char))
1024: {
1025: if (sem_wait(
1026: &((*s_etat_processus).semaphore_fork)) != 0)
1027: {
1028: (*s_etat_processus).erreur_systeme = d_es_processus;
1029: return;
1030: }
1031:
1032: if (longueur_ecriture == -1)
1033: {
1034: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1035:
1036: liberation(s_etat_processus, s_objet_argument_1);
1037: liberation(s_etat_processus, s_objet_argument_2);
1038:
1039: if (registre_stop == 0)
1040: {
1041: if ((*s_etat_processus)
1042: .var_volatile_traitement_retarde_stop
1043: == -1)
1044: {
1045: (*s_etat_processus)
1046: .var_volatile_requete_arret = -1;
1047: }
1048:
1049: (*s_etat_processus)
1050: .var_volatile_traitement_retarde_stop
1051: = registre_stop;
1052: }
1053:
1054: if ((*s_etat_processus).profilage == d_vrai)
1055: {
1056: profilage(s_etat_processus, NULL);
1057: }
1058:
1059: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1060: {
1061: (*s_etat_processus).erreur_systeme =
1062: d_es_signal;
1063: return;
1064: }
1065:
1066: return;
1067: }
1068:
1069: if (sem_post(
1070: &((*s_etat_processus).semaphore_fork)) != 0)
1071: {
1072: (*s_etat_processus).erreur_systeme = d_es_processus;
1073: return;
1074: }
1075: }
1076:
1077: if (ecriture_pipe(s_etat_processus,
1078: (*(*((struct_processus_fils *)
1079: (*(*l_element_courant).donnee).objet)).thread)
1080: .pipe_injections[1], s_objet_argument_2)
1081: == d_erreur)
1082: {
1083: // Le processus fils peut s'être terminé.
1084:
1085: if ((*s_etat_processus).erreur_systeme != d_es)
1086: {
1087: (*s_etat_processus).erreur_systeme = d_es;
1088: }
1089: }
1090:
1091: if (sem_wait(
1092: &((*s_etat_processus).semaphore_fork)) != 0)
1093: {
1094: (*s_etat_processus).erreur_systeme = d_es_processus;
1095: return;
1096: }
1097:
1098: if (registre_stop == 0)
1099: {
1100: if ((*s_etat_processus)
1101: .var_volatile_traitement_retarde_stop
1102: == -1)
1103: {
1104: (*s_etat_processus).var_volatile_requete_arret = -1;
1105: }
1106:
1107: (*s_etat_processus).var_volatile_traitement_retarde_stop
1108: = registre_stop;
1109: }
1110:
1111: if ((*s_etat_processus).profilage == d_vrai)
1112: {
1113: profilage(s_etat_processus, NULL);
1114: }
1115:
1116: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1117: {
1118: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1119:
1120: (*s_etat_processus).erreur_systeme = d_es_signal;
1121: return;
1122: }
1123:
1124: break;
1125: }
1126: }
1127:
1128: l_element_courant = (*l_element_courant).suivant;
1129: }
1130:
1131: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1132: {
1133: (*s_etat_processus).erreur_systeme = d_es_processus;
1134: return;
1135: }
1136:
1137: if (l_element_courant == NULL)
1138: {
1139: liberation(s_etat_processus, s_objet_argument_1);
1140: liberation(s_etat_processus, s_objet_argument_2);
1141:
1142: (*s_etat_processus).erreur_execution = d_ex_processus;
1143: return;
1144: }
1145: }
1146: else
1147: {
1148: liberation(s_etat_processus, s_objet_argument_1);
1149: liberation(s_etat_processus, s_objet_argument_2);
1150:
1151: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1152: return;
1153: }
1154:
1155: liberation(s_etat_processus, s_objet_argument_1);
1156: liberation(s_etat_processus, s_objet_argument_2);
1157:
1158: return;
1159: }
1160:
1161:
1162: /*
1163: ================================================================================
1164: Fonction 'private'
1165: ================================================================================
1166: Entrées :
1167: --------------------------------------------------------------------------------
1168: Sorties :
1169: --------------------------------------------------------------------------------
1170: Effets de bord : néant
1171: ================================================================================
1172: */
1173:
1174: void
1175: instruction_private(struct_processus *s_etat_processus)
1176: {
1177: struct_liste_chainee *l_element_courant;
1178:
1179: struct_objet *s_objet;
1180:
1181: (*s_etat_processus).erreur_execution = d_ex;
1182:
1183: if ((*s_etat_processus).affichage_arguments == 'Y')
1184: {
1185: printf("\n PRIVATE ");
1186:
1187: if ((*s_etat_processus).langue == 'F')
1188: {
1189: printf("(rend privée une variable partagée)\n\n");
1190: }
1191: else
1192: {
1193: printf("(switch a shared variable to private one)\n\n");
1194: }
1195:
1196: printf(" 1: %s, %s\n", d_NOM, d_LST);
1197:
1198: return;
1199: }
1200: else if ((*s_etat_processus).test_instruction == 'Y')
1201: {
1202: (*s_etat_processus).nombre_arguments = -1;
1203: return;
1204: }
1205:
1206: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1207: {
1208: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1209: {
1210: return;
1211: }
1212: }
1213:
1214: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1215: &s_objet) == d_erreur)
1216: {
1217: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1218: return;
1219: }
1220:
1221: if ((*s_objet).type == NOM)
1222: {
1223: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
1224: (*s_objet).objet)).nom)) == d_faux)
1225: {
1226: liberation(s_etat_processus, s_objet);
1227:
1228: (*s_etat_processus).erreur_systeme = d_es;
1229: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1230: return;
1231: }
1232:
1233: if (pthread_mutex_lock(&((*(*s_etat_processus)
1234: .s_liste_variables_partagees).mutex)) != 0)
1235: {
1236: (*s_etat_processus).erreur_systeme = d_es_processus;
1237: return;
1238: }
1239:
1240: if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
1241: (*s_objet).objet)).nom), (*(*s_etat_processus)
1242: .pointeur_variable_courante).variable_partagee,
1243: (*(*s_etat_processus).pointeur_variable_courante).origine)
1244: == d_faux)
1245: {
1246: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1247: .s_liste_variables_partagees).mutex)) != 0)
1248: {
1249: (*s_etat_processus).erreur_systeme = d_es_processus;
1250: return;
1251: }
1252:
1253: liberation(s_etat_processus, s_objet);
1254:
1255: (*s_etat_processus).erreur_systeme = d_es;
1256: return;
1257: }
1258:
1259: (*(*s_etat_processus).pointeur_variable_courante).objet =
1260: (*(*s_etat_processus).s_liste_variables_partagees).table
1261: [(*(*s_etat_processus).s_liste_variables_partagees)
1262: .position_variable].objet;
1263: (*(*s_etat_processus).s_liste_variables_partagees).table
1264: [(*(*s_etat_processus).s_liste_variables_partagees)
1265: .position_variable].objet = NULL;
1266:
1267: if (retrait_variable_partagee(s_etat_processus,
1268: (*((struct_nom *) (*s_objet).objet)).nom,
1269: (*(*s_etat_processus).pointeur_variable_courante)
1270: .variable_partagee) == d_erreur)
1271: {
1272: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1273: .s_liste_variables_partagees).mutex)) != 0)
1274: {
1275: (*s_etat_processus).erreur_systeme = d_es_processus;
1276: return;
1277: }
1278:
1279: liberation(s_etat_processus, s_objet);
1280: return;
1281: }
1282:
1283: if ((*(*s_etat_processus).pointeur_variable_courante).origine == 'P')
1284: {
1285: (*(*s_etat_processus).pointeur_variable_courante)
1286: .variable_partagee.adresse = 0;
1287: }
1288: else
1289: {
1290: (*(*s_etat_processus).pointeur_variable_courante)
1291: .variable_partagee.pointeur = NULL;
1292: }
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: else if ((*s_objet).type == LST)
1302: {
1303: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1304:
1305: while(l_element_courant != NULL)
1306: {
1307: if ((*(*l_element_courant).donnee).type != NOM)
1308: {
1309: liberation(s_etat_processus, s_objet);
1310:
1311: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1312: return;
1313: }
1314:
1315: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
1316: (*s_objet).objet)).nom)) == d_faux)
1317: {
1318: liberation(s_etat_processus, s_objet);
1319:
1320: (*s_etat_processus).erreur_systeme = d_es;
1321: (*s_etat_processus).erreur_execution =
1322: d_ex_variable_non_definie;
1323: return;
1324: }
1325:
1326: if (pthread_mutex_lock(&((*(*s_etat_processus)
1327: .s_liste_variables_partagees).mutex)) != 0)
1328: {
1329: (*s_etat_processus).erreur_systeme = d_es_processus;
1330: return;
1331: }
1332:
1333: if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
1334: (*s_objet).objet)).nom), (*(*s_etat_processus)
1335: .pointeur_variable_courante).variable_partagee,
1336: (*(*s_etat_processus).pointeur_variable_courante).origine)
1337: == d_faux)
1338: {
1339: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1340: .s_liste_variables_partagees).mutex)) != 0)
1341: {
1342: (*s_etat_processus).erreur_systeme = d_es_processus;
1343: return;
1344: }
1345:
1346: liberation(s_etat_processus, s_objet);
1347:
1348: (*s_etat_processus).erreur_systeme = d_es;
1349: (*s_etat_processus).erreur_execution =
1350: d_ex_variable_non_definie;
1351: return;
1352: }
1353:
1354: (*(*s_etat_processus).pointeur_variable_courante).objet =
1355: (*(*s_etat_processus).s_liste_variables_partagees).table
1356: [(*(*s_etat_processus).s_liste_variables_partagees)
1357: .position_variable].objet;
1358: (*(*s_etat_processus).s_liste_variables_partagees).table
1359: [(*(*s_etat_processus).s_liste_variables_partagees)
1360: .position_variable].objet = NULL;
1361:
1362: if ((*(*s_etat_processus).pointeur_variable_courante).origine
1363: == 'P')
1364: {
1365: (*(*s_etat_processus).pointeur_variable_courante)
1366: .variable_partagee.adresse = 0;
1367: }
1368: else
1369: {
1370: (*(*s_etat_processus).pointeur_variable_courante)
1371: .variable_partagee.pointeur = NULL;
1372: }
1373:
1374: if (retrait_variable_partagee(s_etat_processus,
1375: (*((struct_nom *) (*s_objet).objet)).nom,
1376: (*(*s_etat_processus).pointeur_variable_courante)
1377: .variable_statique) == d_erreur)
1378: {
1379: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1380: .s_liste_variables_partagees).mutex)) != 0)
1381: {
1382: (*s_etat_processus).erreur_systeme = d_es_processus;
1383: return;
1384: }
1385:
1386: liberation(s_etat_processus, s_objet);
1387: return;
1388: }
1389:
1390: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1391: .s_liste_variables_partagees).mutex)) != 0)
1392: {
1393: (*s_etat_processus).erreur_systeme = d_es_processus;
1394: return;
1395: }
1396:
1397: l_element_courant = (*l_element_courant).suivant;
1398: }
1399: }
1400: else
1401: {
1402: liberation(s_etat_processus, s_objet);
1403:
1404: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1405: return;
1406: }
1407:
1408: liberation(s_etat_processus, s_objet);
1409:
1410: return;
1411: }
1412:
1413:
1414: /*
1415: ================================================================================
1416: Fonction 'pshprfl'
1417: ================================================================================
1418: Entrées : pointeur sur une structure struct_processus
1419: --------------------------------------------------------------------------------
1420: Sorties :
1421: --------------------------------------------------------------------------------
1422: Effets de bord : néant
1423: ================================================================================
1424: */
1425:
1426: void
1427: instruction_pshprfl(struct_processus *s_etat_processus)
1428: {
1429: struct_objet *s_objet_argument;
1430:
1431: (*s_etat_processus).erreur_execution = d_ex;
1432:
1433: if ((*s_etat_processus).affichage_arguments == 'Y')
1434: {
1435: printf("\n PSHPRFL ");
1436:
1437: if ((*s_etat_processus).langue == 'F')
1438: {
1439: printf("(empilement d'un point de profilage)\n\n");
1440: }
1441: else
1442: {
1443: printf("(push profile data)\n\n");
1444: }
1445:
1446: printf(" 1: %s\n", d_CHN);
1447:
1448: return;
1449: }
1450: else if ((*s_etat_processus).test_instruction == 'Y')
1451: {
1452: (*s_etat_processus).nombre_arguments = -1;
1453: return;
1454: }
1455:
1456: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1457: {
1458: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1459: {
1460: return;
1461: }
1462: }
1463:
1464: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1465: &s_objet_argument) == d_erreur)
1466: {
1467: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1468: return;
1469: }
1470:
1471: if ((*s_objet_argument).type == CHN)
1472: {
1473: if ((*s_etat_processus).profilage == d_vrai)
1474: {
1475: profilage(s_etat_processus, (unsigned char *)
1476: (*s_objet_argument).objet);
1477: }
1478: }
1479: else
1480: {
1481: liberation(s_etat_processus, s_objet_argument);
1482:
1483: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1484: return;
1485: }
1486:
1487: liberation(s_etat_processus, s_objet_argument);
1488:
1489: return;
1490: }
1491:
1492:
1493: /*
1494: ================================================================================
1495: Fonction 'pulprfl'
1496: ================================================================================
1497: Entrées : pointeur sur une structure struct_processus
1498: --------------------------------------------------------------------------------
1499: Sorties :
1500: --------------------------------------------------------------------------------
1501: Effets de bord : néant
1502: ================================================================================
1503: */
1504:
1505: void
1506: instruction_pulprfl(struct_processus *s_etat_processus)
1507: {
1508: (*s_etat_processus).erreur_execution = d_ex;
1509:
1510: if ((*s_etat_processus).affichage_arguments == 'Y')
1511: {
1512: printf("\n PULPRFL ");
1513:
1514: if ((*s_etat_processus).langue == 'F')
1515: {
1516: printf("(dépilement d'un point de profilage)\n\n");
1517: printf(" Aucun argument\n");
1518: }
1519: else
1520: {
1521: printf("(pull profile data)\n\n");
1522: printf(" No argument\n");
1523: }
1524:
1525: return;
1526: }
1527: else if ((*s_etat_processus).test_instruction == 'Y')
1528: {
1529: (*s_etat_processus).nombre_arguments = -1;
1530: return;
1531: }
1532:
1533: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1534: {
1535: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1536: {
1537: return;
1538: }
1539: }
1540:
1541: if ((*s_etat_processus).profilage == d_vrai)
1542: {
1543: profilage(s_etat_processus, NULL);
1544: }
1545:
1546: return;
1547: }
1548:
1549:
1550: /*
1551: ================================================================================
1552: Fonction 'plot'
1553: ================================================================================
1554: Entrées : pointeur sur une structure struct_processus
1555: --------------------------------------------------------------------------------
1556: Sorties :
1557: --------------------------------------------------------------------------------
1558: Effets de bord : néant
1559: ================================================================================
1560: */
1561:
1562: void
1563: instruction_plot(struct_processus *s_etat_processus)
1564: {
1565: (*s_etat_processus).erreur_execution = d_ex;
1566:
1567: if ((*s_etat_processus).affichage_arguments == 'Y')
1568: {
1569: printf("\n PLOT ");
1570:
1571: if ((*s_etat_processus).langue == 'F')
1572: {
1573: printf("(affiche les données graphiques mémorisées)\n\n");
1574: printf(" Aucun argument\n");
1575: }
1576: else
1577: {
1578: printf("(plot buffered graphic)\n\n");
1579: printf(" No argument\n");
1580: }
1581:
1582: return;
1583: }
1584: else if ((*s_etat_processus).test_instruction == 'Y')
1585: {
1586: (*s_etat_processus).nombre_arguments = -1;
1587: return;
1588: }
1589:
1590: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1591: {
1592: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1593: {
1594: return;
1595: }
1596: }
1597:
1598: if ((*s_etat_processus).fichiers_graphiques != NULL)
1599: {
1600: appel_gnuplot(s_etat_processus, 'N');
1601: }
1602:
1603: (*s_etat_processus).mise_a_jour_trace_requise = d_faux;
1604:
1605: return;
1606: }
1607:
1608:
1609: /*
1610: ================================================================================
1611: Fonction 'procid'
1612: ================================================================================
1613: Entrées : pointeur sur une structure struct_processus
1614: --------------------------------------------------------------------------------
1615: Sorties :
1616: --------------------------------------------------------------------------------
1617: Effets de bord : néant
1618: ================================================================================
1619: */
1620:
1621: void
1622: instruction_procid(struct_processus *s_etat_processus)
1623: {
1624: pthread_mutexattr_t attributs_mutex;
1625:
1626: struct_objet *s_objet;
1627:
1628: (*s_etat_processus).erreur_execution = d_ex;
1629:
1630: if ((*s_etat_processus).affichage_arguments == 'Y')
1631: {
1632: printf("\n PROCID ");
1633:
1634: if ((*s_etat_processus).langue == 'F')
1635: {
1636: printf("(identifiant du processus)\n\n");
1637: }
1638: else
1639: {
1640: printf("(process identifier)\n\n");
1641: }
1642:
1643: printf("-> 1: %s\n", d_PRC);
1644:
1645: return;
1646: }
1647: else if ((*s_etat_processus).test_instruction == 'Y')
1648: {
1649: (*s_etat_processus).nombre_arguments = -1;
1650: return;
1651: }
1652:
1653: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1654: {
1655: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1656: {
1657: return;
1658: }
1659: }
1660:
1661: if ((s_objet = allocation(s_etat_processus, PRC)) == NULL)
1662: {
1663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1664: return;
1665: }
1666:
1667: if (((*((struct_processus_fils *) (*s_objet).objet)).thread =
1668: malloc(sizeof(struct_descripteur_thread))) == NULL)
1669: {
1670: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1671: return;
1672: }
1673:
1674: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1675: .nombre_references = 1;
1676: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1677: .pid = getpid();
1678: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1679: .tid = pthread_self();
1680: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1681: .processus_detache = (*s_etat_processus).processus_detache;
1682: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1683: .argument = NULL;
1684:
1685: pthread_mutexattr_init(&attributs_mutex);
1686: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
1687: pthread_mutex_init(&((*(*((struct_processus_fils *)
1688: (*s_objet).objet)).thread).mutex), &attributs_mutex);
1689: pthread_mutexattr_destroy(&attributs_mutex);
1690:
1691: pthread_mutexattr_init(&attributs_mutex);
1692: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
1693: pthread_mutex_init(&((*(*((struct_processus_fils *)
1694: (*s_objet).objet)).thread).mutex_nombre_references),
1695: &attributs_mutex);
1696: pthread_mutexattr_destroy(&attributs_mutex);
1697:
1698: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1699: s_objet) == d_erreur)
1700: {
1701: return;
1702: }
1703:
1704: return;
1705: }
1706:
1707: // 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