---

dynload.H

Go to the documentation of this file.

/*
 * Copyright 1998, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef DYNLOAD_H
#define DYNLOAD_H

#include "std/config.H"
#include "std/hash.H"
#include "std/strings.H"

typedef void *(*VOIDfunc)();

/**********************************************************************
 * SYMld
 *
 *      Class for finding dynamically loaded symbols.
 *  Find() attempts to locate a symbol corresponding to the specified
 *         string name.  If the symbol is not currently loaded, then
 *         symbols of the form FOObar are parsed into libfoo.so and
 *         a search is performed for that library in a search path,
 *         specified by $GLUE_ROOT/...
 *  load_module() attempts to both find parameterless function 
 *         symbol (loading a library if necessary as described above) 
 *         and then to call that function.
 *  load_path() attempts to load the shared library specified by its pathname
 *
 **********************************************************************/
class DllImpExp SYMld {
   protected:
            HASH<VOIDfunc>  _entries;
     static SYMld          *_dflt;
     static Cstr_ptr        _extension;

            void             print_error(ostream &, Cstr_ptr &name, char *path);
            VOIDfunc         load(char *path, char *name);
            VOIDfunc         find(Cstr_ptr &);

   public :
                     SYMld():_entries(128) { }
     static VOIDfunc Find       (Cstr_ptr &);
     static bool     load_module(Cstr_ptr &mod);
     static void     load_path  (Cstr_ptr &path);
            void     unload     (Cstr_ptr &s);
     static void     Unload     (Cstr_ptr &s) { if(_dflt) _dflt->unload(s); }
};

#if defined(__GNUC_MINOR__) && __GNUC_MINOR__ < 96
#define JOT_CANT_DO_SYMEXEC
#endif

// Call a function from a shared library that has one parameter
template <class T>
void SYMexec(VOIDfunc f, T a) {
#ifdef JOT_CANT_DO_SYMEXEC
   cerr << "SYMexec: not supported" << endl;
#else
   ((void (*)(T))f)(a); 
#endif
}

// Call a function from a shared library that has two parameters
template <class T, class U>
void SYMexec(VOIDfunc f, T a, U b) {
#ifdef JOT_CANT_DO_SYMEXEC
   cerr << "SYMexec: not supported under g++" << endl;
#else
   ((void (*)(T, U))f)(a, b);
#endif
}

// Call a function from a shared library that has three parameters
template <class T, class U, class V>
void SYMexec(VOIDfunc f, T a, U b, V c) {
#ifdef JOT_CANT_DO_SYMEXEC
   cerr << "SYMexec: not supported under g++" << endl;
#else
   ((void (*)(T, U, V))f)(a, b, c); 
#endif
}
#endif

---