Changeset 15393


Ignore:
Timestamp:
10/10/20 21:43:24 (3 years ago)
Author:
Mark Evenson
Message:

INCOMPLETE Hook up implementation of PathnameJar? and PathnameURL

Current problem:

working through getting TRUENAME working, Lisp.coerceToPathname()
always returns a Pathname even if it creates a JarPathname??

Location:
trunk/abcl
Files:
4 added
11 edited

Legend:

Unmodified
Added
Removed

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

    r15391 r15393  
    106106      final LispThread thread = LispThread.currentThread();
    107107
    108       Pathname name = Pathname.create(resourceName.substring("org/armedbear/lisp/".length()));
     108      Pathname name = (Pathname)Pathname.create(resourceName.substring("org/armedbear/lisp/".length()));
    109109      LispObject truenameFasl = Symbol.LOAD_TRUENAME_FASL.symbolValue(thread);
    110110      LispObject truename = Symbol.LOAD_TRUENAME.symbolValue(thread);

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

    r15391 r15393  
    331331                    if (i + 1 < args.length) {
    332332                        if (arg.equals("--load"))
    333                             Load.load(Pathname.mergePathnames(Pathname.create(args[i + 1]),
     333                          Load.load(Pathname.mergePathnames((Pathname)Pathname.create(args[i + 1]),
    334334                                    checkPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.getSymbolValue())),
    335335                                      false, false, true);

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

    r15391 r15393  
    8787    public byte[] getFunctionClassBytes(String name) {
    8888        Pathname pathname
    89             = Pathname.create(name.substring("org/armedbear/lisp/".length())
     89          = (Pathname)Pathname.create(name.substring("org/armedbear/lisp/".length())
    9090                    + "." + Lisp._COMPILE_FILE_CLASS_EXTENSION_.symbolValue().getStringValue());
    9191        return readFunctionBytes(pathname);
    … …  
    327327            jcl.addURL(((Pathname) jar).toURL());
    328328        } else if (jar instanceof AbstractString) {
    329             jcl.addURL(Pathname.create(jar.toString()).toURL());
     329          jcl.addURL(((Pathname)Pathname.create(jar.toString())).toURL());
    330330        } else {
    331331            error(new TypeError(jar + " must be a pathname designator"));

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

    r15391 r15393  
    13591359  public static final LispObject loadCompiledFunction(final String namestring)
    13601360  {
    1361       Pathname name = Pathname.create(namestring);
     1361    Pathname name = (Pathname)Pathname.create(namestring);
    13621362      byte[] bytes = readFunctionBytes(name);
    13631363      if (bytes != null)

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

    r15391 r15393  
    5858    {
    5959        final LispThread thread = LispThread.currentThread();
    60         return load(Pathname.create(filename),
     60        return load((Pathname)Pathname.create(filename),
    6161                    Symbol.LOAD_VERBOSE.symbolValue(thread) != NIL,
    6262                    Symbol.LOAD_PRINT.symbolValue(thread) != NIL,
    … …  
    185185                    + COMPILE_FILE_INIT_FASL_TYPE;
    186186            }
    187             if (!((mergedPathname = Pathname.create(n)) instanceof Pathname)) {
     187            if (!((mergedPathname = (Pathname)Pathname.create(n)) instanceof Pathname)) {
    188188              return error(new FileError((MessageFormat.format("Failed to address JAR-PATHNAME truename {0} for name {1}", truename.princToString(), name)), truename));
    189189            }
    … …  
    294294        Pathname pathname = null;
    295295        Pathname truename = null;
    296         pathname = Pathname.create(filename);
     296        pathname = (Pathname)Pathname.create(filename);
    297297        LispObject bootPath = Site.getLispHome();
    298298        Pathname mergedPathname;
    … …  
    325325            }               
    326326            if (!bootPath.equals(NIL)) {
    327                 Pathname urlPathname = Pathname.create(url);
     327              Pathname urlPathname = (Pathname)Pathname.create(url);
    328328                loadableFile = findLoadableFile(urlPathname);
    329329                truename = (Pathname)Pathname.truename(loadableFile);
    … …  
    340340        if (truename != null
    341341            && truename.getType().princToString().equals(COMPILE_FILE_TYPE) && Utilities.checkZipFile(truename))  {
    342             Pathname init = Pathname.create(truename.getNamestring());
     342          Pathname init = (Pathname)Pathname.create(truename.getNamestring());
    343343            init.setType(COMPILE_FILE_INIT_FASL_TYPE);
    344344            init.setName(new SimpleString("__loader__"));
    … …  
    528528                    truePathname = Pathname.create((Pathname)truename);
    529529                } else if (truename instanceof AbstractString) {
    530                     truePathname = Pathname.create(truename.getStringValue());
     530                  truePathname = (Pathname)Pathname.create(truename.getStringValue());
    531531                } else {
    532532                    Debug.assertTrue(false);

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

    r15392 r15393  
    7272    return new LogicalPathname();
    7373  }
     74
     75  public static LogicalPathname create(LogicalPathname p) {
     76    Pathname pathname = new Pathname();
     77    pathname.copyFrom(p);
     78    LogicalPathname result = new LogicalPathname();
     79    Pathname.ncoerce(pathname, result);
     80    return result;
     81  }
     82
     83
    7484
    7585  public static LogicalPathname create(String namestring) {

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

    r15392 r15393  
    5858  }
    5959
    60   public static Pathname create(String s) {
     60  public static LispObject create(String s) {
    6161    // TODO distinguish between logical hosts and schemes for URLs
    6262    // which we can meaningfully parse.
    … …  
    7373  }
    7474
    75   public static Pathname create(URL url) {
     75  public static LispObject create(URL url) {
    7676    return new Pathname(url);
    7777  }
    7878
    79   public static Pathname create(URI uri) {
     79  public static LispObject create(URI uri) {
    8080    return new Pathname(uri);
    8181  }
    … …  
    181181    protected Pathname() {}
    182182
     183  private Pathname(Pathname p) {
    183184    /** Copy constructor which shares no structure with the original. */
    184     private Pathname(Pathname p) {
     185      copyFrom(p);
     186    }
     187
     188  /**
     189   *  Coerces Pathname types by copying structure
     190   */
     191  static public LispObject ncoerce(Pathname orig, Pathname dest) {
     192    dest.setHost(orig.getHost());
     193    dest.setDevice(orig.getDevice());
     194    dest.setDirectory(orig.getDirectory());
     195    dest.setName(orig.getName());
     196    dest.setType(orig.getType());
     197    dest.setVersion(orig.getVersion());
     198
     199    return dest;
     200  }
     201
     202  void copyFrom(Pathname p) {
    185203        if (p.host != NIL) {
    186204            if (p.host instanceof SimpleString) {
    … …  
    340358            setDevice(new SimpleString(s.substring(shareIndex + 1, dirIndex)));
    341359
    342             Pathname p = Pathname.create(s.substring(dirIndex));
     360            Pathname p = (Pathname)Pathname.create(s.substring(dirIndex));
    343361            setDirectory(p.getDirectory());
    344362            setName(p.getName());
    … …  
    362380                jar = "jar:file:" + s.substring(i + jarSeparator.length());
    363381                s = s.substring("jar:".length(), i + jarSeparator.length());
    364                 Pathname p = Pathname.create(s);
     382                Pathname p = (Pathname)Pathname.create(s);
    365383                jars = jars.push(p.getDevice().car());
    366384            }
    … …  
    389407                        // We allow "jar:file:baz.jar!/" to construct a relative
    390408                        // path for jar files, so MERGE-PATHNAMES means something.
    391                         jarPathname = Pathname.create(uri.getSchemeSpecificPart());
     409                      jarPathname = (Pathname)Pathname.create(uri.getSchemeSpecificPart());
    392410                    } else {
    393                         jarPathname = Pathname.create((new File(path)).getPath());
     411                      jarPathname = (Pathname)Pathname.create((new File(path)).getPath());
    394412                    }
    395413                } else {
    396                     jarPathname = Pathname.create("");
     414                  jarPathname = (Pathname)Pathname.create("");
    397415                }
    398416                jars = jars.push(jarPathname);
    … …  
    401419                try {
    402420                    url = new URL(jar.substring("jar:".length(), jar.length() - 2));
    403                     Pathname p = Pathname.create(url);
     421                    Pathname p = (Pathname)Pathname.create(url);
    404422                    jars = jars.push(p);
    405423                } catch (MalformedURLException e) {
    … …  
    427445                                    + ex.getMessage()));
    428446            }
    429             Pathname d = Pathname.create(url);
     447            Pathname d = (Pathname)Pathname.create(url);
    430448            if (getDevice() instanceof Cons) {
    431449                LispObject[] jars = d.copyToArray();
    … …  
    436454            }
    437455            s = "/" + s.substring(separatorIndex + jarSeparator.length());
    438             Pathname p = Pathname.create("file:" + s); // Use URI escaping rules
     456            Pathname p = (Pathname)Pathname.create("file:" + s); // Use URI escaping rules
    439457            setDirectory(p.getDirectory());
    440458            setName(p.getName());
    … …  
    477495                  path += "/";
    478496                }
    479                 final Pathname p = Pathname.create(path);
     497                final Pathname p = (Pathname)Pathname.create(path);
    480498                this.setHost(p.getHost());
    481499                this.setDevice(p.getDevice());
    … …  
    529547                setHost(getHost().push(new SimpleString(fragment)));
    530548            }
    531             Pathname p = Pathname.create(path != null ? path : "");
     549            Pathname p = (Pathname)Pathname.create(path != null ? path : "");
    532550
    533551            setDirectory(p.getDirectory());
    … …  
    699717
    700718    public String getNamestring() {
    701         if (namestring != null) {
    702             return namestring;
    703         }
     719        // if (namestring != null) {
     720        //     return namestring;
     721        // }
     722     
     723      // this makes no sense ???
    704724        if (getName() == NIL && getType() != NIL) {
    705725            Debug.assertTrue(namestring == null);
    … …  
    10791099
    10801100    public static Pathname parseNamestring(String s) {
    1081         return Pathname.create(s);
     1101      return (Pathname)Pathname.create(s);
    10821102    }
    10831103
    … …  
    11251145    }
    11261146
    1127     public static Pathname parseNamestring(AbstractString namestring) {
     1147    public static LispObject parseNamestring(AbstractString namestring) {
    11281148        // Check for a logical pathname host.
    11291149        String s = namestring.getStringValue();
    … …  
    13691389            return null;
    13701390        }
    1371         return Pathname.create(namestring);
     1391        return (Pathname)Pathname.create(namestring);
    13721392    }
    13731393
    … …  
    17051725                        namestring = namestring.substring(0, namestring.lastIndexOf("!/") + 2)
    17061726                                 + entry.getName();
    1707                         Pathname p = Pathname.create(namestring);
     1727                        Pathname p = (Pathname)Pathname.create(namestring);
    17081728                        result = new Cons(p, result);
    17091729                    }
    … …  
    17371757                            }
    17381758                            URI pathURI = (new File(path)).toURI();
    1739                             p = Pathname.create(pathURI);
     1759                            p = (Pathname)Pathname.create(pathURI);
    17401760                            result = new Cons(p, result);
    17411761                        }
    … …  
    18191839                            namestring = namestring.substring(0, namestring.lastIndexOf("!/") + 2)
    18201840                                + entry.getName();
    1821                             Pathname p = Pathname.create(namestring);
     1841                            Pathname p = (Pathname)Pathname.create(namestring);
    18221842                            result = new Cons(p, result);
    18231843                        }
    … …  
    18411861                            namestring = namestring.substring(0, namestring.lastIndexOf("!/") + 2)
    18421862                                + entry.getName();
    1843                             Pathname p = Pathname.create(namestring);
     1863                            Pathname p = (Pathname)Pathname.create(namestring);
    18441864                            result = new Cons(p, result);
    18451865                        }
    … …  
    22512271                                       pathname));
    22522272        }
     2273        if (pathname instanceof PathnameJar) {
     2274          return truename((PathnameJar)pathname, errorIfDoesNotExist);
     2275        }
     2276        if (pathname instanceof PathnameURL) {
     2277          return truename((PathnameURL)pathname, errorIfDoesNotExist);
     2278        }
    22532279        if (!(pathname.isJar() || pathname.isURL())) {
    22542280            Pathname result
    … …  
    22622288                } else {
    22632289                    try {
    2264                         result = Pathname.create(file.getCanonicalPath());
     2290                      result = (Pathname)Pathname.create(file.getCanonicalPath());
    22652291                    } catch (IOException e) {
    22662292                        return error(new FileError(e.getMessage(), pathname));
    … …  
    22802306                  && Symbol.GETF.execute(pathname.getHost(), QUERY, NIL) == NIL
    22812307                  && Symbol.GETF.execute(pathname.getHost(), FRAGMENT, NIL) == NIL) {
    2282                 Pathname p = Pathname.create(pathname.getNamestring() + "/");
     2308                Pathname p = (Pathname)Pathname.create(pathname.getNamestring() + "/");
    22832309                if (p.getInputStream() != null) {
    22842310                  return p;
    … …  
    23752401    }
    23762402   
    2377     static private LispObject doTruenameExit(Pathname pathname, boolean errorIfDoesNotExist) {
     2403    static LispObject doTruenameExit(Pathname pathname, boolean errorIfDoesNotExist) {
    23782404        if (errorIfDoesNotExist) {
    23792405            StringBuilder sb = new StringBuilder("The file ");
    … …  
    27992825                }
    28002826            }
    2801             return Pathname.create(namestring);
     2827            return (Pathname)Pathname.create(namestring);
    28022828        } catch (IOException e) {
    28032829            error(new LispError(e.getMessage()));

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

    r15391 r15393  
    5858                LISP_HOME = NIL;
    5959            } else {
    60                 Pathname p = Pathname.create(url);
     60              Pathname p = (Pathname)Pathname.create(url);
    6161                p.setName(NIL);
    6262                p.setType(NIL);

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

    r15391 r15393  
    7878                Thread.yield();
    7979            }
    80             Pathname truename = Pathname.create(file.getAbsolutePath());
     80            Pathname truename = (Pathname)Pathname.create(file.getAbsolutePath());
    8181            StringBuilder sb = new StringBuilder("Unable to delete ");
    8282            sb.append(file.isDirectory() ? "directory " : "file ");

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

    r15391 r15393  
    2929        System.out.println(e.getMessage());
    3030    }
    31     Pathname pathname = Pathname.create(url);
     31    Pathname pathname = (Pathname)Pathname.create(url);
    3232    assertNotNull(pathname);
    3333    assertNotNull(pathname.getNamestring());
    … …  
    6060  @Test
    6161  public void copyConstructor() {
    62       Pathname orig = Pathname.create("/a/b/c/d/e/foo.lisp");
    63       Pathname copy = Pathname.create(orig.getNamestring());
    64       assertTrue(orig.getNamestring().equals(copy.getNamestring()));
     62    Pathname orig = (Pathname)Pathname.create("/a/b/c/d/e/foo.lisp");
     63    Pathname copy = (Pathname)Pathname.create(orig.getNamestring());
     64    assertTrue(orig.getNamestring().equals(copy.getNamestring()));
    6565  }
    6666
    6767  @Test
    6868  public void mergePathnames1() {
    69       Pathname p = Pathname.create("a/b/c/d/foo.lisp");
    70       Pathname d = Pathname.create("/foo/bar/there");
    71       Pathname r = Pathname.mergePathnames(p, d);
    72       String s = r.getNamestring();
    73       assertTrue(s.equals("/foo/bar/a/b/c/d/foo.lisp"));
     69    Pathname p = (Pathname)Pathname.create("a/b/c/d/foo.lisp");
     70    Pathname d = (Pathname)Pathname.create("/foo/bar/there");
     71    Pathname r = (Pathname)Pathname.mergePathnames(p, d);
     72    String s = r.getNamestring();
     73    assertTrue(s.equals("/foo/bar/a/b/c/d/foo.lisp"));
    7474  }
    7575
    7676  @Test
    7777  public void mergePathnames2() {
    78       Pathname p = Pathname.create("/a/b/c/d/foo.lisp");
    79       Pathname d = Pathname.create("/foo/bar/there");
    80       Pathname r = Pathname.mergePathnames(p, d);
    81       assertTrue(r.getNamestring().equals("/a/b/c/d/foo.lisp"));
     78    Pathname p = (Pathname)Pathname.create("/a/b/c/d/foo.lisp");
     79    Pathname d = (Pathname)Pathname.create("/foo/bar/there");
     80    Pathname r = (Pathname)Pathname.mergePathnames(p, d);
     81    assertTrue(r.getNamestring().equals("/a/b/c/d/foo.lisp"));
    8282  }
    8383
    … …  
    8888      args = args.push(new SimpleString("abcl-tmp"));
    8989      args = args.nreverse();
    90       Pathname p = Pathname.makePathname(args);
    91       Pathname d = Pathname.create("/foo/bar.abcl");
    92       Pathname r = Pathname.mergePathnames(p, d);
     90      Pathname p = (Pathname)Pathname.makePathname(args);
     91      Pathname d = (Pathname)Pathname.create("/foo/bar.abcl");
     92      Pathname r = (Pathname)Pathname.mergePathnames(p, d);
    9393      assertTrue(r.getNamestring().equals("/foo/bar.abcl-tmp"));
    9494  }
    … …  
    9696  @Test
    9797  public void mergePathnames4() {
    98       Pathname p = Pathname.create("jar:file:foo.jar!/bar.abcl");
    99       Pathname d = Pathname.create("/a/b/c/");
    100       Pathname r = Pathname.mergePathnames(p, d);
    101       String s = r.getNamestring();
    102       assertTrue(s.equals("jar:file:/a/b/c/foo.jar!/bar.abcl"));
     98    Pathname p = (Pathname)Pathname.create("jar:file:foo.jar!/bar.abcl");
     99    Pathname d = (Pathname)Pathname.create("/a/b/c/");
     100    Pathname r = (Pathname)Pathname.mergePathnames(p, d);
     101    String s = r.getNamestring();
     102    assertTrue(s.equals("jar:file:/a/b/c/foo.jar!/bar.abcl"));
    103103  }
    104104  @Test
    105105  public void constructorFileDirectory() {
    106     Pathname p = Pathname.create("file://tmp/");
     106    Pathname p = (Pathname)Pathname.create("file://tmp/");
    107107    assertTrue(p.getNamestring().endsWith("/"));
    108108  }
    109109  @Test
    110     public void constructorFileWindowsDevice() {
    111     Pathname p = Pathname.create("file:c://tmp/");
     110  public void constructorFileWindowsDevice() {
     111    Pathname p = (Pathname)Pathname.create("file:c://tmp/");
    112112    LispObject device = p.getDevice();
    113113    if (Utilities.isPlatformWindows) {
    … …  
    115115    }
    116116  }
     117  // Necessary for ASDF output translations to work
     118  @Test
     119  public void wildInferiorsJars() {
     120    String namestring = "jar:file:/**/*.jar!/**/*.*";
     121    Pathname p = (Pathname)Pathname.create(namestring);
     122    String parsedNamestring = p.getNamestring();
     123    assertTrue(parsedNamestring.equals(namestring));
     124  }
    117125}

  • trunk/abcl/test/src/org/armedbear/lisp/UtilitiesTest.java

    r15391 r15393  
    4242  public void getZipInputStreamZipEntry() throws FileNotFoundException, IOException {
    4343      JarFile jar = new JarFile(zipFile);
    44       Pathname pathname = Pathname.create("a/b/bar.abcl");
     44      Pathname pathname = (Pathname)Pathname.create("a/b/bar.abcl");
    4545      InputStream entryInputStream = Utilities.getInputStream(jar, pathname);
    4646      assertNotNull(entryInputStream);
Note: See TracChangeset for help on using the changeset viewer.