Mercurial > hg > xemacs-beta
annotate src/emodules.c @ 5538:580ef98f2beb
Suppress a "shadowed global" warning.
The warning is for j1 from <math.h> on Darwin.
| author | Stephen J. Turnbull <stephen@xemacs.org> |
|---|---|
| date | Mon, 08 Aug 2011 13:57:18 +0900 |
| parents | b9167d522a9a |
| children | 56144c8593a8 |
| rev | line source |
|---|---|
| 428 | 1 /* emodules.c - Support routines for dynamic module loading |
| 2 (C) Copyright 1998, 1999 J. Kean Johnston. All rights reserved. | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3 (C) Copyright 2010 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5169
diff
changeset
|
7 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 8 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5169
diff
changeset
|
9 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5169
diff
changeset
|
10 option) any later version. |
| 428 | 11 |
| 12 XEmacs 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 GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5169
diff
changeset
|
18 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 428 | 19 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
20 /* This file has been Mule-ized, Ben Wing, 1-26-10. */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
21 |
| 428 | 22 #include "emodules.h" |
| 23 #include "sysdll.h" | |
| 2078 | 24 #ifdef HAVE_LTDL |
| 25 #include <ltdl.h> | |
| 26 #endif | |
| 428 | 27 |
| 1750 | 28 /* Load path */ |
| 29 static Lisp_Object Vmodule_load_path; | |
| 30 | |
| 31 /* Module lFile extensions */ | |
| 32 static Lisp_Object Vmodule_extensions; | |
| 33 | |
| 428 | 34 #ifdef HAVE_SHLIB |
| 35 | |
| 36 /* CE-Emacs version number */ | |
| 37 Lisp_Object Vmodule_version; | |
| 38 | |
| 39 /* Do we do our work quietly? */ | |
| 40 int load_modules_quietly; | |
| 41 | |
| 996 | 42 /* Set this while unloading a module. This should NOT be made set by users, |
| 43 as it allows the unbinding of symbol-value-forward variables. */ | |
| 44 int unloading_module; | |
| 45 | |
| 564 | 46 Lisp_Object Qdll_error; |
| 996 | 47 Lisp_Object Qmodule, Qunload_module, module_tag; |
| 564 | 48 |
| 428 | 49 typedef struct _emodules_list |
| 50 { | |
| 996 | 51 int used; /* Is this slot used? */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
52 Ibyte *soname; /* Name of the shared object loaded (full path) */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
53 Ibyte *modname; /* The name of the module */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
54 Ibyte *modver; /* The module version string */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
55 Ibyte *modtitle; /* How the module announces itself */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
56 void (*unload) (void);/* Module cleanup function to run before unloading */ |
| 996 | 57 dll_handle dlhandle; /* Dynamic lib handle */ |
| 428 | 58 } emodules_list; |
| 59 | |
| 60 static int emodules_depth; | |
| 61 static dll_handle dlhandle; | |
| 62 static emodules_list *modules; | |
| 63 static int modnum; | |
| 64 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
65 static int find_make_module (Lisp_Object mod, const Ibyte *name, |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
66 const Ibyte *ver, int make_or_find); |
| 428 | 67 static Lisp_Object module_load_unwind (Lisp_Object); |
| 68 static void attempt_module_delete (int mod); | |
| 69 | |
| 70 DEFUN ("load-module", Fload_module, 1, 3, "FLoad dynamic module: ", /* | |
| 71 Load in a C Emacs Extension module named FILE. | |
| 72 The optional NAME and VERSION are used to identify specific modules. | |
| 73 | |
| 996 | 74 DO NOT USE THIS FUNCTION in your programs. Use `require' instead. |
| 75 | |
| 428 | 76 This function is similar in intent to `load' except that it loads in |
| 77 pre-compiled C or C++ code, using dynamic shared objects. If NAME is | |
| 78 specified, then the module is only loaded if its internal name matches | |
| 79 the NAME specified. If VERSION is specified, then the module is only | |
| 80 loaded if it matches that VERSION. This function will check to make | |
| 81 sure that the same module is not loaded twice. Modules are searched | |
| 82 for in the same way as Lisp files, except that the valid file | |
| 1632 | 83 extensions are `.so', `.dll', `.ell', or `.dylib'. |
| 428 | 84 |
| 85 All symbols in the shared module must be completely resolved in order | |
| 86 for this function to be successful. Any modules which the specified | |
| 87 FILE depends on will be automatically loaded. You can determine which | |
| 88 modules have been loaded as dynamic shared objects by examining the | |
| 89 return value of the function `list-modules'. | |
| 90 | |
| 996 | 91 It is possible, although unwise, to unload modules using `unload-feature'. |
| 442 | 92 The preferred mechanism for unloading or reloading modules is to quit |
| 428 | 93 XEmacs, and then reload those new or changed modules that are required. |
| 94 | |
| 95 Messages informing you of the progress of the load are displayed unless | |
| 96 the variable `load-modules-quietly' is non-NIL. | |
| 97 */ | |
| 444 | 98 (file, name, version)) |
| 428 | 99 { |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
100 const Ibyte *mod, *mname, *mver; |
| 428 | 101 int speccount = specpdl_depth(); |
| 102 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
103 CHECK_STRING (file); |
| 428 | 104 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
105 mod = XSTRING_DATA (file); |
| 428 | 106 |
| 107 if (NILP (name)) | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
108 mname = (const Ibyte *) ""; |
| 428 | 109 else |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
110 mname = XSTRING_DATA (name); |
| 428 | 111 |
| 112 if (NILP (version)) | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
113 mver = (const Ibyte *) ""; |
| 428 | 114 else |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
115 mver = XSTRING_DATA (version); |
| 428 | 116 |
| 117 dlhandle = 0; | |
| 118 record_unwind_protect (module_load_unwind, make_int(modnum)); | |
| 119 emodules_load (mod, mname, mver); | |
| 771 | 120 unbind_to (speccount); |
| 428 | 121 |
| 122 return Qt; | |
| 123 } | |
| 124 | |
| 996 | 125 DEFUN ("unload-module", Funload_module, 1, 3, 0, /* |
| 126 Unload a module previously loaded with load-module. | |
| 428 | 127 |
| 996 | 128 DO NOT USE THIS FUNCTION in your programs. Use `unload-feature' instead. |
| 428 | 129 |
| 130 As with load-module, this function requires at least the module FILE, and | |
| 131 optionally the module NAME and VERSION to unload. It may not be possible | |
| 132 for the module to be unloaded from memory, as there may be Lisp objects | |
| 442 | 133 referring to variables inside the module code. However, once you have |
| 428 | 134 requested a module to be unloaded, it will be unloaded from memory as |
| 135 soon as the last reference to symbols within the module is destroyed. | |
| 136 */ | |
| 444 | 137 (file, name, version)) |
| 428 | 138 { |
| 139 int x; | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
140 const Ibyte *mname, *mver; |
| 996 | 141 Lisp_Object foundname = Qnil; |
| 142 struct gcpro gcpro1; | |
| 428 | 143 |
| 144 CHECK_STRING(file); | |
| 145 | |
| 996 | 146 GCPRO1 (foundname); |
| 147 if (locate_file (Vmodule_load_path, file, Vmodule_extensions, &foundname, 0) | |
| 148 < 0) | |
| 149 return Qt; | |
| 150 UNGCPRO; | |
| 428 | 151 |
| 152 if (NILP (name)) | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
153 mname = (const Ibyte *) ""; |
| 428 | 154 else |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
155 mname = XSTRING_DATA (name); |
| 428 | 156 |
| 157 if (NILP (version)) | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
158 mver = (const Ibyte *) ""; |
| 428 | 159 else |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
160 mver = XSTRING_DATA (version); |
| 428 | 161 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
162 x = find_make_module (foundname, mname, mver, 1); |
| 428 | 163 if (x != -1) |
| 996 | 164 { |
| 165 if (modules[x].unload != NULL) | |
| 166 modules[x].unload (); | |
| 167 attempt_module_delete (x); | |
| 168 } | |
| 428 | 169 return Qt; |
| 170 } | |
| 171 | |
| 172 DEFUN ("list-modules", Flist_modules, 0, 0, "", /* | |
| 173 Produce a list of loaded dynamic modules. | |
| 174 | |
| 175 This function will return a list of all the loaded dynamic modules. | |
| 176 Each element in the list is a list in the form (SONAME NAME VER DESC), | |
| 177 where SONAME is the name of the shared object that was loaded, NAME | |
| 178 is the internal module name, VER is the version of the module, and DESC | |
| 179 is how the module describes itself. | |
| 180 | |
| 181 This function returns a list, so you will need to assign the return value | |
| 182 to a variable and then examine the variable with `describe-variable'. | |
| 183 For example: | |
| 184 | |
| 185 (setq mylist (list-modules)) | |
| 186 (describe-variable 'mylist) | |
| 187 | |
| 188 | |
| 189 NOTE: It is possible for the same module to be loaded more than once, | |
| 190 at different versions. However, you should never see the same module, | |
| 191 with the same name and version, loaded more than once. If you do, this | |
| 192 is a bug, and you are encouraged to report it. | |
| 193 */ | |
| 194 ()) | |
| 195 { | |
| 196 Lisp_Object mlist = Qnil; | |
| 197 int i; | |
| 198 | |
| 199 for (i = 0; i < modnum; i++) | |
| 200 { | |
| 201 if (modules[i].used == 1) | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
202 mlist = Fcons (list4 (build_istring (modules[i].soname), |
|
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
203 build_istring (modules[i].modname), |
|
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
204 build_istring (modules[i].modver), |
|
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
205 build_istring (modules[i].modtitle)), mlist); |
| 428 | 206 } |
| 207 | |
| 208 return mlist; | |
| 209 } | |
| 210 | |
| 211 static int | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
212 find_make_module (Lisp_Object mod, const Ibyte *name, const Ibyte *ver, |
| 1706 | 213 int mof) |
| 428 | 214 { |
| 215 int i, fs = -1; | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
216 Ibyte *modstr = XSTRING_DATA (mod); |
| 428 | 217 |
| 218 for (i = 0; i < modnum; i++) | |
| 219 { | |
| 220 if (fs == -1 && modules[i].used == 0) | |
| 221 fs = i; | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
222 if (qxestrcmp (modules[i].soname, modstr) == 0) |
| 428 | 223 { |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
224 if (name && name[0] && qxestrcmp (modules[i].modname, name)) |
| 428 | 225 continue; |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
226 if (ver && ver[0] && qxestrcmp (modules[i].modver, ver)) |
| 428 | 227 continue; |
| 228 return i; /* Found a match */ | |
| 229 } | |
| 230 } | |
| 231 | |
| 232 if (mof) | |
| 233 return fs; | |
| 234 | |
| 235 if (fs != -1) | |
| 236 return fs; /* First free slot */ | |
| 237 | |
| 238 /* | |
| 442 | 239 * We only get here if we haven't found a free slot and the module was |
| 428 | 240 * not previously loaded. |
| 241 */ | |
| 1706 | 242 if (modules == NULL) |
| 2367 | 243 modules = xnew (emodules_list); |
| 428 | 244 modnum++; |
| 2367 | 245 XREALLOC_ARRAY (modules, emodules_list, modnum); |
| 428 | 246 |
| 247 fs = modnum - 1; | |
| 2367 | 248 memset (&modules[fs], 0, sizeof (emodules_list)); |
| 428 | 249 return fs; |
| 250 } | |
| 251 | |
| 252 static void | |
| 253 attempt_module_delete (int mod) | |
| 254 { | |
| 255 if (dll_close (modules[mod].dlhandle) == 0) | |
| 256 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
257 xfree (modules[mod].soname); |
|
5169
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
258 modules[mod].soname = 0; |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
259 xfree (modules[mod].modname); |
|
5169
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
260 modules[mod].modname = 0; |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
261 xfree (modules[mod].modver); |
|
5169
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
262 modules[mod].modver = 0; |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
263 xfree (modules[mod].modtitle); |
|
5169
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
264 modules[mod].modtitle = 0; |
| 428 | 265 modules[mod].dlhandle = 0; |
| 266 modules[mod].used = 0; | |
| 267 } | |
| 268 else if (modules[mod].used > 1) | |
| 269 modules[mod].used = 1; /* We couldn't delete it - it stays */ | |
| 270 } | |
| 271 | |
| 272 static Lisp_Object | |
| 273 module_load_unwind (Lisp_Object upto) | |
| 274 { | |
| 275 int x,l=0; | |
| 276 | |
| 277 /* | |
| 278 * First close off the current handle if it is open. | |
| 279 */ | |
| 280 if (dlhandle != 0) | |
| 281 dll_close (dlhandle); | |
| 282 dlhandle = 0; | |
| 283 | |
| 284 if (CONSP (upto)) | |
| 285 { | |
| 286 if (INTP (XCAR (upto))) | |
| 287 l = XINT (XCAR (upto)); | |
| 853 | 288 free_cons (upto); |
| 428 | 289 } |
| 290 else | |
| 291 l = XINT (upto); | |
| 292 | |
| 293 /* | |
| 294 * Here we need to go through and dlclose() (IN REVERSE ORDER!) any | |
| 295 * modules that were loaded as part of this load chain. We only mark | |
| 296 * the slots as closed if the dlclose() succeeds. | |
| 297 */ | |
| 298 for (x = modnum-1; x >= l; x--) | |
| 299 { | |
| 300 if (modules[x].used > 1) | |
| 301 attempt_module_delete (x); | |
| 302 } | |
| 303 emodules_depth = 0; | |
| 304 | |
| 305 return Qnil; | |
| 306 } | |
| 307 | |
| 308 /* | |
| 309 * Do the actual grunt-work of loading in a module. We first try and | |
| 310 * dlopen() the module. If that fails, we have an error and we bail | |
| 311 * out immediately. If the dlopen() succeeds, we need to check for the | |
| 442 | 312 * existence of certain special symbols. |
| 428 | 313 * |
| 314 * All modules will have complete access to the variables and functions | |
| 315 * defined within XEmacs itself. It is up to the module to declare any | |
| 316 * variables or functions it uses, however. Modules will also have access | |
| 317 * to other functions and variables in other loaded modules, unless they | |
| 318 * are defined as STATIC. | |
| 319 * | |
| 320 * We need to be very careful with how we load modules. If we encounter an | |
| 321 * error along the way, we need to back out completely to the point at | |
| 442 | 322 * which the user started. Since we can be called recursively, we need to |
| 428 | 323 * take care with marking modules as loaded. When we first start loading |
| 324 * modules, we set the counter to zero. As we enter the function each time, | |
| 442 | 325 * we increment the counter, and before we leave we decrement it. When |
| 428 | 326 * we get back down to 0, we know we are at the end of the chain and we |
| 327 * can mark all the modules in the list as loaded. | |
| 328 * | |
| 329 * When we signal an error, we need to be sure to unwind all modules loaded | |
| 330 * thus far (but only for this module chain). It is assumed that if any | |
| 331 * modules in a chain fail, then they all do. This is logical, considering | |
| 442 | 332 * that the only time we recurse is when we have dependent modules. So in |
| 428 | 333 * the error handler we take great care to close off the module chain before |
| 334 * we call "error" and let the Fmodule_load unwind_protect() function handle | |
| 335 * the cleaning up. | |
| 336 */ | |
| 337 void | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
338 emodules_load (const Ibyte *module, const Ibyte *modname, |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
339 const Ibyte *modver) |
| 428 | 340 { |
| 996 | 341 Lisp_Object old_load_list; |
| 428 | 342 Lisp_Object filename; |
| 996 | 343 Lisp_Object foundname, lisp_modname; |
| 344 int x, mpx; | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
345 const Extbyte **f; |
| 442 | 346 const long *ellcc_rev; |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
347 Ibyte *mver, *mname, *mtitle, *symname; |
| 428 | 348 void (*modload)(void) = 0; |
| 349 void (*modsyms)(void) = 0; | |
| 350 void (*modvars)(void) = 0; | |
| 351 void (*moddocs)(void) = 0; | |
| 996 | 352 void (*modunld)(void) = 0; |
| 428 | 353 emodules_list *mp; |
| 996 | 354 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; |
| 428 | 355 |
| 356 filename = Qnil; | |
| 357 foundname = Qnil; | |
| 358 | |
| 359 emodules_depth++; | |
| 360 dlhandle = 0; | |
| 361 | |
| 1706 | 362 if (module == NULL || module[0] == '\0') |
| 563 | 363 invalid_argument ("Empty module name", Qunbound); |
| 428 | 364 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
365 GCPRO4 (filename, foundname, old_load_list, lisp_modname); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
366 filename = build_istring (module); |
| 996 | 367 if (locate_file (Vmodule_load_path, filename, Vmodule_extensions, |
| 368 &foundname, 0) < 0) | |
| 563 | 369 signal_error (Qdll_error, "Cannot open dynamic module", filename); |
| 428 | 370 |
| 996 | 371 lisp_modname = call1 (Qfile_name_sans_extension, |
| 372 Ffile_name_nondirectory (foundname)); | |
| 428 | 373 |
| 1706 | 374 dlhandle = dll_open (foundname); |
| 375 if (dlhandle == NULL) | |
| 563 | 376 { |
| 1811 | 377 signal_error (Qdll_error, "Opening dynamic module", dll_error ()); |
| 563 | 378 } |
| 428 | 379 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
380 ellcc_rev = (const long *) dll_variable (dlhandle, |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
381 (const Ibyte *) "emodule_compiler"); |
| 1706 | 382 if (ellcc_rev == NULL || *ellcc_rev <= 0L) |
| 563 | 383 signal_error (Qdll_error, "Invalid dynamic module: Missing symbol `emodule_compiler'", Qunbound); |
| 428 | 384 if (*ellcc_rev > EMODULES_REVISION) |
| 563 | 385 signal_ferror (Qdll_error, "Invalid dynamic module: Unsupported version `%ld(%ld)'", *ellcc_rev, EMODULES_REVISION); |
| 428 | 386 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
387 f = (const Extbyte **) dll_variable (dlhandle, |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
388 (const Ibyte *) "emodule_name"); |
| 1706 | 389 if (f == NULL || *f == NULL) |
| 563 | 390 signal_error (Qdll_error, "Invalid dynamic module: Missing symbol `emodule_name'", Qunbound); |
|
5293
63f247c5da0a
In emodules_load(), dereference f = dll_variable() once more.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5169
diff
changeset
|
391 mname = EXTERNAL_TO_ITEXT (*f, Qemodule_string_encoding); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
392 |
| 428 | 393 if (mname[0] == '\0') |
| 563 | 394 signal_error (Qdll_error, "Invalid dynamic module: Empty value for `emodule_name'", Qunbound); |
| 428 | 395 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
396 f = (const Extbyte **) dll_variable (dlhandle, |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
397 (const Ibyte *) "emodule_version"); |
| 1706 | 398 if (f == NULL || *f == NULL) |
| 563 | 399 signal_error (Qdll_error, "Missing symbol `emodule_version': Invalid dynamic module", Qunbound); |
|
5293
63f247c5da0a
In emodules_load(), dereference f = dll_variable() once more.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5169
diff
changeset
|
400 mver = EXTERNAL_TO_ITEXT (*f, Qemodule_string_encoding); |
| 428 | 401 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
402 f = (const Extbyte **) dll_variable (dlhandle, |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
403 (const Ibyte *) "emodule_title"); |
| 1706 | 404 if (f == NULL || *f == NULL) |
| 563 | 405 signal_error (Qdll_error, "Invalid dynamic module: Missing symbol `emodule_title'", Qunbound); |
|
5293
63f247c5da0a
In emodules_load(), dereference f = dll_variable() once more.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5169
diff
changeset
|
406 mtitle = EXTERNAL_TO_ITEXT (*f, Qemodule_string_encoding); |
| 428 | 407 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
408 symname = alloca_ibytes (qxestrlen (mname) + 15); |
| 428 | 409 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
410 qxestrcpy_ascii (symname, "modules_of_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
411 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
412 modload = (void (*)(void)) dll_function (dlhandle, symname); |
| 428 | 413 /* |
| 442 | 414 * modload is optional. If the module doesn't require other modules it can |
| 428 | 415 * be left out. |
| 416 */ | |
| 417 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
418 qxestrcpy_ascii (symname, "syms_of_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
419 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
420 modsyms = (void (*)(void)) dll_function (dlhandle, symname); |
| 1706 | 421 if (modsyms == NULL) |
| 563 | 422 { |
| 423 missing_symbol: | |
| 424 signal_error (Qdll_error, "Invalid dynamic module: Missing symbol", | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
425 build_istring (symname)); |
| 563 | 426 } |
| 428 | 427 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
428 qxestrcpy_ascii (symname, "vars_of_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
429 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
430 modvars = (void (*)(void)) dll_function (dlhandle, symname); |
| 1706 | 431 if (modvars == NULL) |
| 563 | 432 goto missing_symbol; |
| 428 | 433 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
434 qxestrcpy_ascii (symname, "docs_of_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
435 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
436 moddocs = (void (*)(void)) dll_function (dlhandle, symname); |
| 1706 | 437 if (moddocs == NULL) |
| 563 | 438 goto missing_symbol; |
| 428 | 439 |
| 996 | 440 /* Now look for the optional unload function. */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
441 qxestrcpy_ascii (symname, "unload_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
442 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
443 modunld = (void (*)(void)) dll_function (dlhandle, symname); |
| 996 | 444 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
445 if (modname && modname[0] && qxestrcmp (modname, mname)) |
| 563 | 446 signal_error (Qdll_error, "Module name mismatch", Qunbound); |
| 428 | 447 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
448 if (modver && modver[0] && qxestrcmp (modver, mver)) |
| 563 | 449 signal_error (Qdll_error, "Module version mismatch", Qunbound); |
| 428 | 450 |
| 451 /* | |
| 452 * Attempt to make a new slot for this module. If this really is the | |
| 453 * first time we are loading this module, the used member will be 0. | |
| 454 * If that is non-zero, we know that we have a previously loaded module | |
| 442 | 455 * of the same name and version, and we don't need to go any further. |
| 428 | 456 */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
457 mpx = find_make_module (foundname, mname, mver, 0); |
| 428 | 458 mp = &modules[mpx]; |
| 459 if (mp->used > 0) | |
| 460 { | |
| 461 emodules_depth--; | |
| 462 dll_close (dlhandle); | |
| 806 | 463 dlhandle = 0; /* Zero this out before module_load_unwind runs */ |
| 428 | 464 return; |
| 465 } | |
| 466 | |
| 467 if (!load_modules_quietly) | |
| 468 message ("Loading %s v%s (%s)", mname, mver, mtitle); | |
| 469 | |
| 470 /* | |
| 471 * We have passed the basic initialization, and can now add this | |
| 472 * module to the list of modules. | |
| 473 */ | |
| 474 mp->used = emodules_depth + 1; | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
475 mp->soname = qxestrdup (XSTRING_DATA (foundname)); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
476 mp->modname = qxestrdup (mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
477 mp->modver = qxestrdup (mver); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
478 mp->modtitle = qxestrdup (mtitle); |
| 428 | 479 mp->dlhandle = dlhandle; |
| 996 | 480 mp->unload = modunld; |
| 428 | 481 dlhandle = 0; |
| 482 | |
| 996 | 483 old_load_list = Vcurrent_load_list; |
| 484 Vcurrent_load_list = Qnil; | |
| 485 LOADHIST_ATTACH (lisp_modname); | |
| 486 LOADHIST_ATTACH (module_tag); | |
| 487 | |
| 428 | 488 /* |
| 489 * Now we need to call the module init function and perform the various | |
| 490 * startup tasks. | |
| 491 */ | |
| 492 if (modload != 0) | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
493 (*modload) (); |
| 428 | 494 |
| 495 /* | |
| 496 * Now we can get the module to initialize its symbols, and then its | |
| 497 * variables, and lastly the documentation strings. | |
| 498 */ | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
499 (*modsyms) (); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
500 (*modvars) (); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
501 (*moddocs) (); |
| 428 | 502 |
| 503 if (!load_modules_quietly) | |
| 504 message ("Loaded module %s v%s (%s)", mname, mver, mtitle); | |
| 505 | |
| 996 | 506 Vload_history = Fcons (Fnreverse (Vcurrent_load_list), Vload_history); |
| 507 Vcurrent_load_list = old_load_list; | |
| 508 UNGCPRO; | |
| 428 | 509 |
| 510 emodules_depth--; | |
| 511 if (emodules_depth == 0) | |
| 512 { | |
| 513 /* | |
| 514 * We have reached the end of the load chain. We now go through the | |
| 515 * list of loaded modules and mark all the valid modules as just | |
| 516 * that. | |
| 517 */ | |
| 518 for (x = 0; x < modnum; x++) | |
| 519 if (modules[x].used > 1) | |
| 520 modules[x].used = 1; | |
| 521 } | |
| 522 } | |
| 523 | |
| 524 void | |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
525 emodules_doc_subr (const Ascbyte *symname, const Ascbyte *doc) |
| 428 | 526 { |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
527 Bytecount len; |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
528 Lisp_Object sym; |
| 440 | 529 Lisp_Subr *subr; |
| 428 | 530 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
531 ASSERT_ASCTEXT_ASCII (symname); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
532 len = strlen (symname); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
533 sym = oblookup (Vobarray, (const Ibyte *) symname, len); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
534 |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
535 /* We do this assert to avoid the possibility of externally formatted |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
536 text ending up in the doc string, where it could cause crashes. |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
537 It you need to have a non-ASCII doc string, create another version |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
538 emodules_doc_subr_istring() that accepts an Ibyte * and doesn't |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
539 assert, or create an emodules_doc_subr_extstring() that takes |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
540 an externally_formatted string and a coding system name. */ |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
541 ASSERT_ASCTEXT_ASCII (doc); |
| 1632 | 542 /* Skip autoload cookies */ |
| 543 if (SYMBOLP (sym) && SUBRP (XSYMBOL (sym)->function)) | |
| 428 | 544 { |
| 1632 | 545 subr = XSUBR (XSYMBOL (sym)->function); |
| 428 | 546 subr->doc = xstrdup (doc); |
| 547 } | |
| 548 /* | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
549 * #### FIXME: I wish there was some way to avoid the xstrdup(). Is it |
| 428 | 550 * possible to just set a pointer to the string, or somehow create a |
| 551 * symbol whose value we can point to the constant string? Can someone | |
| 552 * look into this? | |
| 553 */ | |
| 554 } | |
| 555 | |
| 556 void | |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
557 emodules_doc_sym (const Ascbyte *symname, const Ascbyte *doc) |
| 428 | 558 { |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
559 Bytecount len; |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
560 Lisp_Object sym; |
| 428 | 561 Lisp_Object docstr; |
| 562 struct gcpro gcpro1; | |
| 563 | |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
564 ASSERT_ASCTEXT_ASCII (symname); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
565 len = strlen (symname); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
566 sym = oblookup (Vobarray, (const Ibyte *) symname, len); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
567 |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
568 /* See comments above in emodules_doc_subr() about why we assert like |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
569 this. */ |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
570 ASSERT_ASCTEXT_ASCII (doc); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
571 if (SYMBOLP (sym)) |
| 428 | 572 { |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
573 docstr = build_ascstring (doc); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
574 GCPRO1 (docstr); |
| 428 | 575 Fput (sym, Qvariable_documentation, docstr); |
| 576 UNGCPRO; | |
| 577 } | |
| 578 } | |
| 579 | |
| 580 | |
| 581 void | |
| 582 syms_of_module (void) | |
| 583 { | |
| 564 | 584 DEFERROR_STANDARD (Qdll_error, Qerror); |
| 996 | 585 DEFSYMBOL (Qmodule); |
| 586 DEFSYMBOL (Qunload_module); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
587 DEFSUBR (Fload_module); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
588 DEFSUBR (Flist_modules); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
589 DEFSUBR (Funload_module); |
| 996 | 590 module_tag = Fcons (Qmodule, Qnil); |
| 591 staticpro (&module_tag); | |
| 592 Fput (Qunload_module, Qdisabled, Qt); | |
| 428 | 593 } |
| 594 | |
| 595 void | |
| 596 reinit_vars_of_module (void) | |
| 597 { | |
| 598 emodules_depth = 0; | |
| 1706 | 599 modules = NULL; |
| 428 | 600 modnum = 0; |
| 601 } | |
| 602 | |
| 1750 | 603 #endif /* HAVE_SHLIB */ |
| 604 | |
| 428 | 605 void |
| 606 vars_of_module (void) | |
| 607 { | |
| 1750 | 608 #ifdef HAVE_SHLIB |
| 609 Fprovide (intern ("modules")); | |
| 610 | |
| 2078 | 611 #ifdef HAVE_LTDL |
| 612 lt_dlinit (); | |
| 613 lt_dlmalloc = (lt_ptr (*) (size_t)) xmalloc; | |
| 614 lt_dlrealloc = (lt_ptr (*) (lt_ptr, size_t)) xrealloc; | |
| 615 lt_dlfree = (void (*) (lt_ptr)) xfree_1; | |
| 616 #endif | |
| 617 | |
| 428 | 618 DEFVAR_LISP ("module-version", &Vmodule_version /* |
| 619 Emacs dynamic loading mechanism version, as a string. | |
| 620 | |
| 621 This string is in the form XX.YY.ppp, where XX is the major version | |
| 622 number, YY is the minor version number, and ppp is the patch level. | |
| 442 | 623 This variable can be used to distinguish between different versions of |
| 428 | 624 the dynamic loading technology used in Emacs, if required. It is not |
| 625 a given that this value will be the same as the Emacs version number. | |
| 626 */ ); | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
627 Vmodule_version = build_cistring (EMODULES_VERSION); |
| 428 | 628 |
| 629 DEFVAR_BOOL ("load-modules-quietly", &load_modules_quietly /* | |
| 630 *Set to t if module loading is to be silent. | |
| 631 | |
| 632 Normally, when loading dynamic modules, Emacs will inform you of its | |
| 633 progress, and will display the module name and version if the module | |
| 634 is loaded correctly. Setting this variable to `t' will suppress these | |
| 635 messages. This would normally only be done if `load-module' was being | |
| 636 called by a Lisp function. | |
| 637 */); | |
| 1733 | 638 load_modules_quietly = 0; |
| 428 | 639 |
| 1750 | 640 DEFVAR_BOOL ("unloading-module", &unloading_module /* |
| 641 Used internally by `unload-feature'. Do not set this variable. | |
| 642 Danger, danger, Will Robinson! | |
| 643 */); | |
| 644 unloading_module = 0; | |
| 645 | |
| 646 #endif /* HAVE_SHLIB */ | |
| 647 | |
| 428 | 648 DEFVAR_LISP ("module-load-path", &Vmodule_load_path /* |
| 649 *List of directories to search for dynamic modules to load. | |
| 650 Each element is a string (directory name) or nil (try default directory). | |
| 651 | |
| 652 Note that elements of this list *may not* begin with "~", so you must | |
| 442 | 653 call `expand-file-name' on them before adding them to this list. |
| 428 | 654 |
| 655 Initialized based on EMACSMODULEPATH environment variable, if any, otherwise | |
| 656 to default specified the file `paths.h' when XEmacs was built. If there | |
| 657 were no paths specified in `paths.h', then XEmacs chooses a default | |
| 658 value for this variable by looking around in the file-system near the | |
| 659 directory in which the XEmacs executable resides. | |
| 660 | |
| 661 Due to the nature of dynamic modules, the path names should almost always | |
| 442 | 662 refer to architecture-dependent directories. It is unwise to attempt to |
| 663 store dynamic modules in a heterogenous environment. Some environments | |
| 428 | 664 are similar enough to each other that XEmacs will be unable to determine |
| 665 the correctness of a dynamic module, which can have unpredictable results | |
| 666 when a dynamic module is loaded. | |
| 667 */); | |
| 1733 | 668 Vmodule_load_path = Qnil; |
| 428 | 669 |
| 1733 | 670 DEFVAR_LISP ("module-extensions", &Vmodule_extensions /* |
| 671 *List of filename extensions to use when searching for dynamic modules. | |
| 672 */); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
673 Vmodule_extensions = list5 (build_ascstring (".ell"), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
674 build_ascstring (".so"), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
675 build_ascstring (".dll"), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
676 build_ascstring (".dylib"), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
677 build_ascstring ("")); |
| 428 | 678 } |