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