/[libtool]/libtool/libltdl/ltdl.c
ViewVC logotype

Diff of /libtool/libltdl/ltdl.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.144 by gary, Sun Aug 5 16:01:56 2001 UTC revision 1.145 by gary, Mon Aug 13 17:25:49 2001 UTC
# Line 597  argz_next (argz, argz_len, entry) Line 597  argz_next (argz, argz_len, entry)
597    
598    
599    
600    #if ! HAVE_ARGZ_STRINGIFY
601    #  define argz_stringify rpl_argz_stringify
602    
603    static void argz_stringify LT_PARAMS((char *argz, size_t argz_len,
604                                           int sep));
605    
606    void
607    argz_stringify (argz, argz_len, sep)
608         char *argz;
609         size_t argz_len;
610         int sep;
611    {
612      assert ((argz && argz_len) || (!argz && !argz_len));
613    
614      if (sep)
615        {
616          while (--argz_len >= 0)
617            {
618              if (argz[argz_len] == LT_EOS_CHAR)
619                argz[argz_len] = sep;
620            }
621        }
622    }
623    #endif /* !HAVE_ARGZ_STRINGIFY */
624    
625    
626    
627    
628  /* --- TYPE DEFINITIONS -- */  /* --- TYPE DEFINITIONS -- */
629    
# Line 1604  static int     foreachfile_callback  LT_PARA Line 1631  static int     foreachfile_callback  LT_PARA
1631                                                   lt_ptr data2));                                                   lt_ptr data2));
1632    
1633    
1634  static  int      canonicalize_path    LT_PARAMS((const char *path,  static  int     canonicalize_path     LT_PARAMS((const char *path,
1635                                                   char **pcanonical));                                                   char **pcanonical));
1636  static  int      argzize_path         LT_PARAMS((const char *path,  static  int     argzize_path          LT_PARAMS((const char *path,
1637                                                   char **pargz,                                                   char **pargz,
1638                                                   size_t *pargz_len));                                                   size_t *pargz_len));
1639  static  FILE    *find_file            LT_PARAMS((const char *search_path,  static  FILE   *find_file             LT_PARAMS((const char *search_path,
1640                                                   const char *base_name,                                                   const char *base_name,
1641                                                   char **pdir));                                                   char **pdir));
1642  static  lt_dlhandle *find_handle      LT_PARAMS((const char *search_path,  static  lt_dlhandle *find_handle      LT_PARAMS((const char *search_path,
# Line 1630  static int     trim                  LT_PARAMS((char * Line 1657  static int     trim                  LT_PARAMS((char *
1657  static  int     tryall_dlopen         LT_PARAMS((lt_dlhandle *handle,  static  int     tryall_dlopen         LT_PARAMS((lt_dlhandle *handle,
1658                                                   const char *filename));                                                   const char *filename));
1659  static  int     unload_deplibs        LT_PARAMS((lt_dlhandle handle));  static  int     unload_deplibs        LT_PARAMS((lt_dlhandle handle));
1660    static  int     lt_argz_insert        LT_PARAMS((char **pargz,
1661                                                     size_t *pargz_len,
1662                                                     char *before,
1663                                                     const char *entry));
1664    static  int     lt_argz_insertinorder LT_PARAMS((char **pargz,
1665                                                     size_t *pargz_len,
1666                                                     const char *entry));
1667    static  int     lt_dlpath_insertdir   LT_PARAMS((char **ppath,
1668                                                     char *before,
1669                                                     const char *dir));
1670    
1671  static  char           *user_search_path= 0;  static  char           *user_search_path= 0;
1672  static  lt_dlloader    *loaders         = 0;  static  lt_dlloader    *loaders         = 0;
# Line 2855  lt_dlopenext (filename) Line 2891  lt_dlopenext (filename)
2891    return 0;    return 0;
2892  }  }
2893    
2894    
2895    int
2896    lt_argz_insert (pargz, pargz_len, before, entry)
2897         char **pargz;
2898         size_t *pargz_len;
2899         char *before;
2900         const char *entry;
2901    {
2902      error_t error;
2903    
2904      if ((error = argz_insert (pargz, pargz_len, before, entry)))
2905        {
2906          switch (error)
2907            {
2908            case ENOMEM:
2909              LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));
2910              break;
2911            default:
2912              LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN));
2913              break;
2914            }
2915          return 1;
2916        }
2917    
2918      return 0;
2919    }
2920    
2921  int  int
2922  lt_argz_insert (pargz, pargz_len, entry)  lt_argz_insertinorder (pargz, pargz_len, entry)
2923       char **pargz;       char **pargz;
2924       size_t *pargz_len;       size_t *pargz_len;
2925       const char *entry;       const char *entry;
# Line 2875  lt_argz_insert (pargz, pargz_len, entry) Line 2938  lt_argz_insert (pargz, pargz_len, entry)
2938          if (cmp < 0)  break;          if (cmp < 0)  break;
2939          if (cmp == 0) return 0; /* No duplicates! */          if (cmp == 0) return 0; /* No duplicates! */
2940        }        }
     
   {  
     error_t error;  
   
     if ((error = argz_insert (pargz, pargz_len, before, entry)))  
       {  
         switch (error)  
           {  
           case ENOMEM:  
             LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY));  
             break;  
           default:  
             LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN));  
             break;  
           }  
         return 1;  
       }  
   }  
2941    
2942    return 0;    return lt_argz_insert (pargz, pargz_len, before, entry);
2943  }  }
2944    
2945  int  int
# Line 2955  lt_argz_insertdir (pargz, pargz_len, dir Line 3000  lt_argz_insertdir (pargz, pargz_len, dir
3000    buf[buf_len] = LT_EOS_CHAR;    buf[buf_len] = LT_EOS_CHAR;
3001    
3002    /* Try to insert (in order) into ARGZ/ARGZ_LEN.  */    /* Try to insert (in order) into ARGZ/ARGZ_LEN.  */
3003    if (lt_argz_insert (pargz, pargz_len, buf) != 0)    if (lt_argz_insertinorder (pargz, pargz_len, buf) != 0)
3004      ++errors;      ++errors;
3005    
3006    LT_DLFREE (buf);    LT_DLFREE (buf);
# Line 3255  lt_dlerror () Line 3300  lt_dlerror ()
3300  }  }
3301    
3302  int  int
3303  lt_dladdsearchdir (search_dir)  lt_dlpath_insertdir (ppath, before, dir)
3304       const char *search_dir;       char **ppath;
3305         char *before;
3306         const char *dir;
3307  {  {
3308    int errors = 0;    int    errors         = 0;
3309      char  *canonical      = 0;
3310      char  *argz           = 0;
3311      size_t argz_len       = 0;
3312    
3313    if (!search_dir || !LT_STRLEN(search_dir))    assert (ppath);
3314      assert (dir && *dir);
3315    
3316      if (canonicalize_path (dir, &canonical) != 0)
3317      {      {
3318        return errors;        ++errors;
3319          goto cleanup;
3320      }      }
3321    
3322    LT_DLMUTEX_LOCK ();    assert (canonical && *canonical);
3323    if (!user_search_path)  
3324      /* If *PPATH is empty, set it to DIR.  */
3325      if (*ppath == 0)
3326      {      {
3327        user_search_path = lt_estrdup (search_dir);        assert (!before);         /* BEFORE cannot be set without PPATH.  */
3328        if (!user_search_path)        assert (dir);             /* Without DIR, don't call this function!  */
3329    
3330          *ppath = lt_estrdup (dir);
3331          if (*ppath == 0)
3332          ++errors;          ++errors;
3333    
3334          return errors;
3335      }      }
3336    else  
3337      assert (ppath && *ppath);
3338    
3339      if (argzize_path (*ppath, &argz, &argz_len) != 0)
3340      {      {
3341        size_t len = LT_STRLEN (user_search_path) + 1 + LT_STRLEN (search_dir);        ++errors;
3342        char  *new_search_path = LT_EMALLOC (char, 1+ len);        goto cleanup;
3343        }
3344    
3345      /* Convert BEFORE into an equivalent offset into ARGZ.  This only works
3346         if *PPATH is already canonicalized, and hence does not change length
3347         with respect to ARGZ.  We canonicalize each entry as it is added to
3348         the search path, and don't call this function with (uncanonicalized)
3349         user paths, so this is a fair assumption.  */
3350      if (before)
3351        {
3352          assert (*ppath <= before);
3353          assert (before - *ppath <= strlen (*ppath));
3354    
3355          before = before - *ppath + argz;
3356        }
3357    
3358      if (lt_argz_insert (&argz, &argz_len, before, dir) != 0)
3359        {
3360          ++errors;
3361          goto cleanup;
3362        }
3363      
3364      argz_stringify (argz, argz_len, LT_PATHSEP_CHAR);
3365      LT_DLMEM_REASSIGN (*ppath,  argz);
3366    
3367     cleanup:
3368      LT_DLFREE (canonical);
3369      LT_DLFREE (argz);
3370    
3371        if (!new_search_path)    return errors;
3372    }
3373      
3374    int
3375    lt_dladdsearchdir (search_dir)
3376         const char *search_dir;
3377    {
3378      int errors = 0;
3379    
3380      if (search_dir && *search_dir)
3381        {
3382          LT_DLMUTEX_LOCK ();
3383          if (lt_dlpath_insertdir (&user_search_path, 0, search_dir) != 0)
3384            ++errors;
3385          LT_DLMUTEX_UNLOCK ();
3386        }
3387    
3388      return errors;
3389    }
3390    
3391    int
3392    lt_dlinsertsearchdir (before, search_dir)
3393         const char *before;
3394         const char *search_dir;
3395    {
3396      int errors = 0;
3397    
3398      if (before)
3399        {
3400          LT_DLMUTEX_LOCK ();
3401          if ((before < user_search_path)
3402              || (before >= LT_STRLEN (user_search_path)))
3403          {          {
3404            ++errors;            LT_DLMUTEX_UNLOCK ();
3405              LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_POSITION));
3406              return 1;
3407          }          }
3408        else        LT_DLMUTEX_UNLOCK ();
3409          {      }
           sprintf (new_search_path, "%s%c%s", user_search_path,  
                    LT_PATHSEP_CHAR, search_dir);  
3410    
3411            LT_DLMEM_REASSIGN (user_search_path, new_search_path);    if (search_dir && *search_dir)
3412        {
3413          LT_DLMUTEX_LOCK ();
3414          if (lt_dlpath_insertdir (&user_search_path,
3415                                   (char *) before, search_dir) != 0)
3416            {
3417              ++errors;
3418          }          }
3419          LT_DLMUTEX_UNLOCK ();
3420      }      }
   LT_DLMUTEX_UNLOCK ();  
3421    
3422    return errors;    return errors;
3423  }  }
# Line 3298  int Line 3426  int
3426  lt_dlsetsearchpath (search_path)  lt_dlsetsearchpath (search_path)
3427       const char *search_path;       const char *search_path;
3428  {  {
3429    int errors = 0;    int   errors      = 0;
3430    
3431    LT_DLMUTEX_LOCK ();    LT_DLMUTEX_LOCK ();
3432    LT_DLFREE (user_search_path);    LT_DLFREE (user_search_path);
# Line 3310  lt_dlsetsearchpath (search_path) Line 3438  lt_dlsetsearchpath (search_path)
3438      }      }
3439    
3440    LT_DLMUTEX_LOCK ();    LT_DLMUTEX_LOCK ();
3441    user_search_path = lt_estrdup (search_path);    if (canonicalize_path (search_path, &user_search_path) != 0)
   if (!user_search_path)  
3442      ++errors;      ++errors;
3443    LT_DLMUTEX_UNLOCK ();    LT_DLMUTEX_UNLOCK ();
3444    

Legend:
Removed from v.1.144  
changed lines
  Added in v.1.145

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26