1 // module.c - deal with dynamic modules

     2 //

     3 // © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

     4 //

     5 /*

     6  * This file is part of zsh, the Z shell.

     7  *

     8  * Copyright (c) 1996-1997 Zoltán Hidvégi

     9  * All rights reserved.

    10  *

    11  * Permission is hereby granted, without written agreement and without

    12  * license or royalty fees, to use, copy, modify, and distribute this

    13  * software and to distribute modified versions of this software for any

    14  * purpose, provided that the above copyright notice and the following

    15  * two paragraphs appear in all copies of this software.

    16  *

    17  * In no event shall Zoltán Hidvégi or the Zsh Development Group be liable

    18  * to any party for direct, indirect, special, incidental, or consequential

    19  * damages arising out of the use of this software and its documentation,

    20  * even if Zoltán Hidvégi and the Zsh Development Group have been advised of

    21  * the possibility of such damage.

    22  *

    23  * Zoltán Hidvégi and the Zsh Development Group specifically disclaim any

    24  * warranties, including, but not limited to, the implied warranties of

    25  * merchantability and fitness for a particular purpose.  The software

    26  * provided hereunder is on an "as is" basis, and Zoltán Hidvégi and the

    27  * Zsh Development Group have no obligation to provide maintenance,

    28  * support, updates, enhancements, or modifications.

    29  *

    30  */

    31 #include "zsh.mdh"

    32 #include "module.pro"

    33 

    34 #ifdef __SYMBIAN32__

    35 #ifdef __WINSCW__

    36 #pragma warn_unusedarg off

    37 #pragma warn_possunwant off

    38 #endif//__WINSCW__

    39 #endif//__SYMBIAN32__

    40 

    41 /* List of linked-in modules. */

    42 

    43 /**/

    44 LinkList linkedmodules;

    45 

    46 

    47 /* The `zsh/main' module contains all the base code that can't actually be *

    48  * built as a separate module.  It is initialised by main(), so there's    *

    49  * nothing for the boot function to do.                                    */

    50 

    51 /**/

    52 int

    53 setup_(UNUSED(Module m))

    54 {

    55     return 0;

    56 }

    57 

    58 /**/

    59 int

    60 boot_(UNUSED(Module m))

    61 {

    62     return 0;

    63 }

    64 

    65 /**/

    66 int

    67 cleanup_(UNUSED(Module m))

    68 {

    69     return 0;

    70 }

    71 

    72 /**/

    73 int

    74 finish_(UNUSED(Module m))

    75 {

    76     return 0;

    77 }

    78 

    79 /* This registers a builtin module.                                   */

    80 

    81 /**/

    82 void

    83 register_module(char *n, Module_func setup, Module_func boot,

    84 		Module_func cleanup, Module_func finish)

    85 {

    86     Linkedmod m;

    87 

    88     m = (Linkedmod) zalloc(sizeof(*m));

    89 

    90     m->name = ztrdup(n);

    91     m->setup = setup;

    92     m->boot = boot;

    93     m->cleanup = cleanup;

    94     m->finish = finish;

    95 

    96     zaddlinknode(linkedmodules, m);

    97 }

    98 

    99 /* Print an alias. */

   100 

   101 /**/

   102 static void

   103 printmodalias(Module m, Options ops)

   104 {

   105     if (OPT_ISSET(ops,'L')) {

   106 	printf("zmodload -A ");

   107 	if (m->nam[0] == '-')

   108 	    fputs("-- ", stdout);

   109 	quotedzputs(m->nam, stdout);

   110 	putchar('=');

   111 	quotedzputs(m->u.alias, stdout);

   112     } else {

   113 	nicezputs(m->nam, stdout);

   114 	fputs(" -> ", stdout);

   115 	nicezputs(m->u.alias, stdout);

   116     }

   117     putchar('\n');

   118 }

   119 

   120 /* Check if a module is linked in. */

   121 

   122 /**/

   123 Linkedmod

   124 module_linked(char const *name)

   125 {

   126     LinkNode node;

   127 

   128     for (node = firstnode(linkedmodules); node; incnode(node))

   129 	if (!strcmp(((Linkedmod) getdata(node))->name, name))

   130 	    return (Linkedmod) getdata(node);

   131 

   132     return NULL;

   133 }

   134 

   135 /* addbuiltin() can be used to add a new builtin.  It returns zero on *

   136  * success, 1 on failure.  The only possible type of failure is that  *

   137  * a builtin with the specified name already exists.  An autoloaded   *

   138  * builtin can be replaced using this function.                       */

   139 

   140 /**/

   141 int

   142 addbuiltin(Builtin b)

   143 {

   144     Builtin bn = (Builtin) builtintab->getnode2(builtintab, b->nam);

   145     if (bn && (bn->flags & BINF_ADDED))

   146 	return 1;

   147     if (bn)

   148 	builtintab->freenode(builtintab->removenode(builtintab, b->nam));

   149     builtintab->addnode(builtintab, b->nam, b);

   150     return 0;

   151 }

   152 

   153 /* Add multiple builtins.  binl points to a table of `size' builtin      *

   154  * structures.  Those for which (.flags & BINF_ADDED) is false are to be *

   155  * added; that flag is set if they succeed.  If any fail, an error       *

   156  * message is printed, using nam as the leading name.  Returns 1 if all  *

   157  * additions succeed, 2 if some succeed and some fail, and 0 if all (and *

   158  * at least 1) fail.  The usual usage in a boot_*() function would be    *

   159  *  return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab)); */

   160 

   161 /**/

   162 mod_export int

   163 addbuiltins(char const *nam, Builtin binl, int size)

   164 {

   165     int hads = 0, hadf = 0, n;

   166 

   167     for(n = 0; n < size; n++) {

   168 	Builtin b = &binl[n];

   169 	if(b->flags & BINF_ADDED)

   170 	    continue;

   171 	if(addbuiltin(b)) {

   172 	    zwarnnam(nam, "name clash when adding builtin `%s'", b->nam, 0);

   173 	    hadf = 1;

   174 	} else {

   175 	    b->flags |= BINF_ADDED;

   176 	    hads = 2;

   177 	}

   178     }

   179     return hadf ? hads : 1;

   180 }

   181 

   182 /* The list of function wrappers defined. */

   183 

   184 /**/

   185 FuncWrap wrappers;

   186 

   187 /* This adds a definition for a wrapper. Return value is one in case of *

   188  * error and zero if all went fine. */

   189 

   190 /**/

   191 mod_export int

   192 addwrapper(Module m, FuncWrap w)

   193 {

   194     FuncWrap p, q;

   195 

   196     /*

   197      * We can't add a wrapper to an alias, since it's supposed

   198      * to behave identically to the resolved module.  This shouldn't

   199      * happen since we usually add wrappers when a real module is

   200      * loaded.

   201      */

   202     if (m->flags & MOD_ALIAS)

   203 	return 1;

   204 

   205     if (w->flags & WRAPF_ADDED)

   206 	return 1;

   207     for (p = wrappers, q = NULL; p; q = p, p = p->next);

   208     if (q)

   209 	q->next = w;

   210     else

   211 	wrappers = w;

   212     w->next = NULL;

   213     w->flags |= WRAPF_ADDED;

   214     w->module = m;

   215 

   216     return 0;

   217 }

   218 

   219 /* $module_path ($MODULE_PATH) */

   220 

   221 /**/

   222 char **module_path;

   223 

   224 /* List of modules */

   225 

   226 /**/

   227 mod_export LinkList modules;

   228 

   229 /* Define an autoloadable builtin.  It returns 0 on success, or 1 on *

   230  * failure.  The only possible cause of failure is that a builtin    *

   231  * with the specified name already exists.                           */

   232 

   233 /**/

   234 int

   235 add_autobin(char *nam, char *module)

   236 {

   237     Builtin bn = zshcalloc(sizeof(*bn));

   238     bn->nam = ztrdup(nam);

   239     bn->optstr = ztrdup(module);

   240     return addbuiltin(bn);

   241 }

   242 

   243 /* Remove the builtin added previously by addbuiltin().  Returns *

   244  * zero on succes and -1 if there is no builtin with that name.  */

   245 

   246 /**/

   247 int

   248 deletebuiltin(char *nam)

   249 {

   250     Builtin bn;

   251 

   252     bn = (Builtin) builtintab->removenode(builtintab, nam);

   253     if (!bn)

   254 	return -1;

   255     builtintab->freenode((HashNode)bn);

   256     return 0;

   257 }

   258 

   259 /* Delete multiple builtins.  binl points to a table of `size' builtin  *

   260  * structures.  Those for which (.flags & BINF_ADDED) is true are to be *

   261  * deleted; that flag is cleared.  If any fail, an error message is     *

   262  * printed, using nam as the leading name.  Returns 1 if all deletions  *

   263  * succeed, 2 if some succeed and some fail, and 0 if all (and at least *

   264  * 1) fail.  In normal use, from a cleanup_*() function, this return    *

   265  * value would be ignored -- the only cause of failure would be that a  *

   266  * wayward module had deleted our builtin without telling us.           */

   267 

   268 /**/

   269 mod_export int

   270 deletebuiltins(char const *nam, Builtin binl, int size)

   271 {

   272     int hads = 0, hadf = 0, n;

   273 

   274     for(n = 0; n < size; n++) {

   275 	Builtin b = &binl[n];

   276 	if(!(b->flags & BINF_ADDED))

   277 	    continue;

   278 	if(deletebuiltin(b->nam)) {

   279 	    zwarnnam(nam, "builtin `%s' already deleted", b->nam, 0);

   280 	    hadf = 1;

   281 	} else

   282 	    hads = 2;

   283 	b->flags &= ~BINF_ADDED;

   284     }

   285     return hadf ? hads : 1;

   286 }

   287 

   288 /* This removes the given wrapper definition from the list. Returned is *

   289  * one in case of error and zero otherwise. */

   290 

   291 /**/

   292 mod_export int

   293 deletewrapper(Module m, FuncWrap w)

   294 {

   295     FuncWrap p, q;

   296 

   297     if (m->flags & MOD_ALIAS)

   298 	return 1;

   299 

   300     if (w->flags & WRAPF_ADDED) {

   301 	for (p = wrappers, q = NULL; p && p != w; q = p, p = p->next);

   302 

   303 	if (p) {

   304 	    if (q)

   305 		q->next = p->next;

   306 	    else

   307 		wrappers = p->next;

   308 	    p->flags &= ~WRAPF_ADDED;

   309 

   310 	    return 0;

   311 	}

   312     }

   313     return 1;

   314 }

   315 

   316 /**/

   317 #ifdef DYNAMIC

   318 

   319 /**/

   320 #ifdef AIXDYNAMIC

   321 

   322 #include <sys/ldr.h>

   323 

   324 static char *dlerrstr[256];

   325 

   326 static void *

   327 load_and_bind(const char *fn)

   328 {

   329     void *ret = (void *) load((char *) fn, L_NOAUTODEFER, NULL);

   330 

   331     if (ret) {

   332 	LinkNode node;

   333 	int err = loadbind(0, (void *) addbuiltin, ret);

   334 	for (node = firstnode(modules); !err && node; incnode(node)) {

   335 	    Module m = (Module) getdata(node);

   336 	    if (!(m->flags & MOD_ALIAS) &&

   337 		m->u.handle && !(m->flags & MOD_LINKED))

   338 		err |= loadbind(0, m->u.handle, ret);

   339 	}

   340 

   341 	if (err) {

   342 	    loadquery(L_GETMESSAGES, dlerrstr, sizeof(dlerrstr));

   343 	    unload(ret);

   344 	    ret = NULL;

   345 	}

   346     } else

   347 	loadquery(L_GETMESSAGES, dlerrstr, sizeof(dlerrstr));

   348 

   349     return ret;

   350 }

   351 

   352 #define dlopen(X,Y) load_and_bind(X)

   353 #define dlclose(X)  unload(X)

   354 #define dlerror()   (dlerrstr[0])

   355 

   356 /**/

   357 #else

   358 

   359 #ifdef HAVE_DLFCN_H

   360 # if defined(HAVE_DL_H) && defined(HPUXDYNAMIC)

   361 #  include <dl.h>

   362 # else

   363 #  include <dlfcn.h>

   364 # endif

   365 #else

   366 # ifdef HAVE_DL_H

   367 #  include <dl.h>

   368 #  define RTLD_LAZY BIND_DEFERRED

   369 #  define RTLD_GLOBAL DYNAMIC_PATH

   370 # else

   371 #  include <sys/types.h>

   372 #  include <nlist.h>

   373 #  include <link.h>

   374 # endif

   375 #endif

   376 

   377 /**/

   378 #ifdef HPUXDYNAMIC

   379 # define dlopen(file,mode) (void *)shl_load((file), (mode), (long) 0)

   380 # define dlclose(handle) shl_unload((shl_t)(handle))

   381 

   382 static

   383 void *

   384 hpux_dlsym(void *handle, char *name)

   385 {

   386     void *sym_addr;

   387     if (!shl_findsym((shl_t *)&handle, name, TYPE_UNDEFINED, &sym_addr))

   388 	return sym_addr;

   389     return NULL;

   390 }

   391 

   392 # define dlsym(handle,name) hpux_dlsym(handle,name)

   393 # define dlerror() 0

   394 #else

   395 # ifndef HAVE_DLCLOSE

   396 #  define dlclose(X) ((X), 0)

   397 # endif

   398 /**/

   399 #endif

   400 

   401 #ifdef DLSYM_NEEDS_UNDERSCORE

   402 # define STR_SETUP     "_setup_"

   403 # define STR_BOOT      "_boot_"

   404 # define STR_CLEANUP   "_cleanup_"

   405 # define STR_FINISH    "_finish_"

   406 #else /* !DLSYM_NEEDS_UNDERSCORE */

   407 # define STR_SETUP     "setup_"

   408 # define STR_BOOT      "boot_"

   409 # define STR_CLEANUP   "cleanup_"

   410 # define STR_FINISH    "finish_"

   411 #endif /* !DLSYM_NEEDS_UNDERSCORE */

   412 

   413 /**/

   414 #endif /* !AIXDYNAMIC */

   415 

   416 #ifndef RTLD_LAZY

   417 # define RTLD_LAZY 1

   418 #endif

   419 #ifndef RTLD_GLOBAL

   420 # define RTLD_GLOBAL 0

   421 #endif

   422 

   423 /**/

   424 static void *

   425 try_load_module(char const *name)

   426 {

   427     char buf[PATH_MAX + 1];

   428     char **pp;

   429     void *ret = NULL;

   430     int l;

   431 

   432     l = 1 + strlen(name) + 1 + strlen(DL_EXT);

   433     for (pp = module_path; !ret && *pp; pp++) {

   434 	if (l + (**pp ? strlen(*pp) : 1) > PATH_MAX)

   435 	    continue;

   436 	sprintf(buf, "%s/%s.%s", **pp ? *pp : ".", name, DL_EXT);

   437 	ret = dlopen(unmeta(buf), RTLD_LAZY | RTLD_GLOBAL);

   438     }

   439 

   440     return ret;

   441 }

   442 

   443 /**/

   444 static void *

   445 do_load_module(char const *name)

   446 {

   447     void *ret;

   448 

   449     ret = try_load_module(name);

   450     if (!ret) {

   451 	int waserr = errflag;

   452 	zerr("failed to load module: %s", name, 0);

   453 	errflag = waserr;

   454     }

   455     return ret;

   456 }

   457 

   458 /**/

   459 #else /* !DYNAMIC */

   460 

   461 /**/

   462 static void *

   463 do_load_module(char const *name)

   464 {

   465     int waserr = errflag;

   466 

   467     zerr("failed to load module: %s", name, 0);

   468     errflag = waserr;

   469 

   470     return NULL;

   471 }

   472 

   473 /**/

   474 #endif /* !DYNAMIC */

   475 

   476 /*

   477  * Find a module in the list.

   478  * If aliasp is non-zero, resolve any aliases to the underlying module.

   479  * If namep is set, this is set to point to the last alias value resolved,

   480  *   even if that module was not loaded. or the module name if no aliases.

   481  *   Hence this is always the physical module to load in a chain of aliases.

   482  * Return NULL if the module named is not stored as a structure, or if we were

   483  * resolving aliases and the final module named is not stored as a

   484  * structure.

   485  *

   486  * TODO: now we have aliases, there may be some merit in using a hash

   487  * table instead of a linked list.

   488  */

   489 /**/

   490 static LinkNode

   491 find_module(const char *name, int aliasp, const char **namep)

   492 {

   493     Module m;

   494     LinkNode node;

   495 

   496     for (node = firstnode(modules); node; incnode(node)) {

   497 	m = (Module) getdata(node);

   498 	if (!strcmp(m->nam, name)) {

   499 	    if (aliasp && (m->flags & MOD_ALIAS)) {

   500 		if (namep)

   501 		    *namep = m->u.alias;

   502 		return find_module(m->u.alias, 1, namep);

   503 	    }

   504 	    if (namep)

   505 		*namep = m->nam;

   506 	    return node;

   507 	}

   508     }

   509     return NULL;

   510 }

   511 

   512 /*

   513  * Unlink and free a module node from the linked list.

   514  */

   515 

   516 /**/

   517 static void

   518 delete_module(LinkNode node)

   519 {

   520     Module m = (Module) remnode(modules, node);

   521 

   522     if (m->flags & MOD_ALIAS)

   523 	zsfree(m->u.alias);

   524     zsfree(m->nam);

   525     if (m->deps)

   526 	freelinklist(m->deps, freestr);

   527     zfree(m, sizeof(*m));

   528 }

   529 

   530 /**/

   531 mod_export int

   532 module_loaded(const char *name)

   533 {

   534     LinkNode node;

   535     Module m;

   536 

   537     return ((node = find_module(name, 1, NULL)) &&

   538 	    (m = ((Module) getdata(node)))->u.handle &&

   539 	    !(m->flags & MOD_UNLOAD));

   540 }

   541 

   542 /*

   543  * Setup and cleanup functions:  we don't search for aliases here,

   544  * since they should have been resolved before we try to load or unload

   545  * the module.

   546  */

   547 

   548 /**/

   549 #ifdef DYNAMIC

   550 

   551 /**/

   552 #ifdef AIXDYNAMIC

   553 

   554 /**/

   555 static int

   556 dyn_setup_module(Module m)

   557 {

   558     return ((int (*)_((int,Module))) m->u.handle)(0, m);

   559 }

   560 

   561 /**/

   562 static int

   563 dyn_boot_module(Module m)

   564 {

   565     return ((int (*)_((int,Module))) m->u.handle)(1, m);

   566 }

   567 

   568 /**/

   569 static int

   570 dyn_cleanup_module(Module m)

   571 {

   572     return ((int (*)_((int,Module))) m->u.handle)(2, m);

   573 }

   574 

   575 /**/

   576 static int

   577 dyn_finish_module(Module m)

   578 {

   579     return ((int (*)_((int,Module))) m->u.handle)(3, m);

   580 }

   581 

   582 /**/

   583 #else

   584 

   585 static Module_func

   586 module_func(Module m, char *name)

   587 {

   588 #ifdef DYNAMIC_NAME_CLASH_OK

   589     return (Module_func) dlsym(m->u.handle, name);

   590 #else /* !DYNAMIC_NAME_CLASH_OK */

   591     VARARR(char, buf, strlen(name) + strlen(m->nam)*2 + 1);

   592     char const *p;

   593     char *q;

   594     strcpy(buf, name);

   595     q = strchr(buf, 0);

   596     for(p = m->nam; *p; p++) {

   597 	if(*p == '/') {

   598 	    *q++ = 'Q';

   599 	    *q++ = 's';

   600 	} else if(*p == '_') {

   601 	    *q++ = 'Q';

   602 	    *q++ = 'u';

   603 	} else if(*p == 'Q') {

   604 	    *q++ = 'Q';

   605 	    *q++ = 'q';

   606 	} else

   607 	    *q++ = *p;

   608     }

   609     *q = 0;

   610     return (Module_func) dlsym(m->u.handle, buf);

   611 #endif /* !DYNAMIC_NAME_CLASH_OK */

   612 }

   613 

   614 /**/

   615 static int

   616 dyn_setup_module(Module m)

   617 {

   618     Module_func fn = module_func(m, STR_SETUP);

   619 

   620     if (fn)

   621 	return fn(m);

   622     zwarnnam(m->nam, "no setup function", NULL, 0);

   623     return 1;

   624 }

   625 

   626 /**/

   627 static int

   628 dyn_boot_module(Module m)

   629 {

   630     Module_func fn = module_func(m, STR_BOOT);

   631 

   632     if(fn)

   633 	return fn(m);

   634     zwarnnam(m->nam, "no boot function", NULL, 0);

   635     return 1;

   636 }

   637 

   638 /**/

   639 static int

   640 dyn_cleanup_module(Module m)

   641 {

   642     Module_func fn = module_func(m, STR_CLEANUP);

   643 

   644     if(fn)

   645 	return fn(m);

   646     zwarnnam(m->nam, "no cleanup function", NULL, 0);

   647     return 1;

   648 }

   649 

   650 /* Note that this function does more than just calling finish_foo(), *

   651  * it really unloads the module. */

   652 

   653 /**/

   654 static int

   655 dyn_finish_module(Module m)

   656 {

   657     Module_func fn = module_func(m, STR_FINISH);

   658     int r;

   659 

   660     if (fn)

   661 	r = fn(m);

   662     else {

   663 	zwarnnam(m->nam, "no finish function", NULL, 0);

   664 	r = 1;

   665     }

   666     dlclose(m->u.handle);

   667     return r;

   668 }

   669 

   670 /**/

   671 #endif /* !AIXDYNAMIC */

   672 

   673 /**/

   674 static int

   675 setup_module(Module m)

   676 {

   677     return ((m->flags & MOD_LINKED) ?

   678 	    (m->u.linked->setup)(m) : dyn_setup_module(m));

   679 }

   680 

   681 /**/

   682 static int

   683 boot_module(Module m)

   684 {

   685     return ((m->flags & MOD_LINKED) ?

   686 	    (m->u.linked->boot)(m) : dyn_boot_module(m));

   687 }

   688 

   689 /**/

   690 static int

   691 cleanup_module(Module m)

   692 {

   693     return ((m->flags & MOD_LINKED) ?

   694 	    (m->u.linked->cleanup)(m) : dyn_cleanup_module(m));

   695 }

   696 

   697 /**/

   698 static int

   699 finish_module(Module m)

   700 {

   701     return ((m->flags & MOD_LINKED) ?

   702 	    (m->u.linked->finish)(m) : dyn_finish_module(m));

   703 }

   704 

   705 /**/

   706 #else /* !DYNAMIC */

   707 

   708 /**/

   709 static int

   710 setup_module(Module m)

   711 {

   712     return ((m->flags & MOD_LINKED) ? (m->u.linked->setup)(m) : 1);

   713 }

   714 

   715 /**/

   716 static int

   717 boot_module(Module m)

   718 {

   719     return ((m->flags & MOD_LINKED) ? (m->u.linked->boot)(m) : 1);

   720 }

   721 

   722 /**/

   723 static int

   724 cleanup_module(Module m)

   725 {

   726     return ((m->flags & MOD_LINKED) ? (m->u.linked->cleanup)(m) : 1);

   727 }

   728 

   729 /**/

   730 static int

   731 finish_module(Module m)

   732 {

   733     return ((m->flags & MOD_LINKED) ? (m->u.linked->finish)(m) : 1);

   734 }

   735 

   736 /**/

   737 #endif /* !DYNAMIC */

   738 

   739 /**/

   740 static int

   741 modname_ok(char const *p)

   742 {

   743     do {

   744 	if(*p != '_' && !ialnum(*p))

   745 	    return 0;

   746 	do {

   747 	    p++;

   748 	} while(*p == '_' || ialnum(*p));

   749 	if(!*p)

   750 	    return 1;

   751     } while(*p++ == '/');

   752     return 0;

   753 }

   754 

   755 /**/

   756 mod_export int

   757 load_module(char const *name)

   758 {

   759     Module m;

   760     void *handle = NULL;

   761     Linkedmod linked;

   762     LinkNode node, n;

   763     int set;

   764 

   765     if (!modname_ok(name)) {

   766 	zerr("invalid module name `%s'", name, 0);

   767 	return 0;

   768     }

   769     /*

   770      * The following function call may alter name to the final name in a

   771      * chain of aliases.  This makes sure the actual module loaded

   772      * is the right one.

   773      */

   774     queue_signals();

   775     if (!(node = find_module(name, 1, &name))) {

   776 	if (!(linked = module_linked(name)) &&

   777 	    !(handle = do_load_module(name))) {

   778 	    unqueue_signals();

   779 	    return 0;

   780 	}

   781 	m = zshcalloc(sizeof(*m));

   782 	m->nam = ztrdup(name);

   783 	if (handle) {

   784 	    m->u.handle = handle;

   785 	    m->flags |= MOD_SETUP;

   786 	} else {

   787 	    m->u.linked = linked;

   788 	    m->flags |= MOD_SETUP | MOD_LINKED;

   789 	}

   790 	node = zaddlinknode(modules, m);

   791 

   792 	if ((set = setup_module(m)) || boot_module(m)) {

   793 	    if (!set)

   794 		finish_module(m);

   795 	    delete_module(node);

   796 	    unqueue_signals();

   797 	    return 0;

   798 	}

   799 	m->flags |= MOD_INIT_S | MOD_INIT_B;

   800 	m->flags &= ~MOD_SETUP;

   801 	unqueue_signals();

   802 	return 1;

   803     } 

   804     m = (Module) getdata(node);

   805     if (m->flags & MOD_SETUP) {

   806 	unqueue_signals();

   807 	return 1;

   808     }

   809     if (m->flags & MOD_UNLOAD)

   810 	m->flags &= ~MOD_UNLOAD;

   811     else if ((m->flags & MOD_LINKED) ? m->u.linked : m->u.handle) {

   812 	unqueue_signals();

   813 	return 1;

   814     }

   815     if (m->flags & MOD_BUSY) {

   816 	zerr("circular dependencies for module %s", name, 0);

   817 	return 0;

   818     }

   819     m->flags |= MOD_BUSY;

   820     if (m->deps)

   821 	for (n = firstnode(m->deps); n; incnode(n))

   822 	    if (!load_module((char *) getdata(n))) {

   823 		m->flags &= ~MOD_BUSY;

   824 		unqueue_signals();

   825 		return 0;

   826 	    }

   827     m->flags &= ~MOD_BUSY;

   828     if (!m->u.handle) {

   829 	handle = NULL;

   830 	if (!(linked = module_linked(name)) &&

   831 	    !(handle = do_load_module(name))) {

   832 	    unqueue_signals();

   833 	    return 0;

   834 	}

   835 	if (handle) {

   836 	    m->u.handle = handle;

   837 	    m->flags |= MOD_SETUP;

   838 	} else {

   839 	    m->u.linked = linked;

   840 	    m->flags |= MOD_SETUP | MOD_LINKED;

   841 	}

   842 	if (setup_module(m)) {

   843 	    if (handle)

   844 		m->u.handle = NULL;

   845 	    else

   846 		m->u.linked = NULL;

   847 	    m->flags &= ~MOD_SETUP;

   848 	    unqueue_signals();

   849 	    return 0;

   850 	}

   851 	m->flags |= MOD_INIT_S;

   852     }

   853     m->flags |= MOD_SETUP;

   854     if (boot_module(m)) {

   855 	finish_module(m);

   856 	if (m->flags & MOD_LINKED)

   857 	    m->u.linked = NULL;

   858 	else

   859 	    m->u.handle = NULL;

   860 	m->flags &= ~MOD_SETUP;

   861 	unqueue_signals();

   862 	return 0;

   863     }

   864     m->flags |= MOD_INIT_B;

   865     m->flags &= ~MOD_SETUP;

   866     unqueue_signals();

   867     return 1;

   868 }

   869 

   870 /* This ensures that the module with the name given as the second argument

   871  * is loaded.

   872  * The third argument should be non-zero if the function should complain

   873  * about trying to load a module with a full path name in restricted mode.

   874  * The last argument should be non-zero if this function should signal an

   875  * error if the module is already loaded.

   876  * The return value is non-zero if the module was found or loaded. */

   877 

   878 /**/

   879 mod_export int

   880 require_module(char *nam, const char *module, UNUSED(int res), int test)

   881 {

   882     Module m = NULL;

   883     LinkNode node;

   884     int ret = 1;

   885 

   886     /* Resolve aliases and actual loadable module as for load_module */

   887     queue_signals();

   888     node = find_module(module, 1, &module);

   889     if (node && (m = ((Module) getdata(node)))->u.handle &&

   890 	!(m->flags & MOD_UNLOAD)) {

   891 	if (test) {

   892 	    unqueue_signals();

   893 	    zwarnnam(nam, "module %s already loaded.", module, 0);

   894 	    return 0;

   895 	}

   896     } else

   897 	ret = load_module(module);

   898     unqueue_signals();

   899 

   900     return ret;

   901 }

   902 

   903 /**/

   904 void

   905 add_dep(const char *name, char *from)

   906 {

   907     LinkNode node;

   908     Module m;

   909 

   910     /*

   911      * If we were passed an alias, we must resolve it to a final

   912      * module name (and maybe add the corresponding struct), since otherwise

   913      * we would need to check all modules to see if they happen

   914      * to be aliased to the same thing to implement dependencies properly.

   915      *

   916      * This should mean that an attempt to add an alias which would

   917      * have the same name as a module which has dependencies is correctly

   918      * rejected, because then the module named already exists as a non-alias.

   919      * Better make sure.  (There's no problem making a an alias which

   920      * *points* to a module with dependencies, of course.)

   921      */

   922     if (!(node = find_module(name, 1, &name))) {

   923 	m = zshcalloc(sizeof(*m));

   924 	m->nam = ztrdup(name);

   925 	zaddlinknode(modules, m);

   926     } else

   927 	m = (Module) getdata(node);

   928     if (!m->deps)

   929 	m->deps = znewlinklist();

   930     for (node = firstnode(m->deps);

   931 	 node && strcmp((char *) getdata(node), from);

   932 	 incnode(node));

   933     if (!node)

   934 	zaddlinknode(m->deps, ztrdup(from));

   935 }

   936 

   937 /**/

   938 static void

   939 autoloadscan(HashNode hn, int printflags)

   940 {

   941     Builtin bn = (Builtin) hn;

   942 

   943     if(bn->flags & BINF_ADDED)

   944 	return;

   945     if(printflags & PRINT_LIST) {

   946 	fputs("zmodload -ab ", stdout);

   947 	if(bn->optstr[0] == '-')

   948 	    fputs("-- ", stdout);

   949 	quotedzputs(bn->optstr, stdout);

   950 	if(strcmp(bn->nam, bn->optstr)) {

   951 	    putchar(' ');

   952 	    quotedzputs(bn->nam, stdout);

   953 	}

   954     } else {

   955 	nicezputs(bn->nam, stdout);

   956 	if(strcmp(bn->nam, bn->optstr)) {

   957 	    fputs(" (", stdout);

   958 	    nicezputs(bn->optstr, stdout);

   959 	    putchar(')');

   960 	}

   961     }

   962     putchar('\n');

   963 }

   964 

   965 #ifndef __SYMBIAN32__

   966 /**/

   967 int

   968 bin_zmodload(char *nam, char **args, Options ops, UNUSED(int func))

   969 {

   970     int ops_bcpf = OPT_ISSET(ops,'b') || OPT_ISSET(ops,'c') || 

   971 	OPT_ISSET(ops,'p') || OPT_ISSET(ops,'f');

   972     int ops_au = OPT_ISSET(ops,'a') || OPT_ISSET(ops,'u');

   973     int ret = 1;

   974 

   975     if (ops_bcpf && !ops_au) {

   976 	zwarnnam(nam, "-b, -c, -f, and -p must be combined with -a or -u",

   977 		 NULL, 0);

   978 	return 1;

   979     }

   980     if (OPT_ISSET(ops,'A') || OPT_ISSET(ops,'R')) {

   981 	if (ops_bcpf || ops_au || OPT_ISSET(ops,'d') || 

   982 	    (OPT_ISSET(ops,'R') && OPT_ISSET(ops,'e'))) {

   983 	    zwarnnam(nam, "illegal flags combined with -A or -R", NULL, 0);

   984 	    return 1;

   985 	}

   986 	if (!OPT_ISSET(ops,'e'))

   987 	    return bin_zmodload_alias(nam, args, ops);

   988     }

   989     if (OPT_ISSET(ops,'d') && OPT_ISSET(ops,'a')) {

   990 	zwarnnam(nam, "-d cannot be combined with -a", NULL, 0);

   991 	return 1;

   992     }

   993     if (OPT_ISSET(ops,'u') && !*args) {

   994 	zwarnnam(nam, "what do you want to unload?", NULL, 0);

   995 	return 1;

   996     }

   997     if (OPT_ISSET(ops,'e') && (OPT_ISSET(ops,'I') || OPT_ISSET(ops,'L') || 

   998 			       OPT_ISSET(ops,'a') || OPT_ISSET(ops,'d') ||

   999 			       OPT_ISSET(ops,'i') || OPT_ISSET(ops,'u'))) {

  1000 	zwarnnam(nam, "-e cannot be combined with other options", NULL, 0);

  1001 	return 1;

  1002     }

  1003     queue_signals();

  1004     if (OPT_ISSET(ops,'e'))

  1005 	ret = bin_zmodload_exist(nam, args, ops);

  1006     else if (OPT_ISSET(ops,'d'))

  1007 	ret = bin_zmodload_dep(nam, args, ops);

  1008     else if ((OPT_ISSET(ops,'a') || OPT_ISSET(ops,'b')) && 

  1009 	     !(OPT_ISSET(ops,'c') || OPT_ISSET(ops,'p') || OPT_ISSET(ops,'f')))

  1010 	ret = bin_zmodload_auto(nam, args, ops);

  1011     else if (OPT_ISSET(ops,'c') && !(OPT_ISSET(ops,'b') || OPT_ISSET(ops,'p')))

  1012 	ret = bin_zmodload_cond(nam, args, ops);

  1013     else if (OPT_ISSET(ops,'f') && !(OPT_ISSET(ops,'b') || OPT_ISSET(ops,'p')))

  1014 	ret = bin_zmodload_math(nam, args, ops);

  1015     else if (OPT_ISSET(ops,'p') && !(OPT_ISSET(ops,'b') || OPT_ISSET(ops,'c')))

  1016 	ret = bin_zmodload_param(nam, args, ops);

  1017     else if (!(OPT_ISSET(ops,'a') || OPT_ISSET(ops,'b') || 

  1018 	       OPT_ISSET(ops,'c') || OPT_ISSET(ops,'p')))

  1019 	ret = bin_zmodload_load(nam, args, ops);

  1020     else

  1021 	zwarnnam(nam, "use only one of -b, -c, or -p", NULL, 0);

  1022     unqueue_signals();

  1023 

  1024     return ret;

  1025 }

  1026 #endif //#ifndef __SYMBIAN32__

  1027 

  1028 /**/

  1029 static int

  1030 bin_zmodload_alias(char *nam, char **args, Options ops)

  1031 {

  1032     /*

  1033      * TODO: while it would be too nasty to have aliases, as opposed

  1034      * to real loadable modules, with dependencies --- just what would

  1035      * we need to load when, exactly? --- there is in principle no objection

  1036      * to making it possible to force an alias onto an existing unloaded

  1037      * module which has dependencies.  This would simply transfer

  1038      * the dependencies down the line to the aliased-to module name.

  1039      * This is actually useful, since then you can alias zsh/zle=mytestzle

  1040      * to load another version of zle.  But then what happens when the

  1041      * alias is removed?  Do you transfer the dependencies back? And

  1042      * suppose other names are aliased to the same file?  It might be

  1043      * kettle of fish best left unwormed.

  1044      */

  1045     LinkNode node;

  1046     Module m;

  1047     int ret = 0;

  1048 

  1049     if (!*args) {

  1050 	if (OPT_ISSET(ops,'R')) {

  1051 	    zwarnnam(nam, "no module alias to remove", NULL, 0);

  1052 	    return 1;

  1053 	}

  1054 	for (node = firstnode(modules); node; incnode(node)) {

  1055 	    m = (Module) getdata(node);

  1056 	    if (m->flags & MOD_ALIAS)

  1057 		printmodalias(m, ops);

  1058 	}

  1059 	return 0;

  1060     }

  1061 

  1062     for (; !ret && *args; args++) {

  1063 	char *eqpos = strchr(*args, '=');

  1064 	char *aliasname = eqpos ? eqpos+1 : NULL;

  1065 	if (eqpos)

  1066 	    *eqpos = '\0';

  1067 	if (!modname_ok(*args)) {

  1068 	    zwarnnam(nam, "invalid module name `%s'", *args, 0);

  1069 	    return 1;

  1070 	}

  1071 	if (OPT_ISSET(ops,'R')) {

  1072 	    if (aliasname) {

  1073 		zwarnnam(nam, "bad syntax for removing module alias: %s",

  1074 			 *args, 0);

  1075 		return 1;

  1076 	    }

  1077 	    node = find_module(*args, 0, NULL);

  1078 	    if (node) {

  1079 		m = (Module) getdata(node);

  1080 		if (!(m->flags & MOD_ALIAS)) {

  1081 		    zwarnnam(nam, "module is not an alias: %s", *args, 0);

  1082 		    ret = 1;

  1083 		    break;

  1084 		}

  1085 		delete_module(node);

  1086 	    } else {

  1087 		zwarnnam(nam, "no such module alias: %s", *args, 0);

  1088 		return 1;

  1089 	    }

  1090 	} else {

  1091 	    if (aliasname) {

  1092 		const char *mname = aliasname;

  1093 		if (!modname_ok(aliasname)) {

  1094 		    zwarnnam(nam, "invalid module name `%s'", aliasname, 0);

  1095 		    return 1;

  1096 		}

  1097 		find_module(aliasname, 1, &mname);

  1098 		if (!strcmp(mname, *args)) {

  1099 		    zwarnnam(nam, "module alias would refer to itself: %s",

  1100 			     *args, 0);

  1101 		    return 1;

  1102 		}

  1103 		node = find_module(*args, 0, NULL);

  1104 		if (node) {

  1105 		    m = (Module) getdata(node);

  1106 		    if (!(m->flags & MOD_ALIAS)) {

  1107 			zwarnnam(nam, "module is not an alias: %s", *args, 0);

  1108 			return 1;

  1109 		    }

  1110 		    zsfree(m->u.alias);

  1111 		} else {

  1112 		    m = (Module) zshcalloc(sizeof(*m));

  1113 		    m->nam = ztrdup(*args);

  1114 		    m->flags = MOD_ALIAS;

  1115 		    zaddlinknode(modules, m);

  1116 		}

  1117 		m->u.alias = ztrdup(aliasname);

  1118 	    } else {

  1119 		if ((node = find_module(*args, 0, NULL))) {

  1120 		    m = (Module) getdata(node);

  1121 		    if (m->flags & MOD_ALIAS)

  1122 			printmodalias(m, ops);

  1123 		    else {

  1124 			zwarnnam(nam, "module is not an alias: %s",

  1125 				 *args, 0);

  1126 			return 1;

  1127 		    }

  1128 		} else {

  1129 		    zwarnnam(nam, "no such module alias: %s", *args, 0);

  1130 		    return 1;

  1131 		}

  1132 	    }

  1133 	}

  1134     }