Changeset 9947


Ignore:
Timestamp:
09/08/05 18:30:30 (16 years ago)
Author:
piso
Message:

Close ZipFiles?.

Location:
trunk/j/src/org/armedbear/lisp
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r9923 r9947  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Lisp.java,v 1.389 2005-08-26 00:40:39 piso Exp $
     5 * $Id: Lisp.java,v 1.390 2005-09-08 18:29:40 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    899899                            }
    900900                            ZipFile zipFile = new ZipFile(zipFileName);
    901                             ZipEntry entry = zipFile.getEntry(entryName);
    902                             if (entry != null) {
    903                                 long size = entry.getSize();
    904                                 InputStream in = zipFile.getInputStream(entry);
    905                                 byte[] bytes = new byte[(int)size];
    906                                 int bytesRemaining = (int) size;
    907                                 int bytesRead = 0;
    908                                 while (bytesRemaining > 0) {
    909                                     int n;
    910                                     if (bytesRemaining >= 4096)
    911                                         n = in.read(bytes, bytesRead, 4096);
    912                                     else
    913                                         n = in.read(bytes, bytesRead, bytesRemaining);
    914                                     if (n < 0)
    915                                         break;
    916                                     bytesRead += n;
    917                                     bytesRemaining -= n;
     901                            try {
     902                                ZipEntry entry = zipFile.getEntry(entryName);
     903                                if (entry != null) {
     904                                    long size = entry.getSize();
     905                                    InputStream in = zipFile.getInputStream(entry);
     906                                    byte[] bytes = new byte[(int)size];
     907                                    int bytesRemaining = (int) size;
     908                                    int bytesRead = 0;
     909                                    while (bytesRemaining > 0) {
     910                                        int n;
     911                                        if (bytesRemaining >= 4096)
     912                                            n = in.read(bytes, bytesRead, 4096);
     913                                        else
     914                                            n = in.read(bytes, bytesRead, bytesRemaining);
     915                                        if (n < 0)
     916                                            break;
     917                                        bytesRead += n;
     918                                        bytesRemaining -= n;
     919                                    }
     920                                    in.close();
     921                                    if (bytesRemaining > 0)
     922                                        Debug.trace("bytesRemaining = " + bytesRemaining);
     923                                    JavaClassLoader loader = new JavaClassLoader();
     924                                    Class c =
     925                                        loader.loadClassFromByteArray(null, bytes, 0, bytes.length);
     926                                    if (c != null) {
     927                                        Class[] parameterTypes = new Class[0];
     928                                        Constructor constructor =
     929                                            c.getConstructor(parameterTypes);
     930                                        Object[] initargs = new Object[0];
     931                                        LispObject obj =
     932                                            (LispObject) constructor.newInstance(initargs);
     933                                        if (obj instanceof Function)
     934                                            ((Function)obj).setClassBytes(bytes);
     935                                        return obj != null ? obj : NIL;
     936                                    }
    918937                                }
    919                                 in.close();
    920                                 if (bytesRemaining > 0)
    921                                     Debug.trace("bytesRemaining = " + bytesRemaining);
    922                                 JavaClassLoader loader = new JavaClassLoader();
    923                                 Class c =
    924                                     loader.loadClassFromByteArray(null, bytes, 0, bytes.length);
    925                                 if (c != null) {
    926                                     Class[] parameterTypes = new Class[0];
    927                                     Constructor constructor =
    928                                         c.getConstructor(parameterTypes);
    929                                     Object[] initargs = new Object[0];
    930                                     LispObject obj =
    931                                         (LispObject) constructor.newInstance(initargs);
    932                                     if (obj instanceof Function)
    933                                         ((Function)obj).setClassBytes(bytes);
    934                                     return obj != null ? obj : NIL;
    935                                 }
     938                            }
     939                            finally {
     940                                zipFile.close();
    936941                            }
    937942                        }
     
    982987            String zipFileName = ((Pathname)loadTruename).getNamestring();
    983988            ZipFile zipFile = new ZipFile(zipFileName);
    984             ZipEntry entry = zipFile.getEntry(namestring);
    985             if (entry != null) {
    986                 LispObject obj = loadCompiledFunction(zipFile.getInputStream(entry),
    987                                                       (int) entry.getSize());
     989            try {
     990                ZipEntry entry = zipFile.getEntry(namestring);
     991                if (entry != null) {
     992                    LispObject obj = loadCompiledFunction(zipFile.getInputStream(entry),
     993                                                          (int) entry.getSize());
     994                    if (obj != null)
     995                        return obj;
     996                    Debug.trace("Unable to load " + namestring);
     997                    return signal(new LispError("Unable to load " + namestring));
     998                }
     999            }
     1000            finally {
    9881001                zipFile.close();
    989                 if (obj != null)
    990                     return obj;
    991                 Debug.trace("Unable to load " + namestring);
    992                 return signal(new LispError("Unable to load " + namestring));
    993             } else
    994                 zipFile.close();
     1002            }
    9951003        }
    9961004        catch (Throwable t) {
  • trunk/j/src/org/armedbear/lisp/Load.java

    r9825 r9947  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Load.java,v 1.115 2005-08-10 19:21:51 piso Exp $
     5 * $Id: Load.java,v 1.116 2005-09-08 18:30:30 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    136136        }
    137137        catch (FaslVersionMismatch e) {
    138             StringBuffer sb = new StringBuffer("Incorrect fasl version: ");
     138            FastStringBuffer sb =
     139                new FastStringBuffer("Incorrect fasl version: ");
    139140            sb.append(truename);
    140141            return signal(new SimpleError(sb.toString()));
     
    146147            catch (IOException e) {
    147148                return signal(new LispError(e.getMessage()));
     149            }
     150            if (zipfile != null) {
     151                try {
     152                    zipfile.close();
     153                }
     154                catch (IOException e) {
     155                    return signal(new LispError(e.getMessage()));
     156                }
    148157            }
    149158        }
     
    212221            if (s == null)
    213222                break;
     223            ZipFile zipfile = null;
    214224            final String dir = Site.getLispHome();
    215             if (dir != null) {
    216                 File file = new File(dir, s);
    217                 if (file.isFile()) {
    218                     // File exists. For system files, we know the extension
    219                     // will be .abcl if it's a compiled file.
    220                     String ext = getExtension(s);
    221                     if (ext.equalsIgnoreCase(".abcl")) {
    222                         try {
    223                             ZipFile zipfile = new ZipFile(file);
    224                             String name = file.getName();
    225           int index = name.lastIndexOf('.');
    226           Debug.assertTrue(index >= 0);
    227           name = name.substring(0, index).concat("._");
    228                             ZipEntry entry = zipfile.getEntry(name);
    229                             if (entry != null) {
    230                                 in = zipfile.getInputStream(entry);
     225            try {
     226                if (dir != null) {
     227                    File file = new File(dir, s);
     228                    if (file.isFile()) {
     229                        // File exists. For system files, we know the extension
     230                        // will be .abcl if it is a compiled file.
     231                        String ext = getExtension(s);
     232                        if (ext.equalsIgnoreCase(".abcl")) {
     233                            try {
     234                                zipfile = new ZipFile(file);
     235                                String name = file.getName();
     236                                int index = name.lastIndexOf('.');
     237                                Debug.assertTrue(index >= 0);
     238                                name = name.substring(0, index).concat("._");
     239                                ZipEntry entry = zipfile.getEntry(name);
     240                                if (entry != null) {
     241                                    in = zipfile.getInputStream(entry);
     242                                    truename = file.getCanonicalPath();
     243                                }
     244                            }
     245                            catch (ZipException e) {
     246                                // Fall through.
     247                            }
     248                            catch (Throwable t) {
     249                                Debug.trace(t);
     250                                in = null;
     251                                // Fall through.
     252                            }
     253                        }
     254                        if (in == null) {
     255                            try {
     256                                in = new FileInputStream(file);
    231257                                truename = file.getCanonicalPath();
    232258                            }
     259                            catch (IOException e) {
     260                                in = null;
     261                            }
    233262                        }
    234                         catch (ZipException e) {
    235                             // Fall through.
    236                         }
    237                         catch (Throwable t) {
    238                             Debug.trace(t);
    239                             in = null;
    240                             // Fall through.
    241                         }
    242                     }
    243                     if (in == null) {
     263                    }
     264                } else {
     265                    URL url = Lisp.class.getResource(s);
     266                    if (url != null) {
    244267                        try {
    245                             in = new FileInputStream(file);
    246                             truename = file.getCanonicalPath();
     268                            in = url.openStream();
     269                            if ("jar".equals(url.getProtocol()))
     270                                pathname = new Pathname(url);
     271                            truename = getPath(url);
    247272                        }
    248273                        catch (IOException e) {
     
    251276                    }
    252277                }
    253             } else {
    254                 URL url = Lisp.class.getResource(s);
    255                 if (url != null) {
     278                if (in != null) {
     279                    final LispThread thread = LispThread.currentThread();
     280                    final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
     281                    thread.bindSpecial(_WARN_ON_REDEFINITION_, NIL);
    256282                    try {
    257                         in = url.openStream();
    258                         if ("jar".equals(url.getProtocol()))
    259                             pathname = new Pathname(url);
    260                         truename = getPath(url);
    261                     }
    262                     catch (IOException e) {
    263                         in = null;
    264                     }
    265                 }
    266             }
    267             if (in != null) {
    268                 final LispThread thread = LispThread.currentThread();
    269                 final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    270                 thread.bindSpecial(_WARN_ON_REDEFINITION_, NIL);
    271                 try {
    272                     return loadFileFromStream(pathname, truename,
    273                                               new Stream(in, Symbol.CHARACTER),
    274                                               verbose, print, auto);
    275                 }
    276                 catch (FaslVersionMismatch e) {
    277                     StringBuffer sb =
    278                         new StringBuffer("; Incorrect fasl version: ");
    279                     sb.append(truename);
    280                     System.err.println(sb.toString());
    281                 }
    282                 finally {
    283                     thread.lastSpecialBinding = lastSpecialBinding;
     283                        return loadFileFromStream(pathname, truename,
     284                                                  new Stream(in, Symbol.CHARACTER),
     285                                                  verbose, print, auto);
     286                    }
     287                    catch (FaslVersionMismatch e) {
     288                        StringBuffer sb =
     289                            new StringBuffer("; Incorrect fasl version: ");
     290                        sb.append(truename);
     291                        System.err.println(sb.toString());
     292                    }
     293                    finally {
     294                        thread.lastSpecialBinding = lastSpecialBinding;
     295                        try {
     296                            in.close();
     297                        }
     298                        catch (IOException e) {
     299                            return signal(new LispError(e.getMessage()));
     300                        }
     301                    }
     302                }
     303            }
     304            finally {
     305                if (zipfile != null) {
    284306                    try {
    285                         in.close();
     307                        zipfile.close();
    286308                    }
    287309                    catch (IOException e) {
Note: See TracChangeset for help on using the changeset viewer.