![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s9.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_s9.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.7 ! bertrand 3: RPL/2 (R) version 4.0.14
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 'sort'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_sort(struct_processus *s_etat_processus)
40: {
41: integer8 i;
42: integer8 j;
43: integer8 nombre_elements;
44:
45: logical1 condition;
46: logical1 inversion;
47: logical1 presence_nom;
48: logical1 terminaison_boucle_1;
49: logical1 terminaison_boucle_2;
50: logical1 terminaison_boucle_3;
51: logical1 variable_partagee;
52:
53: struct_liste_chainee *l_element_courant;
54: struct_liste_chainee *l_element_precedent;
55: struct_liste_chainee *l_element_tampon;
56:
57: struct_objet *s_objet_copie;
58: struct_objet *s_objet_critere;
59: struct_objet *s_objet_liste;
60: struct_objet *s_objet_test;
61:
62: signed long indice_i;
63: signed long indice_j;
64: signed long indice_k;
65: signed long indice_l;
66:
67: unsigned long ecartement;
68:
69: (*s_etat_processus).erreur_execution = d_ex;
70:
71: if ((*s_etat_processus).affichage_arguments == 'Y')
72: {
73: printf("\n SORT ");
74:
75: if ((*s_etat_processus).langue == 'F')
76: {
77: printf("(trie une liste selon un critère paramétrable)\n\n");
78: }
79: else
80: {
81: printf("(sort a list)\n\n");
82: }
83:
84: printf(" 2: %s\n", d_LST);
85: printf(" 1: %s\n", d_RPN);
86: printf("-> 1: %s\n\n", d_LST);
87:
88: printf(" 2: %s\n", d_TAB);
89: printf(" 1: %s\n", d_RPN);
90: printf("-> 1: %s\n\n", d_LST);
91:
92: printf(" 2: %s\n", d_NOM);
93: printf(" 1: %s\n", d_RPN);
94:
95: return;
96: }
97: else if ((*s_etat_processus).test_instruction == 'Y')
98: {
99: (*s_etat_processus).nombre_arguments = -1;
100: return;
101: }
102:
103: if (test_cfsf(s_etat_processus, 31) == d_vrai)
104: {
105: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
106: {
107: return;
108: }
109: }
110:
111: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
112: &s_objet_critere) == d_erreur)
113: {
114: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
115: return;
116: }
117:
118: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
119: &s_objet_liste) == d_erreur)
120: {
121: liberation(s_etat_processus, s_objet_critere);
122:
123: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
124: return;
125: }
126:
127: variable_partagee = d_faux;
128:
129: if ((*s_objet_liste).type == NOM)
130: {
131: if (recherche_variable(s_etat_processus, (*((struct_nom *)
132: (*s_objet_liste).objet)).nom) == d_faux)
133: {
134: (*s_etat_processus).erreur_systeme = d_es;
135: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
136:
137: liberation(s_etat_processus, s_objet_critere);
138: liberation(s_etat_processus, s_objet_liste);
139:
140: return;
141: }
142:
143: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
144: .position_variable_courante].variable_verrouillee == d_vrai)
145: {
146: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
147:
148: liberation(s_etat_processus, s_objet_critere);
149: liberation(s_etat_processus, s_objet_liste);
150:
151: return;
152: }
153:
154: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
155: .position_variable_courante].objet == NULL)
156: {
157: if (pthread_mutex_lock(&((*(*s_etat_processus)
158: .s_liste_variables_partagees).mutex)) != 0)
159: {
160: (*s_etat_processus).erreur_systeme = d_es_processus;
161: return;
162: }
163:
164: if (recherche_variable_partagee(s_etat_processus,
165: (*s_etat_processus).s_liste_variables
166: [(*s_etat_processus).position_variable_courante].nom,
167: (*s_etat_processus).s_liste_variables
168: [(*s_etat_processus).position_variable_courante]
169: .variable_partagee, (*s_etat_processus).s_liste_variables
170: [(*s_etat_processus).position_variable_courante].origine)
171: == d_faux)
172: {
173: if (pthread_mutex_unlock(&((*(*s_etat_processus)
174: .s_liste_variables_partagees).mutex)) != 0)
175: {
176: (*s_etat_processus).erreur_systeme = d_es_processus;
177: return;
178: }
179:
180: (*s_etat_processus).erreur_execution =
181: d_ex_erreur_type_argument;
182:
183: liberation(s_etat_processus, s_objet_critere);
184: liberation(s_etat_processus, s_objet_liste);
185:
186: return;
187: }
188:
1.6 bertrand 189: if (((*(*(*s_etat_processus).s_liste_variables_partagees)
1.1 bertrand 190: .table[(*(*s_etat_processus).s_liste_variables_partagees)
1.6 bertrand 191: .position_variable].objet).type != LST) &&
192: ((*(*(*s_etat_processus).s_liste_variables_partagees)
193: .table[(*(*s_etat_processus).s_liste_variables_partagees)
194: .position_variable].objet).type != TBL))
1.1 bertrand 195: {
196: if (pthread_mutex_unlock(&((*(*s_etat_processus)
197: .s_liste_variables_partagees).mutex)) != 0)
198: {
199: (*s_etat_processus).erreur_systeme = d_es_processus;
200: return;
201: }
202:
203: (*s_etat_processus).erreur_execution =
204: d_ex_erreur_type_argument;
205:
206: liberation(s_etat_processus, s_objet_critere);
207: liberation(s_etat_processus, s_objet_liste);
208:
209: return;
210: }
211:
212: liberation(s_etat_processus, s_objet_liste);
213:
214: s_objet_liste = (*(*s_etat_processus).s_liste_variables_partagees)
215: .table[(*(*s_etat_processus).s_liste_variables_partagees)
216: .position_variable].objet;
217:
218: if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
219: 'N')) == NULL)
220: {
221: if (pthread_mutex_unlock(&((*(*s_etat_processus)
222: .s_liste_variables_partagees).mutex)) != 0)
223: {
224: (*s_etat_processus).erreur_systeme = d_es_processus;
225: return;
226: }
227:
228: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
229: return;
230: }
231:
232: variable_partagee = d_vrai;
233: }
234: else
235: {
1.6 bertrand 236: if (((*(*s_etat_processus).s_liste_variables
237: [(*s_etat_processus).position_variable_courante].objet)
238: .type != LST) &&
239: ((*(*s_etat_processus).s_liste_variables
1.1 bertrand 240: [(*s_etat_processus).position_variable_courante].objet)
1.6 bertrand 241: .type != TBL))
1.1 bertrand 242: {
243: (*s_etat_processus).erreur_execution =
244: d_ex_erreur_type_argument;
245:
246: liberation(s_etat_processus, s_objet_critere);
247: liberation(s_etat_processus, s_objet_liste);
248:
249: return;
250: }
251:
252: liberation(s_etat_processus, s_objet_liste);
253:
254: s_objet_liste = (*s_etat_processus).s_liste_variables
255: [(*s_etat_processus).position_variable_courante].objet;
256:
257: if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
258: 'N')) == NULL)
259: {
260: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
261: return;
262: }
263: }
264:
265: liberation(s_etat_processus, s_objet_liste);
266: s_objet_liste = s_objet_copie;
267:
268: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
269: .position_variable_courante].objet = s_objet_liste;
270:
271: presence_nom = d_vrai;
272: }
273: else
274: {
275: if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste, 'N'))
276: == NULL)
277: {
278: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
279: return;
280: }
281:
282: liberation(s_etat_processus, s_objet_liste);
283: s_objet_liste = s_objet_copie;
284: presence_nom = d_faux;
285: }
286:
287: if (((*s_objet_liste).type == LST) &&
288: ((*s_objet_critere).type == RPN))
289: {
290: /*
291: * Tri bulle de la liste chaînée. On se contente d'un tri bulle
292: * car on travaille sur une liste chaînée et non sur un tableau
293: * sur lequel on pourrait accéder directement aux données grâce à
294: * leur indice.
295: */
296:
297: nombre_elements = 0;
298: l_element_courant = (*s_objet_liste).objet;
299:
300: while(l_element_courant != NULL)
301: {
302: l_element_courant = (*l_element_courant).suivant;
303: nombre_elements++;
304: }
305:
306: // Si la liste est vide, on considère qu'elle est triée.
307: // De la même manière, on considère qu'une liste d'un
308: // seul élément est toujours triée.
309:
310: if (nombre_elements > 1)
311: {
312: j = nombre_elements;
313:
314: do
315: {
316: inversion = d_faux;
317:
318: l_element_courant = (*s_objet_liste).objet;
319: l_element_precedent = NULL;
320:
321: for(i = 0; i < j - 1; i++)
322: {
323: // Test des éléments adjacents. Pour cela, on
324: // empile les deux éléments adjacents dans la pile dans
325: // l'ordre [i] [i+1] et on évalue le critère d'ordre.
326:
327: if ((s_objet_copie = copie_objet(s_etat_processus,
328: (*l_element_courant).donnee, 'P')) == NULL)
329: {
330: (*s_etat_processus).erreur_systeme =
331: d_es_allocation_memoire;
332: return;
333: }
334:
335: if (empilement(s_etat_processus,
336: &((*s_etat_processus).l_base_pile),
337: s_objet_copie) == d_erreur)
338: {
339: return;
340: }
341:
342: if ((s_objet_copie = copie_objet(s_etat_processus,
343: (*(*l_element_courant)
344: .suivant).donnee, 'P')) == NULL)
345: {
346: (*s_etat_processus).erreur_systeme =
347: d_es_allocation_memoire;
348: return;
349: }
350:
351: if (empilement(s_etat_processus,
352: &((*s_etat_processus).l_base_pile),
353: s_objet_copie) == d_erreur)
354: {
355: return;
356: }
357:
358: if (evaluation(s_etat_processus, s_objet_critere, 'N')
359: == d_erreur)
360: {
361: liberation(s_etat_processus, s_objet_critere);
362: liberation(s_etat_processus, s_objet_liste);
363:
364: return;
365: }
366:
367: if (depilement(s_etat_processus,
368: &((*s_etat_processus).l_base_pile), &s_objet_test)
369: == d_erreur)
370: {
371: liberation(s_etat_processus, s_objet_critere);
372: liberation(s_etat_processus, s_objet_liste);
373:
374: (*s_etat_processus).erreur_execution =
375: d_ex_manque_argument;
376: return;
377: }
378:
379: if ((*s_objet_test).type == INT)
380: {
381: condition = ((*((integer8 *) (*s_objet_test).objet))
382: == 0) ? d_faux : d_vrai;
383: }
384: else if ((*s_objet_test).type == REL)
385: {
386: condition = ((*((real8 *) (*s_objet_test).objet))
387: == 0) ? d_faux : d_vrai;
388: }
389: else
390: {
391: liberation(s_etat_processus, s_objet_critere);
392: liberation(s_etat_processus, s_objet_liste);
393: liberation(s_etat_processus, s_objet_test);
394:
395: (*s_etat_processus).erreur_execution =
396: d_ex_erreur_type_argument;
397: return;
398: }
399:
400: liberation(s_etat_processus, s_objet_test);
401:
402: if (condition == d_faux)
403: {
404: // On échange les deux éléments adjacents
405:
406: inversion = d_vrai;
407:
408: if (l_element_precedent == NULL)
409: {
410: // Échange des deux premiers éléments
411: // de la liste.
412:
413: l_element_tampon = (*(*l_element_courant)
414: .suivant).suivant;
415: (*s_objet_liste).objet = (*l_element_courant)
416: .suivant;
417: (*((struct_liste_chainee *) (*s_objet_liste)
418: .objet)).suivant = l_element_courant;
419: (*l_element_courant).suivant =
420: l_element_tampon;
421: l_element_courant = (*s_objet_liste).objet;
422: }
423: else
424: {
425: // Échange de deux éléments quelconques de la
426: // liste.
427:
428: l_element_tampon = (*l_element_courant).suivant;
429: (*l_element_courant).suivant =
430: (*(*l_element_courant).suivant).suivant;
431: (*l_element_precedent).suivant = l_element_tampon;
432: (*l_element_tampon).suivant = l_element_courant;
433:
434: l_element_courant = l_element_tampon;
435: }
436: }
437:
438: l_element_precedent = l_element_courant;
439: l_element_courant = (*l_element_courant).suivant;
440: }
441:
442: j--;
443: } while(inversion != d_faux);
444: }
445: }
446: else if (((*s_objet_liste).type == TBL) &&
447: ((*s_objet_critere).type == RPN))
448: {
449: /*
450: * Tri Shell-Metzner d'une table
451: */
452:
453: ecartement = (*((struct_tableau *) (*s_objet_liste).objet))
454: .nombre_elements;
455: terminaison_boucle_1 = d_faux;
456:
457: do
458: {
459: ecartement = ecartement / 2;
460:
461: if (ecartement >= 1)
462: {
463: indice_j = 0;
464: indice_k = (*((struct_tableau *) (*s_objet_liste).objet))
465: .nombre_elements - ecartement;
466:
467: terminaison_boucle_2 = d_faux;
468:
469: do
470: {
471: indice_i = indice_j;
472: terminaison_boucle_3 = d_faux;
473:
474: do
475: {
476: indice_l = indice_i + ecartement;
477:
478: if ((indice_i > 0) && (indice_l > 0))
479: {
480: if ((s_objet_copie = copie_objet(s_etat_processus,
481: (*((struct_tableau *) (*s_objet_liste)
482: .objet)).elements[indice_i - 1], 'P'))
483: == NULL)
484: {
485: (*s_etat_processus).erreur_systeme =
486: d_es_allocation_memoire;
487: return;
488: }
489:
490: if (empilement(s_etat_processus,
491: &((*s_etat_processus).l_base_pile),
492: s_objet_copie) == d_erreur)
493: {
494: return;
495: }
496:
497: if ((s_objet_copie = copie_objet(s_etat_processus,
498: (*((struct_tableau *) (*s_objet_liste)
499: .objet)).elements[indice_l - 1], 'P'))
500: == NULL)
501: {
502: (*s_etat_processus).erreur_systeme =
503: d_es_allocation_memoire;
504: return;
505: }
506:
507: if (empilement(s_etat_processus,
508: &((*s_etat_processus).l_base_pile),
509: s_objet_copie) == d_erreur)
510: {
511: return;
512: }
513:
514: if (evaluation(s_etat_processus, s_objet_critere,
515: 'N') == d_erreur)
516: {
517: liberation(s_etat_processus, s_objet_critere);
518: liberation(s_etat_processus, s_objet_liste);
519:
520: return;
521: }
522:
523: if (depilement(s_etat_processus,
524: &((*s_etat_processus).l_base_pile),
525: &s_objet_test) == d_erreur)
526: {
527: liberation(s_etat_processus, s_objet_critere);
528: liberation(s_etat_processus, s_objet_liste);
529:
530: (*s_etat_processus).erreur_execution =
531: d_ex_manque_argument;
532: return;
533: }
534:
535: if ((*s_objet_test).type == INT)
536: {
537: condition = ((*((integer8 *) (*s_objet_test)
538: .objet)) == 0) ? d_faux : d_vrai;
539: }
540: else if ((*s_objet_test).type == REL)
541: {
542: condition = ((*((real8 *) (*s_objet_test)
543: .objet)) == 0) ? d_faux : d_vrai;
544: }
545: else
546: {
547: liberation(s_etat_processus, s_objet_critere);
548: liberation(s_etat_processus, s_objet_liste);
549: liberation(s_etat_processus, s_objet_test);
550:
551: (*s_etat_processus).erreur_execution =
552: d_ex_erreur_type_argument;
553: return;
554: }
555:
556: liberation(s_etat_processus, s_objet_test);
557:
558: if (condition == d_faux)
559: {
560: swap((void *) (*((struct_tableau *)
561: (*s_objet_liste).objet)).elements
562: [indice_i - 1], (void *)
563: (*((struct_tableau *) (*s_objet_liste)
564: .objet)).elements[indice_l - 1],
565: sizeof(struct_objet));
566:
567: indice_i -= ecartement;
568:
569: if (indice_i < 1)
570: {
571: terminaison_boucle_3 = d_vrai;
572: }
573: }
574: else
575: {
576: terminaison_boucle_3 = d_vrai;
577: }
578: }
579: else
580: {
581: terminaison_boucle_3 = d_vrai;
582: }
583: } while(terminaison_boucle_3 == d_faux);
584:
585: indice_j++;
586:
587: if (indice_j > indice_k)
588: {
589: terminaison_boucle_2 = d_vrai;
590: }
591: } while(terminaison_boucle_2 == d_faux);
592: }
593: else
594: {
595: terminaison_boucle_1 = d_vrai;
596: }
597: } while(terminaison_boucle_1 == d_faux);
598: }
599: else
600: {
601: if (pthread_mutex_unlock(&((*(*s_etat_processus)
602: .s_liste_variables_partagees).mutex)) != 0)
603: {
604: (*s_etat_processus).erreur_systeme = d_es_processus;
605: return;
606: }
607:
608: liberation(s_etat_processus, s_objet_liste);
609: liberation(s_etat_processus, s_objet_critere);
610:
611: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
612: return;
613: }
614:
615: if (presence_nom == d_faux)
616: {
617: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
618: s_objet_liste) == d_erreur)
619: {
620: return;
621: }
622: }
623: else
624: {
625: if (variable_partagee == d_vrai)
626: {
627: (*(*s_etat_processus).s_liste_variables_partagees)
628: .table[(*(*s_etat_processus).s_liste_variables_partagees)
629: .position_variable].objet = s_objet_liste;
630:
631: if (pthread_mutex_unlock(&((*(*s_etat_processus)
632: .s_liste_variables_partagees).mutex)) != 0)
633: {
634: (*s_etat_processus).erreur_systeme = d_es_processus;
635: return;
636: }
637: }
638: }
639:
640: liberation(s_etat_processus, s_objet_critere);
641:
642: return;
643: }
644:
645:
646: /*
647: ================================================================================
648: Fonction 'save'
649: ================================================================================
650: Entrées : structure processus
651: --------------------------------------------------------------------------------
652: Sorties :
653: --------------------------------------------------------------------------------
654: Effets de bord : néant
655: ================================================================================
656: */
657:
658: void
659: instruction_save(struct_processus *s_etat_processus)
660: {
661: logical1 presence_variable;
662:
663: long i;
664:
665: struct_objet *s_objet_1;
666: struct_objet *s_objet_2;
667:
668: struct_variable s_variable;
669:
670: (*s_etat_processus).erreur_execution = d_ex;
671:
672: if ((*s_etat_processus).affichage_arguments == 'Y')
673: {
674: printf("\n SAVE ");
675:
676: if ((*s_etat_processus).langue == 'F')
677: {
678: printf("(affecte un objet à une variable globale)\n\n");
679: }
680: else
681: {
682: printf("(store an object in a global variable)\n\n");
683: }
684:
685: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
686: " %s, %s, %s, %s, %s,\n"
687: " %s, %s, %s, %s, %s,\n"
688: " %s, %s, %s, %s,\n"
689: " %s, %s\n",
690: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
691: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
692: d_SQL, d_SLB, d_PRC, d_MTX);
693: printf(" 1: %s\n", d_NOM);
694:
695: return;
696: }
697: else if ((*s_etat_processus).test_instruction == 'Y')
698: {
699: (*s_etat_processus).nombre_arguments = -1;
700: return;
701: }
702:
703: if (test_cfsf(s_etat_processus, 31) == d_vrai)
704: {
705: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
706: {
707: return;
708: }
709: }
710:
711: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
712: &s_objet_1) == d_erreur)
713: {
714: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
715: return;
716: }
717:
718: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
719: &s_objet_2) == d_erreur)
720: {
721: liberation(s_etat_processus, s_objet_1);
722:
723: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
724: return;
725: }
726:
727: if ((*s_objet_1).type != NOM)
728: {
729: liberation(s_etat_processus, s_objet_1);
730: liberation(s_etat_processus, s_objet_2);
731:
732: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
733: return;
734: }
735:
736: if (recherche_variable(s_etat_processus, (*((struct_nom *)
737: (*s_objet_1).objet)).nom) == d_vrai)
738: {
739: /*
740: * Une variable est accessible directement.
741: */
742:
743: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
744: .position_variable_courante].niveau == 1)
745: {
746: // La variable accessible directement est une variable globale.
747:
748: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
749: .position_variable_courante].variable_verrouillee == d_vrai)
750: {
751: liberation(s_etat_processus, s_objet_1);
752: liberation(s_etat_processus, s_objet_2);
753:
754: (*s_etat_processus).erreur_execution =
755: d_ex_variable_verrouillee;
756: return;
757: }
758:
759: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
760: .position_variable_courante].objet == NULL)
761: {
762: liberation(s_etat_processus, s_objet_1);
763: liberation(s_etat_processus, s_objet_2);
764:
765: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
766: return;
767: }
768:
769: liberation(s_etat_processus,
770: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
771: .position_variable_courante].objet);
772:
773: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
774: .position_variable_courante].objet = s_objet_2;
775: }
776: else
777: {
778: // On cherche une variable globale de même nom.
779:
780: i = (*s_etat_processus).position_variable_courante;
781: presence_variable = d_faux;
782:
783: while(i >= 0)
784: {
785: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
786: (*((struct_nom *) (*s_objet_1).objet)).nom) == 0) &&
787: ((*s_etat_processus).s_liste_variables[i].niveau == 1))
788: {
789: presence_variable = d_vrai;
790: break;
791: }
792:
793: i--;
794: }
795:
796: (*s_etat_processus).position_variable_courante = i;
797:
798: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
799: .position_variable_courante].niveau == 1)
800: {
801: // On a trouvé une variable globale correspondant au nom et
802: // que l'on modifie.
803:
804: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
805: .position_variable_courante].variable_verrouillee ==
806: d_vrai)
807: {
808: liberation(s_etat_processus, s_objet_1);
809: liberation(s_etat_processus, s_objet_2);
810:
811: (*s_etat_processus).erreur_execution =
812: d_ex_variable_verrouillee;
813: return;
814: }
815:
816: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
817: .position_variable_courante].objet == NULL)
818: {
819: liberation(s_etat_processus, s_objet_1);
820: liberation(s_etat_processus, s_objet_2);
821:
822: (*s_etat_processus).erreur_execution =
823: d_ex_variable_partagee;
824: return;
825: }
826:
827: liberation(s_etat_processus,
828: (*s_etat_processus).s_liste_variables
829: [(*s_etat_processus).position_variable_courante].objet);
830:
831: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
832: .position_variable_courante].objet = s_objet_2;
833: }
834: else
835: {
836: if ((s_variable.nom = malloc((strlen((*((struct_nom *)
837: (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))
838: == NULL)
839: {
840: (*s_etat_processus).erreur_systeme =
841: d_es_allocation_memoire;
842: return;
843: }
844:
845: strcpy(s_variable.nom, (*((struct_nom *)
846: (*s_objet_1).objet)).nom);
847: s_variable.niveau = 1;
848:
849: /*
850: * Le niveau 0 correspond aux définitions. Les variables
851: * commencent à 1 car elles sont toujours incluses dans
852: * une définition.
853: */
854:
855: s_variable.objet = s_objet_2;
856:
857: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
858: == d_erreur)
859: {
860: return;
861: }
862: }
863: }
864: }
865: else
866: {
867: /*
868: * Aucune variable n'est accessible (ni locale, ni globale).
869: */
870:
871: if ((s_variable.nom = malloc((strlen((*((struct_nom *)
872: (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))
873: == NULL)
874: {
875: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
876: return;
877: }
878:
879: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_1).objet)).nom);
880: s_variable.niveau = 1;
881:
882: /*
883: * Le niveau 0 correspond aux définitions. Les variables
884: * commencent à 1 car elles sont toujours incluses dans
885: * une définition.
886: */
887:
888: s_variable.objet = s_objet_2;
889:
890: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
891: == d_erreur)
892: {
893: return;
894: }
895:
896: (*s_etat_processus).erreur_systeme = d_es;
897: }
898:
899: liberation(s_etat_processus, s_objet_1);
900:
901: return;
902: }
903:
904:
905: /*
906: ================================================================================
907: Fonction 'suspend'
908: ================================================================================
909: Entrées : structure processus
910: --------------------------------------------------------------------------------
911: Sorties :
912: --------------------------------------------------------------------------------
913: Effets de bord : néant
914: ================================================================================
915: */
916:
917: void
918: instruction_suspend(struct_processus *s_etat_processus)
919: {
920: sigset_t masque;
921:
922: (*s_etat_processus).erreur_execution = d_ex;
923:
924: if ((*s_etat_processus).affichage_arguments == 'Y')
925: {
926: printf("\n SUSPEND ");
927:
928: if ((*s_etat_processus).langue == 'F')
929: {
930: printf("(attend un signal SIGCONT)\n\n");
931: printf(" Aucun argument\n");
932: }
933: else
934: {
935: printf("(wait for SIGCONT signal)\n\n");
936: printf(" No argument\n");
937: }
938:
939: return;
940: }
941: else if ((*s_etat_processus).test_instruction == 'Y')
942: {
943: (*s_etat_processus).nombre_arguments = -1;
944: return;
945: }
946:
947: if (test_cfsf(s_etat_processus, 31) == d_vrai)
948: {
949: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
950: {
951: return;
952: }
953: }
954:
955: if (sigfillset(&masque) != 0)
956: {
957: (*s_etat_processus).erreur_systeme = d_es_processus;
958: return;
959: }
960:
961: if (sigdelset(&masque, SIGCONT) != 0)
962: {
963: (*s_etat_processus).erreur_systeme = d_es_processus;
964: return;
965: }
966:
967: if (sigdelset(&masque, SIGFSTOP) != 0)
968: {
969: (*s_etat_processus).erreur_systeme = d_es_processus;
970: return;
971: }
972:
973: if (sigdelset(&masque, SIGURG) != 0)
974: {
975: (*s_etat_processus).erreur_systeme = d_es_processus;
976: return;
977: }
978:
979: if (sigdelset(&masque, SIGALRM) != 0)
980: {
981: (*s_etat_processus).erreur_systeme = d_es_processus;
982: return;
983: }
984:
985: if ((*s_etat_processus).profilage == d_vrai)
986: {
987: profilage(s_etat_processus, "Suspend");
988:
989: if ((*s_etat_processus).erreur_systeme != d_es)
990: {
991: return;
992: }
993: }
994:
995: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
996: {
997: (*s_etat_processus).erreur_systeme = d_es_processus;
998: return;
999: }
1000:
1001: sigsuspend(&masque);
1002:
1003: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1004: {
1005: if (errno != EINTR)
1006: {
1007: (*s_etat_processus).erreur_systeme = d_es_processus;
1008: return;
1009: }
1010: }
1011:
1012: if ((*s_etat_processus).profilage == d_vrai)
1013: {
1014: profilage(s_etat_processus, NULL);
1015: }
1016:
1017: return;
1018: }
1019:
1020:
1021: /*
1022: ================================================================================
1023: Fonction 'static'
1024: ================================================================================
1025: Entrées : structure processus
1026: --------------------------------------------------------------------------------
1027: Sorties :
1028: --------------------------------------------------------------------------------
1029: Effets de bord : néant
1030: ================================================================================
1031: */
1032:
1033: void
1034: instruction_static(struct_processus *s_etat_processus)
1035: {
1036: (*s_etat_processus).erreur_execution = d_ex;
1037:
1038: if ((*s_etat_processus).affichage_arguments == 'Y')
1039: {
1040: printf("\n STATIC ");
1041:
1042: if ((*s_etat_processus).langue == 'F')
1043: {
1044: printf("(déclaration de variables statiques)\n\n");
1045: printf(" Aucun argument\n");
1046: }
1047: else
1048: {
1049: printf("(static variables declaration)\n\n");
1050: printf(" No argument\n");
1051: }
1052:
1053: return;
1054: }
1055: else if ((*s_etat_processus).test_instruction == 'Y')
1056: {
1057: (*s_etat_processus).nombre_arguments = -1;
1058: return;
1059: }
1060:
1061: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1062: {
1063: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1064: {
1065: return;
1066: }
1067: }
1068:
1069: if ((*s_etat_processus).creation_variables_partagees == d_vrai)
1070: {
1071: (*s_etat_processus).erreur_execution = d_ex_variable_statique_partagee;
1072: return;
1073: }
1074:
1075: (*s_etat_processus).creation_variables_statiques = d_vrai;
1076:
1077: return;
1078: }
1079:
1080:
1081: /*
1082: ================================================================================
1083: Fonction 'shared'
1084: ================================================================================
1085: Entrées : structure processus
1086: --------------------------------------------------------------------------------
1087: Sorties :
1088: --------------------------------------------------------------------------------
1089: Effets de bord : néant
1090: ================================================================================
1091: */
1092:
1093: void
1094: instruction_shared(struct_processus *s_etat_processus)
1095: {
1096: (*s_etat_processus).erreur_execution = d_ex;
1097:
1098: if ((*s_etat_processus).affichage_arguments == 'Y')
1099: {
1100: printf("\n SHARED ");
1101:
1102: if ((*s_etat_processus).langue == 'F')
1103: {
1104: printf("(déclaration de variables partagées)\n\n");
1105: printf(" Aucun argument\n");
1106: }
1107: else
1108: {
1109: printf("(shared variables declaration)\n\n");
1110: printf(" No argument\n");
1111: }
1112:
1113: return;
1114: }
1115: else if ((*s_etat_processus).test_instruction == 'Y')
1116: {
1117: (*s_etat_processus).nombre_arguments = -1;
1118: return;
1119: }
1120:
1121: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1122: {
1123: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1124: {
1125: return;
1126: }
1127: }
1128:
1129: if ((*s_etat_processus).creation_variables_partagees == d_vrai)
1130: {
1131: (*s_etat_processus).erreur_execution = d_ex_variable_statique_partagee;
1132: return;
1133: }
1134:
1135: (*s_etat_processus).creation_variables_partagees = d_vrai;
1136:
1137: return;
1138: }
1139:
1140:
1141: /*
1142: ================================================================================
1143: Fonction 'stoswi'
1144: ================================================================================
1145: Entrées : structure processus
1146: --------------------------------------------------------------------------------
1147: Sorties :
1148: --------------------------------------------------------------------------------
1149: Effets de bord : néant
1150: ================================================================================
1151: */
1152:
1153: void
1154: instruction_stoswi(struct_processus *s_etat_processus)
1155: {
1156: integer8 interruption;
1157:
1158: struct_objet *s_objet_argument_1;
1159: struct_objet *s_objet_argument_2;
1160:
1161: (*s_etat_processus).erreur_execution = d_ex;
1162:
1163: if ((*s_etat_processus).affichage_arguments == 'Y')
1164: {
1165: printf("\n STOSWI ");
1166:
1167: if ((*s_etat_processus).langue == 'F')
1168: {
1169: printf("(définition d'une interruption logicielle)\n\n");
1170: }
1171: else
1172: {
1173: printf("(software interrupt definition)\n\n");
1174: }
1175:
1176: printf(" 2: %s, %s\n", d_NOM, d_RPN);
1177: printf(" 1: %s\n", d_INT);
1178:
1179: return;
1180: }
1181: else if ((*s_etat_processus).test_instruction == 'Y')
1182: {
1183: (*s_etat_processus).nombre_arguments = -1;
1184: return;
1185: }
1186:
1187: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1188: {
1189: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1190: {
1191: return;
1192: }
1193: }
1194:
1195: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1196: &s_objet_argument_1) == d_erreur)
1197: {
1198: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1199: return;
1200: }
1201:
1202: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1203: &s_objet_argument_2) == d_erreur)
1204: {
1205: liberation(s_etat_processus, s_objet_argument_1);
1206:
1207: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1208: return;
1209: }
1210:
1211: if ((*s_objet_argument_1).type == INT)
1212: {
1213: interruption = (*((integer8 *) (*s_objet_argument_1).objet));
1214:
1215: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
1216: {
1217: liberation(s_etat_processus, s_objet_argument_1);
1218: liberation(s_etat_processus, s_objet_argument_2);
1219:
1220: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
1221: return;
1222: }
1223:
1224: if ((*s_objet_argument_2).type == NOM)
1225: {
1226: liberation(s_etat_processus, (*s_etat_processus).corps_interruptions
1227: [interruption - 1]);
1228: (*s_etat_processus).corps_interruptions[interruption - 1] =
1229: s_objet_argument_2;
1230: }
1231: else if((*s_objet_argument_2).type == RPN)
1232: {
1233: liberation(s_etat_processus, (*s_etat_processus).corps_interruptions
1234: [interruption - 1]);
1235: (*s_etat_processus).corps_interruptions[interruption - 1] =
1236: s_objet_argument_2;
1237: }
1238: else
1239: {
1240: liberation(s_etat_processus, s_objet_argument_1);
1241: liberation(s_etat_processus, s_objet_argument_2);
1242:
1243: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1244: return;
1245: }
1246: }
1247: else
1248: {
1249: liberation(s_etat_processus, s_objet_argument_1);
1250: liberation(s_etat_processus, s_objet_argument_2);
1251:
1252: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1253: return;
1254: }
1255:
1256: liberation(s_etat_processus, s_objet_argument_1);
1257:
1258: return;
1259: }
1260:
1261:
1262: /*
1263: ================================================================================
1264: Fonction 'swi'
1265: ================================================================================
1266: Entrées : structure processus
1267: --------------------------------------------------------------------------------
1268: Sorties :
1269: --------------------------------------------------------------------------------
1270: Effets de bord : néant
1271: ================================================================================
1272: */
1273:
1274: void
1275: instruction_swi(struct_processus *s_etat_processus)
1276: {
1277: int interruption_reduite;
1278:
1279: integer8 interruption;
1280:
1281: pid_t pid;
1282:
1283: pthread_t tid;
1284:
1285: sig_atomic_t registre;
1286:
1287: ssize_t longueur_ecriture;
1288:
1289: struct_objet *s_objet_argument;
1290:
1291: struct timespec attente;
1292:
1293: unsigned char tampon;
1294:
1295: (*s_etat_processus).erreur_execution = d_ex;
1296:
1297: if ((*s_etat_processus).affichage_arguments == 'Y')
1298: {
1299: printf("\n SWI ");
1300:
1301: if ((*s_etat_processus).langue == 'F')
1302: {
1303: printf("(interruption logicielle)\n\n");
1304: }
1305: else
1306: {
1307: printf("(software interrupt)\n\n");
1308: }
1309:
1310: printf(" 1: %s\n", d_INT);
1311:
1312: return;
1313: }
1314: else if ((*s_etat_processus).test_instruction == 'Y')
1315: {
1316: (*s_etat_processus).nombre_arguments = -1;
1317: return;
1318: }
1319:
1320: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1321: {
1322: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1323: {
1324: return;
1325: }
1326: }
1327:
1328: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1329: &s_objet_argument) == d_erreur)
1330: {
1331: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1332: return;
1333: }
1334:
1335: if ((*s_objet_argument).type == INT)
1336: {
1337: interruption = (*((integer8 *) (*s_objet_argument).objet));
1338:
1339: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
1340: {
1341: liberation(s_etat_processus, s_objet_argument);
1342:
1343: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
1344: return;
1345: }
1346:
1347: if ((*s_etat_processus).presence_pipes == d_faux)
1348: {
1349: liberation(s_etat_processus, s_objet_argument);
1350:
1351: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
1352: return;
1353: }
1354:
1355: // Envoi d'un PID invalide (-1) pour ne pas bloquer le thread
1356: // de surveillance.
1357:
1358: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
1359: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
1360:
1361: if ((*s_etat_processus).processus_detache == d_vrai)
1362: {
1363: pid = -1;
1364:
1365: attente.tv_sec = 0;
1366: attente.tv_nsec = GRANULARITE_us * 1000;
1367:
1368: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1369: {
1370: (*s_etat_processus).erreur_systeme = d_es_processus;
1371: return;
1372: }
1373:
1374: while((longueur_ecriture = write_atomic(s_etat_processus,
1375: (*s_etat_processus).pipe_nombre_objets_attente,
1376: &pid, sizeof(pid))) != sizeof(pid))
1377: {
1378: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1379: {
1380: if (errno != EINTR)
1381: {
1382: (*s_etat_processus).erreur_systeme = d_es_processus;
1383: return;
1384: }
1385: }
1386:
1387: if (longueur_ecriture == -1)
1388: {
1389: if (registre == 0)
1390: {
1391: if ((*s_etat_processus)
1392: .var_volatile_traitement_retarde_stop == -1)
1393: {
1394: (*s_etat_processus).var_volatile_requete_arret = -1;
1395: }
1396:
1397: (*s_etat_processus)
1398: .var_volatile_traitement_retarde_stop
1399: = registre;
1400: }
1401:
1402: (*s_etat_processus).erreur_systeme = d_es_processus;
1403: return;
1404: }
1405:
1406: nanosleep(&attente, NULL);
1407: INCR_GRANULARITE(attente.tv_nsec);
1408:
1409: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1410: {
1411: (*s_etat_processus).erreur_systeme = d_es_processus;
1412: return;
1413: }
1414: }
1415:
1416: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1417: {
1418: if (errno != EINTR)
1419: {
1420: (*s_etat_processus).erreur_systeme = d_es_processus;
1421: return;
1422: }
1423: }
1424: }
1425: else
1426: {
1427: tid = -1;
1428:
1429: attente.tv_sec = 0;
1430: attente.tv_nsec = GRANULARITE_us * 1000;
1431:
1432: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1433: {
1434: (*s_etat_processus).erreur_systeme = d_es_processus;
1435: return;
1436: }
1437:
1438: while((longueur_ecriture = write_atomic(s_etat_processus,
1439: (*s_etat_processus).pipe_nombre_objets_attente,
1440: &tid, sizeof(tid))) != sizeof(tid))
1441: {
1442: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1443: {
1444: if (errno != EINTR)
1445: {
1446: (*s_etat_processus).erreur_systeme = d_es_processus;
1447: return;
1448: }
1449: }
1450:
1451: if (longueur_ecriture == -1)
1452: {
1453: if (registre == 0)
1454: {
1455: if ((*s_etat_processus)
1456: .var_volatile_traitement_retarde_stop == -1)
1457: {
1458: (*s_etat_processus).var_volatile_requete_arret = -1;
1459: }
1460:
1461: (*s_etat_processus)
1462: .var_volatile_traitement_retarde_stop
1463: = registre;
1464: }
1465:
1466: (*s_etat_processus).erreur_systeme = d_es_processus;
1467: return;
1468: }
1469:
1470: nanosleep(&attente, NULL);
1471: INCR_GRANULARITE(attente.tv_nsec);
1472:
1473: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1474: {
1475: (*s_etat_processus).erreur_systeme = d_es_processus;
1476: return;
1477: }
1478: }
1479:
1480: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1481: {
1482: if (errno != EINTR)
1483: {
1484: (*s_etat_processus).erreur_systeme = d_es_processus;
1485: return;
1486: }
1487: }
1488: }
1489:
1490: interruption_reduite = interruption;
1491:
1492: attente.tv_sec = 0;
1493: attente.tv_nsec = GRANULARITE_us * 1000;
1494:
1495: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1496: {
1497: (*s_etat_processus).erreur_systeme = d_es_processus;
1498: return;
1499: }
1500:
1501: while((longueur_ecriture = write_atomic(s_etat_processus,
1502: (*s_etat_processus).pipe_interruptions,
1503: &interruption_reduite, sizeof(interruption_reduite)))
1504: != sizeof(interruption_reduite))
1505: {
1506: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1507: {
1508: if (errno != EINTR)
1509: {
1510: (*s_etat_processus).erreur_systeme = d_es_processus;
1511: return;
1512: }
1513: }
1514:
1515: if (longueur_ecriture == -1)
1516: {
1517: if (registre == 0)
1518: {
1519: if ((*s_etat_processus)
1520: .var_volatile_traitement_retarde_stop == -1)
1521: {
1522: (*s_etat_processus).var_volatile_requete_arret = -1;
1523: }
1524:
1525: (*s_etat_processus)
1526: .var_volatile_traitement_retarde_stop
1527: = registre;
1528: }
1529:
1530: (*s_etat_processus).erreur_systeme = d_es_processus;
1531: return;
1532: }
1533:
1534: nanosleep(&attente, NULL);
1535: INCR_GRANULARITE(attente.tv_nsec);
1536:
1537: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1538: {
1539: (*s_etat_processus).erreur_systeme = d_es_processus;
1540: return;
1541: }
1542: }
1543:
1544: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1545: {
1546: if (errno != EINTR)
1547: {
1548: (*s_etat_processus).erreur_systeme = d_es_processus;
1549: return;
1550: }
1551: }
1552:
1553: if ((*s_etat_processus).processus_detache == d_vrai)
1554: {
1555: pid = -3;
1556:
1557: attente.tv_sec = 0;
1558: attente.tv_nsec = GRANULARITE_us * 1000;
1559:
1560: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1561: {
1562: (*s_etat_processus).erreur_systeme = d_es_processus;
1563: return;
1564: }
1565:
1566: while((longueur_ecriture = write_atomic(s_etat_processus,
1567: (*s_etat_processus).pipe_nombre_interruptions_attente,
1568: &pid, sizeof(pid))) != sizeof(pid))
1569: {
1570: while(sem_wait(&((*s_etat_processus).semaphore_fork))
1571: == -1)
1572: {
1573: (*s_etat_processus).erreur_systeme = d_es_processus;
1574: return;
1575: }
1576:
1577: if (longueur_ecriture == -1)
1578: {
1579: if (registre == 0)
1580: {
1581: if ((*s_etat_processus)
1582: .var_volatile_traitement_retarde_stop == -1)
1583: {
1584: (*s_etat_processus).var_volatile_requete_arret = -1;
1585: }
1586:
1587: (*s_etat_processus)
1588: .var_volatile_traitement_retarde_stop
1589: = registre;
1590: }
1591:
1592: (*s_etat_processus).erreur_systeme = d_es_processus;
1593: return;
1594: }
1595:
1596: nanosleep(&attente, NULL);
1597: INCR_GRANULARITE(attente.tv_nsec);
1598:
1599: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1600: {
1601: (*s_etat_processus).erreur_systeme = d_es_processus;
1602: return;
1603: }
1604: }
1605:
1606: pid = getpid();
1607:
1608: attente.tv_sec = 0;
1609: attente.tv_nsec = GRANULARITE_us * 1000;
1610:
1611: while((longueur_ecriture = write_atomic(s_etat_processus,
1612: (*s_etat_processus).pipe_nombre_interruptions_attente,
1613: &pid, sizeof(pid))) != sizeof(pid))
1614: {
1615: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1616: {
1617: if (errno != EINTR)
1618: {
1619: (*s_etat_processus).erreur_systeme = d_es_processus;
1620: return;
1621: }
1622: }
1623:
1624: if (longueur_ecriture == -1)
1625: {
1626: if (registre == 0)
1627: {
1628: if ((*s_etat_processus)
1629: .var_volatile_traitement_retarde_stop == -1)
1630: {
1631: (*s_etat_processus).var_volatile_requete_arret = -1;
1632: }
1633:
1634: (*s_etat_processus)
1635: .var_volatile_traitement_retarde_stop
1636: = registre;
1637: }
1638:
1639: (*s_etat_processus).erreur_systeme = d_es_processus;
1640: return;
1641: }
1642:
1643: nanosleep(&attente, NULL);
1644: INCR_GRANULARITE(attente.tv_nsec);
1645:
1646: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1647: {
1648: (*s_etat_processus).erreur_systeme = d_es_processus;
1649: return;
1650: }
1651: }
1652:
1653: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1654: {
1655: if (errno != EINTR)
1656: {
1657: (*s_etat_processus).erreur_systeme = d_es_processus;
1658: return;
1659: }
1660: }
1661: }
1662: else
1663: {
1664: tid = -3;
1665:
1666: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1667: {
1668: (*s_etat_processus).erreur_systeme = d_es_processus;
1669: return;
1670: }
1671:
1672: while((longueur_ecriture = write_atomic(s_etat_processus,
1673: (*s_etat_processus).pipe_nombre_interruptions_attente,
1674: &tid, sizeof(tid))) != sizeof(tid))
1675: {
1676: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1677: {
1678: if (errno != EINTR)
1679: {
1680: (*s_etat_processus).erreur_systeme = d_es_processus;
1681: return;
1682: }
1683: }
1684:
1685: if (longueur_ecriture == -1)
1686: {
1687: if (registre == 0)
1688: {
1689: if ((*s_etat_processus)
1690: .var_volatile_traitement_retarde_stop == -1)
1691: {
1692: (*s_etat_processus).var_volatile_requete_arret = -1;
1693: }
1694:
1695: (*s_etat_processus)
1696: .var_volatile_traitement_retarde_stop
1697: = registre;
1698: }
1699:
1700: (*s_etat_processus).erreur_systeme = d_es_processus;
1701: return;
1702: }
1703:
1704: nanosleep(&attente, NULL);
1705: INCR_GRANULARITE(attente.tv_nsec);
1706:
1707: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1708: {
1709: (*s_etat_processus).erreur_systeme = d_es_processus;
1710: return;
1711: }
1712: }
1713:
1714: tid = pthread_self();
1715:
1716: attente.tv_sec = 0;
1717: attente.tv_nsec = GRANULARITE_us * 1000;
1718:
1719: while((longueur_ecriture = write_atomic(s_etat_processus,
1720: (*s_etat_processus).pipe_nombre_interruptions_attente,
1721: &tid, sizeof(tid))) != sizeof(tid))
1722: {
1723: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1724: {
1725: if (errno != EINTR)
1726: {
1727: (*s_etat_processus).erreur_systeme = d_es_processus;
1728: return;
1729: }
1730: }
1731:
1732: if (longueur_ecriture == -1)
1733:
1734: {
1735: if (registre == 0)
1736: {
1737: if ((*s_etat_processus)
1738: .var_volatile_traitement_retarde_stop == -1)
1739: {
1740: (*s_etat_processus).var_volatile_requete_arret = -1;
1741: }
1742:
1743: (*s_etat_processus)
1744: .var_volatile_traitement_retarde_stop
1745: = registre;
1746: }
1747:
1748: (*s_etat_processus).erreur_systeme = d_es_processus;
1749: return;
1750: }
1751:
1752: nanosleep(&attente, NULL);
1753: INCR_GRANULARITE(attente.tv_nsec);
1754:
1755: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1756: {
1757: (*s_etat_processus).erreur_systeme = d_es_processus;
1758: return;
1759: }
1760: }
1761:
1762: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1763: {
1764: if (errno != EINTR)
1765: {
1766: (*s_etat_processus).erreur_systeme = d_es_processus;
1767: return;
1768: }
1769: }
1770: }
1771:
1772: attente.tv_sec = 0;
1773: attente.tv_nsec = GRANULARITE_us * 1000;
1774:
1775: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1776: {
1777: (*s_etat_processus).erreur_systeme = d_es_processus;
1778: return;
1779: }
1780:
1781: while(read_atomic(s_etat_processus,
1782: (*s_etat_processus).pipe_acquittement,
1783: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
1784: {
1785: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1786: {
1787: if (errno != EINTR)
1788: {
1789: (*s_etat_processus).erreur_systeme = d_es_processus;
1790: return;
1791: }
1792: }
1793:
1794: nanosleep(&attente, NULL);
1795: INCR_GRANULARITE(attente.tv_nsec);
1796:
1797: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1798: {
1799: (*s_etat_processus).erreur_systeme = d_es_processus;
1800: return;
1801: }
1802: }
1803:
1804: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
1805: {
1806: if (errno != EINTR)
1807: {
1808: (*s_etat_processus).erreur_systeme = d_es_processus;
1809: return;
1810: }
1811: }
1812:
1813: if (registre == 0)
1814: {
1815: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
1816: {
1817: (*s_etat_processus).var_volatile_requete_arret = -1;
1818: }
1819:
1820: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
1821: }
1822: }
1823: else
1824: {
1825: liberation(s_etat_processus, s_objet_argument);
1826:
1827: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1828: return;
1829: }
1830:
1831: liberation(s_etat_processus, s_objet_argument);
1832:
1833: return;
1834: }
1835:
1836:
1837: /*
1838: ================================================================================
1839: Fonction 'swilock'
1840: ================================================================================
1841: Entrées : structure processus
1842: --------------------------------------------------------------------------------
1843: Sorties :
1844: --------------------------------------------------------------------------------
1845: Effets de bord : néant
1846: ================================================================================
1847: */
1848:
1849: void
1850: instruction_swilock(struct_processus *s_etat_processus)
1851: {
1852: integer8 interruption;
1853:
1854: struct_liste_chainee *l_element_courant;
1855:
1856: struct_objet *s_objet_argument;
1857:
1858: (*s_etat_processus).erreur_execution = d_ex;
1859:
1860: if ((*s_etat_processus).affichage_arguments == 'Y')
1861: {
1862: printf("\n SWILOCK ");
1863:
1864: if ((*s_etat_processus).langue == 'F')
1865: {
1866: printf("(verrouillage des interruptions logicielles)\n\n");
1867: }
1868: else
1869: {
1870: printf("(software interrupt lock)\n\n");
1871: }
1872:
1873: printf(" 1: %s, %s\n", d_INT, d_LST);
1874:
1875: return;
1876: }
1877: else if ((*s_etat_processus).test_instruction == 'Y')
1878: {
1879: (*s_etat_processus).nombre_arguments = -1;
1880: return;
1881: }
1882:
1883: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1884: {
1885: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1886: {
1887: return;
1888: }
1889: }
1890:
1891: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1892: &s_objet_argument) == d_erreur)
1893: {
1894: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1895: return;
1896: }
1897:
1898: if ((*s_objet_argument).type == INT)
1899: {
1900: interruption = (*((integer8 *) (*s_objet_argument).objet));
1901:
1902: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
1903: {
1904: liberation(s_etat_processus, s_objet_argument);
1905:
1906: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
1907: return;
1908: }
1909:
1910: (*s_etat_processus).masque_interruptions[interruption - 1] = 'I';
1911: }
1912: else if ((*s_objet_argument).type == LST)
1913: {
1914: l_element_courant = (*s_objet_argument).objet;
1915:
1916: while(l_element_courant)
1917: {
1918: if ((*(*l_element_courant).donnee).type != INT)
1919: {
1920: liberation(s_etat_processus, s_objet_argument);
1921:
1922: (*s_etat_processus).erreur_execution =
1923: d_ex_erreur_type_argument;
1924: return;
1925: }
1926:
1927: interruption = (*((integer8 *) (*(*l_element_courant)
1928: .donnee).objet));
1929:
1930: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
1931: {
1932: liberation(s_etat_processus, s_objet_argument);
1933:
1934: (*s_etat_processus).erreur_execution =
1935: d_ex_interruption_invalide;
1936: return;
1937: }
1938:
1939: (*s_etat_processus).masque_interruptions[interruption - 1] = 'I';
1940: l_element_courant = (*l_element_courant).suivant;
1941: }
1942: }
1943: else
1944: {
1945: liberation(s_etat_processus, s_objet_argument);
1946:
1947: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1948: return;
1949: }
1950:
1951: liberation(s_etat_processus, s_objet_argument);
1952:
1953: return;
1954: }
1955:
1956:
1957: /*
1958: ================================================================================
1959: Fonction 'swistatus'
1960: ================================================================================
1961: Entrées : structure processus
1962: --------------------------------------------------------------------------------
1963: Sorties :
1964: --------------------------------------------------------------------------------
1965: Effets de bord : néant
1966: ================================================================================
1967: */
1968:
1969: void
1970: instruction_swistatus(struct_processus *s_etat_processus)
1971: {
1972: int i;
1973:
1974: struct_liste_chainee *l_element_courant;
1975: struct_liste_chainee *l_element_futur;
1976: struct_liste_chainee *l_element_liste;
1977:
1978: struct_objet *s_objet_resultat;
1979:
1980: (*s_etat_processus).erreur_execution = d_ex;
1981:
1982: if ((*s_etat_processus).affichage_arguments == 'Y')
1983: {
1984: printf("\n SWISTATUS ");
1985:
1986: if ((*s_etat_processus).langue == 'F')
1987: {
1988: printf("(état des interruptions logicielles)\n\n");
1989: }
1990: else
1991: {
1992: printf("(software interrupts status)\n\n");
1993: }
1994:
1995: printf("-> 1: %s\n\n", d_LST);
1996:
1997: if ((*s_etat_processus).langue == 'F')
1998: {
1999: printf(" Utilisation :\n\n");
2000: }
2001: else
2002: {
2003: printf(" Usage:\n\n");
2004: }
2005:
2006: printf(" { { initialized interrupts }\n"
2007: " { unlocked interrupts }\n"
2008: " { queued interrupts }\n"
2009: " { locked interrupts } }\n");
2010: return;
2011: }
2012: else if ((*s_etat_processus).test_instruction == 'Y')
2013: {
2014: (*s_etat_processus).nombre_arguments = -1;
2015: return;
2016: }
2017:
2018: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2019: {
2020: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
2021: {
2022: return;
2023: }
2024: }
2025:
2026: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
2027: {
2028: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2029: return;
2030: }
2031:
2032: if (((*s_objet_resultat).objet =
2033: allocation_maillon(s_etat_processus)) == NULL)
2034: {
2035: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2036: return;
2037: }
2038:
2039: l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet;
2040:
2041: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
2042: == NULL)
2043: {
2044: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2045: return;
2046: }
2047:
2048: l_element_liste = NULL;
2049: l_element_futur = NULL;
2050:
2051: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
2052: {
2053: if ((*s_etat_processus).corps_interruptions[i] != NULL)
2054: {
2055: if (l_element_liste == NULL)
2056: {
2057: if ((l_element_liste =
2058: allocation_maillon(s_etat_processus)) == NULL)
2059: {
2060: (*s_etat_processus).erreur_systeme =
2061: d_es_allocation_memoire;
2062: return;
2063: }
2064:
2065: l_element_futur = l_element_liste;
2066: }
2067: else
2068: {
2069: if (((*l_element_liste).suivant =
2070: allocation_maillon(s_etat_processus)) == NULL)
2071: {
2072: (*s_etat_processus).erreur_systeme =
2073: d_es_allocation_memoire;
2074: return;
2075: }
2076:
2077: l_element_liste = (*l_element_liste).suivant;
2078: }
2079:
2080: (*l_element_liste).suivant = NULL;
2081:
2082: if (((*l_element_liste).donnee = allocation(s_etat_processus,
2083: INT)) == NULL)
2084: {
2085: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2086: return;
2087: }
2088:
2089: (*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
2090: }
2091: }
2092:
2093: (*(*l_element_courant).donnee).objet = l_element_futur;
2094:
2095: if (((*l_element_courant).suivant =
2096: allocation_maillon(s_etat_processus)) == NULL)
2097: {
2098: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2099: return;
2100: }
2101:
2102: l_element_courant = (*l_element_courant).suivant;
2103:
2104: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
2105: == NULL)
2106: {
2107: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2108: return;
2109: }
2110:
2111: l_element_liste = NULL;
2112: l_element_futur = NULL;
2113:
2114: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
2115: {
2116: if ((*s_etat_processus).masque_interruptions[i] == 'N')
2117: {
2118: if (l_element_liste == NULL)
2119: {
2120: if ((l_element_liste =
2121: allocation_maillon(s_etat_processus)) == NULL)
2122: {
2123: (*s_etat_processus).erreur_systeme =
2124: d_es_allocation_memoire;
2125: return;
2126: }
2127:
2128: l_element_futur = l_element_liste;
2129: }
2130: else
2131: {
2132: if (((*l_element_liste).suivant =
2133: allocation_maillon(s_etat_processus)) == NULL)
2134: {
2135: (*s_etat_processus).erreur_systeme =
2136: d_es_allocation_memoire;
2137: return;
2138: }
2139:
2140: l_element_liste = (*l_element_liste).suivant;
2141: }
2142:
2143: (*l_element_liste).suivant = NULL;
2144:
2145: if (((*l_element_liste).donnee = allocation(s_etat_processus,
2146: INT)) == NULL)
2147: {
2148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2149: return;
2150: }
2151:
2152: (*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
2153: }
2154: }
2155:
2156: (*(*l_element_courant).donnee).objet = l_element_futur;
2157:
2158: if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus))
2159: == NULL)
2160: {
2161: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2162: return;
2163: }
2164:
2165: l_element_courant = (*l_element_courant).suivant;
2166:
2167: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
2168: == NULL)
2169: {
2170: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2171: return;
2172: }
2173:
2174: l_element_liste = NULL;
2175: l_element_futur = NULL;
2176:
2177: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
2178: {
2179: if ((*s_etat_processus).masque_interruptions[i] == 'Q')
2180: {
2181: if (l_element_liste == NULL)
2182: {
2183: if ((l_element_liste =
2184: allocation_maillon(s_etat_processus)) == NULL)
2185: {
2186: (*s_etat_processus).erreur_systeme =
2187: d_es_allocation_memoire;
2188: return;
2189: }
2190:
2191: l_element_futur = l_element_liste;
2192: }
2193: else
2194: {
2195: if (((*l_element_liste).suivant =
2196: allocation_maillon(s_etat_processus)) == NULL)
2197: {
2198: (*s_etat_processus).erreur_systeme =
2199: d_es_allocation_memoire;
2200: return;
2201: }
2202:
2203: l_element_liste = (*l_element_liste).suivant;
2204: }
2205:
2206: (*l_element_liste).suivant = NULL;
2207:
2208: if (((*l_element_liste).donnee = allocation(s_etat_processus,
2209: INT)) == NULL)
2210: {
2211: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2212: return;
2213: }
2214:
2215: (*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
2216: }
2217: }
2218:
2219: (*(*l_element_courant).donnee).objet = l_element_futur;
2220:
2221: if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus))
2222: == NULL)
2223: {
2224: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2225: return;
2226: }
2227:
2228: l_element_courant = (*l_element_courant).suivant;
2229:
2230: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
2231: == NULL)
2232: {
2233: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2234: return;
2235: }
2236:
2237: l_element_liste = NULL;
2238: l_element_futur = NULL;
2239:
2240: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
2241: {
2242: if ((*s_etat_processus).masque_interruptions[i] == 'I')
2243: {
2244: if (l_element_liste == NULL)
2245: {
2246: if ((l_element_liste =
2247: allocation_maillon(s_etat_processus)) == NULL)
2248: {
2249: (*s_etat_processus).erreur_systeme =
2250: d_es_allocation_memoire;
2251: return;
2252: }
2253:
2254: l_element_futur = l_element_liste;
2255: }
2256: else
2257: {
2258: if (((*l_element_liste).suivant =
2259: allocation_maillon(s_etat_processus)) == NULL)
2260: {
2261: (*s_etat_processus).erreur_systeme =
2262: d_es_allocation_memoire;
2263: return;
2264: }
2265:
2266: l_element_liste = (*l_element_liste).suivant;
2267: }
2268:
2269: (*l_element_liste).suivant = NULL;
2270:
2271: if (((*l_element_liste).donnee = allocation(s_etat_processus,
2272: INT)) == NULL)
2273: {
2274: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2275: return;
2276: }
2277:
2278: (*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
2279: }
2280: }
2281:
2282: (*(*l_element_courant).donnee).objet = l_element_futur;
2283:
2284: (*l_element_courant).suivant = NULL;
2285:
2286: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2287: s_objet_resultat) == d_erreur)
2288: {
2289: return;
2290: }
2291:
2292: return;
2293: }
2294:
2295:
2296: /*
2297: ================================================================================
2298: Fonction 'swiunlock'
2299: ================================================================================
2300: Entrées : structure processus
2301: --------------------------------------------------------------------------------
2302: Sorties :
2303: --------------------------------------------------------------------------------
2304: Effets de bord : néant
2305: ================================================================================
2306: */
2307:
2308: void
2309: instruction_swiunlock(struct_processus *s_etat_processus)
2310: {
2311: integer8 interruption;
2312:
2313: struct_liste_chainee *l_element_courant;
2314:
2315: struct_objet *s_objet_argument;
2316:
2317: (*s_etat_processus).erreur_execution = d_ex;
2318:
2319: if ((*s_etat_processus).affichage_arguments == 'Y')
2320: {
2321: printf("\n SWIUNLOCK ");
2322:
2323: if ((*s_etat_processus).langue == 'F')
2324: {
2325: printf("(déverrouillage des interruptions logicielles)\n\n");
2326: }
2327: else
2328: {
2329: printf("(software interrupt unlock)\n\n");
2330: }
2331:
2332: printf(" 1: %s, %s\n", d_INT, d_LST);
2333:
2334: return;
2335: }
2336: else if ((*s_etat_processus).test_instruction == 'Y')
2337: {
2338: (*s_etat_processus).nombre_arguments = -1;
2339: return;
2340: }
2341:
2342: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2343: {
2344: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2345: {
2346: return;
2347: }
2348: }
2349:
2350: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2351: &s_objet_argument) == d_erreur)
2352: {
2353: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2354: return;
2355: }
2356:
2357: if ((*s_objet_argument).type == INT)
2358: {
2359: interruption = (*((integer8 *) (*s_objet_argument).objet));
2360:
2361: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
2362: {
2363: liberation(s_etat_processus, s_objet_argument);
2364:
2365: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
2366: return;
2367: }
2368:
2369: (*s_etat_processus).masque_interruptions[interruption - 1] = 'N';
2370: }
2371: else if ((*s_objet_argument).type == LST)
2372: {
2373: l_element_courant = (*s_objet_argument).objet;
2374:
2375: while(l_element_courant)
2376: {
2377: if ((*(*l_element_courant).donnee).type != INT)
2378: {
2379: liberation(s_etat_processus, s_objet_argument);
2380:
2381: (*s_etat_processus).erreur_execution =
2382: d_ex_erreur_type_argument;
2383: return;
2384: }
2385:
2386: interruption = (*((integer8 *) (*(*l_element_courant)
2387: .donnee).objet));
2388:
2389: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
2390: {
2391: liberation(s_etat_processus, s_objet_argument);
2392:
2393: (*s_etat_processus).erreur_execution =
2394: d_ex_interruption_invalide;
2395: return;
2396: }
2397:
2398: (*s_etat_processus).masque_interruptions[interruption - 1] = 'N';
2399: l_element_courant = (*l_element_courant).suivant;
2400: }
2401: }
2402: else
2403: {
2404: liberation(s_etat_processus, s_objet_argument);
2405:
2406: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2407: return;
2408: }
2409:
2410: liberation(s_etat_processus, s_objet_argument);
2411:
2412: return;
2413: }
2414:
2415:
2416: /*
2417: ================================================================================
2418: Fonction 'swiqueue'
2419: ================================================================================
2420: Entrées : structure processus
2421: --------------------------------------------------------------------------------
2422: Sorties :
2423: --------------------------------------------------------------------------------
2424: Effets de bord : néant
2425: ================================================================================
2426: */
2427:
2428: void
2429: instruction_swiqueue(struct_processus *s_etat_processus)
2430: {
2431: integer8 interruption;
2432:
2433: struct_liste_chainee *l_element_courant;
2434:
2435: struct_objet *s_objet_argument;
2436:
2437: (*s_etat_processus).erreur_execution = d_ex;
2438:
2439: if ((*s_etat_processus).affichage_arguments == 'Y')
2440: {
2441: printf("\n SWIQUEUE ");
2442:
2443: if ((*s_etat_processus).langue == 'F')
2444: {
2445: printf("(enregistre des interruptions logicielles)\n\n");
2446: }
2447: else
2448: {
2449: printf("(software interrupt record)\n\n");
2450: }
2451:
2452: printf(" 1: %s, %s\n", d_INT, d_LST);
2453:
2454: return;
2455: }
2456: else if ((*s_etat_processus).test_instruction == 'Y')
2457: {
2458: (*s_etat_processus).nombre_arguments = -1;
2459: return;
2460: }
2461:
2462: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2463: {
2464: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2465: {
2466: return;
2467: }
2468: }
2469:
2470: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2471: &s_objet_argument) == d_erreur)
2472: {
2473: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2474: return;
2475: }
2476:
2477: if ((*s_objet_argument).type == INT)
2478: {
2479: interruption = (*((integer8 *) (*s_objet_argument).objet));
2480:
2481: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
2482: {
2483: liberation(s_etat_processus, s_objet_argument);
2484:
2485: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
2486: return;
2487: }
2488:
2489: (*s_etat_processus).masque_interruptions[interruption - 1] = 'Q';
2490: }
2491: else if ((*s_objet_argument).type == LST)
2492: {
2493: l_element_courant = (*s_objet_argument).objet;
2494:
2495: while(l_element_courant)
2496: {
2497: if ((*(*l_element_courant).donnee).type != INT)
2498: {
2499: liberation(s_etat_processus, s_objet_argument);
2500:
2501: (*s_etat_processus).erreur_execution =
2502: d_ex_erreur_type_argument;
2503: return;
2504: }
2505:
2506: interruption = (*((integer8 *) (*(*l_element_courant)
2507: .donnee).objet));
2508:
2509: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
2510: {
2511: liberation(s_etat_processus, s_objet_argument);
2512:
2513: (*s_etat_processus).erreur_execution =
2514: d_ex_interruption_invalide;
2515: return;
2516: }
2517:
2518: (*s_etat_processus).masque_interruptions[interruption - 1] = 'Q';
2519: l_element_courant = (*l_element_courant).suivant;
2520: }
2521: }
2522: else
2523: {
2524: liberation(s_etat_processus, s_objet_argument);
2525:
2526: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2527: return;
2528: }
2529:
2530: liberation(s_etat_processus, s_objet_argument);
2531:
2532: return;
2533: }
2534:
2535:
2536: /*
2537: ================================================================================
2538: Fonction 'sched'
2539: ================================================================================
2540: Entrées : structure processus
2541: --------------------------------------------------------------------------------
2542: Sorties :
2543: --------------------------------------------------------------------------------
2544: Effets de bord : néant
2545: ================================================================================
2546: */
2547:
2548: void
2549: instruction_sched(struct_processus *s_etat_processus)
2550: {
2551: real8 pourcentage;
2552:
2553: struct_objet *s_objet_argument;
2554:
2555: (*s_etat_processus).erreur_execution = d_ex;
2556:
2557: if ((*s_etat_processus).affichage_arguments == 'Y')
2558: {
2559: printf("\n SCHED ");
2560:
2561: if ((*s_etat_processus).langue == 'F')
2562: {
2563: printf("(limitation des ressources de calcul)\n\n");
2564: }
2565: else
2566: {
2567: printf("(CPU ressources limitation)\n\n");
2568: }
2569:
2570: printf(" 1: %s, %s\n", d_INT, d_REL);
2571:
2572: return;
2573: }
2574: else if ((*s_etat_processus).test_instruction == 'Y')
2575: {
2576: (*s_etat_processus).nombre_arguments = -1;
2577: return;
2578: }
2579:
2580: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2581: {
2582: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2583: {
2584: return;
2585: }
2586: }
2587:
2588: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2589: &s_objet_argument) == d_erreur)
2590: {
2591: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2592: return;
2593: }
2594:
2595: if ((*s_objet_argument).type == INT)
2596: {
2597: pourcentage = (real8) (*((integer8 *) (*s_objet_argument).objet));
2598: }
2599: else if ((*s_objet_argument).type == REL)
2600: {
2601: pourcentage = (*((real8 *) (*s_objet_argument).objet));
2602: }
2603: else
2604: {
2605: liberation(s_etat_processus, s_objet_argument);
2606:
2607: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2608: return;
2609: }
2610:
2611: liberation(s_etat_processus, s_objet_argument);
2612:
2613: if ((pourcentage <= 0) || (pourcentage > 100))
2614: {
2615: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
2616: return;
2617: }
2618:
2619: (*s_etat_processus).pourcentage_maximal_cpu = pourcentage;
2620:
2621: return;
2622: }
2623:
2624: // vim: ts=4