1 /* dynl.c - dynamic linking
3 * Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2, or (at your option)
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this software; see the file COPYING. If not, write to
17 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307 USA
20 * As a special exception, the Free Software Foundation gives permission
21 * for additional uses of the text contained in its release of GUILE.
23 * The exception is that, if you link the GUILE library with other files
24 * to produce an executable, this does not by itself cause the
25 * resulting executable to be covered by the GNU General Public License.
26 * Your use of that executable is in no way restricted on account of
27 * linking the GUILE library code into it.
29 * This exception does not however invalidate any other reasons why
30 * the executable file might be covered by the GNU General Public License.
32 * This exception applies only to the code released by the
33 * Free Software Foundation under the name GUILE. If you copy
34 * code from other Free Software Foundation releases into a copy of
35 * GUILE, as the General Public License permits, the exception does
36 * not apply to the code that you add in this way. To avoid misleading
37 * anyone as to the status of such modified files, you must delete
38 * this exception notice from them.
40 * If you write modifications of your own for GUILE, it is your choice
41 * whether to permit this exception to apply to your modifications.
42 * If you do not wish that, delete this exception notice. */
44 /* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
45 gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
48 /* "dynl.c" dynamically link&load object files.
50 Modified for libguile by Marius Vollmer */
52 #if 0 /* Disabled until we know for sure that it isn't needed */
53 /* XXX - This is only here to drag in a definition of __eprintf. This
54 is needed for proper operation of dynamic linking. The real
55 solution would probably be a shared libgcc. */
61 maybe_drag_in_eprintf ()
63 assert (!maybe_drag_in_eprintf
);
77 /* Converting a list of SCM strings into a argv-style array. You must
78 have ints disabled for the whole lifetime of the created argv (from
79 before MAKE_ARGV_FROM_STRINGLIST until after
80 MUST_FREE_ARGV). Atleast this is was the documentation for
81 MAKARGVFROMSTRS says, it isn't really used that way.
83 This code probably belongs into strings.c */
86 scm_make_argv_from_stringlist (SCM args
,int *argcp
,const char *subr
,int argn
)
91 argc
= scm_ilength (args
);
92 argv
= (char **) scm_must_malloc ((1L + argc
) * sizeof (char *), subr
);
93 for (i
= 0; SCM_NNULLP (args
); args
= SCM_CDR (args
), i
++) {
96 SCM str
= SCM_CAR (args
);
98 SCM_ASSERT (SCM_ROSTRINGP (str
), str
, argn
, subr
);
99 len
= 1 + SCM_ROLENGTH (str
);
100 dst
= (char *) scm_must_malloc ((long) len
, subr
);
101 src
= SCM_ROCHARS (str
);
114 scm_must_free_argv(char **argv
)
122 /* Coerce an arbitrary readonly-string into a zero-terminated string.
126 scm_coerce_rostring (SCM rostr
,const char *subr
,int argn
)
128 SCM_ASSERT (SCM_ROSTRINGP (rostr
), rostr
, argn
, subr
);
129 if (SCM_SUBSTRP (rostr
))
130 rostr
= scm_makfromstr (SCM_ROCHARS (rostr
), SCM_ROLENGTH (rostr
), 0);
137 /* We can't use SCM objects here. One should be able to call
138 SCM_REGISTER_MODULE from a C++ constructor for a static
139 object. This happens before main and thus before libguile is
143 struct moddata
*link
;
148 static struct moddata
*registered_mods
= NULL
;
151 scm_register_module_xxx (char *module_name
, void *init_func
)
155 /* XXX - should we (and can we) DEFER_INTS here? */
157 for (md
= registered_mods
; md
; md
= md
->link
)
158 if (!strcmp (md
->module_name
, module_name
))
160 md
->init_func
= init_func
;
164 md
= (struct moddata
*) malloc (sizeof (struct moddata
));
168 "guile: can't register module (%s): not enough memory",
173 md
->module_name
= module_name
;
174 md
->init_func
= init_func
;
175 md
->link
= registered_mods
;
176 registered_mods
= md
;
179 SCM_DEFINE (scm_registered_modules
, "c-registered-modules", 0, 0, 0,
181 "Return a list of the object code modules that have been imported into\n"
182 "the current Guile process. Each element of the list is a pair whose\n"
183 "car is the name of the module, and whose cdr is the function handle\n"
184 "for that module's initializer function. The name is the string that\n"
185 "has been passed to scm_register_module_xxx.")
186 #define FUNC_NAME s_scm_registered_modules
192 for (md
= registered_mods
; md
; md
= md
->link
)
193 res
= scm_cons (scm_cons (scm_makfrom0str (md
->module_name
),
194 scm_ulong2num ((unsigned long) md
->init_func
)),
200 SCM_DEFINE (scm_clear_registered_modules
, "c-clear-registered-modules", 0, 0, 0,
202 "Destroy the list of modules registered with the current Guile process.\n"
203 "The return value is unspecified. @strong{Warning:} this function does\n"
204 "not actually unlink or deallocate these modules, but only destroys the\n"
205 "records of which modules have been loaded. It should therefore be used\n"
206 "only by module bookkeeping operations.")
207 #define FUNC_NAME s_scm_clear_registered_modules
209 struct moddata
*md1
, *md2
;
213 for (md1
= registered_mods
; md1
; md1
= md2
)
218 registered_mods
= NULL
;
221 return SCM_UNSPECIFIED
;
225 /* Dispatch to the system dependent files
227 * They define some static functions. These functions are called with
228 * deferred interrupts. When they want to throw errors, they are
229 * expected to insert a SCM_ALLOW_INTS before doing the throw. It
230 * might work to throw an error while interrupts are deferred (because
231 * they will be unconditionally allowed the next time a SCM_ALLOW_INTS
232 * is executed, SCM_DEFER_INTS and SCM_ALLOW_INTS do not nest).
235 #define DYNL_GLOBAL 0x0001
237 #ifdef DYNAMIC_LINKING
242 sysdep_dynl_link (const char *fname
, int flags
, const char *subr
)
245 handle
= lt_dlopenext (fname
);
249 scm_misc_error (subr
, (char *) lt_dlerror (), SCM_EOL
);
251 return (void *) handle
;
255 sysdep_dynl_unlink (void *handle
, const char *subr
)
257 if (lt_dlclose ((lt_dlhandle
) handle
))
260 scm_misc_error (subr
, (char *) lt_dlerror (), SCM_EOL
);
265 sysdep_dynl_func (const char *symb
, void *handle
, const char *subr
)
269 fptr
= lt_dlsym ((lt_dlhandle
) handle
, symb
);
273 scm_misc_error (subr
, (char *) lt_dlerror (), SCM_EOL
);
286 /* no dynamic linking available, throw errors. */
289 sysdep_dynl_init (void)
294 no_dynl_error (const char *subr
)
297 scm_misc_error (subr
, "dynamic linking not available", SCM_EOL
);
301 sysdep_dynl_link (const char *filename
,
305 no_dynl_error (subr
);
310 sysdep_dynl_unlink (void *handle
,
313 no_dynl_error (subr
);
317 sysdep_dynl_func (const char *symbol
,
321 no_dynl_error (subr
);
327 int scm_tc16_dynamic_obj
;
334 #define DYNL_OBJ(x) ((struct dynl_obj *) &SCM_CDR (x))
336 #define DYNL_FILENAME(x) (DYNL_OBJ (x)->filename)
337 #define DYNL_HANDLE(x) (DYNL_OBJ (x)->handle)
340 mark_dynl_obj (SCM ptr
)
342 return DYNL_FILENAME (ptr
);
346 print_dynl_obj (SCM exp
,SCM port
,scm_print_state
*pstate
)
348 scm_puts ("#<dynamic-object ", port
);
349 scm_iprin1 (DYNL_FILENAME (exp
), port
, pstate
);
350 if (DYNL_HANDLE (exp
) == NULL
)
351 scm_puts (" (unlinked)", port
);
352 scm_putc ('>', port
);
356 static SCM kw_global
;
357 SCM_SYMBOL (sym_global
, "-global");
359 SCM_DEFINE (scm_dynamic_link
, "dynamic-link", 1, 0, 1,
360 (SCM fname
, SCM rest
),
361 "Open the dynamic library @var{library-file}. A library handle\n"
362 "representing the opened library is returned; this handle should be used\n"
363 "as the @var{lib} argument to the following functions.")
364 #define FUNC_NAME s_scm_dynamic_link
367 int flags
= DYNL_GLOBAL
;
369 SCM_COERCE_ROSTRING (1, fname
);
372 while (SCM_CONSP (rest
))
377 rest
= SCM_CDR (rest
);
379 if (!SCM_CONSP (rest
))
380 SCM_MISC_ERROR ("keyword without value", SCM_EOL
);
382 val
= SCM_CAR (rest
);
383 rest
= SCM_CDR (rest
);
387 if (SCM_FALSEP (val
))
388 flags
&= ~DYNL_GLOBAL
;
391 SCM_MISC_ERROR ("unknown keyword argument: ~A",
392 scm_cons (kw
, SCM_EOL
));
395 handle
= sysdep_dynl_link (SCM_CHARS (fname
), flags
, FUNC_NAME
);
397 SCM_RETURN_NEWSMOB2 (scm_tc16_dynamic_obj
, fname
, handle
);
401 static struct dynl_obj
*
402 get_dynl_obj (SCM dobj
, const char *subr
, int argn
)
405 SCM_ASSERT (SCM_NIMP (dobj
) && SCM_UNPACK_CAR (dobj
) == scm_tc16_dynamic_obj
,
408 SCM_ASSERT (d
->handle
!= NULL
, dobj
, argn
, subr
);
412 SCM_DEFINE (scm_dynamic_object_p
, "dynamic-object?", 1, 0, 0,
414 "Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}\n"
416 #define FUNC_NAME s_scm_dynamic_object_p
418 return SCM_BOOL (SCM_NIMP (obj
)
419 && SCM_UNPACK_CAR (obj
) == scm_tc16_dynamic_obj
);
423 SCM_DEFINE (scm_dynamic_unlink
, "dynamic-unlink", 1, 0, 0,
425 "Unlink the library represented by @var{library-handle}, and remove any\n"
426 "imported symbols from the address space.\n"
427 "GJB:FIXME:DOC: 2nd version below:\n"
428 "Unlink the indicated object file from the application. The argument\n"
429 "@var{dynobj} should be one of the values returned by\n"
430 "@code{dynamic-link}. When @code{dynamic-unlink} has been called on\n"
431 "@var{dynobj}, it is no longer usable as an argument to the functions\n"
432 "below and you will get type mismatch errors when you try to.\n"
434 #define FUNC_NAME s_scm_dynamic_unlink
436 /*fixme* GC-problem */
437 struct dynl_obj
*d
= get_dynl_obj (dobj
, FUNC_NAME
, SCM_ARG1
);
439 sysdep_dynl_unlink (d
->handle
, FUNC_NAME
);
442 return SCM_UNSPECIFIED
;
446 SCM_DEFINE (scm_dynamic_func
, "dynamic-func", 2, 0, 0,
447 (SCM symb
, SCM dobj
),
448 "Import the symbol @var{func} from @var{lib} (a dynamic library handle).\n"
449 "A @dfn{function handle} representing the imported function is returned.\n"
450 "GJB:FIXME:DOC: 2nd version below\n"
451 "Search the C function indicated by @var{function} (a string or symbol)\n"
452 "in @var{dynobj} and return some Scheme object that can later be used\n"
453 "with @code{dynamic-call} to actually call this function. Right now,\n"
454 "these Scheme objects are formed by casting the address of the function\n"
455 "to @code{long} and converting this number to its Scheme representation.\n\n"
456 "Regardless whether your C compiler prepends an underscore @samp{_} to\n"
457 "the global names in a program, you should @strong{not} include this\n"
458 "underscore in @var{function}. Guile knows whether the underscore is\n"
459 "needed or not and will add it when necessary.\n\n"
461 #define FUNC_NAME s_scm_dynamic_func
466 SCM_COERCE_ROSTRING (1, symb
);
467 /*fixme* GC-problem */
468 d
= get_dynl_obj (dobj
, FUNC_NAME
, SCM_ARG2
);
471 func
= (void (*) ()) sysdep_dynl_func (SCM_CHARS (symb
),
476 return scm_ulong2num ((unsigned long) func
);
480 SCM_DEFINE (scm_dynamic_call
, "dynamic-call", 2, 0, 0,
481 (SCM func
, SCM dobj
),
482 "Call @var{lib-thunk}, a procedure of no arguments. If @var{lib-thunk}\n"
483 "is a string, it is assumed to be a symbol found in the dynamic library\n"
484 "@var{lib} and is fetched with @code{dynamic-func}. Otherwise, it should\n"
485 "be a function handle returned by a previous call to @code{dynamic-func}.\n"
486 "The return value is unspecified.\n"
487 "GJB:FIXME:DOC 2nd version below\n"
488 "Call the C function indicated by @var{function} and @var{dynobj}. The\n"
489 "function is passed no arguments and its return value is ignored. When\n"
490 "@var{function} is something returned by @code{dynamic-func}, call that\n"
491 "function and ignore @var{dynobj}. When @var{function} is a string (or\n"
492 "symbol, etc.), look it up in @var{dynobj}; this is equivalent to\n\n"
494 "(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))\n"
495 "@end smallexample\n\n"
496 "Interrupts are deferred while the C function is executing (with\n"
497 "@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).\n"
499 #define FUNC_NAME s_scm_dynamic_call
503 if (SCM_ROSTRINGP (func
))
504 func
= scm_dynamic_func (func
, dobj
);
505 fptr
= (void (*) ()) SCM_NUM2ULONG (1, func
);
509 return SCM_UNSPECIFIED
;
513 SCM_DEFINE (scm_dynamic_args_call
, "dynamic-args-call", 3, 0, 0,
514 (SCM func
, SCM dobj
, SCM args
),
515 "Call @var{proc}, a dynamically loaded function, passing it the argument\n"
516 "list @var{args} (a list of strings). As with @code{dynamic-call},\n"
517 "@var{proc} should be either a function handle or a string, in which case\n"
518 "it is first fetched from @var{lib} with @code{dynamic-func}.\n\n"
519 "@var{proc} is assumed to return an integer, which is used as the return\n"
520 "value from @code{dynamic-args-call}.\n\n"
521 "GJB:FIXME:DOC 2nd version below\n"
522 "Call the C function indicated by @var{function} and @var{dynobj}, just\n"
523 "like @code{dynamic-call}, but pass it some arguments and return its\n"
524 "return value. The C function is expected to take two arguments and\n"
525 "return an @code{int}, just like @code{main}:\n\n"
527 "int c_func (int argc, char **argv);\n"
528 "@end smallexample\n\n"
529 "The parameter @var{args} must be a list of strings and is converted into\n"
530 "an array of @code{char *}. The array is passed in @var{argv} and its\n"
531 "size in @var{argc}. The return value is converted to a Scheme number\n"
532 "and returned from the call to @code{dynamic-args-call}.\n\n\n"
534 #define FUNC_NAME s_scm_dynamic_args_call
536 int (*fptr
) (int argc
, char **argv
);
540 if (SCM_ROSTRINGP (func
))
541 func
= scm_dynamic_func (func
, dobj
);
543 fptr
= (int (*) (int, char **)) SCM_NUM2ULONG (1, func
);
545 argv
= scm_make_argv_from_stringlist (args
, &argc
, FUNC_NAME
, SCM_ARG3
);
546 result
= (*fptr
) (argc
, argv
);
547 scm_must_free_argv (argv
);
550 return SCM_MAKINUM (0L + result
);
555 scm_init_dynamic_linking ()
557 scm_tc16_dynamic_obj
= scm_make_smob_type ("dynamic-object", 0);
558 scm_set_smob_mark (scm_tc16_dynamic_obj
, mark_dynl_obj
);
559 scm_set_smob_print (scm_tc16_dynamic_obj
, print_dynl_obj
);
562 kw_global
= scm_make_keyword_from_dash_symbol (sym_global
);