X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fxwt%2FRes.java;h=1f1a9279e90f20b458962cfedaeeb8595de95d31;hb=1019725cfa88d9ad5dfabaf178e87da79c9c3e17;hp=bf7b6f81152c7e753b155bd9f8fe6bdbd17555b8;hpb=4923e8529bbd51d0d03387d2f08ae08b38d5ef4a;p=org.ibex.core.git

diff --git a/src/org/xwt/Res.java b/src/org/xwt/Res.java
index bf7b6f8..1f1a927 100644
--- a/src/org/xwt/Res.java
+++ b/src/org/xwt/Res.java
@@ -2,57 +2,259 @@
 package org.xwt;
 
 import java.io.*;
+import java.util.*;
+import java.util.zip.*;
+import org.xwt.js.*;
+import org.xwt.util.*;
+import org.bouncycastle.util.encoders.Base64;
 
 /** base class for XWT resources */
-public abstract class Res {
+public abstract class Res extends JS {
 
-    public abstract InputStream getInputStream();
-    public Res getSubResource(String key) { return Null.singleton; }
+    public String getDescriptiveName() { return ""; }
 
-    public static Res stringToRes(String url) {
-        if (url.indexOf('!') == -1)
-            return new Zip(stringToRes(url.substring(0, url.lastIndexOf('!'))),
-                           url.substring(url.lastIndexOf('!') + 1));
-        if (url.startsWith("http://")) return new HTTP(url);
-        if (url.startsWith("https://")) return new HTTP(url);
-        throw new JS.Exn("invalid resource specifier");
+    /** cache of subresources so that the equality operator works on them */
+    private Hash refCache = null;
+
+    public Template t = null;
+
+    public Res getParent() { return null; }
+
+    /** returns an InputStream containing the Resource's contents */
+    public InputStream getInputStream() throws IOException { return getInputStream(""); }
+    public abstract InputStream getInputStream(String path) throws IOException;
+
+    /** graft newResource in place of this resource on its parent */
+    public Res graft(Object newResource) { throw new JS.Exn("cannot graft onto this resource"); }
+
+    /** if the path of this resource does not end with extension, return a new one wit it appended */
+    public Res addExtension(String extension) { return new Ref(this, extension); }
+
+    public Object[] keys() { throw new JS.Exn("cannot enumerate a resource"); } 
+    public void put(Object key, Object val) { throw new JS.Exn("cannot put to a resource"); } 
+    public Object get(Object key) {
+        if ("".equals(key)) {
+            Template t = Template.getTemplate(addExtension(".xwt"));
+            return t == null ? null : t.getStatic();
+        }
+        Object ret = refCache == null ? null : refCache.get(key);
+        if (ret != null) return ret;
+        ret = new Ref(this, key);
+        if (refCache == null) refCache = new Hash();
+        refCache.put(key, ret);
+        return ret;
     }
 
-    /** the invalid resource; only causes an error if you actually try to use it */
-    public static class Null extends Res {
-        Null() { }
-        private static singleton = new Null();
-        public InputStream getInputStream() throws JS.Exn { throw new JS.Exn("invalid resource"); }
+    public static Res stringToRes(String url) { return stringToRes(url, false); }
+    public static Res stringToRes(String url, boolean permitLocalFilesystem) {
+        if (url.indexOf('!') != -1)
+            return (Res)(new Zip(stringToRes(url.substring(0, url.lastIndexOf('!')))).get(url.substring(url.lastIndexOf('!') + 1)));
+        if (url.startsWith("http://")) return new HTTP(url);
+        if (url.startsWith("https://")) return new HTTP(url);
+        if (url.startsWith("file:") && permitLocalFilesystem) return new File(url.substring(5));
+        if (url.startsWith("cab:")) return new CAB(stringToRes(url.substring(4)));
+        if (url.startsWith("data:")) return new ByteArray(Base64.decode(url.substring(5)));
+        throw new JS.Exn("invalid resource specifier " + url);
     }
 
     /** HTTP or HTTPS resource */
     public static class HTTP extends Res {
         private String url;
         HTTP(String url) { this.url = url; }
-        public InputStream getInputStream() { return new HTTP(url).GET(); }
-        public Res getSubResource(String key) { return new HTTP(url + "/" + key); }
+        public InputStream getInputStream(String path) throws IOException { return new org.xwt.HTTP(url + path).GET(); }
+    }
+
+    /** byte arrays */
+    public static class ByteArray extends Res {
+        private byte[] bytes;
+        ByteArray(byte[] bytes) { this.bytes = bytes; }
+        public InputStream getInputStream(String path) throws IOException {
+            if (!"".equals(path)) throw new JS.Exn("can't get subresources of a byte[] resource");
+            return new ByteArrayInputStream(bytes);
+        }
+    }
+
+    /** a file */
+    public static class File extends Res {
+        private String path;
+        File(String path) { this.path = path; }
+        public InputStream getInputStream(String rest) throws IOException {
+            return new FileInputStream((path + rest).replace('/', java.io.File.separatorChar)); }
     }
 
     /** wrap a Res around a preexisting InputStream */
     public static class IS extends Res {
         InputStream parent;
         IS(InputStream parent) { this.parent = parent; }
-        public InputStream getInputStream() { return parent; }
+        public InputStream getInputStream(String path) {
+            if (!"".equals(path)) throw new JS.Exn("can't access subresources of IS");
+            return parent;
+        }
     }
 
     /** "unwrap" a Zip archive */
     public static class Zip extends Res {
         private Res parent;
-        private String path = "";
-        Zip(Res parent, String path) { this.parent = parent; this.path = path; }
-        public InputStream getInputStream() {
+        Zip(Res parent) { this.parent = parent; }
+        public InputStream getInputStream(String path) throws IOException {
+            if (path.startsWith("/")) path = path.substring(1);
             ZipInputStream zis = new ZipInputStream(parent.getInputStream());
             ZipEntry ze = zis.getNextEntry();
             while(ze != null && !ze.getName().equals(path)) ze = zis.getNextEntry();
-            if (ze == null) throw new JS.Exn("zip file not found in archive");
+            if (ze == null) throw new JS.Exn("requested file not found in archive");
             return zis;
         }
-        public Res getSubResource(String key) { return new Zip(parent, path + '/' + key); }
     }
 
+    /** what you get when you reference a subresource */
+    public static class Ref extends Res {
+        Res parent;
+        Object key;
+        Ref(Res parent, Object key) { this.parent = parent; this.key = key; }
+        public String getDescriptiveName() {
+            String pdn = parent.getDescriptiveName();
+            return pdn.equals("") ? key.toString() : (pdn + "." + key.toString());
+        }
+        public Res addExtension(String extension) {
+            return (key instanceof String && ((String)key).endsWith(extension)) ? this : new Ref(parent, key + extension);
+        }
+        public InputStream getInputStream(String path) throws IOException {
+            return parent.getInputStream("/" + key + path);
+        }
+        public Res getParent() { return parent; }
+        public Res graft(Object newResource) { return new Graft(parent, key, newResource); }
+    }
+
+    /** shadow resource which replaces the graft */
+    public static class Graft extends Res {
+        Res graftee;
+        Object replaced_key;
+        Object replaced_val;
+        Graft(Res graftee, Object key, Object val) { this.graftee = graftee; replaced_key = key; replaced_val = val; }
+        public boolean equals(Object o) { return (this == o || graftee.equals(o)); }
+        public int hashCode() { return graftee.hashCode(); }
+        public InputStream getInputStream(String s) throws IOException { return graftee.getInputStream(s); }
+        public Object get(Object key) { return replaced_key.equals(key) ? replaced_val : graftee.get(key); }
+        public String getDescriptiveName() { return graftee.getDescriptiveName(); }
+        public Res getParent() { return graftee.getParent(); }
+    }
+
+    /** unpacks a Microsoft CAB file (possibly embedded in another file; we scan for 'MSCF' */
+    public static class CAB extends Res {
+        private Res parent;
+        CAB(Res parent) { this.parent = parent; }
+        private int swap_endian(int i) {
+            return ((i & 0xff) << 24) | ((i & 0xff00) << 8) | ((i & 0xff0000) >>> 8) | (i >>> 24);
+        }
+        public InputStream getInputStream(String path) throws IOException {
+            InputStream is = parent.getInputStream();
+            byte[] scan = new byte[4];
+            int ofs = 0;
+            for(int i=0; i<2; i++)  {
+                // wierdly, .exe files have three MSCF's
+                while(scan[0] != 'M' || scan[1] != 'S' || scan[2] != 'C' || scan[3] != 'F') {
+                    System.arraycopy(scan, 1, scan, 0, 3);
+                    int read = is.read();
+                    if (read == -1) throw new JS.Exn("MSCF header tag not found in file");
+                    scan[3] = (byte)read;
+                    ofs++;
+                }
+                scan[0] = 0;
+            }
+            Log.log(this, "found MSCF header at offset " + ofs);
+            return org.xwt.util.CAB.getFileInputStream(is, path, true);
+        }
+    }
+
+    public Object callMethod(Object method, Array args, boolean checkOnly) throws JS.Exn {
+        if (method.equals("getUTF")) {
+            if (checkOnly) return Boolean.TRUE;
+            if (args.length() != 0) return null;
+            try {
+                CharArrayWriter caw = new CharArrayWriter();
+                InputStream is = getInputStream();
+                BufferedReader r = new BufferedReader(new InputStreamReader(is));
+                char[] buf = new char[1024];
+                while(true) {
+                    int numread = r.read(buf, 0, 1024);
+                    if (numread == -1) break;
+                    caw.write(buf, 0, numread);
+                }
+                return caw.toString();
+            } catch (IOException e) {
+                if (Log.on) Log.log(Res.class, "IO Exception while reading from file");
+                if (Log.on) Log.log(Res.class, e);
+                throw new JS.Exn("error while reading from Resource");
+            }
+        } else if (method.equals("getDOM")) {
+            if (checkOnly) return Boolean.TRUE;
+            if (args.length() != 0) return null;
+            return new XMLHelper().doParse();
+        }
+        if (checkOnly) return Boolean.FALSE;
+        return null;
+    }
+
+    private class XMLHelper extends XML {
+        Vector obStack = new Vector();
+        public XMLHelper() { super(BUFFER_SIZE); }
+        public void startElement(XML.Element c) throws XML.SchemaException {
+            JS o = new JS.Obj();
+            o.put("$name", c.localName);
+            for(int i=0; i<c.len; i++) o.put(c.keys[i], c.vals[i]);
+            o.put("$numchildren", new Integer(0));
+            obStack.addElement(o);
+        }
+        public void endElement(XML.Element c) throws XML.SchemaException {
+            if (obStack.size() == 1) return;
+            JS me = (JS)obStack.lastElement();
+            obStack.setSize(obStack.size() - 1);
+            JS parent = (JS)obStack.lastElement();
+            int numchildren = ((Integer)parent.get("$numchildren")).intValue();
+            parent.put("$numchildren", new Integer(numchildren + 1));
+            parent.put(new Integer(numchildren), me);
+        }
+        public void characters(char[] ch, int start, int length) throws XML.SchemaException {
+            String s = new String(ch, start, length);
+            JS parent = (JS)obStack.lastElement();
+            int numchildren = ((Integer)parent.get("$numchildren")).intValue();
+            Object lastChild = parent.get(new Integer(numchildren - 1));
+            if (lastChild instanceof String) {
+                parent.put(new Integer(numchildren - 1), lastChild + s);
+            } else {
+                parent.put("$numchildren", new Integer(numchildren + 1));
+                parent.put(new Integer(numchildren), s);
+            }
+        }
+        public void whitespace(char[] ch, int start, int length) {}
+        public JS doParse() throws JS.Exn {
+            try { 
+                InputStream is = getInputStream();
+                BufferedReader r = new BufferedReader(new InputStreamReader(is));
+                parse(r);
+            } catch (XML.XMLException e) {
+                throw new JS.Exn("error parsing XML: " + e.toString());
+            } catch (IOException e) {
+                if (Log.on) Log.log(this, "IO Exception while reading from file");
+                if (Log.on) Log.log(this, e);
+                throw new JS.Exn("error reading from Resource");
+            }
+            return obStack.size() >= 1 ? (JS)obStack.elementAt(0) : null;
+        }
+    }
+
+    public void writeTo(OutputStream os) throws IOException {
+        InputStream is = getInputStream();
+        byte[] buf = new byte[1024];
+        while(true) {
+            int numread = is.read(buf, 0, 1024);
+            if (numread == -1) break;
+            if (Log.on) Log.log(this, "wrote " + numread + " bytes");
+            os.write(buf, 0, numread);
+        }
+        os.flush();
+
+        // we have to close this because flush() doesn't work on Win32-GCJ
+        os.close();
+    }
 }