Changeset 15406


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

Able to OPEN, PROBE-FILE, and LOAD contents of nested jar

Pathname.mergePathname() returns a Pathname, while Pathname.truename()
returns a LispObject as it needs to be able to return NIL.

PathnameURL.truename() coerces its result to a PathnameURL if necessary.

Location:
trunk/abcl/src/org/armedbear/lisp
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r15395 r15406  
    111111     
    112112      if (truenameFasl instanceof Pathname) {
    113           return ((Pathname)Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST))
     113          return (Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST))
    114114                    .getInputStream();
    115115      } else if (truename instanceof Pathname) {
    116           return ((Pathname)Pathname.mergePathnames(name, (Pathname) truename, Keyword.NEWEST))
     116          return (Pathname.mergePathnames(name, (Pathname) truename, Keyword.NEWEST))
    117117                  .getInputStream();
    118118      } else if (!Symbol.PROBE_FILE.execute(name).equals(NIL)) {

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

    r15395 r15406  
    331331                    if (i + 1 < args.length) {
    332332                        if (arg.equals("--load"))
    333                           Load.load((Pathname)Pathname.mergePathnames((Pathname)Pathname.create(args[i + 1]),
     333                          Load.load(Pathname.mergePathnames((Pathname)Pathname.create(args[i + 1]),
    334334                                    checkPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.getSymbolValue())),
    335                                       false, false, true);
     335                                    false, false, true);
    336336
    337337                        else

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

    r15396 r15406  
    13791379      LispObject truename = Symbol.LOAD_TRUENAME.symbolValue(thread);
    13801380      if (truenameFasl instanceof Pathname) {
    1381           load = (Pathname)Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST);
     1381          load = Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST);
    13821382      } else if (truename instanceof Pathname) {
    1383           load = (Pathname)Pathname.mergePathnames(name, (Pathname) truename, Keyword.NEWEST);
     1383          load = Pathname.mergePathnames(name, (Pathname)truename, Keyword.NEWEST);
    13841384      } else {
    13851385        if (!Symbol.PROBE_FILE.execute(name).equals(NIL)) {

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

    r15400 r15406  
    154154            Pathname pathnameDefaults
    155155                = coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue());
    156             mergedPathname = (Pathname)Pathname.mergePathnames(pathname, pathnameDefaults);
     156            mergedPathname = Pathname.mergePathnames(pathname, pathnameDefaults);
    157157        }
    158158        Pathname loadableFile = findLoadableFile(mergedPathname != null ? mergedPathname : pathname);
    … …  
    171171
    172172        if (ZipCache.checkZipFile(truename)) {
    173             // String n = truename.getNamestring();
    174             // String name = Pathname.uriEncode(truename.getName().getStringValue());
    175             // if (n.startsWith("jar:")) {
    176             //     n = "jar:" + n + "!/" + name + "."
    177             //         + COMPILE_FILE_INIT_FASL_TYPE;
    178       // } else if (n.startsWith("zip:")) {
    179             //     n = "zip:" + n + "!/" + name + "."
    180             //         + COMPILE_FILE_INIT_FASL_TYPE;
    181             // } else {
    182             //     n = "jar:file:" + Pathname.uriEncode(n) + "!/" + name + "."
    183             //         + COMPILE_FILE_INIT_FASL_TYPE;
    184             // }
    185             // if (!((mergedPathname = (Pathname)Pathname.create(n)) instanceof Pathname)) {
    186             //   return error(new FileError((MessageFormat.format("Failed to address JAR-PATHNAME truename {0} for name {1}", truename.princToString(), name)), truename));
    187             // }
    188           truename = (Pathname) PathnameJar.createFromPathname(truename);
    189           Pathname loader = (Pathname)Pathname.create("__loader__._"); // FIXME use constants
     173          if (truename instanceof PathnameJar) {
     174            truename = PathnameJar.createFromEntry((PathnameJar)truename);
     175          } else {
     176            truename = PathnameJar.createFromPathname(truename);
     177          }
     178          Pathname loader = Pathname.create("__loader__._"); // FIXME use constants
    190179          mergedPathname = (Pathname)Symbol.MERGE_PATHNAMES.execute(loader, truename);
    191180
    192             LispObject initTruename = Symbol.PROBE_FILE.execute(mergedPathname);
    193             if (initTruename.equals(NIL)) {
    194                 // Maybe the enclosing JAR has been renamed?
    195                 Pathname p = Pathname.create(mergedPathname);
    196                 p.setName(Keyword.WILD);
    197                 LispObject result = Symbol.MATCH_WILD_JAR_PATHNAME.execute(p);
    198 
    199                 if (result instanceof Cons
    200                     && ((Cons)result).length() == 1
    201                     && ((Cons)result).car() instanceof Pathname) {
    202                     initTruename = (Pathname)result.car();
    203                 } else {
    204                   String errorMessage
    205                       = "Loadable FASL not found for "
    206                       + "'" + pathname.printObject() + "'"
    207                       + " in "
    208                       + "'" + mergedPathname.printObject() + "'";
    209                   if (ifDoesNotExist) {
    210                       return error(new FileError(errorMessage, mergedPathname));
    211                   } else {
    212                       Debug.trace(errorMessage);
    213                       return NIL;
    214                   }
    215                 }
    216             }
    217             truename = (Pathname)initTruename;
     181          LispObject initTruename = Symbol.PROBE_FILE.execute(mergedPathname);
     182          if (initTruename.equals(NIL)) {
     183            // Maybe the enclosing JAR has been renamed?
     184            Pathname p = Pathname.create(mergedPathname);
     185            p.setName(Keyword.WILD);
     186            LispObject result = Symbol.MATCH_WILD_JAR_PATHNAME.execute(p);
     187           
     188            if (result instanceof Cons
     189                && ((Cons)result).length() == 1
     190                && ((Cons)result).car() instanceof Pathname) {
     191              initTruename = (Pathname)result.car();
     192            } else {
     193              String errorMessage
     194                = "Loadable FASL not found for "
     195                + pathname.printObject()
     196                + " in "
     197                + mergedPathname.printObject();
     198              if (ifDoesNotExist) {
     199                return error(new FileError(errorMessage, mergedPathname));
     200              } else {
     201                Debug.trace(errorMessage);
     202                return NIL;
     203              }
     204            }
     205          }
     206          truename = (Pathname)initTruename;
    218207        }
    219208       

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

    r15405 r15406  
    6363  }
    6464
    65   public static LispObject create(String s) {
     65  public static Pathname create(String s) {
    6666    // TODO distinguish between logical hosts and schemes for URLs
    6767    // which we can meaningfully parse.
    … …  
    16171617    }
    16181618
    1619   public static final LispObject mergePathnames(Pathname pathname, Pathname defaultPathname) {
     1619  public static final Pathname mergePathnames(Pathname pathname, Pathname defaultPathname) {
    16201620    return mergePathnames(pathname, defaultPathname, Keyword.NEWEST);
    16211621  }
    16221622   
    1623   public static final LispObject mergePathnames(final Pathname pathname,
    1624                                                 final Pathname defaultPathname,
    1625                                                 final LispObject defaultVersion) {
     1623  public static final Pathname mergePathnames(final Pathname pathname,
     1624                                              final Pathname defaultPathname,
     1625                                              final LispObject defaultVersion) {
    16261626    Pathname result;
    16271627    Pathname p = Pathname.create(pathname);
    … …  
    16331633    } else {
    16341634      if (pathname instanceof PathnameJar
    1635           // If the defaults contain a JAR-PATHNAME, and the pathname to
    1636           // be be merged is not a JAR-PATHNAME, does not have a specified
    1637           // DEVICE, a specified HOST, and doesn't contain a relative
    1638           // DIRECTORY, then the result will not be a JAR-PATHNAME
     1635          // If the defaults contain a JAR-PATHNAME, and the pathname
     1636          // to be be merged is not a JAR-PATHNAME, does not have a
     1637          // specified DEVICE or a specified HOST and has a NIL or
     1638          // relative directory then the result will be a JAR-PATHNAME.
    16391639          || (defaultPathname instanceof PathnameJar
    16401640              && !(pathname instanceof PathnameJar)
     1641              && pathname.getHost().equals(NIL)
    16411642              && pathname.getDevice().equals(NIL)
    1642               && !(!pathname.getDirectory().equals(NIL)
    1643                    && pathname.getDirectory().car().equals(Keyword.ABSOLUTE)))) {
     1643              && (pathname.getDirectory().equals(NIL)
     1644                  || pathname.getDirectory().car().equals(Keyword.RELATIVE)))) {
    16441645        result = PathnameJar.create();
    16451646      } else if (pathname instanceof PathnameURL) {
    … …  
    16531654      } else {
    16541655        if (defaultPathname instanceof PathnameJar) {
    1655           d = PathnameJar.create(defaultPathname);
     1656          d = PathnameJar.create((PathnameJar)defaultPathname);
    16561657        } else if (defaultPathname instanceof PathnameURL) {
    16571658          d = PathnameURL.create(defaultPathname);
    … …  
    16861687        // :UNSPECIFIC.
    16871688        if ((d instanceof PathnameJar)
    1688             && (result instanceof Pathname)) {
    1689           if (pathname.getHost() == NIL
    1690               && pathname.getDevice() == NIL
    1691               && d.isJar()
    1692               && !Utilities.isPlatformWindows) {
    1693             if (pathname.getDirectory() != NIL
    1694                 && pathname.getDirectory().car() == Keyword.ABSOLUTE) {
    1695               result.setDevice(Keyword.UNSPECIFIC);
    1696             } else {
    1697               result.setDevice(d.getDevice());
    1698             }
     1689            && !(result instanceof PathnameJar)) {
     1690          if (!Utilities.isPlatformWindows) {
     1691            result.setDevice(Keyword.UNSPECIFIC);
    16991692          } else {
    17001693            result.setDevice(d.getDevice());
    … …  
    21472140  }
    21482141
     2142  Pathname getEntryPath() {
     2143    return Pathname.create(asEntryPath());
     2144  }
     2145
    21492146  /** @return The representation of the DIRECTORY/NAME/TYPE elements
    21502147   *  of pathname suitable for referencing an entry in a Zip/JAR file.
    … …  
    21522149   *  This representation is always a relative path.
    21532150   */
    2154   protected String asEntryPath() {
     2151  String asEntryPath() {
    21552152    Pathname p = Pathname.create();
    21562153    p.setDirectory(getDirectory())

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

    r15405 r15406  
    6363
    6464  public static PathnameJar create(PathnameJar p) {
    65     return (PathnameJar)PathnameJar.create(p.getNamestring());
     65    PathnameJar result = new PathnameJar();
     66    result.copyFrom(p);
     67    return result;
    6668  }
    6769
    … …  
    8183  }
    8284
     85  /** Transform an entry in a jar to a reference as a jar */
     86  public static PathnameJar createFromEntry(PathnameJar p) {
     87    PathnameJar result = new PathnameJar();
     88    result
     89      .copyFrom(p)
     90      .setDirectory(NIL)
     91      .setName(NIL)
     92      .setType(NIL);
     93    Pathname entryPath = p.getEntryPath();
     94    LispObject device = p.getDevice();
     95    device = device.nreverse().push(entryPath).nreverse();
     96    result.setDevice(device);
     97    return result;
     98  }
     99   
    83100  static public PathnameJar createFromFile(String s) {
    84101    return PathnameJar.create(JAR_URI_PREFIX + "file:" + s + JAR_URI_SUFFIX);
    … …  
    340357    p.copyFrom(pathname);
    341358
    342     PathnameURL rootJar = (PathnameURL) p.getRootJar();
    343     if (rootJar.isLocalFile()) {
     359    // Run a truename resolution on the path of local jar archives
     360    if (p.isLocalFile()) {
     361      PathnameURL rootJar = new PathnameURL();
     362      rootJar.copyFrom((Pathname)p.getRootJar());
     363      // Ensure that we don't return a PathnameJar if the current default is one
     364      if (rootJar.getDevice().equals(NIL)) {
     365        rootJar.setDevice(Keyword.UNSPECIFIC);
     366      }
    344367      LispObject trueRootJar = PathnameURL.truename(rootJar, errorIfDoesNotExist);
    345368      if (trueRootJar.equals(NIL)) {
    … …  
    402425
    403426  public InputStream getInputStream() {
    404     String entryPath = asEntryPath();
    405427    // XXX We only return the bytes of an entry in a JAR
    406428    if (!isArchiveEntry()) {

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

    r15405 r15406  
    5555  protected PathnameURL() {}
    5656
    57   public static Pathname create() {
     57  public static PathnameURL create() {
    5858    return new PathnameURL();
    5959  }
    … …  
    6464
    6565  public static PathnameURL create(PathnameURL p) {
    66     return (PathnameURL) PathnameURL.create(p.getNamestring());
    67   }
    68 
    69   public static LispObject create(URL url) {
     66    PathnameURL result = new PathnameURL();
     67    result.copyFrom(p);
     68    return result;
     69  }
     70
     71  public static PathnameURL create(URL url) {
    7072    return PathnameURL.create(url.toString());
    7173  }
    7274
    73   public static LispObject create(URI uri) {
     75  public static PathnameURL create(URI uri) {
    7476    return PathnameURL.create(uri.toString());
    7577  }
    7678
    77   public static LispObject createFromFile(Pathname p) {
     79  public static PathnameURL createFromFile(Pathname p) {
    7880    String ns = "file:" + p.getNamestring();
    7981    return create(ns);
    … …  
    287289     || Symbol.GETF.execute(p.getHost(), PathnameURL.SCHEME, NIL)
    288290          .equals("file")) {
    289       return Pathname.truename(p, errorIfDoesNotExist);
     291      LispObject fileTruename = Pathname.truename(p, errorIfDoesNotExist);
     292      if (fileTruename.equals(NIL)) {
     293        return NIL;
     294      }
     295      if (!(fileTruename instanceof PathnameURL)) {
     296        PathnameURL urlTruename = PathnameURL.create((Pathname)fileTruename);
     297        return urlTruename;
     298      }
     299      return fileTruename;
    290300    }
    291301       

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

    r15405 r15406  
    166166
    167167  public static InputStream getEntryAsInputStream(PathnameJar archiveEntry) {
    168     InputStream result = null;
    169     if (archiveEntry.getDevice().length() > 1) {
    170       simple_error("Unimplemented retrieval of InputStream from a nested jar reference");
    171       return (InputStream)UNREACHED;
    172       // Pathname inner = (Pathname) getDevice().cdr().car();
    173       // InputStream input = ZipCache.getInputStream(jarFile, inner);
    174       // ZipInputStream zipInputStream = new ZipInputStream(input);
    175       // result =  ZipCache.getEntryAsInputStream(zipInputStream, entryPath);
    176     } else {
    177       Archive archive = ZipCache.getArchive(archiveEntry);
    178       // ZipFile zipFile = archive.file;
    179       // ZipEntry entry = archive.getEntry(archiveEntry);
    180      
    181       result = archive.getEntryAsInputStream(archiveEntry);
    182       if (result == null) {
    183         simple_error("Failed to get InputStream for ~a", archiveEntry);
    184       }
     168    PathnameJar archiveJar = archiveEntry.getArchive();
     169    Archive archive = ZipCache.getArchive(archiveJar);
     170    InputStream result = archive.getEntryAsInputStream(archiveEntry);
     171    if (result == null) {
     172      simple_error("Failed to get InputStream for ~a", archiveEntry);
    185173    }
    186174    return result;

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

    r15400 r15406  
    6161                                   pathname));
    6262      final Pathname defaultedPathname
    63               = (Pathname)Pathname.mergePathnames(pathname,
     63              = Pathname.mergePathnames(pathname,
    6464                                coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()),
    6565                                NIL);

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

    r15405 r15406  
    6464            return PathnameJar.truename(p, false);
    6565          } else if (p instanceof PathnameURL) {
    66             return PathnameURL.truename(p, false);
     66            return PathnameURL.truename((PathnameURL)p, false);
    6767          } else {
    6868            return Pathname.truename(p, false);
    … …  
    9393            return PathnameJar.truename(p, true);
    9494          } else if (p instanceof PathnameURL) {
    95             return PathnameURL.truename(p, true);
     95            return PathnameURL.truename((PathnameURL)p, true);
    9696          } else {
    9797            return Pathname.truename(p, true);

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

    r15400 r15406  
    7272    private LispObject unzipToDirectory(Pathname zipPath, Pathname dirPath) {
    7373        if (!zipPath.isAbsolute()) {
    74             zipPath = (Pathname)Pathname.mergePathnames(zipPath,
     74            zipPath = Pathname.mergePathnames(zipPath,
    7575                                              coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()));
    7676        }
Note: See TracChangeset for help on using the changeset viewer.