xemacs-beta: src/emodules.c comparison

comparison src/emodules.c @ 442:abe6d1db359e r21-2-36

Import from CVS: tag r21-2-36

author	cvs
date	Mon, 13 Aug 2007 11:35:02 +0200
parents	8de8e3f6228a
children	576fb035e263

comparison

equal deleted inserted replaced

-:72a7cfa4a488
+:abe6d1db359e
 static int emodules_depth;
 static dll_handle dlhandle;
 static emodules_list *modules;
 static int modnum;
-static int find_make_module (CONST char *mod, CONST char *name, CONST char *ver, int make_or_find);
+static int find_make_module (const char *mod, const char *name, const char *ver, int make_or_find);
 static Lisp_Object module_load_unwind (Lisp_Object);
 static void attempt_module_delete (int mod);
 DEFUN ("load-module", Fload_module, 1, 3, "FLoad dynamic module: ", /*
 Load in a C Emacs Extension module named FILE.
 FILE depends on will be automatically loaded.  You can determine which
 modules have been loaded as dynamic shared objects by examining the
 return value of the function `list-modules'.
 It is possible, although unwise, to unload modules using `unload-module'.
-The prefered mechanism for unloading or reloading modules is to quit
+The preferred mechanism for unloading or reloading modules is to quit
 XEmacs, and then reload those new or changed modules that are required.
 Messages informing you of the progress of the load are displayed unless
 the variable `load-modules-quietly' is non-NIL.
 */
 Unload a module previously loaded with load-module.
 As with load-module, this function requires at least the module FILE, and
 optionally the module NAME and VERSION to unload.  It may not be possible
 for the module to be unloaded from memory, as there may be Lisp objects
-refering to variables inside the module code.  However, once you have
+referring to variables inside the module code.  However, once you have
 requested a module to be unloaded, it will be unloaded from memory as
 soon as the last reference to symbols within the module is destroyed.
 */
 (file,name,version))
 {
 return mlist;
 }
 static int
-find_make_module (CONST char *mod, CONST char *name, CONST char *ver, int mof)
+find_make_module (const char *mod, const char *name, const char *ver, int mof)
 {
 int i, fs = -1;
 for (i = 0; i < modnum; i++)
 {
 if (fs != -1)
 return fs; /* First free slot */
 /*
-* We only get here if we havent found a free slot and the module was
+* We only get here if we haven't found a free slot and the module was
 * not previously loaded.
 */
 if (modules == (emodules_list *)0)
 modules = (emodules_list *) xmalloc (sizeof (emodules_list));
 modnum++;
 /*
 * Do the actual grunt-work of loading in a module. We first try and
 * dlopen() the module. If that fails, we have an error and we bail
 * out immediately. If the dlopen() succeeds, we need to check for the
-* existance of certain special symbols.
+* existence of certain special symbols.
 *
 * All modules will have complete access to the variables and functions
 * defined within XEmacs itself.  It is up to the module to declare any
 * variables or functions it uses, however.  Modules will also have access
 * to other functions and variables in other loaded modules, unless they
 * are defined as STATIC.
 *
 * We need to be very careful with how we load modules. If we encounter an
 * error along the way, we need to back out completely to the point at
-* which the user started. Since we can be called resursively, we need to
+* which the user started. Since we can be called recursively, we need to
 * take care with marking modules as loaded. When we first start loading
 * modules, we set the counter to zero. As we enter the function each time,
-* we incremement the counter, and before we leave we decrement it. When
+* we increment the counter, and before we leave we decrement it. When
 * we get back down to 0, we know we are at the end of the chain and we
 * can mark all the modules in the list as loaded.
 *
 * When we signal an error, we need to be sure to unwind all modules loaded
 * thus far (but only for this module chain). It is assumed that if any
 * modules in a chain fail, then they all do. This is logical, considering
-* that the only time we recurse is when we have dependant modules. So in
+* that the only time we recurse is when we have dependent modules. So in
 * the error handler we take great care to close off the module chain before
 * we call "error" and let the Fmodule_load unwind_protect() function handle
 * the cleaning up.
 */
 void
-emodules_load(CONST char *module, CONST char *modname, CONST char *modver)
+emodules_load(const char *module, const char *modname, const char *modver)
 {
 Lisp_Object filename;
 Lisp_Object foundname;
 int fd, x, mpx;
 char *soname, *tmod;
-CONST char **f;
+const char **f;
-CONST long *ellcc_rev;
+const long *ellcc_rev;
 char *mver, *mname, *mtitle, *symname;
 void (*modload)(void) = 0;
 void (*modsyms)(void) = 0;
 void (*modvars)(void) = 0;
 void (*moddocs)(void) = 0;
 foundname = Qnil;
 emodules_depth++;
 dlhandle = 0;
-if ((module == (CONST char *)0) || (module[0] == '\0'))
+if ((module == (const char *)0) || (module[0] == '\0'))
 error ("Empty module name");
 /* This is to get around the fact that build_string() is not declared
 as taking a const char * as an argument. I HATE compiler warnings. */
 tmod = (char *)alloca (strlen (module) + 1);
 dlhandle = dll_open (soname);
 if (dlhandle == (dll_handle)0)
 error ("Opening dynamic module: %s", dll_error (dlhandle));
-ellcc_rev = (CONST long *)dll_variable (dlhandle, "emodule_compiler");
+ellcc_rev = (const long *)dll_variable (dlhandle, "emodule_compiler");
-if ((ellcc_rev == (CONST long *)0) || (*ellcc_rev <= 0))
+if ((ellcc_rev == (const long *)0) || (*ellcc_rev <= 0))
 error ("Missing symbol `emodule_compiler': Invalid dynamic module");
 if (*ellcc_rev > EMODULES_REVISION)
 error ("Unsupported version `%ld(%ld)': Invalid dynamic module",
 *ellcc_rev, EMODULES_REVISION);
-f = (CONST char **)dll_variable (dlhandle, "emodule_name");
+f = (const char **)dll_variable (dlhandle, "emodule_name");
-if ((f == (CONST char **)0) || (*f == (CONST char *)0))
+if ((f == (const char **)0) || (*f == (const char *)0))
 error ("Missing symbol `emodule_name': Invalid dynamic module");
 mname = (char *)alloca (strlen (*f) + 1);
 strcpy (mname, *f);
 if (mname[0] == '\0')
 error ("Empty value for `emodule_name': Invalid dynamic module");
-f = (CONST char **)dll_variable (dlhandle, "emodule_version");
+f = (const char **)dll_variable (dlhandle, "emodule_version");
-if ((f == (CONST char **)0) || (*f == (CONST char *)0))
+if ((f == (const char **)0) || (*f == (const char *)0))
 error ("Missing symbol `emodule_version': Invalid dynamic module");
 mver = (char *)alloca (strlen (*f) + 1);
 strcpy (mver, *f);
-f = (CONST char **)dll_variable (dlhandle, "emodule_title");
+f = (const char **)dll_variable (dlhandle, "emodule_title");
-if ((f == (CONST char **)0) || (*f == (CONST char *)0))
+if ((f == (const char **)0) || (*f == (const char *)0))
 error ("Missing symbol `emodule_title': Invalid dynamic module");
 mtitle = (char *)alloca (strlen (*f) + 1);
 strcpy (mtitle, *f);
 strcpy (symname, "modules_of_");
 strcat (symname, mname);
 modload = (void (*)(void))dll_function (dlhandle, symname);
 /*
-* modload is optional. If the module doesnt require other modules it can
+* modload is optional. If the module doesn't require other modules it can
 * be left out.
 */
 strcpy (symname, "syms_of_");
 strcat (symname, mname);
 /*
 * Attempt to make a new slot for this module. If this really is the
 * first time we are loading this module, the used member will be 0.
 * If that is non-zero, we know that we have a previously loaded module
-* of the same name and version, and we dont need to go any further.
+* of the same name and version, and we don't need to go any further.
 */
 mpx = find_make_module (soname, mname, mver, 0);
 mp = &modules[mpx];
 if (mp->used > 0)
 {
 modules[x].used = 1;
 }
 }
 void
-emodules_doc_subr(CONST char *symname, CONST char *doc)
+emodules_doc_subr(const char *symname, const char *doc)
 {
 Bytecount len = strlen (symname);
-Lisp_Object sym = oblookup (Vobarray, (CONST Bufbyte *)symname, len);
+Lisp_Object sym = oblookup (Vobarray, (const Bufbyte *)symname, len);
 Lisp_Subr *subr;
 if (SYMBOLP(sym))
 {
 subr = XSUBR( XSYMBOL(sym)->function);
 * look into this?
 */
 }
 void
-emodules_doc_sym (CONST char *symname, CONST char *doc)
+emodules_doc_sym (const char *symname, const char *doc)
 {
 Bytecount len = strlen (symname);
-Lisp_Object sym = oblookup (Vobarray, (CONST Bufbyte *)symname, len);
+Lisp_Object sym = oblookup (Vobarray, (const Bufbyte *)symname, len);
 Lisp_Object docstr;
 struct gcpro gcpro1;
 if (SYMBOLP(sym))
 {
 DEFVAR_LISP ("module-version", &Vmodule_version /*
 Emacs dynamic loading mechanism version, as a string.
 This string is in the form XX.YY.ppp, where XX is the major version
 number, YY is the minor version number, and ppp is the patch level.
-This variable can be used to distinquish between different versions of
+This variable can be used to distinguish between different versions of
 the dynamic loading technology used in Emacs, if required.  It is not
 a given that this value will be the same as the Emacs version number.
 */ );
 Vmodule_version = build_string (EMODULES_VERSION);
 DEFVAR_LISP ("module-load-path", &Vmodule_load_path /*
 *List of directories to search for dynamic modules to load.
 Each element is a string (directory name) or nil (try default directory).
 Note that elements of this list *may not* begin with "~", so you must
-call `expland-file-name' on them before adding them to this list.
+call `expand-file-name' on them before adding them to this list.
 Initialized based on EMACSMODULEPATH environment variable, if any, otherwise
 to default specified the file `paths.h' when XEmacs was built.  If there
 were no paths specified in `paths.h', then XEmacs chooses a default
 value for this variable by looking around in the file-system near the
 directory in which the XEmacs executable resides.
 Due to the nature of dynamic modules, the path names should almost always
-refer to architecture-dependant directories.  It is unwise to attempt to
+refer to architecture-dependent directories.  It is unwise to attempt to
-store dynamic modules in a hetrogenous environment.  Some environments
+store dynamic modules in a heterogenous environment.  Some environments
 are similar enough to each other that XEmacs will be unable to determine
 the correctness of a dynamic module, which can have unpredictable results
 when a dynamic module is loaded.
 */);

Mercurial > hg > xemacs-beta

comparison src/emodules.c @ 442:abe6d1db359e r21-2-36