Multiple 'whence' and path search fixes

Hopefully this doesn't introduce new bugs, but it does fix at
least the following:

1. When whence -v/-a found an "undefined" (i.e. autoloadable)
   function in $FPATH, it actually loaded the function as a side
   effect of reporting on its existence (!). Now it only reports.

2. 'whence' will now canonicalise paths properly. Examples:
	$ whence ///usr/lib/../bin//./env
	/usr/bin/env
	$ (cd /; whence -v dev/../usr/bin//./env)
	dev/../usr/bin//./env is /usr/bin/env

3. 'whence' no longer prefixes a spurious double slash when doing
   something like 'cd / && whence bin/echo'. On Cygwin, an initial
   double slash denotes a network server, so this was not just a
   cosmetic problem.

4. 'whence -a' now reports a "tracked alias" (a.k.a. hash table
   entry, i.e. cached $PATH search) even if an actual alias by the
   same name exists. This needed fixing because in fact the hash
   table entry continues to be used when bypassing the alias.
   Aliases and "tracked aliases" are not remotely the same thing;
   confusing nomenclature is not a reason to report wrong results.

5. When using 'hash' or 'alias -t' on a command that is also a
   builtin to force caching a $PATH search for the external
   command, 'whence -a' double-reported the path:
	$ hash printf; whence -a printf
	printf is a shell builtin
	printf is /usr/bin/printf
	printf is a tracked alias for /usr/bin/printf
   This is now fixed so that the second output line is gone.
   Plus, if there were multiple versions of the command on $PATH,
   the tracked alias was reported at the end, which is the wrong
   order. This is also fixed.

src/cmd/ksh93/bltins/whence.c: whence():
- Refactor the do...while loop that handles whence -v/-a for path
  searches in such a way that the code actually makes sense and
  stops looking like higher esotericism. Just doing this fixed #2,
  #4 and #5 above (the latter two before I even noticed them). For
  instance, the path_fullname() call to canonicalise paths was
  already there; it was just never used.
- Remove broken 'notrack' flaggery for deciding whether to report a
  hash table entry a.k.a. "tracked alias"; instead, check the hash
  table (shp->track_tree).

src/cmd/ksh93/sh/path.c:
- path_search(): Re #3: When prefixing the PWD, first check if
  we're in '/' and if so, don't prefix it; otherwise, adding the
  next slash causes an initial double slash. (Since '/' is the only
  valid single-character absolute path, all we need to do is check
  if the second character pwd[1] is non-null.)
- path_search(): Re #1: Stop autoloading when called by 'whence':
  * The 'flag==2' check to avoid autoloading a function was
    broken. The flag value is 2 on the first whence() loop
    iteration, but 3 on subsequent ones. Change to 'flag >= 2'.
  * However, this only fixes it if the function file does not have
    the x permission bit, as executable files are handled by
    path_absolute() which unconditionally autoloads functions!
    So, pass on our flag parameter when callling path_absolute().
- path_absolute(): Re #1: Add flag parameter. Do not autoload
  functions if flag >= 2.

src/cmd/ksh93/include/path.h,
src/cmd/ksh93/bltins/typeset.c,
src/cmd/ksh93/sh/main.c,
src/cmd/ksh93/sh/xec.c:
- Re #1: Update path_absolute() calls, adding a 0 flag parameter.

src/cmd/ksh93/include/name.h:
- Remove now-unused pathcomp member from union Value. It was
  introduced in 99065353 to allow examining the value of a tracked
  alias. This commit uses nv_getval() instead.

src/cmd/ksh93/tests/builtins.sh,
src/cmd/ksh93/tests/path.sh:
- Add and tweak various related tests.

Fixes: https://github.com/ksh93/ksh/issues/84

src/cmd/ksh93/sh/main.c

@@ -300,7 +300,7 @@ int sh_main(int ac, char *av[], Shinit_f userinit)
 					if(fdin < 0 && !strchr(name,'/'))
 					{
 #ifdef PATH_BFPATH
-						if(path_absolute(shp,name,NIL(Pathcomp_t*)))
+						if(path_absolute(shp,name,NIL(Pathcomp_t*),0))
 							sp = stakptr(PATH_OFFSET);
 #else
 							sp = path_absolute(shp,name,NIL(char*));

src/cmd/ksh93/sh/path.c

@@ -643,12 +643,26 @@ static void funload(Shell_t *shp,int fno, const char *name)
 
 /*
  * do a path search and track alias if requested
- * if flag is 0, or if name not found, then try autoloading function
- * if flag==2 or 3, returns 1 if name found on FPATH
- * if flag==3 no tracked alias will be set
- * returns 1, if function was autoloaded.
+ *
+ * If flag is 0, or if name not found, then try autoloading function and return 1 if successful.
+ * If flag is >=1, do a regular path search. If it yields an autoloadable function, load it.
+ * If flag is 2 or 3, never autoload a function but return 1 if name found on FPATH.
+ * If flag is 3, no tracked alias will be set (IOW, the result won't be cached in the hash table).
  * If oldpp is not NULL, it will contain a pointer to the path component
  *    where it was found.
+ *
+ * path_search() returns 1/true if:
+ * - the given absolute path was found executable
+ * - the given name is a function or non-path-bound builtin, and a path search found nothing external
+ * - the given name matched an autoloadable function on FPATH
+ *
+ * path_search() returns 0/false if:
+ * - the given relative path was found executable; the PWD is prefixed to make it absolute
+ * - a tracked alias (a.k.a. hash table entry) was found and used
+ * - the given name was found on PATH as an executable command or path-bound builtin (irrespective of
+ *   whether it exists as a function or normal builtin); its full path is written on the stack, except
+ *   if the matching $PATH entry is '.' or empty, the simple name is written without prefixing the PWD
+ * - nothing executable was found
  */
 
 int	path_search(Shell_t *shp,register const char *name,Pathcomp_t **oldpp, int flag)
@@ -658,6 +672,7 @@ int	path_search(Shell_t *shp,register const char *name,Pathcomp_t **oldpp, int f
 	Pathcomp_t *pp=0;
 	if(name && strchr(name,'/'))
 	{
+		char *pwd;
 		stakseek(PATH_OFFSET);
 		stakputs(name);
 		if(canexecute(shp,stakptr(PATH_OFFSET),0)<0)
@@ -668,7 +683,9 @@ int	path_search(Shell_t *shp,register const char *name,Pathcomp_t **oldpp, int f
 		if(*name=='/')
 			return(1);
 		stakseek(PATH_OFFSET);
-		stakputs(path_pwd(shp,1));
+		pwd = path_pwd(shp,1);
+		if(pwd[1])		/* if pwd=="/", avoid starting with "//" */
+			stakputs(pwd);
 		stakputc('/');
 		stakputs(name);
 		stakputc(0);
@@ -697,7 +714,7 @@ int	path_search(Shell_t *shp,register const char *name,Pathcomp_t **oldpp, int f
 			stakputc(0);
 			return(0);
 		}
-		pp = path_absolute(shp,name,oldpp?*oldpp:NIL(Pathcomp_t*));
+		pp = path_absolute(shp,name,oldpp?*oldpp:NIL(Pathcomp_t*),flag);
 		if(oldpp)
 			*oldpp = pp;
 		if(!pp && (np=nv_search(name,shp->fun_tree,0))&&np->nvalue.ip)
@@ -711,7 +728,7 @@ int	path_search(Shell_t *shp,register const char *name,Pathcomp_t **oldpp, int f
 			pp=sh_isstate(SH_DEFPATH)?shp->defpathlist:shp->pathlist;
 		if(pp && strmatch(name,e_alphanum)  && (fno=path_opentype(shp,name,pp,1))>=0)
 		{
-			if(flag==2)
+			if(flag >= 2)
 			{
 				sh_close(fno);
 				return(1);
@@ -732,8 +749,10 @@ int	path_search(Shell_t *shp,register const char *name,Pathcomp_t **oldpp, int f
 
 /*
  * do a path search and find the full pathname of file name
+ *
+ * If flag >= 2, do not autoload functions (cf. path_search()).
  */
-Pathcomp_t *path_absolute(Shell_t *shp,register const char *name, Pathcomp_t *pp)
+Pathcomp_t *path_absolute(Shell_t *shp,register const char *name, Pathcomp_t *pp, int flag)
 {
 	register int	f,isfun;
 	int		noexec=0;
@@ -874,10 +893,12 @@ Pathcomp_t *path_absolute(Shell_t *shp,register const char *name, Pathcomp_t *pp
 		}
 		if(isfun && f>=0)
 		{
-			nv_onattr(nv_open(name,sh_subfuntree(1),NV_NOARRAY|NV_IDENT|NV_NOSCOPE),NV_LTOU|NV_FUNCTION);
-			funload(shp,f,name);
-			close(f);
-			f = -1;
+			if(flag < 2)
+			{
+				nv_onattr(nv_open(name,sh_subfuntree(1),NV_NOARRAY|NV_IDENT|NV_NOSCOPE),NV_LTOU|NV_FUNCTION);
+				funload(shp,f,name);
+				close(f);
+			}
 			return(0);
 		}
 		else if(f>=0 && (oldpp->flags & PATH_STD_DIR))

src/cmd/ksh93/sh/xec.c

@@ -3619,7 +3619,7 @@ static pid_t sh_ntfork(Shell_t *shp,const Shnode_t *t,char *argv[],int *jobid,in
 			&& !nv_isattr(np,NV_NOALIAS)
 			&& np->nvalue.cp)
 				path = nv_getval(np);
-			else if(path_absolute(shp,path,NIL(Pathcomp_t*)))
+			else if(path_absolute(shp,path,NIL(Pathcomp_t*),0))
 			{
 				path = stkptr(shp->stk,PATH_OFFSET);
 				stkfreeze(shp->stk,0);