Mercurial > hg > xemacs-beta
annotate src/emodules.c @ 4976:16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-02-04 Ben Wing <ben@xemacs.org>
* alloc.c (release_breathing_space):
* alloc.c (resize_string):
* alloc.c (sweep_lcrecords_1):
* alloc.c (SWEEP_FIXED_TYPE_BLOCK_1):
* alloc.c (ADDITIONAL_FREE_compiled_function):
* alloc.c (compact_string_chars):
* alloc.c (ADDITIONAL_FREE_string):
* alloc.c (sweep_strings):
* alloca.c (xemacs_c_alloca):
* alsaplay.c (alsa_play_sound_file):
* buffer.c (init_initial_directory):
* buffer.h:
* buffer.h (BUFFER_FREE):
* console-stream.c (stream_delete_console):
* console-tty.c (free_tty_console_struct):
* data.c (Fnumber_to_string):
* device-gtk.c (gtk_init_device):
* device-gtk.c (free_gtk_device_struct):
* device-gtk.c (gtk_delete_device):
* device-msw.c (mswindows_delete_device):
* device-msw.c (msprinter_delete_device):
* device-tty.c (free_tty_device_struct):
* device-tty.c (tty_delete_device):
* device-x.c (x_init_device):
* device-x.c (free_x_device_struct):
* device-x.c (x_delete_device):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-x.c (dbox_descriptor_to_widget_value):
* dired-msw.c (Fmswindows_insert_directory):
* dired.c (free_user_cache):
* dired.c (user_name_completion_unwind):
* doc.c (unparesseuxify_doc_string):
* doc.c (Fsubstitute_command_keys):
* doprnt.c (emacs_doprnt_1):
* dumper.c (pdump_load_finish):
* dumper.c (pdump_file_free):
* dumper.c (pdump_file_unmap):
* dynarr.c:
* dynarr.c (Dynarr_free):
* editfns.c (uncache_home_directory):
* editfns.c (Fset_time_zone_rule):
* elhash.c:
* elhash.c (pdump_reorganize_hash_table):
* elhash.c (maphash_unwind):
* emacs.c (make_arg_list_1):
* emacs.c (free_argc_argv):
* emacs.c (sort_args):
* emacs.c (Frunning_temacs_p):
* emodules.c (attempt_module_delete):
* eval.c (free_pointer):
* event-Xt.c (unselect_filedesc):
* event-Xt.c (emacs_Xt_select_process):
* event-gtk.c (unselect_filedesc):
* event-gtk.c (dragndrop_data_received):
* event-msw.c (winsock_closer):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* event-stream.c (finalize_command_builder):
* event-stream.c (free_command_builder):
* extents.c (free_gap_array):
* extents.c (free_extent_list):
* extents.c (free_soe):
* extents.c (extent_fragment_delete):
* extents.c (extent_priority_sort_function):
* file-coding.c (make_coding_system_1):
* file-coding.c (coding_finalizer):
* file-coding.c (set_coding_stream_coding_system):
* file-coding.c (chain_finalize_coding_stream_1):
* file-coding.c (chain_finalize):
* file-coding.c (free_detection_state):
* file-coding.c (coding_category_symbol_to_id):
* fileio.c:
* fileio.c (Ffile_name_directory):
* fileio.c (if):
* fileio.c (Ffile_symlink_p):
* filelock.c (FREE_LOCK_INFO):
* filelock.c (current_lock_owner):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* frame-gtk.c (gtk_delete_frame):
* frame-msw.c (mswindows_delete_frame):
* frame-msw.c (msprinter_delete_frame):
* frame-x.c (x_cde_destroy_callback):
* frame-x.c (Fcde_start_drag_internal):
* frame-x.c (x_cde_transfer_callback):
* frame-x.c (x_delete_frame):
* frame.c (update_frame_title):
* frame.c (Fset_frame_pointer):
* gc.c (register_for_finalization):
* gccache-gtk.c (free_gc_cache):
* gccache-gtk.c (gc_cache_lookup):
* gccache-x.c (free_gc_cache):
* gccache-x.c (gc_cache_lookup):
* glyphs-eimage.c:
* glyphs-eimage.c (jpeg_instantiate_unwind):
* glyphs-eimage.c (gif_instantiate_unwind):
* glyphs-eimage.c (png_instantiate_unwind):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate_unwind):
* glyphs-gtk.c (convert_EImage_to_GDKImage):
* glyphs-gtk.c (gtk_finalize_image_instance):
* glyphs-gtk.c (gtk_init_image_instance_from_eimage):
* glyphs-gtk.c (gtk_xpm_instantiate):
* glyphs-msw.c (convert_EImage_to_DIBitmap):
* glyphs-msw.c (mswindows_init_image_instance_from_eimage):
* glyphs-msw.c (mswindows_initialize_image_instance_mask):
* glyphs-msw.c (xpm_to_eimage):
* glyphs-msw.c (mswindows_xpm_instantiate):
* glyphs-msw.c (xbm_create_bitmap_from_data):
* glyphs-msw.c (mswindows_finalize_image_instance):
* glyphs-x.c (convert_EImage_to_XImage):
* glyphs-x.c (x_finalize_image_instance):
* glyphs-x.c (x_init_image_instance_from_eimage):
* glyphs-x.c (x_xpm_instantiate):
* gui-x.c (free_popup_widget_value_tree):
* hash.c (free_hash_table):
* hash.c (grow_hash_table):
* hash.c (pregrow_hash_table_if_necessary):
* imgproc.c (build_EImage_quantable):
* insdel.c (uninit_buffer_text):
* intl-win32.c (convert_multibyte_to_internal_malloc):
* intl.c:
* intl.c (Fset_current_locale):
* keymap.c:
* keymap.c (where_is_recursive_mapper):
* keymap.c (where_is_internal):
* lisp.h:
* lisp.h (xfree):
* lstream.c (Lstream_close):
* lstream.c (resizing_buffer_closer):
* mule-coding.c:
* mule-coding.c (iso2022_finalize_detection_state):
* nt.c:
* nt.c (mswindows_get_long_filename):
* nt.c (nt_get_resource):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_opendir):
* nt.c (mswindows_closedir):
* nt.c (mswindows_readdir):
* nt.c (mswindows_stat):
* nt.c (mswindows_getdcwd):
* nt.c (Fmswindows_long_file_name):
* ntplay.c (nt_play_sound_file):
* ntplay.c (play_sound_data_1):
* number-gmp.c (gmp_free):
* number-gmp.c (init_number_gmp):
* number-mp.c (bignum_to_string):
* number-mp.c (BIGNUM_TO_TYPE):
* number.c (bignum_print):
* number.c (bignum_convfree):
* number.c (ratio_print):
* number.c (bigfloat_print):
* number.c (bigfloat_finalize):
* objects-gtk.c (gtk_finalize_color_instance):
* objects-gtk.c (gtk_finalize_font_instance):
* objects-msw.c (mswindows_finalize_color_instance):
* objects-msw.c (mswindows_finalize_font_instance):
* objects-tty.c (tty_finalize_color_instance):
* objects-tty.c (tty_finalize_font_instance):
* objects-tty.c (tty_font_list):
* objects-x.c (x_finalize_color_instance):
* objects-x.c (x_finalize_font_instance):
* process.c:
* process.c (finalize_process):
* realpath.c:
* redisplay.c (add_propagation_runes):
* regex.c:
* regex.c (xfree):
* regex.c (REGEX_FREE_STACK):
* regex.c (FREE_STACK_RETURN):
* regex.c (regex_compile):
* regex.c (regexec):
* regex.c (regfree):
* scrollbar-gtk.c (gtk_free_scrollbar_instance):
* scrollbar-gtk.c (gtk_release_scrollbar_instance):
* scrollbar-msw.c (mswindows_free_scrollbar_instance):
* scrollbar-msw.c (unshow_that_mofo):
* scrollbar-x.c (x_free_scrollbar_instance):
* scrollbar-x.c (x_release_scrollbar_instance):
* select-gtk.c (emacs_gtk_selection_handle):
* select-msw.c (mswindows_own_selection):
* select-x.c:
* select-x.c (x_handle_selection_request):
* select-x.c (unexpect_property_change):
* select-x.c (x_handle_property_notify):
* select-x.c (receive_incremental_selection):
* select-x.c (x_get_window_property_as_lisp_data):
* select-x.c (Fx_get_cutbuffer_internal):
* specifier.c (finalize_specifier):
* syntax.c (uninit_buffer_syntax_cache):
* sysdep.c (qxe_allocating_getcwd):
* sysdep.c (qxe_lstat):
* sysdep.c (copy_in_passwd):
* sysdep.c (qxe_ctime):
* sysdep.c (closedir):
* sysdep.c (DIRSIZ):
* termcap.c (tgetent):
* termcap.c (tprint):
* tests.c (Ftest_data_format_conversion):
* text.c (new_dfc_convert_copy_data):
* text.h (eifree):
* text.h (eito_alloca):
* text.h (eito_external):
* toolbar-msw.c (mswindows_output_toolbar):
* ui-gtk.c (CONVERT_RETVAL):
* ui-gtk.c (__allocate_object_storage):
* unicode.c (free_from_unicode_table):
* unicode.c (free_to_unicode_table):
* unicode.c (free_charset_unicode_tables):
* win32.c (mswindows_read_link_1):
Rename: xfree(VAL, TYPE)->xfree(VAL)
Command used:
gr 'xfree *\((.*),.*\);' 'xfree (\1);' *.[ch]
Followed by grepping for 'xfree.*,' and fixing anything left.
Rationale: Having to specify the TYPE argument is annoying and
error-prone. It was originally put in to work around warnings
due to strict aliasing but years and years ago I rewrote it
in a way that doesn't use the TYPE argument at all and no one
has complained since then. (And anyway, XEmacs is far from
ever being in compliance with strict aliasing and would require
far-reaching changes to get that way.)
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Thu, 04 Feb 2010 07:28:14 -0600 |
| parents | 3461165c79be |
| children | 3c3c1d139863 |
| 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 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
390 mname = NEW_EXTERNAL_TO_C_STRING (f, Qemodule_string_encoding); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
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 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
403 mver = NEW_EXTERNAL_TO_C_STRING (f, Qemodule_string_encoding); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
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 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
413 mtitle = NEW_EXTERNAL_TO_C_STRING (f, Qemodule_string_encoding); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
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 } |