OpenJDK / amber / amber

--- a/jaxp/.hgignore	Fri Oct 30 10:54:43 2009 -0700
+++ b/jaxp/.hgignore	Fri Nov 06 17:26:01 2009 -0800
@@ -1,5 +1,6 @@
 ^build/
 ^dist/
 ^drop/
+^drop_included/
 ^webrev/
 ^nbproject/private/
--- a/jaxp/build-defs.xml	Fri Oct 30 10:54:43 2009 -0700
+++ b/jaxp/build-defs.xml	Fri Nov 06 17:26:01 2009 -0800
@@ -68,32 +68,14 @@
         </replaceregexp>
     </target>

-    <!-- Try to get drop sources, set property use.orig.src.dir if no drops. -->
+    <!-- Try to get drop sources. -->
     <target name="-set-props"
 	    depends="init,
                      jaxp_src-update">
-        <condition property="use.orig.src.dir">
-            <and>
-                <available file="${orig.src.dir}" type="dir"/>
-                <not>
-                    <and>
-                        <available file="${jaxp_src.src.dir}" type="dir"/>
-                    </and>
-                </not>
-            </and>
-        </condition>
     </target>

-    <!-- Set up source to use orig.src.dir, if use.orig.src.dir defined. -->
-    <target name="-use-orig" depends="-set-props" if="use.orig.src.dir">
-        <property name="primary.src.dir" value="${orig.src.dir}"/>
-        <path id="src.dir.id">
-            <pathelement path="${primary.src.dir}"/>
-        </path>
-    </target>
-
-    <!-- Set up source to use drop.dir, if use.orig.src.dir not defined. -->
-    <target name="-use-drop" depends="-set-props" unless="use.orig.src.dir">
+    <!-- Set up source to use drop.dir. -->
+    <target name="-use-drop" depends="-set-props">
         <property name="primary.src.dir" value="${jaxp_src.src.dir}"/>
         <path id="src.dir.id">
             <pathelement path="${primary.src.dir}"/>
@@ -102,24 +84,19 @@

     <!-- Source directory selection. -->
     <target name="-init-src-dirs"
-	    depends="init, -use-orig, -use-drop">
+	    depends="init, -use-drop">
         <echo message="Using primary.src.dir=${primary.src.dir}"/>
         <pathconvert property="src.list.id" refid="src.dir.id"/>
         <echo message="Using src.dir.id=${src.list.id}"/>
     </target>

-    <!-- Create orig src.zip. -->
-    <target name="-orig-src-zip" depends="init, -set-props" if="use.orig.src.dir">
-        <zip file="${dist.src.zip}" basedir="${primary.src.dir}"/>
-    </target>
-
     <!-- Create drop src.zip. -->
-    <target name="-drop-src-zip" depends="init, -set-props" unless="use.orig.src.dir">
+    <target name="-drop-src-zip" depends="init, -set-props">
         <zip file="${dist.src.zip}" basedir="${primary.src.dir}"/>
     </target>

     <!-- Create src.zip. -->
-    <target name="-dist-src-zip" depends="init, -orig-src-zip, -drop-src-zip">
+    <target name="-dist-src-zip" depends="init, -drop-src-zip">
     </target>

 </project>
--- a/jaxp/build-drop-template.xml	Fri Oct 30 10:54:43 2009 -0700
+++ b/jaxp/build-drop-template.xml	Fri Nov 06 17:26:01 2009 -0800
@@ -34,7 +34,7 @@

     <!-- Location where the copied bundle lands. -->
     <property name="@DROP@.bundle.copy"
-              value="${drop.dir}/bundles/${@DROP@.bundle.name}"/>
+              value="${drop.expanded.dir}/bundles/${@DROP@.bundle.name}"/>

     <!-- Root of exploded area. -->
     <property name="@DROP@.root.dir" value="${drop.dir}/@DROP@"/>
@@ -43,10 +43,13 @@
     <!-- To see if the drop areas are ready. (ignoring bundles) -->
     <target name="-@DROP@-ready">
         <condition property="@DROP@.ready">
-            <and>
-                <available file="${@DROP@.root.dir}" type="dir"/>
-                <available file="${@DROP@.root.dir}/PATCHED" type="file"/>
-            </and>
+            <or>
+                <available file="${drop.included.dir}" type="dir"/>
+                <and>
+                    <available file="${@DROP@.root.dir}" type="dir"/>
+                    <available file="${@DROP@.root.dir}/PATCHED" type="file"/>
+                </and>
+            </or>
         </condition>
     </target>

@@ -72,7 +75,6 @@
     <target name="-@DROP@-url-should-be-used" unless="@DROP@.url.should.be.used">
         <condition property="@DROP@.url.should.be.used">
             <and>
-                <http url="${@DROP@.master.bundle.url.base}"/>
                 <not>
                     <isset property="@DROP@.master.bundle.copy.exists"/>
                 </not>
@@ -106,6 +108,16 @@
         <delete dir="${@DROP@.root.dir}"/>
         <delete dir="${@DROP@.root.dir}-temp"/>
         <mkdir dir="${@DROP@.root.dir}-temp"/>
+	<checksum file="${@DROP@.bundle.copy}"
+		  property="@DROP@.bundle.md5.checksum.is"/>
+        <condition property="@DROP@.bundle.md5.checksum.good">
+            <equals arg1="${@DROP@.bundle.md5.checksum}"
+                    arg2="${@DROP@.bundle.md5.checksum.is}"/>
+        </condition>
+        <fail unless="@DROP@.bundle.md5.checksum.good">
+              Checksum on file ${@DROP@.bundle.copy} is
+              ${@DROP@.bundle.md5.checksum.is}, not ${@DROP@.bundle.md5.checksum}
+        </fail>
         <unzip src="${@DROP@.bundle.copy}" dest="${@DROP@.root.dir}-temp"/>
         <move file="${@DROP@.root.dir}-temp" tofile="${@DROP@.root.dir}"/>
         <touch>
--- a/jaxp/build.properties	Fri Oct 30 10:54:43 2009 -0700
+++ b/jaxp/build.properties	Fri Nov 06 17:26:01 2009 -0800
@@ -25,7 +25,7 @@

 # Base locations where bundles are located
 slashjava=/java
-devtools=${slashjava}/devtools
+drops.dir=${slashjava}/devtools/share/jdk7-drops

 # This is the JDK used to build and run the bootstrap version of javac.
 # The bootstrap javac is used to compile both boostrap versions of the
@@ -64,16 +64,15 @@
 dist.classes.jar=${dist.lib.dir}/classes.jar
 dist.src.zip=${dist.lib.dir}/src.zip

-# Where all drop sources live
-drop.dir=./drop
+# Where all drop sources get placed when downloaded and unzipped
+drop.expanded.dir=${output.dir}/drop
+
+# Location if the sources were included already
+drop.included.dir=./drop_included

 # Where patches to drop bundle sources live
 patches.dir=patches

-# Original source area
-orig.dir=src
-orig.src.dir=${orig.dir}/share/classes
-
 # Sanity information
 sanity.info= Sanity Settings:${line.separator}\
   ant.home=${ant.home}${line.separator}\
@@ -98,6 +97,7 @@
   build.dir=${build.dir}${line.separator}\
   dist.dir=${dist.dir}${line.separator}\
   drop.dir=${drop.dir}${line.separator}\
+  drops.dir=${drops.dir}${line.separator}\
 ${line.separator}

 #------------------------------------------------------------
--- a/jaxp/build.xml	Fri Oct 30 10:54:43 2009 -0700
+++ b/jaxp/build.xml	Fri Nov 06 17:26:01 2009 -0800
@@ -49,6 +49,13 @@
     <!-- Project build properties. -->
     <property file="build.properties"/>

+    <!-- See if drop sources were included. -->
+    <condition property="drop.dir"
+               value="${drop.included.dir}"
+               else="${drop.expanded.dir}">
+        <available file="${drop.included.dir}" type="dir"/>
+    </condition>
+
     <!-- Get shared targets. -->
     <import file="build-defs.xml"/>

@@ -131,6 +138,16 @@
             description="Populate all source file directories">
     </target>

+    <!-- Populate drop_included area. -->
+    <target name="drop_included"
+            depends="clobber"
+            description="Populate all source file directories">
+        <delete dir="${drop.included.dir}"/>
+        <antcall target="source"/>
+        <move file="${drop.expanded.dir}" tofile="${drop.included.dir}"/>
+        <delete dir="${drop.included.dir}/bundles"/>
+    </target>
+
     <!-- Clean up compiled files. -->
     <target name="clean"
             description="Delete all generated files">
@@ -142,7 +159,7 @@
     <target name="clobber"
 	    depends="clean"
             description="Delete all generated files, including imported sources">
-        <delete dir="${drop.dir}"/>
+        <delete dir="${drop.expanded.dir}"/>
     </target>

     <target name="-banner">
--- a/jaxp/jaxp.properties	Fri Oct 30 10:54:43 2009 -0700
+++ b/jaxp/jaxp.properties	Fri Nov 06 17:26:01 2009 -0800
@@ -23,12 +23,12 @@
 # have any questions.
 #

-drops.master.copy.base=${devtools}/share/jdk7-drops
-drops.master.url.base=http://kenai.com/projects/jdk7-drops/downloads/download
+drops.master.copy.base=${drops.dir}
+drops.master.url.base=https://jaxp.dev.java.net/files/documents/913/144160

-jaxp_src.bundle.name=jdk7-jaxp-2009_09_28.zip
+jaxp_src.bundle.name=jdk7-jaxp-m5.zip
+jaxp_src.bundle.md5.checksum=8b58ce7919cda8e32a9afc5cb4b58bb1
 jaxp_src.master.bundle.dir=${drops.master.copy.base}
-#jaxp_src.bundle.url.base=https://jaxp.dev.java.net/files/documents/913/142147
 jaxp_src.master.bundle.url.base=${drops.master.url.base}

 jaxp_tests.bundle.name=jdk7-jaxp-tests-2009_08_28.zip
--- a/jaxp/make/Makefile	Fri Oct 30 10:54:43 2009 -0700
+++ b/jaxp/make/Makefile	Fri Nov 06 17:26:01 2009 -0800
@@ -86,15 +86,22 @@
   endif
 endif

-# Where is /java/devtools in case we need it
-ifdef ALT_JDK_DEVTOOLS_DIR
-  _DEVTOOLS = $(ALT_JDK_DEVTOOLS_DIR)
+# Do we have the drops already downloaded?
+# Check ALT_DROPS_DIR for a full path first,
+# before trying to use the devtools path,
+# either via ALT_JDK_DEVTOOLS_DIR or /java/devtools.
+ifdef ALT_DROPS_DIR
+  DROPS_DIR = $(ALT_DROPS_DIR)
 else
-  _DEVTOOLS = $(_SLASHJAVA)/devtools
+  ifdef ALT_JDK_DEVTOOLS_DIR
+    DROPS_DIR = $(ALT_JDK_DEVTOOLS_DIR)/share/jdk7-drops
+  else
+    DROPS_DIR = $(_SLASHJAVA)/devtools/share/jdk7-drops
+  endif
 endif

-# Add in path to devtools
-ANT_OPTIONS += -Ddevtools=$(_DEVTOOLS)
+# Add in path to drops already downloaded
+ANT_OPTIONS += -Ddrops.dir=$(DROPS_DIR)

 ifdef ALT_OUTPUTDIR
   OUTPUTDIR = $(ALT_OUTPUTDIR)
@@ -130,7 +137,7 @@
 default: all

 # All ant targets of interest
-ANT_TARGETS = all source build dist clobber clean sanity
+ANT_TARGETS = all source drop_included build dist clobber clean sanity

 # Create a make target for each
 $(ANT_TARGETS):
--- a/jaxp/src/share/classes/com/sun/java_cup/internal/runtime/Scanner.java	Fri Oct 30 10:54:43 2009 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,45 +0,0 @@
-/*
- * Copyright 2003-2005 Sun Microsystems, Inc.  All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package com.sun.java_cup.internal.runtime;
-
-/**
- * Defines the Scanner interface, which CUP uses in the default
- * implementation of <code>lr_parser.scan()</code>.  Integration
- * of scanners implementing <code>Scanner</code> is facilitated.
- *
- * @author David MacMahon <davidm@smartsc.com>
- */
-
-/* *************************************************
-  Interface Scanner
-
-  Declares the next_token() method that should be
-  implemented by scanners.  This method is typically
-  called by lr_parser.scan().
- ***************************************************/
-public interface Scanner {
-    public Symbol next_token() throws java.lang.Exception;
-}
--- a/jaxp/src/share/classes/com/sun/java_cup/internal/runtime/Symbol.java	Fri Oct 30 10:54:43 2009 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,129 +0,0 @@
-/*
- * Copyright 2003-2005 Sun Microsystems, Inc.  All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package com.sun.java_cup.internal.runtime;
-
-/**
- * Defines the Symbol class, which is used to represent all terminals
- * and nonterminals while parsing.  The lexer should pass CUP Symbols
- * and CUP returns a Symbol.
- *
- * @author  Frank Flannery
- */
-
-/* ****************************************************************
-  Class Symbol
-  what the parser expects to receive from the lexer.
-  the token is identified as follows:
-  sym:    the symbol type
-  parse_state: the parse state.
-  value:  is the lexical value of type Object
-  left :  is the left position in the original input file
-  right:  is the right position in the original input file
-******************************************************************/
-
-public class Symbol {
-
-/*******************************
-  Constructor for l,r values
- *******************************/
-
-  public Symbol(int id, int l, int r, Object o) {
-    this(id);
-    left = l;
-    right = r;
-    value = o;
-  }
-
-/*******************************
-  Constructor for no l,r values
-********************************/
-
-  public Symbol(int id, Object o) {
-    this(id);
-    left = -1;
-    right = -1;
-    value = o;
-  }
-
-/*****************************
-  Constructor for no value
-  ***************************/
-
-  public Symbol(int sym_num, int l, int r) {
-    sym = sym_num;
-    left = l;
-    right = r;
-    value = null;
-  }
-
-/***********************************
-  Constructor for no value or l,r
-***********************************/
-
-  public Symbol(int sym_num) {
-    this(sym_num, -1);
-    left = -1;
-    right = -1;
-    value = null;
-  }
-
-/***********************************
-  Constructor to give a start state
-***********************************/
-  public Symbol(int sym_num, int state)
-    {
-      sym = sym_num;
-      parse_state = state;
-    }
-
-/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The symbol number of the terminal or non terminal being represented */
-  public int sym;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The parse state to be recorded on the parse stack with this symbol.
-   *  This field is for the convenience of the parser and shouldn't be
-   *  modified except by the parser.
-   */
-  public int parse_state;
-  /** This allows us to catch some errors caused by scanners recycling
-   *  symbols.  For the use of the parser only. [CSA, 23-Jul-1999] */
-  boolean used_by_parser = false;
-
-/*******************************
-  The data passed to parser
- *******************************/
-
-  public int left, right;
-  public Object value;
-
-  /*****************************
-    Printing this token out. (Override for pretty-print).
-    ****************************/
-  public String toString() { return "#"+sym; }
-}
--- a/jaxp/src/share/classes/com/sun/java_cup/internal/runtime/lr_parser.java	Fri Oct 30 10:54:43 2009 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1251 +0,0 @@
-/*
- * Copyright 2003-2005 Sun Microsystems, Inc.  All Rights Reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-
-package com.sun.java_cup.internal.runtime;
-
-import java.util.Stack;
-
-/** This class implements a skeleton table driven LR parser.  In general,
- *  LR parsers are a form of bottom up shift-reduce parsers.  Shift-reduce
- *  parsers act by shifting input onto a parse stack until the Symbols
- *  matching the right hand side of a production appear on the top of the
- *  stack.  Once this occurs, a reduce is performed.  This involves removing
- *  the Symbols corresponding to the right hand side of the production
- *  (the so called "handle") and replacing them with the non-terminal from
- *  the left hand side of the production.  <p>
- *
- *  To control the decision of whether to shift or reduce at any given point,
- *  the parser uses a state machine (the "viable prefix recognition machine"
- *  built by the parser generator).  The current state of the machine is placed
- *  on top of the parse stack (stored as part of a Symbol object representing
- *  a terminal or non terminal).  The parse action table is consulted
- *  (using the current state and the current lookahead Symbol as indexes) to
- *  determine whether to shift or to reduce.  When the parser shifts, it
- *  changes to a new state by pushing a new Symbol (containing a new state)
- *  onto the stack.  When the parser reduces, it pops the handle (right hand
- *  side of a production) off the stack.  This leaves the parser in the state
- *  it was in before any of those Symbols were matched.  Next the reduce-goto
- *  table is consulted (using the new state and current lookahead Symbol as
- *  indexes) to determine a new state to go to.  The parser then shifts to
- *  this goto state by pushing the left hand side Symbol of the production
- *  (also containing the new state) onto the stack.<p>
- *
- *  This class actually provides four LR parsers.  The methods parse() and
- *  debug_parse() provide two versions of the main parser (the only difference
- *  being that debug_parse() emits debugging trace messages as it parses).
- *  In addition to these main parsers, the error recovery mechanism uses two
- *  more.  One of these is used to simulate "parsing ahead" in the input
- *  without carrying out actions (to verify that a potential error recovery
- *  has worked), and the other is used to parse through buffered "parse ahead"
- *  input in order to execute all actions and re-synchronize the actual parser
- *  configuration.<p>
- *
- *  This is an abstract class which is normally filled out by a subclass
- *  generated by the JavaCup parser generator.  In addition to supplying
- *  the actual parse tables, generated code also supplies methods which
- *  invoke various pieces of user supplied code, provide access to certain
- *  special Symbols (e.g., EOF and error), etc.  Specifically, the following
- *  abstract methods are normally supplied by generated code:
- *  <dl compact>
- *  <dt> short[][] production_table()
- *  <dd> Provides a reference to the production table (indicating the index of
- *       the left hand side non terminal and the length of the right hand side
- *       for each production in the grammar).
- *  <dt> short[][] action_table()
- *  <dd> Provides a reference to the parse action table.
- *  <dt> short[][] reduce_table()
- *  <dd> Provides a reference to the reduce-goto table.
- *  <dt> int start_state()
- *  <dd> Indicates the index of the start state.
- *  <dt> int start_production()
- *  <dd> Indicates the index of the starting production.
- *  <dt> int EOF_sym()
- *  <dd> Indicates the index of the EOF Symbol.
- *  <dt> int error_sym()
- *  <dd> Indicates the index of the error Symbol.
- *  <dt> Symbol do_action()
- *  <dd> Executes a piece of user supplied action code.  This always comes at
- *       the point of a reduce in the parse, so this code also allocates and
- *       fills in the left hand side non terminal Symbol object that is to be
- *       pushed onto the stack for the reduce.
- *  <dt> void init_actions()
- *  <dd> Code to initialize a special object that encapsulates user supplied
- *       actions (this object is used by do_action() to actually carry out the
- *       actions).
- *  </dl>
- *
- *  In addition to these routines that <i>must</i> be supplied by the
- *  generated subclass there are also a series of routines that <i>may</i>
- *  be supplied.  These include:
- *  <dl>
- *  <dt> Symbol scan()
- *  <dd> Used to get the next input Symbol from the scanner.
- *  <dt> Scanner getScanner()
- *  <dd> Used to provide a scanner for the default implementation of
- *       scan().
- *  <dt> int error_sync_size()
- *  <dd> This determines how many Symbols past the point of an error
- *       must be parsed without error in order to consider a recovery to
- *       be valid.  This defaults to 3.  Values less than 2 are not
- *       recommended.
- *  <dt> void report_error(String message, Object info)
- *  <dd> This method is called to report an error.  The default implementation
- *       simply prints a message to System.err and where the error occurred.
- *       This method is often replaced in order to provide a more sophisticated
- *       error reporting mechanism.
- *  <dt> void report_fatal_error(String message, Object info)
- *  <dd> This method is called when a fatal error that cannot be recovered from
- *       is encountered.  In the default implementation, it calls
- *       report_error() to emit a message, then throws an exception.
- *  <dt> void syntax_error(Symbol cur_token)
- *  <dd> This method is called as soon as syntax error is detected (but
- *       before recovery is attempted).  In the default implementation it
- *       invokes: report_error("Syntax error", null);
- *  <dt> void unrecovered_syntax_error(Symbol cur_token)
- *  <dd> This method is called if syntax error recovery fails.  In the default
- *       implementation it invokes:<br>
- *         report_fatal_error("Couldn't repair and continue parse", null);
- *  </dl>
- *
- * @see     com.sun.java_cup.internal.runtime.Symbol
- * @see     com.sun.java_cup.internal.runtime.Symbol
- * @see     com.sun.java_cup.internal.runtime.virtual_parse_stack
- * @author  Frank Flannery
- */
-
-public abstract class lr_parser {
-
-  /*-----------------------------------------------------------*/
-  /*--- Constructor(s) ----------------------------------------*/
-  /*-----------------------------------------------------------*/
-
-  /** Simple constructor. */
-  public lr_parser()
-    {
-      /* nothing to do here */
-    }
-
-  /** Constructor that sets the default scanner. [CSA/davidm] */
-  public lr_parser(Scanner s) {
-    this(); /* in case default constructor someday does something */
-    setScanner(s);
-  }
-
-  /*-----------------------------------------------------------*/
-  /*--- (Access to) Static (Class) Variables ------------------*/
-  /*-----------------------------------------------------------*/
-
-  /** The default number of Symbols after an error we much match to consider
-   *  it recovered from.
-   */
-  protected final static int _error_sync_size = 3;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The number of Symbols after an error we much match to consider it
-   *  recovered from.
-   */
-  protected int error_sync_size() {return _error_sync_size; }
-
-  /*-----------------------------------------------------------*/
-  /*--- (Access to) Instance Variables ------------------------*/
-  /*-----------------------------------------------------------*/
-
-  /** Table of production information (supplied by generated subclass).
-   *  This table contains one entry per production and is indexed by
-   *  the negative-encoded values (reduce actions) in the action_table.
-   *  Each entry has two parts, the index of the non-terminal on the
-   *  left hand side of the production, and the number of Symbols
-   *  on the right hand side.
-   */
-  public abstract short[][] production_table();
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The action table (supplied by generated subclass).  This table is
-   *  indexed by state and terminal number indicating what action is to
-   *  be taken when the parser is in the given state (i.e., the given state
-   *  is on top of the stack) and the given terminal is next on the input.
-   *  States are indexed using the first dimension, however, the entries for
-   *  a given state are compacted and stored in adjacent index, value pairs
-   *  which are searched for rather than accessed directly (see get_action()).
-   *  The actions stored in the table will be either shifts, reduces, or
-   *  errors.  Shifts are encoded as positive values (one greater than the
-   *  state shifted to).  Reduces are encoded as negative values (one less
-   *  than the production reduced by).  Error entries are denoted by zero.
-   *
-   * @see com.sun.java_cup.internal.runtime.lr_parser#get_action
-   */
-  public abstract short[][] action_table();
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The reduce-goto table (supplied by generated subclass).  This
-   *  table is indexed by state and non-terminal number and contains
-   *  state numbers.  States are indexed using the first dimension, however,
-   *  the entries for a given state are compacted and stored in adjacent
-   *  index, value pairs which are searched for rather than accessed
-   *  directly (see get_reduce()).  When a reduce occurs, the handle
-   *  (corresponding to the RHS of the matched production) is popped off
-   *  the stack.  The new top of stack indicates a state.  This table is
-   *  then indexed by that state and the LHS of the reducing production to
-   *  indicate where to "shift" to.
-   *
-   * @see com.sun.java_cup.internal.runtime.lr_parser#get_reduce
-   */
-  public abstract short[][] reduce_table();
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The index of the start state (supplied by generated subclass). */
-  public abstract int start_state();
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The index of the start production (supplied by generated subclass). */
-  public abstract int start_production();
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The index of the end of file terminal Symbol (supplied by generated
-   *  subclass).
-   */
-  public abstract int EOF_sym();
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The index of the special error Symbol (supplied by generated subclass). */
-  public abstract int error_sym();
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Internal flag to indicate when parser should quit. */
-  protected boolean _done_parsing = false;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** This method is called to indicate that the parser should quit.  This is
-   *  normally called by an accept action, but can be used to cancel parsing
-   *  early in other circumstances if desired.
-   */
-  public void done_parsing()
-    {
-      _done_parsing = true;
-    }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-  /* Global parse state shared by parse(), error recovery, and
-   * debugging routines */
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Indication of the index for top of stack (for use by actions). */
-  protected int tos;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The current lookahead Symbol. */
-  protected Symbol cur_token;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** The parse stack itself. */
-  protected Stack stack = new Stack();
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Direct reference to the production table. */
-  protected short[][] production_tab;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Direct reference to the action table. */
-  protected short[][] action_tab;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Direct reference to the reduce-goto table. */
-  protected short[][] reduce_tab;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** This is the scanner object used by the default implementation
-   *  of scan() to get Symbols.  To avoid name conflicts with existing
-   *  code, this field is private. [CSA/davidm] */
-  private Scanner _scanner;
-
-  /**
-   * Simple accessor method to set the default scanner.
-   */
-  public void setScanner(Scanner s) { _scanner = s; }
-
-  /**
-   * Simple accessor method to get the default scanner.
-   */
-  public Scanner getScanner() { return _scanner; }
-
-  /*-----------------------------------------------------------*/
-  /*--- General Methods ---------------------------------------*/
-  /*-----------------------------------------------------------*/
-
-  /** Perform a bit of user supplied action code (supplied by generated
-   *  subclass).  Actions are indexed by an internal action number assigned
-   *  at parser generation time.
-   *
-   * @param act_num   the internal index of the action to be performed.
-   * @param parser    the parser object we are acting for.
-   * @param stack     the parse stack of that object.
-   * @param top       the index of the top element of the parse stack.
-   */
-  public abstract Symbol do_action(
-    int       act_num,
-    lr_parser parser,
-    Stack     stack,
-    int       top)
-    throws java.lang.Exception;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** User code for initialization inside the parser.  Typically this
-   *  initializes the scanner.  This is called before the parser requests
-   *  the first Symbol.  Here this is just a placeholder for subclasses that
-   *  might need this and we perform no action.   This method is normally
-   *  overridden by the generated code using this contents of the "init with"
-   *  clause as its body.
-   */
-  public void user_init() throws java.lang.Exception { }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Initialize the action object.  This is called before the parser does
-   *  any parse actions. This is filled in by generated code to create
-   *  an object that encapsulates all action code.
-   */
-  protected abstract void init_actions() throws java.lang.Exception;
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Get the next Symbol from the input (supplied by generated subclass).
-   *  Once end of file has been reached, all subsequent calls to scan
-   *  should return an EOF Symbol (which is Symbol number 0).  By default
-   *  this method returns getScanner().next_token(); this implementation
-   *  can be overriden by the generated parser using the code declared in
-   *  the "scan with" clause.  Do not recycle objects; every call to
-   *  scan() should return a fresh object.
-   */
-  public Symbol scan() throws java.lang.Exception {
-    return getScanner().next_token();
-  }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Report a fatal error.  This method takes a  message string and an
-   *  additional object (to be used by specializations implemented in
-   *  subclasses).  Here in the base class a very simple implementation
-   *  is provided which reports the error then throws an exception.
-   *
-   * @param message an error message.
-   * @param info    an extra object reserved for use by specialized subclasses.
-   */
-  public void report_fatal_error(
-    String   message,
-    Object   info)
-    throws java.lang.Exception
-    {
-      /* stop parsing (not really necessary since we throw an exception, but) */
-      done_parsing();
-
-      /* use the normal error message reporting to put out the message */
-      report_error(message, info);
-
-      /* throw an exception */
-      throw new Exception("Can't recover from previous error(s)");
-    }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Report a non fatal error (or warning).  This method takes a message
-   *  string and an additional object (to be used by specializations
-   *  implemented in subclasses).  Here in the base class a very simple
-   *  implementation is provided which simply prints the message to
-   *  System.err.
-   *
-   * @param message an error message.
-   * @param info    an extra object reserved for use by specialized subclasses.
-   */
-  public void report_error(String message, Object info)
-    {
-      System.err.print(message);
-      if (info instanceof Symbol)
-        if (((Symbol)info).left != -1)
-        System.err.println(" at character " + ((Symbol)info).left +
-                           " of input");
-        else System.err.println("");
-      else System.err.println("");
-    }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** This method is called when a syntax error has been detected and recovery
-   *  is about to be invoked.  Here in the base class we just emit a
-   *  "Syntax error" error message.
-   *
-   * @param cur_token the current lookahead Symbol.
-   */
-  public void syntax_error(Symbol cur_token)
-    {
-      report_error("Syntax error", cur_token);
-    }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** This method is called if it is determined that syntax error recovery
-   *  has been unsuccessful.  Here in the base class we report a fatal error.
-   *
-   * @param cur_token the current lookahead Symbol.
-   */
-  public void unrecovered_syntax_error(Symbol cur_token)
-    throws java.lang.Exception
-    {
-      report_fatal_error("Couldn't repair and continue parse", cur_token);
-    }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Fetch an action from the action table.  The table is broken up into
-   *  rows, one per state (rows are indexed directly by state number).
-   *  Within each row, a list of index, value pairs are given (as sequential
-   *  entries in the table), and the list is terminated by a default entry
-   *  (denoted with a Symbol index of -1).  To find the proper entry in a row
-   *  we do a linear or binary search (depending on the size of the row).
-   *
-   * @param state the state index of the action being accessed.
-   * @param sym   the Symbol index of the action being accessed.
-   */
-  protected final short get_action(int state, int sym)
-    {
-      short tag;
-      int first, last, probe;
-      short[] row = action_tab[state];
-
-      /* linear search if we are < 10 entries */
-      if (row.length < 20)
-        for (probe = 0; probe < row.length; probe++)
-          {
-            /* is this entry labeled with our Symbol or the default? */
-            tag = row[probe++];
-            if (tag == sym || tag == -1)
-              {
-                /* return the next entry */
-                return row[probe];
-              }
-          }
-      /* otherwise binary search */
-      else
-        {
-          first = 0;
-          last = (row.length-1)/2 - 1;  /* leave out trailing default entry */
-          while (first <= last)
-            {
-              probe = (first+last)/2;
-              if (sym == row[probe*2])
-                return row[probe*2+1];
-              else if (sym > row[probe*2])
-                first = probe+1;
-              else
-                last = probe-1;
-            }
-
-          /* not found, use the default at the end */
-          return row[row.length-1];
-        }
-
-      /* shouldn't happened, but if we run off the end we return the
-         default (error == 0) */
-      return 0;
-    }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** Fetch a state from the reduce-goto table.  The table is broken up into
-   *  rows, one per state (rows are indexed directly by state number).
-   *  Within each row, a list of index, value pairs are given (as sequential
-   *  entries in the table), and the list is terminated by a default entry
-   *  (denoted with a Symbol index of -1).  To find the proper entry in a row
-   *  we do a linear search.
-   *
-   * @param state the state index of the entry being accessed.
-   * @param sym   the Symbol index of the entry being accessed.
-   */
-  protected final short get_reduce(int state, int sym)
-    {
-      short tag;
-      short[] row = reduce_tab[state];
-
-      /* if we have a null row we go with the default */
-      if (row == null)
-        return -1;
-
-      for (int probe = 0; probe < row.length; probe++)
-        {
-          /* is this entry labeled with our Symbol or the default? */
-          tag = row[probe++];
-          if (tag == sym || tag == -1)
-            {
-              /* return the next entry */
-              return row[probe];
-            }
-        }
-      /* if we run off the end we return the default (error == -1) */
-      return -1;
-    }
-
-  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
-  /** This method provides the main parsing routine.  It returns only when
-   *  done_parsing() has been called (typically because the parser has
-   *  accepted, or a fatal error has been reported).  See the header
-   *  documentation for the class regarding how shift/reduce parsers operate
-   *  and how the various tables are used.
-   */
-  public Symbol parse() throws java.lang.Exception
-    {
-      /* the current action code */
-      int act;
-
-      /* the Symbol/stack element returned by a reduce */
-      Symbol lhs_sym = null;
-
-      /* information about production being reduced with */
-      short handle_size, lhs_sym_num;
-
-      /* set up direct reference to tables to drive the parser */
-
-      production_tab = production_table();
-      action_tab     = action_table();
-      reduce_tab     = reduce_table();
-