rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/jxxload_help/DiscardHelp.java

@@ -0,0 +1,59 @@
+// Copyright 2000 Samuele Pedroni
+
+package jxxload_help;
+
+import org.python.core.PyJavaClass;
+
+public class DiscardHelp extends Object {
+
+  private DiscardHelp() {
+  }
+
+  private static boolean check(Class c,ClassLoader loader,java.util.Vector interfaces) {
+    try {
+        Class s = c;
+        do {
+            if (s.getClassLoader() == loader) return true;
+            s = s.getSuperclass();
+        } while (s != null);
+        
+        for(java.util.Enumeration enumm=interfaces.elements(); enumm.hasMoreElements();) {
+            Class intf = (Class)enumm.nextElement();
+            if (intf.isAssignableFrom(c)) return true;
+        }
+        
+    } catch(SecurityException e) {
+    }
+    return false;
+  }
+
+  // clearly not thread safe
+  public static void discard(ClassLoader loader,java.util.Vector interfaces) {
+    
+    org.python.core.InternalTables tbl = PyJavaClass.getInternalTables();
+    
+    tbl._beginCanonical();
+    
+    PyJavaClass jc;
+    while ((jc = (PyJavaClass)tbl._next()) != null ) {
+        Class c = (Class)jc.__tojava__(Class.class);
+        if(check(c,loader,interfaces)) tbl._flushCurrent();    
+    }
+    
+    tbl._beginOverAdapterClasses();
+    
+    Class c;
+    
+    while ((c = (Class)tbl._next()) != null) {
+        if(interfaces.contains(c)) tbl._flushCurrent();
+    }
+    
+    tbl._beginOverAdapters();
+    
+    while ((c = (Class)tbl._next()) != null) {
+        if(interfaces.contains(c)) tbl._flushCurrent();
+    }
+    
+  }
+
+}

data/lib/rubyfox/server/data/lib/Lib/jxxload_help/JavaLoaderFactory.java

@@ -0,0 +1,9 @@
+// Copyright 2000 Samuele Pedroni
+
+package jxxload_help;
+
+public interface JavaLoaderFactory {
+    
+    public ClassLoader makeLoader();
+
+}

data/lib/rubyfox/server/data/lib/Lib/jxxload_help/PackageManager.java

@@ -0,0 +1,58 @@
+// Copyright 2000 Samuele Pedroni
+
+package jxxload_help;
+
+public class PackageManager extends org.python.core.PathPackageManager {
+    
+    private JavaLoaderFactory factory;
+    private ClassLoader loader;
+    
+    public synchronized ClassLoader getLoader() {
+        if (loader == null) loader = factory.makeLoader();
+        return loader;
+    }
+    
+    public synchronized  ClassLoader checkLoader() {
+        return loader;
+    }
+    
+    public synchronized void resetLoader() {
+        loader = null;
+    }
+    
+    // ??pending add cache support?
+    public PackageManager(org.python.core.PyList path,JavaLoaderFactory factory) { 
+        this.factory = factory;
+        
+        for (int i = 0; i < path.__len__(); i++) {
+            String entry = path.__finditem__(i).toString();
+            if (entry.endsWith(".jar") || entry.endsWith(".zip")) {
+                addJarToPackages(new java.io.File(entry),false);
+            } else {
+                java.io.File dir = new java.io.File(entry);
+                if (entry.length() == 0 || dir.isDirectory()) addDirectory(dir);
+            }
+        }
+    }
+
+    public Class findClass(String pkg,String name,String reason) {
+        if (pkg != null && pkg.length()>0) name = pkg + '.' + name;
+        try {
+            return getLoader().loadClass(name);
+        } 
+        catch(ClassNotFoundException e) {
+            return null;
+        }
+        catch (LinkageError e) {
+            throw org.python.core.Py.JavaError(e);
+        }
+    }
+
+    public void addJarDir(String jdir, boolean cache) {
+        throw new RuntimeException("addJarDir not supported for reloadable packages");
+    }  
+
+    public void addJar(String jdir, boolean cache) {
+        throw new RuntimeException("addDir not supported for reloadable packages");
+    }  
+}

data/lib/rubyfox/server/data/lib/Lib/jxxload_help/PathVFS.java

@@ -0,0 +1,98 @@
+// Copyright 2000 Samuele Pedroni
+
+package jxxload_help;
+
+import java.util.Vector;
+import java.util.Hashtable;
+import java.util.Enumeration;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipEntry;
+import java.io.*;
+
+public class PathVFS extends Object {
+    
+    public interface VFS {
+        
+       public InputStream open(String id);
+        
+    }
+        
+    public static class JarVFS implements VFS {
+        private ZipFile zipfile;
+        
+        public JarVFS(String fname) throws IOException {
+            zipfile = new ZipFile(fname);
+        }
+        
+        public InputStream open(String id) {
+            ZipEntry ent = zipfile.getEntry(id);
+            if (ent == null) return null;
+            try {
+                return zipfile.getInputStream(ent);
+            } catch(IOException e) {
+                return null;
+            }
+        }
+        
+    }
+    
+    public static class DirVFS implements VFS {
+        private String prefix;
+        
+        public DirVFS(String dir) {
+            if (dir.length() == 0)
+                prefix = null;
+            else
+                prefix = dir;
+        }
+        
+        public InputStream open(String id) {
+            File file = new File(prefix,id.replace('/',File.separatorChar));
+            if (file.isFile()) {
+                try {
+                    return new BufferedInputStream(new FileInputStream(file));
+                } catch(IOException e) {
+                    return null;
+                }
+            }           
+            return null;
+        }
+    }
+    
+    private Vector vfs = new Vector();
+    private Hashtable once = new Hashtable();
+    
+    private final static Object PRESENT = new Object();
+    
+    public void addVFS(String fname) {
+        if (fname.length() == 0) {
+            if (!once.containsKey("")) {
+                once.put("",PRESENT);
+                vfs.addElement(new DirVFS(""));
+            }
+            return;
+        }
+        try {
+            File file = new File(fname);
+            String canon = file.getCanonicalPath().toString();
+            if (!once.containsKey(canon)) {
+                once.put(canon,PRESENT);
+                if (file.isDirectory()) vfs.addElement(new DirVFS(fname));
+                else if (file.exists() &&  (fname.endsWith(".jar") || fname.endsWith(".zip"))) {
+                    vfs.addElement(new JarVFS(fname));
+                }
+            }
+            
+        } catch(IOException e) {}
+    }
+    
+    public InputStream open(String id) {
+        for(Enumeration enumm = vfs.elements(); enumm.hasMoreElements();) {
+            VFS v = (VFS)enumm.nextElement();
+            InputStream stream = v.open(id);
+            if (stream != null) return stream;
+        }
+        return null;
+    }
+      
+}

data/lib/rubyfox/server/data/lib/Lib/jxxload_help/PathVFSJavaLoader.java

@@ -0,0 +1,49 @@
+// Copyright 2000 Samuele Pedroni
+
+package jxxload_help;
+
+public class PathVFSJavaLoader extends ClassLoader {
+    private ClassLoader parent;
+   
+    private PathVFS vfs;
+    
+    public java.util.Vector interfaces = new java.util.Vector();
+    
+    public PathVFSJavaLoader(PathVFS vfs,ClassLoader parent) {
+        this.vfs = vfs;
+        this.parent = parent;
+    }
+    
+    protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        Class c;
+        
+        c = findLoadedClass(name);
+        if (c != null) return c;
+        
+        try {
+            if (parent != null) return parent.loadClass(name);
+        } catch(ClassNotFoundException e) {
+        }
+        
+        java.io.InputStream in = vfs.open(name.replace('.','/')+".class");
+        if (in == null) throw new ClassNotFoundException(name);
+        try {
+	    byte[] buf = org.python.core.FileUtil.readBytes( in );
+            in.close();
+            return loadClassFromBytes(name,buf);
+        } catch(java.io.IOException e) {
+            throw new ClassNotFoundException(name);
+        }
+    }
+
+    private Class loadClassFromBytes(String name, byte[] data) {
+        Class c = defineClass(name, data, 0, data.length);
+        resolveClass(c);
+        if (c.isInterface()) interfaces.addElement(c);
+        if (!org.python.core.Options.skipCompile) {
+            Compiler.compileClass(c);
+        }
+        return c;
+    }
+  
+}

data/lib/rubyfox/server/data/lib/Lib/keyword.py

@@ -0,0 +1,97 @@
+#! /usr/bin/env python
+
+"""Keywords (from "graminit.c")
+
+This file is automatically generated; please don't muck it up!
+
+To update the symbols in this file, 'cd' to the top directory of
+the python source tree after building the interpreter and run:
+
+    python Lib/keyword.py
+"""
+
+__all__ = ["iskeyword", "kwlist"]
+
+kwlist = [
+#--start keywords--
+        'and',
+        'assert',
+        'break',
+        'class',
+        'continue',
+        'def',
+        'del',
+        'elif',
+        'else',
+        'except',
+        'exec',
+        'finally',
+        'for',
+        'from',
+        'global',
+        'if',
+        'import',
+        'in',
+        'is',
+        'lambda',
+        'not',
+        'or',
+        'pass',
+        'print',
+        'raise',
+        'return',
+        'try',
+        'while',
+        'yield',
+#--end keywords--
+        ]
+
+kwdict = {}
+for keyword in kwlist:
+    kwdict[keyword] = 1
+
+iskeyword = kwdict.has_key
+
+def main():
+    import sys, re
+
+    args = sys.argv[1:]
+    iptfile = args and args[0] or "Python/graminit.c"
+    if len(args) > 1: optfile = args[1]
+    else: optfile = "Lib/keyword.py"
+
+    # scan the source file for keywords
+    fp = open(iptfile)
+    strprog = re.compile('"([^"]+)"')
+    lines = []
+    while 1:
+        line = fp.readline()
+        if not line: break
+        if line.find('{1, "') > -1:
+            match = strprog.search(line)
+            if match:
+                lines.append("        '" + match.group(1) + "',\n")
+    fp.close()
+    lines.sort()
+
+    # load the output skeleton from the target
+    fp = open(optfile)
+    format = fp.readlines()
+    fp.close()
+
+    # insert the lines of keywords
+    try:
+        start = format.index("#--start keywords--\n") + 1
+        end = format.index("#--end keywords--\n")
+        format[start:end] = lines
+    except ValueError:
+        sys.stderr.write("target does not contain format markers\n")
+        sys.exit(1)
+
+    # write the output file
+    fp = open(optfile, 'w')
+    fp.write(''.join(format))
+    fp.close()
+
+if __name__ == "__main__":
+    main()

data/lib/rubyfox/server/data/lib/Lib/linecache.py

@@ -0,0 +1,101 @@
+"""Cache lines from files.
+
+This is intended to read lines from modules imported -- hence if a filename
+is not found, it will look down the module search path for a file by
+that name.
+"""
+
+import sys
+import os
+from stat import *
+
+__all__ = ["getline","clearcache","checkcache"]
+
+def getline(filename, lineno):
+    lines = getlines(filename)
+    if 1 <= lineno <= len(lines):
+        return lines[lineno-1]
+    else:
+        return ''
+
+
+# The cache
+
+cache = {} # The cache
+
+
+def clearcache():
+    """Clear the cache entirely."""
+
+    global cache
+    cache = {}
+
+
+def getlines(filename):
+    """Get the lines for a file from the cache.
+    Update the cache if it doesn't contain an entry for this file already."""
+
+    if cache.has_key(filename):
+        return cache[filename][2]
+    else:
+        return updatecache(filename)
+
+
+def checkcache():
+    """Discard cache entries that are out of date.
+    (This is not checked upon each call!)"""
+
+    for filename in cache.keys():
+        size, mtime, lines, fullname = cache[filename]
+        try:
+            stat = os.stat(fullname)
+        except os.error:
+            del cache[filename]
+            continue
+        if size != stat[ST_SIZE] or mtime != stat[ST_MTIME]:
+            del cache[filename]
+
+
+def updatecache(filename):
+    """Update a cache entry and return its list of lines.
+    If something's wrong, print a message, discard the cache entry,
+    and return an empty list."""
+
+    if cache.has_key(filename):
+        del cache[filename]
+    if not filename or filename[0] + filename[-1] == '<>':
+        return []
+    fullname = filename
+    try:
+        stat = os.stat(fullname)
+    except os.error, msg:
+        # Try looking through the module search path.
+        basename = os.path.split(filename)[1]
+        for dirname in sys.path:
+            # When using imputil, sys.path may contain things other than
+            # strings; ignore them when it happens.
+            try:
+                fullname = os.path.join(dirname, basename)
+            except (TypeError, AttributeError):
+                # Not sufficiently string-like to do anything useful with.
+                pass
+            else:
+                try:
+                    stat = os.stat(fullname)
+                    break
+                except os.error:
+                    pass
+        else:
+            # No luck
+##          print '*** Cannot stat', filename, ':', msg
+            return []
+    try:
+        fp = open(fullname, 'r')
+        lines = fp.readlines()
+        fp.close()
+    except IOError, msg:
+##      print '*** Cannot open', fullname, ':', msg
+        return []
+    size, mtime = stat[ST_SIZE], stat[ST_MTIME]
+    cache[filename] = size, mtime, lines, fullname
+    return lines