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