lisplib: split autoload entries into namespaces.

Autoloads are now keyed to spearate namespaces for
functions/macros, variables, structures, slots and a keyword
namespace for autoloading miscellaneous things tied to
keywords like parameter macros.

There is some renaming going on as part of this. The "dlt"
acronym is replaced by "autload". Some functions in lisplib.c
were in an inconsistent order, and were reordered.

Motivation: the one namespace autoload causes hidden problems
in the standard library, due to inappropriate loads. This
shows up particularly when then uncompiled library is used.
Tests no longer execute as they should.

Story time: when struct.tl is autloaded, it loads param.tl
for parameter parsing, param.tl defines a structure that has
an opt slot, and accesses it with an expression like me.opt.
When this expression is expanded, the qref macro checks
whether opt is a valid slot, and for that, autoload is
triggered. But, oops, opt is a function in getopts.tl,
Thus param.tl autoloads getopt.tl. Paul A. Patience recently
introduced changes into getopt.tl that make use of pattern
matching. So getopt.tl auto-loads match.tl. But match.tl uses
structures. But, oops, that material is defined in struct.tl,
which is in progress of being auto-loaded. Thus, a false
circular dependency exists, caused by a check of the opt slot
triggering the loading of the irrelevant getopts.tl module.

These irrelevant loads will also slow down the compiling of
the library also, as well as test cases when the library is
not compiled: especially tests run under the GC torture test.

* lisplib.c (dl_table): Global variable removed.
(autoload_hash): New static array.
(set_dlt_entries_impl): Renamed to autoload_set_impl.
(autoload_set_impl): Takes al_ns_t namespace enum argument.
Operates on the hash table indicated by that argument.
(set_dlt_entries): Renamed to autoload_set.
(set_dlt_entries_sys): Renamed to autoload_sys_set.
(autoload_key_set): New static function.
(place_set_entries, ver_set_entries, ifa_set_entries,
txr_case_set_entries, with_resources_set_entries,
path_test_set_entries, struct_set_entries,
with_stream_set_entries, hash_set_entries, except_set_entries,
type_set_entries, yield_set_entries, sock_set_entries,
termios_set_entries, awk_set_entries, build_set_entries,
trace_set_entries, getopts_set_entries, package_set_entries,
getput_set_entries, tagbody_set_entries, pmac_set_entries,
error_set_entries, keyparams_set_entries, ffi_set_entries,
doloop_set_entries, stream_wrap_set_entries, asm_set_entries,
compiler_set_entries, debugger_set_entries, op_set_entries,
save_exe_set_entries, defset_set_entries,
copy_file_set_entries, arith_each_set_entries,
each_prod_set_entries, quips_set_entries, match_set_entries,
doc_set_entries, pic_set_entries, constfun_set_entries):
Separate name arrays into multipel namespaces as appropriate
and register using approprate namespace enums.
(dlt_register): Renamed to autoload_reg.
(autoload_reg): dlt parameter removed.
(lisplib_try_load): Take namespace enum argument, and check
against the corresponding hash.
(lisplib_try_load_fun, lisplib_try_load_var,
lisplib_try_load_slot, lisblib_try_load_struct,
lisplib_try_load_keyword): Pass appropriate enum value to
lisplib_try_load to request the right namespace.
(lisplib_try_load_fun_var): Call lisplib_try_load_fun,
and if that does nothing, lisplib_try_load_var.
(lisplib_init_tables): New function.
(lisplib_init): References to dl_table removed. Call to
dlt_register replaced with autoload_reg.

* lisplib.h (dl_table): Declaration removed.
(enum autoload_ns, al_ns_t): New enum.
(set_dlt_entries, dlt_register): Declarations removed.
(autoload_set, autoload_reg): Declared.

* gencadr.txr (cadr_set_entries): Drop dlt parameter, call
autoload_set instead of set_dlt_entries.
(cadr_init): Call autoload_reg instead of dlt_register.

* cadr.c: regenerated.

4 files changed, 289 insertions, 243 deletions

diff --git a/cadr.c b/cadr.c
index 8eff2bfd..d0c7765a 100644
--- a/cadr.c
+++ b/cadr.c
@@ -407,7 +407,7 @@ static val cadr_register(val set_fun)
   return nil;
 }
 
-static val cadr_set_entries(val dlt, val fun)
+static val cadr_set_entries(val fun)
 {
   val name[] = {
     lit("caar"),
@@ -473,11 +473,11 @@ static val cadr_set_entries(val dlt, val fun)
     nil
   };
 
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
 void cadr_init(void)
 {
-  dlt_register(dl_table, cadr_register, cadr_set_entries);
+  autoload_reg(cadr_register, cadr_set_entries);
 }
diff --git a/gencadr.txr b/gencadr.txr
index 4e32045c..20e7b7bb 100644
--- a/gencadr.txr
+++ b/gencadr.txr
@@ -50,7 +50,7 @@ static val cadr_register(val set_fun)
   return nil;
 }
 
-static val cadr_set_entries(val dlt, val fun)
+static val cadr_set_entries(val fun)
 {
   val name[] = {
 @  (repeat)
@@ -59,13 +59,13 @@ static val cadr_set_entries(val dlt, val fun)
     nil
   };
 
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
 void cadr_init(void)
 {
-  dlt_register(dl_table, cadr_register, cadr_set_entries);
+  autoload_reg(cadr_register, cadr_set_entries);
 }
 @(end)
 @(output "cadr.h")
diff --git a/lisplib.c b/lisplib.c
index 44885041..07485518 100644
--- a/lisplib.c
+++ b/lisplib.c
@@ -41,30 +41,36 @@
 #include "socket.h"
 #include "lisplib.h"
 
-val dl_table;
 int opt_dbg_autoload;
 val trace_loaded;
 
-static void set_dlt_entries_impl(val dlt, val *name, val fun, val package)
+static val autoload_hash[al_max + 1];
+
+static void autload_set_impl(al_ns_t ns, val *name, val fun, val package)
 {
   for (; *name; name++) {
     val sym = intern(*name, package);
 
     if (fun)
-      sethash(dlt, sym, fun);
+      sethash(autoload_hash[ns], sym, fun);
     else
-      remhash(dlt, sym);
+      remhash(autoload_hash[ns], sym);
   }
 }
 
-void set_dlt_entries(val dlt, val *name, val fun)
+void autoload_set(al_ns_t ns, val *name, val fun)
+{
+  autload_set_impl(ns, name, fun, user_package);
+}
+
+static void autoload_sys_set(al_ns_t ns, val *name, val fun)
 {
-  set_dlt_entries_impl(dlt, name, fun, user_package);
+  autload_set_impl(ns, name, fun, system_package);
 }
 
-static void set_dlt_entries_sys(val dlt, val *name, val fun)
+static void autoload_key_set(al_ns_t ns, val *name, val fun)
 {
-  set_dlt_entries_impl(dlt, name, fun, system_package);
+  autload_set_impl(ns, name, fun, keyword_package);
 }
 
 static void intern_only(val *name)
@@ -73,16 +79,19 @@ static void intern_only(val *name)
     intern(*name, user_package);
 }
 
-static val place_set_entries(val dlt, val fun)
+static val place_set_entries(val fun)
 {
   val sys_name[] = {
     lit("get-fun-getter-setter"), lit("get-mb"), lit("get-vb"),
     lit("register-simple-accessor"),
     nil
   };
-  val name[] = {
+  val vname[] = {
     lit("*place-clobber-expander*"), lit("*place-update-expander*"),
     lit("*place-delete-expander*"), lit("*place-macro*"),
+    nil
+  };
+  val name[] = {
     lit("get-update-expander"), lit("get-clobber-expander"),
     lit("get-delete-expander"),
     lit("place-form-p"),
@@ -103,8 +112,9 @@ static val place_set_entries(val dlt, val fun)
     nil
   };
 
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_fun, sys_name, fun);
+  autoload_set(al_var, vname, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -115,10 +125,10 @@ static val place_instantiate(val set_fun)
   return nil;
 }
 
-static val ver_set_entries(val dlt, val fun)
+static val ver_set_entries(val fun)
 {
-  val name[] = { lit("*lib-version*"), lit("lib-version"), nil };
-  set_dlt_entries(dlt, name, fun);
+  val vname[] = { lit("*lib-version*"), lit("lib-version"), nil };
+  autoload_set(al_var, vname, fun);
   return nil;
 }
 
@@ -129,12 +139,12 @@ static val ver_instantiate(val set_fun)
   return nil;
 }
 
-static val ifa_set_entries(val dlt, val fun)
+static val ifa_set_entries(val fun)
 {
   val name[] = {
     lit("ifa"), lit("whena"), lit("conda"), lit("condlet"), lit("it"), nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -145,10 +155,10 @@ static val ifa_instantiate(val set_fun)
   return nil;
 }
 
-static val txr_case_set_entries(val dlt, val fun)
+static val txr_case_set_entries(val fun)
 {
   val name[] = { lit("txr-if"), lit("txr-when"), lit("txr-case"), nil };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -159,14 +169,14 @@ static val txr_case_instantiate(val set_fun)
   return nil;
 }
 
-static val with_resources_set_entries(val dlt, val fun)
+static val with_resources_set_entries(val fun)
 {
   val name[] = {
     lit("with-resources"),
     lit("with-objects"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -177,7 +187,7 @@ static val with_resources_instantiate(val set_fun)
   return nil;
 }
 
-static val path_test_set_entries(val dlt, val fun)
+static val path_test_set_entries(val fun)
 {
   val name[] = {
     lit("path-exists-p"), lit("path-file-p"), lit("path-dir-p"),
@@ -193,8 +203,7 @@ static val path_test_set_entries(val dlt, val fun)
     lit("path-dir-empty"),
     nil
   };
-
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -205,7 +214,7 @@ static val path_test_instantiate(val set_fun)
   return nil;
 }
 
-static val struct_set_entries(val dlt, val fun)
+static val struct_set_entries(val fun)
 {
   val sys_name[] = {
     lit("define-method"), lit("rslotset"), nil
@@ -214,16 +223,20 @@ static val struct_set_entries(val dlt, val fun)
     lit("defstruct"), lit("qref"), lit("uref"), lit("new"), lit("lnew"),
     lit("new*"), lit("lnew*"),
     lit("meth"), lit("umeth"), lit("usl"), lit("defmeth"), lit("rslot"),
-    lit("*struct-clause-expander*"), lit("define-struct-clause"), nil
+    lit("define-struct-clause"), nil
+  };
+  val vname[] = {
+    lit("*struct-clause-expander*"), nil
   };
 
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_fun, sys_name, fun);
+  autoload_set(al_fun, name, fun);
+  autoload_set(al_var, vname, fun);
 
   if (fun)
-    sethash(dlt, struct_lit_s, fun);
+    sethash(autoload_hash[al_fun], struct_lit_s, fun);
   else
-    remhash(dlt, struct_lit_s);
+    remhash(autoload_hash[al_fun], struct_lit_s);
 
   return nil;
 }
@@ -235,7 +248,7 @@ static val struct_instantiate(val set_fun)
   return nil;
 }
 
-static val with_stream_set_entries(val dlt, val fun)
+static val with_stream_set_entries(val fun)
 {
   val name[] = {
     lit("with-out-string-stream"),
@@ -247,7 +260,7 @@ static val with_stream_set_entries(val dlt, val fun)
     lit("with-stream"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -258,10 +271,10 @@ static val with_stream_instantiate(val set_fun)
   return nil;
 }
 
-static val hash_set_entries(val dlt, val fun)
+static val hash_set_entries(val fun)
 {
   val name[] = { lit("with-hash-iter"), nil };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -272,14 +285,14 @@ static val hash_instantiate(val set_fun)
   return nil;
 }
 
-static val except_set_entries(val dlt, val fun)
+static val except_set_entries(val fun)
 {
   val name[] = {
     lit("catch"), lit("catch*"), lit("catch**"), lit("handle"), lit("handle*"),
     lit("ignwarn"), lit("macro-time-ignwarn"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -290,12 +303,12 @@ static val except_instantiate(val set_fun)
   return nil;
 }
 
-static val type_set_entries(val dlt, val fun)
+static val type_set_entries(val fun)
 {
   val name[] = {
     lit("typecase"), lit("etypecase"), nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -306,7 +319,7 @@ static val type_instantiate(val set_fun)
   return nil;
 }
 
-static val yield_set_entries(val dlt, val fun)
+static val yield_set_entries(val fun)
 {
   val sys_name[] = {
     lit("obtain-impl"), nil
@@ -317,9 +330,8 @@ static val yield_set_entries(val dlt, val fun)
     lit("suspend"), lit("hlet"), lit("hlet*"),
     nil
   };
-
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_fun, sys_name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -331,12 +343,14 @@ static val yield_instantiate(val set_fun)
 }
 
 #if HAVE_SOCKETS
-static val sock_set_entries(val dlt, val fun)
+static val sock_set_entries(val fun)
 {
-  val name[] = {
+  val sname[] = {
     lit("sockaddr"), lit("sockaddr-in"), lit("sockaddr-in6"),
     lit("sockaddr-un"), lit("addrinfo"),
-    lit("getaddrinfo"),
+    nil
+  };
+  val vname[] = {
     lit("af-unspec"), lit("af-unix"), lit("af-inet"), lit("af-inet6"),
     lit("sock-stream"), lit("sock-dgram"),
     lit("inaddr-any"), lit("inaddr-loopback"),
@@ -345,6 +359,10 @@ static val sock_set_entries(val dlt, val fun)
     lit("ai-passive"), lit("ai-canonname"), lit("ai-numerichost"),
     lit("ai-v4mapped"), lit("ai-all"), lit("ai-addrconfig"),
     lit("ai-numericserv"),
+    nil
+  };
+  val name[] = {
+    lit("getaddrinfo"),
     lit("str-inaddr"), lit("str-in6addr"),
     lit("str-inaddr-net"), lit("str-in6addr-net"),
     lit("inaddr-str"), lit("in6addr-str"),
@@ -361,7 +379,9 @@ static val sock_set_entries(val dlt, val fun)
     lit("scope-id"), lit("prefix"), lit("path"), lit("flags"), lit("socktype"),
     lit("protocol"), lit("canonname"), nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_struct, sname, fun);
+  autoload_set(al_var, vname, fun);
+  autoload_set(al_fun, name, fun);
   intern_only(name_noload);
   return nil;
 }
@@ -378,15 +398,15 @@ static val sock_instantiate(val set_fun)
 
 #if HAVE_TERMIOS
 
-static val termios_set_entries(val dlt, val fun)
+static val termios_set_entries(val fun)
 {
-  val name[] = {
+  val slname[] = {
     lit("set-iflags"), lit("set-oflags"), lit("set-cflags"), lit("set-lflags"),
     lit("clear-iflags"), lit("clear-oflags"), lit("clear-cflags"), lit("clear-lflags"),
     lit("go-raw"), lit("go-cbreak"), lit("go-canon"),
     lit("string-encode"), lit("string-decode"), nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_slot, slname, fun);
   return nil;
 }
 
@@ -399,9 +419,9 @@ static val termios_instantiate(val set_fun)
 
 #endif
 
-static val awk_set_entries(val dlt, val fun)
+static val awk_set_entries(val fun)
 {
-  val sys_name[] = {
+  val sys_sname[] = {
     lit("awk-state"), nil
   };
   val name[] = {
@@ -419,9 +439,8 @@ static val awk_set_entries(val dlt, val fun)
     lit("iz"), lit("oz"), lit("xz"), lit("bz"), lit("cz"), lit("rz"),
     nil
   };
-
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_struct, sys_sname, fun);
+  autoload_set(al_fun, name, fun);
   intern_only(name_noload);
   return nil;
 }
@@ -433,10 +452,13 @@ static val awk_instantiate(val set_fun)
   return nil;
 }
 
-static val build_set_entries(val dlt, val fun)
+static val build_set_entries(val fun)
 {
+  val sname[] = {
+    lit("list-builder"), nil
+  };
   val name[] = {
-    lit("list-builder"), lit("build-list"), lit("build"), lit("buildn"), nil
+    lit("build-list"), lit("build"), lit("buildn"), nil
   };
   val name_noload[] = {
     lit("head"), lit("tail"), lit("add"), lit("add*"), lit("pend"),
@@ -444,8 +466,8 @@ static val build_set_entries(val dlt, val fun)
     lit("del"), lit("del*"),
     nil
   };
-
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_struct, sname, fun);
+  autoload_set(al_fun, name, fun);
   intern_only(name_noload);
   return nil;
 }
@@ -457,17 +479,20 @@ static val build_instantiate(val set_fun)
   return nil;
 }
 
-static val trace_set_entries(val dlt, val fun)
+static val trace_set_entries(val fun)
 {
   val sys_name[] = {
     lit("trace"), lit("untrace"), nil
   };
+  val vname[] = {
+    lit("*trace-output*"), nil
+  };
   val name[] = {
-    lit("*trace-output*"), lit("trace"), lit("untrace"), nil
+    lit("trace"), lit("untrace"), nil
   };
-
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_fun, sys_name, fun);
+  autoload_set(al_var, vname, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -479,10 +504,12 @@ static val trace_instantiate(val set_fun)
   return nil;
 }
 
-static val getopts_set_entries(val dlt, val fun)
+static val getopts_set_entries(val fun)
 {
+  val sname[] = {
+    lit("opt-desc"), lit("opts"), nil
+  };
   val name[] = {
-    lit("opt-desc"), lit("opts"),
     lit("opt"), lit("getopts"), lit("opthelp"), lit("opthelp-conventions"),
     lit("opthelp-types"), lit("define-option-struct"),
     nil
@@ -491,7 +518,8 @@ static val getopts_set_entries(val dlt, val fun)
     lit("short"), lit("long"), lit("helptext"), lit("type"),
     lit("in-args"), lit("out-args"), lit("cumul"), lit("opt-error"), nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_struct, sname, fun);
+  autoload_set(al_fun, name, fun);
   intern_only(name_noload);
   return nil;
 }
@@ -503,13 +531,13 @@ static val getopts_instantiate(val set_fun)
   return nil;
 }
 
-static val package_set_entries(val dlt, val fun)
+static val package_set_entries(val fun)
 {
   val name[] = {
     lit("defpackage"), lit("in-package"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -520,7 +548,7 @@ static val package_instantiate(val set_fun)
   return nil;
 }
 
-static val getput_set_entries(val dlt, val fun)
+static val getput_set_entries(val fun)
 {
   val name[] = {
     lit("get-jsons"), lit("put-jsons"),
@@ -539,7 +567,7 @@ static val getput_set_entries(val dlt, val fun)
     lit("command-get-jsons"), lit("command-put-jsons"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -550,12 +578,12 @@ static val getput_instantiate(val set_fun)
   return nil;
 }
 
-static val tagbody_set_entries(val dlt, val fun)
+static val tagbody_set_entries(val fun)
 {
   val name[] = {
     lit("tagbody"), lit("go"), lit("prog"), lit("prog*"), nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -566,12 +594,12 @@ static val tagbody_instantiate(val set_fun)
   return nil;
 }
 
-static val pmac_set_entries(val dlt, val fun)
+static val pmac_set_entries(val fun)
 {
   val name[] = {
     lit("define-param-expander"), nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -582,7 +610,7 @@ static val pmac_instantiate(val set_fun)
   return nil;
 }
 
-static val error_set_entries(val dlt, val fun)
+static val error_set_entries(val fun)
 {
   val sys_name[] = {
     lit("bind-mac-error"), lit("bind-mac-check"),
@@ -594,8 +622,8 @@ static val error_set_entries(val dlt, val fun)
     lit("compile-error"), lit("compile-warning"), lit("compile-defr-warning"),
     nil
   };
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_fun, sys_name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -606,22 +634,20 @@ static val error_instantiate(val set_fun)
   return nil;
 }
 
-static val keyparams_set_entries(val dlt, val fun)
+static val keyparams_set_entries(val fun)
 {
   val sys_name[] = {
-    lit("extract-keys"),
-    nil
+    lit("extract-keys"), nil
+  };
+  val sys_kname[] = {
+    lit("key"), nil
   };
   val name_noload[] = {
     lit("--"),
     nil
   };
-  val key_k = intern(lit("key"), keyword_package);
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  if (fun)
-    sethash(dlt, key_k, fun);
-  else
-    remhash(dlt, key_k);
+  autoload_sys_set(al_fun, sys_name, fun);
+  autoload_key_set(al_key, sys_kname, fun);
   intern_only(name_noload);
   return nil;
 }
@@ -633,7 +659,7 @@ static val keyparams_instantiate(val set_fun)
   return nil;
 }
 
-static val ffi_set_entries(val dlt, val fun)
+static val ffi_set_entries(val fun)
 {
   val name[] = {
     lit("with-dyn-lib"), lit("deffi"), lit("deffi-type"), lit("deffi-cb"),
@@ -645,7 +671,7 @@ static val ffi_set_entries(val dlt, val fun)
     lit("sub-buf"), lit("znew"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -656,13 +682,13 @@ static val ffi_instantiate(val set_fun)
   return nil;
 }
 
-static val doloop_set_entries(val dlt, val fun)
+static val doloop_set_entries(val fun)
 {
   val name[] = {
     lit("doloop"), lit("doloop*"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -673,9 +699,9 @@ static val doloop_instantiate(val set_fun)
   return nil;
 }
 
-static val stream_wrap_set_entries(val dlt, val fun)
+static val stream_wrap_set_entries(val fun)
 {
-  val name[] = {
+  val sname[] = {
     lit("stream-wrap"),
     nil
   };
@@ -683,8 +709,7 @@ static val stream_wrap_set_entries(val dlt, val fun)
     lit("close"), lit("flush"), lit("seek"), lit("truncate"),
     lit("get-prop"), lit("set-prop"), lit("get-fd"), nil
   };
-
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_struct, sname, fun);
   intern_only(name_noload);
   return nil;
 }
@@ -696,16 +721,9 @@ static val stream_wrap_instantiate(val set_fun)
   return nil;
 }
 
-static val asm_instantiate(val set_fun)
-{
-  funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("asm")));
-  return nil;
-}
-
-static val asm_set_entries(val dlt, val fun)
+static val asm_set_entries(val fun)
 {
-  val sys_name[] = {
+  val sys_sname[] = {
     lit("assembler"),
     nil
   };
@@ -713,20 +731,19 @@ static val asm_set_entries(val dlt, val fun)
     lit("disassemble"),
     nil
   };
-
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_struct, sys_sname, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
-static val compiler_instantiate(val set_fun)
+static val asm_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("compiler")));
+  load(scat2(stdlib_path, lit("asm")));
   return nil;
 }
 
-static val compiler_set_entries(val dlt, val fun)
+static val compiler_set_entries(val fun)
 {
   val sys_name[] = {
     lit("compiler"), lit("*in-compilation-unit*"),
@@ -736,35 +753,43 @@ static val compiler_set_entries(val dlt, val fun)
     lit("compile-toplevel"), lit("compile"), lit("compile-file"),
     lit("compile-update-file"),
     lit("with-compilation-unit"), lit("dump-compiled-objects"),
+    nil
+  };
+  val vname[] = {
     lit("*opt-level*"),
     nil
   };
-
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_struct, sys_name, fun);
+  autoload_set(al_fun, name, fun);
+  autoload_set(al_var, vname, fun);
   return nil;
 }
 
-static val debugger_instantiate(val set_fun)
+static val compiler_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("debugger")));
+  load(scat2(stdlib_path, lit("compiler")));
   return nil;
 }
 
-static val debugger_set_entries(val dlt, val fun)
+static val debugger_set_entries(val fun)
 {
   val sys_name[] = {
     lit("debugger"), lit("print-backtrace"),
     nil
   };
-
-  set_dlt_entries_sys(dlt, sys_name, fun);
+  autoload_sys_set(al_fun, sys_name, fun);
   return nil;
 }
 
+static val debugger_instantiate(val set_fun)
+{
+  funcall1(set_fun, nil);
+  load(scat2(stdlib_path, lit("debugger")));
+  return nil;
+}
 
-static val op_set_entries(val dlt, val fun)
+static val op_set_entries(val fun)
 {
   val name[] = {
     lit("op"), lit("do"), lit("lop"), lit("ldo"), lit("ap"), lit("ip"),
@@ -772,7 +797,7 @@ static val op_set_entries(val dlt, val fun)
     lit("opip"), lit("oand"), lit("flow"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -783,32 +808,25 @@ static val op_instantiate(val set_fun)
   return nil;
 }
 
-static val save_exe_instantiate(val set_fun)
-{
-  funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("save-exe")));
-  return nil;
-}
-
-static val save_exe_set_entries(val dlt, val fun)
+static val save_exe_set_entries(val fun)
 {
   val name[] = {
     lit("save-exe"),
     nil
   };
 
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
-static val defset_instantiate(val set_fun)
+static val save_exe_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("defset")));
+  load(scat2(stdlib_path, lit("save-exe")));
   return nil;
 }
 
-static val defset_set_entries(val dlt, val fun)
+static val defset_set_entries(val fun)
 {
   val name[] = {
     lit("defset"), lit("sub-list"), lit("sub-vec"), lit("sub-str"),
@@ -816,56 +834,61 @@ static val defset_set_entries(val dlt, val fun)
     lit("set-mask"), lit("clear-mask"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
- 
-static val copy_file_instantiate(val set_fun)
+
+static val defset_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("copy-file")));
+  load(scat2(stdlib_path, lit("defset")));
   return nil;
 }
 
-static val copy_file_set_entries(val dlt, val fun)
+static val copy_file_set_entries(val fun)
 {
+  val sname[] = {
+    lit("copy-path-opts"),
+    nil
+  };
   val name[] = {
-    lit("copy-path-opts"), lit("copy-file"), lit("copy-files"), lit("cat-files"),
+    lit("copy-file"), lit("copy-files"), lit("cat-files"),
     lit("copy-path-rec"), lit("remove-path-rec"),
     lit("chown-rec"), lit("chmod-rec"), lit("touch"), lit("rel-path"),
     lit("path-equal"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_struct, sname, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
-static val arith_each_instantiate(val set_fun)
+static val copy_file_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("arith-each")));
+  load(scat2(stdlib_path, lit("copy-file")));
   return nil;
 }
 
-static val arith_each_set_entries(val dlt, val fun)
+static val arith_each_set_entries(val fun)
 {
   val name[] = {
     lit("sum-each"), lit("mul-each"), lit("sum-each*"), lit("mul-each*"),
     lit("each-true"), lit("some-true"), lit("each-false"), lit("some-false"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
-static val each_prod_instantiate(val set_fun)
+static val arith_each_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("each-prod")));
+  load(scat2(stdlib_path, lit("arith-each")));
   return nil;
 }
 
-static val each_prod_set_entries(val dlt, val fun)
+static val each_prod_set_entries(val fun)
 {
   val name[] = {
     lit("each-prod"), lit("collect-each-prod"), lit("append-each-prod"),
@@ -874,35 +897,34 @@ static val each_prod_set_entries(val dlt, val fun)
     lit("sum-each-prod*"), lit("mul-each-prod*"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
-static val quips_instantiate(val set_fun)
+static val each_prod_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("quips")));
+  load(scat2(stdlib_path, lit("each-prod")));
   return nil;
 }
 
-static val quips_set_entries(val dlt, val fun)
+static val quips_set_entries(val fun)
 {
   val name[] = {
-    lit("quip"),
-    nil
+    lit("quip"), nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
-static val match_instantiate(val set_fun)
+static val quips_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
-  load(scat2(stdlib_path, lit("match")));
+  load(scat2(stdlib_path, lit("quips")));
   return nil;
 }
 
-static val match_set_entries(val dlt, val fun)
+static val match_set_entries(val fun)
 {
   val name_noload[] = {
     lit("all*"), lit("as"), lit("with"), lit("scan"), lit("sme"), lit("match-error"),
@@ -916,21 +938,44 @@ static val match_set_entries(val dlt, val fun)
     lit("each-match"), lit("append-matches"),
     lit("keep-matches"), lit("each-match-product"),
     lit("append-match-products"), lit("keep-match-products"),
+    nil
+  };
+  val vname[] = {
     lit("*match-macro*"),
     nil
   };
-  val match_k = intern(lit("match"), keyword_package);
-
-  if (fun)
-    sethash(dlt, match_k, fun);
-  else
-    remhash(dlt, match_k);
+  val kname[] = {
+    lit("match"),
+    nil
+  };
 
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
+  autoload_set(al_var, vname, fun);
+  autoload_key_set(al_key, kname, fun);
   intern_only(name_noload);
   return nil;
 }
 
+static val match_instantiate(val set_fun)
+{
+  funcall1(set_fun, nil);
+  load(scat2(stdlib_path, lit("match")));
+  return nil;
+}
+
+static val doc_set_entries(val fun)
+{
+  val name[] = {
+    lit("doc"), nil
+  };
+  val vname[] = {
+    lit("*doc-url*"), nil
+  };
+  autoload_set(al_fun, name, fun);
+  autoload_set(al_var, vname, fun);
+  return nil;
+}
+
 static val doc_instantiate(val set_fun)
 {
   funcall1(set_fun, nil);
@@ -938,13 +983,13 @@ static val doc_instantiate(val set_fun)
   return nil;
 }
 
-static val doc_set_entries(val dlt, val fun)
+static val pic_set_entries(val fun)
 {
   val name[] = {
-    lit("doc"), lit("*doc-url*"),
+    lit("pic"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_set(al_fun, name, fun);
   return nil;
 }
 
@@ -955,13 +1000,13 @@ static val pic_instantiate(val set_fun)
   return nil;
 }
 
-static val pic_set_entries(val dlt, val fun)
+static val constfun_set_entries(val fun)
 {
-  val name[] = {
-    lit("pic"),
+  val sys_vname[] = {
+    lit("%const-foldable%"),
     nil
   };
-  set_dlt_entries(dlt, name, fun);
+  autoload_sys_set(al_var, sys_vname, fun);
   return nil;
 }
 
@@ -972,82 +1017,79 @@ static val constfun_instantiate(val set_fun)
   return nil;
 }
 
-static val constfun_set_entries(val dlt, val fun)
+val autoload_reg(val (*instantiate)(val),
+                 val (*set_entries)(val))
 {
-  val sys_name[] = {
-    lit("%const-foldable%"),
-    nil
-  };
-  set_dlt_entries_sys(dlt, sys_name, fun);
-  return nil;
+  return set_entries(func_f0(func_n1(set_entries), instantiate));
 }
 
-val dlt_register(val dlt,
-                 val (*instantiate)(val),
-                 val (*set_entries)(val, val))
+static void lisplib_init_tables(void)
 {
-  return set_entries(dl_table, func_f0(func_f1(dlt, set_entries), instantiate));
+  int i;
+  for (i = 0; i <= al_max; i++) {
+    autoload_hash[i] = make_hash(hash_weak_none, nil);
+    prot1(&autoload_hash[i]);
+  }
 }
 
 void lisplib_init(void)
 {
-  prot1(&dl_table);
-  dl_table = make_hash(hash_weak_none, nil);
-  dlt_register(dl_table, place_instantiate, place_set_entries);
-  dlt_register(dl_table, ver_instantiate, ver_set_entries);
-  dlt_register(dl_table, ifa_instantiate, ifa_set_entries);
-  dlt_register(dl_table, txr_case_instantiate, txr_case_set_entries);
-  dlt_register(dl_table, with_resources_instantiate, with_resources_set_entries);
-  dlt_register(dl_table, path_test_instantiate, path_test_set_entries);
-  dlt_register(dl_table, struct_instantiate, struct_set_entries);
-  dlt_register(dl_table, with_stream_instantiate, with_stream_set_entries);
-  dlt_register(dl_table, hash_instantiate, hash_set_entries);
-  dlt_register(dl_table, except_instantiate, except_set_entries);
-  dlt_register(dl_table, type_instantiate, type_set_entries);
-  dlt_register(dl_table, yield_instantiate, yield_set_entries);
+  lisplib_init_tables();
+  autoload_reg(place_instantiate, place_set_entries);
+  autoload_reg(ver_instantiate, ver_set_entries);
+  autoload_reg(ifa_instantiate, ifa_set_entries);
+  autoload_reg(txr_case_instantiate, txr_case_set_entries);
+  autoload_reg(with_resources_instantiate, with_resources_set_entries);
+  autoload_reg(path_test_instantiate, path_test_set_entries);
+  autoload_reg(struct_instantiate, struct_set_entries);
+  autoload_reg(with_stream_instantiate, with_stream_set_entries);
+  autoload_reg(hash_instantiate, hash_set_entries);
+  autoload_reg(except_instantiate, except_set_entries);
+  autoload_reg(type_instantiate, type_set_entries);
+  autoload_reg(yield_instantiate, yield_set_entries);
 #if HAVE_SOCKETS
-  dlt_register(dl_table, sock_instantiate, sock_set_entries);
+  autoload_reg(sock_instantiate, sock_set_entries);
 #endif
 #if HAVE_TERMIOS
-  dlt_register(dl_table, termios_instantiate, termios_set_entries);
+  autoload_reg(termios_instantiate, termios_set_entries);
 #endif
-  dlt_register(dl_table, awk_instantiate, awk_set_entries);
-  dlt_register(dl_table, build_instantiate, build_set_entries);
-  dlt_register(dl_table, trace_instantiate, trace_set_entries);
-  dlt_register(dl_table, getopts_instantiate, getopts_set_entries);
-  dlt_register(dl_table, package_instantiate, package_set_entries);
-  dlt_register(dl_table, getput_instantiate, getput_set_entries);
-  dlt_register(dl_table, tagbody_instantiate, tagbody_set_entries);
-  dlt_register(dl_table, pmac_instantiate, pmac_set_entries);
-  dlt_register(dl_table, error_instantiate, error_set_entries);
-  dlt_register(dl_table, keyparams_instantiate, keyparams_set_entries);
-  dlt_register(dl_table, ffi_instantiate, ffi_set_entries);
-  dlt_register(dl_table, doloop_instantiate, doloop_set_entries);
-  dlt_register(dl_table, stream_wrap_instantiate, stream_wrap_set_entries);
-  dlt_register(dl_table, asm_instantiate, asm_set_entries);
-  dlt_register(dl_table, compiler_instantiate, compiler_set_entries);
-  dlt_register(dl_table, debugger_instantiate, debugger_set_entries);
+  autoload_reg(awk_instantiate, awk_set_entries);
+  autoload_reg(build_instantiate, build_set_entries);
+  autoload_reg(trace_instantiate, trace_set_entries);
+  autoload_reg(getopts_instantiate, getopts_set_entries);
+  autoload_reg(package_instantiate, package_set_entries);
+  autoload_reg(getput_instantiate, getput_set_entries);
+  autoload_reg(tagbody_instantiate, tagbody_set_entries);
+  autoload_reg(pmac_instantiate, pmac_set_entries);
+  autoload_reg(error_instantiate, error_set_entries);
+  autoload_reg(keyparams_instantiate, keyparams_set_entries);
+  autoload_reg(ffi_instantiate, ffi_set_entries);
+  autoload_reg(doloop_instantiate, doloop_set_entries);
+  autoload_reg(stream_wrap_instantiate, stream_wrap_set_entries);
+  autoload_reg(asm_instantiate, asm_set_entries);
+  autoload_reg(compiler_instantiate, compiler_set_entries);
+  autoload_reg(debugger_instantiate, debugger_set_entries);
 
   if (!opt_compat || opt_compat >= 185)
-    dlt_register(dl_table, op_instantiate, op_set_entries);
-
-  dlt_register(dl_table, save_exe_instantiate, save_exe_set_entries);
-  dlt_register(dl_table, defset_instantiate, defset_set_entries);
-  dlt_register(dl_table, copy_file_instantiate, copy_file_set_entries);
-  dlt_register(dl_table, arith_each_instantiate, arith_each_set_entries);
-  dlt_register(dl_table, each_prod_instantiate, each_prod_set_entries);
-  dlt_register(dl_table, quips_instantiate, quips_set_entries);
-  dlt_register(dl_table, match_instantiate, match_set_entries);
-  dlt_register(dl_table, doc_instantiate, doc_set_entries);
-  dlt_register(dl_table, pic_instantiate, pic_set_entries);
-  dlt_register(dl_table, constfun_instantiate, constfun_set_entries);
+    autoload_reg(op_instantiate, op_set_entries);
+
+  autoload_reg(save_exe_instantiate, save_exe_set_entries);
+  autoload_reg(defset_instantiate, defset_set_entries);
+  autoload_reg(copy_file_instantiate, copy_file_set_entries);
+  autoload_reg(arith_each_instantiate, arith_each_set_entries);
+  autoload_reg(each_prod_instantiate, each_prod_set_entries);
+  autoload_reg(quips_instantiate, quips_set_entries);
+  autoload_reg(match_instantiate, match_set_entries);
+  autoload_reg(doc_instantiate, doc_set_entries);
+  autoload_reg(pic_instantiate, pic_set_entries);
+  autoload_reg(constfun_instantiate, constfun_set_entries);
 
   reg_fun(intern(lit("try-load-fun"), system_package), func_n1(lisplib_try_load_fun));
 }
 
-static val lisplib_try_load(val sym)
+static val lisplib_try_load(al_ns_t ns, val sym)
 {
-  val fun = gethash(dl_table, sym);
+  val fun = gethash(autoload_hash[ns], sym);
 
   if (fun) {
      unsigned ds = debug_clear(opt_dbg_autoload ? 0 : DBG_ENABLE);
@@ -1065,30 +1107,32 @@ static val lisplib_try_load(val sym)
 
 val lisplib_try_load_fun(val sym)
 {
-  return lisplib_try_load(sym);
+  return lisplib_try_load(al_fun, sym);
 }
 
 val lisplib_try_load_var(val sym)
 {
-  return lisplib_try_load(sym);
+  return lisplib_try_load(al_var, sym);
 }
 
 val lisplib_try_load_fun_var(val sym)
 {
-  return lisplib_try_load(sym);
+  uses_or2;
+  return or2(lisplib_try_load_fun(sym),
+             lisplib_try_load_var(sym));
 }
 
 val lisplib_try_load_slot(val sym)
 {
-  return lisplib_try_load(sym);
+  return lisplib_try_load(al_slot, sym);
 }
 
 val lisplib_try_load_struct(val sym)
 {
-  return lisplib_try_load(sym);
+  return lisplib_try_load(al_struct, sym);
 }
 
 val lisplib_try_load_keyword(val sym)
 {
-  return lisplib_try_load(sym);
+  return lisplib_try_load(al_key, sym);
 }
diff --git a/lisplib.h b/lisplib.h
index 65aa2693..5a364a9e 100644
--- a/lisplib.h
+++ b/lisplib.h
@@ -26,7 +26,10 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-extern val dl_table;
+typedef enum autoload_ns {
+  al_var, al_fun, al_slot, al_struct, al_key, al_max = al_key
+} al_ns_t;
+
 extern val trace_loaded;
 void lisplib_init(void);
 val lisplib_try_load_fun(val sym);
@@ -35,7 +38,6 @@ val lisplib_try_load_fun_var(val sym);
 val lisplib_try_load_slot(val sym);
 val lisplib_try_load_struct(val sym);
 val lisplib_try_load_keyword(val sym);
-void set_dlt_entries(val dlt, val *name, val fun);
-val dlt_register(val dlt,
-                 val (*instantiate)(val),
-                 val (*set_entries)(val, val));
+void autoload_set(al_ns_t ns, val *name, val fun);
+val autoload_reg(val (*instantiate)(val),
+                 val (*set_entries)(val));