From: <dal...@us...> - 2008-05-10 16:46:57
|
Revision: 12614 http://jedit.svn.sourceforge.net/jedit/?rev=12614&view=rev Author: daleanson Date: 2008-05-10 09:46:55 -0700 (Sat, 10 May 2008) Log Message: ----------- Fixed javadoc warnings. There are still a number of warnings like this: [javadoc] javadoc: warning - Multiple sources of package comments found for package "org.gjt.sp.jedit.search" These are due to a bug in the javadoc tool, see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5095714 Modified Paths: -------------- jEdit/trunk/org/gjt/sp/jedit/BeanShellFacade.java jEdit/trunk/org/gjt/sp/jedit/Buffer.java jEdit/trunk/org/gjt/sp/jedit/GUIUtilities.java jEdit/trunk/org/gjt/sp/jedit/bsh/BshClassManager.java jEdit/trunk/org/gjt/sp/jedit/bsh/BshIterator.java jEdit/trunk/org/gjt/sp/jedit/bsh/CollectionManager.java jEdit/trunk/org/gjt/sp/jedit/bsh/ConsoleInterface.java jEdit/trunk/org/gjt/sp/jedit/bsh/NameSource.java jEdit/trunk/org/gjt/sp/jedit/bsh/NameSpace.java jEdit/trunk/org/gjt/sp/jedit/bsh/This.java jEdit/trunk/org/gjt/sp/jedit/bsh/UtilEvalError.java jEdit/trunk/org/gjt/sp/jedit/bsh/XThis.java jEdit/trunk/org/gjt/sp/jedit/bsh/classpath/BshClassLoader.java jEdit/trunk/org/gjt/sp/jedit/bsh/collection/CollectionIterator.java jEdit/trunk/org/gjt/sp/jedit/bsh/org/objectweb/asm/ClassWriter.java jEdit/trunk/org/gjt/sp/jedit/bufferio/MarkersSaveRequest.java jEdit/trunk/org/gjt/sp/jedit/gui/AbstractContextOptionPane.java jEdit/trunk/org/gjt/sp/jedit/gui/FilteredListModel.java jEdit/trunk/org/gjt/sp/jedit/gui/ShortcutPrefixActiveEvent.java jEdit/trunk/org/gjt/sp/jedit/textarea/TextArea.java jEdit/trunk/org/gjt/sp/jedit/textarea/TextAreaPainter.java Modified: jEdit/trunk/org/gjt/sp/jedit/BeanShellFacade.java =================================================================== --- jEdit/trunk/org/gjt/sp/jedit/BeanShellFacade.java 2008-05-10 15:30:22 UTC (rev 12613) +++ jEdit/trunk/org/gjt/sp/jedit/BeanShellFacade.java 2008-05-10 16:46:55 UTC (rev 12614) @@ -46,7 +46,7 @@ public abstract class BeanShellFacade<T> { //{{{ BeanShellFacade constructor - public BeanShellFacade() + public BeanShellFacade() { classManager = new ClassManagerImpl(); classManager.setClassLoader(new JARClassLoader()); @@ -70,7 +70,7 @@ global.importPackage("org.gjt.sp.jedit.textarea"); global.importPackage("org.gjt.sp.util"); } //}}} - + //{{{ evalSelection() method /** * Evaluates the text selected in the specified text area. @@ -87,7 +87,7 @@ if(returnValue != null) textArea.setSelectedText(returnValue.toString()); } //}}} - + //{{{ eval() method /** * Evaluates the specified BeanShell expression with the global namespace @@ -98,7 +98,7 @@ { return eval(param, global, command); } //}}} - + //{{{ eval() method /** * Evaluates the specified BeanShell expression. Errors are reported in @@ -122,7 +122,7 @@ return null; } //}}} - + //{{{ _eval() method /** * Evaluates the specified BeanShell expression. Unlike @@ -166,7 +166,7 @@ } } } //}}} - + //{{{ cacheBlock() method /** * Caches a block of code, returning a handle that can be passed to @@ -194,13 +194,12 @@ return global.getMethod(name,new Class[0]); } } //}}} - + //{{{ runCachedBlock() method /** * Runs a cached block of code in the specified namespace. Faster than * evaluating the block each time. * @param method The method instance returned by cacheBlock() - * @param view The view * @param namespace The namespace to run the code in * @exception Exception instances are thrown when various BeanShell * errors occur @@ -246,7 +245,7 @@ resetDefaultVariables(namespace); } } //}}} - + //{{{ getNameSpace() method /** * Returns the global namespace. @@ -255,7 +254,7 @@ { return global; } //}}} - + //{{{ resetClassManager() method /** * Causes BeanShell internal structures to drop references to cached @@ -265,27 +264,27 @@ { classManager.reset(); } //}}} - + //{{{ setupDefaultVariables() method protected abstract void setupDefaultVariables(NameSpace namespace, T param) throws UtilEvalError; //}}} //{{{ resetDefaultVariables() method - protected abstract void resetDefaultVariables(NameSpace namespace) + protected abstract void resetDefaultVariables(NameSpace namespace) throws UtilEvalError; //}}} - + //{{{ handleException() method protected abstract void handleException(T param, String path, Throwable t); //}}} - + //{{{ createInterpreter() method protected static Interpreter createInterpreter(NameSpace nameSpace) { return new Interpreter(null,System.out,System.err,false,nameSpace); } //}}} - + //{{{ unwrapException() method /** * This extracts an exception from a 'wrapping' exception, as BeanShell @@ -313,7 +312,7 @@ throw e; } //}}} - + //{{{ Static variables protected NameSpace global; private BshClassManager classManager; Modified: jEdit/trunk/org/gjt/sp/jedit/Buffer.java =================================================================== --- jEdit/trunk/org/gjt/sp/jedit/Buffer.java 2008-05-10 15:30:22 UTC (rev 12613) +++ jEdit/trunk/org/gjt/sp/jedit/Buffer.java 2008-05-10 16:46:55 UTC (rev 12614) @@ -96,7 +96,7 @@ public static final String CARET_POSITIONED = "Buffer__caretPositioned"; /** - * Stores a List of {@link Selection} instances. + * Stores a List of {@link org.gjt.sp.jedit.textarea.Selection} instances. */ public static final String SELECTION = "Buffer__selection"; @@ -590,8 +590,8 @@ updateMarkersFile(view); } }); - - int check = jEdit.getIntegerProperty("checkFileStatus"); + + int check = jEdit.getIntegerProperty("checkFileStatus"); if((! disableFileStatusCheck) && (check == 1 || check == 2)) jEdit.checkBufferStatus(view,false); @@ -2009,7 +2009,7 @@ //{{{ editSyntaxStyle() method /** * Edit the syntax style of the token under the caret. - * + * * @param textArea the textarea where your caret is * @since jEdit 4.3pre11 */ @@ -2017,11 +2017,11 @@ int lineNum = textArea.getCaretLine(); int start = getLineStartOffset(lineNum); int position = textArea.getCaretPosition(); - + DefaultTokenHandler tokenHandler = new DefaultTokenHandler(); markTokens(lineNum,tokenHandler); Token token = tokenHandler.getTokens(); - + while(token.id != Token.END) { int next = start + token.length; Modified: jEdit/trunk/org/gjt/sp/jedit/GUIUtilities.java =================================================================== --- jEdit/trunk/org/gjt/sp/jedit/GUIUtilities.java 2008-05-10 15:30:22 UTC (rev 12613) +++ jEdit/trunk/org/gjt/sp/jedit/GUIUtilities.java 2008-05-10 16:46:55 UTC (rev 12614) @@ -384,7 +384,7 @@ JToolBar toolB = new JToolBar(); toolB.setFloatable(false); toolB.setMargin(new Insets(0,0,0,0)); - + String buttons = jEdit.getProperty(name); if(buttons != null) { @@ -1377,7 +1377,7 @@ * @param x The x co-ordinate * @param y The y co-ordinate * @since jEdit 4.0pre1 - * @see {@link javax.swing.JComponent#setComponentPopupMenu(javax.swing.JPopupMenu)}, + * @see javax.swing.JComponent#setComponentPopupMenu(javax.swing.JPopupMenu) setComponentPopupMenu * which works better and is simpler to use: you don't have to write the code to * show/hide popups in response to mouse events anymore. */ Modified: jEdit/trunk/org/gjt/sp/jedit/bsh/BshClassManager.java =================================================================== --- jEdit/trunk/org/gjt/sp/jedit/bsh/BshClassManager.java 2008-05-10 15:30:22 UTC (rev 12613) +++ jEdit/trunk/org/gjt/sp/jedit/bsh/BshClassManager.java 2008-05-10 16:46:55 UTC (rev 12614) @@ -7,7 +7,7 @@ * * * The contents of this file are subject to the Sun Public License Version * * 1.0 (the "License"); you may not use this file except in compliance with * - * the License. A copy of the License is available at http://www.sun.com * + * the License. A copy of the License is available at http://www.sun.com * * * * The Original Code is BeanShell. The Initial Developer of the Original * * Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright * @@ -41,610 +41,609 @@ import java.lang.reflect.Modifier; /** - BshClassManager manages all classloading in BeanShell. - It also supports a dynamically loaded extension (bsh.classpath package) - which allows classpath extension and class file reloading. + BshClassManager manages all classloading in BeanShell. + It also supports a dynamically loaded extension (bsh.classpath package) + which allows classpath extension and class file reloading. - Currently the extension relies on 1.2 for BshClassLoader and weak - references. + Currently the extension relies on 1.2 for BshClassLoader and weak + references. - See http://www.beanshell.org/manual/classloading.html for details - on the bsh classloader architecture. - <p> + See http://www.beanshell.org/manual/classloading.html for details + on the bsh classloader architecture. + <p> - Bsh has a multi-tiered class loading architecture. No class loader is - used unless/until the classpath is modified or a class is reloaded. - <p> + Bsh has a multi-tiered class loading architecture. No class loader is + used unless/until the classpath is modified or a class is reloaded. + <p> */ /* - Implementation notes: + Implementation notes: - Note: we may need some synchronization in here + Note: we may need some synchronization in here - Note on version dependency: This base class is JDK 1.1 compatible, - however we are forced to use weak references in the full featured - implementation (the optional bsh.classpath package) to accomodate all of - the fleeting namespace listeners as they fall out of scope. (NameSpaces - must be informed if the class space changes so that they can un-cache - names). - <p> + Note on version dependency: This base class is JDK 1.1 compatible, + however we are forced to use weak references in the full featured + implementation (the optional bsh.classpath package) to accomodate all of + the fleeting namespace listeners as they fall out of scope. (NameSpaces + must be informed if the class space changes so that they can un-cache + names). + <p> - Perhaps a simpler idea would be to have entities that reference cached - types always perform a light weight check with a counter / reference - value and use that to detect changes in the namespace. This puts the - burden on the consumer to check at appropriate times, but could eliminate - the need for the listener system in many places and the necessity of weak - references in this package. - <p> + Perhaps a simpler idea would be to have entities that reference cached + types always perform a light weight check with a counter / reference + value and use that to detect changes in the namespace. This puts the + burden on the consumer to check at appropriate times, but could eliminate + the need for the listener system in many places and the necessity of weak + references in this package. + <p> */ public class BshClassManager { - /** Identifier for no value item. Use a hashtable as a Set. */ - private static Object NOVALUE = new Object(); - /** - The interpreter which created the class manager - This is used to load scripted classes from source files. - */ - private Interpreter declaringInterpreter; - - /** - An external classloader supplied by the setClassLoader() command. - */ - protected ClassLoader externalClassLoader; + /** Identifier for no value item. Use a hashtable as a Set. */ + private static Object NOVALUE = new Object(); + /** + The interpreter which created the class manager + This is used to load scripted classes from source files. + */ + private Interpreter declaringInterpreter; - /** - Global cache for things we know are classes. - Note: these should probably be re-implemented with Soft references. - (as opposed to strong or Weak) - */ + /** + An external classloader supplied by the setClassLoader() command. + */ + protected ClassLoader externalClassLoader; + + /** + Global cache for things we know are classes. + Note: these should probably be re-implemented with Soft references. + (as opposed to strong or Weak) + */ protected transient Hashtable absoluteClassCache = new Hashtable(); - /** - Global cache for things we know are *not* classes. - Note: these should probably be re-implemented with Soft references. - (as opposed to strong or Weak) - */ + /** + Global cache for things we know are *not* classes. + Note: these should probably be re-implemented with Soft references. + (as opposed to strong or Weak) + */ protected transient Hashtable absoluteNonClasses = new Hashtable(); - /** - Caches for resolved object and static methods. - We keep these maps separate to support fast lookup in the general case - where the method may be either. - */ - protected transient Hashtable resolvedObjectMethods = new Hashtable(); - protected transient Hashtable resolvedStaticMethods = new Hashtable(); + /** + Caches for resolved object and static methods. + We keep these maps separate to support fast lookup in the general case + where the method may be either. + */ + protected transient Hashtable resolvedObjectMethods = new Hashtable(); + protected transient Hashtable resolvedStaticMethods = new Hashtable(); - protected transient Hashtable definingClasses = new Hashtable(); - protected transient Hashtable definingClassesBaseNames = new Hashtable(); + protected transient Hashtable definingClasses = new Hashtable(); + protected transient Hashtable definingClassesBaseNames = new Hashtable(); - /** - Create a new instance of the class manager. - Class manager instnaces are now associated with the interpreter. + /** + Create a new instance of the class manager. + Class manager instnaces are now associated with the interpreter. - @see org.gjt.sp.jedit.bsh.Interpreter.getClassManager() - @see org.gjt.sp.jedit.bsh.Interpreter.setClassLoader( ClassLoader ) - */ - public static BshClassManager createClassManager( Interpreter interpreter ) - { - BshClassManager manager; + @see org.gjt.sp.jedit.bsh.Interpreter#getClassManager() getClassManager + @see org.gjt.sp.jedit.bsh.Interpreter#setClassLoader(ClassLoader) setClassLoader + */ + public static BshClassManager createClassManager( Interpreter interpreter ) + { + BshClassManager manager; - // Do we have the necessary jdk1.2 packages and optional package? - if ( Capabilities.classExists("java.lang.ref.WeakReference") - && Capabilities.classExists("java.util.HashMap") - && Capabilities.classExists("org.gjt.sp.jedit.bsh.classpath.ClassManagerImpl") - ) - try { - // Try to load the module - // don't refer to it directly here or we're dependent upon it - Class clas = Class.forName( "org.gjt.sp.jedit.bsh.classpath.ClassManagerImpl" ); - manager = (BshClassManager)clas.newInstance(); - } catch ( Exception e ) { - throw new InterpreterError("Error loading classmanager: "+e); - } - else - manager = new BshClassManager(); + // Do we have the necessary jdk1.2 packages and optional package? + if ( Capabilities.classExists("java.lang.ref.WeakReference") + && Capabilities.classExists("java.util.HashMap") + && Capabilities.classExists("org.gjt.sp.jedit.bsh.classpath.ClassManagerImpl") + ) + try { + // Try to load the module + // don't refer to it directly here or we're dependent upon it + Class clas = Class.forName( "org.gjt.sp.jedit.bsh.classpath.ClassManagerImpl" ); + manager = (BshClassManager)clas.newInstance(); + } catch ( Exception e ) { + throw new InterpreterError("Error loading classmanager: "+e); + } + else + manager = new BshClassManager(); - if ( interpreter == null ) - interpreter = new Interpreter(); - manager.declaringInterpreter = interpreter; - return manager; - } + if ( interpreter == null ) + interpreter = new Interpreter(); + manager.declaringInterpreter = interpreter; + return manager; + } - public boolean classExists( String name ) { - return ( classForName( name ) != null ); - } + public boolean classExists( String name ) { + return ( classForName( name ) != null ); + } - /** - Load the specified class by name, taking into account added classpath - and reloaded classes, etc. - Note: Again, this is just a trivial implementation. - See bsh.classpath.ClassManagerImpl for the fully functional class - management package. - @return the class or null - */ - public Class classForName( String name ) - { - if ( isClassBeingDefined( name ) ) - throw new InterpreterError( - "Attempting to load class in the process of being defined: " - +name ); + /** + Load the specified class by name, taking into account added classpath + and reloaded classes, etc. + Note: Again, this is just a trivial implementation. + See bsh.classpath.ClassManagerImpl for the fully functional class + management package. + @return the class or null + */ + public Class classForName( String name ) + { + if ( isClassBeingDefined( name ) ) + throw new InterpreterError( + "Attempting to load class in the process of being defined: " + +name ); - Class clas = null; - try { - clas = plainClassForName( name ); - } catch ( ClassNotFoundException e ) { /*ignore*/ } + Class clas = null; + try { + clas = plainClassForName( name ); + } catch ( ClassNotFoundException e ) { /*ignore*/ } - // try scripted class - if ( clas == null ) - clas = loadSourceClass( name ); + // try scripted class + if ( clas == null ) + clas = loadSourceClass( name ); - return clas; - } - - // Move me to classpath/ClassManagerImpl??? - protected Class loadSourceClass( String name ) - { - String fileName = "/"+name.replace('.','/')+".java"; - InputStream in = getResourceAsStream( fileName ); - if ( in == null ) - return null; + return clas; + } - try { - System.out.println("Loading class from source file: "+fileName); - declaringInterpreter.eval( new InputStreamReader(in) ); - } catch ( EvalError e ) { - // ignore - System.err.println( e ); - } - try { - return plainClassForName( name ); - } catch ( ClassNotFoundException e ) { - System.err.println("Class not found in source file: "+name ); - return null; - } - } + // Move me to classpath/ClassManagerImpl??? + protected Class loadSourceClass( String name ) + { + String fileName = "/"+name.replace('.','/')+".java"; + InputStream in = getResourceAsStream( fileName ); + if ( in == null ) + return null; - /** - Perform a plain Class.forName() or call the externally provided - classloader. - If a BshClassManager implementation is loaded the call will be - delegated to it, to allow for additional hooks. - <p/> + try { + System.out.println("Loading class from source file: "+fileName); + declaringInterpreter.eval( new InputStreamReader(in) ); + } catch ( EvalError e ) { + // ignore + System.err.println( e ); + } + try { + return plainClassForName( name ); + } catch ( ClassNotFoundException e ) { + System.err.println("Class not found in source file: "+name ); + return null; + } + } - This simply wraps that bottom level class lookup call and provides a - central point for monitoring and handling certain Java version - dependent bugs, etc. + /** + Perform a plain Class.forName() or call the externally provided + classloader. + If a BshClassManager implementation is loaded the call will be + delegated to it, to allow for additional hooks. + <p/> - @see #classForName( String ) - @return the class - */ - public Class plainClassForName( String name ) - throws ClassNotFoundException - { - Class c = null; + This simply wraps that bottom level class lookup call and provides a + central point for monitoring and handling certain Java version + dependent bugs, etc. - try { - if ( externalClassLoader != null ) - c = externalClassLoader.loadClass( name ); - else - c = Class.forName( name ); + @see #classForName( String ) + @return the class + */ + public Class plainClassForName( String name ) + throws ClassNotFoundException + { + Class c = null; - cacheClassInfo( name, c ); + try { + if ( externalClassLoader != null ) + c = externalClassLoader.loadClass( name ); + else + c = Class.forName( name ); - /* - Original note: Jdk under Win is throwing these to - warn about lower case / upper case possible mismatch. - e.g. bsh.console bsh.Console - - Update: Prior to 1.3 we were squeltching NoClassDefFoundErrors - which was very annoying. I cannot reproduce the original problem - and this was never a valid solution. If there are legacy VMs that - have problems we can include a more specific test for them here. - */ - } catch ( NoClassDefFoundError e ) { - throw noClassDefFound( name, e ); - } + cacheClassInfo( name, c ); - return c; - } + /* + Original note: Jdk under Win is throwing these to + warn about lower case / upper case possible mismatch. + e.g. bsh.console bsh.Console - /** - Get a resource URL using the BeanShell classpath - @param path should be an absolute path - */ - public URL getResource( String path ) - { - URL url = null; - if ( externalClassLoader != null ) - { - // classloader wants no leading slash - url = externalClassLoader.getResource( path.substring(1) ); - } - if ( url == null ) - url = Interpreter.class.getResource( path ); + Update: Prior to 1.3 we were squeltching NoClassDefFoundErrors + which was very annoying. I cannot reproduce the original problem + and this was never a valid solution. If there are legacy VMs that + have problems we can include a more specific test for them here. + */ + } catch ( NoClassDefFoundError e ) { + throw noClassDefFound( name, e ); + } - return url; - } - /** - Get a resource stream using the BeanShell classpath - @param path should be an absolute path - */ - public InputStream getResourceAsStream( String path ) - { - InputStream in = null; - if ( externalClassLoader != null ) - { - // classloader wants no leading slash - in = externalClassLoader.getResourceAsStream( path.substring(1) ); - } - if ( in == null ) - in = Interpreter.class.getResourceAsStream( path ); + return c; + } - return in; - } + /** + Get a resource URL using the BeanShell classpath + @param path should be an absolute path + */ + public URL getResource( String path ) + { + URL url = null; + if ( externalClassLoader != null ) + { + // classloader wants no leading slash + url = externalClassLoader.getResource( path.substring(1) ); + } + if ( url == null ) + url = Interpreter.class.getResource( path ); - /** - Cache info about whether name is a class or not. - @param value - if value is non-null, cache the class - if value is null, set the flag that it is *not* a class to - speed later resolution - */ - public void cacheClassInfo( String name, Class value ) { - if ( value != null ) - absoluteClassCache.put( name, value ); - else - absoluteNonClasses.put( name, NOVALUE ); - } + return url; + } + /** + Get a resource stream using the BeanShell classpath + @param path should be an absolute path + */ + public InputStream getResourceAsStream( String path ) + { + InputStream in = null; + if ( externalClassLoader != null ) + { + // classloader wants no leading slash + in = externalClassLoader.getResourceAsStream( path.substring(1) ); + } + if ( in == null ) + in = Interpreter.class.getResourceAsStream( path ); - /** - Cache a resolved (possibly overloaded) method based on the - argument types used to invoke it, subject to classloader change. - Static and Object methods are cached separately to support fast lookup - in the general case where either will do. - */ - public void cacheResolvedMethod( - Class clas, Class [] types, Method method ) - { - if ( Interpreter.DEBUG ) - Interpreter.debug( - "cacheResolvedMethod putting: " + clas +" "+ method ); - - SignatureKey sk = new SignatureKey( clas, method.getName(), types ); - if ( Modifier.isStatic( method.getModifiers() ) ) - resolvedStaticMethods.put( sk, method ); - else - resolvedObjectMethods.put( sk, method ); - } + return in; + } - /** - Return a previously cached resolved method. - @param onlyStatic specifies that only a static method may be returned. - @return the Method or null - */ - protected Method getResolvedMethod( - Class clas, String methodName, Class [] types, boolean onlyStatic ) - { - SignatureKey sk = new SignatureKey( clas, methodName, types ); + /** + Cache info about whether name is a class or not. + @param value + if value is non-null, cache the class + if value is null, set the flag that it is *not* a class to + speed later resolution + */ + public void cacheClassInfo( String name, Class value ) { + if ( value != null ) + absoluteClassCache.put( name, value ); + else + absoluteNonClasses.put( name, NOVALUE ); + } - // Try static and then object, if allowed - // Note that the Java compiler should not allow both. - Method method = (Method)resolvedStaticMethods.get( sk ); - if ( method == null && !onlyStatic) - method = (Method)resolvedObjectMethods.get( sk ); + /** + Cache a resolved (possibly overloaded) method based on the + argument types used to invoke it, subject to classloader change. + Static and Object methods are cached separately to support fast lookup + in the general case where either will do. + */ + public void cacheResolvedMethod( + Class clas, Class [] types, Method method ) + { + if ( Interpreter.DEBUG ) + Interpreter.debug( + "cacheResolvedMethod putting: " + clas +" "+ method ); - if ( Interpreter.DEBUG ) - { - if ( method == null ) - Interpreter.debug( - "getResolvedMethod cache MISS: " + clas +" - "+methodName ); - else - Interpreter.debug( - "getResolvedMethod cache HIT: " + clas +" - " +method ); - } - return method; - } + SignatureKey sk = new SignatureKey( clas, method.getName(), types ); + if ( Modifier.isStatic( method.getModifiers() ) ) + resolvedStaticMethods.put( sk, method ); + else + resolvedObjectMethods.put( sk, method ); + } - /** - Clear the caches in BshClassManager - @see public void #reset() for external usage - */ - protected void clearCaches() - { - absoluteNonClasses = new Hashtable(); - absoluteClassCache = new Hashtable(); - resolvedObjectMethods = new Hashtable(); - resolvedStaticMethods = new Hashtable(); - } + /** + Return a previously cached resolved method. + @param onlyStatic specifies that only a static method may be returned. + @return the Method or null + */ + protected Method getResolvedMethod( + Class clas, String methodName, Class [] types, boolean onlyStatic ) + { + SignatureKey sk = new SignatureKey( clas, methodName, types ); - /** - Set an external class loader. BeanShell will use this at the same - point it would otherwise use the plain Class.forName(). - i.e. if no explicit classpath management is done from the script - (addClassPath(), setClassPath(), reloadClasses()) then BeanShell will - only use the supplied classloader. If additional classpath management - is done then BeanShell will perform that in addition to the supplied - external classloader. - However BeanShell is not currently able to reload - classes supplied through the external classloader. - */ - public void setClassLoader( ClassLoader externalCL ) - { - externalClassLoader = externalCL; - classLoaderChanged(); - } + // Try static and then object, if allowed + // Note that the Java compiler should not allow both. + Method method = (Method)resolvedStaticMethods.get( sk ); + if ( method == null && !onlyStatic) + method = (Method)resolvedObjectMethods.get( sk ); - public void addClassPath( URL path ) - throws IOException { - } + if ( Interpreter.DEBUG ) + { + if ( method == null ) + Interpreter.debug( + "getResolvedMethod cache MISS: " + clas +" - "+methodName ); + else + Interpreter.debug( + "getResolvedMethod cache HIT: " + clas +" - " +method ); + } + return method; + } - /** - Clear all loaders and start over. No class loading. - */ - public void reset() { - clearCaches(); - } + /** + Clear the caches in BshClassManager + */ + protected void clearCaches() + { + absoluteNonClasses = new Hashtable(); + absoluteClassCache = new Hashtable(); + resolvedObjectMethods = new Hashtable(); + resolvedStaticMethods = new Hashtable(); + } - /** - Set a new base classpath and create a new base classloader. - This means all types change. - */ - public void setClassPath( URL [] cp ) - throws UtilEvalError - { - throw cmUnavailable(); - } + /** + Set an external class loader. BeanShell will use this at the same + point it would otherwise use the plain Class.forName(). + i.e. if no explicit classpath management is done from the script + (addClassPath(), setClassPath(), reloadClasses()) then BeanShell will + only use the supplied classloader. If additional classpath management + is done then BeanShell will perform that in addition to the supplied + external classloader. + However BeanShell is not currently able to reload + classes supplied through the external classloader. + */ + public void setClassLoader( ClassLoader externalCL ) + { + externalClassLoader = externalCL; + classLoaderChanged(); + } - /** - Overlay the entire path with a new class loader. - Set the base path to the user path + base path. + public void addClassPath( URL path ) + throws IOException { + } - No point in including the boot class path (can't reload thos). - */ - public void reloadAllClasses() throws UtilEvalError { - throw cmUnavailable(); - } + /** + Clear all loaders and start over. No class loading. + */ + public void reset() { + clearCaches(); + } - /** - Reloading classes means creating a new classloader and using it - whenever we are asked for classes in the appropriate space. - For this we use a DiscreteFilesClassLoader - */ - public void reloadClasses( String [] classNames ) - throws UtilEvalError - { - throw cmUnavailable(); - } + /** + Set a new base classpath and create a new base classloader. + This means all types change. + */ + public void setClassPath( URL [] cp ) + throws UtilEvalError + { + throw cmUnavailable(); + } - /** - Reload all classes in the specified package: e.g. "com.sun.tools" + /** + Overlay the entire path with a new class loader. + Set the base path to the user path + base path. - The special package name "<unpackaged>" can be used to refer - to unpackaged classes. - */ - public void reloadPackage( String pack ) - throws UtilEvalError - { - throw cmUnavailable(); - } + No point in including the boot class path (can't reload thos). + */ + public void reloadAllClasses() throws UtilEvalError { + throw cmUnavailable(); + } - /** - This has been removed from the interface to shield the core from the - rest of the classpath package. If you need the classpath you will have - to cast the classmanager to its impl. + /** + Reloading classes means creating a new classloader and using it + whenever we are asked for classes in the appropriate space. + For this we use a DiscreteFilesClassLoader + */ + public void reloadClasses( String [] classNames ) + throws UtilEvalError + { + throw cmUnavailable(); + } - public BshClassPath getClassPath() throws ClassPathException; - */ + /** + Reload all classes in the specified package: e.g. "com.sun.tools" - /** - Support for "import *;" - Hide details in here as opposed to NameSpace. - */ - protected void doSuperImport() - throws UtilEvalError - { - throw cmUnavailable(); - } + The special package name "<unpackaged>" can be used to refer + to unpackaged classes. + */ + public void reloadPackage( String pack ) + throws UtilEvalError + { + throw cmUnavailable(); + } - /** - A "super import" ("import *") operation has been performed. - */ - protected boolean hasSuperImport() - { - return false; - } + /** + This has been removed from the interface to shield the core from the + rest of the classpath package. If you need the classpath you will have + to cast the classmanager to its impl. - /** - Return the name or null if none is found, - Throw an ClassPathException containing detail if name is ambigous. - */ - protected String getClassNameByUnqName( String name ) - throws UtilEvalError - { - throw cmUnavailable(); - } + public BshClassPath getClassPath() throws ClassPathException; + */ - public void addListener( Listener l ) { } + /** + Support for "import *;" + Hide details in here as opposed to NameSpace. + */ + protected void doSuperImport() + throws UtilEvalError + { + throw cmUnavailable(); + } - public void removeListener( Listener l ) { } + /** + A "super import" ("import *") operation has been performed. + */ + protected boolean hasSuperImport() + { + return false; + } - public void dump( PrintWriter pw ) { - pw.println("BshClassManager: no class manager."); - } + /** + Return the name or null if none is found, + Throw an ClassPathException containing detail if name is ambigous. + */ + protected String getClassNameByUnqName( String name ) + throws UtilEvalError + { + throw cmUnavailable(); + } - /** - Flag the class name as being in the process of being defined. - The class manager will not attempt to load it. - */ - /* - Note: this implementation is temporary. We currently keep a flat - namespace of the base name of classes. i.e. BeanShell cannot be in the - process of defining two classes in different packages with the same - base name. To remove this limitation requires that we work through - namespace imports in an analogous (or using the same path) as regular - class import resolution. This workaround should handle most cases - so we'll try it for now. - */ - protected void definingClass( String className ) { - String baseName = Name.suffix(className,1); - int i = baseName.indexOf("$"); - if ( i != -1 ) - baseName = baseName.substring(i+1); - String cur = (String)definingClassesBaseNames.get( baseName ); - if ( cur != null ) - throw new InterpreterError("Defining class problem: "+className - +": BeanShell cannot yet simultaneously define two or more " - +"dependant classes of the same name. Attempt to define: " - + className +" while defining: "+cur - ); - definingClasses.put( className, NOVALUE ); - definingClassesBaseNames.put( baseName, className ); - } + public void addListener( Listener l ) { } - protected boolean isClassBeingDefined( String className ) { - return definingClasses.get( className ) != null; - } + public void removeListener( Listener l ) { } - /** - This method is a temporary workaround used with definingClass. - It is to be removed at some point. - */ - protected String getClassBeingDefined( String className ) { - String baseName = Name.suffix(className,1); - return (String)definingClassesBaseNames.get( baseName ); - } + public void dump( PrintWriter pw ) { + pw.println("BshClassManager: no class manager."); + } - /** - Indicate that the specified class name has been defined and may be - loaded normally. - */ - protected void doneDefiningClass( String className ) { - String baseName = Name.suffix(className,1); - definingClasses.remove( className ); - definingClassesBaseNames.remove( baseName ); - } + /** + Flag the class name as being in the process of being defined. + The class manager will not attempt to load it. + */ + /* + Note: this implementation is temporary. We currently keep a flat + namespace of the base name of classes. i.e. BeanShell cannot be in the + process of defining two classes in different packages with the same + base name. To remove this limitation requires that we work through + namespace imports in an analogous (or using the same path) as regular + class import resolution. This workaround should handle most cases + so we'll try it for now. + */ + protected void definingClass( String className ) { + String baseName = Name.suffix(className,1); + int i = baseName.indexOf("$"); + if ( i != -1 ) + baseName = baseName.substring(i+1); + String cur = (String)definingClassesBaseNames.get( baseName ); + if ( cur != null ) + throw new InterpreterError("Defining class problem: "+className + +": BeanShell cannot yet simultaneously define two or more " + +"dependant classes of the same name. Attempt to define: " + + className +" while defining: "+cur + ); + definingClasses.put( className, NOVALUE ); + definingClassesBaseNames.put( baseName, className ); + } - /* - The real implementation in the classpath.ClassManagerImpl handles - reloading of the generated classes. - */ - public Class defineClass( String name, byte [] code ) - { - throw new InterpreterError("Can't create class ("+name - +") without class manager package."); - /* - Old implementation injected classes into the parent classloader. - This was incorrect behavior for several reasons. The biggest problem - is that classes could therefore only be defined once across all - executions of the script... + protected boolean isClassBeingDefined( String className ) { + return definingClasses.get( className ) != null; + } - ClassLoader cl = this.getClass().getClassLoader(); - Class clas; - try { - clas = (Class)Reflect.invokeObjectMethod( - cl, "defineClass", - new Object [] { - name, code, - new Primitive( (int)0 )/offset/, - new Primitive( code.length )/len/ - }, - (Interpreter)null, (CallStack)null, (SimpleNode)null - ); - } catch ( Exception e ) { - e.printStackTrace(); - throw new InterpreterError("Unable to define class: "+ e ); - } - absoluteNonClasses.remove( name ); // may have been axed previously - return clas; - */ - } + /** + This method is a temporary workaround used with definingClass. + It is to be removed at some point. + */ + protected String getClassBeingDefined( String className ) { + String baseName = Name.suffix(className,1); + return (String)definingClassesBaseNames.get( baseName ); + } - protected void classLoaderChanged() { } + /** + Indicate that the specified class name has been defined and may be + loaded normally. + */ + protected void doneDefiningClass( String className ) { + String baseName = Name.suffix(className,1); + definingClasses.remove( className ); + definingClassesBaseNames.remove( baseName ); + } - /** - Annotate the NoClassDefFoundError with some info about the class - we were trying to load. - */ - protected static Error noClassDefFound( String className, Error e ) { - return new NoClassDefFoundError( - "A class required by class: "+className +" could not be loaded:\n" - +e.toString() ); - } + /* + The real implementation in the classpath.ClassManagerImpl handles + reloading of the generated classes. + */ + public Class defineClass( String name, byte [] code ) + { + throw new InterpreterError("Can't create class ("+name + +") without class manager package."); + /* + Old implementation injected classes into the parent classloader. + This was incorrect behavior for several reasons. The biggest problem + is that classes could therefore only be defined once across all + executions of the script... - protected static UtilEvalError cmUnavailable() { - return new Capabilities.Unavailable( - "ClassLoading features unavailable."); - } + ClassLoader cl = this.getClass().getClassLoader(); + Class clas; + try { + clas = (Class)Reflect.invokeObjectMethod( + cl, "defineClass", + new Object [] { + name, code, + new Primitive( (int)0 )/offset/, + new Primitive( code.length )/len/ + }, + (Interpreter)null, (CallStack)null, (SimpleNode)null + ); + } catch ( Exception e ) { + e.printStackTrace(); + throw new InterpreterError("Unable to define class: "+ e ); + } + absoluteNonClasses.remove( name ); // may have been axed previously + return clas; + */ + } - public static interface Listener - { - public void classLoaderChanged(); - } + protected void classLoaderChanged() { } - /** - SignatureKey serves as a hash of a method signature on a class - for fast lookup of overloaded and general resolved Java methods. - <p> - */ - /* - Note: is using SignatureKey in this way dangerous? In the pathological - case a user could eat up memory caching every possible combination of - argument types to an untyped method. Maybe we could be smarter about - it by ignoring the types of untyped parameter positions? The method - resolver could return a set of "hints" for the signature key caching? + /** + Annotate the NoClassDefFoundError with some info about the class + we were trying to load. + */ + protected static Error noClassDefFound( String className, Error e ) { + return new NoClassDefFoundError( + "A class required by class: "+className +" could not be loaded:\n" + +e.toString() ); + } - There is also the overhead of creating one of these for every method - dispatched. What is the alternative? - */ - static class SignatureKey - { - Class clas; - Class [] types; - String methodName; - int hashCode = 0; + protected static UtilEvalError cmUnavailable() { + return new Capabilities.Unavailable( + "ClassLoading features unavailable."); + } - SignatureKey( Class clas, String methodName, Class [] types ) { - this.clas = clas; - this.methodName = methodName; - this.types = types; - } + public static interface Listener + { + public void classLoaderChanged(); + } - public int hashCode() - { - if ( hashCode == 0 ) - { - hashCode = clas.hashCode() * methodName.hashCode(); - if ( types == null ) // no args method - return hashCode; - for( int i =0; i < types.length; i++ ) { - int hc = types[i] == null ? 21 : types[i].hashCode(); - hashCode = hashCode*(i+1) + hc; - } - } - return hashCode; - } + /** + SignatureKey serves as a hash of a method signature on a class + for fast lookup of overloaded and general resolved Java methods. + <p> + */ + /* + Note: is using SignatureKey in this way dangerous? In the pathological + case a user could eat up memory caching every possible combination of + argument types to an untyped method. Maybe we could be smarter about + it by ignoring the types of untyped parameter positions? The method + resolver could return a set of "hints" for the signature key caching? - public boolean equals( Object o ) { - SignatureKey target = (SignatureKey)o; - if ( types == null ) - return target.types == null; - if ( clas != target.clas ) - return false; - if ( !methodName.equals( target.methodName ) ) - return false; - if ( types.length != target.types.length ) - return false; - for( int i =0; i< types.length; i++ ) - { - if ( types[i]==null ) - { - if ( !(target.types[i]==null) ) - return false; - } else - if ( !types[i].equals( target.types[i] ) ) - return false; - } + There is also the overhead of creating one of these for every method + dispatched. What is the alternative? + */ + static class SignatureKey + { + Class clas; + Class [] types; + String methodName; + int hashCode = 0; - return true; - } - } + SignatureKey( Class clas, String methodName, Class [] types ) { + this.clas = clas; + this.methodName = methodName; + this.types = types; + } + + public int hashCode() + { + if ( hashCode == 0 ) + { + hashCode = clas.hashCode() * methodName.hashCode(); + if ( types == null ) // no args method + return hashCode; + for( int i =0; i < types.length; i++ ) { + int hc = types[i] == null ? 21 : types[i].hashCode(); + hashCode = hashCode*(i+1) + hc; + } + } + return hashCode; + } + + public boolean equals( Object o ) { + SignatureKey target = (SignatureKey)o; + if ( types == null ) + return target.types == null; + if ( clas != target.clas ) + return false; + if ( !methodName.equals( target.methodName ) ) + return false; + if ( types.length != target.types.length ) + return false; + for( int i =0; i< types.length; i++ ) + { + if ( types[i]==null ) + { + if ( !(target.types[i]==null) ) + return false; + } else + if ( !types[i].equals( target.types[i] ) ) + return false; + } + + return true; + } + } } Modified: jEdit/trunk/org/gjt/sp/jedit/bsh/BshIterator.java =================================================================== --- jEdit/trunk/org/gjt/sp/jedit/bsh/BshIterator.java 2008-05-10 15:30:22 UTC (rev 12613) +++ jEdit/trunk/org/gjt/sp/jedit/bsh/BshIterator.java 2008-05-10 16:46:55 UTC (rev 12614) @@ -7,7 +7,7 @@ * * * The contents of this file are subject to the Sun Public License Version * * 1.0 (the "License"); you may not use this file except in compliance with * - * the License. A copy of the License is available at http://www.sun.com * + * the License. A copy of the License is available at http://www.sun.com * * * * The Original Code is BeanShell. The Initial Developer of the Original * * Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright * @@ -34,24 +34,24 @@ package org.gjt.sp.jedit.bsh; /** - An interface implemented by classes wrapping instances of iterators, - enumerations, collections, etc. - @see CollectionManager.getBshIterator(Object) + An interface implemented by classes wrapping instances of iterators, + enumerations, collections, etc. + @see CollectionManager#getBshIterator(Object) getBshIterator */ -public interface BshIterator +public interface BshIterator { - /** - * Fetch the next object in the iteration - * - * @return The next object - */ - public Object next(); - - /** - * Returns true if and only if there are more objects available - * via the <code>next()</code> method - * - * @return The next object - */ - public boolean hasNext(); + /** + * Fetch the next object in the iteration + * + * @return The next object + */ + public Object next(); + + /** + * Returns true if and only if there are more objects available + * via the <code>next()</code> method + * + * @return The next object + */ + public boolean hasNext(); } Modified: jEdit/trunk/org/gjt/sp/jedit/bsh/CollectionManager.java =================================================================== --- jEdit/trunk/org/gjt/sp/jedit/bsh/CollectionManager.java 2008-05-10 15:30:22 UTC (rev 12613) +++ jEdit/trunk/org/gjt/sp/jedit/bsh/CollectionManager.java 2008-05-10 16:46:55 UTC (rev 12614) @@ -7,7 +7,7 @@ * * * The contents of this file are subject to the Sun Public License Version * * 1.0 (the "License"); you may not use this file except in compliance with * - * the License. A copy of the License is available at http://www.sun.com * + * the License. A copy of the License is available at http://www.sun.com * * * * The Original Code is BeanShell. The Initial Developer of the Original * * Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright * @@ -39,161 +39,159 @@ import java.lang.reflect.Array; /** - The default CollectionManager (which remains Java 1.1 compatible) - supports iteration over objects of type: - Enumeration, Vector, String, StringBuffer and array. - The dynamically loaded CollectionManagerImpl supports additional types when - it is present. - - @see BshIterable.java + The default CollectionManager (which remains Java 1.1 compatible) + supports iteration over objects of type: + Enumeration, Vector, String, StringBuffer and array. + The dynamically loaded CollectionManagerImpl supports additional types when + it is present. */ public class CollectionManager { - private static CollectionManager manager; + private static CollectionManager manager; - public synchronized static CollectionManager getCollectionManager() - { - if ( manager == null - && Capabilities.classExists("java.util.Collection") ) - { - Class clas; - try { - clas = Class.forName( "org.gjt.sp.jedit.bsh.collection.CollectionManagerImpl" ); - manager = (CollectionManager)clas.newInstance(); - } catch ( Exception e ) { - Interpreter.debug("unable to load CollectionManagerImpl: "+e); - } - } + public synchronized static CollectionManager getCollectionManager() + { + if ( manager == null + && Capabilities.classExists("java.util.Collection") ) + { + Class clas; + try { + clas = Class.forName( "org.gjt.sp.jedit.bsh.collection.CollectionManagerImpl" ); + manager = (CollectionManager)clas.newInstance(); + } catch ( Exception e ) { + Interpreter.debug("unable to load CollectionManagerImpl: "+e); + } + } - if ( manager == null ) - manager = new CollectionManager(); // default impl - - return manager; - } + if ( manager == null ) + manager = new CollectionManager(); // default impl - /** - */ - public boolean isBshIterable( Object obj ) - { - // This could be smarter... - try { - getBshIterator( obj ); - return true; - } catch( IllegalArgumentException e ) { - return false; - } - } + return manager; + } - public BshIterator getBshIterator( Object obj ) - throws IllegalArgumentException - { - return new BasicBshIterator( obj ); - } + /** + */ + public boolean isBshIterable( Object obj ) + { + // This could be smarter... + try { + getBshIterator( obj ); + return true; + } catch( IllegalArgumentException e ) { + return false; + } + } - public boolean isMap( Object obj ) { - return obj instanceof Hashtable; - } + public BshIterator getBshIterator( Object obj ) + throws IllegalArgumentException + { + return new BasicBshIterator( obj ); + } - public Object getFromMap( Object map, Object key ) { - return ((Hashtable)map).get(key); - } + public boolean isMap( Object obj ) { + return obj instanceof Hashtable; + } - public Object putInMap( Object map, Object key, Object value ) - { - return ((Hashtable)map).put(key, value); - } + public Object getFromMap( Object map, Object key ) { + return ((Hashtable)map).get(key); + } - /** - Determine dynamically if the target is an iterator by the presence of a - pair of next() and hasNext() methods. - public static boolean isIterator() { } - */ + public Object putInMap( Object map, Object key, Object value ) + { + return ((Hashtable)map).put(key, value); + } - /** - * An implementation that works with JDK 1.1 - */ - public static class BasicBshIterator implements BshIterator - { - Enumeration enumeration; - - /** - * Construct a basic BasicBshIterator - * - * @param The object over which we are iterating - * - * @throws java.lang.IllegalArgumentException If the argument is not a - * supported (i.e. iterable) type. - * - * @throws java.lang.NullPointerException If the argument is null - */ - public BasicBshIterator(Object iterateOverMe) { - enumeration = createEnumeration(iterateOverMe); - } - - /** - * Create an enumeration over the given object - * - * @param iterateOverMe Object of type Enumeration, Vector, String, - * StringBuffer or an array - * - * @return an enumeration - * - * @throws java.lang.IllegalArgumentException If the argument is not a - * supported (i.e. iterable) type. - * - * @throws java.lang.NullPointerException If the argument is null - */ - protected Enumeration createEnumeration( Object iterateOverMe ) - { - if(iterateOverMe==null) - throw new NullPointerException("Object arguments passed to " + - "the BasicBshIterator constructor cannot be null."); + /** + Determine dynamically if the target is an iterator by the presence of a + pair of next() and hasNext() methods. + public static boolean isIterator() { } + */ - if (iterateOverMe instanceof Enumeration) - return (Enumeration)iterateOverMe; + /** + * An implementation that works with JDK 1.1 + */ + public static class BasicBshIterator implements BshIterator + { + Enumeration enumeration; - if (iterateOverMe instanceof Vector) - return ((Vector)iterateOverMe).elements(); + /** + * Construct a basic BasicBshIterator + * + * @param iterateOverMe The object over which we are iterating + * + * @throws java.lang.IllegalArgumentException If the argument is not a + * supported (i.e. iterable) type. + * + * @throws java.lang.NullPointerException If the argument is null + */ + public BasicBshIterator(Object iterateOverMe) { + enumeration = createEnumeration(iterateOverMe); + } - if (iterateOverMe.getClass().isArray()) { - final Object array = iterateOverMe; - return new Enumeration() { - int index = 0, length = Array.getLength(array); - public Object nextElement() { - return Array.get(array, index++); - } - public boolean hasMoreElements() { return index<length; } - }; - } - - if (iterateOverMe instanceof String) - return createEnumeration(((String)iterateOverMe).toCharArray()); - - if (iterateOverMe instanceof StringBuffer) - return createEnumeration( - iterateOverMe.toString().toCharArray()); + /** + * Create an enumeration over the given object + * + * @param iterateOverMe Object of type Enumeration, Vector, String, + * StringBuffer or an array + * + * @return an enumeration + * + * @throws java.lang.IllegalArgumentException If the argument is not a + * supported (i.e. iterable) type. + * + * @throws java.lang.NullPointerException If the argument is null + */ + protected Enumeration createEnumeration( Object iterateOverMe ) + { + if(iterateOverMe==null) + throw new NullPointerException("Object arguments passed to " + + "the BasicBshIterator constructor cannot be null."); - throw new IllegalArgumentException( - "Cannot enumerate object of type "+iterateOverMe.getClass()); - } - - /** - * Fetch the next object in the iteration - * - * @return The next object - */ - public Object next() { - return enumeration.nextElement(); - } - - /** - * Returns true if and only if there are more objects available - * via the <code>next()</code> method - * - * @return The next object - */ - public boolean hasNext() { - return enumeration.hasMoreElements(); - } - } + if (iterateOverMe instanceof Enumeration) + return (Enumeration)iterateOverMe; + + if (iterateOverMe instanceof Vector) + return ((Vector)iterateOverMe).elements(); + + if (iterateOverMe.getClass().isArray()) { + final Object array = iterateOverMe; + return new Enumeration() { + int index = 0, length = Array.getLength(array); + public Object nextElement() { + return Array.get(array, index++); + } + public boolean hasMoreElements() { return index<length; } + }; + } + + if (iterateOverMe instanceof String) + return createEnumeration(((String)iterateOverMe).toCharArray()); + + if (iterateOverMe instanceof StringBuffer) + return createEnumeration( + iterateOverMe.toString().toCharArray()); + + throw new IllegalArgumentException( + "Cannot enumerate object of type "+iterateOverMe.getClass()); + } + + /** + * Fetch the next object in the iteration + * + * @return The next object + */ + public Object next() { + return enumeration.nextElement(); + } + + /** + * Returns true if and only if there are more objects available + * via the <code>next()</code> method + * + * @return The next object + */ + public boolean hasNext() { + return enumeration.hasMoreElements(); + } + } } Modified: jEdit/trunk/org/gjt/sp/jedit/bsh/ConsoleInterface.java =================================================================== --- jEdit/trunk/org/gjt/sp/jedit/bsh/ConsoleInterface.java 2008-05-10 15:30:22 UTC (rev 12613) +++ jEdit/trunk/org/gjt/sp/jedit/bsh/ConsoleInterface.java 2008-05-10 16:46:55 UTC (rev 12614) @@ -7,7 +7,7 @@ * * * The contents of this file are subject t... [truncated message content] |