Changeset 15405

Timestamp:

10/10/20 21:43:43 (3 years ago)

Author:

Mark Evenson

Message:

INCOMPLETE Implement Zip from InputStream? access

ZipCache?.Archive.getEntry() now works on pathnames relative to the
root of the Archive.

Able to retrieve the reference to the InputStream? for a nested pathname.

Now need to implement accessing entries within this reference.

TODO Rework decision to always use fully qualified pathname in the cache.

• * *

Fix Pathname.copyFrom() not to change order of DEVICE cons

Reproduce via:

#p"jar:jar:file:/var/tmp/cl-ppcre-all-2.1.1.jar!/cl-ppcre/packages.abcl!/**/*"
(namestring *)

• * *

PROBE-FILE fails for archive stream

Somewhere in the code we can construct root jar as a Pathname rather
than PathnameURL which means that the two values are not
java.lang.Object.equals(), so not matched.

TODO figure out how we are getting such a value

• * *

Start being more explicit about the truename method

• * *

Delegate cloning of device to the JAR-PATHNAME Java object

TODO PathnameXXX.createXXX() routines uniformly return object over
LispObject. Is this really necessary? It seems to work now in a kind
of "mixed" state.

Location:

trunk/abcl

Files:

• src/org/armedbear/lisp/Pathname.java (modified) (7 diffs)
• src/org/armedbear/lisp/PathnameJar.java (modified) (17 diffs)
• src/org/armedbear/lisp/PathnameURL.java (modified) (7 diffs)
• src/org/armedbear/lisp/ZipCache.java (modified) (6 diffs)
• src/org/armedbear/lisp/probe_file.java (modified) (2 diffs)
• test/src/org/armedbear/lisp/ZipTest.java (modified) (2 diffs)

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

@@ -166 +166 @@
   }
 
-  void copyFrom(Pathname p) {
+  /**
+   *
+   */
+  Pathname copyFrom(Pathname p) {
         if (p.host != NIL) {
             if (p.host instanceof SimpleString) {
@@ -183 +186 @@
             } else if (p.getDevice() instanceof Cons) {
               LispObject jars = p.getDevice();
-              jars = jars.nreverse();
-              device = NIL;
+              setDevice(NIL);
+              PathnameURL root = PathnameURL.create((Pathname)jars.car());
+              device = device.push(root);
+              jars = jars.cdr();
               while (jars.car() != NIL) {
-                Pathname jar = (Pathname) Pathname.create(((Pathname)jars.car()).getNamestring());
+                Pathname jar
+                  = (Pathname) Pathname.create(((Pathname)jars.car()).getNamestring());
                 device = device.push(jar);
                 jars = jars.cdr();
               }
+              device.nreverse();
             } else if (p.device instanceof Symbol) { // When is this the case?
                 device = p.device;
@@ -241 +248 @@
         }
     }
+    return this;
   }
 
@@ -1218 +1226 @@
         p.validateDirectory(true);
 
-        // TODO:  need to check for downcast to PathnameURL as well
+        // ???  need to check for downcast to PathnameURL as well?
         // Possibly downcast type to PathnameJar
         if (p.getDevice() instanceof Cons) {
           PathnameJar result = new PathnameJar();
-          ncoerce(p, result);
+          result
+            .copyFrom(p)
+            .setDevice(PathnameJar.makeJarDeviceFrom(p));
+          
           // sanity check that the pathname has been constructed correctly
           result.validateComponents();
@@ -1827 +1838 @@
     }
 
-    public static final LispObject truename(Pathname pathname) {
+    public static LispObject truename(Pathname pathname) {
         return truename(pathname, false);
     }
 
-    public static final LispObject truename(LispObject arg) {
+    public static LispObject truename(LispObject arg) {
         return truename(arg, false);
     }
 
-    public static final LispObject truename(LispObject arg, boolean errorIfDoesNotExist) {
+    public static LispObject truename(LispObject arg, boolean errorIfDoesNotExist) {
         final Pathname pathname = coerceToPathname(arg);
         return truename(pathname, errorIfDoesNotExist);
@@ -1844 +1855 @@
      * LispError if there are logical problems with the input.
      */
-    public static final LispObject truename(Pathname pathname,
-                                            boolean errorIfDoesNotExist) {
+    public static LispObject truename(Pathname pathname,
+            boolean errorIfDoesNotExist) {
       if (pathname == null || pathname.equals(NIL)) {  
         return doTruenameExit(pathname, errorIfDoesNotExist); 
@@ -2136 +2147 @@
   }
 
-  /** @return The representation of this pathname suitable for
-   *  referencing an entry in a Zip/JAR file 
+  /** @return The representation of the DIRECTORY/NAME/TYPE elements
+   *  of pathname suitable for referencing an entry in a Zip/JAR file.
+   *
+   *  This representation is always a relative path.
    */
   protected String asEntryPath() {

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

@@ -58 +58 @@
   protected PathnameJar() {}
 
-  public static Pathname create() {
+  public static PathnameJar create() {
     return new PathnameJar();
   }
@@ -66 +66 @@
   }
 
-  public static LispObject createFromPathname(Pathname p) {
+  public static PathnameJar createFromPathname(Pathname p) {
     if (p instanceof PathnameURL) {
       return PathnameJar.create(JAR_URI_PREFIX
@@ -77 +77 @@
                                 + JAR_URI_SUFFIX);
     } else {
-      return p;
-    }
-  }
-
-  static public LispObject createFromFile(String s) {
+      return (PathnameJar)p;
+    }
+  }
+
+  static public PathnameJar createFromFile(String s) {
     return PathnameJar.create(JAR_URI_PREFIX + "file:" + s + JAR_URI_SUFFIX);
   }
 
-  static public LispObject createEntryFromFile(String jar, String entry) {
+  static public PathnameJar createEntryFromFile(String jar, String entry) {
     return PathnameJar.create(JAR_URI_PREFIX + "file:" + jar + JAR_URI_SUFFIX + entry);
   }
 
-  static public LispObject createEntryFromJar(PathnameJar jar, String entry) {
+  static public PathnameJar createEntryFromJar(PathnameJar jar, String entry) {
     if (jar.isArchiveEntry()) {
-      return simple_error("Failed to create the entry ~a in ~a", entry, jar);
+      simple_error("Failed to create the entry ~a in ~a", entry, jar);
+      return (PathnameJar)UNREACHED;
     }
     return PathnameJar.create(jar.getNamestring() + entry);
@@ -159 +160 @@
   }
 
-  static public LispObject create(String s) {
+  static public PathnameJar create(String s) {
     if (!s.startsWith(JAR_URI_PREFIX)) {
-      return parse_error("Cannot create a PATHNAME-JAR from namestring: " + s);
+      parse_error("Cannot create a PATHNAME-JAR from namestring: " + s);
+      return (PathnameJar)UNREACHED;
     }
     
@@ -167 +169 @@
 
     if (contents == null) {
-      return parse_error("Couldn't parse PATHNAME-JAR from namestring: " + s);
+      parse_error("Couldn't parse PATHNAME-JAR from namestring: " + s);
+      return (PathnameJar)UNREACHED;
     }
     
     PathnameJar result = new PathnameJar();
 
-    LispObject rootPathname = Pathname.create(contents.get(0));
+    // Normalize the root jar to be a URL
+    String rootNamestring = contents.get(0);
+    if (!isValidURL(rootNamestring)) {
+      rootNamestring = "file:" + rootNamestring;
+    }
+
+    PathnameURL rootPathname = (PathnameURL)PathnameURL.create(rootNamestring);
 
     LispObject jars = NIL;
@@ -207 +216 @@
 
     LispObject jars = getDevice();
+
+    LispObject rootJar = getRootJar();
+    if (!(rootJar instanceof PathnameURL)) {
+        return type_error("The first element in the DEVICE component of a JAR-PATHNAME is not of expected type",
+                          rootJar,
+                          Symbol.URL_PATHNAME);
+    }
+
+    jars = jars.cdr();
+    
     while (!jars.car().equals(NIL)) {
       LispObject jar = jars.car();
@@ -221 +240 @@
     return T;
   }
-    
 
   public String getNamestring() {
     StringBuffer sb = new StringBuffer();
 
-    LispObject jars = getDevice();
+    LispObject jars = getJars();
 
     if (jars.equals(NIL) || jars.equals(Keyword.UNSPECIFIC)) { 
-      type_error("JAR-PATHNAME has bad DEVICE",
-                 jars,
-                 list(Symbol.NOT,
-                      list(Symbol.OR,
-                           list(Symbol.EQL, NIL),
-                           list(Symbol.EQL, Keyword.UNSPECIFIC))));
-      return (String)UNREACHED;
+      // type_error("JAR-PATHNAME has bad DEVICE",
+      //            jars,
+      //            list(Symbol.NOT,
+      //                 list(Symbol.OR,
+      //                      list(Symbol.EQL, NIL),
+      //                      list(Symbol.EQL, Keyword.UNSPECIFIC))));
+      return null;
     }
 
@@ -242 +260 @@
     }
 
-    LispObject root = jars.car();
+    LispObject root = getRootJar();
 
     if (root instanceof PathnameURL) {
@@ -259 +277 @@
     }
 
-    if (jars.length() > 1) {
-      LispObject innerJars = jars.cdr();
-      while (innerJars.car() != NIL) {
-        Pathname jar = (Pathname)innerJars.car();
-        Pathname p = new Pathname();
-        p.copyFrom(jar)
-         .setDevice(NIL);
-        String ns = p.getNamestring();
-        sb.append(ns)
-          .append(JAR_URI_SUFFIX);
-        innerJars = innerJars.cdr();
-      }
+    LispObject innerJars = jars.cdr();
+    while (innerJars.car() != NIL) {
+      Pathname jar = (Pathname)innerJars.car();
+      Pathname p = new Pathname();
+      p.copyFrom(jar)
+        .setDevice(NIL);
+      String ns = p.getNamestring();
+      sb.append(ns)
+        .append(JAR_URI_SUFFIX);
+      innerJars = innerJars.cdr();
     }
 
@@ -316 +332 @@
   }
 
-  public static final LispObject truename(PathnameJar pathname,
-                                          boolean errorIfDoesNotExist) {
-    PathnameJar result = pathname;
-
-    LispObject jars = pathname.getJars();
-    Pathname rootJar = (Pathname) pathname.getRootJar();
-    LispObject enclosingJars = jars.cdr();
-
-    // if (!rootJar.isLocalFile()) {
-        
-    // } 
-
+  public static LispObject truename(Pathname pathname,
+            boolean errorIfDoesNotExist) {
+    if (!(pathname instanceof PathnameJar)) {
+      return PathnameURL.truename(pathname, errorIfDoesNotExist);
+    }
     PathnameJar p = new PathnameJar();
     p.copyFrom(pathname);
-    p.setDevice(new Cons(rootJar, enclosingJars));
+
+    PathnameURL rootJar = (PathnameURL) p.getRootJar();
+    if (rootJar.isLocalFile()) {
+      LispObject trueRootJar = PathnameURL.truename(rootJar, errorIfDoesNotExist);
+      if (trueRootJar.equals(NIL)) {
+  return Pathname.doTruenameExit(rootJar, errorIfDoesNotExist);
+      }
+      LispObject otherJars = p.getJars().cdr();
+      p.setDevice(new Cons(trueRootJar, otherJars));
+    }
 
     if (!p.isArchiveEntry()) {
@@ -396 +414 @@
   }
 
-  /** List the contents of the directory */
+  /** List the contents of a directory within a JAR archive */
   static public LispObject listDirectory(PathnameJar pathname) {
     String directory = pathname.asEntryPath();
@@ -404 +422 @@
     }
 
-    // if (pathname.getDevice().cdr() instanceof Cons) {
-    //   return error(new FileError("Unimplemented directory listing of JAR within JAR.", pathname));
-    // }
-    
     if (directory.length() == 0) {
       directory = "/*";
@@ -419 +433 @@
 
     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);
@@ -430 +440 @@
       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);
@@ -469 +469 @@
         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
+        .copyFrom(pathname)
         .setDirectory(NIL)
         .setName(NIL)
@@ -499 +496 @@
       }
 
-      // 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;
     }
@@ -555 +514 @@
     return 0;
   }
+
+  static PathnameJar joinEntry(PathnameJar root, Pathname entry) {
+    PathnameJar result = new PathnameJar();
+    result
+      .copyFrom(root)
+      .setDirectory(entry.getDirectory())
+      .setName(entry.getName())
+      .setType(entry.getType()); // ??? VERSION
+    return result;
+  }
+
+  static LispObject makeDeviceFrom(PathnameJar p) {
+    PathnameJar result = new PathnameJar();
+    result.copyFrom(p);
+    Pathname rootJar = (Pathname)result.getRootJar();
+    if (!rootJar.equals(NIL)
+        && (rootJar instanceof Pathname)) {
+      rootJar = (Pathname)PathnameURL.createFromFile(rootJar);
+      result.setDevice(new Cons(rootJar, result.getJars().cdr()));
+    }
+    return result;
+  }
+
+  static LispObject makeJarDeviceFrom(Pathname p) {
+    PathnameJar result = new PathnameJar();
+    result.copyFrom(p);
+    Pathname rootJar = (Pathname)result.getRootJar();
+    // Ensure
+    if (!rootJar.equals(NIL)
+        && (rootJar instanceof Pathname)) {
+      rootJar = (Pathname)PathnameURL.createFromFile(rootJar);
+      result.setDevice(new Cons(rootJar, result.getJars().cdr()));
+    }
+    return result.getDevice();
+  }
 }

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

@@ -59 +59 @@
   }
 
+  public static PathnameURL create(Pathname p) {
+    return (PathnameURL)createFromFile((Pathname)p);
+  }
+
   public static PathnameURL create(PathnameURL p) {
     return (PathnameURL) PathnameURL.create(p.getNamestring());
@@ -71 +75 @@
   }
 
-  public static LispObject create(String s) {
+  public static LispObject createFromFile(Pathname p) {
+    String ns = "file:" + p.getNamestring();
+    return create(ns);
+  }
+
+  public static PathnameURL create(String s) {
     if (!isValidURL(s)) {
       parse_error("Cannot form a PATHNAME-URL from " + s);
@@ -84 +93 @@
       url = new URL(s);
     } catch (MalformedURLException e) {
-      return parse_error("Malformed URL in namestring '" + s + "': " + e.toString());
+      parse_error("Malformed URL in namestring '" + s + "': " + e.toString());
+      return (PathnameURL) UNREACHED;
     }
     String scheme = url.getProtocol();
@@ -92 +102 @@
         uri = new URI(s);
       } catch (URISyntaxException ex) {
-        return parse_error("Improper URI syntax for "
-                           + "'" + url.toString() + "'"
-                           + ": " + ex.toString());
+        parse_error("Improper URI syntax for "
+        + "'" + url.toString() + "'"
+        + ": " + ex.toString());
+  return (PathnameURL)UNREACHED;
       }
             
@@ -103 +114 @@
         uriPath = uri.getSchemeSpecificPart();
         if (uriPath == null || uriPath.equals("")) {
-          return parse_error("The namestring URI has no path: " + uri);
+          parse_error("The namestring URI has no path: " + uri);
+    return (PathnameURL)UNREACHED;
         }
       }
@@ -126 +138 @@
       uri = url.toURI().normalize();
     } catch (URISyntaxException e) {
-      return parse_error("Couldn't form URI from "
-                         + "'" + url + "'"
-                         + " because: " + e);
+      parse_error("Couldn't form URI from "
+      + "'" + url + "'"
+      + " because: " + e);
+      return (PathnameURL)UNREACHED;
     }
     String authority = uri.getAuthority();
@@ -265 +278 @@
   }
 
+  public static LispObject truename(Pathname p, boolean errorIfDoesNotExist) {
+    PathnameURL pathnameURL = (PathnameURL)PathnameURL.createFromFile(p);
+    return PathnameURL.truename(pathnameURL, errorIfDoesNotExist);
+  }
+
   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);
+     || Symbol.GETF.execute(p.getHost(), PathnameURL.SCHEME, NIL)
+          .equals("file")) {
+      return Pathname.truename(p, errorIfDoesNotExist);
     }
         

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

@@ -211 +211 @@
     extends Archive
   {
-    InputStream source;
+    ZipInputStream source;
+
+    // TODO wrap in a weak reference to allow JVM to possibly reclaim memory
+    LinkedHashMap<PathnameJar, ByteArrayOutputStream> contents
+      = new LinkedHashMap<PathnameJar, ByteArrayOutputStream>();
 
     public InputStream getEntryAsInputStream(PathnameJar entry) {
+      ByteArrayOutputStream bytes = contents.get(entry);
+      if (bytes != null) {
+        return new ByteArrayInputStream(bytes.toByteArray());
+      }
       return null;
     }
 
+    boolean populated = false;
+
     public ZipEntry getEntry(PathnameJar entry) {
-      return null;
-    }
-
-    void populateAllEntries() {}
+      if (!populated) {
+        populateAllEntries();
+      }
+      ZipEntry result = entries.get(entry);
+      return result;
+    }
+
+    void populateAllEntries() {
+      if (populated) {
+        return;
+      }
+      ZipEntry entry;
+      try {
+        while ((entry = source.getNextEntry()) != null) {
+          String name = entry.getName();
+          PathnameJar entryPathname
+            = (PathnameJar)PathnameJar.createEntryFromJar(root, name);
+          entries.put(entryPathname, entry);
+          ByteArrayOutputStream bytes
+            = readEntry(source);
+          contents.put(entryPathname, bytes);
+        }
+        populated = true;
+      } catch (IOException e) {
+        simple_error("Failed to read entries from zip archive", root);
+      }
+    }
 
     void close () {
@@ -323 +356 @@
       try { 
         result = file.getInputStream(zipEntry);
-      } catch (IOException e) {}
+      } catch (IOException e) {} // FIXME how to signal a meaningful error?
 
       return result;
@@ -336 +369 @@
     }
   }
-  
 
   static boolean cacheEnabled = true;
@@ -368 +400 @@
   }
 
-
   static ZipEntry getZipEntry(PathnameJar archiveEntry) {
     PathnameJar archiveJar = archiveEntry.getArchive();
@@ -376 +407 @@
   }
 
+  // ??? we assume that DIRECTORY, NAME, and TYPE components are NIL
   synchronized public static Archive getArchive(PathnameJar jar) {
-    Archive cached = cache.get(jar);
-    if (cached != null) {
-      return cached;
+    Archive result = cache.get(jar);
+    if (result != null) {
+      return result;
     }
 
@@ -392 +424 @@
       return getArchiveFile(jar);
     } else {
-      PathnameJar rootPathname = (PathnameJar)PathnameJar.createFromPathname(rootJar);
-
-      Archive current = ZipCache.getArchive(rootPathname);
-
-      // FIXME
-      //while (innerJars.car() != NIL) {
-      // TODO Finish me!
-      // Pathname next = (Pathname)innerJars.car();
-      //  String entryPath = next.asEntryPath();
-      // InputStream source;
-      // if (current instanceof ArchiveFile) {
-      //   ArchiveFile zipFile = ((ArchiveFile)current).get();
-      //   ZipEntry entry = zipFile.getEntry(entryPath);
-      //   source = zipFile.getInputStream(entry);
-      //   ArchiveStream stream = new ArchiveStream();
-      //   stream.source = source;
-      // }
-      // }
-
-      simple_error("Currently unimplemented recursive archive: ~a" , jar);
-      return (Archive)UNREACHED;
+      PathnameJar root = new PathnameJar();
+      root.setDevice(new Cons(rootJar, NIL));
+      ArchiveFile rootArchiveFile = (ArchiveFile)getArchiveFile(root);
+
+      PathnameJar innerArchive = new PathnameJar();
+      Pathname nextJar = (Pathname)innerJars.car();
+      LispObject jars = list(rootJar, nextJar);
+      innerArchive.setDevice(jars);
+
+      PathnameJar innerArchiveAsEntry = new PathnameJar();
+      innerArchiveAsEntry
+        .setDevice(new Cons(rootJar, NIL))
+        .setDirectory(nextJar.getDirectory())
+        .setName(nextJar.getName())
+        .setType(nextJar.getType());
+
+      ZipEntry entry = rootArchiveFile.getEntry(innerArchiveAsEntry);
+      if (entry == null) {
+        return null;
+      }
+      InputStream inputStream = rootArchiveFile.getEntryAsInputStream(innerArchiveAsEntry);
+      if (inputStream == null) {
+        return null;
+      }
+      ArchiveStream stream = new ArchiveStream();
+      stream.source = new ZipInputStream(inputStream);
+      stream.root = innerArchive;
+      stream.lastModified = entry.getTime();
+      result = stream;
+      cache.put(innerArchive, result); 
+      
+      innerJars = innerJars.cdr();
+      while (innerJars.car() != NIL) {
+        simple_error("Currently unimplemented nested zip archive of depth greater than two: ~a" , jar);
+        return (Archive)UNREACHED;
+      }
+
+      return result;
     }
   }

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

@@ -52 +52 @@
         public LispObject execute(LispObject arg)
         {
+    if (arg == null || arg.equals(NIL)) {
+      return NIL;
+    }
           Pathname p = coerceToPathname(arg);
+          if (p.isWild()) {
+            return error(new FileError("Cannot find the TRUENAME for a wild pathname.",
+                                       p));
+          }
           // TODO: refactor Pathname{,Jar,URL}.truename() to be non-static?
           if (p instanceof PathnameJar) {
-            return PathnameJar.truename((PathnameJar)p, false);
+            return PathnameJar.truename(p, false);
           } else if (p instanceof PathnameURL) {
-            return PathnameURL.truename((PathnameURL)p, false);
+            return PathnameURL.truename(p, false);
           } else {
             return Pathname.truename(p, false);
@@ -77 +84 @@
         {
           Pathname p = coerceToPathname(arg);
+          if (p.isWild()) {
+            return error(new FileError("Cannot find the TRUENAME for a wild pathname.",
+                                       p));
+          }
+
           // TODO: refactor Pathname{,Jar,URL}.truename() to be non-static?
           if (p instanceof PathnameJar) {
-            return PathnameJar.truename((PathnameJar)p, true);
+            return PathnameJar.truename(p, true);
           } else if (p instanceof PathnameURL) {
-            return PathnameURL.truename((PathnameURL)p, true);
+            return PathnameURL.truename(p, true);
           } else {
             return Pathname.truename(p, true);

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

@@ -20 +20 @@
   // FIXME These need to be created as part of executing the tests
   String zipFile = "/Users/evenson/work/abcl/dist/abcl-contrib.jar";
+  // created via
+  //   (require :abcl-contrib)
+  //   (asdf:load-system :asdf-jar)
+  //   (asdf-jar:package :cl-ppcre)
+  String nestedJarFile = "/var/tmp/cl-ppcre-all-2.1.1.jar";
   PathnameJar zip;
-  String nestedJarFile = "/var/tmp/cl-ppcre-2.1.1.jar";
   PathnameJar nestedJar;
 
@@ -61 +65 @@
   }
 
+  @Test
+  public void getNestedJar() {
+    String nestedNamestring = "jar:jar:file:/var/tmp/cl-ppcre-all-2.1.1.jar!/cl-ppcre/packages.abcl!/";
+    PathnameJar nested = (PathnameJar)PathnameJar.create(nestedNamestring);
+    ZipCache.Archive archive = ZipCache.getArchive(nested);
+    assertTrue("Able to retrieve nested jar archive",
+               !archive.equals(null));
+  }
 
-  @Test
-  public void nestedJar() {
-    String nestedNamestring = "jar:jar:file:/var/tmp/cl-ppcre-2.1.1.jar!/cl-ppcre/packages.abcl!/__loader__._";
-    Pathname nested = (Pathname)PathnameJar.create(nestedNamestring);
+  //  @Test
+  public void getNestedJarEntry() {
+    String nestedNamestring = "jar:jar:file:/var/tmp/cl-ppcre-all-2.1.1.jar!/cl-ppcre/packages.abcl!/__loader__._";
   }
-  
+