home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / a / bin / modules-.2 / modules- / modules-1.2.8 / depmod / symbol.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-14  |  3.8 KB  |  170 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <etc.h>
  4. #include "link.h"
  5.  
  6.  
  7. #define ALLOC_SYM    10000    // Nombre de symbole alloué par chunk
  8. /*
  9.     Liste des symboles
  10.     Pour chaque symbole, on retient son module de provenance.
  11. */
  12. PUBLIC SYMBOLS::SYMBOLS()
  13. {
  14.     sym.cur = NULL;
  15.     memset (hash,0,sizeof(hash));
  16.     allocsym();
  17. }
  18.  
  19. /*
  20.     Alloue un nouveau buffer d'accumulation pour les symboles
  21. */
  22. PROTECTED void SYMBOLS::allocsym()
  23. {
  24.     LIST_SYMBOL *list = (LIST_SYMBOL*) malloc_err (sizeof(LIST_SYMBOL)
  25.         +ALLOC_SYM*sizeof(SYMBOL),1);
  26.     list->next = sym.cur;
  27.     sym.cur = list;
  28.     sym.nb  = 0;
  29.     sym.ptacc = list->alloc;
  30.     sym.lastacc = list->alloc+ALLOC_SYM;
  31. }
  32.  
  33. /*
  34.     Ajoute un symbole ou localise.
  35.     Ce symbole est soit publique ou un external (requis).
  36.  
  37.     Retourne le symbole localisé ou ajouté
  38. */
  39. PUBLIC SYMBOL *SYMBOLS::add (
  40.     const char *name,
  41.     MODULE *module,            // Module qui déclare ce symbole ou NULL.
  42.     SYM_STATUS status,
  43.     int &module_requis,        // Contiendra != 0 si on établis que le module
  44.                             // en traitement est requis par un autre
  45.                             // module vue précédemment.
  46.                             // Assume qu'il y a deja une valeure dedans
  47.     int is_common)
  48. {
  49. //    if (strncmp(name,"__PLT_",6)==0 || strncmp(name,"__GOT_",6)==0){
  50. //        name += 6;
  51. //    }
  52. //printf (":%s: %d\n",name,status);
  53.     // Recherche le nom
  54.     unsigned hashval = 0;
  55.     const char *pt = name;
  56.     while (*pt != '\0'){
  57.         hashval = (hashval << 1) + *pt++;
  58.     }
  59.     hashval %= 2048;
  60.     SYMBOL **ffind = hash + hashval;
  61.     SYMBOL *find = *ffind;
  62.     while (find != NULL){
  63.         if (strcmp(find->name,name)==0) break;
  64.         find = find->next;
  65.     }
  66.     if (find == NULL){
  67.         // Ajoute a la liste
  68.         if (sym.ptacc == sym.lastacc) allocsym();
  69.         find = sym.ptacc++;
  70.         sym.nb++;
  71.         find->name = alloctxt_add (name);
  72.         find->module = NULL;
  73.         find->next = *ffind;
  74.         *ffind = find;
  75.         find->force = 0;
  76.         find->is_common = 0;
  77.         find->is_dup = 0;
  78.         if (status == SYM_REQUIS){
  79.             find->requis = 1;
  80.             find->defini = 0;
  81.             find->vue_avant = 0;
  82.         }else if (status == SYM_PASUTIL){
  83.             find->requis = 0;
  84.             find->defini = 0;
  85.             find->vue_avant = 0;
  86.         }else{
  87.             find->requis = 0;
  88.             find->defini = 1;
  89.             find->vue_avant = 1;
  90.             find->is_common = is_common;
  91.             find->module = module;
  92.         }
  93.     }else{
  94.         // Deja la
  95.         if (status == SYM_DEFINI){
  96.             if (find->defini){
  97.                 // Le symbole est déjà définie
  98.                 // On ne l'insere pas dans le hashing et on note
  99.                 // qu'il est en double. Si jamais un module doit
  100.                 // être chargé et possède un symbole "duplicate"
  101.                 // on pourra signale le probleme.
  102.                 if (sym.ptacc == sym.lastacc) allocsym();
  103.                 find = sym.ptacc++;
  104.                 sym.nb++;
  105.                 find->name = alloctxt_add (name);
  106.                 find->next = NULL;
  107.                 find->force = 0;
  108.                 find->is_common = 0;
  109.                 find->is_dup = 1;
  110.                 find->requis = 0;
  111.                 find->vue_avant = 0;
  112.             }
  113.             find->module = module;
  114.             find->defini = 1;
  115.             find->is_common = is_common;
  116.             if (find->requis) module_requis = 1;
  117.         }else if (status == SYM_REQUIS){
  118.             find->requis = 1;
  119.         }
  120.     }
  121.     return find;
  122. }
  123.  
  124. /*
  125.     Trouve les symboles qui doivent être "demander" au linker.
  126.     On fait ca pour eviter un link multi-passe.
  127.  
  128.     Retourne le nombre de symbole placé dans tb.
  129. */
  130. PUBLIC int SYMBOLS::findforce (
  131.     char **tb,        // tb peut être NULL
  132.                     // Ca permet de les compter
  133.     int maxtb)
  134. {
  135.     int ret = 0;
  136.     LIST_SYMBOL *list = sym.cur;
  137.     int nbsym = sym.nb;
  138.     while (list != NULL){
  139.         SYMBOL *ptsym = list->alloc;
  140.         for (int i=0; i<nbsym; i++, ptsym++){
  141.             if (ptsym->force){
  142.                 if (tb != NULL) tb[ret++] = strdup_err (ptsym->name,1);
  143.             }
  144.         }
  145.         nbsym = ALLOC_SYM;
  146.         list = list->next;
  147.     }
  148.     return ret;
  149. }
  150.  
  151. /*
  152.     Présente toute la liste de symbole en mémoire
  153. */
  154. PUBLIC void SYMBOLS::dump (FILE *fout)
  155. {
  156.     LIST_SYMBOL *list = sym.cur;
  157.     int nbsym = sym.nb;
  158.     while (list != NULL){
  159.         SYMBOL *ptsym = list->alloc;
  160.         for (int i=0; i<nbsym; i++, ptsym++){
  161.             fprintf (fout,"%s %d %d %d %d %d\n",ptsym->name,ptsym->requis
  162.                 ,ptsym->defini,ptsym->vue_avant
  163.                 ,ptsym->is_common,ptsym->force);
  164.         }
  165.         nbsym = ALLOC_SYM;
  166.         list = list->next;
  167.     }
  168. }
  169.  
  170.