1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.12
4: Copyright (C) 1989-2012 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: static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
26:
27:
28: /*
29: ================================================================================
30: Procédure de chargement d'une bibliothèque dynamique
31: ================================================================================
32: Entrée :
33: --------------------------------------------------------------------------------
34: Sortie :
35: --------------------------------------------------------------------------------
36: Effets de bord : néant
37: ================================================================================
38: */
39:
40: void *
41: chargement_bibliotheque(struct_processus *s_etat_processus,
42: unsigned char *bibliotheque)
43: {
44: char **(*fonction)(unsigned long *, const char *);
45: char *message;
46:
47: long i;
48: long nombre_symboles;
49:
50: struct_rpl_arguments rpl_arguments;
51:
52: struct_liste_chainee *l_element_courant;
53: struct_liste_chainee *l_nouvel_element;
54:
55: unsigned char **tableau;
56: unsigned char *tampon;
57:
58: void *descripteur_bibliotheque;
59: void (*onloading)(struct_rpl_arguments *);
60:
61: /*
62: * On vérifie que la bibliothèque n'est pas déjà chargée.
63: */
64:
65: l_element_courant = (*s_etat_processus).s_bibliotheques;
66:
67: while(l_element_courant != NULL)
68: {
69: if (strcmp((*((struct_bibliotheque *) (*l_element_courant).donnee)).nom,
70: bibliotheque) == 0)
71: {
72: (*s_etat_processus).erreur_execution = d_ex_bibliotheque_chargee;
73: return(NULL);
74: }
75:
76: l_element_courant = (*l_element_courant).suivant;
77: }
78:
79: /*
80: * Ouverture de la bibliothèque
81: */
82:
83: if ((descripteur_bibliotheque = dlopen(bibliotheque,
84: RTLD_NOW | RTLD_LOCAL)) == NULL)
85: {
86: if (pthread_mutex_lock(&mutex) != 0)
87: {
88: (*s_etat_processus).erreur_systeme = d_es_processus;
89: return(NULL);
90: }
91:
92: printf("%s\n", dlerror());
93:
94: if (pthread_mutex_unlock(&mutex) != 0)
95: {
96: (*s_etat_processus).erreur_systeme = d_es_processus;
97: return(NULL);
98: }
99:
100: (*s_etat_processus).erreur_execution = d_ex_erreur_bibliotheque;
101: return(NULL);
102: }
103:
104: if (pthread_mutex_lock(&mutex) != 0)
105: {
106: (*s_etat_processus).erreur_systeme = d_es_processus;
107: return(NULL);
108: }
109:
110: dlerror();
111: onloading = dlsym(descripteur_bibliotheque, "__runOnLoading");
112:
113: if (((message = dlerror()) == NULL) && (onloading != NULL))
114: {
115: if (pthread_mutex_unlock(&mutex) != 0)
116: {
117: (*s_etat_processus).erreur_systeme = d_es_processus;
118: return(NULL);
119: }
120:
121: rpl_arguments.l_base_pile = (*s_etat_processus).l_base_pile;
122: rpl_arguments.l_base_pile_last = (*s_etat_processus).l_base_pile_last;
123:
124: for(i = 0; i < 8; i++)
125: {
126: rpl_arguments.drapeaux_etat[i] =
127: (*s_etat_processus).drapeaux_etat[i];
128: }
129:
130: rpl_arguments.message_erreur = NULL;
131: rpl_arguments.type_erreur = 'E';
132: rpl_arguments.erreur = 0;
133: rpl_arguments.aide = ((*s_etat_processus).affichage_arguments
134: == 'N') ? d_faux : d_vrai;
135: rpl_arguments.affichage_arguments = (*s_etat_processus)
136: .affichage_arguments;
137: rpl_arguments.test_instruction = (*s_etat_processus).test_instruction;
138: rpl_arguments.constante_symbolique = (*s_etat_processus)
139: .constante_symbolique;
140: rpl_arguments.instruction_valide = 'N';
141: rpl_arguments.s_etat_processus = s_etat_processus;
142:
143: (*s_etat_processus).erreur_execution = d_ex;
144:
145: if ((*s_etat_processus).profilage == d_vrai)
146: {
147: if ((tampon = malloc((strlen(bibliotheque) + 14) *
148: sizeof(unsigned char))) == NULL)
149: {
150: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
151: return(NULL);
152: }
153:
154: sprintf(tampon, "%s$runOnLoading", bibliotheque);
155: profilage(s_etat_processus, tampon);
156: free(tampon);
157:
158: if ((*s_etat_processus).erreur_systeme != d_es)
159: {
160: return(NULL);
161: }
162: }
163:
164: # ifndef SEMAPHORES_NOMMES
165: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
166: # else
167: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
168: # endif
169: {
170: (*s_etat_processus).erreur_systeme = d_es_processus;
171: return(NULL);
172: }
173:
174: (*onloading)(&rpl_arguments);
175:
176: # ifndef SEMAPHORES_NOMMES
177: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
178: # else
179: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
180: # endif
181: {
182: if (errno != EINTR)
183: {
184: (*s_etat_processus).erreur_systeme = d_es_processus;
185: return(NULL);
186: }
187: }
188:
189: if ((*s_etat_processus).profilage == d_vrai)
190: {
191: profilage(s_etat_processus, NULL);
192: }
193:
194: (*s_etat_processus).nombre_arguments = rpl_arguments.nombre_arguments;
195: (*s_etat_processus).constante_symbolique = rpl_arguments
196: .constante_symbolique;
197: (*s_etat_processus).instruction_valide = rpl_arguments
198: .instruction_valide;
199:
200: if ((*s_etat_processus).test_instruction == 'Y')
201: {
202: if ((*s_etat_processus).nombre_arguments == 0)
203: {
204: (*s_etat_processus).nombre_arguments = -1;
205: }
206: }
207:
208: if (rpl_arguments.erreur != 0)
209: {
210: if (((*s_etat_processus).arret_si_exception == d_vrai) ||
211: (rpl_arguments.type_erreur == 'S'))
212: {
213: if (test_cfsf(s_etat_processus, 51) == d_faux)
214: {
215: printf("%s", ds_beep);
216: }
217:
218: if (rpl_arguments.type_erreur == 'S')
219: {
220: (*s_etat_processus).derniere_erreur_execution = -1;
221:
222: if ((*s_etat_processus).langue == 'F')
223: {
224: printf("+++Système : Fonction dynamique %s "
225: "(ligne %lld)\n",
226: "onLoading", rpl_arguments.erreur);
227: }
228: else
229: {
230: printf("+++System : %s dynamic function (line %lld)\n",
231: "onLoading", rpl_arguments.erreur);
232: }
233: }
234: else
235: {
236: (*s_etat_processus).derniere_erreur_systeme = -1;
237:
238: if ((*s_etat_processus).langue == 'F')
239: {
240: printf("+++Erreur : Fonction dynamique %s "
241: "(ligne %lld)\n",
242: "onLoading" , rpl_arguments.erreur);
243: }
244: else
245: {
246: printf("+++Error : %s dynamic function (line %lld)\n",
247: "onLoading", rpl_arguments.erreur);
248: }
249: }
250:
251: if (rpl_arguments.message_erreur != NULL)
252: {
253: printf("%s\n", rpl_arguments.message_erreur);
254: }
255:
256: fflush(stdout);
257: }
258:
259: if (rpl_arguments.type_erreur == 'S')
260: {
261: (*s_etat_processus).erreur_systeme =
262: d_es_execution_bibliotheque;
263: }
264: else
265: {
266: (*s_etat_processus).erreur_execution =
267: d_ex_execution_bibliotheque;
268: }
269: }
270:
271: (*s_etat_processus).l_base_pile = rpl_arguments.l_base_pile;
272: (*s_etat_processus).l_base_pile_last = rpl_arguments.l_base_pile_last;
273:
274: for(i = 0; i < 8; i++)
275: {
276: (*s_etat_processus).drapeaux_etat[i] =
277: rpl_arguments.drapeaux_etat[i];
278: }
279:
280: l_element_courant = (*s_etat_processus).l_base_pile;
281: (*s_etat_processus).hauteur_pile_operationnelle = 0;
282:
283: while(l_element_courant != NULL)
284: {
285: (*s_etat_processus).hauteur_pile_operationnelle++;
286: l_element_courant = (*l_element_courant).suivant;
287: }
288: }
289: else
290: {
291: printf("%s\n", message);
292:
293: if (pthread_mutex_unlock(&mutex) != 0)
294: {
295: (*s_etat_processus).erreur_systeme = d_es_processus;
296: return(NULL);
297: }
298: }
299:
300: if (pthread_mutex_lock(&mutex) != 0)
301: {
302: (*s_etat_processus).erreur_systeme = d_es_processus;
303: return(NULL);
304: }
305:
306: dlerror();
307: fonction = dlsym(descripteur_bibliotheque, "__external_symbols");
308:
309: if (fonction == NULL)
310: {
311: if ((message = dlerror()) != NULL)
312: {
313: printf("%s\n", message);
314:
315: if (pthread_mutex_unlock(&mutex) != 0)
316: {
317: (*s_etat_processus).erreur_systeme = d_es_processus;
318: return(NULL);
319: }
320:
321: (*s_etat_processus).erreur_execution = d_ex_erreur_bibliotheque;
322: return(NULL);
323: }
324: }
325:
326: dlerror();
327:
328: if (pthread_mutex_unlock(&mutex) != 0)
329: {
330: (*s_etat_processus).erreur_systeme = d_es_processus;
331: return(NULL);
332: }
333:
334: /*
335: * Ajout des symboles externes
336: */
337:
338: if ((tableau = (unsigned char **) (*fonction)((&nombre_symboles),
339: d_version_rpl)) == NULL)
340: {
341: /*
342: * Nombre symboles :
343: * 0 : aucun symbole exporté
344: * >0 : nombre de symboles exportés
345: * -1 : version de bibliothèque incompatible
346: */
347:
348: if (nombre_symboles == 0)
349: {
350: (*s_etat_processus).erreur_execution = d_ex_aucun_symbole;
351: }
352: else if (nombre_symboles == -1)
353: {
354: (*s_etat_processus).erreur_execution = d_ex_version_bibliotheque;
355: }
356: else
357: {
358: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
359: }
360:
361: return(NULL);
362: }
363:
364: if (((*s_etat_processus).s_instructions_externes = realloc(
365: (*s_etat_processus).s_instructions_externes,
366: ((*s_etat_processus).nombre_instructions_externes + nombre_symboles)
367: * sizeof(struct_instruction_externe))) == NULL)
368: {
369: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
370: return(NULL);
371: }
372:
373: for(i = 0; i < nombre_symboles; i++)
374: {
375: (*s_etat_processus).s_instructions_externes[(*s_etat_processus)
376: .nombre_instructions_externes].descripteur_bibliotheque =
377: descripteur_bibliotheque;
378:
379: if (((*s_etat_processus).s_instructions_externes[(*s_etat_processus)
380: .nombre_instructions_externes].nom =
381: malloc((strlen(index(tableau[i], '$') + 1) + 1) *
382: sizeof(unsigned char))) == NULL)
383: {
384: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
385: return(NULL);
386: }
387:
388: strcpy((*s_etat_processus).s_instructions_externes[(*s_etat_processus)
389: .nombre_instructions_externes].nom,
390: index(tableau[i], '$') + 1);
391:
392: *(index(tableau[i], '$')) = d_code_fin_chaine;
393:
394: if (((*s_etat_processus).s_instructions_externes[(*s_etat_processus)
395: .nombre_instructions_externes].nom_bibliotheque = malloc(
396: (strlen(tableau[i]) + 1) * sizeof(unsigned char))) == NULL)
397: {
398: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
399: return(NULL);
400: }
401:
402: strcpy((*s_etat_processus).s_instructions_externes[(*s_etat_processus)
403: .nombre_instructions_externes].nom_bibliotheque, tableau[i]);
404: (*s_etat_processus).nombre_instructions_externes++;
405:
406: free(tableau[i]);
407: }
408:
409: /*
410: * Ajout de la nouvelle bibliothèque
411: */
412:
413: if ((l_nouvel_element = (struct_liste_chainee *)
414: malloc(sizeof(struct_liste_chainee))) == NULL)
415: {
416: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
417: return(NULL);
418: }
419:
420: if (((*l_nouvel_element).donnee = malloc(sizeof(struct_bibliotheque)))
421: == NULL)
422: {
423: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
424: return(NULL);
425: }
426:
427: (*((struct_bibliotheque *) (*l_nouvel_element).donnee)).descripteur =
428: descripteur_bibliotheque;
429: (*((struct_bibliotheque *) (*l_nouvel_element).donnee)).pid =
430: getpid();
431: (*((struct_bibliotheque *) (*l_nouvel_element).donnee)).tid =
432: pthread_self();
433:
434: if (((*((struct_bibliotheque *) (*l_nouvel_element).donnee)).nom =
435: malloc((strlen((*s_etat_processus).s_instructions_externes
436: [(*s_etat_processus).nombre_instructions_externes - 1]
437: .nom_bibliotheque) + 1) * sizeof(unsigned char))) == NULL)
438: {
439: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
440: return(NULL);
441: }
442:
443: strcpy((*((struct_bibliotheque *) (*l_nouvel_element).donnee)).nom,
444: (*s_etat_processus).s_instructions_externes
445: [(*s_etat_processus).nombre_instructions_externes - 1]
446: .nom_bibliotheque);
447:
448: (*l_nouvel_element).suivant = (*s_etat_processus).s_bibliotheques;
449: (*s_etat_processus).s_bibliotheques = l_nouvel_element;
450:
451: tri_base_symboles_externes(s_etat_processus);
452:
453: free(tableau);
454:
455: return(descripteur_bibliotheque);
456: }
457:
458:
459: /*
460: ================================================================================
461: Procédure de retrait d'une bibliothèque dynamique
462: ================================================================================
463: Entrée :
464: --------------------------------------------------------------------------------
465: Sortie :
466: --------------------------------------------------------------------------------
467: Effets de bord : néant
468: ================================================================================
469: */
470:
471: logical1
472: retrait_bibliotheque(struct_processus *s_etat_processus,
473: struct_bibliotheque *descripteur)
474: {
475: char *message;
476:
477: logical1 presence_bibliotheque;
478:
479: struct_instruction_externe *registre;
480:
481: struct_liste_chainee *l_element_courant;
482: struct_liste_chainee *l_element_precedent;
483:
484: struct_rpl_arguments rpl_arguments;
485:
486: unsigned char *tampon;
487:
488: unsigned long i;
489: unsigned long j;
490: unsigned long nombre_symboles_residuels;
491:
492: void (*onclosing)(struct_rpl_arguments *);
493:
494: l_element_courant = (*s_etat_processus).s_bibliotheques;
495: presence_bibliotheque = d_faux;
496: l_element_precedent = NULL;
497:
498: /*
499: * Recherche de la bibliothèque à supprimer
500: */
501:
502: while(l_element_courant != NULL)
503: {
504: if (((*((struct_bibliotheque *) (*l_element_courant).donnee))
505: .descripteur == (*descripteur).descripteur) &&
506: ((*((struct_bibliotheque *) (*l_element_courant).donnee)).pid
507: == getpid()) && (pthread_equal((*((struct_bibliotheque *)
508: (*l_element_courant).donnee)).tid, pthread_self()) != 0))
509: {
510: presence_bibliotheque = d_vrai;
511: break;
512: }
513:
514: l_element_precedent = l_element_courant;
515: l_element_courant = (*l_element_courant).suivant;
516: }
517:
518: if (presence_bibliotheque == d_vrai)
519: {
520: if (pthread_mutex_lock(&mutex) != 0)
521: {
522: (*s_etat_processus).erreur_systeme = d_es_processus;
523: return(d_erreur);
524: }
525:
526: dlerror();
527: onclosing = dlsym((*descripteur).descripteur, "__runOnClosing");
528:
529: if (((message = dlerror()) == NULL) && (onclosing != NULL))
530: {
531: if (pthread_mutex_unlock(&mutex) != 0)
532: {
533: (*s_etat_processus).erreur_systeme = d_es_processus;
534: return(d_erreur);
535: }
536:
537: rpl_arguments.l_base_pile = (*s_etat_processus).l_base_pile;
538: rpl_arguments.l_base_pile_last =
539: (*s_etat_processus).l_base_pile_last;
540:
541: for(i = 0; i < 8; i++)
542: {
543: rpl_arguments.drapeaux_etat[i] =
544: (*s_etat_processus).drapeaux_etat[i];
545: }
546:
547: rpl_arguments.message_erreur = NULL;
548: rpl_arguments.type_erreur = 'E';
549: rpl_arguments.erreur = 0;
550: rpl_arguments.aide = ((*s_etat_processus).affichage_arguments
551: == 'N') ? d_faux : d_vrai;
552: rpl_arguments.affichage_arguments = (*s_etat_processus)
553: .affichage_arguments;
554: rpl_arguments.test_instruction =
555: (*s_etat_processus).test_instruction;
556: rpl_arguments.constante_symbolique = (*s_etat_processus)
557: .constante_symbolique;
558: rpl_arguments.instruction_valide = 'N';
559: rpl_arguments.s_etat_processus = s_etat_processus;
560:
561: (*s_etat_processus).erreur_execution = d_ex;
562:
563: if ((*s_etat_processus).profilage == d_vrai)
564: {
565: if ((tampon = malloc((strlen((*descripteur).nom) + 14) *
566: sizeof(unsigned char))) == NULL)
567: {
568: (*s_etat_processus).erreur_systeme =
569: d_es_allocation_memoire;
570: return(d_erreur);
571: }
572:
573: sprintf(tampon, "%s$runOnClosing", (*descripteur).nom);
574: profilage(s_etat_processus, tampon);
575: free(tampon);
576:
577: if ((*s_etat_processus).erreur_systeme != d_es)
578: {
579: return(d_erreur);
580: }
581: }
582:
583: # ifndef SEMAPHORES_NOMMES
584: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
585: # else
586: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
587: # endif
588: {
589: (*s_etat_processus).erreur_systeme = d_es_processus;
590: return(d_erreur);
591: }
592:
593: (*onclosing)(&rpl_arguments);
594:
595: # ifndef SEMAPHORES_NOMMES
596: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
597: # else
598: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
599: # endif
600: {
601: if (errno != EINTR)
602: {
603: (*s_etat_processus).erreur_systeme = d_es_processus;
604: return(d_erreur);
605: }
606: }
607:
608: if ((*s_etat_processus).profilage == d_vrai)
609: {
610: profilage(s_etat_processus, NULL);
611: }
612:
613: (*s_etat_processus).nombre_arguments =
614: rpl_arguments.nombre_arguments;
615: (*s_etat_processus).constante_symbolique = rpl_arguments
616: .constante_symbolique;
617: (*s_etat_processus).instruction_valide = rpl_arguments
618: .instruction_valide;
619:
620: if ((*s_etat_processus).test_instruction == 'Y')
621: {
622: if ((*s_etat_processus).nombre_arguments == 0)
623: {
624: (*s_etat_processus).nombre_arguments = -1;
625: }
626: }
627:
628: if (rpl_arguments.erreur != 0)
629: {
630: if (((*s_etat_processus).arret_si_exception == d_vrai) ||
631: (rpl_arguments.type_erreur == 'S'))
632: {
633: if (test_cfsf(s_etat_processus, 51) == d_faux)
634: {
635: printf("%s", ds_beep);
636: }
637:
638: if (rpl_arguments.type_erreur == 'S')
639: {
640: (*s_etat_processus).derniere_erreur_execution = -1;
641:
642: if ((*s_etat_processus).langue == 'F')
643: {
644: printf("+++Système : Fonction dynamique "
645: "%s (ligne %lld)\n",
646: "onClosing" , rpl_arguments.erreur);
647: }
648: else
649: {
650: printf("+++System : %s dynamic function "
651: "(line %lld)\n",
652: "onClosing", rpl_arguments.erreur);
653: }
654: }
655: else
656: {
657: (*s_etat_processus).derniere_erreur_systeme = -1;
658:
659: if ((*s_etat_processus).langue == 'F')
660: {
661: printf("+++Erreur : Fonction dynamique %s "
662: "(ligne %lld)\n",
663: "onClosing", rpl_arguments.erreur);
664: }
665: else
666: {
667: printf("+++Error : %s dynamic function "
668: "(line %lld)\n",
669: "onClosing", rpl_arguments.erreur);
670: }
671: }
672:
673: if (rpl_arguments.message_erreur != NULL)
674: {
675: printf("%s\n", rpl_arguments.message_erreur);
676: }
677:
678: fflush(stdout);
679: }
680:
681: if (rpl_arguments.type_erreur == 'S')
682: {
683: (*s_etat_processus).erreur_systeme =
684: d_es_execution_bibliotheque;
685: }
686: else
687: {
688: (*s_etat_processus).erreur_execution =
689: d_ex_execution_bibliotheque;
690: }
691: }
692:
693: (*s_etat_processus).l_base_pile = rpl_arguments.l_base_pile;
694: (*s_etat_processus).l_base_pile_last =
695: rpl_arguments.l_base_pile_last;
696:
697: for(i = 0; i < 8; i++)
698: {
699: (*s_etat_processus).drapeaux_etat[i] =
700: rpl_arguments.drapeaux_etat[i];
701: }
702:
703: l_element_courant = (*s_etat_processus).l_base_pile;
704: (*s_etat_processus).hauteur_pile_operationnelle = 0;
705:
706: while(l_element_courant != NULL)
707: {
708: (*s_etat_processus).hauteur_pile_operationnelle++;
709: l_element_courant = (*l_element_courant).suivant;
710: }
711: }
712: else
713: {
714: printf("%s\n", message);
715:
716: if (pthread_mutex_unlock(&mutex) != 0)
717: {
718: (*s_etat_processus).erreur_systeme = d_es_processus;
719: return(d_erreur);
720: }
721: }
722:
723: /*
724: * Retrait de la bibliothèque de la pile
725: */
726:
727: dlclose((*descripteur).descripteur);
728:
729: l_element_courant = (*s_etat_processus).s_bibliotheques;
730:
731: while(l_element_courant != NULL)
732: {
733: if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
734: .descripteur == (*descripteur).descripteur)
735: {
736: break;
737: }
738:
739: l_element_precedent = l_element_courant;
740: l_element_courant = (*l_element_courant).suivant;
741: }
742:
743: if (l_element_precedent == NULL)
744: {
745: (*s_etat_processus).s_bibliotheques = (*l_element_courant).suivant;
746: }
747: else
748: {
749: (*l_element_precedent).suivant = (*l_element_courant).suivant;
750: }
751:
752: free((*((struct_bibliotheque *) (*l_element_courant).donnee)).nom);
753: free((*l_element_courant).donnee);
754: free(l_element_courant);
755:
756: /*
757: * Retrait des symboles associés à la bibliothèque
758: */
759:
760: nombre_symboles_residuels = 0;
761:
762: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
763: {
764: if ((*s_etat_processus).s_instructions_externes[i]
765: .descripteur_bibliotheque != (*descripteur).descripteur)
766: {
767: nombre_symboles_residuels++;
768: }
769: }
770:
771: if (nombre_symboles_residuels == 0)
772: {
773: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes;
774: i++)
775: {
776: free((*s_etat_processus).s_instructions_externes[i].nom);
777: free((*s_etat_processus).s_instructions_externes[i]
778: .nom_bibliotheque);
779: }
780:
781: free((*s_etat_processus).s_instructions_externes);
782: (*s_etat_processus).s_instructions_externes = NULL;
783: }
784: else
785: {
786: registre = (*s_etat_processus).s_instructions_externes;
787:
788: if (((*s_etat_processus).s_instructions_externes =
789: malloc(nombre_symboles_residuels *
790: sizeof(struct_instruction_externe))) == NULL)
791: {
792: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
793:
794: return(d_erreur);
795: }
796:
797: for(i = j = 0; i < (*s_etat_processus).nombre_instructions_externes;
798: i++)
799: {
800: if (registre[i].descripteur_bibliotheque !=
801: (*descripteur).descripteur)
802: {
803: (*s_etat_processus).s_instructions_externes[j].nom =
804: registre[i].nom;
805: (*s_etat_processus).s_instructions_externes[j]
806: .nom_bibliotheque = registre[i].nom_bibliotheque;
807: (*s_etat_processus).s_instructions_externes[j]
808: .descripteur_bibliotheque = registre[i]
809: .descripteur_bibliotheque;
810: j++;
811: }
812: else
813: {
814: free(registre[i].nom);
815: free(registre[i].nom_bibliotheque);
816: }
817: }
818:
819: free(registre);
820: }
821:
822: (*s_etat_processus).nombre_instructions_externes =
823: nombre_symboles_residuels;
824:
825: return(d_absence_erreur);
826: }
827: else
828: {
829: (*s_etat_processus).erreur_execution = d_ex_erreur_bibliotheque;
830:
831: return(d_erreur);
832: }
833: }
834:
835:
836: /*
837: ================================================================================
838: Procédure d'exécution d'une fonction d'une bibliothèque
839: ================================================================================
840: Entrée :
841: --------------------------------------------------------------------------------
842: Sortie :
843: --------------------------------------------------------------------------------
844: Effets de bord : néant
845: ================================================================================
846: */
847:
848: logical1
849: execution_fonction_de_bibliotheque(struct_processus *s_etat_processus,
850: unsigned char *nom_fonction, unsigned char *bibliotheque)
851: {
852: logical1 presence_bibliotheque;
853: logical1 unicite_symbole;
854:
855: long difference;
856: long difference_inferieure;
857: long difference_superieure;
858: long i;
859:
860: struct_liste_chainee *l_element_courant;
861:
862: struct_rpl_arguments rpl_arguments;
863:
864: unsigned char *nom_fonction_externe;
865: unsigned char *tampon;
866:
867: unsigned long borne_inferieure;
868: unsigned long borne_superieure;
869: unsigned long moyenne;
870: unsigned long nombre_iterations_maximal;
871: unsigned long ordre_iteration;
872:
873: void (*fonction)(struct_rpl_arguments *);
874:
875: /*
876: * Recherche dichotomique de la définition externe
877: */
878:
879: if ((*s_etat_processus).nombre_instructions_externes == 0)
880: {
881: return(d_faux);
882: }
883:
884: if (bibliotheque != NULL)
885: {
886: presence_bibliotheque = d_faux;
887: l_element_courant = (*s_etat_processus).s_bibliotheques;
888:
889: while(l_element_courant != NULL)
890: {
891: if (strcmp((*((struct_bibliotheque *) (*l_element_courant).donnee))
892: .nom, bibliotheque) == 0)
893: {
894: presence_bibliotheque = d_vrai;
895: break;
896: }
897:
898: l_element_courant = (*l_element_courant).suivant;
899: }
900:
901: if (presence_bibliotheque == d_faux)
902: {
903: return(d_faux);
904: }
905: }
906:
907: ordre_iteration = 0;
908: nombre_iterations_maximal = ((unsigned long)
909: (log((*s_etat_processus).nombre_instructions_externes) / log(2)))
910: + 2;
911:
912: borne_inferieure = 0;
913: borne_superieure = (*s_etat_processus).nombre_instructions_externes - 1;
914:
915: do
916: {
917: moyenne = (borne_inferieure + borne_superieure) / 2;
918: ordre_iteration++;
919:
920: if ((2 * ((unsigned long) ((borne_inferieure + borne_superieure) / 2)))
921: == (borne_inferieure + borne_superieure))
922: {
923: difference = strcmp(nom_fonction, (*s_etat_processus)
924: .s_instructions_externes[moyenne].nom);
925:
926: if (difference != 0)
927: {
928: if (difference > 0)
929: {
930: borne_inferieure = moyenne;
931: }
932: else
933: {
934: borne_superieure = moyenne;
935: }
936: }
937: }
938: else
939: {
940: difference_inferieure = strcmp(nom_fonction,
941: (*s_etat_processus).s_instructions_externes[moyenne].nom);
942: difference_superieure = strcmp(nom_fonction,
943: (*s_etat_processus).s_instructions_externes[moyenne + 1]
944: .nom);
945:
946: if (difference_inferieure == 0)
947: {
948: difference = 0;
949: }
950: else if (difference_superieure == 0)
951: {
952: difference = 0;
953: moyenne++;
954: }
955: else
956: {
957: difference = difference_inferieure;
958:
959: if (difference > 0)
960: {
961: borne_inferieure = moyenne;
962: }
963: else
964: {
965: borne_superieure = moyenne;
966: }
967: }
968: }
969: } while((difference != 0) &&
970: (ordre_iteration <= nombre_iterations_maximal));
971:
972: if (ordre_iteration > nombre_iterations_maximal)
973: {
974: return(d_faux);
975: }
976:
977: if (bibliotheque != NULL)
978: { // Nom de la bibliothèque spécifié
979: if (strcmp((*s_etat_processus).s_instructions_externes[moyenne]
980: .nom_bibliotheque, bibliotheque) > 0)
981: {
982: i = moyenne;
983:
984: while(i >= 0)
985: {
986: if (strcmp((*s_etat_processus).s_instructions_externes[i]
987: .nom, nom_fonction) != 0)
988: {
989: break;
990: }
991: else if (strcmp((*s_etat_processus).s_instructions_externes[i]
992: .nom_bibliotheque, bibliotheque) == 0)
993: {
994: break;
995: }
996:
997: i--;
998: }
999:
1000: moyenne = i;
1001: }
1002: else if (strcmp((*s_etat_processus).s_instructions_externes[moyenne]
1003: .nom_bibliotheque, bibliotheque) < 0)
1004: {
1005: i = moyenne;
1006:
1007: while((unsigned long) i <
1008: (*s_etat_processus).nombre_instructions_externes)
1009: {
1010: if (strcmp((*s_etat_processus).s_instructions_externes[i]
1011: .nom, nom_fonction) != 0)
1012: {
1013: break;
1014: }
1015: else if (strcmp((*s_etat_processus).s_instructions_externes[i]
1016: .nom_bibliotheque, bibliotheque) == 0)
1017: {
1018: break;
1019: }
1020:
1021: i++;
1022: }
1023:
1024: moyenne = i;
1025: }
1026: }
1027: else
1028: { // Nom de la bibliothèque non spécifié
1029:
1030: /*
1031: * Vérification de l'unicité du symbole
1032: */
1033:
1034: unicite_symbole = d_vrai;
1035:
1036: if (moyenne > 0)
1037: {
1038: if (strcmp((*s_etat_processus).s_instructions_externes
1039: [moyenne - 1].nom, nom_fonction) == 0)
1040: {
1041: unicite_symbole = d_faux;
1042: }
1043: }
1044:
1045: if ((moyenne + 1) < (*s_etat_processus)
1046: .nombre_instructions_externes)
1047: {
1048: if (strcmp((*s_etat_processus).s_instructions_externes
1049: [moyenne + 1].nom, nom_fonction) == 0)
1050: {
1051: unicite_symbole = d_faux;
1052: }
1053: }
1054:
1055: if (unicite_symbole == d_faux)
1056: {
1057: (*s_etat_processus).erreur_execution = d_ex_definition_ambigue;
1058: return(d_faux);
1059: }
1060: }
1061:
1062: if ((nom_fonction_externe = malloc((strlen(nom_fonction) + 12)
1063: * sizeof(unsigned char))) == NULL)
1064: {
1065: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1066: return(d_faux);
1067: }
1068:
1069: sprintf(nom_fonction_externe, "__external_%s", nom_fonction);
1070:
1071: if (pthread_mutex_lock(&mutex) != 0)
1072: {
1073: (*s_etat_processus).erreur_systeme = d_es_processus;
1074: return(d_faux);
1075: }
1076:
1077: dlerror();
1078: fonction = dlsym((*s_etat_processus).s_instructions_externes
1079: [moyenne].descripteur_bibliotheque, nom_fonction_externe);
1080:
1081: free(nom_fonction_externe);
1082:
1083: /*
1084: * Vérification de la présence du symbole
1085: */
1086:
1087: if (fonction == NULL)
1088: {
1089: if (dlerror() != NULL)
1090: {
1091: if (pthread_mutex_unlock(&mutex) != 0)
1092: {
1093: (*s_etat_processus).erreur_systeme = d_es_processus;
1094: return(d_faux);
1095: }
1096:
1097: return(d_faux);
1098: }
1099: }
1100:
1101: dlerror();
1102:
1103: if (pthread_mutex_unlock(&mutex) != 0)
1104: {
1105: (*s_etat_processus).erreur_systeme = d_es_processus;
1106: return(d_faux);
1107: }
1108:
1109: /*
1110: * Exécution de la fonction externe
1111: */
1112:
1113: rpl_arguments.l_base_pile = (*s_etat_processus).l_base_pile;
1114: rpl_arguments.l_base_pile_last = (*s_etat_processus).l_base_pile_last;
1115:
1116: for(i = 0; i < 8; i++)
1117: {
1118: rpl_arguments.drapeaux_etat[i] =
1119: (*s_etat_processus).drapeaux_etat[i];
1120: }
1121:
1122: rpl_arguments.message_erreur = NULL;
1123: rpl_arguments.type_erreur = 'E';
1124: rpl_arguments.erreur = 0;
1125: rpl_arguments.aide = ((*s_etat_processus).affichage_arguments
1126: == 'N') ? d_faux : d_vrai;
1127: rpl_arguments.affichage_arguments = (*s_etat_processus)
1128: .affichage_arguments;
1129: rpl_arguments.test_instruction = (*s_etat_processus).test_instruction;
1130: rpl_arguments.constante_symbolique = (*s_etat_processus)
1131: .constante_symbolique;
1132: rpl_arguments.instruction_valide = 'N';
1133: rpl_arguments.s_etat_processus = s_etat_processus;
1134:
1135: (*s_etat_processus).erreur_execution = d_ex;
1136:
1137: if ((*s_etat_processus).profilage == d_vrai)
1138: {
1139: if ((tampon = malloc(strlen((*s_etat_processus)
1140: .s_instructions_externes[moyenne].nom_bibliotheque)
1141: + strlen(nom_fonction) + 2)) == NULL)
1142: {
1143: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1144: return(d_faux);
1145: }
1146:
1147: sprintf(tampon, "%s$%s", (*s_etat_processus).s_instructions_externes
1148: [moyenne].nom_bibliotheque, nom_fonction);
1149: profilage(s_etat_processus, tampon);
1150: free(tampon);
1151:
1152: if ((*s_etat_processus).erreur_systeme != d_es)
1153: {
1154: return(d_faux);
1155: }
1156: }
1157:
1158: # ifndef SEMAPHORES_NOMMES
1159: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1160: # else
1161: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1162: # endif
1163: {
1164: (*s_etat_processus).erreur_systeme = d_es_processus;
1165: return(d_faux);
1166: }
1167:
1168: (*fonction)(&rpl_arguments);
1169:
1170: # ifndef SEMAPHORES_NOMMES
1171: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1172: # else
1173: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1174: # endif
1175: {
1176: if (errno != EINTR)
1177: {
1178: (*s_etat_processus).erreur_systeme = d_es_processus;
1179: return(d_faux);
1180: }
1181: }
1182:
1183: if ((*s_etat_processus).profilage == d_vrai)
1184: {
1185: profilage(s_etat_processus, NULL);
1186: }
1187:
1188: (*s_etat_processus).nombre_arguments = rpl_arguments.nombre_arguments;
1189: (*s_etat_processus).constante_symbolique = rpl_arguments
1190: .constante_symbolique;
1191: (*s_etat_processus).instruction_valide = rpl_arguments
1192: .instruction_valide;
1193:
1194: if ((*s_etat_processus).test_instruction == 'Y')
1195: {
1196: if ((*s_etat_processus).nombre_arguments == 0)
1197: {
1198: (*s_etat_processus).nombre_arguments = -1;
1199: }
1200: }
1201:
1202: if (rpl_arguments.erreur != 0)
1203: {
1204: if (((*s_etat_processus).arret_si_exception == d_vrai) ||
1205: (rpl_arguments.type_erreur == 'S'))
1206: {
1207: if (test_cfsf(s_etat_processus, 51) == d_faux)
1208: {
1209: printf("%s", ds_beep);
1210: }
1211:
1212: if (rpl_arguments.type_erreur == 'S')
1213: {
1214: (*s_etat_processus).derniere_erreur_execution = -1;
1215:
1216: if ((*s_etat_processus).langue == 'F')
1217: {
1218: printf("+++Système : Fonction dynamique %s (ligne %lld)\n",
1219: nom_fonction, rpl_arguments.erreur);
1220: }
1221: else
1222: {
1223: printf("+++System : %s dynamic function (line %lld)\n",
1224: nom_fonction, rpl_arguments.erreur);
1225: }
1226: }
1227: else
1228: {
1229: (*s_etat_processus).derniere_erreur_systeme = -1;
1230:
1231: if ((*s_etat_processus).langue == 'F')
1232: {
1233: printf("+++Erreur : Fonction dynamique %s (ligne %lld)\n",
1234: nom_fonction, rpl_arguments.erreur);
1235: }
1236: else
1237: {
1238: printf("+++Error : %s dynamic function (line %lld)\n",
1239: nom_fonction, rpl_arguments.erreur);
1240: }
1241: }
1242:
1243: if (rpl_arguments.message_erreur != NULL)
1244: {
1245: printf("%s\n", rpl_arguments.message_erreur);
1246: }
1247:
1248: fflush(stdout);
1249: }
1250:
1251: if (rpl_arguments.type_erreur == 'S')
1252: {
1253: (*s_etat_processus).erreur_systeme =
1254: d_es_execution_bibliotheque;
1255: }
1256: else
1257: {
1258: (*s_etat_processus).erreur_execution =
1259: d_ex_execution_bibliotheque;
1260: }
1261: }
1262:
1263: (*s_etat_processus).l_base_pile = rpl_arguments.l_base_pile;
1264: (*s_etat_processus).l_base_pile_last = rpl_arguments.l_base_pile_last;
1265:
1266: for(i = 0; i < 8; i++)
1267: {
1268: (*s_etat_processus).drapeaux_etat[i] =
1269: rpl_arguments.drapeaux_etat[i];
1270: }
1271:
1272: l_element_courant = (*s_etat_processus).l_base_pile;
1273: (*s_etat_processus).hauteur_pile_operationnelle = 0;
1274:
1275: while(l_element_courant != NULL)
1276: {
1277: (*s_etat_processus).hauteur_pile_operationnelle++;
1278: l_element_courant = (*l_element_courant).suivant;
1279: }
1280:
1281: #undef return
1282: return(d_vrai);
1283: }
1284:
1285:
1286: /*
1287: ================================================================================
1288: Wrapper vers une fonction intrinsèque
1289: ================================================================================
1290: Entrée :
1291: --------------------------------------------------------------------------------
1292: Sortie :
1293: --------------------------------------------------------------------------------
1294: Effets de bord : néant
1295: ================================================================================
1296: */
1297:
1298: int
1299: wrapper_instruction_intrinseque(void (*fonction)(),
1300: struct_rpl_arguments *rpl_arguments)
1301: {
1302: int i;
1303:
1304: logical1 registre31;
1305:
1306: struct_liste_chainee *l_element_courant;
1307:
1308: struct_processus *s_etat_processus;
1309:
1310: s_etat_processus = (*rpl_arguments).s_etat_processus;
1311:
1312: (*s_etat_processus).nombre_arguments = (*rpl_arguments).nombre_arguments;
1313: (*s_etat_processus).constante_symbolique = (*rpl_arguments)
1314: .constante_symbolique;
1315: (*s_etat_processus).instruction_valide = (*rpl_arguments)
1316: .instruction_valide;
1317: (*s_etat_processus).l_base_pile = (*rpl_arguments).l_base_pile;
1318: (*s_etat_processus).l_base_pile_last = (*rpl_arguments).l_base_pile_last;
1319:
1320: for(i = 0; i < 8; i++)
1321: {
1322: (*s_etat_processus).drapeaux_etat[i] =
1323: (*rpl_arguments).drapeaux_etat[i];
1324: }
1325:
1326: l_element_courant = (*s_etat_processus).l_base_pile;
1327: (*s_etat_processus).hauteur_pile_operationnelle = 0;
1328:
1329: while(l_element_courant != NULL)
1330: {
1331: (*s_etat_processus).hauteur_pile_operationnelle++;
1332: l_element_courant = (*l_element_courant).suivant;
1333: }
1334:
1335: registre31 = test_cfsf(s_etat_processus, 31);
1336: cf(s_etat_processus, 31);
1337:
1338: (*fonction)(s_etat_processus);
1339:
1340: if (registre31 == d_vrai)
1341: {
1342: sf(s_etat_processus, 31);
1343: }
1344: else
1345: {
1346: cf(s_etat_processus, 31);
1347: }
1348:
1349: (*rpl_arguments).l_base_pile = (*s_etat_processus).l_base_pile;
1350: (*rpl_arguments).l_base_pile_last = (*s_etat_processus).l_base_pile_last;
1351:
1352: for(i = 0; i < 8; i++)
1353: {
1354: (*rpl_arguments).drapeaux_etat[i] =
1355: (*s_etat_processus).drapeaux_etat[i];
1356: }
1357:
1358: (*rpl_arguments).message_erreur = NULL;
1359: (*rpl_arguments).type_erreur = 'E';
1360: (*rpl_arguments).erreur = 0;
1361: (*rpl_arguments).aide = ((*s_etat_processus).affichage_arguments
1362: == 'N') ? d_faux : d_vrai;
1363: (*rpl_arguments).affichage_arguments = (*s_etat_processus)
1364: .affichage_arguments;
1365: (*rpl_arguments).test_instruction = (*s_etat_processus).test_instruction;
1366: (*rpl_arguments).constante_symbolique = (*s_etat_processus)
1367: .constante_symbolique;
1368: (*rpl_arguments).instruction_valide = 'Y';
1369: (*rpl_arguments).s_etat_processus = s_etat_processus;
1370:
1371: if (((*s_etat_processus).erreur_execution != d_ex) ||
1372: ((*s_etat_processus).exception != d_ep))
1373: {
1374: return(1);
1375: }
1376:
1377: if ((*s_etat_processus).erreur_systeme != d_es)
1378: {
1379: return(2);
1380: }
1381:
1382: (*s_etat_processus).erreur_execution = d_ex;
1383: (*s_etat_processus).erreur_systeme = d_es;
1384: (*s_etat_processus).exception = d_ep;
1385:
1386: return(0);
1387: }
1388:
1389:
1390: /*
1391: ================================================================================
1392: Procédure d'empilement d'un nouvel élément
1393: ================================================================================
1394: Entrée :
1395: --------------------------------------------------------------------------------
1396: Sortie :
1397: --------------------------------------------------------------------------------
1398: Effets de bord : néant
1399: ================================================================================
1400: */
1401:
1402: struct_liste_chainee *
1403: empilement_pile_operationnelle(struct_rpl_arguments *s_rpl_arguments,
1404: struct_objet *s_objet)
1405: {
1406: struct_liste_chainee *l_ancienne_base_liste;
1407: struct_liste_chainee *l_nouvelle_base_liste;
1408:
1409: l_ancienne_base_liste = (*s_rpl_arguments).l_base_pile;
1410:
1411: l_nouvelle_base_liste = (struct_liste_chainee *) malloc(
1412: sizeof(struct_liste_chainee));
1413:
1414: if (l_nouvelle_base_liste != NULL)
1415: {
1416: (*l_nouvelle_base_liste).donnee = s_objet;
1417: (*l_nouvelle_base_liste).suivant = l_ancienne_base_liste;
1418: }
1419:
1420: (*s_rpl_arguments).l_base_pile = l_nouvelle_base_liste;
1421:
1422: return l_nouvelle_base_liste;
1423: }
1424:
1425:
1426: /*
1427: ================================================================================
1428: Procédure de dépilement d'un élément. L'emplacement est libéré dans la pile.
1429: ================================================================================
1430: Entrée :
1431: --------------------------------------------------------------------------------
1432: Sortie :
1433: --------------------------------------------------------------------------------
1434: Effets de bord : néant
1435: ================================================================================
1436: */
1437:
1438: struct_liste_chainee *
1439: depilement_pile_operationnelle(struct_rpl_arguments *s_rpl_arguments,
1440: struct_objet **s_objet)
1441: {
1442: struct_liste_chainee *l_ancienne_base_liste;
1443: struct_liste_chainee *l_nouvelle_base_liste;
1444:
1445: if ((*s_rpl_arguments).l_base_pile == NULL)
1446: {
1447: *s_objet = NULL;
1448: return(NULL);
1449: }
1450: else
1451: {
1452: l_ancienne_base_liste = (*s_rpl_arguments).l_base_pile;
1453: l_nouvelle_base_liste = (*l_ancienne_base_liste).suivant;
1454:
1455: *s_objet = (*l_ancienne_base_liste).donnee;
1456: free(l_ancienne_base_liste);
1457:
1458: (*s_rpl_arguments).l_base_pile = l_nouvelle_base_liste;
1459:
1460: return(l_nouvelle_base_liste);
1461: }
1462: }
1463:
1464:
1465: /*
1466: ================================================================================
1467: Procédure de sauvegarde des arguments dans la pile last
1468: ================================================================================
1469: Entrée : structure processus et nombre d'aguments à empiler
1470: --------------------------------------------------------------------------------
1471: Sortie : drapeau d'erreur de la structure rpl_arguments
1472: --------------------------------------------------------------------------------
1473: Effets de bord : efface le précédent contenu de la pile LAST
1474: ================================================================================
1475: */
1476:
1477: struct_liste_chainee *
1478: sauvegarde_arguments(struct_rpl_arguments *s_rpl_arguments,
1479: unsigned long nombre_arguments)
1480: {
1481: struct_liste_chainee *l_ancienne_base_liste;
1482: struct_liste_chainee *l_element_courant;
1483: struct_liste_chainee *l_element_suivant;
1484: struct_liste_chainee *l_nouvelle_base_liste;
1485:
1486: struct_objet *s_objet;
1487:
1488: logical1 erreur;
1489:
1490: t_8_bits masque;
1491:
1492: unsigned char indice_bit;
1493: unsigned char indice_bloc;
1494: unsigned char indice_drapeau;
1495: unsigned char taille_bloc;
1496:
1497: unsigned long i;
1498:
1499: struct_processus *s_etat_processus;
1500:
1501: (*s_rpl_arguments).erreur = 0;
1502: s_etat_processus = (*s_rpl_arguments).s_etat_processus;
1503:
1504: indice_drapeau = 31;
1505: indice_drapeau--;
1506: taille_bloc = sizeof(t_8_bits) * 8;
1507: indice_bloc = indice_drapeau / taille_bloc;
1508: indice_bit = indice_drapeau % taille_bloc;
1509:
1510: masque = ((t_8_bits) 1) << (taille_bloc - indice_bit - 1);
1511:
1512: if (((*s_rpl_arguments).drapeaux_etat[indice_bloc] & masque) == 0)
1513: {
1514: return (*s_rpl_arguments).l_base_pile_last;
1515: }
1516:
1517: erreur = d_absence_erreur;
1518:
1519: l_element_courant = (*s_rpl_arguments).l_base_pile_last;
1520: while(l_element_courant != NULL)
1521: {
1522: liberation(s_etat_processus, (*l_element_courant).donnee);
1523: l_element_suivant = (*l_element_courant).suivant;
1524: free(l_element_courant);
1525: l_element_courant = l_element_suivant;
1526: }
1527:
1528: (*s_rpl_arguments).l_base_pile_last = NULL;
1529: l_element_courant = (*s_rpl_arguments).l_base_pile;
1530: l_nouvelle_base_liste = (*s_rpl_arguments).l_base_pile_last;
1531:
1532: for(i = 0; ((i < nombre_arguments) && (erreur == d_absence_erreur)
1533: && (l_element_courant != NULL)); i++)
1534: {
1535: s_objet = copie_objet(s_etat_processus,
1536: (*l_element_courant).donnee, 'P');
1537:
1538: if (s_objet != NULL)
1539: {
1540: l_ancienne_base_liste = l_nouvelle_base_liste;
1541: l_nouvelle_base_liste = (struct_liste_chainee *) malloc(
1542: sizeof(struct_liste_chainee));
1543:
1544: if (l_nouvelle_base_liste != NULL)
1545: {
1546: (*l_nouvelle_base_liste).donnee = s_objet;
1547: (*l_nouvelle_base_liste).suivant = l_ancienne_base_liste;
1548:
1549: }
1550: else
1551: {
1552: erreur = d_erreur;
1553: }
1554:
1555: l_element_courant = (*l_element_courant).suivant;
1556: }
1557: else
1558: {
1559: erreur = d_erreur;
1560: }
1561: }
1562:
1563: if (i != nombre_arguments)
1564: {
1565: /*
1566: * Erreur système : la pile est vidée et la routine renvoie NULL.
1567: */
1568:
1569: l_element_courant = l_nouvelle_base_liste;
1570: while(l_element_courant != NULL)
1571: {
1572: liberation(s_etat_processus, (*l_element_courant).donnee);
1573: l_element_suivant = (*l_element_courant).suivant;
1574: free(l_element_courant);
1575: l_element_courant = l_element_suivant;
1576: }
1577:
1578: l_nouvelle_base_liste = NULL;
1579: (*s_rpl_arguments).erreur = i;
1580: }
1581:
1582: return(l_nouvelle_base_liste);
1583: }
1584:
1585:
1586: /*
1587: ================================================================================
1588: Procédure de tri des symboles externes
1589:
1590: Principe du tri dit de Shell-Metzner
1591: ================================================================================
1592: Entrée :
1593: --------------------------------------------------------------------------------
1594: Sortie :
1595: --------------------------------------------------------------------------------
1596: Effets de bord : néant
1597: ================================================================================
1598: */
1599:
1600: void
1601: tri_base_symboles_externes(struct_processus *s_etat_processus)
1602: {
1603: logical1 terminaison_boucle;
1604: logical1 terminaison_boucle_1;
1605: logical1 terminaison_boucle_2;
1606: logical1 terminaison_boucle_3;
1607:
1608: signed long indice_i;
1609: signed long indice_j;
1610: signed long indice_k;
1611: signed long indice_l;
1612:
1613: unsigned long borne_inferieure;
1614: unsigned long borne_superieure;
1615: unsigned long ecartement;
1616: unsigned long indice;
1617:
1618: ecartement = (*s_etat_processus).nombre_instructions_externes;
1619:
1620: terminaison_boucle_1 = d_faux;
1621:
1622: do
1623: {
1624: ecartement = ecartement / 2;
1625:
1626: if (ecartement >= 1)
1627: {
1628: indice_j = 0;
1629: indice_k = (*s_etat_processus).nombre_instructions_externes
1630: - ecartement;
1631:
1632: terminaison_boucle_2 = d_faux;
1633:
1634: do
1635: {
1636: indice_i = indice_j;
1637: terminaison_boucle_3 = d_faux;
1638:
1639: do
1640: {
1641: indice_l = indice_i + ecartement;
1642:
1643: if ((indice_i > 0) && (indice_l > 0))
1644: {
1645: if (strcmp(((*s_etat_processus).s_instructions_externes
1646: [indice_i - 1]).nom, ((*s_etat_processus)
1647: .s_instructions_externes[indice_l - 1]).nom)
1648: > 0)
1649: {
1650: swap((void *) &((*s_etat_processus)
1651: .s_instructions_externes
1652: [indice_i - 1]), (void *)
1653: &((*s_etat_processus)
1654: .s_instructions_externes[indice_l - 1]),
1655: sizeof(struct_instruction_externe));
1656:
1657: indice_i -= ecartement;
1658:
1659: if (indice_i < 1)
1660: {
1661: terminaison_boucle_3 = d_vrai;
1662: }
1663: }
1664: else
1665: {
1666: terminaison_boucle_3 = d_vrai;
1667: }
1668: }
1669: else
1670: {
1671: terminaison_boucle_3 = d_vrai;
1672: }
1673: } while(terminaison_boucle_3 == d_faux);
1674:
1675: indice_j++;
1676:
1677: if (indice_j > indice_k)
1678: {
1679: terminaison_boucle_2 = d_vrai;
1680: }
1681: } while(terminaison_boucle_2 == d_faux);
1682: }
1683: else
1684: {
1685: terminaison_boucle_1 = d_vrai;
1686: }
1687: } while(terminaison_boucle_1 == d_faux);
1688:
1689: indice_i = 0;
1690:
1691: do
1692: {
1693: indice_j = indice_i;
1694:
1695: while(((unsigned long) (indice_i + 1) < (*s_etat_processus)
1696: .nombre_instructions_externes) && (strcmp(((*s_etat_processus)
1697: .s_instructions_externes[indice_i]).nom, ((*s_etat_processus)
1698: .s_instructions_externes[indice_i + 1]).nom) == 0))
1699: {
1700: indice_i++;
1701: }
1702:
1703: borne_inferieure = indice_j;
1704: borne_superieure = indice_i;
1705:
1706: do
1707: {
1708: terminaison_boucle = d_vrai;
1709:
1710: for(indice = borne_inferieure + 1; indice <= borne_superieure;
1711: indice++)
1712: {
1713: if (strcmp((*s_etat_processus).s_instructions_externes[indice]
1714: .nom_bibliotheque, (*s_etat_processus)
1715: .s_instructions_externes[indice - 1].nom_bibliotheque)
1716: < 0)
1717: {
1718: swap((void *) &((*s_etat_processus).s_instructions_externes
1719: [indice - 1]), (void *) &((*s_etat_processus)
1720: .s_instructions_externes[indice]),
1721: sizeof(struct_instruction_externe));
1722:
1723: terminaison_boucle = d_faux;
1724: }
1725: }
1726: } while(terminaison_boucle == d_faux);
1727:
1728: indice_i++;
1729: } while((unsigned long) (indice_i + 1) <
1730: (*s_etat_processus).nombre_instructions_externes);
1731:
1732: return;
1733: }
1734:
1735: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bibliotheques_externes.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src