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