Changeset 15435

Timestamp:

10/29/20 16:54:27 (2 years ago)

Author:

Mark Evenson

Message:

Initial implementation of accessing recursive entries in local jars

SYS:CLEAR-ZIP-CACHE will clear the cache

• * *

Fix accessing remote jar contents

• * *

Speculatively fix merging remote jar pathnames

Location:

trunk/abcl/src/org/armedbear/lisp

Files:

• Cons.java (modified) (1 diff)
• JarPathname.java (modified) (2 diffs)
• Pathname.java (modified) (1 diff)
• ZipCache.java (modified) (5 diffs)

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

@@ -151 +151 @@
   }
 
+  @Override
+  public int hashCode() {
+    return this.sxhash();
+  }
+  
   @Override
   public final int sxhash()

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

@@ -343 +343 @@
 
   String getRootJarAsURLString() {
-   return
-     JarPathname.JAR_URI_PREFIX
-     + ((Pathname)getRootJar()).getNamestring()
-     + JarPathname.JAR_URI_SUFFIX;
+    return
+      JarPathname.JAR_URI_PREFIX
+      + ((URLPathname)getRootJar()).getNamestring()
+      + JarPathname.JAR_URI_SUFFIX;
   }
 
@@ -398 +398 @@
       return true;
     }
-    return super.isLocalFile();
+    return false;
   }
 

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

@@ -1720 +1720 @@
           }
         } else {
-    if (p.isLocalFile() && d.isLocalFile()) {
+    if (p.isLocalFile()) {
       result.setDevice(d.getDevice());
     } else {

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

@@ -280 +280 @@
         = (JarURLConnection) rootJarURL.openConnection();
 
-      this.root = root;
-      this.connection = connection;
+      this.root = jar;
+      this.connection = jarConnection;
       this.file = (ZipFile)connection.getJarFile();
       this.lastModified = connection.getLastModified();
@@ -413 +413 @@
       return result;
     }
-
     Pathname rootJar = (Pathname) jar.getRootJar();
     LispObject innerJars = jar.getJars().cdr();
@@ -424 +423 @@
       return getArchiveFile(jar);
     } else {
+      result = getArchiveStreamFromFile(jar);
+      cache.put(result.root, result); 
+
+      JarPathname nextArchive = new JarPathname();
+      nextArchive
+        .setDevice(new Cons(rootJar,
+                            new Cons(innerJars.car(), NIL)))
+        .setDirectory(NIL)
+        .setName(NIL)
+        .setType(NIL);
+      
+      innerJars = innerJars.cdr();
+      while (innerJars.car() != NIL) {
+        Pathname nextJarArchive = (Pathname)innerJars.car();
+
+        JarPathname nextAsEntry = new JarPathname();
+        nextAsEntry
+          .setDevice(nextArchive.getDevice())
+          .setDirectory(nextJarArchive.getDirectory())
+          .setName(nextJarArchive.getName())
+          .setType(nextJarArchive.getType());
+        // FIXME 
+        // The pathnames for subsquent entries in a PATHNAME-JAR are relative.  Should they be?
+        if (nextAsEntry.getDirectory().car().equals(Keyword.RELATIVE)) {
+          LispObject directories = nextAsEntry.getDirectory();
+          directories = directories.cdr();
+          directories = directories.push(Keyword.ABSOLUTE);
+          nextAsEntry.setDirectory(directories);
+        }
+        nextArchive.setDevice(nextArchive.getDevice().reverse().push(nextJarArchive).reverse());
+        ArchiveStream stream = (ArchiveStream) result;
+
+        ZipEntry entry = stream.getEntry(nextAsEntry);
+        if (entry == null) {
+          return null;
+        }
+        
+        InputStream inputStream = stream.getEntryAsInputStream(nextAsEntry);
+        if (inputStream == null) {
+          return null;
+        }
+        stream = new ArchiveStream(inputStream, nextArchive, entry);
+        result = stream;
+        cache.put(nextArchive, result); 
+
+        innerJars = innerJars.cdr();
+        if (innerJars.cdr().equals(NIL)
+            && (!jar.getDirectory().equals(NIL)
+                || !jar.getName().equals(NIL)
+                || !jar.getType().equals(NIL))) {
+          simple_error("Currently unimplemented retrieval of an entry in a nested pathnames");
+          return (Archive)UNREACHED;
+        }
+      }
+
+      return result;
+    }
+  }
+
+  static ArchiveStream getArchiveStreamFromFile(JarPathname p) {
       JarPathname root = new JarPathname();
-      root.setDevice(new Cons(rootJar, NIL));
+      root.setDevice(new Cons(p.getRootJar(), NIL));
+      Pathname nextJar = (Pathname)p.getJars().cdr().car();      
       ArchiveFile rootArchiveFile = (ArchiveFile)getArchiveFile(root);
 
       JarPathname innerArchive = new JarPathname();
-      Pathname nextJar = (Pathname)innerJars.car();
-      LispObject jars = list(rootJar, nextJar);
+
+      LispObject jars = list(p.getRootJar(), nextJar);
       innerArchive.setDevice(jars);
 
       JarPathname innerArchiveAsEntry = new JarPathname();
       innerArchiveAsEntry
-        .setDevice(new Cons(rootJar, NIL))
+        .setDevice(new Cons(root, NIL))
         .setDirectory(nextJar.getDirectory())
         .setName(nextJar.getName())
@@ -448 +508 @@
         return null;
       }
-      ArchiveStream stream = new ArchiveStream(inputStream, innerArchive, entry);
-      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;
-    }
-  }
+      ArchiveStream result = new ArchiveStream(inputStream, innerArchive, entry);
+      return result;
+  }
+    
+  
 
   public static Archive getArchiveURL(JarPathname jar) {
@@ -552 +604 @@
   }
 
+  // ## clear-zip-cache  => boolean
+  private static final Primitive CLEAR_ZIP_CACHE = new clear_zip_cache();
+  private static class clear_zip_cache extends Primitive { 
+    clear_zip_cache() {
+      super("clear-zip-cache", PACKAGE_SYS, true);
+    }
+    @Override
+    public LispObject execute() {
+      int size = cache.size();
+      cache.clear();
+      return size == 0 ? NIL : T;
+    }
+  }
+
   // ## remove-zip-cache-entry pathname => boolean
   private static final Primitive REMOVE_ZIP_CACHE_ENTRY = new remove_zip_cache_entry();