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