![[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.2 ! bertrand 3: RPL/2 (R) version 4.0.10
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:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'protect'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_protect(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_element_courant;
42:
43: struct_objet *s_objet;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n PROTECT ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(verrouille une variable)\n\n");
54: }
55: else
56: {
57: printf("(lock a variable)\n\n");
58: }
59:
60: printf(" 1: %s, %s\n", d_NOM, d_LST);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if ((*s_objet).type == NOM)
86: {
87: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
88: (*s_objet).objet)).nom)) == d_faux)
89: {
90: liberation(s_etat_processus, s_objet);
91:
92: (*s_etat_processus).erreur_systeme = d_es;
93: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
94: return;
95: }
96:
97: ((*s_etat_processus).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:
849: if (sem_post(&((*s_etat_processus).semaphore_fork))
850: != 0)
851: {
852: (*s_etat_processus).erreur_systeme = d_es_processus;
853: return;
854: }
855:
856: while((longueur_ecriture = write_atomic(s_etat_processus,
857: (*(*((struct_processus_fils *)
858: (*(*l_element_courant).donnee).objet)).thread)
859: .pipe_nombre_injections[1], "-",
860: sizeof(unsigned char))) != sizeof(unsigned char))
861: {
862: while(sem_wait(&((*s_etat_processus)
863: .semaphore_fork)) == -1)
864: {
865: if (errno != EINTR)
866: {
867: (*s_etat_processus).erreur_systeme =
868: d_es_processus;
869: return;
870: }
871: }
872:
873: if (longueur_ecriture == -1)
874: {
875: pthread_mutex_unlock(&((*s_etat_processus).mutex));
876:
877: liberation(s_etat_processus, s_objet_argument_1);
878: liberation(s_etat_processus, s_objet_argument_2);
879:
880: if (registre_stop == 0)
881: {
882: if ((*s_etat_processus)
883: .var_volatile_traitement_retarde_stop
884: == -1)
885: {
886: (*s_etat_processus)
887: .var_volatile_requete_arret = -1;
888: }
889:
890: (*s_etat_processus)
891: .var_volatile_traitement_retarde_stop
892: = registre_stop;
893: }
894:
895: if ((*s_etat_processus).profilage == d_vrai)
896: {
897: profilage(s_etat_processus, NULL);
898: }
899:
900: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
901: {
902: (*s_etat_processus).erreur_systeme =
903: d_es_signal;
904: return;
905: }
906:
907: return;
908: }
909:
910: if (sem_post(&((*s_etat_processus)
911: .semaphore_fork)) != 0)
912: {
913: (*s_etat_processus).erreur_systeme = d_es_processus;
914: return;
915: }
916: }
917:
918: if (ecriture_pipe(s_etat_processus,
919: (*(*((struct_processus_fils *)
920: (*(*l_element_courant).donnee).objet)).thread)
921: .pipe_injections[1], s_objet_argument_2)
922: == d_erreur)
923: {
924: // Le processus fils peut s'être terminé.
925:
926: if ((*s_etat_processus).erreur_systeme != d_es)
927: {
928: (*s_etat_processus).erreur_systeme = d_es;
929: }
930: }
931:
932: while(sem_wait(&((*s_etat_processus).semaphore_fork))
933: == -1)
934: {
935: if (errno == EINTR)
936: {
937: (*s_etat_processus).erreur_systeme = d_es_processus;
938: return;
939: }
940: }
941:
942: if (registre_stop == 0)
943: {
944: if ((*s_etat_processus)
945: .var_volatile_traitement_retarde_stop
946: == -1)
947: {
948: (*s_etat_processus).var_volatile_requete_arret = -1;
949: }
950:
951: (*s_etat_processus).var_volatile_traitement_retarde_stop
952: = registre_stop;
953: }
954:
955: if ((*s_etat_processus).profilage == d_vrai)
956: {
957: profilage(s_etat_processus, NULL);
958: }
959:
960: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
961: {
962: pthread_mutex_unlock(&((*s_etat_processus).mutex));
963:
964: (*s_etat_processus).erreur_systeme = d_es_signal;
965: return;
966: }
967:
968: break;
969: }
970: }
971: else
972: {
973: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
974: .donnee).objet)).thread).processus_detache == d_vrai)
975: {
976: l_element_courant = (*l_element_courant).suivant;
977: continue;
978: }
979:
980: if (((pthread_equal((*(*((struct_processus_fils *)
981: (*s_objet_argument_1).objet)).thread).tid,
982: (*(*((struct_processus_fils *)
983: (*(*l_element_courant).donnee).objet)).thread).tid)
984: != 0)) && ((*(*((struct_processus_fils *)
985: (*s_objet_argument_1).objet)).thread).pid ==
986: (*(*((struct_processus_fils *)
987: (*(*l_element_courant).donnee).objet)).thread).pid))
988: {
989: // Envoi des données
990: // Attention : si le processus n'existe plus, il n'y a plus
991: // de lecteur et on peut se prendre un SIGPIPE dans la
992: // figure !
993:
994: action.sa_handler = SIG_IGN;
995: action.sa_flags = SA_ONSTACK;
996:
997: if (sigaction(SIGPIPE, &action, ®istre) != 0)
998: {
999: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1000:
1001: (*s_etat_processus).erreur_systeme = d_es_signal;
1002: return;
1003: }
1004:
1005: // Validation des données. On envoie un signal pour
1006: // débloquer les instructions de type WF* pour les
1007: // lectures bloquantes.
1008:
1009: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1010: (*(*l_element_courant).donnee).objet)).thread)
1011: .mutex)) != 0)
1012: {
1013: (*s_etat_processus).erreur_systeme = d_es_processus;
1014: return;
1015: }
1016:
1017: if ((*(*((struct_processus_fils *)
1018: (*(*l_element_courant).donnee).objet)).thread)
1019: .thread_actif == d_vrai)
1020: {
1021: if (pthread_kill((*(*((struct_processus_fils *)
1022: (*(*l_element_courant).donnee).objet)).thread)
1023: .tid, SIGINJECT) != 0)
1024: {
1025: // Le processus fils peut s'être terminé.
1026:
1027: if (pthread_mutex_unlock(
1028: &((*(*((struct_processus_fils *)
1029: (*(*l_element_courant).donnee).objet))
1030: .thread).mutex)) != 0)
1031: {
1032: (*s_etat_processus).erreur_systeme =
1033: d_es_processus;
1034: return;
1035: }
1036:
1037: break;
1038: }
1039: }
1040: else
1041: {
1042: if (pthread_mutex_unlock(
1043: &((*(*((struct_processus_fils *)
1044: (*(*l_element_courant).donnee).objet))
1045: .thread).mutex)) != 0)
1046: {
1047: (*s_etat_processus).erreur_systeme = d_es_processus;
1048: return;
1049: }
1050:
1051: break;
1052: }
1053:
1054: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1055: (*(*l_element_courant).donnee).objet)).thread)
1056: .mutex)) != 0)
1057: {
1058: (*s_etat_processus).erreur_systeme = d_es_processus;
1059: return;
1060: }
1061:
1062: registre_stop = (*s_etat_processus)
1063: .var_volatile_traitement_retarde_stop;
1064: (*s_etat_processus).var_volatile_traitement_retarde_stop
1065: = 1;
1066:
1067: if ((*s_etat_processus).profilage == d_vrai)
1068: {
1069: profilage(s_etat_processus,
1070: "Interthread communications (POKE)");
1071:
1072: if ((*s_etat_processus).erreur_systeme != d_es)
1073: {
1074: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1075: return;
1076: }
1077: }
1078:
1079: if (sem_post(&((*s_etat_processus).semaphore_fork))
1080: != 0)
1081: {
1082: (*s_etat_processus).erreur_systeme = d_es_processus;
1083: return;
1084: }
1085:
1086: while((longueur_ecriture = write_atomic(s_etat_processus,
1087: (*(*((struct_processus_fils *)
1088: (*(*l_element_courant).donnee).objet)).thread)
1089: .pipe_nombre_injections[1], "-",
1090: sizeof(unsigned char))) != sizeof(unsigned char))
1091: {
1092: while(sem_wait(&((*s_etat_processus)
1093: .semaphore_fork)) == -1)
1094: {
1095: if (errno != EINTR)
1096: {
1097: (*s_etat_processus).erreur_systeme =
1098: d_es_processus;
1099: return;
1100: }
1101: }
1102:
1103: if (longueur_ecriture == -1)
1104: {
1105: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1106:
1107: liberation(s_etat_processus, s_objet_argument_1);
1108: liberation(s_etat_processus, s_objet_argument_2);
1109:
1110: if (registre_stop == 0)
1111: {
1112: if ((*s_etat_processus)
1113: .var_volatile_traitement_retarde_stop
1114: == -1)
1115: {
1116: (*s_etat_processus)
1117: .var_volatile_requete_arret = -1;
1118: }
1119:
1120: (*s_etat_processus)
1121: .var_volatile_traitement_retarde_stop
1122: = registre_stop;
1123: }
1124:
1125: if ((*s_etat_processus).profilage == d_vrai)
1126: {
1127: profilage(s_etat_processus, NULL);
1128: }
1129:
1130: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1131: {
1132: (*s_etat_processus).erreur_systeme =
1133: d_es_signal;
1134: return;
1135: }
1136:
1137: return;
1138: }
1139:
1140: if (sem_post(&((*s_etat_processus)
1141: .semaphore_fork)) != 0)
1142: {
1143: (*s_etat_processus).erreur_systeme = d_es_processus;
1144: return;
1145: }
1146: }
1147:
1148: if (ecriture_pipe(s_etat_processus,
1149: (*(*((struct_processus_fils *)
1150: (*(*l_element_courant).donnee).objet)).thread)
1151: .pipe_injections[1], s_objet_argument_2)
1152: == d_erreur)
1153: {
1154: // Le processus fils peut s'être terminé.
1155:
1156: if ((*s_etat_processus).erreur_systeme != d_es)
1157: {
1158: (*s_etat_processus).erreur_systeme = d_es;
1159: }
1160: }
1161:
1162: while(sem_wait(&((*s_etat_processus)
1163: .semaphore_fork)) == -1)
1164: {
1165: if (errno != EINTR)
1166: {
1167: (*s_etat_processus).erreur_systeme = d_es_processus;
1168: return;
1169: }
1170: }
1171:
1172: if (registre_stop == 0)
1173: {
1174: if ((*s_etat_processus)
1175: .var_volatile_traitement_retarde_stop
1176: == -1)
1177: {
1178: (*s_etat_processus).var_volatile_requete_arret = -1;
1179: }
1180:
1181: (*s_etat_processus).var_volatile_traitement_retarde_stop
1182: = registre_stop;
1183: }
1184:
1185: if ((*s_etat_processus).profilage == d_vrai)
1186: {
1187: profilage(s_etat_processus, NULL);
1188: }
1189:
1190: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1191: {
1192: pthread_mutex_unlock(&((*s_etat_processus).mutex));
1193:
1194: (*s_etat_processus).erreur_systeme = d_es_signal;
1195: return;
1196: }
1197:
1198: break;
1199: }
1200: }
1201:
1202: l_element_courant = (*l_element_courant).suivant;
1203: }
1204:
1205: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
1206: {
1207: (*s_etat_processus).erreur_systeme = d_es_processus;
1208: return;
1209: }
1210:
1211: if (l_element_courant == NULL)
1212: {
1213: liberation(s_etat_processus, s_objet_argument_1);
1214: liberation(s_etat_processus, s_objet_argument_2);
1215:
1216: (*s_etat_processus).erreur_execution = d_ex_processus;
1217: return;
1218: }
1219: }
1220: else
1221: {
1222: liberation(s_etat_processus, s_objet_argument_1);
1223: liberation(s_etat_processus, s_objet_argument_2);
1224:
1225: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1226: return;
1227: }
1228:
1229: liberation(s_etat_processus, s_objet_argument_1);
1230: liberation(s_etat_processus, s_objet_argument_2);
1231:
1232: return;
1233: }
1234:
1235:
1236: /*
1237: ================================================================================
1238: Fonction 'private'
1239: ================================================================================
1240: Entrées :
1241: --------------------------------------------------------------------------------
1242: Sorties :
1243: --------------------------------------------------------------------------------
1244: Effets de bord : néant
1245: ================================================================================
1246: */
1247:
1248: void
1249: instruction_private(struct_processus *s_etat_processus)
1250: {
1251: struct_liste_chainee *l_element_courant;
1252:
1253: struct_objet *s_objet;
1254:
1255: (*s_etat_processus).erreur_execution = d_ex;
1256:
1257: if ((*s_etat_processus).affichage_arguments == 'Y')
1258: {
1259: printf("\n PRIVATE ");
1260:
1261: if ((*s_etat_processus).langue == 'F')
1262: {
1263: printf("(rend privée une variable partagée)\n\n");
1264: }
1265: else
1266: {
1267: printf("(switch a shared variable to private one)\n\n");
1268: }
1269:
1270: printf(" 1: %s, %s\n", d_NOM, d_LST);
1271:
1272: return;
1273: }
1274: else if ((*s_etat_processus).test_instruction == 'Y')
1275: {
1276: (*s_etat_processus).nombre_arguments = -1;
1277: return;
1278: }
1279:
1280: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1281: {
1282: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1283: {
1284: return;
1285: }
1286: }
1287:
1288: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1289: &s_objet) == d_erreur)
1290: {
1291: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1292: return;
1293: }
1294:
1295: if ((*s_objet).type == NOM)
1296: {
1297: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
1298: (*s_objet).objet)).nom)) == d_faux)
1299: {
1300: liberation(s_etat_processus, s_objet);
1301:
1302: (*s_etat_processus).erreur_systeme = d_es;
1303: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1304: return;
1305: }
1306:
1307: if (pthread_mutex_lock(&((*(*s_etat_processus)
1308: .s_liste_variables_partagees).mutex)) != 0)
1309: {
1310: (*s_etat_processus).erreur_systeme = d_es_processus;
1311: return;
1312: }
1313:
1314: if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
1315: (*s_objet).objet)).nom), ((*s_etat_processus).s_liste_variables
1316: [(*s_etat_processus).position_variable_courante])
1317: .variable_partagee, ((*s_etat_processus).s_liste_variables
1318: [(*s_etat_processus).position_variable_courante]).origine)
1319: == d_faux)
1320: {
1321: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1322: .s_liste_variables_partagees).mutex)) != 0)
1323: {
1324: (*s_etat_processus).erreur_systeme = d_es_processus;
1325: return;
1326: }
1327:
1328: liberation(s_etat_processus, s_objet);
1329:
1330: (*s_etat_processus).erreur_systeme = d_es;
1331: return;
1332: }
1333:
1334: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1335: .position_variable_courante].objet =
1336: (*(*s_etat_processus).s_liste_variables_partagees).table
1337: [(*(*s_etat_processus).s_liste_variables_partagees)
1338: .position_variable].objet;
1339: (*(*s_etat_processus).s_liste_variables_partagees).table
1340: [(*(*s_etat_processus).s_liste_variables_partagees)
1341: .position_variable].objet = NULL;
1342:
1343: if (retrait_variable_partagee(s_etat_processus,
1344: (*((struct_nom *) (*s_objet).objet)).nom,
1345: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1346: .position_variable_courante].variable_partagee) == d_erreur)
1347: {
1348: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1349: .s_liste_variables_partagees).mutex)) != 0)
1350: {
1351: (*s_etat_processus).erreur_systeme = d_es_processus;
1352: return;
1353: }
1354:
1355: liberation(s_etat_processus, s_objet);
1356: return;
1357: }
1358:
1359: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
1360: .position_variable_courante].origine == 'P')
1361: {
1362: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1363: .position_variable_courante].variable_partagee.adresse = 0;
1364: }
1365: else
1366: {
1367: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1368: .position_variable_courante].variable_partagee.pointeur
1369: = NULL;
1370: }
1371:
1372: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1373: .s_liste_variables_partagees).mutex)) != 0)
1374: {
1375: (*s_etat_processus).erreur_systeme = d_es_processus;
1376: return;
1377: }
1378: }
1379: else if ((*s_objet).type == LST)
1380: {
1381: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1382:
1383: while(l_element_courant != NULL)
1384: {
1385: if ((*(*l_element_courant).donnee).type != NOM)
1386: {
1387: liberation(s_etat_processus, s_objet);
1388:
1389: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1390: return;
1391: }
1392:
1393: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
1394: (*s_objet).objet)).nom)) == d_faux)
1395: {
1396: liberation(s_etat_processus, s_objet);
1397:
1398: (*s_etat_processus).erreur_systeme = d_es;
1399: (*s_etat_processus).erreur_execution =
1400: d_ex_variable_non_definie;
1401: return;
1402: }
1403:
1404: if (pthread_mutex_lock(&((*(*s_etat_processus)
1405: .s_liste_variables_partagees).mutex)) != 0)
1406: {
1407: (*s_etat_processus).erreur_systeme = d_es_processus;
1408: return;
1409: }
1410:
1411: if (recherche_variable_partagee(s_etat_processus, ((*((struct_nom *)
1412: (*s_objet).objet)).nom), ((*s_etat_processus)
1413: .s_liste_variables[(*s_etat_processus)
1414: .position_variable_courante]).variable_partagee,
1415: ((*s_etat_processus).s_liste_variables
1416: [(*s_etat_processus).position_variable_courante]).origine)
1417: == d_faux)
1418: {
1419: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1420: .s_liste_variables_partagees).mutex)) != 0)
1421: {
1422: (*s_etat_processus).erreur_systeme = d_es_processus;
1423: return;
1424: }
1425:
1426: liberation(s_etat_processus, s_objet);
1427:
1428: (*s_etat_processus).erreur_systeme = d_es;
1429: (*s_etat_processus).erreur_execution =
1430: d_ex_variable_non_definie;
1431: return;
1432: }
1433:
1434: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1435: .position_variable_courante].objet =
1436: (*(*s_etat_processus).s_liste_variables_partagees).table
1437: [(*(*s_etat_processus).s_liste_variables_partagees)
1438: .position_variable].objet;
1439: (*(*s_etat_processus).s_liste_variables_partagees).table
1440: [(*(*s_etat_processus).s_liste_variables_partagees)
1441: .position_variable].objet = NULL;
1442:
1443: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
1444: .position_variable_courante].origine == 'P')
1445: {
1446: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1447: .position_variable_courante].variable_partagee.adresse
1448: = 0;
1449: }
1450: else
1451: {
1452: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1453: .position_variable_courante].variable_partagee.pointeur
1454: = NULL;
1455: }
1456:
1457: if (retrait_variable_partagee(s_etat_processus,
1458: (*((struct_nom *) (*s_objet).objet)).nom,
1459: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
1460: .position_variable_courante].variable_statique) == d_erreur)
1461: {
1462: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1463: .s_liste_variables_partagees).mutex)) != 0)
1464: {
1465: (*s_etat_processus).erreur_systeme = d_es_processus;
1466: return;
1467: }
1468:
1469: liberation(s_etat_processus, s_objet);
1470: return;
1471: }
1472:
1473: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1474: .s_liste_variables_partagees).mutex)) != 0)
1475: {
1476: (*s_etat_processus).erreur_systeme = d_es_processus;
1477: return;
1478: }
1479:
1480: l_element_courant = (*l_element_courant).suivant;
1481: }
1482: }
1483: else
1484: {
1485: liberation(s_etat_processus, s_objet);
1486:
1487: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1488: return;
1489: }
1490:
1491: liberation(s_etat_processus, s_objet);
1492:
1493: return;
1494: }
1495:
1496:
1497: /*
1498: ================================================================================
1499: Fonction 'pshprfl'
1500: ================================================================================
1501: Entrées : pointeur sur une structure struct_processus
1502: --------------------------------------------------------------------------------
1503: Sorties :
1504: --------------------------------------------------------------------------------
1505: Effets de bord : néant
1506: ================================================================================
1507: */
1508:
1509: void
1510: instruction_pshprfl(struct_processus *s_etat_processus)
1511: {
1512: struct_objet *s_objet_argument;
1513:
1514: (*s_etat_processus).erreur_execution = d_ex;
1515:
1516: if ((*s_etat_processus).affichage_arguments == 'Y')
1517: {
1518: printf("\n PSHPRFL ");
1519:
1520: if ((*s_etat_processus).langue == 'F')
1521: {
1522: printf("(empilement d'un point de profilage)\n\n");
1523: }
1524: else
1525: {
1526: printf("(push profile data)\n\n");
1527: }
1528:
1529: printf(" 1: %s\n", d_CHN);
1530:
1531: return;
1532: }
1533: else if ((*s_etat_processus).test_instruction == 'Y')
1534: {
1535: (*s_etat_processus).nombre_arguments = -1;
1536: return;
1537: }
1538:
1539: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1540: {
1541: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1542: {
1543: return;
1544: }
1545: }
1546:
1547: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1548: &s_objet_argument) == d_erreur)
1549: {
1550: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1551: return;
1552: }
1553:
1554: if ((*s_objet_argument).type == CHN)
1555: {
1556: if ((*s_etat_processus).profilage == d_vrai)
1557: {
1558: profilage(s_etat_processus, (unsigned char *)
1559: (*s_objet_argument).objet);
1560: }
1561: }
1562: else
1563: {
1564: liberation(s_etat_processus, s_objet_argument);
1565:
1566: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1567: return;
1568: }
1569:
1570: liberation(s_etat_processus, s_objet_argument);
1571:
1572: return;
1573: }
1574:
1575:
1576: /*
1577: ================================================================================
1578: Fonction 'pulprfl'
1579: ================================================================================
1580: Entrées : pointeur sur une structure struct_processus
1581: --------------------------------------------------------------------------------
1582: Sorties :
1583: --------------------------------------------------------------------------------
1584: Effets de bord : néant
1585: ================================================================================
1586: */
1587:
1588: void
1589: instruction_pulprfl(struct_processus *s_etat_processus)
1590: {
1591: (*s_etat_processus).erreur_execution = d_ex;
1592:
1593: if ((*s_etat_processus).affichage_arguments == 'Y')
1594: {
1595: printf("\n PULPRFL ");
1596:
1597: if ((*s_etat_processus).langue == 'F')
1598: {
1599: printf("(dépilement d'un point de profilage)\n\n");
1600: printf(" Aucun argument\n");
1601: }
1602: else
1603: {
1604: printf("(pull profile data)\n\n");
1605: printf(" No argument\n");
1606: }
1607:
1608: return;
1609: }
1610: else if ((*s_etat_processus).test_instruction == 'Y')
1611: {
1612: (*s_etat_processus).nombre_arguments = -1;
1613: return;
1614: }
1615:
1616: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1617: {
1618: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1619: {
1620: return;
1621: }
1622: }
1623:
1624: if ((*s_etat_processus).profilage == d_vrai)
1625: {
1626: profilage(s_etat_processus, NULL);
1627: }
1628:
1629: return;
1630: }
1631:
1632:
1633: /*
1634: ================================================================================
1635: Fonction 'plot'
1636: ================================================================================
1637: Entrées : pointeur sur une structure struct_processus
1638: --------------------------------------------------------------------------------
1639: Sorties :
1640: --------------------------------------------------------------------------------
1641: Effets de bord : néant
1642: ================================================================================
1643: */
1644:
1645: void
1646: instruction_plot(struct_processus *s_etat_processus)
1647: {
1648: (*s_etat_processus).erreur_execution = d_ex;
1649:
1650: if ((*s_etat_processus).affichage_arguments == 'Y')
1651: {
1652: printf("\n PLOT ");
1653:
1654: if ((*s_etat_processus).langue == 'F')
1655: {
1656: printf("(affiche les données graphiques mémorisées)\n\n");
1657: printf(" Aucun argument\n");
1658: }
1659: else
1660: {
1661: printf("(plot buffered graphic)\n\n");
1662: printf(" No argument\n");
1663: }
1664:
1665: return;
1666: }
1667: else if ((*s_etat_processus).test_instruction == 'Y')
1668: {
1669: (*s_etat_processus).nombre_arguments = -1;
1670: return;
1671: }
1672:
1673: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1674: {
1675: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1676: {
1677: return;
1678: }
1679: }
1680:
1681: if ((*s_etat_processus).fichiers_graphiques != NULL)
1682: {
1683: appel_gnuplot(s_etat_processus, 'N');
1684: }
1685:
1686: (*s_etat_processus).mise_a_jour_trace_requise = d_faux;
1687:
1688: return;
1689: }
1690:
1691: // vim: ts=4