Changeset 15395

trunk/abcl/src/org/armedbear/lisp/Autoload.java

-                      r14997
+                      r15395
             thread.resetSpecialBindings(mark);
+        }
+        if (debug) {
+            if (symbol != null) {
+                if (symbol.getSymbolFunction() instanceof Autoload) {
+                    Debug.trace("Unable to autoload " + symbol.princToString());
+                    throw new IntegrityError();
+                }
+            }
+        }
+        // if (debug) {
+        if (symbol != null) {
+          if (symbol.getSymbolFunction() instanceof Autoload) {
+            simple_error("Unable to autoload " + symbol.princToString(), symbol, fileName, className);
+          }
+        } // end if (debug)
+    }

trunk/abcl/src/org/armedbear/lisp/FaslClassLoader.java

-                      r15393
+                      r15395
       if (truenameFasl instanceof Pathname) {
           return Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST)
+          return ((Pathname)Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST))
                     .getInputStream();
       } else if (truename instanceof Pathname) {
           return Pathname.mergePathnames(name, (Pathname) truename, Keyword.NEWEST)
+          return ((Pathname)Pathname.mergePathnames(name, (Pathname) truename, Keyword.NEWEST))
                   .getInputStream();
       } else if (!Pathname.truename(name).equals(NIL)) {
               return name.getInputStream();
+      } else if (!Symbol.PROBE_FILE.execute(name).equals(NIL)) {
+        return name.getInputStream();
+      }

trunk/abcl/src/org/armedbear/lisp/Interpreter.java

r15393	r15395
331	331	if (i + 1 < args.length) {
332	332	if (arg.equals("--load"))
333		Load.load(Pathname.mergePathnames((Pathname)Pathname.create(args[i + 1]),
	333	Load.load((Pathname)Pathname.mergePathnames((Pathname)Pathname.create(args[i + 1]),
334	334	checkPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.getSymbolValue())),
335	335	false, false, true);

trunk/abcl/src/org/armedbear/lisp/Lisp.java

-                      r15394
+                      r15395
       LispObject truename = Symbol.LOAD_TRUENAME.symbolValue(thread);
       if (truenameFasl instanceof Pathname) {
           load = Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST);
+          load = (Pathname)Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST);
       } else if (truename instanceof Pathname) {
           load = Pathname.mergePathnames(name, (Pathname) truename, Keyword.NEWEST);
+          load = (Pathname)Pathname.mergePathnames(name, (Pathname) truename, Keyword.NEWEST);
       } else {
           if (!Pathname.truename(name).equals(NIL)) {
               load = name;
           } else {
               load = null;
+          }
+        if (!Symbol.PROBE_FILE.execute(name).equals(NIL)) {
+          load = name;
+        } else {
+          load = null;
+        }
+      }
       InputStream input = null;
 …
       return (Pathname) arg;
     if (arg instanceof AbstractString)
       return (Pathname)Pathname.parseNamestring((AbstractString)arg);
+      return (Pathname)Pathname.create(((AbstractString)arg).toString());
     if (arg instanceof FileStream)
       return ((FileStream)arg).getPathname();
 …
     if (arg instanceof URLStream)
       return ((URLStream)arg).getPathname();
+    type_error(arg, list(Symbol.OR, Symbol.PATHNAME,
+                         Symbol.STRING, Symbol.FILE_STREAM,
+                         Symbol.JAR_STREAM, Symbol.URL_STREAM));
+    type_error(arg, list(Symbol.OR,
+                           Symbol.STRING,
+                           Symbol.PATHNAME, Symbol.JAR_PATHNAME, Symbol.URL_PATHNAME,
+                           Symbol.FILE_STREAM, Symbol.JAR_STREAM, Symbol.URL_STREAM));
     // Not reached.
     return null;

trunk/abcl/src/org/armedbear/lisp/Load.java

-                      r15393
+                      r15395
      * none can be determined. */
     private static final Pathname findLoadableFile(Pathname name) {
+        LispObject truename  = Pathname.truename(name, false);
+        if (truename instanceof Pathname) {
+            Pathname t = (Pathname)truename;
+            if (t.getName() != NIL
+                && t.getName() != null) {
+                return t;
+            }
+        }
+        final String COMPILE_FILE_TYPE = Lisp._COMPILE_FILE_TYPE_.symbolValue().getStringValue();
+        if (name.getType() == NIL
+            && (name.getName() != NIL || name.getName() != null)) {
+            Pathname lispPathname = Pathname.create(name);
+            lispPathname.setType(new SimpleString("lisp"));
+            lispPathname.invalidateNamestring();
+            LispObject lisp = Pathname.truename(lispPathname, false);
+            Pathname abclPathname = Pathname.create(name);
+            abclPathname.setType(new SimpleString(COMPILE_FILE_TYPE));
+            abclPathname.invalidateNamestring();
+            LispObject abcl = Pathname.truename(abclPathname, false);
+            if (lisp instanceof Pathname && abcl instanceof Pathname) {
+              lispPathname = (Pathname)lisp;
+              abclPathname = (Pathname)abcl;
+              long lispLastModified = lispPathname.getLastModified();
+              long abclLastModified = abclPathname.getLastModified();
+              if (abclLastModified > lispLastModified) {
+                  return abclPathname;  // fasl file is newer
+              } else {
+                  return lispPathname;
+              }
+            } else if (abcl instanceof Pathname) {
+                return (Pathname) abcl;
+            } else if (lisp instanceof Pathname) {
+                return (Pathname) lisp;
+            }
+        }
+        if (name.isJar()) {
+            if (name.getType().equals(NIL)) {
+                name.setType(COMPILE_FILE_INIT_FASL_TYPE);
+                name.invalidateNamestring();
+                Pathname result = findLoadableFile(name);
+                if (result != null) {
+                    return result;
+                }
+                name.setType(new SimpleString(COMPILE_FILE_TYPE));
+                name.invalidateNamestring();
+                result = findLoadableFile(name);
+                if (result != null) {
+                    return result;
+                }
+            }
+        }
+        return null;
+      LispObject truename  = Symbol.PROBE_FILE.execute(name);
+      if (truename instanceof Pathname) {
+        Pathname t = (Pathname)truename;
+        if (t.getName() != NIL
+            && t.getName() != null) {
+          return t;
+        }
+      }
+      final String COMPILE_FILE_TYPE = Lisp._COMPILE_FILE_TYPE_.symbolValue().getStringValue();
+      if (name.getType() == NIL
+          && (name.getName() != NIL || name.getName() != null)) {
+        Pathname lispPathname = Pathname.create(name);
+        lispPathname.setType(new SimpleString("lisp"));
+        LispObject lisp = Symbol.PROBE_FILE.execute(lispPathname);
+        Pathname abclPathname = Pathname.create(name);
+        abclPathname.setType(new SimpleString(COMPILE_FILE_TYPE));
+        LispObject abcl = Symbol.PROBE_FILE.execute(abclPathname);
+        if (lisp instanceof Pathname && abcl instanceof Pathname) {
+          lispPathname = (Pathname)lisp;
+          abclPathname = (Pathname)abcl;
+          long lispLastModified = lispPathname.getLastModified();
+          long abclLastModified = abclPathname.getLastModified();
+          if (abclLastModified > lispLastModified) {
+            return abclPathname;  // fasl file is newer
+          } else {
+            return lispPathname;
+          }
+        } else if (abcl instanceof Pathname) {
+          return (Pathname) abcl;
+        } else if (lisp instanceof Pathname) {
+          return (Pathname) lisp;
+        }
+      }
+      if (name.isJar()) {
+        if (name.getType().equals(NIL)) {
+          name.setType(COMPILE_FILE_INIT_FASL_TYPE);
+          Pathname result = findLoadableFile(name);
+          if (result != null) {
+            return result;
+          }
+          name.setType(new SimpleString(COMPILE_FILE_TYPE));
+          name.invalidateNamestring();
+          result = findLoadableFile(name);
+          if (result != null) {
+            return result;
+          }
+        }
+      }
+      return null;
+    }
 …
             Pathname pathnameDefaults
                 = coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue());
             mergedPathname = Pathname.mergePathnames(pathname, pathnameDefaults);
+            mergedPathname = (Pathname)Pathname.mergePathnames(pathname, pathnameDefaults);
+        }
         Pathname loadableFile = findLoadableFile(mergedPathname != null ? mergedPathname : pathname);
+        Pathname truename = coercePathnameOrNull(Pathname.truename(loadableFile));
+        if (truename == null || truename.equals(NIL)) {
+            if (ifDoesNotExist) {
+                return error(new FileError("File not found: " + pathname.princToString(), pathname));
+            } else {
+                Debug.warn("Failed to load " + pathname.getNamestring());
+                return NIL;
+            }
+        }
+        if (Utilities.checkZipFile(truename)) {
+            String n = truename.getNamestring();
+            String name = Pathname.uriEncode(truename.getName().getStringValue());
+            if (n.startsWith("jar:")) {
+                n = "jar:" + n + "!/" + name + "."
+                    + COMPILE_FILE_INIT_FASL_TYPE;
+      } else if (n.startsWith("zip:")) {
+                n = "zip:" + n + "!/" + name + "."
+                    + COMPILE_FILE_INIT_FASL_TYPE;
+            } else {
+                n = "jar:file:" + Pathname.uriEncode(n) + "!/" + name + "."
+                    + COMPILE_FILE_INIT_FASL_TYPE;
+            }
+            if (!((mergedPathname = (Pathname)Pathname.create(n)) instanceof Pathname)) {
+              return error(new FileError((MessageFormat.format("Failed to address JAR-PATHNAME truename {0} for name {1}", truename.princToString(), name)), truename));
+            }
+            LispObject initTruename = coercePathnameOrNull(Pathname.truename(mergedPathname));
+            if (initTruename == null || initTruename.equals(NIL)) {
+        Pathname truename = (Pathname)Symbol.PROBE_FILE.execute(loadableFile);
+        if (truename.equals(NIL)) {
+          if (ifDoesNotExist) {
+            return error(new FileError("File not found: " + pathname.princToString(), pathname));
+          } else {
+            Debug.warn("Failed to load " + pathname.getNamestring());
+            return NIL;
+          }
+        }
+        if (ZipCache.checkZipFile(truename)) {
+            // String n = truename.getNamestring();
+            // String name = Pathname.uriEncode(truename.getName().getStringValue());
+            // if (n.startsWith("jar:")) {
+            //     n = "jar:" + n + "!/" + name + "."
+            //         + COMPILE_FILE_INIT_FASL_TYPE;
+      // } else if (n.startsWith("zip:")) {
+            //     n = "zip:" + n + "!/" + name + "."
+            //         + COMPILE_FILE_INIT_FASL_TYPE;
+            // } else {
+            //     n = "jar:file:" + Pathname.uriEncode(n) + "!/" + name + "."
+            //         + COMPILE_FILE_INIT_FASL_TYPE;
+            // }
+            // if (!((mergedPathname = (Pathname)Pathname.create(n)) instanceof Pathname)) {
+            //   return error(new FileError((MessageFormat.format("Failed to address JAR-PATHNAME truename {0} for name {1}", truename.princToString(), name)), truename));
+            // }
+          truename = (Pathname) PathnameJar.createFromPathname(truename);
+          Pathname loader = (Pathname)Pathname.create("__loader__._"); // FIXME use constants
+          mergedPathname = (Pathname)Symbol.MERGE_PATHNAMES.execute(loader, truename);
+            LispObject initTruename = Symbol.PROBE_FILE.execute(mergedPathname);
+            if (initTruename.equals(NIL)) {
                 // Maybe the enclosing JAR has been renamed?
                 Pathname p = Pathname.create(mergedPathname);
                 p.setName(Keyword.WILD);
+                p.invalidateNamestring();
+                LispObject result = Pathname.MATCH_WILD_JAR_PATHNAME.execute(p);
+                if      (result instanceof Cons
+                LispObject result = Symbol.MATCH_WILD_JAR_PATHNAME.execute(p);
+                if (result instanceof Cons
                     && ((Cons)result).length() == 1
                     && ((Cons)result).car() instanceof Pathname) {
 …
         Pathname mergedPathname;
         if (bootPath instanceof Pathname) {
             mergedPathname = Pathname.mergePathnames(pathname, (Pathname)bootPath);
+          mergedPathname = (Pathname)Symbol.MERGE_PATHNAMES.execute(pathname, bootPath);
         } else {
             mergedPathname = pathname;
+          mergedPathname = pathname;
+        }
         URL url = null;
         Pathname loadableFile = findLoadableFile(mergedPathname);
         truename = coercePathnameOrNull(Pathname.truename(loadableFile));
+        truename = (Pathname)Symbol.PROBE_FILE.execute(loadableFile);
         final String COMPILE_FILE_TYPE
 …
             if (!bootPath.equals(NIL)) {
               Pathname urlPathname = (Pathname)Pathname.create(url);
                 loadableFile = findLoadableFile(urlPathname);
                 truename = (Pathname)Pathname.truename(loadableFile);
                 if (truename == null) {
                     return error(new LispError("Failed to find loadable system file in boot classpath "
                                                + "'" + url + "'"));
+                }
+              loadableFile = findLoadableFile(urlPathname);
+              truename = (Pathname)Symbol.PROBE_FILE.execute(loadableFile);
+              if (truename.equals(NIL)) {
+                return error(new LispError("Failed to find loadable system file in boot classpath "
+                                           + "'" + url + "'"));
+              }
             } else {
                 truename = null; // We can't represent the FASL in a Pathname (q.v. OSGi)
 …
         // Look for a init FASL inside a packed FASL
         if (truename != null
             && truename.getType().princToString().equals(COMPILE_FILE_TYPE) && Utilities.checkZipFile(truename))  {
+            && truename.getType().princToString().equals(COMPILE_FILE_TYPE) && ZipCache.checkZipFile(truename))  {
           Pathname init = (Pathname)Pathname.create(truename.getNamestring());
             init.setType(COMPILE_FILE_INIT_FASL_TYPE);
             init.setName(new SimpleString("__loader__"));
             LispObject t = Pathname.truename(init);
+            LispObject t = Symbol.PROBE_FILE.execute(init);
             if (t instanceof Pathname) {
                 truename = (Pathname)t;

trunk/abcl/src/org/armedbear/lisp/Pathname.java

-                      r15394
+                      r15395
+      }
+    }
     Pathname result = new Pathname();
+    result.init(s);
+    Pathname result = Pathname.init(s);
     return result;
+  }
 …
   public static LispObject create(URL url) {
     return new Pathname(url);
+    return Pathname.create(url.toString());
+  }
   public static LispObject create(URI uri) {
     return new Pathname(uri);
+    return Pathname.create(uri.toString());
+  }
   protected LispObject host = NIL;
 …
     return host;
+  }
   public LispObject setHost(LispObject host) {
+  public Pathname setHost(LispObject host) {
     this.host = host;
     return this;
 …
     return device;
+  }
   public LispObject setDevice(LispObject device) {
+  public Pathname setDevice(LispObject device) {
     this.device = device;
     return this;
 …
     return directory;
+  }
   public LispObject setDirectory(LispObject directory) {
+  public Pathname setDirectory(LispObject directory) {
     this.directory = directory;
     return this;
 …
     return name;
+  }
   public LispObject setName(LispObject name) {
+  public Pathname setName(LispObject name) {
     this.name = name;
     return this;
 …
     return type;
+  }
   public LispObject setType(LispObject type) {
+  public Pathname setType(LispObject type) {
     this.type = type;
     return this;
 …
+  }
   public LispObject setVersion(LispObject version) {
+  public Pathname setVersion(LispObject version) {
     this.version = version;
     return this;
 …
         if (p.host != NIL) {
             if (p.host instanceof SimpleString) {
                 host = new SimpleString(((SimpleString)p.getHost()).getStringValue());
+              setHost(new SimpleString(((SimpleString)p.getHost()).getStringValue()));
             } else  if (p.host instanceof Symbol) {
                 host = p.host;
+              setHost(p.host);
             } else if (p.host instanceof Cons) {
                 host = new Cons((Cons)p.getHost());
             } else {
                 Debug.assertTrue(false);
+              simple_error("Failed to copy host in pathname ~a", p);
+            }
+        }
 …
             if (p.device instanceof SimpleString) {
                 device = new SimpleString(((SimpleString)p.getDevice()).getStringValue());
+            } else if (p.device instanceof Cons) {
+                Cons jars = (Cons)p.device;
+                device = new Cons(NIL, NIL);
+                LispObject first = jars.car();
+                if (first instanceof Pathname) {
+                    ((Cons)device).car = Pathname.create((Pathname)first);
+                } else {
+                    Debug.assertTrue(false);
+                }
+                if (!jars.cdr().equals(NIL)) {
+                    if (jars.cdr() instanceof Cons) {
+                        ((Cons)device).cdr = new Cons(Pathname.create((Pathname)jars.cdr().car()), NIL);
+                    } else {
+                        Debug.assertTrue(false);
+                    }
+                }
+            } else if (p.device instanceof Symbol) {
+            } else if (p.getDevice() instanceof Cons) {
+              LispObject jars = p.getDevice();
+              jars = jars.nreverse();
+              device = NIL;
+              while (jars.car() != NIL) {
+                Pathname jar = (Pathname) Pathname.create(((Pathname)jars.car()).getNamestring());
+                device = device.push(jar);
+                jars = jars.cdr();
+              }
+            } else if (p.device instanceof Symbol) { // When is this the case?
                 device = p.device;
             } else {
                 Debug.assertTrue(false);
+              simple_error("Failed to copy device in pathname ~a", p);
+            }
+        }
 …
                 directory.nreverse();
             } else {
                 Debug.assertTrue(false);
+              simple_error("Failed to copy directory in pathname ~a", p);
+            }
+        }
 …
                 name = p.name;
             } else {
                 Debug.assertTrue(false);
+              simple_error("Failed to copy name in pathname ~a", p);
+            }
+        }
 …
                 type = p.type;
             } else {
                 Debug.assertTrue(false);
+              simple_error("Failed to copy type in pathname ~a", p);
+            }
+        }
 …
         version = p.version;
         } else {
+        Debug.assertTrue(false);
+        }
+    }
+    }
+    private Pathname(String s) {
+        init(s);
+    }
+          simple_error("Failed to copy version in pathname ~a", p);
+        }
+    }
+  }
     public static boolean isSupportedProtocol(String protocol) {
 …
+    }
-    private Pathname(URL url) {
-         // URL handling is now buried in init(String), as the URI
-         // escaping mechanism didn't interact well with '+' and other
-         // characters.
-        init(url.toString());
+    }
-    private Pathname(URI uri) {
-        init(uri.toString());
+    }
     static final Symbol SCHEME = internKeyword("SCHEME");
     static final Symbol AUTHORITY = internKeyword("AUTHORITY");
 …
     static final private String jarSeparator = "!/";
+    private final void init(String s) {
+  private static final Pathname init(String s) {
+      Pathname result = new Pathname();
         if (s == null) {
             return;
+          return (Pathname)simple_error("Refusing to create a PATHNAME for the null reference.");
+        }
         if (s.equals(".") || s.equals("./")
           || (Utilities.isPlatformWindows && s.equals(".\\"))) {
             setDirectory(new Cons(Keyword.RELATIVE));
             return;
+        }
+            result.setDirectory(new Cons(Keyword.RELATIVE));
+            return result;
+        }
         if (s.equals("..") || s.equals("../")) {
+            setDirectory(list(Keyword.RELATIVE, Keyword.UP));
+            return;
+        }
+            result.setDirectory(list(Keyword.RELATIVE, Keyword.UP));
+            return result;
+        }
+        // UNC Windows shares
         if (Utilities.isPlatformWindows) {
           if (s.startsWith("\\\\") || s.startsWith("//")) {
 …
+            }
             if (shareIndex == -1 || dirIndex == -1) {
+              error(new LispError("Unsupported UNC path format: \"" + s + '"'));
+            }
+            setHost(new SimpleString(s.substring(2, shareIndex)));
+            setDevice(new SimpleString(s.substring(shareIndex + 1, dirIndex)));
+              return Pathname_simple_error("Unsupported UNC path format: \"" + s + '"');
+            }
+            result
+              .setHost(new SimpleString(s.substring(2, shareIndex)))
+              .setDevice(new SimpleString(s.substring(shareIndex + 1, dirIndex)));
             Pathname p = (Pathname)Pathname.create(s.substring(dirIndex));
             setDirectory(p.getDirectory());
             setName(p.getName());
             setType(p.getType());
             setVersion(p.getVersion());
             invalidateNamestring();
             return;
+            result
+              .setDirectory(p.getDirectory())
+              .setName(p.getName())
+              .setType(p.getType())
+              .setVersion(p.getVersion());
+            return result;
+          }
+        }
 …
         // A JAR file
         if (s.startsWith("jar:") && s.endsWith(jarSeparator)) {
+            LispObject jars = NIL;
+            int i = s.lastIndexOf(jarSeparator, s.length() - jarSeparator.length() - 1);
+            String jar = null;
+            if (i == -1) {
+                jar = s;
+            } else {
+                // There can be no more than two jar references and the
+                // inner one must be a file reference within the outer.
+                jar = "jar:file:" + s.substring(i + jarSeparator.length());
+                s = s.substring("jar:".length(), i + jarSeparator.length());
+                Pathname p = (Pathname)Pathname.create(s);
+                jars = jars.push(p.getDevice().car());
+            }
+            if (jar.startsWith("jar:file:")) {
+                String file
+                    = jar.substring("jar:file:".length(),
+                                    jar.length() - jarSeparator.length());
+                Pathname jarPathname;
+                if (file.length() > 0) {
+                    URL url = null;
+                    URI uri = null;
+                    try {
+                        url = new URL("file:" + file);
+                        uri = url.toURI();
+                    } catch (MalformedURLException e1) {
+                        error(new SimpleError("Failed to create URI from "
+                                            + "'" + file + "'"
+                                            + ": " + e1.getMessage()));
+                    } catch (URISyntaxException e2) {
+                        error(new SimpleError("Failed to create URI from "
+                                            + "'" + file + "'"
+                                            + ": " + e2.getMessage()));
+                    }
+                    String path = uri.getPath();
+                    if (path == null) {
+                        // We allow "jar:file:baz.jar!/" to construct a relative
+                        // path for jar files, so MERGE-PATHNAMES means something.
+                      jarPathname = (Pathname)Pathname.create(uri.getSchemeSpecificPart());
+                    } else {
+                      jarPathname = (Pathname)Pathname.create((new File(path)).getPath());
+                    }
+                } else {
+                  jarPathname = (Pathname)Pathname.create("");
+                }
+                jars = jars.push(jarPathname);
+            } else {
+                URL url = null;
+                try {
+                    url = new URL(jar.substring("jar:".length(), jar.length() - 2));
+                    Pathname p = (Pathname)Pathname.create(url);
+                    jars = jars.push(p);
+                } catch (MalformedURLException e) {
+                    error(new LispError("Failed to parse URL "
+                                        + "'" + url + "'"
+                                        + e.getMessage()));
+                }
+            }
+            jars = jars.nreverse();
+            setDevice(jars);
+            invalidateNamestring();
+            return;
+          return (PathnameJar)PathnameJar.create(s);
+        }
 …
         final int separatorIndex = s.lastIndexOf(jarSeparator);
         if (separatorIndex > 0 && s.startsWith("jar:")) {
+            final String jarURL = s.substring(0, separatorIndex + jarSeparator.length());
+            URL url = null;
+            try {
+                url = new URL(jarURL);
+            } catch (MalformedURLException ex) {
+                error(new LispError("Failed to parse URL "
+                                    + "'" + jarURL + "'"
+                                    + ex.getMessage()));
+            }
+            Pathname d = (Pathname)Pathname.create(url);
+            if (getDevice() instanceof Cons) {
+                LispObject[] jars = d.copyToArray();
+                //  XXX Is this ever reached?  If so, need to append lists
+                Debug.assertTrue(false);
+            } else {
+                setDevice(d.getDevice());
+            }
+            s = "/" + s.substring(separatorIndex + jarSeparator.length());
+            Pathname p = (Pathname)Pathname.create("file:" + s); // Use URI escaping rules
+            setDirectory(p.getDirectory());
+            setName(p.getName());
+            setType(p.getType());
+            setVersion(p.getVersion());
+            return;
+        }
+        // A URL
+          return (PathnameJar)PathnameJar.create(s);
+        }
+        // A URL (anything with a scheme that is not a logical
+        // pathname, and not a JAR file or an entry in a JAR file)
         if (isValidURL(s)) {
+            URL url = null;
+            try {
+                url = new URL(s);
+            } catch (MalformedURLException e) {
+                Debug.assertTrue(false);
+            }
+            String scheme = url.getProtocol();
+            if (scheme.equals("file")) {
+                URI uri = null;
+                try {
+                    uri = new URI(s);
+                } catch (URISyntaxException ex) {
+                    error(new SimpleError("Improper URI syntax for "
+                                    + "'" + url.toString() + "'"
+                                    + ": " + ex.toString()));
+                }
+                String uriPath = uri.getPath();
+                if (null == uriPath) {
+                                  // Under Windows, deal with pathnames containing
+                                  // devices expressed as "file:z:/foo/path"
+                                  uriPath = uri.getSchemeSpecificPart();
+                                  if (uriPath == null || uriPath.equals("")) {
+                    error(new LispError("The URI has no path: " + uri));
+                  }
+                }
+                final File file = new File(uriPath);
+                String path = file.getPath();
+                if (uri.toString().endsWith("/") && !path.endsWith("/")) {
+                  path += "/";
+                }
+                final Pathname p = (Pathname)Pathname.create(path);
+                this.setHost(p.getHost());
+                this.setDevice(p.getDevice());
+                this.setDirectory(p.getDirectory());
+                this.setName(p.getName());
+                this.setType(p.getType());
+                this.setVersion(p.getVersion());
+                return;
+            }
+            Debug.assertTrue(scheme != null);
+            URI uri = null;
+            try {
+                uri = url.toURI().normalize();
+            } catch (URISyntaxException e) {
+                error(new LispError("Couldn't form URI from "
+                                    + "'" + url + "'"
+                                    + " because: " + e));
+            }
+            String authority = uri.getAuthority();
+        if (authority == null) {
+          authority = url.getAuthority();
+          if (authority == null) {
+            Debug.trace(MessageFormat.format("{0} has a null authority.", url));
+          }
+        }
+        setHost(NIL);
+        setHost(getHost().push(SCHEME));
+        setHost(getHost().push(new SimpleString(scheme)));
+        if (authority != null) {
+          setHost(getHost().push(AUTHORITY));
+          setHost(getHost().push(new SimpleString(authority)));
+        }
+        setDevice(NIL);
+        // URI encode necessary characters
+        String path = uri.getRawPath();
+        if (path == null) {
+          path = "";
+        }
+        String query = uri.getRawQuery();
+        if (query != null) {
+          setHost(getHost().push(QUERY));
+                setHost(getHost().push(new SimpleString(query)));
+            }
+            String fragment = uri.getRawFragment();
+            if (fragment != null) {
+                setHost(getHost().push(FRAGMENT));
+                setHost(getHost().push(new SimpleString(fragment)));
+            }
+            Pathname p = (Pathname)Pathname.create(path != null ? path : "");
+            setDirectory(p.getDirectory());
+            setName(p.getName());
+            setType(p.getType());
+            setHost(getHost().nreverse());
+            invalidateNamestring();
+            return;
+          return (PathnameURL)PathnameURL.create(s);
+        }
 …
+            }
+        }
         namestring = s;
+        //        namestring = s;
         if (Utilities.isPlatformWindows) {
             if (s.length() >= 2 && s.charAt(1) == ':') {
                 setDevice(new SimpleString(s.charAt(0)));
+                result.setDevice(new SimpleString(s.charAt(0)));
                 s = s.substring(2);
+            }
 …
                 s = "";
+            }
             setDirectory(parseDirectory(d));
+            result.setDirectory(parseDirectory(d));
+        }
         if (s.startsWith(".")
 …
             && (s.indexOf(".", 1) == -1
                 || s.substring(s.length() -1).equals("."))) {
             setName(new SimpleString(s));
             return;
+            result.setName(new SimpleString(s));
+            return result;
+        }
         int index = s.lastIndexOf('.');
 …
         if (n != null) {
             if (n.equals("*")) {
                 setName(Keyword.WILD);
+                result.setName(Keyword.WILD);
             } else {
                 setName(new SimpleString(n));
+                result.setName(new SimpleString(n));
+            }
+        }
         if (t != null) {
             if (t.equals("*")) {
                 setType(Keyword.WILD);
+                result.setType(Keyword.WILD);
             } else {
+                setType(new SimpleString(t));
+            }
+        }
+    }
+                result.setType(new SimpleString(t));
+            }
+        }
+        return result;
+  }
     private static final LispObject parseDirectory(String d) {
 …
         if (getDevice() == NIL) {
         } else if (getDevice() == Keyword.UNSPECIFIC) {
         } else if (isJar()) {
             LispObject[] jars = ((Cons) getDevice()).copyToArray();
             StringBuilder prefix = new StringBuilder();
             for (int i = 0; i < jars.length; i++) {
                 prefix.append("jar:");
                 LispObject component = jars[i];
                 if (!(component instanceof Pathname)) {
                   return null; // If DEVICE is a CONS, it should only contain Pathname
+                }
                 if (! ((Pathname)component).isURL() && i == 0) {
                   sb.append("file:");
                   uriEncoded = true;
+                }
                 Pathname jar = (Pathname) component;
                 String encodedNamestring;
                 if (uriEncoded) {
                   encodedNamestring = uriEncode(jar.getNamestring());
                 } else {
                   encodedNamestring = jar.getNamestring();
+                }
                 sb.append(encodedNamestring);
                 sb.append("!/");
+            }
             sb = prefix.append(sb);
+        // } else if (isJar()) {
+        //     LispObject[] jars = ((Cons) getDevice()).copyToArray();
+        //     StringBuilder prefix = new StringBuilder();
+        //     for (int i = 0; i < jars.length; i++) {
+        //         prefix.append("jar:");
+        //         LispObject component = jars[i];
+        //         if (!(component instanceof Pathname)) {
+        //           return null; // If DEVICE is a CONS, it should only contain Pathname
+        //         }
+        //         if (! ((Pathname)component).isURL() && i == 0) {
+        //           sb.append("file:");
+        //           uriEncoded = true;
+        //         }
+        //         Pathname jar = (Pathname) component;
+        //         String encodedNamestring;
+        //         if (uriEncoded) {
+        //           encodedNamestring = uriEncode(jar.getNamestring());
+        //         } else {
+        //           encodedNamestring = jar.getNamestring();
+        //         }
+        //         sb.append(encodedNamestring);
+        //         sb.append("!/");
+        //     }
+        //     sb = prefix.append(sb);
         } else if (getDevice() instanceof AbstractString) {
             sb.append(getDevice().getStringValue());
 …
             directoryNamestring = uriEncode(directoryNamestring);
+        }
         if (isJar()) {
             if (directoryNamestring.startsWith("/")) {
                 sb.append(directoryNamestring.substring(1));
             } else {
                 sb.append(directoryNamestring);
+            }
         } else {
+        // if (isJar()) {
+        //     if (directoryNamestring.startsWith("/")) {
+        //         sb.append(directoryNamestring.substring(1));
+        //     } else {
+        //         sb.append(directoryNamestring);
+        //     }
+        // } else {
             sb.append(directoryNamestring);
+        }
+            //        }
         if (getName() instanceof AbstractString) {
             String n = getName().getStringValue();
 …
+        }
         if (isURL()) {
             LispObject o = Symbol.GETF.execute(getHost(), QUERY, NIL);
             if (o != NIL) {
                 sb.append("?");
                 sb.append(o.getStringValue());
+            }
             o = Symbol.GETF.execute(getHost(), FRAGMENT, NIL);
             if (o != NIL) {
                 sb.append("#");
                 sb.append(o.getStringValue());
+            }
+        }
+        // if (isURL()) {
+        //     LispObject o = Symbol.GETF.execute(getHost(), QUERY, NIL);
+        //     if (o != NIL) {
+        //         sb.append("?");
+        //         sb.append(o.getStringValue());
+        //     }
+        //     o = Symbol.GETF.execute(getHost(), FRAGMENT, NIL);
+        //     if (o != NIL) {
+        //         sb.append("#");
+        //         sb.append(o.getStringValue());
+        //     }
+        // }
         if (this instanceof LogicalPathname) {
 …
+    }
-    /** @return The representation of this pathname suitable for
-     *  referencing an entry in a Zip/JAR file
-     */
-    protected String asEntryPath() {
-        Pathname p = Pathname.create();
-        p.setDirectory(getDirectory());
-        p.setName(getName());
-        p.setType(getType());
-        p.invalidateNamestring();
-        String path = p.getNamestring();
-        StringBuilder result = new StringBuilder();
-        result.append(path);
-        // Entries in jar files are always relative, but Pathname
-        // directories are :ABSOLUTE.
-        if (result.length() > 1
-          && result.substring(0, 1).equals("/")) {
-            return result.substring(1);
+        }
-        return result.toString();
+    }
     @Override
 …
     public boolean equalp(LispObject obj) {
         return equal(obj);
+    }
+    public boolean equals(Object o) {
+      if (!(this.getClass().isAssignableFrom(o.getClass()))) {
+        return super.equals(o);
+      }
+      return equal((Pathname)o);
+    }
+    public int hashCode() {
+      return sxhash();
+    }
 …
         @Override
         public LispObject execute(LispObject arg, LispObject resolveSymlinks) {
+            Pathname pathname = coerceToPathname(arg);
+            if (pathname instanceof LogicalPathname) {
+                pathname = LogicalPathname.translateLogicalPathname((LogicalPathname) pathname);
+            }
+            LispObject result = NIL;
+            if (pathname.isJar()) {
+                String directory = pathname.asEntryPath();
+                Debug.assertTrue(directory != null);  // We should only be listing directories
+                if (pathname.getDevice().cdr() instanceof Cons) {
+                    return error(new FileError("Unimplemented directory listing of JAR within JAR.", pathname));
+                }
+                if (directory.length() == 0) {
+                    directory = "/*";
+                } else {
+                    if (directory.endsWith("/")) {
+                        directory = "/" + directory + "*";
+                    } else {
+                        directory = "/" + directory + "/*";
+                    }
+                }
+                SimpleString wildcard = new SimpleString(directory);
+                SimpleString wildcardDirectory = new SimpleString(directory + "/");
+                ZipFile jar = ZipCache.get((Pathname)pathname.getDevice().car());
+                LispObject matches;
+                for (Enumeration<? extends ZipEntry> entries = jar.entries();
+                     entries.hasMoreElements();) {
+                    ZipEntry entry = entries.nextElement();
+                    String entryName = "/" + entry.getName();
+                    if (entryName.endsWith("/")) {
+                        matches = Symbol.PATHNAME_MATCH_P
+                            .execute(new SimpleString(entryName), wildcardDirectory);
+                    } else {
+                        matches = Symbol.PATHNAME_MATCH_P.
+                            execute(new SimpleString(entryName), wildcard);
+                    }
+                    if (!matches.equals(NIL)) {
+                        String namestring = new String(pathname.getNamestring());
+                        namestring = namestring.substring(0, namestring.lastIndexOf("!/") + 2)
+                                 + entry.getName();
+                        Pathname p = (Pathname)Pathname.create(namestring);
+                        result = new Cons(p, result);
+                    }
+                }
+                return result;
+            }
+            if (pathname.isURL()) {
+                return error(new LispError("Unimplemented.")); // XXX
+            }
+            String s = pathname.getNamestring();
+            if (s != null) {
+                File f = new File(s);
+                if (f.isDirectory()) {
+                    try {
+                        File[] files = f.listFiles();
+                        if (files == null) {
+                            return error(new FileError("Unable to list directory "
+                                                       + pathname.princToString() + ".",
+                                                       pathname));
+                        }
+                        for (int i = files.length; i-- > 0;) {
+                            File file = files[i];
+                            Pathname p;
+                            String path;
+                            if (resolveSymlinks == NIL) {
+                              path = file.getAbsolutePath();
+                            } else {
+                              path = file.getCanonicalPath();
+                            }
+                            URI pathURI = (new File(path)).toURI();
+                            p = (Pathname)Pathname.create(pathURI);
+                            result = new Cons(p, result);
+                        }
+                    } catch (IOException e) {
+                        return error(new FileError("Unable to list directory "
+                                                   + pathname.princToString() + ".",
+                                                   pathname));
+                    } catch (SecurityException e) {
+                        Debug.trace(e);
+                    } catch (NullPointerException e) {
+                        Debug.trace(e);
+                    }
+                }
+            }
+            return result;
+        }
+    }
+    @DocString(name="match-wild-jar-pathname",
+               args="wild-jar-pathname",
+               returns="pathnames",
+    doc="Returns the pathnames matching WILD-JAR-PATHNAME which is both wild and a jar-pathname.")
+    static final Primitive MATCH_WILD_JAR_PATHNAME = new pf_match_wild_jar_pathname();
+    private static class pf_match_wild_jar_pathname extends Primitive {
+        pf_match_wild_jar_pathname() {
+            super("match-wild-jar-pathname", PACKAGE_SYS, false, "wild-jar-pathname");
+        }
+        @Override
+        public LispObject execute(LispObject arg) {
+            Pathname pathname = coerceToPathname(arg);
+            if (pathname instanceof LogicalPathname) {
+                pathname = LogicalPathname.translateLogicalPathname((LogicalPathname) pathname);
+            }
+            if (!pathname.isJar()) {
+                return new FileError("Not a jar pathname.", pathname);
+            }
+            if (!pathname.isWild()) {
+                return new FileError("Not a wild pathname.", pathname);
+            }
+            Pathname jarPathname = Pathname.create(pathname);
+            jarPathname.setDirectory(NIL);
+            jarPathname.setName(NIL);
+            jarPathname.setType(NIL);
+            jarPathname.invalidateNamestring();
+            LispObject jarTruename = truename(jarPathname, false);
+            // We can't match anything in a non-existent jar
+            if (jarTruename == NIL) {
+                return NIL;
+            }
+            LispObject result = NIL;
+            String wild = "/" + pathname.asEntryPath();
+            final SimpleString wildcard = new SimpleString(wild);
+            if (pathname.getDevice().cdr() instanceof Cons) {
+                ZipFile outerJar = ZipCache.get((Pathname)pathname.getDevice().car());
+                String entryPath = ((Pathname)pathname.getDevice().cdr().car()).getNamestring(); //???
+                if (entryPath.startsWith("/")) {
+                    entryPath = entryPath.substring(1);
+                }
+                ZipEntry entry = outerJar.getEntry(entryPath);
+                InputStream inputStream = null;
+                try {
+                    inputStream = outerJar.getInputStream(entry);
+                } catch (IOException e) {
+                    return new FileError("Failed to read zip input stream inside zip.",
+                                         pathname);
+                }
+                ZipInputStream zipInputStream
+                    = new ZipInputStream(inputStream);
+                try {
+                    while ((entry = zipInputStream.getNextEntry()) != null) {
+                        String entryName = "/" + entry.getName();
+                        LispObject matches = Symbol.PATHNAME_MATCH_P
+                            .execute(new SimpleString(entryName), wildcard);
+                        if (!matches.equals(NIL)) {
+                            String namestring = new String(pathname.getNamestring());
+                            namestring = namestring.substring(0, namestring.lastIndexOf("!/") + 2)
+                                + entry.getName();
+                            Pathname p = (Pathname)Pathname.create(namestring);
+                            result = new Cons(p, result);
+                        }
+                    }
+                } catch (IOException e) {
+                    return new FileError("Failed to seek through zip inputstream inside zip.",
+                                         pathname);
+                }
+            } else {
+                ZipFile jar = ZipCache.get((Pathname)pathname.getDevice().car());
+                for (Enumeration<? extends ZipEntry> entries = jar.entries();
+                     entries.hasMoreElements();)
+                    {
+                        ZipEntry entry = entries.nextElement();
+                        String entryName = "/" + entry.getName();
+                        LispObject matches = Symbol.PATHNAME_MATCH_P
+                            .execute(new SimpleString(entryName), wildcard);
+                        if (!matches.equals(NIL)) {
+                            String namestring = new String(pathname.getNamestring());
+                            namestring = namestring.substring(0, namestring.lastIndexOf("!/") + 2)
+                                + entry.getName();
+                            Pathname p = (Pathname)Pathname.create(namestring);
+                            result = new Cons(p, result);
+                        }
+                    }
+            }
+            return result;
+        }
+    }
+          Pathname pathname = coerceToPathname(arg);
+          if (pathname instanceof LogicalPathname) {
+            pathname = LogicalPathname.translateLogicalPathname((LogicalPathname) pathname);
+          }
+          LispObject result = NIL;
+          if (pathname.isJar()) {
+            return PathnameJar.listDirectory((PathnameJar)pathname);
+          }
+          // "All" pathnames are PathnameURLs now, so this condition needs to be tightened
+          // should be all remote URLs can't have directory listings?
+          // if (pathname.isURL()) {
+          //   return error(new LispError("Unimplemented.")); // XXX
+          // }
+          String s = pathname.getNamestring();
+          if (s != null) {
+            File f = new File(s);
+            if (f.isDirectory()) {
+              try {
+                File[] files = f.listFiles();
+                if (files == null) {
+                  return error(new FileError("Unable to list directory "
+                                             + pathname.princToString() + ".",
+                                             pathname));
+                }
+                for (int i = files.length; i-- > 0;) {
+                  File file = files[i];
+                  Pathname p;
+                  String path;
+                  if (resolveSymlinks == NIL) {
+                    path = file.getAbsolutePath();
+                  } else {
+                    path = file.getCanonicalPath();
+                  }
+                  URI pathURI = (new File(path)).toURI();
+                  p = (Pathname)Pathname.create(pathURI);
+                  result = new Cons(p, result);
+                }
+              } catch (IOException e) {
+                return error(new FileError("Unable to list directory "
+                                           + pathname.princToString() + ".",
+                                           pathname));
+              } catch (SecurityException e) {
+                Debug.trace(e);
+              } catch (NullPointerException e) {
+                Debug.trace(e);
+              }
+            }
+          }
+          return result;
+        }
+    };
     public boolean isAbsolute()  {
 …
+        }
+    }
     static final Primitive MERGE_PATHNAMES = new pf_merge_pathnames();
     @DocString(name="merge-pathnames",
 …
     static final class pf_merge_pathnames extends Primitive {
         pf_merge_pathnames() {
             super("merge-pathnames", "pathname &optional default-pathname default-version");
+            super(Symbol.MERGE_PATHNAMES, "pathname &optional default-pathname default-version");
+        }
         @Override
         public LispObject execute(LispObject arg) {
             Pathname pathname = coerceToPathname(arg);
             Pathname defaultPathname =
                 coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue());
             LispObject defaultVersion = Keyword.NEWEST;
             return mergePathnames(pathname, defaultPathname, defaultVersion);
+          Pathname pathname = coerceToPathname(arg);
+          Pathname defaultPathname
+            = coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue());
+          LispObject defaultVersion = Keyword.NEWEST;
+          return mergePathnames(pathname, defaultPathname, defaultVersion);
+        }
         @Override
         public LispObject execute(LispObject first, LispObject second) {
             Pathname pathname = coerceToPathname(first);
+            Pathname defaultPathname =
+                coerceToPathname(second);
+            Pathname defaultPathname = coerceToPathname(second);
             LispObject defaultVersion = Keyword.NEWEST;
             return mergePathnames(pathname, defaultPathname, defaultVersion);
 …
                                   LispObject third) {
             Pathname pathname = coerceToPathname(first);
+            Pathname defaultPathname =
+                coerceToPathname(second);
+            Pathname defaultPathname = coerceToPathname(second);
             LispObject defaultVersion = third;
             return mergePathnames(pathname, defaultPathname, defaultVersion);
 …
+    }
     public static final Pathname mergePathnames(Pathname pathname, Pathname defaultPathname) {
         return mergePathnames(pathname, defaultPathname, Keyword.NEWEST);
+    }
+  public static final LispObject mergePathnames(Pathname pathname, Pathname defaultPathname) {
+    return mergePathnames(pathname, defaultPathname, Keyword.NEWEST);
+  }
+    public static final Pathname mergePathnames(final Pathname pathname,
+                                                final Pathname defaultPathname,
+                                                final LispObject defaultVersion)
+    {
+        Pathname result;
+        Pathname p = Pathname.create(pathname);
+        Pathname d;
+        if (pathname instanceof LogicalPathname) {
+            result = LogicalPathname.create();
+  public static final LispObject mergePathnames(final Pathname pathname,
+                                              final Pathname defaultPathname,
+                                              final LispObject defaultVersion) {
+    Pathname result;
+    Pathname p = Pathname.create(pathname);
+    Pathname d;
+      if (pathname instanceof LogicalPathname) {
+        result = LogicalPathname.create();
+        d = Pathname.create(defaultPathname);
+      } else {
+        if ((pathname instanceof PathnameJar)
+            || (defaultPathname instanceof PathnameJar)) {
+          result = PathnameJar.create();
+        } else {
+          result = Pathname.create();
+        }
+        if (defaultPathname instanceof LogicalPathname) {
+          d = LogicalPathname.translateLogicalPathname((LogicalPathname) defaultPathname);
+        } else {
+          if (defaultPathname instanceof PathnameJar) {
+            d = PathnameJar.create(defaultPathname);
+          } else {
             d = Pathname.create(defaultPathname);
+          }
+        }
+      }
+      if (pathname.getHost() != NIL) {
+        result.setHost(p.getHost());
+      } else {
+        result.setHost(d.getHost());
+      }
+      if (pathname.getDevice() != NIL) {
+        result.setDevice(p.getDevice());
+      } else {
+        if (d instanceof PathnameJar) {
+          // If the defaults contain a JAR-PATHNAME, and the pathname
+          // to be be merged does not have a specified DEVICE, a
+          // specified HOST, and doesn't contain a relative DIRECTORY,
+          // then on non-MSDOG, set its device to :UNSPECIFIC.
+          if (pathname.getHost() == NIL
+              && pathname.getDevice() == NIL
+              && d.isJar()
+              && !Utilities.isPlatformWindows) {
+            if (pathname.getDirectory() != NIL
+                && pathname.getDirectory().car() == Keyword.ABSOLUTE) {
+              result.setDevice(Keyword.UNSPECIFIC);
+            } else {
+              result.setDevice(d.getDevice());
+            }
+          } else {
+            result.setDevice(d.getDevice());
+          }
+        }
+      }
+      // This part I no longer understand
+      // if (pathname.isJar()) {
+      //   Cons jars = (Cons)result.getDevice();
+      //   LispObject jar = jars.car;
+      //   if (jar instanceof Pathname) {
+      //     Pathname defaults = Pathname.create(d);
+      //     if (defaults.isJar()) {
+      //       defaults.setDevice(NIL);
+      //     }
+      //     Pathname o = mergePathnames((Pathname)jar, defaults);
+      //     if (o.getDirectory() instanceof Cons
+      //         && ((Cons)o.getDirectory()).length() == 1) { // i.e. (:ABSOLUTE) or (:RELATIVE)
+      //       o.setDirectory(NIL);
+      //     }
+      //     ((Cons)result.device).car = o;
+      //   }
+      //   result.setDirectory(p.getDirectory());
+      // } else {
+      //   result.setDirectory(mergeDirectories(p.getDirectory(), d.getDirectory()));
+      // }
+      result.setDirectory(mergeDirectories(p.getDirectory(), d.getDirectory()));
+      if (pathname.getName() != NIL) {
+        result.setName(p.getName());
+      } else {
+        result.setName(d.getName());
+      }
+      if (pathname.getType() != NIL) {
+        result.setType(p.getType());
+      } else {
+        result.setType(d.getType());
+      }
+      //  CLtLv2 MERGE-PATHNAMES
+      // "[T]he missing components in the given pathname are filled
+      // in from the defaults pathname, except that if no version is
+      // specified the default version is used."
+      // "The merging rules for the version are more complicated and
+      // depend on whether the pathname specifies a name. If the
+      // pathname doesn't specify a name, then the version, if not
+      // provided, will come from the defaults, just like the other
+      // components. However, if the pathname does specify a name,
+      // then the version is not affected by the defaults. The
+      // reason is that the version ``belongs to'' some other file
+      // name and is unlikely to have anything to do with the new
+      // one. Finally, if this process leaves the
+      // version missing, the default version is used."
+      if (p.getVersion() != NIL) {
+        result.setVersion(p.getVersion());
+      } else if (p.getName() == NIL) {
+        if (defaultPathname.getVersion() == NIL) {
+          result.setVersion(defaultVersion);
         } else {
+            result = Pathname.create();
+            if (defaultPathname instanceof LogicalPathname) {
+                d = LogicalPathname.translateLogicalPathname((LogicalPathname) defaultPathname);
+            } else {
+                d = Pathname.create(defaultPathname);
+            }
+        }
+        if (pathname.getHost() != NIL) {
+          result.setHost(p.getHost());
+        } else {
+          result.setHost(d.getHost());
+        }
+        if (pathname.getDevice() != NIL) { // XXX if device represent JARs we want to merge
+          result.setDevice(p.getDevice());
+        } else {
+            if (!p.isURL()) {
+                // If the defaults contain a JAR-PATHNAME, and the
+                // pathname to be be merged does not have a specified
+                // DEVICE, a specified HOST, and doesn't contain a
+                // relative DIRECTORY, then on non-MSDOG, set its
+                // device to :UNSPECIFIC.
+                if (pathname.getHost() == NIL
+                    && pathname.getDevice() == NIL
+                    && d.isJar()
+                    && !Utilities.isPlatformWindows) {
+                    if (pathname.getDirectory() != NIL
+                        && pathname.getDirectory().car() == Keyword.ABSOLUTE) {
+                      result.setDevice(Keyword.UNSPECIFIC);
+                    } else {
+                      result.setDevice(d.getDevice());
+                    }
+                } else {
+                  result.setDevice(d.getDevice());
+                }
+            }
+        }
+        if (pathname.isJar()) {
+            Cons jars = (Cons)result.getDevice();
+            LispObject jar = jars.car;
+            if (jar instanceof Pathname) {
+                Pathname defaults = Pathname.create(d);
+                if (defaults.isJar()) {
+                  defaults.setDevice(NIL);
+                }
+                Pathname o = mergePathnames((Pathname)jar, defaults);
+                if (o.getDirectory() instanceof Cons
+                    && ((Cons)o.getDirectory()).length() == 1) { // i.e. (:ABSOLUTE) or (:RELATIVE)
+                  o.setDirectory(NIL);
+                }
+                ((Cons)result.device).car = o;
+            }
+            result.setDirectory(p.getDirectory());
+        } else {
+          result.setDirectory(mergeDirectories(p.getDirectory(), d.getDirectory()));
+        }
+        if (pathname.getName() != NIL) {
+          result.setName(p.getName());
+        } else {
+          result.setName(d.getName());
+        }
+        if (pathname.getType() != NIL) {
+          result.setType(p.getType());
+        } else {
+          result.setType(d.getType());
+        }
+        //  CLtLv2 MERGE-PATHNAMES
+    // "[T]he missing components in the given pathname are filled
+    // in from the defaults pathname, except that if no version is
+    // specified the default version is used."
+    // "The merging rules for the version are more complicated and
+    // depend on whether the pathname specifies a name. If the
+    // pathname doesn't specify a name, then the version, if not
+    // provided, will come from the defaults, just like the other
+    // components. However, if the pathname does specify a name,
+    // then the version is not affected by the defaults. The
+    // reason is that the version ``belongs to'' some other file
+    // name and is unlikely to have anything to do with the new
+    // one. Finally, if this process leaves the
+    // version missing, the default version is used."
+        if (p.getVersion() != NIL) {
+          result.setVersion(p.getVersion());
+        } else if (p.getName() == NIL) {
+            if (defaultPathname.getVersion() == NIL) {
+              result.setVersion(defaultVersion);
+            } else {
+              result.setVersion(defaultPathname.getVersion());
+            }
+        } else if (defaultVersion == NIL) {
+          result.setVersion(p.getVersion());
+        }
+        if (result.getVersion() == NIL) {
+          result.setVersion(defaultVersion);
+        }
+        if (pathname instanceof LogicalPathname) {
+            // When we're returning a logical
+            result.setDevice(Keyword.UNSPECIFIC);
+            if (result.getDirectory().listp()) {
+                LispObject original = result.getDirectory();
+                LispObject canonical = NIL;
+                while (original != NIL) {
+                    LispObject component = original.car();
+                    if (component instanceof AbstractString) {
+                        component = LogicalPathname.canonicalizeStringComponent((AbstractString) component);
+                    }
+                    canonical = canonical.push(component);
+                    original = original.cdr();
+                }
+                result.setDirectory(canonical.nreverse());
+            }
+            if (result.getName() instanceof AbstractString) {
+              result.setName(LogicalPathname.canonicalizeStringComponent((AbstractString) result.getName()));
+            }
+            if (result.getType() instanceof AbstractString) {
+              result.setType(LogicalPathname.canonicalizeStringComponent((AbstractString) result.getType()));
+            }
+        }
+        result.invalidateNamestring();
+        return result;
+          result.setVersion(defaultPathname.getVersion());
+        }
+      } else if (defaultVersion == NIL) {
+        result.setVersion(p.getVersion());
+      }
+      if (result.getVersion() == NIL) {
+        result.setVersion(defaultVersion);
+      }
+      if (pathname instanceof LogicalPathname) {
+        // When we're returning a logical
+        result.setDevice(Keyword.UNSPECIFIC);
+        if (result.getDirectory().listp()) {
+          LispObject original = result.getDirectory();
+          LispObject canonical = NIL;
+          while (original != NIL) {
+            LispObject component = original.car();
+            if (component instanceof AbstractString) {
+              component = LogicalPathname.canonicalizeStringComponent((AbstractString) component);
+            }
+            canonical = canonical.push(component);
+            original = original.cdr();
+          }
+          result.setDirectory(canonical.nreverse());
+        }
+        if (result.getName() instanceof AbstractString) {
+          result.setName(LogicalPathname.canonicalizeStringComponent((AbstractString) result.getName()));
+        }
+        if (result.getType() instanceof AbstractString) {
+          result.setType(LogicalPathname.canonicalizeStringComponent((AbstractString) result.getType()));
+        }
+      }
+      return result;
+    }
 …
+    }
     public static final LispObject truename(Pathname pathname) {
         return truename(pathname, false);
 …
      */
     public static final LispObject truename(Pathname pathname,
+                                            boolean errorIfDoesNotExist)
+    {
+        if (pathname == null || pathname.equals(NIL)) {
+           return doTruenameExit(pathname, errorIfDoesNotExist);
+        }
+        if (pathname instanceof LogicalPathname) {
+            pathname = LogicalPathname.translateLogicalPathname((LogicalPathname) pathname);
+        }
+        if (pathname.isWild()) {
+            return error(new FileError("Bad place for a wild pathname.",
+                                       pathname));
+        }
+        if (pathname instanceof PathnameJar) {
+          return truename((PathnameJar)pathname, errorIfDoesNotExist);
+        }
+        if (pathname instanceof PathnameURL) {
+          return truename((PathnameURL)pathname, errorIfDoesNotExist);
+        }
+        if (!(pathname.isJar() || pathname.isURL())) {
+            Pathname result
+                = mergePathnames(pathname,
+                                 coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()),
+                                 NIL);
+            final File file = result.getFile();
+            if (file.exists()) {
+                if (file.isDirectory()) {
+                    result = Pathname.getDirectoryPathname(file);
+                } else {
+                    try {
+                      result = (Pathname)Pathname.create(file.getCanonicalPath());
+                    } catch (IOException e) {
+                        return error(new FileError(e.getMessage(), pathname));
+                    }
+                }
+                if (Utilities.isPlatformUnix) {
+                  result.setDevice(Keyword.UNSPECIFIC);
+                }
+                return result;
+            }
+        } else if (pathname.isURL()) {
+            if (pathname.getInputStream() != null) {
+              // If there is no type, query or fragment, we check to
+              // see if there is URL available "underneath".
+              if (pathname.getName() != NIL
+                  && pathname.getType() == NIL
+                  && Symbol.GETF.execute(pathname.getHost(), QUERY, NIL) == NIL
+                  && Symbol.GETF.execute(pathname.getHost(), FRAGMENT, NIL) == NIL) {
+                Pathname p = (Pathname)Pathname.create(pathname.getNamestring() + "/");
+                if (p.getInputStream() != null) {
+                  return p;
+                }
+              }
+              return pathname;
+            }
+        } else
+        jarfile: {
+            // Possibly canonicalize jar file directory
+            Cons jars = (Cons) pathname.getDevice();
+            LispObject o = jars.car();
+        if (!(o instanceof Pathname)) {
+           return doTruenameExit(pathname, errorIfDoesNotExist);
+        }
+            if (o instanceof Pathname
+                && !(((Pathname)o).isURL())
+                // XXX Silently fail to call truename() if the default
+                // pathname defaults exist within a jar, as that will
+                // (probably) not succeed.  The better solution would
+                // probably be to parametize the value of
+                // *DEFAULT-PATHNAME-DEFAULTS* on invocations of
+                // truename().
+                && !coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()).isJar())
+                {
+                LispObject truename = Pathname.truename((Pathname)o, errorIfDoesNotExist);
+                if (truename != null && truename != NIL
+                    && truename instanceof Pathname) {
+                    Pathname truePathname = (Pathname)truename;
+                    // A jar that is a directory makes no sense, so exit
+                    if (truePathname.getNamestring().endsWith("/")) {
+                        break jarfile;
+                    }
+                    jars.car = truePathname;
+                } else {
+                    break jarfile;
+                }
+            }
+            // Check for existence of a JAR file and/or JarEntry
+            //
+            // Cases:
+            // 1.  JAR
+            // 2.  JAR in JAR
+            // 3.  JAR with Entry
+            // 4.  JAR in JAR with Entry
+            ZipFile jarFile = ZipCache.get((Pathname)jars.car());
+            String entryPath = pathname.asEntryPath();
+            if (jarFile != null) {
+                if (jars.cdr() instanceof Cons) {
+                  Pathname inner = (Pathname) jars.cdr().car();
+                  InputStream inputStream = Utilities.getInputStream(jarFile, inner);
+                  if (inputStream != null) {
+                      if (entryPath.length() == 0) {
+                          return pathname; // Case 2
+                      } else {
+                          ZipInputStream zipInputStream
+                              = new ZipInputStream(inputStream);
+                          ZipEntry entry = Utilities.getEntry(zipInputStream,
+                                                              entryPath,
+                                                              false);
+                          if (entry != null) {
+                              // XXX this could possibly be a directory?
+                              return pathname; // Case 4
+                         }
+                      }
+                  }
+                } else {
+                    if (entryPath.length() == 0) {
+                        return pathname; // Case 1
+                    } else {
+                        ZipEntry entry = jarFile.getEntry(entryPath);
+                        if (entry != null) {
+                            // ensure this isn't a directory
+                            if (entry.isDirectory()) {
+                                break jarfile;
+                            }
+                            try {
+                                InputStream input = jarFile.getInputStream(entry);
+                                if (input != null) {
+                                    return pathname; // Case 3
+                                }
+                            } catch (IOException e) {
+                                break jarfile;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        error:
+                                            boolean errorIfDoesNotExist) {
+      if (pathname == null || pathname.equals(NIL)) {
+        return doTruenameExit(pathname, errorIfDoesNotExist);
+      }
+      if (pathname instanceof LogicalPathname) {
+        pathname = LogicalPathname.translateLogicalPathname((LogicalPathname) pathname);
+      }
+      if (pathname.isWild()) {
+        return error(new FileError("Fundamentally unable to find a truename for any wild pathname.",
+                                   pathname));
+      }
+      Pathname result
+        = (Pathname)mergePathnames(pathname,
+                                   coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()),
+                                   NIL);
+      final File file = result.getFile();
+      if (file.exists()) {
+        if (file.isDirectory()) {
+          result = Pathname.getDirectoryPathname(file);
+        } else {
+          try {
+            result = (Pathname)Pathname.create(file.getCanonicalPath());
+          } catch (IOException e) {
+            return error(new FileError(e.getMessage(), pathname));
+          }
+        }
+        if (Utilities.isPlatformUnix) {
+          result.setDevice(Keyword.UNSPECIFIC);
+        }
+        return result;
+      }
       return doTruenameExit(pathname, errorIfDoesNotExist);
+    }
 …
+    }
   };
+    public InputStream getInputStream() {
+        InputStream result = null;
+        if (isJar()) {
+            String entryPath = asEntryPath();
+            // XXX We only return the bytes of an entry in a JAR
+            Debug.assertTrue(entryPath != null);
+            ZipFile jarFile = ZipCache.get((Pathname)getDevice().car());
+            Debug.assertTrue(jarFile != null);
+            // Is this a JAR within a JAR?
+            if (getDevice().cdr() instanceof Cons) {
+                Pathname inner = (Pathname) getDevice().cdr().car();
+                InputStream input = Utilities.getInputStream(jarFile, inner);
+                ZipInputStream zipInputStream = new ZipInputStream(input);
+                result =  Utilities.getEntryAsInputStream(zipInputStream, entryPath);
+            } else {
+                ZipEntry entry = jarFile.getEntry(entryPath);
+                if (entry == null) {
+                    Debug.trace("Failed to get InputStream for "
+                                + "'" + getNamestring() + "'");
+                    // XXX should this be fatal?
+                    Debug.assertTrue(false);
+                }
+                try {
+                    result = jarFile.getInputStream(entry);
+                } catch (IOException e) {
+                    Debug.warn("Failed to get InputStream from "
+                                + "'" + getNamestring() + "'"
+                                + ": " + e);
+                }
+            }
+        } else if (isURL()) {
+            URL url = this.toURL();
+            try {
+                result = url.openStream();
+            } catch (IOException e) {
+                Debug.warn("Failed to get InputStream from "
+                            + "'" + getNamestring() + "'"
+                            + ": " + e);
+            }
+        } else {
+            File file = getFile();
+            try {
+                result = new FileInputStream(file);
+            } catch (IOException e) {
+                Debug.warn("Failed to get InputStream from "
+                            + "'" + getNamestring() + "'"
+                            + ": " + e);
+            }
+        }
+        return result;
+    }
+    /** @return Time in milliseconds since the UNIX epoch at which the
+     * resource was last modified, or 0 if the time is unknown.
+     */
+    public long getLastModified() {
+        if (!(isJar() || isURL())) {
+            File f = getFile();
+            return f.lastModified();
+        }
+        if (isJar()) {
+            // JAR cases
+            // 0.  JAR from URL
+            // 1.  JAR
+            // 2.  JAR in JAR
+            // 3.  Entry in JAR
+            // 4.  Entry in JAR in JAR
+            String entryPath = asEntryPath();
+            Cons d = (Cons)getDevice();
+            if (d.cdr().equals(NIL)) {
+                if (entryPath.length() == 0) {
+                    LispObject o = d.car();
+                        // 0. JAR from URL
+                        // 1. JAR
+                    return ((Pathname)o).getLastModified();
+                } else {
+                    // 3. Entry in JAR
+                    final ZipEntry entry
+                        = ZipCache.get((Pathname)getDevice().car()).getEntry(entryPath);
+                    if (entry == null) {
+                        return 0;
+                    }
+                    final long time = entry.getTime();
+                    if (time == -1) {
+                        return 0;
+                    }
+                    return time;
+                }
+            } else {
+                ZipFile outerJar = ZipCache.get((Pathname)d.car());
+                if (entryPath.length() == 0) {
+                    // 4.  JAR in JAR
+                    String jarPath = ((Pathname)d.cdr()).asEntryPath();
+                    final ZipEntry entry = outerJar.getEntry(jarPath);
+                    final long time = entry.getTime();
+                    if (time == -1) {
+                        return 0;
+                    }
+                    return time;
+                } else {
+                    // 5. Entry in JAR in JAR
+                    String innerJarPath = ((Pathname)d.cdr()).asEntryPath();
+                    ZipEntry entry = outerJar.getEntry(entryPath);
+                    ZipInputStream innerJarInputStream
+                        = Utilities.getZipInputStream(outerJar, innerJarPath);
+                    ZipEntry innerEntry = Utilities.getEntry(innerJarInputStream,
+                                                             entryPath);
+                    long time = innerEntry.getTime();
+                    if (time == -1) {
+                        return 0;
+                    }
+                    return time;
+                }
+            }
+        }
+        if (isURL()) {
+            return getURLConnection().getLastModified();
+        }
+        return 0;
+    }
+    private static final Primitive MKDIR = new pf_mkdir();
+    @DocString(name="mkdir",
+               args="pathname",
+               returns="generalized-boolean",
+    doc="Attempts to create directory at PATHNAME returning the success or failure.")
+    private static class pf_mkdir extends Primitive {
+        pf_mkdir() {
+            super("mkdir", PACKAGE_SYS, false, "pathname");
+        }
+        @Override
+        public LispObject execute(LispObject arg) {
+            final Pathname pathname = coerceToPathname(arg);
+            if (pathname.isWild()) {
+                error(new FileError("Bad place for a wild pathname.", pathname));
+            }
+            Pathname defaultedPathname =
+                mergePathnames(pathname,
+                               coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()),
+                               NIL);
+            if (defaultedPathname.isURL() || defaultedPathname.isJar()) {
+                return new FileError("Cannot mkdir with a "
+                                     + (defaultedPathname.isURL() ? "URL" : "jar")
+                                     + " Pathname.",
+                                     defaultedPathname);
+            }
+  public InputStream getInputStream() {
+    InputStream result = null;
+    File file = getFile();
+    try {
+      result = new FileInputStream(file);
+    } catch (IOException e) {
+      simple_error("Failed to get InputStream from ~a because ~a", this,  e);
+    }
+    return result;
+  }
+  /** @return Time in milliseconds since the UNIX epoch at which the
+   * resource was last modified, or 0 if the time is unknown.
+   */
+  public long getLastModified() {
+    File f = getFile();
+    return f.lastModified();
+  }
+  private static final Primitive MKDIR = new pf_mkdir();
+  @DocString(name="mkdir",
+             args="pathname",
+             returns="generalized-boolean",
+             doc="Attempts to create directory at PATHNAME returning the success or failure.")
+ private static class pf_mkdir extends Primitive {
+   pf_mkdir() {
+     super("mkdir", PACKAGE_SYS, false, "pathname");
+   }
+   @Override
+   public LispObject execute(LispObject arg) {
+     final Pathname pathname = coerceToPathname(arg);
+     if (pathname.isWild()) {
+       error(new FileError("Bad place for a wild pathname.", pathname));
+     }
+     Pathname defaultedPathname
+       = (Pathname)mergePathnames(pathname,
+                                  coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()),
+                                  NIL);
+     if (defaultedPathname.isURL() || defaultedPathname.isJar()) {
+       return new FileError("Cannot mkdir with a "
+                            + (defaultedPathname.isURL() ? "URL" : "jar")
+                            + " Pathname.",
+                            defaultedPathname);
+     }
             File file = defaultedPathname.getFile();
             return file.mkdir() ? T : NIL;
+        }
+    }
     private static final Primitive RENAME_FILE = new pf_rename_file();
     @DocString(name="rename-file",
+     File file = defaultedPathname.getFile();
+     return file.mkdir() ? T : NIL;
+   }
+ }
+  private static final Primitive RENAME_FILE = new pf_rename_file();
+  @DocString(name="rename-file",
                args="filespec new-name",
                returns="defaulted-new-name, old-truename, new-truename",
 …
                + "value, OLD-TRUENAME, is the truename of the file before it was renamed. The tertiary \n"
                + "value, NEW-TRUENAME, is the truename of the file after it was renamed.\n")
+    private static class pf_rename_file extends Primitive {
+        pf_rename_file() {
+            super("rename-file", "filespec new-name");
+        }
+        @Override
+        public LispObject execute(LispObject first, LispObject second) {
+            Pathname oldPathname = coerceToPathname(first);
+            Pathname oldTruename = (Pathname) truename(oldPathname, true);
+            Pathname newName = coerceToPathname(second);
+            if (newName.isWild()) {
+                error(new FileError("Bad place for a wild pathname.", newName));
+            }
+            if (oldTruename.isJar()) {
+                error(new FileError("Bad place for a jar pathname.", oldTruename));
+            }
+            if (newName.isJar()) {
+                error(new FileError("Bad place for a jar pathname.", newName));
+            }
+            if (oldTruename.isURL()) {
+                error(new FileError("Bad place for a URL pathname.", oldTruename));
+            }
+            if (newName.isURL()) {
+                error(new FileError("Bad place for a jar pathname.", newName));
+            }
+            Pathname defaultedNewName = mergePathnames(newName, oldTruename, NIL);
+            File source = oldTruename.getFile();
+            File destination = null;
+            if (defaultedNewName instanceof LogicalPathname) {
+                destination = LogicalPathname.translateLogicalPathname((LogicalPathname)defaultedNewName)
+                    .getFile();
+            } else {
+                destination = defaultedNewName.getFile();
+            }
+            // By default, MSDOG doesn't allow one to remove files that are open.
+            if (Utilities.isPlatformWindows) {
+              if (destination.isFile()) {
+                ZipCache.remove(destination);
+                destination.delete();
+              }
+            }
+            if (source.renameTo(destination)) { // Success!
+              Pathname newTruename = (Pathname)truename(defaultedNewName, true);
+              return LispThread.currentThread().setValues(defaultedNewName,
+                                                          oldTruename,
+                                                          newTruename);
+            }
+            return error(new FileError("Unable to rename "
+                                       + oldTruename.princToString()
+                                       + " to " + newName.princToString()
+                                       + ".",
+                                       oldTruename));
+        }
+    }
+  private static class pf_rename_file extends Primitive {
+    pf_rename_file() {
+      super("rename-file", "filespec new-name");
+    }
+    @Override
+    public LispObject execute(LispObject first, LispObject second) {
+      Pathname oldPathname = coerceToPathname(first);
+      Pathname oldTruename = (Pathname) Symbol.TRUENAME.execute(oldPathname);
+      Pathname newName = coerceToPathname(second);
+      if (newName.isWild()) {
+        error(new FileError("Bad place for a wild pathname.", newName));
+      }
+      if (oldTruename.isJar()) {
+        error(new FileError("Bad place for a jar pathname.", oldTruename));
+      }
+      if (newName.isJar()) {
+        error(new FileError("Bad place for a jar pathname.", newName));
+      }
+      if (oldTruename.isURL()) {
+        error(new FileError("Bad place for a URL pathname.", oldTruename));
+      }
+      if (newName.isURL()) {
+        error(new FileError("Bad place for a jar pathname.", newName));
+      }
+      Pathname defaultedNewName = (Pathname)mergePathnames(newName, oldTruename, NIL);
+      File source = oldTruename.getFile();
+      File destination = null;
+      if (defaultedNewName instanceof LogicalPathname) {
+        destination = LogicalPathname.translateLogicalPathname((LogicalPathname)defaultedNewName)
+          .getFile();
+      } else {
+        destination = defaultedNewName.getFile();
+      }
+      if (Utilities.isPlatformWindows) {
+        if (destination.isFile()) {
+          //if (destination.isJar()) {
+            // By default, MSDOG doesn't allow one to remove files that are open, so we need to close
+            // any open jar references
+            // FIXME
+            //            ZipCache.remove(destination);
+          //          }
+          destination.delete();
+        }
+      }
+      if (source.renameTo(destination)) { // Success!
+        Pathname newTruename = (Pathname)truename(defaultedNewName, true);
+        return LispThread.currentThread().setValues(defaultedNewName,
+                                                    oldTruename,
+                                                    newTruename);
+      }
+      return error(new FileError("Unable to rename "
+                                 + oldTruename.princToString()
+                                 + " to " + newName.princToString()
+                                 + ".",
+                                 oldTruename));
+    }
+  }
     // TODO clarify uri encoding cases in implementation and document
     private static final Primitive FILE_NAMESTRING = new pf_file_namestring();
     @DocString(name="file-namestring",
                args="pathname",
                returns="namestring",
     doc="Returns just the name, type, and version components of PATHNAME.")
     private static class pf_file_namestring extends Primitive {
         pf_file_namestring() {
             super("file-namestring", "pathname");
+        }
         @Override
         public LispObject execute(LispObject arg) {
             Pathname p = coerceToPathname(arg);
             StringBuilder sb = new StringBuilder();
             if (p.getName() instanceof AbstractString) {
                 sb.append(p.getName().getStringValue());
             } else if (p.getName() == Keyword.WILD) {
                 sb.append('*');
             } else {
                 return NIL;
+            }
             if (p.getType() instanceof AbstractString) {
                 sb.append('.');
                 sb.append(p.getType().getStringValue());
             } else if (p.getType() == Keyword.WILD) {
                 sb.append(".*");
+            }
             return new SimpleString(sb);
+        }
+    }
     private static final Primitive HOST_NAMESTRING = new pf_host_namestring();
     @DocString(name="host-namestring",
                args="pathname",
                returns="namestring",
     doc="Returns the host name of PATHNAME.")
     private static class pf_host_namestring extends Primitive {
         pf_host_namestring() {
             super("host-namestring", "pathname");
+        }
         @Override
         public LispObject execute(LispObject arg) {
             return coerceToPathname(arg).getHost(); // XXX URL-PATHNAME
+        }
+    }
+  // TODO clarify uri encoding cases in implementation and document
+  private static final Primitive FILE_NAMESTRING = new pf_file_namestring();
+  @DocString(name="file-namestring",
+             args="pathname",
+             returns="namestring",
+             doc="Returns just the name, type, and version components of PATHNAME.")
+  private static class pf_file_namestring extends Primitive {
+    pf_file_namestring() {
+      super(Symbol.FILE_NAMESTRING, "pathname");
+    }
+    @Override
+    public LispObject execute(LispObject arg) {
+      Pathname p = coerceToPathname(arg);
+      StringBuilder sb = new StringBuilder();
+      if (p.getName() instanceof AbstractString) {
+        sb.append(p.getName().getStringValue());
+      } else if (p.getName() == Keyword.WILD) {
+        sb.append('*');
+      } else {
+        return NIL;
+      }
+      if (p.getType() instanceof AbstractString) {
+        sb.append('.');
+        sb.append(p.getType().getStringValue());
+      } else if (p.getType() == Keyword.WILD) {
+        sb.append(".*");
+      }
+      return new SimpleString(sb);
+    }
+  }
+  private static final Primitive HOST_NAMESTRING = new pf_host_namestring();
+  @DocString(name="host-namestring",
+             args="pathname",
+             returns="namestring",
+             doc="Returns the host name of PATHNAME.")
+  private static class pf_host_namestring extends Primitive {
+    pf_host_namestring() {
+      super("host-namestring", "pathname");
+    }
+    @Override
+    public LispObject execute(LispObject arg) {
+      return coerceToPathname(arg).getHost(); // XXX URL-PATHNAME
+    }
+  }
     public URL toURL() {
         try {
             if (isURL()) {
                 return new URL(getNamestring());
             } else {
                 return toFile().toURI().toURL();
+            }
         } catch (MalformedURLException e) {
             error(new LispError(getNamestring() + " is not a valid URL"));
             return null; // not reached
+        }
+    }
     public File toFile() {
         if(!isURL()) {
             return new File(getNamestring());
         } else {
             throw new RuntimeException(this + " does not represent a file");
+        }
+    }
     static {
         LispObject obj = Symbol.DEFAULT_PATHNAME_DEFAULTS.getSymbolValue();
         Symbol.DEFAULT_PATHNAME_DEFAULTS.setSymbolValue(coerceToPathname(obj));
+    }
+  public URL toURL() {
+    try {
+      if (isURL()) {
+        return new URL(getNamestring());
+      } else {
+        return toFile().toURI().toURL();
+      }
+    } catch (MalformedURLException e) {
+      error(new LispError(getNamestring() + " is not a valid URL"));
+      return null; // not reached
+    }
+  }
+  public File toFile() {
+    if(!isURL()) {
+      return new File(getNamestring());
+    } else {
+      throw new RuntimeException(this + " does not represent a file");
+    }
+  }
+  static {
+    LispObject obj = Symbol.DEFAULT_PATHNAME_DEFAULTS.getSymbolValue();
+    Symbol.DEFAULT_PATHNAME_DEFAULTS.setSymbolValue(coerceToPathname(obj));
+  }
     @DocString(name="uri-decode",
                args="string",
                returns="string",
     doc="Decode STRING percent escape sequences in the manner of URI encodings.")
     private static final Primitive URI_DECODE = new pf_uri_decode();
     private static final class pf_uri_decode extends Primitive {
         pf_uri_decode() {
             super("uri-decode", PACKAGE_EXT, true);
+        }
         @Override
         public LispObject execute(LispObject arg) {
             if (!(arg instanceof AbstractString)) {
                 return type_error(arg, Symbol.STRING);
+            }
             String result = uriDecode(((AbstractString)arg).toString());
             return new SimpleString(result);
+        }
     };
     static String uriDecode(String s) {
         try {
             URI uri = new URI("file://foo?" + s);
             return uri.getQuery();
         } catch (URISyntaxException e) {}
         return null;  // Error
+    }
+  @DocString(name="uri-decode",
+             args="string",
+             returns="string",
+  doc="Decode STRING percent escape sequences in the manner of URI encodings.")
+  private static final Primitive URI_DECODE = new pf_uri_decode();
+  private static final class pf_uri_decode extends Primitive {
+    pf_uri_decode() {
+      super("uri-decode", PACKAGE_EXT, true);
+    }
+    @Override
+    public LispObject execute(LispObject arg) {
+      if (!(arg instanceof AbstractString)) {
+        return type_error(arg, Symbol.STRING);
+      }
+      String result = uriDecode(((AbstractString)arg).toString());
+      return new SimpleString(result);
+    }
+  };
+  static String uriDecode(String s) {
+    try {
+      URI uri = new URI("file://foo?" + s);
+      return uri.getQuery();
+    } catch (URISyntaxException e) {}
+    return null;  // Error
+  }
     @DocString(name="uri-encode",
                args="string",
                returns="string",
     doc="Encode percent escape sequences in the manner of URI encodings.")
     private static final Primitive URI_ENCODE = new pf_uri_encode();
     private static final class pf_uri_encode extends Primitive {
         pf_uri_encode() {
             super("uri-encode", PACKAGE_EXT, true);
+        }
         @Override
         public LispObject execute(LispObject arg) {
             if (!(arg instanceof AbstractString)) {
                 return type_error(arg, Symbol.STRING);
+            }
             String result = uriEncode(((AbstractString)arg).toString());
             return new SimpleString(result);
+        }
     };
     static String uriEncode(String s) {
         // The constructor we use here only allows absolute paths, so
         // we manipulate the input and output correspondingly.
         String u;
         if (!s.startsWith("/")) {
             u = "/" + s;
         } else {
             u = new String(s);
+        }
         try {
             URI uri = new URI("file", "", u, "");
             String result = uri.getRawPath();
             if (!s.startsWith("/")) {
                 return result.substring(1);
+            }
             return result;
         } catch (URISyntaxException e) {
             Debug.assertTrue(false);
+        }
         return null; // Error
+    }
     File getFile() {
         String namestring = getNamestring(); // XXX UNC pathnames currently have no namestring
         if (namestring != null) {
             return new File(namestring);
+        }
         error(new FileError("Pathname has no namestring: " + princToString(),
+  @DocString(name="uri-encode",
+             args="string",
+             returns="string",
+  doc="Encode percent escape sequences in the manner of URI encodings.")
+  private static final Primitive URI_ENCODE = new pf_uri_encode();
+  private static final class pf_uri_encode extends Primitive {
+    pf_uri_encode() {
+      super("uri-encode", PACKAGE_EXT, true);
+    }
+    @Override
+    public LispObject execute(LispObject arg) {
+      if (!(arg instanceof AbstractString)) {
+        return type_error(arg, Symbol.STRING);
+      }
+      String result = uriEncode(((AbstractString)arg).toString());
+      return new SimpleString(result);
+    }
+  };
+  static String uriEncode(String s) {
+    // The constructor we use here only allows absolute paths, so
+    // we manipulate the input and output correspondingly.
+    String u;
+    if (!s.startsWith("/")) {
+      u = "/" + s;
+    } else {
+      u = new String(s);
+    }
+    try {
+      URI uri = new URI("file", "", u, "");
+      String result = uri.getRawPath();
+      if (!s.startsWith("/")) {
+        return result.substring(1);
+      }
+      return result;
+    } catch (URISyntaxException e) {
+      Debug.assertTrue(false);
+    }
+    return null; // Error
+  }
+  File getFile() {
+    String namestring = getNamestring(); // XXX UNC pathnames currently have no namestring
+    if (namestring != null) {
+      return new File(namestring);
+    }
+    error(new FileError("Pathname has no namestring: " + princToString(),
                         this));
         // Not reached.
         return null;
+    }
     public static Pathname getDirectoryPathname(File file) {
+    return (File)UNREACHED;
+  }
+  public static Pathname getDirectoryPathname(File file) {
         try {
             String namestring = file.getCanonicalPath();
 …
+        }
+    }
+  // Whether this pathname represents a file on the filesystem, not
+  // addressed as a JAR-PATHNAME
+  public boolean isLocalFile() {
+    if (getHost().equals(NIL)
+        || Symbol.GETF.execute(getHost(), PathnameURL.SCHEME, NIL).equals("file")) {
+      return true;
+    }
+    return false;
+  }
+  /** @return The representation of this pathname suitable for
+   *  referencing an entry in a Zip/JAR file
+   */
+  protected String asEntryPath() {
+    Pathname p = Pathname.create();
+    p.setDirectory(getDirectory())
+      .setName(getName())
+      .setType(getType());
+    String path = p.getNamestring();
+    StringBuilder result = new StringBuilder();
+    result.append(path);
+    // Entries in jar files are always relative, but Pathname
+    // directories are :ABSOLUTE.
+    if (result.length() > 1
+        && result.substring(0, 1).equals("/")) {
+      return result.substring(1);
+    }
+    return result.toString();
+  }
+}

trunk/abcl/src/org/armedbear/lisp/PathnameJar.java

-                      r15393
+                      r15395
 import static org.armedbear.lisp.Lisp.*;
+import java.io.InputStream;
 import java.io.IOException;
 import java.io.File;
 …
 import java.net.URISyntaxException;
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 …
   extends PathnameURL
+{
+  static final public String JAR_URI_SUFFIX = "!/";
+  static final public String JAR_URI_PREFIX = "jar:";
   protected PathnameJar() {}
 …
+  }
+  static final public String JAR_URI_SUFFIX = "!/";
+  static final public String JAR_URI_PREFIX = "jar:";
+  public static LispObject createFromPathname(Pathname p) {
+    if (p instanceof PathnameURL) {
+      return PathnameJar.create(JAR_URI_PREFIX + ((PathnameURL)p).getNamestringAsURI() + JAR_URI_SUFFIX);
+    } else if (p instanceof Pathname) {
+      // FIXME: not going to work with namestrings with characters that need URI escaping
+      return PathnameJar.create(JAR_URI_PREFIX + "file://" + p.getNamestring() + JAR_URI_SUFFIX);
+    } else {
+      return p;
+    }
+  }
+  static public LispObject createFromFile(String s) {
+    return PathnameJar.create("jar:file:" + s + JAR_URI_SUFFIX);
+  }
+  static public LispObject createEntryFromFile(String jar, String entry) {
+    return PathnameJar.create("jar:file:" + jar + JAR_URI_SUFFIX + entry);
+  }
+  static public LispObject createEntryFromJar(PathnameJar jar, String entry) {
+    if (jar.isArchiveEntry()) {
+      return simple_error("Failed to create the entry ~a in ~a", entry, jar);
+    }
+    return PathnameJar.create(jar.getNamestring() + entry);
+  }
   /**
    *  Enumerate the components of a jar namestring
 …
+    }
+    // the first value is not a jar Pathname,
+    // The root, non-PathnameJar location of this reference
+    // For files, possibly either a relative or absolute directory
     result.add(parts[0]);
+    // the references to jars, all suffixed with JAR_URI_SUFFIX
+    // The references to the pathnames of archives located within the
+    // root jar.
+    // These will be relative directory paths suffixed with JAR_URI_SUFFIX
     for (int j = 1; j < prefixCount; j++) {
       String ns = parts[j] + JAR_URI_SUFFIX;
 …
+    }
     // possibly return the path inside the last jar
+    // possibly return the path inside the last jar as an absolute path
     if (parts.length == (prefixCount + 1)) {
       result.add("/" + parts[parts.length - 1]);
 …
+  }
+  static public Pathname create() {
+    return new PathnameJar();
+  }
   static public LispObject create(String s) {
     if (!s.startsWith(JAR_URI_PREFIX)) {
 …
       return parse_error("Couldn't parse PATHNAME-JAR from namestring: " + s);
+    }
     PathnameJar result = new PathnameJar();
 …
+  }
+  LispObject getRootJar() {
+    return getDevice().car();
+  }
+  LispObject getJars() {
+    return getDevice();
+  }
   public static final LispObject truename(PathnameJar pathname,
                                           boolean errorIfDoesNotExist) {
-    // PathnameJar result
-    //   = (PathnameJar) mergePathnames(pathname,
-    //                                  coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()),
-    //                                  NIL);
     PathnameJar result = pathname;
+    LispObject enclosingJars = NIL;
+    LispObject current = pathname.getDevice();
+    while (current instanceof PathnameJar){
+      enclosingJars = enclosingJars.push(current);
+      current = ((PathnameJar)current).getDevice();
+    }
+    LispObject outerJar = Pathname.truename(current, errorIfDoesNotExist);
+    String outerJarNamestring = ((Pathname)outerJar).getNamestring();
+    try {
+      ZipFile jarFile = new ZipFile(outerJarNamestring);
+      while (enclosingJars.car() != NIL) {
+        LispObject jar = enclosingJars.car();
+        String ns = ((Pathname)jar).getNamestring();
+        ZipFile f = new ZipFile(ns);
+        enclosingJars = enclosingJars.cdr();
+      }
+    } catch (IOException e) {
+      return Pathname.doTruenameExit(result, errorIfDoesNotExist);
+    }
+    return result;
+    LispObject jars = pathname.getJars();
+    Pathname rootJar = (Pathname) pathname.getRootJar();
+    LispObject enclosingJars = jars.cdr();
+    if (!rootJar.isLocalFile()) {
+      // FIXME implement me
+      simple_error("Unimplemented TRUENAME for non-file root jar.");
+    } else {
+      rootJar = (Pathname)Symbol.MERGE_PATHNAMES.execute(rootJar);
+    }
+    rootJar = (Pathname)Symbol.TRUENAME.execute(rootJar);
+    PathnameJar p = new PathnameJar();
+    p.copyFrom(pathname);
+    p.setDevice(new Cons(rootJar, enclosingJars));
+    if (!p.isArchiveEntry()) {
+      ZipCache.Archive archive = ZipCache.getArchive(p);
+      if (archive == null) {
+        if (errorIfDoesNotExist) {
+          return simple_error("Accessible TRUENAME can't be determined for: ~a", pathname); //time !?
+        } else {
+          return NIL;
+        }
+      }
+      return p;
+    }
+    ZipEntry entry = ZipCache.getZipEntry(p);
+    if (entry == null) {
+      if (errorIfDoesNotExist) {
+        return simple_error("Accessible TRUENAME can't be determined for: ~a", pathname); //time !?
+      } else {
+        return NIL;
+      }
+    }
+    return p;
+  }
+  public boolean isLocalFile() {
+    Pathname p = (Pathname) getRootJar();
+    if (p.isLocalFile()) {
+      return true;
+    }
+    return super.isLocalFile();
+  }
+  public boolean isArchiveEntry() {
+    return !(getDirectory().equals(NIL)
+             && getName().equals(NIL)
+             && getType().equals(NIL));
+  }
+  public PathnameJar getArchive() {
+    if (!isArchiveEntry()) {
+      return (PathnameJar)simple_error("Pathname already represents an archive.");
+    }
+    PathnameJar archive = new PathnameJar();
+    archive.copyFrom(this);
+    archive
+      .setDirectory(NIL)
+      .setName(NIL)
+      .setType(NIL);
+    return archive;
+  }
 …
+  }
+        //   jarfile: {
+  public InputStream getInputStream() {
+    String entryPath = asEntryPath();
+    // XXX We only return the bytes of an entry in a JAR
+    if (!isArchiveEntry()) {
+      simple_error("Can only get input stream for an entry in a JAR-PATHNAME.", this);
+    }
+    InputStream result = ZipCache.getEntryAsInputStream(this);
+    if (result == null) {
+      error(new FileError("Failed to get InputStream", this));
+    }
+    return result;
+  }
+  /** List the contents of the directory */
+  static public LispObject listDirectory(PathnameJar pathname) {
+    String directory = pathname.asEntryPath();
+    // We should only be listing directories
+    if (pathname.getDirectory() == NIL) {
+      return simple_error("Not a directory in a jar ~a", pathname);
+    }
+    // if (pathname.getDevice().cdr() instanceof Cons) {
+    //   return error(new FileError("Unimplemented directory listing of JAR within JAR.", pathname));
+    // }
+    if (directory.length() == 0) {
+      directory = "/*";
+    } else {
+      if (directory.endsWith("/")) {
+        directory = "/" + directory + "*";
+      } else {
+        directory = "/" + directory + "/*";
+      }
+    }
+    Pathname wildcard = (Pathname)Pathname.create(directory);
+    //    String wildcard = new SimpleString(directory);
+    // directories in a a jar aren't marked with a suffixed slash
+    //    SimpleString wildcardDirectory = new SimpleString(directory + "/");
+    LispObject result = NIL;
+    //LispObject matches;
+    Iterator<Map.Entry<PathnameJar,ZipEntry>> iterator = ZipCache.getEntriesIterator(pathname);
+    while (iterator.hasNext()) {
+      Map.Entry<PathnameJar,ZipEntry> e = iterator.next();
+      PathnameJar entry = e.getKey();
+      // PathnameJar jarPath = (PathnameJar)PathnameJar.create(e.getKey());
+      // ZipEntry entry = e.getValue();
+      // if (entryName.endsWith("/")) {
+      //   matches = Symbol.PATHNAME_MATCH_P
+      //     .execute(new SimpleString(entryName), wildcardDirectory);
+      // } else {
+      //   matches = Symbol.PATHNAME_MATCH_P.
+      //     execute(new SimpleString(entryName), wildcard);
+      // }
+      if (!Symbol.PATHNAME_MATCH_P.execute(entry, wildcard).equals(NIL)) {
+        result = result.push(entry);
+      }
+    }
+    return result.nreverse();
+  }
+  @DocString(name="match-wild-jar-pathname",
+             args="wild-jar-pathname",
+             returns="pathnames",
+  doc="Returns the pathnames matching WILD-JAR-PATHNAME which must be both wild and a JAR-PATHNAME")
+  static final Primitive MATCH_WILD_JAR_PATHNAME = new pf_match_wild_jar_pathname();
+  private static class pf_match_wild_jar_pathname extends Primitive {
+    pf_match_wild_jar_pathname() {
+      super(Symbol.MATCH_WILD_JAR_PATHNAME, "wild-jar-pathname");
+    }
+    @Override
+    public LispObject execute(LispObject arg) {
+      Pathname pathname = coerceToPathname(arg);
+      if (pathname instanceof LogicalPathname) {
+        pathname = LogicalPathname.translateLogicalPathname((LogicalPathname) pathname);
+      }
+      if (!pathname.isJar()) {
+        return new FileError("Not a jar pathname.", pathname);
+      }
+      if (!pathname.isWild()) {
+        return new FileError("Not a wild pathname.", pathname);
+      }
+      if (!((PathnameJar)pathname).getJars().cdr().equals(NIL)) {
+        return simple_error("Unimplemented match on contents of inner jars"); // FIXME
+      }
+      PathnameJar jarPathname = new PathnameJar();
+      jarPathname.copyFrom(pathname);
+      jarPathname
+        .setDirectory(NIL)
+        .setName(NIL)
+        .setType(NIL);
+      PathnameJar wildcard = (PathnameJar)Symbol.TRUENAME.execute(jarPathname);
+      Iterator<Map.Entry<PathnameJar,ZipEntry>> iterator
+        = ZipCache.getEntriesIterator(wildcard);
+      wildcard
+        .setDirectory(pathname.getDirectory())
+        .setName(pathname.getName())
+        .setType(pathname.getType());
+      LispObject result = NIL;
+      while (iterator.hasNext()) {
+        Map.Entry<PathnameJar,ZipEntry> e = iterator.next();
+        PathnameJar entry = e.getKey();
+        LispObject matches
+          = Symbol.PATHNAME_MATCH_P.execute(entry, wildcard);
+        if (!matches.equals(NIL)) {
+          result = new Cons(entry, result);
+        }
+      }
+      // FIXME implement recursive jars
+      // if (pathname.getDevice().cdr() instanceof Cons) {
+      //   ZipFile outerJar = ZipCache.get((Pathname)pathname.getDevice().car());
+      //   String entryPath = ((Pathname)pathname.getDevice().cdr().car()).getNamestring(); //???
+      //   if (entryPath.startsWith("/")) {
+      //     entryPath = entryPath.substring(1);
+      //   }
+      //   ZipEntry entry = outerJar.getEntry(entryPath);
+      //   InputStream inputStream = null;
+      //   try {
+      //     inputStream = outerJar.getInputStream(entry);
+      //   } catch (IOException e) {
+      //     return new FileError("Failed to read zip input stream inside zip.",
+      //                          pathname);
+      //   }
+      //   ZipInputStream zipInputStream
+      //     = new ZipInputStream(inputStream);
+      //   try {
+      //     while ((entry = zipInputStream.getNextEntry()) != null) {
+      //       String entryName = "/" + entry.getName();
+      //       LispObject matches = Symbol.PATHNAME_MATCH_P
+      //         .execute(new SimpleString(entryName), wildcard);
+      //       if (!matches.equals(NIL)) {
+      //         String namestring = new String(pathname.getNamestring());
+      //         namestring = namestring.substring(0, namestring.lastIndexOf("!/") + 2)
+      //           + entry.getName();
+      //         Pathname p = (Pathname)Pathname.create(namestring);
+      //         result = new Cons(p, result);
+      //       }
+      //     }
+      //   } catch (IOException e) {
+      //     return new FileError("Failed to seek through zip inputstream inside zip.",
+      //                          pathname);
+      //   }
+      // } else {
+      // }
+      return result;
+    }
+  }
+  public long getLastModified() {
+    if (!isArchiveEntry()) {
+      ZipCache.Archive archive = ZipCache.getArchive(this);
+      if (archive != null) {
+        return archive.lastModified;
+      }
+    } else {
+      ZipEntry entry = ZipCache.getZipEntry(this);
+      if (entry != null) {
+        return entry.getTime();
+      }
+    }
+    return -1; // shouldn't be reached
+  }
+}
+    // String rootJarNamestring = ((Pathname)rootJar).getNamestring();
+    // try {
+    //   ZipFile jarFile = new ZipFile(rootJarNamestring);
+    //   ZipFileInputStream inputStream = null;
+    //   while (enclosingJars.car() != NIL) {
+    //     LispObject jar = enclosingJars.car();
+    //     String ns = ((Pathname)jar).getNamestring();
+    //     ZipEntry entry = currentZip.getEntry(ns);
+    //     if (entry == null) {
+    //       return simple_error("Failed to find entry ~a in ~a", ns, pathname);
+    //     }
+    //     InputStream i = entry.getInputStream();
+    //     ZipInputStream zi = new ZipInputStream(i);
+    //     enclosingJars = enclosingJars.cdr();
+    //   }
+    // } catch (IOException e) {
+    //   return Pathname.doTruenameExit(result, errorIfDoesNotExist);
+    // }
+  // truename
+  //   jarfile: {
         //     // Possibly canonicalize jar file directory
         //     LispObject o = pathname.getDevice();
 …
         // }
+}
+// Pathname.init()
+          // A JAR file
+            // LispObject jars = NIL;
+            // int i = s.lastIndexOf(jarSeparator, s.length() - jarSeparator.length() - 1);
+            // String jar = null;
+            // if (i == -1) {
+            //     jar = s;
+            // } else {
+            //     // There can be no more than two jar references and the
+            //     // inner one must be a file reference within the outer.
+            //     jar = "jar:file:" + s.substring(i + jarSeparator.length());
+            //     s = s.substring("jar:".length(), i + jarSeparator.length());
+            //     Pathname p = (Pathname) Pathname.create(s);
+            //     jars = jars.push(p.getDevice().car());
+            // }
+            // if (jar.startsWith("jar:file:")) { // PathnameJar should handle this partâŠ
+            //     String file
+            //         = jar.substring("jar:file:".length(),
+            //                         jar.length() - jarSeparator.length());
+            //     Pathname jarPathname;
+            //     if (file.length() > 0) {
+            //         URL url = null;
+            //         URI uri = null;
+            //         try {
+            //             url = new URL("file:" + file);
+            //             uri = url.toURI();
+            //         } catch (MalformedURLException e1) {
+            //             error(new SimpleError("Failed to create URI from "
+            //                                 + "'" + file + "'"
+            //                                 + ": " + e1.getMessage()));
+            //         } catch (URISyntaxException e2) {
+            //             error(new SimpleError("Failed to create URI from "
+            //                                 + "'" + file + "'"
+            //                                 + ": " + e2.getMessage()));
+            //         }
+            //         String path = uri.getPath();
+            //         if (path == null) {
+            //             // We allow "jar:file:baz.jar!/" to construct a relative
+            //             // path for jar files, so MERGE-PATHNAMES means something.
+            //           jarPathname = (Pathname)Pathname.create(uri.getSchemeSpecificPart());
+            //         } else {
+            //           jarPathname = (Pathname)Pathname.create((new File(path)).getPath());
+            //         }
+            //     } else {
+            //       jarPathname = (Pathname)Pathname.create("");
+            //     }
+            //     jars = jars.push(jarPathname);
+            // } else {
+            //     URL url = null;
+            //     try {
+            //         url = new URL(jar.substring("jar:".length(), jar.length() - 2));
+            //         Pathname p = (Pathname)Pathname.create(url);
+            //         jars = jars.push(p);
+            //     } catch (MalformedURLException e) {
+            //         error(new LispError("Failed to parse URL "
+            //                             + "'" + url + "'"
+            //                             + e.getMessage()));
+            //     }
+            // }
+            // jars = jars.nreverse();
+            // setDevice(jars);
+            // invalidateNamestring();
+            // return;
+        // // An entry in a JAR file
+        // final int separatorIndex = s.lastIndexOf(jarSeparator);
+        // if (separatorIndex > 0 && s.startsWith("jar:")) {
+        //   return PathnameJar.create(s);
+        // }
+        //     final String jarURL = s.substring(0, separatorIndex + jarSeparator.length());
+        //     URL url = null;
+        //     try {
+        //         url = new URL(jarURL);
+        //     } catch (MalformedURLException ex) {
+        //         error(new LispError("Failed to parse URL "
+        //                             + "'" + jarURL + "'"
+        //                             + ex.getMessage()));
+        //     }
+        //     Pathname d = (Pathname)Pathname.create(url);
+        //     if (getDevice() instanceof Cons) {
+        //         LispObject[] jars = d.copyToArray();
+        //         //  XXX Is this ever reached?  If so, need to append lists
+        //         Debug.assertTrue(false);
+        //     } else {
+        //         setDevice(d.getDevice());
+        //     }
+        //     s = "/" + s.substring(separatorIndex + jarSeparator.length());
+        //     Pathname p = (Pathname)Pathname.create("file:" + s); // Use URI escaping rules
+        //     setDirectory(p.getDirectory());
+        //     setName(p.getName());
+        //     setType(p.getType());
+        //     setVersion(p.getVersion());
+        //     return;
+        // }

trunk/abcl/src/org/armedbear/lisp/PathnameURL.java

-                      r15393
+                      r15395
 /*
  * PathnameJar.java
+ * PathnameURL.java
+ *
  * Copyright (C) 2020 @easye
 …
 import java.io.File;
+import java.io.InputStream;
+import java.io.IOException;
 import java.net.URL;
 import java.net.URI;
 …
 import java.text.MessageFormat;
+public class PathnameURL extends Pathname {
+public class PathnameURL
+  extends Pathname
+{
   static final Symbol SCHEME = internKeyword("SCHEME");
   static final Symbol AUTHORITY = internKeyword("AUTHORITY");
 …
     Pathname p = (Pathname)Pathname.create(path != null ? path : "");
+    result.setDirectory(p.getDirectory());
+    result.setName(p.getName());
+    result.setType(p.getType());
+    result
+      .setDirectory(p.getDirectory())
+      .setName(p.getName())
+      .setType(p.getType());
     return result;
 …
   public String getNamestringAsURI() {
+    URL url = makeURL(this);
+    return url.toString();
+    LispObject schemeProperty = Symbol.GETF.execute(getHost(), SCHEME, NIL);
+    LispObject authorityProperty = Symbol.GETF.execute(getHost(), AUTHORITY, NIL);
+    LispObject queryProperty = Symbol.GETF.execute(getHost(), QUERY, NIL);
+    LispObject fragmentProperty = Symbol.GETF.execute(getHost(), FRAGMENT, NIL);
+    String scheme;
+    String authority;
+    if (!schemeProperty.equals(NIL)) {
+      scheme = schemeProperty.getStringValue();
+      authority =  authorityProperty.getStringValue();
+    } else {
+      scheme = "file";
+      authority = "";
+    }
+    String directory = getDirectoryNamestring();
+    String file = Symbol.FILE_NAMESTRING.execute(this).getStringValue();
+    String path = "";
+    if (!directory.equals("")) {
+      path = directory + file;
+    } else {
+      path = file;
+    }
+    String query = null;
+    if (!queryProperty.equals(NIL)) {
+      query = queryProperty.getStringValue();
+    }
+    String fragment = null;
+    if (!fragmentProperty.equals(NIL)) {
+      fragment = fragmentProperty.getStringValue();
+    }
+    try {
+      URI uri = new URI(scheme, authority, path, query, fragment);
+      return uri.toString();
+    } catch (URISyntaxException e) {
+      simple_error("Failed to construct a URI: ~a", this);
+      return (String)UNREACHED;
+    }
+  }
 …
   public static LispObject truename(PathnameURL p, boolean errorIfDoesNotExist) {
+    if (p.getHost().equals(NIL)
+        || Symbol.GETF.execute(p.getHost(), PathnameURL.SCHEME, NIL).equals("file")) {
+      return Pathname.truename((Pathname)p, errorIfDoesNotExist);
+    }
     if (p.getInputStream() != null) {
       // If there is no type, query or fragment, we check to
 …
     return Pathname.doTruenameExit(p, errorIfDoesNotExist);
+  }
+  public InputStream getInputStream() {
+    InputStream result = null;
+    URL url = this.toURL();
+    try {
+      result = url.openStream();
+    } catch (IOException e) {
+      Debug.warn("Failed to get InputStream from "
+                 + "'" + getNamestring() + "'"
+                 + ": " + e);
+    }
+    return result;
+  }
+  public long getLastModified() {
+    return getURLConnection().getLastModified();
+  }
+}
+// From Pathname.init()
+        // A URL
+        // if (isValidURL(s)) {
+        //     URL url = null;
+        //     try {
+        //         url = new URL(s);
+        //     } catch (MalformedURLException e) {
+        //         Debug.assertTrue(false);
+        //     }
+        //     String scheme = url.getProtocol();
+        //     if (scheme.equals("file")) {
+        //         URI uri = null;
+        //         try {
+        //             uri = new URI(s);
+        //         } catch (URISyntaxException ex) {
+        //             error(new SimpleError("Improper URI syntax for "
+        //                             + "'" + url.toString() + "'"
+        //                             + ": " + ex.toString()));
+        //         }
+        //         String uriPath = uri.getPath();
+        //         if (null == uriPath) {
+        //                           // Under Windows, deal with pathnames containing
+        //                           // devices expressed as "file:z:/foo/path"
+        //                           uriPath = uri.getSchemeSpecificPart();
+        //                           if (uriPath == null || uriPath.equals("")) {
+        //             error(new LispError("The URI has no path: " + uri));
+        //           }
+        //         }
+        //         final File file = new File(uriPath);
+        //         String path = file.getPath();
+        //         if (uri.toString().endsWith("/") && !path.endsWith("/")) {
+        //           path += "/";
+        //         }
+        //         final Pathname p = (Pathname)Pathname.create(path);
+        //         this.setHost(p.getHost());
+        //         this.setDevice(p.getDevice());
+        //         this.setDirectory(p.getDirectory());
+        //         this.setName(p.getName());
+        //         this.setType(p.getType());
+        //         this.setVersion(p.getVersion());
+        //         return;
+        //     }
+        //     Debug.assertTrue(scheme != null);
+        //     URI uri = null;
+        //     try {
+        //         uri = url.toURI().normalize();
+        //     } catch (URISyntaxException e) {
+        //         error(new LispError("Couldn't form URI from "
+        //                             + "'" + url + "'"
+        //                             + " because: " + e));
+        //     }
+        //     String authority = uri.getAuthority();
+        // if (authority == null) {
+        //   authority = url.getAuthority();
+        //   if (authority == null) {
+        //     Debug.trace(MessageFormat.format("{0} has a null authority.", url));
+        //   }
+        // }

trunk/abcl/src/org/armedbear/lisp/Site.java

-                      r15393
+                      r15395
             return;
+        }
         URL url = Lisp.class.getResource("boot.lisp");
+        URL url = Lisp.class.getResource("boot.lisp"); // what if this was "__loader__._"?!!
         if (url != null) {
             if (!Pathname.isSupportedProtocol(url.getProtocol())) {
 …
             } else {
               Pathname p = (Pathname)Pathname.create(url);
+                p.setName(NIL);
+                p.setType(NIL);
+                p.invalidateNamestring();
+                LISP_HOME = p;
+              p.setName(NIL).setType(NIL);
+              LISP_HOME = p;
+            }
             return;
+        }
         Debug.trace("Unable to determine LISP_HOME.");
+        simple_error("Unable to determine LISP_HOME.");
+    }

trunk/abcl/src/org/armedbear/lisp/Symbol.java

r15099	r15395
3111	3111	public static final Symbol LAYOUT =
3112	3112	PACKAGE_SYS.addExternalSymbol("LAYOUT");
	3113	public static final Symbol MATCH_WILD_JAR_PATHNAME =
	3114	PACKAGE_SYS.addExternalSymbol("MATCH-WILD-JAR-PATHNAME");
3113	3115	public static final Symbol NAME =
3114	3116	PACKAGE_SYS.addExternalSymbol("NAME");

trunk/abcl/src/org/armedbear/lisp/Utilities.java

-                      r14176
+                      r15395
+    }
-    public static ZipInputStream getZipInputStream(ZipFile zipfile,
-                                                   String entryName) {
-        return Utilities.getZipInputStream(zipfile, entryName, false);
+    }
-  public static ZipInputStream getZipInputStream(ZipFile zipfile,
-                                                 String entryName,
-                                                 boolean errorOnFailure) {
-    ZipEntry zipEntry = zipfile.getEntry(entryName);
-    ZipInputStream stream = null;
-    try {
-      stream = new ZipInputStream(zipfile.getInputStream(zipEntry));
-    } catch (IOException e) {
-      if (errorOnFailure) {
-          Lisp.error(new FileError("Failed to open '" + entryName + "' in zipfile '"
-                                   + zipfile + "': " + e.getMessage()));
+      }
-      return null;
+    }
-    return stream;
+  }
-  public static InputStream getEntryAsInputStream(ZipInputStream zipInputStream,
-                                                  String entryName)
+    {
-        ZipEntry entry = getEntry(zipInputStream, entryName);
-        ByteArrayOutputStream bytes = readEntry(zipInputStream);
-        return new ByteArrayInputStream(bytes.toByteArray());
+    }
-    public static ByteArrayOutputStream readEntry(ZipInputStream stream) {
-        ByteArrayOutputStream result = new ByteArrayOutputStream();
-        int count;
-        byte buf[] = new byte[1024];
-        try {
-            while ((count = stream.read(buf, 0, buf.length)) != -1) {
-                result.write(buf, 0, count);
+            }
-        } catch (java.io.IOException e) {
-            Debug.trace("Failed to read entry from "
-                        + stream
-                        + ": " + e);
-            return null;
+        }
-        return result;
+    }
-    public static ZipEntry getEntry(ZipInputStream zipInputStream, String entryName) {
-        return Utilities.getEntry(zipInputStream, entryName, false);
+    }
-  public static ZipEntry getEntry(ZipInputStream zipInputStream,
-                                  String entryName,
-                                  boolean errorOnFailure)
+  {
-    ZipEntry entry = null;
-    do {
-      try {
-        entry = zipInputStream.getNextEntry();
-      } catch (IOException e) {
-        if (errorOnFailure) {
-          Lisp.error(new FileError("Failed to seek for "
-            + "'" + entryName + "'"
-            + " in " + zipInputStream.toString()));
+        }
-        return null;
+      }
-    } while (entry != null && !entry.getName().equals(entryName));
-    if (entry != null) {
-      return entry;
+    }
-    if (errorOnFailure) {
-      Lisp.error(new FileError("Failed to find "
-        + "'" + entryName + "'"
-        + " in " + zipInputStream.toString()));
+    }
-    return null;
+  }
-    public static final boolean checkZipFile(Pathname name) {
-        InputStream input = name.getInputStream();
-        try {
-            byte[] bytes = new byte[4];
-            int bytesRead = input.read(bytes);
-            return (bytesRead == 4
-                    && bytes[0] == 0x50
-                    && bytes[1] == 0x4b
-                    && bytes[2] == 0x03
-                    && bytes[3] == 0x04);
-        } catch (Throwable t) { // any error probably means 'no'
-            return false;
-        } finally {
-            if (input != null) {
-                try {
-                    input.close();
+                }
-                catch (IOException e) {} // ignore exceptions
+            }
+        }
+    }
-    static InputStream getInputStream(ZipFile jarFile, Pathname inner) {
-        String entryPath = inner.asEntryPath();
-        ZipEntry entry = jarFile.getEntry(entryPath);
-        if (entry == null) {
-            Debug.trace("Failed to find entry "
-                    + "'" + entryPath + "'"
-                    + " in "
-                    + "'" + jarFile.getName() + "'");
-            return null;
+        }
-        InputStream result = null;
-        try {
-            result = jarFile.getInputStream(entry);
-        } catch (IOException e) {
-            Debug.trace("Failed to open InputStream for "
-              + "'" + entryPath + "'"
-              + " in "
-              + "'" + jarFile.getName() + "'");
-            return null;
+        }
-        return result;
+    }
     static String escapeFormat(String s) {

trunk/abcl/src/org/armedbear/lisp/ZipCache.java

-                      r14627
+                      r15395
 package org.armedbear.lisp;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import org.armedbear.lisp.util.HttpHead;
 import static org.armedbear.lisp.Lisp.*;
 …
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.JarURLConnection;
 import java.net.MalformedURLException;
 …
 import java.text.SimpleDateFormat;
 import java.util.Date;
+import java.util.Enumeration;
+import java.util.Iterator;
 import java.util.HashMap;
 import java.util.Locale;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
 import java.util.zip.ZipException;
 import java.util.zip.ZipFile;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
 /**
  * A cache for all zip/jar file accesses by URL that uses the last
+ * A cache for all zip/jar file access by JarPathname that uses the last
  * modified time of the cached resource.
+ *
- * This implementation is synchronized on accesses via get().
- * Usage without multiple threads recompiling code that is then
- * re-loaded should be fine.
+ *
  * If you run into problems with caching, use
 …
  */
 public class ZipCache {
+    // To make this thread safe, we should return a proxy for ZipFile
+    // that keeps track of the number of outstanding references handed
+    // out, not allowing ZipFile.close() to succeed until that count
+    // has been reduced to 1 or the finalizer is executing.
+    // Unfortunately the relatively simple strategy of extending
+    // ZipFile via a CachedZipFile does not work because there is not
+    // a null arg constructor for ZipFile.
+    static class Entry {
+        long lastModified;
+        ZipFile file;
+    }
+    static boolean cacheEnabled = true;
+    private final static Primitive DISABLE_ZIP_CACHE = new disable_zip_cache();
+    final static class disable_zip_cache extends Primitive {
+        disable_zip_cache() {
+            super("disable-zip-cache", PACKAGE_SYS, true, "",
+                  "Disable all caching of ABCL FASLs and ZIPs.");
+  public static final boolean checkZipFile(Pathname name) {
+    InputStream input = name.getInputStream();
+    try {
+      byte[] bytes = new byte[4];
+      int bytesRead = input.read(bytes);
+      return bytesRead == 4 && bytes[0] == 80 && bytes[1] == 75 && bytes[2] == 3 && bytes[3] == 4;
+    } catch (Throwable t) {
+      // any error probably means 'no'
+      return false;
+    } finally {
+      if (input != null) {
+        try {
+          input.close();
+        } catch (IOException e) {
+        } // ignore exceptions
+      }
+    }
+  }
+  static InputStream getInputStream(ZipFile jarFile, String entryPath) {
+    ZipEntry entry = jarFile.getEntry(entryPath);
+    if (entry == null) {
+      Debug.trace("Failed to find entry " + "'" + entryPath + "'" + " in " + "'" + jarFile.getName() + "'");
+      return null;
+    }
+    InputStream result = null;
+    try {
+      result = jarFile.getInputStream(entry);
+    } catch (IOException e) {
+      Debug.trace("Failed to open InputStream for " + "'" + entryPath + "'" + " in " + "'" + jarFile.getName() + "'");
+      return null;
+    }
+    return result;
+  }
+  public static ZipInputStream getZipInputStream(ZipFile zipfile, String entryName) {
+    return ZipCache.getZipInputStream(zipfile, entryName, false);
+  }
+  public static ZipInputStream getZipInputStream(ZipFile zipfile, String entryName, boolean errorOnFailure) {
+    ZipEntry zipEntry = zipfile.getEntry(entryName);
+    ZipInputStream stream = null;
+    try {
+      stream = new ZipInputStream(zipfile.getInputStream(zipEntry));
+    } catch (IOException e) {
+      if (errorOnFailure) {
+        simple_error("Failed to open '" + entryName + "' in zipfile '" + zipfile + "': " + e.getMessage());
+      }
+      return null;
+    }
+    return stream;
+  }
+  public static ByteArrayOutputStream readEntry(ZipInputStream stream) {
+    ByteArrayOutputStream result = new ByteArrayOutputStream();
+    int count;
+    byte[] buf = new byte[1024]; // What's a decent buffer size?
+    try {
+      while ((count = stream.read(buf, 0, buf.length)) != -1) {
+        result.write(buf, 0, count);
+      }
+    } catch (IOException e) {
+      Debug.trace("Failed to read entry from " + stream + ": " + e);
+      return null;
+    }
+    return result;
+  }
+  public static ZipEntry getEntry(ZipInputStream zipInputStream, String entryName) {
+    return ZipCache.getEntry(zipInputStream, entryName, false);
+  }
+  public static ZipEntry getEntry(ZipInputStream zipInputStream, String entryName, boolean errorOnFailure) {
+    ZipEntry entry = null;
+    do {
+      try {
+        entry = zipInputStream.getNextEntry();
+      } catch (IOException e) {
+        if (errorOnFailure) {
+          Lisp.error(new FileError("Failed to seek for " + "'" + entryName + "'" + " in " + zipInputStream.toString()));
+        }
+        @Override
+        public LispObject execute() {
+            ZipCache.disable();
+            return T;
+        return null;
+      }
+    } while (entry != null && !entry.getName().equals(entryName));
+    if (entry != null) {
+      return entry;
+    }
+    if (errorOnFailure) {
+      Lisp.error(new FileError("Failed to find " + "'" + entryName + "'" + " in " + zipInputStream.toString()));
+    }
+    return null;
+  }
+  public static InputStream getEntryAsInputStream(ZipInputStream zipInputStream, String entryName) {
+    ZipEntry entry = getEntry(zipInputStream, entryName);
+    ByteArrayOutputStream bytes = readEntry(zipInputStream);
+    return new ByteArrayInputStream(bytes.toByteArray());
+  }
+  public static InputStream getEntryAsInputStream(PathnameJar archiveEntry) {
+    InputStream result = null;
+    if (archiveEntry.getDevice().length() > 1) {
+      simple_error("Unimplemented retrieval of InputStream from a nested jar reference");
+      return (InputStream)UNREACHED;
+      // Pathname inner = (Pathname) getDevice().cdr().car();
+      // InputStream input = ZipCache.getInputStream(jarFile, inner);
+      // ZipInputStream zipInputStream = new ZipInputStream(input);
+      // result =  ZipCache.getEntryAsInputStream(zipInputStream, entryPath);
+    } else {
+      Archive archive = ZipCache.getArchive(archiveEntry);
+      ZipFile zipFile = archive.file;
+      ZipEntry entry = archive.getEntry(archiveEntry);
+      try {
+        result = zipFile.getInputStream(entry);
+      } catch (IOException e) {
+        simple_error("Failed to get InputStream for ~a", archiveEntry);
+      }
+    }
+    return result;
+  }
+  // To make this thread safe, we should return a proxy for ZipFile
+  // that keeps track of the number of outstanding references handed
+  // out, not allowing ZipFile.close() to succeed until that count
+  // has been reduced to 1 or the finalizer is executing.
+  // Unfortunately the relatively simple strategy of extending
+  // ZipFile via a CachedZipFile does not work because there is not
+  // a null arg constructor for ZipFile.
+  static HashMap<PathnameJar, Archive> cache = new HashMap<PathnameJar, Archive>();
+  static public class Archive {
+    ZipFile file;
+    ZipInputStream inputStream;   // Unused, speculative
+    LinkedHashMap<PathnameJar, ZipEntry> entries
+      = new LinkedHashMap<PathnameJar, ZipEntry>();
+    long lastModified;
+    public ZipEntry getEntry(PathnameJar entryPathname) {
+      ZipEntry result = entries.get(entryPathname);
+      if (result != null) {
+        return result;
+      }
+      String entryPath = entryPathname.asEntryPath();
+      result = file.getEntry(entryPath);
+      if (result == null) {
+        return null;
+      }
+      // ZipFile.getEntry() will return directories when asked for
+      // files.
+      if (result.isDirectory()
+          && (!entryPathname.getName().equals(NIL)
+              || !entryPathname.getType().equals(NIL))) {
+        return null;
+      }
+      entries.put(entryPathname, result);
+      return result;
+    }
+    void populateAllEntries(PathnameJar jar) {
+      ZipFile f = file;
+      if (f.size() == entries.size()) {
+        return;
+      }
+      Enumeration<? extends ZipEntry> e = f.entries();
+      while (e.hasMoreElements()) {
+        ZipEntry entry = e.nextElement();
+        String name = entry.getName();
+        PathnameJar entryPathname
+          = (PathnameJar)PathnameJar.createEntryFromJar(jar, name);
+        entries.put(entryPathname, entry);
+      }
+    }
+  }
+  static boolean cacheEnabled = true;
+  private final static Primitive DISABLE_ZIP_CACHE = new disable_zip_cache();
+  final static class disable_zip_cache extends Primitive {
+    disable_zip_cache() {
+      super("disable-zip-cache", PACKAGE_SYS, true, "",
+            "Disable all caching of ABCL FASLs and ZIPs.");
+    }
+    @Override
+    public LispObject execute() {
+      ZipCache.disable();
+      return T;
+    }
+  }
+  static public synchronized void disable() {
+    cacheEnabled = false;
+    cache.clear();
+  }
+  synchronized public static LinkedHashMap<PathnameJar,ZipEntry> getEntries(PathnameJar jar) {
+    Archive archive = getArchive(jar);
+    archive.populateAllEntries(jar); // Very expensive for jars with large number of entries
+    return archive.entries;
+  }
+  synchronized public static Iterator<Map.Entry<PathnameJar,ZipEntry>> getEntriesIterator(PathnameJar jar) {
+    LinkedHashMap<PathnameJar,ZipEntry> entries = getEntries(jar);
+    Set<Map.Entry<PathnameJar,ZipEntry>> set = entries.entrySet();
+    return set.iterator();
+  }
+  static ZipEntry getZipEntry(PathnameJar archiveEntry) {
+    PathnameJar archiveJar = archiveEntry.getArchive();
+    Archive zip = getArchive(archiveJar);
+    ZipEntry entry = zip.getEntry(archiveEntry);
+    return entry;
+  }
+  synchronized public static Archive getArchive(PathnameJar jar) {
+    Pathname rootJar = (Pathname) jar.getRootJar();
+    LispObject innerJars = jar.getJars().cdr();
+    if (innerJars != NIL) {
+      // FIXME
+      simple_error("Currently unimplemented recursive archive: ~a" , jar);
+      return (Archive)UNREACHED;
+    }
+    if (jar.isLocalFile()) {
+      Archive cached = cache.get(jar);
+      if (cached != null) {
+        return cached;
+      }
+      File f = rootJar.getFile();
+      try {
+        Archive result = new Archive();
+        result.file = new ZipFile(f);
+        result.lastModified = f.lastModified();
+        cache.put(jar, result);
+        return result;
+      } catch (ZipException e) {
+        error(new FileError("Failed to construct ZipFile"
+                            + " because " + e,
+                            Pathname.makePathname(f)));
+        return null;
+      } catch (IOException e) {
+        error(new FileError("Failed to contruct ZipFile"
+                            + " because " + e,
+                            Pathname.makePathname(f)));
+        return (Archive)UNREACHED;
+      }
+    } else {
+      simple_error("Unimplemented fetch of remote resource.");
+      return (Archive)UNREACHED;
+      // CachedItem e = fetchURL(jarOrEntry, false);
+      // return e;
+    }
+  }
+  // Archive archive  = cache.getArchive(jar);
+  //   // Check that the cache entry still accesses a valid ZipFile
+  //   if (entry != null) {
+  //     // Simplest way to call private ZipFile.ensureOpen()
+  //     try {
+  //       int size = archive.file.size();
+  //     } catch (IllegalStateException e) {
+  //       cache.remove(jar);
+  //       entry = null;
+  //     }
+  //   }
+  //   if (entry != null) {
+  //     if (url.getProtocol().equals("file")) {
+  //       File f = new File(url.getPath());
+  //       long current = f.lastModified();
+  //       if (current > entry.lastModified) {
+  //         try {
+  //           entry.file = new ZipFile(f);
+  //           entry.lastModified = current;
+  //         } catch (IOException e) {
+  //           Debug.trace(e.toString()); // XXX
+  //         }
+  //       }
+  //     } else if (url.getProtocol().equals("http")) {
+  //       checkRemoteLastModified();
+  //     } else {
+  //       entry = fetchURL(url, false);
+  //       zipCache.put(url, entry);
+  //     }
+  //   } else {
+  //     if (url.getProtocol().equals("file")) {
+  //       entry = new Entry();
+  //       String path = url.getPath();
+  //       if (Utilities.isPlatformWindows) {
+  //         String authority = url.getAuthority();
+  //         if (authority != null) {
+  //           path = authority + path;
+  //         }
+  //       }
+  //       File f = new File(path);
+  //       entry.lastModified = f.lastModified();
+  //       try {
+  //         entry.file = new ZipFile(f);
+  //       } catch (ZipException e) {
+  //         error(new FileError("Failed to get cached ZipFile"
+  //                             + " because " + e,
+  //                             Pathname.makePathname(f)));
+  //       } catch (IOException e) {
+  //         error(new FileError("Failed to get cached ZipFile"
+  //                             + " because " + e,
+  //                             Pathname.makePathname(f)));
+  //       }
+  //     } else {
+  //       entry = fetchURL(url, true);
+  //     }
+  //     zipCache.put(url, entry);
+  //   }
+  //   return entry.file;
+  // }
+  static final SimpleDateFormat ASCTIME
+    = new SimpleDateFormat("EEE MMM d HH:mm:ss yyyy", Locale.US);
+  static final SimpleDateFormat RFC_1036
+    = new SimpleDateFormat("EEEE, dd-MMM-yy HH:mm:ss zzz", Locale.US);
+  static final SimpleDateFormat RFC_1123
+    = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
+  static void checkRemoteLastModified (PathnameJar jarEntry) {
+    // Unfortunately, the Apple JDK under OS X doesn't do
+    // HTTP HEAD requests, instead refetching the entire
+    // resource, and I assume this is the case in all
+    // Sun-derived JVMs.  So, we use a custom HEAD
+    // implementation only looking for Last-Modified
+    // headers, which if we don't find, we give up and
+    // refetch the resource.
+    String dateString = null;
+    // try {
+    //   dateString = HttpHead.get(url, "Last-Modified");
+    // } catch (IOException ex) {
+    //   Debug.trace(ex);
+    // }
+    // Date date = null;
+    // ParsePosition pos = new ParsePosition(0);
+    // if (dateString != null) {
+    //   date = RFC_1123.parse(dateString, pos);
+    //   if (date == null) {
+    //     date = RFC_1036.parse(dateString, pos);
+    //     if (date == null)
+    //       date = ASCTIME.parse(dateString, pos);
+    //   }
+    // }
+    // if (date == null || date.getTime() > entry.lastModified) {
+    //   entry = fetchURL(url, false);
+    //   cache.put(url, entry);
+    //   }
+    //   if (date == null) {
+    //     if (dateString == null) {
+    //       Debug.trace("Failed to retrieve request header: "
+    //                   + url.toString());
+    //     } else {
+    //       Debug.trace("Failed to parse Last-Modified date: " +
+    //                   dateString);
+    //     }
+    //   }
+  }
+  // FIXME recode once local fileaccesses are working
+  static private ZipFile fetchURL(PathnameJar url, boolean useCaches) {
+    ZipFile result = null;
+    URL jarURL = null;
+    try {
+      jarURL = new URL("jar:" + url.getRootJar() + "!/");
+    } catch (MalformedURLException e) {
+      error(new LispError("Failed to form a jar: URL from "
+                          + "'" + url + "'"
+                          + " because " + e));
+    }
+    URLConnection connection = null;
+    try {
+      connection = jarURL.openConnection();
+    } catch (IOException e) {
+      error(new LispError("Failed to open "
+                          + "'" + jarURL + "'"
+                          + " with exception "
+                          + e));
+    }
+    if (!(connection instanceof JarURLConnection)) {
+      error(new LispError("Could not get a URLConnection from "
+                          + "'" + jarURL + "'"));
+    }
+    JarURLConnection jarURLConnection = (JarURLConnection) connection;
+    jarURLConnection.setUseCaches(useCaches);
+    try {
+      result = jarURLConnection.getJarFile();
+    } catch (IOException e) {
+      error(new LispError("Failed to fetch URL "
+                          + "'" + jarURLConnection + "'"
+                          + " because " + e));
+    }
+    if (cacheEnabled) {
+      Archive archive = new Archive();
+      archive.file = result;
+      archive.lastModified = jarURLConnection.getLastModified();
+      cache.put(url, archive);
+    }
+    return result;
+  }
+  // ## remove-zip-cache-entry pathname => boolean
+  private static final Primitive REMOVE_ZIP_CACHE_ENTRY = new remove_zip_cache_entry();
+  private static class remove_zip_cache_entry extends Primitive {
+    remove_zip_cache_entry() {
+      super("remove-zip-cache-entry", PACKAGE_SYS, true, "pathname");
+    }
+    @Override
+    public LispObject execute(LispObject arg) {
+      Pathname p = coerceToPathname(arg);
+      if (!(p instanceof PathnameJar)) {
+        type_error(arg, Symbol.JAR_PATHNAME);
+      }
+      boolean result = ZipCache.remove((PathnameJar)p);
+      return result ? T : NIL;
+    }
+  }
+  synchronized public static boolean remove(PathnameJar p) {
+    Archive archive = cache.get(p.getNamestring());
+    if (archive != null) {
+      try {
+        if (archive.file != null) {
+          archive.file.close();
+        }
+    }
+    static public synchronized void disable() {
+        cacheEnabled = false;
+        zipCache.clear();
+    }
+    static HashMap<URL, Entry> zipCache = new HashMap<URL, Entry>();
+    synchronized public static ZipFile get(Pathname p) {
+        return get(Pathname.makeURL(p));
+    }
+    static final SimpleDateFormat ASCTIME
+        = new SimpleDateFormat("EEE MMM d HH:mm:ss yyyy", Locale.US);
+    static final SimpleDateFormat RFC_1036
+        = new SimpleDateFormat("EEEE, dd-MMM-yy HH:mm:ss zzz", Locale.US);
+    static final SimpleDateFormat RFC_1123
+        = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
+    synchronized public static ZipFile get(final URL url) {
+        if (!cacheEnabled) {
+            if (url.getProtocol().equals("file")) {
+                File f = new File(url.getPath());
+                try {
+                    return new ZipFile(f);
+                } catch (ZipException e) {
+                    error(new FileError("Failed to construct ZipFile"
+                                        + " because " + e,
+                                        Pathname.makePathname(f)));
+                } catch (IOException e) {
+                    error(new FileError("Failed to contruct ZipFile"
+                                        + " because " + e,
+                                        Pathname.makePathname(f)));
+                }
+            } else {
+                Entry e = fetchURL(url, false);
+                return e.file;
+            }
+        }
+        Entry entry = zipCache.get(url);
+        // Check that the cache entry still accesses a valid ZipFile
+        if (entry != null) {
+            // Simplest way to call private ZipFile.ensureOpen()
+            try {
+                int size = entry.file.size();
+            } catch (IllegalStateException e) {
+                zipCache.remove(url);
+                entry = null;
+            }
+        if (archive.inputStream != null) {
+          archive.inputStream.close();
+        }
+        if (entry != null) {
+            if (url.getProtocol().equals("file")) {
+                File f = new File(url.getPath());
+                long current = f.lastModified();
+                if (current > entry.lastModified) {
+                    try {
+                        entry.file = new ZipFile(f);
+                        entry.lastModified = current;
+                    } catch (IOException e) {
+                        Debug.trace(e.toString()); // XXX
+                    }
+                }
+            } else if (url.getProtocol().equals("http")) {
+                // Unfortunately, the Apple JDK under OS X doesn't do
+                // HTTP HEAD requests, instead refetching the entire
+                // resource, and I assume this is the case in all
+                // Sun-derived JVMs.  So, we use a custom HEAD
+                // implementation only looking for Last-Modified
+                // headers, which if we don't find, we give up and
+                // refetch the resource.
+                String dateString = null;
+                try {
+                  dateString = HttpHead.get(url, "Last-Modified");
+                } catch (IOException ex) {
+                  Debug.trace(ex);
+                }
+                Date date = null;
+                ParsePosition pos = new ParsePosition(0);
+                if (dateString != null) {
+                    date = RFC_1123.parse(dateString, pos);
+                    if (date == null) {
+                        date = RFC_1036.parse(dateString, pos);
+                        if (date == null)
+                            date = ASCTIME.parse(dateString, pos);
+                    }
+                }
+                if (date == null || date.getTime() > entry.lastModified) {
+                    entry = fetchURL(url, false);
+                    zipCache.put(url, entry);
+                }
+                if (date == null) {
+                    if (dateString == null)
+                        Debug.trace("Failed to retrieve request header: "
+                                    + url.toString());
+                    else
+                        Debug.trace("Failed to parse Last-Modified date: " +
+                                    dateString);
+                }
+           } else {
+                entry = fetchURL(url, false);
+                zipCache.put(url, entry);
+            }
+        } else {
+            if (url.getProtocol().equals("file")) {
+                entry = new Entry();
+                String path = url.getPath();
+                if (Utilities.isPlatformWindows) {
+                    String authority = url.getAuthority();
+                    if (authority != null) {
+                        path = authority + path;
+                    }
+                }
+                File f = new File(path);
+                entry.lastModified = f.lastModified();
+                try {
+                    entry.file = new ZipFile(f);
+                } catch (ZipException e) {
+                    error(new FileError("Failed to get cached ZipFile"
+                                        + " because " + e,
+                                        Pathname.makePathname(f)));
+                } catch (IOException e) {
+                    error(new FileError("Failed to get cached ZipFile"
+                                        + " because " + e,
+                                        Pathname.makePathname(f)));
+                }
+            } else {
+                entry = fetchURL(url, true);
+            }
+            zipCache.put(url, entry);
+        }
+        return entry.file;
+    }
+    static private Entry fetchURL(URL url, boolean cached) {
+        Entry result = new Entry();
+        URL jarURL = null;
+        try {
+            jarURL = new URL("jar:" + url + "!/");
+        } catch (MalformedURLException e) {
+            error(new LispError("Failed to form a jar: URL from "
+                                + "'" + url + "'"
+                                + " because " + e));
+        }
+        URLConnection connection = null;
+        try {
+            connection = jarURL.openConnection();
+        } catch (IOException e) {
+            error(new LispError("Failed to open "
+                                + "'" + jarURL + "'"
+                                + " with exception "
+                                + e));
+        }
+        if (!(connection instanceof JarURLConnection)) {
+            error(new LispError("Could not get a URLConnection from "
+                                + "'" + jarURL + "'"));
+        }
+        JarURLConnection jarURLConnection = (JarURLConnection) connection;
+        jarURLConnection.setUseCaches(cached);
+        try {
+            result.file = jarURLConnection.getJarFile();
+        } catch (IOException e) {
+            error(new LispError("Failed to fetch URL "
+                                 + "'" + jarURLConnection + "'"
+                                + " because " + e));
+        }
+        result.lastModified = jarURLConnection.getLastModified();
+        return result;
+    }
+    // ## remove-zip-cache-entry pathname => boolean
+    private static final Primitive REMOVE_ZIP_CACHE_ENTRY = new remove_zip_cache_entry();
+    private static class remove_zip_cache_entry extends Primitive {
+        remove_zip_cache_entry() {
+            super("remove-zip-cache-entry", PACKAGE_SYS, true, "pathname");
+        }
+        @Override
+        public LispObject execute(LispObject arg) {
+            Pathname p = coerceToPathname(arg);
+            boolean result = ZipCache.remove(p);
+            return result ? T : NIL;
+        }
+    }
+    synchronized public static boolean remove(URL url) {
+        Entry entry = zipCache.get(url);
+        if (entry != null) {
+            try {
+                entry.file.close();
+            } catch (IOException e) {}
+            zipCache.remove(entry);
+            return true;
+        }
+        return false;
+    }
+    synchronized public static boolean remove(Pathname p) {
+        URL url = Pathname.makeURL(p);
+        if (url == null) {
+            return false;
+        }
+        return ZipCache.remove(url);
+    }
+    synchronized public static boolean remove(File f) {
+        Pathname p = Pathname.makePathname(f);
+        return ZipCache.remove(p);
+    }
+        cache.remove(p);
+        return true;
+      } catch (IOException e) {
+        simple_error("failed to close zip cache references", e);
+      }
+    }
+    return false;
+  }
+  static public long getLastModified(PathnameJar p) {
+    return 0; // FIXME
+    // JAR cases
+    // 0.  JAR from URL
+    // 1.  JAR
+    // 2.  JAR in JAR
+    // 3.  Entry in JAR
+    // 4.  Entry in JAR in JAR
+    // String entryPath = p.asEntryPath();
+    // LispObject jars = p.getDevice();
+    // if (jars.cdr().equals(NIL)) {
+    //   if (entryPath.length() == 0) {
+    //     LispObject o = jars.car();
+    //     // 0. JAR from URL
+    //     // 1. JAR
+    //     return ((Pathname)o).getLastModified();
+    //   } else {
+    //     // 3. Entry in JAR
+    //     final ZipEntry entry
+    //       = ZipCache.get((Pathname)getDevice().car()).getEntry(entryPath);
+    //     if (entry == null) {
+    //       return 0;
+    //     }
+    //     final long time = entry.getTime();
+    //     if (time == -1) {
+    //       return 0;
+    //     }
+    //     return time;
+    //   }
+    // } else {
+    //   ZipFile outerJar = ZipCache.get((Pathname)d.car());
+    //   if (entryPath.length() == 0) {
+    //     // 4.  JAR in JAR
+    //     String jarPath = ((Pathname)d.cdr()).asEntryPath();
+    //     final ZipEntry entry = outerJar.getEntry(jarPath);
+    //     final long time = entry.getTime();
+    //     if (time == -1) {
+    //       return 0;
+    //     }
+    //     return time;
+    //   } else {
+    //     // 5. Entry in JAR in JAR
+    //     String innerJarPath = ((Pathname)d.cdr()).asEntryPath();
+    //     ZipEntry entry = outerJar.getEntry(entryPath);
+    //     ZipInputStream innerJarInputStream
+    //       = ZipCache.getZipInputStream(outerJar, innerJarPath);
+    //     ZipEntry innerEntry = ZipCache.getEntry(innerJarInputStream,
+    //                                             entryPath);
+    //     long time = innerEntry.getTime();
+    //     if (time == -1) {
+    //       return 0;
+    //     }
+    //     return time;
+    //   }
+    // }
+  }
+}

trunk/abcl/src/org/armedbear/lisp/delete_file.java

-                      r15393
+                      r15395
     public LispObject execute(LispObject arg)
+    {
+        // Don't follow symlinks! We want to delete the symlink itself, not
+        // the linked-to file.
+        Pathname pathname = coerceToPathname(arg);
+        if (arg instanceof Stream)
+            ((Stream)arg)._close();
+        if (pathname instanceof LogicalPathname)
+            pathname = LogicalPathname.translateLogicalPathname((LogicalPathname)pathname);
+        if (pathname.isWild())
+            return error(new FileError("Bad place for a wild pathname.",
+                                        pathname));
+        final Pathname defaultedPathname =
+            Pathname.mergePathnames(pathname,
+                                    coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()),
+                                    NIL);
+        final String namestring = defaultedPathname.getNamestring();
+        if (namestring == null)
+            return error(new FileError("Pathname has no namestring: " + defaultedPathname.princToString(),
+                                        defaultedPathname));
+        final File file = new File(namestring);
+  ZipCache.remove(file);
+        if (file.exists()) {
+            // File exists.
+            for (int i = 0; i < 5; i++) {
+                if (file.delete())
+                    return T;
+                System.gc();
+                Thread.yield();
+            }
+            Pathname truename = (Pathname)Pathname.create(file.getAbsolutePath());
+            StringBuilder sb = new StringBuilder("Unable to delete ");
+            sb.append(file.isDirectory() ? "directory " : "file ");
+            sb.append(truename.princToString());
+            sb.append('.');
+            return error(new FileError(sb.toString(), truename));
+        } else {
+            // File does not exist.
+      // Don't follow symlinks! We want to delete the symlink itself, not
+      // the linked-to file.
+      Pathname pathname = coerceToPathname(arg);
+      if (arg instanceof Stream)
+        ((Stream)arg)._close();
+      if (pathname instanceof LogicalPathname)
+        pathname = LogicalPathname.translateLogicalPathname((LogicalPathname)pathname);
+      if (pathname.isWild())
+        return error(new FileError("Bad place for a wild pathname.",
+                                   pathname));
+      final Pathname defaultedPathname
+              = (Pathname)Pathname.mergePathnames(pathname,
+                                coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()),
+                                NIL);
+      final String namestring = defaultedPathname.getNamestring();
+      if (namestring == null)
+        return error(new FileError("Pathname has no namestring: " + defaultedPathname.princToString(),
+                                   defaultedPathname));
+      final File file = new File(namestring);
+      if (file.exists()) {
+        // File exists.
+        for (int i = 0; i < 5; i++) {
+          if (file.delete())
             return T;
+          System.gc();
+          Thread.yield();
+        }
+        Pathname truename = (Pathname)Pathname.create(file.getAbsolutePath());
+        StringBuilder sb = new StringBuilder("Unable to delete ");
+        sb.append(file.isDirectory() ? "directory " : "file ");
+        sb.append(truename.princToString());
+        sb.append('.');
+        return error(new FileError(sb.toString(), truename));
+      } else {
+        // File does not exist.
+        return T;
+      }
+    }

trunk/abcl/src/org/armedbear/lisp/probe_file.java

-                      r14921
+                      r15395
     private static final class pf_probe_file extends Primitive {
         pf_probe_file() {
             super("probe-file", "pathspec");
+            super(Symbol.PROBE_FILE, "pathspec");
+        }
         @Override
         public LispObject execute(LispObject arg)
+        {
+            return Pathname.truename(arg, false);
+          Pathname p = coerceToPathname(arg);
+          // TODO: refactor Pathname{,Jar,URL}.truename() to be non-static?
+          if (p instanceof PathnameJar) {
+            return PathnameJar.truename((PathnameJar)p, false);
+          } else if (p instanceof PathnameURL) {
+            return PathnameURL.truename((PathnameURL)p, false);
+          } else {
+            return Pathname.truename(p, false);
+          }
+        }
     };
 …
     private static class pf_truename extends Primitive {
         pf_truename() {
             super("truename", "filespec");
+            super(Symbol.TRUENAME, "filespec");
+        }
         @Override
         public LispObject execute(LispObject arg)
+        {
+            return Pathname.truename(arg, true);
+          Pathname p = coerceToPathname(arg);
+          // TODO: refactor Pathname{,Jar,URL}.truename() to be non-static?
+          if (p instanceof PathnameJar) {
+            return PathnameJar.truename((PathnameJar)p, true);
+          } else if (p instanceof PathnameURL) {
+            return PathnameURL.truename((PathnameURL)p, true);
+          } else {
+            return Pathname.truename(p, true);
+          }
+        }
     };
 …
+        {
             Pathname pathname = coerceToPathname(arg);
+            if (pathname.isWild())
+                error(new FileError("Bad place for a wild pathname.", pathname));
+            if (pathname.isWild()) {
+                error(new FileError("Cannot probe a wild pathname as a directory.", pathname));
+            }
             Pathname defaultedPathname = (Pathname)Pathname.MERGE_PATHNAMES.execute(pathname);
             File file = defaultedPathname.getFile();
 …
             Pathname pathname = coerceToPathname(arg);
             if (pathname.isWild()) {
+                error(new FileError("Bad place for a wild pathname.", pathname));
+                error(new FileError("Fundamentally unable to determine whether a wild pathname is a directory.",
+                                    pathname));
+            }
             return isDirectory(pathname);
 …
             if (wildErrorP != NIL) {
                 if (pathname.isWild()) {
+                    error(new FileError("Bad place for a wild pathname.", pathname));
+                    error(new FileError("Fundamentally to determine whether a wild pathname is a directory.",
+                                        pathname));
+                }
+            }

trunk/abcl/src/org/armedbear/lisp/unzip.java

-                      r15391
+                      r15395
     private LispObject unzipToDirectory(Pathname zipPath, Pathname dirPath) {
         if (!zipPath.isAbsolute()) {
             zipPath = Pathname.mergePathnames(zipPath,
+            zipPath = (Pathname)Pathname.mergePathnames(zipPath,
                                               coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()));
+        }
         LispObject o = Pathname.truename(zipPath, false);
+        LispObject o = Symbol.PROBE_FILE.execute(zipPath);
         if (!(o instanceof Pathname)) {
             return error(new FileError("No file found: " + zipPath, zipPath));

trunk/abcl/src/org/armedbear/lisp/zip.java

-                      r14176
+                      r15395
             ZipOutputStream out =
                 new ZipOutputStream(new FileOutputStream(zipfileNamestring));
             Pathname root = (Pathname) Pathname.truename(coerceToPathname(third));
+            Pathname root = (Pathname) Symbol.PROBE_FILE.execute(third);
             String rootPath = root.getDirectoryNamestring();
             int rootPathLength = rootPath.length();
 …
             LispObject list = second;
             while (list != NIL) {
                 Pathname pathname = (Pathname) Pathname.truename(coerceToPathname(list.car()));
+              Pathname pathname = (Pathname) Symbol.PROBE_FILE.execute(list.car());
                 String namestring = pathname.getNamestring();
                 if (namestring == null) {

trunk/abcl/test/src/org/armedbear/lisp/PathnameJarTest.java

-                      r15394
+                      r15395
 import static org.junit.Assert.*;
+public class PathnameJarTest {
+  public PathnameJarTest() {
+  }
+  @BeforeClass
+  public static void setUpClass() {
+  }
+  @AfterClass
+  public static void tearDownClass() {
+  }
+  @Before
+  public void setUp() {
+  }
+  @After
+  public void tearDown() {
+public class PathnameJarTest
+{
+  @Test
+  public void enumerate1() {
+    String s = "jar:jar:file:/a/foo.jar!/b/baz.abcl!/path/c.lisp";
+    List<String> r = PathnameJar.enumerate(s);
+    assertTrue("3 results", r.size() == 3);
+    String parts[] = {
+      "file:/a/foo.jar",
+      "b/baz.abcl!/",
+      "/path/c.lisp"
+    };
+    for (int i = 0; i < parts.length; i++) {
+      assertTrue(parts[i], r.get(i).equals(parts[i]));
+    }
+  }
   @Test
+  public void testParseJars1() {
+    String s1 = "jar:jar:file:/a/foo.jar!/b/baz.abcl!/path/c.lisp";
+    List<String> r1 = PathnameJar.enumerate(s1);
+    assertTrue(r1.size() == 3);
+    String s10 = "file:/a/foo.jar";
+    assertTrue(s10.equals(r1.get(0)));
+    String s11 = "/b/baz.abcl!/";
+    assertTrue(s11.equals(r1.get(1)));
+    String s12 = "/path/c.lisp";
+    assertTrue(s12.equals(r1.get(2)));
+  public void enumerate2() {
+    String s = "jar:jar:file:/a/foo.jar!/b/baz.abcl!/";
+    List<String> r = PathnameJar.enumerate(s);
+    assertTrue("2 results", r.size() == 2);
+    String parts[] = {
+      "file:/a/foo.jar",
+      "b/baz.abcl!/"
+    };
+    for (int i = 0; i < parts.length; i++) {
+      assertTrue(parts[i], r.get(i).equals(parts[i]));
+    }
+  }
   @Test
+  public void testParseJars10() {
+    String s1 = "jar:jar:file:/a/foo.jar!/b/baz.abcl!/";
+    List<String> r1 = PathnameJar.enumerate(s1);
+    assertTrue(r1.size() == 2);
+    String s10 = "file:/a/foo.jar";
+    assertTrue(s10.equals(r1.get(0)));
+    String s11 = "/b/baz.abcl!/";
+    assertTrue(s11.equals(r1.get(1)));
+  public void enumerate3() {
+    String s = "jar:jar:https://example.com/a/foo.jar!/b/baz.abcl!/path/c.lisp";
+    List<String> r = PathnameJar.enumerate(s);
+    assertTrue("3 results", r.size() == 3);
+    String parts[] = {
+      "https://example.com/a/foo.jar",
+      "b/baz.abcl!/",
+      "/path/c.lisp"
+    };
+    for (int i = 0; i < parts.length; i++) {
+      assertTrue(parts[i], r.get(i).equals(parts[i]));
+    }
+  }
   @Test
+  public void testParseJars2() {
+    String s1 = "jar:jar:https://example.com/a/foo.jar!/b/baz.abcl!/path/c.lisp";
+    List<String> r1 = PathnameJar.enumerate(s1);
+    assertTrue(r1.size() == 3);
+    String s10 = "https://example.com/a/foo.jar";
+    assertTrue(s10.equals(r1.get(0)));
+    String s11 = "/b/baz.abcl!/";
+    assertTrue(s11.equals(r1.get(1)));
+    String s12 = "/path/c.lisp";
+    assertTrue(s12.equals(r1.get(2)));
+  public void enumerate4() {
+    String s = "jar:jar:jar:file:/a/foo.jar!/b/baz.abcl!/log4j.jar!/MF/manifest.mf";
+    List<String> r = PathnameJar.enumerate(s);
+    assertTrue("4 results", r.size() == 4);
+    String parts[] = {
+      "file:/a/foo.jar",
+      "b/baz.abcl!/",
+      "log4j.jar!/",
+      "/MF/manifest.mf"
+    };
+    for (int i = 0; i < parts.length; i++) {
+      assertTrue(parts[i], r.get(i).equals(parts[i]));
+    }
+  }
 …
     String namestrings[] = {
       "jar:file:foo.jar!/",
+      "jar:file:/foo.jar!/",
       "jar:jar:file:foo.jar!/baz.abcl!/",
+      "jar:jar:file:foo.jar!/baz.abcl!/__loader__._"
+      "jar:jar:file:/foo.jar!/baz.abcl!/",
+      "jar:jar:file:foo.jar!/baz.abcl!/__loader__._",
+      "jar:jar:file:/foo.jar!/baz.abcl!/__loader__._",
+      "jar:jar:jar:file:a/b/foo.jar!/c/baz.zip!/log4j.jar!/MF/manifest.mf",
+      "jar:jar:jar:file:/a/b/foo.jar!/c/baz.zip!/log4j.jar!/MF/manifest.mf"
     };

trunk/abcl/test/src/org/armedbear/lisp/PathnameTest.java

-                      r15393
+                      r15395
     assertTrue(parsedNamestring.equals(namestring));
+  }
+  @Test
+  public void equality() {
+    Pathname p1 = (Pathname)Pathname.create("file://tmp/");
+    Pathname p2 = (Pathname)Pathname.create("file://tmp/");
+    boolean result = p1.equals(p2);
+    assertTrue("Java equals() for Pathname", result);
+    PathnameJar p3 = (PathnameJar)Pathname.create("jar:file:/abcl.jar!/tmp/");
+    PathnameJar p4 = (PathnameJar)Pathname.create("jar:file:/abcl.jar!/tmp/");
+    result = p3.equals(p4);
+    assertTrue("Java equals() for PathnameJar", result);
+  }
+}

Context Navigation

Legend:

trunk/abcl/src/org/armedbear/lisp/Autoload.java

trunk/abcl/src/org/armedbear/lisp/FaslClassLoader.java

trunk/abcl/src/org/armedbear/lisp/Interpreter.java

trunk/abcl/src/org/armedbear/lisp/Lisp.java

trunk/abcl/src/org/armedbear/lisp/Load.java

trunk/abcl/src/org/armedbear/lisp/Pathname.java

trunk/abcl/src/org/armedbear/lisp/PathnameJar.java

trunk/abcl/src/org/armedbear/lisp/PathnameURL.java

trunk/abcl/src/org/armedbear/lisp/Site.java

trunk/abcl/src/org/armedbear/lisp/Symbol.java

trunk/abcl/src/org/armedbear/lisp/Utilities.java

trunk/abcl/src/org/armedbear/lisp/ZipCache.java

trunk/abcl/src/org/armedbear/lisp/delete_file.java

trunk/abcl/src/org/armedbear/lisp/probe_file.java

trunk/abcl/src/org/armedbear/lisp/unzip.java

trunk/abcl/src/org/armedbear/lisp/zip.java

trunk/abcl/test/src/org/armedbear/lisp/PathnameJarTest.java

trunk/abcl/test/src/org/armedbear/lisp/PathnameTest.java

Download in other formats: