Mercurial > hg > xemacs-beta
annotate src/emodules.c @ 5887:6eca500211f4
Prototype for X509_check_host() has changed, detect this in configure.ac
ChangeLog addition:
2015-04-09 Aidan Kehoe <kehoea@parhasard.net>
* configure.ac:
If X509_check_host() is available, check the number of arguments
it takes. Don't use it if it takes any number of arguments other
than five. Also don't use it if <openssl/x509v3.h> does not
declare it, since if that is so there is no portable way to tell
how many arguments it should take, and so we would end up smashing
the stack.
* configure: Regenerate.
src/ChangeLog addition:
2015-04-09 Aidan Kehoe <kehoea@parhasard.net>
* tls.c:
#include <openssl/x509v3.h> for its prototype for
X509_check_host().
* tls.c (tls_open):
Pass the new fifth argument to X509_check_host().
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Thu, 09 Apr 2015 14:27:02 +0100 |
| parents | 56144c8593a8 |
| children | 574f0cded429 |
| 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; | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5420
diff
changeset
|
118 record_unwind_protect (module_load_unwind, make_fixnum(modnum)); |
| 428 | 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 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5420
diff
changeset
|
286 if (FIXNUMP (XCAR (upto))) |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5420
diff
changeset
|
287 l = XFIXNUM (XCAR (upto)); |
| 853 | 288 free_cons (upto); |
| 428 | 289 } |
| 290 else | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5420
diff
changeset
|
291 l = XFIXNUM (upto); |
| 428 | 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 } |