From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 9059 invoked from network); 23 Jun 1999 08:14:08 -0000 Received: from sunsite.auc.dk (130.225.51.30) by ns1.primenet.com.au with SMTP; 23 Jun 1999 08:14:08 -0000 Received: (qmail 25397 invoked by alias); 23 Jun 1999 08:13:57 -0000 Mailing-List: contact zsh-workers-help@sunsite.auc.dk; run by ezmlm Precedence: bulk X-No-Archive: yes X-Seq: 6799 Received: (qmail 25390 invoked from network); 23 Jun 1999 08:13:56 -0000 Date: Wed, 23 Jun 1999 10:13:55 +0200 (MET DST) Message-Id: <199906230813.KAA05413@beta.informatik.hu-berlin.de> From: Sven Wischnowsky To: zsh-workers@sunsite.auc.dk Subject: PATCH: zmodload: builtin modules and testing The last one of the things I did yesterday evening... This adds the `-e' option to `zmodload' which lists all modules -- builtin ones and loaded ones (there may be a better option character, I was thinking about `existing' or something like that). Like `zle -l' with the previous patch this accepts optional arguments which are taken to be names of modules. The returns status is set to reflect if the named modules are all loaded/linked or not. I.e. `if zmodload -e complist; then ZLS=...; fi' or something... The also defines a default implementation of `zmodload' for shells without dynamic linking. The only option supported by it is `-e' (which, of course works only on linked in modules in this case). I've made it return non-zero if it is called without arguments and options. I think this is sensible because in a shell with dynamic loading this would list the loaded modules and return zero, but in a shell without dynamic loading there are no loaded modules. And of course this finally gives us a way to test if the shell has dynamic loading at all: `if zmodload > /dev/null; then echo dynamic; fi'. Bye Sven diff -u -r os/builtin.c Src/builtin.c --- os/builtin.c Tue Jun 22 14:00:50 1999 +++ Src/builtin.c Tue Jun 22 22:15:15 1999 @@ -120,7 +120,9 @@ BUILTIN("which", 0, bin_whence, 0, -1, 0, "ampsw", "c"), #ifdef DYNAMIC - BUILTIN("zmodload", 0, bin_zmodload, 0, -1, 0, "ILabcdipu", NULL), + BUILTIN("zmodload", 0, bin_zmodload, 0, -1, 0, "ILabcdipue", NULL), +#else + BUILTIN("zmodload", 0, bin_zmodload, 0, -1, 0, "e", NULL), #endif }; diff -u -r os/module.c Src/module.c --- os/module.c Tue Jun 22 14:00:53 1999 +++ Src/module.c Tue Jun 22 22:42:59 1999 @@ -709,7 +709,14 @@ zwarnnam(nam, "what do you want to unload?", NULL, 0); return 1; } - if (ops['d']) + if (ops['e'] && (ops['I'] || ops['L'] || ops['a'] || ops['d'] || + ops['i'] || ops['u'])) { + zwarnnam(nam, "-e cannot be combined with other options", NULL, 0); + return 1; + } + if (ops['e']) + return bin_zmodload_exist(nam, args, ops); + else if (ops['d']) return bin_zmodload_dep(nam, args, ops); else if ((ops['a'] || ops['b']) && !(ops['c'] || ops['p'])) return bin_zmodload_auto(nam, args, ops); @@ -727,6 +734,46 @@ /**/ static int +bin_zmodload_exist(char *nam, char **args, char *ops) +{ + LinkNode node; + Module m; + + if (!*args) { + for (node = firstnode(bltinmodules); node; incnode(node)) { + nicezputs((char *) getdata(node), stdout); + putchar('\n'); + } + for (node = firstnode(modules); node; incnode(node)) { + m = (Module) getdata(node); + if (m->handle && !(m->flags & MOD_UNLOAD)) { + nicezputs(m->nam, stdout); + putchar('\n'); + } + } + return 0; + } else { + int ret = 0, f; + + for (; !ret && *args; args++) { + f = 0; + for (node = firstnode(bltinmodules); + !f && node; incnode(node)) + f = !strcmp(*args, (char *) getdata(node)); + for (node = firstnode(modules); + !f && node; incnode(node)) { + m = (Module) getdata(node); + if (m->handle && !(m->flags & MOD_UNLOAD)) + f = !strcmp(*args, m->nam); + } + ret = !f; + } + return ret; + } +} + +/**/ +static int bin_zmodload_dep(char *nam, char **args, char *ops) { LinkNode node; @@ -1113,6 +1160,37 @@ return ret; } +} + +/**/ +#else /* DYNAMIC */ + +/* This is the version for shells without dynamic linking. */ + +/**/ +int +bin_zmodload(char *nam, char **args, char *ops, int func) +{ + /* We understand only the -e option. */ + + if (ops['e']) { + LinkNode node; + + if (!*args) { + for (node = firstnode(bltinmodules); node; incnode(node)) { + nicezputs((char *) getdata(node), stdout); + putchar('\n'); + } + } else { + for (; *args; args++) + for (node = firstnode(bltinmodules); node; incnode(node)) + if (strcmp(*args, (char *) getdata(node))) + return 1; + } + return 0; + } + /* Otherwise we return 1 -- different from the dynamic version. */ + return 1; } /**/ diff -u od/Zsh/builtins.yo Doc/Zsh/builtins.yo --- od/Zsh/builtins.yo Tue Jun 22 21:33:21 1999 +++ Doc/Zsh/builtins.yo Tue Jun 22 22:30:17 1999 @@ -1192,6 +1192,7 @@ cindex(modules, loading) cindex(loading modules) xitem(tt(zmodload) [ tt(-dL) ] [ ... ]) +xitem(tt(zmodload -e) [ ... ]) xitem(tt(zmodload) [ tt(-a) [ tt(-bcp) [ tt(-I) ] ] ] [ tt(-iL) ] ...) item(tt(zmodload) tt(-u) [ tt(-abcdp) [ tt(-I) ] ] [ tt(-iL) ] ...)( tt(zmodload) performs operations relating to zsh's loadable modules. @@ -1287,6 +1288,21 @@ item(tt(zmodload) tt(-ua) [ tt(-i) ] var(builtin) ...)( Equivalent to tt(-ab) and tt(-ub). ) +item(tt(zmodload -e) [ var(string) ... ])( +The tt(-e) option without arguments lists all modules loaded or linked +into the shell. With arguments only the return status is set to zero +if all var(string)s given as arguments are names of modules loaded or +linked in and to one if at least on var(string) is not the name of a +module loaded or linked. This can be used to test for the availability +of things implemented by modules. +) enditem() + +In a shell without dynamic loading only the tt(-e) option is +supported. In such a shell the return status of tt(zmodload) without +arguments or options is one whereas in a shell with dynamic loading +the return status without arguments or options is always zero. This +can be used to test if the shell supports dynamic loading of modules +or not. ) enditem() -- Sven Wischnowsky wischnow@informatik.hu-berlin.de