Overhaul of self-load-path mechanism.

The self-load-path symbol macro is as of now
deprecated. It simply expands to *load-path*.
*load-path* is a new special variable which is
dynamically bound to the path of a file
being loaded.

* eval.c (self_load_path_s): Global variable renamed
to load_path_s.
(sys_load): Bind *load-path* around processing of loaded file.
(me_load): Expand (load x) simply to (sys:load x *load-path*).
(set_get_symacro): Function removed.
(reg_symacro): New static function.
(eval_init): Initialize renamed load_path_s with interned
symbol having the name *load-path*. Register the *load-path*
special variable. Set up the sel-load-path symbol macro
aliasing for *load-path*.

* eval.h (self_load_path_s): Declaration renamed.

* match.c (v_load): Bind *load-path* around loading
or inclusion.

* parser.c (load_rcfile): Bind *load-path* around loading
of .txr_profile file.

* txr.c (txr_main): Bind *load-path* instead of
self-load-path symbol macro.

* txr.1: Updated documentation for @(load) directive
and load macro. Replaced documentation of self-load-path
with *load-path*.

6 files changed, 132 insertions, 71 deletions

diff --git a/eval.c b/eval.c
index 08c24f1a..ad17b2c0 100644
--- a/eval.c
+++ b/eval.c
@@ -98,7 +98,7 @@ val macro_time_s, with_saved_vars_s, macrolet_s;
 val defsymacro_s, symacrolet_s, prof_s;
 val fbind_s, lbind_s, flet_s, labels_s;
 val opip_s, oand_s, chain_s, chand_s;
-val sys_load_s, self_load_path_s, sys_lisp1_value_s;
+val sys_load_s, load_path_s, sys_lisp1_value_s;
 
 val special_s, unbound_s;
 val whole_k, form_k, symacro_k;
@@ -3346,7 +3346,7 @@ static val me_mlet(val form, val menv)
 static val sys_load(val target, val sloc)
 {
   uses_or2;
-  val parent = or2(cdr(sloc), null_string);
+  val parent = or2(sloc, null_string);
   val path = if3(abs_path_p(target),
                  target,
                  cat_str(nappend2(sub_list(split_str(parent, lit("/")),
@@ -3354,7 +3354,7 @@ static val sys_load(val target, val sloc)
                                   cons(target, nil)), lit("/")));
   val name, stream;
   val txr_lisp_p = t;
-  val self_load_path_old = nil;
+  val saved_dyn_env = dyn_env;
 
   open_txr_file(path, &txr_lisp_p, &name, &stream);
 
@@ -3366,7 +3366,8 @@ static val sys_load(val target, val sloc)
 
   uw_simple_catch_begin;
 
-  self_load_path_old = set_get_symacro(self_load_path_s, path);
+  dyn_env = make_env(nil, nil, dyn_env);
+  env_vbind(dyn_env, load_path_s, path);
 
   if (!read_eval_stream(stream, std_error, nil)) {
     rlset(sloc, sloc);
@@ -3374,8 +3375,9 @@ static val sys_load(val target, val sloc)
     eval_error(sloc, lit("load: ~a contains errors"), path, nao);
   }
 
+  dyn_env = saved_dyn_env;
+
   uw_unwind {
-    set_get_symacro(self_load_path_s, self_load_path_old);
     close_stream(stream, nil);
   }
 
@@ -3394,7 +3396,7 @@ static val me_load(val form, val menv)
   if (args)
     uw_throwf(error_s, lit("load: too many arguments"), nao);
 
-  return list(sys_load_s, name, list(quote_s, source_loc(form), nao), nao);
+  return list(sys_load_s, name, load_path_s, nao);
 }
 
 val load(val target)
@@ -4506,22 +4508,15 @@ void reg_var(val sym, val val)
   mark_special(sym);
 }
 
-val set_get_symacro(val sym, val form)
+static void reg_symacro(val sym, val form)
 {
   val cell = gethash_c(top_smb, sym, nulloc);
   val binding = cdr(cell);
-  val old = cdr(binding);
 
-  if (form) {
-    if (binding)
-      rplacd(binding, form);
-    else
-      rplacd(cell, cons(sym, form));
-  } else {
-    remhash(top_smb, sym);
-  }
-
-  return old;
+  if (binding)
+    rplacd(binding, form);
+  else
+    rplacd(cell, cons(sym, form));
 }
 
 static val if_fun(val cond, val then, val alt)
@@ -4803,7 +4798,7 @@ void eval_init(void)
   chain_s = intern(lit("chain"), user_package);
   chand_s = intern(lit("chand"), user_package);
   sys_load_s = intern(lit("load"), system_package);
-  self_load_path_s = intern(lit("self-load-path"), user_package);
+  load_path_s = intern(lit("*load-path*"), user_package);
   sys_lisp1_value_s = intern(lit("lisp1-value"), system_package);
 
   qquote_init();
@@ -5132,6 +5127,8 @@ void eval_init(void)
   reg_fun(intern(lit("read"), user_package), func_n5o(lisp_parse, 0));
   reg_fun(intern(lit("iread"), user_package), func_n5o(iread, 0));
   reg_fun(sys_load_s, func_n2(sys_load));
+  reg_var(load_path_s, nil);
+  reg_symacro(intern(lit("self-load-path"), user_package), load_path_s);
   reg_fun(intern(lit("expand"), system_package), func_n2o(expand, 1));
   reg_fun(intern(lit("macro-form-p"), user_package), func_n2o(macro_form_p, 1));
   reg_fun(intern(lit("macroexpand-1"), user_package),
diff --git a/eval.h b/eval.h
index fb9c34f4..d36290fb 100644
--- a/eval.h
+++ b/eval.h
@@ -30,7 +30,7 @@ extern val eval_error_s, if_s, call_s;
 extern val eq_s, eql_s, equal_s;
 extern val car_s, cdr_s;
 extern val last_form_evaled, last_form_expanded;
-extern val self_load_path_s;
+extern val load_path_s;
 
 noreturn val eval_error(val ctx, val fmt, ...);
 val ctx_form(val obj);
diff --git a/match.c b/match.c
index 8470f29c..75407cd9 100644
--- a/match.c
+++ b/match.c
@@ -3886,13 +3886,14 @@ static val v_load(match_files_ctx *c)
     val stream, name;
     val txr_lisp_p = nil;
     val ret = nil;
-    val self_load_path_old = nil;
+    val saved_dyn_env = dyn_env;
 
     open_txr_file(path, &txr_lisp_p, &name, &stream);
 
     uw_simple_catch_begin;
 
-    self_load_path_old = set_get_symacro(self_load_path_s, name);
+    dyn_env = make_env(nil, nil, dyn_env);
+    env_vbind(dyn_env, load_path_s, name);
 
     if (!txr_lisp_p) {
       int gc = gc_state(0);
@@ -3942,8 +3943,9 @@ static val v_load(match_files_ctx *c)
       ret = (sym == include_s) ? nil : next_spec_k;
     }
 
+    dyn_env = saved_dyn_env;
+
     uw_unwind {
-      set_get_symacro(self_load_path_s, self_load_path_old);
       close_stream(stream, nil);
     }
 
diff --git a/parser.c b/parser.c
index 88e24475..1e0b2b6f 100644
--- a/parser.c
+++ b/parser.c
@@ -408,7 +408,6 @@ static void load_rcfile(val name)
   val catch_syms = cons(error_s, nil);
   val path_private_to_me_p =  intern(lit("path-private-to-me-p"), user_package);
   val path_exists_p =  intern(lit("path-exists-p"), user_package);
-  val self_load_path_old = nil;
 
   if (!funcall1(path_exists_p, name))
     return;
@@ -417,15 +416,16 @@ static void load_rcfile(val name)
 
   open_txr_file(name, &lisp_p, &resolved_name, &stream);
 
-  self_load_path_old = set_get_symacro(self_load_path_s, resolved_name);
-
   if (stream) {
     if (!funcall1(path_private_to_me_p, statf(stream))) {
       format(std_output,
              lit("** possible security problem: ~a is writable to others\n"),
              name, nao);
     } else {
+      val saved_dyn_env = set_dyn_env(make_env(nil, nil, dyn_env));
+      env_vbind(dyn_env, load_path_s, resolved_name);
       read_eval_stream(stream, std_output, nil);
+      dyn_env = saved_dyn_env;
     }
   }
 
@@ -438,7 +438,6 @@ static void load_rcfile(val name)
   }
 
   uw_unwind {
-    set_get_symacro(self_load_path_s, self_load_path_old);
     if (stream)
       close_stream(stream, nil);
   }
diff --git a/txr.1 b/txr.1
index 738eca10..91f89c40 100644
--- a/txr.1
+++ b/txr.1
@@ -7633,36 +7633,72 @@ Where
 .meta expr
 is a Lisp expression that
 evaluates to a string giving the path of the file to load.
-Unless the path is absolute, it is interpreted relative to the directory of the
-source file from which the
-.code @(load)
-syntax was read. If there was no such
-source file (for instance, the script was read from standard input),
-then it is resolved relative to the current working directory.
 
-If the file cannot be opened, then the
+If the
+.code *load-path*
+has a current value which is not
+.code nil
+and the path is relative, then the path is interpreted relative
+to the directory portion of the path which is stored in
+.codn *load-path* .
+
+If
+.code *load-path*
+is nil, or the load path is absolute, then it the path is
+taken as-is.
+
+If the file named by the path cannot be opened, then the
 .code .txr
 suffix is added and another
 attempt is made. Thus load expressions need not refer to the suffix.
 In the future, additional suffixes may be searched (compiled versions
 of a file).
 
-The two directives differ as follows. The action of
+Both the
+.code load
+and
+.code include
+directives bind the
+.code *load-path*
+variable to the path of the loaded file just before parsing syntax from it,
+and remove the binding when their processing of the file is complete.
+Processing \*(TL code means that each of its forms is read, and evaluated.
+Processing \*(TX code means parsing the entire file in its entirety,
+and then executing its directives against the current input.
+
+The
+.code load
+and
+.code include
+directives differ as follows.
+The action of
 .code load
 is not performed immediately but at evaluation time. Evaluation time
 occurs after a \*(TX program is read from beginning to end and parsed.
-The action of
+That is to say, when a \*(TX query is parsed, any embedded
+.code "@(load ...)"
+forms in it are parsed and constitute part of its syntax tree.
+They are executed when that query is executed and its execution
+reaches those
+.code load
+directives.
+
+By contrast, the action of
 .code include
-is performed immediately, as the code is being scanned and parsed.
-That is to say, as the \*(TX parser encounters
-.code @(include)
-it processes it immediately. The included material is read and parsed, and its
-syntax tree is substituted in place of the
+is performed immediately, right after the
+.code "@(include ...)"
+directive syntax is parsed.  That is to say, as the \*(TX parser encounters
+this syntax it processes it immediately. The included material is read
+and processed. If it is \*(TX syntax, then it is parsed and incorporated
+into the syntax tree in place of the
 .code include
 directive. The parser then
 continues processing the original file after the
 .code include
-directive.
+directive. If \*(TL code is processed by the
+.code include
+directive, then its forms are read and evaluated. An empty directive
+is substituted into the syntax tree in this case.
 
 Note: the
 .code include
@@ -7675,9 +7711,10 @@ takes place prior to evaluation time, whereas
 doesn't execute until evaluation time.
 
 See also: the
-.code self-path
-and
+.codn self-path ,
 .code stdlib
+and
+.code *load-path*
 variables in \*(TL.
 
 .SS* Output
@@ -44879,12 +44916,25 @@ The
 macro causes a file of \*(TL code to be read and evaluated.
 The
 .meta target
-argument is a string. If
+argument is a string.
+
+If
 .meta target
-specifies a relative pathname, then it is assumed to be a reference relative
-to the directory of the file in which the
+specifies a relative pathname, then a special behavior applies.
+If an existing load operation is in progress, then the special variable
+.code *load-path*
+has a binding. In this case,
 .code load
-macro form occurs.
+will assume that the relative pathname is a reference relative to the
+directory portion of that path name.
+If
+.code *load-path*
+has the value
+.codn nil ,
+then a relative
+.meta target
+pathname is used as-is, and thus resolved relative to the current working
+directory.
 
 If
 .meta target
@@ -44914,43 +44964,54 @@ If a syntax error is encountered, an exception of type
 .code eval-error
 is thrown.
 
+Over the evaluation of the forms, the special variable
+.code *load-path*
+to the path name of that file.
+
 Parser error messages are directed to the
 .code *stderr*
 stream.
 
-.coNP Symbol Macro @ self-load-path
+.coNP Special Variable @ *load-path*
 .desc
 The
-.code self-load-path
-symbol macro expands to a string which holds the name of the file being
-loaded. This is a symbol macro rather than a variable so that it can
-be replaced during the macro-expansion process, thereby permanently embedding
-the file name into the expanded code.
+.code *load-path*
+special variable has a top-level value which is
+.codn nil .
 
-An expansion for
-.code self-load-path
-is established for a \*(TX or \*(TL file which is loaded from the
-command line.
+When a file is being loaded, it is dynamically bound to the
+path name of that file. This value is visible to the forms
+are evaluated in that file during the loading process.
+
+The
+.code *load-path*
+variable is is bound when a \*(TX or \*(TL file is loaded from the command
+line.
 
 If the
 .code -i
 command line option is used to enter the interactive listener,
 and a file to be loaded is also specified, then the
-.code self-load-path
-macro remains bound to the name of that file.
+.code *load-path*
+macro remains bound to the name of that file inside the
+listener.
 
-An expansion for
-.code self-load-path
-is also established by the
+The
 .code load
-function and the
+macro establishes a binding for
+.code *load-path*
+prior to processing and evaluating all the top-level forms
+in the target file. When the forms are evaluated, the binding
+is discarded and
+.code load
+returns.
+
+The
 .code @(load)
-directive, referring to the file being loaded.  When loading completes, the
-previous expansion of
-.code self-load-path
-is restored.
+directive, also similarly establishes a binding around the
+parsing and processing of a loaded \*(TX source file.
 
-During the processing of the profile file (see Interactive Profile File),
+Also, during the processing of the profile file (see Interactive Profile File),
 the variable is bound to the name of that file.
 
 .coNP Variable @ txr-path
diff --git a/txr.c b/txr.c
index 10f1f137..3fff8910 100644
--- a/txr.c
+++ b/txr.c
@@ -907,7 +907,8 @@ int txr_main(int argc, char **argv)
     if (wcscmp(c_str(spec_file), L"-") != 0) {
       open_txr_file(spec_file, &txr_lisp_p, &spec_file_str, &parse_stream);
       simulate_setuid_setgid(parse_stream);
-      set_get_symacro(self_load_path_s, spec_file_str);
+      dyn_env = make_env(nil, nil, dyn_env);
+      env_vbind(dyn_env, load_path_s, spec_file_str);
     } else {
       drop_privilege();
       spec_file_str = lit("stdin");
@@ -933,7 +934,8 @@ int txr_main(int argc, char **argv)
     if (!equal(arg, lit("-"))) {
       open_txr_file(arg, &txr_lisp_p, &spec_file_str, &parse_stream);
       simulate_setuid_setgid(parse_stream);
-      set_get_symacro(self_load_path_s, spec_file_str);
+      dyn_env = make_env(nil, nil, dyn_env);
+      env_vbind(dyn_env, load_path_s, spec_file_str);
     } else {
       drop_privilege();
       spec_file_str = lit("stdin");