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