From 9a6624c49770e9b5e630a7c51eb0a13002d9df83 Mon Sep 17 00:00:00 2001 From: green Date: Sun, 8 Aug 1999 14:06:23 +0000 Subject: 1999-08-09 Anthony Green * gij.cc: New file. * include/config.h.in: Rebuilt. * acconfig.h: Add INTERPRETER. * configure: Rebuilt. * Makefile.in: Rebuilt. * Makefile.am (libffi_files): Identify the libffi object files for inclusion in libgcj. (LIBFFIINCS): Define. * interpret.cc (gnu::gcj::runtime::MethodInvocation::continue1): Dummy definition for configurations without an interpreter. * java/net/natPlainSocketImpl.cc (getOption): Disamiguate call to java::lang::Boolean constructor. * include/java-interp.h: Always include java-cpool.h. * java/lang/natClassLoader.cc (getVMClassLoader0): Always return 0 when INTERPRETER not defined. * java/lang/Class.h (finalize): Define. * gnu/gcj/util/path/DirectoryPathEntry.java (getURL): Catch IOException from File.getCanonicalPath. (getStream): Likewise. * NEWS: More news. * THANKS: More thanks. 1999-08-09 Kresten Krab Thorup * resolve.cc (get_ffi_type_from_signature): Generate uint16 for jchar type. (_Jv_PrepareClass): Allow non-abstract classes to have abstract subclasses. (_Jv_ResolvePoolEntry): Revert subclass check for protected fields and methods. * interpret.cc (continue1/perform_invoke): Don't sign extend uint16 return val. (continue1/lshl,lshr): Push long, not int. (continue1/ulshr): Use UINT64, not long long. * defineclass.cc (handleFieldsEnd): Handle case when all fields are static. * java/lang/natClass.cc (forName): Add call to _Jv_InitClass. * java/lang/FirstThread.java (run): Add top-level exception handler. (run0): Renamed from run. 1999-08-08 Kresten Krab Thorup * configure.in (--with-interpreter): Added. * include/config.h.in (INTERPRETER): Added. * java/lang/ClassLoader.java: File replaced. * java/lang/VMClassLoader.java: New file. * java/lang/natClassLoader.cc: New file. * gnu/gcj/runtime/MethodInvocation.java: New file. * gnu/gcj/util/path/SearchPath.java: New file. * gnu/gcj/util/path/PathEntry.java: New file. * gnu/gcj/util/path/DirectoryPathEntry.java: New file. * gnu/gcj/util/path/ZipPathEntry.java: New file. * gnu/gcj/util/path/URLPathEntry.java: New file. * gnu/gcj/util/path/CacheEntry.java: New file. * include/java-interp.h: New file. * include/java-cpool.h: New file. * include/java-insns.h: New file. * defineclass.cc: New file. * interpret.cc: New file. * resolve.cc: New file. * java/lang/natClass.cc (loaded_classes, _Jv_RegisterClass, _Jv_RegisterClasses, _Jv_FindClassInCache, _Jv_FindClass, _Jv_NewClass, _Jv_FindArrayClass): Moved to natClassLoader.cc. (finalize): New. (STATE_NOTHING, STATE_RESOLVED, STATE_IN_PROGRESS, STATE_DONE, STATE_ERROR): Moved to java/lang/Class.h and renamed with JV_ prefix. (initializeClass): Use new JV_ prefixed names. Also, call ClassLoader::resolveClass instead of _Jv_ResolveClass. * java/lang/Class.h (JV_STATE_PRELOADING, JV_STATE_LOADING, JV_STATE_LOADED, JV_STATE_COMPILED, JV_STATE_PREPARED, JV_STATE_LINKED): New. (_Jv_WaitForState, _Jv_RegisterInitiatingLoader, _Jv_UnregisterClass, _Jv_InternClassStrings): New friends. (_Jv_IsInterpretedClass, _Jv_InitField, _Jv_LookupDeclaredMethod, _Jv_DetermineVTableIndex, _Jv_ResolvePoolEntry, _Jv_PrepareClass, _Jv_ClassReader, _Jv_InterpClass, _Jv_InterpMethod, _Jv_InterpMethodInvocation): New friends for interpreter. (finalize): New. (CONSTANT_Class, CONSTANT_String, etc.): Moved to include/java-cpool.h and renamed with JV_ prefix. * include/jvm.h (_Jv_makeUtf8Const, _Jv_makeUtf8TypeConst): New decls. (_Jv_UnregisterClass): New decl. * java/lang/natClassLoader.cc (_Jv_FindArrayClass): Added class loader argument. (_Jv_FindClass): Use class loader. * prims.cc (_Jv_makeUtf8Const): New function. (_Jv_NewObjectArray): Change use of _Jv_FindArrayClass. (_Jv_NewPrimArray): Ditto. (_Jv_FindClassFromSignature): Ditto. * java/lang/reflect/natArray.cc (newInstance): Ditto. * java/lang/reflect/natMethod.cc (getType): Ditto. * include/java-field.h (_Jv_Field::isRef): Make robust for non-resolved contexts. * boehm.cc (_Jv_MarkObj): Mark interpreter-related fields. Also, don't mark class->next field. * java/lang/VirtualMachineError.java: Added FIXME note. * configure.in (INTERPSPEC): New spec. * libgcj.spec.in: Added INTERPSPEC. * Makefile.am: Added gcjh friends for java/lang/VMClassLoader and gnu/gcj/runtime/MethodInvocation. (libgcj_la_SOURCES): Added resolve.cc defineclass.cc interpret.cc. (ordinary_java_source_files): Added above mentioned java classes. * configure: Rebuilt. * Makefile.in: Rebuilt. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@28597 138bc75d-0d04-0410-961f-82ee72b054a4 --- libjava/gnu/gcj/util/path/SearchPath.java | 205 ++++++++++++++++++++++++++++++ 1 file changed, 205 insertions(+) create mode 100644 libjava/gnu/gcj/util/path/SearchPath.java (limited to 'libjava/gnu/gcj/util/path/SearchPath.java') diff --git a/libjava/gnu/gcj/util/path/SearchPath.java b/libjava/gnu/gcj/util/path/SearchPath.java new file mode 100644 index 00000000000..ffc2ca8d178 --- /dev/null +++ b/libjava/gnu/gcj/util/path/SearchPath.java @@ -0,0 +1,205 @@ +// SearchPath.java -- generic search path utility + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/* Author: Kresten Krab Thorup */ + + +package gnu.gcj.util.path; + +import java.util.*; +import java.util.zip.*; +import java.io.*; +import java.net.*; + +final public class SearchPath { + + final static String path_seperator + = System.getProperty ("path.separator"); + final static char path_seperator_char + = path_seperator.charAt (0); + final static String file_seperator + = System.getProperty ("file.separator"); + final static char file_seperator_char + = file_seperator.charAt (0); + + private Vector path; + + /** + * Constructs a SearchPath object, given a system path. + * The system path is expected to be seperated by the string + * defined by the path.seperator property. + * (":" on unix, ; on Windows, etc.). + * The path may contain names of directories, or names of + * .zip or .jar files. Elements that are neither of these + * are ignored. + * @param sys_path the search path + */ + + SearchPath (String sys_path) + { + StringTokenizer st = new StringTokenizer (sys_path, path_seperator); + init (st); + } + + /** + * Constructs a SearchPath object, given a Vector of + * String, File or URL + * objects. + * The path may contain names of directories, or names of + * .zip or .jar files. Elements that are neither of these + * are ignored. + * @param p the vector of search path elements + */ + + SearchPath (Vector p) + { + init (p.elements ()); + } + + public URL getURL (String element) + { + URL result; + + Enumeration e = path.elements (); + while (e.hasMoreElements ()) + { + PathEntry ent = (PathEntry) e.nextElement (); + + result = ent.getURL (element); + + if (result != null) + { + return result; + } + } + + return null; + } + + + public InputStream getStream (String element) + { + InputStream result; + + Enumeration e = path.elements (); + while (e.hasMoreElements ()) + { + PathEntry ent = (PathEntry) e.nextElement (); + + result = ent.getStream (element); + + if (result != null) + { + return result; + } + } + + return null; + } + + + public byte[] getBytes (String element) + { + byte[] result; + + Enumeration e = path.elements (); + while (e.hasMoreElements ()) + { + PathEntry ent = (PathEntry) e.nextElement (); + result = ent.getBytes (element); + if (result != null) + { + System.out.println ("loading " + ent + + "(" + element + ")"); + return result; + } + } + + return null; + } + + + + private void init (Enumeration st) + { + path = new Vector (); + while (st.hasMoreElements ()) + { + Object e = st.nextElement (); + + String elem; + File efile; + + if (e instanceof URL) + { + path.addElement (new URLPathEntry ((URL) e)); + continue; + } + + if (e instanceof File) + { + efile = (File) e; + elem = efile.getPath (); + } + + else if (e instanceof String) + { + elem = (String) e; + efile = new File (elem); + } + + else + throw new IllegalArgumentException (); + + // make sure it is absolute, so we won't get + // trouble if the cwd is changed... + if (! efile.isAbsolute ()) + efile = new File (efile.getAbsolutePath ()); + + if (efile.isDirectory ()) + { + try { + path.addElement(new DirectoryPathEntry (efile)); + } catch (IOException x) { + /* ignore for now */ + } + } + + else if (efile.isFile ()) + { + int ext = elem.lastIndexOf ('.'); + if (ext == -1) + continue; + + if (!elem.substring(ext+1).equalsIgnoreCase("zip")) + continue; + + ZipPathEntry zpe = null; + try { + zpe = new ZipPathEntry (efile); + } catch (ZipException zx) { + System.err.println ("SearchPath::ZipException"); + zpe = null; + } catch (MalformedURLException mx) { + System.err.println ("SearchPath::URLException"); + zpe = null; + } catch (IOException iox) { + System.err.println ("SearchPath::IOException"); + zpe = null; + } + if (zpe != null) path.addElement (zpe); + } + } + + } + + +} + -- cgit v1.2.3