Changeset 15392

Timestamp:

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

Author:

Mark Evenson

Message:

Debugging Pathname transition with logical pathnames

Added LogicalPathname?.create() and LogicalPathname?()

Solved problems with getting Pathname._makePathname() to return objects of
type LogicalPathname?.

(ignore-errors (asdf:load-system :abcl/test/lisp))
(abcl-test:run-matching "logical")

TODO: refactor the creation of logical pathnames in
Pathname._makePathname() into a new LogicalPathname?._makePathname().

• * *

Used UNREACHED constant to mark non-local exits

TODO do this consistently

Location:

trunk/abcl/src/org/armedbear/lisp

Files:

• LogicalPathname.java (modified) (3 diffs)
• Pathname.java (modified) (13 diffs)
• file_error_pathname.java (modified) (1 diff)

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

@@ -47 +47 @@
     = new HashMap();
 
+  // A logical host is represented as the string that names it.
+  // (defvar *logical-pathname-translations* (make-hash-table :test 'equal))
+  public static HashTable TRANSLATIONS
+    = HashTable.newEqualHashTable(LOGICAL_PATHNAME_CHARS.length(), NIL, NIL);
+  private static final Symbol _TRANSLATIONS_
+    = exportSpecial("*LOGICAL-PATHNAME-TRANSLATIONS*", PACKAGE_SYS, TRANSLATIONS);
+
   static public boolean isValidLogicalPathname(String namestring) {
     if (!isValidURL(namestring)) {
       String host = getHostString(namestring);
       if (host != null
-       && LOGICAL_PATHNAME_TRANSLATIONS.get(new SimpleString(host)) != null) {
+       && LogicalPathname.TRANSLATIONS.get(new SimpleString(host)) != null) {
         return true;
       }
     }
     return false;
+  }
+
+  protected LogicalPathname() {
+  }
+  
+  // Used in Pathname._makePathname to indicate type for namestring 
+  public static LogicalPathname create() {
+    return new LogicalPathname();
   }
 
   public static LogicalPathname create(String namestring) {
     // parse host out then call create(host, rest);
+    LogicalPathname result = null;
     if (LogicalPathname.isValidLogicalPathname(namestring)) {
       String h = LogicalPathname.getHostString(namestring);
-      return LogicalPathname.create(h,
-                                    namestring.substring(namestring.indexOf(':') + 1));
-    }
-    return null;  // Ugh.  I bet this is gonna cause problems. Tighten entrance points
+      result
+        = LogicalPathname.create(h, namestring.substring(namestring.indexOf(':') + 1));
+      return result;
+    }
+    error(new FileError("Failed to find a valid logical Pathname host in '" + namestring + "'",
+                        NIL));  // ??? return NIL as we don't have a
+                                // PATHNAME.  Maybe signal a different
+                                // condition?
+    return (LogicalPathname)UNREACHED;
   }
 
@@ -71 +92 @@
     // This may be "too late" in the creation chain to be meaningful?
     SimpleString h = new SimpleString(host);
-    if (LOGICAL_PATHNAME_TRANSLATIONS.get(h) == null) {
+    if (LogicalPathname.TRANSLATIONS.get(h) == null) {
       // Logical pathnames are only valid when it's host exists
       String message = MessageFormat.format("'{0}' is not a defined logical host", host);
@@ -335 +356 @@
                                                 h + '"'));
                 }
-                if (Pathname.LOGICAL_PATHNAME_TRANSLATIONS.get(new SimpleString(h)) != null) {
+                if (LogicalPathname.TRANSLATIONS.get(new SimpleString(h)) != null) {
                     // A defined logical pathname host.
                     return LogicalPathname.create(h, s.substring(s.indexOf(':') + 1));

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

@@ -1077 +1077 @@
         return unreadableString(sb.toString());
     }
-    // A logical host is represented as the string that names it.
-    // (defvar *logical-pathname-translations* (make-hash-table :test 'equal))
-    public static HashTable LOGICAL_PATHNAME_TRANSLATIONS =
-      HashTable.newEqualHashTable(64, NIL, NIL);
-    private static final Symbol _LOGICAL_PATHNAME_TRANSLATIONS_ =
-      exportSpecial("*LOGICAL-PATHNAME-TRANSLATIONS*", PACKAGE_SYS,
-      LOGICAL_PATHNAME_TRANSLATIONS);
 
     public static Pathname parseNamestring(String s) {
@@ -1137 +1130 @@
         if (!isValidURL(s)) {
             String h = LogicalPathname.getHostString(s);
-            if (h != null && LOGICAL_PATHNAME_TRANSLATIONS.get(new SimpleString(h)) != null) {
+            if (h != null
+                && LogicalPathname.TRANSLATIONS.get(new SimpleString(h)) != null) {
                 // A defined logical pathname host.
                 return LogicalPathname.create(h, s.substring(s.indexOf(':') + 1));
@@ -1164 +1158 @@
             s = s.substring(s.indexOf(':') + 1);
         }
-        if (LOGICAL_PATHNAME_TRANSLATIONS.get(host) != null) {
+        if (LogicalPathname.TRANSLATIONS.get(host) != null) {
             // A defined logical pathname host.
             return LogicalPathname.create(host.getStringValue(), s);
@@ -1356 +1350 @@
         @Override
         public LispObject execute(LispObject[] args) {
-            return _makePathname(args);
+          LispObject result = _makePathname(args);
+          return result;
         }
     }
@@ -1362 +1357 @@
     // Used by the #p reader.
     public static final Pathname makePathname(LispObject args) {
-        return _makePathname(args.copyToArray());
+      return (Pathname) _makePathname(args.copyToArray());
     }
 
@@ -1378 +1373 @@
 
 
-    static final Pathname _makePathname(LispObject[] args) {
+  // ??? changed to return a LispObject, as we wish to return a
+  // meaningful Java type (Pathname for files, LogicalPathnames for you know
)
+    static final LispObject _makePathname(LispObject[] args) {
         if (args.length % 2 != 0) {
             program_error("Odd number of keyword arguments.");
@@ -1464 +1461 @@
             }
         }
-        final Pathname p;
-        final boolean logical;
+        Pathname p;
         LispObject logicalHost = NIL;
         if (host != NIL) {
@@ -1471 +1467 @@
                 logicalHost = LogicalPathname.canonicalizeStringComponent((AbstractString) host);
             }
-            if (LOGICAL_PATHNAME_TRANSLATIONS.get(logicalHost) == null) {
+            if (LogicalPathname.TRANSLATIONS.get(logicalHost) == null) {
                 // Not a defined logical pathname host -- A UNC path
                 //warning(new LispError(host.printObject() + " is not defined as a logical pathname host."));
                 p = Pathname.create();
-                logical = false;
                 p.setHost(host);
             } else { 
                 p = LogicalPathname.create();
-                logical = true;
                 p.setHost(logicalHost);
             }
@@ -1485 +1479 @@
         } else {
             p = Pathname.create();
-            logical = false;
         }
         if (device != NIL) {
-            if (logical) {
+            if (p instanceof LogicalPathname) {
                 // "The device component of a logical pathname is always :UNSPECIFIC."
                 if (device != Keyword.UNSPECIFIC) {
@@ -1498 +1491 @@
         }
         if (directory != NIL) {
-            if (logical) {
+            if (p instanceof LogicalPathname) {
                 if (directory.listp()) {
                     LispObject d = NIL;
@@ -1521 +1514 @@
         }
         if (name != NIL) {
-            if (logical && name instanceof AbstractString) {
+            if (p instanceof LogicalPathname && name instanceof AbstractString) {
               p.setName(LogicalPathname.canonicalizeStringComponent((AbstractString) name));
             } else if (name instanceof AbstractString) {
@@ -1530 +1523 @@
         }
         if (type != NIL) {
-            if (logical && type instanceof AbstractString) {
+            if (p instanceof LogicalPathname && type instanceof AbstractString) {
               p.setType(LogicalPathname.canonicalizeStringComponent((AbstractString) type));
             } else {
@@ -1539 +1532 @@
         p.setVersion(version);
         p.validateDirectory(true);
+        
         return p;
     }

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

@@ -50 +50 @@
     }
 
-    private static final file_error_pathname FILE_ERROR_PATHNAME =
-        new file_error_pathname();
+    private static final file_error_pathname FILE_ERROR_PATHNAME
+      = new file_error_pathname();
 }