Changeset 15408

Timestamp:

10/14/20 07:07:14 (2 years ago)

Author:

Mark Evenson

Message:

Refactor pathname java hierarchy to reflect lisp hierarchy

JarPathname? instead of PathnameJar?, usw. correcting for my dyslexia.

Location:

trunk/abcl

Files:

• src/org/armedbear/lisp/JarPathname.java (added)
• src/org/armedbear/lisp/JavaClassLoader.java (modified) (1 diff)
• src/org/armedbear/lisp/Load.java (modified) (2 diffs)
• src/org/armedbear/lisp/Pathname.java (modified) (16 diffs)
• src/org/armedbear/lisp/PathnameJar.java (deleted)
• src/org/armedbear/lisp/PathnameURL.java (deleted)
• src/org/armedbear/lisp/Site.java (modified) (1 diff)
• src/org/armedbear/lisp/URLPathname.java (added)
• src/org/armedbear/lisp/ZipCache.java (modified) (18 diffs)
• src/org/armedbear/lisp/delete_file.java (modified) (1 diff)
• src/org/armedbear/lisp/probe_file.java (modified) (2 diffs)
• test/src/org/armedbear/lisp/JarPathnameTest.java (added)
• test/src/org/armedbear/lisp/PathnameJarTest.java (deleted)
• test/src/org/armedbear/lisp/PathnameTest.java (modified) (2 diffs)
• test/src/org/armedbear/lisp/PathnameURLTest.java (deleted)
• test/src/org/armedbear/lisp/URLPathnameTest.java (added)
• test/src/org/armedbear/lisp/ZipTest.java (modified) (4 diffs)

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

@@ -338 +338 @@
             LispObject list = NIL;
             for(URL u : ((URLClassLoader) o).getURLs()) {
-                list = list.push(PathnameURL.create(u));
+                list = list.push(URLPathname.create(u));
             }
             return new Cons(new JavaObject(o), list.nreverse());

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

@@ -171 +171 @@
 
         if (ZipCache.checkZipFile(truename)) {
-          if (truename instanceof PathnameJar) {
-            truename = PathnameJar.createFromEntry((PathnameJar)truename);
+          if (truename instanceof JarPathname) {
+            truename = JarPathname.createFromEntry((JarPathname)truename);
           } else {
-            truename = PathnameJar.createFromPathname(truename);
+            truename = JarPathname.createFromPathname(truename);
           }
           Pathname loader = Pathname.create("__loader__._"); // FIXME use constants
@@ -323 +323 @@
             }                
             if (!bootPath.equals(NIL)) {
-              Pathname urlPathname = (Pathname)PathnameURL.create(url);
+              Pathname urlPathname = (Pathname)URLPathname.create(url);
               loadableFile = findLoadableFile(urlPathname);
               truename = (Pathname)Symbol.PROBE_FILE.execute(loadableFile);

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

@@ -54 +54 @@
 
   protected static Pathname create(Pathname p) {
-    if (p instanceof PathnameJar) {
-      return (PathnameJar)PathnameJar.create(p.getNamestring());
-    } else if (p instanceof PathnameURL) {
-      return (PathnameURL)PathnameURL.create(((PathnameURL)p).getNamestringAsURI());
+    if (p instanceof JarPathname) {
+      return (JarPathname)JarPathname.create(p.getNamestring());
+    } else if (p instanceof URLPathname) {
+      return (URLPathname)URLPathname.create(((URLPathname)p).getNamestringAsURI());
     } else {
       return new Pathname(p);
@@ -67 +67 @@
     // which we can meaningfully parse.
 
-    if (s.startsWith(PathnameJar.JAR_URI_PREFIX)) {
-        return PathnameJar.create(s);
+    if (s.startsWith(JarPathname.JAR_URI_PREFIX)) {
+        return JarPathname.create(s);
     }
     if (isValidURL(s)) {
-      return PathnameURL.create(s);
+      return URLPathname.create(s);
     } else {
       if (LogicalPathname.isValidLogicalPathname(s)) {
@@ -187 +187 @@
               LispObject jars = p.getDevice();
               setDevice(NIL);
-              PathnameURL root = PathnameURL.create((Pathname)jars.car());
+              URLPathname root = URLPathname.create((Pathname)jars.car());
               device = device.push(root);
               jars = jars.cdr();
@@ -318 +318 @@
         
         // A JAR file
-        if (s.startsWith(PathnameJar.JAR_URI_PREFIX)
-            && s.endsWith(PathnameJar.JAR_URI_SUFFIX)) {
-          return (PathnameJar)PathnameJar.create(s);
+        if (s.startsWith(JarPathname.JAR_URI_PREFIX)
+            && s.endsWith(JarPathname.JAR_URI_SUFFIX)) {
+          return (JarPathname)JarPathname.create(s);
         }
 
         // An entry in a JAR file
-        final int separatorIndex = s.lastIndexOf(PathnameJar.JAR_URI_SUFFIX);
-        if (separatorIndex > 0 && s.startsWith(PathnameJar.JAR_URI_PREFIX)) {
-          return (PathnameJar)PathnameJar.create(s);
+        final int separatorIndex = s.lastIndexOf(JarPathname.JAR_URI_SUFFIX);
+        if (separatorIndex > 0 && s.startsWith(JarPathname.JAR_URI_PREFIX)) {
+          return (JarPathname)JarPathname.create(s);
         }
 
@@ -332 +332 @@
         // pathname, and not a JAR file or an entry in a JAR file)
         if (isValidURL(s)) {
-          return (PathnameURL)PathnameURL.create(s);
+          return (URLPathname)URLPathname.create(s);
         }
 
@@ -507 +507 @@
                              || isURL());
             if (isURL()) {
-                LispObject scheme = Symbol.GETF.execute(getHost(), PathnameURL.SCHEME, NIL);
-                LispObject authority = Symbol.GETF.execute(getHost(), PathnameURL.AUTHORITY, NIL);
+                LispObject scheme = Symbol.GETF.execute(getHost(), URLPathname.SCHEME, NIL);
+                LispObject authority = Symbol.GETF.execute(getHost(), URLPathname.AUTHORITY, NIL);
                 Debug.assertTrue(scheme != NIL);
                 sb.append(scheme.getStringValue());
@@ -1226 +1226 @@
         p.validateDirectory(true);
 
-        // ???  need to check for downcast to PathnameURL as well?
-        // Possibly downcast type to PathnameJar
+        // ???  need to check for downcast to URLPathname as well?
+        // Possibly downcast type to JarPathname
         if (p.getDevice() instanceof Cons) {
-          PathnameJar result = new PathnameJar();
+          JarPathname result = new JarPathname();
           result
             .copyFrom(p)
-            .setDevice(PathnameJar.makeJarDeviceFrom(p));
+            .setDevice(JarPathname.makeJarDeviceFrom(p));
           
           // sanity check that the pathname has been constructed correctly
@@ -1375 +1375 @@
           LispObject result = NIL;
           if (pathname.isJar()) {
-            return PathnameJar.listDirectory((PathnameJar)pathname);
+            return JarPathname.listDirectory((JarPathname)pathname);
           }
 
@@ -1632 +1632 @@
       d = Pathname.create(defaultPathname);
     } else {
-      if (pathname instanceof PathnameJar
+      if (pathname instanceof JarPathname
           // If the defaults contain a JAR-PATHNAME, and the pathname
           // to be be merged is not a JAR-PATHNAME, does not have a
           // specified DEVICE or a specified HOST and has a NIL or
           // relative directory then the result will be a JAR-PATHNAME.
-          || (defaultPathname instanceof PathnameJar
-              && !(pathname instanceof PathnameJar)
+          || (defaultPathname instanceof JarPathname
+              && !(pathname instanceof JarPathname)
               && pathname.getHost().equals(NIL)
               && pathname.getDevice().equals(NIL)
               && (pathname.getDirectory().equals(NIL)
                   || pathname.getDirectory().car().equals(Keyword.RELATIVE)))) {
-        result = PathnameJar.create();
-      } else if (pathname instanceof PathnameURL) {
-        result = PathnameURL.create();
+        result = JarPathname.create();
+      } else if (pathname instanceof URLPathname) {
+        result = URLPathname.create();
       } else {
         result = Pathname.create();
@@ -1653 +1653 @@
         d = LogicalPathname.translateLogicalPathname((LogicalPathname) defaultPathname);
       } else {
-        if (defaultPathname instanceof PathnameJar) {
-          d = PathnameJar.create((PathnameJar)defaultPathname);
-        } else if (defaultPathname instanceof PathnameURL) {
-          d = PathnameURL.create(defaultPathname);
+        if (defaultPathname instanceof JarPathname) {
+          d = JarPathname.create((JarPathname)defaultPathname);
+        } else if (defaultPathname instanceof URLPathname) {
+          d = URLPathname.create(defaultPathname);
         } else {
           d = Pathname.create(defaultPathname);
@@ -1673 +1673 @@
           result.setDevice(p.getDevice());
         } else {
-          if (d instanceof PathnameJar
-        && p instanceof PathnameJar) {
+          if (d instanceof JarPathname
+        && p instanceof JarPathname) {
             result.setDevice(d.getDevice());
           } else { 
@@ -1686 +1686 @@
         // relative DIRECTORY, then on non-MSDOG, set its device to
         // :UNSPECIFIC.
-        if ((d instanceof PathnameJar)
-            && !(result instanceof PathnameJar)) {
+        if ((d instanceof JarPathname)
+            && !(result instanceof JarPathname)) {
           if (!Utilities.isPlatformWindows) {
             result.setDevice(Keyword.UNSPECIFIC);
@@ -1701 +1701 @@
       // default directory.  
       // if (pathname.isJar()) {
-      //   Pathname root = ((PathnameJar)result).getRootJar();
+      //   Pathname root = ((JarPathname)result).getRootJar();
         
 
@@ -2134 +2134 @@
   public boolean isLocalFile() {
     if (getHost().equals(NIL)
-        || Symbol.GETF.execute(getHost(), PathnameURL.SCHEME, NIL).equals("file")) {
+        || Symbol.GETF.execute(getHost(), URLPathname.SCHEME, NIL).equals("file")) {
       return true;
     }
@@ -2169 +2169 @@
 
   boolean isRemote() {
-    if (this instanceof PathnameURL) {
-      PathnameURL p = (PathnameURL) this;
-      LispObject scheme = Symbol.GETF.execute(p.getHost(), PathnameURL.SCHEME, NIL);
+    if (this instanceof URLPathname) {
+      URLPathname p = (URLPathname) this;
+      LispObject scheme = Symbol.GETF.execute(p.getHost(), URLPathname.SCHEME, NIL);
       if (scheme.equals(NIL)
           || p.getHost().getStringValue().equals("file")) {
@@ -2177 +2177 @@
       }
       return true;
-    } else if (this instanceof PathnameJar) {
-      Pathname root = (Pathname) ((PathnameJar)this).getRootJar();
+    } else if (this instanceof JarPathname) {
+      Pathname root = (Pathname) ((JarPathname)this).getRootJar();
       return root.isRemote();
     } else {

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

@@ -58 +58 @@
                 LISP_HOME = NIL;
             } else {
-              Pathname p = (Pathname)PathnameURL.create(url);
+              Pathname p = (Pathname)URLPathname.create(url);
               p.setName(NIL).setType(NIL);
               LISP_HOME = p;

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

@@ -165 +165 @@
   }
 
-  public static InputStream getEntryAsInputStream(PathnameJar archiveEntry) {
-    PathnameJar archiveJar = archiveEntry.getArchive();
+  public static InputStream getEntryAsInputStream(JarPathname archiveEntry) {
+    JarPathname archiveJar = archiveEntry.getArchive();
     Archive archive = ZipCache.getArchive(archiveJar);
     InputStream result = archive.getEntryAsInputStream(archiveEntry);
@@ -182 +182 @@
   // 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 HashMap<JarPathname, Archive> cache = new HashMap<JarPathname, Archive>();
 
   abstract static public class Archive {
-    PathnameJar root;
-    LinkedHashMap<PathnameJar, ZipEntry> entries
-      = new LinkedHashMap<PathnameJar, ZipEntry>();
+    JarPathname root;
+    LinkedHashMap<JarPathname, ZipEntry> entries
+      = new LinkedHashMap<JarPathname, ZipEntry>();
     long lastModified;
 
-    abstract InputStream getEntryAsInputStream(PathnameJar entry);
-    abstract ZipEntry getEntry(PathnameJar entry);
+    abstract InputStream getEntryAsInputStream(JarPathname entry);
+    abstract ZipEntry getEntry(JarPathname entry);
     abstract void populateAllEntries();
     abstract void close();
@@ -202 +202 @@
 
     // 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) {
+    LinkedHashMap<JarPathname, ByteArrayOutputStream> contents
+      = new LinkedHashMap<JarPathname, ByteArrayOutputStream>();
+
+    public InputStream getEntryAsInputStream(JarPathname entry) {
       ByteArrayOutputStream bytes = contents.get(entry);
       if (bytes != null) {
@@ -215 +215 @@
     boolean populated = false;
 
-    public ZipEntry getEntry(PathnameJar entry) {
+    public ZipEntry getEntry(JarPathname entry) {
       if (!populated) {
         populateAllEntries();
@@ -231 +231 @@
         while ((entry = source.getNextEntry()) != null) {
           String name = entry.getName();
-          PathnameJar entryPathname
-            = (PathnameJar)PathnameJar.createEntryFromJar(root, name);
+          JarPathname entryPathname
+            = (JarPathname)JarPathname.createEntryFromJar(root, name);
           entries.put(entryPathname, entry);
           ByteArrayOutputStream bytes
@@ -260 +260 @@
     JarURLConnection connection;
 
-    public ArchiveURL(PathnameJar jar)
+    public ArchiveURL(JarPathname jar)
       throws java.io.IOException
     {
@@ -289 +289 @@
     ArchiveFile() {}
 
-    public ArchiveFile(PathnameJar jar)
+    public ArchiveFile(JarPathname jar)
       throws ZipException, IOException
     {
@@ -298 +298 @@
     }
 
-    public ZipEntry getEntry(PathnameJar entryPathname) {
+    public ZipEntry getEntry(JarPathname entryPathname) {
       ZipEntry result = entries.get(entryPathname);
       if (result != null) {
@@ -332 +332 @@
         ZipEntry entry = e.nextElement();
         String name = entry.getName();
-        PathnameJar entryPathname
-          = (PathnameJar)PathnameJar.createEntryFromJar(root, name);
+        JarPathname entryPathname
+          = (JarPathname)JarPathname.createEntryFromJar(root, name);
         entries.put(entryPathname, entry);
       }
     }
 
-    InputStream getEntryAsInputStream(PathnameJar entry) {
+    InputStream getEntryAsInputStream(JarPathname entry) {
       InputStream result = null;
       ZipEntry zipEntry = getEntry(entry);
@@ -376 +376 @@
   }
 
-  synchronized public static LinkedHashMap<PathnameJar,ZipEntry> getEntries(PathnameJar jar) {
+  synchronized public static LinkedHashMap<JarPathname,ZipEntry> getEntries(JarPathname jar) {
     Archive archive = getArchive(jar);
     archive.populateAllEntries(); // Very expensive for jars with large number of entries
@@ -382 +382 @@
   }
 
-  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();
+  synchronized public static Iterator<Map.Entry<JarPathname,ZipEntry>> getEntriesIterator(JarPathname jar) {
+    LinkedHashMap<JarPathname,ZipEntry> entries = getEntries(jar);
+    Set<Map.Entry<JarPathname,ZipEntry>> set = entries.entrySet();
     return set.iterator();
   }
 
-  static ZipEntry getZipEntry(PathnameJar archiveEntry) {
-    PathnameJar archiveJar = archiveEntry.getArchive();
+  static ZipEntry getZipEntry(JarPathname archiveEntry) {
+    JarPathname archiveJar = archiveEntry.getArchive();
     Archive zip = getArchive(archiveJar);
     ZipEntry entry = zip.getEntry(archiveEntry);
@@ -396 +396 @@
 
   // ??? we assume that DIRECTORY, NAME, and TYPE components are NIL
-  synchronized public static Archive getArchive(PathnameJar jar) {
+  synchronized public static Archive getArchive(JarPathname jar) {
     Archive result = cache.get(jar);
     if (result != null) {
@@ -412 +412 @@
       return getArchiveFile(jar);
     } else {
-      PathnameJar root = new PathnameJar();
+      JarPathname root = new JarPathname();
       root.setDevice(new Cons(rootJar, NIL));
       ArchiveFile rootArchiveFile = (ArchiveFile)getArchiveFile(root);
 
-      PathnameJar innerArchive = new PathnameJar();
+      JarPathname innerArchive = new JarPathname();
       Pathname nextJar = (Pathname)innerJars.car();
       LispObject jars = list(rootJar, nextJar);
       innerArchive.setDevice(jars);
 
-      PathnameJar innerArchiveAsEntry = new PathnameJar();
+      JarPathname innerArchiveAsEntry = new JarPathname();
       innerArchiveAsEntry
         .setDevice(new Cons(rootJar, NIL))
@@ -453 +453 @@
   }
 
-  public static Archive getArchiveURL(PathnameJar jar) {
+  public static Archive getArchiveURL(JarPathname jar) {
     Pathname rootJar = (Pathname) jar.getRootJar();
 
@@ -470 +470 @@
   }
 
-  static public Archive getArchiveFile(PathnameJar jar) {
+  static public Archive getArchiveFile(JarPathname jar) {
     try {
       ArchiveFile result = new ArchiveFile(jar);
@@ -528 +528 @@
     // Replace older item in cache
     if (date == null || date.getTime() > archive.lastModified) {
-      PathnameJar root = archive.root;
+      JarPathname root = archive.root;
       Archive entry = getArchiveURL(root);
       cache.put(root, entry);
@@ -553 +553 @@
       Pathname p = coerceToPathname(arg);
       boolean result = false;
-      if (p instanceof PathnameJar) {
-        result = ZipCache.remove((PathnameJar)p);
+      if (p instanceof JarPathname) {
+        result = ZipCache.remove((JarPathname)p);
       } 
       return result ? T : NIL;
@@ -560 +560 @@
   }
       
-  synchronized public static boolean remove(PathnameJar p) {
+  synchronized public static boolean remove(JarPathname p) {
     Archive archive = cache.get(p.getNamestring());
     if (archive != null) {

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

@@ -68 +68 @@
       if (defaultedPathname.isRemote()) {
         return error(new FileError("Unable to delete remote pathnames", defaultedPathname));
-      } else if (defaultedPathname instanceof PathnameJar) {
-        PathnameJar jar = (PathnameJar)defaultedPathname;
+      } else if (defaultedPathname instanceof JarPathname) {
+        JarPathname jar = (JarPathname)defaultedPathname;
         Pathname root = (Pathname)jar.getRootJar();
         Cons jars = (Cons)jar.getJars();

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

@@ -61 +61 @@
           }
           // TODO: refactor Pathname{,Jar,URL}.truename() to be non-static?
-          if (p instanceof PathnameJar) {
-            return PathnameJar.truename(p, false);
-          } else if (p instanceof PathnameURL) {
-            return PathnameURL.truename((PathnameURL)p, false);
+          if (p instanceof JarPathname) {
+            return JarPathname.truename(p, false);
+          } else if (p instanceof URLPathname) {
+            return URLPathname.truename((URLPathname)p, false);
           } else {
             return Pathname.truename(p, false);
@@ -90 +90 @@
 
           // TODO: refactor Pathname{,Jar,URL}.truename() to be non-static?
-          if (p instanceof PathnameJar) {
-            return PathnameJar.truename(p, true);
-          } else if (p instanceof PathnameURL) {
-            return PathnameURL.truename((PathnameURL)p, true);
+          if (p instanceof JarPathname) {
+            return JarPathname.truename(p, true);
+          } else if (p instanceof URLPathname) {
+            return URLPathname.truename((URLPathname)p, true);
           } else {
             return Pathname.truename(p, true);

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

@@ -29 +29 @@
         System.out.println(e.getMessage());
     }
-    Pathname pathname = (Pathname)PathnameURL.create(url);
+    Pathname pathname = (Pathname)URLPathname.create(url);
     assertNotNull(pathname);
     assertNotNull(pathname.getNamestring());
@@ -132 +132 @@
     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/");
+    JarPathname p3 = (JarPathname)Pathname.create("jar:file:///abcl.jar!/tmp/");
+    JarPathname p4 = (JarPathname)Pathname.create("jar:file:///abcl.jar!/tmp/");
     result = p3.equals(p4);
     assertTrue("Java equals() for PathnameJar", result);

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

@@ -25 +25 @@
   //   (asdf-jar:package :cl-ppcre)
   String nestedJarFile = "/var/tmp/cl-ppcre-all-2.1.1.jar";
-  PathnameJar zip;
-  PathnameJar nestedJar;
+  JarPathname zip;
+  JarPathname nestedJar;
 
   @Before
   public void setup() {
-    zip = (PathnameJar) PathnameJar.createFromFile(zipFile);
-    nestedJar = (PathnameJar) PathnameJar.createFromFile(nestedJarFile);
+    zip = (JarPathname) JarPathname.createFromFile(zipFile);
+    nestedJar = (JarPathname) JarPathname.createFromFile(nestedJarFile);
   }
 
@@ -40 +40 @@
                archive1 instanceof ZipCache.ArchiveFile
                && ((ZipCache.ArchiveFile)archive1).file != null);
-    PathnameJar zip2
-      = (PathnameJar) PathnameJar.createFromFile(zipFile);
+    JarPathname zip2
+      = (JarPathname) JarPathname.createFromFile(zipFile);
     ZipCache.Archive archive2 = ZipCache.getArchive(zip2);
     assertTrue("Get cached ZipArchive from pathname",
@@ -53 +53 @@
   public void getEntry() {
     String entryPath = "abcl-asdf/abcl-asdf-tests.asd";
-    PathnameJar entryPathname
-      = (PathnameJar) PathnameJar.createEntryFromFile(zipFile, entryPath);
+    JarPathname entryPathname
+      = (JarPathname) JarPathname.createEntryFromFile(zipFile, entryPath);
     ZipEntry entry = ZipCache.getZipEntry(entryPathname);
     assertTrue("Getting entry from jar",
                entry.getName().equals(entryPath));
-    PathnameJar entryPathname2
-      = (PathnameJar) PathnameJar.createEntryFromFile(zipFile, entryPath);
+    JarPathname entryPathname2
+      = (JarPathname) JarPathname.createEntryFromFile(zipFile, entryPath);
     ZipEntry entry2 = ZipCache.getZipEntry(entryPathname2);
     assertTrue("Cached ZipEntry returns same object",
@@ -68 +68 @@
   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);
+    JarPathname nested = (JarPathname)JarPathname.create(nestedNamestring);
     ZipCache.Archive archive = ZipCache.getArchive(nested);
     assertTrue("Able to retrieve nested jar archive",