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