Commits

Anonymous committed 4f99aa6

Updated to jde-2.0.5

Comments (0)

Files changed (7)

+1998-06-30  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde-gen.el: Added source file boilerplate support.
+
+	* jde-run.el: Fixed jde-run-parse-args to recognize % as an argument
+	character.
+
+	* jde-db.el:
+	Added variables `jde-db-read-vm-args' and `jde-db-read-app-args'. The use of
+	these variables is the same as the corresponding jde-run variables.
+
+1998-06-29  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde.el:
+	Added the customization variable `jde-read-compile-args'. If non-nil,
+	this variable causes the jde-compile command to read compilation options
+	from the minibuffer and append them to the options specified by
+	the `jde-compile-option group of customization' variables. The JDE
+	maintains a history of compiler options entered in the minibuffer.
+
+	* jde-run.el:
+	Added the variables `jde-run-read-vm-args' and `jde-run-read-app-args'.
+	The first cause the jde-run command to read vm arguments from the
+	minibuffer and append them to the vm arguments specified by
+	the `jde-run-option' group of customization variables. The second
+	causes jde-run to read arguments to be passed to the application
+	from the minibuffer and append them to the arguments specified
+	by `jde-run-applications-args'. The JDE maintains separate histories
+	for both types of arguments.
+
+1998-06-28  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde.el: Use fboundp instead of Emacs version to determine whether
+	easy-menu-create-menu is bound.
+
+	* jde-db.el: Fixed bug in marker filter.
+
+1998-06-26  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde.el:
+	Fixed bug where the JDE was invoking global-font-lock-mode on XEmacs,
+	where it is not defined.
+
+	Updated JDE to call easy-menu-create-menu instead of easy-menu-create-keymaps
+	on Emacs 20. (The former replaces the latter as of Emacs 20.x);
+
+	* jde-db.el:
+	Provided a hack to handle reordering of threaded messages on Solaris.
+
+	Provided code to handle case where current class has no line number
+	information.
+
+	* jde-gen.el:
+	Fixed capitalization on get-set method pair. Thanks to Jere_McDevitt@HomeDepot.COM
+
+1998-06-25  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde-db.el: Removed debug messages from jde-db-marker-filter.
+
+	* jde-db.el:
+	Modified jde-db-marker-filter to accummulate debugger output
+	in chunks. Fixes bug reported by Eric Prud'hommeaux (eric@w3.org).
+
+1998-06-21  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde-db.el:
+	Added jde-db-startup-commands variable. This variable allows you to
+	specify debugger commands to run when the debugger is started.
+
+	* jde.el: Updated JDE version number to 2.0.2.
+
+	* jde.el: Changed buffer change code to reload a project file
+	when a user changed jde-mode buffers, not just .java
+	buffers. This allows using extensions other than .java
+	for Java source code files.
+
+	Made post-command-hook buffer local to improve performance.
+
+	Thanks to David J. Biesack( sasdjb@unx.sas.com) for the above changes.
+
+1998-06-20  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde-db.el:
+	Added a customizable feature, jde-db-set-initial-breakpoint, that causes
+	the JDE to set an initial breakpoint in an app's main routine and run
+	to the breakpoint on debugger startup. The feature is enabled by default.
+
+	* jde-db.el:
+	Made jde-db-marker-regexp a custom variable to facilitate the use of the JDE
+	with debuggers other than jdb.
+
+	Changed the marker regular expression to detect only jdb breakpoint messages,
+	i.e., messages of the form
+
+	  Breakpoint hit: qualified.class.name (class:line)
+
+	This should eliminate the problem of spurious hits when exceptions occur and
+	stack traces are printed.
+
+1998-06-18  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde.el: Added XEmacs compatibility changes requested by xemacs.org.
+
+1998-06-16  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde.el: Added support for abbreviations.
+
+	* jde-gen.el:
+	Fixed bug that caused jfc-app to be generated instead of console app.
+	Added a mouse motion listener template.
+	Added a toString method template.
+
+1998-05-28  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde-make.el:
+	Added dummy function for jde-make-mode to facilitate autoloading.
+
+	* jde.el: Added no-op function for jde-mode to facilitate autoloading.
+	Thanks to Andy Piper <andyp@parallax.co.uk> for the suggestion.
+
+1998-05-27  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde.el: Updated JDE version number to 2.01.
+	
+	* jde-db.el, jde-make.el, jde-run.el, jde-gen.el:
+	Added autoload comments.
+
+	* jde.el: Added autoload comments for JDE functions.
+
+1998-05-17  paulk@mathworks.com  <paulk@PAULK_HOMEPC>
+
+	* jde.el:
+	Changed names of the Files->JDE New->Custom and JDE-Autocode->Custom
+	to Other...
+
+	* jde-gen.el:
+	Added templates for a Swing application and an inner class.
+
+	Fixed a bug in jde-gen-buffer
+
 1998-04-19  paulk@mathworks.com  <kinnucan@HOMEPC>
 
 	* jde.el: Updated version number.
 # along with XEmacs; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 # Boston, MA 02111-1307, USA.
-VERSION = 1.02
-AUTHOR_VERSION = 2.01
+VERSION = 1.03
+AUTHOR_VERSION = 2.05
 MAINTAINER = Andy Piper <andyp@parallax.co.uk>
 #MAINTAINER = Paul Kinnucan <paulk@mathworks.com>
 PACKAGE = jde
 <HTML>
 <HEAD>
    <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
-   <META NAME="GENERATOR" CONTENT="Mozilla/4.04 [en] (Win95; I) [Netscape]">
+   <META NAME="GENERATOR" CONTENT="Mozilla/4.05 [en] (Win95; I) [Netscape]">
    <TITLE>JDE User's Guide</TITLE>
 </HEAD>
 <BODY BGCOLOR="#FFFFFF">
 Contents</H2>
 <A HREF="#Introduction">Introduction</A>
 
-<P><A HREF="#ConfiguringJDE">Configuring the JDE</A>
+<P><A HREF="#EditingJavaSourceFiles">Editing Java Source Files</A>
 
 <P><A HREF="#Generating Code Automatically">Generating Code Automatically</A>
 
-<P><A HREF="#EditingJavaSourceFiles">Editing Java Source Files</A>
-
 <P><A HREF="#CompilingJavaPrograms">Compiling Java Programs</A>
 
 <P><A HREF="#BuildingJavaApplications">Building Java Applications</A>
 
 <P><A HREF="#BrowsingSourceCode">Browsing Source Code</A>
 
+<P><A HREF="#ConfiguringJDE">Configuring the JDE</A>
+
 <P><A HREF="#Customizingjde_mode">Customizing jde-mode</A>
 <H2>
 <A NAME="Introduction"></A>Introduction</H2>
 in the source code.</LI>
 
 <LI>
+generates class and method skeletons automatically</LI>
+
+<LI>
 run Java application in an interactive (comint) Emacs buffer</LI>
 
 <LI>
 Latest Version</H3>
 See the <A HREF="http://sunsite.auc.dk/jde/">Emacs JDE Home Page</A> for
 instructions on downloading and installing the most recent version of the
-JDE>
+JDE.
 <H3>
 Contacting the Author</H3>
 Please send bug reports and enhancement suggestions to Paul Kinnucan at
 <A HREF="mailto:paulk@mathworks.com">paulk@mathworks.com</A>.
+<BR>&nbsp;
 <H2>
-<A NAME="ConfiguringJDE"></A>Configuring the JDE</H2>
-The JDE is highly customizable. You can specify everything from what compiler
-the JDE uses to compile Java source files to what color it uses to color
-comments in a source file. You configure the JDE by setting the values
-of configuration variables. Some of these variables are defined by the
-JDE itself; some are defined by the packages on which the JDE relies, such
-as cc-mode, custom, speedbar, and so on. The names of configuration variables
-defined by the JDE begin with jde-. The variables defined by other packages
-have other prefixes.
+<A NAME="EditingJavaSourceFiles"></A>Editing Java Source Files</H2>
+To edit an existing Java source file, load it into an Emacs buffer by executing
+<TT>C-x f</TT>. Loading a Java source file into a buffer causes the buffer
+to enter into <TT>java-mode</TT>, a variant of the standard Emacs <TT>cc-mode</TT>
+for editing source files written in C and related languages. Java mode
+offers all the specialized source file editing commands of <TT>cc-mode</TT>
+plus functions for compiling, running, and debugging Java source files.
+You can invoke the commands by selecting them from the <B>JDE</B> menu
+that <TT>java-mode</TT> displays on the Emacs menu bar or by typing the
+commands in the Emacs minibuffer (see the figure below).
 
-<P>You can use any of the following methods to set configuration variables
+<P>&nbsp;<IMG SRC="fig1.gif" HEIGHT=393 WIDTH=585>
 <BR>&nbsp;
-<UL>
-<LI>
-insert Lisp <TT>setq</TT> forms in your Emacs initialization (<TT>.emacs</TT>)
-file</LI>
-
-<BR>For example, the following form tells the JDE not to turn on font-locking
-(syntax coloring).
-<BR><TT>(setq jde-use-font-lock nil)</TT>
+<H2>
+Abbreviations</H2>
+The JDE provides an optional abbreviation mode for Java keywords. When
+this mode is enabled, you can type an abbreviation and JDE replaces the
+abbreviation with the keyword. For example, in abbreviation mode, to enter
+the Java keyword <TT>extend</TT>, type <TT>ext</TT> followed by a space.
+The JDE&nbsp; replaces <TT>ex</TT> with <TT>extend</TT>. To enable abbreviation
+mode, select <B><FONT SIZE=-1>JDE->Options->Project</FONT></B> and
+<BR>toggle the boolean variable <TT>jde-enable-abbrev-mode</TT>. To change,
+remove, or add an abbreviation, edit the variable <TT>jde-mode-abbreviation</TT>s
+in the project customization buffer.
 <BR>&nbsp;
-<LI>
-interactively, using keyboard commands</LI>
-
-<BR>The JDE provides commands for setting some configuration variables.
-For example, the command
-<BR><TT>M-x set-compile-options</TT>
-<BR>sets the variable <TT>jde-compile-option-command-line-args</TT> to
-a string of compiler command-line arguments that you specify. The JDE passes
-this string to the compiler whenever you invoke the JDE compile command.
-<BR>&nbsp;
-<LI>
-interactively, using the Emacs customization feature</LI>
-</UL>
-
-<H3>
-About the Emacs Customization Feature</H3>
-The Emacs customization feature is a new feature that allows you to locate
-and set configuration variables by interacting with text "widgets" (buttons,
-text fields, checkboxes, menus) displayed in a customization buffer. (You
-can think of such a buffer as the Emacs equivalent of a dialog box). The
-customization feature arranges all Emacs customization variables, including
-those provide by Emacs extension packages, such as cc-mode and the JDE,
-in a tree-structured hierarchy of customization groups. You can navigate
-up and down the customization tree by clicking navigation buttons in customization
-buffers. To display the root customization buffer (the Emacs group), type
-<TT>M-x customize</TT>. The root buffer displays the next layer of customization
-groups in the hierarchy. You can navigate to these groups by clicking their
-names, and so on, until you reach the group containing the variable(s)
-you want to set.
-
-<P>The buffer for each group lists the variables and subgroups that the
-group contains. For each variable, the buffer lists the variable's current
-value and documentation. You can change the current value by interacting
-with text widgets associated with the variable.&nbsp; Each variable has
-an associated State button that displays a menu of options for setting
-the variable's value. The options include applying a change permanently
-or only for the duration of the current session or restoring the variable's
-default value. If you choose to apply a change permanently, Emacs saves
-the new value in a customization file. By default, the customization file
-is your .emacs file.You can specify another file by setting an option in
-the Custom Group. For more information, see <A HREF="http://www.dina.kvl.dk/~abraham/custom/">custom.</A>
-<BR>&nbsp;
-<H3>
-&nbsp;JDE Customization Groups</H3>
-The JDE defines a top-level customization group, the JDE Group, for JDE
-configuration variables. The JDE Group itself contains the following subgroups
-<H4>
-Compile Option Group</H4>
-Specifies compile options corresponding to the command-line arguments (e.g.,
--d) accepted by the JDK compiler, javac. When you execute the JDE compile
-command, the JDE uses the settings of this group to construct a list of
-command-line arguments that it passes to the Java compiler that the JDE
-uses to compile Java source programs. The compiler is itself an option
-that you can specify (see the Project Option Group). You can specify command-line
-arguments directly by setting the value of the <TT>jde-compile-option-command-line-args</TT>
-variable. You can display the customization buffer for the Compile Option
-Group by selecting <B>Options->Compile</B> from the <B>JDE</B> menu.
-<H4>
-Run Option Group</H4>
-Specifies run-time options corresponding to the command-line arguments
-(for example, -classpath) accepted by the JDK virtual machine, java. When
-you execute the JDE Run command,&nbsp; the JDE uses the settings of this
-group to construct a list of command-line arguments that it passes to the
-Java interpreter used by the JDE to run applications. This group also contains
-options for specifying non-java command-line arguments (in case you want
-to use a vm that accepts a different set of arguments than java does) and
-for specifying arguments to be passed to the application (as opposed to
-the virtual machine interpreting the application.) You can display the
-customization buffer for the Run Option Group by selecting <B>Options->Run</B>
-from the <B>JDE</B> menu.
-<H4>
-Debug Option Group</H4>
-Specifies run-time options corresponding to the command-line arguments
-(for example, -classpath) accepted by the JDK debugger, jdb. jdb accepts
-the same command-line arguments as java. However, the JDE maintains two
-parallel sets of configuration variables for these programs in case you
-want to use a different set of options for running a program in debug mode
-then you use for running it normally. When you execute the JDE Debug command,&nbsp;
-the JDE uses the settings of this group to construct a list of command-line
-arguments that it passes to the Java debugger used by the JDE to run applications
-in debug mode. You can display the customization buffer for the Debug Option
-Group by selecting <B>Options->Debug</B> from the <B>JDE</B> menu.
-<H4>
-Autocode Group</H4>
-Specifies templates used to generate code automatically.
-<H4>
-Project Options Group</H4>
-Specify all other JDE options. You can display the customization buffer
-for the Debug Option Group by selecting <B>Options->Debug</B> from the
-<B>JDE</B> menu.
 <H2>
 <A NAME="Generating Code Automatically"></A>Generating Code Automatically</H2>
 The JDE provides a set of commands that generate skeleton Java code for
 class of the same name as the newly created file. In particular, the command
 <UL>
 <LI>
-<B>Files->JDE New->Class</B> creates a buffer containing a generic Java
-public class.</LI>
+<B><FONT SIZE=-1>Files->JDE New->Class</FONT></B> creates a buffer containing
+a generic Java public class.</LI>
 
 <LI>
-<B>Files->JDE New->Console</B> creates a buffer containing&nbsp; the main
-class of a Java console application.</LI>
+<B><FONT SIZE=-1>Files->JDE New->Console</FONT></B> creates a buffer containing&nbsp;
+the main class of a Java console application.</LI>
 
 <LI>
-<B>Files->JDE NEw->Custom</B> prompts you to create any of the above buffers
-or a custom (user-defined) buffer.</LI>
+<B><FONT SIZE=-1>Files->JDE NEw->Other</FONT></B> prompts you to create
+any of the above buffers or a custom (user-defined) buffer.</LI>
 </UL>
-You can create an empty Java class buffer&nbsp; by selecting <B>Files->Open</B>
+You can create an empty Java class buffer&nbsp; by selecting <B><FONT SIZE=-1>Files->Open</FONT></B>
 (<TT>C-x f</TT>) and entering the path for a new file whose root name is
 the same as the class you want to create and whose extension is <TT>.java.</TT>
 
 
 <TH>Group</TH>
 
-<TH>Variable</TH>
+<TH>Usage</TH>
 </TR>
 
 <TR>
 
 <TD>Autocode</TD>
 
-<TD>Defines a template for a generic public class buffer.</TD>
+<TD>Template for a generic public class buffer.</TD>
 </TR>
 
 <TR>
 
 <TD>Autocode</TD>
 
-<TD>Defines a template for a console application buffer.</TD>
+<TD>Template for a console application buffer.</TD>
+</TR>
+
+<TR>
+<TD><TT>jde-gen-jfc-app-buffer-template</TT></TD>
+
+<TD>Autocode</TD>
+
+<TD>Template for a JFC (Swing) application.</TD>
 </TR>
 
 <TR>
 for a specified component.</LI>
 
 <LI>
-<B>JDE->Generate->Custom</B> allows you to select any of the above templates
+<B>JDE->Generate->Other</B> allows you to select any of the above templates
 or a custom (user-defined) template.</LI>
 </UL>
 &nbsp;The following variables control generation of code at point:
 
 <TH>Group</TH>
 
-<TH>Variable</TH>
+<TH>Usage</TH>
 </TR>
 
 <TR>
 </TR>
 
 <TR>
+<TD VALIGN=TOP><TT>jde-gen-inner-class-template</TT></TD>
+
+<TD VALIGN=TOP>Autocode</TD>
+
+<TD>Defines a template for creating a class inside another class or inside
+an existing source buffer.</TD>
+</TR>
+
+<TR>
 <TD><TT>jde-gen-code-templates</TT></TD>
 
 <TD>Autocode</TD>
 you can specify different sets of templates for different projects, by
 setting and saving the template list variables in project files.
 <H2>
-<A NAME="EditingJavaSourceFiles"></A>Editing Java Source Files</H2>
-To edit an existing Java source file, load it into an Emacs buffer by executing
-<TT>C-x f</TT>. Loading a Java source file into a buffer causes the buffer
-to enter into <TT>java-mode</TT>, a variant of the standard Emacs <TT>cc-mode</TT>
-for editing source files written in C and related languages. Java mode
-offers all the specialized source file editing commands of <TT>cc-mode</TT>
-plus functions for compiling, running, and debugging Java source files.
-You can invoke the commands by selecting them from the <B>JDE</B> menu
-that <TT>java-mode</TT> displays on the Emacs menu bar or by typing the
-commands in the Emacs minibuffer (see the figure below).
-
-<P><IMG SRC="fig1.gif" HEIGHT=255 WIDTH=425>
-<H2>
 <A NAME="CompilingJavaPrograms"></A>Compiling Java Programs</H2>
 The <TT>jde-compile</TT> command (<B>JDE->Compile, </B><TT>C-c C-v C-c</TT>)
 compiles the Java source file in the current buffer, using <TT>javac</TT>,
 &nbsp;
 <H2>
 <A NAME="BuildingJavaApplications"></A>Building Java Applications</H2>
-The <B>JDE->Build</B> command builds or rebuilds an application. This command
-has two operating modes: java and make. In java mode, this command uses
-javac's built-in make facility to rebuild a project. In make mode, this
-command uses a user-specified make utility, such as GNU make, to rebuild
-a project. See&nbsp; <A HREF="#SampleMakefile">Sample Makefile</A>&nbsp;
-for an example of a makefile for building a Java project. JDE configuration
-variables control which mode is used. In particular, if the variable <TT>jde-build-use-make</TT>
-is non-<TT>nil</TT>, this command invokes the make program specified by
-the variable <TT>jde-make-program</TT>. If the variable <TT>jde-make-args</TT>
-is a non-empty string, this function uses its contents to invoke make;
-otherwise, it prompts you to enter command-line arguments for make. If
-<TT>jde-build-use-make</TT> is <TT>nil</TT>, this function invokes javac
-on the source file specified by <TT>jde-run-app-class</TT>, with the <TT>-depend</TT>
-option. This causes javac to recompile all missing or out-of-date files
-required to run the application's main class.
+The <B><FONT SIZE=-1>JDE->Build</FONT></B> command builds or rebuilds an
+application. This command has two operating modes: java and make. In java
+mode, this command uses javac's built-in make (<TT>-depend</TT>) facility
+to rebuild a project. In make mode, this command uses a user-specified
+make utility, such as GNU make, to rebuild a project. See&nbsp; <A HREF="#SampleMakefile">Sample
+Makefile</A>&nbsp; for an example of a makefile for building a Java project.
+JDE configuration variables control which mode is used. In particular,
+if the variable <TT>jde-build-use-make</TT> is non-<TT>nil</TT>, this command
+invokes the make program specified by the variable <TT>jde-make-program</TT>.
+If the variable <TT>jde-make-args</TT> is a non-empty string, this function
+uses its contents to invoke make; otherwise, it prompts you to enter command-line
+arguments for make. If <TT>jde-build-use-make</TT> is <TT>nil</TT>, this
+function invokes javac on the source file specified by <TT>jde-run-app-class</TT>,
+with the <TT>-depend</TT> option. This causes javac to recompile all missing
+or out-of-date files required to run the application's main class.
 
 <P>The following table summarizes the usage of the build configuration
 variables.
 extensive set of command-line history commands to speed interaction. To
 run an application, enter
 <BLOCKQUOTE><TT>M-x jde-run</TT></BLOCKQUOTE>
-or select <B>Java->Run App</B> on the Emacs menubar or type <TT>C-c C-v
-C-r</TT>.
+or select <B><FONT SIZE=-1>Java->Run App</FONT></B> on the Emacs menubar
+or type <TT>C-c C-v C-r</TT>.
 <H3>
 Run-Time Options</H3>
 The JDE allows you to specify run-time options by setting run variables.You
 can use the Emacs customization feature to set run-time variables interactively.
-To use the customization feature, select <B>Options->Run</B> from the <B>JDE</B>
-menu. (See <A HREF="#ConfiguringJDE">Configuring the JDE</A> for more information
-on using the customization feature). In some cases, the JDE also provides
-functions for setting the buffer-local values of the compilation variables.
-To save the compilation settings in the project file (see <A HREF="#UsingProjectFiles">Using
-Project Files</A>) for the current source buffer, select <B>Options->Update
-Project</B> from the <B>JDE</B> menu.
+To use the customization feature, select <B><FONT SIZE=-1>Options->Run</FONT></B>
+from the <B><FONT SIZE=-1>JDE</FONT></B> menu. (See <A HREF="#ConfiguringJDE">Configuring
+the JDE</A> for more information on using the customization feature). In
+some cases, the JDE also provides functions for setting the buffer-local
+values of the compilation variables. To save the compilation settings in
+the project file (see <A HREF="#UsingProjectFiles">Using Project Files</A>)
+for the current source buffer, select <B><FONT SIZE=-1>Options->Update
+Project</FONT></B> from the <B><FONT SIZE=-1>JDE</FONT></B> menu.
 
 <P>The following table lists the JDE run-time variables and the functions
 used to set them.
 <A NAME="RunningApplets"></A>Running Applets</H2>
 The JDE lets you run an applet as a subprocess of the current Emacs session.
 To run an applet, enter
-<BLOCKQUOTE>M-x jde-run-applet</BLOCKQUOTE>
-or select <B>Java->Run Applet</B> from the Emacs menu bar or type <TT>C-c
-C-v C-a</TT>. If you type the command <TT>jde-run-applet</TT>, the JDE
-prompts you to enter the name of the document that contains the applet.
-By default, It opens the specified document in <TT>appletviewer</TT>, the
-applet viewer suppled with the JDK. You can specify another viewer via
-the <TT>jde-run-applet-viewer</TT> variable. If you select <B>Java->Run
-Applet</B>, the JDE assumes by default that you want to view a document
+<BLOCKQUOTE><TT>M-x jde-run-applet</TT></BLOCKQUOTE>
+or select <B><FONT SIZE=-1>Java->Run Applet</FONT></B> from the Emacs menu
+bar or type <TT>C-c C-v C-a</TT>. If you type the command <TT>jde-run-applet</TT>,
+the JDE prompts you to enter the name of the document that contains the
+applet. By default, It opens the specified document in <TT>appletviewer</TT>,
+the applet viewer suppled with the JDK. You can specify another viewer
+via the <TT>jde-run-applet-viewer</TT> variable. If you select <B><FONT SIZE=-1>Java->Run
+Applet</FONT></B>, the JDE assumes by default that you want to view a document
 called <TT>index.html</TT> and that that document is located in the current
 directory. You can specify another document via the <TT>jde-run-applet-doc</TT>
 variable. The JDE opens the specified document in the current viewer.
 The JDE allows you to specify run-time options for applets by setting JDE
 configuration variables.You can use the Emacs customization feature to
 set applet run-time variables interactively. To use the customization feature,
-select <B>Options->Run</B> from the <B>JDE</B> menu. (See <A HREF="#ConfiguringJDE">Configuring
-the JDE</A> for more information on using the customization feature). In
-some cases, the JDE also provides functions for setting the buffer-local
-values of the compilation variables. To save the compilation settings in
-the project file (see <A HREF="#UsingProjectFiles">Using Project Files</A>)
-for the current source buffer, select <B>Options->Update Project</B> from
-the <B>JDE</B> menu.
+select <B><FONT SIZE=-1>Options->Run</FONT></B> from the <B><FONT SIZE=-1>JDE</FONT></B>
+menu. (See <A HREF="#ConfiguringJDE">Configuring the JDE</A> for more information
+on using the customization feature). In some cases, the JDE also provides
+functions for setting the buffer-local values of the compilation variables.
+To save the compilation settings in the project file (see <A HREF="#UsingProjectFiles">Using
+Project Files</A>) for the current source buffer, select <B><FONT SIZE=-1>Options->Update
+Project</FONT></B> from the <B><FONT SIZE=-1>JDE</FONT></B> menu.
 
 <P>The following table lists the JDE applet run-time variables and the
 functions used to set them.
 </TR>
 
 <TR>
-<TD VALIGN=TOP>jde-run-applet-viewer</TD>
+<TD VALIGN=TOP><TT>jde-run-applet-viewer</TT></TD>
 
 <TD VALIGN=TOP>Project&nbsp;</TD>
 
 </TR>
 
 <TR>
-<TD VALIGN=TOP>jde-run-applet-doc</TD>
+<TD VALIGN=TOP><TT>jde-run-applet-doc</TT></TD>
 
 <TD VALIGN=TOP>Project&nbsp;</TD>
 
 
 <H3>
 Starting the Debugger</H3>
-The jde-db command (<B>JDE->Debug</B>, <TT>C-c C-v C-d</TT>) starts the
-debugger and opens a debugger interaction window.
+To start the debugger, run the <TT>jde-db</TT> command (<B><FONT SIZE=-1>JDE->Debug</FONT></B>,
+<TT>C-c C-v C-d</TT>). The JDE splits the Emacs window into two frames.
+One shows the debugger interaction buffer. The other frame displays your
+application's main method. An arrow (=>) points to the main method's first
+line. The menu bar of the source buffer displays a menu (<B><FONT SIZE=-1>Jdb</FONT></B>)
+of debug commands.
 
-<P><IMG SRC="debug1.gif" HEIGHT=383 WIDTH=585>
+<P>&nbsp;<IMG SRC="debug1.gif" HEIGHT=457 WIDTH=601>
+<H3>
+Entering Debugger Commands</H3>
+The JDE lets you enter commands from either the current source buffer or
+from the debugger command-line interaction buffer. You can enter all debugger
+commands from the debugger buffer. You can enter only a subset of debugger
+commands from the current source buffer.
+<H4>
+Entering Commands from the Current Source Buffer</H4>
+The current source buffer is the buffer in which your program is currently
+halted (initially the buffer containing the source for your program's main
+class).To enter a debugger command from the current source buffer, select
+the command from the jdb menu or type the shortcut key for the command.
+The <B><FONT SIZE=-1>jdb</FONT></B> menu lists the shortcut keys for debugger
+commands.
+<H4>
+&nbsp;Entering Commands in the Debugger Interaction Window</H4>
+To enter a command in the debugger interaction window, type the command
+at the debugger prompt and press the <TT>Enter</TT> key. To see a list
+of debugger commands, enter the command <TT>help</TT>.
 <H3>
 Running an Application Step-by-Step</H3>
-First set a breakpoint at the line where you want to begin stepping through
-your program (see <A HREF="#SettingBreakpoints">Setting Breakpoints</A>).
-You can set other breakpoints at this point as well. Then, at the debugger
-prompt (<TT>></TT>), type the <TT>run</TT> command. The debugger runs your
-program, stopping at the initial breakpoint. The JDE splits the Emacs window
-into two frames. One shows the debugger interaction buffer. The other frame
-displays the source file containing the line at which your program has
-stopped. An arrow (=>) points to the current line. The menu bar of the
-source buffer displays a menu (<B>Jdb</B>) of debug commands.
-
-<P><IMG SRC="debug3.gif" HEIGHT=383 WIDTH=641>
-
-<P>At this point, you can step through your code by entering commands in
-either the Java source buffer or the jdb interaction buffer.
+Set a breakpoint at the line where you want to begin stepping through your
+program (see <A HREF="#SettingBreakpoints">Setting Breakpoints</A>). Then,&nbsp;
+type the <TT>run</TT> command. The debugger runs your program, stopping
+at the breakpoint. At this point, you can step through your code by entering
+commands in either the Java source buffer or the jdb interaction buffer.
 <UL>
 <LI>
-In the source buffer, choose <B>Jdb->Step</B> (<TT>C-x C-a C-s</TT>) or
-<B>Jdb->Next</B> (<TT>C-x C-a C-n</TT>) to step into or step over the current
-line, respectively. Select Jdb->Continue (C-x C-a C-r) to continue to the
-next breakpoint or to the end of your program, whichever comes first.</LI>
+In the source buffer, choose <B><FONT SIZE=-1>Jdb->Step</FONT></B> (<TT>C-x
+C-a C-s</TT>) or <B><FONT SIZE=-1>Jdb->Next</FONT></B> (<TT>C-x C-a C-n</TT>)
+to step into or step over the current line, respectively. Select <B><FONT SIZE=-1>Jdb->Continue</FONT></B>
+(<TT>C-x C-a C-r</TT>) to continue to the next breakpoint or to the end
+of your program, whichever comes first.</LI>
 
+<BR>&nbsp;
 <LI>
 In the jdb buffer, enter <TT>step</TT>, <TT>next</TT>, or <TT>cont</TT>
 at the <TT>jdb</TT> command prompt.</LI>
 execution path of your program.
 <H3>
 <A NAME="SettingBreakpoints"></A>Setting Breakpoints</H3>
-You can set breakpoints in your program from either of two places: the
-debugger interaction buffer or the source buffer created by the debugger.
-When setting breakpoints from the source code buffer, you can set breakpoints
-only in classes whose source is displayed in the buffer. If you want to
-set breakpoints at other points in your program, you must set them from
+You can set breakpoints in the debugger&nbsp; buffer or the current source
+buffer. When setting breakpoints from the current source buffer, you can
+set breakpoints only in the class displayed in the buffer. If you want
+to set breakpoints at other points in your program, you must set them from
 the debugger interaction buffer.
-
-<P>Since the debugger does not create a source code buffer until it has
-reached the first breakpoint, you must set the first breakpoint from the
-debugger buffer. Thereafter, you can use the source buffer to set breakpoints
-whose source is displayed in the buffer.
 <H4>
 Setting Breakpoints from the Debugger Buffer</H4>
 The <TT>stop in</TT> command sets a breakpoint in a specified function.
 <H4>
 Setting Breakpoints in the Source Buffer</H4>
 To set a breakpoint on any executable line in the source file buffer, click
-on the line and select <B>Jdb->Set Breakpoint</B> (<TT>C-x SPC</TT>). To
-clear a breakpoint from a line in the current buffer, click on the line
-and select <B>Jdb->Remove Breakpoint</B> (<TT>C-x C-a C-d</TT>).
+on the line and select <B><FONT SIZE=-1>Jdb->Set Breakpoint</FONT></B>
+(<TT>C-x SPC</TT>). To clear a breakpoint from a line in the current buffer,
+click on the line and select <B><FONT SIZE=-1>Jdb->Remove Breakpoint</FONT></B>
+(<TT>C-x C-a C-d</TT>).
 <H3>
 <A NAME="SpecifyingSourceCodePaths"></A>Specifying Source Code Paths</H3>
-Type <TT>M-x jde-db-set-source-paths</TT> to specify the source paths of
-files you might visit while debugging your app. The JDE displays a prompt
-in the minibuffer. Enter the source paths separated by colons (on Unix
-systems) or semicolons (on Win32 systems) and press enter.
+The <TT>jde-db-source-directories</TT> variable specifies the directories
+the JDE should search for source for classes visited by the debugger as
+you step through your program. You can set the value of this variable in
+a customization buffer or in the minibuffer.
+<H4>
+Using Customization to Set Source Paths</H4>
+To use customization, select <B><FONT SIZE=-1>JDE->Options->Project</FONT></B>
+and edit the <TT>jde-db-source-directories</TT> entry in the resulting
+customization buffer. To show the current value of the variable, select
+the <B><FONT SIZE=-1>Show/Hide</FONT></B> button. To add a directory, click
+the last <B><FONT SIZE=-1>INS</FONT></B> button in the list&nbsp; and enter
+the directory in the resulting edit field. When you are done adding entries,
+press the <B><FONT SIZE=-1>State</FONT></B> button to set the variable.
+To save the setting in your project file, select <B><FONT SIZE=-1>JDE->Options->Save
+Project</FONT></B>. The following figure shows an example of the <TT>jde-db-source-directories</TT>
+entry in a customization buffer.
+
+<P><IMG SRC="debug2.gif" HEIGHT=393 WIDTH=657>
+<BR>&nbsp;
+<H4>
+Entering Source Paths in the Minibuffer</H4>
+To specify the source paths in the minibuffer, enter <TT>M-x jde-db-set-source-paths</TT>.
+The JDE displays a prompt in the minibuffer. Enter the source paths separated
+by colons (on Unix systems) or semicolons (on Win32 systems) and press
+enter. The jde-db-set-source-paths command sets the <TT>jde-db-source-directories</TT>
+variable to the specified paths.
 
 <P>You must specify the paths of the top-level directories of any source
 code that you might visit while debugging your application. The source
 path of <TT>myapp</TT>'s parent directory.
 
 <P><B>Tip:</B> If you want to step through the JDK source code, select
-the source code install option when you install the JDK and the use <TT>jde-db-set-source-paths</TT>
-to specify the directory containing the source code. You need specify only
-the path of the top-level directory. The JDE will use the JDK's package
-structure to find the source code in the subdirectories.
+the source code install option when you install the JDK and set the&nbsp;
+<TT>jde-db-source-directoiries</TT> variable to&nbsp; the top-level directory
+containing the source code. The JDE will use the JDK's package structure
+to find the source code in the subdirectories.
 
-<P><B>Tip:</B> Specify source paths in your <TT>prj.el</TT> file (see <A HREF="#SavingProjSettings">Saving
-Project Settings</A>) to avoid having to set them every time you start
-a session. For example, entering
-<BLOCKQUOTE><TT>(jde-db-set-source-paths "c:/jdk/src/;c:/java_projects/")</TT></BLOCKQUOTE>
-in your <TT>prj.el</TT> file tells the JDE to look for source files in
-the specified directories when stepping through your applications.
+<P><B>Tip:</B> Save the setting of <TT>jde-db-source-directories</TT> in
+your <TT>prj.el</TT> file (see <A HREF="#SavingProjSettings">Saving Project
+Settings</A>) to avoid having to set them every time you start a session.
 <H3>
 Displaying Variables</H3>
 The debugger lets you display the value of any local variable currently
 whose value you want to display. The debugger displays the value of the
 variable in the debugger buffer. To display a local, in-scope variable
 whose source is displayed in the debugger source buffer, put the point
-on the variable and select <B>Jdb->Print Expression</B> or type <TT>C-x
-C-a C-p</TT>. To display all variables in scope, enter <TT>locals</TT>
-at the debugger command prompt in the debugger buffer.
+on the variable and select <B><FONT SIZE=-1>Jdb->Print Expression</FONT></B>
+or type <TT>C-x C-a C-p</TT>. To display all variables in scope, enter
+<TT>locals</TT> at the debugger command prompt in the debugger buffer.
 
 <P>When the debugger displays a user-defined object, it prints the value
 returned by the object's <TT>toString()</TT> method. By default, the toString()
 </TR>
 
 <TR>
+<TD VALIGN=TOP><TT>jde-db-set-initial-breakpoint</TT></TD>
+
+<TD VALIGN=TOP>Project</TD>
+
+<TD>If non-<TT>nil</TT>, causes the JDE to set an initial breakpoint at
+the beginning of the application's main method and run the application
+at debugger startup. This variable is <TT>t</TT> by default. If you want
+to specify an initial breakpoint, set this variable to <TT>nil</TT>.</TD>
+</TR>
+
+<TR>
 <TD VALIGN=TOP><TT>jde-db-mode-hook</TT></TD>
 
 <TD VALIGN=TOP>Project&nbsp;</TD>
 </TR>
 
 <TR>
+<TD VALIGN=TOP><TT>jde-db-startup-commands</TT></TD>
+
+<TD VALIGN=TOP>Project</TD>
+
+<TD>List of commands to run at debugger startup. This variable overrides
+<FONT SIZE=-1>jde-db-set-initial-breakpoint</FONT>.</TD>
+</TR>
+
+<TR>
+<TD VALIGN=TOP><TT>jde-db-marker-regexp</TT></TD>
+
+<TD VALIGN=TOP>Project</TD>
+
+<TD>Regular expression used to recognize breakpoint markers in the debugger
+output. This expression should have two subexpressions: the first matches
+the name of the class in which the program stopped; the second, the number
+of the line at which the program stopped. By default, this variable is
+set to an expression that matches breakpoing markers in jdb's output.</TD>
+</TR>
+
+<TR>
 <TD VALIGN=TOP><TT>jde-global-classpath</TT></TD>
 
 <TD VALIGN=TOP>Project&nbsp;</TD>
 the file containing the definition and positioning the point at the definition.
 (The first time you type <TT>M-x .</TT>, Emacs prompts you to load the
 <TT>TAGS</TT> file.)
+<BR>&nbsp;
+<BR>&nbsp;
+<H2>
+<A NAME="ConfiguringJDE"></A>Configuring the JDE</H2>
+The JDE is highly customizable. You can specify everything from what compiler
+the JDE uses to compile Java source files to what color it uses to color
+comments in a source file. You configure the JDE by setting the values
+of configuration variables. Some of these variables are defined by the
+JDE itself; some are defined by the packages on which the JDE relies, such
+as cc-mode, custom, speedbar, and so on. The names of configuration variables
+defined by the JDE begin with jde-. The variables defined by other packages
+have other prefixes.
+
+<P>You can use any of the following methods to set configuration variables
+<UL>
+<LI>
+insert Lisp <TT>setq</TT> forms in your Emacs initialization (<TT>.emacs</TT>)
+file</LI>
+
+<BR>For example, the following form tells the JDE not to turn on font-locking
+(syntax coloring).
+<BR><TT>(setq jde-use-font-lock nil)</TT>
+<BR>&nbsp;
+<LI>
+interactively, using keyboard commands</LI>
+
+<BR>The JDE provides commands for setting some configuration variables.
+For example, the command
+<BR><TT>M-x set-compile-options</TT>
+<BR>sets the variable <TT>jde-compile-option-command-line-args</TT> to
+a string of compiler command-line arguments that you specify. The JDE passes
+this string to the compiler whenever you invoke the JDE compile command.
+<BR>&nbsp;
+<LI>
+interactively, using the Emacs customization feature</LI>
+</UL>
+
+<H3>
+About the Emacs Customization Feature</H3>
+The Emacs customization feature allows you to locate and set configuration
+variables by interacting with text "widgets" (buttons, text fields, checkboxes,
+menus) displayed in a customization buffer. (You can think of such a buffer
+as the Emacs equivalent of a dialog box). The customization feature arranges
+all Emacs customization variables, including those provide by Emacs extension
+packages, such as cc-mode and the JDE, in a tree-structured hierarchy of
+customization groups. You can navigate up and down the customization tree
+by clicking navigation buttons in customization buffers. To display the
+root customization buffer (the Emacs group), type <TT>M-x customize</TT>.
+The root buffer displays the next layer of customization groups in the
+hierarchy. You can navigate to these groups by clicking their names, and
+so on, until you reach the group containing the variable(s) you want to
+set.
+
+<P>The buffer for each group lists the variables and subgroups that the
+group contains. For each variable, the buffer lists the variable's current
+value and documentation. You can change the current value by interacting
+with text widgets associated with the variable.&nbsp; Each variable has
+an associated State button that displays a menu of options for setting
+the variable's value. The options include applying a change permanently
+or only for the duration of the current session or restoring the variable's
+default value. If you choose to apply a change permanently, Emacs saves
+the new value in a customization file. By default, the customization file
+is your .emacs file.You can specify another file by setting an option in
+the Custom Group. For more information, see <A HREF="http://www.dina.kvl.dk/~abraham/custom/">custom.</A>
+<BR>&nbsp;
+<H3>
+&nbsp;JDE Customization Groups</H3>
+The JDE defines a top-level customization group, the JDE Group, for JDE
+configuration variables. The JDE Group itself contains the following subgroups
+<H4>
+Compile Option Group</H4>
+Specifies compile options corresponding to the command-line arguments (e.g.,
+-d) accepted by the JDK compiler, javac. When you execute the JDE compile
+command, the JDE uses the settings of this group to construct a list of
+command-line arguments that it passes to the Java compiler that the JDE
+uses to compile Java source programs. The compiler is itself an option
+that you can specify (see the Project Option Group). You can specify command-line
+arguments directly by setting the value of the <TT>jde-compile-option-command-line-args</TT>
+variable. You can display the customization buffer for the Compile Option
+Group by selecting <B>Options->Compile</B> from the <B>JDE</B> menu.
+<H4>
+Run Option Group</H4>
+Specifies run-time options corresponding to the command-line arguments
+(for example, -classpath) accepted by the JDK virtual machine, java. When
+you execute the JDE Run command,&nbsp; the JDE uses the settings of this
+group to construct a list of command-line arguments that it passes to the
+Java interpreter used by the JDE to run applications. This group also contains
+options for specifying non-java command-line arguments (in case you want
+to use a vm that accepts a different set of arguments than java does) and
+for specifying arguments to be passed to the application (as opposed to
+the virtual machine interpreting the application.) You can display the
+customization buffer for the Run Option Group by selecting <B>Options->Run</B>
+from the <B>JDE</B> menu.
+<H4>
+Debug Option Group</H4>
+Specifies run-time options corresponding to the command-line arguments
+(for example, -classpath) accepted by the JDK debugger, jdb. jdb accepts
+the same command-line arguments as java. However, the JDE maintains two
+parallel sets of configuration variables for these programs in case you
+want to use a different set of options for running a program in debug mode
+then you use for running it normally. When you execute the JDE Debug command,&nbsp;
+the JDE uses the settings of this group to construct a list of command-line
+arguments that it passes to the Java debugger used by the JDE to run applications
+in debug mode. You can display the customization buffer for the Debug Option
+Group by selecting <B>Options->Debug</B> from the <B>JDE</B> menu.
+<H4>
+Autocode Group</H4>
+Specifies templates used to generate code automatically.
+<H4>
+Project Options Group</H4>
+Specify all other JDE options. You can display the customization buffer
+for the Debug Option Group by selecting <B>Options->Debug</B> from the
+<B>JDE</B> menu.
 <H2>
 <A NAME="Customizingjde_mode"></A>Customizing jde-mode</H2>
 The JDE defines a major mode, named jde-mode, for editing Java source files.
   :type 'hook
 )
 
+(defcustom jde-db-set-initial-breakpoint t
+  "*Set breakpoint in main and run application.
+If this variable is non-nil, the JDE issues the following 
+debugger commands at startup:
+
+  stop in app-class.main
+  run
+
+where app-class is the qualified name of your application's
+main class. This variable is non-nil by default. Set it to
+nil, if you want to set an initial breakpoint yourself."
+  :group 'jde-project
+  :type 'boolean)
+
+(defcustom jde-db-startup-commands nil
+  "*Commands to run at debugger startup."
+  :group 'jde-project
+  :type '(repeat (string :tag "Command"))
+)
+
+(defcustom jde-db-read-vm-args nil
+"*Read vm arguments from the minibuffer.
+If this variable is non-nil, the jde-db command reads vm arguments
+from the minibuffer and appends them to those specified by
+the `jde-db-option' variable group."
+  :group 'jde-project
+  :type 'boolean)
+
+(defvar jde-db-interactive-vm-args ""
+"Vm arguments read from the minibuffer.")
+
+(defvar jde-db-interactive-vm-arg-history nil
+"History of vm arguments read from the minibuffer")
+
+(defcustom jde-db-read-app-args nil
+"*Read arguments to be passed to application from the minibuffer."
+  :group 'jde-project
+  :type 'boolean)
+
+(defvar jde-db-interactive-app-args ""
+"Application arguments read from the minibuffer.")
+
+(defvar jde-db-interactive-app-arg-history nil
+"History of application arguments read from the minibuffer")
+
+
 (defgroup jde-db-options nil
   "JDE Interpreter Options"
   :group 'jde
 (defun jde-db-xemacs-menu ()
   (cons "Jdb" jde-db-xemacs-menu))
 
-(defvar jde-db-marker-regexp
-  "(\\([^\$]*\\).*:\\([0-9]*\\))"
-"Regular expression used to find a jdb breakpoint position marker. The marker has
-the syntax (CLASS:LINENO), where class is the name of the class in which
-jdb has stopped and LINENO is the number of the line at which it is stopped.")
+(defcustom jde-db-marker-regexp
+  "^Breakpoint hit: .*(\\([^\$]*\\).*:\\([0-9]*\\))"
+"*Regular expression used to find a jdb breakpoint position marker.
+The regular expression must have two subexpressions. The first matches
+the name of the class in which the breakpoint occurs; the second, the
+line number at which the breakpoint occurs. The default expression
+matches breakpoint messages emitted by jdb. You may need to change
+the expression to accommodate other debuggers."
+  :group 'jde-project
+  :type 'string
+)
+
+(defcustom jde-db-nodebug-marker-regexp
+  "^Breakpoint hit: .*(pc \\([0-9]*\\))"
+"*Regular expression to match breakpoint message for which no
+line number information is available.")
+
+;; I'm not sure the following is necessary anymore. PK.
 
 ;; Thanks to "David J. Biesack" <sasdjb@unx.sas.com> for this function
 ;; and its use in jde-db-marker-filter.
 breakpoint message."
   (concat "\\b\\(\\(\\(\\w*\\.\\)*\\)" class "\\)\\b"))
 
+
+;; There's no guarantee that Emacs will hand the filter the entire
+;; marker at once; it could be broken up across several strings.  We
+;; might even receive a big chunk with several markers in it.  If we
+;; receive a chunk of text which looks like it might contain the
+;; beginning of a marker, we save it here between calls to the
+;; filter.
+(defvar jde-db-marker-acc "")
+(make-variable-buffer-local 'jde-db-marker-acc)
+
 (defun jde-db-marker-filter (input)
-  (let ((output input))
+
+  ;; Accumulate next chunk of debugger output.
+  (setq jde-db-marker-acc (concat jde-db-marker-acc input))
+
+  ;; This is a hack to accommodate reorder of message chunks
+  ;; on Solaris at debugger startup.
+  (if (string-match "running ...\n" jde-db-marker-acc)
+      (setq jde-db-marker-acc
+	    (concat "running ...\n"
+		    (substring jde-db-marker-acc 0 (match-beginning 0))
+		    (substring jde-db-marker-acc (match-end 0)))))
+		    
+  (let ((output ""))
+
+    ;; (message (concat "jdb output:" input))
+    ;; (message (concat "acc = " jde-db-marker-acc))
     
-    ;; Check for a jdb stepper message.
-    (if (string-match jde-db-marker-regexp input)
+    ;; Process all the complete markers in this chunk.
+    (if (string-match jde-db-marker-regexp jde-db-marker-acc)
 	;; Extract the frame position from the marker.
-	(let ((marker (substring input (match-beginning 0) (match-end 0)))
-	      (class (substring input (match-beginning 1) (match-end 1)))
-	      (line-no (string-to-int (substring input
+	(let ((premarker (substring jde-db-marker-acc 0 (match-beginning 0)))
+	      (marker (substring jde-db-marker-acc (match-beginning 0) (match-end 0)))
+	      (class (substring jde-db-marker-acc  (match-beginning 1) (match-end 1)))
+	      (line-no (string-to-int (substring jde-db-marker-acc
 						 (match-beginning 2)
 						 (match-end 2))))
-	      (rest (substring input (match-end 0))))
-
-
-	  ;; regexp picks up ".java" from jdb; remove it
-	  (and (> (length class) 5)
-	       (string-equal ".java" (substring class -5))
-	       (setq class (substring class 0 -5)))
+	      (rest (substring jde-db-marker-acc (match-end 0))))
 
 	  (setq gud-last-frame (cons (concat class ".java") line-no))
 
 	  ;; Extract package path from input.
 	  (setq jde-db-last-package "")
-	  (and (string-match (jde-db-make-qualified-class-name-regexp class) input)
+	  (and (string-match (jde-db-make-qualified-class-name-regexp class) marker)
 	       (setq jde-db-last-package
-		     (substring output (match-beginning 2) (match-end 2))))
+		     (substring marker (match-beginning 2) (match-end 2))))
 
 	  ;; (message "jde-db package: %s" jde-db-last-package)
 
-	  (setq output (concat "Stopped at " 
-			       (substring marker 1
-					  (- (length marker) 1)) rest))))
+	  (setq output (concat premarker "Stopped at line " line-no " in "
+			       class ".java"))
+
+	  ;; Set the accumulator to the remaining text.
+	  (setq jde-db-marker-acc rest)
+	  ))
+
+    ;; Handle case where there is no line number info in current class.
+    (if (string-match jde-db-nodebug-marker-regexp jde-db-marker-acc) 
+	(let ((premarker (substring jde-db-marker-acc 0 (match-beginning 0)))
+	      (marker (substring jde-db-marker-acc (match-beginning 0) (match-end 0)))
+	      (pc (substring jde-db-marker-acc (match-beginning 1) (match-end 1)))
+	      (rest (substring jde-db-marker-acc (match-end 0))))
+
+	  (setq output (concat premarker marker))
+	  ))
+
+    ;; Does the remaining text look like it might end with the
+    ;; beginning of another marker?  If it does, then keep it in
+    ;; jde-db-marker-acc until we receive the rest of it.  Since we
+    ;; know the full marker regexp above failed, it's pretty simple to
+    ;; test for marker starts.
+    (if (string-match "^Breakpoint hit:" jde-db-marker-acc)
+	(progn
+	  ;; Everything before the potential marker start can be output.
+	  (setq output (concat output (substring jde-db-marker-acc
+						 0 (match-beginning 0))))
+
+	  ;; Everything after, we save, to combine with later input.
+	  (setq jde-db-marker-acc
+		(substring jde-db-marker-acc (match-beginning 0))))
+
+      (setq output (concat output jde-db-marker-acc)
+	    jde-db-marker-acc ""))    
 
     output))
 
 	   ((and (jde-db-contains-package-p curr-dir package)
 		 (jde-db-contains-file-p
 		  (concat curr-dir (jde-db-pkg-to-path package)) file))
-	    ; (message "jde-db-search-src-dirs found %s in %s" file (concat curr-dir (jde-db-pkg-to-path jde-db-last-package)))
+	    ;; (message "jde-db-search-src-dirs found %s in %s" file (concat curr-dir (jde-db-pkg-to-path jde-db-last-package)))
 	    (throw 'found
 		   (concat curr-dir 
 			   (jde-db-pkg-to-path package))))
-	   ; (t (message "jde-db-search-src-dirs: %s not in %s" file curr-dir))
+	   ;; (t (message "jde-db-search-src-dirs: %s not in %s" file curr-dir))
 	    ))
 	(setq n (1+ n))))))
 
 
 ;;; The jde-db-call function must do the right thing whether its invoking
 ;;; keystroke is from the GUD buffer itself (via major-mode binding)
-;;; or a C buffer.  In the former case, we want to supply data from
+;;; or a Java buffer.  In the former case, we want to supply data from
 ;;; gud-last-frame.  Here's how we do it:
 ;;; Note: this is adapted from the gud-format-command function
 ;;; in gud.el.
 are interpreted specially if present.  These are:
 
   %f name (without directory) of current source file.
-  %c    fully qualified class name
+  %c fully qualified class name
   %d directory of current source file.
   %l number of current source line
   %e text of the C lvalue or function-call expression surrounding point.
   %p prefix argument to the command (if any) as a number
 
   The `current' source file is the file of the current buffer (if
-we're in a C file) or the source file current at the last break or
-step (if we're in the GUD buffer).
+we're in a Java file) or the source file current at the last break or
+step (if we're in the jdb buffer).
   The `current' line is that of the current buffer (if we're in a
 source file) or the source line number at the last break or step (if
-we're in the GUD buffer)."
+we're in the jdb buffer)."
   (list 'progn
 	(list 'defun func '(arg)
 	      (or doc "")
 		  (list 'concat 'gud-key-prefix key)
 		  (list 'quote func)))))
 
+(defun jde-db-get-vm-args-from-user ()
+  (if jde-db-read-vm-args
+      (jde-run-parse-args
+       (read-from-minibuffer
+	"Vm args: "
+	jde-db-interactive-vm-args
+	nil nil
+	'(jde-db-interactive-vm-arg-history . 1)))))
+
+(defun jde-db-get-app-args-from-user ()
+  (if jde-db-read-app-args
+      (jde-run-parse-args
+       (read-from-minibuffer
+	"Application args: "
+	jde-db-interactive-app-args
+	nil nil
+	'(jde-db-interactive-app-arg-history . 1)))))
+
 (defun jde-db-init(app-class marker-filter find-file)
   (let ((debug-buf-name (concat "*debug" app-class "*")))
     (if (not (comint-check-proc debug-buf-name))
 	       (prog-args (if (string= (cdr jde-db-debugger) "Executable")
 			      (append 
 			       (jde-db-get-vm-args)
+			       (jde-db-get-vm-args-from-user)
 			       (list app-class)
-			       jde-db-option-application-args)
+			       jde-db-option-application-args
+			       (jde-db-get-app-args-from-user))
 			    (append
 			     (list (car jde-db-debugger))
 			     (jde-db-get-vm-args)
+			     (jde-db-get-vm-args-from-user)
 			     (list app-class)
-			     jde-db-option-application-args)))
+			     jde-db-option-application-args
+			     (jde-db-get-app-args-from-user))))
 	       (command-string (concat
 				program " "
 				(jde-run-make-arg-string prog-args) "\n\n")))
 	  (setq gud-find-file find-file)
 	  (set-process-filter (get-buffer-process (current-buffer)) 'gud-filter)
 	  (set-process-sentinel (get-buffer-process (current-buffer)) 'gud-sentinel)
-	  (gud-set-buffer))
+	  (gud-set-buffer)
+	  (if jde-db-startup-commands
+	    (mapc 'gud-basic-call jde-db-startup-commands)
+	   (when jde-db-set-initial-breakpoint
+	    (gud-basic-call (concat "stop in " app-class ".main"))
+	    (gud-basic-call "run")))
+	  )
       (message "An instance of %s is running." app-class)			
       (pop-to-buffer debug-buf-name))))			   
 	  
 
-
 (defun jde-db-get-package ()
   "Return the package of the class whose source file resides in the current
 buffer."
 
 ;; Change History
 ;; $Log$
+;; Revision 1.30  1998/06/30 04:03:19  paulk
+;; Added variables `jde-db-read-vm-args' and `jde-db-read-app-args'. The use of
+;; these variables is the same as the corresponding jde-run variables.
+;;
+;; Revision 1.29  1998/06/29 02:50:44  paulk
+;; Fixed bug in marker filter.
+;;
+;; Revision 1.28  1998/06/27 03:34:31  paulk
+;; Provided a hack to handle reordering of threaded messages on Solaris.
+;;
+;; Provided code to handle case where current class has no line number
+;; information.
+;;
+;; Revision 1.27  1998/06/25 04:27:23  paulk
+;; Removed debug messages from jde-db-marker-filter.
+;;
+;; Revision 1.26  1998/06/25 04:21:10  paulk
+;; Modified jde-db-marker-filter to accummulate debugger output
+;; in chunks. Fixes bug reported by Eric Prud'hommeaux (eric@w3.org).
+;;
+;; Revision 1.25  1998/06/22 03:52:28  paulk
+;; Added jde-db-startup-commands variable. This variable allows you to
+;; specify debugger commands to run when the debugger is started.
+;;
+;; Revision 1.24  1998/06/21 00:09:43  paulk
+;; Added a customizable feature, jde-db-set-initial-breakpoint, that causes
+;; the JDE to set an initial breakpoint in an app's main routine and run
+;; to the breakpoint on debugger startup. The feature is enabled by default.
+;;
+;; Revision 1.23  1998/06/20 23:42:07  paulk
+;; Made jde-db-marker-regexp a custom variable to facilitate the use of the JDE
+;; with debuggers other than jdb.
+;;
+;; Changed the marker regular expression to detect only jdb breakpoint messages,
+;; i.e., messages of the form
+;;
+;;   Breakpoint hit: qualified.class.name (class:line)
+;;
+;; This should eliminate the problem of spurious hits when exceptions occur and
+;; stack traces are printed.
+;;
 ;; Revision 1.22  1998/05/27 06:09:46  paulk
 ;; Added autoload comments.
 ;;
 ;; Initial revision
 ;;
 
-;;; end of jde-db.el
+;;; end of jde-db.el
 	    (concat "'(" template-string ")"))
       (eval (car (read-from-string template-string)))))
 
+(defcustom jde-gen-buffer-boilerplate nil
+"*Lines of boilerplate text to put at the head of a buffer template."
+  :group 'jde-gen
+  :type '(repeat (string :tag "Line")))
+
+(defcustom jde-gen-boilerplate-function 'jde-gen-create-buffer-boilerplate
+"*Specifes buffer boilerplate text function.
+This variable specifies a function to create boilerplate text for
+insertion at the head of Java source buffers generated by JDE
+templates. The specified function should take no arguments and should
+return a text string.  The default value is
+`jde-gen-create-buffer-boilerplate', which returns the lines of text
+specified by `jde-gen-buffer-boilerplate'."
+  :group 'jde-gen
+  :type 'function)
+
+(defun jde-gen-create-buffer-boilerplate ()
+"This function creates buffer boilerplate from the
+variable `jde-gen-buffer-boilerplate."
+  (if jde-gen-buffer-boilerplate
+      (let ((bp "")
+	    (n (length jde-gen-buffer-boilerplate))
+	    (i 0))
+	(while (< i n)
+	  (setq bp
+		(concat bp (elt jde-gen-buffer-boilerplate i) "\n"))
+	  (setq i (1+ i)))
+	bp)))
 
 (defcustom jde-gen-class-buffer-template
   '(
+    "(funcall jde-gen-boilerplate-function) 'n"
     "\"/**\" 'n"
     "\" * \"" 
     "(file-name-nondirectory buffer-file-name) 'n"
   :type '(repeat string)
   :set '(lambda (sym val)
 	  (defalias 'jde-gen-jfc-app
-	    (tempo-define-template "java-console-buffer-template"
+	    (tempo-define-template "java-jfc-app-buffer-template"
 		       (jde-gen-read-template val)
                        nil
                        "Insert skeleton for a JFC app buffer"))
 insertion command."
   :group 'jde-gen
   :type '(repeat
-	  (cons (string :tag "Title")
-		(function :tag "Command")))
+	  (cons :tag "Template"
+	   (string :tag "Title")
+	   (function :tag "Command")))
   :set '(lambda (sym val)
 	  (let ((n (length val))
 		(i 0))
   (backward-char 1)
   (c-indent-exp))
 
+(defun jde-gen-init-cap (name)
+  (concat (upcase (substring name 0 1)) (substring name 1)))
+
 (defcustom jde-gen-get-set-var-template
   '(
-    "'& (P \"Variable type: \" type) \" \""
+    "'n>"
+    "(P \"Variable type: \" type) \" \""
     "(P \"Variable name: \" name) \";\" 'n> 'n>"
     "\"/**\" 'n>"
     "\"* Get the value of \" (s name) \".\" 'n>"
     "\"* @return Value of \" (s name) \".\" 'n>"
     "\"*/\" 'n>"
-    "\"public \" (s type) \" get\" (capitalize (jde-gen-lookup-named 'name))"
+    "\"public \" (s type) \" get\" (jde-gen-init-cap (jde-gen-lookup-named 'name))"
     "\"() {return \" (s name) \";}\" 'n> 'n>"
     "\"/**\" 'n>"
     "\"* Set the value of \" (s name) \".\" 'n>"
     "\"* @param v  Value to assign to \" (s name) \".\" 'n>"
     "\"*/\" 'n>"
-    "\"public void set\" (capitalize (jde-gen-lookup-named 'name))"
+    "\"public void set\" (jde-gen-init-cap (jde-gen-lookup-named 'name))"
     "\"(\" (s type) \"  v) {this.\" (s name) \" = v;}\" 'n>" 
     )
   "*Template for creating a get/set method pair.
 (defcustom jde-gen-mouse-listener-template
   '(
     "'& (P \"Component name: \")"
-    "\".addMouseListener(new MouseAdaptor() {\" 'n>"
+    "\".addMouseListener(new MouseAdapter() {\" 'n>"
     "\"public void mouseClicked(MouseEvent e) {}\" 'n>"
+    "\"public void mouseEntered(MouseEvent e) {}\" 'n>"
     "\"public void mouseExited(MouseEvent e) {}\" 'n>"
     "\"public void mousePressed(MouseEvent e) {}\" 'n>"
     "\"public void mouseReleased(MouseEvent e) {}});\" 'n>"
 	     "Insert skeleton mouse listener."))
 	  (set-default sym val)))
 
+(defcustom jde-gen-mouse-motion-listener-template
+  '(
+    "'& (P \"Component name: \")"
+    "\".addMouseMotionListener(new MouseMotionAdapter() {\" 'n>"
+    "\"public void mouseDragged(MouseEvent e) {}\" 'n>"
+    "\"public void mouseMoved(MouseEvent e) {}});\" 'n>"
+    )
+  "*Template for generating a mouse listener.
+Setting this variable defines a template instantiation
+command, `jde-gen-mouse-motion-listener', as a side-effect."
+  :group 'jde-gen
+  :type '(repeat string)
+  :set '(lambda (sym val)
+	  (defalias 'jde-gen-mouse-motion-listener
+	    (tempo-define-template
+	     "java-mouse-motion-listener"
+	     (jde-gen-read-template val)
+	     nil
+	     "Insert skeleton mouse motion listener."))
+	  (set-default sym val)))
+
+
+(defcustom jde-gen-to-string-method-template
+  '(
+    "'&"
+    "\"public String toString() {\" 'n>" 
+    "\"return super.toString();\" 'n>"
+    "\"}\" 'n>"
+    )
+  "*Template for generating a toString method.
+Setting this variable defines a template instantiation
+command, `jde-gen-to-string-method', as a side-effect."
+  :group 'jde-gen
+  :type '(repeat string)
+  :set '(lambda (sym val)
+	  (defalias 'jde-gen-to-string-method
+	    (tempo-define-template
+	     "toString method"
+	     (jde-gen-read-template val)
+	     nil
+	     "Insert skeleton toString method."))
+	  (set-default sym val)))
 
 (defcustom jde-gen-code-templates 
   (list (cons "Get Set Pair" 'jde-gen-get-set)
+	(cons "toString method" 'jde-gen-to-string-method)
 	(cons "Action Listener" 'jde-gen-action-listener)
 	(cons "Window Listener" 'jde-gen-window-listener)
 	(cons "Mouse Listener" 'jde-gen-mouse-listener)
+	(cons "Mouse Motion Listener" 'jde-gen-mouse-motion-listener)
 	(cons "Inner Class" 'jde-gen-inner-class))
   "*Specifies available autocode templates.
 The value of this variable is an association list. The car of
 insertion command."
   :group 'jde-gen
   :type '(repeat
-	  (cons (string :tag "Name")
-		(function :tag "Command")))
+	  (cons :tag "Template"
+	   (string :tag "Name")
+	   (function :tag "Command")))
   :set '(lambda (sym val)
 	  (let ((n (length val))
 		(i 0))
 (provide 'jde-gen)
 
 ;; $Log$
+;; Revision 1.12  1998/07/01 03:54:40  paulk
+;; Added source file boilerplate support.
+;;
+;; Revision 1.11  1998/06/27 03:04:46  paulk
+;; Fixed capitalization on get-set method pair. Thanks to Jere_McDevitt@HomeDepot.COM
+;;
+;; Revision 1.10  1998/06/17 03:49:21  paulk
+;; Fixed bug that caused jfc-app to be generated instead of console app.
+;; Added a mouse motion listener template.
+;; Added a toString method template.
+;;
 ;; Revision 1.9  1998/05/27 05:55:20  paulk
 ;; Added autoload comments.
 ;;
   :group 'jde-project
   :type 'string)
 
+(defcustom jde-run-read-vm-args nil
+"*Read vm arguments from the minibuffer.
+If this variable is non-nil, the jde-run command reads vm arguments
+from the minibuffer and appends them to those specified by
+the `jde-run-option' variable group."
+  :group 'jde-project
+  :type 'boolean)
+
+(defvar jde-run-interactive-vm-args ""
+"Vm arguments read from the minibuffer.")
+
+(defvar jde-run-interactive-vm-arg-history nil
+"History of vm arguments read from the minibuffer")
+
+(defcustom jde-run-read-app-args nil
+"*Read arguments to be passed to application from the minibuffer."
+  :group 'jde-project
+  :type 'boolean)
+
+(defvar jde-run-interactive-app-args ""
+"Application arguments read from the minibuffer.")
+
+(defvar jde-run-interactive-app-arg-history nil
+"History of application arguments read from the minibuffer")
+
 (defgroup jde-run-options nil
   "JDE Interpreter Options"
   :group 'jde
 
 (defun jde-run-parse-args (s)
 "Converts a string of command-line arguments to a list of arguments."
-  (let ((n (string-match "[a-zA-Z0-9\\.:=;\\_/-]+" s))
+  (let ((n (string-match "[a-zA-Z0-9\\.:=;%+\\_/-]+" s))
 	(i 0)
 	(tokens '()))
     (while n
       (setq tokens (append tokens (list (match-string 0 s))))
       (setq n (match-end 0))
-      (setq n (string-match "[a-zA-Z0-9\\.:=;\\_/-]+" s n)))
+      (setq n (string-match "[a-zA-Z0-9\\.:=;%+\\_/-]+" s n)))
     tokens))
 
 (defun jde-run-make-arg-string (args)
 		       jde-run-java-vm))
 	       (prog-args (append
 			   (jde-run-get-vm-args)
+			   (if jde-run-read-vm-args
+			       (jde-run-parse-args
+				(read-from-minibuffer
+				 "Vm args: "
+				 jde-run-interactive-vm-args
+				 nil nil
+				 '(jde-run-interactive-vm-arg-history . 1))))
 			   (list app-class)
-			    jde-run-option-application-args))
+			   jde-run-option-application-args
+			   (if jde-run-read-app-args
+			       (jde-run-parse-args
+				(read-from-minibuffer
+				 "Application args: "
+				 jde-run-interactive-app-args
+				 nil nil
+				 '(jde-run-interactive-app-arg-history . 1))))
+			   ))
 	       (command-string (concat prog " " 
 				       (jde-run-make-arg-string
 					prog-args)
 
 ;; Change History
 ;; $Log$
+;; Revision 1.17  1998/06/30 21:10:28  paulk
+;; Fixed jde-run-parse-args to recognize % as an argument
+;; character.
+;;
+;; Revision 1.16  1998/06/30 03:32:37  paulk
+;; Added the variables `jde-run-read-vm-args' and `jde-run-read-app-args'.
+;; The first cause the jde-run command to read vm arguments from the
+;; minibuffer and append them to the vm arguments specified by
+;; the `jde-run-option' group of customization variables. The second
+;; causes jde-run to read arguments to be passed to the application
+;; from the minibuffer and append them to the arguments specified
+;; by `jde-run-applications-args'. The JDE maintains separate histories
+;; for both types of arguments.
+;;
 ;; Revision 1.15  1998/05/27 06:01:04  paulk
 ;; Added autoload comments.
 ;;
 ;; Boston, MA 02111-1307, USA.
 
 ;;;###autoload
-(defconst jde-version "2.01"
+(defconst jde-version "2.0.5"
   "JDE version number.")
 
 ;;; Commentary:
   :group 'jde-project
   :type 'string)
 
+(defcustom jde-read-compile-args nil
+"*Specify whether to prompt for additional compiler arguments.
+If this variable is non-nil, the jde-compile command prompts
+you to enter additional compiler arguments in the minibuffer.
+These arguments are appended to those specified by customization
+variables. The JDE maintains a history list of arguments 
+entered in the minibuffer."
+  :group 'jde-project
+  :type 'boolean
+)
+
+(defvar jde-interactive-compile-args ""
+"String of compiler arguments entered in the minibuffer.")
+
+(defvar jde-interactive-compile-arg-history nil
+"History of compiler arguments entered in the minibuffer.")
+
+
 (defcustom jde-entering-java-buffer-hooks nil
 "*Lists functions to run when entering a Java source buffer"
   :group 'jde-project
   :group 'jde-compile-options
   :type 'boolean)
 
+(defcustom jde-enable-abbrev-mode nil
+"*Enable expansion of abbreviations in jde-mode.
+See `jde-mode-abbreviations' for more information."
+  :group 'jde-project
+  :type 'boolean)
+
+(defcustom jde-mode-abbreviations
+  (list 
+   (cons "ab" "abstract")
+   (cons "bo" "boolean")
+   (cons "br" "break")
+   (cons "by" "byte")
+   (cons "byv" "byvalue")
+   (cons "cas" "cast")
+   (cons "ca" "catch")
+   (cons "ch" "char")
+   (cons "cl" "class")
+   (cons "co" "const")
+   (cons "con" "continue")
+   (cons "de" "default")
+   (cons "dou" "double")
+   (cons "el" "else")
+   (cons "ex" "extends")
+   (cons "fa" "false")
+   (cons "fi" "final")
+   (cons "fin" "finally")
+   (cons "fl" "float")
+   (cons "fo" "for")
+   (cons "fu" "future")
+   (cons "ge" "generic")
+   (cons "go" "goto")
+   (cons "impl" "implements")
+   (cons "impo" "import")
+   (cons "ins" "instanceof")
+   (cons "in" "int")
+   (cons "inte" "interface")
+   (cons "lo" "long")
+   (cons "na" "native")
+   (cons "ne" "new")
+   (cons "nu" "null")
+   (cons "pa" "package")
+   (cons "pri" "private")
+   (cons "pro" "protected")
+   (cons "pu" "public")
+   (cons "re" "return")
+   (cons "sh" "short")
+   (cons "st" "static")
+   (cons "su" "super")
+   (cons "sw" "switch")
+   (cons "sy" "synchronized")
+   (cons "th" "this")
+   (cons "thr" "throw")
+   (cons "throw" "throws")
+   (cons "tra" "transient")
+   (cons "tr" "true")
+   (cons "vo" "void")
+   (cons "vol" "volatile")
+   (cons "wh" "while")
+   )
+"*Abbreviations used for Java keywords.
+To use these abbreviations, you must enable abbrev-mode (see
+`jde-enable-abbrev-mode'). To use an abbreviation, enter the
+abbreviation followed by a white-space character. To suppress
+expansion, enter C-q white-space."
+   :group 'jde-project
+  :type '(repeat 
+	  (cons :tag "jde-mode abbreviation"
+		(string :tag "Abbreviation")
+		(string :tag "Expansion"))))
+
+
 ;;;###autoload
 (defun jde-set-compiler (compiler)
   "Specify the pathname of the compiler to be used to compile the
   (interactive)
   (browse-url jde-jdk-doc-url browse-url-new-window-p))
 
-(defun jde-make-compile-command ()
+(defun jde-make-compile-command (more-args)
   "Constructs the java compile command as: jde-compiler + options + buffer file name."
   (concat jde-compiler " " 
-;	  (if (jde-get-classpath-arg)
-;	      (concat (jde-get-classpath-arg) " "))
-	  (jde-get-compile-options) " "
+	  (jde-get-compile-options) 
+	  (if (not (string= more-args ""))
+	      (concat " " more-args))
+	  " "
 	  (file-name-nondirectory buffer-file-name)))
 
 (defun jde-get-compile-options ()
 
 ;;;###autoload
 (defun jde-compile ()
-  "Compile the Java program in the current buffer."
+  "Compile the Java program in the current buffer.
+This command invokes the compiler specified by `jde-compiler'
+with the options specified by the JDE customization variables
+that begin with `jde-compile'. If the variable
+`jde-read-compile-args' is non-nil, this command reads
+additional compilation options from the minibuffer, with
+history enabled."
   (interactive)
-  (let ((compile-command (jde-make-compile-command)))
+
+  (if jde-read-compile-args
+      (setq jde-interactive-compile-args
+	      (read-from-minibuffer 
+	       "Compile args: "
+	       jde-interactive-compile-args
+	       nil nil
+	       '(jde-interactive-compile-arg-history . 1))))
+
+  (let ((compile-command
+	 (jde-make-compile-command 
+	  jde-interactive-compile-args)))
+	  
+
+  
 
     ;; Force save-some-buffers to use the minibuffer
     ;; to query user about whether to save modified buffers.
   (make-local-variable 'jde-project-name)
 
 
+  ;; Enable support for automatic project switching.
+  ;; This feature loads the appropriate project settings whenever
+  ;; a user switches from a Java buffer belonging to one project
+  ;; to a buffer belonging to another.
+  (make-local-hook 'post-command-hook)
+  (unless (find 'jde-detect-java-buffer-activation post-command-hook)
+    (add-hook 'post-command-hook 'jde-detect-java-buffer-activation))
+
   (if jde-xemacsp
       (jde-insert-menu-in-XEmacs-menubar))
 
 
   (setq jde-current-project jde-project-name)
 
-  ;; Enable support for automatic project switching.
-  ;; This feature loads the appropriate project settings whenever
-  ;; a user switches from a Java buffer belonging to one project
-  ;; to a buffer belonging to another.
-  (unless (find 'jde-detect-java-buffer-activation post-command-hook)
-    (add-hook 'post-command-hook 'jde-detect-java-buffer-activation))
+
+  ;; Define abbreviations.
+  (mapc (lambda (x) 
+	  (define-mode-abbrev (car x) (cdr x)))
+	jde-mode-abbreviations)
+
+  (if jde-enable-abbrev-mode
+      (abbrev-mode 1))
+
   )
 
 (defun jde-setup-syntax-coloring() 
   ;; Set up syntax coloring.
   (cond (window-system
-	 (turn-on-font-lock)
+;	 (turn-on-font-lock)
 	 (setq font-lock-maximum-decoration t)
 
-	 (if jde-xemacsp
-	     (turn-on-lazy-lock)
-	   (setq font-lock-support-mode 'lazy-lock-mode
-		 lazy-lock-defer-on-scrolling t
-		 lazy-lock-stealth-time 5
-		 lazy-lock-stealth-verbose nil))
+	 (if (not jde-xemacsp)
+	     (global-font-lock-mode 1))
 	 )))
 
 ;; Setup jde-mode for font locking.
   "Menu for JDE.")
 
 ;; Define JDE menu for FSF Emacs.
-(if (or (not jde-xemacsp) (featurep 'infodock))
+(if (not jde-xemacsp)
     (easy-menu-do-define 'jde-menu 
 			 jde-mode-map
 			 "Menu for JDE."
 (if (not jde-xemacsp)
     (let* ((mb (assq 'menu-bar global-map))
 	   (files (assq 'files mb))
-	   (menu (easy-menu-create-keymaps 
-		  (car jde-new-buffer-menu) (cdr jde-new-buffer-menu)))
+	   (menu (if (fboundp 'easy-menu-create-menu)
+		     (easy-menu-create-menu 
+		      (car jde-new-buffer-menu) (cdr jde-new-buffer-menu))
+		   (easy-menu-create-keymaps 
+		    (car jde-new-buffer-menu) (cdr jde-new-buffer-menu))))     
 	   (menu-name (car jde-new-buffer-menu)))
       (define-key-after (cdr (cdr files)) [jde-new]
 	(cons menu-name menu)
 	 (equal curr-buff jde-current-buffer))
 	(progn
 	  (setq jde-current-buffer curr-buff)
-	  (let ((buff-file-name (buffer-file-name curr-buff)))
-	    (if (and buff-file-name
-		     (string-match ".java" buff-file-name))
-		(run-hooks 'jde-entering-java-buffer-hooks)
-	      ))))))
+	  (if (eq major-mode 'jde-mode)
+		(run-hooks 'jde-entering-java-buffer-hooks))))))
 
 
 (defun jde-count-open-java-buffers ()
 ;; Change History
 ;;
 ;; $Log$
+;; Revision 1.58  1998/06/30 03:35:10  paulk
+;; Added the customization variable `jde-read-compile-args'. If non-nil,
+;; this variable causes the jde-compile command to read compilation options
+;; from the minibuffer and append them to the options specified by
+;; the `jde-compile-option group of customization' variables. The JDE
+;; maintains a history of compiler options entered in the minibuffer.
+;;
+;; Revision 1.57  1998/06/29 03:18:11  paulk
+;; Use fboundp instead of Emacs version to determine whether
+;; easy-menu-create-menu is bound.
+;;
+;; Revision 1.56  1998/06/27 03:43:10  paulk
+;; Updated release to 2.0.3
+;;
+;; Revision 1.55  1998/06/27 03:40:20  paulk
+;; Fixed bug where the JDE was invoking global-font-lock-mode on XEmacs,
+;; where it is not defined.
+;;
+;; Updated JDE to call easy-menu-create-menu instead of easy-menu-create-keymaps
+;; on Emacs 20. (The former replaces the latter as of Emacs 20.x);
+;;
+;; Revision 1.54  1998/06/21 05:23:56  paulk
+;; Updated JDE version number to 2.0.2.
+;;
+;; Revision 1.53  1998/06/21 05:22:59  paulk
+;; Changed buffer change code to reload a project file
+;; when a user changed jde-mode buffers, not just .java
+;; buffers. This allows using extensions other than .java
+;; for Java source code files.
+;;
+;; Made post-command-hook buffer local to improve performance.
+;;
+;; Thanks to David J. Biesack( sasdjb@unx.sas.com) for the above changes.
+;;
+;; Revision 1.52  1998/06/18 18:14:08  paulk
+;; Added XEmacs compatibility changes requested by xemacs.org.
+;;
+;; Revision 1.51  1998/06/17 03:49:58  paulk
+;; Added support for abbreviations.
+;;
 ;; Revision 1.50  1998/05/29 01:42:08  paulk
 ;; Added no-op function for jde-mode to facilitate autoloading.
 ;; Thanks to Andy Piper <andyp@parallax.co.uk> for the suggestion.
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.