From mevenson at common-lisp.net  Mon Nov  2 12:25:55 2009
From: mevenson at common-lisp.net (Mark Evenson)
Date: Mon, 02 Nov 2009 07:25:55 -0500
Subject: [armedbear-cvs] r12238 - trunk/abcl
Message-ID: <E1N4vyt-0004FJ-I2@common-lisp.net>

Author: mevenson
Date: Mon Nov  2 07:25:53 2009
New Revision: 12238

Log:
New targets for binary releases 'abcl.binary.tar' and 'abcl.binary.zip'.



Modified:
   trunk/abcl/build.xml

Modified: trunk/abcl/build.xml
==============================================================================
--- trunk/abcl/build.xml	(original)
+++ trunk/abcl/build.xml	Mon Nov  2 07:25:53 2009
@@ -494,6 +494,42 @@
 	<zipfileset dir="${abcl.build.src.dir}" prefix="abcl-src-${abcl.version}"/>
       </zip>
     </target>
+    
+    <target name="abcl.binary.prepare" depends="abcl.stamp.version">
+      <property name="abcl.build.binary.dir"
+                value="${build.dir}/abcl-bin-${abcl.version}"/>
+      <mkdir dir="${abcl.build.binary.dir}"/>
+      <copy todir="${abcl.build.binary.dir}"
+            preservelastmodified="true">
+        <fileset dir="${basedir}/dist">
+          <patternset>
+            <include name="abcl.jar"/>
+          </patternset>
+        </fileset>
+        <fileset dir="${basedir}">
+          <patternset>
+            <include name="README"/>
+            <include name="CHANGES"/>
+          </patternset>
+        </fileset>
+      </copy>
+    </target>
+
+    <target name="abcl.binary.tar" depends="abcl.binary.prepare">
+      <tar destfile="${dist.dir}/abcl-bin-${abcl.version}.tar.gz"
+           compression="gzip">
+        <tarfileset dir="${build.dir}">
+          <include name="abcl-bin-${abcl.version}/**"/>
+          </tarfileset>
+      </tar>
+    </target>
+
+    <target name="abcl.binary.zip" depends="abcl.binary.prepare">
+      <zip destfile="${dist.dir}/abcl-bin-${abcl.version}.zip"
+           compress="true">
+        <zipfileset dir="${abcl.build.binary.dir}" prefix="abcl-bin-${abcl.version}"/>
+      </zip>
+    </target>
 
     <property name="abcl.test.classes.dir"
 	      value="${build.dir}/classes-test"/>



From ehuelsmann at common-lisp.net  Mon Nov  2 19:29:32 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Mon, 02 Nov 2009 14:29:32 -0500
Subject: [armedbear-cvs] r12239 - branches/0.17.x
Message-ID: <E1N52aq-0002Nf-In@common-lisp.net>

Author: ehuelsmann
Date: Mon Nov  2 14:29:28 2009
New Revision: 12239

Log:
Create ABCL 0.17 release branch.

Added:
   branches/0.17.x/
      - copied from r12238, /trunk/



From ehuelsmann at common-lisp.net  Mon Nov  2 19:43:29 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Mon, 02 Nov 2009 14:43:29 -0500
Subject: [armedbear-cvs] r12240 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N52oL-0003Np-OM@common-lisp.net>

Author: ehuelsmann
Date: Mon Nov  2 14:43:27 2009
New Revision: 12240

Log:
Bump trunk version number with 0.17 branched.

Modified:
   trunk/abcl/src/org/armedbear/lisp/Version.java

Modified: trunk/abcl/src/org/armedbear/lisp/Version.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Version.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Version.java	Mon Nov  2 14:43:27 2009
@@ -41,6 +41,6 @@
 
   public static String getVersion()
   {
-    return "0.17.0-dev";
+    return "0.18.0-dev";
   }
 }



From ehuelsmann at common-lisp.net  Mon Nov  2 20:40:38 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Mon, 02 Nov 2009 15:40:38 -0500
Subject: [armedbear-cvs] r12241 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N53hd-0008Ea-Ug@common-lisp.net>

Author: ehuelsmann
Date: Mon Nov  2 15:40:35 2009
New Revision: 12241

Log:
Document getStringValue() to return the string value from string designators.
Change string designators (Symbol, LispCharacter) to return a value too.

Modified:
   trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
   trunk/abcl/src/org/armedbear/lisp/LispObject.java
   trunk/abcl/src/org/armedbear/lisp/Symbol.java

Modified: trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispCharacter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispCharacter.java	Mon Nov  2 15:40:35 2009
@@ -226,6 +226,13 @@
     return Character.toUpperCase(value);
   }
 
+  /** See LispObject.getStringValue() */
+  @Override
+  public String getStringValue() throws ConditionThrowable
+  {
+    return String.valueOf(value);
+  }
+
   @Override
   public final String writeToString() throws ConditionThrowable
   {

Modified: trunk/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispObject.java	Mon Nov  2 15:40:35 2009
@@ -1062,6 +1062,11 @@
     return null;
   }
 
+  /** Returns a string representing the value
+   * of a 'string designator', if the instance is one.
+   *
+   * Throws an error if the instance isn't a string designator.
+   */
   public String getStringValue() throws ConditionThrowable
   {
     type_error(this, Symbol.STRING);

Modified: trunk/abcl/src/org/armedbear/lisp/Symbol.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Symbol.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Symbol.java	Mon Nov  2 15:40:35 2009
@@ -420,6 +420,13 @@
     this.function = obj;
   }
 
+  /** See LispObject.getStringValue() */
+  @Override
+  public String getStringValue() throws ConditionThrowable
+  {
+    return name.getStringValue();
+  }
+
   @Override
   public final LispObject getPropertyList()
   {



From ehuelsmann at common-lisp.net  Tue Nov  3 19:07:46 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Tue, 03 Nov 2009 14:07:46 -0500
Subject: [armedbear-cvs] r12242 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N5OjK-0003jV-3e@common-lisp.net>

Author: ehuelsmann
Date: Tue Nov  3 14:07:42 2009
New Revision: 12242

Log:
Increment FASL version for 0.17 release.

Modified:
   trunk/abcl/src/org/armedbear/lisp/Load.java

Modified: trunk/abcl/src/org/armedbear/lisp/Load.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Load.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Load.java	Tue Nov  3 14:07:42 2009
@@ -427,7 +427,7 @@
     // ### *fasl-version*
     // internal symbol
     private static final Symbol _FASL_VERSION_ =
-        exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(32));
+        exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(33));
 
     // ### *fasl-anonymous-package*
     // internal symbol



From ehuelsmann at common-lisp.net  Tue Nov  3 19:11:22 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Tue, 03 Nov 2009 14:11:22 -0500
Subject: [armedbear-cvs] r12243 - branches/0.17.x/abcl/src/org/armedbear/lisp
Message-ID: <E1N5Omo-0003ln-Il@common-lisp.net>

Author: ehuelsmann
Date: Tue Nov  3 14:11:21 2009
New Revision: 12243

Log:
Backport r12242: FASL version increment.

Modified:
   branches/0.17.x/abcl/src/org/armedbear/lisp/Load.java

Modified: branches/0.17.x/abcl/src/org/armedbear/lisp/Load.java
==============================================================================
--- branches/0.17.x/abcl/src/org/armedbear/lisp/Load.java	(original)
+++ branches/0.17.x/abcl/src/org/armedbear/lisp/Load.java	Tue Nov  3 14:11:21 2009
@@ -427,7 +427,7 @@
     // ### *fasl-version*
     // internal symbol
     private static final Symbol _FASL_VERSION_ =
-        exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(32));
+        exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(33));
 
     // ### *fasl-anonymous-package*
     // internal symbol



From astalla at common-lisp.net  Tue Nov  3 21:49:31 2009
From: astalla at common-lisp.net (Alessio Stalla)
Date: Tue, 03 Nov 2009 16:49:31 -0500
Subject: [armedbear-cvs] r12244 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N5RFr-00061U-Nn@common-lisp.net>

Author: astalla
Date: Tue Nov  3 16:49:29 2009
New Revision: 12244

Log:
Implemented AbstractString.toString() returning the Java string for nicer printing in Java


Modified:
   trunk/abcl/src/org/armedbear/lisp/AbstractString.java

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractString.java	Tue Nov  3 16:49:29 2009
@@ -118,4 +118,18 @@
     {
         return writeToString(0, length());
     }
+
+    public String toString() {
+	try {
+	    int length = length();
+	    StringBuilder sb = new StringBuilder(length);
+	    for(int i = 0; i < length; ++i) {
+		sb.append(charAt(i));
+	    }
+	    return sb.toString();
+	} catch(ConditionThrowable t) {
+	    throw new Error(t); //Should never happen
+	}
+    }
+
 }



From ehuelsmann at common-lisp.net  Tue Nov  3 22:23:01 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Tue, 03 Nov 2009 17:23:01 -0500
Subject: [armedbear-cvs] r12245 - public_html
Message-ID: <E1N5RmH-0008Ne-8g@common-lisp.net>

Author: ehuelsmann
Date: Tue Nov  3 17:22:57 2009
New Revision: 12245

Log:
Include examples of what could be achieved with money.

Modified:
   public_html/commercial-support.shtml

Modified: public_html/commercial-support.shtml
==============================================================================
--- public_html/commercial-support.shtml	(original)
+++ public_html/commercial-support.shtml	Tue Nov  3 17:22:57 2009
@@ -45,6 +45,15 @@
 </p>
 
 
+<p>Projects / tasks to be addressed include:</p>
+
+<ul>
+  <li>Finalizing Gray stream support</li>
+  <li>Performance research and improvements</li>
+  <li>(More) [A]MOP support</li>
+  <li>Better Java/JNA (foreign library) integration</li>
+</ul>
+
 <p><span style="size:70%">Other developers are free to get their names added
     to this list, but at this point no other developers are known to
     want to provide this type of support.</span></p>



From ehuelsmann at common-lisp.net  Wed Nov  4 22:00:52 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Wed, 04 Nov 2009 17:00:52 -0500
Subject: [armedbear-cvs] r12246 - public_html
Message-ID: <E1N5nuO-0000RS-Dk@common-lisp.net>

Author: ehuelsmann
Date: Wed Nov  4 17:00:47 2009
New Revision: 12246

Log:
Better visual styling of release notes.

Modified:
   public_html/release-notes-0.16.shtml
   public_html/style.css

Modified: public_html/release-notes-0.16.shtml
==============================================================================
--- public_html/release-notes-0.16.shtml	(original)
+++ public_html/release-notes-0.16.shtml	Wed Nov  4 17:00:47 2009
@@ -3,29 +3,28 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
-  <title><!--#include virtual="project-name" --></title>
+  <title>ABCL - Release notes v0.16</title>
   <link rel="stylesheet" type="text/css" href="style.css"/>
   <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
-<style>
-dt { font-size: 105%; font-family: sans-serif; font-weight: bold }
-dd { }
-</style>
 </head>
 
 <body>
  <div class="header">
-   <h1><!--#include virtual="project-name" --></h1>
+   <h1>ABCL - Release notes for version 0.16</h1>
  </div>
 
 <!--#include virtual="left-menu" -->
 
-<div style="float:left;width:80ex;margin-top:1cm">
+<div class="rn">
 
-<h2 style="text-align:center">Release notes for ABCL 0.16</h2>
-<p>
-  <b style="font-family: sans-serif; font-size: 125%;">Major changes and new features</b>
-</p>
-<dl style="margin-left:3cm;width:20cm">
+<h2>Most notable changes in ABCL 0.16</h2>
+
+
+<p><a href="release-notes-0.15.shtml">Release notes for older releases</a>.</p>
+
+
+
+<dl>
   <dt>Improved THE type checking</dt>
   <dd>The compiler outputs type checks for simple enough types at
     *safety* levels 1 and 2 now.<br />
@@ -49,95 +48,8 @@
 </dl>
 
 
-<h2 style="text-align:center">Release notes for ABCL 0.15</h2>
-<p>
-  <b style="font-family: sans-serif; font-size: 125%;">Major changes and new features</b>
-</p>
-<dl style="margin-left:3cm;width:20cm">
-  <dt>Fixed special bindings un-binding in compiled code for (local)
-    transfer of control using GO/RETURN-FROM</dt>
-  <dd>Special bindings now will get unbound in many more cases and much
-    more efficiently upon local transfer of control.
-  </dd>
-  <dt>Reduced ANSI failures in both compiled and interpreted modes</dt>
-  <dd>MULTIPLE-VALUE-SETQ wasn't working correctly on symbol macros.
-    Multiple issues with DEFINE-SETF-EXPANDER, and others. See CHANGES.
-  </dd>
-  <dt>Multiple JSR-233 (Java scripting) support fixes</dt>
-  <dd>See the logs for more: too much to summarize.
-  </dd>
-  <dt>Compiler new feature</dt>
-  <dd>Support for COMPILE-ing functions with non-empty lexical environments -
-    which themselves are not being compiled.
-  </dd>
-  <dt>Google App Engine</dt>
-  <dd>Don't break when being run on Google App Engine because 'os.arch'
-    isn't set.
-  </dd>
-  <dt>COMPILER-LET and MACROEXPAND-ALL</dt>
-  <dd>CLtL2 primitive COMPILER-LET is now supported in the EXT package,
-    so is MACROEXPAND-ALL.
-  </dd>
-</dl>
-
-<h2 style="text-align:center">Release notes for ABCL 0.14</h2>
-<p>
-  <b style="font-family: sans-serif; font-size: 125%;">Major changes and new features</b>
-</p>
-<dl style="margin-left:3cm;width:20cm">
-  <dt>Fixed special bindings un-binding in compiled code for
-   MULTIPLE-VALUE-BIND, LET, LET*, PROGV and function bodies</dt>
-  </dt>
-  <dd>Special bindings now will get unbound even in case of (non-Lisp)
-      exceptions.
-  </dd>
-  <dt>Reduced ANSI failures in interpreted mode</dt>
-  <dd>RESTART-CASE wrongly didn't use the macro expansion environment
-    to expand subforms.
-  </dd>
-  <dt>Lisp build system changed for parity with the Ant based build</dt>
-  <dd>The Lisp build was lagging behind on adjustments made to the Ant
-    based build.  abcl.jar generated from either should now be the same.
-  </dd>
-  <dt>Several fixes to numeric calculations</dt>
-  <dd>EXPT fixed for (EXPT NUMBER BIGNUM) and (EXPT BIGNUM RATIO).
-    Also, ACOS with a complex double-float argument.
-  </dd>
-</dl>
 
 
-<h2 style="text-align:center">Release notes for ABCL 0.13</h2>
-
-<p>
-  <b style="font-family: sans-serif; font-size: 125%;">Major changes and new features</b>
-
-</p>
-<dl style="margin-left:3cm;width:20cm">
-  <dt>JSR-223: Java Scripting Plugin
-  </dt>
-  <dd>ABCL supports - when built with the <code>javax.script</code> package
-    in the CLASSPATH - the interfaces defined in <a href="http://java.sun.com/developer/technicalArticles/J2SE/Desktop/scripting/">JSR-223</a>.
-  </dd>
-  <dt>Support for inlining FLOAT results</dt>
-  <dd>When given the right DECLARE forms, ABCL is now able to inline
-    calculations and intermediate values relating to FLOAT types.  Before,
-    it used to box all FLOAT values and results, without inlining.</dd>
-  <dt>Compiler cleanups</dt>
-  <dd>Lots of code cleanup in the compiler, such as elimination of
-    nearly-equivalent code blocks.</dd>
-  <dt>TRACE-ing fixes</dt>
-  <dd>TRACE should no longer blow up when tracing FORMAT or inside
-    the compiler.</dd>
-  <dt>Support for "partial" wildcards in CL:DIRECTORY</dt>
-  <dd>Patterns such as #p"cl-*.lisp" are now supported.</dd>
-</dl>
-
-<h2 style="text-align:center">Release notes for ABCL 0.12 and older</h2>
-
-<p>These release notes have not been created before. If someone takes
-  the effort to create them, they will be added for 0.11 and 0.12.</p>
-
-</div>
 
 <div style="float:left;width:100%">
  <hr />

Modified: public_html/style.css
==============================================================================
--- public_html/style.css	(original)
+++ public_html/style.css	Wed Nov  4 17:00:47 2009
@@ -63,4 +63,25 @@
 .summary-header span {
     font-weight: normal;
     font-size: 80%;
-}
\ No newline at end of file
+}
+
+div.rn {
+  float:        left;
+  width:        20cm;
+  margin-top:    1cm;
+  margin-bottom: 1cm;
+}
+
+div.rn dl {
+  margin-left: 3cm;
+  width:      17cm;
+}
+
+div.rn dl dt {
+  font-family: sans-serif;
+  font-weight:       bold;
+  margin-top:         1cm;
+  background:        #369;
+  color:             #fff;
+  padding-left:       2ex;
+}



From ehuelsmann at common-lisp.net  Wed Nov  4 22:03:15 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Wed, 04 Nov 2009 17:03:15 -0500
Subject: [armedbear-cvs] r12247 - public_html
Message-ID: <E1N5nwh-0000Vt-8S@common-lisp.net>

Author: ehuelsmann
Date: Wed Nov  4 17:03:14 2009
New Revision: 12247

Log:
More styling changes.

Modified:
   public_html/style.css

Modified: public_html/style.css
==============================================================================
--- public_html/style.css	(original)
+++ public_html/style.css	Wed Nov  4 17:03:14 2009
@@ -73,8 +73,7 @@
 }
 
 div.rn dl {
-  margin-left: 3cm;
-  width:      17cm;
+  width:      20cm;
 }
 
 div.rn dl dt {



From ehuelsmann at common-lisp.net  Thu Nov  5 20:01:41 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Thu, 05 Nov 2009 15:01:41 -0500
Subject: [armedbear-cvs] r12248 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N68Wb-0001gE-Dp@common-lisp.net>

Author: ehuelsmann
Date: Thu Nov  5 15:01:38 2009
New Revision: 12248

Log:
Fix macroexpansion bug in the precompiler.

Reported by: szergling at gmail


Modified:
   trunk/abcl/src/org/armedbear/lisp/precompiler.lisp

Modified: trunk/abcl/src/org/armedbear/lisp/precompiler.lisp
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/precompiler.lisp	(original)
+++ trunk/abcl/src/org/armedbear/lisp/precompiler.lisp	Thu Nov  5 15:01:38 2009
@@ -894,7 +894,7 @@
          (when (and (consp form)
                     (symbolp (%car form))
                     (special-operator-p (%car form)))
-           (return-from expand-macro form)))
+           (return-from expand-macro (values form exp))))
        (multiple-value-bind (result expanded)
            (macroexpand-1 form *precompile-env*)
          (unless expanded



From ehuelsmann at common-lisp.net  Thu Nov  5 20:08:18 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Thu, 05 Nov 2009 15:08:18 -0500
Subject: [armedbear-cvs] r12249 - branches/0.17.x/abcl/src/org/armedbear/lisp
Message-ID: <E1N68d0-0001wM-7z@common-lisp.net>

Author: ehuelsmann
Date: Thu Nov  5 15:08:17 2009
New Revision: 12249

Log:
Backport precompiler fix.

Modified:
   branches/0.17.x/abcl/src/org/armedbear/lisp/precompiler.lisp

Modified: branches/0.17.x/abcl/src/org/armedbear/lisp/precompiler.lisp
==============================================================================
--- branches/0.17.x/abcl/src/org/armedbear/lisp/precompiler.lisp	(original)
+++ branches/0.17.x/abcl/src/org/armedbear/lisp/precompiler.lisp	Thu Nov  5 15:08:17 2009
@@ -894,7 +894,7 @@
          (when (and (consp form)
                     (symbolp (%car form))
                     (special-operator-p (%car form)))
-           (return-from expand-macro form)))
+           (return-from expand-macro (values form exp))))
        (multiple-value-bind (result expanded)
            (macroexpand-1 form *precompile-env*)
          (unless expanded



From ehuelsmann at common-lisp.net  Thu Nov  5 20:15:57 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Thu, 05 Nov 2009 15:15:57 -0500
Subject: [armedbear-cvs] r12250 - developer-resources
Message-ID: <E1N68kP-0002FK-T9@common-lisp.net>

Author: ehuelsmann
Date: Thu Nov  5 15:15:56 2009
New Revision: 12250

Log:
Add a directory for "developer stuff".

Added:
   developer-resources/



From astalla at common-lisp.net  Thu Nov  5 21:22:44 2009
From: astalla at common-lisp.net (Alessio Stalla)
Date: Thu, 05 Nov 2009 16:22:44 -0500
Subject: [armedbear-cvs] r12251 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N69n2-0007sa-DQ@common-lisp.net>

Author: astalla
Date: Thu Nov  5 16:22:42 2009
New Revision: 12251

Log:
Fixed misuse of ConditionThrowable to signal program errors.


Modified:
   trunk/abcl/src/org/armedbear/lisp/JavaClass.java

Modified: trunk/abcl/src/org/armedbear/lisp/JavaClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaClass.java	Thu Nov  5 16:22:42 2009
@@ -135,11 +135,11 @@
 	private static final Primitive _FIND_JAVA_CLASS = new Primitive(
 			"%find-java-class", PACKAGE_JAVA, false, "string") {
 		public LispObject execute(LispObject arg) throws ConditionThrowable {
-			try {
-				return findJavaClass(Class.forName((String) arg.getStringValue()));
-			} catch (ClassNotFoundException e) {
-				throw new ConditionThrowable("Cannot find Java class " + arg.getStringValue());
-			}
+		    try {
+			return findJavaClass(Class.forName((String) arg.getStringValue()));
+		    } catch (ClassNotFoundException e) {
+			return error(new LispError("Cannot find Java class " + arg.getStringValue()));
+		    }
 		}
 
 	};



From ehuelsmann at common-lisp.net  Thu Nov  5 21:52:12 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Thu, 05 Nov 2009 16:52:12 -0500
Subject: [armedbear-cvs] r12252 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N6AFY-00020S-NR@common-lisp.net>

Author: ehuelsmann
Date: Thu Nov  5 16:52:10 2009
New Revision: 12252

Log:
Annotate dubious uses of ConditionThrowable with FIXME's.

Modified:
   trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
   trunk/abcl/src/org/armedbear/lisp/AbstractString.java
   trunk/abcl/src/org/armedbear/lisp/Autoload.java
   trunk/abcl/src/org/armedbear/lisp/ComplexString.java
   trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java
   trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java
   trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/Interpreter.java
   trunk/abcl/src/org/armedbear/lisp/JHandler.java
   trunk/abcl/src/org/armedbear/lisp/JProxy.java
   trunk/abcl/src/org/armedbear/lisp/Java.java
   trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java
   trunk/abcl/src/org/armedbear/lisp/LispThread.java
   trunk/abcl/src/org/armedbear/lisp/Pathname.java
   trunk/abcl/src/org/armedbear/lisp/Profiler.java
   trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java
   trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
   trunk/abcl/src/org/armedbear/lisp/Stream.java
   trunk/abcl/src/org/armedbear/lisp/Symbol.java

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java	Thu Nov  5 16:52:10 2009
@@ -168,6 +168,7 @@
             for (int i = 0; i < limit; i++)
                 hashCode = hashCode * 31 + getBit(i);
         }
+        // ### fixme exception
         catch (ConditionThrowable t) {
             // Shouldn't happen.
             Debug.trace(t);

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractString.java	Thu Nov  5 16:52:10 2009
@@ -128,6 +128,7 @@
 	    }
 	    return sb.toString();
 	} catch(ConditionThrowable t) {
+        // ### FIXME exception
 	    throw new Error(t); //Should never happen
 	}
     }

Modified: trunk/abcl/src/org/armedbear/lisp/Autoload.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Autoload.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Autoload.java	Thu Nov  5 16:52:10 2009
@@ -83,6 +83,7 @@
                 pkg.export(symbol);
             }
             catch (ConditionThrowable t) {
+                // ### FIXME exception
                 Debug.assertTrue(false);
             }
         }

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexString.java	Thu Nov  5 16:52:10 2009
@@ -532,6 +532,7 @@
           }
         catch (ConditionThrowable t)
           {
+            // ### FIXME exception
             Debug.trace(t);
           }
         hashCode += (hashCode << 10);
@@ -557,6 +558,7 @@
           }
         catch (ConditionThrowable t)
           {
+            // ### FIXME exception
             Debug.trace(t);
           }
         hashCode += (hashCode << 10);

Modified: trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java	Thu Nov  5 16:52:10 2009
@@ -61,6 +61,7 @@
             if (key == e.key || key.equal(e.key))
               return e.value;
           }
+        // ### FIXME exception
         catch (ConditionThrowable t)
           {
             Debug.trace(t);

Modified: trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java	Thu Nov  5 16:52:10 2009
@@ -59,6 +59,7 @@
             if (key.equalp(e.key))
               return e.value;
           }
+        // ### FIXME exception
         catch (ConditionThrowable t)
           {
             Debug.trace(t);

Modified: trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java	Thu Nov  5 16:52:10 2009
@@ -78,6 +78,7 @@
                     string.ensureCapacity(fp + limit);
                 }
                 catch (ConditionThrowable t) {
+                    // ### FIXME exception
                     // Shouldn't happen.
                     Debug.trace(t);
                 }
@@ -86,6 +87,7 @@
                         string.setCharAt(fp, cbuf[i]);
                     }
                     catch (ConditionThrowable t) {
+                        // ### FIXME exception
                         // Shouldn't happen.
                         Debug.trace(t);
                     }

Modified: trunk/abcl/src/org/armedbear/lisp/Interpreter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Interpreter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Interpreter.java	Thu Nov  5 16:52:10 2009
@@ -164,6 +164,7 @@
                 Load.loadSystemFile("boot.lisp", false, false, false);
             }
             catch (ConditionThrowable c) {
+                // ### FIXME exception
                 reportError(c, LispThread.currentThread());
             }
             catch (Throwable t) {
@@ -184,6 +185,7 @@
                 Load.loadSystemFile("j.lisp");
             }
             catch (ConditionThrowable c) {
+                // ### FIXME exception
                 reportError(c, LispThread.currentThread());
             }
             catch (Throwable t) {
@@ -276,6 +278,7 @@
                             evaluate(args[i + 1]);
                         }
                         catch (ConditionThrowable c) {
+                            // ### FIXME exception
                             final String separator =
                                 System.getProperty("line.separator");
                             FastStringBuffer sb = new FastStringBuffer();
@@ -311,6 +314,7 @@
                                 Load.loadSystemFile(args[i + 1]);
                         }
                         catch (ConditionThrowable c) {
+                            // ### FIXME exception
                             System.err.println("Caught condition: " +
                                                c.getCondition().writeToString() +
                                                " while loading: " +
@@ -384,6 +388,7 @@
                     out._writeLine("Stack overflow");
                 }
                 catch (ConditionThrowable c) {
+                    // ### FIXME exception
                     reportError(c, thread);
                 }
                 catch (Throwable t) {
@@ -490,6 +495,7 @@
                     thread.lastSpecialBinding = lastSpecialBinding;
                 }
             }
+            // ### FIXME conditionthrowable
             throw new ConditionThrowable(condition);
         }
     };

Modified: trunk/abcl/src/org/armedbear/lisp/JHandler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JHandler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JHandler.java	Thu Nov  5 16:52:10 2009
@@ -85,6 +85,7 @@
                     f.execute(args);
                 }
                 catch (ConditionThrowable t) {
+                    // ### FIXME exception
                     t.printStackTrace();
                 }
             }

Modified: trunk/abcl/src/org/armedbear/lisp/JProxy.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JProxy.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JProxy.java	Thu Nov  5 16:52:10 2009
@@ -106,6 +106,7 @@
                                                LispThread.currentThread());
                   return (method.getReturnType() == void.class ? null : result.javaInstance());
                 }
+              // ### FIXME exception
               catch (ConditionThrowable t)
                 {
                   t.printStackTrace();

Modified: trunk/abcl/src/org/armedbear/lisp/Java.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Java.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Java.java	Thu Nov  5 16:52:10 2009
@@ -763,6 +763,7 @@
 			} catch (Exception e) {
 				ConditionThrowable t = new ConditionThrowable("Exception reading property");
 				t.initCause(e);
+                // ### FIXME conditionthrowable -> error()
 				throw t;
 			}
         }
@@ -793,6 +794,7 @@
 		pd.getWriteMethod().invoke(obj, jValue);
 		return value;
 	    } catch (Exception e) {
+            // ### FIXME conditionthrowable -> error()
 		ConditionThrowable t = new ConditionThrowable("Exception writing property " + propertyName.writeToString() + " in object " + obj + " to " + value.writeToString());
 		t.initCause(e);
 		throw t;
@@ -808,6 +810,7 @@
         		return pd;
         	}
         }
+        // ### FIXME conditionthrowable -> error()
 		throw new ConditionThrowable("Property " + prop + " not found in " + obj);
     }
     

Modified: trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java	Thu Nov  5 16:52:10 2009
@@ -59,6 +59,7 @@
       result = unreadableString(JAVA_STACK_FRAME + " " 
 				+ toLispString().toString()); 
     } catch (ConditionThrowable t) {
+        // ### FIXME exception
       Debug.trace("Implementation error: ");
       Debug.trace(t);
       result = unreadableString(JAVA_STACK_FRAME);

Modified: trunk/abcl/src/org/armedbear/lisp/LispThread.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispThread.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispThread.java	Thu Nov  5 16:52:10 2009
@@ -111,6 +111,7 @@
             if (name != NIL)
                 javaThread.setName(name.getStringValue());
         } catch (ConditionThrowable ex) {
+            // ### FIXME exception
             Debug.trace("Failed to set thread name:");
 	    Debug.trace(ex);
         }
@@ -794,6 +795,7 @@
                 stream.print(')');
             }
             catch (ConditionThrowable t) {
+                // ### FIXME exception
                 Debug.trace(t);
             }
         } else {
@@ -1063,6 +1065,7 @@
             PACKAGE_EXT.export(Symbol.intern("INTERRUPT-THREAD", PACKAGE_THREADS));
             PACKAGE_EXT.export(Symbol.intern("CURRENT-THREAD", PACKAGE_THREADS));
         }
+        // ### FIXME exception
         catch (ConditionThrowable ct) { }
     }
 

Modified: trunk/abcl/src/org/armedbear/lisp/Pathname.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Pathname.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Pathname.java	Thu Nov  5 16:52:10 2009
@@ -571,6 +571,7 @@
             return sb.toString();
         }
         catch (ConditionThrowable t) {
+            // ### FIXME exception
             return unreadableString("PATHNAME");
         }
     }

Modified: trunk/abcl/src/org/armedbear/lisp/Profiler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Profiler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Profiler.java	Thu Nov  5 16:52:10 2009
@@ -93,6 +93,7 @@
                                     thread.incrementCallCounts();
                                     Thread.sleep(sleep);
                                 }
+                                //### FIXME exception
                                 catch (InterruptedException e) {
                                     Debug.trace(e);
                                 }

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java	Thu Nov  5 16:52:10 2009
@@ -65,6 +65,7 @@
             setLambdaList(new SimpleString(arglist));
         }
         catch (ConditionThrowable t) {
+            // ### FIXME exception
             Debug.assertTrue(false);
         }
     }

Modified: trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java	Thu Nov  5 16:52:10 2009
@@ -88,6 +88,7 @@
       }
     catch (ConditionThrowable t)
       {
+        // ### FIXME exception
         Debug.assertTrue(false);
       }
   }

Modified: trunk/abcl/src/org/armedbear/lisp/Stream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Stream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Stream.java	Thu Nov  5 16:52:10 2009
@@ -326,6 +326,7 @@
       if (encIsCp)
           encoding = "Cp" + encoding;
     }
+    // ### FIXME exception
     catch (ConditionThrowable ct) { }
     
     eolChar = (eolStyle == EolStyle.CR) ? '\r' : '\n';

Modified: trunk/abcl/src/org/armedbear/lisp/Symbol.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Symbol.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Symbol.java	Thu Nov  5 16:52:10 2009
@@ -50,6 +50,7 @@
       }
     catch (ConditionThrowable t)
       {
+        // ### FIXME exception
         Debug.trace(t); // Shouldn't happen.
         return null;
       }



From ehuelsmann at common-lisp.net  Thu Nov  5 22:45:54 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Thu, 05 Nov 2009 17:45:54 -0500
Subject: [armedbear-cvs] r12253 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N6B5W-0005ye-7H@common-lisp.net>

Author: ehuelsmann
Date: Thu Nov  5 17:45:52 2009
New Revision: 12253

Log:
Make ConditionThrowable abstract: it's the parent of
  non-local ControlTransfer "events", but has no meaning by itself.

Modified:
   trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java
   trunk/abcl/src/org/armedbear/lisp/Interpreter.java
   trunk/abcl/src/org/armedbear/lisp/Java.java
   trunk/abcl/src/org/armedbear/lisp/Primitives.java
   trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java

Modified: trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java	Thu Nov  5 17:45:52 2009
@@ -33,10 +33,8 @@
 
 package org.armedbear.lisp;
 
-public class ConditionThrowable extends Throwable
+abstract public class ConditionThrowable extends RuntimeException
 {
-    public Condition condition;
-
     public ConditionThrowable()
     {
     }
@@ -50,18 +48,10 @@
 	return this;
     }
 
-    public ConditionThrowable(Condition condition)
-    {
-        this.condition = condition;
-    }
-
     public ConditionThrowable(String message)
     {
         super(message);
     }
 
-    public LispObject getCondition() throws ConditionThrowable
-    {
-        return condition != null ? condition : new Condition();
-    }
+    public abstract LispObject getCondition() throws ConditionThrowable;
 }

Modified: trunk/abcl/src/org/armedbear/lisp/Interpreter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Interpreter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Interpreter.java	Thu Nov  5 17:45:52 2009
@@ -457,12 +457,25 @@
         System.err.println("Interpreter.finalize");
     }
 
+    public static final class UnhandledCondition extends Error
+    {
+        LispObject condition;
+
+        UnhandledCondition(LispObject condition) {
+            this.condition = condition;
+        }
+
+        public LispObject getCondition() {
+            return condition;
+        }
+    };
+
     private static final Primitive _DEBUGGER_HOOK_FUNCTION =
         new Primitive("%debugger-hook-function", PACKAGE_SYS, false)
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+            throws ConditionThrowable, UnhandledCondition
         {
             final Condition condition = (Condition) first;
             if (interpreter == null) {
@@ -495,8 +508,7 @@
                     thread.lastSpecialBinding = lastSpecialBinding;
                 }
             }
-            // ### FIXME conditionthrowable
-            throw new ConditionThrowable(condition);
+            throw new UnhandledCondition(condition);
         }
     };
 
@@ -512,6 +524,14 @@
     }
 
     // For j.
+    /** Runs its input string through the lisp reader and evaluates the result.
+     *
+     * @param s A string with a valid Common Lisp expression
+     * @return The result of the evaluation
+     * @throws org.armedbear.lisp.ConditionThrowable
+     * @exception UnhandledCondition in case the an error occurs which
+     *      should be passed to the Lisp debugger
+     */
     public static LispObject evaluate(String s) throws ConditionThrowable
     {
         if (!initialized)

Modified: trunk/abcl/src/org/armedbear/lisp/Java.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Java.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Java.java	Thu Nov  5 17:45:52 2009
@@ -761,10 +761,7 @@
 				    return NIL;
 				}
 			} catch (Exception e) {
-				ConditionThrowable t = new ConditionThrowable("Exception reading property");
-				t.initCause(e);
-                // ### FIXME conditionthrowable -> error()
-				throw t;
+                return error(new JavaException(e));
 			}
         }
     };
@@ -794,10 +791,7 @@
 		pd.getWriteMethod().invoke(obj, jValue);
 		return value;
 	    } catch (Exception e) {
-            // ### FIXME conditionthrowable -> error()
-		ConditionThrowable t = new ConditionThrowable("Exception writing property " + propertyName.writeToString() + " in object " + obj + " to " + value.writeToString());
-		t.initCause(e);
-		throw t;
+            return error(new JavaException(e));
 	    }
         }
     };
@@ -810,8 +804,9 @@
         		return pd;
         	}
         }
-        // ### FIXME conditionthrowable -> error()
-		throw new ConditionThrowable("Property " + prop + " not found in " + obj);
+        error(new LispError("Property " + prop + " not found in " + obj));
+
+        return null; // not reached
     }
     
     private static Class classForName(String className) throws ConditionThrowable

Modified: trunk/abcl/src/org/armedbear/lisp/Primitives.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Primitives.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Primitives.java	Thu Nov  5 17:45:52 2009
@@ -1490,6 +1490,12 @@
     };
 
   // ### signal
+  /** Placeholder function, to be replaced by the function
+   * defined in signal.lisp
+   *
+   * Calling this function is an error: we're not set up for
+   * signalling yet.
+   */
   private static final Primitive SIGNAL =
     new Primitive(Symbol.SIGNAL, "datum &rest arguments")
     {
@@ -1497,10 +1503,10 @@
       public LispObject execute(LispObject[] args) throws ConditionThrowable
       {
         if (args.length < 1)
-          throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
+          return error(new WrongNumberOfArgumentsException(this));
         if (args[0] instanceof Condition)
-          throw new ConditionThrowable((Condition)args[0]);
-        throw new ConditionThrowable(new SimpleCondition());
+          return error((Condition)args[0]);
+        return error(new SimpleCondition());
       }
     };
 

Modified: trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java	Thu Nov  5 17:45:52 2009
@@ -43,4 +43,10 @@
     {
         super(message);
     }
+
+    @Override
+    public LispObject getCondition() throws ConditionThrowable
+    {
+        return new ControlError("Thread destroyed.");
+    }
 }



From ehuelsmann at common-lisp.net  Fri Nov  6 20:07:59 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Fri, 06 Nov 2009 15:07:59 -0500
Subject: [armedbear-cvs] r12254 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N6V6F-0008SO-3P@common-lisp.net>

Author: ehuelsmann
Date: Fri Nov  6 15:07:54 2009
New Revision: 12254

Log:
Remove 'throws ConditionThrowable' method annotations:
  it's an unchecked exception now, so no need to declare it thrown.

Modified:
   trunk/abcl/src/org/armedbear/lisp/AbstractArray.java
   trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
   trunk/abcl/src/org/armedbear/lisp/AbstractString.java
   trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
   trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java
   trunk/abcl/src/org/armedbear/lisp/Autoload.java
   trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java
   trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java
   trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java
   trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java
   trunk/abcl/src/org/armedbear/lisp/Bignum.java
   trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java
   trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java
   trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/CapitalizeFirstStream.java
   trunk/abcl/src/org/armedbear/lisp/CapitalizeStream.java
   trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java
   trunk/abcl/src/org/armedbear/lisp/CellError.java
   trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Closure.java
   trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java
   trunk/abcl/src/org/armedbear/lisp/CompilerError.java
   trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java
   trunk/abcl/src/org/armedbear/lisp/Complex.java
   trunk/abcl/src/org/armedbear/lisp/ComplexArray.java
   trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java
   trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java
   trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java
   trunk/abcl/src/org/armedbear/lisp/ComplexString.java
   trunk/abcl/src/org/armedbear/lisp/ComplexVector.java
   trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java
   trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java
   trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java
   trunk/abcl/src/org/armedbear/lisp/Condition.java
   trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java
   trunk/abcl/src/org/armedbear/lisp/Cons.java
   trunk/abcl/src/org/armedbear/lisp/ControlError.java
   trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java
   trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java
   trunk/abcl/src/org/armedbear/lisp/Do.java
   trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java
   trunk/abcl/src/org/armedbear/lisp/DowncaseStream.java
   trunk/abcl/src/org/armedbear/lisp/EchoStream.java
   trunk/abcl/src/org/armedbear/lisp/EndOfFile.java
   trunk/abcl/src/org/armedbear/lisp/Environment.java
   trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java
   trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java
   trunk/abcl/src/org/armedbear/lisp/Extensions.java
   trunk/abcl/src/org/armedbear/lisp/FaslReader.java
   trunk/abcl/src/org/armedbear/lisp/FileError.java
   trunk/abcl/src/org/armedbear/lisp/FileStream.java
   trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/Fixnum.java
   trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java
   trunk/abcl/src/org/armedbear/lisp/FloatingPointInexact.java
   trunk/abcl/src/org/armedbear/lisp/FloatingPointInvalidOperation.java
   trunk/abcl/src/org/armedbear/lisp/FloatingPointOverflow.java
   trunk/abcl/src/org/armedbear/lisp/FloatingPointUnderflow.java
   trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java
   trunk/abcl/src/org/armedbear/lisp/Function.java
   trunk/abcl/src/org/armedbear/lisp/GenericFunction.java
   trunk/abcl/src/org/armedbear/lisp/Go.java
   trunk/abcl/src/org/armedbear/lisp/HashTable.java
   trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java
   trunk/abcl/src/org/armedbear/lisp/IllegalMonitorState.java
   trunk/abcl/src/org/armedbear/lisp/Interpreter.java
   trunk/abcl/src/org/armedbear/lisp/JHandler.java
   trunk/abcl/src/org/armedbear/lisp/JProxy.java
   trunk/abcl/src/org/armedbear/lisp/Java.java
   trunk/abcl/src/org/armedbear/lisp/JavaClass.java
   trunk/abcl/src/org/armedbear/lisp/JavaException.java
   trunk/abcl/src/org/armedbear/lisp/JavaObject.java
   trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java
   trunk/abcl/src/org/armedbear/lisp/Layout.java
   trunk/abcl/src/org/armedbear/lisp/Lisp.java
   trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
   trunk/abcl/src/org/armedbear/lisp/LispClass.java
   trunk/abcl/src/org/armedbear/lisp/LispError.java
   trunk/abcl/src/org/armedbear/lisp/LispObject.java
   trunk/abcl/src/org/armedbear/lisp/LispReader.java
   trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java
   trunk/abcl/src/org/armedbear/lisp/LispThread.java
   trunk/abcl/src/org/armedbear/lisp/Load.java
   trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java
   trunk/abcl/src/org/armedbear/lisp/MacroObject.java
   trunk/abcl/src/org/armedbear/lisp/MathFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Nil.java
   trunk/abcl/src/org/armedbear/lisp/NilVector.java
   trunk/abcl/src/org/armedbear/lisp/Operator.java
   trunk/abcl/src/org/armedbear/lisp/Package.java
   trunk/abcl/src/org/armedbear/lisp/PackageError.java
   trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Packages.java
   trunk/abcl/src/org/armedbear/lisp/ParseError.java
   trunk/abcl/src/org/armedbear/lisp/Pathname.java
   trunk/abcl/src/org/armedbear/lisp/Primitive.java
   trunk/abcl/src/org/armedbear/lisp/Primitives.java
   trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java
   trunk/abcl/src/org/armedbear/lisp/Profiler.java
   trunk/abcl/src/org/armedbear/lisp/ProgramError.java
   trunk/abcl/src/org/armedbear/lisp/RandomState.java
   trunk/abcl/src/org/armedbear/lisp/Ratio.java
   trunk/abcl/src/org/armedbear/lisp/ReaderError.java
   trunk/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java
   trunk/abcl/src/org/armedbear/lisp/Readtable.java
   trunk/abcl/src/org/armedbear/lisp/Return.java
   trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java
   trunk/abcl/src/org/armedbear/lisp/SeriousCondition.java
   trunk/abcl/src/org/armedbear/lisp/ShellCommand.java
   trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java
   trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java
   trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java
   trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java
   trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java
   trunk/abcl/src/org/armedbear/lisp/SimpleCondition.java
   trunk/abcl/src/org/armedbear/lisp/SimpleError.java
   trunk/abcl/src/org/armedbear/lisp/SimpleString.java
   trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java
   trunk/abcl/src/org/armedbear/lisp/SimpleVector.java
   trunk/abcl/src/org/armedbear/lisp/SimpleWarning.java
   trunk/abcl/src/org/armedbear/lisp/SingleFloat.java
   trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java
   trunk/abcl/src/org/armedbear/lisp/SlimeOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/SlotClass.java
   trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java
   trunk/abcl/src/org/armedbear/lisp/SocketStream.java
   trunk/abcl/src/org/armedbear/lisp/SpecialBinding.java
   trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java
   trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
   trunk/abcl/src/org/armedbear/lisp/StackFrame.java
   trunk/abcl/src/org/armedbear/lisp/StandardClass.java
   trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
   trunk/abcl/src/org/armedbear/lisp/StandardMethod.java
   trunk/abcl/src/org/armedbear/lisp/StandardObject.java
   trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java
   trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java
   trunk/abcl/src/org/armedbear/lisp/StorageCondition.java
   trunk/abcl/src/org/armedbear/lisp/Stream.java
   trunk/abcl/src/org/armedbear/lisp/StreamError.java
   trunk/abcl/src/org/armedbear/lisp/StringFunctions.java
   trunk/abcl/src/org/armedbear/lisp/StringInputStream.java
   trunk/abcl/src/org/armedbear/lisp/StringOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/StructureClass.java
   trunk/abcl/src/org/armedbear/lisp/StructureObject.java
   trunk/abcl/src/org/armedbear/lisp/StyleWarning.java
   trunk/abcl/src/org/armedbear/lisp/Symbol.java
   trunk/abcl/src/org/armedbear/lisp/SynonymStream.java
   trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java
   trunk/abcl/src/org/armedbear/lisp/Throw.java
   trunk/abcl/src/org/armedbear/lisp/Time.java
   trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java
   trunk/abcl/src/org/armedbear/lisp/TypeError.java
   trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java
   trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java
   trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java
   trunk/abcl/src/org/armedbear/lisp/UpcaseStream.java
   trunk/abcl/src/org/armedbear/lisp/Utilities.java
   trunk/abcl/src/org/armedbear/lisp/Warning.java
   trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java
   trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java
   trunk/abcl/src/org/armedbear/lisp/adjust_array.java
   trunk/abcl/src/org/armedbear/lisp/arglist.java
   trunk/abcl/src/org/armedbear/lisp/ash.java
   trunk/abcl/src/org/armedbear/lisp/assq.java
   trunk/abcl/src/org/armedbear/lisp/assql.java
   trunk/abcl/src/org/armedbear/lisp/ceiling.java
   trunk/abcl/src/org/armedbear/lisp/cell_error_name.java
   trunk/abcl/src/org/armedbear/lisp/copy_list.java
   trunk/abcl/src/org/armedbear/lisp/create_new_file.java
   trunk/abcl/src/org/armedbear/lisp/cxr.java
   trunk/abcl/src/org/armedbear/lisp/delete_file.java
   trunk/abcl/src/org/armedbear/lisp/disassemble_class_bytes.java
   trunk/abcl/src/org/armedbear/lisp/dolist.java
   trunk/abcl/src/org/armedbear/lisp/dotimes.java
   trunk/abcl/src/org/armedbear/lisp/file_author.java
   trunk/abcl/src/org/armedbear/lisp/file_error_pathname.java
   trunk/abcl/src/org/armedbear/lisp/file_length.java
   trunk/abcl/src/org/armedbear/lisp/file_string_length.java
   trunk/abcl/src/org/armedbear/lisp/file_write_date.java
   trunk/abcl/src/org/armedbear/lisp/float_sign.java
   trunk/abcl/src/org/armedbear/lisp/floor.java
   trunk/abcl/src/org/armedbear/lisp/ftruncate.java
   trunk/abcl/src/org/armedbear/lisp/function_info.java
   trunk/abcl/src/org/armedbear/lisp/get_properties.java
   trunk/abcl/src/org/armedbear/lisp/input_stream_p.java
   trunk/abcl/src/org/armedbear/lisp/interactive_stream_p.java
   trunk/abcl/src/org/armedbear/lisp/jclass_name.java
   trunk/abcl/src/org/armedbear/lisp/jclass_of.java
   trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java
   trunk/abcl/src/org/armedbear/lisp/last.java
   trunk/abcl/src/org/armedbear/lisp/listen.java
   trunk/abcl/src/org/armedbear/lisp/logand.java
   trunk/abcl/src/org/armedbear/lisp/logandc1.java
   trunk/abcl/src/org/armedbear/lisp/logandc2.java
   trunk/abcl/src/org/armedbear/lisp/logbitp.java
   trunk/abcl/src/org/armedbear/lisp/logcount.java
   trunk/abcl/src/org/armedbear/lisp/logeqv.java
   trunk/abcl/src/org/armedbear/lisp/logior.java
   trunk/abcl/src/org/armedbear/lisp/lognand.java
   trunk/abcl/src/org/armedbear/lisp/lognor.java
   trunk/abcl/src/org/armedbear/lisp/lognot.java
   trunk/abcl/src/org/armedbear/lisp/logorc1.java
   trunk/abcl/src/org/armedbear/lisp/logorc2.java
   trunk/abcl/src/org/armedbear/lisp/logtest.java
   trunk/abcl/src/org/armedbear/lisp/logxor.java
   trunk/abcl/src/org/armedbear/lisp/machine_type.java
   trunk/abcl/src/org/armedbear/lisp/machine_version.java
   trunk/abcl/src/org/armedbear/lisp/make_array.java
   trunk/abcl/src/org/armedbear/lisp/make_condition.java
   trunk/abcl/src/org/armedbear/lisp/make_server_socket.java
   trunk/abcl/src/org/armedbear/lisp/make_socket.java
   trunk/abcl/src/org/armedbear/lisp/mod.java
   trunk/abcl/src/org/armedbear/lisp/open_stream_p.java
   trunk/abcl/src/org/armedbear/lisp/output_stream_p.java
   trunk/abcl/src/org/armedbear/lisp/package_error_package.java
   trunk/abcl/src/org/armedbear/lisp/peek_char.java
   trunk/abcl/src/org/armedbear/lisp/probe_file.java
   trunk/abcl/src/org/armedbear/lisp/rem.java
   trunk/abcl/src/org/armedbear/lisp/room.java
   trunk/abcl/src/org/armedbear/lisp/server_socket_close.java
   trunk/abcl/src/org/armedbear/lisp/simple_list_remove_duplicates.java
   trunk/abcl/src/org/armedbear/lisp/socket_accept.java
   trunk/abcl/src/org/armedbear/lisp/socket_close.java
   trunk/abcl/src/org/armedbear/lisp/socket_stream.java
   trunk/abcl/src/org/armedbear/lisp/software_type.java
   trunk/abcl/src/org/armedbear/lisp/software_version.java
   trunk/abcl/src/org/armedbear/lisp/stream_element_type.java
   trunk/abcl/src/org/armedbear/lisp/stream_external_format.java
   trunk/abcl/src/org/armedbear/lisp/truncate.java
   trunk/abcl/src/org/armedbear/lisp/unbound_slot_instance.java
   trunk/abcl/src/org/armedbear/lisp/zip.java

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractArray.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractArray.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractArray.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public abstract class AbstractArray extends LispObject
 {
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.ARRAY)
             return T;
@@ -46,7 +46,7 @@
     }
 
     @Override
-    public boolean equalp(LispObject obj) throws ConditionThrowable
+    public boolean equalp(LispObject obj)
     {
         if (obj instanceof AbstractArray) {
             AbstractArray a = (AbstractArray) obj;
@@ -70,7 +70,7 @@
         return false;
     }
 
-    public LispObject arrayDisplacement() throws ConditionThrowable
+    public LispObject arrayDisplacement()
     {
         return LispThread.currentThread().setValues(NIL, Fixnum.ZERO);
     }
@@ -80,18 +80,18 @@
         return false;
     }
 
-    public int getFillPointer() throws ConditionThrowable
+    public int getFillPointer()
     {
         noFillPointer();
         return -1; // Not reached.
     }
 
-    public void setFillPointer(LispObject fillPointer) throws ConditionThrowable
+    public void setFillPointer(LispObject fillPointer)
     {
         setFillPointer(fillPointer.intValue());
     }
 
-    public void setFillPointer(int fillPointer) throws ConditionThrowable
+    public void setFillPointer(int fillPointer)
     {
         noFillPointer();
     }
@@ -105,7 +105,7 @@
 
     public abstract LispObject getDimensions();
 
-    public abstract int getDimension(int n) throws ConditionThrowable;
+    public abstract int getDimension(int n);
 
     public abstract LispObject getElementType();
 
@@ -113,7 +113,7 @@
 
     @Override
     public abstract void aset(int index, LispObject newValue)
-        throws ConditionThrowable;
+       ;
 
     // FIXME Detect overflow!
     protected static final int computeTotalSize(int[] dimensions)
@@ -125,7 +125,7 @@
     }
 
     public int getRowMajorIndex(LispObject[] subscripts)
-        throws ConditionThrowable
+
     {
         int[] subs = new int[subscripts.length];
         for (int i = 0; i < subscripts.length; i++) {
@@ -138,7 +138,7 @@
         return getRowMajorIndex(subs);
     }
 
-    public int getRowMajorIndex(int[] subscripts) throws ConditionThrowable
+    public int getRowMajorIndex(int[] subscripts)
     {
         final int rank = getRank();
         if (rank != subscripts.length) {
@@ -165,20 +165,20 @@
         return sum;
     }
 
-    public LispObject get(int[] subscripts) throws ConditionThrowable
+    public LispObject get(int[] subscripts)
     {
         return AREF(getRowMajorIndex(subscripts));
     }
 
     public void set(int[] subscripts, LispObject newValue)
-        throws ConditionThrowable
+
     {
         aset(getRowMajorIndex(subscripts), newValue);
     }
 
-    public abstract void fill(LispObject obj) throws ConditionThrowable;
+    public abstract void fill(LispObject obj);
 
-    public String writeToString(int[] dimv) throws ConditionThrowable
+    public String writeToString(int[] dimv)
     {
         StringBuilder sb = new StringBuilder();
         LispThread thread = LispThread.currentThread();
@@ -229,7 +229,7 @@
     // Helper for writeToString().
     private void appendContents(int[] dimensions, int index, StringBuilder sb,
                                 LispThread thread)
-        throws ConditionThrowable
+
     {
         if (dimensions.length == 0) {
             if (Symbol.PRINT_CIRCLE.symbolValue(thread) != NIL) {
@@ -318,12 +318,10 @@
      * @param initialElement @c null if none
      * @param initialContents @c null if none
      * @return @c this or a new array
-     * @throws org.armedbear.lisp.ConditionThrowable
      */
     public abstract AbstractArray adjustArray(int[] dims,
                                               LispObject initialElement,
-                                              LispObject initialContents)
-        throws ConditionThrowable;
+                                              LispObject initialContents);
 
     /**
      *
@@ -331,10 +329,8 @@
      * @param displacedTo
      * @param displacement
      * @return
-     * @throws org.armedbear.lisp.ConditionThrowable
      */
     public abstract AbstractArray adjustArray(int[] dims,
                                               AbstractArray displacedTo,
-                                              int displacement)
-        throws ConditionThrowable;
+                                              int displacement);
 }

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
     protected long[] bits;
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.BIT_VECTOR)
             return T;
@@ -71,7 +71,7 @@
     }
 
     @Override
-    public boolean equal(LispObject obj) throws ConditionThrowable
+    public boolean equal(LispObject obj)
     {
         if (this == obj)
             return true;
@@ -89,7 +89,7 @@
     }
 
     @Override
-    public boolean equalp(LispObject obj) throws ConditionThrowable
+    public boolean equalp(LispObject obj)
     {
         if (this == obj)
             return true;
@@ -111,7 +111,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             switch (((Fixnum)obj).value) {
@@ -140,7 +140,7 @@
     }
 
     @Override
-    public LispObject subseq(int start, int end) throws ConditionThrowable
+    public LispObject subseq(int start, int end)
     {
         SimpleBitVector v = new SimpleBitVector(end - start);
         int i = start, j = 0;
@@ -177,7 +177,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         final LispThread thread = LispThread.currentThread();
         final int length = length();
@@ -198,13 +198,13 @@
 
     // Ignores fill pointer.
     @Override
-    public LispObject AREF(LispObject index) throws ConditionThrowable
+    public LispObject AREF(LispObject index)
     {
         return AREF(Fixnum.getValue(index));
     }
 
     @Override
-    public LispObject reverse() throws ConditionThrowable
+    public LispObject reverse()
     {
         int length = length();
         SimpleBitVector result = new SimpleBitVector(length);
@@ -218,9 +218,9 @@
         return result;
     }
 
-    protected abstract int getBit(int index) throws ConditionThrowable;
+    protected abstract int getBit(int index);
 
-    protected abstract void setBit(int index) throws ConditionThrowable;
+    protected abstract void setBit(int index);
 
-    protected abstract void clearBit(int index) throws ConditionThrowable;
+    protected abstract void clearBit(int index);
 }

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractString.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public abstract class AbstractString extends AbstractVector
 {
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type instanceof Symbol) {
             if (type == Symbol.STRING)
@@ -81,14 +81,14 @@
         return this;
     }
 
-    public abstract void fill(char c) throws ConditionThrowable;
+    public abstract void fill(char c);
 
-    public abstract char charAt(int index) throws ConditionThrowable;
+    public abstract char charAt(int index);
 
-    public abstract void setCharAt(int index, char c) throws ConditionThrowable;
+    public abstract void setCharAt(int index, char c);
 
     public final String writeToString(int beginIndex, int endIndex)
-        throws ConditionThrowable
+
     {
         if (beginIndex < 0)
             beginIndex = 0;
@@ -114,7 +114,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         return writeToString(0, length());
     }

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractVector.java	Fri Nov  6 15:07:54 2009
@@ -35,7 +35,7 @@
 public abstract class AbstractVector extends AbstractArray
 {
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.VECTOR)
       return T;
@@ -61,7 +61,7 @@
   }
 
   @Override
-  public boolean equalp(LispObject obj) throws ConditionThrowable
+  public boolean equalp(LispObject obj)
   {
     if (obj instanceof AbstractVector)
       {
@@ -89,7 +89,7 @@
   }
 
   @Override
-  public final int getDimension(int n) throws ConditionThrowable
+  public final int getDimension(int n)
   {
     if (n != 0)
       {
@@ -108,9 +108,9 @@
 
   public abstract int capacity();
 
-  public abstract LispObject subseq(int start, int end) throws ConditionThrowable;
+  public abstract LispObject subseq(int start, int end);
 
-  public LispObject deleteEq(LispObject item) throws ConditionThrowable
+  public LispObject deleteEq(LispObject item)
   {
     final int limit = length();
     int i = 0;
@@ -127,7 +127,7 @@
     return this;
   }
 
-  public LispObject deleteEql(LispObject item) throws ConditionThrowable
+  public LispObject deleteEql(LispObject item)
   {
     final int limit = length();
     int i = 0;
@@ -144,16 +144,16 @@
     return this;
   }
 
-  public abstract void shrink(int n) throws ConditionThrowable;
+  public abstract void shrink(int n);
 
-  public int checkIndex(int index) throws ConditionThrowable
+  public int checkIndex(int index)
   {
     if (index < 0 || index >= capacity())
       badIndex(index, capacity());
     return index;
   }
 
-  protected void badIndex(int index, int limit) throws ConditionThrowable
+  protected void badIndex(int index, int limit)
   {
     FastStringBuffer sb = new FastStringBuffer("Invalid array index ");
     sb.append(index);
@@ -173,12 +173,12 @@
 
   }
 
-  public void setFillPointer(int n) throws ConditionThrowable
+  public void setFillPointer(int n)
   {
     noFillPointer();
   }
 
-  public void setFillPointer(LispObject obj) throws ConditionThrowable
+  public void setFillPointer(LispObject obj)
   {
     noFillPointer();
   }
@@ -189,10 +189,10 @@
   }
 
   @Override
-  public abstract LispObject reverse() throws ConditionThrowable;
+  public abstract LispObject reverse();
 
   @Override
-  public LispObject nreverse() throws ConditionThrowable
+  public LispObject nreverse()
   {
     int i = 0;
     int j = length() - 1;
@@ -208,7 +208,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     final LispThread thread = LispThread.currentThread();
     if (Symbol.PRINT_READABLY.symbolValue(thread) != NIL)
@@ -300,24 +300,24 @@
   public abstract AbstractArray adjustArray(int size,
                                               LispObject initialElement,
                                               LispObject initialContents)
-    throws ConditionThrowable;
+   ;
   public abstract AbstractArray adjustArray(int size,
                                               AbstractArray displacedTo,
                                               int displacement)
-    throws ConditionThrowable;
+   ;
 
 
   public AbstractArray adjustArray(int[] dims,
                                               LispObject initialElement,
                                               LispObject initialContents)
-    throws ConditionThrowable {
+    {
       return adjustArray(dims[0], initialElement, initialContents);
   }
 
   public AbstractArray adjustArray(int[] dims,
                                               AbstractArray displacedTo,
                                               int displacement)
-    throws ConditionThrowable {
+    {
       return adjustArray(dims[0], displacedTo, displacement);
   }
 }

Modified: trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java	Fri Nov  6 15:07:54 2009
@@ -35,19 +35,19 @@
 
 public class ArithmeticError extends LispError
 {
-    protected ArithmeticError(LispClass cls) throws ConditionThrowable
+    protected ArithmeticError(LispClass cls)
     {
         super(cls);
     }
 
-    public ArithmeticError(LispObject initArgs) throws ConditionThrowable
+    public ArithmeticError(LispObject initArgs)
     {
         super(StandardClass.ARITHMETIC_ERROR);
         initialize(initArgs);
     }
 
     @Override
-    protected void initialize(LispObject initArgs) throws ConditionThrowable
+    protected void initialize(LispObject initArgs)
     {
         super.initialize(initArgs);
         LispObject operation = NIL;
@@ -67,7 +67,7 @@
         setOperands(operands);
     }
 
-    public ArithmeticError(String message) throws ConditionThrowable
+    public ArithmeticError(String message)
     {
         super(StandardClass.ARITHMETIC_ERROR);
         setFormatControl(message);
@@ -89,7 +89,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.ARITHMETIC_ERROR)
             return T;
@@ -98,24 +98,24 @@
         return super.typep(type);
     }
 
-    private final LispObject getOperation() throws ConditionThrowable
+    private final LispObject getOperation()
     {
         return getInstanceSlotValue(Symbol.OPERATION);
     }
 
     private final void setOperation(LispObject operation)
-        throws ConditionThrowable
+
     {
         setInstanceSlotValue(Symbol.OPERATION, operation);
     }
 
-    private final LispObject getOperands() throws ConditionThrowable
+    private final LispObject getOperands()
     {
         return getInstanceSlotValue(Symbol.OPERANDS);
     }
 
     private final void setOperands(LispObject operands)
-        throws ConditionThrowable
+
     {
         setInstanceSlotValue(Symbol.OPERANDS, operands);
     }
@@ -125,7 +125,7 @@
         new Primitive("arithmetic-error-operation", "condition")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof ArithmeticError) {
                 return ((ArithmeticError)arg).getOperation();
@@ -140,7 +140,7 @@
         new Primitive("arithmetic-error-operands", "condition")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof ArithmeticError) {
                 return ((ArithmeticError)arg).getOperands();

Modified: trunk/abcl/src/org/armedbear/lisp/Autoload.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Autoload.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Autoload.java	Fri Nov  6 15:07:54 2009
@@ -99,7 +99,7 @@
                                                   "org.armedbear.lisp.".concat(className)));
     }
 
-    public void load() throws ConditionThrowable
+    public void load()
     {
         if (className != null) {
             final LispThread thread = LispThread.currentThread();
@@ -156,14 +156,14 @@
     }
 
     @Override
-    public LispObject execute() throws ConditionThrowable
+    public LispObject execute()
     {
         load();
         return symbol.execute();
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         load();
         return symbol.execute(arg);
@@ -171,7 +171,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         load();
         return symbol.execute(first, second);
@@ -180,7 +180,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third)
-        throws ConditionThrowable
+
     {
         load();
         return symbol.execute(first, second, third);
@@ -189,7 +189,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
     {
         load();
         return symbol.execute(first, second, third, fourth);
@@ -199,7 +199,7 @@
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth,
                               LispObject fifth)
-        throws ConditionThrowable
+
     {
         load();
         return symbol.execute(first, second, third, fourth, fifth);
@@ -209,7 +209,7 @@
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth)
-        throws ConditionThrowable
+
     {
         load();
         return symbol.execute(first, second, third, fourth, fifth, sixth);
@@ -220,7 +220,7 @@
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth,
                               LispObject seventh)
-        throws ConditionThrowable
+
     {
         load();
         return symbol.execute(first, second, third, fourth, fifth, sixth,
@@ -232,7 +232,7 @@
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth,
                               LispObject seventh, LispObject eighth)
-        throws ConditionThrowable
+
     {
         load();
         return symbol.execute(first, second, third, fourth, fifth, sixth,
@@ -240,14 +240,14 @@
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         load();
         return symbol.execute(args);
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         StringBuffer sb = new StringBuffer("#<AUTOLOAD ");
         sb.append(symbol.writeToString());
@@ -270,7 +270,7 @@
         new Primitive("autoload", PACKAGE_EXT, true)
     {
         @Override
-        public LispObject execute(LispObject first) throws ConditionThrowable
+        public LispObject execute(LispObject first)
         {
             if (first instanceof Symbol) {
                 Symbol symbol = (Symbol) first;
@@ -288,7 +288,7 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             final String fileName = second.getStringValue();
             if (first instanceof Symbol) {
@@ -313,7 +313,7 @@
         new Primitive("resolve", PACKAGE_EXT, true, "symbol")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             Symbol symbol = checkSymbol(arg);
             LispObject fun = symbol.getSymbolFunction();
@@ -331,7 +331,7 @@
         new Primitive("autoloadp", PACKAGE_EXT, true, "symbol")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof Symbol) {
                 if (arg.getSymbolFunction() instanceof Autoload)

Modified: trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java	Fri Nov  6 15:07:54 2009
@@ -46,7 +46,7 @@
     }
 
     private static void installAutoloadMacro(Symbol symbol, String fileName)
-        throws ConditionThrowable
+
     {
         AutoloadMacro am = new AutoloadMacro(symbol, fileName);
         if (symbol.getSymbolFunction() instanceof SpecialOperator)
@@ -56,13 +56,13 @@
     }
 
     @Override
-    public void load() throws ConditionThrowable
+    public void load()
     {
         Load.loadSystemFile(getFileName(), true);
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         StringBuffer sb = new StringBuffer("#<AUTOLOAD-MACRO ");
         sb.append(getSymbol().writeToString());
@@ -77,7 +77,7 @@
         new Primitive("autoload-macro", PACKAGE_EXT, true)
     {
         @Override
-        public LispObject execute(LispObject first) throws ConditionThrowable
+        public LispObject execute(LispObject first)
         {
             if (first instanceof Symbol) {
                 Symbol symbol = (Symbol) first;
@@ -95,7 +95,7 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             final String fileName = second.getStringValue();
             if (first instanceof Symbol) {

Modified: trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
     }
 
     private BasicVector_UnsignedByte16(LispObject[] array)
-        throws ConditionThrowable
+
     {
         capacity = array.length;
         elements = new int[capacity];
@@ -69,7 +69,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SIMPLE_ARRAY)
             return T;
@@ -115,7 +115,7 @@
     }
 
     @Override
-    public LispObject elt(int index) throws ConditionThrowable
+    public LispObject elt(int index)
     {
         try {
             return Fixnum.getInstance(elements[index]);
@@ -128,7 +128,7 @@
 
     // Ignores fill pointer.
     @Override
-    public int aref(int index) throws ConditionThrowable
+    public int aref(int index)
     {
         try {
             return elements[index];
@@ -142,7 +142,7 @@
 
     // Ignores fill pointer.
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         try {
             return Fixnum.getInstance(elements[index]);
@@ -155,7 +155,7 @@
 
     // Ignores fill pointer.
     @Override
-    public LispObject AREF(LispObject index) throws ConditionThrowable
+    public LispObject AREF(LispObject index)
     {
         try {
             return Fixnum.getInstance(elements[Fixnum.getValue(index)]);
@@ -167,7 +167,7 @@
     }
 
     @Override
-    public void aset(int index, int n) throws ConditionThrowable
+    public void aset(int index, int n)
     {
         try {
             elements[index] = n;
@@ -178,7 +178,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject obj) throws ConditionThrowable
+    public void aset(int index, LispObject obj)
     {
         if (obj instanceof Fixnum) {
                 try {
@@ -194,7 +194,7 @@
     }
 
     @Override
-    public LispObject subseq(int start, int end) throws ConditionThrowable
+    public LispObject subseq(int start, int end)
     {
         BasicVector_UnsignedByte16 v = new BasicVector_UnsignedByte16(end - start);
         int i = start, j = 0;
@@ -209,7 +209,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         int n = Fixnum.getValue(obj);
         for (int i = capacity; i-- > 0;)
@@ -217,7 +217,7 @@
     }
 
     @Override
-    public void shrink(int n) throws ConditionThrowable
+    public void shrink(int n)
     {
         if (n < capacity) {
             int[] newArray = new int[n];
@@ -232,7 +232,7 @@
     }
 
     @Override
-    public LispObject reverse() throws ConditionThrowable
+    public LispObject reverse()
     {
         BasicVector_UnsignedByte16 result = new BasicVector_UnsignedByte16(capacity);
         int i, j;
@@ -242,7 +242,7 @@
     }
 
     @Override
-    public LispObject nreverse() throws ConditionThrowable
+    public LispObject nreverse()
     {
         int i = 0;
         int j = capacity - 1;
@@ -260,7 +260,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        LispObject initialElement,
                                        LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null) {
             LispObject[] newElements = new LispObject[newCapacity];

Modified: trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java	Fri Nov  6 15:07:54 2009
@@ -48,7 +48,7 @@
   }
 
   public BasicVector_UnsignedByte32(LispObject[] array)
-    throws ConditionThrowable
+
   {
     capacity = array.length;
     elements = new long[capacity];
@@ -70,7 +70,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.SIMPLE_ARRAY)
       return T;
@@ -116,7 +116,7 @@
   }
 
   @Override
-  public LispObject elt(int index) throws ConditionThrowable
+  public LispObject elt(int index)
   {
     try
       {
@@ -130,7 +130,7 @@
   }
 
   @Override
-  public int aref(int index) throws ConditionThrowable
+  public int aref(int index)
   {
     try
       {
@@ -144,7 +144,7 @@
   }
 
   @Override
-  public long aref_long(int index) throws ConditionThrowable
+  public long aref_long(int index)
   {
     try
       {
@@ -158,7 +158,7 @@
   }
 
   @Override
-  public LispObject AREF(int index) throws ConditionThrowable
+  public LispObject AREF(int index)
   {
     try
       {
@@ -172,7 +172,7 @@
   }
 
   @Override
-  public LispObject AREF(LispObject index) throws ConditionThrowable
+  public LispObject AREF(LispObject index)
   {
         final int idx = Fixnum.getValue(index);
     try
@@ -187,7 +187,7 @@
   }
 
   @Override
-  public void aset(int index, LispObject newValue) throws ConditionThrowable
+  public void aset(int index, LispObject newValue)
   {
     try
       {
@@ -200,7 +200,7 @@
   }
 
   @Override
-  public LispObject subseq(int start, int end) throws ConditionThrowable
+  public LispObject subseq(int start, int end)
   {
     BasicVector_UnsignedByte32 v = new BasicVector_UnsignedByte32(end - start);
     int i = start, j = 0;
@@ -218,14 +218,14 @@
   }
 
   @Override
-  public void fill(LispObject obj) throws ConditionThrowable
+  public void fill(LispObject obj)
   {
     for (int i = capacity; i-- > 0;)
       elements[i] = obj.longValue();
   }
 
   @Override
-  public void shrink(int n) throws ConditionThrowable
+  public void shrink(int n)
   {
     if (n < capacity)
       {
@@ -241,7 +241,7 @@
   }
 
   @Override
-  public LispObject reverse() throws ConditionThrowable
+  public LispObject reverse()
   {
     BasicVector_UnsignedByte32 result = new BasicVector_UnsignedByte32(capacity);
     int i, j;
@@ -251,7 +251,7 @@
   }
 
   @Override
-  public LispObject nreverse() throws ConditionThrowable
+  public LispObject nreverse()
   {
     int i = 0;
     int j = capacity - 1;
@@ -270,7 +270,7 @@
   public AbstractVector adjustArray(int newCapacity,
                                      LispObject initialElement,
                                      LispObject initialContents)
-    throws ConditionThrowable
+
   {
     if (initialContents != null)
       {

Modified: trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
   }
 
   public BasicVector_UnsignedByte8(LispObject[] array)
-    throws ConditionThrowable
+
   {
     capacity = array.length;
     elements = new byte[capacity];
@@ -68,7 +68,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.SIMPLE_ARRAY)
       return T;
@@ -114,7 +114,7 @@
   }
 
   @Override
-  public LispObject elt(int index) throws ConditionThrowable
+  public LispObject elt(int index)
   {
     try
       {
@@ -128,7 +128,7 @@
   }
 
   @Override
-  public int aref(int index) throws ConditionThrowable
+  public int aref(int index)
   {
     try
       {
@@ -143,7 +143,7 @@
   }
 
   @Override
-  public LispObject AREF(int index) throws ConditionThrowable
+  public LispObject AREF(int index)
   {
     try
       {
@@ -157,7 +157,7 @@
   }
 
   @Override
-  public LispObject AREF(LispObject index) throws ConditionThrowable
+  public LispObject AREF(LispObject index)
   {
           int idx = Fixnum.getValue(index);
     try
@@ -172,7 +172,7 @@
   }
 
   @Override
-  public void aset(int index, int n) throws ConditionThrowable
+  public void aset(int index, int n)
   {
     try
       {
@@ -185,7 +185,7 @@
   }
 
   @Override
-  public void aset(int index, LispObject value) throws ConditionThrowable
+  public void aset(int index, LispObject value)
   {
     try
       {
@@ -198,7 +198,7 @@
   }
 
   @Override
-  public LispObject subseq(int start, int end) throws ConditionThrowable
+  public LispObject subseq(int start, int end)
   {
     BasicVector_UnsignedByte8 v = new BasicVector_UnsignedByte8(end - start);
     int i = start, j = 0;
@@ -215,7 +215,7 @@
   }
 
   @Override
-  public void fill(LispObject obj) throws ConditionThrowable
+  public void fill(LispObject obj)
   {
     byte b = coerceLispObjectToJavaByte(obj);
     for (int i = capacity; i-- > 0;)
@@ -223,7 +223,7 @@
   }
 
   @Override
-  public void shrink(int n) throws ConditionThrowable
+  public void shrink(int n)
   {
     if (n < capacity)
       {
@@ -239,7 +239,7 @@
   }
 
   @Override
-  public LispObject reverse() throws ConditionThrowable
+  public LispObject reverse()
   {
     BasicVector_UnsignedByte8 result = new BasicVector_UnsignedByte8(capacity);
     int i, j;
@@ -249,7 +249,7 @@
   }
 
   @Override
-  public LispObject nreverse() throws ConditionThrowable
+  public LispObject nreverse()
   {
     int i = 0;
     int j = capacity - 1;
@@ -268,7 +268,7 @@
   public AbstractVector adjustArray(int newCapacity,
                                      LispObject initialElement,
                                      LispObject initialContents)
-    throws ConditionThrowable
+
   {
     if (initialContents != null)
       {

Modified: trunk/abcl/src/org/armedbear/lisp/Bignum.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Bignum.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Bignum.java	Fri Nov  6 15:07:54 2009
@@ -112,7 +112,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type instanceof Symbol)
       {
@@ -221,7 +221,7 @@
   }
 
   @Override
-  public boolean equalp(LispObject obj) throws ConditionThrowable
+  public boolean equalp(LispObject obj)
   {
     if (obj instanceof Bignum)
       return value.equals(((Bignum)obj).value);
@@ -253,13 +253,13 @@
   }
 
   @Override
-  public boolean evenp() throws ConditionThrowable
+  public boolean evenp()
   {
     return !value.testBit(0);
   }
 
   @Override
-  public boolean oddp() throws ConditionThrowable
+  public boolean oddp()
   {
     return value.testBit(0);
   }
@@ -295,7 +295,7 @@
   }
 
   @Override
-  public float floatValue() throws ConditionThrowable
+  public float floatValue()
   {
     float f = value.floatValue();
     if (Float.isInfinite(f))
@@ -305,7 +305,7 @@
   }
 
   @Override
-  public double doubleValue() throws ConditionThrowable
+  public double doubleValue()
   {
     double d = value.doubleValue();
     if (Double.isInfinite(d))
@@ -314,7 +314,7 @@
     return d;
   }
 
-  public static BigInteger getValue(LispObject obj) throws ConditionThrowable
+  public static BigInteger getValue(LispObject obj)
   {
           
     if (obj instanceof Bignum)
@@ -339,13 +339,13 @@
   }
 
   @Override
-  public LispObject add(int n) throws ConditionThrowable
+  public LispObject add(int n)
   {
     return number(value.add(BigInteger.valueOf(n)));
   }
 
   @Override
-  public LispObject add(LispObject obj) throws ConditionThrowable
+  public LispObject add(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return number(value.add(Fixnum.getBigInteger(obj)));
@@ -371,7 +371,7 @@
   }
 
   @Override
-  public LispObject subtract(LispObject obj) throws ConditionThrowable
+  public LispObject subtract(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return number(value.subtract(Fixnum.getBigInteger(obj)));
@@ -398,7 +398,7 @@
   }
 
   @Override
-  public LispObject multiplyBy(int n) throws ConditionThrowable
+  public LispObject multiplyBy(int n)
   {
     if (n == 0)
       return Fixnum.ZERO;
@@ -408,7 +408,7 @@
   }
 
   @Override
-  public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
+  public LispObject multiplyBy(LispObject obj)
   {
     if (obj instanceof Fixnum)
       {
@@ -440,7 +440,7 @@
   }
 
   @Override
-  public LispObject divideBy(LispObject obj) throws ConditionThrowable
+  public LispObject divideBy(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return number(value, Fixnum.getBigInteger(obj));
@@ -469,7 +469,7 @@
   }
 
   @Override
-  public boolean isEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isEqualTo(LispObject obj)
   {
     if (obj instanceof Bignum)
       return value.equals(((Bignum)obj).value);
@@ -485,7 +485,7 @@
   }
 
   @Override
-  public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isNotEqualTo(LispObject obj)
   {
     if (obj instanceof Bignum)
       return !value.equals(((Bignum)obj).value);
@@ -501,7 +501,7 @@
   }
 
   @Override
-  public boolean isLessThan(LispObject obj) throws ConditionThrowable
+  public boolean isLessThan(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value.compareTo(Fixnum.getBigInteger(obj)) < 0;
@@ -522,7 +522,7 @@
   }
 
   @Override
-  public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
+  public boolean isGreaterThan(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value.compareTo(Fixnum.getBigInteger(obj)) > 0;
@@ -543,7 +543,7 @@
   }
 
   @Override
-  public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isLessThanOrEqualTo(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value.compareTo(Fixnum.getBigInteger(obj)) <= 0;
@@ -564,7 +564,7 @@
   }
 
   @Override
-  public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isGreaterThanOrEqualTo(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value.compareTo(Fixnum.getBigInteger(obj)) >= 0;
@@ -585,7 +585,7 @@
   }
 
   @Override
-  public LispObject truncate(LispObject obj) throws ConditionThrowable
+  public LispObject truncate(LispObject obj)
   {
     final LispThread thread = LispThread.currentThread();
     LispObject value1, value2;
@@ -647,7 +647,7 @@
   }
 
   @Override
-  public LispObject ash(LispObject obj) throws ConditionThrowable
+  public LispObject ash(LispObject obj)
   {
     BigInteger n = value;
     if (obj instanceof Fixnum)
@@ -680,7 +680,7 @@
   }
 
   @Override
-  public LispObject LOGAND(int n) throws ConditionThrowable
+  public LispObject LOGAND(int n)
   {
     if (n >= 0)
       return Fixnum.getInstance(value.intValue() & n);
@@ -689,7 +689,7 @@
   }
 
   @Override
-  public LispObject LOGAND(LispObject obj) throws ConditionThrowable
+  public LispObject LOGAND(LispObject obj)
   {
     if (obj instanceof Fixnum)
       {
@@ -709,13 +709,13 @@
   }
 
   @Override
-  public LispObject LOGIOR(int n) throws ConditionThrowable
+  public LispObject LOGIOR(int n)
   {
     return number(value.or(BigInteger.valueOf(n)));
   }
 
   @Override
-  public LispObject LOGIOR(LispObject obj) throws ConditionThrowable
+  public LispObject LOGIOR(LispObject obj)
   {
     if (obj instanceof Fixnum)
       {
@@ -732,13 +732,13 @@
   }
 
   @Override
-  public LispObject LOGXOR(int n) throws ConditionThrowable
+  public LispObject LOGXOR(int n)
   {
     return number(value.xor(BigInteger.valueOf(n)));
   }
 
   @Override
-  public LispObject LOGXOR(LispObject obj) throws ConditionThrowable
+  public LispObject LOGXOR(LispObject obj)
   {
     final BigInteger n;
     if (obj instanceof Fixnum)
@@ -765,7 +765,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     final LispThread thread = LispThread.currentThread();
     final int base = Fixnum.getValue(Symbol.PRINT_BASE.symbolValue(thread));

Modified: trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java	Fri Nov  6 15:07:54 2009
@@ -37,7 +37,7 @@
 {
     private final Stream[] streams;
 
-    private BroadcastStream(Stream[] streams) throws ConditionThrowable
+    private BroadcastStream(Stream[] streams)
     {
         this.streams = streams;
         isOutputStream = true;
@@ -72,7 +72,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.BROADCAST_STREAM)
             return T;
@@ -82,7 +82,7 @@
     }
 
     @Override
-    public LispObject listen() throws ConditionThrowable
+    public LispObject listen()
     {
         notSupported();
         // Not reached.
@@ -90,7 +90,7 @@
     }
 
     @Override
-    public LispObject fileLength() throws ConditionThrowable
+    public LispObject fileLength()
     {
         if (streams.length > 0)
             return streams[streams.length - 1].fileLength();
@@ -99,7 +99,7 @@
     }
 
     @Override
-    public LispObject fileStringLength(LispObject arg) throws ConditionThrowable
+    public LispObject fileStringLength(LispObject arg)
     {
         if (streams.length > 0)
             return streams[streams.length - 1].fileStringLength(arg);
@@ -109,7 +109,7 @@
 
     // Returns -1 at end of file.
     @Override
-    protected int _readChar() throws ConditionThrowable
+    protected int _readChar()
     {
         notSupported();
         // Not reached.
@@ -117,13 +117,13 @@
     }
 
     @Override
-    protected void _unreadChar(int n) throws ConditionThrowable
+    protected void _unreadChar(int n)
     {
         notSupported();
     }
 
     @Override
-    protected boolean _charReady() throws ConditionThrowable
+    protected boolean _charReady()
     {
         notSupported();
         // Not reached.
@@ -131,7 +131,7 @@
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         for (int i = 0; i < streams.length; i++)
             streams[i]._writeChar(c);
@@ -139,21 +139,21 @@
 
     @Override
     public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
+
     {
         for (int i = 0; i < streams.length; i++)
             streams[i]._writeChars(chars, start, end);
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         for (int i = 0; i < streams.length; i++)
             streams[i]._writeString(s);
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         for (int i = 0; i < streams.length; i++)
             streams[i]._writeLine(s);
@@ -161,7 +161,7 @@
 
     // Reads an 8-bit byte.
     @Override
-    public int _readByte() throws ConditionThrowable
+    public int _readByte()
     {
         notSupported();
         // Not reached.
@@ -170,27 +170,27 @@
 
     // Writes an 8-bit byte.
     @Override
-    public void _writeByte(int n) throws ConditionThrowable
+    public void _writeByte(int n)
     {
         for (int i = 0; i < streams.length; i++)
             streams[i]._writeByte(n);
     }
 
     @Override
-    public void _finishOutput() throws ConditionThrowable
+    public void _finishOutput()
     {
         for (int i = 0; i < streams.length; i++)
             streams[i]._finishOutput();
     }
 
     @Override
-    public void _clearInput() throws ConditionThrowable
+    public void _clearInput()
     {
         notSupported();
     }
 
     @Override
-    protected long _getFilePosition() throws ConditionThrowable
+    protected long _getFilePosition()
     {
         if (streams.length == 0)
             return 0;
@@ -199,18 +199,18 @@
     }
 
     @Override
-    protected boolean _setFilePosition(LispObject arg) throws ConditionThrowable
+    protected boolean _setFilePosition(LispObject arg)
     {
         return false;
     }
 
     @Override
-    public void _close() throws ConditionThrowable
+    public void _close()
     {
         setOpen(false);
     }
 
-    private void notSupported() throws ConditionThrowable
+    private void notSupported()
     {
         error(new TypeError("Operation is not supported for streams of type BROADCAST-STREAM."));
     }
@@ -226,12 +226,12 @@
         new Primitive("make-broadcast-stream", "&rest streams")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return new BroadcastStream(new Stream[0]);
         }
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             Stream[] streams = new Stream[args.length];
             for (int i = 0; i < args.length; i++) {
@@ -255,7 +255,7 @@
         new Primitive("broadcast-stream-streams", "broadcast-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof BroadcastStream) {
                 BroadcastStream stream = (BroadcastStream) arg;

Modified: trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java	Fri Nov  6 15:07:54 2009
@@ -53,7 +53,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.BUILT_IN_CLASS)
       return T;
@@ -63,13 +63,13 @@
   }
 
   @Override
-  public LispObject getDescription() throws ConditionThrowable
+  public LispObject getDescription()
   {
     return new SimpleString(writeToString());
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     FastStringBuffer sb = new FastStringBuffer("#<BUILT-IN-CLASS ");
     sb.append(symbol.writeToString());

Modified: trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java	Fri Nov  6 15:07:54 2009
@@ -61,20 +61,20 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         return super.typep(type); //TODO
     }
 
     @Override
-    protected long _getFilePosition() throws ConditionThrowable
+    protected long _getFilePosition()
     {
         if (elementType == NIL)
             return 0;
         return byteArrayOutputStream.size();
     }
 
-    public byte[] getByteArray() throws ConditionThrowable
+    public byte[] getByteArray()
     {
         if (elementType == NIL) {
             return new byte[0];
@@ -97,12 +97,12 @@
     {
 
         @Override
-        public LispObject execute() throws ConditionThrowable {
+        public LispObject execute() {
             return new ByteArrayOutputStream();
         }
 
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return new ByteArrayOutputStream(arg);
         }
@@ -115,7 +115,7 @@
                        "byte-array-output-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof ByteArrayOutputStream) {
                 return JavaObject.getInstance(((ByteArrayOutputStream)arg).getByteArray());

Modified: trunk/abcl/src/org/armedbear/lisp/CapitalizeFirstStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CapitalizeFirstStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CapitalizeFirstStream.java	Fri Nov  6 15:07:54 2009
@@ -37,13 +37,13 @@
 {
     boolean virgin = true;
 
-    public CapitalizeFirstStream(Stream target) throws ConditionThrowable
+    public CapitalizeFirstStream(Stream target)
     {
         super(target);
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         if (virgin) {
             if (Character.isLetterOrDigit(c)) {
@@ -56,7 +56,7 @@
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         final int length = s.length();
         for (int i = 0; i < length; i++)
@@ -64,7 +64,7 @@
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         _writeString(s);
         _writeChar('\n');

Modified: trunk/abcl/src/org/armedbear/lisp/CapitalizeStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CapitalizeStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CapitalizeStream.java	Fri Nov  6 15:07:54 2009
@@ -37,13 +37,13 @@
 {
     private boolean inWord;
 
-    public CapitalizeStream(Stream target) throws ConditionThrowable
+    public CapitalizeStream(Stream target)
     {
         super(target);
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         if (inWord) {
             if (Character.isUpperCase(c)) {
@@ -66,7 +66,7 @@
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         final int limit = s.length();
         for (int i = 0; i < limit; i++)
@@ -74,7 +74,7 @@
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         target._writeString(s);
         target._writeChar('\n');

Modified: trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java	Fri Nov  6 15:07:54 2009
@@ -38,14 +38,14 @@
     protected final Stream target;
 
     protected CaseFrobStream(Stream target)
-        throws ConditionThrowable
+
     {
         Debug.assertTrue(target.isCharacterOutputStream());
         this.target = target;
     }
 
     @Override
-    public LispObject getElementType() throws ConditionThrowable
+    public LispObject getElementType()
     {
         return target.getElementType();
     }
@@ -63,7 +63,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.CASE_FROB_STREAM)
             return T;
@@ -85,25 +85,25 @@
     }
 
     @Override
-    public boolean isCharacterInputStream() throws ConditionThrowable
+    public boolean isCharacterInputStream()
     {
         return false;
     }
 
     @Override
-    public boolean isBinaryInputStream() throws ConditionThrowable
+    public boolean isBinaryInputStream()
     {
         return false;
     }
 
     @Override
-    public boolean isCharacterOutputStream() throws ConditionThrowable
+    public boolean isCharacterOutputStream()
     {
         return true;
     }
 
     @Override
-    public boolean isBinaryOutputStream() throws ConditionThrowable
+    public boolean isBinaryOutputStream()
     {
         return false;
     }
@@ -122,7 +122,7 @@
 
     // Returns -1 at end of file.
     @Override
-    protected int _readChar() throws ConditionThrowable
+    protected int _readChar()
     {
         notSupported();
         // Not reached.
@@ -130,13 +130,13 @@
     }
 
     @Override
-    protected void _unreadChar(int n) throws ConditionThrowable
+    protected void _unreadChar(int n)
     {
         notSupported();
     }
 
     @Override
-    protected boolean _charReady() throws ConditionThrowable
+    protected boolean _charReady()
     {
         notSupported();
         // Not reached.
@@ -145,14 +145,14 @@
 
     @Override
     public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
+
     {
         _writeString(new String(chars, start, end));
     }
 
     // Reads an 8-bit byte.
     @Override
-    public int _readByte() throws ConditionThrowable
+    public int _readByte()
     {
         notSupported();
         // Not reached.
@@ -161,32 +161,32 @@
 
     // Writes an 8-bit byte.
     @Override
-    public void _writeByte(int n) throws ConditionThrowable
+    public void _writeByte(int n)
     {
         notSupported();
     }
 
     @Override
-    public void _finishOutput() throws ConditionThrowable
+    public void _finishOutput()
     {
         target._finishOutput();
     }
 
     @Override
-    public void _clearInput() throws ConditionThrowable
+    public void _clearInput()
     {
         notSupported();
     }
 
     @Override
-    public LispObject close(LispObject abort) throws ConditionThrowable
+    public LispObject close(LispObject abort)
     {
         setOpen(false);
         return T;
     }
 
     @Override
-    public LispObject listen() throws ConditionThrowable
+    public LispObject listen()
     {
         notSupported();
         // Not reached.
@@ -194,13 +194,13 @@
     }
 
     @Override
-    public LispObject terpri() throws ConditionThrowable
+    public LispObject terpri()
     {
         return target.terpri();
     }
 
     @Override
-    public LispObject freshLine() throws ConditionThrowable
+    public LispObject freshLine()
     {
         return target.freshLine();
     }
@@ -211,7 +211,7 @@
         return unreadableString("CASE-FROB-STREAM");
     }
 
-    private void notSupported() throws ConditionThrowable
+    private void notSupported()
     {
         error(new TypeError("Operation is not supported for streams of type CASE-FROB-STREAM."));
     }
@@ -222,7 +222,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             Stream target = checkCharacterOutputStream(first);
             if (second == Keyword.UPCASE)

Modified: trunk/abcl/src/org/armedbear/lisp/CellError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CellError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CellError.java	Fri Nov  6 15:07:54 2009
@@ -35,19 +35,19 @@
 
 public class CellError extends LispError
 {
-    protected CellError(LispClass cls) throws ConditionThrowable
+    protected CellError(LispClass cls)
     {
         super(cls);
     }
 
-    public CellError(LispObject initArgs) throws ConditionThrowable
+    public CellError(LispObject initArgs)
     {
         super(StandardClass.CELL_ERROR);
         initialize(initArgs);
     }
 
     @Override
-    protected void initialize(LispObject initArgs) throws ConditionThrowable
+    protected void initialize(LispObject initArgs)
     {
         super.initialize(initArgs);
         LispObject name = NIL;
@@ -63,12 +63,12 @@
         setCellName(name);
     }
 
-    public final LispObject getCellName() throws ConditionThrowable
+    public final LispObject getCellName()
     {
         return getInstanceSlotValue(Symbol.NAME);
     }
 
-    protected final void setCellName(LispObject name) throws ConditionThrowable
+    protected final void setCellName(LispObject name)
     {
         setInstanceSlotValue(Symbol.NAME, name);
     }
@@ -86,7 +86,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.CELL_ERROR)
             return T;
@@ -96,7 +96,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (Symbol.PRINT_ESCAPE.symbolValue() == NIL)
             return super.writeToString();

Modified: trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java	Fri Nov  6 15:07:54 2009
@@ -40,12 +40,12 @@
         new Primitive("char=", "&rest characters")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return error(new WrongNumberOfArgumentsException(this));
         }
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof LispCharacter)
                 return T;
@@ -53,12 +53,12 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             return LispCharacter.getValue(first) == LispCharacter.getValue(second) ? T : NIL;
         }
         @Override
-        public LispObject execute(LispObject[] array) throws ConditionThrowable
+        public LispObject execute(LispObject[] array)
         {
             final int length = array.length;
             final char c0 = LispCharacter.getValue(array[0]);
@@ -75,12 +75,12 @@
         new Primitive("char-equal", "&rest characters")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return error(new WrongNumberOfArgumentsException(this));
         }
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof LispCharacter)
                 return T;
@@ -88,7 +88,7 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             final char c1, c2;
             c1 = LispCharacter.getValue(first);
@@ -102,7 +102,7 @@
             return NIL;
         }
         @Override
-        public LispObject execute(LispObject[] array) throws ConditionThrowable
+        public LispObject execute(LispObject[] array)
         {
             final int length = array.length;
             final char c0 = LispCharacter.getValue(array[0]);
@@ -125,12 +125,12 @@
         new Primitive("char-greaterp", "&rest characters")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return error(new WrongNumberOfArgumentsException(this));
         }
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof LispCharacter)
                 return T;
@@ -138,14 +138,14 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first));
             char c2 = LispCharacter.toUpperCase(LispCharacter.getValue(second));
             return c1 > c2 ? T : NIL;
         }
         @Override
-        public LispObject execute(LispObject[] array) throws ConditionThrowable
+        public LispObject execute(LispObject[] array)
         {
             final int length = array.length;
             char[] chars = new char[length];
@@ -164,12 +164,12 @@
         new Primitive("char-not-greaterp", "&rest characters")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return error(new WrongNumberOfArgumentsException(this));
         }
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof LispCharacter)
                 return T;
@@ -177,14 +177,14 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first));
             char c2 = LispCharacter.toUpperCase(LispCharacter.getValue(second));
             return c1 <= c2 ? T : NIL;
         }
         @Override
-        public LispObject execute(LispObject[] array) throws ConditionThrowable
+        public LispObject execute(LispObject[] array)
         {
             final int length = array.length;
             char[] chars = new char[length];
@@ -203,12 +203,12 @@
         new Primitive("char<", "&rest characters")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return error(new WrongNumberOfArgumentsException(this));
         }
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof LispCharacter)
                 return T;
@@ -216,12 +216,12 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             return LispCharacter.getValue(first) < LispCharacter.getValue(second) ? T : NIL;
        }
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             final int length = args.length;
             char[] chars = new char[length];
@@ -241,12 +241,12 @@
         new Primitive("char<=", "&rest characters")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return error(new WrongNumberOfArgumentsException(this));
         }
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof LispCharacter)
                 return T;
@@ -254,14 +254,14 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             return LispCharacter.getValue(first) <= LispCharacter.getValue(second) ? T : NIL;
         }
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             if (LispCharacter.getValue(first) > LispCharacter.getValue(second))
                 return NIL;
@@ -270,7 +270,7 @@
             return T;
         }
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             final int length = args.length;
             char[] chars = new char[length];
@@ -290,12 +290,12 @@
         new Primitive("char-lessp", "&rest characters")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return error(new WrongNumberOfArgumentsException(this));
         }
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof LispCharacter)
                 return T;
@@ -303,14 +303,14 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first));
             char c2 = LispCharacter.toUpperCase(LispCharacter.getValue(second));
             return c1 < c2 ? T : NIL;
         }
         @Override
-        public LispObject execute(LispObject[] array) throws ConditionThrowable
+        public LispObject execute(LispObject[] array)
         {
             final int length = array.length;
             char[] chars = new char[length];
@@ -329,12 +329,12 @@
         new Primitive("char-not-lessp", "&rest characters")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return error(new WrongNumberOfArgumentsException(this));
         }
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof LispCharacter)
                 return T;
@@ -342,14 +342,14 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first));
             char c2 = LispCharacter.toUpperCase(LispCharacter.getValue(second));
             return c1 >= c2 ? T : NIL;
         }
         @Override
-        public LispObject execute(LispObject[] array) throws ConditionThrowable
+        public LispObject execute(LispObject[] array)
         {
             final int length = array.length;
             char[] chars = new char[length];

Modified: trunk/abcl/src/org/armedbear/lisp/Closure.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Closure.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Closure.java	Fri Nov  6 15:07:54 2009
@@ -84,14 +84,14 @@
   private boolean bindInitForms;
 
   public Closure(LispObject lambdaExpression, Environment env)
-    throws ConditionThrowable
+
   {
     this(null, lambdaExpression, env);
   }
 
   public Closure(final LispObject name, final LispObject lambdaExpression,
                  final Environment env)
-    throws ConditionThrowable
+
   {
     super(name, lambdaExpression.cadr());
     final LispObject lambdaList = lambdaExpression.cadr();
@@ -338,14 +338,14 @@
   }
 
   private static final void invalidParameter(LispObject obj)
-    throws ConditionThrowable
+
   {
     error(new LispError(obj.writeToString() +
                          " may not be used as a variable in a lambda list."));
   }
 
   @Override
-  public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+  public LispObject typep(LispObject typeSpecifier)
   {
     if (typeSpecifier == Symbol.COMPILED_FUNCTION)
       return NIL;
@@ -372,7 +372,7 @@
   }
 
   @Override
-  public LispObject execute() throws ConditionThrowable
+  public LispObject execute()
   {
     if (arity == 0)
       {
@@ -384,7 +384,7 @@
   }
     
   private final LispObject bindParametersAndExecute(LispObject... objects)
-  throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
@@ -412,7 +412,7 @@
   private final void bindRequiredParameters(Environment ext,
                                             LispThread thread,
                                             LispObject[] objects)
-  throws ConditionThrowable
+
   {
     // &whole and &environment before anything
     if (envVar != null)
@@ -424,13 +424,13 @@
   }
 
   public final LispObject invokeArrayExecute(LispObject... objects)
-  throws ConditionThrowable
+
   {
     return execute(objects);
   }
 
   @Override
-  public LispObject execute(LispObject arg) throws ConditionThrowable
+  public LispObject execute(LispObject arg)
   {
     if (minArgs == 1)
       {
@@ -444,7 +444,7 @@
 
   @Override
   public LispObject execute(LispObject first, LispObject second)
-    throws ConditionThrowable
+
   {
     if (minArgs == 2)
       {
@@ -459,7 +459,7 @@
   @Override
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third)
-    throws ConditionThrowable
+
   {
     if (minArgs == 3)
       {
@@ -474,7 +474,7 @@
   @Override
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth)
-    throws ConditionThrowable
+
   {
     if (minArgs == 4)
       {
@@ -490,7 +490,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth)
-    throws ConditionThrowable
+
   {
     if (minArgs == 5)
       {
@@ -507,7 +507,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth)
-    throws ConditionThrowable
+
   {
     if (minArgs == 6)
       {
@@ -526,7 +526,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh)
-    throws ConditionThrowable
+
   {
     if (minArgs == 7)
       {
@@ -545,7 +545,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh, LispObject eighth)
-    throws ConditionThrowable
+
   {
     if (minArgs == 8)
       {
@@ -560,7 +560,7 @@
   }
 
   private final void declareFreeSpecials(Environment ext)
-    throws ConditionThrowable
+
   {
     LispObject s = specials;
     special:
@@ -578,7 +578,7 @@
   }
 
   @Override
-  public LispObject execute(LispObject[] args) throws ConditionThrowable
+  public LispObject execute(LispObject[] args)
   {
     final LispThread thread = LispThread.currentThread();
     SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
@@ -610,7 +610,7 @@
   }
 
   protected final LispObject[] processArgs(LispObject[] args, LispThread thread)
-    throws ConditionThrowable
+
   {
     if (optionalParameters.length == 0 && keywordParameters.length == 0)
       return fastProcessArgs(args);
@@ -871,7 +871,7 @@
 
   // No optional or keyword parameters.
   protected final LispObject[] fastProcessArgs(LispObject[] args)
-    throws ConditionThrowable
+
   {
     final int argsLength = args.length;
     if (arity >= 0)
@@ -949,7 +949,7 @@
   private final void bindParameterDefaults(Parameter[] parameters,
                                            Environment env,
                                            LispThread thread)
-    throws ConditionThrowable
+
   {
     for (Parameter parameter : parameters)
       {
@@ -965,7 +965,7 @@
   }
 
   private final void bindAuxVars(Environment env, LispThread thread)
-    throws ConditionThrowable
+
   {
     // Aux variable processing is analogous to LET* processing.
     for (Parameter parameter : auxVars)
@@ -1002,7 +1002,7 @@
     }
 
     public Parameter(Symbol var, LispObject initForm, int type)
-      throws ConditionThrowable
+
     {
       this.var = var;
       this.initForm = initForm;
@@ -1015,7 +1015,7 @@
 
     public Parameter(Symbol var, LispObject initForm, LispObject svar,
                      int type)
-      throws ConditionThrowable
+
     {
       this.var = var;
       this.initForm = initForm;
@@ -1028,7 +1028,7 @@
 
     public Parameter(Symbol keyword, Symbol var, LispObject initForm,
                      LispObject svar)
-      throws ConditionThrowable
+
     {
       this.var = var;
       this.initForm = initForm;
@@ -1058,7 +1058,7 @@
     }
 
     private static final LispObject processInitForm(LispObject initForm)
-      throws ConditionThrowable
+
     {
       if (initForm.constantp())
         {
@@ -1080,7 +1080,7 @@
       new Primitive("lambda-list-names", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         Closure closure = new Closure(list(Symbol.LAMBDA, arg, NIL), new Environment());
         return closure.getVariableList();

Modified: trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java	Fri Nov  6 15:07:54 2009
@@ -40,7 +40,7 @@
   public ClosureBinding[] ctx;
 
   public CompiledClosure(LispObject lambdaList)
-    throws ConditionThrowable
+
   {
     super(list(Symbol.LAMBDA, lambdaList), null);
   }
@@ -62,21 +62,21 @@
   }
 
   @Override
-  public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+  public LispObject typep(LispObject typeSpecifier)
   {
     if (typeSpecifier == Symbol.COMPILED_FUNCTION)
       return T;
     return super.typep(typeSpecifier);
   }
 
-  private final LispObject notImplemented() throws ConditionThrowable
+  private final LispObject notImplemented()
   {
     return error(new WrongNumberOfArgumentsException(this));
   }
 
 
   // Zero args.
-  public LispObject execute() throws ConditionThrowable
+  public LispObject execute()
   {
     LispObject[] args = new LispObject[0];
     return execute(args);
@@ -84,7 +84,7 @@
 
   // One arg.
   public LispObject execute( LispObject first)
-    throws ConditionThrowable
+
   {
     LispObject[] args = new LispObject[1];
     args[0] = first;
@@ -94,7 +94,7 @@
   // Two args.
   public LispObject execute( LispObject first,
                             LispObject second)
-    throws ConditionThrowable
+
   {
     LispObject[] args = new LispObject[2];
     args[0] = first;
@@ -105,7 +105,7 @@
   // Three args.
   public LispObject execute( LispObject first,
                             LispObject second, LispObject third)
-    throws ConditionThrowable
+
   {
     LispObject[] args = new LispObject[3];
     args[0] = first;
@@ -118,7 +118,7 @@
   public LispObject execute( LispObject first,
                             LispObject second, LispObject third,
                             LispObject fourth)
-    throws ConditionThrowable
+
   {
     LispObject[] args = new LispObject[4];
     args[0] = first;
@@ -132,7 +132,7 @@
   public LispObject execute( LispObject first,
                             LispObject second, LispObject third,
                             LispObject fourth, LispObject fifth)
-    throws ConditionThrowable
+
   {
     LispObject[] args = new LispObject[5];
     args[0] = first;
@@ -148,7 +148,7 @@
                             LispObject second, LispObject third,
                             LispObject fourth, LispObject fifth,
                             LispObject sixth)
-    throws ConditionThrowable
+
   {
     LispObject[] args = new LispObject[6];
     args[0] = first;
@@ -165,7 +165,7 @@
                             LispObject second, LispObject third,
                             LispObject fourth, LispObject fifth,
                             LispObject sixth, LispObject seventh)
-    throws ConditionThrowable
+
   {
     LispObject[] args = new LispObject[7];
     args[0] = first;
@@ -184,7 +184,7 @@
                             LispObject fourth, LispObject fifth,
                             LispObject sixth, LispObject seventh,
                             LispObject eighth)
-    throws ConditionThrowable
+
   {
     LispObject[] args = new LispObject[8];
     args[0] = first;
@@ -200,7 +200,7 @@
 
   // Arg array.
   public LispObject execute(LispObject[] args)
-    throws ConditionThrowable
+
   {
     return notImplemented();
   }
@@ -210,7 +210,7 @@
       new Primitive("load-compiled-function", PACKAGE_SYS, true, "source")
   {
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
       String namestring = null;
       if (arg instanceof Pathname)
@@ -236,7 +236,7 @@
       new Primitive("varlist", PACKAGE_SYS, false)
   {
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
       if (arg instanceof Closure)
         return ((Closure)arg).getVariableList();

Modified: trunk/abcl/src/org/armedbear/lisp/CompilerError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CompilerError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CompilerError.java	Fri Nov  6 15:07:54 2009
@@ -35,7 +35,7 @@
 
 public class CompilerError extends Condition
 {
-    public CompilerError(LispObject initArgs) throws ConditionThrowable
+    public CompilerError(LispObject initArgs)
     {
         super(initArgs);
     }
@@ -53,7 +53,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.COMPILER_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java	Fri Nov  6 15:07:54 2009
@@ -35,7 +35,7 @@
 
 public class CompilerUnsupportedFeatureError extends Condition
 {
-    public CompilerUnsupportedFeatureError(LispObject initArgs) throws ConditionThrowable
+    public CompilerUnsupportedFeatureError(LispObject initArgs)
     {
         super(initArgs);
     }
@@ -53,7 +53,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.COMPILER_UNSUPPORTED_FEATURE_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/Complex.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Complex.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Complex.java	Fri Nov  6 15:07:54 2009
@@ -46,7 +46,7 @@
 
   public static LispObject getInstance(LispObject realpart,
                                        LispObject imagpart)
-    throws ConditionThrowable
+
   {
     if (!realpart.realp())
       return type_error(realpart, Symbol.REAL);
@@ -91,7 +91,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.COMPLEX)
       return T;
@@ -136,7 +136,7 @@
   }
 
   @Override
-  public boolean equalp(LispObject obj) throws ConditionThrowable
+  public boolean equalp(LispObject obj)
   {
     if (this == obj)
       return true;
@@ -174,19 +174,19 @@
   }
 
   @Override
-  public final LispObject incr() throws ConditionThrowable
+  public final LispObject incr()
   {
     return new Complex(realpart.add(Fixnum.ONE), imagpart);
   }
 
   @Override
-  public final LispObject decr() throws ConditionThrowable
+  public final LispObject decr()
   {
     return new Complex(realpart.subtract(Fixnum.ONE), imagpart);
   }
 
   @Override
-  public LispObject add(LispObject obj) throws ConditionThrowable
+  public LispObject add(LispObject obj)
   {
     if (obj instanceof Complex)
       {
@@ -197,7 +197,7 @@
   }
 
   @Override
-  public LispObject subtract(LispObject obj) throws ConditionThrowable
+  public LispObject subtract(LispObject obj)
   {
     if (obj instanceof Complex)
       {
@@ -209,7 +209,7 @@
   }
 
   @Override
-  public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
+  public LispObject multiplyBy(LispObject obj)
   {
     if (obj instanceof Complex)
       {
@@ -231,7 +231,7 @@
   }
 
   @Override
-  public LispObject divideBy(LispObject obj) throws ConditionThrowable
+  public LispObject divideBy(LispObject obj)
   {
     if (obj instanceof Complex)
       {
@@ -252,7 +252,7 @@
   }
 
   @Override
-  public boolean isEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isEqualTo(LispObject obj)
   {
     if (obj instanceof Complex)
       {
@@ -295,13 +295,13 @@
   }
 
   @Override
-  public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isNotEqualTo(LispObject obj)
   {
     return !isEqualTo(obj);
   }
 
   @Override
-  public LispObject ABS() throws ConditionThrowable
+  public LispObject ABS()
   {
     if (realpart.zerop())
       return imagpart.ABS();
@@ -314,7 +314,7 @@
   }
 
   @Override
-  public boolean zerop() throws ConditionThrowable
+  public boolean zerop()
   {
     return realpart.zerop() && imagpart.zerop();
   }
@@ -338,7 +338,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     FastStringBuffer sb = new FastStringBuffer("#C(");
     sb.append(realpart.writeToString());

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexArray.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexArray.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexArray.java	Fri Nov  6 15:07:54 2009
@@ -59,7 +59,7 @@
     public ComplexArray(int[] dimv,
                         LispObject elementType,
                         LispObject initialContents)
-        throws ConditionThrowable
+
     {
         this.dimv = dimv;
         this.elementType = elementType;
@@ -85,7 +85,7 @@
 
     private int setInitialContents(int axis, int[] dims, LispObject contents,
                                    int index)
-        throws ConditionThrowable
+
     {
         if (dims.length == 0) {
             try {
@@ -153,7 +153,7 @@
     }
 
     @Override
-    public int getDimension(int n) throws ConditionThrowable
+    public int getDimension(int n)
     {
         try {
             return dimv[n];
@@ -177,7 +177,7 @@
     }
 
     @Override
-    public LispObject arrayDisplacement() throws ConditionThrowable
+    public LispObject arrayDisplacement()
     {
         LispObject value1, value2;
         if (array != null) {
@@ -191,7 +191,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (data != null) {
             try {
@@ -205,7 +205,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         if (data != null) {
             try {
@@ -219,7 +219,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         if (data != null) {
             for (int i = data.length; i-- > 0;)
@@ -231,7 +231,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         return writeToString(dimv);
     }
@@ -240,7 +240,7 @@
     public AbstractArray adjustArray(int[] dims,
                                               LispObject initialElement,
                                               LispObject initialContents)
-            throws ConditionThrowable {
+            {
         if (isAdjustable()) {
             if (initialContents != null)
                 setInitialContents(0, dims, initialContents, 0);
@@ -273,7 +273,7 @@
     public AbstractArray adjustArray(int[] dims,
                                               AbstractArray displacedTo,
                                               int displacement)
-            throws ConditionThrowable {
+            {
         if (isAdjustable()) {
             for (int i = 0; i < dims.length; i++)
                 dimv[i] = dims[i];

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java	Fri Nov  6 15:07:54 2009
@@ -56,7 +56,7 @@
     }
 
     public ComplexArray_UnsignedByte32(int[] dimv, LispObject initialContents)
-        throws ConditionThrowable
+
     {
         this.dimv = dimv;
         final int rank = dimv.length;
@@ -81,7 +81,7 @@
 
     private int setInitialContents(int axis, int[] dims, LispObject contents,
                                    int index)
-        throws ConditionThrowable
+
     {
         if (dims.length == 0) {
             try {
@@ -149,7 +149,7 @@
     }
 
     @Override
-    public int getDimension(int n) throws ConditionThrowable
+    public int getDimension(int n)
     {
         try {
             return dimv[n];
@@ -173,7 +173,7 @@
     }
 
     @Override
-    public LispObject arrayDisplacement() throws ConditionThrowable
+    public LispObject arrayDisplacement()
     {
         LispObject value1, value2;
         if (array != null) {
@@ -187,7 +187,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (data != null) {
             try {
@@ -201,7 +201,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         if (data != null) {
             try {
@@ -215,7 +215,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         if (data != null) {
             for (int i = data.length; i-- > 0;)
@@ -227,7 +227,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         return writeToString(dimv);
     }
@@ -237,7 +237,7 @@
     public AbstractArray adjustArray(int[] dims,
                                               LispObject initialElement,
                                               LispObject initialContents)
-            throws ConditionThrowable {
+            {
         if (isAdjustable()) {
             if (initialContents != null)
                 setInitialContents(0, dims, initialContents, 0);
@@ -270,7 +270,7 @@
     public AbstractArray adjustArray(int[] dims,
                                               AbstractArray displacedTo,
                                               int displacement)
-            throws ConditionThrowable {
+            {
         if (isAdjustable()) {
             for (int i = 0; i < dims.length; i++)
                 dimv[i] = dims[i];

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java	Fri Nov  6 15:07:54 2009
@@ -53,7 +53,7 @@
     }
 
     public ComplexArray_UnsignedByte8(int[] dimv, LispObject initialContents)
-        throws ConditionThrowable
+
     {
         this.dimv = dimv;
         final int rank = dimv.length;
@@ -77,7 +77,7 @@
 
     private int setInitialContents(int axis, int[] dims, LispObject contents,
                                    int index)
-        throws ConditionThrowable
+
     {
         if (dims.length == 0) {
             try {
@@ -145,7 +145,7 @@
     }
 
     @Override
-    public int getDimension(int n) throws ConditionThrowable
+    public int getDimension(int n)
     {
         try {
             return dimv[n];
@@ -169,7 +169,7 @@
     }
 
     @Override
-    public LispObject arrayDisplacement() throws ConditionThrowable
+    public LispObject arrayDisplacement()
     {
         LispObject value1, value2;
         if (array != null) {
@@ -183,7 +183,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (data != null) {
             try {
@@ -197,7 +197,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         if (data != null) {
             try {
@@ -211,7 +211,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         if (data != null) {
             byte b = coerceLispObjectToJavaByte(obj);
@@ -224,7 +224,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
             error(new PrintNotReadable(list(Keyword.OBJECT, this)));
@@ -239,7 +239,7 @@
     public AbstractArray adjustArray(int[] dims,
                                               LispObject initialElement,
                                               LispObject initialContents)
-            throws ConditionThrowable {
+            {
         if (isAdjustable()) {
             if (initialContents != null)
                 setInitialContents(0, dims, initialContents, 0);
@@ -272,7 +272,7 @@
     public AbstractArray adjustArray(int[] dims,
                                               AbstractArray displacedTo,
                                               int displacement)
-            throws ConditionThrowable {
+            {
         if (isAdjustable()) {
             for (int i = 0; i < dims.length; i++)
                 dimv[i] = dims[i];

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     private AbstractArray array;
     private int displacement;
 
-    public ComplexBitVector(int capacity) throws ConditionThrowable
+    public ComplexBitVector(int capacity)
     {
         this.capacity = capacity;
         int size = capacity >>> 6;
@@ -84,7 +84,7 @@
     }
 
     @Override
-    public void setFillPointer(LispObject obj) throws ConditionThrowable
+    public void setFillPointer(LispObject obj)
     {
         if (obj == T)
             fillPointer = capacity();
@@ -108,7 +108,7 @@
     }
 
     @Override
-    public LispObject arrayDisplacement() throws ConditionThrowable
+    public LispObject arrayDisplacement()
     {
         LispObject value1, value2;
         if (array != null) {
@@ -128,7 +128,7 @@
     }
 
     @Override
-    public LispObject elt(int index) throws ConditionThrowable
+    public LispObject elt(int index)
     {
         if (index >= length())
             badIndex(index, length());
@@ -136,7 +136,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (index < 0 || index >= capacity)
             badIndex(index, capacity);
@@ -150,7 +150,7 @@
     }
 
     @Override
-    protected int getBit(int index) throws ConditionThrowable
+    protected int getBit(int index)
     {
         if (bits != null) {
             int offset = index >> 6;
@@ -160,7 +160,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         if (index < 0 || index >= capacity)
             badIndex(index, capacity);
@@ -187,7 +187,7 @@
     }
 
     @Override
-    protected void setBit(int index) throws ConditionThrowable
+    protected void setBit(int index)
     {
         if (bits != null) {
             int offset = index >> 6;
@@ -197,7 +197,7 @@
     }
 
     @Override
-    protected void clearBit(int index) throws ConditionThrowable
+    protected void clearBit(int index)
     {
         if (bits != null) {
             int offset = index >> 6;
@@ -207,7 +207,7 @@
     }
 
     @Override
-    public void shrink(int n) throws ConditionThrowable
+    public void shrink(int n)
     {
         if (bits != null) {
             if (n < capacity) {
@@ -236,7 +236,7 @@
 
     // FIXME
     @Override
-    public void vectorPushExtend(LispObject element) throws ConditionThrowable
+    public void vectorPushExtend(LispObject element)
     {
         final int fp = getFillPointer();
         if (fp < 0)
@@ -252,7 +252,7 @@
     // FIXME
     @Override
     public LispObject VECTOR_PUSH_EXTEND(LispObject element)
-        throws ConditionThrowable
+
     {
         vectorPushExtend(element);
         return Fixnum.getInstance(getFillPointer() - 1);
@@ -261,7 +261,7 @@
     // FIXME
     @Override
     public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
-        throws ConditionThrowable
+
     {
         int ext = Fixnum.getValue(extension);
         final int fp = getFillPointer();
@@ -277,7 +277,7 @@
         return Fixnum.getInstance(fp);
     }
 
-    private final void ensureCapacity(int minCapacity) throws ConditionThrowable
+    private final void ensureCapacity(int minCapacity)
     {
         if (bits != null) {
             if (capacity < minCapacity) {
@@ -320,7 +320,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        LispObject initialElement,
                                        LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (bits == null) {
             // Copy array.
@@ -380,7 +380,7 @@
     @Override
     public AbstractVector adjustArray(int size, AbstractArray displacedTo,
                                        int displacement)
-        throws ConditionThrowable
+
     {
         capacity = size;
         array = displacedTo;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexString.java	Fri Nov  6 15:07:54 2009
@@ -92,7 +92,7 @@
   }
 
   @Override
-  public void setFillPointer(LispObject obj) throws ConditionThrowable
+  public void setFillPointer(LispObject obj)
   {
     if (obj == T)
       fillPointer = capacity();
@@ -127,7 +127,7 @@
   }
 
   @Override
-  public LispObject arrayDisplacement() throws ConditionThrowable
+  public LispObject arrayDisplacement()
   {
     LispObject value1, value2;
     if (array != null)
@@ -144,7 +144,7 @@
   }
 
   @Override
-  public char[] chars() throws ConditionThrowable
+  public char[] chars()
   {
     if (chars != null)
       return chars;
@@ -166,7 +166,7 @@
   }
 
   @Override
-  public char[] getStringChars() throws ConditionThrowable
+  public char[] getStringChars()
   {
     if (fillPointer < 0)
       return chars();
@@ -176,7 +176,7 @@
   }
 
   @Override
-  public boolean equal(LispObject obj) throws ConditionThrowable
+  public boolean equal(LispObject obj)
   {
     if (this == obj)
       return true;
@@ -196,7 +196,7 @@
   }
 
   @Override
-  public boolean equalp(LispObject obj) throws ConditionThrowable
+  public boolean equalp(LispObject obj)
   {
     if (this == obj)
       return true;
@@ -223,7 +223,7 @@
   }
 
   @Override
-  public LispObject subseq(int start, int end) throws ConditionThrowable
+  public LispObject subseq(int start, int end)
   {
     SimpleString s = new SimpleString(end - start);
     int i = start, j = 0;
@@ -233,20 +233,20 @@
   }
 
   @Override
-  public void fill(LispObject obj) throws ConditionThrowable
+  public void fill(LispObject obj)
   {
     fill(LispCharacter.getValue(obj));
   }
 
   @Override
-  public void fill(char c) throws ConditionThrowable
+  public void fill(char c)
   {
     for (int i = length(); i-- > 0;)
       setCharAt(i, c);
   }
 
   @Override
-  public void shrink(int n) throws ConditionThrowable
+  public void shrink(int n)
   {
     if (chars != null)
       {
@@ -290,7 +290,7 @@
   }
 
   @Override
-  public LispObject reverse() throws ConditionThrowable
+  public LispObject reverse()
   {
     int length = length();
     SimpleString result = new SimpleString(length);
@@ -301,7 +301,7 @@
   }
 
   @Override
-  public LispObject nreverse() throws ConditionThrowable
+  public LispObject nreverse()
   {
     int i = 0;
     int j = length() - 1;
@@ -317,7 +317,7 @@
   }
 
   @Override
-  public String getStringValue() throws ConditionThrowable
+  public String getStringValue()
   {
     if (fillPointer >= 0)
       return new String(chars(), 0, fillPointer);
@@ -326,13 +326,13 @@
   }
 
   @Override
-  public Object javaInstance() throws ConditionThrowable
+  public Object javaInstance()
   {
     return new String(chars());
   }
 
   @Override
-  public Object javaInstance(Class c) throws ConditionThrowable
+  public Object javaInstance(Class c)
   {
     return javaInstance();
   }
@@ -350,7 +350,7 @@
   }
 
   @Override
-  public char charAt(int index) throws ConditionThrowable
+  public char charAt(int index)
   {
     if (chars != null)
       {
@@ -369,7 +369,7 @@
   }
 
   @Override
-  public void setCharAt(int index, char c) throws ConditionThrowable
+  public void setCharAt(int index, char c)
   {
     if (chars != null)
       {
@@ -387,7 +387,7 @@
   }
 
   @Override
-  public LispObject elt(int index) throws ConditionThrowable
+  public LispObject elt(int index)
   {
     final int limit = length();
     if (index < 0 || index >= limit)
@@ -397,34 +397,34 @@
 
   // Ignores fill pointer.
   @Override
-  public LispObject CHAR(int index) throws ConditionThrowable
+  public LispObject CHAR(int index)
   {
     return LispCharacter.getInstance(charAt(index));
   }
 
   // Ignores fill pointer.
   @Override
-  public LispObject AREF(int index) throws ConditionThrowable
+  public LispObject AREF(int index)
   {
     return LispCharacter.getInstance(charAt(index));
   }
 
   // Ignores fill pointer.
   @Override
-  public LispObject AREF(LispObject index) throws ConditionThrowable
+  public LispObject AREF(LispObject index)
   {
     return LispCharacter.getInstance(charAt(Fixnum.getValue(index)));
   }
 
   @Override
-  public void aset(int index, LispObject newValue) throws ConditionThrowable
+  public void aset(int index, LispObject newValue)
   {
       setCharAt(index, LispCharacter.getValue(newValue));
   }
 
   @Override
   public void vectorPushExtend(LispObject element)
-    throws ConditionThrowable
+
   {
     if (fillPointer < 0)
       noFillPointer();
@@ -444,7 +444,7 @@
 
   @Override
   public LispObject VECTOR_PUSH_EXTEND(LispObject element)
-    throws ConditionThrowable
+
   {
     vectorPushExtend(element);
     return Fixnum.getInstance(fillPointer - 1);
@@ -452,7 +452,7 @@
 
   @Override
   public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
-    throws ConditionThrowable
+
   {
     int ext = Fixnum.getValue(extension);
     if (fillPointer < 0)
@@ -472,7 +472,7 @@
     return Fixnum.getInstance(fillPointer++);
   }
 
-  public final void ensureCapacity(int minCapacity) throws ConditionThrowable
+  public final void ensureCapacity(int minCapacity)
   {
     if (chars != null)
       {
@@ -574,7 +574,7 @@
   public AbstractVector adjustArray(int newCapacity,
                                      LispObject initialElement,
                                      LispObject initialContents)
-    throws ConditionThrowable
+
   {
     if (initialContents != null)
       {
@@ -651,7 +651,7 @@
   public AbstractVector adjustArray(int newCapacity,
                                      AbstractArray displacedTo,
                                      int displacement)
-    throws ConditionThrowable
+
   {
     capacity = newCapacity;
     array = displacedTo;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexVector.java	Fri Nov  6 15:07:54 2009
@@ -95,7 +95,7 @@
     }
 
     @Override
-    public void setFillPointer(LispObject obj) throws ConditionThrowable
+    public void setFillPointer(LispObject obj)
     {
         if (obj == T)
             fillPointer = capacity();
@@ -125,7 +125,7 @@
     }
 
     @Override
-    public LispObject arrayDisplacement() throws ConditionThrowable
+    public LispObject arrayDisplacement()
     {
         LispObject value1, value2;
         if (array != null) {
@@ -163,7 +163,7 @@
     }
 
     @Override
-    public LispObject elt(int index) throws ConditionThrowable
+    public LispObject elt(int index)
     {
         final int limit = length();
         if (index < 0 || index >= limit)
@@ -173,7 +173,7 @@
 
     // Ignores fill pointer.
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (elements != null) {
             try {
@@ -194,13 +194,13 @@
     // Ignores fill pointer.
     // FIXME inline
     @Override
-    public LispObject AREF(LispObject index) throws ConditionThrowable
+    public LispObject AREF(LispObject index)
     {
         return AREF(Fixnum.getValue(index));
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         if (elements != null) {
             try {
@@ -219,7 +219,7 @@
     }
 
     @Override
-    public LispObject subseq(int start, int end) throws ConditionThrowable
+    public LispObject subseq(int start, int end)
     {
         SimpleVector v = new SimpleVector(end - start);
         int i = start, j = 0;
@@ -234,14 +234,14 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         for (int i = capacity; i-- > 0;)
             elements[i] = obj;
     }
 
     @Override
-    public void shrink(int n) throws ConditionThrowable
+    public void shrink(int n)
     {
         if (elements != null) {
             if (n < elements.length) {
@@ -258,7 +258,7 @@
     }
 
     @Override
-    public LispObject reverse() throws ConditionThrowable
+    public LispObject reverse()
     {
         int length = length();
         SimpleVector result = new SimpleVector(length);
@@ -269,7 +269,7 @@
     }
 
     @Override
-    public LispObject nreverse() throws ConditionThrowable
+    public LispObject nreverse()
     {
         if (elements != null) {
             int i = 0;
@@ -300,7 +300,7 @@
 
     @Override
     public void vectorPushExtend(LispObject element)
-        throws ConditionThrowable
+
     {
         if (fillPointer < 0)
             noFillPointer();
@@ -313,7 +313,7 @@
 
     @Override
     public LispObject VECTOR_PUSH_EXTEND(LispObject element)
-        throws ConditionThrowable
+
     {
         vectorPushExtend(element);
         return Fixnum.getInstance(fillPointer - 1);
@@ -321,7 +321,7 @@
 
     @Override
     public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
-        throws ConditionThrowable
+
     {
         int ext = Fixnum.getValue(extension);
         if (fillPointer < 0)
@@ -335,7 +335,7 @@
         return Fixnum.getInstance(fillPointer++);
     }
 
-    private final void ensureCapacity(int minCapacity) throws ConditionThrowable
+    private final void ensureCapacity(int minCapacity)
     {
         if (elements != null) {
             if (capacity < minCapacity) {
@@ -368,7 +368,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        LispObject initialElement,
                                        LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null) {
             // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
@@ -416,7 +416,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        AbstractArray displacedTo,
                                        int displacement)
-        throws ConditionThrowable
+
     {
         capacity = newCapacity;
         array = displacedTo;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java	Fri Nov  6 15:07:54 2009
@@ -96,7 +96,7 @@
     }
 
     @Override
-    public void setFillPointer(LispObject obj) throws ConditionThrowable
+    public void setFillPointer(LispObject obj)
     {
         if (obj == T)
             fillPointer = capacity();
@@ -126,7 +126,7 @@
     }
 
     @Override
-    public LispObject arrayDisplacement() throws ConditionThrowable
+    public LispObject arrayDisplacement()
     {
         LispObject value1, value2;
         if (array != null) {
@@ -164,7 +164,7 @@
     }
 
     @Override
-    public LispObject elt(int index) throws ConditionThrowable
+    public LispObject elt(int index)
     {
         final int limit = length();
         if (index < 0 || index >= limit)
@@ -174,7 +174,7 @@
 
     // Ignores fill pointer.
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (elements != null) {
             try {
@@ -195,13 +195,13 @@
     // Ignores fill pointer.
     // FIXME inline
     @Override
-    public LispObject AREF(LispObject index) throws ConditionThrowable
+    public LispObject AREF(LispObject index)
     {
         return AREF(Fixnum.getValue(index));
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         if (elements != null) {
             try {
@@ -220,7 +220,7 @@
     }
 
     @Override
-    public LispObject subseq(int start, int end) throws ConditionThrowable
+    public LispObject subseq(int start, int end)
     {
         SimpleVector v = new SimpleVector(end - start);
         int i = start, j = 0;
@@ -235,14 +235,14 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         for (int i = capacity; i-- > 0;)
             elements[i] = obj;
     }
 
     @Override
-    public void shrink(int n) throws ConditionThrowable
+    public void shrink(int n)
     {
         if (elements != null) {
             if (n < elements.length) {
@@ -259,7 +259,7 @@
     }
 
     @Override
-    public LispObject reverse() throws ConditionThrowable
+    public LispObject reverse()
     {
         int length = length();
         SimpleVector result = new SimpleVector(length);
@@ -270,7 +270,7 @@
     }
 
     @Override
-    public LispObject nreverse() throws ConditionThrowable
+    public LispObject nreverse()
     {
         if (elements != null) {
             int i = 0;
@@ -301,7 +301,7 @@
 
     @Override
     public void vectorPushExtend(LispObject element)
-        throws ConditionThrowable
+
     {
         if (fillPointer < 0)
             noFillPointer();
@@ -315,7 +315,7 @@
 
     @Override
     public LispObject VECTOR_PUSH_EXTEND(LispObject element)
-        throws ConditionThrowable
+
     {
         vectorPushExtend(element);
         return Fixnum.getInstance(fillPointer - 1);
@@ -323,7 +323,7 @@
 
     @Override
     public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
-        throws ConditionThrowable
+
     {
         int ext = Fixnum.getValue(extension);
         if (fillPointer < 0)
@@ -337,7 +337,7 @@
         return Fixnum.getInstance(fillPointer++);
     }
 
-    private final void ensureCapacity(int minCapacity) throws ConditionThrowable
+    private final void ensureCapacity(int minCapacity)
     {
         if (elements != null) {
             if (capacity < minCapacity) {
@@ -370,7 +370,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        LispObject initialElement,
                                        LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null) {
             // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
@@ -419,7 +419,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        AbstractArray displacedTo,
                                        int displacement)
-        throws ConditionThrowable
+
     {
         capacity = newCapacity;
         array = displacedTo;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java	Fri Nov  6 15:07:54 2009
@@ -94,7 +94,7 @@
     }
 
     @Override
-    public void setFillPointer(LispObject obj) throws ConditionThrowable
+    public void setFillPointer(LispObject obj)
     {
         if (obj == T)
             fillPointer = capacity();
@@ -124,7 +124,7 @@
     }
 
     @Override
-    public LispObject arrayDisplacement() throws ConditionThrowable
+    public LispObject arrayDisplacement()
     {
         LispObject value1, value2;
         if (array != null) {
@@ -162,7 +162,7 @@
     }
 
     @Override
-    public LispObject elt(int index) throws ConditionThrowable
+    public LispObject elt(int index)
     {
         final int limit = length();
         if (index < 0 || index >= limit)
@@ -172,7 +172,7 @@
 
     // Ignores fill pointer.
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (elements != null) {
             try {
@@ -193,13 +193,13 @@
     // Ignores fill pointer.
     // FIXME inline
     @Override
-    public LispObject AREF(LispObject index) throws ConditionThrowable
+    public LispObject AREF(LispObject index)
     {
         return AREF(Fixnum.getValue(index));
     }
 
     @Override
-    public void aset(int index, int n) throws ConditionThrowable
+    public void aset(int index, int n)
     {
         if (elements != null) {
             try {
@@ -218,7 +218,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         if (elements != null) {
             try {
@@ -232,7 +232,7 @@
     }
 
     @Override
-    public LispObject subseq(int start, int end) throws ConditionThrowable
+    public LispObject subseq(int start, int end)
     {
         SimpleVector v = new SimpleVector(end - start);
         int i = start, j = 0;
@@ -247,7 +247,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         byte b = (byte) Fixnum.getValue(obj);
         for (int i = capacity; i-- > 0;)
@@ -255,7 +255,7 @@
     }
 
     @Override
-    public void shrink(int n) throws ConditionThrowable
+    public void shrink(int n)
     {
         if (elements != null) {
             if (n < elements.length) {
@@ -272,7 +272,7 @@
     }
 
     @Override
-    public LispObject reverse() throws ConditionThrowable
+    public LispObject reverse()
     {
         int length = length();
         BasicVector_UnsignedByte8 result = new BasicVector_UnsignedByte8(length);
@@ -283,7 +283,7 @@
     }
 
     @Override
-    public LispObject nreverse() throws ConditionThrowable
+    public LispObject nreverse()
     {
         if (elements != null) {
             int i = 0;
@@ -313,7 +313,7 @@
     }
 
     @Override
-    public void vectorPushExtend(LispObject element) throws ConditionThrowable
+    public void vectorPushExtend(LispObject element)
     {
         if (fillPointer < 0)
             noFillPointer();
@@ -327,7 +327,7 @@
 
     @Override
     public LispObject VECTOR_PUSH_EXTEND(LispObject element)
-        throws ConditionThrowable
+
     {
         vectorPushExtend(element);
         return Fixnum.getInstance(fillPointer - 1);
@@ -335,7 +335,7 @@
 
     @Override
     public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
-        throws ConditionThrowable
+
     {
         int ext = Fixnum.getValue(extension);
         if (fillPointer < 0)
@@ -349,7 +349,7 @@
         return Fixnum.getInstance(fillPointer++);
     }
 
-    private final void ensureCapacity(int minCapacity) throws ConditionThrowable
+    private final void ensureCapacity(int minCapacity)
     {
         if (elements != null) {
             if (capacity < minCapacity) {
@@ -382,7 +382,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        LispObject initialElement,
                                        LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null) {
             // "If INITIAL-CONTENTS is supplied, it is treated as for MAKE-
@@ -432,7 +432,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        AbstractArray displacedTo,
                                        int displacement)
-        throws ConditionThrowable
+
     {
         capacity = newCapacity;
         array = displacedTo;

Modified: trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java	Fri Nov  6 15:07:54 2009
@@ -37,14 +37,14 @@
 {
     private LispObject streams;
 
-    private ConcatenatedStream(LispObject streams) throws ConditionThrowable
+    private ConcatenatedStream(LispObject streams)
     {
         this.streams = streams;
         isInputStream = true;
     }
 
     @Override
-    public boolean isCharacterInputStream() throws ConditionThrowable
+    public boolean isCharacterInputStream()
     {
         if (streams == NIL)
             return true;
@@ -52,7 +52,7 @@
     }
 
     @Override
-    public boolean isBinaryInputStream() throws ConditionThrowable
+    public boolean isBinaryInputStream()
     {
         if (streams == NIL)
             return true;
@@ -60,13 +60,13 @@
     }
 
     @Override
-    public boolean isCharacterOutputStream() throws ConditionThrowable
+    public boolean isCharacterOutputStream()
     {
         return false;
     }
 
     @Override
-    public boolean isBinaryOutputStream() throws ConditionThrowable
+    public boolean isBinaryOutputStream()
     {
         return false;
     }
@@ -84,7 +84,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.CONCATENATED_STREAM)
             return T;
@@ -94,7 +94,7 @@
     }
 
     @Override
-    public LispObject getElementType() throws ConditionThrowable
+    public LispObject getElementType()
     {
         if (streams == NIL)
             return NIL;
@@ -103,7 +103,7 @@
 
     @Override
     public LispObject readCharNoHang(boolean eofError, LispObject eofValue)
-        throws ConditionThrowable
+
     {
         if (streams == NIL) {
             if (eofError)
@@ -122,7 +122,7 @@
     }
 
     @Override
-    public LispObject listen() throws ConditionThrowable
+    public LispObject listen()
     {
         if (unreadChar >= 0)
             return T;
@@ -139,7 +139,7 @@
 
     // Returns -1 at end of file.
     @Override
-    protected int _readChar() throws ConditionThrowable, java.io.IOException
+    protected int _readChar() throws java.io.IOException
     {
         int n;
         if (unreadChar >= 0) {
@@ -158,7 +158,7 @@
     }
 
     @Override
-    protected void _unreadChar(int n) throws ConditionThrowable
+    protected void _unreadChar(int n)
     {
         if (unreadChar >= 0)
             error(new StreamError(this, "UNREAD-CHAR was invoked twice consecutively without an intervening call to READ-CHAR."));
@@ -166,7 +166,7 @@
     }
 
     @Override
-    protected boolean _charReady() throws ConditionThrowable, java.io.IOException
+    protected boolean _charReady() throws java.io.IOException
     {
         if (unreadChar >= 0)
             return true;
@@ -186,33 +186,33 @@
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         outputStreamError();
     }
 
     @Override
     public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
+
     {
         outputStreamError();
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         outputStreamError();
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         outputStreamError();
     }
 
     // Reads an 8-bit byte.
     @Override
-    public int _readByte() throws ConditionThrowable
+    public int _readByte()
     {
         if (streams == NIL)
             return -1;
@@ -226,24 +226,24 @@
 
     // Writes an 8-bit byte.
     @Override
-    public void _writeByte(int n) throws ConditionThrowable
+    public void _writeByte(int n)
     {
         outputStreamError();
     }
 
     @Override
-    public void _finishOutput() throws ConditionThrowable
+    public void _finishOutput()
     {
         outputStreamError();
     }
 
     @Override
-    public void _clearInput() throws ConditionThrowable
+    public void _clearInput()
     {
         // FIXME
     }
 
-    private void outputStreamError() throws ConditionThrowable
+    private void outputStreamError()
     {
         error(new StreamError(this,
                                String.valueOf(this) + " is not an output stream."));
@@ -254,7 +254,7 @@
         new Primitive("make-concatenated-stream", "&rest streams")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             LispObject streams = NIL;
             for (int i = 0; i < args.length; i++) {
@@ -278,7 +278,7 @@
         new Primitive("concatenated-stream-streams", "concatenated-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof ConcatenatedStream) 
                 return ((ConcatenatedStream)arg).streams;

Modified: trunk/abcl/src/org/armedbear/lisp/Condition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Condition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Condition.java	Fri Nov  6 15:07:54 2009
@@ -37,14 +37,14 @@
 {
   protected String message;
 
-  public Condition() throws ConditionThrowable
+  public Condition()
   {
     super(StandardClass.CONDITION);
     Debug.assertTrue(slots.length == 2);
     setFormatArguments(NIL);
   }
 
-  protected Condition(LispClass cls) throws ConditionThrowable
+  protected Condition(LispClass cls)
   {
     super(cls);
     Debug.assertTrue(slots.length >= 2);
@@ -56,14 +56,14 @@
     super(cls, length);
   }
 
-  public Condition(LispObject initArgs) throws ConditionThrowable
+  public Condition(LispObject initArgs)
   {
     super(StandardClass.CONDITION);
     Debug.assertTrue(slots.length == 2);
     initialize(initArgs);
   }
 
-  protected void initialize(LispObject initArgs) throws ConditionThrowable
+  protected void initialize(LispObject initArgs)
   {
     LispObject control = null;
     LispObject arguments = null;
@@ -107,34 +107,34 @@
       }
   }
 
-  public final LispObject getFormatControl() throws ConditionThrowable
+  public final LispObject getFormatControl()
   {
     return getInstanceSlotValue(Symbol.FORMAT_CONTROL);
   }
 
   public final void setFormatControl(LispObject formatControl)
-    throws ConditionThrowable
+
   {
     setInstanceSlotValue(Symbol.FORMAT_CONTROL, formatControl);
   }
 
-  public final void setFormatControl(String s) throws ConditionThrowable
+  public final void setFormatControl(String s)
   {
     setFormatControl(new SimpleString(s));
   }
 
-  public final LispObject getFormatArguments() throws ConditionThrowable
+  public final LispObject getFormatArguments()
   {
     return getInstanceSlotValue(Symbol.FORMAT_ARGUMENTS);
   }
 
   public final void setFormatArguments(LispObject formatArguments)
-    throws ConditionThrowable
+
   {
     setInstanceSlotValue(Symbol.FORMAT_ARGUMENTS, formatArguments);
   }
 
-  public String getMessage() throws ConditionThrowable
+  public String getMessage()
   {
     return message;
   }
@@ -158,7 +158,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.CONDITION)
       return T;
@@ -167,7 +167,7 @@
     return super.typep(type);
   }
 
-  public String getConditionReport() throws ConditionThrowable
+  public String getConditionReport()
   {
     String s = getMessage();
     if (s != null)
@@ -185,7 +185,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     final LispThread thread = LispThread.currentThread();
     if (Symbol.PRINT_ESCAPE.symbolValue(thread) == NIL)

Modified: trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java	Fri Nov  6 15:07:54 2009
@@ -53,5 +53,5 @@
         super(message);
     }
 
-    public abstract LispObject getCondition() throws ConditionThrowable;
+    public abstract LispObject getCondition();
 }

Modified: trunk/abcl/src/org/armedbear/lisp/Cons.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Cons.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Cons.java	Fri Nov  6 15:07:54 2009
@@ -72,7 +72,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+  public LispObject typep(LispObject typeSpecifier)
   {
     if (typeSpecifier instanceof Symbol)
       {
@@ -142,7 +142,7 @@
   }
 
   @Override
-  public LispObject RPLACA(LispObject obj) throws ConditionThrowable
+  public LispObject RPLACA(LispObject obj)
   {
     car = obj;
     return this;
@@ -155,32 +155,32 @@
   }
 
   @Override
-  public LispObject RPLACD(LispObject obj) throws ConditionThrowable
+  public LispObject RPLACD(LispObject obj)
   {
     cdr = obj;
     return this;
   }
 
   @Override
-  public final LispObject cadr() throws ConditionThrowable
+  public final LispObject cadr()
   {
     return cdr.car();
   }
 
   @Override
-  public final LispObject cddr() throws ConditionThrowable
+  public final LispObject cddr()
   {
     return cdr.cdr();
   }
 
   @Override
-  public final LispObject caddr() throws ConditionThrowable
+  public final LispObject caddr()
   {
     return cdr.cadr();
   }
 
   @Override
-  public LispObject nthcdr(int n) throws ConditionThrowable
+  public LispObject nthcdr(int n)
   {
     if (n < 0)
       return type_error(Fixnum.getInstance(n),
@@ -230,7 +230,7 @@
   }
 
   @Override
-  public final int psxhash() //throws ConditionThrowable
+  public final int psxhash()
   {
     return computeEqualpHash(this, 4);
   }
@@ -253,7 +253,7 @@
   }
 
   @Override
-  public final boolean equal(LispObject obj) throws ConditionThrowable
+  public final boolean equal(LispObject obj)
   {
     if (this == obj)
       return true;
@@ -266,7 +266,7 @@
   }
 
   @Override
-  public final boolean equalp(LispObject obj) throws ConditionThrowable
+  public final boolean equalp(LispObject obj)
   {
     if (this == obj)
       return true;
@@ -279,7 +279,7 @@
   }
 
   @Override
-  public final int length() throws ConditionThrowable
+  public final int length()
   {
     int length = 1;
     LispObject obj = cdr;
@@ -294,7 +294,7 @@
   }
 
   @Override
-  public LispObject NTH(int index) throws ConditionThrowable
+  public LispObject NTH(int index)
   {
     if (index < 0)
       type_error(Fixnum.getInstance(index), Symbol.UNSIGNED_BYTE);
@@ -312,7 +312,7 @@
   }
 
   @Override
-  public LispObject NTH(LispObject arg) throws ConditionThrowable
+  public LispObject NTH(LispObject arg)
   {
     int index;
     if (arg instanceof Fixnum)
@@ -346,7 +346,7 @@
   }
 
   @Override
-  public LispObject elt(int index) throws ConditionThrowable
+  public LispObject elt(int index)
   {
     if (index < 0)
       type_error(Fixnum.getInstance(index), Symbol.UNSIGNED_BYTE);
@@ -383,7 +383,7 @@
   }
 
   @Override
-  public LispObject reverse() throws ConditionThrowable
+  public LispObject reverse()
   {
     Cons cons = this;
     LispObject result = new Cons(cons.car);
@@ -398,7 +398,7 @@
   }
 
   @Override
-  public final LispObject nreverse() throws ConditionThrowable
+  public final LispObject nreverse()
   {
     if (cdr instanceof Cons)
       {
@@ -456,7 +456,7 @@
   }
 
   @Override
-  public final LispObject[] copyToArray() throws ConditionThrowable
+  public final LispObject[] copyToArray()
   {
     final int length = length();
     LispObject[] array = new LispObject[length];
@@ -470,7 +470,7 @@
   }
 
   @Override
-  public LispObject execute() throws ConditionThrowable
+  public LispObject execute()
   {
     if (car == Symbol.LAMBDA)
       {
@@ -481,7 +481,7 @@
   }
 
   @Override
-  public LispObject execute(LispObject arg) throws ConditionThrowable
+  public LispObject execute(LispObject arg)
   {
     if (car == Symbol.LAMBDA)
       {
@@ -493,7 +493,7 @@
 
   @Override
   public LispObject execute(LispObject first, LispObject second)
-    throws ConditionThrowable
+
   {
     if (car == Symbol.LAMBDA)
       {
@@ -506,7 +506,7 @@
   @Override
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third)
-    throws ConditionThrowable
+
   {
     if (car == Symbol.LAMBDA)
       {
@@ -519,7 +519,7 @@
   @Override
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth)
-    throws ConditionThrowable
+
   {
     if (car == Symbol.LAMBDA)
       {
@@ -533,7 +533,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth)
-    throws ConditionThrowable
+
   {
     if (car == Symbol.LAMBDA)
       {
@@ -547,7 +547,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth)
-    throws ConditionThrowable
+
   {
     if (car == Symbol.LAMBDA)
       {
@@ -562,7 +562,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh)
-    throws ConditionThrowable
+
   {
     if (car == Symbol.LAMBDA)
       {
@@ -578,7 +578,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh, LispObject eighth)
-    throws ConditionThrowable
+
   {
     if (car == Symbol.LAMBDA)
       {
@@ -590,7 +590,7 @@
   }
 
   @Override
-  public LispObject execute(LispObject[] args) throws ConditionThrowable
+  public LispObject execute(LispObject[] args)
   {
     if (car == Symbol.LAMBDA)
       {
@@ -600,14 +600,14 @@
     return signalExecutionError();
   }
 
-  private final LispObject signalExecutionError() throws ConditionThrowable
+  private final LispObject signalExecutionError()
   {
     return type_error(this, list(Symbol.OR, Symbol.FUNCTION,
                                        Symbol.SYMBOL));
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     final LispThread thread = LispThread.currentThread();
     final LispObject printLength = Symbol.PRINT_LENGTH.symbolValue(thread);

Modified: trunk/abcl/src/org/armedbear/lisp/ControlError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ControlError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ControlError.java	Fri Nov  6 15:07:54 2009
@@ -35,13 +35,13 @@
 
 public final class ControlError extends LispError
 {
-    public ControlError(LispObject initArgs) throws ConditionThrowable
+    public ControlError(LispObject initArgs)
     {
         super(StandardClass.CONTROL_ERROR);
         initialize(initArgs);
     }
 
-    public ControlError(String message) throws ConditionThrowable
+    public ControlError(String message)
     {
         super(StandardClass.CONTROL_ERROR);
         setFormatControl(message);
@@ -61,7 +61,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.CONTROL_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java	Fri Nov  6 15:07:54 2009
@@ -64,7 +64,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third)
-        throws ConditionThrowable
+
     {
         Stream stream = inSynonymOf(first);
         char c = LispCharacter.getValue(second);
@@ -77,5 +77,5 @@
     }
 
     public abstract LispObject execute(Stream stream, char c, int n)
-        throws ConditionThrowable;
+       ;
 }

Modified: trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java	Fri Nov  6 15:07:54 2009
@@ -35,13 +35,13 @@
 
 public final class DivisionByZero extends ArithmeticError
 {
-    public DivisionByZero() throws ConditionThrowable
+    public DivisionByZero()
     {
         super(StandardClass.DIVISION_BY_ZERO);
         setFormatControl("Arithmetic error DIVISION-BY-ZERO signalled.");
     }
 
-    public DivisionByZero(LispObject initArgs) throws ConditionThrowable
+    public DivisionByZero(LispObject initArgs)
     {
         super(StandardClass.DIVISION_BY_ZERO);
         initialize(initArgs);
@@ -60,7 +60,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.DIVISION_BY_ZERO)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/Do.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Do.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Do.java	Fri Nov  6 15:07:54 2009
@@ -41,7 +41,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         return _do(args, env, false);
       }
@@ -53,7 +53,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         return _do(args, env, true);
       }
@@ -61,7 +61,7 @@
 
   private static final LispObject _do(LispObject args, Environment env,
                                       boolean sequential)
-    throws ConditionThrowable
+
   {
     LispObject varlist = args.car();
     LispObject second = args.cadr();

Modified: trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java	Fri Nov  6 15:07:54 2009
@@ -86,7 +86,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.FLOAT)
             return T;
@@ -168,7 +168,7 @@
     }
 
     @Override
-    public boolean equalp(LispObject obj) throws ConditionThrowable
+    public boolean equalp(LispObject obj)
     {
         if (obj instanceof SingleFloat)
             return value == ((SingleFloat)obj).value;
@@ -223,7 +223,7 @@
         return true;
     }
 
-    public static double getValue(LispObject obj) throws ConditionThrowable
+    public static double getValue(LispObject obj)
     {
         if (obj instanceof DoubleFloat) 
             return ((DoubleFloat)obj).value;
@@ -280,7 +280,7 @@
     }
 
     @Override
-    public LispObject add(LispObject obj) throws ConditionThrowable
+    public LispObject add(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new DoubleFloat(value + ((Fixnum)obj).value);
@@ -300,7 +300,7 @@
     }
 
     @Override
-    public LispObject subtract(LispObject obj) throws ConditionThrowable
+    public LispObject subtract(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new DoubleFloat(value - ((Fixnum)obj).value);
@@ -321,7 +321,7 @@
     }
 
     @Override
-    public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
+    public LispObject multiplyBy(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new DoubleFloat(value * ((Fixnum)obj).value);
@@ -342,7 +342,7 @@
     }
 
     @Override
-    public LispObject divideBy(LispObject obj) throws ConditionThrowable
+    public LispObject divideBy(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new DoubleFloat(value / ((Fixnum)obj).value);
@@ -368,7 +368,7 @@
     }
 
     @Override
-    public boolean isEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isEqualTo(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return value == ((Fixnum)obj).value;
@@ -388,13 +388,13 @@
     }
 
     @Override
-    public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isNotEqualTo(LispObject obj)
     {
         return !isEqualTo(obj);
     }
 
     @Override
-    public boolean isLessThan(LispObject obj) throws ConditionThrowable
+    public boolean isLessThan(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return value < ((Fixnum)obj).value;
@@ -412,7 +412,7 @@
     }
 
     @Override
-    public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
+    public boolean isGreaterThan(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return value > ((Fixnum)obj).value;
@@ -430,7 +430,7 @@
     }
 
     @Override
-    public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isLessThanOrEqualTo(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return value <= ((Fixnum)obj).value;
@@ -448,7 +448,7 @@
     }
 
     @Override
-    public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isGreaterThanOrEqualTo(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return value >= ((Fixnum)obj).value;
@@ -466,7 +466,7 @@
     }
 
     @Override
-    public LispObject truncate(LispObject obj) throws ConditionThrowable
+    public LispObject truncate(LispObject obj)
     {
         // "When rationals and floats are combined by a numerical function,
         // the rational is first converted to a float of the same format."
@@ -579,7 +579,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (value == Double.POSITIVE_INFINITY) {
             FastStringBuffer sb = new FastStringBuffer("#.");
@@ -614,7 +614,7 @@
             return s1;
     }
 
-    public LispObject rational() throws ConditionThrowable
+    public LispObject rational()
     {
         final long bits = Double.doubleToRawLongBits(value);
         int sign = ((bits >> 63) == 0) ? 1 : -1;
@@ -641,7 +641,7 @@
         return number(numerator, denominator);
     }
 
-    public static DoubleFloat coerceToFloat(LispObject obj) throws ConditionThrowable
+    public static DoubleFloat coerceToFloat(LispObject obj)
     {
         if (obj instanceof DoubleFloat)
             return (DoubleFloat) obj;

Modified: trunk/abcl/src/org/armedbear/lisp/DowncaseStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/DowncaseStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/DowncaseStream.java	Fri Nov  6 15:07:54 2009
@@ -35,25 +35,25 @@
 
 public final class DowncaseStream extends CaseFrobStream
 {
-    public DowncaseStream(Stream target) throws ConditionThrowable
+    public DowncaseStream(Stream target)
     {
         super(target);
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         target._writeChar(LispCharacter.toLowerCase(c));
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         target._writeString(s.toLowerCase());
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         target._writeLine(s.toLowerCase());
     }

Modified: trunk/abcl/src/org/armedbear/lisp/EchoStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EchoStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EchoStream.java	Fri Nov  6 15:07:54 2009
@@ -54,7 +54,7 @@
     }
 
     @Override
-    public LispObject getElementType() throws ConditionThrowable
+    public LispObject getElementType()
     {
         LispObject itype = in.getElementType();
         LispObject otype = out.getElementType();
@@ -86,7 +86,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.ECHO_STREAM)
             return T;
@@ -108,32 +108,32 @@
     }
 
     @Override
-    public boolean isCharacterInputStream() throws ConditionThrowable
+    public boolean isCharacterInputStream()
     {
         return in.isCharacterInputStream();
     }
 
     @Override
-    public boolean isBinaryInputStream() throws ConditionThrowable
+    public boolean isBinaryInputStream()
     {
         return in.isBinaryInputStream();
     }
 
     @Override
-    public boolean isCharacterOutputStream() throws ConditionThrowable
+    public boolean isCharacterOutputStream()
     {
         return out.isCharacterOutputStream();
     }
 
     @Override
-    public boolean isBinaryOutputStream() throws ConditionThrowable
+    public boolean isBinaryOutputStream()
     {
         return out.isBinaryOutputStream();
     }
 
     // Returns -1 at end of file.
     @Override
-    protected int _readChar() throws ConditionThrowable, java.io.IOException
+    protected int _readChar() throws java.io.IOException
     {
         int n = in._readChar();
         if (n >= 0) {
@@ -147,46 +147,46 @@
     }
 
     @Override
-    protected void _unreadChar(int n) throws ConditionThrowable, java.io.IOException
+    protected void _unreadChar(int n) throws java.io.IOException
     {
         in._unreadChar(n);
         unreadChar = n;
     }
 
     @Override
-    protected boolean _charReady() throws ConditionThrowable, java.io.IOException
+    protected boolean _charReady() throws java.io.IOException
     {
         return in._charReady();
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         out._writeChar(c);
     }
 
     @Override
     public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
+
     {
         out._writeChars(chars, start, end);
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         out._writeString(s);
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         out._writeLine(s);
     }
 
     // Reads an 8-bit byte.
     @Override
-    public int _readByte() throws ConditionThrowable
+    public int _readByte()
     {
         int n = in._readByte();
         if (n >= 0)
@@ -196,25 +196,25 @@
 
     // Writes an 8-bit byte.
     @Override
-    public void _writeByte(int n) throws ConditionThrowable
+    public void _writeByte(int n)
     {
         out._writeByte(n);
     }
 
     @Override
-    public void _finishOutput() throws ConditionThrowable
+    public void _finishOutput()
     {
         out._finishOutput();
     }
 
     @Override
-    public void _clearInput() throws ConditionThrowable
+    public void _clearInput()
     {
         in._clearInput();
     }
 
     @Override
-    public LispObject close(LispObject abort) throws ConditionThrowable
+    public LispObject close(LispObject abort)
     {
         // "The effect of CLOSE on a constructed stream is to close the
         // argument stream only. There is no effect on the constituents of
@@ -224,13 +224,13 @@
     }
 
     @Override
-    public LispObject listen() throws ConditionThrowable
+    public LispObject listen()
     {
         return in.listen();
     }
 
     @Override
-    public LispObject freshLine() throws ConditionThrowable
+    public LispObject freshLine()
     {
         return out.freshLine();
     }
@@ -248,7 +248,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if (!(first instanceof Stream))
                 return type_error(first, Symbol.STREAM);
@@ -264,7 +264,7 @@
         new Primitive("echo-stream-input-stream", "echo-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof EchoStream)
                 return ((EchoStream)arg).getInputStream();
@@ -278,7 +278,7 @@
         new Primitive("echo-stream-output-stream", "echo-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof EchoStream)
                 return ((EchoStream)arg).getOutputStream();

Modified: trunk/abcl/src/org/armedbear/lisp/EndOfFile.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EndOfFile.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EndOfFile.java	Fri Nov  6 15:07:54 2009
@@ -35,13 +35,13 @@
 
 public final class EndOfFile extends StreamError
 {
-    public EndOfFile(Stream stream) throws ConditionThrowable
+    public EndOfFile(Stream stream)
     {
         super(StandardClass.END_OF_FILE);
         setStream(stream);
     }
 
-    public EndOfFile(LispObject initArgs) throws ConditionThrowable
+    public EndOfFile(LispObject initArgs)
     {
         super(StandardClass.END_OF_FILE);
         initialize(initArgs);
@@ -60,7 +60,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.END_OF_FILE)
             return T;
@@ -70,7 +70,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         return unreadableString(Symbol.END_OF_FILE);
     }

Modified: trunk/abcl/src/org/armedbear/lisp/Environment.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Environment.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Environment.java	Fri Nov  6 15:07:54 2009
@@ -75,7 +75,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.ENVIRONMENT)
       return T;
@@ -140,7 +140,7 @@
   }
 
   public LispObject lookupFunction(LispObject name)
-    throws ConditionThrowable
+
   {
     FunctionBinding binding = lastFunctionBinding;
     if (name instanceof Symbol)
@@ -214,7 +214,7 @@
 
   // Returns body with declarations removed.
   public LispObject processDeclarations(LispObject body)
-    throws ConditionThrowable
+
   {
     LispObject bodyAndDecls = parseBody(body, false);
     LispObject specials = parseSpecials(bodyAndDecls.NTH(1));
@@ -243,7 +243,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     return unreadableString(Symbol.ENVIRONMENT);
   }
@@ -259,7 +259,7 @@
         return new Environment();
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg == NIL)
           return new Environment();
@@ -275,7 +275,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         Environment env = checkEnvironment(first);
         LispObject name = second;
@@ -293,7 +293,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         checkEnvironment(first).addFunctionBinding(second, third);
         return first;
@@ -308,7 +308,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         checkEnvironment(first).bind(checkSymbol(second), third);
         return first;
@@ -320,7 +320,7 @@
     new Primitive("empty-environment-p", PACKAGE_SYS, true, "environment")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkEnvironment(arg).isEmpty() ? T : NIL;
       }
@@ -331,7 +331,7 @@
     new Primitive("environment-variables", PACKAGE_SYS, true, "environment")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             Environment env = checkEnvironment(arg);
             LispObject result = NIL;
@@ -347,7 +347,7 @@
     new Primitive("environment-all-variables", PACKAGE_SYS, true, "environment")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             Environment env = checkEnvironment(arg);
             LispObject result = NIL;
@@ -366,7 +366,7 @@
     new Primitive("environment-all-functions", PACKAGE_SYS, true, "environment")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             Environment env = checkEnvironment(arg);
             LispObject result = NIL;

Modified: trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java	Fri Nov  6 15:07:54 2009
@@ -72,7 +72,7 @@
   }
 
   @Override
-  public void put(LispObject key, LispObject value) throws ConditionThrowable
+  public void put(LispObject key, LispObject value)
   {
     int index = key.sxhash() & mask;
     HashEntry e = buckets[index];
@@ -98,7 +98,7 @@
   }
 
   @Override
-  public LispObject remove(LispObject key) throws ConditionThrowable
+  public LispObject remove(LispObject key)
   {
     final int index = key.sxhash() & mask;
     HashEntry e = buckets[index];

Modified: trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java	Fri Nov  6 15:07:54 2009
@@ -70,7 +70,7 @@
   }
 
   @Override
-  public void put(LispObject key, LispObject value) throws ConditionThrowable
+  public void put(LispObject key, LispObject value)
   {
     int index = key.psxhash() % buckets.length;
     HashEntry e = buckets[index];
@@ -96,7 +96,7 @@
   }
 
   @Override
-  public LispObject remove(LispObject key) throws ConditionThrowable
+  public LispObject remove(LispObject key)
   {
     final int index = key.psxhash() % buckets.length;
     HashEntry e = buckets[index];

Modified: trunk/abcl/src/org/armedbear/lisp/Extensions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Extensions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Extensions.java	Fri Nov  6 15:07:54 2009
@@ -49,7 +49,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() != 2)
           return error(new WrongNumberOfArgumentsException(this));
@@ -63,7 +63,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first != second ? T : NIL;
       }
@@ -75,7 +75,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject list)
-        throws ConditionThrowable
+
       {
         while (list instanceof Cons)
           {
@@ -95,7 +95,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject list)
-        throws ConditionThrowable
+
       {
         while (list instanceof Cons)
           {
@@ -115,7 +115,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject list)
-        throws ConditionThrowable
+
       {
         return memql(item, list) ? list : new Cons(item, list);
       }
@@ -126,7 +126,7 @@
     new Primitive("special-variable-p", PACKAGE_EXT, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.isSpecialVariable() ? T : NIL;
       }
@@ -137,7 +137,7 @@
     new Primitive("source", PACKAGE_EXT, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return get(arg, Symbol._SOURCE, NIL);
       }
@@ -148,7 +148,7 @@
     new Primitive("source-file-position", PACKAGE_EXT, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         LispObject obj = get(arg, Symbol._SOURCE, NIL);
         if (obj instanceof Cons)
@@ -162,7 +162,7 @@
     new Primitive("source-pathname", PACKAGE_EXT, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         LispObject obj = get(arg, Symbol._SOURCE, NIL);
         if (obj instanceof Cons)
@@ -176,14 +176,14 @@
     new Primitive("exit", PACKAGE_EXT, true, "&key status")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         exit(0);
         return LispThread.currentThread().nothing();
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         int status = 0;
         if (first == Keyword.STATUS)
@@ -201,14 +201,14 @@
     new Primitive("quit", PACKAGE_EXT, true, "&key status")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         exit(0);
         return LispThread.currentThread().nothing();
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         int status = 0;
         if (first == Keyword.STATUS)
@@ -226,7 +226,7 @@
     new Primitive("dump-java-stack", PACKAGE_EXT, true)
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         Thread.dumpStack();
         return LispThread.currentThread().nothing();
@@ -238,7 +238,7 @@
     new Primitive("make-temp-file", PACKAGE_EXT, true, "")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         try
           {
@@ -259,7 +259,7 @@
     new Primitive("interrupt-lisp", PACKAGE_EXT, true, "")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         setInterrupted(true);
         return T;
@@ -271,7 +271,7 @@
       new Primitive("getenv", PACKAGE_EXT, true)
   {
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
       AbstractString string;
       if (arg instanceof AbstractString) {

Modified: trunk/abcl/src/org/armedbear/lisp/FaslReader.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FaslReader.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FaslReader.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored)
-            throws ConditionThrowable
+
         {
           try 
             {
@@ -68,7 +68,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char terminator)
-            throws ConditionThrowable
+
         {
             final Readtable rt = FaslReadtable.getInstance();
             FastStringBuffer sb = new FastStringBuffer();
@@ -133,7 +133,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored)
-            throws ConditionThrowable
+
         {
             return stream.readList(false, true);
         }
@@ -146,7 +146,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored)
-            throws ConditionThrowable
+
         {
             return error(new ReaderError("Unmatched right parenthesis.", stream));
         }
@@ -159,7 +159,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored)
-            throws ConditionThrowable
+
         {
             return new Cons(Symbol.QUOTE,
                             new Cons(stream.faslRead(true, NIL, true,
@@ -174,7 +174,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c)
-            throws ConditionThrowable
+
         {
             return stream.readDispatchChar(c, true);
         }
@@ -187,7 +187,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             LispObject list = stream.readList(true, true);
@@ -214,7 +214,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored, int n)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             final Readtable rt = FaslReadtable.getInstance();
@@ -285,7 +285,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             if (Symbol.READ_EVAL.symbolValue(thread) == NIL)
@@ -304,7 +304,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             LispThread thread = LispThread.currentThread();
             Symbol symbol = (Symbol) stream.readSymbol(FaslReadtable.getInstance());
@@ -323,7 +323,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.faslReadArray(n);
         }
@@ -336,7 +336,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.faslReadRadix(2);
         }
@@ -349,7 +349,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.faslReadComplex();
         }
@@ -362,7 +362,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.faslReadRadix(8);
         }
@@ -375,7 +375,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.faslReadPathname();
         }
@@ -388,7 +388,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.faslReadRadix(n);
         }
@@ -401,7 +401,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readStructure();
         }
@@ -414,7 +414,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.faslReadRadix(16);
         }
@@ -427,7 +427,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return new Cons(Symbol.FUNCTION,
                             new Cons(stream.faslRead(true, NIL, true,
@@ -442,7 +442,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readCharacterLiteral(FaslReadtable.getInstance(),
                                                LispThread.currentThread());
@@ -456,7 +456,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             stream.skipBalancedComment();
             return null;
@@ -470,7 +470,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             FastStringBuffer sb =
                 new FastStringBuffer("Illegal # macro character: #\\");

Modified: trunk/abcl/src/org/armedbear/lisp/FileError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FileError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FileError.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public final class FileError extends LispError
 {
     // initArgs is either a normal initArgs list or a pathname.
-    public FileError(LispObject initArgs) throws ConditionThrowable
+    public FileError(LispObject initArgs)
     {
         super(StandardClass.FILE_ERROR);
         if (initArgs instanceof Cons)
@@ -46,7 +46,7 @@
     }
 
     @Override
-    protected void initialize(LispObject initArgs) throws ConditionThrowable
+    protected void initialize(LispObject initArgs)
     {
         super.initialize(initArgs);
         LispObject pathname = NIL;
@@ -62,7 +62,7 @@
         setPathname(pathname);
     }
 
-    public FileError(String message) throws ConditionThrowable
+    public FileError(String message)
     {
         super(StandardClass.FILE_ERROR);
         setFormatControl(message);
@@ -70,7 +70,7 @@
     }
 
     public FileError(String message, LispObject pathname)
-        throws ConditionThrowable
+
     {
         super(StandardClass.FILE_ERROR);
         setFormatControl(message);
@@ -78,12 +78,12 @@
         setPathname(pathname);
     }
 
-    public LispObject getPathname() throws ConditionThrowable
+    public LispObject getPathname()
     {
         return getInstanceSlotValue(Symbol.PATHNAME);
     }
 
-    private void setPathname(LispObject pathname) throws ConditionThrowable
+    private void setPathname(LispObject pathname)
     {
         setInstanceSlotValue(Symbol.PATHNAME, pathname);
     }
@@ -101,7 +101,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.FILE_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/FileStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FileStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FileStream.java	Fri Nov  6 15:07:54 2009
@@ -146,7 +146,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.FILE_STREAM)
             return T;
@@ -161,7 +161,7 @@
     }
 
     @Override
-    public LispObject fileLength() throws ConditionThrowable
+    public LispObject fileLength()
     {
         final long length;
         if (isOpen()) {
@@ -189,7 +189,7 @@
     }
 
     @Override
-    protected void _unreadChar(int n) throws ConditionThrowable
+    protected void _unreadChar(int n)
     {
         try {
             racf.unreadChar((char)n);
@@ -200,13 +200,13 @@
     }
 
     @Override
-    protected boolean _charReady() throws ConditionThrowable
+    protected boolean _charReady()
     {
         return true;
     }
 
     @Override
-    public void _clearInput() throws ConditionThrowable
+    public void _clearInput()
     {
         try {
 	    if (isInputStream) {
@@ -221,7 +221,7 @@
     }
 
     @Override
-    protected long _getFilePosition() throws ConditionThrowable
+    protected long _getFilePosition()
     {
         try {
             long pos = racf.position();
@@ -235,7 +235,7 @@
     }
 
     @Override
-    protected boolean _setFilePosition(LispObject arg) throws ConditionThrowable
+    protected boolean _setFilePosition(LispObject arg)
     {
         try {
             long pos;
@@ -256,7 +256,7 @@
     }
 
     @Override
-    public void _close() throws ConditionThrowable
+    public void _close()
     {
         try {
             racf.close();
@@ -268,7 +268,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         return unreadableString(Symbol.FILE_STREAM);
     }
@@ -282,7 +282,7 @@
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third, LispObject fourth,
                                   LispObject fifth, LispObject sixth)
-            throws ConditionThrowable
+
         {
             final Pathname pathname;
             if(first instanceof Pathname) {

Modified: trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java	Fri Nov  6 15:07:54 2009
@@ -53,7 +53,7 @@
         new Primitive("make-fill-pointer-output-stream", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof ComplexString) {
                 ComplexString string = (ComplexString) arg;

Modified: trunk/abcl/src/org/armedbear/lisp/Fixnum.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Fixnum.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Fixnum.java	Fri Nov  6 15:07:54 2009
@@ -109,7 +109,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type instanceof Symbol)
       {
@@ -268,13 +268,13 @@
   }
 
   @Override
-  public boolean evenp() throws ConditionThrowable
+  public boolean evenp()
   {
     return (value & 0x01) == 0;
   }
 
   @Override
-  public boolean oddp() throws ConditionThrowable
+  public boolean oddp()
   {
     return (value & 0x01) != 0;
   }
@@ -297,7 +297,7 @@
     return value == 0;
   }
 
-  public static int getValue(LispObject obj) throws ConditionThrowable
+  public static int getValue(LispObject obj)
   {
           if (obj instanceof Fixnum) return ((Fixnum)obj).value;
           type_error(obj, Symbol.FIXNUM);
@@ -315,7 +315,7 @@
     return (double)value;
   }
 
-  public static int getInt(LispObject obj) throws ConditionThrowable
+  public static int getInt(LispObject obj)
   {
           if (obj instanceof Fixnum) return ((Fixnum)obj).value;
           type_error(obj, Symbol.FIXNUM);
@@ -323,7 +323,7 @@
           return 0;
   }
 
-  public static BigInteger getBigInteger(LispObject obj) throws ConditionThrowable
+  public static BigInteger getBigInteger(LispObject obj)
   {
           if (obj instanceof Fixnum) return BigInteger.valueOf(((Fixnum)obj).value);
           type_error(obj, Symbol.FIXNUM);
@@ -373,7 +373,7 @@
   }
 
   @Override
-  public LispObject add(LispObject obj) throws ConditionThrowable
+  public LispObject add(LispObject obj)
   {
     if (obj instanceof Fixnum)
       {
@@ -408,7 +408,7 @@
   }
 
   @Override
-  public LispObject subtract(LispObject obj) throws ConditionThrowable
+  public LispObject subtract(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return number((long) value - ((Fixnum)obj).value);
@@ -443,7 +443,7 @@
   }
 
   @Override
-  public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
+  public LispObject multiplyBy(LispObject obj)
   {
     if (obj instanceof Fixnum)
       {
@@ -474,7 +474,7 @@
   }
 
   @Override
-  public LispObject divideBy(LispObject obj) throws ConditionThrowable
+  public LispObject divideBy(LispObject obj)
   {
     try
       {
@@ -528,7 +528,7 @@
   }
 
   @Override
-  public boolean isEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isEqualTo(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value == ((Fixnum)obj).value;
@@ -552,7 +552,7 @@
   }
 
   @Override
-  public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isNotEqualTo(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value != ((Fixnum)obj).value;
@@ -577,7 +577,7 @@
   }
 
   @Override
-  public boolean isLessThan(LispObject obj) throws ConditionThrowable
+  public boolean isLessThan(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value < ((Fixnum)obj).value;
@@ -598,13 +598,13 @@
   }
 
   @Override
-  public boolean isGreaterThan(int n) throws ConditionThrowable
+  public boolean isGreaterThan(int n)
   {
     return value > n;
   }
 
   @Override
-  public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
+  public boolean isGreaterThan(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value > ((Fixnum)obj).value;
@@ -631,7 +631,7 @@
   }
 
   @Override
-  public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isLessThanOrEqualTo(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value <= ((Fixnum)obj).value;
@@ -658,7 +658,7 @@
   }
 
   @Override
-  public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isGreaterThanOrEqualTo(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return value >= ((Fixnum)obj).value;
@@ -679,7 +679,7 @@
   }
 
   @Override
-  public LispObject truncate(LispObject obj) throws ConditionThrowable
+  public LispObject truncate(LispObject obj)
   {
     final LispThread thread = LispThread.currentThread();
     final LispObject value1, value2;
@@ -741,7 +741,7 @@
   }
 
   @Override
-  public LispObject MOD(LispObject divisor) throws ConditionThrowable
+  public LispObject MOD(LispObject divisor)
   {
     if (divisor instanceof Fixnum)
       return MOD(((Fixnum)divisor).value);
@@ -749,7 +749,7 @@
   }
 
   @Override
-  public LispObject MOD(int divisor) throws ConditionThrowable
+  public LispObject MOD(int divisor)
   {
     final int r;
     try
@@ -803,7 +803,7 @@
   }
 
   @Override
-  public LispObject ash(LispObject obj) throws ConditionThrowable
+  public LispObject ash(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return ash(((Fixnum)obj).value);
@@ -829,13 +829,13 @@
   }
 
   @Override
-  public LispObject LOGAND(int n) throws ConditionThrowable
+  public LispObject LOGAND(int n)
   {
     return Fixnum.getInstance(value & n);
   }
 
   @Override
-  public LispObject LOGAND(LispObject obj) throws ConditionThrowable
+  public LispObject LOGAND(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return Fixnum.getInstance(value & ((Fixnum)obj).value);
@@ -857,13 +857,13 @@
   }
 
   @Override
-  public LispObject LOGIOR(int n) throws ConditionThrowable
+  public LispObject LOGIOR(int n)
   {
     return Fixnum.getInstance(value | n);
   }
 
   @Override
-  public LispObject LOGIOR(LispObject obj) throws ConditionThrowable
+  public LispObject LOGIOR(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return Fixnum.getInstance(value | ((Fixnum)obj).value);
@@ -877,13 +877,13 @@
   }
 
   @Override
-  public LispObject LOGXOR(int n) throws ConditionThrowable
+  public LispObject LOGXOR(int n)
   {
     return Fixnum.getInstance(value ^ n);
   }
 
   @Override
-  public LispObject LOGXOR(LispObject obj) throws ConditionThrowable
+  public LispObject LOGXOR(LispObject obj)
   {
     if (obj instanceof Fixnum)
       return Fixnum.getInstance(value ^ ((Fixnum)obj).value);
@@ -908,7 +908,7 @@
 
   /** Computes fixnum^bignum, returning a fixnum or a bignum.
     */
-  public LispObject pow(LispObject obj) throws ConditionThrowable
+  public LispObject pow(LispObject obj)
   {
     BigInteger y = Bignum.getValue(obj);
 
@@ -949,7 +949,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     final LispThread thread = LispThread.currentThread();
     int base = Fixnum.getValue(Symbol.PRINT_BASE.symbolValue(thread));

Modified: trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
                       "&key traps")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length % 2 != 0)
                 error(new ProgramError("Odd number of keyword arguments."));
@@ -78,7 +78,7 @@
         new Primitive("get-floating-point-modes", PACKAGE_EXT, true, "")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             LispObject traps = NIL;
             if (TRAP_UNDERFLOW)
@@ -104,7 +104,7 @@
         // See also: http://paste.lisp.org/display/10847
 
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat) {
                 int bits =
@@ -149,7 +149,7 @@
         new Primitive("%float-bits", PACKAGE_SYS, true, "integer")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat) {
                 int bits = Float.floatToIntBits(((SingleFloat)arg).value);
@@ -170,7 +170,7 @@
         new Primitive("rational", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat)
                 return ((SingleFloat)arg).rational();
@@ -188,7 +188,7 @@
         new Primitive("float-radix", "float")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat || arg instanceof DoubleFloat)
                 return Fixnum.TWO;
@@ -205,7 +205,7 @@
         new Primitive("float-digits", "float")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat)
                 return FIXNUM_24;
@@ -221,7 +221,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if (first instanceof SingleFloat) {
                 float f = ((SingleFloat)first).value;
@@ -242,7 +242,7 @@
         new Primitive("coerce-to-single-float", PACKAGE_SYS, false)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return SingleFloat.coerceToFloat(arg);
         }
@@ -253,7 +253,7 @@
         new Primitive("coerce-to-double-float", PACKAGE_SYS, false)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return DoubleFloat.coerceToFloat(arg);
         }
@@ -265,7 +265,7 @@
         new Primitive("float", "number &optional prototype")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat || arg instanceof DoubleFloat)
                 return arg;
@@ -273,7 +273,7 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if (second instanceof SingleFloat)
                 return SingleFloat.coerceToFloat(first);
@@ -288,7 +288,7 @@
     private static final Primitive FLOATP = new Primitive("floatp", "object")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat)
                 return T;
@@ -303,7 +303,7 @@
         new Primitive("single-float-bits", PACKAGE_SYS, true, "float")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat) {
                 SingleFloat f = (SingleFloat) arg;
@@ -318,7 +318,7 @@
         new Primitive("double-float-high-bits", PACKAGE_SYS, true, "float")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof DoubleFloat) {
                 DoubleFloat f = (DoubleFloat) arg;
@@ -333,7 +333,7 @@
         new Primitive("double-float-low-bits", PACKAGE_SYS, true, "float")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof DoubleFloat) {
                 DoubleFloat f = (DoubleFloat) arg;
@@ -349,7 +349,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof Fixnum) {
                 int bits = ((Fixnum)arg).value;
@@ -369,7 +369,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof Fixnum) {
                 long bits = (long) ((Fixnum)arg).value;
@@ -389,7 +389,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof SingleFloat)
                 return Float.isInfinite(((SingleFloat)arg).value) ? T : NIL;
@@ -405,7 +405,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof SingleFloat)
                 return Float.isNaN(((SingleFloat)arg).value) ? T : NIL;
@@ -420,7 +420,7 @@
         new Primitive("float-string", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             final String s1;
             if (arg instanceof SingleFloat)

Modified: trunk/abcl/src/org/armedbear/lisp/FloatingPointInexact.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatingPointInexact.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatingPointInexact.java	Fri Nov  6 15:07:54 2009
@@ -35,7 +35,7 @@
 
 public final class FloatingPointInexact extends ArithmeticError
 {
-    public FloatingPointInexact(LispObject initArgs) throws ConditionThrowable
+    public FloatingPointInexact(LispObject initArgs)
     {
         super(StandardClass.FLOATING_POINT_INEXACT);
         initialize(initArgs);
@@ -54,7 +54,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.FLOATING_POINT_INEXACT)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/FloatingPointInvalidOperation.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatingPointInvalidOperation.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatingPointInvalidOperation.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public final class FloatingPointInvalidOperation extends ArithmeticError
 {
     public FloatingPointInvalidOperation(LispObject initArgs)
-        throws ConditionThrowable
+
     {
         super(StandardClass.FLOATING_POINT_INVALID_OPERATION);
         initialize(initArgs);
@@ -55,7 +55,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.FLOATING_POINT_INVALID_OPERATION)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/FloatingPointOverflow.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatingPointOverflow.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatingPointOverflow.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public final class FloatingPointOverflow extends ArithmeticError
 {
     public FloatingPointOverflow(LispObject initArgs)
-        throws ConditionThrowable
+
     {
         super(StandardClass.FLOATING_POINT_OVERFLOW);
         initialize(initArgs);
@@ -55,7 +55,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.FLOATING_POINT_OVERFLOW)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/FloatingPointUnderflow.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatingPointUnderflow.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatingPointUnderflow.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public final class FloatingPointUnderflow extends ArithmeticError
 {
     public FloatingPointUnderflow(LispObject initArgs)
-        throws ConditionThrowable
+
     {
         super(StandardClass.FLOATING_POINT_UNDERFLOW);
         initialize(initArgs);
@@ -55,7 +55,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.FLOATING_POINT_UNDERFLOW)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java	Fri Nov  6 15:07:54 2009
@@ -53,7 +53,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.FORWARD_REFERENCED_CLASS)
             return T;
@@ -63,7 +63,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         StringBuffer sb =
             new StringBuffer(Symbol.FORWARD_REFERENCED_CLASS.writeToString());
@@ -80,7 +80,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof Symbol) {
                 Symbol name = (Symbol) arg;

Modified: trunk/abcl/src/org/armedbear/lisp/Function.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Function.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Function.java	Fri Nov  6 15:07:54 2009
@@ -150,7 +150,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.FUNCTION)
             return T;
@@ -177,27 +177,27 @@
         propertyList = obj;
     }
 
-    public final void setClassBytes(byte[] bytes) throws ConditionThrowable
+    public final void setClassBytes(byte[] bytes)
     {
         propertyList = putf(propertyList, Symbol.CLASS_BYTES,
                             new JavaObject(bytes));
     }
 
     @Override
-    public LispObject execute() throws ConditionThrowable
+    public LispObject execute()
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
@@ -205,7 +205,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third)
-        throws ConditionThrowable
+
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
@@ -213,7 +213,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
@@ -222,7 +222,7 @@
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth,
                               LispObject fifth)
-        throws ConditionThrowable
+
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
@@ -231,7 +231,7 @@
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth)
-        throws ConditionThrowable
+
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
@@ -241,7 +241,7 @@
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth,
                               LispObject seventh)
-        throws ConditionThrowable
+
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
@@ -251,19 +251,19 @@
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth,
                               LispObject seventh, LispObject eighth)
-        throws ConditionThrowable
+
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         return error(new WrongNumberOfArgumentsException(this));
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         LispObject name = getLambdaName();
         if (name != null && name != NIL) {
@@ -302,7 +302,7 @@
     }
 
     // Used by the JVM compiler.
-    public final void argCountError() throws ConditionThrowable
+    public final void argCountError()
     {
         error(new WrongNumberOfArgumentsException(this));
     }

Modified: trunk/abcl/src/org/armedbear/lisp/GenericFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/GenericFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/GenericFunction.java	Fri Nov  6 15:07:54 2009
@@ -41,7 +41,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.GENERIC_FUNCTION)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/Go.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Go.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Go.java	Fri Nov  6 15:07:54 2009
@@ -55,7 +55,7 @@
     }
 
     @Override
-    public LispObject getCondition() throws ConditionThrowable
+    public LispObject getCondition()
     {
         try {
             StringBuffer sb = new StringBuffer("No tag named ");

Modified: trunk/abcl/src/org/armedbear/lisp/HashTable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/HashTable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/HashTable.java	Fri Nov  6 15:07:54 2009
@@ -112,7 +112,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.HASH_TABLE)
       return T;
@@ -122,7 +122,7 @@
   }
 
   @Override
-  public boolean equalp(LispObject obj) throws ConditionThrowable
+  public boolean equalp(LispObject obj)
   {
     if (this == obj)
       return true;
@@ -149,7 +149,7 @@
   }
 
   @Override
-  public LispObject getParts() throws ConditionThrowable
+  public LispObject getParts()
   {
     LispObject parts = NIL;
     for (int i = 0; i < buckets.length; i++)
@@ -174,7 +174,7 @@
 
   // gethash key hash-table &optional default => value, present-p
   public synchronized LispObject gethash(LispObject key)
-    throws ConditionThrowable
+
   {
     LispObject value = get(key);
     final LispObject presentp;
@@ -188,7 +188,7 @@
   // gethash key hash-table &optional default => value, present-p
   public synchronized LispObject gethash(LispObject key,
                                          LispObject defaultValue)
-    throws ConditionThrowable
+
   {
     LispObject value = get(key);
     final LispObject presentp;
@@ -203,14 +203,14 @@
   }
 
   public synchronized LispObject gethash1(LispObject key)
-    throws ConditionThrowable
+
   {
     final LispObject value = get(key);
     return value != null ? value : NIL;
   }
 
   public synchronized LispObject puthash(LispObject key, LispObject newValue)
-    throws ConditionThrowable
+
   {
     put(key, newValue);
     return newValue;
@@ -218,14 +218,14 @@
 
   // remhash key hash-table => generalized-boolean
   public synchronized LispObject remhash(LispObject key)
-    throws ConditionThrowable
+
   {
     // A value in a Lisp hash table can never be null, so...
     return remove(key) != null ? T : NIL;
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     if (Symbol.PRINT_READABLY.symbolValue(LispThread.currentThread()) != NIL)
       {
@@ -250,9 +250,9 @@
   public abstract LispObject get(LispObject key);
 
   public abstract void put(LispObject key, LispObject value)
-    throws ConditionThrowable;
+   ;
 
-  public abstract LispObject remove(LispObject key) throws ConditionThrowable;
+  public abstract LispObject remove(LispObject key);
 
   protected abstract void rehash();
 
@@ -272,7 +272,7 @@
     return list;
   }
 
-  public LispObject MAPHASH(LispObject function) throws ConditionThrowable
+  public LispObject MAPHASH(LispObject function)
   {
     for (int i = buckets.length; i-- > 0;)
       {

Modified: trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java	Fri Nov  6 15:07:54 2009
@@ -51,7 +51,7 @@
       @Override
       public LispObject execute(LispObject test, LispObject size,
                                 LispObject rehashSize, LispObject rehashThreshold)
-        throws ConditionThrowable
+
       {
         final int n = Fixnum.getValue(size);
         if (test == FUNCTION_EQL || test == NIL)
@@ -73,7 +73,7 @@
     {
       @Override
       public LispObject execute(LispObject key, LispObject ht)
-        throws ConditionThrowable
+
       {
           return checkHashTable(ht).gethash(key);
       }
@@ -81,7 +81,7 @@
       @Override
       public LispObject execute(LispObject key, LispObject ht,
                                 LispObject defaultValue)
-        throws ConditionThrowable
+
       {
           return checkHashTable(ht).gethash(key, defaultValue);
       }
@@ -93,7 +93,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final HashTable ht = checkHashTable(second);
         synchronized (ht)
@@ -112,14 +112,14 @@
       @Override
       public LispObject execute(LispObject key, LispObject ht,
                                 LispObject value)
-        throws ConditionThrowable
+
       {
           return checkHashTable(ht).puthash(key, value);
       }
       @Override
       public LispObject execute(LispObject key, LispObject ht,
                                 LispObject ignored, LispObject value)
-        throws ConditionThrowable
+
       {
           return checkHashTable(ht).puthash(key, value);
       }
@@ -131,7 +131,7 @@
     {
       @Override
       public LispObject execute(LispObject key, LispObject ht)
-        throws ConditionThrowable
+
       {
             return checkHashTable(ht).remhash(key);
       }
@@ -142,7 +142,7 @@
     new Primitive(Symbol.CLRHASH, "hash-table")
     {
       @Override
-      public LispObject execute(LispObject ht) throws ConditionThrowable
+      public LispObject execute(LispObject ht)
       {
           checkHashTable(ht).clear();
           return ht;
@@ -154,7 +154,7 @@
     new Primitive(Symbol.HASH_TABLE_COUNT, "hash-table")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return Fixnum.getInstance(checkHashTable(arg).getCount());
       }
@@ -165,7 +165,7 @@
     new Primitive(Symbol.SXHASH, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Fixnum.getInstance(arg.sxhash());
       }
@@ -177,7 +177,7 @@
     new Primitive("psxhash", PACKAGE_SYS, true, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Fixnum.getInstance(arg.psxhash());
       }
@@ -188,7 +188,7 @@
     new Primitive(Symbol.HASH_TABLE_P,"object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof HashTable ? T : NIL;
       }
@@ -199,7 +199,7 @@
     new Primitive("hash-table-entries", PACKAGE_SYS, false)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkHashTable(arg).ENTRIES();
       }
@@ -210,7 +210,7 @@
     new Primitive(Symbol.HASH_TABLE_TEST, "hash-table")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkHashTable(arg).getTest();
       }
@@ -221,7 +221,7 @@
     new Primitive(Symbol.HASH_TABLE_SIZE, "hash-table")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return Fixnum.getInstance(checkHashTable(arg).getSize());
       }
@@ -232,7 +232,7 @@
     new Primitive(Symbol.HASH_TABLE_REHASH_SIZE, "hash-table")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkHashTable(arg).getRehashSize();
       }
@@ -243,7 +243,7 @@
     new Primitive(Symbol.HASH_TABLE_REHASH_THRESHOLD, "hash-table")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkHashTable(arg).getRehashThreshold();
       }
@@ -255,13 +255,13 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return checkHashTable(second).MAPHASH(first);
       }
     };
 
-protected static HashTable checkHashTable(LispObject ht) throws ConditionThrowable {
+protected static HashTable checkHashTable(LispObject ht) {
         if (ht instanceof HashTable) return (HashTable)ht;
     type_error(ht, Symbol.HASH_TABLE);    
         return null;

Modified: trunk/abcl/src/org/armedbear/lisp/IllegalMonitorState.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/IllegalMonitorState.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/IllegalMonitorState.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public final class IllegalMonitorState extends ProgramError
 {
     public IllegalMonitorState()
-        throws ConditionThrowable
+
     {
         // This is really just an ordinary PROGRAM-ERROR, broken out into its
         // own Java class as a convenience for the implementation.

Modified: trunk/abcl/src/org/armedbear/lisp/Interpreter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Interpreter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Interpreter.java	Fri Nov  6 15:07:54 2009
@@ -151,7 +151,7 @@
     }
 
     // Interface.
-    public LispObject eval(String s) throws ConditionThrowable
+    public LispObject eval(String s)
     {
         return eval(new StringInputStream(s).read(true, NIL, false,
                                                   LispThread.currentThread()));
@@ -234,7 +234,7 @@
     // Check for --noinit; verify that arguments are supplied for --load and
     // --eval options.
     private static void preprocessCommandLineArguments(String[] args)
-        throws ConditionThrowable
+
     {
         if (args != null) {
             for (int i = 0; i < args.length; ++i) {
@@ -267,7 +267,7 @@
 
     // Do the --load and --eval actions.
     private static void postprocessCommandLineArguments(String[] args)
-        throws ConditionThrowable
+
     {
         if (args != null) {
             for (int i = 0; i < args.length; ++i) {
@@ -475,7 +475,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable, UnhandledCondition
+            throws UnhandledCondition
         {
             final Condition condition = (Condition) first;
             if (interpreter == null) {
@@ -528,11 +528,10 @@
      *
      * @param s A string with a valid Common Lisp expression
      * @return The result of the evaluation
-     * @throws org.armedbear.lisp.ConditionThrowable
      * @exception UnhandledCondition in case the an error occurs which
      *      should be passed to the Lisp debugger
      */
-    public static LispObject evaluate(String s) throws ConditionThrowable
+    public static LispObject evaluate(String s)
     {
         if (!initialized)
             initializeJLisp();

Modified: trunk/abcl/src/org/armedbear/lisp/JHandler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JHandler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JHandler.java	Fri Nov  6 15:07:54 2009
@@ -97,7 +97,7 @@
         new Primitive("%jregister-handler", PACKAGE_JAVA)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 5)
                 return error(new WrongNumberOfArgumentsException(this));

Modified: trunk/abcl/src/org/armedbear/lisp/JProxy.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JProxy.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JProxy.java	Fri Nov  6 15:07:54 2009
@@ -50,7 +50,7 @@
                   "interface &rest method-names-and-defs")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         int length = args.length;
         if (length < 3 || length % 2 != 1)
@@ -202,7 +202,7 @@
 	    new Primitive("%jmake-invocation-handler", PACKAGE_JAVA, false,
 	                  "function") {
 		
-	      	public LispObject execute(LispObject[] args) throws ConditionThrowable {
+	      	public LispObject execute(LispObject[] args) {
 	      		int length = args.length;
 	      		if (length != 1) {
 	      			return error(new WrongNumberOfArgumentsException(this));
@@ -218,7 +218,7 @@
 	    new Primitive("%jmake-proxy", PACKAGE_JAVA, false,
 	                  "interface invocation-handler") {
 		
-	      	public LispObject execute(final LispObject[] args) throws ConditionThrowable {
+	      	public LispObject execute(final LispObject[] args) {
 	      		int length = args.length;
 	      		if (length != 3) {
 	      			return error(new WrongNumberOfArgumentsException(this));

Modified: trunk/abcl/src/org/armedbear/lisp/Java.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Java.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Java.java	Fri Nov  6 15:07:54 2009
@@ -53,7 +53,7 @@
 
     private static final LispClass java_exception = LispClass.findClass(Symbol.JAVA_EXCEPTION);
 
-    private static boolean isJavaException(LispClass lc) throws ConditionThrowable
+    private static boolean isJavaException(LispClass lc)
     {
         return lc.subclassp(java_exception);
     }
@@ -65,7 +65,7 @@
     {
         @Override
         public LispObject execute(LispObject className, LispObject symbol)
-            throws ConditionThrowable
+
         {
             // FIXME Verify that CONDITION-SYMBOL is a symbol that names a condition.
             // FIXME Signal a continuable error if the exception is already registered.
@@ -85,14 +85,14 @@
     {
         @Override
         public LispObject execute(LispObject className)
-            throws ConditionThrowable
+
         {
             // FIXME Verify that EXCEPTION-NAME designates a subclass of Throwable.
             return registeredExceptions.remove(classForName(className.getStringValue())) == null ? NIL : T;
         }
     };
 
-    private static Symbol getCondition(Class cl) throws ConditionThrowable
+    private static Symbol getCondition(Class cl)
     {
 	Class o = classForName("java.lang.Object");
      	for (Class c = cl ; c != o ; c = c.getSuperclass()) {
@@ -110,7 +110,7 @@
 "Returns a reference to the Java class designated by NAME-OR-CLASS-REF.")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return JavaObject.getInstance(javaClass(arg));
         }
@@ -146,7 +146,7 @@
     //
 
     private static final LispObject jfield(Primitive fun, LispObject[] args, boolean translate)
-            throws ConditionThrowable
+
     {
         if (args.length < 2 || args.length > 4)
             error(new WrongNumberOfArgumentsException(fun));
@@ -225,7 +225,7 @@
                       "class-ref-or-field field-or-instance &optional instance value")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             return jfield(this, args, true);
         }
@@ -237,7 +237,7 @@
                       "class-ref-or-field field-or-instance &optional instance value")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             return jfield(this, args, false);
         }
@@ -249,7 +249,7 @@
                       "class-ref &rest parameter-class-refs")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 1)
                 error(new WrongNumberOfArgumentsException(this));
@@ -294,7 +294,7 @@
                       "class-ref name &rest parameter-class-refs")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 2)
                 error(new WrongNumberOfArgumentsException(this));
@@ -347,7 +347,7 @@
     };
 
     private static final LispObject jstatic(Primitive fun, LispObject[] args, boolean translate)
-            throws ConditionThrowable
+
     {
         if (args.length < 2)
             error(new WrongNumberOfArgumentsException(fun));
@@ -414,7 +414,7 @@
         new Primitive("jstatic", PACKAGE_JAVA, true, "method class &rest args")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             return jstatic(this, args, true);
         }
@@ -426,7 +426,7 @@
                       "method class &rest args")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             return jstatic(this, args, false);
         }
@@ -437,7 +437,7 @@
         new Primitive("jnew", PACKAGE_JAVA, true, "constructor &rest args")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 1)
                 error(new WrongNumberOfArgumentsException(this));
@@ -481,7 +481,7 @@
                       "element-type &rest dimensions")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 2)
                 error(new WrongNumberOfArgumentsException(this));
@@ -501,7 +501,7 @@
     };
 
     private static final LispObject jarray_ref(Primitive fun, LispObject[] args, boolean translate)
-            throws ConditionThrowable
+
     {
         if (args.length < 2)
             error(new WrongNumberOfArgumentsException(fun));
@@ -534,7 +534,7 @@
                       "java-array &rest indices")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             return jarray_ref(this, args, true);
         }
@@ -546,7 +546,7 @@
                       "java-array &rest indices")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             return jarray_ref(this, args, false);
         }
@@ -558,7 +558,7 @@
                       "java-array new-value &rest indices")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 3)
                 error(new WrongNumberOfArgumentsException(this));
@@ -593,7 +593,7 @@
         new Primitive(Symbol.JCALL, "method-ref instance &rest args")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             return jcall(this, args, true);
         }
@@ -606,14 +606,14 @@
         new Primitive(Symbol.JCALL_RAW, "method-ref instance &rest args")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             return jcall(this, args, false);
         }
     };
 
     private static LispObject jcall(Primitive fun, LispObject[] args, boolean translate)
-            throws ConditionThrowable
+
     {
         if (args.length < 2)
             error(new WrongNumberOfArgumentsException(fun));
@@ -689,7 +689,7 @@
                       "object &optional type")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 1)
                 error(new WrongNumberOfArgumentsException(this));
@@ -726,7 +726,7 @@
         new Primitive("java-object-p", PACKAGE_JAVA, true, "object")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return (arg instanceof JavaObject) ? T : NIL;
         }
@@ -737,7 +737,7 @@
         new Primitive("jobject-lisp-value", PACKAGE_JAVA, true, "java-object")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return JavaObject.getInstance(arg.javaInstance(), true);
         }
@@ -748,7 +748,7 @@
 	                  "java-object property-name") {
     	
         @Override
-        public LispObject execute(LispObject javaObject, LispObject propertyName) throws ConditionThrowable {
+        public LispObject execute(LispObject javaObject, LispObject propertyName) {
 			try {
 				Object obj = javaObject.javaInstance();
 				PropertyDescriptor pd = getPropertyDescriptor(obj, propertyName);
@@ -771,7 +771,7 @@
 	                  "java-object property-name value") {
     	
         @Override
-        public LispObject execute(LispObject javaObject, LispObject propertyName, LispObject value) throws ConditionThrowable {
+        public LispObject execute(LispObject javaObject, LispObject propertyName, LispObject value) {
 	    Object obj = null;
 	    try {
 		obj = javaObject.javaInstance();
@@ -796,7 +796,7 @@
         }
     };
     
-    private static PropertyDescriptor getPropertyDescriptor(Object obj, LispObject propertyName) throws ConditionThrowable, IntrospectionException {
+    private static PropertyDescriptor getPropertyDescriptor(Object obj, LispObject propertyName) throws IntrospectionException {
         String prop = ((AbstractString) propertyName).getStringValue();
         BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
         for(PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) {
@@ -809,7 +809,7 @@
         return null; // not reached
     }
     
-    private static Class classForName(String className) throws ConditionThrowable
+    private static Class classForName(String className)
     {
         try {
             return Class.forName(className);
@@ -827,7 +827,7 @@
     }
 
     // Supports Java primitive types too.
-    private static Class javaClass(LispObject obj) throws ConditionThrowable
+    private static Class javaClass(LispObject obj)
     {
         if (obj instanceof AbstractString || obj instanceof Symbol) {
             String s = javaString(obj);

Modified: trunk/abcl/src/org/armedbear/lisp/JavaClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaClass.java	Fri Nov  6 15:07:54 2009
@@ -84,7 +84,7 @@
 		return StandardClass.JAVA_CLASS;
 	}
 
-	public LispObject typep(LispObject type) throws ConditionThrowable {
+	public LispObject typep(LispObject type) {
 		if (type == Symbol.JAVA_CLASS)
 			return T;
 		if (type == StandardClass.JAVA_CLASS)
@@ -92,11 +92,11 @@
 		return super.typep(type);
 	}
 
-	public LispObject getDescription() throws ConditionThrowable {
+	public LispObject getDescription() {
 		return new SimpleString(writeToString());
 	}
 
-	public String writeToString() throws ConditionThrowable {
+	public String writeToString() {
 		FastStringBuffer sb = new FastStringBuffer("#<JAVA-CLASS ");
 		sb.append(javaClass.getCanonicalName());
 		sb.append('>');
@@ -119,7 +119,7 @@
 		return javaClass;
 	}
 
-	public boolean subclassp(LispObject obj) throws ConditionThrowable {
+	public boolean subclassp(LispObject obj) {
 		if(obj == BuiltInClass.CLASS_T) {
 			return true;
 		}
@@ -134,7 +134,7 @@
 
 	private static final Primitive _FIND_JAVA_CLASS = new Primitive(
 			"%find-java-class", PACKAGE_JAVA, false, "string") {
-		public LispObject execute(LispObject arg) throws ConditionThrowable {
+		public LispObject execute(LispObject arg) {
 		    try {
 			return findJavaClass(Class.forName((String) arg.getStringValue()));
 		    } catch (ClassNotFoundException e) {

Modified: trunk/abcl/src/org/armedbear/lisp/JavaException.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaException.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaException.java	Fri Nov  6 15:07:54 2009
@@ -40,7 +40,7 @@
 {
     private final Throwable throwable;
 
-    public JavaException(Throwable throwable) throws ConditionThrowable
+    public JavaException(Throwable throwable)
     {
         super(StandardClass.JAVA_EXCEPTION);
         Debug.assertTrue(slots.length == 3);
@@ -62,7 +62,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.JAVA_EXCEPTION)
             return T;
@@ -91,7 +91,7 @@
 "  object that caused JAVA-EXCEPTION to be signalled.)")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return Symbol.STD_SLOT_VALUE.execute(arg, Symbol.CAUSE);
         }

Modified: trunk/abcl/src/org/armedbear/lisp/JavaObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaObject.java	Fri Nov  6 15:07:54 2009
@@ -65,7 +65,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.JAVA_OBJECT)
             return T;
@@ -108,7 +108,7 @@
      * @return a LispObject representing or encapsulating obj
      */
     public final static LispObject getInstance(Object obj, boolean translated)
-            throws ConditionThrowable
+
     {
         if (! translated)
             return getInstance(obj);
@@ -175,7 +175,7 @@
     }
 
     @Override
-    public Object javaInstance(Class c) throws ConditionThrowable {
+    public Object javaInstance(Class c) {
 	return javaInstance();
     }
 
@@ -190,7 +190,7 @@
     }
 
     public static final Object getObject(LispObject o)
-        throws ConditionThrowable
+
     {
         if (o instanceof JavaObject)
                 return ((JavaObject)o).obj;        
@@ -221,7 +221,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (obj instanceof ConditionThrowable)
             return obj.toString();
@@ -245,12 +245,12 @@
     }
 
     @Override
-    public LispObject getDescription() throws ConditionThrowable {
+    public LispObject getDescription() {
 	return new SimpleString(describeJavaObject(this));
     }
 
     @Override
-    public LispObject getParts() throws ConditionThrowable {
+    public LispObject getParts() {
 	if(obj != null) {
 	    LispObject parts = NIL;
 	    if(obj.getClass().isArray()) {
@@ -273,12 +273,12 @@
     }
 
     private LispObject getInspectedFields()
-	throws ConditionThrowable {
+	{
 	final LispObject[] acc = new LispObject[] { NIL };
 	doClassHierarchy(obj.getClass(), new Function() {
 		@Override
 		public LispObject execute(LispObject arg)
-		    throws ConditionThrowable {
+		    {
 		    //No possibility of type error - we're mapping this function
 		    //over a list of classes
 		    Class<?> c = (Class) arg.javaInstance();
@@ -305,7 +305,7 @@
     private static void doClassHierarchy(Collection<Class<?>> classes,
 					 LispObject callback,
 					 Set<Class<?>> visited)
-	throws ConditionThrowable {
+	{
 	Collection<Class<?>> newClasses = new LinkedList<Class<?>>();
 	for(Class<?> clss : classes) {
 	    if(clss == null) {
@@ -334,7 +334,7 @@
      * interfaces.
      */
     public static void doClassHierarchy(Class<?> clss, LispObject callback)
-	throws ConditionThrowable {
+	{
 	if (clss != null) {
 	    Set<Class<?>> visited = new HashSet<Class<?>>();
 	    Collection<Class<?>> classes = new ArrayList<Class<?>>(1);
@@ -345,12 +345,12 @@
 
     public static LispObject mapcarClassHierarchy(Class<?> clss,
 						  final LispObject fn)
-    throws ConditionThrowable {
+    {
 	final LispObject[] acc = new LispObject[] { NIL };
 	doClassHierarchy(clss, new Function() {
 		@Override
 		public LispObject execute(LispObject arg)
-		    throws ConditionThrowable {
+		    {
 		    acc[0] = acc[0].push(fn.execute(arg));
 		    return acc[0];
 		}
@@ -359,7 +359,7 @@
     }
 
     public static String describeJavaObject(final JavaObject javaObject)
-	throws ConditionThrowable {
+	{
 	final Object obj = javaObject.getObject();
 	final FastStringBuffer sb =
 	    new FastStringBuffer(javaObject.writeToString());
@@ -423,7 +423,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if (!(first instanceof JavaObject))
                 return type_error(first, Symbol.JAVA_OBJECT);

Modified: trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java	Fri Nov  6 15:07:54 2009
@@ -69,7 +69,7 @@
 
   @Override
   public LispObject typep(LispObject typeSpecifier) 
-     throws ConditionThrowable
+
   {
      if (typeSpecifier == Symbol.JAVA_STACK_FRAME)
        return T;
@@ -84,7 +84,7 @@
   static final Symbol LINE = Packages.internKeyword("LINE");
   static final Symbol NATIVE_METHOD = Packages.internKeyword("NATIVE-METHOD");
 
-  public LispObject toLispList() throws ConditionThrowable
+  public LispObject toLispList()
   {
     LispObject result = Lisp.NIL;
     
@@ -109,14 +109,14 @@
 
   @Override
   public SimpleString toLispString() 
-    throws ConditionThrowable 
+
   {
     return new SimpleString(javaFrame.toString());
   }
 
   @Override
   public LispObject getParts() 
-    throws ConditionThrowable
+
   { 
     LispObject result = NIL;
     result = result.push(new Cons("CLASS", 

Modified: trunk/abcl/src/org/armedbear/lisp/Layout.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Layout.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Layout.java	Fri Nov  6 15:07:54 2009
@@ -104,7 +104,7 @@
   }
 
   @Override
-  public LispObject getParts() throws ConditionThrowable
+  public LispObject getParts()
   {
     LispObject result = NIL;
     result = result.push(new Cons("class", lispClass));
@@ -142,7 +142,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     return unreadableString(Symbol.LAYOUT);
   }
@@ -172,7 +172,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
           return new Layout(checkClass(first), checkList(second),
                               checkList(third));
@@ -185,7 +185,7 @@
     new Primitive("layout-class", PACKAGE_SYS, true, "layout")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkLayout(arg).lispClass;
       }
@@ -196,7 +196,7 @@
     new Primitive("layout-length", PACKAGE_SYS, true, "layout")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return Fixnum.getInstance(checkLayout(arg).slotNames.length);
       }
@@ -211,7 +211,7 @@
   }
 
   public LispObject getSharedSlotLocation(LispObject slotName)
-    throws ConditionThrowable
+
   {
     LispObject rest = sharedSlots;
     while (rest != NIL)
@@ -230,7 +230,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           final LispObject slotNames[] = checkLayout(first).slotNames;
           for (int i = slotNames.length; i-- > 0;)
@@ -248,7 +248,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
                 final Layout layOutFirst = checkLayout(first);
             final LispObject slotNames[] = layOutFirst.slotNames;
@@ -276,7 +276,7 @@
     new Primitive("%make-instances-obsolete", PACKAGE_SYS, true, "class")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final LispClass lispClass = checkClass(arg);
         Layout oldLayout = lispClass.getClassLayout();

Modified: trunk/abcl/src/org/armedbear/lisp/Lisp.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Lisp.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Lisp.java	Fri Nov  6 15:07:54 2009
@@ -155,7 +155,7 @@
   // args must not be null!
   public static final LispObject funcall(LispObject fun, LispObject[] args,
                                          LispThread thread)
-    throws ConditionThrowable
+
   {
     thread._values = null;
 
@@ -194,7 +194,7 @@
   public static final LispObject macroexpand(LispObject form,
                                              final Environment env,
                                              final LispThread thread)
-    throws ConditionThrowable
+
   {
     LispObject expanded = NIL;
     while (true)
@@ -213,7 +213,7 @@
   public static final LispObject macroexpand_1(final LispObject form,
                                                final Environment env,
                                                final LispThread thread)
-    throws ConditionThrowable
+
   {
     if (form instanceof Cons)
       {
@@ -272,7 +272,7 @@
     new Primitive("interactive-eval", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject object) throws ConditionThrowable
+      public LispObject execute(LispObject object)
       {
         final LispThread thread = LispThread.currentThread();
         thread.setSpecialVariable(Symbol.MINUS, object);
@@ -337,7 +337,7 @@
       }
     };
 
-  private static final void pushJavaStackFrames() throws ConditionThrowable
+  private static final void pushJavaStackFrames()
   {
       final LispThread thread = LispThread.currentThread();
       final StackTraceElement[] frames = thread.getJavaStackTrace();
@@ -360,14 +360,14 @@
 
 
   public static final LispObject error(LispObject condition)
-    throws ConditionThrowable
+
   {
     pushJavaStackFrames();
     return Symbol.ERROR.execute(condition);
   }
 
   public static final LispObject error(LispObject condition, LispObject message)
-    throws ConditionThrowable
+
   {
     pushJavaStackFrames();
     return Symbol.ERROR.execute(condition, Keyword.FORMAT_CONTROL, message);
@@ -375,7 +375,7 @@
 
   public static final LispObject type_error(LispObject datum,
                                             LispObject expectedType)
-    throws ConditionThrowable
+
   {
     return error(new TypeError(datum, expectedType));
   }
@@ -387,7 +387,7 @@
     interrupted = b;
   }
 
-  public static final void handleInterrupt() throws ConditionThrowable
+  public static final void handleInterrupt()
   {
     setInterrupted(false);
     Symbol.BREAK.getSymbolFunction().execute();
@@ -396,7 +396,7 @@
 
   // Used by the compiler.
   public static final LispObject loadTimeValue(LispObject obj)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     if (Symbol.LOAD_TRUENAME.symbolValue(thread) != NIL)
@@ -406,7 +406,7 @@
   }
 
   public static final LispObject eval(LispObject obj)
-    throws ConditionThrowable
+
   {
     return eval(obj, new Environment(), LispThread.currentThread());
   }
@@ -414,7 +414,7 @@
   public static final LispObject eval(final LispObject obj,
                                       final Environment env,
                                       final LispThread thread)
-    throws ConditionThrowable
+
   {
     thread._values = null;
     if (interrupted)
@@ -493,7 +493,7 @@
                                              LispObject args,
                                              Environment env,
                                              LispThread thread)
-    throws ConditionThrowable
+
   {
     if (args == NIL)
       return thread.execute(function);
@@ -578,7 +578,7 @@
 
   public static final LispObject parseBody(LispObject body,
                                            boolean documentationAllowed)
-    throws ConditionThrowable
+
   {
       LispObject decls = NIL;
       LispObject doc = NIL;
@@ -600,7 +600,7 @@
   }
 
   public static final LispObject parseSpecials(LispObject forms)
-    throws ConditionThrowable
+
   {
     LispObject specials = NIL;
     while (forms != NIL) {
@@ -631,7 +631,7 @@
 
   public static final LispObject progn(LispObject body, Environment env,
                                        LispThread thread)
-    throws ConditionThrowable
+
   {
     LispObject result = NIL;
     while (body != NIL)
@@ -644,7 +644,7 @@
 
   public static final LispObject preprocessTagBody(LispObject body,
                                                    Environment env)
-    throws ConditionThrowable
+
   {
     LispObject localTags = NIL; // Tags that are local to this TAGBODY.
     while (body != NIL)
@@ -668,7 +668,7 @@
    */
   public static final LispObject nonLocalGo(LispObject tagbody,
                                             LispObject tag)
-    throws ConditionThrowable
+
   {
     if (tagbody == null)
       return error(new ControlError("Unmatched tag "
@@ -686,7 +686,7 @@
    */
   public static final LispObject nonLocalGo(Binding binding,
                                             LispObject tag)
-    throws ConditionThrowable
+
   {
     if (binding.env.inactive)
       return error(new ControlError("Unmatched tag "
@@ -705,7 +705,7 @@
   public static final LispObject nonLocalReturn(LispObject blockId,
                                                 LispObject blockName,
                                                 LispObject result)
-    throws ConditionThrowable
+
   {
     if (blockId == null)
       return error(new ControlError("Unmatched block "
@@ -724,7 +724,7 @@
   public static final LispObject nonLocalReturn(Binding binding,
                                                 Symbol block,
                                                 LispObject result)
-    throws ConditionThrowable
+
   {
     if (binding == null)
       {
@@ -744,7 +744,7 @@
   public static final LispObject processTagBody(LispObject body,
                                                 LispObject localTags,
                                                 Environment env)
-    throws ConditionThrowable
+
   {
     LispObject remaining = body;
     LispThread thread = LispThread.currentThread();
@@ -802,7 +802,7 @@
   // Environment wrappers.
   private static final boolean isSpecial(Symbol sym, LispObject ownSpecials,
                                          Environment env)
-    throws ConditionThrowable
+
   {
     if (ownSpecials != null)
       {
@@ -820,7 +820,7 @@
   protected static final void bindArg(LispObject ownSpecials,
                                       Symbol sym, LispObject value,
                                       Environment env, LispThread thread)
-    throws ConditionThrowable
+
   {
     if (isSpecial(sym, ownSpecials, env)) {
       env.declareSpecial(sym);
@@ -947,7 +947,7 @@
 
   // Used by the compiler.
   public static final LispObject multipleValueList(LispObject result)
-    throws ConditionThrowable
+
   {
     LispThread thread = LispThread.currentThread();
     LispObject[] values = thread._values;
@@ -964,7 +964,7 @@
   public static final LispObject multipleValueCall1(LispObject result,
                                                     LispObject function,
                                                     LispThread thread)
-    throws ConditionThrowable
+
   {
     LispObject[] values = thread._values;
     thread._values = null;
@@ -977,7 +977,7 @@
   public static final void progvBindVars(LispObject symbols,
                                          LispObject values,
                                          LispThread thread)
-    throws ConditionThrowable
+
   {
     for (LispObject list = symbols; list != NIL; list = list.cdr())
       {
@@ -998,7 +998,7 @@
       }
   }
 
-  public static Symbol checkSymbol(LispObject obj) throws ConditionThrowable
+  public static Symbol checkSymbol(LispObject obj)
   {             
           if (obj instanceof Symbol)      
                   return (Symbol) obj;         
@@ -1007,7 +1007,7 @@
   }
 
   public static final LispObject checkList(LispObject obj)
-    throws ConditionThrowable
+
   {
     if (obj.listp())
       return obj;
@@ -1015,7 +1015,7 @@
   }
 
   public static final AbstractArray checkArray(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof AbstractArray)       
                   return (AbstractArray) obj;         
@@ -1024,7 +1024,7 @@
   }
 
   public static final AbstractVector checkVector(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof AbstractVector)      
                   return (AbstractVector) obj;         
@@ -1033,7 +1033,7 @@
   }
 
   public static final DoubleFloat checkDoubleFloat(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof DoubleFloat)
                   return (DoubleFloat) obj;
@@ -1042,7 +1042,7 @@
   }
 
   public static final SingleFloat checkSingleFloat(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof SingleFloat)
                   return (SingleFloat) obj;
@@ -1051,7 +1051,7 @@
   }
 
   public static final StackFrame checkStackFrame(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof StackFrame)      
                   return (StackFrame) obj;         
@@ -1066,13 +1066,13 @@
   }
 
   public static final Symbol gensym(LispThread thread)
-    throws ConditionThrowable
+
   {
     return gensym("G", thread);
   }
 
   public static final Symbol gensym(String prefix, LispThread thread)
-    throws ConditionThrowable
+
   {
     FastStringBuffer sb = new FastStringBuffer(prefix);
     SpecialBinding binding = thread.getSpecialBinding(Symbol.GENSYM_COUNTER);
@@ -1113,7 +1113,7 @@
   }
 
   public static final String javaString(LispObject arg)
-    throws ConditionThrowable
+
   {
     if (arg instanceof AbstractString)
       return arg.getStringValue();
@@ -1140,7 +1140,7 @@
 
   public static final LispObject number(BigInteger numerator,
                                         BigInteger denominator)
-    throws ConditionThrowable
+
   {
     if (denominator.signum() == 0)
       error(new DivisionByZero());
@@ -1170,7 +1170,7 @@
   }
 
   public static final int mod(int number, int divisor)
-    throws ConditionThrowable
+
   {
     final int r;
     try
@@ -1221,7 +1221,7 @@
   }
 
   public static final LispObject loadCompiledFunction(final String namestring)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     final boolean absolute = Utilities.isFilenameAbsolute(namestring);
@@ -1446,7 +1446,7 @@
 
   public static final LispObject makeCompiledClosure(LispObject template,
                                                      ClosureBinding[] context)
-    throws ConditionThrowable
+
   {
     return ((CompiledClosure)template).dup().setContext(context);
   }
@@ -1502,7 +1502,7 @@
     Bignum.getInstance(4294967296L);
 
   public static final LispObject getUpgradedArrayElementType(LispObject type)
-    throws ConditionThrowable
+
   {
     if (type instanceof Symbol)
       {
@@ -1605,7 +1605,7 @@
   }
 
   public static final byte coerceLispObjectToJavaByte(LispObject obj)
-    throws ConditionThrowable
+
   {
           return (byte)Fixnum.getValue(obj);
   }
@@ -1616,7 +1616,7 @@
   }
 
   public static final LispCharacter checkCharacter(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof LispCharacter) 
                   return (LispCharacter) obj;         
@@ -1625,7 +1625,7 @@
   }
 
   public static final Package checkPackage(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof Package)     
                   return (Package) obj;         
@@ -1634,7 +1634,7 @@
   }
 
   public static final Function checkFunction(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof Function)    
                   return (Function) obj;         
@@ -1643,7 +1643,7 @@
   }
 
   public static final Stream checkStream(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof Stream)      
                   return (Stream) obj;         
@@ -1652,7 +1652,7 @@
   }
 
   public static final Stream checkCharacterInputStream(LispObject obj)
-    throws ConditionThrowable
+
   {
           final Stream stream = checkStream(obj);
           if (stream.isCharacterInputStream())      
@@ -1663,7 +1663,7 @@
   }
 
   public static final Stream checkCharacterOutputStream(LispObject obj)
-    throws ConditionThrowable
+
   {
           final Stream stream = checkStream(obj);
           if (stream.isCharacterOutputStream())      
@@ -1674,7 +1674,7 @@
   }
 
   public static final Stream checkBinaryInputStream(LispObject obj)
-    throws ConditionThrowable
+
   {
           final Stream stream = checkStream(obj);
           if (stream.isBinaryInputStream())      
@@ -1685,7 +1685,7 @@
   }
   
   public static final Stream outSynonymOf(LispObject obj)
-  throws ConditionThrowable
+
   {       
           if (obj instanceof Stream)
             return (Stream) obj;
@@ -1698,7 +1698,7 @@
   }
 
   public static final Stream inSynonymOf(LispObject obj)
-    throws ConditionThrowable
+
   {
     if (obj instanceof Stream)
       return (Stream) obj;
@@ -1711,7 +1711,7 @@
   }
 
   public static final void writeByte(int n, LispObject obj)
-    throws ConditionThrowable
+
   {
     if (n < 0 || n > 255)
       type_error(Fixnum.getInstance(n), UNSIGNED_BYTE_8);
@@ -1719,7 +1719,7 @@
   }
 
   public static final Readtable checkReadtable(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof Readtable)   
                   return (Readtable) obj;         
@@ -1728,7 +1728,7 @@
   }
   
   public final static AbstractString checkString(LispObject obj) 
-   throws ConditionThrowable 
+
   {
           if (obj instanceof AbstractString)            
                   return (AbstractString) obj;                    
@@ -1737,7 +1737,7 @@
   }
   
   public final static LispClass checkClass(LispObject obj) 
-   throws ConditionThrowable 
+
    {
           if (obj instanceof LispClass)         
                   return (LispClass) obj;                         
@@ -1746,7 +1746,7 @@
    }   
 
   public final static Layout checkLayout(LispObject obj) 
-   throws ConditionThrowable 
+
   {
           if (obj instanceof Layout)            
                   return (Layout) obj;                    
@@ -1755,7 +1755,7 @@
   }
 
   public static final Readtable designator_readtable(LispObject obj)
-    throws ConditionThrowable
+
   {
     if (obj == NIL)
       obj = STANDARD_READTABLE.symbolValue();
@@ -1765,7 +1765,7 @@
   }
 
   public static final Environment checkEnvironment(LispObject obj)
-    throws ConditionThrowable
+
   {
           if (obj instanceof Environment)         
                   return (Environment) obj;         
@@ -1774,7 +1774,7 @@
   }
 
   public static final void checkBounds(int start, int end, int length)
-    throws ConditionThrowable
+
   {
     if (start < 0 || end < 0 || start > end || end > length)
       {
@@ -1790,7 +1790,7 @@
   }
 
   public static final LispObject coerceToFunction(LispObject obj)
-    throws ConditionThrowable
+
   {
     if (obj instanceof Function)
       return obj;
@@ -1811,7 +1811,7 @@
 
   // Returns package or throws exception.
   public static final Package coerceToPackage(LispObject obj)
-    throws ConditionThrowable
+
   {
     if (obj instanceof Package)
       return (Package) obj;
@@ -1824,7 +1824,7 @@
   }
 
   public static Pathname coerceToPathname(LispObject arg)
-    throws ConditionThrowable
+
   {
     if (arg instanceof Pathname)
       return (Pathname) arg;
@@ -1839,7 +1839,7 @@
   }
 
   public LispObject assq(LispObject item, LispObject alist)
-    throws ConditionThrowable
+
   {
     while (alist instanceof Cons)
       {
@@ -1859,7 +1859,7 @@
   }
 
   public static final boolean memq(LispObject item, LispObject list)
-    throws ConditionThrowable
+
   {
     while (list instanceof Cons)
       {
@@ -1873,7 +1873,7 @@
   }
 
   public static final boolean memql(LispObject item, LispObject list)
-    throws ConditionThrowable
+
   {
     while (list instanceof Cons)
       {
@@ -1889,7 +1889,7 @@
   // Property lists.
   public static final LispObject getf(LispObject plist, LispObject indicator,
                                       LispObject defaultValue)
-    throws ConditionThrowable
+
   {
     LispObject list = plist;
     while (list != NIL)
@@ -1906,7 +1906,7 @@
   }
 
   public static final LispObject get(LispObject symbol, LispObject indicator)
-    throws ConditionThrowable
+
   {
     LispObject list = checkSymbol(symbol).getPropertyList();
     while (list != NIL)
@@ -1920,7 +1920,7 @@
 
   public static final LispObject get(LispObject symbol, LispObject indicator,
                                      LispObject defaultValue)
-    throws ConditionThrowable
+
   {
     LispObject list = checkSymbol(symbol).getPropertyList();
     while (list != NIL)
@@ -1934,7 +1934,7 @@
 
   public static final LispObject put(Symbol symbol, LispObject indicator,
                                      LispObject value)
-    throws ConditionThrowable
+
   {
     LispObject list = symbol.getPropertyList();
     while (list != NIL)
@@ -1957,7 +1957,7 @@
 
   public static final LispObject putf(LispObject plist, LispObject indicator,
                                       LispObject value)
-    throws ConditionThrowable
+
   {
     LispObject list = plist;
     while (list != NIL)
@@ -1976,7 +1976,7 @@
   }
 
   public static final LispObject remprop(Symbol symbol, LispObject indicator)
-    throws ConditionThrowable
+
   {
     LispObject list = checkList(symbol.getPropertyList());
     LispObject prev = null;
@@ -2003,7 +2003,7 @@
 
   public static final String format(LispObject formatControl,
                                     LispObject formatArguments)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     String control = formatControl.getStringValue();
@@ -2112,7 +2112,7 @@
 
   // Used by the compiler.
   public static final Symbol internInPackage(String name, String packageName)
-    throws ConditionThrowable
+
   {
     Package pkg = Packages.findPackage(packageName);
     if (pkg == null)
@@ -2145,7 +2145,7 @@
     {
       @Override
       public LispObject execute(LispObject key, LispObject value)
-        throws ConditionThrowable
+
       {
         objectTable.put(key.getStringValue(), value);
         return NIL;
@@ -2269,7 +2269,7 @@
     return (Stream) Symbol.STANDARD_INPUT.symbolValueNoThrow();
   }
 
-  public static final Stream getStandardOutput() throws ConditionThrowable
+  public static final Stream getStandardOutput()
   {
     return checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue());
   }
@@ -2284,7 +2284,7 @@
   public static final Symbol STANDARD_READTABLE =
     internConstant("+STANDARD-READTABLE+", PACKAGE_SYS, new Readtable());
 
-  public static final Readtable currentReadtable() throws ConditionThrowable
+  public static final Readtable currentReadtable()
   {
     return (Readtable) Symbol.CURRENT_READTABLE.symbolValue();
   }

Modified: trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispCharacter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispCharacter.java	Fri Nov  6 15:07:54 2009
@@ -102,7 +102,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.CHARACTER)
       return T;
@@ -188,7 +188,7 @@
     return false;
   }
 
-  public static char getValue(LispObject obj) throws ConditionThrowable
+  public static char getValue(LispObject obj)
   {       
           if (obj instanceof LispCharacter)
         return ((LispCharacter)obj).value;
@@ -228,13 +228,13 @@
 
   /** See LispObject.getStringValue() */
   @Override
-  public String getStringValue() throws ConditionThrowable
+  public String getStringValue()
   {
     return String.valueOf(value);
   }
 
   @Override
-  public final String writeToString() throws ConditionThrowable
+  public final String writeToString()
   {
     final LispThread thread = LispThread.currentThread();
     boolean printReadably = (Symbol.PRINT_READABLY.symbolValue(thread) != NIL);
@@ -297,7 +297,7 @@
     new Primitive(Symbol.CHARACTER, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof LispCharacter)
           return arg;
@@ -321,7 +321,7 @@
     new Primitive("whitespacep", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return Character.isWhitespace(LispCharacter.getValue(arg)) ? T : NIL;
       }
@@ -332,7 +332,7 @@
     new Primitive(Symbol.CHAR_CODE, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           int n = LispCharacter.getValue(arg);
           return Fixnum.getInstance(n);
@@ -344,7 +344,7 @@
     new Primitive(Symbol.CHAR_INT, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           int n = LispCharacter.getValue(arg);
           return Fixnum.getInstance(n);
@@ -356,7 +356,7 @@
     new Primitive(Symbol.CODE_CHAR, "code")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           int n = Fixnum.getValue(arg);
           if (n < CHAR_MAX)
@@ -373,7 +373,7 @@
     new Primitive(Symbol.CHARACTERP, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof LispCharacter ? T : NIL;
       }
@@ -384,7 +384,7 @@
     new Primitive(Symbol.BOTH_CASE_P, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         char c = getValue(arg);
         if (Character.isLowerCase(c) || Character.isUpperCase(c))
@@ -398,7 +398,7 @@
     new Primitive(Symbol.LOWER_CASE_P, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Character.isLowerCase(getValue(arg)) ? T : NIL;
       }
@@ -409,7 +409,7 @@
     new Primitive(Symbol.UPPER_CASE_P, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Character.isUpperCase(getValue(arg)) ? T : NIL;
       }
@@ -420,7 +420,7 @@
     new Primitive(Symbol.CHAR_DOWNCASE, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           final char c = LispCharacter.getValue(arg);
           if (c < 128)
@@ -434,7 +434,7 @@
     new Primitive(Symbol.CHAR_UPCASE, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final char c;
         c = LispCharacter.getValue(arg);
@@ -449,7 +449,7 @@
     new Primitive(Symbol.DIGIT_CHAR, "weight &optional radix")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           if (arg instanceof Bignum)
               return NIL;
@@ -461,7 +461,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         int radix;
         if (second instanceof Fixnum)
@@ -489,14 +489,14 @@
     new Primitive(Symbol.DIGIT_CHAR_P, "char &optional radix")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           final int n = Character.digit(LispCharacter.getValue(arg), 10);
           return n < 0 ? NIL : Fixnum.getInstance(n);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         char c;
             c = LispCharacter.getValue(first);
@@ -520,7 +520,7 @@
     new Primitive(Symbol.STANDARD_CHAR_P, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkCharacter(arg).isStandardChar() ? T : NIL;
       }
@@ -531,7 +531,7 @@
     new Primitive(Symbol.GRAPHIC_CHAR_P, "char")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           char c = LispCharacter.getValue(arg);
           if (c >= ' ' && c < 127)
@@ -545,7 +545,7 @@
     new Primitive(Symbol.ALPHA_CHAR_P, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return Character.isLetter(LispCharacter.getValue(arg)) ? T : NIL;
       }
@@ -556,7 +556,7 @@
     new Primitive(Symbol.ALPHANUMERICP, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return Character.isLetterOrDigit(LispCharacter.getValue(arg)) ? T : NIL;
       }
@@ -598,7 +598,7 @@
     new Primitive(Symbol.NAME_CHAR, "name")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         String s = arg.STRING().getStringValue();
         int n = nameToChar(s);
@@ -640,7 +640,7 @@
     new Primitive(Symbol.CHAR_NAME, "character")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         String name = charToName(LispCharacter.getValue(arg));
         return name != null ? new SimpleString(name) : NIL;

Modified: trunk/abcl/src/org/armedbear/lisp/LispClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispClass.java	Fri Nov  6 15:07:54 2009
@@ -62,7 +62,7 @@
   }
 
   public static LispObject findClass(LispObject name, boolean errorp)
-    throws ConditionThrowable
+
   {
     final Symbol symbol = checkSymbol(name);
     final LispClass c;
@@ -115,7 +115,7 @@
   }
 
   @Override
-  public LispObject getParts() throws ConditionThrowable
+  public LispObject getParts()
   {
     LispObject result = NIL;
     result = result.push(new Cons("NAME", symbol != null ? symbol : NIL));
@@ -301,7 +301,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.CLASS)
       return T;
@@ -310,7 +310,7 @@
     return super.typep(type);
   }
 
-  public boolean subclassp(LispObject obj) throws ConditionThrowable
+  public boolean subclassp(LispObject obj)
   {
     LispObject cpl = classPrecedenceList;
     while (cpl != NIL)
@@ -327,20 +327,20 @@
     new Primitive(Symbol.FIND_CLASS, "symbol &optional errorp environment")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return findClass(arg, true);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return findClass(first, second != NIL);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         // FIXME Use environment!
         return findClass(first, second != NIL);
@@ -353,7 +353,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final Symbol name = checkSymbol(first);
         if (second == NIL)
@@ -373,7 +373,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final LispClass c = checkClass(first);
         return c.subclassp(second) ? T : NIL;

Modified: trunk/abcl/src/org/armedbear/lisp/LispError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispError.java	Fri Nov  6 15:07:54 2009
@@ -35,22 +35,22 @@
 
 public class LispError extends SeriousCondition
 {
-  public LispError() throws ConditionThrowable
+  public LispError()
   {
   }
 
-  protected LispError(LispClass cls) throws ConditionThrowable
+  protected LispError(LispClass cls)
   {
     super(cls);
   }
 
-  public LispError(LispObject initArgs) throws ConditionThrowable
+  public LispError(LispObject initArgs)
   {
     super(StandardClass.ERROR);
     initialize(initArgs);
   }
 
-  public LispError(String message) throws ConditionThrowable
+  public LispError(String message)
   {
     super(StandardClass.ERROR);
     setFormatControl(message);
@@ -69,7 +69,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.ERROR)
       return T;

Modified: trunk/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispObject.java	Fri Nov  6 15:07:54 2009
@@ -49,7 +49,7 @@
     return BuiltInClass.CLASS_T;
   }
 
-  public LispObject getDescription() throws ConditionThrowable
+  public LispObject getDescription()
   {
     FastStringBuffer sb = new FastStringBuffer("An object of type ");
     sb.append(typeOf().writeToString());
@@ -58,7 +58,7 @@
     return new SimpleString(sb);
   }
 
-  public LispObject getParts() throws ConditionThrowable
+  public LispObject getParts()
   {
     return NIL;
   }
@@ -68,7 +68,7 @@
     return true;
   }
 
-  public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+  public LispObject typep(LispObject typeSpecifier)
   {
     if (typeSpecifier == T)
       return T;
@@ -99,12 +99,12 @@
     return true;
   }
 
-  public Object javaInstance() throws ConditionThrowable
+  public Object javaInstance()
   {
         return this;
   }
 
-  public Object javaInstance(Class<?> c) throws ConditionThrowable
+  public Object javaInstance(Class<?> c)
   {
       if (c.isAssignableFrom(getClass()))
 	  return this;
@@ -117,60 +117,59 @@
    * interoperability
    * 
    * @return An object to be used with synchronized, wait, notify, etc
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public Object lockableInstance() throws ConditionThrowable
+  public Object lockableInstance()
   {
       return this;
   }
 
 
-  public LispObject car() throws ConditionThrowable
+  public LispObject car()
   {
     return type_error(this, Symbol.LIST);
   }
 
-  public void setCar(LispObject obj) throws ConditionThrowable
+  public void setCar(LispObject obj)
   {
     type_error(this, Symbol.CONS);
   }
 
-  public LispObject RPLACA(LispObject obj) throws ConditionThrowable
+  public LispObject RPLACA(LispObject obj)
   {
     return type_error(this, Symbol.CONS);
   }
 
-  public LispObject cdr() throws ConditionThrowable
+  public LispObject cdr()
   {
     return type_error(this, Symbol.LIST);
   }
 
-  public void setCdr(LispObject obj) throws ConditionThrowable
+  public void setCdr(LispObject obj)
   {
     type_error(this, Symbol.CONS);
   }
 
-  public LispObject RPLACD(LispObject obj) throws ConditionThrowable
+  public LispObject RPLACD(LispObject obj)
   {
     return type_error(this, Symbol.CONS);
   }
 
-  public LispObject cadr() throws ConditionThrowable
+  public LispObject cadr()
   {
     return type_error(this, Symbol.LIST);
   }
 
-  public LispObject cddr() throws ConditionThrowable
+  public LispObject cddr()
   {
     return type_error(this, Symbol.LIST);
   }
 
-  public LispObject caddr() throws ConditionThrowable
+  public LispObject caddr()
   {
     return type_error(this, Symbol.LIST);
   }
 
-  public LispObject nthcdr(int n) throws ConditionThrowable
+  public LispObject nthcdr(int n)
   {
     if (n < 0)
       return type_error(Fixnum.getInstance(n),
@@ -178,7 +177,7 @@
     return type_error(this, Symbol.LIST);
   }
 
-  public LispObject push(LispObject obj) throws ConditionThrowable
+  public LispObject push(LispObject obj)
   {
     return type_error(this, Symbol.LIST);
   }
@@ -208,7 +207,7 @@
     return eql(obj) ? T : NIL;
   }
 
-  public final LispObject EQUAL(LispObject obj) throws ConditionThrowable
+  public final LispObject EQUAL(LispObject obj)
   {
     return equal(obj) ? T : NIL;
   }
@@ -218,7 +217,7 @@
     return false;
   }
 
-  public boolean equal(LispObject obj) throws ConditionThrowable
+  public boolean equal(LispObject obj)
   {
     return this == obj;
   }
@@ -228,68 +227,68 @@
     return false;
   }
 
-  public boolean equalp(LispObject obj) throws ConditionThrowable
+  public boolean equalp(LispObject obj)
   {
     return this == obj;
   }
 
-  public LispObject ABS() throws ConditionThrowable
+  public LispObject ABS()
   {
     return type_error(this, Symbol.NUMBER);
   }
 
-  public LispObject NUMERATOR() throws ConditionThrowable
+  public LispObject NUMERATOR()
   {
     return type_error(this, Symbol.RATIONAL);
   }
 
-  public LispObject DENOMINATOR() throws ConditionThrowable
+  public LispObject DENOMINATOR()
   {
     return type_error(this, Symbol.RATIONAL);
   }
 
-  public LispObject EVENP() throws ConditionThrowable
+  public LispObject EVENP()
   {
     return evenp() ? T : NIL;
   }
 
-  public boolean evenp() throws ConditionThrowable
+  public boolean evenp()
   {
     type_error(this, Symbol.INTEGER);
     // Not reached.
     return false;
   }
 
-  public LispObject ODDP() throws ConditionThrowable
+  public LispObject ODDP()
   {
     return oddp() ? T : NIL;
   }
 
-  public boolean oddp() throws ConditionThrowable
+  public boolean oddp()
   {
     type_error(this, Symbol.INTEGER);
     // Not reached.
     return false;
   }
 
-  public LispObject PLUSP() throws ConditionThrowable
+  public LispObject PLUSP()
   {
     return plusp() ? T : NIL;
   }
 
-  public boolean plusp() throws ConditionThrowable
+  public boolean plusp()
   {
     type_error(this, Symbol.REAL);
     // Not reached.
     return false;
   }
 
-  public LispObject MINUSP() throws ConditionThrowable
+  public LispObject MINUSP()
   {
     return minusp() ? T : NIL;
   }
 
-  public boolean minusp() throws ConditionThrowable
+  public boolean minusp()
   {
     type_error(this, Symbol.REAL);
     // Not reached.
@@ -306,12 +305,12 @@
     return false;
   }
 
-  public LispObject ZEROP() throws ConditionThrowable
+  public LispObject ZEROP()
   {
     return zerop() ? T : NIL;
   }
 
-  public boolean zerop() throws ConditionThrowable
+  public boolean zerop()
   {
     type_error(this, Symbol.NUMBER);
     // Not reached.
@@ -398,127 +397,127 @@
     return false;
   }
 
-  public int length() throws ConditionThrowable
+  public int length()
   {
     type_error(this, Symbol.SEQUENCE);
     // Not reached.
     return 0;
   }
 
-  public final LispObject LENGTH() throws ConditionThrowable
+  public final LispObject LENGTH()
   {
     return Fixnum.getInstance(length());
   }
 
-  public LispObject CHAR(int index) throws ConditionThrowable
+  public LispObject CHAR(int index)
   {
     return type_error(this, Symbol.STRING);
   }
 
-  public LispObject SCHAR(int index) throws ConditionThrowable
+  public LispObject SCHAR(int index)
   {
     return type_error(this, Symbol.SIMPLE_STRING);
   }
 
-  public LispObject NTH(int index) throws ConditionThrowable
+  public LispObject NTH(int index)
   {
     return type_error(this, Symbol.LIST);
   }
 
-  public LispObject NTH(LispObject arg) throws ConditionThrowable
+  public LispObject NTH(LispObject arg)
   {
     return type_error(this, Symbol.LIST);
   }
 
-  public LispObject elt(int index) throws ConditionThrowable
+  public LispObject elt(int index)
   {
     return type_error(this, Symbol.SEQUENCE);
   }
 
-  public LispObject reverse() throws ConditionThrowable
+  public LispObject reverse()
   {
     return type_error(this, Symbol.SEQUENCE);
   }
 
-  public LispObject nreverse() throws ConditionThrowable
+  public LispObject nreverse()
   {
     return type_error(this, Symbol.SEQUENCE);
   }
 
-  public long aref_long(int index) throws ConditionThrowable
+  public long aref_long(int index)
   {
     return AREF(index).longValue();
   }
 
-  public int aref(int index) throws ConditionThrowable
+  public int aref(int index)
   {
     return AREF(index).intValue();
   }
 
-  public LispObject AREF(int index) throws ConditionThrowable
+  public LispObject AREF(int index)
   {
     return type_error(this, Symbol.ARRAY);
   }
 
-  public LispObject AREF(LispObject index) throws ConditionThrowable
+  public LispObject AREF(LispObject index)
   {
       return AREF(Fixnum.getValue(index));
   }
 
   public void aset(int index, int n)
-    throws ConditionThrowable
+
   {    
           aset(index, Fixnum.getInstance(n));
   }
 
   public void aset(int index, LispObject newValue)
-    throws ConditionThrowable
+
   {
     type_error(this, Symbol.ARRAY);
   }
 
   public void aset(LispObject index, LispObject newValue)
-    throws ConditionThrowable
+
   {
       aset(Fixnum.getValue(index), newValue);
   }
 
-  public LispObject SVREF(int index) throws ConditionThrowable
+  public LispObject SVREF(int index)
   {
     return type_error(this, Symbol.SIMPLE_VECTOR);
   }
 
-  public void svset(int index, LispObject newValue) throws ConditionThrowable
+  public void svset(int index, LispObject newValue)
   {
     type_error(this, Symbol.SIMPLE_VECTOR);
   }
 
   public void vectorPushExtend(LispObject element)
-    throws ConditionThrowable
+
   {
     noFillPointer();
   }
 
   public LispObject VECTOR_PUSH_EXTEND(LispObject element)
-    throws ConditionThrowable
+
   {
     return noFillPointer();
   }
 
   public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
-    throws ConditionThrowable
+
   {
     return noFillPointer();
   }
 
-  public final LispObject noFillPointer() throws ConditionThrowable
+  public final LispObject noFillPointer()
   {
     return type_error(this, list(Symbol.AND, Symbol.VECTOR,
                                        list(Symbol.SATISFIES,
                                              Symbol.ARRAY_HAS_FILL_POINTER_P)));
   }
 
-  public LispObject[] copyToArray() throws ConditionThrowable
+  public LispObject[] copyToArray()
   {
     type_error(this, Symbol.LIST);
     // Not reached.
@@ -540,14 +539,14 @@
     return NIL;
   }
 
-  public boolean endp() throws ConditionThrowable
+  public boolean endp()
   {
     type_error(this, Symbol.LIST);
     // Not reached.
     return false;
   }
 
-  public LispObject ENDP() throws ConditionThrowable
+  public LispObject ENDP()
   {
     return type_error(this, Symbol.LIST);
   }
@@ -557,7 +556,7 @@
     return NIL;
   }
 
-  public boolean isSpecialOperator() throws ConditionThrowable
+  public boolean isSpecialOperator()
   {
     type_error(this, Symbol.SYMBOL);
     // Not reached.
@@ -573,7 +572,7 @@
     new EqHashTable(11, NIL, NIL);
 
   public LispObject getDocumentation(LispObject docType)
-    throws ConditionThrowable
+
   {
     LispObject alist = documentationHashTable.get(this);
     if (alist != null)
@@ -586,7 +585,7 @@
   }
 
   public void setDocumentation(LispObject docType, LispObject documentation)
-    throws ConditionThrowable
+
   {
     LispObject alist = documentationHashTable.get(this);
     if (alist == null)
@@ -612,22 +611,22 @@
   {
   }
 
-  public LispObject getSymbolValue() throws ConditionThrowable
+  public LispObject getSymbolValue()
   {
     return type_error(this, Symbol.SYMBOL);
   }
 
-  public LispObject getSymbolFunction() throws ConditionThrowable
+  public LispObject getSymbolFunction()
   {
     return type_error(this, Symbol.SYMBOL);
   }
 
-  public LispObject getSymbolFunctionOrDie() throws ConditionThrowable
+  public LispObject getSymbolFunctionOrDie()
   {
     return type_error(this, Symbol.SYMBOL);
   }
 
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     return toString();
   }
@@ -635,7 +634,7 @@
   public String unreadableString(String s) {
      return unreadableString(s, true);
   }
-  public String unreadableString(Symbol sym) throws ConditionThrowable {
+  public String unreadableString(Symbol sym) {
      return unreadableString(sym, true);
   }
 
@@ -653,44 +652,44 @@
   }
 
   public String unreadableString(Symbol symbol, boolean identity) 
-    throws ConditionThrowable
+
   {
     return unreadableString(symbol.writeToString(), identity);
   }
 
   // Special operator
   public LispObject execute(LispObject args, Environment env)
-    throws ConditionThrowable
+
   {
     return error(new LispError());
   }
 
-  public LispObject execute() throws ConditionThrowable
+  public LispObject execute()
   {
     return type_error(this, Symbol.FUNCTION);
   }
 
-  public LispObject execute(LispObject arg) throws ConditionThrowable
+  public LispObject execute(LispObject arg)
   {
     return type_error(this, Symbol.FUNCTION);
   }
 
   public LispObject execute(LispObject first, LispObject second)
-    throws ConditionThrowable
+
   {
     return type_error(this, Symbol.FUNCTION);
   }
 
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third)
-    throws ConditionThrowable
+
   {
     return type_error(this, Symbol.FUNCTION);
   }
 
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth)
-    throws ConditionThrowable
+
   {
     return type_error(this, Symbol.FUNCTION);
   }
@@ -698,7 +697,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth)
-    throws ConditionThrowable
+
   {
     return type_error(this, Symbol.FUNCTION);
   }
@@ -706,7 +705,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth)
-    throws ConditionThrowable
+
   {
     return type_error(this, Symbol.FUNCTION);
   }
@@ -715,7 +714,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh)
-    throws ConditionThrowable
+
   {
     return type_error(this, Symbol.FUNCTION);
   }
@@ -724,18 +723,18 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh, LispObject eighth)
-    throws ConditionThrowable
+
   {
     return type_error(this, Symbol.FUNCTION);
   }
 
-  public LispObject execute(LispObject[] args) throws ConditionThrowable
+  public LispObject execute(LispObject[] args)
   {
     return type_error(this, Symbol.FUNCTION);
   }
 
   // Used by COMPILE-MULTIPLE-VALUE-CALL.
-  public LispObject dispatch(LispObject[] args) throws ConditionThrowable
+  public LispObject dispatch(LispObject[] args)
   {
     switch (args.length)
       {
@@ -765,192 +764,192 @@
       }
   }
 
-  public int intValue() throws ConditionThrowable
+  public int intValue()
   {
     type_error(this, Symbol.INTEGER);
     // Not reached.
     return 0;
   }
 
-  public long longValue() throws ConditionThrowable
+  public long longValue()
   {
     type_error(this, Symbol.INTEGER);
     // Not reached.
     return 0;
   }
 
-  public float floatValue() throws ConditionThrowable
+  public float floatValue()
   {
     type_error(this, Symbol.SINGLE_FLOAT);
     // Not reached
     return 0;
   }
 
-  public double doubleValue() throws ConditionThrowable
+  public double doubleValue()
   {
     type_error(this, Symbol.DOUBLE_FLOAT);
     // Not reached
     return 0;
   }
 
-  public LispObject incr() throws ConditionThrowable
+  public LispObject incr()
   {
     return type_error(this, Symbol.NUMBER);
   }
 
-  public LispObject decr() throws ConditionThrowable
+  public LispObject decr()
   {
     return type_error(this, Symbol.NUMBER);
   }
 
-  public LispObject negate() throws ConditionThrowable
+  public LispObject negate()
   {
     return Fixnum.ZERO.subtract(this);
   }
 
-  public LispObject add(int n) throws ConditionThrowable
+  public LispObject add(int n)
   {
     return add(Fixnum.getInstance(n));
   }
 
-  public LispObject add(LispObject obj) throws ConditionThrowable
+  public LispObject add(LispObject obj)
   {
     return type_error(this, Symbol.NUMBER);
   }
 
-  public LispObject subtract(int n) throws ConditionThrowable
+  public LispObject subtract(int n)
   {
     return subtract(Fixnum.getInstance(n));
   }
 
-  public LispObject subtract(LispObject obj) throws ConditionThrowable
+  public LispObject subtract(LispObject obj)
   {
     return type_error(this, Symbol.NUMBER);
   }
 
-  public LispObject multiplyBy(int n) throws ConditionThrowable
+  public LispObject multiplyBy(int n)
   {
     return multiplyBy(Fixnum.getInstance(n));
   }
 
-  public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
+  public LispObject multiplyBy(LispObject obj)
   {
     return type_error(this, Symbol.NUMBER);
   }
 
-  public LispObject divideBy(LispObject obj) throws ConditionThrowable
+  public LispObject divideBy(LispObject obj)
   {
     return type_error(this, Symbol.NUMBER);
   }
 
-  public boolean isEqualTo(int n) throws ConditionThrowable
+  public boolean isEqualTo(int n)
   {
     return isEqualTo(Fixnum.getInstance(n));
   }
 
-  public boolean isEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isEqualTo(LispObject obj)
   {
     type_error(this, Symbol.NUMBER);
     // Not reached.
     return false;
   }
 
-  public LispObject IS_E(LispObject obj) throws ConditionThrowable
+  public LispObject IS_E(LispObject obj)
   {
     return isEqualTo(obj) ? T : NIL;
   }
 
-  public boolean isNotEqualTo(int n) throws ConditionThrowable
+  public boolean isNotEqualTo(int n)
   {
     return isNotEqualTo(Fixnum.getInstance(n));
   }
 
-  public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isNotEqualTo(LispObject obj)
   {
     type_error(this, Symbol.NUMBER);
     // Not reached.
     return false;
   }
 
-  public LispObject IS_NE(LispObject obj) throws ConditionThrowable
+  public LispObject IS_NE(LispObject obj)
   {
     return isNotEqualTo(obj) ? T : NIL;
   }
 
-  public boolean isLessThan(int n) throws ConditionThrowable
+  public boolean isLessThan(int n)
   {
     return isLessThan(Fixnum.getInstance(n));
   }
 
-  public boolean isLessThan(LispObject obj) throws ConditionThrowable
+  public boolean isLessThan(LispObject obj)
   {
     type_error(this, Symbol.REAL);
     // Not reached.
     return false;
   }
 
-  public LispObject IS_LT(LispObject obj) throws ConditionThrowable
+  public LispObject IS_LT(LispObject obj)
   {
     return isLessThan(obj) ? T : NIL;
   }
 
-  public boolean isGreaterThan(int n) throws ConditionThrowable
+  public boolean isGreaterThan(int n)
   {
     return isGreaterThan(Fixnum.getInstance(n));
   }
 
-  public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
+  public boolean isGreaterThan(LispObject obj)
   {
     type_error(this, Symbol.REAL);
     // Not reached.
     return false;
   }
 
-  public LispObject IS_GT(LispObject obj) throws ConditionThrowable
+  public LispObject IS_GT(LispObject obj)
   {
     return isGreaterThan(obj) ? T : NIL;
   }
 
-  public boolean isLessThanOrEqualTo(int n) throws ConditionThrowable
+  public boolean isLessThanOrEqualTo(int n)
   {
     return isLessThanOrEqualTo(Fixnum.getInstance(n));
   }
 
-  public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isLessThanOrEqualTo(LispObject obj)
   {
     type_error(this, Symbol.REAL);
     // Not reached.
     return false;
   }
 
-  public LispObject IS_LE(LispObject obj) throws ConditionThrowable
+  public LispObject IS_LE(LispObject obj)
   {
     return isLessThanOrEqualTo(obj) ? T : NIL;
   }
 
-  public boolean isGreaterThanOrEqualTo(int n) throws ConditionThrowable
+  public boolean isGreaterThanOrEqualTo(int n)
   {
     return isGreaterThanOrEqualTo(Fixnum.getInstance(n));
   }
 
-  public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
+  public boolean isGreaterThanOrEqualTo(LispObject obj)
   {
     type_error(this, Symbol.REAL);
     // Not reached.
     return false;
   }
 
-  public LispObject IS_GE(LispObject obj) throws ConditionThrowable
+  public LispObject IS_GE(LispObject obj)
   {
     return isGreaterThanOrEqualTo(obj) ? T : NIL;
   }
 
-  public LispObject truncate(LispObject obj) throws ConditionThrowable
+  public LispObject truncate(LispObject obj)
   {
     return type_error(this, Symbol.REAL);
   }
 
-  public LispObject MOD(LispObject divisor) throws ConditionThrowable
+  public LispObject MOD(LispObject divisor)
   {
     truncate(divisor);
     final LispThread thread = LispThread.currentThread();
@@ -972,57 +971,57 @@
     return remainder;
   }
 
-  public LispObject MOD(int divisor) throws ConditionThrowable
+  public LispObject MOD(int divisor)
   {
     return MOD(Fixnum.getInstance(divisor));
   }
 
-  public LispObject ash(int shift) throws ConditionThrowable
+  public LispObject ash(int shift)
   {
     return ash(Fixnum.getInstance(shift));
   }
 
-  public LispObject ash(LispObject obj) throws ConditionThrowable
+  public LispObject ash(LispObject obj)
   {
     return type_error(this, Symbol.INTEGER);
   }
 
-  public LispObject LOGNOT() throws ConditionThrowable
+  public LispObject LOGNOT()
   {
     return type_error(this, Symbol.INTEGER);
   }
 
-  public LispObject LOGAND(int n) throws ConditionThrowable
+  public LispObject LOGAND(int n)
   {
     return LOGAND(Fixnum.getInstance(n));
   }
 
-  public LispObject LOGAND(LispObject obj) throws ConditionThrowable
+  public LispObject LOGAND(LispObject obj)
   {
     return type_error(this, Symbol.INTEGER);
   }
 
-  public LispObject LOGIOR(int n) throws ConditionThrowable
+  public LispObject LOGIOR(int n)
   {
     return LOGIOR(Fixnum.getInstance(n));
   }
 
-  public LispObject LOGIOR(LispObject obj) throws ConditionThrowable
+  public LispObject LOGIOR(LispObject obj)
   {
     return type_error(this, Symbol.INTEGER);
   }
 
-  public LispObject LOGXOR(int n) throws ConditionThrowable
+  public LispObject LOGXOR(int n)
   {
     return LOGXOR(Fixnum.getInstance(n));
   }
 
-  public LispObject LOGXOR(LispObject obj) throws ConditionThrowable
+  public LispObject LOGXOR(LispObject obj)
   {
     return type_error(this, Symbol.INTEGER);
   }
 
-  public LispObject LDB(int size, int position) throws ConditionThrowable
+  public LispObject LDB(int size, int position)
   {
     return type_error(this, Symbol.INTEGER);
   }
@@ -1043,19 +1042,19 @@
     return psxhash();
   }
 
-  public LispObject STRING() throws ConditionThrowable
+  public LispObject STRING()
   {
     return error(new TypeError(writeToString() + " cannot be coerced to a string."));
   }
 
-  public char[] chars() throws ConditionThrowable
+  public char[] chars()
   {
     type_error(this, Symbol.STRING);
     // Not reached.
     return null;
   }
 
-  public char[] getStringChars() throws ConditionThrowable
+  public char[] getStringChars()
   {
     type_error(this, Symbol.STRING);
     // Not reached.
@@ -1067,46 +1066,46 @@
    *
    * Throws an error if the instance isn't a string designator.
    */
-  public String getStringValue() throws ConditionThrowable
+  public String getStringValue()
   {
     type_error(this, Symbol.STRING);
     // Not reached.
     return null;
   }
 
-  public LispObject getSlotValue_0() throws ConditionThrowable
+  public LispObject getSlotValue_0()
   {
     return type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
-  public LispObject getSlotValue_1() throws ConditionThrowable
+  public LispObject getSlotValue_1()
   {
     return type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
-  public LispObject getSlotValue_2() throws ConditionThrowable
+  public LispObject getSlotValue_2()
   {
     return type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
-  public LispObject getSlotValue_3() throws ConditionThrowable
+  public LispObject getSlotValue_3()
   {
     return type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
-  public LispObject getSlotValue(int index) throws ConditionThrowable
+  public LispObject getSlotValue(int index)
   {
     return type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
-  public int getFixnumSlotValue(int index) throws ConditionThrowable
+  public int getFixnumSlotValue(int index)
   {
     type_error(this, Symbol.STRUCTURE_OBJECT);
     // Not reached.
     return 0;
   }
 
-  public boolean getSlotValueAsBoolean(int index) throws ConditionThrowable
+  public boolean getSlotValueAsBoolean(int index)
   {
     type_error(this, Symbol.STRUCTURE_OBJECT);
     // Not reached.
@@ -1114,42 +1113,42 @@
   }
 
   public void setSlotValue_0(LispObject value)
-    throws ConditionThrowable
+
   {
     type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
   public void setSlotValue_1(LispObject value)
-    throws ConditionThrowable
+
   {
     type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
   public void setSlotValue_2(LispObject value)
-    throws ConditionThrowable
+
   {
     type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
   public void setSlotValue_3(LispObject value)
-    throws ConditionThrowable
+
   {
     type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
   public void setSlotValue(int index, LispObject value)
-    throws ConditionThrowable
+
   {
     type_error(this, Symbol.STRUCTURE_OBJECT);
   }
 
-  public LispObject SLOT_VALUE(LispObject slotName) throws ConditionThrowable
+  public LispObject SLOT_VALUE(LispObject slotName)
   {
     return type_error(this, Symbol.STANDARD_OBJECT);
   }
 
   public void setSlotValue(LispObject slotName, LispObject newValue)
-    throws ConditionThrowable
+
   {
     type_error(this, Symbol.STANDARD_OBJECT);
   }

Modified: trunk/abcl/src/org/armedbear/lisp/LispReader.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispReader.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispReader.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored)
-            throws ConditionThrowable
+
         {
           try 
             {
@@ -68,7 +68,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char terminator)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             final Readtable rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
@@ -134,7 +134,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored)
-            throws ConditionThrowable
+
         {
             return stream.readList(false, false);
         }
@@ -147,7 +147,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored)
-            throws ConditionThrowable
+
         {
             return error(new ReaderError("Unmatched right parenthesis.", stream));
         }
@@ -160,7 +160,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored)
-            throws ConditionThrowable
+
         {
             return new Cons(Symbol.QUOTE,
                             new Cons(stream.read(true, NIL, true,
@@ -175,7 +175,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c)
-            throws ConditionThrowable
+
         {
             return stream.readDispatchChar(c, false);
         }
@@ -188,7 +188,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             LispObject list = stream.readList(true, false);
@@ -215,7 +215,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char ignored, int n)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             final Readtable rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
@@ -283,7 +283,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             if (Symbol.READ_EVAL.symbolValue(thread) == NIL)
@@ -302,7 +302,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readSymbol();
         }
@@ -315,7 +315,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readArray(n);
         }
@@ -328,7 +328,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readRadix(2);
         }
@@ -341,7 +341,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readComplex();
         }
@@ -354,7 +354,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readRadix(8);
         }
@@ -367,7 +367,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readPathname();
         }
@@ -380,7 +380,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readRadix(n);
         }
@@ -393,7 +393,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readStructure();
         }
@@ -406,7 +406,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return stream.readRadix(16);
         }
@@ -419,7 +419,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             return new Cons(Symbol.FUNCTION,
                             new Cons(stream.read(true, NIL, true,
@@ -434,7 +434,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             final Readtable rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
@@ -449,7 +449,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             stream.skipBalancedComment();
             return null;
@@ -463,7 +463,7 @@
     {
         @Override
         public LispObject execute(Stream stream, char c, int n)
-            throws ConditionThrowable
+
         {
             FastStringBuffer sb = new FastStringBuffer("Illegal # macro character: #\\");
             String s = LispCharacter.charToName(c);

Modified: trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java	Fri Nov  6 15:07:54 2009
@@ -129,7 +129,7 @@
 
   @Override
   public LispObject typep(LispObject typeSpecifier) 
-    throws ConditionThrowable
+
   {
     if (typeSpecifier == Symbol.LISP_STACK_FRAME)
       return T;
@@ -139,7 +139,7 @@
    }
 
   public LispObject toLispList() 
-    throws ConditionThrowable
+
   {
     LispObject result = argsToLispList();
     if (operator instanceof Operator) {
@@ -151,7 +151,7 @@
   }
 
   private LispObject argsToLispList() 
-    throws ConditionThrowable
+
   {
     LispObject result = Lisp.NIL;
     if (args != null) {
@@ -185,7 +185,7 @@
   }
 
   public SimpleString toLispString() 
-    throws ConditionThrowable 
+
   {
     String result;
     try {
@@ -204,7 +204,7 @@
 
   @Override 
   public LispObject getParts() 
-    throws ConditionThrowable
+
   {
     LispObject result = NIL;
     result = result.push(new Cons("OPERATOR", getOperator()));

Modified: trunk/abcl/src/org/armedbear/lisp/LispThread.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispThread.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispThread.java	Fri Nov  6 15:07:54 2009
@@ -136,7 +136,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.THREAD)
             return T;
@@ -169,7 +169,7 @@
     }
 
     private final synchronized void processThreadInterrupts()
-        throws ConditionThrowable
+
     {
         while (pending != NIL) {
             LispObject function = pending.car();
@@ -386,7 +386,7 @@
     }
 
     public final LispObject pushSpecial(Symbol name, LispObject thing)
-        throws ConditionThrowable
+
     {
         SpecialBinding binding = lastSpecialBinding;
         while (binding != null) {
@@ -427,12 +427,12 @@
 
     private LispObject catchTags = NIL;
 
-    public void pushCatchTag(LispObject tag) throws ConditionThrowable
+    public void pushCatchTag(LispObject tag)
     {
         catchTags = new Cons(tag, catchTags);
     }
 
-    public void popCatchTag() throws ConditionThrowable
+    public void popCatchTag()
     {
         if (catchTags != NIL)
             catchTags = catchTags.cdr();
@@ -441,7 +441,7 @@
     }
 
     public void throwToTag(LispObject tag, LispObject result)
-        throws ConditionThrowable
+
     {
         LispObject rest = catchTags;
         while (rest != NIL) {
@@ -468,7 +468,6 @@
     }
 
     public final void pushStackFrame(StackFrame frame) 
-	throws ConditionThrowable
     {
 	frame.setNext(stack);
 	stack = frame;
@@ -487,7 +486,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject function) throws ConditionThrowable
+    public LispObject execute(LispObject function)
     {
         if (use_fast_calls)
             return function.execute();
@@ -503,7 +502,7 @@
 
     @Override
     public LispObject execute(LispObject function, LispObject arg)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(arg);
@@ -520,7 +519,7 @@
     @Override
     public LispObject execute(LispObject function, LispObject first,
                               LispObject second)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(first, second);
@@ -537,7 +536,7 @@
     @Override
     public LispObject execute(LispObject function, LispObject first,
                               LispObject second, LispObject third)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(first, second, third);
@@ -555,7 +554,7 @@
     public LispObject execute(LispObject function, LispObject first,
                               LispObject second, LispObject third,
                               LispObject fourth)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(first, second, third, fourth);
@@ -573,7 +572,7 @@
     public LispObject execute(LispObject function, LispObject first,
                               LispObject second, LispObject third,
                               LispObject fourth, LispObject fifth)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(first, second, third, fourth, fifth);
@@ -592,7 +591,7 @@
                               LispObject second, LispObject third,
                               LispObject fourth, LispObject fifth,
                               LispObject sixth)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(first, second, third, fourth, fifth, sixth);
@@ -612,7 +611,7 @@
                               LispObject second, LispObject third,
                               LispObject fourth, LispObject fifth,
                               LispObject sixth, LispObject seventh)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(first, second, third, fourth, fifth, sixth,
@@ -634,7 +633,7 @@
                               LispObject fourth, LispObject fifth,
                               LispObject sixth, LispObject seventh,
                               LispObject eighth)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(first, second, third, fourth, fifth, sixth,
@@ -652,7 +651,7 @@
     }
 
     public LispObject execute(LispObject function, LispObject[] args)
-        throws ConditionThrowable
+
     {
         if (use_fast_calls)
             return function.execute(args);
@@ -701,7 +700,7 @@
         }
     }
 
-    public LispObject backtrace(int limit) throws ConditionThrowable
+    public LispObject backtrace(int limit)
     {
         LispObject result = NIL;
         if (stack != null) {
@@ -722,7 +721,7 @@
         return result.nreverse();
     }
 
-    public void incrementCallCounts() throws ConditionThrowable
+    public void incrementCallCounts()
     {
         StackFrame s = stack;
 
@@ -750,7 +749,7 @@
     }
 
     private static void pprint(LispObject obj, int indentBy, Stream stream)
-        throws ConditionThrowable
+
     {
         if (stream.getCharPos() == 0) {
             StringBuffer sb = new StringBuffer();
@@ -810,7 +809,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         StringBuffer sb = new StringBuffer("THREAD");
         if (name != NIL) {
@@ -826,7 +825,7 @@
         new Primitive("make-thread", PACKAGE_THREADS, true, "function &optional &key name")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             final int length = args.length;
             if (length == 0)
@@ -853,7 +852,7 @@
 		      "Boolean predicate as whether OBJECT is a thread.")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return arg instanceof LispThread ? T : NIL;
         }
@@ -865,7 +864,7 @@
 		      "Boolean predicate whether THREAD is alive.")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             final LispThread lispThread;
             if (arg instanceof LispThread) {
@@ -884,7 +883,7 @@
 		      "Return the name of THREAD if it has one.")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
                 if (arg instanceof LispThread) {
                 return ((LispThread)arg).name;
@@ -894,7 +893,7 @@
     };
 
     public static final long javaSleepInterval(LispObject lispSleep)
-            throws ConditionThrowable
+
     {
         double d =
             checkDoubleFloat(lispSleep.multiplyBy(new DoubleFloat(1000))).getValue();
@@ -909,7 +908,7 @@
 							 "Causes the invoking thread to sleep for SECONDS seconds.\nSECONDS may be a value between 0 1and 1.")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
 
             try {
@@ -928,7 +927,7 @@
 		      "Applies FUNCTION to all existing threads.")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             Function fun = checkFunction(arg);
             final LispThread thread = LispThread.currentThread();
@@ -949,7 +948,7 @@
 		      "Mark THREAD as destroyed.")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             final LispThread thread;
             if (arg instanceof LispThread) {
@@ -974,7 +973,7 @@
 		      "Interrupts THREAD and forces it to apply FUNCTION to ARGS.\nWhen the function returns, the thread's original computation continues. If  multiple interrupts are queued for a thread, they are all run, but the order is not guaranteed.")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 2)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -1000,7 +999,7 @@
 		      "Returns a reference to invoking thread.")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return currentThread();
         }
@@ -1013,7 +1012,7 @@
     {
         @Override
         public LispObject execute(LispObject[] args)
-            throws ConditionThrowable
+
         {
             if (args.length > 1)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -1027,7 +1026,7 @@
     {
         @Override
         public LispObject execute(LispObject[] args)
-            throws ConditionThrowable
+
         {
             if (args.length != 1)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -1042,7 +1041,7 @@
     {
         @Override
         public LispObject execute(LispObject[] args)
-            throws ConditionThrowable
+
         {
             if (args.length != 1)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -1074,7 +1073,7 @@
         new Primitive("use-fast-calls", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             use_fast_calls = (arg != NIL);
             return use_fast_calls ? T : NIL;
@@ -1088,7 +1087,7 @@
     {
         @Override
         public LispObject execute(LispObject args, Environment env)
-            throws ConditionThrowable
+
         {
           if (args == NIL)
             return error(new WrongNumberOfArgumentsException(this));
@@ -1107,7 +1106,7 @@
     {
         @Override
         public LispObject execute(LispObject object)
-            throws ConditionThrowable
+
         {
             try {
                 object.lockableInstance().wait();
@@ -1123,7 +1122,7 @@
 
         @Override
         public LispObject execute(LispObject object, LispObject timeout)
-            throws ConditionThrowable
+
         {
             try {
                 object.lockableInstance().wait(javaSleepInterval(timeout));
@@ -1145,7 +1144,7 @@
     {
         @Override
         public LispObject execute(LispObject object)
-            throws ConditionThrowable
+
         {
             try {
                 object.lockableInstance().notify();
@@ -1164,7 +1163,7 @@
     {
         @Override
         public LispObject execute(LispObject object)
-            throws ConditionThrowable
+
         {
             try {
                 object.lockableInstance().notifyAll();

Modified: trunk/abcl/src/org/armedbear/lisp/Load.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Load.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Load.java	Fri Nov  6 15:07:54 2009
@@ -50,7 +50,7 @@
 public final class Load extends Lisp
 {
     public static final LispObject load(String filename)
-        throws ConditionThrowable
+
     {
         final LispThread thread = LispThread.currentThread();
         return load(new Pathname(filename),
@@ -93,7 +93,7 @@
                                         boolean verbose,
                                         boolean print,
                                         boolean ifDoesNotExist)
-        throws ConditionThrowable {
+        {
         return load(pathname, filename, verbose, print, ifDoesNotExist, false);
     }
 
@@ -103,7 +103,7 @@
                                         boolean print,
                                         boolean ifDoesNotExist,
                                         boolean returnLastResult)
-        throws ConditionThrowable
+
     {
         String dir = null;
         if (!Utilities.isFilenameAbsolute(filename)) {
@@ -268,7 +268,7 @@
     }
 
     public static final LispObject loadSystemFile(String filename)
-        throws ConditionThrowable
+
     {
         final LispThread thread = LispThread.currentThread();
         return loadSystemFile(filename,
@@ -278,7 +278,7 @@
     }
 
     public static final LispObject loadSystemFile(String filename, boolean auto)
-        throws ConditionThrowable
+
     {
         LispThread thread = LispThread.currentThread();
         if (auto) {
@@ -307,7 +307,7 @@
                                                   boolean verbose,
                                                   boolean print,
                                                   boolean auto)
-        throws ConditionThrowable
+
     {
         final int ARRAY_SIZE = 2;
         String[] candidates = new String[ARRAY_SIZE];
@@ -445,7 +445,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if (first == Keyword.VERSION) {
                 if (second.eql(_FASL_VERSION_.getSymbolValue())) {
@@ -466,7 +466,7 @@
                                                        boolean verbose,
                                                        boolean print,
                                                        boolean auto)
-        throws ConditionThrowable {
+        {
         return loadFileFromStream(pathname, truename, in, verbose, print, auto, false);
     }
 
@@ -477,7 +477,7 @@
                                                        boolean print,
                                                        boolean auto,
                                                        boolean returnLastResult)
-        throws ConditionThrowable
+
     {
         long start = System.currentTimeMillis();
         final LispThread thread = LispThread.currentThread();
@@ -541,13 +541,13 @@
 
     private static final LispObject loadStream(Stream in, boolean print,
                                                LispThread thread)
-        throws ConditionThrowable {
+        {
         return loadStream(in, print, thread, false);
     }
 
     private static final LispObject loadStream(Stream in, boolean print,
                                                LispThread thread, boolean returnLastResult)
-        throws ConditionThrowable
+
     {
         SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
         thread.bindSpecial(_LOAD_STREAM_, in);
@@ -583,7 +583,7 @@
     }
 
     private static final LispObject faslLoadStream(LispThread thread)
-        throws ConditionThrowable
+
     {
         Stream in = (Stream) _LOAD_STREAM_.symbolValue(thread);
         final Environment env = new Environment();
@@ -676,7 +676,7 @@
         @Override
         public LispObject execute(LispObject filespec, LispObject verbose,
                                   LispObject print, LispObject ifDoesNotExist)
-            throws ConditionThrowable {
+            {
             return load(filespec, verbose, print, ifDoesNotExist, NIL);
         }
     };
@@ -689,7 +689,7 @@
         @Override
         public LispObject execute(LispObject filespec, LispObject verbose,
                                   LispObject print, LispObject ifDoesNotExist)
-            throws ConditionThrowable {
+            {
             return load(filespec, verbose, print, ifDoesNotExist, T);
         }
     };
@@ -699,7 +699,7 @@
                                          LispObject print,
                                          LispObject ifDoesNotExist,
                                          LispObject returnLastResult)
-        throws ConditionThrowable {
+        {
         if (filespec instanceof Stream) {
             if (((Stream)filespec).isOpen()) {
                 LispObject pathname;
@@ -738,7 +738,7 @@
         new Primitive("load-system-file", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             final LispThread thread = LispThread.currentThread();
             return loadSystemFile(arg.getStringValue(),

Modified: trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
     {
     }
 
-    public LogicalPathname(String host, String rest) throws ConditionThrowable
+    public LogicalPathname(String host, String rest)
     {
         final int limit = rest.length();
         for (int i = 0; i < limit; i++) {
@@ -120,7 +120,7 @@
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-";
 
     public static final SimpleString canonicalizeStringComponent(AbstractString s)
-        throws ConditionThrowable
+
     {
         final int limit = s.length();
         for (int i = 0; i < limit; i++) {
@@ -137,13 +137,13 @@
     }
 
     public static Pathname translateLogicalPathname(LogicalPathname pathname)
-        throws ConditionThrowable
+
     {
         return (Pathname) Symbol.TRANSLATE_LOGICAL_PATHNAME.execute(pathname);
     }
 
     private static final LispObject parseDirectory(String s)
-        throws ConditionThrowable
+
     {
         LispObject result;
         if (s.charAt(0) == ';') {
@@ -185,7 +185,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.LOGICAL_PATHNAME)
             return T;
@@ -195,7 +195,7 @@
     }
 
     @Override
-    protected String getDirectoryNamestring() throws ConditionThrowable
+    protected String getDirectoryNamestring()
     {
         FastStringBuffer sb = new FastStringBuffer();
         // "If a pathname is converted to a namestring, the symbols NIL and
@@ -233,7 +233,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         final LispThread thread = LispThread.currentThread();
         boolean printReadably = (Symbol.PRINT_READABLY.symbolValue(thread) != NIL);
@@ -281,7 +281,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
                 AbstractString s = checkString(arg);
                 if (s.length() == 0) {
@@ -300,7 +300,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             // Check for a logical pathname host.
             String s = arg.getStringValue();

Modified: trunk/abcl/src/org/armedbear/lisp/MacroObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/MacroObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/MacroObject.java	Fri Nov  6 15:07:54 2009
@@ -48,20 +48,20 @@
   }
 
   @Override
-  public LispObject execute() throws ConditionThrowable
+  public LispObject execute()
   {
     return error(new UndefinedFunction(name));
   }
 
   @Override
-  public LispObject execute(LispObject arg) throws ConditionThrowable
+  public LispObject execute(LispObject arg)
   {
     return error(new UndefinedFunction(name));
   }
 
   @Override
   public LispObject execute(LispObject first, LispObject second)
-    throws ConditionThrowable
+
   {
     return error(new UndefinedFunction(name));
   }
@@ -69,7 +69,7 @@
   @Override
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third)
-    throws ConditionThrowable
+
   {
     return error(new UndefinedFunction(name));
   }
@@ -77,7 +77,7 @@
   @Override
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth)
-    throws ConditionThrowable
+
   {
     return error(new UndefinedFunction(name));
   }
@@ -86,7 +86,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth)
-    throws ConditionThrowable
+
   {
     return error(new UndefinedFunction(name));
   }
@@ -95,7 +95,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth)
-    throws ConditionThrowable
+
   {
     return error(new UndefinedFunction(name));
   }
@@ -105,7 +105,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh)
-    throws ConditionThrowable
+
   {
     return error(new UndefinedFunction(name));
   }
@@ -115,13 +115,13 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh, LispObject eighth)
-    throws ConditionThrowable
+
   {
     return error(new UndefinedFunction(name));
   }
 
   @Override
-  public LispObject execute(LispObject[] args) throws ConditionThrowable
+  public LispObject execute(LispObject[] args)
   {
     return error(new UndefinedFunction(name));
   }

Modified: trunk/abcl/src/org/armedbear/lisp/MathFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/MathFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/MathFunctions.java	Fri Nov  6 15:07:54 2009
@@ -39,13 +39,13 @@
     private static final Primitive SIN = new Primitive("sin", "radians")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return sin(arg);
         }
     };
 
-    private static LispObject sin(LispObject arg) throws ConditionThrowable
+    private static LispObject sin(LispObject arg)
     {
         if (arg instanceof DoubleFloat)
             return new DoubleFloat(Math.sin(((DoubleFloat)arg).value));
@@ -66,13 +66,13 @@
     private static final Primitive COS = new Primitive("cos", "radians")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return cos(arg);
         }
     };
 
-    private static LispObject cos(LispObject arg) throws ConditionThrowable
+    private static LispObject cos(LispObject arg)
     {
         if (arg instanceof DoubleFloat)
             return new DoubleFloat(Math.cos(((DoubleFloat)arg).value));
@@ -92,7 +92,7 @@
     private static final Primitive TAN = new Primitive("tan", "radians")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof DoubleFloat)
                 return new DoubleFloat(Math.tan(((DoubleFloat)arg).value));
@@ -106,13 +106,13 @@
     private static final Primitive ASIN = new Primitive("asin", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return asin(arg);
         }
     };
 
-    private static LispObject asin(LispObject arg) throws ConditionThrowable
+    private static LispObject asin(LispObject arg)
     {
         if (arg instanceof SingleFloat) {
             float f = ((SingleFloat)arg).value;
@@ -147,13 +147,13 @@
     private static final Primitive ACOS = new Primitive("acos", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return acos(arg);
         }
     };
 
-    private static LispObject acos(LispObject arg) throws ConditionThrowable
+    private static LispObject acos(LispObject arg)
     {
         if (arg instanceof DoubleFloat) {
             double d = ((DoubleFloat)arg).value;
@@ -190,7 +190,7 @@
         new Primitive("atan", "number1 &optional number2")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg.numberp())
                 return atan(arg);
@@ -206,7 +206,7 @@
         // y = -0     x = -0       -<PI>
         @Override
         public LispObject execute(LispObject y, LispObject x)
-            throws ConditionThrowable
+
         {
             if (!y.realp())
                 return type_error(y, Symbol.REAL);
@@ -223,7 +223,7 @@
         }
     };
 
-    private static LispObject atan(LispObject arg) throws ConditionThrowable
+    private static LispObject atan(LispObject arg)
     {
         if (arg instanceof Complex) {
             LispObject im = ((Complex)arg).imagpart;
@@ -251,13 +251,13 @@
     private static final Primitive SINH = new Primitive("sinh", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return sinh(arg);
         }
     };
 
-    private static LispObject sinh(LispObject arg) throws ConditionThrowable
+    private static LispObject sinh(LispObject arg)
     {
         if (arg instanceof Complex) {
             LispObject im = ((Complex)arg).getImaginaryPart();
@@ -301,13 +301,13 @@
     private static final Primitive COSH = new Primitive("cosh", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return cosh(arg);
         }
     };
 
-    private static LispObject cosh(LispObject arg) throws ConditionThrowable
+    private static LispObject cosh(LispObject arg)
     {
         if (arg instanceof Complex) {
             LispObject im = ((Complex)arg).getImaginaryPart();
@@ -351,7 +351,7 @@
     private static final Primitive TANH = new Primitive("tanh", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SingleFloat) {
                 try {
@@ -380,13 +380,13 @@
     private static final Primitive ASINH = new Primitive("asinh", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return asinh(arg);
         }
     };
 
-    private static LispObject asinh(LispObject arg) throws ConditionThrowable
+    private static LispObject asinh(LispObject arg)
     {
         if (arg instanceof Complex) {
             LispObject im = ((Complex)arg).getImaginaryPart();
@@ -413,13 +413,13 @@
     private static final Primitive ACOSH = new Primitive("acosh", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return acosh(arg);
         }
     };
 
-    private static LispObject acosh(LispObject arg) throws ConditionThrowable
+    private static LispObject acosh(LispObject arg)
     {
         if (arg instanceof Complex) {
             LispObject im = ((Complex)arg).getImaginaryPart();
@@ -450,13 +450,13 @@
     private static final Primitive ATANH = new Primitive("atanh", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return atanh(arg);
         }
     };
 
-    private static LispObject atanh(LispObject arg) throws ConditionThrowable
+    private static LispObject atanh(LispObject arg)
     {
         if (arg instanceof Complex) {
             LispObject im = ((Complex)arg).getImaginaryPart();
@@ -482,13 +482,13 @@
     private static final Primitive CIS = new Primitive("cis", "radians")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return cis(arg);
         }
     };
 
-    private static LispObject cis(LispObject arg) throws ConditionThrowable
+    private static LispObject cis(LispObject arg)
     {
         if (arg.realp())
             return Complex.getInstance(cos(arg), sin(arg));
@@ -499,13 +499,13 @@
     private static final Primitive EXP = new Primitive("exp", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return exp(arg);
         }
     };
 
-    private static LispObject exp(LispObject arg) throws ConditionThrowable
+    private static LispObject exp(LispObject arg)
     {
         if (arg.realp()) {
             if (arg instanceof DoubleFloat) {
@@ -527,13 +527,13 @@
     private static final Primitive SQRT = new Primitive("sqrt", "number")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return sqrt(arg);
         }
     };
 
-    private static final LispObject sqrt(LispObject obj) throws ConditionThrowable
+    private static final LispObject sqrt(LispObject obj)
     {
         if (obj instanceof DoubleFloat) {
             if (obj.minusp())
@@ -564,13 +564,13 @@
         new Primitive("log", "number &optional base")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return log(arg);
         }
         @Override
         public LispObject execute(LispObject number, LispObject base)
-            throws ConditionThrowable
+
         {
             if (number.realp() && !number.minusp()
                 && base.isEqualTo(Fixnum.getInstance(10))) {
@@ -592,7 +592,7 @@
         }
     };
 
-    private static final LispObject log(LispObject obj) throws ConditionThrowable
+    private static final LispObject log(LispObject obj)
     {
         if (obj.realp() && !obj.minusp()) {
             // Result is real.
@@ -648,7 +648,7 @@
     {
         @Override
         public LispObject execute(LispObject base, LispObject power)
-            throws ConditionThrowable
+
         {
             if (power.zerop()) {
                 if (power instanceof Fixnum) {
@@ -745,10 +745,9 @@
      *
      * @param number
      * @return number or signals an appropriate error
-     * @throws org.armedbear.lisp.ConditionThrowable
      */
     private final static LispObject OverUnderFlowCheck(LispObject number)
-            throws ConditionThrowable
+
     {
         if (number instanceof Complex) {
             OverUnderFlowCheck(((Complex)number).realpart);
@@ -775,10 +774,9 @@
      *
      * @param number
      * @return number or signals an appropriate error
-     * @throws org.armedbear.lisp.ConditionThrowable
      */
     final static float OverUnderFlowCheck(float number)
-            throws ConditionThrowable
+
     {
         if (TRAP_OVERFLOW) {
             if (Float.isInfinite(number))
@@ -795,10 +793,9 @@
      *
      * @param number
      * @return number or signals an appropriate error
-     * @throws org.armedbear.lisp.ConditionThrowable
      */
     public final static double OverUnderFlowCheck(double number)
-            throws ConditionThrowable
+
     {
         if (TRAP_OVERFLOW) {
             if (Double.isInfinite(number))
@@ -815,10 +812,9 @@
      *
      * @param base A value of any type
      * @param power An integer (fixnum or bignum) value
-     * @throws org.armedbear.lisp.ConditionThrowable
      */
     private static final LispObject intexp(LispObject base, LispObject power)
-        throws ConditionThrowable
+
     {
         if (power.isEqualTo(0))
             return Fixnum.ONE;

Modified: trunk/abcl/src/org/armedbear/lisp/Nil.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Nil.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Nil.java	Fri Nov  6 15:07:54 2009
@@ -69,7 +69,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.NULL)
             return T;
@@ -135,7 +135,7 @@
     }
 
     @Override
-    public LispObject nthcdr(int n) throws ConditionThrowable
+    public LispObject nthcdr(int n)
     {
         if (n < 0)
             return type_error(Fixnum.getInstance(n),
@@ -156,7 +156,7 @@
     }
 
     @Override
-    public LispObject NTH(int index) throws ConditionThrowable
+    public LispObject NTH(int index)
     {
         if (index < 0)
             error(new TypeError(String.valueOf(index) +
@@ -165,7 +165,7 @@
     }
 
     @Override
-    public LispObject NTH(LispObject arg) throws ConditionThrowable
+    public LispObject NTH(LispObject arg)
     {
         int index;
                 if (arg instanceof Fixnum) {
@@ -182,7 +182,7 @@
     }
 
     @Override
-    public LispObject elt(int index) throws ConditionThrowable
+    public LispObject elt(int index)
     {
         return error(new TypeError("ELT: invalid index " + index + " for " + this + "."));
     }

Modified: trunk/abcl/src/org/armedbear/lisp/NilVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/NilVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/NilVector.java	Fri Nov  6 15:07:54 2009
@@ -37,13 +37,13 @@
 {
     private int capacity;
 
-    public NilVector(int capacity) throws ConditionThrowable
+    public NilVector(int capacity)
     {
         this.capacity = capacity;
     }
 
     @Override
-    public char[] chars() throws ConditionThrowable
+    public char[] chars()
     {
         if (capacity != 0)
             accessError();
@@ -51,7 +51,7 @@
     }
 
     @Override
-    public char[] getStringChars() throws ConditionThrowable
+    public char[] getStringChars()
     {
         if (capacity != 0)
             accessError();
@@ -59,7 +59,7 @@
     }
 
     @Override
-    public String getStringValue() throws ConditionThrowable
+    public String getStringValue()
     {
         if (capacity != 0)
             accessError();
@@ -79,7 +79,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.NIL_VECTOR)
             return T;
@@ -103,7 +103,7 @@
     }
 
     @Override
-    public boolean equal(LispObject obj) throws ConditionThrowable
+    public boolean equal(LispObject obj)
     {
         if (obj instanceof NilVector) {
             if (capacity != ((NilVector)obj).capacity)
@@ -128,7 +128,7 @@
         return false;
     }
 
-    public String getValue() throws ConditionThrowable
+    public String getValue()
     {
         if (capacity == 0)
             return "";
@@ -156,31 +156,31 @@
     }
 
     @Override
-    public LispObject CHAR(int index) throws ConditionThrowable
+    public LispObject CHAR(int index)
     {
         return accessError();
     }
 
     @Override
-    public LispObject SCHAR(int index) throws ConditionThrowable
+    public LispObject SCHAR(int index)
     {
         return accessError();
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         return accessError();
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         storeError(newValue);
     }
 
     @Override
-    public char charAt(int index) throws ConditionThrowable
+    public char charAt(int index)
     {
         accessError();
         // Not reached.
@@ -188,13 +188,13 @@
     }
 
     @Override
-    public void setCharAt(int index, char c) throws ConditionThrowable
+    public void setCharAt(int index, char c)
     {
         storeError(LispCharacter.getInstance(c));
     }
 
     @Override
-    public LispObject subseq(int start, int end) throws ConditionThrowable
+    public LispObject subseq(int start, int end)
     {
         if (capacity == 0 && start == 0 && end == 0)
             return this;
@@ -202,34 +202,34 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         storeError(obj);
     }
 
     @Override
-    public void fill(char c) throws ConditionThrowable
+    public void fill(char c)
     {
         storeError(LispCharacter.getInstance(c));
     }
 
     @Override
-    public void shrink(int n) throws ConditionThrowable
+    public void shrink(int n)
     {
     }
 
     @Override
-    public LispObject reverse() throws ConditionThrowable
+    public LispObject reverse()
     {
         return accessError();
     }
 
-    public LispObject accessError() throws ConditionThrowable
+    public LispObject accessError()
     {
         return error(new TypeError("Attempt to access an array of element type NIL."));
     }
 
-    private void storeError(LispObject obj) throws ConditionThrowable
+    private void storeError(LispObject obj)
     {
         error(new TypeError(String.valueOf(obj) + " is not of type NIL."));
     }
@@ -250,7 +250,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        LispObject initialElement,
                                        LispObject initialContents)
-        throws ConditionThrowable
+
     {
         accessError();
         // Not reached.
@@ -260,7 +260,7 @@
     @Override
     public AbstractVector adjustArray(int size, AbstractArray displacedTo,
                                        int displacement)
-        throws ConditionThrowable
+
     {
         accessError();
         // Not reached.

Modified: trunk/abcl/src/org/armedbear/lisp/Operator.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Operator.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Operator.java	Fri Nov  6 15:07:54 2009
@@ -60,7 +60,7 @@
     }
 
     @Override
-    public LispObject getParts() throws ConditionThrowable
+    public LispObject getParts()
     {
         LispObject result = NIL;
         result = result.push(new Cons("lambda-name", lambdaName));

Modified: trunk/abcl/src/org/armedbear/lisp/Package.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Package.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Package.java	Fri Nov  6 15:07:54 2009
@@ -95,7 +95,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.PACKAGE)
             return T;
@@ -135,7 +135,7 @@
         return nicknames;
     }
 
-    public final synchronized boolean delete() throws ConditionThrowable
+    public final synchronized boolean delete()
     {
         if (name != null) {
             Packages.deletePackage(this);
@@ -162,7 +162,7 @@
     }
 
     public final synchronized void rename(String newName, LispObject newNicks)
-        throws ConditionThrowable
+
     {
         ArrayList<String> arrayList = null;
         while (newNicks != NIL) {
@@ -198,14 +198,14 @@
 
     // Returns null if symbol is not accessible in this package.
     public synchronized Symbol findAccessibleSymbol(String name)
-        throws ConditionThrowable
+
     {
         return findAccessibleSymbol(new SimpleString(name));
     }
 
     // Returns null if symbol is not accessible in this package.
     public synchronized Symbol findAccessibleSymbol(SimpleString name)
-        throws ConditionThrowable
+
     {
         // Look in external and internal symbols of this package.
         Symbol symbol = externalSymbols.get(name);
@@ -230,7 +230,7 @@
     }
 
     public synchronized LispObject findSymbol(String name)
-        throws ConditionThrowable
+
     {
         final SimpleString s = new SimpleString(name);
         final LispThread thread = LispThread.currentThread();
@@ -366,7 +366,7 @@
     }
 
     public synchronized Symbol internAndExport(String symbolName)
-        throws ConditionThrowable
+
     {
         final SimpleString s = new SimpleString(symbolName);
         final int hash = s.sxhash();
@@ -401,7 +401,7 @@
     }
 
     public synchronized LispObject unintern(final Symbol symbol)
-        throws ConditionThrowable
+
     {
         final String symbolName = symbol.getName();
         final boolean shadow;
@@ -453,7 +453,7 @@
         return T;
     }
 
-    public synchronized void importSymbol(Symbol symbol) throws ConditionThrowable
+    public synchronized void importSymbol(Symbol symbol)
     {
         if (symbol.getPackage() == this)
             return; // Nothing to do.
@@ -471,7 +471,7 @@
             symbol.setPackage(this);
     }
 
-    public synchronized void export(final Symbol symbol) throws ConditionThrowable
+    public synchronized void export(final Symbol symbol)
     {
         final String symbolName = symbol.getName();
         boolean added = false;
@@ -527,7 +527,7 @@
     }
 
     public synchronized void unexport(final Symbol symbol)
-        throws ConditionThrowable
+
     {
         if (symbol.getPackage() == this) {
             if (externalSymbols.get(symbol.name) == symbol) {
@@ -554,7 +554,7 @@
     }
 
     public synchronized void shadow(final String symbolName)
-        throws ConditionThrowable
+
     {
         if (shadowingSymbols == null)
             shadowingSymbols = new HashMap<String,Symbol>();
@@ -576,7 +576,7 @@
         shadowingSymbols.put(symbolName, symbol);
     }
 
-    public synchronized void shadowingImport(Symbol symbol) throws ConditionThrowable
+    public synchronized void shadowingImport(Symbol symbol)
     {
         LispObject where = NIL;
         final String symbolName = symbol.getName();
@@ -622,7 +622,7 @@
     // "USE-PACKAGE causes PACKAGE to inherit all the external symbols of
     // PACKAGES-TO-USE. The inherited symbols become accessible as internal
     // symbols of PACKAGE."
-    public void usePackage(Package pkg) throws ConditionThrowable
+    public void usePackage(Package pkg)
     {
         if (useList == null)
             useList = NIL;
@@ -654,7 +654,7 @@
         }
     }
 
-    public void unusePackage(Package pkg) throws ConditionThrowable
+    public void unusePackage(Package pkg)
     {
         if (useList instanceof Cons) {
             if (memq(pkg, useList)) {
@@ -674,7 +674,7 @@
         }
     }
 
-    public final void addNickname(String s) throws ConditionThrowable
+    public final void addNickname(String s)
     {
         // This call will signal an error if there's a naming conflict.
         Packages.addNickname(this, s);
@@ -714,7 +714,7 @@
         return useList;
     }
 
-    public boolean uses(LispObject pkg) throws ConditionThrowable
+    public boolean uses(LispObject pkg)
     {
         return (useList instanceof Cons) && memq(pkg, useList);
     }
@@ -849,7 +849,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (_PRINT_FASL_.symbolValue() != NIL && name != null) {
             FastStringBuffer sb = new FastStringBuffer("#.(FIND-PACKAGE \"");

Modified: trunk/abcl/src/org/armedbear/lisp/PackageError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/PackageError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/PackageError.java	Fri Nov  6 15:07:54 2009
@@ -35,14 +35,14 @@
 
 public final class PackageError extends LispError
 {
-    public PackageError(LispObject initArgs) throws ConditionThrowable
+    public PackageError(LispObject initArgs)
     {
         super(StandardClass.PACKAGE_ERROR);
         initialize(initArgs);
     }
 
     @Override
-    protected void initialize(LispObject initArgs) throws ConditionThrowable
+    protected void initialize(LispObject initArgs)
     {
         super.initialize(initArgs);
 
@@ -76,7 +76,7 @@
         setPackage(pkg);
     }
 
-    public PackageError(String message) throws ConditionThrowable
+    public PackageError(String message)
     {
         super(StandardClass.PACKAGE_ERROR);
         setFormatControl(message);
@@ -95,7 +95,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.PACKAGE_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java	Fri Nov  6 15:07:54 2009
@@ -40,7 +40,7 @@
     private static final Primitive PACKAGEP = new Primitive("packagep", "object")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return arg instanceof Package ? T : NIL;
         }
@@ -52,7 +52,7 @@
         new Primitive("package-name", "package")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPackage(arg).NAME();
         }
@@ -64,7 +64,7 @@
         new Primitive("package-nicknames", "package")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPackage(arg).packageNicknames();
         }
@@ -76,7 +76,7 @@
         new Primitive("package-use-list", "package")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPackage(arg).getUseList();
         }
@@ -88,7 +88,7 @@
         new Primitive("package-used-by-list", "package")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPackage(arg).getUsedByList();
         }
@@ -100,7 +100,7 @@
         new Primitive("%import", PACKAGE_SYS, false)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length == 0 || args.length > 2)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -124,7 +124,7 @@
         new Primitive("unexport", "symbols &optional package")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length == 0 || args.length > 2)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -148,7 +148,7 @@
         new Primitive("shadow", "symbol-names &optional package")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length == 0 || args.length > 2)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -172,7 +172,7 @@
         new Primitive("shadowing-import", "symbols &optional package")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length == 0 || args.length > 2)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -196,7 +196,7 @@
         new Primitive("package-shadowing-symbols", "package")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPackage(arg).getShadowingSymbols();
         }
@@ -207,7 +207,7 @@
         new Primitive("delete-package", "package")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPackage(arg).delete() ? T : NIL;
         }
@@ -219,7 +219,7 @@
         new Primitive("unuse-package", "packages-to-unuse &optional package")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 1 || args.length > 2)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -246,7 +246,7 @@
         new Primitive("rename-package", "package new-name &optional new-nicknames")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length < 2 || args.length > 3)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -274,7 +274,7 @@
         new Primitive("%defpackage", PACKAGE_SYS, false)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 10)
                 return error(new WrongNumberOfArgumentsException(this));

Modified: trunk/abcl/src/org/armedbear/lisp/Packages.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Packages.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Packages.java	Fri Nov  6 15:07:54 2009
@@ -63,7 +63,7 @@
   }
 
   public static final synchronized void addPackage(Package pkg)
-    throws ConditionThrowable
+
   {
     final String name = pkg.getName();
     if (map.get(name) != null)
@@ -91,7 +91,7 @@
   }
 
   public static final synchronized Package makePackage(String name)
-    throws ConditionThrowable
+
   {
     if (map.get(name) != null)
       {
@@ -106,7 +106,7 @@
   }
 
   public static final synchronized void addNickname(Package pkg, String nickname)
-    throws ConditionThrowable
+
   {
     Object obj = map.get(nickname);
     if (obj != null && obj != pkg)

Modified: trunk/abcl/src/org/armedbear/lisp/ParseError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ParseError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ParseError.java	Fri Nov  6 15:07:54 2009
@@ -35,14 +35,14 @@
 
 public final class ParseError extends LispError
 {
-    public ParseError(String message) throws ConditionThrowable
+    public ParseError(String message)
     {
         super(StandardClass.PARSE_ERROR);
         setFormatControl(message);
         setFormatArguments(NIL);
     }
 
-    public ParseError(LispObject initArgs) throws ConditionThrowable
+    public ParseError(LispObject initArgs)
     {
         super(StandardClass.PARSE_ERROR);
         initialize(initArgs);
@@ -61,7 +61,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.PARSE_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/Pathname.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Pathname.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Pathname.java	Fri Nov  6 15:07:54 2009
@@ -58,12 +58,12 @@
     {
     }
 
-    public Pathname(String s) throws ConditionThrowable
+    public Pathname(String s)
     {
         init(s);
     }
 
-    public Pathname(URL url) throws ConditionThrowable
+    public Pathname(URL url)
     {
         String protocol = url.getProtocol();
         if ("jar".equals(protocol)) {
@@ -109,7 +109,7 @@
         error(new LispError("Unsupported URL: \"" + url.toString() + '"'));
     }
 
-    private final void init(String s) throws ConditionThrowable
+    private final void init(String s)
     {
         if (s == null)
             return;
@@ -230,7 +230,7 @@
     }
 
     private static final LispObject parseDirectory(String d)
-        throws ConditionThrowable
+
     {
         if (d.equals("/") || (Utilities.isPlatformWindows && d.equals("\\")))
             return new Cons(Keyword.ABSOLUTE);
@@ -261,7 +261,7 @@
     }
 
     @Override
-    public LispObject getParts() throws ConditionThrowable
+    public LispObject getParts()
     {
         LispObject parts = NIL;
         parts = parts.push(new Cons("HOST", host));
@@ -286,7 +286,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.PATHNAME)
             return T;
@@ -300,7 +300,7 @@
         return device;
     }
 
-    public String getNamestring() throws ConditionThrowable
+    public String getNamestring()
     {
         if (namestring != null)
             return namestring;
@@ -378,7 +378,7 @@
         return namestring = sb.toString();
     }
 
-    protected String getDirectoryNamestring() throws ConditionThrowable
+    protected String getDirectoryNamestring()
     {
         validateDirectory(true);
         FastStringBuffer sb = new FastStringBuffer();
@@ -430,7 +430,7 @@
     }
 
     @Override
-    public boolean equal(LispObject obj) throws ConditionThrowable
+    public boolean equal(LispObject obj)
     {
         if (this == obj)
             return true;
@@ -472,7 +472,7 @@
     }
 
     @Override
-    public boolean equalp(LispObject obj) throws ConditionThrowable
+    public boolean equalp(LispObject obj)
     {
         return equal(obj);
     }
@@ -488,7 +488,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         try {
             final LispThread thread = LispThread.currentThread();
@@ -586,13 +586,13 @@
                       LOGICAL_PATHNAME_TRANSLATIONS);
 
     public static Pathname parseNamestring(String s)
-        throws ConditionThrowable
+
     {
         return new Pathname(s);
     }
 
     public static Pathname parseNamestring(AbstractString namestring)
-        throws ConditionThrowable
+
     {
         // Check for a logical pathname host.
         String s = namestring.getStringValue();
@@ -606,7 +606,7 @@
 
     public static Pathname parseNamestring(AbstractString namestring,
                                            AbstractString host)
-        throws ConditionThrowable
+
     {
         // Look for a logical pathname host in the namestring.
         String s = namestring.getStringValue();
@@ -642,7 +642,7 @@
     }
 
     private static final void checkCaseArgument(LispObject arg)
-        throws ConditionThrowable
+
     {
         if (arg != Keyword.COMMON && arg != Keyword.LOCAL)
             type_error(arg, list(Symbol.MEMBER, Keyword.COMMON,
@@ -655,7 +655,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             checkCaseArgument(second);
             return coerceToPathname(first).host;
@@ -668,7 +668,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             checkCaseArgument(second);
             return coerceToPathname(first).device;
@@ -681,7 +681,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             checkCaseArgument(second);
             return coerceToPathname(first).directory;
@@ -694,7 +694,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             checkCaseArgument(second);
             return coerceToPathname(first).name;
@@ -707,7 +707,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             checkCaseArgument(second);
             return coerceToPathname(first).type;
@@ -719,7 +719,7 @@
         new Primitive("pathname-version", "pathname")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPathname(arg).version;
         }
@@ -731,7 +731,7 @@
         new Primitive("namestring", "pathname")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             Pathname pathname = coerceToPathname(arg);
             String namestring = pathname.getNamestring();
@@ -748,7 +748,7 @@
         new Primitive("directory-namestring", "pathname")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return new SimpleString(coerceToPathname(arg).getDirectoryNamestring());
         }
@@ -759,7 +759,7 @@
         new Primitive("pathname", "pathspec")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPathname(arg);
         }
@@ -773,7 +773,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             final AbstractString namestring = checkString(first);
@@ -805,7 +805,7 @@
     {
         @Override
         public LispObject execute(LispObject[] args)
-            throws ConditionThrowable
+
         {
             return _makePathname(args);
         }
@@ -813,13 +813,13 @@
 
     // Used by the #p reader.
     public static final Pathname makePathname(LispObject args)
-        throws ConditionThrowable
+
     {
         return _makePathname(args.copyToArray());
     }
 
     private static final Pathname _makePathname(LispObject[] args)
-        throws ConditionThrowable
+
     {
         if (args.length % 2 != 0)
             error(new ProgramError("Odd number of keyword arguments."));
@@ -937,7 +937,7 @@
     }
 
     private static final AbstractString validateStringComponent(AbstractString s)
-        throws ConditionThrowable
+
     {
         final int limit = s.length();
         for (int i = 0; i < limit; i++) {
@@ -954,7 +954,7 @@
     }
 
     private final boolean validateDirectory(boolean signalError)
-        throws ConditionThrowable
+
     {
         LispObject temp = directory;
         while (temp != NIL) {
@@ -983,7 +983,7 @@
         new Primitive("pathnamep", "object")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return arg instanceof Pathname ? T : NIL;
         }
@@ -994,7 +994,7 @@
         new Primitive("logical-pathname-p", PACKAGE_SYS, true, "object")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return arg instanceof LogicalPathname ? T : NIL;
         }
@@ -1005,7 +1005,7 @@
         new Primitive("user-homedir-pathname", "&optional host")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             switch (args.length) {
                 case 0: {
@@ -1027,7 +1027,7 @@
         new Primitive("list-directory", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             Pathname pathname = coerceToPathname(arg);
             if (pathname instanceof LogicalPathname)
@@ -1063,7 +1063,7 @@
         }
     };
 
-    public boolean isWild() throws ConditionThrowable
+    public boolean isWild()
     {
         if (host == Keyword.WILD || host == Keyword.WILD_INFERIORS)
             return true;
@@ -1090,7 +1090,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             Pathname pathname = coerceToPathname(first);
             if (second == NIL)
@@ -1131,7 +1131,7 @@
                       "pathname &optional default-pathname default-version")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             Pathname pathname = coerceToPathname(arg);
             Pathname defaultPathname =
@@ -1141,7 +1141,7 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             Pathname pathname = coerceToPathname(first);
             Pathname defaultPathname =
@@ -1152,7 +1152,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             Pathname pathname = coerceToPathname(first);
             Pathname defaultPathname =
@@ -1165,7 +1165,7 @@
     public static final Pathname mergePathnames(Pathname pathname,
                                                 Pathname defaultPathname,
                                                 LispObject defaultVersion)
-        throws ConditionThrowable
+
     {
         Pathname p;
         if (pathname instanceof LogicalPathname)
@@ -1226,7 +1226,7 @@
 
     private static final LispObject mergeDirectories(LispObject dir,
                                                      LispObject defaultDir)
-        throws ConditionThrowable
+
     {
         if (dir == NIL)
             return defaultDir;
@@ -1262,7 +1262,7 @@
 
     public static final LispObject truename(LispObject arg,
                                             boolean errorIfDoesNotExist)
-        throws ConditionThrowable
+
     {
         Pathname pathname = coerceToPathname(arg);
         if (pathname instanceof LogicalPathname)
@@ -1303,7 +1303,7 @@
         new Primitive("mkdir", PACKAGE_SYS, false)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             final Pathname pathname = coerceToPathname(arg);
             if (pathname.isWild())
@@ -1323,7 +1323,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             final Pathname original = (Pathname) truename(first, true);
             final String originalNamestring = original.getNamestring();
@@ -1360,7 +1360,7 @@
         new Primitive("file-namestring", "pathname")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             Pathname p = coerceToPathname(arg);
             FastStringBuffer sb = new FastStringBuffer();
@@ -1384,7 +1384,7 @@
         new Primitive("host-namestring", "pathname")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return coerceToPathname(arg).host;
         }

Modified: trunk/abcl/src/org/armedbear/lisp/Primitive.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Primitive.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Primitive.java	Fri Nov  6 15:07:54 2009
@@ -94,14 +94,14 @@
     }
 
     @Override
-    public LispObject execute() throws ConditionThrowable
+    public LispObject execute()
     {
         LispObject[] args = new LispObject[0];
         return execute(args);
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         LispObject[] args = new LispObject[1];
         args[0] = arg;
@@ -110,7 +110,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         LispObject[] args = new LispObject[2];
         args[0] = first;
@@ -121,7 +121,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third)
-        throws ConditionThrowable
+
     {
         LispObject[] args = new LispObject[3];
         args[0] = first;
@@ -133,7 +133,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
     {
         LispObject[] args = new LispObject[4];
         args[0] = first;
@@ -147,7 +147,7 @@
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth,
                               LispObject fifth)
-        throws ConditionThrowable
+
     {
         LispObject[] args = new LispObject[5];
         args[0] = first;
@@ -162,7 +162,7 @@
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth)
-        throws ConditionThrowable
+
     {
         LispObject[] args = new LispObject[6];
         args[0] = first;
@@ -179,7 +179,7 @@
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth,
                               LispObject seventh)
-        throws ConditionThrowable
+
     {
         LispObject[] args = new LispObject[7];
         args[0] = first;
@@ -197,7 +197,7 @@
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth,
                               LispObject seventh, LispObject eighth)
-        throws ConditionThrowable
+
     {
         LispObject[] args = new LispObject[8];
         args[0] = first;

Modified: trunk/abcl/src/org/armedbear/lisp/Primitives.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Primitives.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Primitives.java	Fri Nov  6 15:07:54 2009
@@ -48,7 +48,7 @@
         return Fixnum.ONE;
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg.numberp())
           return arg;
@@ -56,12 +56,12 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.multiplyBy(second);
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         LispObject result = Fixnum.ONE;
         for (int i = 0; i < args.length; i++)
@@ -75,23 +75,23 @@
     new Primitive(Symbol.SLASH, "numerator &rest denominators")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Fixnum.ONE.divideBy(arg);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.divideBy(second);
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         LispObject result = args[0];
         for (int i = 1; i < args.length; i++)
@@ -105,12 +105,12 @@
     new Primitive(Symbol.MIN, "&rest reals")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg.realp())
           return arg;
@@ -118,12 +118,12 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.isLessThan(second) ? first : second;
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         LispObject result = args[0];
         if (!result.realp())
@@ -142,12 +142,12 @@
     new Primitive(Symbol.MAX, "&rest reals")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg.realp())
           return arg;
@@ -155,12 +155,12 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.isGreaterThan(second) ? first : second;
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         LispObject result = args[0];
         if (!result.realp())
@@ -179,7 +179,7 @@
     new Primitive(Symbol.IDENTITY, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg;
       }
@@ -190,7 +190,7 @@
     new Primitive(Symbol.COMPILED_FUNCTION_P, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.typep(Symbol.COMPILED_FUNCTION);
       }
@@ -201,7 +201,7 @@
     new Primitive(Symbol.CONSP, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof Cons ? T : NIL;
       }
@@ -212,7 +212,7 @@
     new Primitive(Symbol.LISTP, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.LISTP();
       }
@@ -223,7 +223,7 @@
     new Primitive(Symbol.ABS, "number")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.ABS();
       }
@@ -234,7 +234,7 @@
     new Primitive(Symbol.ARRAYP, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof AbstractArray ? T : NIL;
       }
@@ -245,7 +245,7 @@
     new Primitive(Symbol.ARRAY_HAS_FILL_POINTER_P, "array")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkArray(arg).hasFillPointer() ? T : NIL;
           }
@@ -256,7 +256,7 @@
     new Primitive(Symbol.VECTORP, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.VECTORP();
       }
@@ -267,7 +267,7 @@
     new Primitive(Symbol.SIMPLE_VECTOR_P, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof SimpleVector ? T : NIL;
       }
@@ -278,7 +278,7 @@
     new Primitive(Symbol.BIT_VECTOR_P, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof AbstractBitVector ? T : NIL;
       }
@@ -289,7 +289,7 @@
     new Primitive(Symbol.SIMPLE_BIT_VECTOR_P, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.typep(Symbol.SIMPLE_BIT_VECTOR);
       }
@@ -300,7 +300,7 @@
     new Primitive("%eval", PACKAGE_SYS, false, "form")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return eval(arg, new Environment(), LispThread.currentThread());
       }
@@ -311,7 +311,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first == second ? T : NIL;
       }
@@ -322,7 +322,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.eql(second) ? T : NIL;
       }
@@ -333,7 +333,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.equal(second) ? T : NIL;
       }
@@ -344,7 +344,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.equalp(second) ? T : NIL;
       }
@@ -395,7 +395,7 @@
     new Primitive(Symbol.VALUES_LIST, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg == NIL)
           return LispThread.currentThread().setValues();
@@ -411,7 +411,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return new Cons(first, second);
       }
@@ -422,7 +422,7 @@
     new Primitive(Symbol.LENGTH, "sequence")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.LENGTH();
       }
@@ -434,7 +434,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
             return first.elt(Fixnum.getValue(second));
       }
@@ -444,7 +444,7 @@
   private static final Primitive ATOM = new Primitive(Symbol.ATOM, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof Cons ? NIL : T;
       }
@@ -455,13 +455,13 @@
     new Primitive(Symbol.CONSTANTP, "form &optional environment")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.constantp() ? T : NIL;
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.constantp() ? T : NIL;
       }
@@ -472,7 +472,7 @@
     new Primitive(Symbol.FUNCTIONP, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return (arg instanceof Function || arg instanceof StandardGenericFunction) ? T : NIL;
       }
@@ -483,7 +483,7 @@
     new Primitive(Symbol.SPECIAL_OPERATOR_P, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.isSpecialOperator() ? T : NIL;
       }
@@ -494,7 +494,7 @@
     new Primitive(Symbol.SYMBOLP, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof Symbol ? T : NIL;
       }
@@ -504,7 +504,7 @@
   private static final Primitive ENDP = new Primitive(Symbol.ENDP, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.endp() ? T : NIL;
       }
@@ -514,7 +514,7 @@
   private static final Primitive NULL = new Primitive(Symbol.NULL, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg == NIL ? T : NIL;
       }
@@ -524,7 +524,7 @@
   private static final Primitive NOT = new Primitive(Symbol.NOT, "x")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg == NIL ? T : NIL;
       }
@@ -534,7 +534,7 @@
   private static final Primitive PLUSP = new Primitive(Symbol.PLUSP, "real")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.PLUSP();
       }
@@ -545,7 +545,7 @@
     new Primitive(Symbol.MINUSP, "real")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.MINUSP();
       }
@@ -556,7 +556,7 @@
     new Primitive(Symbol.ZEROP, "number")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.ZEROP();
       }
@@ -567,7 +567,7 @@
     new Primitive("fixnump", PACKAGE_EXT, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg instanceof Fixnum ? T : NIL;
       }
@@ -578,7 +578,7 @@
     new Primitive(Symbol.SYMBOL_VALUE, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final LispObject value;
         value = checkSymbol(arg).symbolValue();
@@ -595,7 +595,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
             return LispThread.currentThread().setSpecialVariable(checkSymbol(first),
                                                                  second);
@@ -608,7 +608,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         first.setCar(second);
         return first;
@@ -621,7 +621,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         first.setCdr(second);
         return first;
@@ -638,7 +638,7 @@
         return Fixnum.ZERO;
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg.numberp())
           return arg;
@@ -646,19 +646,19 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.add(second);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         return first.add(second).add(third);
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         LispObject result = Fixnum.ZERO;
         final int length = args.length;
@@ -673,7 +673,7 @@
     new Primitive(Symbol.ONE_PLUS, "number")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.incr();
       }
@@ -684,23 +684,23 @@
     new Primitive(Symbol.MINUS, "minuend &rest subtrahends")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.negate();
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.subtract(second);
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         LispObject result = args[0];
         for (int i = 1; i < args.length; i++)
@@ -714,7 +714,7 @@
     new Primitive(Symbol.ONE_MINUS, "number")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.decr();
       }
@@ -726,7 +726,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args == NIL)
           return error(new WrongNumberOfArgumentsException(this));
@@ -747,7 +747,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args == NIL)
           return error(new WrongNumberOfArgumentsException(this));
@@ -768,7 +768,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
             checkStream(second)._writeString(first.writeToString());
             return first;
@@ -781,7 +781,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final LispObject out;
             if (second == T)
@@ -800,7 +800,7 @@
     new Primitive("%write-to-string", PACKAGE_SYS, false)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return new SimpleString(arg.writeToString());
       }
@@ -811,7 +811,7 @@
     new Primitive("%stream-terpri", PACKAGE_SYS, true, "output-stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             checkStream(arg)._writeChar('\n');
             return NIL;
@@ -823,7 +823,7 @@
     new Primitive("%terpri", PACKAGE_SYS, false, "output-stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg == T)
           arg = Symbol.TERMINAL_IO.symbolValue();
@@ -841,7 +841,7 @@
     new Primitive("%fresh-line", PACKAGE_SYS, false, "output-stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg == T)
           arg = Symbol.TERMINAL_IO.symbolValue();
@@ -860,7 +860,7 @@
     new Primitive(Symbol.BOUNDP, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final Symbol symbol;
         symbol = checkSymbol(arg);
@@ -881,7 +881,7 @@
     new Primitive(Symbol.FBOUNDP, "name")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Symbol)
           return arg.getSymbolFunction() != null ? T : NIL;
@@ -899,7 +899,7 @@
     new Primitive(Symbol.FMAKUNBOUND, "name")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Symbol)
           {
@@ -920,7 +920,7 @@
     new Primitive("setf-function-name-p", PACKAGE_SYS, true, "thing")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return isValidSetfFunctionName(arg) ? T : NIL;
       }
@@ -932,7 +932,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return remprop(checkSymbol(first), second);
       }
@@ -954,7 +954,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         if (first == NIL)
           return second;
@@ -975,7 +975,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first == NIL)
           return execute(second, third);
@@ -1000,7 +1000,7 @@
         return result;
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         Cons result = null;
         Cons splice = null;
@@ -1057,7 +1057,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         if (first == NIL)
           return second;
@@ -1076,7 +1076,7 @@
         return type_error(first, Symbol.LIST);
       }
       @Override
-      public LispObject execute(LispObject[] array) throws ConditionThrowable
+      public LispObject execute(LispObject[] array)
       {
         LispObject result = null;
         Cons splice = null;
@@ -1122,7 +1122,7 @@
     new Primitive(Symbol.EQUALS, "&rest numbers")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
@@ -1133,14 +1133,14 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.isEqualTo(second) ? T : NIL;
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first.isEqualTo(second) && second.isEqualTo(third))
           return T;
@@ -1148,7 +1148,7 @@
           return NIL;
       }
       @Override
-      public LispObject execute(LispObject[] array) throws ConditionThrowable
+      public LispObject execute(LispObject[] array)
       {
         final int length = array.length;
         final LispObject obj = array[0];
@@ -1167,7 +1167,7 @@
     new Primitive(Symbol.NOT_EQUALS, "&rest numbers")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
@@ -1178,14 +1178,14 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.isNotEqualTo(second) ? T : NIL;
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first.isEqualTo(second))
           return NIL;
@@ -1196,7 +1196,7 @@
         return T;
       }
       @Override
-      public LispObject execute(LispObject[] array) throws ConditionThrowable
+      public LispObject execute(LispObject[] array)
       {
         final int length = array.length;
         for (int i = 0; i < length; i++)
@@ -1218,7 +1218,7 @@
     new Primitive(Symbol.LT, "&rest numbers")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
@@ -1229,14 +1229,14 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.isLessThan(second) ? T : NIL;
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first.isLessThan(second) && second.isLessThan(third))
           return T;
@@ -1244,7 +1244,7 @@
           return NIL;
       }
       @Override
-      public LispObject execute(LispObject[] array) throws ConditionThrowable
+      public LispObject execute(LispObject[] array)
       {
         final int length = array.length;
         for (int i = 1; i < length; i++)
@@ -1261,7 +1261,7 @@
     new Primitive(Symbol.LE, "&rest numbers")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
@@ -1272,14 +1272,14 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.isLessThanOrEqualTo(second) ? T : NIL;
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first.isLessThanOrEqualTo(second) && second.isLessThanOrEqualTo(third))
           return T;
@@ -1287,7 +1287,7 @@
           return NIL;
       }
       @Override
-      public LispObject execute(LispObject[] array) throws ConditionThrowable
+      public LispObject execute(LispObject[] array)
       {
         final int length = array.length;
         for (int i = 1; i < length; i++)
@@ -1304,7 +1304,7 @@
     new Primitive(Symbol.GT, "&rest numbers")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
@@ -1315,14 +1315,14 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.isGreaterThan(second) ? T : NIL;
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first.isGreaterThan(second) && second.isGreaterThan(third))
           return T;
@@ -1330,7 +1330,7 @@
           return NIL;
       }
       @Override
-      public LispObject execute(LispObject[] array) throws ConditionThrowable
+      public LispObject execute(LispObject[] array)
       {
         final int length = array.length;
         for (int i = 1; i < length; i++)
@@ -1347,7 +1347,7 @@
     new Primitive(Symbol.GE, "&rest numbers")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
@@ -1358,14 +1358,14 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.isGreaterThanOrEqualTo(second) ? T : NIL;
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first.isGreaterThanOrEqualTo(second) && second.isGreaterThanOrEqualTo(third))
           return T;
@@ -1373,7 +1373,7 @@
           return NIL;
       }
       @Override
-      public LispObject execute(LispObject[] array) throws ConditionThrowable
+      public LispObject execute(LispObject[] array)
       {
         final int length = array.length;
         for (int i = 1; i < length; i++)
@@ -1390,7 +1390,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return second.NTH(first);
       }
@@ -1403,7 +1403,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         int index = Fixnum.getValue(first);
         if (index < 0)
@@ -1433,7 +1433,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final int index = Fixnum.getValue(first);
         if (index < 0)
@@ -1455,7 +1455,7 @@
     new Primitive(Symbol.ERROR, "datum &rest arguments")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         Error e = new Error();
 
@@ -1483,7 +1483,7 @@
     new Primitive(Symbol.AUTOCOMPILE, "function")
     {
       @Override
-      public LispObject execute(LispObject function) throws ConditionThrowable
+      public LispObject execute(LispObject function)
       {
         return NIL;
       }
@@ -1500,7 +1500,7 @@
     new Primitive(Symbol.SIGNAL, "datum &rest arguments")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length < 1)
           return error(new WrongNumberOfArgumentsException(this));
@@ -1517,7 +1517,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return error(new UndefinedFunction(first));
       }
@@ -1531,7 +1531,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         LispObject destination = first;
         // Copy remaining arguments.
@@ -1544,7 +1544,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         LispObject destination = first;
         // Copy remaining arguments.
@@ -1556,7 +1556,7 @@
         return outputFormattedString(s, destination);
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length < 2)
           return error(new WrongNumberOfArgumentsException(this));
@@ -1569,7 +1569,7 @@
         return outputFormattedString(s, destination);
       }
       private final String _format(LispObject[] args)
-        throws ConditionThrowable
+
       {
         LispObject formatControl = args[0];
         LispObject formatArguments = NIL;
@@ -1580,7 +1580,7 @@
       }
       private final LispObject outputFormattedString(String s,
                                                      LispObject destination)
-        throws ConditionThrowable
+
       {
         if (destination == T)
           {
@@ -1614,7 +1614,7 @@
     internSpecial("*SIMPLE-FORMAT-FUNCTION*", PACKAGE_SYS, _FORMAT);
 
   private static void checkRedefinition(LispObject arg)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     if (_WARN_ON_REDEFINITION_.symbolValue(thread) != NIL)
@@ -1665,7 +1665,7 @@
     {
       @Override
       public LispObject execute(LispObject name, LispObject definition)
-        throws ConditionThrowable
+
       {
         if (name instanceof Symbol)
           {
@@ -1694,7 +1694,7 @@
     new Primitive("fdefinition-block-name", PACKAGE_SYS, true, "function-name")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Symbol)
           return arg;
@@ -1709,7 +1709,7 @@
     new Primitive(Symbol.MACRO_FUNCTION, "symbol &optional environment")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         LispObject obj = arg.getSymbolFunction();
         if (obj instanceof AutoloadMacro)
@@ -1734,7 +1734,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         LispObject obj;
         if (second != NIL)
@@ -1772,7 +1772,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         Symbol symbol = checkSymbol(args.car());
         LispObject lambdaList = checkList(args.cadr());
@@ -1806,7 +1806,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return new MacroObject(first, second);
       }
@@ -1817,7 +1817,7 @@
       new Primitive("macro-function-p", PACKAGE_SYS, true, "value")
   {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return (arg instanceof MacroObject) ? T : NIL;
       }
@@ -1829,7 +1829,7 @@
       new Primitive("make-symbol-macro", PACKAGE_SYS, true, "expansion")
   {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return new SymbolMacro(arg);
       }
@@ -1840,7 +1840,7 @@
       new Primitive("symbol-macro-p", PACKAGE_SYS, true, "value")
   {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return (arg instanceof SymbolMacro) ? T : NIL;
       }
@@ -1853,7 +1853,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         final Symbol symbol;
             symbol = checkSymbol(first);
@@ -1871,7 +1871,7 @@
     new Primitive("%defvar", PACKAGE_SYS, false)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final Symbol symbol;
             symbol = checkSymbol(arg);
@@ -1880,7 +1880,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final Symbol symbol;
             symbol = checkSymbol(first);
@@ -1896,7 +1896,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         final Symbol symbol;
             symbol = checkSymbol(first);
@@ -1918,7 +1918,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject result = NIL;
@@ -1949,7 +1949,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject key = eval(args.car(), env, thread);
@@ -1996,7 +1996,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject key = eval(args.car(), env, thread);
@@ -2062,13 +2062,13 @@
                   "typespec &optional environment")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return getUpgradedArrayElementType(arg);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         // Ignore environment.
         return getUpgradedArrayElementType(first);
@@ -2080,7 +2080,7 @@
     new Primitive(Symbol.ARRAY_RANK, "array")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return Fixnum.getInstance(checkArray(arg).getRank());
 
@@ -2093,7 +2093,7 @@
     new Primitive(Symbol.ARRAY_DIMENSIONS, "array")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkArray(arg).getDimensions();
       }
@@ -2105,7 +2105,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final AbstractArray array = checkArray(first);
         return Fixnum.getInstance(array.getDimension(Fixnum.getValue(second)));
@@ -2117,7 +2117,7 @@
     new Primitive(Symbol.ARRAY_TOTAL_SIZE, "array")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return Fixnum.getInstance(checkArray(arg).getTotalSize());
       }
@@ -2130,7 +2130,7 @@
     new Primitive(Symbol.ARRAY_ELEMENT_TYPE, "array")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkArray(arg).getElementType();
       }
@@ -2141,7 +2141,7 @@
     new Primitive(Symbol.ADJUSTABLE_ARRAY_P, "array")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkArray(arg).isAdjustable() ? T : NIL;
       }
@@ -2152,7 +2152,7 @@
     new Primitive(Symbol.ARRAY_DISPLACEMENT, "array")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkArray(arg).arrayDisplacement();
 
@@ -2164,7 +2164,7 @@
     new Primitive(Symbol.ARRAY_IN_BOUNDS_P, "array &rest subscripts")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length < 1)
           return error(new WrongNumberOfArgumentsException(this));
@@ -2206,7 +2206,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final AbstractArray array;
         array = checkArray(first);
@@ -2220,12 +2220,12 @@
     new Primitive(Symbol.AREF, "array &rest subscripts")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final AbstractArray array;
         array = checkArray( arg);
@@ -2239,19 +2239,19 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.AREF(second);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         return checkArray(first).get(new int[]{Fixnum.getValue(second),Fixnum.getValue(third)} );
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         final AbstractArray array = checkArray(args[0]);
         final int[] subs = new int[args.length - 1];
@@ -2270,7 +2270,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         // Rank zero array.
         final ZeroRankArray array;
@@ -2289,13 +2289,13 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         first.aset(second, third);
         return third;
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         final AbstractArray array = checkArray(args[0]);
         final int nsubs = args.length - 2;
@@ -2314,7 +2314,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {          
             return checkArray(first).AREF(Fixnum.getValue(second));
       }
@@ -2325,7 +2325,7 @@
     new Primitive(Symbol.VECTOR, "&rest objects")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         return new SimpleVector(args);
       }
@@ -2337,7 +2337,7 @@
     {
       @Override
       public LispObject execute(LispObject arg)
-        throws ConditionThrowable
+
       {
           if (arg instanceof AbstractArray) {
                   AbstractArray aa = (AbstractArray)arg;
@@ -2356,7 +2356,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
 
           if (first instanceof AbstractVector) {
@@ -2380,7 +2380,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final AbstractVector v = checkVector(second);
         int fillPointer = v.getFillPointer();
@@ -2402,7 +2402,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return second.VECTOR_PUSH_EXTEND(first);
       }
@@ -2410,7 +2410,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         return second.VECTOR_PUSH_EXTEND(first, third);
       }
@@ -2421,7 +2421,7 @@
     new Primitive(Symbol.VECTOR_POP, "vector")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final AbstractVector v = checkVector( arg);
         int fillPointer = v.getFillPointer();
@@ -2441,7 +2441,7 @@
     new Primitive(Symbol.TYPE_OF, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.typeOf();
       }
@@ -2452,7 +2452,7 @@
     new Primitive(Symbol.CLASS_OF, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.classOf();
       }
@@ -2464,7 +2464,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.typep(second);
       }
@@ -2476,7 +2476,7 @@
     new Primitive(Symbol.FUNCTION_LAMBDA_EXPRESSION, "function")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final LispObject value1, value2, value3;
         if (arg instanceof CompiledClosure)
@@ -2525,32 +2525,32 @@
     new Primitive(Symbol.FUNCALL, "function &rest args")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return LispThread.currentThread().execute(arg);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return LispThread.currentThread().execute(first, second);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         return LispThread.currentThread().execute(first, second, third);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         return LispThread.currentThread().execute(first, second, third,
                                                   fourth);
@@ -2559,7 +2559,7 @@
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth,
                                 LispObject fifth)
-        throws ConditionThrowable
+
       {
         return LispThread.currentThread().execute(first, second, third,
                                                   fourth, fifth);
@@ -2568,7 +2568,7 @@
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth,
                                 LispObject fifth, LispObject sixth)
-        throws ConditionThrowable
+
       {
         return LispThread.currentThread().execute(first, second, third,
                                                   fourth, fifth, sixth);
@@ -2578,7 +2578,7 @@
                                 LispObject third, LispObject fourth,
                                 LispObject fifth, LispObject sixth,
                                 LispObject seventh)
-        throws ConditionThrowable
+
       {
         return LispThread.currentThread().execute(first, second, third,
                                                   fourth, fifth, sixth,
@@ -2589,14 +2589,14 @@
                                 LispObject third, LispObject fourth,
                                 LispObject fifth, LispObject sixth,
                                 LispObject seventh, LispObject eigth)
-        throws ConditionThrowable
+
       {
         return LispThread.currentThread().execute(first, second, third,
                                                   fourth, fifth, sixth,
                                                   seventh, eigth);
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         final int length = args.length - 1; // Number of arguments.
         if (length == 8)
@@ -2621,18 +2621,18 @@
     new Primitive(Symbol.APPLY, "function &rest args")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
       public LispObject execute(LispObject fun, LispObject args)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         final int length = args.length();
@@ -2666,7 +2666,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (third.listp())
           {
@@ -2684,7 +2684,7 @@
         return type_error(third, Symbol.LIST);
       }
       @Override
-      public LispObject execute(final LispObject[] args) throws ConditionThrowable
+      public LispObject execute(final LispObject[] args)
       {
         final int numArgs = args.length;
         LispObject spread = args[numArgs - 1];
@@ -2712,7 +2712,7 @@
     {
       @Override
       public LispObject execute(LispObject fun, LispObject list)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject result = NIL;
@@ -2744,7 +2744,7 @@
       @Override
       public LispObject execute(LispObject fun, LispObject list1,
                                 LispObject list2)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject result = NIL;
@@ -2772,7 +2772,7 @@
       }
       @Override
       public LispObject execute(final LispObject[] args)
-        throws ConditionThrowable
+
       {
         final int numArgs = args.length;
         if (numArgs < 2)
@@ -2814,7 +2814,7 @@
     {
       @Override
       public LispObject execute(LispObject fun, LispObject list)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject result = list;
@@ -2834,7 +2834,7 @@
       @Override
       public LispObject execute(LispObject fun, LispObject list1,
                                 LispObject list2)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject result = list1;
@@ -2849,7 +2849,7 @@
       }
       @Override
       public LispObject execute(final LispObject[] args)
-        throws ConditionThrowable
+
       {
         final int numArgs = args.length;
         if (numArgs < 2)
@@ -2887,7 +2887,7 @@
     new Primitive(Symbol.MACROEXPAND, "form &optional env")
     {
       @Override
-      public LispObject execute(LispObject form) throws ConditionThrowable
+      public LispObject execute(LispObject form)
       {
         return macroexpand(form,
                            new Environment(),
@@ -2895,7 +2895,7 @@
       }
       @Override
       public LispObject execute(LispObject form, LispObject env)
-        throws ConditionThrowable
+
       {
         return macroexpand(form,
                            env != NIL ? checkEnvironment(env) : new Environment(),
@@ -2908,7 +2908,7 @@
     new Primitive(Symbol.MACROEXPAND_1, "form &optional env")
     {
       @Override
-      public LispObject execute(LispObject form) throws ConditionThrowable
+      public LispObject execute(LispObject form)
       {
         return macroexpand_1(form,
                              new Environment(),
@@ -2916,7 +2916,7 @@
       }
       @Override
       public LispObject execute(LispObject form, LispObject env)
-        throws ConditionThrowable
+
       {
         return macroexpand_1(form,
                              env != NIL ? checkEnvironment(env) : new Environment(),
@@ -2929,12 +2929,12 @@
     new Primitive(Symbol.GENSYM, "&optional x")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return gensym("G", LispThread.currentThread());
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Fixnum)
           {
@@ -2969,7 +2969,7 @@
   private static final Primitive STRING = new Primitive(Symbol.STRING, "x")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.STRING();
       }
@@ -2983,7 +2983,7 @@
     new Primitive(Symbol.INTERN, "string &optional package")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final SimpleString s;
         if (arg instanceof SimpleString)
@@ -2996,7 +2996,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final SimpleString s;
         if (first instanceof SimpleString)
@@ -3014,7 +3014,7 @@
     new Primitive(Symbol.UNINTERN, "symbol &optional package")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length == 0 || args.length > 2)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3033,7 +3033,7 @@
     new Primitive(Symbol.FIND_PACKAGE, "name")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Package)
           return arg;
@@ -3070,7 +3070,7 @@
        */
       @Override
       public LispObject execute()
-        throws ConditionThrowable
+
       {
         return new Package();
       }
@@ -3081,7 +3081,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         String packageName = javaString(first);
         Package pkg = Packages.findPackage(packageName);
@@ -3164,7 +3164,7 @@
     new Primitive("%in-package", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final String packageName = javaString(arg);
         final Package pkg = Packages.findPackage(packageName);
@@ -3187,7 +3187,7 @@
     new Primitive(Symbol.USE_PACKAGE, "packages-to-use &optional package")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length < 1 || args.length > 2)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3216,7 +3216,7 @@
     new Primitive("package-symbols", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return coerceToPackage(arg).getSymbols();
       }
@@ -3227,7 +3227,7 @@
     new Primitive("package-internal-symbols", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return coerceToPackage(arg).PACKAGE_INTERNAL_SYMBOLS();
       }
@@ -3238,7 +3238,7 @@
     new Primitive("package-external-symbols", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return coerceToPackage(arg).PACKAGE_EXTERNAL_SYMBOLS();
       }
@@ -3249,7 +3249,7 @@
     new Primitive("package-inherited-symbols", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return coerceToPackage(arg).PACKAGE_INHERITED_SYMBOLS();
       }
@@ -3260,7 +3260,7 @@
     new Primitive(Symbol.EXPORT, "symbols &optional package")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final Package pkg = (Package) Symbol._PACKAGE_.symbolValue();
         if (arg instanceof Cons)
@@ -3275,7 +3275,7 @@
 
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         if (first instanceof Cons)
           {
@@ -3294,14 +3294,14 @@
     new Primitive(Symbol.FIND_SYMBOL, "string &optional package")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return getCurrentPackage().findSymbol(arg.getStringValue());
       }
 
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return coerceToPackage(second).findSymbol(first.getStringValue());
       }
@@ -3314,21 +3314,21 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return execute(first, second, NIL, NIL, NIL);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         return execute(first, second, third, NIL, NIL);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         return execute(first, second, third, fourth, NIL);
       }
@@ -3336,7 +3336,7 @@
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth,
                                 LispObject fifth)
-        throws ConditionThrowable
+
       {
         if (first instanceof Symbol)
           {
@@ -3383,7 +3383,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         checkSymbol(first).setPropertyList(checkList(second));
         return second;
@@ -3396,14 +3396,14 @@
     {
       @Override
       public LispObject execute(LispObject plist, LispObject indicator)
-        throws ConditionThrowable
+
       {
         return getf(plist, indicator, NIL);
       }
       @Override
       public LispObject execute(LispObject plist, LispObject indicator,
                                 LispObject defaultValue)
-        throws ConditionThrowable
+
       {
         return getf(plist, indicator, defaultValue);
       }
@@ -3415,14 +3415,14 @@
     {
       @Override
       public LispObject execute(LispObject symbol, LispObject indicator)
-        throws ConditionThrowable
+
       {
         return get(symbol, indicator, NIL);
       }
       @Override
       public LispObject execute(LispObject symbol, LispObject indicator,
                                 LispObject defaultValue)
-        throws ConditionThrowable
+
       {
         return get(symbol, indicator, defaultValue);
       }
@@ -3435,14 +3435,14 @@
       @Override
       public LispObject execute(LispObject symbol, LispObject indicator,
                                 LispObject value)
-        throws ConditionThrowable
+
       {
             return put(checkSymbol(symbol), indicator, value);
       }
       @Override
       public LispObject execute(LispObject symbol, LispObject indicator,
                                 LispObject defaultValue, LispObject value)
-        throws ConditionThrowable
+
       {
           return put(checkSymbol(symbol), indicator, value);
       }
@@ -3454,7 +3454,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         LispObject defs = checkList(args.car());
         final LispThread thread = LispThread.currentThread();
@@ -3492,7 +3492,7 @@
     {
       @Override
       public LispObject execute(LispObject definition)
-        throws ConditionThrowable
+
       {
         Symbol symbol = checkSymbol(definition.car());
         LispObject lambdaList = definition.cadr();
@@ -3518,7 +3518,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         Environment ext = new Environment(env);
         try {
@@ -3536,7 +3536,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() != 1)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3556,7 +3556,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args == NIL)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3593,7 +3593,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final int length = args.length();
         if (length < 1 || length > 2)
@@ -3614,7 +3614,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() < 1)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3652,7 +3652,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() != 2)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3670,7 +3670,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject result;
@@ -3704,7 +3704,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         LispObject situations = args.car();
         if (situations != NIL)
@@ -3728,7 +3728,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         LispObject vars = args.car();
         args = args.cdr();
@@ -3805,7 +3805,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() == 0)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3828,7 +3828,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() == 0)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3880,7 +3880,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject result = T;
@@ -3909,7 +3909,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         LispObject result = NIL;
@@ -3939,7 +3939,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() != 1)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3965,7 +3965,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() != 2)
           return error(new WrongNumberOfArgumentsException(this));
@@ -3992,7 +3992,7 @@
     new Primitive("call-count", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Fixnum.getInstance(arg.getCallCount());
       }
@@ -4004,7 +4004,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         first.setCallCount(Fixnum.getValue(second));
         return second;
@@ -4016,7 +4016,7 @@
     new Primitive("hot-count", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Fixnum.getInstance(arg.getHotCount());
       }
@@ -4028,7 +4028,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         first.setHotCount(Fixnum.getValue(second));
         return second;
@@ -4040,7 +4040,7 @@
     new Primitive("lambda-name", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Operator)
           {
@@ -4060,7 +4060,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         if (first instanceof Operator)
           {
@@ -4085,7 +4085,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         checkVector(first).shrink(Fixnum.getValue(second));
         return first;
@@ -4098,7 +4098,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final int start = Fixnum.getValue(second);
         if (start < 0)
@@ -4120,7 +4120,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         final int start = Fixnum.getValue(second);
         if (start < 0)
@@ -4161,7 +4161,7 @@
 
   private static final LispObject list_subseq(LispObject list, int start,
                                               int end)
-    throws ConditionThrowable
+
   {
     int index = 0;
     LispObject result = NIL;
@@ -4211,7 +4211,7 @@
                                           new Cons(fourth))));
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         LispObject result = NIL;
         for (int i = args.length; i-- > 0;)
@@ -4225,39 +4225,39 @@
     new Primitive(Symbol.LIST_STAR, "&rest objects")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return error(new WrongNumberOfArgumentsException(this));
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg;
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return new Cons(first, second);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         return new Cons(first, new Cons(second, third));
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         return new Cons(first,
                         new Cons(second,
                                  new Cons(third, fourth)));
       }
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         int i = args.length - 1;
         LispObject result = args[i];
@@ -4272,7 +4272,7 @@
     new Primitive(Symbol.NREVERSE, "sequence")
     {
       @Override
-      public LispObject execute (LispObject arg) throws ConditionThrowable
+      public LispObject execute (LispObject arg)
       {
         return arg.nreverse();
       }
@@ -4284,7 +4284,7 @@
     {
       @Override
       public LispObject execute(LispObject list, LispObject obj)
-        throws ConditionThrowable
+
       {
         if (list instanceof Cons)
           {
@@ -4330,7 +4330,7 @@
     new Primitive(Symbol.REVERSE, "sequence")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.reverse();
       }
@@ -4342,7 +4342,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject sequence)
-        throws ConditionThrowable
+
       {
         if (sequence instanceof AbstractVector)
           return ((AbstractVector)sequence).deleteEq(item);
@@ -4357,7 +4357,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject sequence)
-        throws ConditionThrowable
+
       {
         if (sequence instanceof AbstractVector)
           return ((AbstractVector)sequence).deleteEql(item);
@@ -4372,7 +4372,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject list)
-        throws ConditionThrowable
+
       {
         if (list instanceof Cons)
           {
@@ -4422,7 +4422,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject list)
-        throws ConditionThrowable
+
       {
         if (list instanceof Cons)
           {
@@ -4472,7 +4472,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject vector)
-        throws ConditionThrowable
+
       {
           checkVector(vector).deleteEq(item);
           return vector;
@@ -4485,7 +4485,7 @@
     {
       @Override
       public LispObject execute(LispObject item, LispObject vector)
-        throws ConditionThrowable
+
       {
           checkVector(vector).deleteEql(item);
           return vector;
@@ -4500,7 +4500,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first instanceof AbstractVector)
           {
@@ -4537,7 +4537,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         int size = Fixnum.getValue(first);
         if (size < 0)
@@ -4558,7 +4558,7 @@
       public LispObject execute(LispObject item, LispObject list,
                                 LispObject key, LispObject test,
                                 LispObject testNot)
-        throws ConditionThrowable
+
       {
         LispObject tail = checkList(list);
         if (test != NIL && testNot != NIL)
@@ -4632,7 +4632,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         if (first != NIL)
           return LispThread.currentThread().execute(first, second);
@@ -4645,7 +4645,7 @@
     new Primitive("coerce-to-function", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return coerceToFunction(arg);
       }
@@ -4657,7 +4657,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         if (first instanceof Cons && ((Cons)first).car == Symbol.LAMBDA)
           {
@@ -4699,7 +4699,7 @@
     new Primitive(Symbol.EVENP, "integer")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.EVENP();
       }
@@ -4709,7 +4709,7 @@
   private static final Primitive ODDP = new Primitive(Symbol.ODDP, "integer")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.ODDP();
       }
@@ -4753,7 +4753,7 @@
     new Primitive(Symbol.COMPLEX, "realpart &optional imagpart")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof SingleFloat)
           return Complex.getInstance(arg, SingleFloat.ZERO);
@@ -4765,7 +4765,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return Complex.getInstance(first, second);
       }
@@ -4787,7 +4787,7 @@
     new Primitive(Symbol.NUMERATOR, "rational")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.NUMERATOR();
       }
@@ -4798,7 +4798,7 @@
     new Primitive(Symbol.DENOMINATOR, "rational")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.DENOMINATOR();
       }
@@ -4809,7 +4809,7 @@
     new Primitive(Symbol.REALPART, "number")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Complex)
           return ((Complex)arg).getRealPart();
@@ -4824,7 +4824,7 @@
     new Primitive(Symbol.IMAGPART, "number")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Complex)
           return ((Complex)arg).getImaginaryPart();
@@ -4837,7 +4837,7 @@
     new Primitive(Symbol.INTEGER_LENGTH, "integer")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Fixnum)
           {
@@ -4864,7 +4864,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         BigInteger n1, n2;
         if (first instanceof Fixnum)
@@ -4888,7 +4888,7 @@
     new Primitive("identity-hash-code", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Fixnum.getInstance(System.identityHashCode(arg));
       }
@@ -4901,7 +4901,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         AbstractVector v = checkVector(second);
         if (first.length() == 0)
@@ -4975,7 +4975,7 @@
     new Primitive("uptime", PACKAGE_EXT, true)
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return number(System.currentTimeMillis() - Main.startTimeMillis);
       }
@@ -4986,7 +4986,7 @@
     new Primitive("built-in-function-p", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkSymbol(arg).isBuiltInFunction() ? T : NIL;
       }
@@ -4997,7 +4997,7 @@
     new Primitive("inspected-parts", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.getParts();
       }
@@ -5008,7 +5008,7 @@
     new Primitive("inspected-description", PACKAGE_SYS, false)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.getDescription();
       }
@@ -5019,7 +5019,7 @@
     new Primitive(Symbol.SYMBOL_NAME, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSymbol(arg).name;
       }
@@ -5030,7 +5030,7 @@
     new Primitive(Symbol.SYMBOL_PACKAGE, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSymbol(arg).getPackage();
       }
@@ -5041,7 +5041,7 @@
     new Primitive(Symbol.SYMBOL_FUNCTION, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             LispObject function = checkSymbol(arg).getSymbolFunction();
             if (function != null)
@@ -5057,7 +5057,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
             checkSymbol(first).setSymbolFunction(second);
             return second;
@@ -5069,7 +5069,7 @@
     new Primitive(Symbol.SYMBOL_PLIST, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkSymbol(arg).getPropertyList();
       }
@@ -5080,7 +5080,7 @@
     new Primitive(Symbol.KEYWORDP, "object")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof Symbol)
           {
@@ -5096,7 +5096,7 @@
     new Primitive(Symbol.MAKE_SYMBOL, "name")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg instanceof SimpleString)
           return new Symbol((SimpleString)arg);
@@ -5112,7 +5112,7 @@
     new Primitive(Symbol.MAKUNBOUND, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             checkSymbol(arg).setSymbolValue(null);
             return arg;
@@ -5124,7 +5124,7 @@
     new Primitive("%class-name", PACKAGE_SYS, true, "class")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkClass(arg).symbol;
       }
@@ -5136,7 +5136,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkClass(first).symbol = checkSymbol(second);
           return second;
@@ -5148,7 +5148,7 @@
     new Primitive("class-layout", PACKAGE_SYS, true, "class")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           Layout layout = checkClass(arg).getClassLayout();
           return layout != null ? layout : NIL;
@@ -5161,7 +5161,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         if (second instanceof Layout)
           {
@@ -5177,7 +5177,7 @@
     new Primitive("class-direct-superclasses", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkClass(arg).getDirectSuperclasses();
       }
@@ -5189,7 +5189,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
             checkClass(first).setDirectSuperclasses(second);
             return second;
@@ -5201,7 +5201,7 @@
     new Primitive("class-direct-subclasses", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkClass(arg).getDirectSubclasses();
       }
@@ -5214,7 +5214,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkClass(first).setDirectSubclasses(second);
           return second;
@@ -5226,7 +5226,7 @@
     new Primitive("%class-precedence-list", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkClass(arg).getCPL();
       }
@@ -5238,7 +5238,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkClass(first).classPrecedenceList = second;
           return second;
@@ -5251,7 +5251,7 @@
     {
       @Override
       public LispObject execute(LispObject arg)
-        throws ConditionThrowable
+
       {
           return checkClass(arg).directMethods;
       }
@@ -5263,7 +5263,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkClass(first).directMethods = second;
           return second;
@@ -5276,7 +5276,7 @@
     {
       @Override
       public LispObject execute(LispObject arg)
-        throws ConditionThrowable
+
       {
           return checkClass(arg).documentation;
       }
@@ -5288,7 +5288,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkClass(first).documentation = second;
           return second;
@@ -5300,7 +5300,7 @@
     new Primitive("class-finalized-p", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
             return checkClass(arg).isFinalized() ? T : NIL;
       }
@@ -5312,7 +5312,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkClass(first).setFinalized(second != NIL);
           return second;
@@ -5335,7 +5335,7 @@
     new Primitive("char-to-utf8", PACKAGE_EXT, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final LispCharacter c;
         c = checkCharacter( arg);
@@ -5370,7 +5370,7 @@
     {
       @Override
       public LispObject execute(LispObject object, LispObject docType)
-        throws ConditionThrowable
+
       {
         LispObject doc = object.getDocumentation(docType);
         if (doc == NIL)
@@ -5394,7 +5394,7 @@
       @Override
       public LispObject execute(LispObject object, LispObject docType,
                                 LispObject documentation)
-        throws ConditionThrowable
+
       {
         object.setDocumentation(docType, documentation);
         return documentation;
@@ -5409,7 +5409,7 @@
       @Override
       public LispObject execute(LispObject plist, LispObject indicator,
                                 LispObject newValue)
-        throws ConditionThrowable
+
       {
         return putf(plist, indicator, newValue);
       }
@@ -5420,7 +5420,7 @@
     new Primitive("function-plist", PACKAGE_SYS, true, "function")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkFunction(arg).getPropertyList();
       }
@@ -5431,7 +5431,7 @@
     new Primitive("make-keyword", PACKAGE_SYS, true, "symbol")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return PACKAGE_KEYWORD.intern(checkSymbol(arg).name);
       }

Modified: trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java	Fri Nov  6 15:07:54 2009
@@ -35,7 +35,7 @@
 
 public class PrintNotReadable extends LispError
 {
-    public PrintNotReadable(LispObject initArgs) throws ConditionThrowable
+    public PrintNotReadable(LispObject initArgs)
     {
         super(StandardClass.PRINT_NOT_READABLE);
         super.initialize(initArgs);
@@ -67,7 +67,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.PRINT_NOT_READABLE)
             return T;
@@ -112,7 +112,7 @@
         new Primitive("print-not-readable-object", "condition")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
                 if (arg instanceof PrintNotReadable) return ((PrintNotReadable)arg).getInstanceSlotValue(Symbol.OBJECT);
                 return type_error(arg, Symbol.PRINT_NOT_READABLE);

Modified: trunk/abcl/src/org/armedbear/lisp/Profiler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Profiler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Profiler.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             final LispThread thread = LispThread.currentThread();
             Stream out = getStandardOutput();
@@ -120,7 +120,7 @@
         new Primitive("stop-profiler", PACKAGE_PROF, true)
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             Stream out = getStandardOutput();
             out.freshLine();

Modified: trunk/abcl/src/org/armedbear/lisp/ProgramError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ProgramError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ProgramError.java	Fri Nov  6 15:07:54 2009
@@ -35,12 +35,12 @@
 
 public class ProgramError extends LispError
 {
-    protected ProgramError(LispClass cls) throws ConditionThrowable
+    protected ProgramError(LispClass cls)
     {
         super(cls);
     }
 
-    public ProgramError(LispObject initArgs) throws ConditionThrowable
+    public ProgramError(LispObject initArgs)
     {
         super(StandardClass.PROGRAM_ERROR);
         initialize(initArgs);
@@ -52,7 +52,7 @@
 
     }
 
-    public ProgramError(String message) throws ConditionThrowable
+    public ProgramError(String message)
     {
         super(StandardClass.PROGRAM_ERROR);
         setFormatControl(message);
@@ -72,7 +72,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.PROGRAM_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/RandomState.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/RandomState.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/RandomState.java	Fri Nov  6 15:07:54 2009
@@ -50,7 +50,7 @@
         random = new Random();
     }
 
-    public RandomState(RandomState rs) throws ConditionThrowable
+    public RandomState(RandomState rs)
     {
         try {
             File file = File.createTempFile("MAKE-RANDOM-STATE", null);
@@ -82,7 +82,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.RANDOM_STATE)
             return T;
@@ -92,12 +92,12 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         return unreadableString(Symbol.RANDOM_STATE);
     }
 
-    public LispObject random(LispObject arg) throws ConditionThrowable
+    public LispObject random(LispObject arg)
     {
         if (arg instanceof Fixnum) {
             int limit = ((Fixnum)arg).value;
@@ -136,7 +136,7 @@
         new Primitive(Symbol.RANDOM, "limit &optional random-state")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             RandomState randomState =
                 (RandomState) Symbol._RANDOM_STATE_.symbolValue();
@@ -144,7 +144,7 @@
         }
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if (second instanceof RandomState) {
                 RandomState randomState = (RandomState) second;
@@ -159,13 +159,13 @@
         new Primitive(Symbol.MAKE_RANDOM_STATE, "&optional state")
     {
         @Override
-        public LispObject execute() throws ConditionThrowable
+        public LispObject execute()
         {
             return new RandomState((RandomState)Symbol._RANDOM_STATE_.symbolValue());
         }
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg == NIL)
                 return new RandomState((RandomState)Symbol._RANDOM_STATE_.symbolValue());

Modified: trunk/abcl/src/org/armedbear/lisp/Ratio.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Ratio.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Ratio.java	Fri Nov  6 15:07:54 2009
@@ -81,7 +81,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.RATIO)
             return T;
@@ -225,19 +225,19 @@
     }
 
     @Override
-    public final LispObject incr() throws ConditionThrowable
+    public final LispObject incr()
     {
         return new Ratio(numerator.add(denominator), denominator);
     }
 
     @Override
-    public final LispObject decr() throws ConditionThrowable
+    public final LispObject decr()
     {
         return new Ratio(numerator.subtract(denominator), denominator);
     }
 
     @Override
-    public LispObject add(LispObject obj) throws ConditionThrowable
+    public LispObject add(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             BigInteger n =
@@ -272,7 +272,7 @@
     }
 
     @Override
-    public LispObject subtract(LispObject obj) throws ConditionThrowable
+    public LispObject subtract(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             BigInteger n =
@@ -308,7 +308,7 @@
     }
 
     @Override
-    public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
+    public LispObject multiplyBy(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             BigInteger n = ((Fixnum)obj).getBigInteger();
@@ -338,7 +338,7 @@
     }
 
     @Override
-    public LispObject divideBy(LispObject obj) throws ConditionThrowable
+    public LispObject divideBy(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             BigInteger n = ((Fixnum)obj).getBigInteger();
@@ -380,7 +380,7 @@
     }
 
     @Override
-    public boolean isEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isEqualTo(LispObject obj)
     {
         if (obj instanceof Ratio)
             return (numerator.equals(((Ratio)obj).numerator) &&
@@ -397,13 +397,13 @@
     }
 
     @Override
-    public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isNotEqualTo(LispObject obj)
     {
         return !isEqualTo(obj);
     }
 
     @Override
-    public boolean isLessThan(LispObject obj) throws ConditionThrowable
+    public boolean isLessThan(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             BigInteger n2 = ((Fixnum)obj).getBigInteger().multiply(denominator);
@@ -428,7 +428,7 @@
     }
 
     @Override
-    public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
+    public boolean isGreaterThan(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             BigInteger n2 = ((Fixnum)obj).getBigInteger().multiply(denominator);
@@ -453,7 +453,7 @@
     }
 
     @Override
-    public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isLessThanOrEqualTo(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             BigInteger n2 = ((Fixnum)obj).getBigInteger().multiply(denominator);
@@ -478,7 +478,7 @@
     }
 
     @Override
-    public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isGreaterThanOrEqualTo(LispObject obj)
     {
         if (obj instanceof Fixnum) {
             BigInteger n2 = ((Fixnum)obj).getBigInteger().multiply(denominator);
@@ -503,7 +503,7 @@
     }
 
     @Override
-    public LispObject truncate(LispObject obj) throws ConditionThrowable
+    public LispObject truncate(LispObject obj)
     {
         // "When rationals and floats are combined by a numerical function,
         // the rational is first converted to a float of the same format."
@@ -550,7 +550,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         final LispThread thread = LispThread.currentThread();
         int base = Fixnum.getValue(Symbol.PRINT_BASE.symbolValue(thread));

Modified: trunk/abcl/src/org/armedbear/lisp/ReaderError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ReaderError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ReaderError.java	Fri Nov  6 15:07:54 2009
@@ -35,14 +35,14 @@
 
 public final class ReaderError extends StreamError
 {
-    public ReaderError(String message) throws ConditionThrowable
+    public ReaderError(String message)
     {
         super(StandardClass.READER_ERROR);
         setFormatControl(message);
         setFormatArguments(NIL);
     }
 
-    public ReaderError(String message, Stream stream) throws ConditionThrowable
+    public ReaderError(String message, Stream stream)
     {
         super(StandardClass.READER_ERROR);
         setFormatControl(message);
@@ -50,7 +50,7 @@
         setStream(stream);
     }
 
-    public ReaderError(LispObject initArgs) throws ConditionThrowable
+    public ReaderError(LispObject initArgs)
     {
         super(StandardClass.READER_ERROR);
         initialize(initArgs);
@@ -69,7 +69,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.READER_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java	Fri Nov  6 15:07:54 2009
@@ -63,7 +63,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         Stream stream = inSynonymOf(first);
         char c = LispCharacter.getValue(second);
@@ -71,5 +71,5 @@
     }
 
     public abstract LispObject execute(Stream stream, char c)
-        throws ConditionThrowable;
+       ;
 }

Modified: trunk/abcl/src/org/armedbear/lisp/Readtable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Readtable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Readtable.java	Fri Nov  6 15:07:54 2009
@@ -119,7 +119,7 @@
     readtableCase = Keyword.UPCASE;
   }
 
-  public Readtable(LispObject obj) throws ConditionThrowable
+  public Readtable(LispObject obj)
   {
     Readtable rt;
     if (obj == NIL)
@@ -181,7 +181,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.READTABLE)
       return T;
@@ -228,7 +228,7 @@
       }
   }
 
-  public void checkInvalid(char c, Stream stream) throws ConditionThrowable
+  public void checkInvalid(char c, Stream stream)
   {
     // "... no mechanism is provided for changing the constituent trait of a
     // character." (2.1.4.2)
@@ -250,7 +250,7 @@
     return readerMacroFunctions.get(c);
   }
 
-  private LispObject getMacroCharacter(char c) throws ConditionThrowable
+  private LispObject getMacroCharacter(char c)
   {
     LispObject function = getReaderMacroFunction(c);
     LispObject non_terminating_p;
@@ -283,7 +283,7 @@
   }
 
   public LispObject getDispatchMacroCharacter(char dispChar, char subChar)
-    throws ConditionThrowable
+
   {
     DispatchTable dispatchTable = dispatchTables.get(dispChar);
     if (dispatchTable == null)
@@ -299,7 +299,7 @@
 
   public void setDispatchMacroCharacter(char dispChar, char subChar,
                                         LispObject function)
-    throws ConditionThrowable
+
   {
     DispatchTable dispatchTable = dispatchTables.get(dispChar);
     if (dispatchTable == null)
@@ -343,20 +343,20 @@
     new Primitive("copy-readtable", "&optional from-readtable to-readtable")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return new Readtable(currentReadtable());
       }
 
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return new Readtable(arg);
       }
 
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         Readtable from = designator_readtable(first);
         if (second == NIL)
@@ -373,7 +373,7 @@
     new Primitive("get-macro-character", "char &optional readtable")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         char c = LispCharacter.getValue(arg);
         Readtable rt = currentReadtable();
@@ -382,7 +382,7 @@
 
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         char c = LispCharacter.getValue(first);
         Readtable rt = designator_readtable(second);
@@ -398,7 +398,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return execute(first, second, NIL, currentReadtable());
       }
@@ -406,7 +406,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         return execute(first, second, third, currentReadtable());
       }
@@ -414,7 +414,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         char c = LispCharacter.getValue(first);
         final LispObject designator;
@@ -446,7 +446,7 @@
                   "char &optional non-terminating-p readtable")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length < 1 || args.length > 3)
           return error(new WrongNumberOfArgumentsException(this));
@@ -473,7 +473,7 @@
                   "disp-char sub-char &optional readtable")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length < 2 || args.length > 3)
           return error(new WrongNumberOfArgumentsException(this));
@@ -495,7 +495,7 @@
                   "disp-char sub-char new-function &optional readtable")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length < 3 || args.length > 4)
           return error(new WrongNumberOfArgumentsException(this));
@@ -519,7 +519,7 @@
                   "to-char from-char &optional to-readtable from-readtable")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length < 2 || args.length > 4)
           return error(new WrongNumberOfArgumentsException(this));
@@ -557,7 +557,7 @@
     new Primitive("readtable-case", "readtable")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkReadtable(arg).readtableCase;
       }
@@ -570,7 +570,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
             final Readtable readtable = checkReadtable(first);
             if (second == Keyword.UPCASE || second == Keyword.DOWNCASE ||

Modified: trunk/abcl/src/org/armedbear/lisp/Return.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Return.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Return.java	Fri Nov  6 15:07:54 2009
@@ -69,7 +69,7 @@
     }
 
     @Override
-    public LispObject getCondition() throws ConditionThrowable
+    public LispObject getCondition()
     {
         try {
             FastStringBuffer sb = new FastStringBuffer("No block named ");

Modified: trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java	Fri Nov  6 15:07:54 2009
@@ -49,7 +49,7 @@
         new Primitive("%jnew-runtime-class", PACKAGE_JAVA, false, "class-name &rest method-names-and-defs")
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             int length = args.length;
             if (length < 3 || length % 2 != 1)
@@ -74,7 +74,7 @@
         @Override
         public LispObject execute(LispObject className, LispObject methodName,
                                   LispObject methodDef)
-            throws ConditionThrowable
+
         {
 
 	    String cn = className.getStringValue();
@@ -100,7 +100,7 @@
     {
         @Override
         public LispObject execute(LispObject className, LispObject classBytes)
-            throws ConditionThrowable
+
         {
             String cn = className.getStringValue();
 	      String pn = cn.substring(0,cn.lastIndexOf('.'));
@@ -132,7 +132,7 @@
                                          LispObject args,
                                          Environment env,
                                          LispThread thread)
-        throws ConditionThrowable
+
     {
         return evalCall(function, args, env, thread);
     }
@@ -149,47 +149,47 @@
         methods.put(methodName, def);
     }
 
-    public static final LispObject makeLispObject(Object obj) throws ConditionThrowable
+    public static final LispObject makeLispObject(Object obj)
     {
         return new JavaObject(obj);
     }
 
-    public static final Fixnum makeLispObject(byte i) throws ConditionThrowable
+    public static final Fixnum makeLispObject(byte i)
     {
         return Fixnum.getInstance(i);
     }
 
-    public static final Fixnum makeLispObject(short i) throws ConditionThrowable
+    public static final Fixnum makeLispObject(short i)
     {
         return Fixnum.getInstance(i);
     }
 
-    public static final Fixnum makeLispObject(int i) throws ConditionThrowable
+    public static final Fixnum makeLispObject(int i)
     {
         return Fixnum.getInstance(i);
     }
 
-    public static final LispInteger makeLispObject(long i) throws ConditionThrowable
+    public static final LispInteger makeLispObject(long i)
     {
         return Bignum.getInstance(i);
     }
 
-    public static final SingleFloat makeLispObject(float i) throws ConditionThrowable
+    public static final SingleFloat makeLispObject(float i)
     {
         return new SingleFloat(i);
     }
 
-    public static final DoubleFloat makeLispObject(double i) throws ConditionThrowable
+    public static final DoubleFloat makeLispObject(double i)
     {
         return new DoubleFloat(i);
     }
 
-    public static final LispCharacter makeLispObject(char i) throws ConditionThrowable
+    public static final LispCharacter makeLispObject(char i)
     {
         return LispCharacter.getInstance(i);
     }
 
-    public static final LispObject makeLispObject(boolean i) throws ConditionThrowable
+    public static final LispObject makeLispObject(boolean i)
     {
         return i ? T : NIL;
     }

Modified: trunk/abcl/src/org/armedbear/lisp/SeriousCondition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SeriousCondition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SeriousCondition.java	Fri Nov  6 15:07:54 2009
@@ -35,22 +35,22 @@
 
 public class SeriousCondition extends Condition
 {
-    public SeriousCondition() throws ConditionThrowable
+    public SeriousCondition()
     {
     }
 
-    protected SeriousCondition(LispClass cls) throws ConditionThrowable
+    protected SeriousCondition(LispClass cls)
     {
         super(cls);
     }
 
-    public SeriousCondition(LispObject initArgs) throws ConditionThrowable
+    public SeriousCondition(LispObject initArgs)
     {
         super(initArgs);
     }
 
     @Override
-    protected void initialize(LispObject initArgs) throws ConditionThrowable
+    protected void initialize(LispObject initArgs)
     {
         super.initialize(initArgs);
     }
@@ -73,7 +73,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SERIOUS_CONDITION)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/ShellCommand.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ShellCommand.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ShellCommand.java	Fri Nov  6 15:07:54 2009
@@ -50,7 +50,7 @@
     private int exitValue = -1;
 
     public ShellCommand(String command, String directory, Stream outputStream)
-        throws ConditionThrowable
+
     {
         this.command = command;
         this.directory = directory;
@@ -68,7 +68,7 @@
         return exitValue;
     }
 
-    private void processOutput(String s) throws ConditionThrowable
+    private void processOutput(String s)
     {
         if (outputStream != null)
             outputStream._writeString(s);
@@ -247,7 +247,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             if (!(Utilities.isPlatformUnix || Utilities.isPlatformWindows)) {
               return error(new LispError("run-shell-command not implemented for "

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java	Fri Nov  6 15:07:54 2009
@@ -53,7 +53,7 @@
   public SimpleArray_T(int[] dimv,
                        LispObject elementType,
                        LispObject initialContents)
-    throws ConditionThrowable
+
   {
     this.dimv = dimv;
     this.elementType = elementType;
@@ -70,7 +70,7 @@
   }
 
   public SimpleArray_T(int rank, LispObject initialContents)
-    throws ConditionThrowable
+
   {
     if (rank < 2)
       Debug.assertTrue(false);
@@ -99,7 +99,7 @@
 
   private int setInitialContents(int axis, int[] dims, LispObject contents,
                                  int index)
-    throws ConditionThrowable
+
   {
     if (dims.length == 0)
       {
@@ -163,7 +163,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+  public LispObject typep(LispObject typeSpecifier)
   {
     if (typeSpecifier == Symbol.SIMPLE_ARRAY)
       return T;
@@ -188,7 +188,7 @@
   }
 
   @Override
-  public int getDimension(int n) throws ConditionThrowable
+  public int getDimension(int n)
   {
     try
       {
@@ -220,7 +220,7 @@
   }
 
   @Override
-  public LispObject AREF(int index) throws ConditionThrowable
+  public LispObject AREF(int index)
   {
     try
       {
@@ -233,7 +233,7 @@
   }
 
   @Override
-  public void aset(int index, LispObject newValue) throws ConditionThrowable
+  public void aset(int index, LispObject newValue)
   {
     try
       {
@@ -246,7 +246,7 @@
   }
 
   @Override
-  public int getRowMajorIndex(int[] subscripts) throws ConditionThrowable
+  public int getRowMajorIndex(int[] subscripts)
   {
     final int rank = dimv.length;
     if (rank != subscripts.length)
@@ -281,7 +281,7 @@
   }
 
   @Override
-  public LispObject get(int[] subscripts) throws ConditionThrowable
+  public LispObject get(int[] subscripts)
   {
     try
       {
@@ -296,7 +296,7 @@
 
   @Override
   public void set(int[] subscripts, LispObject newValue)
-    throws ConditionThrowable
+
   {
     try
       {
@@ -317,7 +317,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     return writeToString(dimv);
   }
@@ -325,7 +325,7 @@
   @Override
   public AbstractArray adjustArray(int[] dimv, LispObject initialElement,
                                    LispObject initialContents)
-    throws ConditionThrowable
+
   {
     if (initialContents != null)
       return new SimpleArray_T(dimv, elementType, initialContents);
@@ -347,7 +347,7 @@
 
   // Copy a1 to a2 for index tuples that are valid for both arrays.
   static void copyArray(AbstractArray a1, AbstractArray a2)
-    throws ConditionThrowable
+
   {
     Debug.assertTrue(a1.getRank() == a2.getRank());
     int[] subscripts = new int[a1.getRank()];
@@ -357,7 +357,7 @@
 
   private static void copySubArray(AbstractArray a1, AbstractArray a2,
                                    int[] subscripts, int axis)
-    throws ConditionThrowable
+
   {
     if (axis < subscripts.length)
       {

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
     }
 
     public SimpleArray_UnsignedByte16(int[] dimv, LispObject initialContents)
-        throws ConditionThrowable
+
     {
         this.dimv = dimv;
         final int rank = dimv.length;
@@ -62,7 +62,7 @@
     }
 
     public SimpleArray_UnsignedByte16(int rank, LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (rank < 2)
             Debug.assertTrue(false);
@@ -81,7 +81,7 @@
 
     private int setInitialContents(int axis, int[] dims, LispObject contents,
                                    int index)
-        throws ConditionThrowable
+
     {
         if (dims.length == 0) {
             try {
@@ -134,7 +134,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.SIMPLE_ARRAY)
             return T;
@@ -159,7 +159,7 @@
     }
 
     @Override
-    public int getDimension(int n) throws ConditionThrowable
+    public int getDimension(int n)
     {
         try {
             return dimv[n];
@@ -189,7 +189,7 @@
     }
 
     @Override
-    public int aref(int index) throws ConditionThrowable
+    public int aref(int index)
     {
         try {
             return data[index];
@@ -202,7 +202,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         try {
             return Fixnum.getInstance(data[index]);
@@ -213,7 +213,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject obj) throws ConditionThrowable
+    public void aset(int index, LispObject obj)
     {
         try {
             data[index] = Fixnum.getValue(obj);
@@ -224,7 +224,7 @@
     }
 
     @Override
-    public int getRowMajorIndex(int[] subscripts) throws ConditionThrowable
+    public int getRowMajorIndex(int[] subscripts)
     {
         final int rank = dimv.length;
         if (rank != subscripts.length) {
@@ -256,7 +256,7 @@
     }
 
     @Override
-    public LispObject get(int[] subscripts) throws ConditionThrowable
+    public LispObject get(int[] subscripts)
     {
         try {
             return Fixnum.getInstance(data[getRowMajorIndex(subscripts)]);
@@ -269,7 +269,7 @@
 
     @Override
     public void set(int[] subscripts, LispObject obj)
-        throws ConditionThrowable
+
     {
         try {
             data[getRowMajorIndex(subscripts)] = Fixnum.getValue(obj);
@@ -281,7 +281,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         int n = Fixnum.getValue(obj);
         for (int i = totalSize; i-- > 0;)
@@ -289,7 +289,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
             error(new PrintNotReadable(list(Keyword.OBJECT, this)));
@@ -301,7 +301,7 @@
 
     public AbstractArray adjustArray(int[] dimv, LispObject initialElement,
                                      LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null)
             return new SimpleArray_UnsignedByte16(dimv, initialContents);
@@ -321,7 +321,7 @@
 
     // Copy a1 to a2 for index tuples that are valid for both arrays.
     private static void copyArray(AbstractArray a1, AbstractArray a2)
-        throws ConditionThrowable
+
     {
         Debug.assertTrue(a1.getRank() == a2.getRank());
         int[] subscripts = new int[a1.getRank()];
@@ -331,7 +331,7 @@
 
     private static void copySubArray(AbstractArray a1, AbstractArray a2,
                                      int[] subscripts, int axis)
-        throws ConditionThrowable
+
     {
         if (axis < subscripts.length) {
             final int limit =

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java	Fri Nov  6 15:07:54 2009
@@ -51,7 +51,7 @@
     }
 
     public SimpleArray_UnsignedByte32(int[] dimv, LispObject initialContents)
-        throws ConditionThrowable
+
     {
         this.dimv = dimv;
         final int rank = dimv.length;
@@ -66,7 +66,7 @@
     }
 
     public SimpleArray_UnsignedByte32(int rank, LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (rank < 2)
             Debug.assertTrue(false);
@@ -85,7 +85,7 @@
 
     private int setInitialContents(int axis, int[] dims, LispObject contents,
                                    int index)
-        throws ConditionThrowable
+
     {
         if (dims.length == 0) {
             try {
@@ -138,7 +138,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.SIMPLE_ARRAY)
             return T;
@@ -163,7 +163,7 @@
     }
 
     @Override
-    public int getDimension(int n) throws ConditionThrowable
+    public int getDimension(int n)
     {
         try {
             return dimv[n];
@@ -193,7 +193,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         try {
             return data[index];
@@ -204,7 +204,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         try {
             data[index] = newValue;
@@ -215,7 +215,7 @@
     }
 
     @Override
-    public int getRowMajorIndex(int[] subscripts) throws ConditionThrowable
+    public int getRowMajorIndex(int[] subscripts)
     {
         final int rank = dimv.length;
         if (rank != subscripts.length) {
@@ -247,7 +247,7 @@
     }
 
     @Override
-    public LispObject get(int[] subscripts) throws ConditionThrowable
+    public LispObject get(int[] subscripts)
     {
         try {
             return data[getRowMajorIndex(subscripts)];
@@ -260,7 +260,7 @@
 
     @Override
     public void set(int[] subscripts, LispObject newValue)
-        throws ConditionThrowable
+
     {
         try {
             data[getRowMajorIndex(subscripts)] = newValue;
@@ -279,7 +279,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
             error(new PrintNotReadable(list(Keyword.OBJECT, this)));
@@ -291,7 +291,7 @@
 
     public AbstractArray adjustArray(int[] dimv, LispObject initialElement,
                                      LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null)
             return new SimpleArray_UnsignedByte32(dimv, initialContents);
@@ -311,7 +311,7 @@
 
     // Copy a1 to a2 for index tuples that are valid for both arrays.
     static void copyArray(AbstractArray a1, AbstractArray a2)
-        throws ConditionThrowable
+
     {
         Debug.assertTrue(a1.getRank() == a2.getRank());
         int[] subscripts = new int[a1.getRank()];
@@ -321,7 +321,7 @@
 
     private static void copySubArray(AbstractArray a1, AbstractArray a2,
                                      int[] subscripts, int axis)
-        throws ConditionThrowable
+
     {
         if (axis < subscripts.length) {
             final int limit =

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
     }
 
     public SimpleArray_UnsignedByte8(int[] dimv, LispObject initialContents)
-        throws ConditionThrowable
+
     {
         this.dimv = dimv;
         final int rank = dimv.length;
@@ -62,7 +62,7 @@
     }
 
     public SimpleArray_UnsignedByte8(int rank, LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (rank < 2)
             Debug.assertTrue(false);
@@ -81,7 +81,7 @@
 
     private int setInitialContents(int axis, int[] dims, LispObject contents,
                                    int index)
-        throws ConditionThrowable
+
     {
         if (dims.length == 0) {
             try {
@@ -134,7 +134,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.SIMPLE_ARRAY)
             return T;
@@ -159,7 +159,7 @@
     }
 
     @Override
-    public int getDimension(int n) throws ConditionThrowable
+    public int getDimension(int n)
     {
         try {
             return dimv[n];
@@ -189,7 +189,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         try {
             return coerceJavaByteToLispObject(data[index]);
@@ -200,7 +200,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         try {
             data[index] = coerceLispObjectToJavaByte(newValue);
@@ -211,7 +211,7 @@
     }
 
     @Override
-    public int getRowMajorIndex(int[] subscripts) throws ConditionThrowable
+    public int getRowMajorIndex(int[] subscripts)
     {
         final int rank = dimv.length;
         if (rank != subscripts.length) {
@@ -243,7 +243,7 @@
     }
 
     @Override
-    public LispObject get(int[] subscripts) throws ConditionThrowable
+    public LispObject get(int[] subscripts)
     {
         try {
             return coerceJavaByteToLispObject(data[getRowMajorIndex(subscripts)]);
@@ -256,7 +256,7 @@
 
     @Override
     public void set(int[] subscripts, LispObject newValue)
-        throws ConditionThrowable
+
     {
         try {
             data[getRowMajorIndex(subscripts)] = coerceLispObjectToJavaByte(newValue);
@@ -268,7 +268,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         byte b = coerceLispObjectToJavaByte(obj);
         for (int i = totalSize; i-- > 0;)
@@ -276,7 +276,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
             error(new PrintNotReadable(list(Keyword.OBJECT, this)));
@@ -288,7 +288,7 @@
 
     public AbstractArray adjustArray(int[] dimv, LispObject initialElement,
                                      LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null)
             return new SimpleArray_UnsignedByte8(dimv, initialContents);
@@ -308,7 +308,7 @@
 
     // Copy a1 to a2 for index tuples that are valid for both arrays.
     static void copyArray(AbstractArray a1, AbstractArray a2)
-        throws ConditionThrowable
+
     {
         Debug.assertTrue(a1.getRank() == a2.getRank());
         int[] subscripts = new int[a1.getRank()];
@@ -318,7 +318,7 @@
 
     private static void copySubArray(AbstractArray a1, AbstractArray a2,
                                      int[] subscripts, int axis)
-        throws ConditionThrowable
+
     {
         if (axis < subscripts.length) {
             final int limit =

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java	Fri Nov  6 15:07:54 2009
@@ -49,7 +49,7 @@
         bits = new long[size];
     }
 
-    public SimpleBitVector(String s) throws ConditionThrowable
+    public SimpleBitVector(String s)
     {
         this(s.length());
         for (int i = capacity; i-- > 0;) {
@@ -75,7 +75,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SIMPLE_BIT_VECTOR)
             return T;
@@ -113,7 +113,7 @@
     }
 
     @Override
-    public LispObject elt(int index) throws ConditionThrowable
+    public LispObject elt(int index)
     {
         if (index < 0 || index >= length())
             badIndex(index, length());
@@ -122,7 +122,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (index < 0 || index >= capacity)
             badIndex(index, capacity);
@@ -131,7 +131,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject newValue) throws ConditionThrowable
+    public void aset(int index, LispObject newValue)
     {
         if (index < 0 || index >= capacity)
             badIndex(index, capacity);
@@ -172,7 +172,7 @@
     }
 
     @Override
-    public void shrink(int n) throws ConditionThrowable
+    public void shrink(int n)
     {
         if (n < capacity) {
             int size = n >>> 6;
@@ -195,7 +195,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        LispObject initialElement,
                                        LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null) {
             SimpleBitVector v = new SimpleBitVector(newCapacity);
@@ -240,7 +240,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        AbstractArray displacedTo,
                                        int displacement)
-        throws ConditionThrowable
+
     {
         return new ComplexBitVector(newCapacity, displacedTo, displacement);
     }
@@ -343,7 +343,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).and((SimpleBitVector)second,
                                                 ((SimpleBitVector)third));
@@ -358,7 +358,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).ior((SimpleBitVector)second,
                                                 (SimpleBitVector)third);
@@ -374,7 +374,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).xor((SimpleBitVector)second,
                                                 (SimpleBitVector)third);
@@ -390,7 +390,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).eqv((SimpleBitVector)second,
                                                 (SimpleBitVector)third);
@@ -405,7 +405,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).nand((SimpleBitVector)second,
                                                  (SimpleBitVector)third);
@@ -420,7 +420,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).nor((SimpleBitVector)second,
                                                  (SimpleBitVector)third);
@@ -435,7 +435,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).andc1((SimpleBitVector)second,
                                                   (SimpleBitVector)third);
@@ -450,7 +450,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).andc2((SimpleBitVector)second,
                                                   (SimpleBitVector)third);
@@ -466,7 +466,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).orc1((SimpleBitVector)second,
                                                  (SimpleBitVector)third);
@@ -481,7 +481,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             return ((SimpleBitVector)first).orc2((SimpleBitVector)second,
                                                  (SimpleBitVector)third);
@@ -495,7 +495,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             SimpleBitVector v = (SimpleBitVector) first;
             SimpleBitVector result = (SimpleBitVector) second;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleCondition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleCondition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleCondition.java	Fri Nov  6 15:07:54 2009
@@ -35,20 +35,20 @@
 
 public class SimpleCondition extends Condition
 {
-    public SimpleCondition() throws ConditionThrowable
+    public SimpleCondition()
     {
         setFormatControl(NIL);
         setFormatArguments(NIL);
     }
 
     public SimpleCondition(LispObject formatControl, LispObject formatArguments)
-        throws ConditionThrowable
+
     {
         setFormatControl(formatControl);
         setFormatArguments(formatArguments);
     }
 
-    public SimpleCondition(LispObject initArgs) throws ConditionThrowable
+    public SimpleCondition(LispObject initArgs)
     {
         super(initArgs);
     }
@@ -71,7 +71,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SIMPLE_CONDITION)
             return T;
@@ -85,7 +85,7 @@
         new Primitive(Symbol.SIMPLE_CONDITION_FORMAT_CONTROL, "condition")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return Symbol.STD_SLOT_VALUE.execute(arg, Symbol.FORMAT_CONTROL);
         }
@@ -96,7 +96,7 @@
         new Primitive(Symbol.SIMPLE_CONDITION_FORMAT_ARGUMENTS, "condition")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return Symbol.STD_SLOT_VALUE.execute(arg, Symbol.FORMAT_ARGUMENTS);
         }

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleError.java	Fri Nov  6 15:07:54 2009
@@ -36,20 +36,20 @@
 public final class SimpleError extends LispError
 {
     public SimpleError(LispObject formatControl, LispObject formatArguments)
-        throws ConditionThrowable
+
     {
         super(StandardClass.SIMPLE_ERROR);
         setFormatControl(formatControl);
         setFormatArguments(formatArguments);
     }
 
-    public SimpleError(LispObject initArgs) throws ConditionThrowable
+    public SimpleError(LispObject initArgs)
     {
         super(StandardClass.SIMPLE_ERROR);
         initialize(initArgs);
     }
 
-    public SimpleError(String message) throws ConditionThrowable
+    public SimpleError(String message)
     {
         super(StandardClass.SIMPLE_ERROR);
         setFormatControl(message);
@@ -69,7 +69,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SIMPLE_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleString.java	Fri Nov  6 15:07:54 2009
@@ -118,7 +118,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SIMPLE_STRING)
             return T;
@@ -154,7 +154,7 @@
     }
 
     @Override
-    public boolean equal(LispObject obj) throws ConditionThrowable
+    public boolean equal(LispObject obj)
     {
         if (this == obj)
             return true;
@@ -182,7 +182,7 @@
     }
 
     @Override
-    public boolean equalp(LispObject obj) throws ConditionThrowable
+    public boolean equalp(LispObject obj)
     {
         if (this == obj)
             return true;
@@ -217,13 +217,13 @@
         return false;
     }
 
-    public final SimpleString substring(int start) throws ConditionThrowable
+    public final SimpleString substring(int start)
     {
         return substring(start, capacity);
     }
 
     public final SimpleString substring(int start, int end)
-        throws ConditionThrowable
+
     {
         SimpleString s = new SimpleString(end - start);
         int i = start, j = 0;
@@ -240,13 +240,13 @@
     }
 
     @Override
-    public final LispObject subseq(int start, int end) throws ConditionThrowable
+    public final LispObject subseq(int start, int end)
     {
         return substring(start, end);
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         fill(LispCharacter.getValue(obj));
     }
@@ -259,7 +259,7 @@
     }
 
     @Override
-    public void shrink(int n) throws ConditionThrowable
+    public void shrink(int n)
     {
         if (n < capacity) {
             char[] newArray = new char[n];
@@ -274,7 +274,7 @@
     }
 
     @Override
-    public LispObject reverse() throws ConditionThrowable
+    public LispObject reverse()
     {
         SimpleString result = new SimpleString(capacity);
         int i, j;
@@ -284,7 +284,7 @@
     }
 
     @Override
-    public LispObject nreverse() throws ConditionThrowable
+    public LispObject nreverse()
     {
         int i = 0;
         int j = capacity - 1;
@@ -329,7 +329,7 @@
     }
 
     @Override
-    public char charAt(int index) throws ConditionThrowable
+    public char charAt(int index)
     {
         try {
             return chars[index];
@@ -341,7 +341,7 @@
     }
 
     @Override
-    public void setCharAt(int index, char c) throws ConditionThrowable
+    public void setCharAt(int index, char c)
     {
         try {
             chars[index] = c;
@@ -352,7 +352,7 @@
     }
 
     @Override
-    public LispObject elt(int index) throws ConditionThrowable
+    public LispObject elt(int index)
     {
         try {
             return LispCharacter.getInstance(chars[index]);
@@ -364,7 +364,7 @@
     }
 
     @Override
-    public LispObject CHAR(int index) throws ConditionThrowable
+    public LispObject CHAR(int index)
     {
         try {
             return LispCharacter.getInstance(chars[index]);
@@ -376,7 +376,7 @@
     }
 
     @Override
-    public LispObject SCHAR(int index) throws ConditionThrowable
+    public LispObject SCHAR(int index)
     {
         try {
             return LispCharacter.getInstance(chars[index]);
@@ -388,7 +388,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         try {
             return LispCharacter.getInstance(chars[index]);
@@ -400,7 +400,7 @@
     }
 
     @Override
-    public LispObject AREF(LispObject index) throws ConditionThrowable
+    public LispObject AREF(LispObject index)
     {
         try {
             return LispCharacter.getInstance(chars[Fixnum.getValue(index)]);
@@ -412,7 +412,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject obj) throws ConditionThrowable
+    public void aset(int index, LispObject obj)
     {
         try {
             chars[index] = LispCharacter.getValue(obj);
@@ -457,7 +457,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        LispObject initialElement,
                                        LispObject initialContents)
-        throws ConditionThrowable
+
     {
         if (initialContents != null) {
             char[] newChars = new char[newCapacity];
@@ -492,7 +492,7 @@
     public AbstractVector adjustArray(int newCapacity,
                                        AbstractArray displacedTo,
                                        int displacement)
-        throws ConditionThrowable
+
     {
         return new ComplexString(newCapacity, displacedTo, displacement);
     }

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java	Fri Nov  6 15:07:54 2009
@@ -35,7 +35,7 @@
 
 public final class SimpleTypeError extends TypeError
 {
-    public SimpleTypeError(LispObject initArgs) throws ConditionThrowable
+    public SimpleTypeError(LispObject initArgs)
     {
         super(StandardClass.SIMPLE_TYPE_ERROR);
         initialize(initArgs);
@@ -54,7 +54,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SIMPLE_TYPE_ERROR)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleVector.java	Fri Nov  6 15:07:54 2009
@@ -49,7 +49,7 @@
     this.capacity = capacity;
   }
 
-  public SimpleVector(LispObject obj) throws ConditionThrowable
+  public SimpleVector(LispObject obj)
   {
     if (obj.listp())
       {
@@ -95,7 +95,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.SIMPLE_VECTOR)
       return T;
@@ -145,7 +145,7 @@
   }
 
   @Override
-  public LispObject elt(int index) throws ConditionThrowable
+  public LispObject elt(int index)
   {
     try
       {
@@ -159,7 +159,7 @@
   }
 
   @Override
-  public LispObject AREF(int index) throws ConditionThrowable
+  public LispObject AREF(int index)
   {
     try
       {
@@ -173,7 +173,7 @@
   }
 
   @Override
-  public LispObject AREF(LispObject index) throws ConditionThrowable
+  public LispObject AREF(LispObject index)
   {
         int idx = Fixnum.getValue(index);
     try
@@ -188,7 +188,7 @@
   }
 
   @Override
-  public void aset(int index, LispObject newValue) throws ConditionThrowable
+  public void aset(int index, LispObject newValue)
   {
     try
       {
@@ -201,7 +201,7 @@
   }
 
   @Override
-  public LispObject SVREF(int index) throws ConditionThrowable
+  public LispObject SVREF(int index)
   {
     try
       {
@@ -215,7 +215,7 @@
   }
 
   @Override
-  public void svset(int index, LispObject newValue) throws ConditionThrowable
+  public void svset(int index, LispObject newValue)
   {
     try
       {
@@ -228,7 +228,7 @@
   }
 
   @Override
-  public LispObject subseq(int start, int end) throws ConditionThrowable
+  public LispObject subseq(int start, int end)
   {
     SimpleVector v = new SimpleVector(end - start);
     int i = start, j = 0;
@@ -245,14 +245,14 @@
   }
 
   @Override
-  public void fill(LispObject obj) throws ConditionThrowable
+  public void fill(LispObject obj)
   {
     for (int i = capacity; i-- > 0;)
       data[i] = obj;
   }
 
   @Override
-  public LispObject deleteEq(LispObject item) throws ConditionThrowable
+  public LispObject deleteEq(LispObject item)
   {
     final int limit = capacity;
     int i = 0;
@@ -269,7 +269,7 @@
   }
 
   @Override
-  public LispObject deleteEql(LispObject item) throws ConditionThrowable
+  public LispObject deleteEql(LispObject item)
   {
     final int limit = capacity;
     int i = 0;
@@ -286,7 +286,7 @@
   }
 
   @Override
-  public void shrink(int n) throws ConditionThrowable
+  public void shrink(int n)
   {
     if (n < capacity)
       {
@@ -302,7 +302,7 @@
   }
 
   @Override
-  public LispObject reverse() throws ConditionThrowable
+  public LispObject reverse()
   {
     SimpleVector result = new SimpleVector(capacity);
     int i, j;
@@ -312,7 +312,7 @@
   }
 
   @Override
-  public LispObject nreverse() throws ConditionThrowable
+  public LispObject nreverse()
   {
     int i = 0;
     int j = capacity - 1;
@@ -331,7 +331,7 @@
   public AbstractVector adjustArray(int newCapacity,
                                      LispObject initialElement,
                                      LispObject initialContents)
-    throws ConditionThrowable
+
   {
     if (initialContents != null)
       {
@@ -383,7 +383,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
                         if (first instanceof SimpleVector) {
                                 final SimpleVector sv = (SimpleVector)first;
@@ -408,7 +408,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
                         if (first instanceof SimpleVector) {
                                 final SimpleVector sv = (SimpleVector)first;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleWarning.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleWarning.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleWarning.java	Fri Nov  6 15:07:54 2009
@@ -35,14 +35,14 @@
 
 public final class SimpleWarning extends Warning
 {
-    public SimpleWarning(LispObject initArgs) throws ConditionThrowable
+    public SimpleWarning(LispObject initArgs)
     {
         super(StandardClass.SIMPLE_WARNING);
         initialize(initArgs);
     }
 
     public SimpleWarning(LispObject formatControl, LispObject formatArguments)
-        throws ConditionThrowable
+
     {
         super(StandardClass.SIMPLE_WARNING);
         setFormatControl(formatControl);
@@ -62,7 +62,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SIMPLE_WARNING)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/SingleFloat.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SingleFloat.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SingleFloat.java	Fri Nov  6 15:07:54 2009
@@ -86,7 +86,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.FLOAT)
             return T;
@@ -168,7 +168,7 @@
     }
 
     @Override
-    public boolean equalp(LispObject obj) throws ConditionThrowable
+    public boolean equalp(LispObject obj)
     {
         if (obj instanceof SingleFloat)
             return value == ((SingleFloat)obj).value;
@@ -223,7 +223,7 @@
         return true;
     }
 
-    public static double getValue(LispObject obj) throws ConditionThrowable
+    public static double getValue(LispObject obj)
     {
         if (obj instanceof SingleFloat)
             return ((SingleFloat)obj).value;
@@ -275,7 +275,7 @@
     }
 
     @Override
-    public LispObject add(LispObject obj) throws ConditionThrowable
+    public LispObject add(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new SingleFloat(value + ((Fixnum)obj).value);
@@ -305,7 +305,7 @@
     }
 
     @Override
-    public LispObject subtract(LispObject obj) throws ConditionThrowable
+    public LispObject subtract(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new SingleFloat(value - ((Fixnum)obj).value);
@@ -326,7 +326,7 @@
     }
 
     @Override
-    public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
+    public LispObject multiplyBy(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new SingleFloat(value * ((Fixnum)obj).value);
@@ -347,7 +347,7 @@
     }
 
     @Override
-    public LispObject divideBy(LispObject obj) throws ConditionThrowable
+    public LispObject divideBy(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new SingleFloat(value / ((Fixnum)obj).value);
@@ -373,7 +373,7 @@
     }
 
     @Override
-    public boolean isEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isEqualTo(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return rational().isEqualTo(obj);
@@ -393,13 +393,13 @@
     }
 
     @Override
-    public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isNotEqualTo(LispObject obj)
     {
         return !isEqualTo(obj);
     }
 
     @Override
-    public boolean isLessThan(LispObject obj) throws ConditionThrowable
+    public boolean isLessThan(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return rational().isLessThan(obj);
@@ -417,7 +417,7 @@
     }
 
     @Override
-    public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
+    public boolean isGreaterThan(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return rational().isGreaterThan(obj);
@@ -435,7 +435,7 @@
     }
 
     @Override
-    public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isLessThanOrEqualTo(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return rational().isLessThanOrEqualTo(obj);
@@ -453,7 +453,7 @@
     }
 
     @Override
-    public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
+    public boolean isGreaterThanOrEqualTo(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return rational().isGreaterThanOrEqualTo(obj);
@@ -471,7 +471,7 @@
     }
 
     @Override
-    public LispObject truncate(LispObject obj) throws ConditionThrowable
+    public LispObject truncate(LispObject obj)
     {
         // "When rationals and floats are combined by a numerical function,
         // the rational is first converted to a float of the same format."
@@ -568,7 +568,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         if (value == Float.POSITIVE_INFINITY) {
             StringBuffer sb = new StringBuffer("#.");
@@ -603,7 +603,7 @@
             return s1;
     }
 
-    public LispObject rational() throws ConditionThrowable
+    public LispObject rational()
     {
         final int bits = Float.floatToRawIntBits(value);
         int sign = ((bits >> 31) == 0) ? 1 : -1;
@@ -630,7 +630,7 @@
         return number(numerator, denominator);
     }
 
-    public static SingleFloat coerceToFloat(LispObject obj) throws ConditionThrowable
+    public static SingleFloat coerceToFloat(LispObject obj)
     {
         if (obj instanceof Fixnum)
             return new SingleFloat(((Fixnum)obj).value);

Modified: trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java	Fri Nov  6 15:07:54 2009
@@ -64,7 +64,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SLIME_INPUT_STREAM)
             return T;
@@ -78,7 +78,7 @@
     }
 
     @Override
-    public LispObject close(LispObject abort) throws ConditionThrowable
+    public LispObject close(LispObject abort)
     {
         setOpen(false);
         return T;
@@ -131,7 +131,7 @@
 
 
     @Override
-    public void _clearInput() throws ConditionThrowable
+    public void _clearInput()
     {
         super._clearInput();
         s = "";
@@ -155,7 +155,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             final Function fun;
             final Stream os;

Modified: trunk/abcl/src/org/armedbear/lisp/SlimeOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlimeOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlimeOutputStream.java	Fri Nov  6 15:07:54 2009
@@ -64,7 +64,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SLIME_OUTPUT_STREAM)
             return T;
@@ -78,7 +78,7 @@
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         if (elementType == NIL)
             writeError();
@@ -87,7 +87,7 @@
 
     @Override
     public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
+
     {
         if (elementType == NIL)
             writeError();
@@ -95,7 +95,7 @@
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         if (elementType == NIL)
             writeError();
@@ -103,20 +103,20 @@
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         if (elementType == NIL)
             writeError();
         super._writeLine(s);
     }
 
-    private void writeError() throws ConditionThrowable
+    private void writeError()
     {
         error(new TypeError("Attempt to write to a string output stream of element type NIL."));
     }
 
     @Override
-    protected long _getFilePosition() throws ConditionThrowable
+    protected long _getFilePosition()
     {
         if (elementType == NIL)
             return 0;
@@ -124,7 +124,7 @@
     }
 
     @Override
-    public void _finishOutput() throws ConditionThrowable
+    public void _finishOutput()
     {
         super._finishOutput ();
         if (stringWriter.getBuffer().length() > 0) {
@@ -146,7 +146,7 @@
         new Primitive("make-slime-output-stream", PACKAGE_EXT, true, "function")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             final Function fun;
             if (arg instanceof Symbol)

Modified: trunk/abcl/src/org/armedbear/lisp/SlotClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlotClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlotClass.java	Fri Nov  6 15:07:54 2009
@@ -50,7 +50,7 @@
     }
 
     @Override
-    public LispObject getParts() throws ConditionThrowable
+    public LispObject getParts()
     {
         LispObject result = super.getParts().nreverse();
         result = result.push(new Cons("DIRECT-SLOTS", directSlotDefinitions));
@@ -61,7 +61,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         return super.typep(type);
     }
@@ -101,7 +101,7 @@
         this.defaultInitargs = defaultInitargs;
     }
 
-    private LispObject computeDefaultInitargs() throws ConditionThrowable
+    private LispObject computeDefaultInitargs()
     {
         LispObject result = NIL;
         LispObject cpl = getCPL();
@@ -166,7 +166,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof SlotClass)
                 return ((SlotClass)arg).directSlotDefinitions;
@@ -182,7 +182,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
                 if (first instanceof SlotClass) {
                 ((SlotClass)first).directSlotDefinitions = second;
@@ -200,7 +200,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof SlotClass)
                 return ((SlotClass)arg).slotDefinitions;
@@ -216,7 +216,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
                 if (first instanceof SlotClass) {
                 ((SlotClass)first).slotDefinitions = second;
@@ -234,7 +234,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof SlotClass)
                 return ((SlotClass)arg).directDefaultInitargs;
@@ -250,7 +250,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
                    if (first instanceof SlotClass) {                
                            ((SlotClass)first).directDefaultInitargs = second;                
@@ -266,7 +266,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             if (arg instanceof SlotClass)
                 return ((SlotClass)arg).defaultInitargs;
@@ -282,7 +282,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if (first instanceof SlotClass) {
                 ((SlotClass)first).defaultInitargs = second;
@@ -298,7 +298,7 @@
     {
         @Override
         public LispObject execute(LispObject arg)
-            throws ConditionThrowable
+
         {
             final SlotClass c;
             if (arg instanceof SlotClass) {

Modified: trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java	Fri Nov  6 15:07:54 2009
@@ -82,7 +82,7 @@
       }
   }
   
-  public static SlotDefinition checkSlotDefination(LispObject obj) throws ConditionThrowable {
+  public static SlotDefinition checkSlotDefination(LispObject obj) {
           if (obj instanceof SlotDefinition) return (SlotDefinition)obj;
       return (SlotDefinition)type_error(obj, Symbol.SLOT_DEFINITION);     
   }
@@ -98,7 +98,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     FastStringBuffer sb =
       new FastStringBuffer(Symbol.SLOT_DEFINITION.writeToString());
@@ -116,7 +116,7 @@
     new Primitive("make-slot-definition", PACKAGE_SYS, true, "")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return new SlotDefinition();
       }
@@ -127,7 +127,7 @@
     new Primitive(Symbol._SLOT_DEFINITION_NAME, "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_NAME];
       }
@@ -140,7 +140,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_NAME] = second;
           return second;
@@ -152,7 +152,7 @@
     new Primitive(Symbol._SLOT_DEFINITION_INITFUNCTION, "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION];
       }
@@ -165,7 +165,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = second;
           return second;
@@ -178,7 +178,7 @@
                   "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM];
       }
@@ -191,7 +191,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM] = second;
           return second;
@@ -203,7 +203,7 @@
     new Primitive(Symbol._SLOT_DEFINITION_INITARGS, "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS];
       }
@@ -216,7 +216,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] = second;
           return second;
@@ -229,7 +229,7 @@
                   "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_READERS];
       }
@@ -242,7 +242,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_READERS] = second;
           return second;
@@ -255,7 +255,7 @@
                   "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS];
       }
@@ -268,7 +268,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS] = second;
           return second;
@@ -281,7 +281,7 @@
                   "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION];
       }
@@ -294,7 +294,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = second;
           return second;
@@ -307,7 +307,7 @@
                   "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS];
       }
@@ -320,7 +320,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS] = second;
           return second;
@@ -332,7 +332,7 @@
     new Primitive("%slot-definition-location", PACKAGE_SYS, true, "slot-definition")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION];
       }
@@ -344,7 +344,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION] = second;
           return second;

Modified: trunk/abcl/src/org/armedbear/lisp/SocketStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SocketStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SocketStream.java	Fri Nov  6 15:07:54 2009
@@ -58,7 +58,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SOCKET_STREAM)
             return T;
@@ -68,7 +68,7 @@
     }
 
     @Override
-    public LispObject close(LispObject abort) throws ConditionThrowable
+    public LispObject close(LispObject abort)
     {
 	try {
 	    socket.close();

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialBinding.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialBinding.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialBinding.java	Fri Nov  6 15:07:54 2009
@@ -53,7 +53,7 @@
      * If the binding is invalid, an unbound variable error
      * is raised.
      */
-    final public LispObject getValue() throws ConditionThrowable
+    final public LispObject getValue()
     {
         if (value == null)
             return Lisp.error(new UnboundVariable(name));

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java	Fri Nov  6 15:07:54 2009
@@ -71,20 +71,20 @@
     }
 
     @Override
-    public LispObject execute() throws ConditionThrowable
+    public LispObject execute()
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
@@ -92,7 +92,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third)
-        throws ConditionThrowable
+
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
@@ -100,7 +100,7 @@
     @Override
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
@@ -109,7 +109,7 @@
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth,
                               LispObject fifth)
-        throws ConditionThrowable
+
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
@@ -118,7 +118,7 @@
     public LispObject execute(LispObject first, LispObject second,
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth)
-        throws ConditionThrowable
+
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
@@ -128,7 +128,7 @@
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth,
                               LispObject seventh)
-        throws ConditionThrowable
+
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
@@ -138,19 +138,19 @@
                               LispObject third, LispObject fourth,
                               LispObject fifth, LispObject sixth,
                               LispObject seventh, LispObject eighth)
-        throws ConditionThrowable
+
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         return error(new UndefinedFunction(getLambdaName()));
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         StringBuffer sb = new StringBuffer("#<SPECIAL-OPERATOR ");
         sb.append(lambdaName.writeToString());

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.cdr() != NIL)
           return error(new WrongNumberOfArgumentsException(this));
@@ -57,7 +57,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         switch (args.length())
@@ -87,7 +87,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args == NIL)
           return error(new WrongNumberOfArgumentsException(this));
@@ -101,7 +101,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args == NIL)
           return error(new WrongNumberOfArgumentsException(this));
@@ -111,7 +111,7 @@
 
   private static final LispObject _let(LispObject args, Environment env,
                                        boolean sequential)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
@@ -176,7 +176,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         LispObject varList = checkList(args.car());
         final LispThread thread = LispThread.currentThread();
@@ -227,7 +227,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         switch (args.length())
           {
@@ -247,7 +247,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         final Environment ext = new Environment(env);
@@ -262,7 +262,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         LispThread thread = LispThread.currentThread();
         return progn(args, env, thread);
@@ -275,7 +275,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         return _flet(args, env, false);
       }
@@ -287,7 +287,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         return _flet(args, env, true);
       }
@@ -295,7 +295,7 @@
 
   private static final LispObject _flet(LispObject args, Environment env,
                                         boolean recursive)
-    throws ConditionThrowable
+
   {
     // First argument is a list of local function definitions.
     LispObject defs = checkList(args.car());
@@ -367,7 +367,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() != 2)
           return error(new WrongNumberOfArgumentsException(this));
@@ -402,7 +402,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         if (args.length() < 2)
           return error(new WrongNumberOfArgumentsException(this));
@@ -430,7 +430,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         return NIL;
       }
@@ -442,7 +442,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         final LispObject arg = args.car();
         if (arg instanceof Symbol)
@@ -500,7 +500,7 @@
     {
       @Override
       public LispObject execute(LispObject args, Environment env)
-        throws ConditionThrowable
+
       {
         LispObject value = Symbol.NIL;
         final LispThread thread = LispThread.currentThread();

Modified: trunk/abcl/src/org/armedbear/lisp/StackFrame.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StackFrame.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StackFrame.java	Fri Nov  6 15:07:54 2009
@@ -38,7 +38,7 @@
 {
   @Override
     public LispObject typep(LispObject typeSpecifier) 
-    throws ConditionThrowable
+
    {
      if (typeSpecifier == Symbol.STACK_FRAME)
        return T;
@@ -56,6 +56,6 @@
     return this.next;
   }
   
-  public abstract LispObject toLispList() throws ConditionThrowable;
-  public abstract SimpleString toLispString() throws ConditionThrowable;
+  public abstract LispObject toLispList();
+  public abstract SimpleString toLispString();
 }

Modified: trunk/abcl/src/org/armedbear/lisp/StandardClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardClass.java	Fri Nov  6 15:07:54 2009
@@ -59,7 +59,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.STANDARD_CLASS)
       return T;
@@ -68,7 +68,7 @@
     return super.typep(type);
   }
 
-  public LispObject allocateInstance() throws ConditionThrowable
+  public LispObject allocateInstance()
   {
     Layout layout = getClassLayout();
     if (layout == null)
@@ -83,7 +83,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     FastStringBuffer sb =
       new FastStringBuffer(Symbol.STANDARD_CLASS.writeToString());
@@ -264,7 +264,7 @@
     addClass(Symbol.SLOT_DEFINITION, SLOT_DEFINITION);
   }
 
-  public static void initializeStandardClasses() throws ConditionThrowable
+  public static void initializeStandardClasses()
   {
     // We need to call setDirectSuperclass() here for classes that have a
     // BuiltInClass as a superclass. See comment above (at first mention of

Modified: trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java	Fri Nov  6 15:07:54 2009
@@ -99,7 +99,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.COMPILED_FUNCTION)
       {
@@ -126,20 +126,20 @@
   }
 
   @Override
-  public LispObject execute() throws ConditionThrowable
+  public LispObject execute()
   {
     return function.execute();
   }
 
   @Override
-  public LispObject execute(LispObject arg) throws ConditionThrowable
+  public LispObject execute(LispObject arg)
   {
     return function.execute(arg);
   }
 
   @Override
   public LispObject execute(LispObject first, LispObject second)
-    throws ConditionThrowable
+
   {
     return function.execute(first, second);
   }
@@ -147,7 +147,7 @@
   @Override
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third)
-    throws ConditionThrowable
+
   {
     return function.execute(first, second, third);
   }
@@ -155,7 +155,7 @@
   @Override
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth)
-    throws ConditionThrowable
+
   {
     return function.execute(first, second, third, fourth);
   }
@@ -164,7 +164,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth)
-    throws ConditionThrowable
+
   {
     return function.execute(first, second, third, fourth,
                             fifth);
@@ -174,7 +174,7 @@
   public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth)
-    throws ConditionThrowable
+
   {
     return function.execute(first, second, third, fourth,
                             fifth, sixth);
@@ -185,7 +185,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh)
-    throws ConditionThrowable
+
   {
     return function.execute(first, second, third, fourth,
                             fifth, sixth, seventh);
@@ -196,20 +196,20 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh, LispObject eighth)
-    throws ConditionThrowable
+
   {
     return function.execute(first, second, third, fourth,
                             fifth, sixth, seventh, eighth);
   }
 
   @Override
-  public LispObject execute(LispObject[] args) throws ConditionThrowable
+  public LispObject execute(LispObject[] args)
   {
     return function.execute(args);
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     LispObject name = getGenericFunctionName();
     if (name != null)
@@ -277,7 +277,7 @@
     new Primitive("%generic-function-name", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME];
       }
@@ -289,7 +289,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME] = second;
           return second;
@@ -301,7 +301,7 @@
     new Primitive("%generic-function-lambda-list", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST];
       }
@@ -313,7 +313,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST] = second;
           return second;
@@ -327,7 +327,7 @@
     {
       @Override
       public LispObject execute(LispObject arg)
-        throws ConditionThrowable
+
       {
           return checkStandardGenericFunction(arg).function;
       }
@@ -341,7 +341,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first).function = second;
           return second;
@@ -353,7 +353,7 @@
     new Primitive("gf-required-args", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS];
       }
@@ -365,7 +365,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final StandardGenericFunction gf = checkStandardGenericFunction(first);
         gf.slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS] = second;
@@ -379,7 +379,7 @@
     new Primitive("generic-function-initial-methods", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS];
       }
@@ -391,7 +391,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS] = second;
           return second;
@@ -403,7 +403,7 @@
     new Primitive("generic-function-methods", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS];
       }
@@ -415,7 +415,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] = second;
           return second;
@@ -427,7 +427,7 @@
     new Primitive("generic-function-method-class", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS];
       }
@@ -439,7 +439,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] = second;
           return second;
@@ -451,7 +451,7 @@
     new Primitive("generic-function-method-combination", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION];
       }
@@ -463,7 +463,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION] 
 	    = second;
@@ -476,7 +476,7 @@
     new Primitive("generic-function-argument-precedence-order", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass
 							 .SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER];
@@ -489,7 +489,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first)
 	    .slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER] = second;
@@ -502,7 +502,7 @@
     new Primitive("generic-function-classes-to-emf-table", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg)
 	    .slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE];
@@ -515,7 +515,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first)
 	    .slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE] = second;
@@ -528,7 +528,7 @@
     new Primitive("generic-function-documentation", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION];
       }
@@ -540,7 +540,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION] 
 	    = second;
@@ -554,7 +554,7 @@
                   "generic-function")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           final StandardGenericFunction gf = checkStandardGenericFunction(arg);
           gf.finalizeInternal();        
@@ -569,7 +569,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         final StandardGenericFunction gf = checkStandardGenericFunction(first);
         LispObject args = second;
@@ -594,7 +594,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final StandardGenericFunction gf = checkStandardGenericFunction(first);
         LispObject args = second;
@@ -685,7 +685,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final StandardGenericFunction gf = checkStandardGenericFunction(first);
         return gf.getArgSpecialization(second);
@@ -699,7 +699,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         final StandardGenericFunction gf = checkStandardGenericFunction(first);
         LispObject layout = second;
@@ -718,7 +718,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final StandardGenericFunction gf = checkStandardGenericFunction(first);
         LispObject layout = second;
@@ -781,7 +781,7 @@
       {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-          throws ConditionThrowable
+
         {
           final StandardGenericFunction gf = checkStandardGenericFunction(first);
           LispObject eqlSpecializerObjects = second;
@@ -805,7 +805,7 @@
   }
   
   public static final StandardGenericFunction checkStandardGenericFunction(LispObject obj)
-  throws ConditionThrowable
+
   {
     if (obj instanceof StandardGenericFunction)
       return (StandardGenericFunction) obj;

Modified: trunk/abcl/src/org/armedbear/lisp/StandardMethod.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardMethod.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardMethod.java	Fri Nov  6 15:07:54 2009
@@ -67,7 +67,7 @@
     new Primitive("method-lambda-list", PACKAGE_SYS, true, "method")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST];
       }
@@ -80,7 +80,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST] = second;
           return second;
@@ -92,7 +92,7 @@
     new Primitive("%method-qualifiers", PACKAGE_SYS, true, "method")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS];
       }
@@ -105,7 +105,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {          
           checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS] = second;
           return second;
@@ -117,7 +117,7 @@
     new Primitive("method-documentation", PACKAGE_SYS, true, "method")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION];
       }
@@ -130,7 +130,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION] = second;
           return second;
@@ -143,7 +143,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     LispObject genericFunction =
       slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION];
@@ -186,7 +186,7 @@
     new Primitive("%method-generic-function", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION];
       }
@@ -198,7 +198,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION] = second;
           return second;
@@ -210,7 +210,7 @@
     new Primitive("%method-function", PACKAGE_SYS, true, "method")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_FUNCTION];
       }
@@ -223,7 +223,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_FUNCTION] = second;
           return second;
@@ -235,7 +235,7 @@
     new Primitive("%method-fast-function", PACKAGE_SYS, true, "method")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION];
       }
@@ -248,7 +248,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION] = second;
           return second;
@@ -260,7 +260,7 @@
     new Primitive("%method-specializers", PACKAGE_SYS, true, "method")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS];
       }
@@ -273,7 +273,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS] = second;
           return second;
@@ -296,7 +296,7 @@
                                 list(Symbol.METHOD),
                                 list(StandardClass.STANDARD_METHOD));
 
-        final public static StandardMethod checkStandardMethod(LispObject first) throws ConditionThrowable
+        final public static StandardMethod checkStandardMethod(LispObject first)
         {
                 if (first instanceof StandardMethod)
                         return (StandardMethod) first;

Modified: trunk/abcl/src/org/armedbear/lisp/StandardObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardObject.java	Fri Nov  6 15:07:54 2009
@@ -60,7 +60,7 @@
   }
 
   @Override
-  public LispObject getParts() throws ConditionThrowable
+  public LispObject getParts()
   {
     LispObject parts = NIL;
     if (layout != null)
@@ -119,7 +119,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.STANDARD_OBJECT)
       return T;
@@ -146,7 +146,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     final LispThread thread = LispThread.currentThread();
     int maxLevel = Integer.MAX_VALUE;
@@ -167,7 +167,7 @@
     return unreadableString(typeOf().writeToString());
   }
 
-  private Layout updateLayout() throws ConditionThrowable
+  private Layout updateLayout()
   {
     Debug.assertTrue(layout.isInvalid());
     Layout oldLayout = layout;
@@ -242,7 +242,7 @@
 
   // Only handles instance slots (not shared slots).
   public LispObject getInstanceSlotValue(LispObject slotName)
-    throws ConditionThrowable
+
   {
     Debug.assertTrue(layout != null);
     if (layout.isInvalid())
@@ -260,7 +260,7 @@
 
   // Only handles instance slots (not shared slots).
   public void setInstanceSlotValue(LispObject slotName, LispObject newValue)
-    throws ConditionThrowable
+
   {
     Debug.assertTrue(layout != null);
     if (layout.isInvalid())
@@ -276,7 +276,7 @@
     slots[index] = newValue;
   }
 
-        final public static StandardObject checkStandardObject(LispObject first) throws ConditionThrowable
+        final public static StandardObject checkStandardObject(LispObject first)
         {
                 if (first instanceof StandardObject)
                         return (StandardObject) first;
@@ -289,7 +289,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final StandardObject obj1 = checkStandardObject(first);
         final StandardObject obj2 = checkStandardObject(second);
@@ -305,7 +305,7 @@
     new Primitive("std-instance-layout", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final StandardObject instance = checkStandardObject(arg);
         Layout layout = instance.layout;
@@ -324,7 +324,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStandardObject(first).layout = checkLayout(second);          
           return second;
@@ -336,7 +336,7 @@
     new Primitive("std-instance-class", PACKAGE_SYS, true)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStandardObject(arg).layout.lispClass;
       }
@@ -349,7 +349,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final StandardObject instance = checkStandardObject(first);
         final int index;
@@ -392,7 +392,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
           checkStandardObject(first).slots[Fixnum.getValue(second)] = third; // FIXME
           return third;
@@ -405,7 +405,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final StandardObject instance = checkStandardObject(first);
         Layout layout = instance.layout;
@@ -437,7 +437,7 @@
     };
 
   @Override
-  public LispObject SLOT_VALUE(LispObject slotName) throws ConditionThrowable
+  public LispObject SLOT_VALUE(LispObject slotName)
   {
     if (layout.isInvalid())
       {
@@ -474,7 +474,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return first.SLOT_VALUE(second);
       }
@@ -482,7 +482,7 @@
 
   @Override
   public void setSlotValue(LispObject slotName, LispObject newValue)
-    throws ConditionThrowable
+
   {
     if (layout.isInvalid())
       {
@@ -519,7 +519,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         first.setSlotValue(second, third);
         return third;

Modified: trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java	Fri Nov  6 15:07:54 2009
@@ -40,7 +40,7 @@
     new Primitive("std-allocate-instance", PACKAGE_SYS, true, "class")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg == StandardClass.STANDARD_CLASS)
           return new StandardClass();

Modified: trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java	Fri Nov  6 15:07:54 2009
@@ -46,7 +46,7 @@
       new Primitive("reader-method-slot-name", PACKAGE_MOP, false, "reader-method")
   {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           if (arg instanceof StandardReaderMethod)
               return ((StandardReaderMethod)arg).slots[StandardReaderMethodClass.SLOT_INDEX_SLOT_NAME];
@@ -61,7 +61,7 @@
   {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-          throws ConditionThrowable
+
       {
           if (first instanceof StandardReaderMethod)
           {

Modified: trunk/abcl/src/org/armedbear/lisp/StorageCondition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StorageCondition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StorageCondition.java	Fri Nov  6 15:07:54 2009
@@ -35,11 +35,11 @@
 
 public class StorageCondition extends SeriousCondition
 {
-  public StorageCondition() throws ConditionThrowable
+  public StorageCondition()
   {
   }
 
-  public StorageCondition(LispObject initArgs) throws ConditionThrowable
+  public StorageCondition(LispObject initArgs)
   {
     super(initArgs);
   }
@@ -62,7 +62,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.STORAGE_CONDITION)
       return T;

Modified: trunk/abcl/src/org/armedbear/lisp/Stream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Stream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Stream.java	Fri Nov  6 15:07:54 2009
@@ -224,32 +224,32 @@
     isBinaryStream = true;
   }
 
-  public boolean isInputStream() throws ConditionThrowable
+  public boolean isInputStream()
   {
     return isInputStream;
   }
 
-  public boolean isOutputStream() throws ConditionThrowable
+  public boolean isOutputStream()
   {
     return isOutputStream;
   }
 
-  public boolean isCharacterInputStream() throws ConditionThrowable
+  public boolean isCharacterInputStream()
   {
     return isCharacterStream && isInputStream;
   }
 
-  public boolean isBinaryInputStream() throws ConditionThrowable
+  public boolean isBinaryInputStream()
   {
     return isBinaryStream && isInputStream;
   }
 
-  public boolean isCharacterOutputStream() throws ConditionThrowable
+  public boolean isCharacterOutputStream()
   {
     return isCharacterStream && isOutputStream;
   }
 
-  public boolean isBinaryOutputStream() throws ConditionThrowable
+  public boolean isBinaryOutputStream()
   {
     return isBinaryStream && isOutputStream;
   }
@@ -356,7 +356,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+  public LispObject typep(LispObject typeSpecifier)
   {
     if (typeSpecifier == Symbol.STREAM)
       return T;
@@ -365,7 +365,7 @@
     return super.typep(typeSpecifier);
   }
 
-  public LispObject getElementType() throws ConditionThrowable
+  public LispObject getElementType()
   {
     return elementType;
   }
@@ -401,7 +401,7 @@
 
   public LispObject read(boolean eofError, LispObject eofValue,
                          boolean recursive, LispThread thread)
-    throws ConditionThrowable
+
   {
     LispObject result = readPreservingWhitespace(eofError, eofValue,
                                                  recursive, thread);
@@ -440,7 +440,7 @@
                                              LispObject eofValue,
                                              boolean recursive,
                                              LispThread thread)
-    throws ConditionThrowable
+
   {
     if (recursive)
       {
@@ -488,7 +488,7 @@
 
   public LispObject faslRead(boolean eofError, LispObject eofValue,
                              boolean recursive, LispThread thread)
-    throws ConditionThrowable
+
   {
     try 
       {
@@ -523,7 +523,7 @@
                                                         LispObject eofValue,
                                                         boolean recursive,
                                                         LispThread thread)
-      throws ConditionThrowable, IOException
+      throws IOException
   {
     if (recursive)
       {
@@ -562,7 +562,7 @@
   }
 
   private final LispObject processChar(char c, Readtable rt)
-    throws ConditionThrowable
+
   {
     final LispObject handler = rt.getReaderMacroFunction(c);
     if (handler instanceof ReaderMacroFunction)
@@ -572,7 +572,7 @@
     return readToken(c, rt);
   }
 
-  public LispObject readPathname() throws ConditionThrowable
+  public LispObject readPathname()
   {
     LispObject obj = read(true, NIL, false, LispThread.currentThread());
     if (obj instanceof AbstractString)
@@ -582,7 +582,7 @@
     return error(new TypeError("#p requires a string or list argument."));
   }
 
-  public LispObject faslReadPathname() throws ConditionThrowable
+  public LispObject faslReadPathname()
   {
     LispObject obj = faslRead(true, NIL, false, LispThread.currentThread());
     if (obj instanceof AbstractString)
@@ -592,7 +592,7 @@
     return error(new TypeError("#p requires a string or list argument."));
   }
 
-  public LispObject readSymbol() throws ConditionThrowable
+  public LispObject readSymbol()
   {
     final Readtable rt =
       (Readtable) Symbol.CURRENT_READTABLE.symbolValue(LispThread.currentThread());
@@ -601,14 +601,14 @@
     return new Symbol(sb.toString());
   }
 
-  public LispObject readSymbol(Readtable rt) throws ConditionThrowable
+  public LispObject readSymbol(Readtable rt)
   {
     FastStringBuffer sb = new FastStringBuffer();
     _readToken(sb, rt);
     return new Symbol(sb.toString());
   }
 
-  public LispObject readStructure() throws ConditionThrowable
+  public LispObject readStructure()
   {
     final LispThread thread = LispThread.currentThread();
     LispObject obj = read(true, NIL, true, thread);
@@ -656,7 +656,7 @@
                                   this));
   }
 
-  public LispObject faslReadStructure() throws ConditionThrowable
+  public LispObject faslReadStructure()
   {
     final LispThread thread = LispThread.currentThread();
     LispObject obj = faslRead(true, NIL, true, thread);
@@ -705,7 +705,7 @@
   }
 
   public LispObject readList(boolean requireProperList, boolean useFaslReadtable)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     Cons first = null;
@@ -784,7 +784,7 @@
   }
 
   private static final boolean isTokenDelimiter(char c, Readtable rt)
-    throws ConditionThrowable
+
   {
     switch (c)
       {
@@ -802,7 +802,7 @@
   }
 
   public LispObject readDispatchChar(char dispChar, boolean useFaslReadtable)
-    throws ConditionThrowable
+
   {
     int numArg = -1;
     char c = 0;
@@ -852,7 +852,7 @@
   }
 
   public LispObject readCharacterLiteral(Readtable rt, LispThread thread)
-    throws ConditionThrowable
+
   {
     try 
       {
@@ -892,7 +892,7 @@
       }
   }
 
-  public void skipBalancedComment() throws ConditionThrowable
+  public void skipBalancedComment()
   {
     try 
       {
@@ -925,7 +925,7 @@
       }
   }
 
-  public LispObject readArray(int rank) throws ConditionThrowable
+  public LispObject readArray(int rank)
   {
     final LispThread thread = LispThread.currentThread();
     LispObject obj = read(true, NIL, true, thread);
@@ -949,7 +949,7 @@
       }
   }
 
-  public LispObject faslReadArray(int rank) throws ConditionThrowable
+  public LispObject faslReadArray(int rank)
   {
     final LispThread thread = LispThread.currentThread();
     LispObject obj = faslRead(true, NIL, true, thread);
@@ -973,7 +973,7 @@
       }
   }
 
-  public LispObject readComplex() throws ConditionThrowable
+  public LispObject readComplex()
   {
     final LispThread thread = LispThread.currentThread();
     LispObject obj = read(true, NIL, true, thread);
@@ -1004,7 +1004,7 @@
     return error(new ReaderError(sb.toString(), this));
   }
 
-  public LispObject faslReadComplex() throws ConditionThrowable
+  public LispObject faslReadComplex()
   {
     final LispThread thread = LispThread.currentThread();
     LispObject obj = faslRead(true, NIL, true, thread);
@@ -1035,7 +1035,7 @@
     return error(new ReaderError(sb.toString(), this));
   }
 
-  private String readMultipleEscape(Readtable rt) throws ConditionThrowable
+  private String readMultipleEscape(Readtable rt)
   {
     FastStringBuffer sb = new FastStringBuffer();
     try 
@@ -1109,7 +1109,7 @@
   }
 
   private final LispObject readToken(char c, Readtable rt)
-    throws ConditionThrowable
+
   {
     FastStringBuffer sb = new FastStringBuffer(c);
     final LispThread thread = LispThread.currentThread();
@@ -1214,7 +1214,7 @@
   }
 
   private final BitSet _readToken(FastStringBuffer sb, Readtable rt)
-    throws ConditionThrowable
+
   {
     BitSet flags = null;
     final LispObject readtableCase = rt.getReadtableCase();
@@ -1368,7 +1368,7 @@
   }
 
   private static final int getReadBase(LispThread thread)
-    throws ConditionThrowable
+
   {
     final int readBase;
     final LispObject readBaseObject = Symbol.READ_BASE.symbolValue(thread); 
@@ -1390,7 +1390,7 @@
   }
 
   private final LispObject makeNumber(String token, int length, int radix)
-    throws ConditionThrowable
+
   {
     if (length == 0)
       return null;
@@ -1453,7 +1453,7 @@
   }
 
   private final LispObject makeRatio(String token, int radix)
-    throws ConditionThrowable
+
   {
     final int index = token.indexOf('/');
     if (index < 0)
@@ -1479,7 +1479,7 @@
 
   private static final LispObject makeFloat(final String token,
                                             final int length)
-    throws ConditionThrowable
+
   {
     if (length == 0)
       return null;
@@ -1555,7 +1555,7 @@
       }
   }
 
-  public LispObject readRadix(int radix) throws ConditionThrowable
+  public LispObject readRadix(int radix)
   {
     FastStringBuffer sb = new FastStringBuffer();
     final LispThread thread = LispThread.currentThread();
@@ -1589,7 +1589,7 @@
     return error(new LispError());
   }
 
-  public LispObject faslReadRadix(int radix) throws ConditionThrowable
+  public LispObject faslReadRadix(int radix)
   {
     FastStringBuffer sb = new FastStringBuffer();
     final LispThread thread = LispThread.currentThread();
@@ -1618,7 +1618,7 @@
     return error(new LispError());
   }
 
-  private char flushWhitespace(Readtable rt) throws ConditionThrowable
+  private char flushWhitespace(Readtable rt)
   {
     try 
       {
@@ -1644,7 +1644,7 @@
   }
 
   public LispObject readDelimitedList(char delimiter)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     LispObject result = NIL;
@@ -1668,7 +1668,7 @@
   // => line, missing-newline-p
   // recursive-p is ignored
   public LispObject readLine(boolean eofError, LispObject eofValue)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     FastStringBuffer sb = new FastStringBuffer();
@@ -1701,7 +1701,7 @@
 
   // read-char &optional stream eof-error-p eof-value recursive-p => char
   // recursive-p is ignored
-  public LispObject readChar() throws ConditionThrowable
+  public LispObject readChar()
   {
     try 
       {
@@ -1718,7 +1718,7 @@
   }
 
   public LispObject readChar(boolean eofError, LispObject eofValue)
-    throws ConditionThrowable
+
   {
     try 
       {
@@ -1741,7 +1741,7 @@
   // read-char-no-hang &optional stream eof-error-p eof-value recursive-p => char
   // recursive-p is ignored
   public LispObject readCharNoHang(boolean eofError, LispObject eofValue)
-    throws ConditionThrowable
+
   {
     try 
       {
@@ -1755,7 +1755,7 @@
 
 
   // unread-char character &optional input-stream => nil
-  public LispObject unreadChar(LispCharacter c) throws ConditionThrowable
+  public LispObject unreadChar(LispCharacter c)
   {
     try 
       {
@@ -1768,33 +1768,33 @@
       }
   }
 
-  public LispObject finishOutput() throws ConditionThrowable
+  public LispObject finishOutput()
   {
     _finishOutput();
     return NIL;
   }
 
   // clear-input &optional input-stream => nil
-  public LispObject clearInput() throws ConditionThrowable
+  public LispObject clearInput()
   {
     _clearInput();
     return NIL;
   }
 
-  public LispObject getFilePosition() throws ConditionThrowable
+  public LispObject getFilePosition()
   {
     long pos = _getFilePosition();
     return pos >= 0 ? number(pos) : NIL;
   }
 
-  public LispObject setFilePosition(LispObject arg) throws ConditionThrowable
+  public LispObject setFilePosition(LispObject arg)
   {
     return _setFilePosition(arg) ? T : NIL;
   }
 
   // close stream &key abort => result
   // Must return true if stream was open, otherwise implementation-dependent.
-  public LispObject close(LispObject abort) throws ConditionThrowable
+  public LispObject close(LispObject abort)
   {
     _close();
     return T;
@@ -1809,7 +1809,7 @@
   // read-byte stream &optional eof-error-p eof-value => byte
   // Reads an 8-bit byte.
   public LispObject readByte(boolean eofError, LispObject eofValue)
-    throws ConditionThrowable
+
   {
     int n = _readByte();
     if (n < 0)
@@ -1822,13 +1822,13 @@
     return Fixnum.constants[n];
   }
 
-  public LispObject terpri() throws ConditionThrowable
+  public LispObject terpri()
   {
     _writeChar('\n');
     return NIL;
   }
 
-  public LispObject freshLine() throws ConditionThrowable
+  public LispObject freshLine()
   {
     if (charPos == 0)
       return NIL;
@@ -1836,14 +1836,14 @@
     return T;
   }
 
-  public void print(char c) throws ConditionThrowable
+  public void print(char c)
   {
     _writeChar(c);
   }
 
   // PRIN1 produces output suitable for input to READ.
   // Binds *PRINT-ESCAPE* to true.
-  public void prin1(LispObject obj) throws ConditionThrowable
+  public void prin1(LispObject obj)
   {
     LispThread thread = LispThread.currentThread();
     SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
@@ -1858,7 +1858,7 @@
       }
   }
 
-  public LispObject listen() throws ConditionThrowable
+  public LispObject listen()
   {
     if (pastEnd)
       return NIL;
@@ -1881,12 +1881,12 @@
       }
   }
 
-  public LispObject fileLength() throws ConditionThrowable
+  public LispObject fileLength()
   {
     return type_error(this, Symbol.FILE_STREAM);
   }
 
-  public LispObject fileStringLength(LispObject arg) throws ConditionThrowable
+  public LispObject fileStringLength(LispObject arg)
   {
     if (arg instanceof LispCharacter)
       {
@@ -1922,9 +1922,8 @@
   /** Reads a character off an underlying stream
    * 
    * @return a character, or -1 at end-of-file
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  protected int _readChar() throws ConditionThrowable, IOException
+  protected int _readChar() throws IOException
   {
     if (reader == null)
         streamNotCharacterInputStream();
@@ -1958,9 +1957,8 @@
   /** Puts a character back into the (underlying) stream
    * 
    * @param n
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  protected void _unreadChar(int n) throws ConditionThrowable, IOException
+  protected void _unreadChar(int n) throws IOException
   {
     if (reader == null)
         streamNotCharacterInputStream();
@@ -1979,9 +1977,8 @@
   /** Returns a boolean indicating input readily available
    * 
    * @return true if a character is available
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  protected boolean _charReady() throws ConditionThrowable, IOException
+  protected boolean _charReady() throws IOException
   {
     if (reader == null)
         streamNotCharacterInputStream();
@@ -1992,9 +1989,8 @@
    * updating charPos while doing so
    * 
    * @param c
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public void _writeChar(char c) throws ConditionThrowable
+  public void _writeChar(char c)
   {
     try
       {
@@ -2029,10 +2025,9 @@
    * @param chars
    * @param start
    * @param end
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
   public void _writeChars(char[] chars, int start, int end)
-    throws ConditionThrowable
+
   {
     try
       {
@@ -2085,9 +2080,8 @@
    * updating charPos while doing so
    * 
    * @param s
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public void _writeString(String s) throws ConditionThrowable
+  public void _writeString(String s)
   {
     try
       {
@@ -2106,9 +2100,8 @@
    * a new line and updating charPos while doing so
    * 
    * @param s
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public void _writeLine(String s) throws ConditionThrowable
+  public void _writeLine(String s)
   {
     try
       {
@@ -2126,9 +2119,8 @@
   /** Reads an 8-bit byte off the underlying stream
    * 
    * @return
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public int _readByte() throws ConditionThrowable
+  public int _readByte()
   {
     try
       {
@@ -2150,9 +2142,8 @@
   /** Writes an 8-bit byte off the underlying stream
    * 
    * @param n
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public void _writeByte(int n) throws ConditionThrowable
+  public void _writeByte(int n)
   {
     try
       {
@@ -2171,9 +2162,8 @@
 
   /** Flushes any buffered output in the (underlying) stream
    * 
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public void _finishOutput() throws ConditionThrowable
+  public void _finishOutput()
   {
     try
       {
@@ -2191,9 +2181,8 @@
   /** Reads all input from the underlying stream,
    * until _charReady() indicates no more input to be available
    * 
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public void _clearInput() throws ConditionThrowable
+  public void _clearInput()
   {
     if (reader != null)
       {
@@ -2231,9 +2220,8 @@
    * 
    * @return non-negative value as a position spec
    * @return negative value for 'unspecified'
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  protected long _getFilePosition() throws ConditionThrowable
+  protected long _getFilePosition()
   {
     return -1;
   }
@@ -2242,18 +2230,16 @@
    * 
    * @param arg File position specifier as described in the CLHS
    * @return true on success, false on failure
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  protected boolean _setFilePosition(LispObject arg) throws ConditionThrowable
+  protected boolean _setFilePosition(LispObject arg)
   {
     return false;
   }
 
   /** Closes the stream and underlying streams
    * 
-   * @throws org.armedbear.lisp.ConditionThrowable
    */
-  public void _close() throws ConditionThrowable
+  public void _close()
   {
     try
       {
@@ -2273,7 +2259,7 @@
       }
   }
 
-  public void printStackTrace(Throwable t) throws ConditionThrowable
+  public void printStackTrace(Throwable t)
   {
     StringWriter sw = new StringWriter();
     PrintWriter pw = new PrintWriter(sw);
@@ -2292,27 +2278,27 @@
       }
   }
 
-  protected LispObject streamNotInputStream() throws ConditionThrowable
+  protected LispObject streamNotInputStream()
   {
     return error(new StreamError(this, writeToString() + " is not an input stream."));
   }
 
-  protected LispObject streamNotCharacterInputStream() throws ConditionThrowable
+  protected LispObject streamNotCharacterInputStream()
   {
     return error(new StreamError(this, writeToString() + " is not a character input stream."));
   }
 
-  protected LispObject streamNotOutputStream() throws ConditionThrowable
+  protected LispObject streamNotOutputStream()
   {
     return error(new StreamError(this, writeToString() + " is not an output stream."));
   }
 
-  protected LispObject streamNotBinaryOutputStream() throws ConditionThrowable
+  protected LispObject streamNotBinaryOutputStream()
   {
     return error(new StreamError(this, writeToString() + " is not a binary output stream."));
   }
 
-  protected LispObject streamNotCharacterOutputStream() throws ConditionThrowable
+  protected LispObject streamNotCharacterOutputStream()
   {
     return error(new StreamError(this, writeToString() + " is not a character output stream."));
   }
@@ -2325,7 +2311,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           checkStream(second)._writeChar(LispCharacter.getValue(first));       
           return first;
@@ -2339,7 +2325,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final char c = LispCharacter.getValue(first);
         if (second == T)
@@ -2360,7 +2346,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         final AbstractString s = checkString(first);
         char[] chars = s.chars();
@@ -2384,7 +2370,7 @@
     new Primitive("%finish-output", PACKAGE_SYS, false, "output-stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return finishOutput(arg);
       }
@@ -2395,14 +2381,14 @@
     new Primitive("%force-output", PACKAGE_SYS, false, "output-stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return finishOutput(arg);
       }
     };
 
   private static final LispObject finishOutput(LispObject arg)
-    throws ConditionThrowable
+
   {
     final LispObject out;
         if (arg == T)
@@ -2419,7 +2405,7 @@
     new Primitive(Symbol.CLEAR_INPUT, "&optional input-stream")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         if (args.length > 1)
           return error(new WrongNumberOfArgumentsException(this));
@@ -2440,7 +2426,7 @@
     new Primitive("%clear-output", PACKAGE_SYS, false, "output-stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg == T) // *TERMINAL-IO*
           return NIL;
@@ -2457,7 +2443,7 @@
     new Primitive(Symbol.CLOSE, "stream &key abort")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStream(arg).close(NIL);
       }
@@ -2465,7 +2451,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
           final Stream stream = checkStream(first);
           if (second == Keyword.ABORT)          
@@ -2480,7 +2466,7 @@
     new Primitive("out-synonym-of", PACKAGE_SYS, true, "stream-designator")
     {
       @Override
-      public LispObject execute (LispObject arg) throws ConditionThrowable
+      public LispObject execute (LispObject arg)
       {
         if (arg instanceof Stream)
           return arg;
@@ -2499,7 +2485,7 @@
     {
       @Override
       public LispObject execute (LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         int n = Fixnum.getValue(first);
         if (n < 0 || n > 255)
@@ -2518,14 +2504,14 @@
       @Override
       public LispObject execute (LispObject first, LispObject second,
                                  LispObject third)
-        throws ConditionThrowable
+
       {
         return checkBinaryInputStream(first).readByte((second != NIL),
                                                       third);
       }
 
       @Override
-      public LispObject execute (LispObject[] args) throws ConditionThrowable
+      public LispObject execute (LispObject[] args)
       {
         int length = args.length;
         if (length < 1 || length > 3)
@@ -2544,14 +2530,14 @@
                   "&optional input-stream eof-error-p eof-value recursive-p")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         final LispObject obj = Symbol.STANDARD_INPUT.symbolValue();
         final Stream stream = checkStream(obj);
         return stream.readLine(true, NIL);
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         if (arg == T)
           arg = Symbol.TERMINAL_IO.symbolValue();
@@ -2562,7 +2548,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         if (first == T)
           first = Symbol.TERMINAL_IO.symbolValue();
@@ -2574,7 +2560,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         if (first == T)
           first = Symbol.TERMINAL_IO.symbolValue();
@@ -2586,7 +2572,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         // recursive-p is ignored
         if (first == T)
@@ -2607,7 +2593,7 @@
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth,
                                 LispObject fifth, LispObject sixth)
-        throws ConditionThrowable
+
       {
         String s = first.getStringValue();
         boolean eofError = (second != NIL);
@@ -2641,7 +2627,7 @@
                   "&optional input-stream eof-error-p eof-value recursive-p")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         final LispThread thread = LispThread.currentThread();
         final LispObject obj = Symbol.STANDARD_INPUT.symbolValue(thread);
@@ -2649,7 +2635,7 @@
         return stream.read(true, NIL, false, thread);
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         final LispThread thread = LispThread.currentThread();
         if (arg == T)
@@ -2661,7 +2647,7 @@
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         if (first == T)
@@ -2674,7 +2660,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         if (first == T)
@@ -2687,7 +2673,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         final LispThread thread = LispThread.currentThread();
         if (first == T)
@@ -2706,7 +2692,7 @@
                   "&optional input-stream eof-error-p eof-value recursive-p")
     {
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         int length = args.length;
         if (length > 4)
@@ -2729,32 +2715,32 @@
                   "&optional input-stream eof-error-p eof-value recursive-p")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue()).readChar();
       }
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return inSynonymOf(arg).readChar();
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         return inSynonymOf(first).readChar(second != NIL, NIL);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
         return inSynonymOf(first).readChar(second != NIL, third);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         return inSynonymOf(first).readChar(second != NIL, third);
       }
@@ -2766,7 +2752,7 @@
     new Primitive("read-char-no-hang", "&optional input-stream eof-error-p eof-value recursive-p") {
 
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         int length = args.length;
         if (length > 4)
@@ -2786,7 +2772,7 @@
     new Primitive("read-delimited-list", "char &optional input-stream recursive-p") {
 
       @Override
-      public LispObject execute(LispObject[] args) throws ConditionThrowable
+      public LispObject execute(LispObject[] args)
       {
         int length = args.length;
         if (length < 1 || length > 3)
@@ -2804,13 +2790,13 @@
     new Primitive(Symbol.UNREAD_CHAR, "character &optional input-stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return getStandardInput().unreadChar(checkCharacter(arg));
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         Stream stream = inSynonymOf(second);
         return stream.unreadChar(checkCharacter(first));
@@ -2825,7 +2811,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         final AbstractVector v = checkVector(first);
         final Stream stream = checkStream(second);
@@ -2845,7 +2831,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
         AbstractVector v = checkVector(first);
         Stream stream = checkBinaryInputStream(second);
@@ -2873,13 +2859,13 @@
     new Primitive("file-position", "stream &optional position-spec")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           return checkStream(arg).getFilePosition();
       }
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           return checkStream(first).setFilePosition(second);
       }
@@ -2890,7 +2876,7 @@
     new Primitive("stream-line-number", PACKAGE_SYS, false, "stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return Fixnum.getInstance(checkStream(arg).getLineNumber() + 1);
       }
@@ -2901,7 +2887,7 @@
     new Primitive("stream-offset", PACKAGE_SYS, false, "stream")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return number(checkStream(arg).getOffset());
       }
@@ -2912,7 +2898,7 @@
     new Primitive("stream-charpos", PACKAGE_SYS, false)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         Stream stream = checkCharacterOutputStream(arg);
         return Fixnum.getInstance(stream.getCharPos());
@@ -2925,7 +2911,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         Stream stream = checkCharacterOutputStream(first);
         stream.setCharPos(Fixnum.getValue(second));

Modified: trunk/abcl/src/org/armedbear/lisp/StreamError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StreamError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StreamError.java	Fri Nov  6 15:07:54 2009
@@ -37,13 +37,13 @@
 {
     private final Throwable cause;
 
-    protected StreamError(LispClass cls) throws ConditionThrowable
+    protected StreamError(LispClass cls)
     {
         super(cls);
         cause = null;
     }
 
-    public StreamError(String message) throws ConditionThrowable
+    public StreamError(String message)
     {
         super(StandardClass.STREAM_ERROR);
         setFormatControl(message);
@@ -52,14 +52,14 @@
         cause = null;
     }
 
-    public StreamError(Stream stream) throws ConditionThrowable
+    public StreamError(Stream stream)
     {
         super(StandardClass.STREAM_ERROR);
         setStream(stream != null ? stream : NIL);
         cause = null;
     }
 
-    public StreamError(String message, Stream stream) throws ConditionThrowable
+    public StreamError(String message, Stream stream)
     {
         super(StandardClass.STREAM_ERROR);
         setFormatControl(message);
@@ -68,7 +68,7 @@
         cause = null;
     }
 
-    public StreamError(LispObject initArgs) throws ConditionThrowable
+    public StreamError(LispObject initArgs)
     {
         super(StandardClass.STREAM_ERROR);
         initialize(initArgs);
@@ -76,7 +76,7 @@
     }
 
     @Override
-    protected void initialize(LispObject initArgs) throws ConditionThrowable
+    protected void initialize(LispObject initArgs)
     {
         super.initialize(initArgs);
         while (initArgs != NIL) {
@@ -90,7 +90,7 @@
         }
     }
 
-    public StreamError(Stream stream, String message) throws ConditionThrowable
+    public StreamError(Stream stream, String message)
     {
         super(StandardClass.STREAM_ERROR);
         setFormatControl(message);
@@ -99,19 +99,19 @@
         cause = null;
     }
 
-    public StreamError(Stream stream, Throwable cause) throws ConditionThrowable
+    public StreamError(Stream stream, Throwable cause)
     {
         super(StandardClass.STREAM_ERROR);
         setStream(stream != null ? stream : NIL);
         this.cause = cause;
     }
 
-    public final LispObject getStream() throws ConditionThrowable
+    public final LispObject getStream()
     {
         return getInstanceSlotValue(Symbol.STREAM);
     }
 
-    protected final void setStream(LispObject stream) throws ConditionThrowable
+    protected final void setStream(LispObject stream)
     {
         setInstanceSlotValue(Symbol.STREAM, stream);
     }
@@ -129,7 +129,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.STREAM_ERROR)
             return T;
@@ -154,7 +154,7 @@
         new Primitive("stream-error-stream", "condition")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof StreamError) 
                 return ((StreamError)arg).getStream();                

Modified: trunk/abcl/src/org/armedbear/lisp/StringFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StringFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StringFunctions.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third, LispObject fourth,
                                   LispObject fifth, LispObject sixth)
-            throws ConditionThrowable
+
         {
             char[] array1 = first.STRING().getStringChars();
             char[] array2 = second.STRING().getStringChars();
@@ -85,7 +85,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             char[] array1 = first.STRING().getStringChars();
             char[] array2 = second.STRING().getStringChars();
@@ -105,7 +105,7 @@
         new Primitive("%string/=", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -145,7 +145,7 @@
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third, LispObject fourth,
                                   LispObject fifth, LispObject sixth)
-            throws ConditionThrowable
+
         {
             char[] array1 = first.STRING().getStringChars();
             char[] array2 = second.STRING().getStringChars();
@@ -177,7 +177,7 @@
         new Primitive("%string-not-equal", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -221,7 +221,7 @@
         new Primitive("%string<", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -265,7 +265,7 @@
         new Primitive("%string>", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -307,7 +307,7 @@
         new Primitive("%string<=", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -349,7 +349,7 @@
         new Primitive("%string>=", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -393,7 +393,7 @@
         new Primitive("%string-lessp", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -437,7 +437,7 @@
         new Primitive("%string-greaterp", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -479,7 +479,7 @@
         new Primitive("%string-not-lessp", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -523,7 +523,7 @@
         new Primitive("%string-not-greaterp", PACKAGE_SYS, true)
     {
         @Override
-        public LispObject execute(LispObject[] args) throws ConditionThrowable
+        public LispObject execute(LispObject[] args)
         {
             if (args.length != 6)
                 return error(new WrongNumberOfArgumentsException(this));
@@ -566,7 +566,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             LispObject s = first.STRING();
             final int length = s.length();
@@ -638,7 +638,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             LispObject s = first.STRING();
             final int length = s.length();
@@ -686,7 +686,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             final AbstractString string = checkString(first);
             final int length = string.length();
@@ -715,7 +715,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             final AbstractString string = checkString(first);
             final int length = string.length();
@@ -744,7 +744,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             AbstractString string = checkString(first);
             final int length = string.length();
@@ -782,7 +782,7 @@
     public static final Primitive STRINGP = new Primitive("stringp", "object")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return arg.STRINGP();
         }
@@ -793,7 +793,7 @@
         new Primitive("simple-string-p", "object")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return arg.SIMPLE_STRING_P();
         }
@@ -808,7 +808,7 @@
         @Override
         public LispObject execute(LispObject size, LispObject initialElement,
                                   LispObject elementType)
-            throws ConditionThrowable
+
         {
             final int n = Fixnum.getValue(size);
             if (n < 0 || n >= ARRAY_DIMENSION_MAX) {
@@ -841,7 +841,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
                 return first.CHAR(Fixnum.getValue(second));
         }
@@ -853,7 +853,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             return first.SCHAR(Fixnum.getValue(second));
         }
@@ -866,7 +866,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             checkString(first).setCharAt(Fixnum.getValue(second),
                     LispCharacter.getValue(third));
@@ -881,7 +881,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             if (first instanceof SimpleString) {
                 ((SimpleString)first).setCharAt(Fixnum.getValue(second),
@@ -899,7 +899,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             char c = LispCharacter.getValue(first);
             AbstractString string = checkString(second);
@@ -918,7 +918,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if (first instanceof LispCharacter) {
                 final char c = ((LispCharacter)first).value;
@@ -940,7 +940,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             // FIXME Don't call getStringValue() here! (Just look at the chars.)
             int index = second.getStringValue().indexOf(first.getStringValue());
@@ -954,7 +954,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             if(first instanceof AbstractString) {
                 AbstractString s = (AbstractString) first;

Modified: trunk/abcl/src/org/armedbear/lisp/StringInputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StringInputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StringInputStream.java	Fri Nov  6 15:07:54 2009
@@ -75,7 +75,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.STRING_INPUT_STREAM)
             return T;
@@ -105,14 +105,14 @@
         new Primitive("make-string-input-stream", "string &optional start end")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return new StringInputStream(arg.getStringValue());
         }
 
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             String s = first.getStringValue();
             int start = Fixnum.getValue(second);
@@ -122,7 +122,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third)
-            throws ConditionThrowable
+
         {
             String s = first.getStringValue();
             int start = Fixnum.getValue(second);
@@ -138,7 +138,7 @@
         new Primitive("string-input-stream-current", PACKAGE_EXT, true, "stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof StringInputStream)
                 return Fixnum.getInstance(((StringInputStream)arg).getOffset());

Modified: trunk/abcl/src/org/armedbear/lisp/StringOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StringOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StringOutputStream.java	Fri Nov  6 15:07:54 2009
@@ -64,7 +64,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.STRING_OUTPUT_STREAM)
             return T;
@@ -78,14 +78,14 @@
     }
 
     @Override
-    protected long _getFilePosition() throws ConditionThrowable
+    protected long _getFilePosition()
     {
         if (elementType == NIL)
             return 0;
         return stringWriter.getBuffer().length();
     }
 
-    public LispObject getString() throws ConditionThrowable
+    public LispObject getString()
     {
         if (elementType == NIL)
             return new NilVector(0);
@@ -108,7 +108,7 @@
                        "element-type")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return new StringOutputStream(arg);
         }
@@ -120,7 +120,7 @@
         new Primitive("get-output-stream-string", "string-output-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof StringOutputStream)
                 return ((StringOutputStream)arg).getString();

Modified: trunk/abcl/src/org/armedbear/lisp/StructureClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StructureClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StructureClass.java	Fri Nov  6 15:07:54 2009
@@ -58,7 +58,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.STRUCTURE_CLASS)
             return T;
@@ -68,13 +68,13 @@
     }
 
     @Override
-    public LispObject getDescription() throws ConditionThrowable
+    public LispObject getDescription()
     {
         return new SimpleString(writeToString());
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         StringBuffer sb = new StringBuffer("#<STRUCTURE-CLASS ");
         sb.append(symbol.writeToString());
@@ -89,7 +89,7 @@
         @Override
         public LispObject execute(LispObject first, LispObject second,
                                   LispObject third, LispObject fourth)
-            throws ConditionThrowable
+
         {
             Symbol symbol = checkSymbol(first);
             LispClass existingClass = LispClass.findClass(symbol);

Modified: trunk/abcl/src/org/armedbear/lisp/StructureObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StructureObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StructureObject.java	Fri Nov  6 15:07:54 2009
@@ -39,14 +39,14 @@
   private final LispObject[] slots;
 
   public StructureObject(Symbol symbol, LispObject[] slots)
-    throws ConditionThrowable
+
   {
     structureClass = (StructureClass) LispClass.findClass(symbol); // Might return null.
     this.slots = slots;
   }
 
   public StructureObject(Symbol symbol, LispObject obj0)
-    throws ConditionThrowable
+
   {
     structureClass = (StructureClass) LispClass.findClass(symbol); // Might return null.
     LispObject[] slots = new LispObject[1];
@@ -55,7 +55,7 @@
   }
 
   public StructureObject(Symbol symbol, LispObject obj0, LispObject obj1)
-    throws ConditionThrowable
+
   {
     structureClass = (StructureClass) LispClass.findClass(symbol); // Might return null.
     LispObject[] slots = new LispObject[2];
@@ -66,7 +66,7 @@
 
   public StructureObject(Symbol symbol, LispObject obj0, LispObject obj1,
                          LispObject obj2)
-    throws ConditionThrowable
+
   {
     structureClass = (StructureClass) LispClass.findClass(symbol); // Might return null.
     LispObject[] slots = new LispObject[3];
@@ -78,7 +78,7 @@
 
   public StructureObject(Symbol symbol, LispObject obj0, LispObject obj1,
                          LispObject obj2, LispObject obj3)
-    throws ConditionThrowable
+
   {
     structureClass = (StructureClass) LispClass.findClass(symbol); // Might return null.
     LispObject[] slots = new LispObject[4];
@@ -91,7 +91,7 @@
 
   public StructureObject(Symbol symbol, LispObject obj0, LispObject obj1,
                          LispObject obj2, LispObject obj3, LispObject obj4)
-    throws ConditionThrowable
+
   {
     structureClass = (StructureClass) LispClass.findClass(symbol); // Might return null.
     LispObject[] slots = new LispObject[5];
@@ -106,7 +106,7 @@
   public StructureObject(Symbol symbol, LispObject obj0, LispObject obj1,
                          LispObject obj2, LispObject obj3, LispObject obj4,
                          LispObject obj5)
-    throws ConditionThrowable
+
   {
     structureClass = (StructureClass) LispClass.findClass(symbol); // Might return null.
     LispObject[] slots = new LispObject[6];
@@ -140,7 +140,7 @@
   }
 
   @Override
-  public LispObject getParts() throws ConditionThrowable
+  public LispObject getParts()
   {
     LispObject result = NIL;
     result = result.push(new Cons("class", structureClass));
@@ -157,7 +157,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type instanceof StructureClass)
       return memq(type, structureClass.getCPL()) ? T : NIL;
@@ -177,7 +177,7 @@
   }
 
   @Override
-  public boolean equalp(LispObject obj) throws ConditionThrowable
+  public boolean equalp(LispObject obj)
   {
     if (this == obj)
       return true;
@@ -197,7 +197,7 @@
   }
 
   @Override
-  public LispObject getSlotValue_0() throws ConditionThrowable
+  public LispObject getSlotValue_0()
   {
     try
       {
@@ -210,7 +210,7 @@
   }
 
   @Override
-  public LispObject getSlotValue_1() throws ConditionThrowable
+  public LispObject getSlotValue_1()
   {
     try
       {
@@ -223,7 +223,7 @@
   }
 
   @Override
-  public LispObject getSlotValue_2() throws ConditionThrowable
+  public LispObject getSlotValue_2()
   {
     try
       {
@@ -236,7 +236,7 @@
   }
 
   @Override
-  public LispObject getSlotValue_3() throws ConditionThrowable
+  public LispObject getSlotValue_3()
   {
     try
       {
@@ -249,7 +249,7 @@
   }
 
   @Override
-  public LispObject getSlotValue(int index) throws ConditionThrowable
+  public LispObject getSlotValue(int index)
   {
     try
       {
@@ -262,7 +262,7 @@
   }
 
   @Override
-  public int getFixnumSlotValue(int index) throws ConditionThrowable
+  public int getFixnumSlotValue(int index)
   {
     try
       {
@@ -277,7 +277,7 @@
   }
 
   @Override
-  public boolean getSlotValueAsBoolean(int index) throws ConditionThrowable
+  public boolean getSlotValueAsBoolean(int index)
   {
     try
       {
@@ -293,7 +293,7 @@
 
   @Override
   public void setSlotValue_0(LispObject value)
-    throws ConditionThrowable
+
   {
     try
       {
@@ -307,7 +307,7 @@
 
   @Override
   public void setSlotValue_1(LispObject value)
-    throws ConditionThrowable
+
   {
     try
       {
@@ -321,7 +321,7 @@
 
   @Override
   public void setSlotValue_2(LispObject value)
-    throws ConditionThrowable
+
   {
     try
       {
@@ -335,7 +335,7 @@
 
   @Override
   public void setSlotValue_3(LispObject value)
-    throws ConditionThrowable
+
   {
     try
       {
@@ -349,7 +349,7 @@
 
   @Override
   public void setSlotValue(int index, LispObject value)
-    throws ConditionThrowable
+
   {
     try
       {
@@ -361,7 +361,7 @@
       }
   }
 
-  private LispObject badIndex(int n) throws ConditionThrowable
+  private LispObject badIndex(int n)
   {
     FastStringBuffer sb = new FastStringBuffer("Invalid slot index ");
     sb.append(Fixnum.getInstance(n).writeToString());
@@ -392,7 +392,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     try
       {
@@ -481,7 +481,7 @@
     new Primitive("structure-length", PACKAGE_SYS, true, "instance")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           if (arg instanceof StructureObject)
             return Fixnum.getInstance(((StructureObject)arg).slots.length);
@@ -495,7 +495,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
     if (first instanceof StructureObject)
         try
@@ -518,7 +518,7 @@
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
           
             if (first instanceof StructureObject)
@@ -542,21 +542,21 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           return new StructureObject(checkSymbol(first), second);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third)
-        throws ConditionThrowable
+
       {
           return new StructureObject(checkSymbol(first), second, third);
       }
       @Override
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth)
-        throws ConditionThrowable
+
       {
           return new StructureObject(checkSymbol(first), second, third, fourth);
       }
@@ -564,7 +564,7 @@
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth,
                                 LispObject fifth)
-        throws ConditionThrowable
+
       {
           return new StructureObject(checkSymbol(first), second, third, fourth,
                   fifth);
@@ -573,7 +573,7 @@
       public LispObject execute(LispObject first, LispObject second,
                                 LispObject third, LispObject fourth,
                                 LispObject fifth, LispObject sixth)
-        throws ConditionThrowable
+
       {
           return new StructureObject(checkSymbol(first), second, third, fourth,
                   fifth, sixth);
@@ -583,7 +583,7 @@
                                 LispObject third, LispObject fourth,
                                 LispObject fifth, LispObject sixth,
                                 LispObject seventh)
-        throws ConditionThrowable
+
       {
           return new StructureObject(checkSymbol(first), second, third, fourth,
                   fifth, sixth, seventh);
@@ -596,7 +596,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
           return new StructureObject(checkSymbol(first), second.copyToArray());
       }
@@ -607,7 +607,7 @@
     new Primitive(Symbol.COPY_STRUCTURE, "structure")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
           if (arg instanceof StructureObject)
             return new StructureObject((StructureObject)arg);

Modified: trunk/abcl/src/org/armedbear/lisp/StyleWarning.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StyleWarning.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StyleWarning.java	Fri Nov  6 15:07:54 2009
@@ -35,7 +35,7 @@
 
 public final class StyleWarning extends Warning
 {
-    public StyleWarning(LispObject initArgs) throws ConditionThrowable
+    public StyleWarning(LispObject initArgs)
     {
         super(StandardClass.STYLE_WARNING);
         initialize(initArgs);
@@ -54,7 +54,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.STYLE_WARNING)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/Symbol.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Symbol.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Symbol.java	Fri Nov  6 15:07:54 2009
@@ -113,7 +113,7 @@
   }
 
   @Override
-  public LispObject getDescription() throws ConditionThrowable
+  public LispObject getDescription()
   {
     final LispThread thread = LispThread.currentThread();
     SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
@@ -142,7 +142,7 @@
   }
 
   @Override
-  public LispObject getParts() throws ConditionThrowable
+  public LispObject getParts()
   {
     LispObject parts = NIL;
     parts = parts.push(new Cons("name", name));
@@ -156,7 +156,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.SYMBOL)
       return T;
@@ -315,13 +315,12 @@
    * A lisp error is thrown if the symbol is unbound.
    *
    * @return The associated value
-   * @throws org.armedbear.lisp.ConditionThrowable
    *
    * @see LispThread#lookupSpecial
    * @see Symbol#getSymbolValue()
    *
    */
-  public final LispObject symbolValue() throws ConditionThrowable
+  public final LispObject symbolValue()
   {
     return symbolValue(LispThread.currentThread());
   }
@@ -332,13 +331,12 @@
    * A lisp error is thrown if the symbol is unbound.
    *
    * @return The associated value
-   * @throws org.armedbear.lisp.ConditionThrowable
    *
    * @see LispThread#lookupSpecial
    * @see Symbol#getSymbolValue()
    *
    */
-  public final LispObject symbolValue(LispThread thread) throws ConditionThrowable
+  public final LispObject symbolValue(LispThread thread)
   {
     LispObject val = thread.lookupSpecial(this);
     if (val != null)
@@ -393,7 +391,7 @@
   }
 
   @Override
-  public final LispObject getSymbolFunctionOrDie() throws ConditionThrowable
+  public final LispObject getSymbolFunctionOrDie()
   {
     if (function == null)
       return error(new UndefinedFunction(this));
@@ -406,7 +404,7 @@
   }
 
   public final LispObject getSymbolSetfFunctionOrDie()
-    throws ConditionThrowable
+
   {
     LispObject obj = get(this, Symbol.SETF_FUNCTION, null);
     if (obj == null)
@@ -423,7 +421,7 @@
 
   /** See LispObject.getStringValue() */
   @Override
-  public String getStringValue() throws ConditionThrowable
+  public String getStringValue()
   {
     return name.getStringValue();
   }
@@ -445,7 +443,7 @@
   }
 
   @Override
-  public String writeToString() throws ConditionThrowable
+  public String writeToString()
   {
     final String n = name.getStringValue();
     final LispThread thread = LispThread.currentThread();
@@ -639,7 +637,7 @@
   private static final boolean needsEscape(String s,
                                            LispObject readtableCase,
                                            LispThread thread)
-    throws ConditionThrowable
+
   {
     boolean escape = false;
     final int length = s.length();
@@ -771,7 +769,7 @@
   }
 
   @Override
-  final public LispObject execute() throws ConditionThrowable
+  final public LispObject execute()
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -781,7 +779,7 @@
   }
 
   @Override
-  final public LispObject execute(LispObject arg) throws ConditionThrowable
+  final public LispObject execute(LispObject arg)
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -792,7 +790,7 @@
 
   @Override
   final public LispObject execute(LispObject first, LispObject second)
-    throws ConditionThrowable
+
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -804,7 +802,7 @@
   @Override
   final public LispObject execute(LispObject first, LispObject second,
                             LispObject third)
-    throws ConditionThrowable
+
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -816,7 +814,7 @@
   @Override
   final public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth)
-    throws ConditionThrowable
+
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -829,7 +827,7 @@
   final public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth)
-    throws ConditionThrowable
+
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -844,7 +842,7 @@
   final public LispObject execute(LispObject first, LispObject second,
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth)
-    throws ConditionThrowable
+
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -860,7 +858,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh)
-    throws ConditionThrowable
+
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -876,7 +874,7 @@
                             LispObject third, LispObject fourth,
                             LispObject fifth, LispObject sixth,
                             LispObject seventh, LispObject eighth)
-    throws ConditionThrowable
+
   {
     LispObject fun;
     if ((fun = function) == null)
@@ -888,7 +886,7 @@
   }
 
   @Override
-  final public LispObject execute(LispObject[] args) throws ConditionThrowable
+  final public LispObject execute(LispObject[] args)
   {
     LispObject fun;
     if ((fun = function) == null) {
@@ -902,7 +900,7 @@
   }
 
   private final LispObject undefinedFunction(LispObject args)
-    throws ConditionThrowable
+
   {
     return LispThread.currentThread().execute(Symbol.UNDEFINED_FUNCTION_CALLED,
                                               this, args);

Modified: trunk/abcl/src/org/armedbear/lisp/SynonymStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SynonymStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SynonymStream.java	Fri Nov  6 15:07:54 2009
@@ -43,37 +43,37 @@
     }
 
     @Override
-    public boolean isInputStream() throws ConditionThrowable
+    public boolean isInputStream()
     {
         return checkStream(symbol.symbolValue()).isInputStream();
     }
 
     @Override
-    public boolean isOutputStream() throws ConditionThrowable
+    public boolean isOutputStream()
     {
         return checkStream(symbol.symbolValue()).isOutputStream();
     }
 
     @Override
-    public boolean isCharacterInputStream() throws ConditionThrowable
+    public boolean isCharacterInputStream()
     {
         return checkStream(symbol.symbolValue()).isCharacterInputStream();
     }
 
     @Override
-    public boolean isBinaryInputStream() throws ConditionThrowable
+    public boolean isBinaryInputStream()
     {
         return checkStream(symbol.symbolValue()).isBinaryInputStream();
     }
 
     @Override
-    public boolean isCharacterOutputStream() throws ConditionThrowable
+    public boolean isCharacterOutputStream()
     {
         return checkStream(symbol.symbolValue()).isCharacterOutputStream();
     }
 
     @Override
-    public boolean isBinaryOutputStream() throws ConditionThrowable
+    public boolean isBinaryOutputStream()
     {
         return checkStream(symbol.symbolValue()).isBinaryOutputStream();
     }
@@ -91,7 +91,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
+    public LispObject typep(LispObject typeSpecifier)
     {
         if (typeSpecifier == Symbol.SYNONYM_STREAM)
             return T;
@@ -101,118 +101,118 @@
     }
 
     @Override
-    public LispObject getElementType() throws ConditionThrowable
+    public LispObject getElementType()
     {
         return checkStream(symbol.symbolValue()).getElementType();
     }
 
     @Override
-    public LispObject listen() throws ConditionThrowable
+    public LispObject listen()
     {
         return checkStream(symbol.symbolValue()).listen();
     }
 
     @Override
-    public LispObject fileLength() throws ConditionThrowable
+    public LispObject fileLength()
     {
         return checkStream(symbol.symbolValue()).fileLength();
     }
 
     @Override
-    public LispObject fileStringLength(LispObject arg) throws ConditionThrowable
+    public LispObject fileStringLength(LispObject arg)
     {
         return checkStream(symbol.symbolValue()).fileStringLength(arg);
     }
 
     @Override
-    protected int _readChar() throws ConditionThrowable, java.io.IOException
+    protected int _readChar() throws java.io.IOException
     {
         return checkStream(symbol.symbolValue())._readChar();
     }
 
     @Override
-    protected void _unreadChar(int n) throws ConditionThrowable, java.io.IOException
+    protected void _unreadChar(int n) throws java.io.IOException
     {
         checkStream(symbol.symbolValue())._unreadChar(n);
     }
 
     @Override
-    protected boolean _charReady() throws ConditionThrowable, java.io.IOException
+    protected boolean _charReady() throws java.io.IOException
     {
         return checkStream(symbol.symbolValue())._charReady();
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         checkStream(symbol.symbolValue())._writeChar(c);
     }
 
     @Override
     public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
+
     {
         checkStream(symbol.symbolValue())._writeChars(chars, start, end);
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         checkStream(symbol.symbolValue())._writeString(s);
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         checkStream(symbol.symbolValue())._writeLine(s);
     }
 
     // Reads an 8-bit byte.
     @Override
-    public int _readByte() throws ConditionThrowable
+    public int _readByte()
     {
         return checkStream(symbol.symbolValue())._readByte();
     }
 
     // Writes an 8-bit byte.
     @Override
-    public void _writeByte(int n) throws ConditionThrowable
+    public void _writeByte(int n)
     {
         checkStream(symbol.symbolValue())._writeByte(n);
     }
 
     @Override
-    public void _finishOutput() throws ConditionThrowable
+    public void _finishOutput()
     {
         checkStream(symbol.symbolValue())._finishOutput();
     }
 
     @Override
-    public void _clearInput() throws ConditionThrowable
+    public void _clearInput()
     {
         checkStream(symbol.symbolValue())._clearInput();
     }
 
     @Override
-    protected long _getFilePosition() throws ConditionThrowable
+    protected long _getFilePosition()
     {
         return checkStream(symbol.symbolValue())._getFilePosition();
     }
 
     @Override
-    protected boolean _setFilePosition(LispObject arg) throws ConditionThrowable
+    protected boolean _setFilePosition(LispObject arg)
     {
         return checkStream(symbol.symbolValue())._setFilePosition(arg);
     }
 
     @Override
-    public void _close() throws ConditionThrowable
+    public void _close()
     {
         checkStream(symbol.symbolValue())._close();
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         StringBuffer sb = new StringBuffer("SYNONYM-STREAM ");
         sb.append(symbol.writeToString());
@@ -224,7 +224,7 @@
         new Primitive("make-synonym-stream", "symbol")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return new SynonymStream(checkSymbol(arg));
         }
@@ -235,7 +235,7 @@
         new Primitive("synonym-stream-symbol", "synonym-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             if (arg instanceof SynonymStream) 
                 return ((SynonymStream)arg).symbol;

Modified: trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
     }
 
     @Override
-    public LispObject getCondition() throws ConditionThrowable
+    public LispObject getCondition()
     {
         return new ControlError("Thread destroyed.");
     }

Modified: trunk/abcl/src/org/armedbear/lisp/Throw.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Throw.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Throw.java	Fri Nov  6 15:07:54 2009
@@ -40,21 +40,21 @@
     private final LispObject[] values;
 
     public Throw(LispObject tag, LispObject result, LispThread thread)
-        throws ConditionThrowable
+
     {
         this.tag = tag;
         this.result = result;
         values = thread._values;
     }
 
-    public LispObject getResult(LispThread thread) throws ConditionThrowable
+    public LispObject getResult(LispThread thread)
     {
         thread._values = values;
         return result;
     }
 
     @Override
-    public LispObject getCondition() throws ConditionThrowable
+    public LispObject getCondition()
     {
         try {
             return new ControlError("Attempt to throw to the nonexistent tag " +

Modified: trunk/abcl/src/org/armedbear/lisp/Time.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Time.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Time.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
     new Primitive("%time", PACKAGE_SYS, false)
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         Cons.setCount(0);
         long realStart = System.currentTimeMillis();
@@ -80,7 +80,7 @@
     new Primitive("get-internal-real-time", "")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return number(System.currentTimeMillis());
       }
@@ -91,7 +91,7 @@
     new Primitive("get-internal-run-time", "")
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         return number(System.currentTimeMillis());
       }
@@ -113,7 +113,7 @@
     new Primitive("default-time-zone", PACKAGE_SYS, false)
     {
       @Override
-      public LispObject execute() throws ConditionThrowable
+      public LispObject execute()
       {
         TimeZone tz = TimeZone.getDefault();
         //int offset = tz.getOffset(System.currentTimeMillis());

Modified: trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java	Fri Nov  6 15:07:54 2009
@@ -53,7 +53,7 @@
     }
 
     @Override
-    public LispObject getElementType() throws ConditionThrowable
+    public LispObject getElementType()
     {
         LispObject itype = in.getElementType();
         LispObject otype = out.getElementType();
@@ -73,25 +73,25 @@
     }
 
     @Override
-    public boolean isCharacterInputStream() throws ConditionThrowable
+    public boolean isCharacterInputStream()
     {
         return in.isCharacterInputStream();
     }
 
     @Override
-    public boolean isBinaryInputStream() throws ConditionThrowable
+    public boolean isBinaryInputStream()
     {
         return in.isBinaryInputStream();
     }
 
     @Override
-    public boolean isCharacterOutputStream() throws ConditionThrowable
+    public boolean isCharacterOutputStream()
     {
         return out.isCharacterOutputStream();
     }
 
     @Override
-    public boolean isBinaryOutputStream() throws ConditionThrowable
+    public boolean isBinaryOutputStream()
     {
         return out.isBinaryOutputStream();
     }
@@ -109,7 +109,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.TWO_WAY_STREAM)
             return T;
@@ -120,88 +120,88 @@
 
     // Returns -1 at end of file.
     @Override
-    protected int _readChar() throws ConditionThrowable, java.io.IOException
+    protected int _readChar() throws java.io.IOException
     {
         return in._readChar();
     }
 
     @Override
-    protected void _unreadChar(int n) throws ConditionThrowable, java.io.IOException
+    protected void _unreadChar(int n) throws java.io.IOException
     {
         in._unreadChar(n);
     }
 
     @Override
-    protected boolean _charReady() throws ConditionThrowable, java.io.IOException
+    protected boolean _charReady() throws java.io.IOException
     {
         return in._charReady();
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         out._writeChar(c);
     }
 
     @Override
     public void _writeChars(char[] chars, int start, int end)
-        throws ConditionThrowable
+
     {
         out._writeChars(chars, start, end);
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         out._writeString(s);
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         out._writeLine(s);
     }
 
     // Reads an 8-bit byte.
     @Override
-    public int _readByte() throws ConditionThrowable
+    public int _readByte()
     {
         return in._readByte();
     }
 
     // Writes an 8-bit byte.
     @Override
-    public void _writeByte(int n) throws ConditionThrowable
+    public void _writeByte(int n)
     {
         out._writeByte(n);
     }
 
     @Override
-    public void _finishOutput() throws ConditionThrowable
+    public void _finishOutput()
     {
         out._finishOutput();
     }
 
     @Override
-    public void _clearInput() throws ConditionThrowable
+    public void _clearInput()
     {
         in._clearInput();
     }
 
     @Override
-    public LispObject listen() throws ConditionThrowable
+    public LispObject listen()
     {
         return in.listen();
     }
 
     @Override
-    public LispObject freshLine() throws ConditionThrowable
+    public LispObject freshLine()
     {
         return out.freshLine();
     }
 
     @Override
-    public LispObject close(LispObject abort) throws ConditionThrowable
+    public LispObject close(LispObject abort)
     {
         // "The effect of CLOSE on a constructed stream is to close the
         // argument stream only. There is no effect on the constituents of
@@ -211,7 +211,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         return unreadableString(Symbol.TWO_WAY_STREAM);
     }
@@ -222,7 +222,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             final Stream in = checkStream(first);
             final Stream out = checkStream(second);
@@ -241,7 +241,7 @@
         new Primitive(Symbol.TWO_WAY_STREAM_INPUT_STREAM, "two-way-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
            if (arg instanceof TwoWayStream) 
                return ((TwoWayStream)arg).in;                
@@ -254,7 +254,7 @@
         new Primitive(Symbol.TWO_WAY_STREAM_OUTPUT_STREAM, "two-way-stream")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
            if (arg instanceof TwoWayStream) 
                return ((TwoWayStream)arg).out;                

Modified: trunk/abcl/src/org/armedbear/lisp/TypeError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/TypeError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/TypeError.java	Fri Nov  6 15:07:54 2009
@@ -35,32 +35,32 @@
 
 public class TypeError extends LispError
 {
-    public TypeError() throws ConditionThrowable
+    public TypeError()
     {
         super(StandardClass.TYPE_ERROR);
     }
 
-    protected TypeError(LispClass cls) throws ConditionThrowable
+    protected TypeError(LispClass cls)
     {
         super(cls);
     }
 
     public TypeError(LispObject datum, LispObject expectedType)
-        throws ConditionThrowable
+
     {
         super(StandardClass.TYPE_ERROR);
         setDatum(datum);
         setExpectedType(expectedType);
     }
 
-    public TypeError(LispObject initArgs) throws ConditionThrowable
+    public TypeError(LispObject initArgs)
     {
         super(StandardClass.TYPE_ERROR);
         initialize(initArgs);
     }
 
     @Override
-    protected void initialize(LispObject initArgs) throws ConditionThrowable
+    protected void initialize(LispObject initArgs)
     {
         super.initialize(initArgs);
         LispObject datum = null;
@@ -85,7 +85,7 @@
             setExpectedType(expectedType);
     }
 
-    public TypeError(String message) throws ConditionThrowable
+    public TypeError(String message)
     {
         super(StandardClass.TYPE_ERROR);
         setFormatControl(message);
@@ -94,7 +94,7 @@
     }
 
     public TypeError(String message, LispObject datum, LispObject expectedType)
-        throws ConditionThrowable
+
     {
         super(StandardClass.TYPE_ERROR);
         setFormatControl(message);
@@ -115,7 +115,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.TYPE_ERROR)
             return T;
@@ -172,23 +172,23 @@
         }
     }
 
-    public final LispObject getDatum() throws ConditionThrowable
+    public final LispObject getDatum()
     {
         return getInstanceSlotValue(Symbol.DATUM);
     }
 
-    private final void setDatum(LispObject datum) throws ConditionThrowable
+    private final void setDatum(LispObject datum)
     {
         setInstanceSlotValue(Symbol.DATUM, datum);
     }
 
-    public final LispObject getExpectedType() throws ConditionThrowable
+    public final LispObject getExpectedType()
     {
         return getInstanceSlotValue(Symbol.EXPECTED_TYPE);
     }
 
     private final void setExpectedType(LispObject expectedType)
-        throws ConditionThrowable
+
     {
         setInstanceSlotValue(Symbol.EXPECTED_TYPE, expectedType);
     }
@@ -198,7 +198,7 @@
         new Primitive(Symbol.TYPE_ERROR_DATUM, "condition")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             final StandardObject obj;
             if (arg instanceof StandardObject) {
@@ -216,7 +216,7 @@
         new Primitive(Symbol.TYPE_ERROR_EXPECTED_TYPE, "condition")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             final StandardObject obj;
             if (arg instanceof StandardObject) {

Modified: trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java	Fri Nov  6 15:07:54 2009
@@ -35,14 +35,14 @@
 
 public final class UnboundSlot extends CellError
 {
-    public UnboundSlot(LispObject initArgs) throws ConditionThrowable
+    public UnboundSlot(LispObject initArgs)
     {
         super(StandardClass.UNBOUND_SLOT);
         initialize(initArgs);
     }
 
     @Override
-    protected void initialize(LispObject initArgs) throws ConditionThrowable
+    protected void initialize(LispObject initArgs)
     {
         super.initialize(initArgs);
         while (initArgs != NIL) {
@@ -56,18 +56,18 @@
         }
     }
 
-    public LispObject getInstance() throws ConditionThrowable
+    public LispObject getInstance()
     {
         return getInstanceSlotValue(Symbol.INSTANCE);
     }
 
-    private void setInstance(LispObject instance) throws ConditionThrowable
+    private void setInstance(LispObject instance)
     {
         setInstanceSlotValue(Symbol.INSTANCE, instance);
     }
 
     @Override
-    public String getMessage() throws ConditionThrowable
+    public String getMessage()
     {
         final LispThread thread = LispThread.currentThread();
         SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
@@ -98,7 +98,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.UNBOUND_SLOT)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public final class UnboundVariable extends CellError
 {
   // obj is either the unbound variable itself or an initArgs list.
-  public UnboundVariable(LispObject obj) throws ConditionThrowable
+  public UnboundVariable(LispObject obj)
   {
     super(StandardClass.UNBOUND_VARIABLE);
     if (obj instanceof Cons)
@@ -78,7 +78,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.UNBOUND_VARIABLE)
       return T;

Modified: trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public final class UndefinedFunction extends CellError
 {
   // obj is either the name of the undefined function or an initArgs list.
-  public UndefinedFunction(LispObject obj) throws ConditionThrowable
+  public UndefinedFunction(LispObject obj)
   {
     super(StandardClass.UNDEFINED_FUNCTION);
     if (obj instanceof Cons)
@@ -58,7 +58,7 @@
   }
 
   @Override
-  public LispObject typep(LispObject type) throws ConditionThrowable
+  public LispObject typep(LispObject type)
   {
     if (type == Symbol.UNDEFINED_FUNCTION)
       return T;
@@ -68,7 +68,7 @@
   }
 
   @Override
-  public String getMessage() throws ConditionThrowable
+  public String getMessage()
   {
     FastStringBuffer sb = new FastStringBuffer("The function ");
     sb.append(getCellName().writeToString());

Modified: trunk/abcl/src/org/armedbear/lisp/UpcaseStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UpcaseStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UpcaseStream.java	Fri Nov  6 15:07:54 2009
@@ -35,25 +35,25 @@
 
 public final class UpcaseStream extends CaseFrobStream
 {
-    public UpcaseStream(Stream target) throws ConditionThrowable
+    public UpcaseStream(Stream target)
     {
         super(target);
     }
 
     @Override
-    public void _writeChar(char c) throws ConditionThrowable
+    public void _writeChar(char c)
     {
         target._writeChar(LispCharacter.toUpperCase(c));
     }
 
     @Override
-    public void _writeString(String s) throws ConditionThrowable
+    public void _writeString(String s)
     {
         target._writeString(s.toUpperCase());
     }
 
     @Override
-    public void _writeLine(String s) throws ConditionThrowable
+    public void _writeLine(String s)
     {
         target._writeLine(s.toUpperCase());
     }

Modified: trunk/abcl/src/org/armedbear/lisp/Utilities.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Utilities.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Utilities.java	Fri Nov  6 15:07:54 2009
@@ -85,14 +85,14 @@
         return false;
     }
 
-    public static File getFile(Pathname pathname) throws ConditionThrowable
+    public static File getFile(Pathname pathname)
     {
         return getFile(pathname,
                        coerceToPathname(Symbol.DEFAULT_PATHNAME_DEFAULTS.symbolValue()));
     }
 
     public static File getFile(Pathname pathname, Pathname defaultPathname)
-        throws ConditionThrowable
+
     {
         Pathname merged =
             Pathname.mergePathnames(pathname, defaultPathname, NIL);
@@ -106,7 +106,7 @@
     }
 
     public static Pathname getDirectoryPathname(File file)
-        throws ConditionThrowable
+
     {
         try {
             String namestring = file.getCanonicalPath();
@@ -126,7 +126,7 @@
     public static byte[] getZippedZipEntryAsByteArray(ZipFile zipfile,
                                                       String entryName,
                                                       String subEntryName) 
-      throws ConditionThrowable 
+
   {
       ZipEntry entry = zipfile.getEntry(entryName);
       
@@ -170,7 +170,7 @@
     public static InputStream getZippedZipEntryAsInputStream(ZipFile zipfile,
                                                              String entryName,
                                                              String subEntryName) 
-      throws ConditionThrowable
+
   {
         return 
             new ByteArrayInputStream(Utilities

Modified: trunk/abcl/src/org/armedbear/lisp/Warning.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Warning.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Warning.java	Fri Nov  6 15:07:54 2009
@@ -35,11 +35,11 @@
 
 public class Warning extends Condition
 {
-    protected Warning() throws ConditionThrowable
+    protected Warning()
     {
     }
 
-    public Warning(LispObject initArgs) throws ConditionThrowable
+    public Warning(LispObject initArgs)
     {
         super(initArgs);
     }
@@ -57,7 +57,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.WARNING)
             return T;

Modified: trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java	Fri Nov  6 15:07:54 2009
@@ -38,7 +38,7 @@
     private final Operator operator;
 
     public WrongNumberOfArgumentsException(Operator operator)
-        throws ConditionThrowable
+
     {
         // This is really just an ordinary PROGRAM-ERROR, broken out into its
         // own Java class as a convenience for the implementation.

Modified: trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java	Fri Nov  6 15:07:54 2009
@@ -64,7 +64,7 @@
     }
 
     @Override
-    public LispObject typep(LispObject type) throws ConditionThrowable
+    public LispObject typep(LispObject type)
     {
         if (type == Symbol.SIMPLE_ARRAY)
             return adjustable ? NIL : T;
@@ -84,7 +84,7 @@
     }
 
     @Override
-    public int getDimension(int n) throws ConditionThrowable
+    public int getDimension(int n)
     {
         error(new TypeError("Bad array dimension (" + n + ") for array of rank 0."));
         // Not reached.
@@ -104,7 +104,7 @@
     }
 
     @Override
-    public LispObject AREF(int index) throws ConditionThrowable
+    public LispObject AREF(int index)
     {
         if (index == 0)
             return data;
@@ -113,7 +113,7 @@
     }
 
     @Override
-    public void aset(int index, LispObject obj) throws ConditionThrowable
+    public void aset(int index, LispObject obj)
     {
         if (obj.typep(elementType) == NIL)
             error(new TypeError(obj, elementType));
@@ -124,7 +124,7 @@
     }
 
     @Override
-    public void fill(LispObject obj) throws ConditionThrowable
+    public void fill(LispObject obj)
     {
         if (obj.typep(elementType) == NIL)
             error(new TypeError(obj, elementType));
@@ -132,7 +132,7 @@
     }
 
     @Override
-    public String writeToString() throws ConditionThrowable
+    public String writeToString()
     {
         final LispThread thread = LispThread.currentThread();
         boolean printReadably = (Symbol.PRINT_READABLY.symbolValue(thread) != NIL);
@@ -167,7 +167,7 @@
   public AbstractArray adjustArray(int[] dims,
                                               LispObject initialElement,
                                               LispObject initialContents)
-    throws ConditionThrowable {
+    {
       if (isAdjustable()) {
           // initial element doesn't matter:
           // we're not creating new elements
@@ -185,7 +185,7 @@
   public AbstractArray adjustArray(int[] dims,
                                               AbstractArray displacedTo,
                                               int displacement)
-    throws ConditionThrowable {
+    {
       error(new TypeError("Displacement not supported for array of rank 0."));
       return null;
   }

Modified: trunk/abcl/src/org/armedbear/lisp/adjust_array.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/adjust_array.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/adjust_array.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         if (args.length != 10)
             return error(new WrongNumberOfArgumentsException(this));

Modified: trunk/abcl/src/org/armedbear/lisp/arglist.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/arglist.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/arglist.java	Fri Nov  6 15:07:54 2009
@@ -36,7 +36,7 @@
 public final class arglist extends Lisp
 {
     private static final Operator getOperator(LispObject obj)
-        throws ConditionThrowable
+
     {
         if (obj instanceof Operator)
             return (Operator) obj;
@@ -67,7 +67,7 @@
         new Primitive("arglist", PACKAGE_EXT, true, "extended-function-designator")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             LispThread thread = LispThread.currentThread();
             Operator operator = getOperator(arg);
@@ -108,7 +108,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second)
-            throws ConditionThrowable
+
         {
             Operator operator = null;
             if (first instanceof Operator) {

Modified: trunk/abcl/src/org/armedbear/lisp/ash.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ash.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ash.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         return first.ash(second);
     }

Modified: trunk/abcl/src/org/armedbear/lisp/assq.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/assq.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/assq.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
 
     @Override
     public LispObject execute(LispObject item, LispObject alist)
-        throws ConditionThrowable
+
     {
         return assq(item, alist);
     }

Modified: trunk/abcl/src/org/armedbear/lisp/assql.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/assql.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/assql.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
 
     @Override
     public LispObject execute(LispObject item, LispObject alist)
-        throws ConditionThrowable
+
     {
         while (alist != NIL) {
             LispObject cons = alist.car();

Modified: trunk/abcl/src/org/armedbear/lisp/ceiling.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ceiling.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ceiling.java	Fri Nov  6 15:07:54 2009
@@ -42,14 +42,14 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return execute(arg, Fixnum.ONE);
     }
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         LispObject quotient = first.truncate(second);
         final LispThread thread = LispThread.currentThread();

Modified: trunk/abcl/src/org/armedbear/lisp/cell_error_name.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/cell_error_name.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/cell_error_name.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         final StandardObject obj;
         if (arg instanceof StandardObject) {

Modified: trunk/abcl/src/org/armedbear/lisp/copy_list.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/copy_list.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/copy_list.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
   }
 
   @Override
-  public LispObject execute(LispObject arg) throws ConditionThrowable
+  public LispObject execute(LispObject arg)
   {
     if (arg == NIL)
       return NIL;

Modified: trunk/abcl/src/org/armedbear/lisp/create_new_file.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/create_new_file.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/create_new_file.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         final String namestring = arg.getStringValue();
         try {

Modified: trunk/abcl/src/org/armedbear/lisp/cxr.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/cxr.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/cxr.java	Fri Nov  6 15:07:54 2009
@@ -41,7 +41,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         first.setCar(second);
         return second;
@@ -54,7 +54,7 @@
     {
       @Override
       public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
       {
         first.setCdr(second);
         return second;
@@ -65,7 +65,7 @@
   private static final Primitive CAR = new Primitive(Symbol.CAR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.car();
       }
@@ -75,7 +75,7 @@
   private static final Primitive CDR = new Primitive(Symbol.CDR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cdr();
       }
@@ -85,7 +85,7 @@
   private static final Primitive CAAR = new Primitive(Symbol.CAAR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.car().car();
       }
@@ -95,7 +95,7 @@
   private static final Primitive CADR = new Primitive(Symbol.CADR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cadr();
       }
@@ -105,7 +105,7 @@
   private static final Primitive CDAR = new Primitive(Symbol.CDAR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.car().cdr();
       }
@@ -115,7 +115,7 @@
   private static final Primitive CDDR = new Primitive(Symbol.CDDR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cdr().cdr();
       }
@@ -125,7 +125,7 @@
   private static final Primitive CADDR = new Primitive(Symbol.CADDR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.caddr();
       }
@@ -135,7 +135,7 @@
   private static final Primitive CAADR = new Primitive(Symbol.CAADR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cdr().car().car();
       }
@@ -145,7 +145,7 @@
   private static final Primitive CAAAR = new Primitive(Symbol.CAAAR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.car().car().car();
       }
@@ -155,7 +155,7 @@
   private static final Primitive CDAAR = new Primitive(Symbol.CDAAR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.car().car().cdr();
       }
@@ -165,7 +165,7 @@
   private static final Primitive CDDAR = new Primitive(Symbol.CDDAR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.car().cdr().cdr();
       }
@@ -175,7 +175,7 @@
   private static final Primitive CDDDR = new Primitive(Symbol.CDDDR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cdr().cdr().cdr();
       }
@@ -185,7 +185,7 @@
   private static final Primitive CADAR = new Primitive(Symbol.CADAR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.car().cdr().car();
       }
@@ -195,7 +195,7 @@
   private static final Primitive CDADR = new Primitive(Symbol.CDADR, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cdr().car().cdr();
       }
@@ -205,7 +205,7 @@
   private static final Primitive FIRST = new Primitive(Symbol.FIRST, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.car();
       }
@@ -215,7 +215,7 @@
   private static final Primitive SECOND = new Primitive(Symbol.SECOND, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cadr();
       }
@@ -225,7 +225,7 @@
   private static final Primitive THIRD = new Primitive(Symbol.THIRD, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.caddr();
       }
@@ -235,7 +235,7 @@
   private static final Primitive FOURTH = new Primitive(Symbol.FOURTH, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cdr().cdr().cadr();
       }
@@ -245,7 +245,7 @@
   private static final Primitive REST = new Primitive(Symbol.REST, "list")
     {
       @Override
-      public LispObject execute(LispObject arg) throws ConditionThrowable
+      public LispObject execute(LispObject arg)
       {
         return arg.cdr();
       }

Modified: trunk/abcl/src/org/armedbear/lisp/delete_file.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/delete_file.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/delete_file.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
 
     // ### delete-file filespec => t
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         // Don't follow symlinks! We want to delete the symlink itself, not
         // the linked-to file.

Modified: trunk/abcl/src/org/armedbear/lisp/disassemble_class_bytes.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/disassemble_class_bytes.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/disassemble_class_bytes.java	Fri Nov  6 15:07:54 2009
@@ -46,7 +46,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof JavaObject) {
             byte[] bytes = (byte[]) ((JavaObject)arg).getObject();

Modified: trunk/abcl/src/org/armedbear/lisp/dolist.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/dolist.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/dolist.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
 
   @Override
   public LispObject execute(LispObject args, Environment env)
-    throws ConditionThrowable
+
   {
     LispObject bodyForm = args.cdr();
     args = args.car();

Modified: trunk/abcl/src/org/armedbear/lisp/dotimes.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/dotimes.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/dotimes.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
 
   @Override
   public LispObject execute(LispObject args, Environment env)
-    throws ConditionThrowable
+
   {
     LispObject bodyForm = args.cdr();
     args = args.car();

Modified: trunk/abcl/src/org/armedbear/lisp/file_author.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_author.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_author.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         Pathname pathname = coerceToPathname(arg);
         if (pathname.isWild())

Modified: trunk/abcl/src/org/armedbear/lisp/file_error_pathname.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_error_pathname.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_error_pathname.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return arg instanceof FileError ? ((FileError)arg).getPathname() : NIL;
     }

Modified: trunk/abcl/src/org/armedbear/lisp/file_length.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_length.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_length.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
     // ### file-length
     // file-length stream => length
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return checkStream(arg).fileLength();
     }

Modified: trunk/abcl/src/org/armedbear/lisp/file_string_length.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_string_length.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_string_length.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         return checkStream(first).fileStringLength(second);
     }

Modified: trunk/abcl/src/org/armedbear/lisp/file_write_date.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_write_date.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_write_date.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         Pathname pathname = coerceToPathname(arg);
         if (pathname.isWild())

Modified: trunk/abcl/src/org/armedbear/lisp/float_sign.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/float_sign.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/float_sign.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof SingleFloat) {
             float f = ((SingleFloat)arg).value;
@@ -59,7 +59,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         if (!first.floatp())
             return type_error(first, Symbol.FLOAT);

Modified: trunk/abcl/src/org/armedbear/lisp/floor.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/floor.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/floor.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
 
     @Override
     public LispObject execute(LispObject number)
-        throws ConditionThrowable
+
     {
         LispObject quotient = number.truncate(Fixnum.ONE);
         final LispThread thread = LispThread.currentThread();
@@ -61,7 +61,7 @@
 
     @Override
     public LispObject execute(LispObject number, LispObject divisor)
-        throws ConditionThrowable
+
     {
         LispObject quotient = number.truncate(divisor);
         final LispThread thread = LispThread.currentThread();

Modified: trunk/abcl/src/org/armedbear/lisp/ftruncate.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ftruncate.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ftruncate.java	Fri Nov  6 15:07:54 2009
@@ -50,7 +50,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         final LispThread thread = LispThread.currentThread();
         if (arg.zerop()) {
@@ -99,7 +99,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         final LispThread thread = LispThread.currentThread();
         if (first.zerop()) {

Modified: trunk/abcl/src/org/armedbear/lisp/function_info.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/function_info.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/function_info.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
         new Primitive("function-info", PACKAGE_SYS, false)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             LispObject info = FUNCTION_TABLE.get(arg);
             return info != null ? info : NIL;
@@ -56,7 +56,7 @@
     {
         @Override
         public LispObject execute(LispObject name, LispObject info)
-            throws ConditionThrowable
+
         {
             if (info == NIL)
                 FUNCTION_TABLE.remhash(name);
@@ -73,7 +73,7 @@
     {
         @Override
         public LispObject execute(LispObject name, LispObject indicator)
-            throws ConditionThrowable
+
         {
             // info is an alist
             LispObject info = FUNCTION_TABLE.get(name);
@@ -102,7 +102,7 @@
         @Override
         public LispObject execute(LispObject name, LispObject indicator,
                                   LispObject value)
-            throws ConditionThrowable
+
         {
             // info is an alist
             LispObject info = FUNCTION_TABLE.get(name);

Modified: trunk/abcl/src/org/armedbear/lisp/get_properties.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/get_properties.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/get_properties.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
 
   @Override
   public LispObject execute(LispObject first, LispObject second)
-    throws ConditionThrowable
+
   {
     final LispThread thread = LispThread.currentThread();
     LispObject plist = first;

Modified: trunk/abcl/src/org/armedbear/lisp/input_stream_p.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/input_stream_p.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/input_stream_p.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
             return checkStream(arg).isInputStream() ? T : NIL;
     }

Modified: trunk/abcl/src/org/armedbear/lisp/interactive_stream_p.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/interactive_stream_p.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/interactive_stream_p.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof Stream)
             return ((Stream)arg).isInteractive() ? T : NIL;

Modified: trunk/abcl/src/org/armedbear/lisp/jclass_name.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/jclass_name.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/jclass_name.java	Fri Nov  6 15:07:54 2009
@@ -48,7 +48,7 @@
     // referenced by CLASS-REF.
     @Override
     public LispObject execute(LispObject arg)
-        throws ConditionThrowable
+
     {
         if (arg instanceof AbstractString) {
             String s = arg.getStringValue();
@@ -71,7 +71,7 @@
     // matches NAME.
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         String className = null;
         if (first instanceof AbstractString) {

Modified: trunk/abcl/src/org/armedbear/lisp/jclass_of.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/jclass_of.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/jclass_of.java	Fri Nov  6 15:07:54 2009
@@ -46,7 +46,7 @@
 
     @Override
     public LispObject execute(LispObject arg)
-        throws ConditionThrowable
+
     {
         final String className;
         if (arg instanceof AbstractString)
@@ -62,7 +62,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         final String className;
         if (first instanceof AbstractString)

Modified: trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java	Fri Nov  6 15:07:54 2009
@@ -46,7 +46,7 @@
 
     @Override
     public LispObject execute(LispObject arg)
-        throws ConditionThrowable
+
     {
         if (arg instanceof JavaObject) {
             Object method = ((JavaObject)arg).getObject();

Modified: trunk/abcl/src/org/armedbear/lisp/last.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/last.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/last.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
   }
 
   @Override
-  public LispObject execute(LispObject arg) throws ConditionThrowable
+  public LispObject execute(LispObject arg)
   {
     if (arg == NIL)
       return NIL;
@@ -62,7 +62,7 @@
 
   @Override
   public LispObject execute(LispObject first, LispObject second)
-    throws ConditionThrowable
+
   {
     LispObject list = checkList(first);
     if (second instanceof Fixnum)

Modified: trunk/abcl/src/org/armedbear/lisp/listen.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/listen.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/listen.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute() throws ConditionThrowable
+    public LispObject execute()
     {
         Stream stream =
             checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue());
@@ -50,7 +50,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return inSynonymOf(arg).listen();
     }

Modified: trunk/abcl/src/org/armedbear/lisp/logand.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logand.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logand.java	Fri Nov  6 15:07:54 2009
@@ -50,7 +50,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof Fixnum || arg instanceof Bignum)
             return arg;
@@ -59,13 +59,13 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         return first.LOGAND(second);
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         LispObject result = Fixnum.MINUS_ONE;
         for (int i = 0; i < args.length; i++)

Modified: trunk/abcl/src/org/armedbear/lisp/logandc1.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logandc1.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logandc1.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         if (first instanceof Fixnum) {
             if (second instanceof Fixnum)

Modified: trunk/abcl/src/org/armedbear/lisp/logandc2.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logandc2.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logandc2.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         if (first instanceof Fixnum) {
             if (second instanceof Fixnum)

Modified: trunk/abcl/src/org/armedbear/lisp/logbitp.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logbitp.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logbitp.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         int index = -1;
         if (first instanceof Fixnum) {

Modified: trunk/abcl/src/org/armedbear/lisp/logcount.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logcount.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logcount.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
 
     // FIXME Optimize fixnum case!
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         BigInteger n;
         if (arg instanceof Fixnum)

Modified: trunk/abcl/src/org/armedbear/lisp/logeqv.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logeqv.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logeqv.java	Fri Nov  6 15:07:54 2009
@@ -52,7 +52,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof Fixnum)
             return arg;
@@ -62,7 +62,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         BigInteger result = null;
         for (int i = 0; i < args.length; i++) {

Modified: trunk/abcl/src/org/armedbear/lisp/logior.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logior.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logior.java	Fri Nov  6 15:07:54 2009
@@ -48,7 +48,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof Fixnum || arg instanceof Bignum)
             return arg;
@@ -57,13 +57,13 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         return first.LOGIOR(second);
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         LispObject result = Fixnum.ZERO;
         for (int i = 0; i < args.length; i++)

Modified: trunk/abcl/src/org/armedbear/lisp/lognand.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/lognand.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/lognand.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         if (first instanceof Fixnum) {
             if (second instanceof Fixnum)

Modified: trunk/abcl/src/org/armedbear/lisp/lognor.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/lognor.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/lognor.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         if (first instanceof Fixnum) {
             if (second instanceof Fixnum)

Modified: trunk/abcl/src/org/armedbear/lisp/lognot.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/lognot.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/lognot.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return arg.LOGNOT();
     }

Modified: trunk/abcl/src/org/armedbear/lisp/logorc1.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logorc1.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logorc1.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         if (first instanceof Fixnum) {
             if (second instanceof Fixnum)

Modified: trunk/abcl/src/org/armedbear/lisp/logorc2.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logorc2.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logorc2.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         if (first instanceof Fixnum) {
             if (second instanceof Fixnum)

Modified: trunk/abcl/src/org/armedbear/lisp/logtest.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logtest.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logtest.java	Fri Nov  6 15:07:54 2009
@@ -46,7 +46,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         if (first instanceof Fixnum && second instanceof Fixnum) {
             return (((Fixnum)first).value & ((Fixnum)second).value) == 0 ? NIL : T;

Modified: trunk/abcl/src/org/armedbear/lisp/logxor.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logxor.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logxor.java	Fri Nov  6 15:07:54 2009
@@ -48,7 +48,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof Fixnum || arg instanceof Bignum)
             return arg;
@@ -57,13 +57,13 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         return first.LOGXOR(second);
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         LispObject result = Fixnum.ZERO;
         for (int i = 0; i < args.length; i++)

Modified: trunk/abcl/src/org/armedbear/lisp/machine_type.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/machine_type.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/machine_type.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
   }
 
   @Override
-  public LispObject execute() throws ConditionThrowable
+  public LispObject execute()
   {
     String s = System.getProperty("os.arch");
     if (s == null)

Modified: trunk/abcl/src/org/armedbear/lisp/machine_version.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/machine_version.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/machine_version.java	Fri Nov  6 15:07:54 2009
@@ -47,7 +47,7 @@
     }
 
     @Override
-    public LispObject execute() throws ConditionThrowable
+    public LispObject execute()
     {
         String osName = System.getProperty("os.name");
         if (osName != null && osName.toLowerCase().startsWith("linux")) {

Modified: trunk/abcl/src/org/armedbear/lisp/make_array.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/make_array.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/make_array.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
   }
 
   @Override
-  public LispObject execute(LispObject[] args) throws ConditionThrowable
+  public LispObject execute(LispObject[] args)
   {
     if (args.length != 9)
       return error(new WrongNumberOfArgumentsException(this));

Modified: trunk/abcl/src/org/armedbear/lisp/make_condition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/make_condition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/make_condition.java	Fri Nov  6 15:07:54 2009
@@ -44,7 +44,7 @@
     // %make-condition type slot-initializations => condition
     @Override
     public LispObject execute(LispObject type, LispObject initArgs)
-        throws ConditionThrowable
+
     {
         final Symbol symbol;
         if (type instanceof Symbol)

Modified: trunk/abcl/src/org/armedbear/lisp/make_server_socket.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/make_server_socket.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/make_server_socket.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
 
     @Override
     public LispObject execute(LispObject first)
-        throws ConditionThrowable
+
     {
         int port = Fixnum.getValue(first);
         try {

Modified: trunk/abcl/src/org/armedbear/lisp/make_socket.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/make_socket.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/make_socket.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         String host = first.getStringValue();
         int port = Fixnum.getValue(second);

Modified: trunk/abcl/src/org/armedbear/lisp/mod.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/mod.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/mod.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
 
     @Override
     public LispObject execute(LispObject number, LispObject divisor)
-        throws ConditionThrowable
+
     {
         return number.MOD(divisor);
     }

Modified: trunk/abcl/src/org/armedbear/lisp/open_stream_p.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/open_stream_p.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/open_stream_p.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return checkStream(arg).isOpen() ? T : NIL;
     }

Modified: trunk/abcl/src/org/armedbear/lisp/output_stream_p.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/output_stream_p.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/output_stream_p.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return checkStream(arg).isOutputStream() ? T : NIL;
     }

Modified: trunk/abcl/src/org/armedbear/lisp/package_error_package.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/package_error_package.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/package_error_package.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof PackageError)
             return ((PackageError)arg).getPackage();

Modified: trunk/abcl/src/org/armedbear/lisp/peek_char.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/peek_char.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/peek_char.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         int length = args.length;
         if (length > 5)

Modified: trunk/abcl/src/org/armedbear/lisp/probe_file.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/probe_file.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/probe_file.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
         new Primitive("probe-file", "pathspec")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return Pathname.truename(arg, false);
         }
@@ -55,7 +55,7 @@
         new Primitive("truename", "filespec")
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             return Pathname.truename(arg, true);
         }
@@ -67,7 +67,7 @@
         new Primitive("probe-directory", PACKAGE_EXT, true)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             Pathname pathname = coerceToPathname(arg);
             if (pathname.isWild())
@@ -83,7 +83,7 @@
         new Primitive("file-directory-p", PACKAGE_EXT, true)
     {
         @Override
-        public LispObject execute(LispObject arg) throws ConditionThrowable
+        public LispObject execute(LispObject arg)
         {
             Pathname pathname = coerceToPathname(arg);
             if (pathname.isWild())

Modified: trunk/abcl/src/org/armedbear/lisp/rem.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/rem.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/rem.java	Fri Nov  6 15:07:54 2009
@@ -43,7 +43,7 @@
 
     @Override
     public LispObject execute(LispObject number, LispObject divisor)
-        throws ConditionThrowable
+
     {
         number.truncate(divisor);
         final LispThread thread = LispThread.currentThread();

Modified: trunk/abcl/src/org/armedbear/lisp/room.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/room.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/room.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject[] args) throws ConditionThrowable
+    public LispObject execute(LispObject[] args)
     {
         if (args.length > 1)
             return error(new WrongNumberOfArgumentsException(this));

Modified: trunk/abcl/src/org/armedbear/lisp/server_socket_close.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/server_socket_close.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/server_socket_close.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
 
     @Override
     public LispObject execute(LispObject first)
-        throws ConditionThrowable
+
     {
         try {
 	    ServerSocket serverSocket = (ServerSocket) JavaObject.getObject(first);

Modified: trunk/abcl/src/org/armedbear/lisp/simple_list_remove_duplicates.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/simple_list_remove_duplicates.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/simple_list_remove_duplicates.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject list) throws ConditionThrowable
+    public LispObject execute(LispObject list)
     {
         LispObject result = NIL;
         while (list != NIL) {

Modified: trunk/abcl/src/org/armedbear/lisp/socket_accept.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/socket_accept.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/socket_accept.java	Fri Nov  6 15:07:54 2009
@@ -46,7 +46,7 @@
 
     @Override
     public LispObject execute(LispObject first)
-        throws ConditionThrowable
+
     {
          ServerSocket serverSocket =
             (ServerSocket) ((JavaObject)first).getObject();

Modified: trunk/abcl/src/org/armedbear/lisp/socket_close.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/socket_close.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/socket_close.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
 
     @Override
     public LispObject execute(LispObject first)
-        throws ConditionThrowable
+
     {
 	Socket socket = (Socket) JavaObject.getObject(first);
         try {

Modified: trunk/abcl/src/org/armedbear/lisp/socket_stream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/socket_stream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/socket_stream.java	Fri Nov  6 15:07:54 2009
@@ -45,7 +45,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second, LispObject third)
-        throws ConditionThrowable
+
     {
         Socket socket = (Socket) ((JavaObject)first).getObject();
         LispObject elementType = second; // Checked by caller.

Modified: trunk/abcl/src/org/armedbear/lisp/software_type.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/software_type.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/software_type.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute() throws ConditionThrowable
+    public LispObject execute()
     {
         return new SimpleString(System.getProperty("os.name"));
     }

Modified: trunk/abcl/src/org/armedbear/lisp/software_version.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/software_version.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/software_version.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute() throws ConditionThrowable
+    public LispObject execute()
     {
         return new SimpleString(System.getProperty("os.version"));
     }

Modified: trunk/abcl/src/org/armedbear/lisp/stream_element_type.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/stream_element_type.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/stream_element_type.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return checkStream(arg).getElementType();
     }

Modified: trunk/abcl/src/org/armedbear/lisp/stream_external_format.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/stream_external_format.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/stream_external_format.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof Stream)
             return Keyword.DEFAULT;

Modified: trunk/abcl/src/org/armedbear/lisp/truncate.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/truncate.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/truncate.java	Fri Nov  6 15:07:54 2009
@@ -42,14 +42,14 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         return arg.truncate(Fixnum.ONE);
     }
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         return first.truncate(second);
     }

Modified: trunk/abcl/src/org/armedbear/lisp/unbound_slot_instance.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/unbound_slot_instance.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/unbound_slot_instance.java	Fri Nov  6 15:07:54 2009
@@ -42,7 +42,7 @@
     }
 
     @Override
-    public LispObject execute(LispObject arg) throws ConditionThrowable
+    public LispObject execute(LispObject arg)
     {
         if (arg instanceof UnboundSlot)
             return ((UnboundSlot)arg).getInstance();

Modified: trunk/abcl/src/org/armedbear/lisp/zip.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/zip.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/zip.java	Fri Nov  6 15:07:54 2009
@@ -50,7 +50,7 @@
 
     @Override
     public LispObject execute(LispObject first, LispObject second)
-        throws ConditionThrowable
+
     {
         Pathname zipfilePathname = coerceToPathname(first);
         byte[] buffer = new byte[4096];



From ehuelsmann at common-lisp.net  Fri Nov  6 22:36:36 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Fri, 06 Nov 2009 17:36:36 -0500
Subject: [armedbear-cvs] r12255 - in trunk/abcl/src/org/armedbear/lisp: .
	scripting
Message-ID: <E1N6XQ4-0003MN-Hr@common-lisp.net>

Author: ehuelsmann
Date: Fri Nov  6 17:36:32 2009
New Revision: 12255

Log:
Rename ConditionThrowable to ControlTransfer and remove
  try/catch blocks which don't have anything to do with
  non-local transfer of control.

Added:
   trunk/abcl/src/org/armedbear/lisp/ControlTransfer.java
      - copied, changed from r12254, /trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java
Removed:
   trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java
Modified:
   trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
   trunk/abcl/src/org/armedbear/lisp/AbstractString.java
   trunk/abcl/src/org/armedbear/lisp/Autoload.java
   trunk/abcl/src/org/armedbear/lisp/ComplexString.java
   trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java
   trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java
   trunk/abcl/src/org/armedbear/lisp/FileStream.java
   trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/Function.java
   trunk/abcl/src/org/armedbear/lisp/Go.java
   trunk/abcl/src/org/armedbear/lisp/Interpreter.java
   trunk/abcl/src/org/armedbear/lisp/JHandler.java
   trunk/abcl/src/org/armedbear/lisp/JProxy.java
   trunk/abcl/src/org/armedbear/lisp/Java.java
   trunk/abcl/src/org/armedbear/lisp/JavaClass.java
   trunk/abcl/src/org/armedbear/lisp/JavaObject.java
   trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java
   trunk/abcl/src/org/armedbear/lisp/Lisp.java
   trunk/abcl/src/org/armedbear/lisp/LispThread.java
   trunk/abcl/src/org/armedbear/lisp/Pathname.java
   trunk/abcl/src/org/armedbear/lisp/Profiler.java
   trunk/abcl/src/org/armedbear/lisp/Return.java
   trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java
   trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
   trunk/abcl/src/org/armedbear/lisp/Stream.java
   trunk/abcl/src/org/armedbear/lisp/StringFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Symbol.java
   trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java
   trunk/abcl/src/org/armedbear/lisp/Throw.java
   trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java	Fri Nov  6 17:36:32 2009
@@ -162,17 +162,10 @@
     public int hashCode()
     {
         int hashCode = 1;
-        try {
-            // Consider first 64 bits only.
-            final int limit = Math.min(length(), 64);
-            for (int i = 0; i < limit; i++)
-                hashCode = hashCode * 31 + getBit(i);
-        }
-        // ### fixme exception
-        catch (ConditionThrowable t) {
-            // Shouldn't happen.
-            Debug.trace(t);
-        }
+        // Consider first 64 bits only.
+        final int limit = Math.min(length(), 64);
+        for (int i = 0; i < limit; i++)
+            hashCode = hashCode * 31 + getBit(i);
         return hashCode;
     }
 

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractString.java	Fri Nov  6 17:36:32 2009
@@ -120,17 +120,12 @@
     }
 
     public String toString() {
-	try {
 	    int length = length();
 	    StringBuilder sb = new StringBuilder(length);
 	    for(int i = 0; i < length; ++i) {
-		sb.append(charAt(i));
+			sb.append(charAt(i));
 	    }
 	    return sb.toString();
-	} catch(ConditionThrowable t) {
-        // ### FIXME exception
-	    throw new Error(t); //Should never happen
-	}
     }
 
 }

Modified: trunk/abcl/src/org/armedbear/lisp/Autoload.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Autoload.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Autoload.java	Fri Nov  6 17:36:32 2009
@@ -79,13 +79,7 @@
     {
         Symbol symbol = intern(symbolName.toUpperCase(), pkg);
         if (pkg != PACKAGE_CL && exported) {
-            try {
-                pkg.export(symbol);
-            }
-            catch (ConditionThrowable t) {
-                // ### FIXME exception
-                Debug.assertTrue(false);
-            }
+            pkg.export(symbol);
         }
         if (symbol.getSymbolFunction() == null)
             symbol.setSymbolFunction(new Autoload(symbol, null,

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexString.java	Fri Nov  6 17:36:32 2009
@@ -526,15 +526,7 @@
     final int limit = length();
     for (int i = 0; i < limit; i++)
       {
-        try
-          {
-            hashCode += charAt(i);
-          }
-        catch (ConditionThrowable t)
-          {
-            // ### FIXME exception
-            Debug.trace(t);
-          }
+        hashCode += charAt(i);
         hashCode += (hashCode << 10);
         hashCode ^= (hashCode >> 6);
       }
@@ -552,15 +544,7 @@
     final int limit = length();
     for (int i = 0; i < limit; i++)
       {
-        try
-          {
-            hashCode += Character.toUpperCase(charAt(i));
-          }
-        catch (ConditionThrowable t)
-          {
-            // ### FIXME exception
-            Debug.trace(t);
-          }
+        hashCode += Character.toUpperCase(charAt(i));
         hashCode += (hashCode << 10);
         hashCode ^= (hashCode >> 6);
       }

Copied: trunk/abcl/src/org/armedbear/lisp/ControlTransfer.java (from r12254, /trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java)
==============================================================================
--- /trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ControlTransfer.java	Fri Nov  6 17:36:32 2009
@@ -1,5 +1,5 @@
 /*
- * ConditionThrowable.java
+ * ControlTransfer.java
  *
  * Copyright (C) 2003-2005 Peter Graves
  * $Id$
@@ -33,13 +33,13 @@
 
 package org.armedbear.lisp;
 
-abstract public class ConditionThrowable extends RuntimeException
+abstract public class ControlTransfer extends RuntimeException
 {
-    public ConditionThrowable()
+    public ControlTransfer()
     {
     }
     /**
-     * Overridden in order to make ConditionThrowable construct
+     * Overridden in order to make ControlTransfer construct
      * faster. This avoids gathering stack trace information.
      */
     @Override
@@ -48,7 +48,7 @@
 	return this;
     }
 
-    public ConditionThrowable(String message)
+    public ControlTransfer(String message)
     {
         super(message);
     }

Modified: trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java	Fri Nov  6 17:36:32 2009
@@ -56,16 +56,8 @@
     HashEntry e = buckets[key.sxhash() & mask];
     while (e != null)
       {
-        try
-          {
-            if (key == e.key || key.equal(e.key))
-              return e.value;
-          }
-        // ### FIXME exception
-        catch (ConditionThrowable t)
-          {
-            Debug.trace(t);
-          }
+        if (key == e.key || key.equal(e.key))
+          return e.value;
         e = e.next;
       }
     return null;

Modified: trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java	Fri Nov  6 17:36:32 2009
@@ -54,16 +54,8 @@
     HashEntry e = buckets[index];
     while (e != null)
       {
-        try
-          {
-            if (key.equalp(e.key))
-              return e.value;
-          }
-        // ### FIXME exception
-        catch (ConditionThrowable t)
-          {
-            Debug.trace(t);
-          }
+        if (key.equalp(e.key))
+          return e.value;
         e = e.next;
       }
     return null;

Modified: trunk/abcl/src/org/armedbear/lisp/FileStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FileStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FileStream.java	Fri Nov  6 17:36:32 2009
@@ -116,13 +116,7 @@
 	    }
         } else {
             isBinaryStream = true;
-            int width;
-            try {
-                width = Fixnum.getValue(elementType.cadr());
-            }
-            catch (ConditionThrowable t) {
-                width = 8;
-            }
+            int width = Fixnum.getValue(elementType.cadr());
             bytesPerUnit = width / 8;
 	    if (isInputStream) {
 		initAsBinaryInputStream(racf.getInputStream());

Modified: trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java	Fri Nov  6 17:36:32 2009
@@ -74,23 +74,9 @@
             int fp = string.getFillPointer();
             if (fp >= 0) {
                 final int limit = Math.min(cbuf.length, off + len);
-                try {
-                    string.ensureCapacity(fp + limit);
-                }
-                catch (ConditionThrowable t) {
-                    // ### FIXME exception
-                    // Shouldn't happen.
-                    Debug.trace(t);
-                }
+                string.ensureCapacity(fp + limit);
                 for (int i = off; i < limit; i++) {
-                    try {
-                        string.setCharAt(fp, cbuf[i]);
-                    }
-                    catch (ConditionThrowable t) {
-                        // ### FIXME exception
-                        // Shouldn't happen.
-                        Debug.trace(t);
-                    }
+                    string.setCharAt(fp, cbuf[i]);
                     ++fp;
                 }
             }

Modified: trunk/abcl/src/org/armedbear/lisp/Function.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Function.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Function.java	Fri Nov  6 17:36:32 2009
@@ -68,13 +68,8 @@
         setLambdaName(symbol);
         setLambdaList(new SimpleString(arglist));
         if (docstring != null) {
-            try {
-                symbol.setDocumentation(Symbol.FUNCTION,
-                                        new SimpleString(docstring));
-            }
-            catch (ConditionThrowable t) {
-                Debug.assertTrue(false);
-            }
+            symbol.setDocumentation(Symbol.FUNCTION,
+                                    new SimpleString(docstring));
         }
     }
 
@@ -106,23 +101,18 @@
         if (arglist instanceof String)
             setLambdaList(new SimpleString(arglist));
         if (name != null) {
-            try {
-                Symbol symbol;
-                if (exported)
-                    symbol = pkg.internAndExport(name.toUpperCase());
-                else
-                    symbol = pkg.intern(name.toUpperCase());
-                symbol.setSymbolFunction(this);
-                if (cold)
-                    symbol.setBuiltInFunction(true);
-                setLambdaName(symbol);
-                if (docstring != null)
-                    symbol.setDocumentation(Symbol.FUNCTION,
-                                            new SimpleString(docstring));
-            }
-            catch (ConditionThrowable t) {
-                Debug.assertTrue(false);
-            }
+            Symbol symbol;
+            if (exported)
+                symbol = pkg.internAndExport(name.toUpperCase());
+            else
+                symbol = pkg.intern(name.toUpperCase());
+            symbol.setSymbolFunction(this);
+            if (cold)
+                symbol.setBuiltInFunction(true);
+            setLambdaName(symbol);
+            if (docstring != null)
+                symbol.setDocumentation(Symbol.FUNCTION,
+                                        new SimpleString(docstring));
         }
     }
 

Modified: trunk/abcl/src/org/armedbear/lisp/Go.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Go.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Go.java	Fri Nov  6 17:36:32 2009
@@ -33,7 +33,7 @@
 
 package org.armedbear.lisp;
 
-public final class Go extends ConditionThrowable
+public final class Go extends ControlTransfer
 {
     public final LispObject tagbody;
     public final LispObject tag;

Modified: trunk/abcl/src/org/armedbear/lisp/Interpreter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Interpreter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Interpreter.java	Fri Nov  6 17:36:32 2009
@@ -160,16 +160,7 @@
     public static synchronized void initializeLisp()
     {
         if (!initialized) {
-            try {
-                Load.loadSystemFile("boot.lisp", false, false, false);
-            }
-            catch (ConditionThrowable c) {
-                // ### FIXME exception
-                reportError(c, LispThread.currentThread());
-            }
-            catch (Throwable t) {
-                t.printStackTrace();
-            }
+            Load.loadSystemFile("boot.lisp", false, false, false);
             initialized = true;
         }
     }
@@ -184,11 +175,8 @@
                 Class.forName("org.armedbear.j.LispAPI");
                 Load.loadSystemFile("j.lisp");
             }
-            catch (ConditionThrowable c) {
-                // ### FIXME exception
-                reportError(c, LispThread.currentThread());
-            }
             catch (Throwable t) {
+                // ### FIXME exception
                 t.printStackTrace();
             }
             initialized = true;
@@ -277,8 +265,7 @@
                         try {
                             evaluate(args[i + 1]);
                         }
-                        catch (ConditionThrowable c) {
-                            // ### FIXME exception
+                        catch (UnhandledCondition c) {
                             final String separator =
                                 System.getProperty("line.separator");
                             FastStringBuffer sb = new FastStringBuffer();
@@ -305,22 +292,12 @@
                 } else if (arg.equals("--load") ||
                            arg.equals("--load-system-file")) {
                     if (i + 1 < args.length) {
-                        try {
-                            if (arg.equals("--load"))
-                                Load.load(new Pathname(args[i + 1]),
-                                          args[i + 1],
-                                          false, false, true);
-                            else
-                                Load.loadSystemFile(args[i + 1]);
-                        }
-                        catch (ConditionThrowable c) {
-                            // ### FIXME exception
-                            System.err.println("Caught condition: " +
-                                               c.getCondition().writeToString() +
-                                               " while loading: " +
-                                               args[i+1]);
-                            System.exit(2);
-                        }
+                        if (arg.equals("--load"))
+                            Load.load(new Pathname(args[i + 1]),
+                                      args[i + 1],
+                                      false, false, true);
+                        else
+                            Load.loadSystemFile(args[i + 1]);
                         ++i;
                     } else {
                         // Shouldn't happen.
@@ -387,8 +364,9 @@
                     getStandardInput().clearInput();
                     out._writeLine("Stack overflow");
                 }
-                catch (ConditionThrowable c) {
-                    // ### FIXME exception
+                catch (ControlTransfer c) {
+                    // We're on the toplevel, if this occurs,
+                    // we're toast...
                     reportError(c, thread);
                 }
                 catch (Throwable t) {
@@ -403,7 +381,24 @@
         }
     }
 
-    private static void reportError(ConditionThrowable c, LispThread thread)
+    private static void reportError(ControlTransfer c, LispThread thread)
+    {
+        try {
+            getStandardInput().clearInput();
+            Stream out = getStandardOutput();
+            out.freshLine();
+            Condition condition = (Condition) c.getCondition();
+            out._writeLine("Error: unhandled condition: " +
+                           condition.writeToString());
+            if (thread != null)
+                thread.printBacktrace();
+        }
+        catch (Throwable t) {
+            
+        }
+    }
+
+    private static void reportError(UnhandledCondition c, LispThread thread)
     {
         try {
             getStandardInput().clearInput();

Modified: trunk/abcl/src/org/armedbear/lisp/JHandler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JHandler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JHandler.java	Fri Nov  6 17:36:32 2009
@@ -81,13 +81,7 @@
                 LispObject lispAsVector = new SimpleVector(lispAs);
                 LispObject[] args = new LispObject[] //FIXME: count -> seq_num
                 { data, new JavaObject(o), lispAiVector, lispAsVector, Keyword.internKeyword(s), count };
-                try {
-                    f.execute(args);
-                }
-                catch (ConditionThrowable t) {
-                    // ### FIXME exception
-                    t.printStackTrace();
-                }
+                f.execute(args);
             }
         }
     }

Modified: trunk/abcl/src/org/armedbear/lisp/JProxy.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JProxy.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JProxy.java	Fri Nov  6 17:36:32 2009
@@ -94,23 +94,15 @@
           Function f = entry.getLispMethod(methodName);
           if (f != null)
             {
-              try
+              LispObject lispArgs = NIL;
+              if (args != null)
                 {
-                  LispObject lispArgs = NIL;
-                  if (args != null)
-                    {
-                      for (int i = args.length - 1 ; 0 <= i  ; i--)
-                        lispArgs = lispArgs.push(new JavaObject(args[i]));
-                    }
-                  LispObject result = evalCall(f, lispArgs, new Environment(),
-                                               LispThread.currentThread());
-                  return (method.getReturnType() == void.class ? null : result.javaInstance());
-                }
-              // ### FIXME exception
-              catch (ConditionThrowable t)
-                {
-                  t.printStackTrace();
+                  for (int i = args.length - 1 ; 0 <= i  ; i--)
+                    lispArgs = lispArgs.push(new JavaObject(args[i]));
                 }
+              LispObject result = evalCall(f, lispArgs, new Environment(),
+                                           LispThread.currentThread());
+              return (method.getReturnType() == void.class ? null : result.javaInstance());
             }
         }
       return null;

Modified: trunk/abcl/src/org/armedbear/lisp/Java.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Java.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Java.java	Fri Nov  6 17:36:32 2009
@@ -277,7 +277,7 @@
             catch (NoSuchMethodException e) {
                 error(new LispError("no such constructor"));
             }
-            catch (ConditionThrowable e) {
+            catch (ControlTransfer e) {
                 throw e;
             }
             catch (Throwable t) {
@@ -335,7 +335,7 @@
                 sb.append(')');
                 error(new LispError(sb.toString()));
             }
-            catch (ConditionThrowable e) {
+            catch (ControlTransfer e) {
                 throw e;
             }
             catch (Throwable t) {
@@ -648,7 +648,7 @@
             return JavaObject.getInstance(method.invoke(instance, methodArgs),
                                           translate);
         }
-        catch (ConditionThrowable t) {
+        catch (ControlTransfer t) {
             throw t;
         }
         catch (Throwable t) {

Modified: trunk/abcl/src/org/armedbear/lisp/JavaClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaClass.java	Fri Nov  6 17:36:32 2009
@@ -44,25 +44,21 @@
 
 	private void initCPL() {
 		LispObject cpl = Lisp.NIL;
-		try {
-			cpl = cpl.push(BuiltInClass.CLASS_T);
-			cpl = cpl.push(BuiltInClass.JAVA_OBJECT);
-			Set<Class<?>> alreadySeen = new HashSet<Class<?>>();
-			Stack<JavaClass> stack = new Stack<JavaClass>();
-			Class<?> theClass = javaClass;
-			boolean stop = false;
-			while(!stop && theClass != null) {
-				stop = addClass(alreadySeen, stack, theClass);
-				for(Class<?> c : theClass.getInterfaces()) {
-					stop = addClass(alreadySeen, stack, c) && stop; //watch out for short-circuiting!
-				}
-				theClass = theClass.getSuperclass();
+		cpl = cpl.push(BuiltInClass.CLASS_T);
+		cpl = cpl.push(BuiltInClass.JAVA_OBJECT);
+		Set<Class<?>> alreadySeen = new HashSet<Class<?>>();
+		Stack<JavaClass> stack = new Stack<JavaClass>();
+		Class<?> theClass = javaClass;
+		boolean stop = false;
+		while(!stop && theClass != null) {
+			stop = addClass(alreadySeen, stack, theClass);
+			for(Class<?> c : theClass.getInterfaces()) {
+				stop = addClass(alreadySeen, stack, c) && stop; //watch out for short-circuiting!
 			}
-			while(!stack.isEmpty()) {
-				cpl = cpl.push(stack.pop());
-			}
-		} catch (ConditionThrowable e) {
-			throw new Error("Cannot push class in class precedence list", e);
+			theClass = theClass.getSuperclass();
+		}
+		while(!stack.isEmpty()) {
+			cpl = cpl.push(stack.pop());
 		}
 		setCPL(cpl);
 	}

Modified: trunk/abcl/src/org/armedbear/lisp/JavaObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaObject.java	Fri Nov  6 17:36:32 2009
@@ -223,7 +223,7 @@
     @Override
     public String writeToString()
     {
-        if (obj instanceof ConditionThrowable)
+        if (obj instanceof ControlTransfer)
             return obj.toString();
 	final String s;
 	if(obj != null) {

Modified: trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java	Fri Nov  6 17:36:32 2009
@@ -53,18 +53,9 @@
 
   @Override
   public String writeToString() { 
-    String result = null;
     final String JAVA_STACK_FRAME = "JAVA-STACK-FRAME";
-    try {
-      result = unreadableString(JAVA_STACK_FRAME + " " 
-				+ toLispString().toString()); 
-    } catch (ConditionThrowable t) {
-        // ### FIXME exception
-      Debug.trace("Implementation error: ");
-      Debug.trace(t);
-      result = unreadableString(JAVA_STACK_FRAME);
-    }
-    return result;
+    return unreadableString(JAVA_STACK_FRAME + " "
+				+ toLispString().toString());
   }
 
   @Override

Modified: trunk/abcl/src/org/armedbear/lisp/Lisp.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Lisp.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Lisp.java	Fri Nov  6 17:36:32 2009
@@ -1453,14 +1453,9 @@
 
   public static final String safeWriteToString(LispObject obj)
   {
-    try
-      {
+    try {
         return obj.writeToString();
       }
-    catch (ConditionThrowable t)
-      {
-        return obj.toString();
-      }
     catch (NullPointerException e)
       {
         Debug.trace(e);
@@ -2173,14 +2168,7 @@
                                            LispObject value)
   {
     Symbol symbol = pkg.intern(name);
-    try
-      {
-        pkg.export(symbol); // FIXME Inefficient!
-      }
-    catch (ConditionThrowable t)
-      {
-        Debug.trace(t);
-      }
+    pkg.export(symbol); // FIXME Inefficient!
     symbol.setSpecial(true);
     symbol.setSymbolValue(value);
     return symbol;
@@ -2190,14 +2178,7 @@
                                             LispObject value)
   {
     Symbol symbol = pkg.intern(name);
-    try
-      {
-        pkg.export(symbol); // FIXME Inefficient!
-      }
-    catch (ConditionThrowable t)
-      {
-        Debug.trace(t);
-      }
+    pkg.export(symbol); // FIXME Inefficient!
     symbol.initializeConstant(value);
     return symbol;
   }

Modified: trunk/abcl/src/org/armedbear/lisp/LispThread.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispThread.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispThread.java	Fri Nov  6 17:36:32 2009
@@ -90,12 +90,7 @@
                 }
                 catch (Throwable t) {
                     if (isInterrupted()) {
-                        try {
-                            processThreadInterrupts();
-                        }
-                        catch (ConditionThrowable c) {
-                            Debug.trace(c);
-                        }
+                        processThreadInterrupts();
                     }
                 }
                 finally {
@@ -107,14 +102,8 @@
         javaThread = new Thread(r);
         this.name = name;
         map.put(javaThread, this);
-        try {
-            if (name != NIL)
-                javaThread.setName(name.getStringValue());
-        } catch (ConditionThrowable ex) {
-            // ### FIXME exception
-            Debug.trace("Failed to set thread name:");
-	    Debug.trace(ex);
-        }
+        if (name != NIL)
+            javaThread.setName(name.getStringValue());
         javaThread.setDaemon(true);
         javaThread.start();
     }
@@ -765,38 +754,32 @@
         }
         // Object doesn't fit.
         if (obj instanceof Cons) {
-            try {
-                boolean newlineBefore = false;
-                LispObject[] array = obj.copyToArray();
-                if (array.length > 0) {
-                    LispObject first = array[0];
-                    if (first == Symbol.LET) {
-                        newlineBefore = true;
-                    }
-                }
-                int charPos = stream.getCharPos();
-                if (newlineBefore && charPos != indentBy) {
-                    stream.terpri();
-                    charPos = stream.getCharPos();
+            boolean newlineBefore = false;
+            LispObject[] array = obj.copyToArray();
+            if (array.length > 0) {
+                LispObject first = array[0];
+                if (first == Symbol.LET) {
+                    newlineBefore = true;
                 }
-                if (charPos < indentBy) {
-                    StringBuffer sb = new StringBuffer();
-                    for (int i = charPos; i < indentBy; i++)
-                        sb.append(' ');
-                    stream._writeString(sb.toString());
-                }
-                stream.print('(');
-                for (int i = 0; i < array.length; i++) {
-                    pprint(array[i], indentBy + 2, stream);
-                    if (i < array.length - 1)
-                        stream.print(' ');
-                }
-                stream.print(')');
             }
-            catch (ConditionThrowable t) {
-                // ### FIXME exception
-                Debug.trace(t);
+            int charPos = stream.getCharPos();
+            if (newlineBefore && charPos != indentBy) {
+                stream.terpri();
+                charPos = stream.getCharPos();
+            }
+            if (charPos < indentBy) {
+                StringBuffer sb = new StringBuffer();
+                for (int i = charPos; i < indentBy; i++)
+                    sb.append(' ');
+                stream._writeString(sb.toString());
+            }
+            stream.print('(');
+            for (int i = 0; i < array.length; i++) {
+                pprint(array[i], indentBy + 2, stream);
+                if (i < array.length - 1)
+                   stream.print(' ');
             }
+            stream.print(')');
         } else {
             stream.terpri();
             StringBuffer sb = new StringBuffer();
@@ -1054,18 +1037,14 @@
     static {
         //FIXME: this block has been added for pre-0.16 compatibility
         // and can be removed the latest at release 0.22
-        try {
-            PACKAGE_EXT.export(Symbol.intern("MAKE-THREAD", PACKAGE_THREADS));
-            PACKAGE_EXT.export(Symbol.intern("THREADP", PACKAGE_THREADS));
-            PACKAGE_EXT.export(Symbol.intern("THREAD-ALIVE-P", PACKAGE_THREADS));
-            PACKAGE_EXT.export(Symbol.intern("THREAD-NAME", PACKAGE_THREADS));
-            PACKAGE_EXT.export(Symbol.intern("MAPCAR-THREADS", PACKAGE_THREADS));
-            PACKAGE_EXT.export(Symbol.intern("DESTROY-THREAD", PACKAGE_THREADS));
-            PACKAGE_EXT.export(Symbol.intern("INTERRUPT-THREAD", PACKAGE_THREADS));
-            PACKAGE_EXT.export(Symbol.intern("CURRENT-THREAD", PACKAGE_THREADS));
-        }
-        // ### FIXME exception
-        catch (ConditionThrowable ct) { }
+        PACKAGE_EXT.export(Symbol.intern("MAKE-THREAD", PACKAGE_THREADS));
+        PACKAGE_EXT.export(Symbol.intern("THREADP", PACKAGE_THREADS));
+        PACKAGE_EXT.export(Symbol.intern("THREAD-ALIVE-P", PACKAGE_THREADS));
+        PACKAGE_EXT.export(Symbol.intern("THREAD-NAME", PACKAGE_THREADS));
+        PACKAGE_EXT.export(Symbol.intern("MAPCAR-THREADS", PACKAGE_THREADS));
+        PACKAGE_EXT.export(Symbol.intern("DESTROY-THREAD", PACKAGE_THREADS));
+        PACKAGE_EXT.export(Symbol.intern("INTERRUPT-THREAD", PACKAGE_THREADS));
+        PACKAGE_EXT.export(Symbol.intern("CURRENT-THREAD", PACKAGE_THREADS));
     }
 
     // ### use-fast-calls

Modified: trunk/abcl/src/org/armedbear/lisp/Pathname.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Pathname.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Pathname.java	Fri Nov  6 17:36:32 2009
@@ -490,90 +490,85 @@
     @Override
     public String writeToString()
     {
+        final LispThread thread = LispThread.currentThread();
+        boolean printReadably = (Symbol.PRINT_READABLY.symbolValue(thread) != NIL);
+        boolean printEscape = (Symbol.PRINT_ESCAPE.symbolValue(thread) != NIL);
+        boolean useNamestring;
+        String s = null;
         try {
-            final LispThread thread = LispThread.currentThread();
-            boolean printReadably = (Symbol.PRINT_READABLY.symbolValue(thread) != NIL);
-            boolean printEscape = (Symbol.PRINT_ESCAPE.symbolValue(thread) != NIL);
-            boolean useNamestring;
-            String s = null;
-            try {
-                s = getNamestring();
-            }
-            catch (Throwable t) {}
-            if (s != null) {
-                useNamestring = true;
-                if (printReadably) {
-                    // We have a namestring. Check for pathname components that
-                    // can't be read from the namestring.
-                    if (host != NIL || version != NIL) {
+            s = getNamestring();
+        }
+        // ### FIXME exception
+        catch (Throwable t) {}
+        if (s != null) {
+            useNamestring = true;
+            if (printReadably) {
+                // We have a namestring. Check for pathname components that
+                // can't be read from the namestring.
+                if (host != NIL || version != NIL) {
+                    useNamestring = false;
+                } else if (name instanceof AbstractString) {
+                    String n = name.getStringValue();
+                    if (n.equals(".") || n.equals(".."))
+                        useNamestring = false;
+                    else if (n.indexOf(File.separatorChar) >= 0)
                         useNamestring = false;
-                    } else if (name instanceof AbstractString) {
-                        String n = name.getStringValue();
-                        if (n.equals(".") || n.equals(".."))
-                            useNamestring = false;
-                        else if (n.indexOf(File.separatorChar) >= 0)
-                            useNamestring = false;
-                    }
-                }
-            } else
-                useNamestring = false;
-            FastStringBuffer sb = new FastStringBuffer();
-            if (useNamestring) {
-                if (printReadably || printEscape)
-                    sb.append("#P\"");
-                final int limit = s.length();
-                for (int i = 0; i < limit; i++) {
-                    char c = s.charAt(i);
-                    if (printReadably || printEscape) {
-                        if (c == '\"' || c == '\\')
-                            sb.append('\\');
-                    }
-                    sb.append(c);
-                }
-                if (printReadably || printEscape)
-                    sb.append('"');
-            } else {
-                sb.append("#P(");
-                if (host != NIL) {
-                    sb.append(":HOST ");
-                    sb.append(host.writeToString());
-                    sb.append(' ');
-                }
-                if (device != NIL) {
-                    sb.append(":DEVICE ");
-                    sb.append(device.writeToString());
-                    sb.append(' ');
-                }
-                if (directory != NIL) {
-                    sb.append(":DIRECTORY ");
-                    sb.append(directory.writeToString());
-                    sb.append(" ");
-                }
-                if (name != NIL) {
-                    sb.append(":NAME ");
-                    sb.append(name.writeToString());
-                    sb.append(' ');
-                }
-                if (type != NIL) {
-                    sb.append(":TYPE ");
-                    sb.append(type.writeToString());
-                    sb.append(' ');
                 }
-                if (version != NIL) {
-                    sb.append(":VERSION ");
-                    sb.append(version.writeToString());
-                    sb.append(' ');
+            }
+        } else
+           useNamestring = false;
+        FastStringBuffer sb = new FastStringBuffer();
+        if (useNamestring) {
+            if (printReadably || printEscape)
+                sb.append("#P\"");
+            final int limit = s.length();
+            for (int i = 0; i < limit; i++) {
+                char c = s.charAt(i);
+                if (printReadably || printEscape) {
+                    if (c == '\"' || c == '\\')
+                        sb.append('\\');
                 }
-                if (sb.charAt(sb.length() - 1) == ' ')
-                    sb.setLength(sb.length() - 1);
-                sb.append(')');
-            }
-            return sb.toString();
-        }
-        catch (ConditionThrowable t) {
-            // ### FIXME exception
-            return unreadableString("PATHNAME");
-        }
+                sb.append(c);
+            }
+            if (printReadably || printEscape)
+                sb.append('"');
+        } else {
+            sb.append("#P(");
+            if (host != NIL) {
+                sb.append(":HOST ");
+                sb.append(host.writeToString());
+                sb.append(' ');
+           }
+           if (device != NIL) {
+               sb.append(":DEVICE ");
+               sb.append(device.writeToString());
+               sb.append(' ');
+            }
+            if (directory != NIL) {
+                sb.append(":DIRECTORY ");
+                sb.append(directory.writeToString());
+                sb.append(" ");
+            }
+           if (name != NIL) {
+                sb.append(":NAME ");
+                sb.append(name.writeToString());
+                sb.append(' ');
+            }
+            if (type != NIL) {
+                sb.append(":TYPE ");
+                sb.append(type.writeToString());
+                sb.append(' ');
+            }
+            if (version != NIL) {
+                sb.append(":VERSION ");
+                sb.append(version.writeToString());
+                sb.append(' ');
+            }
+            if (sb.charAt(sb.length() - 1) == ' ')
+                sb.setLength(sb.length() - 1);
+            sb.append(')');
+         }
+         return sb.toString();
     }
 
     // A logical host is represented as the string that names it.

Modified: trunk/abcl/src/org/armedbear/lisp/Profiler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Profiler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Profiler.java	Fri Nov  6 17:36:32 2009
@@ -97,9 +97,6 @@
                                 catch (InterruptedException e) {
                                     Debug.trace(e);
                                 }
-                                catch (ConditionThrowable e) {
-                                    break;
-                                }
                             }
                         }
                     };

Modified: trunk/abcl/src/org/armedbear/lisp/Return.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Return.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Return.java	Fri Nov  6 17:36:32 2009
@@ -33,7 +33,7 @@
 
 package org.armedbear.lisp;
 
-public final class Return extends ConditionThrowable
+public final class Return extends ControlTransfer
 {
     public final LispObject tag;
     public final LispObject block;

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java	Fri Nov  6 17:36:32 2009
@@ -54,20 +54,14 @@
     public SpecialOperator(String name, Package pkg, boolean exported,
                            String arglist)
     {
-        try {
-            Symbol symbol;
-            if (exported)
-                symbol = pkg.internAndExport(name.toUpperCase());
-            else
-                symbol = pkg.intern(name.toUpperCase());
-            symbol.setSymbolFunction(this);
-            setLambdaName(symbol);
-            setLambdaList(new SimpleString(arglist));
-        }
-        catch (ConditionThrowable t) {
-            // ### FIXME exception
-            Debug.assertTrue(false);
-        }
+        Symbol symbol;
+        if (exported)
+           symbol = pkg.internAndExport(name.toUpperCase());
+        else
+           symbol = pkg.intern(name.toUpperCase());
+        symbol.setSymbolFunction(this);
+        setLambdaName(symbol);
+        setLambdaList(new SimpleString(arglist));
     }
 
     @Override

Modified: trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java	Fri Nov  6 17:36:32 2009
@@ -55,42 +55,34 @@
                                  LispObject specializers)
   {
     this();
-    try
-      {
-        Symbol symbol;
-        if (exported)
-          symbol = pkg.internAndExport(name.toUpperCase());
-        else
-          symbol = pkg.intern(name.toUpperCase());
-        symbol.setSymbolFunction(this);
-        this.function = function;
-        slots[StandardGenericFunctionClass.SLOT_INDEX_NAME] = symbol;
-        slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST] =
-          lambdaList;
-        slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS] =
-          lambdaList;
-        numberOfRequiredArgs = lambdaList.length();
-        slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS] =
-          NIL;
-        StandardMethod method =
-          new StandardMethod(this, function, lambdaList, specializers);
-        slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] =
-          list(method);
-        slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] =
-          StandardClass.STANDARD_METHOD;
-        slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION] =
-          Symbol.STANDARD;
-        slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER] =
-          NIL;
-        slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE] =
-          NIL;
-        slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION] = NIL;
-      }
-    catch (ConditionThrowable t)
-      {
-        // ### FIXME exception
-        Debug.assertTrue(false);
-      }
+    Symbol symbol;
+    if (exported)
+      symbol = pkg.internAndExport(name.toUpperCase());
+    else
+      symbol = pkg.intern(name.toUpperCase());
+    symbol.setSymbolFunction(this);
+    this.function = function;
+    slots[StandardGenericFunctionClass.SLOT_INDEX_NAME] = symbol;
+    slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST] =
+      lambdaList;
+    slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS] =
+      lambdaList;
+    numberOfRequiredArgs = lambdaList.length();
+    slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS] =
+      NIL;
+    StandardMethod method =
+      new StandardMethod(this, function, lambdaList, specializers);
+    slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] =
+      list(method);
+    slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] =
+      StandardClass.STANDARD_METHOD;
+    slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION] =
+      Symbol.STANDARD;
+    slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER] =
+      NIL;
+    slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE] =
+      NIL;
+    slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION] = NIL;
   }
 
   private void finalizeInternal()

Modified: trunk/abcl/src/org/armedbear/lisp/Stream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Stream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Stream.java	Fri Nov  6 17:36:32 2009
@@ -281,53 +281,48 @@
       return;
     }
       
-    try {
-      LispObject enc;
-      boolean encIsCp = false;
-      
-      if (format instanceof Cons) {
-          // meaning a non-empty list
-          enc = format.car();
-
-          if (enc == keywordCodePage) {
-              encIsCp = true;
+    LispObject enc;
+    boolean encIsCp = false;
+    
+    if (format instanceof Cons) {
+        // meaning a non-empty list
+        enc = format.car();
+        if (enc == keywordCodePage) {
+            encIsCp = true;
 
-              enc = LispObject.getf(format.cdr(), keywordID, null);
-          }
-          
-          LispObject eol = LispObject.getf(format.cdr(), keywordEolStyle, keywordRAW);
-          if (eol == keywordCR)
-              eolStyle = EolStyle.CR;
-          else if (eol == keywordLF)
-              eolStyle = EolStyle.LF;
-          else if (eol == keywordCRLF)
-              eolStyle = EolStyle.CRLF;
-          else if (eol != keywordRAW)
-              ; //###FIXME: raise an error
+            enc = LispObject.getf(format.cdr(), keywordID, null);
+        }
           
-      } else
-        enc = format;
-      
-      if (enc.numberp())
-          encoding = enc.toString();
-      else if (enc instanceof AbstractString)
-          encoding = enc.getStringValue();
-      else if (enc == keywordDefault)
-          // This allows the user to use the encoding determined by
-          // Java to be the default for the current environment
-          // while still being able to set other stream options
-          // (e.g. :EOL-STYLE)
-          encoding = null;
-      else if (enc instanceof Symbol)
-          encoding = ((Symbol)enc).getName();
-      else
-          ; //###FIXME: raise an error!
-      
-      if (encIsCp)
-          encoding = "Cp" + encoding;
-    }
-    // ### FIXME exception
-    catch (ConditionThrowable ct) { }
+        LispObject eol = LispObject.getf(format.cdr(), keywordEolStyle, keywordRAW);
+        if (eol == keywordCR)
+            eolStyle = EolStyle.CR;
+        else if (eol == keywordLF)
+            eolStyle = EolStyle.LF;
+        else if (eol == keywordCRLF)
+            eolStyle = EolStyle.CRLF;
+        else if (eol != keywordRAW)
+            ; //###FIXME: raise an error
+        
+    } else
+      enc = format;
+    
+    if (enc.numberp())
+        encoding = enc.toString();
+    else if (enc instanceof AbstractString)
+        encoding = enc.getStringValue();
+    else if (enc == keywordDefault)
+        // This allows the user to use the encoding determined by
+        // Java to be the default for the current environment
+        // while still being able to set other stream options
+        // (e.g. :EOL-STYLE)
+        encoding = null;
+    else if (enc instanceof Symbol)
+        encoding = ((Symbol)enc).getName();
+    else
+        ; //###FIXME: raise an error!
+    
+    if (encIsCp)
+        encoding = "Cp" + encoding;
     
     eolChar = (eolStyle == EolStyle.CR) ? '\r' : '\n';
     externalFormat = format;

Modified: trunk/abcl/src/org/armedbear/lisp/StringFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StringFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StringFunctions.java	Fri Nov  6 17:36:32 2009
@@ -601,8 +601,7 @@
     {
         @Override
         public LispObject execute(LispObject first, LispObject second,
-                                  LispObject third) throws
-        ConditionThrowable
+                                  LispObject third)
         {
             LispObject s = first.STRING();
             final int length = s.length();

Modified: trunk/abcl/src/org/armedbear/lisp/Symbol.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Symbol.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Symbol.java	Fri Nov  6 17:36:32 2009
@@ -42,18 +42,9 @@
 
   public static final Symbol addFunction(String name, LispObject obj)
   {
-    try
-      {
-        Symbol symbol = PACKAGE_CL.internAndExport(name);
-        symbol.function = obj;
-        return symbol;
-      }
-    catch (ConditionThrowable t)
-      {
-        // ### FIXME exception
-        Debug.trace(t); // Shouldn't happen.
-        return null;
-      }
+    Symbol symbol = PACKAGE_CL.internAndExport(name);
+    symbol.function = obj;
+    return symbol;
   }
 
   public final SimpleString name;

Modified: trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java	Fri Nov  6 17:36:32 2009
@@ -33,7 +33,7 @@
 
 package org.armedbear.lisp;
 
-public class ThreadDestroyed extends ConditionThrowable
+public class ThreadDestroyed extends ControlTransfer
 {
     public ThreadDestroyed()
     {

Modified: trunk/abcl/src/org/armedbear/lisp/Throw.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Throw.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Throw.java	Fri Nov  6 17:36:32 2009
@@ -33,7 +33,7 @@
 
 package org.armedbear.lisp;
 
-public final class Throw extends ConditionThrowable
+public final class Throw extends ControlTransfer
 {
     public final LispObject tag;
     private final LispObject result;

Modified: trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java	Fri Nov  6 17:36:32 2009
@@ -75,7 +75,7 @@
 	    compileScript = (Function) this.findSymbol("COMPILE-SCRIPT", "ABCL-SCRIPT").getSymbolFunction();
 	    evalCompiledScript = (Function) this.findSymbol("EVAL-COMPILED-SCRIPT", "ABCL-SCRIPT").getSymbolFunction();
 	    evalFunction = (Function) this.findSymbol("EVAL-FUNCTION", "ABCL-SCRIPT").getSymbolFunction();
-	} catch (ConditionThrowable e) {
+	} catch (ControlTransfer e) {
 	    throw new RuntimeException(e);
 	}
     }
@@ -110,13 +110,13 @@
 	return b.toString();
     }
 
-	public LispObject loadFromClasspath(String classpathResource) throws ConditionThrowable {
+	public LispObject loadFromClasspath(String classpathResource) throws ControlTransfer {
 		InputStream istream = getClass().getResourceAsStream(classpathResource);
 		Stream stream = new Stream(istream, Symbol.CHARACTER);
 		return load(stream);
 	}
 
-	public LispObject load(Stream stream) throws ConditionThrowable {
+	public LispObject load(Stream stream) throws ControlTransfer {
 		Symbol keyword_verbose = Lisp.internKeyword("VERBOSE");
 		Symbol keyword_print = Lisp.internKeyword("PRINT");
 		/*
@@ -129,11 +129,11 @@
 						Lisp.T, Keyword.EXTERNAL_FORMAT, Keyword.DEFAULT });
 	}
 
-	public LispObject load(String filespec) throws ConditionThrowable {
+	public LispObject load(String filespec) throws ControlTransfer {
 		return load(filespec, true);
 	}
 
-	public LispObject load(String filespec, boolean compileIfNecessary)	throws ConditionThrowable {
+	public LispObject load(String filespec, boolean compileIfNecessary)	throws ControlTransfer {
 		if (isCompiled(filespec) || !compileIfNecessary) {
 			return interpreter.eval("(load \"" + escape(filespec) + "\")");
 		} else {
@@ -162,11 +162,11 @@
 				&& compiled.lastModified() >= source.lastModified();
 	}
 
-	public LispObject compileFile(String filespec) throws ConditionThrowable {
+	public LispObject compileFile(String filespec) throws ControlTransfer {
 		return interpreter.eval("(compile-file \"" + escape(filespec) + "\")");
 	}
 
-	public LispObject compileAndLoad(String filespec) throws ConditionThrowable {
+	public LispObject compileAndLoad(String filespec) throws ControlTransfer {
 		return interpreter.eval("(load (compile-file \"" + escape(filespec)	+ "\"))");
 	}
 
@@ -174,7 +174,7 @@
 		return obj instanceof Function;
 	}
 
-	public JavaObject jsetq(String symbol, Object value) throws ConditionThrowable {
+	public JavaObject jsetq(String symbol, Object value) throws ControlTransfer {
 		Symbol s = findSymbol(symbol);
 		JavaObject jo;
 		if (value instanceof JavaObject) {
@@ -186,7 +186,7 @@
 		return jo;
 	}
 
-	public Symbol findSymbol(String name, String pkg) throws ConditionThrowable {
+	public Symbol findSymbol(String name, String pkg) throws ControlTransfer {
 		Cons values = (Cons) (interpreter.eval("(cl:multiple-value-list (find-symbol (symbol-name '#:"
 											   + escape(name) + ")" + (pkg == null ? "" : " :" + escape(pkg))
 											   + "))"));
@@ -197,7 +197,7 @@
 		}
 	}
 
-	public Symbol findSymbol(String name) throws ConditionThrowable {
+	public Symbol findSymbol(String name) throws ControlTransfer {
 		//Known bug: doesn't handle escaped ':' e.g. |a:b|
 		int i = name.indexOf(':');
 		if(i < 0) { 
@@ -211,7 +211,7 @@
 		}
 	}
 	
-	public Function findFunction(String name) throws ConditionThrowable {
+	public Function findFunction(String name) throws ControlTransfer {
 		return (Function) interpreter.eval("#'" + name);
 	}
 
@@ -220,7 +220,7 @@
 		return new SimpleBindings();
 	}
 
-	private static LispObject makeBindings(Bindings bindings) throws ConditionThrowable {
+	private static LispObject makeBindings(Bindings bindings) throws ControlTransfer {
 		if (bindings == null || bindings.size() == 0) {
 			return Lisp.NIL;
 		}
@@ -247,7 +247,7 @@
 				       inStream, outStream,
 				       code, new JavaObject(ctx));
 	    return retVal.javaInstance();
-	} catch (ConditionThrowable e) {
+	} catch (ControlTransfer e) {
 	    throw new ScriptException(new Exception(e));
 	} catch (IOException e) {
 	    throw new ScriptException(e);
@@ -300,7 +300,7 @@
 			Symbol s = findSymbol("jmake-proxy", "JAVA");
 			JavaObject iface = new JavaObject(clasz);
 			return (T) ((JavaObject) s.execute(iface, (LispObject) thiz)).javaInstance();
-		} catch (ConditionThrowable e) {
+		} catch (ControlTransfer e) {
 			throw new Error(e);
 		}
 	}	
@@ -329,7 +329,7 @@
 	    } else {
 		throw new NoSuchMethodException(name);
 	    }
-	} catch (ConditionThrowable e) {
+	} catch (ControlTransfer e) {
 	    throw new ScriptException(new RuntimeException(e));
 	}
     }
@@ -365,7 +365,7 @@
 		try {
 		    Function f = (Function) compileScript.execute(new SimpleString(script));
 		    return new AbclCompiledScript(f);
-		} catch (ConditionThrowable e) {
+		} catch (ControlTransfer e) {
 			throw new ScriptException(new Exception(e));
 		} catch(ClassCastException e) {
 			throw new ScriptException(e);



From astalla at common-lisp.net  Sat Nov  7 09:22:55 2009
From: astalla at common-lisp.net (Alessio Stalla)
Date: Sat, 07 Nov 2009 04:22:55 -0500
Subject: [armedbear-cvs] r12256 - trunk/abcl/src/org/armedbear/lisp/scripting
Message-ID: <E1N6hVX-0004Kl-MK@common-lisp.net>

Author: astalla
Date: Sat Nov  7 04:22:52 2009
New Revision: 12256

Log:
Removed unnecessary ConditionThrowables.


Modified:
   trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java

Modified: trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java	Sat Nov  7 04:22:52 2009
@@ -61,23 +61,19 @@
 	if(interpreter == null) {
 	    interpreter = Interpreter.createInstance();
 	}
-	try {
-	    loadFromClasspath("/org/armedbear/lisp/scripting/lisp/packages.lisp");
-	    loadFromClasspath("/org/armedbear/lisp/scripting/lisp/abcl-script.lisp");
-	    loadFromClasspath("/org/armedbear/lisp/scripting/lisp/config.lisp");
-	    if(getClass().getResource("/abcl-script-config.lisp") != null) {
-		System.out.println("ABCL: loading configuration from " + getClass().getResource("/abcl-script-config.lisp"));
-		loadFromClasspath("/abcl-script-config.lisp");
-	    }
-	    ((Function) interpreter.eval("#'abcl-script:configure-abcl")).execute(new JavaObject(this));
-	    System.out.println("ABCL: configured");
-	    evalScript = (Function) this.findSymbol("EVAL-SCRIPT", "ABCL-SCRIPT").getSymbolFunction();
-	    compileScript = (Function) this.findSymbol("COMPILE-SCRIPT", "ABCL-SCRIPT").getSymbolFunction();
-	    evalCompiledScript = (Function) this.findSymbol("EVAL-COMPILED-SCRIPT", "ABCL-SCRIPT").getSymbolFunction();
-	    evalFunction = (Function) this.findSymbol("EVAL-FUNCTION", "ABCL-SCRIPT").getSymbolFunction();
-	} catch (ControlTransfer e) {
-	    throw new RuntimeException(e);
-	}
+	loadFromClasspath("/org/armedbear/lisp/scripting/lisp/packages.lisp");
+	loadFromClasspath("/org/armedbear/lisp/scripting/lisp/abcl-script.lisp");
+	loadFromClasspath("/org/armedbear/lisp/scripting/lisp/config.lisp");
+	if(getClass().getResource("/abcl-script-config.lisp") != null) {
+	    System.out.println("ABCL: loading configuration from " + getClass().getResource("/abcl-script-config.lisp"));
+	    loadFromClasspath("/abcl-script-config.lisp");
+	}
+	((Function) interpreter.eval("#'abcl-script:configure-abcl")).execute(new JavaObject(this));
+	System.out.println("ABCL: configured");
+	evalScript = (Function) this.findSymbol("EVAL-SCRIPT", "ABCL-SCRIPT").getSymbolFunction();
+	compileScript = (Function) this.findSymbol("COMPILE-SCRIPT", "ABCL-SCRIPT").getSymbolFunction();
+	evalCompiledScript = (Function) this.findSymbol("EVAL-COMPILED-SCRIPT", "ABCL-SCRIPT").getSymbolFunction();
+	evalFunction = (Function) this.findSymbol("EVAL-FUNCTION", "ABCL-SCRIPT").getSymbolFunction();
     }
     
     public Interpreter getInterpreter() {
@@ -110,13 +106,13 @@
 	return b.toString();
     }
 
-	public LispObject loadFromClasspath(String classpathResource) throws ControlTransfer {
+	public LispObject loadFromClasspath(String classpathResource) {
 		InputStream istream = getClass().getResourceAsStream(classpathResource);
 		Stream stream = new Stream(istream, Symbol.CHARACTER);
 		return load(stream);
 	}
 
-	public LispObject load(Stream stream) throws ControlTransfer {
+	public LispObject load(Stream stream) {
 		Symbol keyword_verbose = Lisp.internKeyword("VERBOSE");
 		Symbol keyword_print = Lisp.internKeyword("PRINT");
 		/*
@@ -129,11 +125,11 @@
 						Lisp.T, Keyword.EXTERNAL_FORMAT, Keyword.DEFAULT });
 	}
 
-	public LispObject load(String filespec) throws ControlTransfer {
+	public LispObject load(String filespec) {
 		return load(filespec, true);
 	}
 
-	public LispObject load(String filespec, boolean compileIfNecessary)	throws ControlTransfer {
+	public LispObject load(String filespec, boolean compileIfNecessary) {
 		if (isCompiled(filespec) || !compileIfNecessary) {
 			return interpreter.eval("(load \"" + escape(filespec) + "\")");
 		} else {
@@ -162,11 +158,11 @@
 				&& compiled.lastModified() >= source.lastModified();
 	}
 
-	public LispObject compileFile(String filespec) throws ControlTransfer {
+	public LispObject compileFile(String filespec) {
 		return interpreter.eval("(compile-file \"" + escape(filespec) + "\")");
 	}
 
-	public LispObject compileAndLoad(String filespec) throws ControlTransfer {
+	public LispObject compileAndLoad(String filespec) {
 		return interpreter.eval("(load (compile-file \"" + escape(filespec)	+ "\"))");
 	}
 
@@ -174,7 +170,7 @@
 		return obj instanceof Function;
 	}
 
-	public JavaObject jsetq(String symbol, Object value) throws ControlTransfer {
+	public JavaObject jsetq(String symbol, Object value) {
 		Symbol s = findSymbol(symbol);
 		JavaObject jo;
 		if (value instanceof JavaObject) {
@@ -186,7 +182,7 @@
 		return jo;
 	}
 
-	public Symbol findSymbol(String name, String pkg) throws ControlTransfer {
+	public Symbol findSymbol(String name, String pkg) {
 		Cons values = (Cons) (interpreter.eval("(cl:multiple-value-list (find-symbol (symbol-name '#:"
 											   + escape(name) + ")" + (pkg == null ? "" : " :" + escape(pkg))
 											   + "))"));
@@ -197,7 +193,7 @@
 		}
 	}
 
-	public Symbol findSymbol(String name) throws ControlTransfer {
+	public Symbol findSymbol(String name) {
 		//Known bug: doesn't handle escaped ':' e.g. |a:b|
 		int i = name.indexOf(':');
 		if(i < 0) { 
@@ -211,7 +207,7 @@
 		}
 	}
 	
-	public Function findFunction(String name) throws ControlTransfer {
+	public Function findFunction(String name) {
 		return (Function) interpreter.eval("#'" + name);
 	}
 
@@ -220,7 +216,7 @@
 		return new SimpleBindings();
 	}
 
-	private static LispObject makeBindings(Bindings bindings) throws ControlTransfer {
+    private static LispObject makeBindings(Bindings bindings) {
 		if (bindings == null || bindings.size() == 0) {
 			return Lisp.NIL;
 		}
@@ -247,8 +243,6 @@
 				       inStream, outStream,
 				       code, new JavaObject(ctx));
 	    return retVal.javaInstance();
-	} catch (ControlTransfer e) {
-	    throw new ScriptException(new Exception(e));
 	} catch (IOException e) {
 	    throw new ScriptException(e);
 	}
@@ -296,41 +290,33 @@
 	@SuppressWarnings("unchecked")
 	@Override
 	public <T> T getInterface(Object thiz, Class<T> clasz) {
-		try {
-			Symbol s = findSymbol("jmake-proxy", "JAVA");
-			JavaObject iface = new JavaObject(clasz);
-			return (T) ((JavaObject) s.execute(iface, (LispObject) thiz)).javaInstance();
-		} catch (ControlTransfer e) {
-			throw new Error(e);
-		}
+	    Symbol s = findSymbol("jmake-proxy", "JAVA");
+	    JavaObject iface = new JavaObject(clasz);
+	    return (T) ((JavaObject) s.execute(iface, (LispObject) thiz)).javaInstance();
 	}	
 	
     @Override
     public Object invokeFunction(String name, Object... args) throws ScriptException, NoSuchMethodException {
-	try {
-	    Symbol s;
-	    if(name.indexOf(':') >= 0) {
-		s = findSymbol(name);
-	    } else {
-		s = findSymbol(name, "ABCL-SCRIPT-USER");
-	    }
-	    if(s != null) {
-		LispObject f = s.getSymbolFunction();
-		if(f != null && f instanceof Function) {
-		    LispObject functionAndArgs = Lisp.NIL.push(f);
-		    for(int i = 0; i < args.length; ++i) {
-			functionAndArgs = functionAndArgs.push(JavaObject.getInstance(args[i], true));
-		    }
-		    functionAndArgs = functionAndArgs.reverse();
-		    return eval(evalFunction, functionAndArgs, getContext());
-		} else {
-		    throw new NoSuchMethodException(name);
+	Symbol s;
+	if(name.indexOf(':') >= 0) {
+	    s = findSymbol(name);
+	} else {
+	    s = findSymbol(name, "ABCL-SCRIPT-USER");
+	}
+	if(s != null) {
+	    LispObject f = s.getSymbolFunction();
+	    if(f != null && f instanceof Function) {
+		LispObject functionAndArgs = Lisp.NIL.push(f);
+		for(int i = 0; i < args.length; ++i) {
+		    functionAndArgs = functionAndArgs.push(JavaObject.getInstance(args[i], true));
 		}
+		functionAndArgs = functionAndArgs.reverse();
+		return eval(evalFunction, functionAndArgs, getContext());
 	    } else {
 		throw new NoSuchMethodException(name);
 	    }
-	} catch (ControlTransfer e) {
-	    throw new ScriptException(new RuntimeException(e));
+	} else {
+	    throw new NoSuchMethodException(name);
 	}
     }
 
@@ -365,8 +351,6 @@
 		try {
 		    Function f = (Function) compileScript.execute(new SimpleString(script));
 		    return new AbclCompiledScript(f);
-		} catch (ControlTransfer e) {
-			throw new ScriptException(new Exception(e));
 		} catch(ClassCastException e) {
 			throw new ScriptException(e);
 		}



From ehuelsmann at common-lisp.net  Sat Nov  7 11:13:42 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 06:13:42 -0500
Subject: [armedbear-cvs] r12257 - trunk/abcl
Message-ID: <E1N6jEk-0003oi-NW@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 06:13:39 2009
New Revision: 12257

Log:
Update CHANGES.

Modified:
   trunk/abcl/CHANGES

Modified: trunk/abcl/CHANGES
==============================================================================
--- trunk/abcl/CHANGES	(original)
+++ trunk/abcl/CHANGES	Sat Nov  7 06:13:39 2009
@@ -13,6 +13,9 @@
   * Java property to print autoloading information: abcl.autoload.verbose
   * Experimental: binary fasls
   * Default Ant build target now "abcl.clean abcl.wrapper" (from abcl.help)
+  * ConditionThrowable class renamed to ControlTransfer,
+      parent class changed to RuntimeException (to make it unchecked)
+  * API no longer throws ConditionThrowable/ControlTransfer
 
 
 Bugs fixed:
@@ -35,6 +38,8 @@
   * Autoload cleanups
   * System package creation cleaned up
   * CHAR-CODE-LIMIT correctly reflects CHAR-CODE maximum return value
+  * Precompiler macroexpansion failure for macros expanding into
+      special operators
 
 
 Version 0.16.1



From ehuelsmann at common-lisp.net  Sat Nov  7 11:15:36 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 06:15:36 -0500
Subject: [armedbear-cvs] r12258 - branches/0.17.x
Message-ID: <E1N6jGa-000441-Kj@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 06:15:35 2009
New Revision: 12258

Log:
Delete 0.17 branch for re-branching.

Removed:
   branches/0.17.x/



From ehuelsmann at common-lisp.net  Sat Nov  7 11:16:31 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 06:16:31 -0500
Subject: [armedbear-cvs] r12259 - branches/0.17.x
Message-ID: <E1N6jHT-0004AI-DN@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 06:16:30 2009
New Revision: 12259

Log:
Rebranch 0.17.

Added:
   branches/0.17.x/
      - copied from r12258, /trunk/



From ehuelsmann at common-lisp.net  Sat Nov  7 11:19:55 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 06:19:55 -0500
Subject: [armedbear-cvs] r12260 - branches/0.17.x/abcl/src/org/armedbear/lisp
Message-ID: <E1N6jKl-0004HI-El@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 06:19:54 2009
New Revision: 12260

Log:
Setup correct version number on 0.17.x branch.

Modified:
   branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java

Modified: branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java
==============================================================================
--- branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java	(original)
+++ branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java	Sat Nov  7 06:19:54 2009
@@ -41,6 +41,6 @@
 
   public static String getVersion()
   {
-    return "0.18.0-dev";
+    return "0.17.0-dev";
   }
 }



From ehuelsmann at common-lisp.net  Sat Nov  7 12:32:09 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 07:32:09 -0500
Subject: [armedbear-cvs] r12261 - branches/0.17.x/abcl
Message-ID: <E1N6kSf-0000qT-Ee@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 07:32:07 2009
New Revision: 12261

Log:
Mark release date for 0.17.0.

Modified:
   branches/0.17.x/abcl/CHANGES

Modified: branches/0.17.x/abcl/CHANGES
==============================================================================
--- branches/0.17.x/abcl/CHANGES	(original)
+++ branches/0.17.x/abcl/CHANGES	Sat Nov  7 07:32:07 2009
@@ -1,6 +1,8 @@
 Version 0.17.0
 ==============
-(unreleased)
+svn://common-lisp.net/project/armedbear/svn/tags/0.17.0/abcl
+(07 Nov, 2009)
+
 
 Features:
 



From ehuelsmann at common-lisp.net  Sat Nov  7 12:33:33 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 07:33:33 -0500
Subject: [armedbear-cvs] r12262 - trunk/abcl
Message-ID: <E1N6kU1-0000rN-7w@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 07:33:32 2009
New Revision: 12262

Log:
Update CHANGES.

Modified:
   trunk/abcl/CHANGES

Modified: trunk/abcl/CHANGES
==============================================================================
--- trunk/abcl/CHANGES	(original)
+++ trunk/abcl/CHANGES	Sat Nov  7 07:33:32 2009
@@ -1,6 +1,8 @@
 Version 0.17.0
 ==============
-(unreleased)
+svn://common-lisp.net/project/armedbear/svn/tags/0.17.0/abcl
+(07 Nov, 2009)
+
 
 Features:
 



From ehuelsmann at common-lisp.net  Sat Nov  7 12:35:17 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 07:35:17 -0500
Subject: [armedbear-cvs] r12263 - in tags/0.17.0: .
	abcl/src/org/armedbear/lisp
Message-ID: <E1N6kVh-00013Z-4E@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 07:35:16 2009
New Revision: 12263

Log:
Tag 0.17.0.

Added:
   tags/0.17.0/
      - copied from r12262, /branches/0.17.x/
Modified:
   tags/0.17.0/abcl/src/org/armedbear/lisp/Version.java

Modified: tags/0.17.0/abcl/src/org/armedbear/lisp/Version.java
==============================================================================
--- /branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java	(original)
+++ tags/0.17.0/abcl/src/org/armedbear/lisp/Version.java	Sat Nov  7 07:35:16 2009
@@ -41,6 +41,6 @@
 
   public static String getVersion()
   {
-    return "0.17.0-dev";
+    return "0.17.0";
   }
 }



From ehuelsmann at common-lisp.net  Sat Nov  7 13:15:10 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 08:15:10 -0500
Subject: [armedbear-cvs] r12264 - public_html/releases
Message-ID: <E1N6l8I-0006W3-Cd@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 08:15:05 2009
New Revision: 12264

Log:
Upload 0.17.0 release files.

Added:
   public_html/releases/abcl-bin-0.17.0.tar.gz   (contents, props changed)
   public_html/releases/abcl-bin-0.17.0.tar.gz.asc
   public_html/releases/abcl-bin-0.17.0.zip   (contents, props changed)
   public_html/releases/abcl-bin-0.17.0.zip.asc
   public_html/releases/abcl-src-0.17.0.tar.gz   (contents, props changed)
   public_html/releases/abcl-src-0.17.0.tar.gz.asc
   public_html/releases/abcl-src-0.17.0.zip   (contents, props changed)
   public_html/releases/abcl-src-0.17.0.zip.asc

Added: public_html/releases/abcl-bin-0.17.0.tar.gz
==============================================================================
Binary file. No diff available.

Added: public_html/releases/abcl-bin-0.17.0.tar.gz.asc
==============================================================================
--- (empty file)
+++ public_html/releases/abcl-bin-0.17.0.tar.gz.asc	Sat Nov  7 08:15:05 2009
@@ -0,0 +1,7 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.4.9 (GNU/Linux)
+
+iEYEABECAAYFAkr1cb4ACgkQi5O0Epaz9TlrSgCeL8+6FkSYYiibYM5idUyqRzzw
+bkYAnjkvDYVqju/QKAHFL8PKiasqM+zV
+=7t1P
+-----END PGP SIGNATURE-----

Added: public_html/releases/abcl-bin-0.17.0.zip
==============================================================================
Binary file. No diff available.

Added: public_html/releases/abcl-bin-0.17.0.zip.asc
==============================================================================
--- (empty file)
+++ public_html/releases/abcl-bin-0.17.0.zip.asc	Sat Nov  7 08:15:05 2009
@@ -0,0 +1,7 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.4.9 (GNU/Linux)
+
+iEYEABECAAYFAkr1cccACgkQi5O0Epaz9TlHhgCfQF3A7A0NUBCadRBtZmpPz87P
+g1sAnjVlsx3yPvbhmPnCwfinFq8PGfQQ
+=Tcfo
+-----END PGP SIGNATURE-----

Added: public_html/releases/abcl-src-0.17.0.tar.gz
==============================================================================
Binary file. No diff available.

Added: public_html/releases/abcl-src-0.17.0.tar.gz.asc
==============================================================================
--- (empty file)
+++ public_html/releases/abcl-src-0.17.0.tar.gz.asc	Sat Nov  7 08:15:05 2009
@@ -0,0 +1,7 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.4.9 (GNU/Linux)
+
+iEYEABECAAYFAkr1cdYACgkQi5O0Epaz9Tm0xQCfaKi6Jyly/fqA7z0zyBm16h+P
+S+QAmwZb6PavlHEzUqdFBH3mLCp0swX9
+=JO5j
+-----END PGP SIGNATURE-----

Added: public_html/releases/abcl-src-0.17.0.zip
==============================================================================
Binary file. No diff available.

Added: public_html/releases/abcl-src-0.17.0.zip.asc
==============================================================================
--- (empty file)
+++ public_html/releases/abcl-src-0.17.0.zip.asc	Sat Nov  7 08:15:05 2009
@@ -0,0 +1,7 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.4.9 (GNU/Linux)
+
+iEUEABECAAYFAkr1ce0ACgkQi5O0Epaz9TmeTACeOIojhtypOwCvTMpch4sZFxuF
+UZsAljZv50U3+d1W6GluneP4SPUS9l0=
+=zi3q
+-----END PGP SIGNATURE-----



From ehuelsmann at common-lisp.net  Sat Nov  7 14:03:10 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 09:03:10 -0500
Subject: [armedbear-cvs] r12265 - branches/0.17.x/abcl/src/org/armedbear/lisp
Message-ID: <E1N6lsk-0002bV-Nm@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 09:03:08 2009
New Revision: 12265

Log:
Update 0.17.x branch version number with 0.17.0 tagged.

Modified:
   branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java

Modified: branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java
==============================================================================
--- branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java	(original)
+++ branches/0.17.x/abcl/src/org/armedbear/lisp/Version.java	Sat Nov  7 09:03:08 2009
@@ -41,6 +41,6 @@
 
   public static String getVersion()
   {
-    return "0.17.0-dev";
+    return "0.17.1-dev";
   }
 }



From ehuelsmann at common-lisp.net  Sat Nov  7 14:34:42 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 09:34:42 -0500
Subject: [armedbear-cvs] r12266 - public_html
Message-ID: <E1N6mNG-0004uD-AG@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 09:34:38 2009
New Revision: 12266

Log:
Publish 0.17.0 release on the website.

Added:
   public_html/release-notes-0.17.shtml
Modified:
   public_html/index.shtml
   public_html/left-menu

Modified: public_html/index.shtml
==============================================================================
--- public_html/index.shtml	(original)
+++ public_html/index.shtml	Sat Nov  7 09:34:38 2009
@@ -32,9 +32,9 @@
  using <b>Java to Lisp integration</b> APIs.
 </td></tr>
 <tr><th style="border:1px black solid" colspan="2"><a
-href="releases/abcl-src-0.16.1.tar.gz" style="color:black;font-weight:normal">
-Download 0.16.1</a> <a
-href="releases/abcl-src-0.16.1.zip"
+href="releases/abcl-src-0.17.0.tar.gz" style="color:black;font-weight:normal">
+Download 0.17.0</a> <a
+href="releases/abcl-src-0.17.0.zip"
 style="font-size:75%;color:black;font-weight:normal">(zip)</a></th></tr>
 <tr>
 <td class="summary-header">Users

Modified: public_html/left-menu
==============================================================================
--- public_html/left-menu	(original)
+++ public_html/left-menu	Sat Nov  7 09:34:38 2009
@@ -1,7 +1,7 @@
 <div style="margin-top:3cm;margin-right:1cm;float:left;width:20ex;background-color:#fea;font-family:sans-serif;font-size:12px;padding:10px 5px 10px 5px">
 <b><a href="./">Project page</a><br />
 <a href="./testimonials.shtml">Testimonials</a><br />
-<a href="./release-notes-0.16.shtml">Release notes</a><br />
+<a href="./release-notes-0.17.shtml">Release notes</a><br />
 <a href="./commercial-support.shtml">Paid support</a>
 </b>
 <br />

Added: public_html/release-notes-0.17.shtml
==============================================================================
--- (empty file)
+++ public_html/release-notes-0.17.shtml	Sat Nov  7 09:34:38 2009
@@ -0,0 +1,68 @@
+<?xml version="1.0"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>ABCL - Release notes v0.17</title>
+  <link rel="stylesheet" type="text/css" href="style.css"/>
+  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+</head>
+
+<body>
+ <div class="header">
+   <h1>ABCL - Release notes for version 0.17</h1>
+ </div>
+
+<!--#include virtual="left-menu" -->
+
+<div class="rn">
+
+<h2>Most notable changes in ABCL 0.17</h2>
+
+
+<p><a href="release-notes-0.16.shtml">Release notes for older releases</a>.</p>
+
+
+
+<dl>
+  <dt>ConditionThrowable changes to API</dt>
+  <dd>ConditionThrowable has been renamed to ControlTransfer and no
+    longer has Throwable as its parent class using RuntimeException instead.
+    In addition have all the &quot;throws ConditionThrowable&quot; method
+    annotations been removed: API users generally should not be bothered
+    with an implementation 'detail'.</dd>
+  <dt>Increased FASL version number</dt>
+  <dd>Pre-0.17 FASLS identify themselves with versions up to 32;
+    0.17 uses 33.</dd>
+  <dt>Google App Engine example code</dt>
+  <dd>This release contains a "Hello world" example program.</dd>
+  <dt>CLOS improvements</dt>
+  <dd>MAKE-INSTANCE initargs checking improments,
+    discriminating methods and slot accessor performance</dd>
+  <dt>Java property for auto-loading verbosity</dt>
+  <dd>Add &quot;-Dabcl.autoload.verbose=Y&quot; when starting ABCL
+    to make the autoloader process more verbose.</dd>
+  <dt>Fixed unexpected thread termination</dt>
+  <dd>The running thread no longer gets terminated when a GO or
+    RETURN-FROM form gets evaluated outside its lexical scope.</dd>
+  <dt>Loading FASLs from JARs</dt>
+  <dd>When the application has file-system access, it can load
+    FASL files from a JAR it's stored in (enhancement of deployment
+    options).</dd>
+</dl>
+
+
+
+
+
+<div style="float:left;width:100%">
+ <hr />
+ <p>Back to <a href="http://common-lisp.net/">Common-lisp.net</a>.</p>
+
+ <div class="check">
+   <a href="http://validator.w3.org/check/referer">Valid XHTML 1.0 Strict</a>
+ </div>
+<div style="float:right;font-size:10px;font-family:monospace">$Id: release-notes-0.16.shtml 12246 2009-11-04 22:00:47Z ehuelsmann $</div>
+</div>
+</body>
+</html>



From ehuelsmann at common-lisp.net  Sat Nov  7 16:02:10 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 11:02:10 -0500
Subject: [armedbear-cvs] r12267 - trunk/abcl
Message-ID: <E1N6njt-0002W4-Vj@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 11:02:06 2009
New Revision: 12267

Log:
Fix build.xml when being invoked only for distribution purposes.

Modified:
   trunk/abcl/build.xml

Modified: trunk/abcl/build.xml
==============================================================================
--- trunk/abcl/build.xml	(original)
+++ trunk/abcl/build.xml	Sat Nov  7 11:02:06 2009
@@ -495,7 +495,7 @@
       </zip>
     </target>
     
-    <target name="abcl.binary.prepare" depends="abcl.stamp.version">
+    <target name="abcl.binary.prepare" depends="abcl.jar,abcl.stamp.version">
       <property name="abcl.build.binary.dir"
                 value="${build.dir}/abcl-bin-${abcl.version}"/>
       <mkdir dir="${abcl.build.binary.dir}"/>



From ehuelsmann at common-lisp.net  Sat Nov  7 16:05:58 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 11:05:58 -0500
Subject: [armedbear-cvs] r12268 - branches/0.17.x/abcl
Message-ID: <E1N6nna-0002Yg-Hm@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 11:05:53 2009
New Revision: 12268

Log:
Backport build.xml fix.

Modified:
   branches/0.17.x/abcl/build.xml

Modified: branches/0.17.x/abcl/build.xml
==============================================================================
--- branches/0.17.x/abcl/build.xml	(original)
+++ branches/0.17.x/abcl/build.xml	Sat Nov  7 11:05:53 2009
@@ -495,7 +495,7 @@
       </zip>
     </target>
     
-    <target name="abcl.binary.prepare" depends="abcl.stamp.version">
+    <target name="abcl.binary.prepare" depends="abcl.stamp.version,abcl.jar">
       <property name="abcl.build.binary.dir"
                 value="${build.dir}/abcl-bin-${abcl.version}"/>
       <mkdir dir="${abcl.build.binary.dir}"/>



From ehuelsmann at common-lisp.net  Sat Nov  7 16:09:03 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 11:09:03 -0500
Subject: [armedbear-cvs] r12269 - developer-resources
Message-ID: <E1N6nqZ-0002dh-BJ@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 11:09:02 2009
New Revision: 12269

Log:
Add release announcement template.

Added:
   developer-resources/release-announcement.txt

Added: developer-resources/release-announcement.txt
==============================================================================
--- (empty file)
+++ developer-resources/release-announcement.txt	Sat Nov  7 11:09:02 2009
@@ -0,0 +1,46 @@
+Subject: [ANNOUNCE] ABCL 0.17.0 released
+
+
+
+On behalf of the developers of ABCL (Armed Bear Common Lisp) I'm glad to
+be able to announce the 0.17.0 release. ABCL is a Common Lisp
+implementation implemented in Java and running on the JVM, featuring
+both an interpreter and a compiler. The compiler targets the JVM directly
+meaning that its output is runnable JVM bytecode. The fact that ABCL is
+written in Java allows for relatively easy embedding in larger applications.
+For integration with existing applications ABCL implements JSR-223.
+
+
+This release features - among lots of other things - performance improvements,
+a fix for unexpected thread termination due to uncaught exceptions and
+example code for running ABCL on Google App Engine. You can find the full
+release notes at:
+
+ http://common-lisp.net/project/armedbear/release-notes-0.17.shtml
+
+If you have questions regarding use or licensing, or you find issues, please
+report back to the development list:
+
+ armedbear-devel at common-lisp dot net
+
+
+Source distribution archives can be downloaded in ZIP or gzipped tar form:
+
+ http://common-lisp.net/project/armedbear/releases/abcl-src-0.17.0.tar.gz
+ http://common-lisp.net/project/armedbear/releases/abcl-src-0.17.0.zip
+
+Signatures are available under:
+ http://common-lisp.net/project/armedbear/releases/abcl-src-0.17.0.tar.gz.asc
+ http://common-lisp.net/project/armedbear/releases/abcl-src-0.17.0.zip.asc
+
+
+
+In addition, binaries are also available:
+
+ http://common-lisp.net/project/armedbear/releases/abcl-bin-0.17.0.tar.gz
+ http://common-lisp.net/project/armedbear/releases/abcl-bin-0.17.0.zip
+
+With associated signatures:
+ http://common-lisp.net/project/armedbear/releases/abcl-bin-0.17.0.tar.gz.asc
+ http://common-lisp.net/project/armedbear/releases/abcl-bin-0.17.0.zip.asc
+



From ehuelsmann at common-lisp.net  Sat Nov  7 16:33:47 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 07 Nov 2009 11:33:47 -0500
Subject: [armedbear-cvs] r12270 - public_html/releases
Message-ID: <E1N6oEV-0004GY-8f@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov  7 11:33:45 2009
New Revision: 12270

Log:
Fix binary files which were without abcl.jar...

Modified:
   public_html/releases/abcl-bin-0.17.0.tar.gz
   public_html/releases/abcl-bin-0.17.0.tar.gz.asc
   public_html/releases/abcl-bin-0.17.0.zip
   public_html/releases/abcl-bin-0.17.0.zip.asc

Modified: public_html/releases/abcl-bin-0.17.0.tar.gz
==============================================================================
Binary files. No diff available.

Modified: public_html/releases/abcl-bin-0.17.0.tar.gz.asc
==============================================================================
--- public_html/releases/abcl-bin-0.17.0.tar.gz.asc	(original)
+++ public_html/releases/abcl-bin-0.17.0.tar.gz.asc	Sat Nov  7 11:33:45 2009
@@ -1,7 +1,7 @@
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.9 (GNU/Linux)
 
-iEYEABECAAYFAkr1cb4ACgkQi5O0Epaz9TlrSgCeL8+6FkSYYiibYM5idUyqRzzw
-bkYAnjkvDYVqju/QKAHFL8PKiasqM+zV
-=7t1P
+iEYEABECAAYFAkr1oD4ACgkQi5O0Epaz9Tm51QCfQdBdOd1smRCHEA6TEVqIc2zv
+bT8An1FPXapGzkLhiltPljcaLFykKAFl
+=d4Ef
 -----END PGP SIGNATURE-----

Modified: public_html/releases/abcl-bin-0.17.0.zip
==============================================================================
Binary files. No diff available.

Modified: public_html/releases/abcl-bin-0.17.0.zip.asc
==============================================================================
--- public_html/releases/abcl-bin-0.17.0.zip.asc	(original)
+++ public_html/releases/abcl-bin-0.17.0.zip.asc	Sat Nov  7 11:33:45 2009
@@ -1,7 +1,7 @@
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.9 (GNU/Linux)
 
-iEYEABECAAYFAkr1cccACgkQi5O0Epaz9TlHhgCfQF3A7A0NUBCadRBtZmpPz87P
-g1sAnjVlsx3yPvbhmPnCwfinFq8PGfQQ
-=Tcfo
+iEYEABECAAYFAkr1oEUACgkQi5O0Epaz9Tm9SgCdEdx2AkSC4crvlBMhu+yOt8rh
++c4AnAyJ6MmS83HVSVADnTd4Wxdw8QM0
+=muG4
 -----END PGP SIGNATURE-----



From ehuelsmann at common-lisp.net  Sun Nov  8 11:28:41 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sun, 08 Nov 2009 06:28:41 -0500
Subject: [armedbear-cvs] r12271 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N75wm-0007RS-VA@common-lisp.net>

Author: ehuelsmann
Date: Sun Nov  8 06:28:34 2009
New Revision: 12271

Log:
Add documentation to ControlTransfer and inherit ThreadDestroyed from Error.

Modified:
   trunk/abcl/src/org/armedbear/lisp/ControlTransfer.java
   trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java

Modified: trunk/abcl/src/org/armedbear/lisp/ControlTransfer.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ControlTransfer.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ControlTransfer.java	Sun Nov  8 06:28:34 2009
@@ -33,11 +33,27 @@
 
 package org.armedbear.lisp;
 
+/** This class is the parent class of all non-local transfer of
+ * control events in ABCL. The classes inheriting from this class each
+ * represent a transfer of control event as it is available in the
+ * standard: GO (represented by Go), RETURN (by Return) and THROW (by Throw).
+ *
+ * Please note that you should <b>only</b> be using these classes in case
+ * you've establisched a corresponding TAGBODY, BLOCK or CATCH-like
+ * construct in your code.
+ *
+ * Otherwise, be aware that if you are mixing Lisp and Java code,
+ * Lisp code being called into might throw one of the three exception types
+ * and cause execution to be transferred to the nearest handler - presumably
+ * outside your Java code.
+ *
+ */
 abstract public class ControlTransfer extends RuntimeException
 {
     public ControlTransfer()
     {
     }
+    
     /**
      * Overridden in order to make ControlTransfer construct
      * faster. This avoids gathering stack trace information.
@@ -45,7 +61,7 @@
     @Override
     public Throwable fillInStackTrace()
     {
-	return this;
+        return this;
     }
 
     public ControlTransfer(String message)

Modified: trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ThreadDestroyed.java	Sun Nov  8 06:28:34 2009
@@ -33,20 +33,10 @@
 
 package org.armedbear.lisp;
 
-public class ThreadDestroyed extends ControlTransfer
+public class ThreadDestroyed extends Error
 {
     public ThreadDestroyed()
     {
     }
 
-    public ThreadDestroyed(String message)
-    {
-        super(message);
-    }
-
-    @Override
-    public LispObject getCondition()
-    {
-        return new ControlError("Thread destroyed.");
-    }
 }



From ehuelsmann at common-lisp.net  Sun Nov  8 22:37:22 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sun, 08 Nov 2009 17:37:22 -0500
Subject: [armedbear-cvs] r12272 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N7GNu-0001MO-QG@common-lisp.net>

Author: ehuelsmann
Date: Sun Nov  8 17:37:19 2009
New Revision: 12272

Log:
Implement functional (declared final) interface to special bindings state unwinding
in preparation of an experiment to make our special binding access work like SBCL/CCL
with an array of "currently valid" special values. 

Note: FASL version increase is not required: the old way still works.

Added:
   trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java
Modified:
   trunk/abcl/src/org/armedbear/lisp/AbstractArray.java
   trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
   trunk/abcl/src/org/armedbear/lisp/Autoload.java
   trunk/abcl/src/org/armedbear/lisp/Closure.java
   trunk/abcl/src/org/armedbear/lisp/Cons.java
   trunk/abcl/src/org/armedbear/lisp/Do.java
   trunk/abcl/src/org/armedbear/lisp/Function.java
   trunk/abcl/src/org/armedbear/lisp/Interpreter.java
   trunk/abcl/src/org/armedbear/lisp/Lisp.java
   trunk/abcl/src/org/armedbear/lisp/LispThread.java
   trunk/abcl/src/org/armedbear/lisp/Load.java
   trunk/abcl/src/org/armedbear/lisp/Primitives.java
   trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java
   trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
   trunk/abcl/src/org/armedbear/lisp/Stream.java
   trunk/abcl/src/org/armedbear/lisp/Symbol.java
   trunk/abcl/src/org/armedbear/lisp/TypeError.java
   trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java
   trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java
   trunk/abcl/src/org/armedbear/lisp/arglist.java
   trunk/abcl/src/org/armedbear/lisp/compiler-pass2.lisp
   trunk/abcl/src/org/armedbear/lisp/dolist.java
   trunk/abcl/src/org/armedbear/lisp/dotimes.java

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractArray.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractArray.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractArray.java	Sun Nov  8 17:37:19 2009
@@ -258,7 +258,7 @@
                 _CURRENT_PRINT_LEVEL_.symbolValue(thread);
             int currentLevel = Fixnum.getValue(currentPrintLevel);
             if (currentLevel < maxLevel) {
-                SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                final SpecialBindingsMark mark = thread.markSpecialBindings();
                 thread.bindSpecial(_CURRENT_PRINT_LEVEL_, currentPrintLevel.incr());
                 try {
                     sb.append('(');
@@ -281,7 +281,7 @@
                     sb.append(')');
                 }
                 finally {
-                    thread.lastSpecialBinding = lastSpecialBinding;
+                    thread.resetSpecialBindings(mark);
                 }
             } else
                 sb.append('#');

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractVector.java	Sun Nov  8 17:37:19 2009
@@ -244,7 +244,7 @@
               maxLength = ((Fixnum)printLength).value;
             final int length = length();
             final int limit = Math.min(length, maxLength);
-            SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+            final SpecialBindingsMark mark = thread.markSpecialBindings();
             thread.bindSpecial(_CURRENT_PRINT_LEVEL_, currentPrintLevel.incr());
             try
               {
@@ -257,7 +257,7 @@
               }
             finally
               {
-                thread.lastSpecialBinding = lastSpecialBinding;
+                thread.resetSpecialBindings(mark);
               }
             if (limit < length)
               sb.append(limit > 0 ? " ..." : "...");

Modified: trunk/abcl/src/org/armedbear/lisp/Autoload.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Autoload.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Autoload.java	Sun Nov  8 17:37:19 2009
@@ -97,7 +97,7 @@
     {
         if (className != null) {
             final LispThread thread = LispThread.currentThread();
-            final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+            final SpecialBindingsMark mark = thread.markSpecialBindings();
             int loadDepth = Fixnum.getValue(_LOAD_DEPTH_.symbolValue());
             thread.bindSpecial(_LOAD_DEPTH_, Fixnum.getInstance(++loadDepth));
             try {
@@ -128,7 +128,7 @@
                 e.printStackTrace();
             }
             finally {
-                thread.lastSpecialBinding = lastSpecialBinding;
+                thread.resetSpecialBindings(mark);
             }
         } else
             Load.loadSystemFile(getFileName(), true);

Modified: trunk/abcl/src/org/armedbear/lisp/Closure.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Closure.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Closure.java	Sun Nov  8 17:37:19 2009
@@ -387,7 +387,7 @@
 
   {
     final LispThread thread = LispThread.currentThread();
-    final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     Environment ext = new Environment(environment);
     bindRequiredParameters(ext, thread, objects);
     if (arity != minArgs)
@@ -405,7 +405,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
       }
   }
 
@@ -581,7 +581,7 @@
   public LispObject execute(LispObject[] args)
   {
     final LispThread thread = LispThread.currentThread();
-    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     Environment ext = new Environment(environment);
     if (optionalParameters.length == 0 && keywordParameters.length == 0)
       args = fastProcessArgs(args);
@@ -605,7 +605,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
       }
   }
 
@@ -630,7 +630,7 @@
     // The bindings established here (if any) are lost when this function
     // returns. They are used only in the evaluation of initforms for
     // optional and keyword arguments.
-    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     Environment ext = new Environment(environment);
     // Section 3.4.4: "...the &environment parameter is bound along with
     // &whole before any other variables in the lambda list..."
@@ -864,7 +864,7 @@
           }
     }
     finally {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
     }
     return array;
   }

Modified: trunk/abcl/src/org/armedbear/lisp/Cons.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Cons.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Cons.java	Sun Nov  8 17:37:19 2009
@@ -654,7 +654,7 @@
     int currentLevel = Fixnum.getValue(currentPrintLevel);
     if (currentLevel < maxLevel)
       {
-        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         thread.bindSpecial(_CURRENT_PRINT_LEVEL_, currentPrintLevel.incr());
         try
           {
@@ -694,7 +694,7 @@
           }
         finally
           {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
           }
       }
     else

Modified: trunk/abcl/src/org/armedbear/lisp/Do.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Do.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Do.java	Sun Nov  8 17:37:19 2009
@@ -93,7 +93,7 @@
         varlist = varlist.cdr();
       }
     final LispThread thread = LispThread.currentThread();
-    final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     // Process declarations.
 
     final LispObject bodyAndDecls = parseBody(body, false);
@@ -197,7 +197,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
         ext.inactive = true;
       }
   }

Modified: trunk/abcl/src/org/armedbear/lisp/Function.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Function.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Function.java	Sun Nov  8 17:37:19 2009
@@ -273,13 +273,13 @@
                 sb.append("()");
             } else {
                 final LispThread thread = LispThread.currentThread();
-                SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                final SpecialBindingsMark mark = thread.markSpecialBindings();
                 thread.bindSpecial(Symbol.PRINT_LENGTH, Fixnum.THREE);
                 try {
                     sb.append(lambdaList.writeToString());
                 }
                 finally {
-                    thread.lastSpecialBinding = lastSpecialBinding;
+                    thread.resetSpecialBindings(mark);
                 }
             }
             sb.append(")");

Modified: trunk/abcl/src/org/armedbear/lisp/Interpreter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Interpreter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Interpreter.java	Sun Nov  8 17:37:19 2009
@@ -325,7 +325,7 @@
             while (true) {
                 try {
                     thread.resetStack();
-                    thread.lastSpecialBinding = null;
+                    thread.clearSpecialBindings();
                     out._writeString("* ");
                     out._finishOutput();
                     LispObject object =
@@ -475,7 +475,7 @@
             final Condition condition = (Condition) first;
             if (interpreter == null) {
                 final LispThread thread = LispThread.currentThread();
-                final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                final SpecialBindingsMark mark = thread.markSpecialBindings();
                 thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
                 try {
                     final LispObject truename =
@@ -500,7 +500,7 @@
                 }
                 catch (Throwable t) {}
                 finally {
-                    thread.lastSpecialBinding = lastSpecialBinding;
+                    thread.resetSpecialBindings(mark);
                 }
             }
             throw new UnhandledCondition(condition);
@@ -535,13 +535,13 @@
         LispObject obj = stream.read(false, EOF, false, thread);
         if (obj == EOF)
             return error(new EndOfFile(stream));
-        final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         thread.bindSpecial(Symbol.DEBUGGER_HOOK, _DEBUGGER_HOOK_FUNCTION);
         try {
             return eval(obj, new Environment(), thread);
         }
         finally {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
         }
     }
 

Modified: trunk/abcl/src/org/armedbear/lisp/Lisp.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Lisp.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Lisp.java	Sun Nov  8 17:37:19 2009
@@ -2028,11 +2028,15 @@
                     if (j < args.length)
                       {
                         LispObject obj = args[j++];
-                        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                        final SpecialBindingsMark mark = thread.markSpecialBindings();
                         thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
                         thread.bindSpecial(Symbol.PRINT_READABLY, NIL);
-                        sb.append(obj.writeToString());
-                        thread.lastSpecialBinding = lastSpecialBinding;
+                        try {
+                            sb.append(obj.writeToString());
+                        }
+                        finally {
+                            thread.resetSpecialBindings(mark);
+                        }
                       }
                   }
                 else if (c == 'S' || c == 's')
@@ -2040,13 +2044,13 @@
                     if (j < args.length)
                       {
                         LispObject obj = args[j++];
-                        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                        final SpecialBindingsMark mark = thread.markSpecialBindings();
                         thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
                         try {
                             sb.append(obj.writeToString());
                         }
                         finally {
-                            thread.lastSpecialBinding = lastSpecialBinding;
+                            thread.resetSpecialBindings(mark);
                         }
                       }
                   }
@@ -2055,7 +2059,7 @@
                     if (j < args.length)
                       {
                         LispObject obj = args[j++];
-                        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                        final SpecialBindingsMark mark = thread.markSpecialBindings();
                         thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
                         thread.bindSpecial(Symbol.PRINT_RADIX, NIL);
                         thread.bindSpecial(Symbol.PRINT_BASE, Fixnum.constants[10]);
@@ -2063,7 +2067,7 @@
                             sb.append(obj.writeToString());
                         }
                         finally {
-                            thread.lastSpecialBinding = lastSpecialBinding;
+                            thread.resetSpecialBindings(mark);
                         }
                       }
                   }
@@ -2072,7 +2076,7 @@
                     if (j < args.length)
                       {
                         LispObject obj = args[j++];
-                        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                        final SpecialBindingsMark mark = thread.markSpecialBindings();
                         thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
                         thread.bindSpecial(Symbol.PRINT_RADIX, NIL);
                         thread.bindSpecial(Symbol.PRINT_BASE, Fixnum.constants[16]);
@@ -2080,7 +2084,7 @@
                             sb.append(obj.writeToString());
                         }
                         finally {
-                            thread.lastSpecialBinding = lastSpecialBinding;
+                            thread.resetSpecialBindings(mark);
                         }
                       }
                   }

Modified: trunk/abcl/src/org/armedbear/lisp/LispThread.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispThread.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispThread.java	Sun Nov  8 17:37:19 2009
@@ -306,6 +306,29 @@
         return obj;
     }
 
+    /** Marks the state of the special bindings,
+     * for later rewinding by resetSpecialBindings().
+     */
+    public final SpecialBindingsMark markSpecialBindings() {
+        return new SpecialBindingsMark(lastSpecialBinding);
+    }
+
+    /** Restores the state of the special bindings to what
+     * was captured in the marker 'mark' by a call to markSpecialBindings().
+     */
+    public final void resetSpecialBindings(SpecialBindingsMark mark) {
+        lastSpecialBinding = mark.binding;
+    }
+
+    /** Clears out all active special bindings including any marks
+     * previously set. Invoking resetSpecialBindings() with marks
+     * set before this call results in undefined behaviour.
+     */
+    // Package level access: only for Interpreter.run()
+    final void clearSpecialBindings() {
+        lastSpecialBinding = null;
+    }
+
     public final SpecialBinding bindSpecial(Symbol name, LispObject value)
     {
         return lastSpecialBinding

Modified: trunk/abcl/src/org/armedbear/lisp/Load.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Load.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Load.java	Sun Nov  8 17:37:19 2009
@@ -282,7 +282,7 @@
     {
         LispThread thread = LispThread.currentThread();
         if (auto) {
-            SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+            final SpecialBindingsMark mark = thread.markSpecialBindings();
             thread.bindSpecial(Symbol.CURRENT_READTABLE,
                                STANDARD_READTABLE.symbolValue(thread));
             thread.bindSpecial(Symbol._PACKAGE_, PACKAGE_CL_USER);
@@ -293,7 +293,7 @@
                                       auto);
             }
             finally {
-                thread.lastSpecialBinding = lastSpecialBinding;
+                thread.resetSpecialBindings(mark);
             }
         } else {
             return loadSystemFile(filename,
@@ -386,7 +386,7 @@
                 }
                 if (in != null) {
                     final LispThread thread = LispThread.currentThread();
-                    final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                    final SpecialBindingsMark mark = thread.markSpecialBindings();
                     thread.bindSpecial(_WARN_ON_REDEFINITION_, NIL);
                     try {
                         return loadFileFromStream(pathname, truename,
@@ -400,7 +400,7 @@
                         System.err.println(sb.toString());
                     }
                     finally {
-                        thread.lastSpecialBinding = lastSpecialBinding;
+                        thread.resetSpecialBindings(mark);
                         try {
                             in.close();
                         }
@@ -481,7 +481,7 @@
     {
         long start = System.currentTimeMillis();
         final LispThread thread = LispThread.currentThread();
-        final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         // "LOAD binds *READTABLE* and *PACKAGE* to the values they held before
         // loading the file."
         thread.bindSpecialToCurrentValue(Symbol.CURRENT_READTABLE);
@@ -527,7 +527,7 @@
                 return loadStream(in, print, thread, returnLastResult);
         }
         finally {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
         }
     }
 
@@ -549,12 +549,10 @@
                                                LispThread thread, boolean returnLastResult)
 
     {
-        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         thread.bindSpecial(_LOAD_STREAM_, in);
         SpecialBinding sourcePositionBinding =
-            new SpecialBinding(_SOURCE_POSITION_, Fixnum.ZERO,
-                               thread.lastSpecialBinding);
-        thread.lastSpecialBinding = sourcePositionBinding;
+            thread.bindSpecial(_SOURCE_POSITION_, Fixnum.ZERO);
         try {
             final Environment env = new Environment();
             LispObject result = NIL;
@@ -578,7 +576,7 @@
             }
         }
         finally {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
         }
     }
 
@@ -587,7 +585,7 @@
     {
         Stream in = (Stream) _LOAD_STREAM_.symbolValue(thread);
         final Environment env = new Environment();
-        final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         LispObject result = NIL;
         try {
             thread.bindSpecial(_FASL_ANONYMOUS_PACKAGE_, new Package());
@@ -599,7 +597,7 @@
             }
         }
         finally {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
         }
         return result;
         //There's no point in using here the returnLastResult flag like in

Modified: trunk/abcl/src/org/armedbear/lisp/Primitives.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Primitives.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Primitives.java	Sun Nov  8 17:37:19 2009
@@ -1642,7 +1642,7 @@
                   }
                 else
                   {
-                    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                    SpecialBindingsMark mark = thread.markSpecialBindings();
                     thread.bindSpecial(Symbol._PACKAGE_, PACKAGE_CL);
                     try
                       {
@@ -1651,7 +1651,7 @@
                       }
                     finally
                       {
-                        thread.lastSpecialBinding = lastSpecialBinding;
+                        thread.resetSpecialBindings(mark);
                       }
                   }
               }
@@ -3458,7 +3458,7 @@
       {
         LispObject defs = checkList(args.car());
         final LispThread thread = LispThread.currentThread();
-        final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
 
         try
           {
@@ -3481,7 +3481,7 @@
           }
         finally
           {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
           }
       }
     };
@@ -3748,7 +3748,7 @@
         LispObject specials = parseSpecials(bodyAndDecls.NTH(1));
         body = bodyAndDecls.car();
 
-        final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         final Environment ext = new Environment(env);
         int i = 0;
         LispObject var = vars.car();
@@ -3792,7 +3792,7 @@
           }
         finally
           {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
           }
         return result;
       }

Modified: trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java	Sun Nov  8 17:37:19 2009
@@ -89,7 +89,7 @@
         }
         if (object != UNBOUND_VALUE) {
             final LispThread thread = LispThread.currentThread();
-            final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+            final SpecialBindingsMark mark = thread.markSpecialBindings();
             thread.bindSpecial(Symbol.PRINT_READABLY, NIL);
             thread.bindSpecial(Symbol.PRINT_ARRAY, NIL);
             try {
@@ -99,7 +99,7 @@
                 sb.append("Object");
             }
             finally {
-                thread.lastSpecialBinding = lastSpecialBinding;
+                thread.resetSpecialBindings(mark);
             }
         } else
             sb.append("Object");

Added: trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java
==============================================================================
--- (empty file)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java	Sun Nov  8 17:37:19 2009
@@ -0,0 +1,51 @@
+/*
+ * SpecialBindingsMark.java
+ *
+ * Copyright (C) 1009 Erik Huelsmann
+ * $Id: LispThread.java 12255 2009-11-06 22:36:32Z ehuelsmann $
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * As a special exception, the copyright holders of this library give you
+ * permission to link this library with independent modules to produce an
+ * executable, regardless of the license terms of these independent
+ * modules, and to copy and distribute the resulting executable under
+ * terms of your choice, provided that you also meet, for each linked
+ * independent module, the terms and conditions of the license of that
+ * module.  An independent module is a module which is not derived from
+ * or based on this library.  If you modify this library, you may extend
+ * this exception to your version of the library, but you are not
+ * obligated to do so.  If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+package org.armedbear.lisp;
+
+/** Class used to mark special bindings state.
+ * Returned by LispThread.markSpecialBindings() and consumed by
+ * LispThread.resetSpecialBindings() to abstract from the implementation.
+ */
+final public class SpecialBindingsMark {
+
+    /** Special binding state to be restored */
+    // package level access
+    SpecialBinding binding;
+
+    /** Constructor to be called by LispThread.markSpecialBindings() only */
+    // package level access
+    SpecialBindingsMark(SpecialBinding binding) {
+        this.binding = binding;
+    }
+}
\ No newline at end of file

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java	Sun Nov  8 17:37:19 2009
@@ -114,7 +114,7 @@
 
   {
     final LispThread thread = LispThread.currentThread();
-    final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     try
       {
         LispObject varList = checkList(args.car());
@@ -166,7 +166,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
       }
   }
 
@@ -180,7 +180,7 @@
       {
         LispObject varList = checkList(args.car());
         final LispThread thread = LispThread.currentThread();
-        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         Environment ext = new Environment(env);
         try
          {
@@ -215,7 +215,7 @@
               }
         finally
             {
-                thread.lastSpecialBinding = lastSpecialBinding;
+              thread.resetSpecialBindings(mark);
             }
       }
     };
@@ -300,7 +300,7 @@
     // First argument is a list of local function definitions.
     LispObject defs = checkList(args.car());
     final LispThread thread = LispThread.currentThread();
-    final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     final Environment funEnv = new Environment(env);
     while (defs != NIL)
       {
@@ -357,7 +357,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
       }
   }
 
@@ -409,7 +409,7 @@
         final LispThread thread = LispThread.currentThread();
         final LispObject symbols = checkList(eval(args.car(), env, thread));
         LispObject values = checkList(eval(args.cadr(), env, thread));
-        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         try
           {
             // Set up the new bindings.
@@ -419,7 +419,7 @@
           }
         finally
           {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
           }
       }
     };

Modified: trunk/abcl/src/org/armedbear/lisp/Stream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Stream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Stream.java	Sun Nov  8 17:37:19 2009
@@ -468,7 +468,7 @@
       }
     else
       {
-        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         thread.bindSpecial(_SHARP_EQUAL_ALIST_, NIL);
         try
           {
@@ -476,7 +476,7 @@
           }
         finally
           {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
           }
       }
   }
@@ -543,7 +543,7 @@
       }
     else
       {
-        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         thread.bindSpecial(_SHARP_EQUAL_ALIST_, NIL);
         try
           {
@@ -551,7 +551,7 @@
           }
         finally
           {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
           }
       }
   }
@@ -1841,7 +1841,7 @@
   public void prin1(LispObject obj)
   {
     LispThread thread = LispThread.currentThread();
-    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
     try
       {
@@ -1849,7 +1849,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
       }
   }
 

Modified: trunk/abcl/src/org/armedbear/lisp/Symbol.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Symbol.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Symbol.java	Sun Nov  8 17:37:19 2009
@@ -107,7 +107,7 @@
   public LispObject getDescription()
   {
     final LispThread thread = LispThread.currentThread();
-    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
     try
       {
@@ -128,7 +128,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
       }
   }
 

Modified: trunk/abcl/src/org/armedbear/lisp/TypeError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/TypeError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/TypeError.java	Sun Nov  8 17:37:19 2009
@@ -130,7 +130,7 @@
         // FIXME
         try {
             final LispThread thread = LispThread.currentThread();
-            final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+            final SpecialBindingsMark mark = thread.markSpecialBindings();
             thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
             try {
                 String s = super.getMessage();
@@ -164,7 +164,7 @@
                 return toString();
             }
             finally {
-                thread.lastSpecialBinding = lastSpecialBinding;
+                thread.resetSpecialBindings(mark);
             }
         }
         catch (Throwable t) {

Modified: trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java	Sun Nov  8 17:37:19 2009
@@ -70,7 +70,7 @@
     public String getMessage()
     {
         final LispThread thread = LispThread.currentThread();
-        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+        final SpecialBindingsMark mark = thread.markSpecialBindings();
         thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
         try {
             FastStringBuffer sb = new FastStringBuffer("The slot ");
@@ -81,7 +81,7 @@
             return sb.toString();
         }
         finally {
-            thread.lastSpecialBinding = lastSpecialBinding;
+            thread.resetSpecialBindings(mark);
         }
     }
 

Modified: trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java	Sun Nov  8 17:37:19 2009
@@ -49,7 +49,7 @@
   public String getMessage()
   {
     LispThread thread = LispThread.currentThread();
-    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
     StringBuffer sb = new StringBuffer("The variable ");
     // FIXME
@@ -59,7 +59,7 @@
       }
     catch (Throwable t) {}
     finally {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
     }
     sb.append(" is unbound.");
     return sb.toString();

Modified: trunk/abcl/src/org/armedbear/lisp/arglist.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/arglist.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/arglist.java	Sun Nov  8 17:37:19 2009
@@ -81,13 +81,13 @@
                 s = "(" + s + ")";
                 // Bind *PACKAGE* so we use the EXT package if we need
                 // to intern any symbols.
-                SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+                final SpecialBindingsMark mark = thread.markSpecialBindings();
                 thread.bindSpecial(Symbol._PACKAGE_, PACKAGE_EXT);
                 try {
                     arglist = readObjectFromString(s);
                 }
                 finally {
-                    thread.lastSpecialBinding = lastSpecialBinding;
+                    thread.resetSpecialBindings(mark);
                 }
                 operator.setLambdaList(arglist);
             }

Modified: trunk/abcl/src/org/armedbear/lisp/compiler-pass2.lisp
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/compiler-pass2.lisp	(original)
+++ trunk/abcl/src/org/armedbear/lisp/compiler-pass2.lisp	Sun Nov  8 17:37:19 2009
@@ -239,6 +239,8 @@
 (defconstant +lisp-environment-class+ "org/armedbear/lisp/Environment")
 (defconstant +lisp-special-binding+ "Lorg/armedbear/lisp/SpecialBinding;")
 (defconstant +lisp-special-binding-class+ "org/armedbear/lisp/SpecialBinding")
+(defconstant +lisp-special-bindings-mark+ "Lorg/armedbear/lisp/SpecialBindingsMark;")
+(defconstant +lisp-special-bindings-mark-class+ "org/armedbear/lisp/SpecialBindingsMark")
 (defconstant +lisp-throw-class+ "org/armedbear/lisp/Throw")
 (defconstant +lisp-return-class+ "org/armedbear/lisp/Return")
 (defconstant +lisp-go-class+ "org/armedbear/lisp/Go")
@@ -4046,16 +4048,22 @@
   t)
 
 (defun restore-dynamic-environment (register)
-  (emit-push-current-thread)
-  (aload register)
-  (emit 'putfield +lisp-thread-class+ "lastSpecialBinding"
-	+lisp-special-binding+))
+   (emit-push-current-thread)
+   (aload register)
+;;   (emit 'putfield +lisp-thread-class+ "lastSpecialBinding"
+;; 	+lisp-special-binding+)
+   (emit-invokevirtual +lisp-thread-class+ "resetSpecialBindings"
+                       (list +lisp-special-bindings-mark+) nil)
+  )
 
 (defun save-dynamic-environment (register)
-  (emit-push-current-thread)
-  (emit 'getfield +lisp-thread-class+ "lastSpecialBinding"
-	+lisp-special-binding+)
-  (astore register))
+   (emit-push-current-thread)
+;;   (emit 'getfield +lisp-thread-class+ "lastSpecialBinding"
+;; 	+lisp-special-binding+)
+   (emit-invokevirtual +lisp-thread-class+ "markSpecialBindings"
+                       nil +lisp-special-bindings-mark+)
+   (astore register)
+  )
 
 (defun restore-environment-and-make-handler (register label-START)
   (let ((label-END (gensym))

Modified: trunk/abcl/src/org/armedbear/lisp/dolist.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/dolist.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/dolist.java	Sun Nov  8 17:37:19 2009
@@ -51,7 +51,7 @@
     LispObject listForm = args.cadr();
     final LispThread thread = LispThread.currentThread();
     LispObject resultForm = args.cdr().cdr().car();
-    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
     // Process declarations.
     LispObject bodyAndDecls = parseBody(bodyForm, false);
     LispObject specials = parseSpecials(bodyAndDecls.NTH(1));
@@ -121,7 +121,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
         ext.inactive = true;
       }
   }

Modified: trunk/abcl/src/org/armedbear/lisp/dotimes.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/dotimes.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/dotimes.java	Sun Nov  8 17:37:19 2009
@@ -50,7 +50,7 @@
     LispObject countForm = args.cadr();
     final LispThread thread = LispThread.currentThread();
     LispObject resultForm = args.cdr().cdr().car();
-    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
+    final SpecialBindingsMark mark = thread.markSpecialBindings();
 
     LispObject bodyAndDecls = parseBody(bodyForm, false);
     LispObject specials = parseSpecials(bodyAndDecls.NTH(1));
@@ -147,7 +147,7 @@
       }
     finally
       {
-        thread.lastSpecialBinding = lastSpecialBinding;
+        thread.resetSpecialBindings(mark);
         ext.inactive = true;
       }
   }



From ehuelsmann at common-lisp.net  Sun Nov  8 22:57:04 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sun, 08 Nov 2009 17:57:04 -0500
Subject: [armedbear-cvs] r12273 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N7Ggy-0002RS-CO@common-lisp.net>

Author: ehuelsmann
Date: Sun Nov  8 17:57:03 2009
New Revision: 12273

Log:
Set proper properties on newly added file.

Modified:
   trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java   (contents, props changed)

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java	Sun Nov  8 17:57:03 2009
@@ -1,51 +1,51 @@
-/*
- * SpecialBindingsMark.java
- *
- * Copyright (C) 1009 Erik Huelsmann
- * $Id: LispThread.java 12255 2009-11-06 22:36:32Z ehuelsmann $
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program 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 for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
- *
- * As a special exception, the copyright holders of this library give you
- * permission to link this library with independent modules to produce an
- * executable, regardless of the license terms of these independent
- * modules, and to copy and distribute the resulting executable under
- * terms of your choice, provided that you also meet, for each linked
- * independent module, the terms and conditions of the license of that
- * module.  An independent module is a module which is not derived from
- * or based on this library.  If you modify this library, you may extend
- * this exception to your version of the library, but you are not
- * obligated to do so.  If you do not wish to do so, delete this
- * exception statement from your version.
- */
-
-package org.armedbear.lisp;
-
-/** Class used to mark special bindings state.
- * Returned by LispThread.markSpecialBindings() and consumed by
- * LispThread.resetSpecialBindings() to abstract from the implementation.
- */
-final public class SpecialBindingsMark {
-
-    /** Special binding state to be restored */
-    // package level access
-    SpecialBinding binding;
-
-    /** Constructor to be called by LispThread.markSpecialBindings() only */
-    // package level access
-    SpecialBindingsMark(SpecialBinding binding) {
-        this.binding = binding;
-    }
+/*
+ * SpecialBindingsMark.java
+ *
+ * Copyright (C) 1009 Erik Huelsmann
+ * $Id$
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * As a special exception, the copyright holders of this library give you
+ * permission to link this library with independent modules to produce an
+ * executable, regardless of the license terms of these independent
+ * modules, and to copy and distribute the resulting executable under
+ * terms of your choice, provided that you also meet, for each linked
+ * independent module, the terms and conditions of the license of that
+ * module.  An independent module is a module which is not derived from
+ * or based on this library.  If you modify this library, you may extend
+ * this exception to your version of the library, but you are not
+ * obligated to do so.  If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+package org.armedbear.lisp;
+
+/** Class used to mark special bindings state.
+ * Returned by LispThread.markSpecialBindings() and consumed by
+ * LispThread.resetSpecialBindings() to abstract from the implementation.
+ */
+final public class SpecialBindingsMark {
+
+    /** Special binding state to be restored */
+    // package level access
+    SpecialBinding binding;
+
+    /** Constructor to be called by LispThread.markSpecialBindings() only */
+    // package level access
+    SpecialBindingsMark(SpecialBinding binding) {
+        this.binding = binding;
+    }
 }
\ No newline at end of file



From ehuelsmann at common-lisp.net  Tue Nov 10 19:34:21 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Tue, 10 Nov 2009 14:34:21 -0500
Subject: [armedbear-cvs] r12274 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N7wTt-000463-IL@common-lisp.net>

Author: ehuelsmann
Date: Tue Nov 10 14:34:18 2009
New Revision: 12274

Log:
Convert some uses of LispObject to Symbol.

Modified:
   trunk/abcl/src/org/armedbear/lisp/Environment.java
   trunk/abcl/src/org/armedbear/lisp/Lisp.java

Modified: trunk/abcl/src/org/armedbear/lisp/Environment.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Environment.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Environment.java	Tue Nov 10 14:34:18 2009
@@ -235,7 +235,7 @@
      * If there is no binding in the current (lexical) environment,
      * the current dynamic environment (thread) is checked.
      */
-  public boolean isDeclaredSpecial(LispObject var)
+  public boolean isDeclaredSpecial(Symbol var)
   {
     Binding binding = getBinding(var);
     return (binding != null) ? binding.specialp :

Modified: trunk/abcl/src/org/armedbear/lisp/Lisp.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Lisp.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Lisp.java	Tue Nov 10 14:34:18 2009
@@ -423,21 +423,22 @@
       throw new ThreadDestroyed();
     if (obj instanceof Symbol)
       {
+        Symbol symbol = (Symbol)obj;
         LispObject result;
-        if (obj.isSpecialVariable())
+        if (symbol.isSpecialVariable())
           {
-            if (obj.constantp())
-              return obj.getSymbolValue();
+            if (symbol.constantp())
+              return symbol.getSymbolValue();
             else
-              result = thread.lookupSpecial(obj);
+              result = thread.lookupSpecial(symbol);
           }
-        else if (env.isDeclaredSpecial(obj))
-          result = thread.lookupSpecial(obj);
+        else if (env.isDeclaredSpecial(symbol))
+          result = thread.lookupSpecial(symbol);
         else
-          result = env.lookup(obj);
+          result = env.lookup(symbol);
         if (result == null)
           {
-            result = obj.getSymbolValue();
+            result = symbol.getSymbolValue();
             if (result == null)
               return error(new UnboundVariable(obj));
           }



From ehuelsmann at common-lisp.net  Tue Nov 10 19:45:39 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Tue, 10 Nov 2009 14:45:39 -0500
Subject: [armedbear-cvs] r12275 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N7wep-0005r4-GW@common-lisp.net>

Author: ehuelsmann
Date: Tue Nov 10 14:45:37 2009
New Revision: 12275

Log:
Switch special bindings access schema to mirror that of SBCL/CCL/XCL:
  use an array of current bindings with a linked list to store the
  bindings to be restored upon unwinding.

Note: This change means a ~40% performance increase in Maxima;
  given your application, YMMV, but since this schema trades
  efficiency of establishing and unwinding over access, you
  theoretically could see slow downs.


Modified:
   trunk/abcl/src/org/armedbear/lisp/LispThread.java
   trunk/abcl/src/org/armedbear/lisp/Load.java
   trunk/abcl/src/org/armedbear/lisp/SpecialBinding.java
   trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java
   trunk/abcl/src/org/armedbear/lisp/Symbol.java

Modified: trunk/abcl/src/org/armedbear/lisp/LispThread.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispThread.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispThread.java	Tue Nov 10 14:45:37 2009
@@ -35,6 +35,7 @@
 
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public final class LispThread extends LispObject
 {
@@ -66,7 +67,6 @@
     private final Thread javaThread;
     private boolean destroyed;
     private final LispObject name;
-    public SpecialBinding lastSpecialBinding;
     public LispObject[] _values;
     private boolean threadInterrupted;
     private LispObject pending = NIL;
@@ -306,18 +306,57 @@
         return obj;
     }
 
+
+
+    final static int UNASSIGNED_SPECIAL_INDEX = 0;
+
+    /** Indicates the last special slot which has been assigned.
+     * Symbols which don't have a special slot assigned use a slot
+     * index of 0 for efficiency reasons: it eliminates the need to
+     * check for index validity before accessing the specials array.
+     *
+     */
+    final static AtomicInteger lastSpecial
+        = new AtomicInteger(UNASSIGNED_SPECIAL_INDEX);
+
+    /** This array stores the current special binding for every symbol
+     * which has been globally or locally declared special.
+     *
+     * If the array element has a null value, this means there currently
+     * is no active binding. If the array element contains a valid
+     * SpecialBinding object, but the value field of it is null, that
+     * indicates an "UNBOUND VARIABLE" situation.
+     */
+    final SpecialBinding[] specials = new SpecialBinding[4097];
+
+    /** This array stores the symbols associated with the special
+     * bindings slots.
+     */
+    final static Symbol[] specialNames = new Symbol[4097];
+
+    /** This variable points to the head of a linked list of saved
+     * special bindings. Its main purpose is to allow a mark/reset
+     * interface to special binding and unbinding.
+     */
+    private SpecialBindingsMark savedSpecials = null;
+
     /** Marks the state of the special bindings,
      * for later rewinding by resetSpecialBindings().
      */
     public final SpecialBindingsMark markSpecialBindings() {
-        return new SpecialBindingsMark(lastSpecialBinding);
+        return savedSpecials;
     }
 
     /** Restores the state of the special bindings to what
      * was captured in the marker 'mark' by a call to markSpecialBindings().
      */
     public final void resetSpecialBindings(SpecialBindingsMark mark) {
-        lastSpecialBinding = mark.binding;
+        SpecialBindingsMark c = savedSpecials;
+        while (mark != c) {
+            specials[c.idx] = c.binding;
+            c = c.next;
+        }
+        savedSpecials = c;
     }
 
     /** Clears out all active special bindings including any marks
@@ -326,28 +365,46 @@
      */
     // Package level access: only for Interpreter.run()
     final void clearSpecialBindings() {
-        lastSpecialBinding = null;
+        resetSpecialBindings(null);
+    }
+
+    /** Assigns a specials array index number to the symbol,
+     * if it doesn't already have one.
+     */
+    private static final void assignSpecialIndex(Symbol sym)
+    {
+        if (sym.specialIndex != 0)
+            return;
+
+        synchronized (sym) {
+            // Don't use an atomic access: we'll be swapping values only once.
+            if (sym.specialIndex == 0) {
+                sym.specialIndex = lastSpecial.incrementAndGet();
+                specialNames[sym.specialIndex] = sym;
+            }
+        }
     }
 
     public final SpecialBinding bindSpecial(Symbol name, LispObject value)
     {
-        return lastSpecialBinding
-            = new SpecialBinding(name, value, lastSpecialBinding);
+        int idx;
+
+        assignSpecialIndex(name);
+        SpecialBinding binding = specials[idx = name.specialIndex];
+        savedSpecials = new SpecialBindingsMark(idx, binding, savedSpecials);
+        return specials[idx] = new SpecialBinding(idx, value);
     }
 
     public final SpecialBinding bindSpecialToCurrentValue(Symbol name)
     {
-        SpecialBinding binding = lastSpecialBinding;
-        while (binding != null) {
-            if (binding.name == name) {
-                return lastSpecialBinding =
-                    new SpecialBinding(name, binding.value, lastSpecialBinding);
-            }
-            binding = binding.next;
-        }
-        // Not found.
-        return lastSpecialBinding =
-            new SpecialBinding(name, name.getSymbolValue(), lastSpecialBinding);
+        int idx;
+
+        assignSpecialIndex(name);
+        SpecialBinding binding = specials[idx = name.specialIndex];
+        savedSpecials = new SpecialBindingsMark(idx, binding, savedSpecials);
+        return specials[idx]
+            = new SpecialBinding(idx,
+                                 (binding == null) ? null : binding.value);
     }
 
     /** Looks up the value of a special binding in the context of the
@@ -361,38 +418,23 @@
      *
      * @see Symbol#symbolValue
      */
-    public final LispObject lookupSpecial(LispObject name)
+    public final LispObject lookupSpecial(Symbol name)
     {
-        SpecialBinding binding = lastSpecialBinding;
-        while (binding != null) {
-            if (binding.name == name)
-                return binding.value;
-            binding = binding.next;
-        }
-        return null;
+        SpecialBinding binding = specials[name.specialIndex];
+        return (binding == null) ? null : binding.value;
     }
 
-    public final SpecialBinding getSpecialBinding(LispObject name)
+    public final SpecialBinding getSpecialBinding(Symbol name)
     {
-        SpecialBinding binding = lastSpecialBinding;
-        while (binding != null) {
-            if (binding.name == name)
-                return binding;
-            binding = binding.next;
-        }
-        return null;
+        return specials[name.specialIndex];
     }
 
     public final LispObject setSpecialVariable(Symbol name, LispObject value)
     {
-        SpecialBinding binding = lastSpecialBinding;
-        while (binding != null) {
-            if (binding.name == name) {
-                binding.value = value;
-                return value;
-            }
-            binding = binding.next;
-        }
+        SpecialBinding binding = specials[name.specialIndex];
+        if (binding != null)
+            return binding.value = value;
+
         name.setSymbolValue(value);
         return value;
     }
@@ -400,15 +442,10 @@
     public final LispObject pushSpecial(Symbol name, LispObject thing)
 
     {
-        SpecialBinding binding = lastSpecialBinding;
-        while (binding != null) {
-            if (binding.name == name) {
-                LispObject newValue = new Cons(thing, binding.value);
-                binding.value = newValue;
-                return newValue;
-            }
-            binding = binding.next;
-        }
+        SpecialBinding binding = specials[name.specialIndex];
+        if (binding != null)
+            return binding.value = new Cons(thing, binding.value);
+
         LispObject value = name.getSymbolValue();
         if (value != null) {
             LispObject newValue = new Cons(thing, value);
@@ -421,12 +458,10 @@
     // Returns symbol value or NIL if unbound.
     public final LispObject safeSymbolValue(Symbol name)
     {
-        SpecialBinding binding = lastSpecialBinding;
-        while (binding != null) {
-            if (binding.name == name)
-                return binding.value;
-            binding = binding.next;
-        }
+        SpecialBinding binding = specials[name.specialIndex];
+        if (binding != null)
+            return binding.value;
+
         LispObject value = name.getSymbolValue();
         return value != null ? value : NIL;
     }
@@ -479,7 +514,7 @@
     {
     }
 
-    public final void pushStackFrame(StackFrame frame) 
+    public final void pushStackFrame(StackFrame frame)
     {
 	frame.setNext(stack);
 	stack = frame;

Modified: trunk/abcl/src/org/armedbear/lisp/Load.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Load.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Load.java	Tue Nov 10 14:45:37 2009
@@ -427,7 +427,7 @@
     // ### *fasl-version*
     // internal symbol
     private static final Symbol _FASL_VERSION_ =
-        exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(33));
+        exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(34));
 
     // ### *fasl-anonymous-package*
     // internal symbol

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialBinding.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialBinding.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialBinding.java	Tue Nov 10 14:45:37 2009
@@ -33,18 +33,20 @@
 
 package org.armedbear.lisp;
 
-// Package accessibility.
 final public class SpecialBinding
 {
-    final LispObject name;
+    /** The index in the specials array of the symbol
+     *  to which this value belongs.
+     */
+    final int idx;
+
+    /** The value bound */
     public LispObject value;
-    final SpecialBinding next;
 
-    SpecialBinding(LispObject name, LispObject value, SpecialBinding next)
+    SpecialBinding(int idx, LispObject value)
     {
-        this.name = name;
+        this.idx = idx;
         this.value = value;
-        this.next = next;
     }
 
     /** Return the value of the binding,
@@ -56,8 +58,19 @@
     final public LispObject getValue()
     {
         if (value == null)
-            return Lisp.error(new UnboundVariable(name));
+            // return or not: error doesn't return anyway
+            Lisp.error(new UnboundVariable(LispThread.specialNames[idx]));
 
         return value;
     }
+
+    /** Sets the value of the binding.
+     *
+     * Note: this method can only be called when the
+     *    binding is the one which is currently visible.
+     */
+    final public void setValue(LispObject value)
+    {
+        this.value = value;
+    }
 }

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialBindingsMark.java	Tue Nov 10 14:45:37 2009
@@ -39,13 +39,20 @@
  */
 final public class SpecialBindingsMark {
 
+    /** The index in the specials array of the saved binding. */
+    int idx;
+
     /** Special binding state to be restored */
     // package level access
     SpecialBinding binding;
+    SpecialBindingsMark next;
 
     /** Constructor to be called by LispThread.markSpecialBindings() only */
     // package level access
-    SpecialBindingsMark(SpecialBinding binding) {
+    SpecialBindingsMark(int idx, SpecialBinding binding,
+                        SpecialBindingsMark next) {
+        this.idx = idx;
         this.binding = binding;
+        this.next = next;
     }
 }
\ No newline at end of file

Modified: trunk/abcl/src/org/armedbear/lisp/Symbol.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Symbol.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Symbol.java	Tue Nov 10 14:45:37 2009
@@ -49,6 +49,11 @@
 
   public final SimpleString name;
   private int hash = -1;
+
+  /** To be accessed by LispThread only:
+   * used to find the index in the LispThread.specials array
+   */
+  int specialIndex = LispThread.UNASSIGNED_SPECIAL_INDEX;
   private LispObject pkg; // Either a package object or NIL.
   private LispObject value;
   private LispObject function;



From ehuelsmann at common-lisp.net  Wed Nov 11 23:20:31 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Wed, 11 Nov 2009 18:20:31 -0500
Subject: [armedbear-cvs] r12276 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N8MUJ-0001as-Ig@common-lisp.net>

Author: ehuelsmann
Date: Wed Nov 11 18:20:27 2009
New Revision: 12276

Log:
Further reduce forced loading of files: TOPLEVEL will be loaded
  when it's needed; embedded uses will skip loading it now.

Note: Hopefully, this reduces autoloading pressure on GAE.

Modified:
   trunk/abcl/src/org/armedbear/lisp/boot.lisp

Modified: trunk/abcl/src/org/armedbear/lisp/boot.lisp
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/boot.lisp	(original)
+++ trunk/abcl/src/org/armedbear/lisp/boot.lisp	Wed Nov 11 18:20:27 2009
@@ -186,7 +186,6 @@
       (resolve sym))))
 
 (unless (featurep :j)
-  (load-system-file "top-level")
   (unless *noinform*
     (%format t "Startup completed in ~A seconds.~%"
              (float (/ (ext:uptime) 1000)))))



From ehuelsmann at common-lisp.net  Wed Nov 11 23:24:58 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Wed, 11 Nov 2009 18:24:58 -0500
Subject: [armedbear-cvs] r12277 -
	trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae
Message-ID: <E1N8MYc-0001qd-IH@common-lisp.net>

Author: ehuelsmann
Date: Wed Nov 11 18:24:57 2009
New Revision: 12277

Log:
Adjust Google App Engine example to the "disappearance" of ConditionThrowable.

Modified:
   trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae/AbclInit.java
   trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae/HelloWorldServlet.java

Modified: trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae/AbclInit.java
==============================================================================
--- trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae/AbclInit.java	(original)
+++ trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae/AbclInit.java	Wed Nov 11 18:24:57 2009
@@ -1,62 +1,3 @@
-/*package abcl_ae;
-
-import java.io.FileInputStream;
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.io.File;
-//import java.io.IOException;
-//import java.io.FileNotFoundException;
-
-import org.armedbear.lisp.Lisp;
-import org.armedbear.lisp.Interpreter;
-import org.armedbear.lisp.Symbol;
-import org.armedbear.lisp.Pathname;
-import org.armedbear.lisp.Stream;
-import org.armedbear.lisp.Load;
-import org.armedbear.lisp.ConditionThrowable;
-
-public final class AbclInit {
-	static Symbol doGet = null;
-	static boolean hasErrors = false;
-	static String message = "Success";
-	
-	static {
-		FileInputStream in = null;
-		
-		try {
-			in = new FileInputStream("fasls/first-servlet.abcl");
-			Load.load("fasls/first-servlet.abcl");
-			
-			doGet = Lisp.internInPackage("FIRST-SERVLET", "DO-GET");
-		} catch (ConditionThrowable condition) {
-			// How do we handle exceptions?
-			hasErrors = true;
-			message = condition.toString();
-		} catch (Exception e) {
-			// How do we handle exceptions?
-			hasErrors = true;
-			StringWriter sw = new StringWriter();
-			PrintWriter pw = new PrintWriter(sw, true);
-			e.printStackTrace(pw);
-			pw.flush();
-			sw.flush();
-			message = sw.toString();
-		} finally {
-			try {
-				in.close();
-			} catch (Exception e) {
-				hasErrors = true;
-				StringWriter sw = new StringWriter();
-				PrintWriter pw = new PrintWriter(sw, true);
-				e.printStackTrace(pw);
-				pw.flush();
-				sw.flush();
-				message = sw.toString();
-			}
-		}
-	}
-}*/
-
 package abcl_ae;
 
 import java.io.FileInputStream;
@@ -82,11 +23,8 @@
 			if (initialized)
 				return;
 				
-			try {
-				Interpreter.initializeLisp();
-				Load.load("fasls/first-servlet.abcl");
-			}
-			catch (ConditionThrowable ct) { }
+			Interpreter.initializeLisp();
+			Load.load("fasls/first-servlet.abcl");
 			
 			initialized = true;
 		}

Modified: trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae/HelloWorldServlet.java
==============================================================================
--- trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae/HelloWorldServlet.java	(original)
+++ trunk/abcl/examples/abcl/abcl_appengine/src/abcl_ae/HelloWorldServlet.java	Wed Nov 11 18:24:57 2009
@@ -1,53 +1,3 @@
-/*package abcl_ae;
-
-import java.io.IOException;
-import javax.servlet.http.*;
-
-import org.armedbear.lisp.LispThread;
-import org.armedbear.lisp.Lisp;
-import org.armedbear.lisp.Symbol;
-import org.armedbear.lisp.Stream;
-import org.armedbear.lisp.SpecialBinding;
-import org.armedbear.lisp.ConditionThrowable;
-
-public class HelloWorldServlet extends HttpServlet {
-	public void doGet(HttpServletRequest req, HttpServletResponse resp)
-		throws IOException {
-		
-		if (AbclInit.hasErrors)
-		{
-			resp.setContentType("text/plain");
-			resp.getWriter().println(AbclInit.message);
-			return;
-		}
-		
-		// Set the default Lisp output stream to the servlet's output stream.
-		LispThread currentThread = LispThread.currentThread();
-		SpecialBinding lastSpecialBinding = currentThread.lastSpecialBinding;
-		Stream out = new Stream(resp.getOutputStream(), Symbol.CHARACTER, false);
-		
-		currentThread.bindSpecial(Symbol.STANDARD_OUTPUT, out);
-		
-		try {
-			if (AbclInit.doGet == null)
-			{
-				resp.setContentType("text/plain");
-				resp.getWriter().println(AbclInit.message);
-				return;
-			}
-			
-			// Run the Lisp handler.
-			currentThread.execute(AbclInit.doGet);
-		} catch (ConditionThrowable condition) {
-			resp.setContentType("text/plain");
-			resp.getWriter().println(condition.toString());
-		} finally {
-			// Restore the default Lisp output stream.
-			currentThread.lastSpecialBinding = lastSpecialBinding;
-		}
-	}
-}*/
-
 package abcl_ae;
 
 import java.io.IOException;
@@ -59,8 +9,8 @@
 import org.armedbear.lisp.Lisp;
 import org.armedbear.lisp.Symbol;
 import org.armedbear.lisp.SpecialBinding;
-import org.armedbear.lisp.ConditionThrowable;
 import org.armedbear.lisp.Load;
+import org.armedbear.lisp.Stream;
 
 public class HelloWorldServlet extends HttpServlet {
 
@@ -68,10 +18,7 @@
 
 	public void init() throws ServletException {
 		AbclInit.init();
-		try {
-			doGet = Lisp.internInPackage("DO-GET", "FIRST-SERVLET");
-		}
-		catch (ConditionThrowable ct) { }
+		doGet = Lisp.internInPackage("DO-GET", "FIRST-SERVLET");
 	}
 
 
@@ -80,18 +27,15 @@
 
 		LispThread currentThread = LispThread.currentThread();
 
-		SpecialBinding lastSpecialBinding = currentThread.lastSpecialBinding;
+		SpecialBindingsMark mark = currentThread.markSpecialBindings();
 		currentThread.bindSpecial(
 			Symbol.STANDARD_OUTPUT, 
-			new org.armedbear.lisp.Stream(resp.getOutputStream(), Symbol.CHARACTER, false));
+			new Stream(resp.getOutputStream(), Symbol.CHARACTER, false));
 
 		try {
 			currentThread.execute(doGet);
-		} catch (ConditionThrowable condition) {
-			resp.setContentType("text/plain");
-			resp.getWriter().println(condition.toString());
 		} finally {
-			currentThread.lastSpecialBinding = lastSpecialBinding;
+			currentThread.resetSpecialBindings(mark);
 		}
 	}
 }
\ No newline at end of file



From ehuelsmann at common-lisp.net  Sat Nov 14 20:57:45 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sat, 14 Nov 2009 15:57:45 -0500
Subject: [armedbear-cvs] r12278 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N9Pgn-0007SZ-1L@common-lisp.net>

Author: ehuelsmann
Date: Sat Nov 14 15:57:42 2009
New Revision: 12278

Log:
Add some loader process documentation.

Modified:
   trunk/abcl/src/org/armedbear/lisp/Load.java

Modified: trunk/abcl/src/org/armedbear/lisp/Load.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Load.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Load.java	Sat Nov 14 15:57:42 2009
@@ -47,6 +47,23 @@
 import java.util.zip.ZipFile;
 import java.util.zip.ZipInputStream;
 
+/* This file holds ABCL's (FASL and non-FASL) loading behaviours.
+ *
+ * The loading process works like this:
+ *   The loader associates the input filename with a special variable
+ *   and starts evaluating the forms in the file.
+ *
+ *   If one of the forms is (INIT-FASL :VERSION <version>), from that
+ *   point the file is taken to be a FASL.
+ *   The FASL loader takes over and retrieves the file being loaded
+ *   from the special variable and continues loading from there.
+ *
+ *   Note: In order to prevent re-opening the ZIP file again and again,
+ *    ABCL keeps a cache of opened zip files, which are retrieved to load
+ *    .cls (compiled-function files) from the ZIP while loading the main
+ *    ._ file with FASL loading instructions.
+ */
+
 public final class Load extends Lisp
 {
     public static final LispObject load(String filename)
@@ -59,7 +76,7 @@
                     Symbol.LOAD_PRINT.symbolValue(thread) != NIL,
                     true);
     }
-    
+
     private static final File findLoadableFile(final String filename,
                                                final String dir)
     {
@@ -93,7 +110,7 @@
                                         boolean verbose,
                                         boolean print,
                                         boolean ifDoesNotExist)
-        {
+    {
         return load(pathname, filename, verbose, print, ifDoesNotExist, false);
     }
 



From ehuelsmann at common-lisp.net  Sun Nov 15 21:07:30 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sun, 15 Nov 2009 16:07:30 -0500
Subject: [armedbear-cvs] r12279 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1N9mJm-0003gX-35@common-lisp.net>

Author: ehuelsmann
Date: Sun Nov 15 16:07:24 2009
New Revision: 12279

Log:
Make car()/cdr()/setCar()/setCdr()/EQ() non-virtual,
  dispatching where required on instanceof.

Note: Our findings are that virtual calls are slower than
  instanceof checks (followed by a cast if necessary),
  meaning that for small numbers of instanceof comparisons
  the construct now committed will be faster.

Patch by: vvoutilainen

Modified:
   trunk/abcl/src/org/armedbear/lisp/Cons.java
   trunk/abcl/src/org/armedbear/lisp/LispObject.java
   trunk/abcl/src/org/armedbear/lisp/Nil.java

Modified: trunk/abcl/src/org/armedbear/lisp/Cons.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Cons.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Cons.java	Sun Nov 15 16:07:24 2009
@@ -124,24 +124,6 @@
   }
 
   @Override
-  public final LispObject car()
-  {
-    return car;
-  }
-
-  @Override
-  public final LispObject cdr()
-  {
-    return cdr;
-  }
-
-  @Override
-  public final void setCar(LispObject obj)
-  {
-    car = obj;
-  }
-
-  @Override
   public LispObject RPLACA(LispObject obj)
   {
     car = obj;
@@ -149,12 +131,6 @@
   }
 
   @Override
-  public final void setCdr(LispObject obj)
-  {
-    cdr = obj;
-  }
-
-  @Override
   public LispObject RPLACD(LispObject obj)
   {
     cdr = obj;

Modified: trunk/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispObject.java	Sun Nov 15 16:07:24 2009
@@ -124,13 +124,22 @@
   }
 
 
-  public LispObject car()
+  public final LispObject car()
   {
+    if (this instanceof Cons) {
+      return ((Cons)this).car;
+    } else if (this == NIL) {
+      return NIL;
+    }
     return type_error(this, Symbol.LIST);
   }
 
-  public void setCar(LispObject obj)
+  public final void setCar(LispObject obj)
   {
+      if (this instanceof Cons) {
+          ((Cons)this).car = obj;
+          return;
+      }
     type_error(this, Symbol.CONS);
   }
 
@@ -139,13 +148,23 @@
     return type_error(this, Symbol.CONS);
   }
 
-  public LispObject cdr()
+  public final LispObject cdr()
   {
+    if (this instanceof Cons) {
+      return ((Cons)this).cdr;
+    } else if (this instanceof Nil) {
+      return NIL;
+    }
     return type_error(this, Symbol.LIST);
   }
 
-  public void setCdr(LispObject obj)
+  public final void setCdr(LispObject obj)
   {
+      if (this instanceof Cons) {
+          ((Cons)this).cdr = obj;
+          return;
+      }
+
     type_error(this, Symbol.CONS);
   }
 
@@ -182,7 +201,7 @@
     return type_error(this, Symbol.LIST);
   }
 
-  public LispObject EQ(LispObject obj)
+  final public LispObject EQ(LispObject obj)
   {
     return this == obj ? T : NIL;
   }

Modified: trunk/abcl/src/org/armedbear/lisp/Nil.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Nil.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Nil.java	Sun Nov 15 16:07:24 2009
@@ -105,18 +105,6 @@
     }
 
     @Override
-    public LispObject car()
-    {
-        return this;
-    }
-
-    @Override
-    public LispObject cdr()
-    {
-        return this;
-    }
-
-    @Override
     public final LispObject cadr()
     {
         return this;



From ehuelsmann at common-lisp.net  Sun Nov 22 14:35:20 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sun, 22 Nov 2009 09:35:20 -0500
Subject: [armedbear-cvs] r12280 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NCDX6-0006wi-9C@common-lisp.net>

Author: ehuelsmann
Date: Sun Nov 22 09:35:12 2009
New Revision: 12280

Log:
Fix special bindings in case a symbol is bound to its own value,
  where there are no other bindings, but the symbol does have a
  value set. (bindSpecialToCurrentValue)

Modified:
   trunk/abcl/src/org/armedbear/lisp/LispThread.java

Modified: trunk/abcl/src/org/armedbear/lisp/LispThread.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispThread.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispThread.java	Sun Nov 22 09:35:12 2009
@@ -404,7 +404,8 @@
         savedSpecials = new SpecialBindingsMark(idx, binding, savedSpecials);
         return specials[idx]
             = new SpecialBinding(idx,
-                                 (binding == null) ? null : binding.value);
+                                 (binding == null) ?
+                                 name.getSymbolValue() : binding.value);
     }
 
     /** Looks up the value of a special binding in the context of the



From ehuelsmann at common-lisp.net  Sun Nov 22 19:11:57 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Sun, 22 Nov 2009 14:11:57 -0500
Subject: [armedbear-cvs] r12281 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NCHqn-0001HL-9q@common-lisp.net>

Author: ehuelsmann
Date: Sun Nov 22 14:11:54 2009
New Revision: 12281

Log:
Fix a memory leak for objects-with-documentation going out of scope,
  by making the documentation hash table a WeakHashMap.


Modified:
   trunk/abcl/src/org/armedbear/lisp/LispObject.java

Modified: trunk/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispObject.java	Sun Nov 22 14:11:54 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import java.util.WeakHashMap;
+
 public class LispObject extends Lisp
 {
   public LispObject typeOf()
@@ -587,13 +589,16 @@
     return false;
   }
 
-  private static final EqHashTable documentationHashTable =
-    new EqHashTable(11, NIL, NIL);
+  private static final WeakHashMap<LispObject, LispObject>
+      documentationHashTable = new WeakHashMap<LispObject, LispObject>();
 
   public LispObject getDocumentation(LispObject docType)
 
   {
-    LispObject alist = documentationHashTable.get(this);
+    LispObject alist;
+    synchronized (documentationHashTable) {
+      alist = documentationHashTable.get(this);
+    }
     if (alist != null)
       {
         LispObject entry = assq(docType, alist);
@@ -606,19 +611,21 @@
   public void setDocumentation(LispObject docType, LispObject documentation)
 
   {
-    LispObject alist = documentationHashTable.get(this);
-    if (alist == null)
-      alist = NIL;
-    LispObject entry = assq(docType, alist);
-    if (entry instanceof Cons)
-      {
-        ((Cons)entry).cdr = documentation;
-      }
-    else
-      {
-        alist = alist.push(new Cons(docType, documentation));
-        documentationHashTable.put(this, alist);
-      }
+    synchronized (documentationHashTable) {
+      LispObject alist = documentationHashTable.get(this);
+      if (alist == null)
+        alist = NIL;
+      LispObject entry = assq(docType, alist);
+      if (entry instanceof Cons)
+        {
+          ((Cons)entry).cdr = documentation;
+        }
+      else
+        {
+          alist = alist.push(new Cons(docType, documentation));
+          documentationHashTable.put(this, alist);
+        }
+    }
   }
 
   public LispObject getPropertyList()



From ehuelsmann at common-lisp.net  Wed Nov 25 22:34:02 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Wed, 25 Nov 2009 17:34:02 -0500
Subject: [armedbear-cvs] r12282 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NDQR0-0000EO-0P@common-lisp.net>

Author: ehuelsmann
Date: Wed Nov 25 17:33:59 2009
New Revision: 12282

Log:
Fix PRINT-LEVEL.* tests all of which were related to
  *PRINT-LEVEL* restriction on structure printing.

Modified:
   trunk/abcl/src/org/armedbear/lisp/print.lisp

Modified: trunk/abcl/src/org/armedbear/lisp/print.lisp
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/print.lisp	(original)
+++ trunk/abcl/src/org/armedbear/lisp/print.lisp	Wed Nov 25 17:33:59 2009
@@ -133,7 +133,13 @@
               (not (bit-vector-p object)))
          (output-vector object stream))
         ((structure-object-p object)
-         (print-object object stream))
+         (cond
+           ((and (null *print-readably*)
+                 *print-level*
+                 (>= *current-print-level* *print-level*))
+            (write-char #\# stream))
+           (t
+            (print-object object stream))))
         ((standard-object-p object)
          (print-object object stream))
         ((xp::xp-structure-p stream)



From ehuelsmann at common-lisp.net  Wed Nov 25 23:12:42 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Wed, 25 Nov 2009 18:12:42 -0500
Subject: [armedbear-cvs] r12283 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NDR2Q-0002na-Fh@common-lisp.net>

Author: ehuelsmann
Date: Wed Nov 25 18:12:39 2009
New Revision: 12283

Log:
Fix logical pathname translation issue reported by Thomas Russ.

Modified:
   trunk/abcl/src/org/armedbear/lisp/pathnames.lisp

Modified: trunk/abcl/src/org/armedbear/lisp/pathnames.lisp
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/pathnames.lisp	(original)
+++ trunk/abcl/src/org/armedbear/lisp/pathnames.lisp	Wed Nov 25 18:12:39 2009
@@ -214,33 +214,46 @@
          ;; FIXME
          (error "Unsupported wildcard pattern: ~S" to))))
 
-(defun translate-directory-components (source from to case)
-  (cond ((null to)
-         nil
-         )
-        ((memq (car to) '(:absolute :relative))
-         (cons (car to)
-               (translate-directory-components (cdr source) (cdr from) (cdr to) case))
-         )
-        ((eq (car to) :wild)
-         (if (eq (car from) :wild)
-             ;; Grab the next chunk from SOURCE.
-             (append (casify (car source) case)
-                     (translate-directory-components (cdr source) (cdr from) (cdr to) case))
-             (error "Unsupported case 1: ~S ~S ~S" source from to))
-         )
-        ((eq (car to) :wild-inferiors)
-         ;; Grab the next chunk from SOURCE.
-         (append (casify (car source) case)
-                 (translate-directory-components (cdr source) (cdr from) (cdr to) case))
-         )
-        (t
-         ;; "If the piece in TO-WILDCARD is present and not wild, it is copied
-         ;; into the result."
-         (append (casify (car to) case)
-                 (translate-directory-components source from (cdr to) case))
-         )
-        ))
+
+(defun translate-directory-components-aux (src from to case)
+  (cond
+    ((and (null src) (null from) (null to))
+     NIL)
+    ((and to
+          (not (member (car to) '(:wild :wild-inferiors))))
+     (cons (casify (car to) case)
+           (translate-directory-components-aux src from (cdr to) case)))
+    ((not (and src from))
+     ;; both are NIL --> TO is a wildcard which can't be matched
+     ;; either is NIL --> SRC can't be fully matched against FROM, vice versa
+     (throw 'failed-match))
+    ((not (member (car from) '(:wild :wild-inferiors)))
+     (unless (string= (casify (car src) case) (casify (car from) case))
+       (throw 'failed-match)) ;; FROM doesn't match SRC
+     (translate-directory-components-aux (cdr src) (cdr from) to case))
+    ((not (eq (car from) (car to))) ;; TO is NIL while FROM is not, or
+     (throw 'failed-match))         ;; FROM wildcard doesn't match TO wildcard
+    ((eq (car to) :wild)  ;; FROM and TO wildcards are :WILD
+     (cons (casify (car src) case)
+       (translate-directory-components-aux (cdr src) (cdr from) (cdr to) case)))
+    ((eq (car to) :wild-inferiors) ;; FROM and TO wildcards are :WILD-INFERIORS
+     (do ((src (cdr src) (cdr src))
+          (match (list (casify (car src) case))
+                 (cons (casify (car src) case) match)))
+         (NIL) ;; we'll exit the loop in different ways
+       (catch 'failed-match
+         (return-from translate-directory-components-aux
+           (append (reverse match) (translate-directory-components-aux
+                                        src (cdr from) (cdr to) case))))
+       (when (null src) ;; SRC is NIL and we're still here: error exit
+         (throw 'failed-match))))))
+
+(defun translate-directory-components (src from to case)
+  (catch 'failed-match
+    (return-from translate-directory-components
+      (translate-directory-components-aux src from to case)))
+  (error "Unsupported case in TRANSLATE-DIRECTORY-COMPONENTS."))
+
 
 (defun translate-directory (source from to case)
   ;; FIXME The IGNORE-CASE argument to DIRECTORY-MATCH-P should not be nil on
@@ -252,10 +265,7 @@
         ((equal source '(:absolute))
          (remove :wild-inferiors to))
         (t
-         (translate-directory-components (split-directory-components source)
-                                         (split-directory-components from)
-                                         (split-directory-components to)
-                                         case))))
+         (translate-directory-components source from to case))))
 
 ;; "The resulting pathname is TO-WILDCARD with each wildcard or missing field
 ;; replaced by a portion of SOURCE."



From ehuelsmann at common-lisp.net  Thu Nov 26 15:10:07 2009
From: ehuelsmann at common-lisp.net (Erik Huelsmann)
Date: Thu, 26 Nov 2009 10:10:07 -0500
Subject: [armedbear-cvs] r12284 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NDfyx-0006Rc-7y@common-lisp.net>

Author: ehuelsmann
Date: Thu Nov 26 10:10:04 2009
New Revision: 12284

Log:
Delete unused function (split-directory-components).

Modified:
   trunk/abcl/src/org/armedbear/lisp/pathnames.lisp

Modified: trunk/abcl/src/org/armedbear/lisp/pathnames.lisp
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/pathnames.lisp	(original)
+++ trunk/abcl/src/org/armedbear/lisp/pathnames.lisp	Thu Nov 26 10:10:04 2009
@@ -175,25 +175,6 @@
     (t
      thing)))
 
-(defun split-directory-components (directory)
-  (declare (optimize safety))
-  (declare (type list directory))
-  (unless (memq (car directory) '(:absolute :relative))
-    (error "Ill-formed directory list: ~S" directory))
-  (let (result sublist)
-    (push (car directory) result)
-    (dolist (component (cdr directory))
-      (cond ((memq component '(:wild :wild-inferiors))
-             (when sublist
-               (push (nreverse sublist) result)
-               (setf sublist nil))
-             (push component result))
-            (t
-             (push component sublist))))
-    (when sublist
-      (push (nreverse sublist) result))
-    (nreverse result)))
-
 (defun translate-component (source from to &optional case)
   (declare (ignore from))
   (cond ((or (eq to :wild) (null to))



From vvoutilainen at common-lisp.net  Sun Nov 29 19:38:57 2009
From: vvoutilainen at common-lisp.net (Ville Voutilainen)
Date: Sun, 29 Nov 2009 14:38:57 -0500
Subject: [armedbear-cvs] r12285 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NEpbl-0006Sr-BY@common-lisp.net>

Author: vvoutilainen
Date: Sun Nov 29 14:38:53 2009
New Revision: 12285

Log:
Make NUMBERP/LISTP/etc. type query functions final in LispObject.
These usually call their virtual boolean counterpart and then return T or
NIL in the final function. Same change is made for IS_* functions
in LispObject, those also invoke a virtual boolean counterpart.


Modified:
   trunk/abcl/src/org/armedbear/lisp/AbstractString.java
   trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
   trunk/abcl/src/org/armedbear/lisp/Bignum.java
   trunk/abcl/src/org/armedbear/lisp/Complex.java
   trunk/abcl/src/org/armedbear/lisp/Cons.java
   trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java
   trunk/abcl/src/org/armedbear/lisp/Fixnum.java
   trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
   trunk/abcl/src/org/armedbear/lisp/LispObject.java
   trunk/abcl/src/org/armedbear/lisp/Nil.java
   trunk/abcl/src/org/armedbear/lisp/Ratio.java
   trunk/abcl/src/org/armedbear/lisp/SingleFloat.java

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractString.java	Sun Nov 29 14:38:53 2009
@@ -52,12 +52,6 @@
     }
 
     @Override
-    public final LispObject STRINGP()
-    {
-        return T;
-    }
-
-    @Override
     public final boolean stringp()
     {
         return true;

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractVector.java	Sun Nov 29 14:38:53 2009
@@ -49,12 +49,6 @@
   }
 
   @Override
-  public final LispObject VECTORP()
-  {
-    return T;
-  }
-
-  @Override
   public final boolean vectorp()
   {
     return true;

Modified: trunk/abcl/src/org/armedbear/lisp/Bignum.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Bignum.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Bignum.java	Sun Nov 29 14:38:53 2009
@@ -159,24 +159,12 @@
   }
 
   @Override
-  public LispObject NUMBERP()
-  {
-    return T;
-  }
-
-  @Override
   public boolean numberp()
   {
     return true;
   }
 
   @Override
-  public LispObject INTEGERP()
-  {
-    return T;
-  }
-
-  @Override
   public boolean integerp()
   {
     return true;

Modified: trunk/abcl/src/org/armedbear/lisp/Complex.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Complex.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Complex.java	Sun Nov 29 14:38:53 2009
@@ -105,12 +105,6 @@
   }
 
   @Override
-  public LispObject NUMBERP()
-  {
-    return T;
-  }
-
-  @Override
   public boolean numberp()
   {
     return true;

Modified: trunk/abcl/src/org/armedbear/lisp/Cons.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Cons.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Cons.java	Sun Nov 29 14:38:53 2009
@@ -112,12 +112,6 @@
   }
 
   @Override
-  public LispObject ATOM()
-  {
-    return NIL;
-  }
-
-  @Override
   public boolean atom()
   {
     return false;
@@ -414,24 +408,12 @@
   }
 
   @Override
-  public final LispObject LISTP()
-  {
-    return T;
-  }
-
-  @Override
   public final boolean endp()
   {
     return false;
   }
 
   @Override
-  public final LispObject ENDP()
-  {
-    return NIL;
-  }
-
-  @Override
   public final LispObject[] copyToArray()
   {
     final int length = length();

Modified: trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java	Sun Nov 29 14:38:53 2009
@@ -106,12 +106,6 @@
     }
 
     @Override
-    public LispObject NUMBERP()
-    {
-        return T;
-    }
-
-    @Override
     public boolean numberp()
     {
         return true;
@@ -212,12 +206,6 @@
     }
 
     @Override
-    public LispObject FLOATP()
-    {
-        return T;
-    }
-
-    @Override
     public boolean floatp()
     {
         return true;

Modified: trunk/abcl/src/org/armedbear/lisp/Fixnum.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Fixnum.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Fixnum.java	Sun Nov 29 14:38:53 2009
@@ -156,24 +156,12 @@
   }
 
   @Override
-  public LispObject NUMBERP()
-  {
-    return T;
-  }
-
-  @Override
   public boolean numberp()
   {
     return true;
   }
 
   @Override
-  public LispObject INTEGERP()
-  {
-    return T;
-  }
-
-  @Override
   public boolean integerp()
   {
     return true;

Modified: trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispCharacter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispCharacter.java	Sun Nov 29 14:38:53 2009
@@ -116,12 +116,6 @@
   }
 
   @Override
-  public LispObject CHARACTERP()
-  {
-    return T;
-  }
-
-  @Override
   public boolean characterp()
   {
     return true;

Modified: trunk/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispObject.java	Sun Nov 29 14:38:53 2009
@@ -86,14 +86,14 @@
     return true;
   }
 
-  public LispObject CONSTANTP()
+  public final LispObject CONSTANTP()
   {
     return constantp() ? T : NIL;
   }
 
-  public LispObject ATOM()
+  public final LispObject ATOM()
   {
-    return T;
+    return atom() ? T : NIL;
   }
 
   public boolean atom()
@@ -268,7 +268,7 @@
     return type_error(this, Symbol.RATIONAL);
   }
 
-  public LispObject EVENP()
+  public final LispObject EVENP()
   {
     return evenp() ? T : NIL;
   }
@@ -280,7 +280,7 @@
     return false;
   }
 
-  public LispObject ODDP()
+  public final LispObject ODDP()
   {
     return oddp() ? T : NIL;
   }
@@ -292,7 +292,7 @@
     return false;
   }
 
-  public LispObject PLUSP()
+  public final LispObject PLUSP()
   {
     return plusp() ? T : NIL;
   }
@@ -304,7 +304,7 @@
     return false;
   }
 
-  public LispObject MINUSP()
+  public final LispObject MINUSP()
   {
     return minusp() ? T : NIL;
   }
@@ -316,9 +316,9 @@
     return false;
   }
 
-  public LispObject NUMBERP()
+  public final LispObject NUMBERP()
   {
-    return NIL;
+    return numberp() ? T : NIL;
   }
 
   public boolean numberp()
@@ -326,7 +326,7 @@
     return false;
   }
 
-  public LispObject ZEROP()
+  public final LispObject ZEROP()
   {
     return zerop() ? T : NIL;
   }
@@ -343,9 +343,9 @@
     return NIL;
   }
 
-  public LispObject FLOATP()
+  public final LispObject FLOATP()
   {
-    return NIL;
+    return floatp() ? T : NIL;
   }
 
   public boolean floatp()
@@ -353,9 +353,9 @@
     return false;
   }
 
-  public LispObject INTEGERP()
+  public final LispObject INTEGERP()
   {
-    return NIL;
+    return integerp() ? T : NIL;
   }
 
   public boolean integerp()
@@ -363,7 +363,7 @@
     return false;
   }
 
-  public LispObject RATIONALP()
+  public final LispObject RATIONALP()
   {
     return rationalp() ? T : NIL;
   }
@@ -373,7 +373,7 @@
     return false;
   }
 
-  public LispObject REALP()
+  public final LispObject REALP()
   {
     return realp() ? T : NIL;
   }
@@ -383,9 +383,9 @@
     return false;
   }
 
-  public LispObject STRINGP()
+  public final LispObject STRINGP()
   {
-    return NIL;
+    return stringp() ? T : NIL;
   }
 
   public boolean stringp()
@@ -398,9 +398,9 @@
     return NIL;
   }
 
-  public LispObject VECTORP()
+  public final LispObject VECTORP()
   {
-    return NIL;
+    return vectorp() ? T : NIL;
   }
 
   public boolean vectorp()
@@ -408,9 +408,9 @@
     return false;
   }
 
-  public LispObject CHARACTERP()
+  public final LispObject CHARACTERP()
   {
-    return NIL;
+    return characterp() ? T : NIL;
   }
 
   public boolean characterp()
@@ -555,9 +555,9 @@
     return false;
   }
 
-  public LispObject LISTP()
+  public final LispObject LISTP()
   {
-    return NIL;
+    return listp() ? T : NIL;
   }
 
   public boolean endp()
@@ -567,9 +567,9 @@
     return false;
   }
 
-  public LispObject ENDP()
+  public final LispObject ENDP()
   {
-    return type_error(this, Symbol.LIST);
+    return endp() ? T : NIL;
   }
 
   public LispObject NOT()
@@ -880,7 +880,7 @@
     return false;
   }
 
-  public LispObject IS_E(LispObject obj)
+  public final LispObject IS_E(LispObject obj)
   {
     return isEqualTo(obj) ? T : NIL;
   }
@@ -897,7 +897,7 @@
     return false;
   }
 
-  public LispObject IS_NE(LispObject obj)
+  public final LispObject IS_NE(LispObject obj)
   {
     return isNotEqualTo(obj) ? T : NIL;
   }
@@ -914,7 +914,7 @@
     return false;
   }
 
-  public LispObject IS_LT(LispObject obj)
+  public final LispObject IS_LT(LispObject obj)
   {
     return isLessThan(obj) ? T : NIL;
   }
@@ -931,7 +931,7 @@
     return false;
   }
 
-  public LispObject IS_GT(LispObject obj)
+  public final LispObject IS_GT(LispObject obj)
   {
     return isGreaterThan(obj) ? T : NIL;
   }
@@ -948,7 +948,7 @@
     return false;
   }
 
-  public LispObject IS_LE(LispObject obj)
+  public final LispObject IS_LE(LispObject obj)
   {
     return isLessThanOrEqualTo(obj) ? T : NIL;
   }
@@ -965,7 +965,7 @@
     return false;
   }
 
-  public LispObject IS_GE(LispObject obj)
+  public final LispObject IS_GE(LispObject obj)
   {
     return isGreaterThanOrEqualTo(obj) ? T : NIL;
   }

Modified: trunk/abcl/src/org/armedbear/lisp/Nil.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Nil.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Nil.java	Sun Nov 29 14:38:53 2009
@@ -200,24 +200,12 @@
     }
 
     @Override
-    public LispObject LISTP()
-    {
-        return T;
-    }
-
-    @Override
     public boolean endp()
     {
         return true;
     }
 
     @Override
-    public LispObject ENDP()
-    {
-        return T;
-    }
-
-    @Override
     public LispObject NOT()
     {
         return T;

Modified: trunk/abcl/src/org/armedbear/lisp/Ratio.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Ratio.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Ratio.java	Sun Nov 29 14:38:53 2009
@@ -97,12 +97,6 @@
     }
 
     @Override
-    public LispObject NUMBERP()
-    {
-        return T;
-    }
-
-    @Override
     public boolean numberp()
     {
         return true;

Modified: trunk/abcl/src/org/armedbear/lisp/SingleFloat.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SingleFloat.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SingleFloat.java	Sun Nov 29 14:38:53 2009
@@ -106,12 +106,6 @@
     }
 
     @Override
-    public LispObject NUMBERP()
-    {
-        return T;
-    }
-
-    @Override
     public boolean numberp()
     {
         return true;
@@ -212,12 +206,6 @@
     }
 
     @Override
-    public LispObject FLOATP()
-    {
-        return T;
-    }
-
-    @Override
     public boolean floatp()
     {
         return true;



From vvoutilainen at common-lisp.net  Sun Nov 29 19:48:31 2009
From: vvoutilainen at common-lisp.net (Ville Voutilainen)
Date: Sun, 29 Nov 2009 14:48:31 -0500
Subject: [armedbear-cvs] r12286 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NEpl1-0007Ze-LM@common-lisp.net>

Author: vvoutilainen
Date: Sun Nov 29 14:48:30 2009
New Revision: 12286

Log:
LispObject.car() should use instanceof to check for nil,
as cdr() does.


Modified:
   trunk/abcl/src/org/armedbear/lisp/LispObject.java

Modified: trunk/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispObject.java	Sun Nov 29 14:48:30 2009
@@ -130,7 +130,7 @@
   {
     if (this instanceof Cons) {
       return ((Cons)this).car;
-    } else if (this == NIL) {
+    } else if (this instanceof Nil) {
       return NIL;
     }
     return type_error(this, Symbol.LIST);



From vvoutilainen at common-lisp.net  Sun Nov 29 20:23:09 2009
From: vvoutilainen at common-lisp.net (Ville Voutilainen)
Date: Sun, 29 Nov 2009 15:23:09 -0500
Subject: [armedbear-cvs] r12287 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NEqIX-0001Yj-FZ@common-lisp.net>

Author: vvoutilainen
Date: Sun Nov 29 15:23:08 2009
New Revision: 12287

Log:
Make LispObject.push() final.


Modified:
   trunk/abcl/src/org/armedbear/lisp/Cons.java
   trunk/abcl/src/org/armedbear/lisp/LispObject.java
   trunk/abcl/src/org/armedbear/lisp/Nil.java

Modified: trunk/abcl/src/org/armedbear/lisp/Cons.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Cons.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Cons.java	Sun Nov 29 15:23:08 2009
@@ -166,12 +166,6 @@
   }
 
   @Override
-  public final LispObject push(LispObject obj)
-  {
-    return new Cons(obj, this);
-  }
-
-  @Override
   public final int sxhash()
   {
     return computeHash(this, 4);

Modified: trunk/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispObject.java	Sun Nov 29 15:23:08 2009
@@ -198,8 +198,13 @@
     return type_error(this, Symbol.LIST);
   }
 
-  public LispObject push(LispObject obj)
+  public final LispObject push(LispObject obj)
   {
+    if (this instanceof Cons) {
+      return new Cons(obj, this);
+    } else if (this instanceof Nil) {
+      return new Cons(obj);
+    }
     return type_error(this, Symbol.LIST);
   }
 

Modified: trunk/abcl/src/org/armedbear/lisp/Nil.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Nil.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Nil.java	Sun Nov 29 15:23:08 2009
@@ -138,12 +138,6 @@
     }
 
     @Override
-    public LispObject push(LispObject obj)
-    {
-        return new Cons(obj);
-    }
-
-    @Override
     public LispObject NTH(int index)
     {
         if (index < 0)



From vvoutilainen at common-lisp.net  Sun Nov 29 22:00:15 2009
From: vvoutilainen at common-lisp.net (Ville Voutilainen)
Date: Sun, 29 Nov 2009 17:00:15 -0500
Subject: [armedbear-cvs] r12288 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NEroV-0006ax-UG@common-lisp.net>

Author: vvoutilainen
Date: Sun Nov 29 17:00:12 2009
New Revision: 12288

Log:
Don't extend Lisp in LispObject, static import Lisp wherever
necessary. Patch by Douglas R. Miles.


Modified:
   trunk/abcl/src/org/armedbear/lisp/AbstractArray.java
   trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
   trunk/abcl/src/org/armedbear/lisp/AbstractString.java
   trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
   trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java
   trunk/abcl/src/org/armedbear/lisp/Autoload.java
   trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java
   trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java
   trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java
   trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java
   trunk/abcl/src/org/armedbear/lisp/Bignum.java
   trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java
   trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java
   trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java
   trunk/abcl/src/org/armedbear/lisp/CellError.java
   trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Closure.java
   trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java
   trunk/abcl/src/org/armedbear/lisp/CompilerError.java
   trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java
   trunk/abcl/src/org/armedbear/lisp/Complex.java
   trunk/abcl/src/org/armedbear/lisp/ComplexArray.java
   trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java
   trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java
   trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java
   trunk/abcl/src/org/armedbear/lisp/ComplexString.java
   trunk/abcl/src/org/armedbear/lisp/ComplexVector.java
   trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java
   trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java
   trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java
   trunk/abcl/src/org/armedbear/lisp/Condition.java
   trunk/abcl/src/org/armedbear/lisp/Cons.java
   trunk/abcl/src/org/armedbear/lisp/ControlError.java
   trunk/abcl/src/org/armedbear/lisp/Debug.java
   trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java
   trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java
   trunk/abcl/src/org/armedbear/lisp/Do.java
   trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java
   trunk/abcl/src/org/armedbear/lisp/EchoStream.java
   trunk/abcl/src/org/armedbear/lisp/EndOfFile.java
   trunk/abcl/src/org/armedbear/lisp/Environment.java
   trunk/abcl/src/org/armedbear/lisp/Extensions.java
   trunk/abcl/src/org/armedbear/lisp/FaslReader.java
   trunk/abcl/src/org/armedbear/lisp/FileError.java
   trunk/abcl/src/org/armedbear/lisp/FileStream.java
   trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/Fixnum.java
   trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java
   trunk/abcl/src/org/armedbear/lisp/FloatingPointInexact.java
   trunk/abcl/src/org/armedbear/lisp/FloatingPointInvalidOperation.java
   trunk/abcl/src/org/armedbear/lisp/FloatingPointOverflow.java
   trunk/abcl/src/org/armedbear/lisp/FloatingPointUnderflow.java
   trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java
   trunk/abcl/src/org/armedbear/lisp/Function.java
   trunk/abcl/src/org/armedbear/lisp/GenericFunction.java
   trunk/abcl/src/org/armedbear/lisp/HashTable.java
   trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java
   trunk/abcl/src/org/armedbear/lisp/IllegalMonitorState.java
   trunk/abcl/src/org/armedbear/lisp/Interpreter.java
   trunk/abcl/src/org/armedbear/lisp/JHandler.java
   trunk/abcl/src/org/armedbear/lisp/JProxy.java
   trunk/abcl/src/org/armedbear/lisp/Java.java
   trunk/abcl/src/org/armedbear/lisp/JavaClass.java
   trunk/abcl/src/org/armedbear/lisp/JavaException.java
   trunk/abcl/src/org/armedbear/lisp/JavaObject.java
   trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java
   trunk/abcl/src/org/armedbear/lisp/Keyword.java
   trunk/abcl/src/org/armedbear/lisp/Layout.java
   trunk/abcl/src/org/armedbear/lisp/Lisp.java
   trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
   trunk/abcl/src/org/armedbear/lisp/LispClass.java
   trunk/abcl/src/org/armedbear/lisp/LispError.java
   trunk/abcl/src/org/armedbear/lisp/LispObject.java
   trunk/abcl/src/org/armedbear/lisp/LispReader.java
   trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java
   trunk/abcl/src/org/armedbear/lisp/LispThread.java
   trunk/abcl/src/org/armedbear/lisp/Load.java
   trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java
   trunk/abcl/src/org/armedbear/lisp/MacroObject.java
   trunk/abcl/src/org/armedbear/lisp/MathFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Nil.java
   trunk/abcl/src/org/armedbear/lisp/NilVector.java
   trunk/abcl/src/org/armedbear/lisp/Operator.java
   trunk/abcl/src/org/armedbear/lisp/Package.java
   trunk/abcl/src/org/armedbear/lisp/PackageError.java
   trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Packages.java
   trunk/abcl/src/org/armedbear/lisp/ParseError.java
   trunk/abcl/src/org/armedbear/lisp/Pathname.java
   trunk/abcl/src/org/armedbear/lisp/Primitives.java
   trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java
   trunk/abcl/src/org/armedbear/lisp/Profiler.java
   trunk/abcl/src/org/armedbear/lisp/ProgramError.java
   trunk/abcl/src/org/armedbear/lisp/RandomState.java
   trunk/abcl/src/org/armedbear/lisp/Ratio.java
   trunk/abcl/src/org/armedbear/lisp/ReaderError.java
   trunk/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java
   trunk/abcl/src/org/armedbear/lisp/Readtable.java
   trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java
   trunk/abcl/src/org/armedbear/lisp/SeriousCondition.java
   trunk/abcl/src/org/armedbear/lisp/ShellCommand.java
   trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java
   trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java
   trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java
   trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java
   trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java
   trunk/abcl/src/org/armedbear/lisp/SimpleCondition.java
   trunk/abcl/src/org/armedbear/lisp/SimpleError.java
   trunk/abcl/src/org/armedbear/lisp/SimpleString.java
   trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java
   trunk/abcl/src/org/armedbear/lisp/SimpleVector.java
   trunk/abcl/src/org/armedbear/lisp/SimpleWarning.java
   trunk/abcl/src/org/armedbear/lisp/SingleFloat.java
   trunk/abcl/src/org/armedbear/lisp/Site.java
   trunk/abcl/src/org/armedbear/lisp/SiteName.java
   trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java
   trunk/abcl/src/org/armedbear/lisp/SlimeOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/SlotClass.java
   trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java
   trunk/abcl/src/org/armedbear/lisp/SlotDefinitionClass.java
   trunk/abcl/src/org/armedbear/lisp/SocketStream.java
   trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java
   trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
   trunk/abcl/src/org/armedbear/lisp/StackFrame.java
   trunk/abcl/src/org/armedbear/lisp/StandardClass.java
   trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
   trunk/abcl/src/org/armedbear/lisp/StandardGenericFunctionClass.java
   trunk/abcl/src/org/armedbear/lisp/StandardMethod.java
   trunk/abcl/src/org/armedbear/lisp/StandardMethodClass.java
   trunk/abcl/src/org/armedbear/lisp/StandardObject.java
   trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java
   trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java
   trunk/abcl/src/org/armedbear/lisp/StandardReaderMethodClass.java
   trunk/abcl/src/org/armedbear/lisp/StorageCondition.java
   trunk/abcl/src/org/armedbear/lisp/Stream.java
   trunk/abcl/src/org/armedbear/lisp/StreamError.java
   trunk/abcl/src/org/armedbear/lisp/StringFunctions.java
   trunk/abcl/src/org/armedbear/lisp/StringInputStream.java
   trunk/abcl/src/org/armedbear/lisp/StringOutputStream.java
   trunk/abcl/src/org/armedbear/lisp/StructureClass.java
   trunk/abcl/src/org/armedbear/lisp/StructureObject.java
   trunk/abcl/src/org/armedbear/lisp/StyleWarning.java
   trunk/abcl/src/org/armedbear/lisp/Symbol.java
   trunk/abcl/src/org/armedbear/lisp/SynonymStream.java
   trunk/abcl/src/org/armedbear/lisp/Time.java
   trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java
   trunk/abcl/src/org/armedbear/lisp/TypeError.java
   trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java
   trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java
   trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java
   trunk/abcl/src/org/armedbear/lisp/Utilities.java
   trunk/abcl/src/org/armedbear/lisp/Warning.java
   trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java
   trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java
   trunk/abcl/src/org/armedbear/lisp/adjust_array.java
   trunk/abcl/src/org/armedbear/lisp/arglist.java
   trunk/abcl/src/org/armedbear/lisp/assq.java
   trunk/abcl/src/org/armedbear/lisp/assql.java
   trunk/abcl/src/org/armedbear/lisp/cell_error_name.java
   trunk/abcl/src/org/armedbear/lisp/copy_list.java
   trunk/abcl/src/org/armedbear/lisp/create_new_file.java
   trunk/abcl/src/org/armedbear/lisp/cxr.java
   trunk/abcl/src/org/armedbear/lisp/delete_file.java
   trunk/abcl/src/org/armedbear/lisp/disassemble_class_bytes.java
   trunk/abcl/src/org/armedbear/lisp/dolist.java
   trunk/abcl/src/org/armedbear/lisp/dotimes.java
   trunk/abcl/src/org/armedbear/lisp/file_author.java
   trunk/abcl/src/org/armedbear/lisp/file_error_pathname.java
   trunk/abcl/src/org/armedbear/lisp/file_length.java
   trunk/abcl/src/org/armedbear/lisp/file_string_length.java
   trunk/abcl/src/org/armedbear/lisp/file_write_date.java
   trunk/abcl/src/org/armedbear/lisp/float_sign.java
   trunk/abcl/src/org/armedbear/lisp/function_info.java
   trunk/abcl/src/org/armedbear/lisp/gc.java
   trunk/abcl/src/org/armedbear/lisp/get_properties.java
   trunk/abcl/src/org/armedbear/lisp/input_stream_p.java
   trunk/abcl/src/org/armedbear/lisp/interactive_stream_p.java
   trunk/abcl/src/org/armedbear/lisp/jclass_name.java
   trunk/abcl/src/org/armedbear/lisp/jclass_of.java
   trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java
   trunk/abcl/src/org/armedbear/lisp/last.java
   trunk/abcl/src/org/armedbear/lisp/listen.java
   trunk/abcl/src/org/armedbear/lisp/logand.java
   trunk/abcl/src/org/armedbear/lisp/logandc1.java
   trunk/abcl/src/org/armedbear/lisp/logandc2.java
   trunk/abcl/src/org/armedbear/lisp/logbitp.java
   trunk/abcl/src/org/armedbear/lisp/logcount.java
   trunk/abcl/src/org/armedbear/lisp/logeqv.java
   trunk/abcl/src/org/armedbear/lisp/logior.java
   trunk/abcl/src/org/armedbear/lisp/lognand.java
   trunk/abcl/src/org/armedbear/lisp/lognor.java
   trunk/abcl/src/org/armedbear/lisp/logorc1.java
   trunk/abcl/src/org/armedbear/lisp/logorc2.java
   trunk/abcl/src/org/armedbear/lisp/logtest.java
   trunk/abcl/src/org/armedbear/lisp/logxor.java
   trunk/abcl/src/org/armedbear/lisp/machine_version.java
   trunk/abcl/src/org/armedbear/lisp/make_array.java
   trunk/abcl/src/org/armedbear/lisp/make_condition.java
   trunk/abcl/src/org/armedbear/lisp/make_server_socket.java
   trunk/abcl/src/org/armedbear/lisp/make_socket.java
   trunk/abcl/src/org/armedbear/lisp/open_stream_p.java
   trunk/abcl/src/org/armedbear/lisp/output_stream_p.java
   trunk/abcl/src/org/armedbear/lisp/package_error_package.java
   trunk/abcl/src/org/armedbear/lisp/peek_char.java
   trunk/abcl/src/org/armedbear/lisp/probe_file.java
   trunk/abcl/src/org/armedbear/lisp/room.java
   trunk/abcl/src/org/armedbear/lisp/server_socket_close.java
   trunk/abcl/src/org/armedbear/lisp/simple_list_remove_duplicates.java
   trunk/abcl/src/org/armedbear/lisp/socket_accept.java
   trunk/abcl/src/org/armedbear/lisp/socket_close.java
   trunk/abcl/src/org/armedbear/lisp/socket_stream.java
   trunk/abcl/src/org/armedbear/lisp/stream_element_type.java
   trunk/abcl/src/org/armedbear/lisp/stream_external_format.java
   trunk/abcl/src/org/armedbear/lisp/unbound_slot_instance.java
   trunk/abcl/src/org/armedbear/lisp/zip.java

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractArray.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractArray.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractArray.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class AbstractArray extends LispObject
 {
     @Override

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class AbstractBitVector extends AbstractVector
 {
     protected static final int LONG_MASK = 0x3f;

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractString.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class AbstractString extends AbstractVector
 {
     @Override

Modified: trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AbstractVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AbstractVector.java	Sun Nov 29 17:00:12 2009
@@ -32,6 +32,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class AbstractVector extends AbstractArray
 {
   @Override

Modified: trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class ArithmeticError extends LispError
 {
     protected ArithmeticError(LispClass cls)

Modified: trunk/abcl/src/org/armedbear/lisp/Autoload.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Autoload.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Autoload.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class Autoload extends Function
 {
     protected final String fileName;

Modified: trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class AutoloadMacro extends Autoload
 {
     private AutoloadMacro(Symbol symbol)

Modified: trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // A basic vector is a specialized vector that is not displaced to another
 // array, has no fill pointer, and is not expressly adjustable.
 public final class BasicVector_UnsignedByte16 extends AbstractVector

Modified: trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // A basic vector is a specialized vector that is not displaced to another
 // array, has no fill pointer, and is not expressly adjustable.
 public final class BasicVector_UnsignedByte32 extends AbstractVector

Modified: trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // A basic vector is a specialized vector that is not displaced to another
 // array, has no fill pointer, and is not expressly adjustable.
 public final class BasicVector_UnsignedByte8 extends AbstractVector

Modified: trunk/abcl/src/org/armedbear/lisp/Bignum.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Bignum.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Bignum.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 public final class Bignum extends LispInteger

Modified: trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class BroadcastStream extends Stream
 {
     private final Stream[] streams;

Modified: trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class BuiltInClass extends LispClass
 {
   private BuiltInClass(Symbol symbol)

Modified: trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ByteArrayOutputStream extends Stream
 {
     private final java.io.ByteArrayOutputStream byteArrayOutputStream;

Modified: trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class CaseFrobStream extends Stream
 {
     protected final Stream target;

Modified: trunk/abcl/src/org/armedbear/lisp/CellError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CellError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CellError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class CellError extends LispError
 {
     protected CellError(LispClass cls)

Modified: trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class CharacterFunctions extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class CharacterFunctions extends LispTrampolinesFile
 {
     // ### char=
     private static final Primitive CHAR_EQUALS =

Modified: trunk/abcl/src/org/armedbear/lisp/Closure.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Closure.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Closure.java	Sun Nov 29 17:00:12 2009
@@ -34,6 +34,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.ArrayList;
 
 public class Closure extends Function

Modified: trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class CompiledClosure extends Closure
         implements Cloneable
 {

Modified: trunk/abcl/src/org/armedbear/lisp/CompilerError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CompilerError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CompilerError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class CompilerError extends Condition
 {
     public CompilerError(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class CompilerUnsupportedFeatureError extends Condition
 {
     public CompilerUnsupportedFeatureError(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/Complex.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Complex.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Complex.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class Complex extends LispObject
 {
   public final LispObject realpart;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexArray.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexArray.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexArray.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ComplexArray extends AbstractArray
 {
     private final int[] dimv;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ComplexArray_UnsignedByte32 extends AbstractArray
 {
     private final int[] dimv;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ComplexArray_UnsignedByte8 extends AbstractArray
 {
     private final int[] dimv;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ComplexBitVector extends AbstractBitVector
 {
     private int fillPointer = -1; // -1 indicates no fill pointer.

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexString.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ComplexString extends AbstractString
 {
   private int capacity;

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexVector.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // A vector that is displaced to another array, has a fill pointer, and/or is
 // expressly adjustable. It can hold elements of any type.
 public final class ComplexVector extends AbstractVector

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // A specialized vector of element type (UNSIGNED-BYTE 32) that is displaced to
 // another array, has a fill pointer, and/or is expressly adjustable.
 public final class ComplexVector_UnsignedByte32 extends AbstractVector

Modified: trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // A specialized vector of element type (UNSIGNED-BYTE 8) that is displaced to
 // another array, has a fill pointer, and/or is expressly adjustable.
 public final class ComplexVector_UnsignedByte8 extends AbstractVector

Modified: trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ConcatenatedStream extends Stream
 {
     private LispObject streams;

Modified: trunk/abcl/src/org/armedbear/lisp/Condition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Condition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Condition.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class Condition extends StandardObject
 {
   protected String message;

Modified: trunk/abcl/src/org/armedbear/lisp/Cons.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Cons.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Cons.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class Cons extends LispObject
 {
   public LispObject car;

Modified: trunk/abcl/src/org/armedbear/lisp/ControlError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ControlError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ControlError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ControlError extends LispError
 {
     public ControlError(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/Debug.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Debug.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Debug.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,7 @@
 
 package org.armedbear.lisp;
 
-public final class Debug extends Lisp
+public final class Debug
 {
     public static final void assertTrue(boolean b)
     {

Modified: trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class DispatchMacroFunction extends Function
 {
     public DispatchMacroFunction(String name)

Modified: trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class DivisionByZero extends ArithmeticError
 {
     public DivisionByZero()

Modified: trunk/abcl/src/org/armedbear/lisp/Do.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Do.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Do.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class Do extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class Do extends LispTrampolinesFile
 {
   // ### do
   private static final SpecialOperator DO =

Modified: trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 public final class DoubleFloat extends LispObject

Modified: trunk/abcl/src/org/armedbear/lisp/EchoStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EchoStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EchoStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class EchoStream extends Stream
 {
     private final Stream in;

Modified: trunk/abcl/src/org/armedbear/lisp/EndOfFile.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/EndOfFile.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/EndOfFile.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class EndOfFile extends StreamError
 {
     public EndOfFile(Stream stream)

Modified: trunk/abcl/src/org/armedbear/lisp/Environment.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Environment.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Environment.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class Environment extends LispObject
 {
   private Binding vars;

Modified: trunk/abcl/src/org/armedbear/lisp/Extensions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Extensions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Extensions.java	Sun Nov 29 17:00:12 2009
@@ -33,10 +33,12 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.io.IOException;
 
-public final class Extensions extends Lisp
+public final class Extensions extends LispTrampolinesFile
 {
   // ### *ed-functions*
   public static final Symbol _ED_FUNCTIONS_ =

Modified: trunk/abcl/src/org/armedbear/lisp/FaslReader.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FaslReader.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FaslReader.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class FaslReader extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class FaslReader extends LispTrampolinesFile
 {
     // ### fasl-read-comment
     public static final ReaderMacroFunction FASL_READ_COMMENT =

Modified: trunk/abcl/src/org/armedbear/lisp/FileError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FileError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FileError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class FileError extends LispError
 {
     // initArgs is either a normal initArgs list or a pathname.

Modified: trunk/abcl/src/org/armedbear/lisp/FileStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FileStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FileStream.java	Sun Nov 29 17:00:12 2009
@@ -34,6 +34,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.io.InputStream;
 import java.io.OutputStream;

Modified: trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class FillPointerOutputStream extends Stream
 {
     private ComplexString string;

Modified: trunk/abcl/src/org/armedbear/lisp/Fixnum.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Fixnum.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Fixnum.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 public final class Fixnum extends LispInteger

Modified: trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java	Sun Nov 29 17:00:12 2009
@@ -33,9 +33,11 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
-public final class FloatFunctions extends Lisp
+public final class FloatFunctions extends LispTrampolinesFile
 {
     // ### set-floating-point-modes &key traps => <no values>
     private static final Primitive SET_FLOATING_POINT_MODES =

Modified: trunk/abcl/src/org/armedbear/lisp/FloatingPointInexact.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatingPointInexact.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatingPointInexact.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class FloatingPointInexact extends ArithmeticError
 {
     public FloatingPointInexact(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/FloatingPointInvalidOperation.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatingPointInvalidOperation.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatingPointInvalidOperation.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class FloatingPointInvalidOperation extends ArithmeticError
 {
     public FloatingPointInvalidOperation(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/FloatingPointOverflow.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatingPointOverflow.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatingPointOverflow.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class FloatingPointOverflow extends ArithmeticError
 {
     public FloatingPointOverflow(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/FloatingPointUnderflow.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatingPointUnderflow.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatingPointUnderflow.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class FloatingPointUnderflow extends ArithmeticError
 {
     public FloatingPointUnderflow(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class ForwardReferencedClass extends LispClass
 {
     public ForwardReferencedClass(Symbol name)

Modified: trunk/abcl/src/org/armedbear/lisp/Function.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Function.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Function.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class Function extends Operator
 {
     private LispObject propertyList = NIL;

Modified: trunk/abcl/src/org/armedbear/lisp/GenericFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/GenericFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/GenericFunction.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class GenericFunction extends StandardObject
 {
     protected GenericFunction(LispClass cls, int length)

Modified: trunk/abcl/src/org/armedbear/lisp/HashTable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/HashTable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/HashTable.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class HashTable extends LispObject
 {
   private static final int DEFAULT_SIZE = 16;

Modified: trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class HashTableFunctions extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class HashTableFunctions extends LispTrampolinesFile
 {
   private static final LispObject FUNCTION_EQ =
     Symbol.EQ.getSymbolFunction();

Modified: trunk/abcl/src/org/armedbear/lisp/IllegalMonitorState.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/IllegalMonitorState.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/IllegalMonitorState.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class IllegalMonitorState extends ProgramError
 {
     public IllegalMonitorState()

Modified: trunk/abcl/src/org/armedbear/lisp/Interpreter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Interpreter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Interpreter.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.IOException;
@@ -40,7 +42,7 @@
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 
-public final class Interpreter extends Lisp
+public final class Interpreter extends LispTrampolinesFile
 {
     // There can only be one interpreter.
     public static Interpreter interpreter;
@@ -153,7 +155,7 @@
     // Interface.
     public LispObject eval(String s)
     {
-        return eval(new StringInputStream(s).read(true, NIL, false,
+        return Lisp.eval(new StringInputStream(s).read(true, NIL, false,
                                                   LispThread.currentThread()));
     }
 
@@ -334,7 +336,7 @@
                         break;
                     out.setCharPos(0);
                     Symbol.MINUS.setSymbolValue(object);
-                    LispObject result = eval(object, new Environment(), thread);
+                    LispObject result = Lisp.eval(object, new Environment(), thread);
                     Debug.assertTrue(result != null);
                     Symbol.STAR_STAR_STAR.setSymbolValue(Symbol.STAR_STAR.getSymbolValue());
                     Symbol.STAR_STAR.setSymbolValue(Symbol.STAR.getSymbolValue());
@@ -538,7 +540,7 @@
         final SpecialBindingsMark mark = thread.markSpecialBindings();
         thread.bindSpecial(Symbol.DEBUGGER_HOOK, _DEBUGGER_HOOK_FUNCTION);
         try {
-            return eval(obj, new Environment(), thread);
+            return Lisp.eval(obj, new Environment(), thread);
         }
         finally {
             thread.resetSpecialBindings(mark);

Modified: trunk/abcl/src/org/armedbear/lisp/JHandler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JHandler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JHandler.java	Sun Nov 29 17:00:12 2009
@@ -33,11 +33,13 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.WeakHashMap;
 
-public final class JHandler extends Lisp
+public final class JHandler extends LispTrampolinesFile
 {
     private static final Map<Object,Map<String,Entry>> table =
        new WeakHashMap<Object,Map<String,Entry>>();
@@ -80,7 +82,7 @@
                 }
                 LispObject lispAsVector = new SimpleVector(lispAs);
                 LispObject[] args = new LispObject[] //FIXME: count -> seq_num
-                { data, new JavaObject(o), lispAiVector, lispAsVector, Keyword.internKeyword(s), count };
+                { data, new JavaObject(o), lispAiVector, lispAsVector, internKeyword(s), count };
                 f.execute(args);
             }
         }

Modified: trunk/abcl/src/org/armedbear/lisp/JProxy.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JProxy.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JProxy.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
@@ -40,7 +42,7 @@
 import java.util.Map;
 import java.util.WeakHashMap;
 
-public final class JProxy extends Lisp
+public final class JProxy extends LispTrampolinesFile
 {
   private static final Map<Object,Entry> table = new WeakHashMap<Object,Entry>();
 

Modified: trunk/abcl/src/org/armedbear/lisp/Java.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Java.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Java.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.beans.BeanInfo;
 import java.beans.IntrospectionException;
 import java.beans.Introspector;
@@ -46,7 +48,7 @@
 import java.util.HashMap;
 import java.util.Map;
 
-public final class Java extends Lisp
+public final class Java extends LispTrampolinesFile
 {
     private static final Map<Class,Symbol> registeredExceptions =
        new HashMap<Class,Symbol>();

Modified: trunk/abcl/src/org/armedbear/lisp/JavaClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaClass.java	Sun Nov 29 17:00:12 2009
@@ -21,6 +21,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;

Modified: trunk/abcl/src/org/armedbear/lisp/JavaException.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaException.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaException.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.PrintWriter;
 import java.io.StringWriter;
 

Modified: trunk/abcl/src/org/armedbear/lisp/JavaObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaObject.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.lang.reflect.*;
 
 import java.math.BigInteger;

Modified: trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class JavaStackFrame 
   extends StackFrame
 {
@@ -69,11 +71,11 @@
      return super.typep(typeSpecifier);
    }
 
-  static final Symbol CLASS = Packages.internKeyword("CLASS");
-  static final Symbol METHOD = Packages.internKeyword("METHOD");
-  static final Symbol FILE = Packages.internKeyword("FILE");
-  static final Symbol LINE = Packages.internKeyword("LINE");
-  static final Symbol NATIVE_METHOD = Packages.internKeyword("NATIVE-METHOD");
+  static final Symbol CLASS = internKeyword("CLASS");
+  static final Symbol METHOD = internKeyword("METHOD");
+  static final Symbol FILE = internKeyword("FILE");
+  static final Symbol LINE = internKeyword("LINE");
+  static final Symbol NATIVE_METHOD = internKeyword("NATIVE-METHOD");
 
   public LispObject toLispList()
   {

Modified: trunk/abcl/src/org/armedbear/lisp/Keyword.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Keyword.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Keyword.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class Keyword extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class Keyword extends LispTrampolinesFile
 {
     public static final Symbol
         ABCL                = internKeyword("ABCL"),

Modified: trunk/abcl/src/org/armedbear/lisp/Layout.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Layout.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Layout.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class Layout extends LispObject
 {
   public final LispClass lispClass;

Modified: trunk/abcl/src/org/armedbear/lisp/Lisp.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Lisp.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Lisp.java	Sun Nov 29 17:00:12 2009
@@ -46,7 +46,7 @@
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
-public abstract class Lisp
+public final class Lisp
 {
   public static final boolean debug = true;
 
@@ -380,7 +380,7 @@
     return error(new TypeError(datum, expectedType));
   }
 
-  protected static volatile boolean interrupted;
+  public static volatile boolean interrupted;
 
   public static synchronized final void setInterrupted(boolean b)
   {
@@ -490,7 +490,7 @@
   public static final int CALL_REGISTERS_MAX = 8;
 
   // Also used in JProxy.java.
-  protected static final LispObject evalCall(LispObject function,
+  public static final LispObject evalCall(LispObject function,
                                              LispObject args,
                                              Environment env,
                                              LispThread thread)
@@ -818,7 +818,7 @@
     return false;
   }
 
-  protected static final void bindArg(LispObject ownSpecials,
+  public static final void bindArg(LispObject ownSpecials,
                                       Symbol sym, LispObject value,
                                       Environment env, LispThread thread)
 
@@ -1834,7 +1834,7 @@
     return null;
   }
 
-  public LispObject assq(LispObject item, LispObject alist)
+  public static LispObject assq(LispObject item, LispObject alist)
 
   {
     while (alist instanceof Cons)

Modified: trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispCharacter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispCharacter.java	Sun Nov 29 17:00:12 2009
@@ -32,6 +32,8 @@
  */
 
 package org.armedbear.lisp;
+
+import static org.armedbear.lisp.Lisp.*;
 import java.util.HashMap;
 import java.util.Map;
 

Modified: trunk/abcl/src/org/armedbear/lisp/LispClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class LispClass extends StandardObject
 {
   private static final EqHashTable map = new EqHashTable(256, NIL, NIL);

Modified: trunk/abcl/src/org/armedbear/lisp/LispError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class LispError extends SeriousCondition
 {
   public LispError()

Modified: trunk/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispObject.java	Sun Nov 29 17:00:12 2009
@@ -33,9 +33,10 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
 import java.util.WeakHashMap;
 
-public class LispObject extends Lisp
+public class LispObject //extends Lisp
 {
   public LispObject typeOf()
   {

Modified: trunk/abcl/src/org/armedbear/lisp/LispReader.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispReader.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispReader.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class LispReader extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class LispReader extends LispTrampolinesFile
 {
     // ### read-comment
     public static final ReaderMacroFunction READ_COMMENT =

Modified: trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class LispStackFrame 
   extends StackFrame
 {

Modified: trunk/abcl/src/org/armedbear/lisp/LispThread.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispThread.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispThread.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -1096,14 +1098,14 @@
     static {
         //FIXME: this block has been added for pre-0.16 compatibility
         // and can be removed the latest at release 0.22
-        PACKAGE_EXT.export(Symbol.intern("MAKE-THREAD", PACKAGE_THREADS));
-        PACKAGE_EXT.export(Symbol.intern("THREADP", PACKAGE_THREADS));
-        PACKAGE_EXT.export(Symbol.intern("THREAD-ALIVE-P", PACKAGE_THREADS));
-        PACKAGE_EXT.export(Symbol.intern("THREAD-NAME", PACKAGE_THREADS));
-        PACKAGE_EXT.export(Symbol.intern("MAPCAR-THREADS", PACKAGE_THREADS));
-        PACKAGE_EXT.export(Symbol.intern("DESTROY-THREAD", PACKAGE_THREADS));
-        PACKAGE_EXT.export(Symbol.intern("INTERRUPT-THREAD", PACKAGE_THREADS));
-        PACKAGE_EXT.export(Symbol.intern("CURRENT-THREAD", PACKAGE_THREADS));
+        PACKAGE_EXT.export(intern("MAKE-THREAD", PACKAGE_THREADS));
+        PACKAGE_EXT.export(intern("THREADP", PACKAGE_THREADS));
+        PACKAGE_EXT.export(intern("THREAD-ALIVE-P", PACKAGE_THREADS));
+        PACKAGE_EXT.export(intern("THREAD-NAME", PACKAGE_THREADS));
+        PACKAGE_EXT.export(intern("MAPCAR-THREADS", PACKAGE_THREADS));
+        PACKAGE_EXT.export(intern("DESTROY-THREAD", PACKAGE_THREADS));
+        PACKAGE_EXT.export(intern("INTERRUPT-THREAD", PACKAGE_THREADS));
+        PACKAGE_EXT.export(intern("CURRENT-THREAD", PACKAGE_THREADS));
     }
 
     // ### use-fast-calls

Modified: trunk/abcl/src/org/armedbear/lisp/Load.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Load.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Load.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -64,7 +66,7 @@
  *    ._ file with FASL loading instructions.
  */
 
-public final class Load extends Lisp
+public final class Load extends LispTrampolinesFile
 {
     public static final LispObject load(String filename)
 

Modified: trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.HashMap;
 import java.util.StringTokenizer;
 

Modified: trunk/abcl/src/org/armedbear/lisp/MacroObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/MacroObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/MacroObject.java	Sun Nov 29 17:00:12 2009
@@ -33,9 +33,11 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class MacroObject extends Function
 {
-  private final LispObject name;
+  protected final LispObject name;
   public final LispObject expander;
 
   public MacroObject(LispObject name, LispObject expander)

Modified: trunk/abcl/src/org/armedbear/lisp/MathFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/MathFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/MathFunctions.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class MathFunctions extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class MathFunctions extends LispTrampolinesFile
 {
     // ### sin
     private static final Primitive SIN = new Primitive("sin", "radians")

Modified: trunk/abcl/src/org/armedbear/lisp/Nil.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Nil.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Nil.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class Nil extends Symbol
 {
     final static Nil NIL = new Nil(PACKAGE_CL);

Modified: trunk/abcl/src/org/armedbear/lisp/NilVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/NilVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/NilVector.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class NilVector extends AbstractString
 {
     private int capacity;

Modified: trunk/abcl/src/org/armedbear/lisp/Operator.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Operator.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Operator.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class Operator extends LispObject
 {
     protected LispObject lambdaName;

Modified: trunk/abcl/src/org/armedbear/lisp/Package.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Package.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Package.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;

Modified: trunk/abcl/src/org/armedbear/lisp/PackageError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/PackageError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/PackageError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class PackageError extends LispError
 {
     public PackageError(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class PackageFunctions extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class PackageFunctions extends LispTrampolinesFile
 {
     // ### packagep
     // packagep object => generalized-boolean

Modified: trunk/abcl/src/org/armedbear/lisp/Packages.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Packages.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Packages.java	Sun Nov 29 17:00:12 2009
@@ -33,12 +33,14 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 
-public final class Packages extends Lisp
+public final class Packages extends LispTrampolinesFile
 {
   private static final ArrayList<Package> packages = new ArrayList<Package>();
   private static final HashMap<String,Package> map = new HashMap<String,Package>();

Modified: trunk/abcl/src/org/armedbear/lisp/ParseError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ParseError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ParseError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ParseError extends LispError
 {
     public ParseError(String message)

Modified: trunk/abcl/src/org/armedbear/lisp/Pathname.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Pathname.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Pathname.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.io.IOException;
 import java.net.URL;

Modified: trunk/abcl/src/org/armedbear/lisp/Primitives.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Primitives.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Primitives.java	Sun Nov 29 17:00:12 2009
@@ -33,10 +33,12 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 import java.util.ArrayList;
 
-public final class Primitives extends Lisp
+public final class Primitives extends LispTrampolinesFile
 {
   // ### *
   public static final Primitive MULTIPLY =

Modified: trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class PrintNotReadable extends LispError
 {
     public PrintNotReadable(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/Profiler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Profiler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Profiler.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public class Profiler extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public class Profiler extends LispTrampolinesFile
 {
     private static int sleep = 1;
 

Modified: trunk/abcl/src/org/armedbear/lisp/ProgramError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ProgramError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ProgramError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class ProgramError extends LispError
 {
     protected ProgramError(LispClass cls)

Modified: trunk/abcl/src/org/armedbear/lisp/RandomState.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/RandomState.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/RandomState.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;

Modified: trunk/abcl/src/org/armedbear/lisp/Ratio.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Ratio.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Ratio.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 public final class Ratio extends LispObject

Modified: trunk/abcl/src/org/armedbear/lisp/ReaderError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ReaderError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ReaderError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ReaderError extends StreamError
 {
     public ReaderError(String message)

Modified: trunk/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class ReaderMacroFunction extends Function
 {
     public ReaderMacroFunction(String name)

Modified: trunk/abcl/src/org/armedbear/lisp/Readtable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Readtable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Readtable.java	Sun Nov 29 17:00:12 2009
@@ -32,6 +32,8 @@
  */
 
 package org.armedbear.lisp;
+
+import static org.armedbear.lisp.Lisp.*;
 import java.util.Iterator;
 
 public class Readtable extends LispObject

Modified: trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java	Sun Nov 29 17:00:12 2009
@@ -33,11 +33,13 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.util.Map;
 import java.util.HashMap;
 
-public class RuntimeClass extends Lisp
+public class RuntimeClass extends LispTrampolinesFile
 {
     private static Map<String,RuntimeClass> classes = new HashMap<String,RuntimeClass>();
 

Modified: trunk/abcl/src/org/armedbear/lisp/SeriousCondition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SeriousCondition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SeriousCondition.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class SeriousCondition extends Condition
 {
     public SeriousCondition()

Modified: trunk/abcl/src/org/armedbear/lisp/ShellCommand.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ShellCommand.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ShellCommand.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
@@ -40,7 +42,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public final class ShellCommand extends Lisp implements Runnable
+public final class ShellCommand extends LispTrampolinesFile implements Runnable
 {
     private final String command;
     private final String directory;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SimpleArray_T extends AbstractArray
 {
   private final int[] dimv;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SimpleArray_UnsignedByte16 extends AbstractArray
 {
     private final int[] dimv;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SimpleArray_UnsignedByte32 extends AbstractArray
 {
     private final int[] dimv;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SimpleArray_UnsignedByte8 extends AbstractArray
 {
     private final int[] dimv;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // "The type of a bit vector that is not displaced to another array, has no
 // fill pointer, and is not expressly adjustable is a subtype of type SIMPLE-
 // BIT-VECTOR."

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleCondition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleCondition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleCondition.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class SimpleCondition extends Condition
 {
     public SimpleCondition()

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SimpleError extends LispError
 {
     public SimpleError(LispObject formatControl, LispObject formatArguments)

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleString.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleString.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleString.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SimpleString extends AbstractString
 {
     private int capacity;

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SimpleTypeError extends TypeError
 {
     public SimpleTypeError(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleVector.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleVector.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleVector.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // "The type of a vector that is not displaced to another array, has no fill
 // pointer, is not expressly adjustable and is able to hold elements of any
 // type is a subtype of type SIMPLE-VECTOR."

Modified: trunk/abcl/src/org/armedbear/lisp/SimpleWarning.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SimpleWarning.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SimpleWarning.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SimpleWarning extends Warning
 {
     public SimpleWarning(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/SingleFloat.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SingleFloat.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SingleFloat.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 public final class SingleFloat extends LispObject

Modified: trunk/abcl/src/org/armedbear/lisp/Site.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Site.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Site.java	Sun Nov 29 17:00:12 2009
@@ -33,11 +33,13 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.net.URL;
 import java.net.URLDecoder;
 
-public final class Site extends Lisp
+public final class Site extends LispTrampolinesFile
 {
     private static final String LISP_HOME;
 

Modified: trunk/abcl/src/org/armedbear/lisp/SiteName.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SiteName.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SiteName.java	Sun Nov 29 17:00:12 2009
@@ -33,9 +33,11 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.net.InetAddress;
 
-public final class SiteName extends Lisp
+public final class SiteName extends LispTrampolinesFile
 {
     private static LispObject getHostName()
     {

Modified: trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class SlimeInputStream extends Stream
 {
     String s;

Modified: trunk/abcl/src/org/armedbear/lisp/SlimeOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlimeOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlimeOutputStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.StringWriter;
 
 public final class SlimeOutputStream extends Stream

Modified: trunk/abcl/src/org/armedbear/lisp/SlotClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlotClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlotClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class SlotClass extends LispClass
 {
     private LispObject directSlotDefinitions = NIL;

Modified: trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SlotDefinition extends StandardObject
 {
   public SlotDefinition()

Modified: trunk/abcl/src/org/armedbear/lisp/SlotDefinitionClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SlotDefinitionClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SlotDefinitionClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SlotDefinitionClass extends StandardClass
 {
     public static final int SLOT_INDEX_NAME             = 0;

Modified: trunk/abcl/src/org/armedbear/lisp/SocketStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SocketStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SocketStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.net.Socket;
 
 public final class SocketStream extends TwoWayStream

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class SpecialOperator extends Operator
 {
     private int callCount;

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java	Sun Nov 29 17:00:12 2009
@@ -33,9 +33,11 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.ArrayList;
 import java.util.LinkedList;
-public final class SpecialOperators extends Lisp
+public final class SpecialOperators extends LispTrampolinesFile
 {
   // ### quote
   private static final SpecialOperator QUOTE =
@@ -502,7 +504,7 @@
       public LispObject execute(LispObject args, Environment env)
 
       {
-        LispObject value = Symbol.NIL;
+        LispObject value = Nil.NIL;
         final LispThread thread = LispThread.currentThread();
         while (args != NIL)
           {

Modified: trunk/abcl/src/org/armedbear/lisp/StackFrame.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StackFrame.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StackFrame.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public abstract class StackFrame 
   extends LispObject
 {

Modified: trunk/abcl/src/org/armedbear/lisp/StandardClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class StandardClass extends SlotClass
 {
   public StandardClass()

Modified: trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.util.HashMap;
 
 public final class StandardGenericFunction extends StandardObject

Modified: trunk/abcl/src/org/armedbear/lisp/StandardGenericFunctionClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardGenericFunctionClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardGenericFunctionClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class StandardGenericFunctionClass extends StandardClass
 {
   public static final int SLOT_INDEX_NAME                      = 0;

Modified: trunk/abcl/src/org/armedbear/lisp/StandardMethod.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardMethod.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardMethod.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class StandardMethod extends StandardObject
 {
   public StandardMethod()

Modified: trunk/abcl/src/org/armedbear/lisp/StandardMethodClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardMethodClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardMethodClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class StandardMethodClass extends StandardClass
 {
   public static final int SLOT_INDEX_GENERIC_FUNCTION = 0;

Modified: trunk/abcl/src/org/armedbear/lisp/StandardObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardObject.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class StandardObject extends LispObject
 {
   protected Layout layout;

Modified: trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public class StandardObjectFunctions extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public class StandardObjectFunctions extends LispTrampolinesFile
 {
   // ### std-allocate-instance class => instance
   private static final Primitive STD_ALLOCATE_INSTANCE =

Modified: trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class StandardReaderMethod extends StandardMethod
 {
   public StandardReaderMethod()

Modified: trunk/abcl/src/org/armedbear/lisp/StandardReaderMethodClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardReaderMethodClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardReaderMethodClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class StandardReaderMethodClass extends StandardClass
 {
   // From StandardMethodClass.java:

Modified: trunk/abcl/src/org/armedbear/lisp/StorageCondition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StorageCondition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StorageCondition.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class StorageCondition extends SeriousCondition
 {
   public StorageCondition()

Modified: trunk/abcl/src/org/armedbear/lisp/Stream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Stream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Stream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
@@ -90,22 +92,22 @@
     LF
   }
 
-  static final protected Symbol keywordDefault = Packages.internKeyword("DEFAULT");
+  static final protected Symbol keywordDefault = internKeyword("DEFAULT");
   
-  static final private Symbol keywordCodePage = Packages.internKeyword("CODE-PAGE");
-  static final private Symbol keywordID = Packages.internKeyword("ID");
+  static final private Symbol keywordCodePage = internKeyword("CODE-PAGE");
+  static final private Symbol keywordID = internKeyword("ID");
 
-  static final private Symbol keywordEolStyle = Packages.internKeyword("EOL-STYLE");
-  static final private Symbol keywordCR = Packages.internKeyword("CR");
-  static final private Symbol keywordLF = Packages.internKeyword("LF");
-  static final private Symbol keywordCRLF = Packages.internKeyword("CRLF");
-  static final private Symbol keywordRAW = Packages.internKeyword("RAW");
+  static final private Symbol keywordEolStyle = internKeyword("EOL-STYLE");
+  static final private Symbol keywordCR = internKeyword("CR");
+  static final private Symbol keywordLF = internKeyword("LF");
+  static final private Symbol keywordCRLF = internKeyword("CRLF");
+  static final private Symbol keywordRAW = internKeyword("RAW");
     
   public final static EolStyle platformEolStyle = Utilities.isPlatformWindows ? EolStyle.CRLF : EolStyle.LF;
     
   protected EolStyle eolStyle = platformEolStyle;
   protected char eolChar = (eolStyle == EolStyle.CR) ? '\r' : '\n';
-  protected LispObject externalFormat = LispObject.NIL;
+  protected LispObject externalFormat = NIL;
   protected String encoding = null;
   protected char lastChar = 0;
   
@@ -290,10 +292,10 @@
         if (enc == keywordCodePage) {
             encIsCp = true;
 
-            enc = LispObject.getf(format.cdr(), keywordID, null);
+            enc = getf(format.cdr(), keywordID, null);
         }
           
-        LispObject eol = LispObject.getf(format.cdr(), keywordEolStyle, keywordRAW);
+        LispObject eol = getf(format.cdr(), keywordEolStyle, keywordRAW);
         if (eol == keywordCR)
             eolStyle = EolStyle.CR;
         else if (eol == keywordLF)

Modified: trunk/abcl/src/org/armedbear/lisp/StreamError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StreamError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StreamError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class StreamError extends LispError
 {
     private final Throwable cause;

Modified: trunk/abcl/src/org/armedbear/lisp/StringFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StringFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StringFunctions.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class StringFunctions extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class StringFunctions extends LispTrampolinesFile
 {
     // ### %string=
     // Case sensitive.

Modified: trunk/abcl/src/org/armedbear/lisp/StringInputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StringInputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StringInputStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.StringReader;
 
 public final class StringInputStream extends Stream

Modified: trunk/abcl/src/org/armedbear/lisp/StringOutputStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StringOutputStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StringOutputStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.StringWriter;
 
 public final class StringOutputStream extends Stream

Modified: trunk/abcl/src/org/armedbear/lisp/StructureClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StructureClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StructureClass.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class StructureClass extends SlotClass
 {
     private StructureClass(Symbol symbol)

Modified: trunk/abcl/src/org/armedbear/lisp/StructureObject.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StructureObject.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StructureObject.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class StructureObject extends LispObject
 {
   private final StructureClass structureClass;

Modified: trunk/abcl/src/org/armedbear/lisp/StyleWarning.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StyleWarning.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StyleWarning.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class StyleWarning extends Warning
 {
     public StyleWarning(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/Symbol.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Symbol.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Symbol.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class Symbol extends LispObject
 {
   // Bit flags.

Modified: trunk/abcl/src/org/armedbear/lisp/SynonymStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SynonymStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SynonymStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class SynonymStream extends Stream
 {
     private final Symbol symbol;

Modified: trunk/abcl/src/org/armedbear/lisp/Time.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Time.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Time.java	Sun Nov 29 17:00:12 2009
@@ -33,11 +33,13 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.lang.reflect.Method;
 import java.util.Date;
 import java.util.TimeZone;
 
-public final class Time extends Lisp
+public final class Time extends LispTrampolinesFile
 {
 
   // ### %time

Modified: trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class TwoWayStream extends Stream
 {
     public final Stream in;

Modified: trunk/abcl/src/org/armedbear/lisp/TypeError.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/TypeError.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/TypeError.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class TypeError extends LispError
 {
     public TypeError()

Modified: trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class UnboundSlot extends CellError
 {
     public UnboundSlot(LispObject initArgs)

Modified: trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class UnboundVariable extends CellError
 {
   // obj is either the unbound variable itself or an initArgs list.

Modified: trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class UndefinedFunction extends CellError
 {
   // obj is either the name of the undefined function or an initArgs list.

Modified: trunk/abcl/src/org/armedbear/lisp/Utilities.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Utilities.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Utilities.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -42,7 +44,7 @@
 import java.util.zip.ZipFile;
 import java.util.zip.ZipInputStream;
 
-public final class Utilities extends Lisp
+public final class Utilities extends LispTrampolinesFile
 {
     public static final boolean isPlatformUnix;
     public static final boolean isPlatformWindows;

Modified: trunk/abcl/src/org/armedbear/lisp/Warning.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Warning.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Warning.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public class Warning extends Condition
 {
     protected Warning()

Modified: trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class WrongNumberOfArgumentsException extends ProgramError
 {
     private final Operator operator;

Modified: trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class ZeroRankArray extends AbstractArray
 {
     private final LispObject elementType;

Modified: trunk/abcl/src/org/armedbear/lisp/adjust_array.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/adjust_array.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/adjust_array.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### %adjust-array array new-dimensions element-type initial-element
 // initial-element-p initial-contents initial-contents-p fill-pointer
 // displaced-to displaced-index-offset => new-array

Modified: trunk/abcl/src/org/armedbear/lisp/arglist.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/arglist.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/arglist.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class arglist extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class arglist extends LispTrampolinesFile
 {
     private static final Operator getOperator(LispObject obj)
 

Modified: trunk/abcl/src/org/armedbear/lisp/assq.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/assq.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/assq.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### assq item alist => entry
 public final class assq extends Primitive
 {
@@ -45,7 +47,7 @@
     public LispObject execute(LispObject item, LispObject alist)
 
     {
-        return assq(item, alist);
+        return Lisp.assq(item, alist);
     }
 
     private static final Primitive ASSQ = new assq();

Modified: trunk/abcl/src/org/armedbear/lisp/assql.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/assql.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/assql.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### assql item alist => entry
 public final class assql extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/cell_error_name.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/cell_error_name.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/cell_error_name.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### cell-error-name
 public final class cell_error_name extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/copy_list.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/copy_list.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/copy_list.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### copy-list list => copy
 public final class copy_list extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/create_new_file.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/create_new_file.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/create_new_file.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.io.IOException;
 

Modified: trunk/abcl/src/org/armedbear/lisp/cxr.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/cxr.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/cxr.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class cxr extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class cxr extends LispTrampolinesFile
 {
   // ### set-car
   private static final Primitive SET_CAR =

Modified: trunk/abcl/src/org/armedbear/lisp/delete_file.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/delete_file.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/delete_file.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.io.IOException;
 

Modified: trunk/abcl/src/org/armedbear/lisp/disassemble_class_bytes.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/disassemble_class_bytes.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/disassemble_class_bytes.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;

Modified: trunk/abcl/src/org/armedbear/lisp/dolist.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/dolist.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/dolist.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### dolist
 public final class dolist extends SpecialOperator
 {

Modified: trunk/abcl/src/org/armedbear/lisp/dotimes.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/dotimes.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/dotimes.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class dotimes extends SpecialOperator
 {
   private dotimes()

Modified: trunk/abcl/src/org/armedbear/lisp/file_author.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_author.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_author.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 
 // ### file-author

Modified: trunk/abcl/src/org/armedbear/lisp/file_error_pathname.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_error_pathname.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_error_pathname.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### file-error-pathname
 public final class file_error_pathname extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/file_length.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_length.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_length.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class file_length extends Primitive
 {
     private file_length()

Modified: trunk/abcl/src/org/armedbear/lisp/file_string_length.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_string_length.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_string_length.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### file-string-length
 public final class file_string_length extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/file_write_date.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/file_write_date.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/file_write_date.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 
 // ### file-write-date

Modified: trunk/abcl/src/org/armedbear/lisp/float_sign.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/float_sign.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/float_sign.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### float-sign
 public final class float_sign extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/function_info.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/function_info.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/function_info.java	Sun Nov 29 17:00:12 2009
@@ -33,7 +33,9 @@
 
 package org.armedbear.lisp;
 
-public final class function_info extends Lisp
+import static org.armedbear.lisp.Lisp.*;
+
+public final class function_info extends LispTrampolinesFile
 {
     private static EqualHashTable FUNCTION_TABLE =
         new EqualHashTable(64, NIL, NIL);

Modified: trunk/abcl/src/org/armedbear/lisp/gc.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/gc.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/gc.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### gc
 public final class gc extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/get_properties.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/get_properties.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/get_properties.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### get-properties
 public final class get_properties extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/input_stream_p.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/input_stream_p.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/input_stream_p.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### input-stream-p
 public final class input_stream_p extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/interactive_stream_p.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/interactive_stream_p.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/interactive_stream_p.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### interactive-stream-p
 public final class interactive_stream_p extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/jclass_name.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/jclass_name.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/jclass_name.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### jclass-name class-ref &optional name
 public final class jclass_name extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/jclass_of.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/jclass_of.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/jclass_of.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### jclass-of object &optional name
 public final class jclass_of extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.lang.reflect.Method;
 
 // ### jmethod-return-type method => class

Modified: trunk/abcl/src/org/armedbear/lisp/last.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/last.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/last.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### last list &optional n => tail
 public final class last extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/listen.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/listen.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/listen.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### listen
 public final class listen extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/logand.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logand.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logand.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 // ### logand &rest integers => result-integer

Modified: trunk/abcl/src/org/armedbear/lisp/logandc1.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logandc1.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logandc1.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 public final class logandc1 extends Primitive

Modified: trunk/abcl/src/org/armedbear/lisp/logandc2.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logandc2.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logandc2.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 // ### logandc2

Modified: trunk/abcl/src/org/armedbear/lisp/logbitp.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logbitp.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logbitp.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 // ### logbitp index integer => generalized-boolean

Modified: trunk/abcl/src/org/armedbear/lisp/logcount.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logcount.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logcount.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 // ### logcount integer => number-of-on-bits

Modified: trunk/abcl/src/org/armedbear/lisp/logeqv.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logeqv.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logeqv.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 // ### logeqv

Modified: trunk/abcl/src/org/armedbear/lisp/logior.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logior.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logior.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### logior &rest integers => result-integer
 public final class logior extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/lognand.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/lognand.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/lognand.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 public final class lognand extends Primitive

Modified: trunk/abcl/src/org/armedbear/lisp/lognor.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/lognor.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/lognor.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 public final class lognor extends Primitive

Modified: trunk/abcl/src/org/armedbear/lisp/logorc1.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logorc1.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logorc1.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 // ### logorc1

Modified: trunk/abcl/src/org/armedbear/lisp/logorc2.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logorc2.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logorc2.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 // ### logorc2

Modified: trunk/abcl/src/org/armedbear/lisp/logtest.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logtest.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logtest.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.math.BigInteger;
 
 // ### logtest integer-1 integer-2 => generalized-boolean

Modified: trunk/abcl/src/org/armedbear/lisp/logxor.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/logxor.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/logxor.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### logxor &rest integers => result-integer
 public final class logxor extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/machine_version.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/machine_version.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/machine_version.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.BufferedReader;
 import java.io.FileInputStream;
 import java.io.IOException;

Modified: trunk/abcl/src/org/armedbear/lisp/make_array.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/make_array.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/make_array.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### %make-array dimensions element-type initial-element initial-element-p
 // initial-contents adjustable fill-pointer displaced-to displaced-index-offset
 // => new-array

Modified: trunk/abcl/src/org/armedbear/lisp/make_condition.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/make_condition.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/make_condition.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 public final class make_condition extends Primitive
 {
     private make_condition()

Modified: trunk/abcl/src/org/armedbear/lisp/make_server_socket.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/make_server_socket.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/make_server_socket.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.net.ServerSocket;
 
 // ### %make-server-socket

Modified: trunk/abcl/src/org/armedbear/lisp/make_socket.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/make_socket.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/make_socket.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.net.Socket;
 
 // ### %make-socket

Modified: trunk/abcl/src/org/armedbear/lisp/open_stream_p.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/open_stream_p.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/open_stream_p.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### open-stream-p
 public final class open_stream_p extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/output_stream_p.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/output_stream_p.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/output_stream_p.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### output-stream-p
 public final class output_stream_p extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/package_error_package.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/package_error_package.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/package_error_package.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### package-error-package
 public final class package_error_package extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/peek_char.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/peek_char.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/peek_char.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### peek-char
 public final class peek_char extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/probe_file.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/probe_file.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/probe_file.java	Sun Nov 29 17:00:12 2009
@@ -33,9 +33,11 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 
-public final class probe_file extends Lisp
+public final class probe_file extends LispTrampolinesFile
 {
     // ### probe-file
     // probe-file pathspec => truename

Modified: trunk/abcl/src/org/armedbear/lisp/room.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/room.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/room.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### room
 public final class room extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/server_socket_close.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/server_socket_close.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/server_socket_close.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.net.ServerSocket;
 
 // ### %server-socket-close

Modified: trunk/abcl/src/org/armedbear/lisp/simple_list_remove_duplicates.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/simple_list_remove_duplicates.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/simple_list_remove_duplicates.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### simple-list-remove-duplicates
 public final class simple_list_remove_duplicates extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/socket_accept.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/socket_accept.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/socket_accept.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.net.ServerSocket;
 import java.net.Socket;
 

Modified: trunk/abcl/src/org/armedbear/lisp/socket_close.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/socket_close.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/socket_close.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.net.Socket;
 
 // ### %socket-close

Modified: trunk/abcl/src/org/armedbear/lisp/socket_stream.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/socket_stream.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/socket_stream.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.net.Socket;
 
 // ### %socket-stream

Modified: trunk/abcl/src/org/armedbear/lisp/stream_element_type.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/stream_element_type.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/stream_element_type.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### stream-element-type
 public final class stream_element_type extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/stream_external_format.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/stream_external_format.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/stream_external_format.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### stream-external-format
 public final class stream_external_format extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/unbound_slot_instance.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/unbound_slot_instance.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/unbound_slot_instance.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 // ### unbound-slot-instance
 public final class unbound_slot_instance extends Primitive
 {

Modified: trunk/abcl/src/org/armedbear/lisp/zip.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/zip.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/zip.java	Sun Nov 29 17:00:12 2009
@@ -33,6 +33,8 @@
 
 package org.armedbear.lisp;
 
+import static org.armedbear.lisp.Lisp.*;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;



From vvoutilainen at common-lisp.net  Mon Nov 30 16:40:17 2009
From: vvoutilainen at common-lisp.net (Ville Voutilainen)
Date: Mon, 30 Nov 2009 11:40:17 -0500
Subject: [armedbear-cvs] r12289 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NF9IP-00016v-KU@common-lisp.net>

Author: vvoutilainen
Date: Mon Nov 30 11:40:14 2009
New Revision: 12289

Log:
Add missing file.


Added:
   trunk/abcl/src/org/armedbear/lisp/LispTrampolinesFile.java

Added: trunk/abcl/src/org/armedbear/lisp/LispTrampolinesFile.java
==============================================================================
--- (empty file)
+++ trunk/abcl/src/org/armedbear/lisp/LispTrampolinesFile.java	Mon Nov 30 11:40:14 2009
@@ -0,0 +1,5 @@
+package org.armedbear.lisp;
+
+abstract public class LispTrampolinesFile {
+
+}



From vvoutilainen at common-lisp.net  Mon Nov 30 22:28:53 2009
From: vvoutilainen at common-lisp.net (Ville Voutilainen)
Date: Mon, 30 Nov 2009 17:28:53 -0500
Subject: [armedbear-cvs] r12290 - trunk/abcl/src/org/armedbear/lisp
Message-ID: <E1NFEjl-0006T1-BX@common-lisp.net>

Author: vvoutilainen
Date: Mon Nov 30 17:28:50 2009
New Revision: 12290

Log:
Remove LispTrampolinesFile and all references to it.


Removed:
   trunk/abcl/src/org/armedbear/lisp/LispTrampolinesFile.java
Modified:
   trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Do.java
   trunk/abcl/src/org/armedbear/lisp/Extensions.java
   trunk/abcl/src/org/armedbear/lisp/FaslReader.java
   trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java
   trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Interpreter.java
   trunk/abcl/src/org/armedbear/lisp/JHandler.java
   trunk/abcl/src/org/armedbear/lisp/JProxy.java
   trunk/abcl/src/org/armedbear/lisp/Java.java
   trunk/abcl/src/org/armedbear/lisp/Keyword.java
   trunk/abcl/src/org/armedbear/lisp/LispReader.java
   trunk/abcl/src/org/armedbear/lisp/Load.java
   trunk/abcl/src/org/armedbear/lisp/MathFunctions.java
   trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Packages.java
   trunk/abcl/src/org/armedbear/lisp/Primitives.java
   trunk/abcl/src/org/armedbear/lisp/Profiler.java
   trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java
   trunk/abcl/src/org/armedbear/lisp/ShellCommand.java
   trunk/abcl/src/org/armedbear/lisp/Site.java
   trunk/abcl/src/org/armedbear/lisp/SiteName.java
   trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
   trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java
   trunk/abcl/src/org/armedbear/lisp/StringFunctions.java
   trunk/abcl/src/org/armedbear/lisp/Time.java
   trunk/abcl/src/org/armedbear/lisp/Utilities.java
   trunk/abcl/src/org/armedbear/lisp/arglist.java
   trunk/abcl/src/org/armedbear/lisp/cxr.java
   trunk/abcl/src/org/armedbear/lisp/function_info.java
   trunk/abcl/src/org/armedbear/lisp/probe_file.java

Modified: trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class CharacterFunctions extends LispTrampolinesFile
+public final class CharacterFunctions
 {
     // ### char=
     private static final Primitive CHAR_EQUALS =

Modified: trunk/abcl/src/org/armedbear/lisp/Do.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Do.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Do.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class Do extends LispTrampolinesFile
+public final class Do
 {
   // ### do
   private static final SpecialOperator DO =

Modified: trunk/abcl/src/org/armedbear/lisp/Extensions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Extensions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Extensions.java	Mon Nov 30 17:28:50 2009
@@ -38,7 +38,7 @@
 import java.io.File;
 import java.io.IOException;
 
-public final class Extensions extends LispTrampolinesFile
+public final class Extensions
 {
   // ### *ed-functions*
   public static final Symbol _ED_FUNCTIONS_ =

Modified: trunk/abcl/src/org/armedbear/lisp/FaslReader.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FaslReader.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FaslReader.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class FaslReader extends LispTrampolinesFile
+public final class FaslReader
 {
     // ### fasl-read-comment
     public static final ReaderMacroFunction FASL_READ_COMMENT =

Modified: trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java	Mon Nov 30 17:28:50 2009
@@ -37,7 +37,7 @@
 
 import java.math.BigInteger;
 
-public final class FloatFunctions extends LispTrampolinesFile
+public final class FloatFunctions
 {
     // ### set-floating-point-modes &key traps => <no values>
     private static final Primitive SET_FLOATING_POINT_MODES =

Modified: trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class HashTableFunctions extends LispTrampolinesFile
+public final class HashTableFunctions
 {
   private static final LispObject FUNCTION_EQ =
     Symbol.EQ.getSymbolFunction();

Modified: trunk/abcl/src/org/armedbear/lisp/Interpreter.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Interpreter.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Interpreter.java	Mon Nov 30 17:28:50 2009
@@ -42,7 +42,7 @@
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 
-public final class Interpreter extends LispTrampolinesFile
+public final class Interpreter
 {
     // There can only be one interpreter.
     public static Interpreter interpreter;

Modified: trunk/abcl/src/org/armedbear/lisp/JHandler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JHandler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JHandler.java	Mon Nov 30 17:28:50 2009
@@ -39,7 +39,7 @@
 import java.util.Map;
 import java.util.WeakHashMap;
 
-public final class JHandler extends LispTrampolinesFile
+public final class JHandler
 {
     private static final Map<Object,Map<String,Entry>> table =
        new WeakHashMap<Object,Map<String,Entry>>();

Modified: trunk/abcl/src/org/armedbear/lisp/JProxy.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/JProxy.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/JProxy.java	Mon Nov 30 17:28:50 2009
@@ -42,7 +42,7 @@
 import java.util.Map;
 import java.util.WeakHashMap;
 
-public final class JProxy extends LispTrampolinesFile
+public final class JProxy
 {
   private static final Map<Object,Entry> table = new WeakHashMap<Object,Entry>();
 

Modified: trunk/abcl/src/org/armedbear/lisp/Java.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Java.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Java.java	Mon Nov 30 17:28:50 2009
@@ -48,7 +48,7 @@
 import java.util.HashMap;
 import java.util.Map;
 
-public final class Java extends LispTrampolinesFile
+public final class Java
 {
     private static final Map<Class,Symbol> registeredExceptions =
        new HashMap<Class,Symbol>();

Modified: trunk/abcl/src/org/armedbear/lisp/Keyword.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Keyword.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Keyword.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class Keyword extends LispTrampolinesFile
+public final class Keyword
 {
     public static final Symbol
         ABCL                = internKeyword("ABCL"),

Modified: trunk/abcl/src/org/armedbear/lisp/LispReader.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/LispReader.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/LispReader.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class LispReader extends LispTrampolinesFile
+public final class LispReader
 {
     // ### read-comment
     public static final ReaderMacroFunction READ_COMMENT =

Modified: trunk/abcl/src/org/armedbear/lisp/Load.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Load.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Load.java	Mon Nov 30 17:28:50 2009
@@ -66,7 +66,7 @@
  *    ._ file with FASL loading instructions.
  */
 
-public final class Load extends LispTrampolinesFile
+public final class Load
 {
     public static final LispObject load(String filename)
 

Modified: trunk/abcl/src/org/armedbear/lisp/MathFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/MathFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/MathFunctions.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class MathFunctions extends LispTrampolinesFile
+public final class MathFunctions
 {
     // ### sin
     private static final Primitive SIN = new Primitive("sin", "radians")

Modified: trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class PackageFunctions extends LispTrampolinesFile
+public final class PackageFunctions
 {
     // ### packagep
     // packagep object => generalized-boolean

Modified: trunk/abcl/src/org/armedbear/lisp/Packages.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Packages.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Packages.java	Mon Nov 30 17:28:50 2009
@@ -40,7 +40,7 @@
 import java.util.Iterator;
 import java.util.List;
 
-public final class Packages extends LispTrampolinesFile
+public final class Packages
 {
   private static final ArrayList<Package> packages = new ArrayList<Package>();
   private static final HashMap<String,Package> map = new HashMap<String,Package>();

Modified: trunk/abcl/src/org/armedbear/lisp/Primitives.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Primitives.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Primitives.java	Mon Nov 30 17:28:50 2009
@@ -38,7 +38,7 @@
 import java.math.BigInteger;
 import java.util.ArrayList;
 
-public final class Primitives extends LispTrampolinesFile
+public final class Primitives
 {
   // ### *
   public static final Primitive MULTIPLY =

Modified: trunk/abcl/src/org/armedbear/lisp/Profiler.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Profiler.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Profiler.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public class Profiler extends LispTrampolinesFile
+public class Profiler
 {
     private static int sleep = 1;
 

Modified: trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java	Mon Nov 30 17:28:50 2009
@@ -39,7 +39,7 @@
 import java.util.Map;
 import java.util.HashMap;
 
-public class RuntimeClass extends LispTrampolinesFile
+public class RuntimeClass
 {
     private static Map<String,RuntimeClass> classes = new HashMap<String,RuntimeClass>();
 

Modified: trunk/abcl/src/org/armedbear/lisp/ShellCommand.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/ShellCommand.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/ShellCommand.java	Mon Nov 30 17:28:50 2009
@@ -42,7 +42,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public final class ShellCommand extends LispTrampolinesFile implements Runnable
+public final class ShellCommand implements Runnable
 {
     private final String command;
     private final String directory;

Modified: trunk/abcl/src/org/armedbear/lisp/Site.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Site.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Site.java	Mon Nov 30 17:28:50 2009
@@ -39,7 +39,7 @@
 import java.net.URL;
 import java.net.URLDecoder;
 
-public final class Site extends LispTrampolinesFile
+public final class Site
 {
     private static final String LISP_HOME;
 

Modified: trunk/abcl/src/org/armedbear/lisp/SiteName.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SiteName.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SiteName.java	Mon Nov 30 17:28:50 2009
@@ -37,7 +37,7 @@
 
 import java.net.InetAddress;
 
-public final class SiteName extends LispTrampolinesFile
+public final class SiteName
 {
     private static LispObject getHostName()
     {

Modified: trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java	Mon Nov 30 17:28:50 2009
@@ -37,7 +37,7 @@
 
 import java.util.ArrayList;
 import java.util.LinkedList;
-public final class SpecialOperators extends LispTrampolinesFile
+public final class SpecialOperators
 {
   // ### quote
   private static final SpecialOperator QUOTE =

Modified: trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public class StandardObjectFunctions extends LispTrampolinesFile
+public class StandardObjectFunctions
 {
   // ### std-allocate-instance class => instance
   private static final Primitive STD_ALLOCATE_INSTANCE =

Modified: trunk/abcl/src/org/armedbear/lisp/StringFunctions.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/StringFunctions.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/StringFunctions.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class StringFunctions extends LispTrampolinesFile
+public final class StringFunctions
 {
     // ### %string=
     // Case sensitive.

Modified: trunk/abcl/src/org/armedbear/lisp/Time.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Time.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Time.java	Mon Nov 30 17:28:50 2009
@@ -39,7 +39,7 @@
 import java.util.Date;
 import java.util.TimeZone;
 
-public final class Time extends LispTrampolinesFile
+public final class Time
 {
 
   // ### %time

Modified: trunk/abcl/src/org/armedbear/lisp/Utilities.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/Utilities.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/Utilities.java	Mon Nov 30 17:28:50 2009
@@ -44,7 +44,7 @@
 import java.util.zip.ZipFile;
 import java.util.zip.ZipInputStream;
 
-public final class Utilities extends LispTrampolinesFile
+public final class Utilities
 {
     public static final boolean isPlatformUnix;
     public static final boolean isPlatformWindows;

Modified: trunk/abcl/src/org/armedbear/lisp/arglist.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/arglist.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/arglist.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class arglist extends LispTrampolinesFile
+public final class arglist
 {
     private static final Operator getOperator(LispObject obj)
 

Modified: trunk/abcl/src/org/armedbear/lisp/cxr.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/cxr.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/cxr.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class cxr extends LispTrampolinesFile
+public final class cxr
 {
   // ### set-car
   private static final Primitive SET_CAR =

Modified: trunk/abcl/src/org/armedbear/lisp/function_info.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/function_info.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/function_info.java	Mon Nov 30 17:28:50 2009
@@ -35,7 +35,7 @@
 
 import static org.armedbear.lisp.Lisp.*;
 
-public final class function_info extends LispTrampolinesFile
+public final class function_info
 {
     private static EqualHashTable FUNCTION_TABLE =
         new EqualHashTable(64, NIL, NIL);

Modified: trunk/abcl/src/org/armedbear/lisp/probe_file.java
==============================================================================
--- trunk/abcl/src/org/armedbear/lisp/probe_file.java	(original)
+++ trunk/abcl/src/org/armedbear/lisp/probe_file.java	Mon Nov 30 17:28:50 2009
@@ -37,7 +37,7 @@
 
 import java.io.File;
 
-public final class probe_file extends LispTrampolinesFile
+public final class probe_file
 {
     // ### probe-file
     // probe-file pathspec => truename