Mercurial > hg > xemacs-beta
annotate src/emodules.c @ 5139:a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
the other stuff related to the file they're in. In the process, fix a few
places with incorrect initialization of symbols and variables.
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-03-12 Ben Wing <ben@xemacs.org>
* lisp.h:
* lisp.h (redo-symbols): Removed.
Put the Lisp variables and symbols where they belong, with other
stuff related to the file they're in.
* event-Xt.c (THIS_IS_X):
* event-Xt.c (syms_of_event_Xt):
* event-Xt.c (reinit_vars_of_event_Xt):
* event-gtk.c:
* event-gtk.c (syms_of_event_gtk):
* event-gtk.c (reinit_vars_of_event_gtk):
* event-stream.c:
* event-stream.c (syms_of_event_stream):
* event-stream.c (reinit_vars_of_event_stream):
* events.c (reinit_vars_of_events):
* events.c (vars_of_events):
`sans-modifiers' was defsymbol'ed more than once. Move it to
events-stream.c. `self-insert-command' was defsymbol'ed more than once.
Vevent_resource should be staticpro_nodump()ed as it's declared in
a reinit_*() method.
* lread.c (vars_of_lread):
Vfile_domain wasn't staticpro'ed.
* minibuf.c:
* minibuf.c (reinit_complex_vars_of_minibuf):
Vminibuffer_zero and Vecho_area_buffer weren't staticpro'ed.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 12 Mar 2010 20:23:50 -0600 |
| parents | 3c3c1d139863 |
| children | 6c6d78781d59 |
| 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 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
259 xfree (modules[mod].soname); |
|
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
260 xfree (modules[mod].modname); |
|
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
261 xfree (modules[mod].modver); |
|
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
262 xfree (modules[mod].modtitle); |
| 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 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
378 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
|
379 (const Ibyte *) "emodule_compiler"); |
| 1706 | 380 if (ellcc_rev == NULL || *ellcc_rev <= 0L) |
| 563 | 381 signal_error (Qdll_error, "Invalid dynamic module: Missing symbol `emodule_compiler'", Qunbound); |
| 428 | 382 if (*ellcc_rev > EMODULES_REVISION) |
| 563 | 383 signal_ferror (Qdll_error, "Invalid dynamic module: Unsupported version `%ld(%ld)'", *ellcc_rev, EMODULES_REVISION); |
| 428 | 384 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
385 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
|
386 (const Ibyte *) "emodule_name"); |
| 1706 | 387 if (f == NULL || *f == NULL) |
| 563 | 388 signal_error (Qdll_error, "Invalid dynamic module: Missing symbol `emodule_name'", Qunbound); |
| 428 | 389 |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
390 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
|
391 /* #### 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
|
392 code did so */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
393 IBYTE_STRING_TO_ALLOCA (mname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
394 |
| 428 | 395 if (mname[0] == '\0') |
| 563 | 396 signal_error (Qdll_error, "Invalid dynamic module: Empty value for `emodule_name'", Qunbound); |
| 428 | 397 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
398 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
|
399 (const Ibyte *) "emodule_version"); |
| 1706 | 400 if (f == NULL || *f == NULL) |
| 563 | 401 signal_error (Qdll_error, "Missing symbol `emodule_version': Invalid dynamic module", Qunbound); |
| 428 | 402 |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
403 mver = 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
|
404 /* #### 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
|
405 code did so */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
406 IBYTE_STRING_TO_ALLOCA (mver, mver); |
| 428 | 407 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
408 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
|
409 (const Ibyte *) "emodule_title"); |
| 1706 | 410 if (f == NULL || *f == NULL) |
| 563 | 411 signal_error (Qdll_error, "Invalid dynamic module: Missing symbol `emodule_title'", Qunbound); |
| 428 | 412 |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4956
diff
changeset
|
413 mtitle = 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
|
414 /* #### 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
|
415 code did so */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
416 IBYTE_STRING_TO_ALLOCA (mtitle, mtitle); |
| 428 | 417 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
418 symname = alloca_ibytes (qxestrlen (mname) + 15); |
| 428 | 419 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
420 qxestrcpy_ascii (symname, "modules_of_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
421 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
422 modload = (void (*)(void)) dll_function (dlhandle, symname); |
| 428 | 423 /* |
| 442 | 424 * modload is optional. If the module doesn't require other modules it can |
| 428 | 425 * be left out. |
| 426 */ | |
| 427 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
428 qxestrcpy_ascii (symname, "syms_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 modsyms = (void (*)(void)) dll_function (dlhandle, symname); |
| 1706 | 431 if (modsyms == NULL) |
| 563 | 432 { |
| 433 missing_symbol: | |
| 434 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
|
435 build_istring (symname)); |
| 563 | 436 } |
| 428 | 437 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
438 qxestrcpy_ascii (symname, "vars_of_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
439 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
440 modvars = (void (*)(void)) dll_function (dlhandle, symname); |
| 1706 | 441 if (modvars == NULL) |
| 563 | 442 goto missing_symbol; |
| 428 | 443 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
444 qxestrcpy_ascii (symname, "docs_of_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
445 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
446 moddocs = (void (*)(void)) dll_function (dlhandle, symname); |
| 1706 | 447 if (moddocs == NULL) |
| 563 | 448 goto missing_symbol; |
| 428 | 449 |
| 996 | 450 /* 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
|
451 qxestrcpy_ascii (symname, "unload_"); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
452 qxestrcat (symname, mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
453 modunld = (void (*)(void)) dll_function (dlhandle, symname); |
| 996 | 454 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
455 if (modname && modname[0] && qxestrcmp (modname, mname)) |
| 563 | 456 signal_error (Qdll_error, "Module name mismatch", Qunbound); |
| 428 | 457 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
458 if (modver && modver[0] && qxestrcmp (modver, mver)) |
| 563 | 459 signal_error (Qdll_error, "Module version mismatch", Qunbound); |
| 428 | 460 |
| 461 /* | |
| 462 * Attempt to make a new slot for this module. If this really is the | |
| 463 * first time we are loading this module, the used member will be 0. | |
| 464 * If that is non-zero, we know that we have a previously loaded module | |
| 442 | 465 * of the same name and version, and we don't need to go any further. |
| 428 | 466 */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
467 mpx = find_make_module (foundname, mname, mver, 0); |
| 428 | 468 mp = &modules[mpx]; |
| 469 if (mp->used > 0) | |
| 470 { | |
| 471 emodules_depth--; | |
| 472 dll_close (dlhandle); | |
| 806 | 473 dlhandle = 0; /* Zero this out before module_load_unwind runs */ |
| 428 | 474 return; |
| 475 } | |
| 476 | |
| 477 if (!load_modules_quietly) | |
| 478 message ("Loading %s v%s (%s)", mname, mver, mtitle); | |
| 479 | |
| 480 /* | |
| 481 * We have passed the basic initialization, and can now add this | |
| 482 * module to the list of modules. | |
| 483 */ | |
| 484 mp->used = emodules_depth + 1; | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
485 mp->soname = qxestrdup (XSTRING_DATA (foundname)); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
486 mp->modname = qxestrdup (mname); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
487 mp->modver = qxestrdup (mver); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
488 mp->modtitle = qxestrdup (mtitle); |
| 428 | 489 mp->dlhandle = dlhandle; |
| 996 | 490 mp->unload = modunld; |
| 428 | 491 dlhandle = 0; |
| 492 | |
| 996 | 493 old_load_list = Vcurrent_load_list; |
| 494 Vcurrent_load_list = Qnil; | |
| 495 LOADHIST_ATTACH (lisp_modname); | |
| 496 LOADHIST_ATTACH (module_tag); | |
| 497 | |
| 428 | 498 /* |
| 499 * Now we need to call the module init function and perform the various | |
| 500 * startup tasks. | |
| 501 */ | |
| 502 if (modload != 0) | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
503 (*modload) (); |
| 428 | 504 |
| 505 /* | |
| 506 * Now we can get the module to initialize its symbols, and then its | |
| 507 * variables, and lastly the documentation strings. | |
| 508 */ | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
509 (*modsyms) (); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
510 (*modvars) (); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
511 (*moddocs) (); |
| 428 | 512 |
| 513 if (!load_modules_quietly) | |
| 514 message ("Loaded module %s v%s (%s)", mname, mver, mtitle); | |
| 515 | |
| 996 | 516 Vload_history = Fcons (Fnreverse (Vcurrent_load_list), Vload_history); |
| 517 Vcurrent_load_list = old_load_list; | |
| 518 UNGCPRO; | |
| 428 | 519 |
| 520 emodules_depth--; | |
| 521 if (emodules_depth == 0) | |
| 522 { | |
| 523 /* | |
| 524 * We have reached the end of the load chain. We now go through the | |
| 525 * list of loaded modules and mark all the valid modules as just | |
| 526 * that. | |
| 527 */ | |
| 528 for (x = 0; x < modnum; x++) | |
| 529 if (modules[x].used > 1) | |
| 530 modules[x].used = 1; | |
| 531 } | |
| 532 } | |
| 533 | |
| 534 void | |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
535 emodules_doc_subr (const Ascbyte *symname, const Ascbyte *doc) |
| 428 | 536 { |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
537 Bytecount len; |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
538 Lisp_Object sym; |
| 440 | 539 Lisp_Subr *subr; |
| 428 | 540 |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
541 ASSERT_ASCTEXT_ASCII (symname); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
542 len = strlen (symname); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
543 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
|
544 |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
545 /* 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
|
546 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
|
547 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
|
548 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
|
549 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
|
550 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
|
551 ASSERT_ASCTEXT_ASCII (doc); |
| 1632 | 552 /* Skip autoload cookies */ |
| 553 if (SYMBOLP (sym) && SUBRP (XSYMBOL (sym)->function)) | |
| 428 | 554 { |
| 1632 | 555 subr = XSUBR (XSYMBOL (sym)->function); |
| 428 | 556 subr->doc = xstrdup (doc); |
| 557 } | |
| 558 /* | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
559 * #### FIXME: I wish there was some way to avoid the xstrdup(). Is it |
| 428 | 560 * possible to just set a pointer to the string, or somehow create a |
| 561 * symbol whose value we can point to the constant string? Can someone | |
| 562 * look into this? | |
| 563 */ | |
| 564 } | |
| 565 | |
| 566 void | |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
567 emodules_doc_sym (const Ascbyte *symname, const Ascbyte *doc) |
| 428 | 568 { |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
569 Bytecount len; |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
570 Lisp_Object sym; |
| 428 | 571 Lisp_Object docstr; |
| 572 struct gcpro gcpro1; | |
| 573 | |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
574 ASSERT_ASCTEXT_ASCII (symname); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
575 len = strlen (symname); |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
576 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
|
577 |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
578 /* 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
|
579 this. */ |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
580 ASSERT_ASCTEXT_ASCII (doc); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
581 if (SYMBOLP (sym)) |
| 428 | 582 { |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
583 docstr = build_ascstring (doc); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
584 GCPRO1 (docstr); |
| 428 | 585 Fput (sym, Qvariable_documentation, docstr); |
| 586 UNGCPRO; | |
| 587 } | |
| 588 } | |
| 589 | |
| 590 | |
| 591 void | |
| 592 syms_of_module (void) | |
| 593 { | |
| 564 | 594 DEFERROR_STANDARD (Qdll_error, Qerror); |
| 996 | 595 DEFSYMBOL (Qmodule); |
| 596 DEFSYMBOL (Qunload_module); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
597 DEFSUBR (Fload_module); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
598 DEFSUBR (Flist_modules); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
599 DEFSUBR (Funload_module); |
| 996 | 600 module_tag = Fcons (Qmodule, Qnil); |
| 601 staticpro (&module_tag); | |
| 602 Fput (Qunload_module, Qdisabled, Qt); | |
| 428 | 603 } |
| 604 | |
| 605 void | |
| 606 reinit_vars_of_module (void) | |
| 607 { | |
| 608 emodules_depth = 0; | |
| 1706 | 609 modules = NULL; |
| 428 | 610 modnum = 0; |
| 611 } | |
| 612 | |
| 1750 | 613 #endif /* HAVE_SHLIB */ |
| 614 | |
| 428 | 615 void |
| 616 vars_of_module (void) | |
| 617 { | |
| 1750 | 618 #ifdef HAVE_SHLIB |
| 619 Fprovide (intern ("modules")); | |
| 620 | |
| 2078 | 621 #ifdef HAVE_LTDL |
| 622 lt_dlinit (); | |
| 623 lt_dlmalloc = (lt_ptr (*) (size_t)) xmalloc; | |
| 624 lt_dlrealloc = (lt_ptr (*) (lt_ptr, size_t)) xrealloc; | |
| 625 lt_dlfree = (void (*) (lt_ptr)) xfree_1; | |
| 626 #endif | |
| 627 | |
| 428 | 628 DEFVAR_LISP ("module-version", &Vmodule_version /* |
| 629 Emacs dynamic loading mechanism version, as a string. | |
| 630 | |
| 631 This string is in the form XX.YY.ppp, where XX is the major version | |
| 632 number, YY is the minor version number, and ppp is the patch level. | |
| 442 | 633 This variable can be used to distinguish between different versions of |
| 428 | 634 the dynamic loading technology used in Emacs, if required. It is not |
| 635 a given that this value will be the same as the Emacs version number. | |
| 636 */ ); | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
637 Vmodule_version = build_cistring (EMODULES_VERSION); |
| 428 | 638 |
| 639 DEFVAR_BOOL ("load-modules-quietly", &load_modules_quietly /* | |
| 640 *Set to t if module loading is to be silent. | |
| 641 | |
| 642 Normally, when loading dynamic modules, Emacs will inform you of its | |
| 643 progress, and will display the module name and version if the module | |
| 644 is loaded correctly. Setting this variable to `t' will suppress these | |
| 645 messages. This would normally only be done if `load-module' was being | |
| 646 called by a Lisp function. | |
| 647 */); | |
| 1733 | 648 load_modules_quietly = 0; |
| 428 | 649 |
| 1750 | 650 DEFVAR_BOOL ("unloading-module", &unloading_module /* |
| 651 Used internally by `unload-feature'. Do not set this variable. | |
| 652 Danger, danger, Will Robinson! | |
| 653 */); | |
| 654 unloading_module = 0; | |
| 655 | |
| 656 #endif /* HAVE_SHLIB */ | |
| 657 | |
| 428 | 658 DEFVAR_LISP ("module-load-path", &Vmodule_load_path /* |
| 659 *List of directories to search for dynamic modules to load. | |
| 660 Each element is a string (directory name) or nil (try default directory). | |
| 661 | |
| 662 Note that elements of this list *may not* begin with "~", so you must | |
| 442 | 663 call `expand-file-name' on them before adding them to this list. |
| 428 | 664 |
| 665 Initialized based on EMACSMODULEPATH environment variable, if any, otherwise | |
| 666 to default specified the file `paths.h' when XEmacs was built. If there | |
| 667 were no paths specified in `paths.h', then XEmacs chooses a default | |
| 668 value for this variable by looking around in the file-system near the | |
| 669 directory in which the XEmacs executable resides. | |
| 670 | |
| 671 Due to the nature of dynamic modules, the path names should almost always | |
| 442 | 672 refer to architecture-dependent directories. It is unwise to attempt to |
| 673 store dynamic modules in a heterogenous environment. Some environments | |
| 428 | 674 are similar enough to each other that XEmacs will be unable to determine |
| 675 the correctness of a dynamic module, which can have unpredictable results | |
| 676 when a dynamic module is loaded. | |
| 677 */); | |
| 1733 | 678 Vmodule_load_path = Qnil; |
| 428 | 679 |
| 1733 | 680 DEFVAR_LISP ("module-extensions", &Vmodule_extensions /* |
| 681 *List of filename extensions to use when searching for dynamic modules. | |
| 682 */); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
683 Vmodule_extensions = list5 (build_ascstring (".ell"), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
684 build_ascstring (".so"), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
685 build_ascstring (".dll"), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
686 build_ascstring (".dylib"), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
687 build_ascstring ("")); |
| 428 | 688 } |