[armedbear-cvs] r11893 - branches/fewer-executes/abcl/src/org/armedbear/lisp
Erik Huelsmann
ehuelsmann at common-lisp.net
Mon May 18 18:02:43 UTC 2009
Author: ehuelsmann
Date: Mon May 18 14:02:39 2009
New Revision: 11893
Log:
As per Ville's request, upload the progress
with respect to the deletion of the execute methods.
Modified:
branches/fewer-executes/abcl/src/org/armedbear/lisp/AbstractArray.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Autoload.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Closure.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/CompiledFunction.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Condition.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Cons.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Function.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/HashTable.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Interpreter.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/JProxy.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Java.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/JavaException.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Lisp.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/LispObject.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/LispThread.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/LogicalPathname.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/MacroObject.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Primitive.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Primitives.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Profiler.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/SimpleCondition.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/SlimeInputStream.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/SlimeOutputStream.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/SlotClass.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/SpecialOperator.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardClass.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardObject.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Stream.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/StructureObject.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Symbol.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/Time.java
branches/fewer-executes/abcl/src/org/armedbear/lisp/ZeroRankArray.java
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/AbstractArray.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/AbstractArray.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/AbstractArray.java Mon May 18 14:02:39 2009
@@ -235,7 +235,7 @@
if (Symbol.PRINT_CIRCLE.symbolValue(thread) != NIL) {
StringOutputStream stream = new StringOutputStream();
thread.execute(Symbol.OUTPUT_OBJECT.getSymbolFunction(),
- AREF(index), stream);
+ new LispObject[] { AREF(index), stream });
sb.append(stream.getString().getStringValue());
} else
sb.append(AREF(index).writeToString());
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Autoload.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Autoload.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Autoload.java Mon May 18 14:02:39 2009
@@ -153,90 +153,6 @@
}
@Override
- public LispObject execute() throws ConditionThrowable
- {
- load();
- return symbol.execute();
- }
-
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- load();
- return symbol.execute(arg);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- load();
- return symbol.execute(first, second);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- load();
- return symbol.execute(first, second, third);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- throws ConditionThrowable
- {
- load();
- return symbol.execute(first, second, third, fourth);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- load();
- return symbol.execute(first, second, third, fourth, fifth);
- }
-
- @Override
- 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);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- load();
- return symbol.execute(first, second, third, fourth, fifth, sixth,
- seventh);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh, LispObject eighth)
- throws ConditionThrowable
- {
- load();
- return symbol.execute(first, second, third, fourth, fifth, sixth,
- seventh, eighth);
- }
-
- @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
load();
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Closure.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Closure.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Closure.java Mon May 18 14:02:39 2009
@@ -371,18 +371,6 @@
return environment;
}
- @Override
- public LispObject execute() throws ConditionThrowable
- {
- if (arity == 0)
- {
- return progn(executionBody, environment,
- LispThread.currentThread());
- }
- else
- return execute(new LispObject[0]);
- }
-
private final LispObject bindParametersAndExecute(LispObject... objects)
throws ConditionThrowable
{
@@ -429,136 +417,6 @@
return execute(objects);
}
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- if (minArgs == 1)
- {
- return bindParametersAndExecute(arg);
- }
- else
- {
- return invokeArrayExecute(arg);
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- if (minArgs == 2)
- {
- return bindParametersAndExecute(first, second);
- }
- else
- {
- return invokeArrayExecute(first, second);
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- if (minArgs == 3)
- {
- return bindParametersAndExecute(first, second, third);
- }
- else
- {
- return invokeArrayExecute(first, second, third);
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- throws ConditionThrowable
- {
- if (minArgs == 4)
- {
- return bindParametersAndExecute(first, second, third, fourth);
- }
- else
- {
- return invokeArrayExecute(first, second, third, fourth);
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- if (minArgs == 5)
- {
- return bindParametersAndExecute(first, second, third, fourth,
- fifth);
- }
- else
- {
- return invokeArrayExecute(first, second, third, fourth, fifth);
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth)
- throws ConditionThrowable
- {
- if (minArgs == 6)
- {
- return bindParametersAndExecute(first, second, third, fourth,
- fifth, sixth);
- }
- else
- {
- return invokeArrayExecute(first, second, third, fourth, fifth,
- sixth);
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- if (minArgs == 7)
- {
- return bindParametersAndExecute(first, second, third, fourth,
- fifth, sixth, seventh);
- }
- else
- {
- return invokeArrayExecute(first, second, third, fourth, fifth,
- sixth, seventh);
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh, LispObject eighth)
- throws ConditionThrowable
- {
- if (minArgs == 8)
- {
- return bindParametersAndExecute(first, second, third, fourth,
- fifth, sixth, seventh, eighth);
- }
- else
- {
- return invokeArrayExecute(first, second, third, fourth, fifth,
- sixth, seventh, eighth);
- }
- }
-
private final void declareFreeSpecials(Environment ext)
throws ConditionThrowable
{
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/CompiledFunction.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/CompiledFunction.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/CompiledFunction.java Mon May 18 14:02:39 2009
@@ -60,124 +60,6 @@
}
@Override
- public LispObject execute() throws ConditionThrowable
- {
- LispObject[] args = new LispObject[0];
- return execute(args);
- }
-
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- LispObject[] args = new LispObject[1];
- args[0] = arg;
- return execute(args);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- LispObject[] args = new LispObject[2];
- args[0] = first;
- args[1] = second;
- return execute(args);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- LispObject[] args = new LispObject[3];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- return execute(args);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- throws ConditionThrowable
- {
- LispObject[] args = new LispObject[4];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- return execute(args);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- LispObject[] args = new LispObject[5];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- return execute(args);
- }
-
- @Override
- 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;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- return execute(args);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- LispObject[] args = new LispObject[7];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- args[6] = seventh;
- return execute(args);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh, LispObject eighth)
- throws ConditionThrowable
- {
- LispObject[] args = new LispObject[8];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- args[6] = seventh;
- args[7] = eighth;
- return execute(args);
- }
-
- @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
return error(new LispError("Not implemented."));
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Condition.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Condition.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Condition.java Mon May 18 14:02:39 2009
@@ -197,7 +197,7 @@
if (formatControl instanceof Function)
{
StringOutputStream stream = new StringOutputStream();
- Symbol.APPLY.execute(formatControl, stream, getFormatArguments());
+ Symbol.APPLY.execute(new LispObject[] { formatControl, stream, getFormatArguments() });
return stream.getString().getStringValue();
}
if (formatControl instanceof AbstractString)
@@ -205,7 +205,7 @@
LispObject f = Symbol.FORMAT.getSymbolFunction();
if (f == null || f instanceof Autoload)
return format(formatControl, getFormatArguments());
- return Symbol.APPLY.execute(f, NIL, formatControl, getFormatArguments()).getStringValue();
+ return Symbol.APPLY.execute(new LispObject[] { f, NIL, formatControl, getFormatArguments() }).getStringValue();
}
}
final int maxLevel;
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Cons.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Cons.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Cons.java Mon May 18 14:02:39 2009
@@ -470,126 +470,6 @@
}
@Override
- public LispObject execute() throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute();
- }
- return signalExecutionError();
- }
-
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute(arg);
- }
- return signalExecutionError();
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute(first, second);
- }
- return signalExecutionError();
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute(first, second, third);
- }
- return signalExecutionError();
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute(first, second, third, fourth);
- }
- return signalExecutionError();
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute(first, second, third, fourth, fifth);
- }
- return signalExecutionError();
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth)
- throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute(first, second, third, fourth, fifth, sixth);
- }
- return signalExecutionError();
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute(first, second, third, fourth, fifth, sixth,
- seventh);
- }
- return signalExecutionError();
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh, LispObject eighth)
- throws ConditionThrowable
- {
- if (car == Symbol.LAMBDA)
- {
- Closure closure = new Closure(this, new Environment());
- return closure.execute(first, second, third, fourth, fifth, sixth,
- seventh, eighth);
- }
- return signalExecutionError();
- }
-
- @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
if (car == Symbol.LAMBDA)
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java Mon May 18 14:02:39 2009
@@ -62,17 +62,19 @@
}
@Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
+ public LispObject execute(LispObject[] args)
throws ConditionThrowable
{
- Stream stream = inSynonymOf(first);
- char c = LispCharacter.getValue(second);
+ if (args.length != 3)
+ return error(new WrongNumberOfArgumentsException(this));
+
+ Stream stream = inSynonymOf(args[0]);
+ char c = LispCharacter.getValue(args[1]);
int n;
- if (third == NIL)
+ if (args[2] == NIL)
n = -1;
else
- n = Fixnum.getValue(third);
+ n = Fixnum.getValue(args[2]);
return execute(stream, c, n);
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Function.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Function.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Function.java Mon May 18 14:02:39 2009
@@ -183,79 +183,6 @@
}
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
-
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth)
- throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- 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
{
return error(new WrongNumberOfArgumentsException(this));
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/HashTable.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/HashTable.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/HashTable.java Mon May 18 14:02:39 2009
@@ -279,7 +279,7 @@
HashEntry e = buckets[i];
while (e != null)
{
- function.execute(e.key, e.value);
+ function.execute(new LispObject[] { e.key, e.value });
e = e.next;
}
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Interpreter.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Interpreter.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Interpreter.java Mon May 18 14:02:39 2009
@@ -335,7 +335,7 @@
Symbol TOP_LEVEL_LOOP = intern("TOP-LEVEL-LOOP", PACKAGE_TPL);
LispObject tplFun = TOP_LEVEL_LOOP.getSymbolFunction();
if (tplFun instanceof Function) {
- thread.execute(tplFun);
+ thread.execute(new LispObject[] { tplFun });
return;
}
// We only arrive here if something went wrong and we weren't able
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/JProxy.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/JProxy.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/JProxy.java Mon May 18 14:02:39 2009
@@ -187,7 +187,7 @@
}
Object retVal =
LispThread.currentThread().execute
- (Symbol.APPLY, function, lispArgs.reverse()).javaInstance();
+ (Symbol.APPLY, new LispObject[] { function, lispArgs.reverse() }).javaInstance();
//(function.execute(lispArgs)).javaInstance();
/* DOES NOT WORK due to autoboxing!
if(retVal != null && !method.getReturnType().isAssignableFrom(retVal.getClass())) {
@@ -200,7 +200,7 @@
private static final Primitive _JMAKE_INVOCATION_HANDLER =
new Primitive("%jmake-invocation-handler", PACKAGE_JAVA, false,
"function") {
-
+ @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable {
int length = args.length;
if (length != 1) {
@@ -216,7 +216,7 @@
private static final Primitive _JMAKE_PROXY =
new Primitive("%jmake-proxy", PACKAGE_JAVA, false,
"interface invocation-handler") {
-
+ @Override
public LispObject execute(final LispObject[] args) throws ConditionThrowable {
int length = args.length;
if (length != 3) {
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Java.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Java.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Java.java Mon May 18 14:02:39 2009
@@ -399,11 +399,12 @@
error(new JavaException(t));
else
Symbol.SIGNAL.execute(
- condition,
- Keyword.CAUSE,
- JavaObject.getInstance(t),
- Keyword.FORMAT_CONTROL,
- new SimpleString(getMessage(t)));
+ new LispObject[] {
+ condition,
+ Keyword.CAUSE,
+ JavaObject.getInstance(t),
+ Keyword.FORMAT_CONTROL,
+ new SimpleString(getMessage(t)) });
}
// Not reached.
return NIL;
@@ -464,11 +465,12 @@
error(new JavaException(t));
else
Symbol.SIGNAL.execute(
- condition,
- Keyword.CAUSE,
- JavaObject.getInstance(t),
- Keyword.FORMAT_CONTROL,
- new SimpleString(getMessage(t)));
+ new LispObject[] {
+ condition,
+ Keyword.CAUSE,
+ JavaObject.getInstance(t),
+ Keyword.FORMAT_CONTROL,
+ new SimpleString(getMessage(t)) });
}
// Not reached.
return NIL;
@@ -518,11 +520,12 @@
error(new JavaException(t));
else
Symbol.SIGNAL.execute(
- condition,
- Keyword.CAUSE,
- JavaObject.getInstance(t),
- Keyword.FORMAT_CONTROL,
- new SimpleString(getMessage(t)));
+ new LispObject[] {
+ condition,
+ Keyword.CAUSE,
+ JavaObject.getInstance(t),
+ Keyword.FORMAT_CONTROL,
+ new SimpleString(getMessage(t)) });
}
// Not reached.
return NIL;
@@ -576,11 +579,12 @@
error(new JavaException(t));
else
Symbol.SIGNAL.execute(
- condition,
- Keyword.CAUSE,
- JavaObject.getInstance(t),
- Keyword.FORMAT_CONTROL,
- new SimpleString(getMessage(t)));
+ new LispObject[] {
+ condition,
+ Keyword.CAUSE,
+ JavaObject.getInstance(t),
+ Keyword.FORMAT_CONTROL,
+ new SimpleString(getMessage(t)) });
}
// Not reached.
return NIL;
@@ -658,11 +662,12 @@
error(new JavaException(t));
else
Symbol.SIGNAL.execute(
- condition,
- Keyword.CAUSE,
- JavaObject.getInstance(t),
- Keyword.FORMAT_CONTROL,
- new SimpleString(getMessage(t)));
+ new LispObject[] {
+ condition,
+ Keyword.CAUSE,
+ JavaObject.getInstance(t),
+ Keyword.FORMAT_CONTROL,
+ new SimpleString(getMessage(t)) });
}
// Not reached.
return null;
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/JavaException.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/JavaException.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/JavaException.java Mon May 18 14:02:39 2009
@@ -93,7 +93,7 @@
@Override
public LispObject execute(LispObject arg) throws ConditionThrowable
{
- return Symbol.STD_SLOT_VALUE.execute(arg, Symbol.CAUSE);
+ return Symbol.STD_SLOT_VALUE.execute(new LispObject[] { arg, Symbol.CAUSE });
}
};
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Lisp.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Lisp.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Lisp.java Mon May 18 14:02:39 2009
@@ -140,49 +140,12 @@
fun.incrementCallCount();
try
{
- switch (args.length)
- {
- case 0:
- result = fun.execute();
- break;
- case 1:
- result = fun.execute(args[0]);
- break;
- case 2:
- result = fun.execute(args[0], args[1]);
- break;
- case 3:
- result = fun.execute(args[0], args[1], args[2]);
- break;
- case 4:
- result = fun.execute(args[0], args[1], args[2], args[3]);
- break;
- case 5:
- result = fun.execute(args[0], args[1], args[2], args[3],
- args[4]);
- break;
- case 6:
- result = fun.execute(args[0], args[1], args[2], args[3],
- args[4], args[5]);
- break;
- case 7:
- result = fun.execute(args[0], args[1], args[2], args[3],
- args[4], args[5], args[6]);
- break;
- case 8:
- result = fun.execute(args[0], args[1], args[2], args[3],
- args[4], args[5], args[6], args[7]);
- break;
- default:
- result = fun.execute(args);
- break;
- }
+ return fun.execute(args);
}
finally
{
thread.setStack(stack);
}
- return result;
}
public static final LispObject macroexpand(LispObject form,
@@ -239,7 +202,7 @@
expander.incrementCallCount();
LispObject hook =
coerceToFunction(Symbol.MACROEXPAND_HOOK.symbolValue(thread));
- return thread.setValues(hook.execute(expander, form, env),
+ return thread.setValues(hook.execute(new LispObject[] {expander, form, env} ),
T);
}
}
@@ -273,7 +236,8 @@
LispObject result;
try
{
- result = thread.execute(Symbol.EVAL.getSymbolFunction(), object);
+ result = thread.execute(Symbol.EVAL.getSymbolFunction(),
+ new LispObject[] { object });
}
catch (OutOfMemoryError e)
{
@@ -334,13 +298,13 @@
public static final LispObject error(LispObject condition)
throws ConditionThrowable
{
- return Symbol.ERROR.execute(condition);
+ return Symbol.ERROR.execute(new LispObject[] { condition });
}
public static final LispObject error(LispObject condition, LispObject message)
throws ConditionThrowable
{
- return Symbol.ERROR.execute(condition, Keyword.FORMAT_CONTROL, message);
+ return Symbol.ERROR.execute(new LispObject[] { condition, Keyword.FORMAT_CONTROL, message });
}
public static final LispObject type_error(LispObject datum,
@@ -360,7 +324,7 @@
public static final void handleInterrupt() throws ConditionThrowable
{
setInterrupted(false);
- Symbol.BREAK.getSymbolFunction().execute();
+ Symbol.BREAK.getSymbolFunction().execute(new LispObject[0]);
setInterrupted(false);
}
@@ -465,79 +429,9 @@
LispThread thread)
throws ConditionThrowable
{
- if (args == NIL)
- return thread.execute(function);
- LispObject first = eval(args.car(), env, thread);
- args = ((Cons)args).cdr;
- if (args == NIL)
- {
- thread._values = null;
- return thread.execute(function, first);
- }
- LispObject second = eval(args.car(), env, thread);
- args = ((Cons)args).cdr;
- if (args == NIL)
- {
- thread._values = null;
- return thread.execute(function, first, second);
- }
- LispObject third = eval(args.car(), env, thread);
- args = ((Cons)args).cdr;
- if (args == NIL)
- {
- thread._values = null;
- return thread.execute(function, first, second, third);
- }
- LispObject fourth = eval(args.car(), env, thread);
- args = ((Cons)args).cdr;
- if (args == NIL)
- {
- thread._values = null;
- return thread.execute(function, first, second, third, fourth);
- }
- LispObject fifth = eval(args.car(), env, thread);
- args = ((Cons)args).cdr;
- if (args == NIL)
- {
- thread._values = null;
- return thread.execute(function, first, second, third, fourth, fifth);
- }
- LispObject sixth = eval(args.car(), env, thread);
- args = ((Cons)args).cdr;
- if (args == NIL)
- {
- thread._values = null;
- return thread.execute(function, first, second, third, fourth, fifth,
- sixth);
- }
- LispObject seventh = eval(args.car(), env, thread);
- args = ((Cons)args).cdr;
- if (args == NIL)
- {
- thread._values = null;
- return thread.execute(function, first, second, third, fourth, fifth,
- sixth, seventh);
- }
- LispObject eighth = eval(args.car(), env, thread);
- args = ((Cons)args).cdr;
- if (args == NIL)
- {
- thread._values = null;
- return thread.execute(function, first, second, third, fourth, fifth,
- sixth, seventh, eighth);
- }
- // More than CALL_REGISTERS_MAX arguments.
- final int length = args.length() + CALL_REGISTERS_MAX;
+ final int length = args.length();
LispObject[] array = new LispObject[length];
- array[0] = first;
- array[1] = second;
- array[2] = third;
- array[3] = fourth;
- array[4] = fifth;
- array[5] = sixth;
- array[6] = seventh;
- array[7] = eighth;
- for (int i = CALL_REGISTERS_MAX; i < length; i++)
+ for (int i = 0; i < length; i++)
{
array[i] = eval(args.car(), env, thread);
args = args.cdr();
@@ -782,7 +676,8 @@
LispObject[] values = thread._values;
thread._values = null;
if (values == null)
- return thread.execute(coerceToFunction(function), result);
+ return thread.execute(coerceToFunction(function),
+ new LispObject[] { result });
else
return funcall(coerceToFunction(function), values, thread);
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/LispObject.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/LispObject.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/LispObject.java Mon May 18 14:02:39 2009
@@ -646,70 +646,6 @@
return error(new LispError());
}
- public LispObject execute() throws ConditionThrowable
- {
- return type_error(this, Symbol.FUNCTION);
- }
-
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- 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);
- }
-
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- return type_error(this, Symbol.FUNCTION);
- }
-
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth)
- throws ConditionThrowable
- {
- return type_error(this, Symbol.FUNCTION);
- }
-
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- return type_error(this, Symbol.FUNCTION);
- }
-
- public LispObject execute(LispObject first, LispObject second,
- 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
{
return type_error(this, Symbol.FUNCTION);
@@ -718,32 +654,7 @@
// Used by COMPILE-MULTIPLE-VALUE-CALL.
public LispObject dispatch(LispObject[] args) throws ConditionThrowable
{
- switch (args.length)
- {
- case 0:
- return execute();
- case 1:
- return execute(args[0]);
- case 2:
- return execute(args[0], args[1]);
- case 3:
- return execute(args[0], args[1], args[2]);
- case 4:
- return execute(args[0], args[1], args[2], args[3]);
- case 5:
- return execute(args[0], args[1], args[2], args[3], args[4]);
- case 6:
- return execute(args[0], args[1], args[2], args[3], args[4],
- args[5]);
- case 7:
- return execute(args[0], args[1], args[2], args[3], args[4],
- args[5], args[6]);
- case 8:
- return execute(args[0], args[1], args[2], args[3], args[4],
- args[5], args[6], args[7]);
- default:
- return type_error(this, Symbol.FUNCTION);
- }
+ return type_error(this, Symbol.FUNCTION);
}
public int intValue() throws ConditionThrowable
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/LispThread.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/LispThread.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/LispThread.java Mon May 18 14:02:39 2009
@@ -585,248 +585,6 @@
stack = NIL;
}
- @Override
- public LispObject execute(LispObject function) throws ConditionThrowable
- {
- if (use_fast_calls)
- return function.execute();
-
- LispObject oldStack = stack;
- pushStackFrame(function);
- try {
- return function.execute();
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
- @Override
- public LispObject execute(LispObject function, LispObject arg)
- throws ConditionThrowable
- {
- if (use_fast_calls)
- return function.execute(arg);
-
- LispObject oldStack = stack;
- pushStackFrame(function, arg);
- try {
- return function.execute(arg);
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
- @Override
- public LispObject execute(LispObject function, LispObject first,
- LispObject second)
- throws ConditionThrowable
- {
- if (use_fast_calls)
- return function.execute(first, second);
-
- LispObject oldStack = stack;
- pushStackFrame(function, first, second);
- try {
- return function.execute(first, second);
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
- @Override
- public LispObject execute(LispObject function, LispObject first,
- LispObject second, LispObject third)
- throws ConditionThrowable
- {
- if (use_fast_calls)
- return function.execute(first, second, third);
-
- LispObject oldStack = stack;
- pushStackFrame(function, first, second, third);
- try {
- return function.execute(first, second, third);
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
- @Override
- 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);
-
- LispObject oldStack = stack;
- LispObject[] args = new LispObject[4];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- pushStackFrame(function, args);
- try {
- return function.execute(first, second, third, fourth);
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
- @Override
- 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);
-
- LispObject oldStack = stack;
- LispObject[] args = new LispObject[5];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- pushStackFrame(function, args);
- try {
- return function.execute(first, second, third, fourth, fifth);
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
- @Override
- public LispObject execute(LispObject function, LispObject first,
- 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);
-
- LispObject oldStack = stack;
- LispObject[] args = new LispObject[6];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- pushStackFrame(function, args);
- try {
- return function.execute(first, second, third, fourth, fifth, sixth);
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
- @Override
- public LispObject execute(LispObject function, LispObject first,
- 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,
- seventh);
-
- LispObject oldStack = stack;
- LispObject[] args = new LispObject[7];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- args[6] = seventh;
- pushStackFrame(function, args);
- try {
- return function.execute(first, second, third, fourth, fifth, sixth,
- seventh);
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
- public LispObject execute(LispObject function, LispObject first,
- LispObject second, LispObject third,
- 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,
- seventh, eighth);
-
- LispObject oldStack = stack;
- LispObject[] args = new LispObject[8];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- args[6] = seventh;
- args[7] = eighth;
- pushStackFrame(function, args);
- try {
- return function.execute(first, second, third, fourth, fifth, sixth,
- seventh, eighth);
- }
- finally {
- if (profiling && sampling) {
- if (sampleNow)
- Profiler.sample(this);
- }
- stack = oldStack;
- }
- }
-
public LispObject execute(LispObject function, LispObject[] args)
throws ConditionThrowable
{
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/LogicalPathname.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/LogicalPathname.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/LogicalPathname.java Mon May 18 14:02:39 2009
@@ -99,7 +99,8 @@
else if (v.equals("NEWEST") || v.equals("newest"))
version = Keyword.NEWEST;
else
- version = PACKAGE_CL.intern("PARSE-INTEGER").execute(new SimpleString(v));
+ version = PACKAGE_CL.intern("PARSE-INTEGER")
+ .execute(new LispObject[] { new SimpleString(v) });
} else {
String t = rest;
if (t.equals("*"))
@@ -139,7 +140,8 @@
public static Pathname translateLogicalPathname(LogicalPathname pathname)
throws ConditionThrowable
{
- return (Pathname) Symbol.TRANSLATE_LOGICAL_PATHNAME.execute(pathname);
+ return (Pathname) Symbol.TRANSLATE_LOGICAL_PATHNAME
+ .execute(new LispObject[] { pathname });
}
private static final LispObject parseDirectory(String s)
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/MacroObject.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/MacroObject.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/MacroObject.java Mon May 18 14:02:39 2009
@@ -48,79 +48,6 @@
}
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new UndefinedFunction(name));
- }
-
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- return error(new UndefinedFunction(name));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- return error(new UndefinedFunction(name));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- return error(new UndefinedFunction(name));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- throws ConditionThrowable
- {
- return error(new UndefinedFunction(name));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- return error(new UndefinedFunction(name));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth)
- throws ConditionThrowable
- {
- return error(new UndefinedFunction(name));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- return error(new UndefinedFunction(name));
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- 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
{
return error(new UndefinedFunction(name));
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Primitive.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Primitive.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Primitive.java Mon May 18 14:02:39 2009
@@ -93,121 +93,99 @@
return Symbol.COMPILED_FUNCTION;
}
- @Override
public LispObject execute() throws ConditionThrowable
{
- LispObject[] args = new LispObject[0];
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
- @Override
public LispObject execute(LispObject arg) throws ConditionThrowable
{
- LispObject[] args = new LispObject[1];
- args[0] = arg;
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
- @Override
public LispObject execute(LispObject first, LispObject second)
throws ConditionThrowable
{
- LispObject[] args = new LispObject[2];
- args[0] = first;
- args[1] = second;
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third)
throws ConditionThrowable
{
- LispObject[] args = new LispObject[3];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth)
throws ConditionThrowable
{
- LispObject[] args = new LispObject[4];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth)
throws ConditionThrowable
{
- LispObject[] args = new LispObject[5];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
- @Override
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;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth, LispObject sixth,
LispObject seventh)
throws ConditionThrowable
{
- LispObject[] args = new LispObject[7];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- args[6] = seventh;
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth, LispObject sixth,
LispObject seventh, LispObject eighth)
throws ConditionThrowable
{
- LispObject[] args = new LispObject[8];
- args[0] = first;
- args[1] = second;
- args[2] = third;
- args[3] = fourth;
- args[4] = fifth;
- args[5] = sixth;
- args[6] = seventh;
- args[7] = eighth;
- return execute(args);
+ return error(new WrongNumberOfArgumentsException(this));
}
+
+ @Override
+ public LispObject execute(LispObject[] args) throws ConditionThrowable
+ {
+ switch (args.length)
+ {
+ case 0:
+ return execute();
+ case 1:
+ return execute(args[0]);
+ case 2:
+ return execute(args[0], args[1]);
+ case 3:
+ return execute(args[0], args[1], args[2]);
+ case 4:
+ return execute(args[0], args[1], args[2], args[3]);
+ case 5:
+ return execute(args[0], args[1], args[2], args[3], args[4]);
+ case 6:
+ return execute(args[0], args[1], args[2], args[3], args[4],
+ args[5]);
+ case 7:
+ return execute(args[0], args[1], args[2], args[3], args[4],
+ args[5], args[6]);
+ case 8:
+ return execute(args[0], args[1], args[2], args[3], args[4],
+ args[5], args[6], args[7]);
+ default:
+ return error(new WrongNumberOfArgumentsException(this));
+ }
+ }
+
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Primitives.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Primitives.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Primitives.java Mon May 18 14:02:39 2009
@@ -48,19 +48,6 @@
return Fixnum.ONE;
}
@Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- if (arg.numberp())
- return arg;
- return type_error(arg, Symbol.NUMBER);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- return first.multiplyBy(second);
- }
- @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
LispObject result = Fixnum.ONE;
@@ -75,24 +62,11 @@
new Primitive(Symbol.SLASH, "numerator &rest denominators")
{
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- 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
{
+ if (args.length == 0)
+ return error(new WrongNumberOfArgumentsException(this));
+
LispObject result = args[0];
for (int i = 1; i < args.length; i++)
result = result.divideBy(args[i]);
@@ -105,26 +79,10 @@
new Primitive(Symbol.MIN, "&rest reals")
{
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- if (arg.realp())
- return arg;
- return type_error(arg, Symbol.REAL);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- return first.isLessThan(second) ? first : second;
- }
- @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
+ if (args.length == 0)
+ return error(new WrongNumberOfArgumentsException(this));
LispObject result = args[0];
if (!result.realp())
type_error(result, Symbol.REAL);
@@ -142,26 +100,10 @@
new Primitive(Symbol.MAX, "&rest reals")
{
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- if (arg.realp())
- return arg;
- return type_error(arg, Symbol.REAL);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- return first.isGreaterThan(second) ? first : second;
- }
- @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
+ if (args.length == 0)
+ return error(new WrongNumberOfArgumentsException(this));
LispObject result = args[0];
if (!result.realp())
type_error(result, Symbol.REAL);
@@ -355,34 +297,6 @@
new Primitive(Symbol.VALUES, "&rest object")
{
@Override
- public LispObject execute()
- {
- return LispThread.currentThread().setValues();
- }
- @Override
- public LispObject execute(LispObject arg)
- {
- return LispThread.currentThread().setValues(arg);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second)
- {
- return LispThread.currentThread().setValues(first, second);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- {
- return LispThread.currentThread().setValues(first, second, third);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- {
- return LispThread.currentThread().setValues(first, second, third,
- fourth);
- }
- @Override
public LispObject execute(LispObject[] args)
{
return LispThread.currentThread().setValues(args);
@@ -633,31 +547,6 @@
new Primitive(Symbol.PLUS, "&rest numbers")
{
@Override
- public LispObject execute()
- {
- return Fixnum.ZERO;
- }
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- if (arg.numberp())
- return arg;
- return type_error(arg, Symbol.NUMBER);
- }
- @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
{
LispObject result = Fixnum.ZERO;
@@ -684,24 +573,12 @@
new Primitive(Symbol.MINUS, "minuend &rest subtrahends")
{
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- 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
{
+ if (args.length == 0)
+ return error(new WrongNumberOfArgumentsException(this));
+ if (args.length == 1)
+ return args[0].negate();
LispObject result = args[0];
for (int i = 1; i < args.length; i++)
result = result.subtract(args[i]);
@@ -943,65 +820,14 @@
new Primitive(Symbol.APPEND, "&rest lists")
{
@Override
- public LispObject execute()
- {
- return NIL;
- }
- @Override
- public LispObject execute(LispObject arg)
- {
- return arg;
- }
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- if (first == NIL)
- return second;
- // APPEND is required to copy its first argument.
- Cons result = new Cons(first.car());
- Cons splice = result;
- first = first.cdr();
- while (first != NIL)
- {
- Cons temp = new Cons(first.car());
- splice.cdr = temp;
- splice = temp;
- first = first.cdr();
- }
- splice.cdr = second;
- return result;
- }
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- if (first == NIL)
- return execute(second, third);
- Cons result = new Cons(first.car());
- Cons splice = result;
- first = first.cdr();
- while (first != NIL)
- {
- Cons temp = new Cons(first.car());
- splice.cdr = temp;
- splice = temp;
- first = first.cdr();
- }
- while (second != NIL)
- {
- Cons temp = new Cons(second.car());
- splice.cdr = temp;
- splice = temp;
- second = second.cdr();
- }
- splice.cdr = third;
- return result;
- }
- @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
+ if (args.length == 0)
+ return NIL;
+
+ if (args.length == 1)
+ return args[0];
+
Cons result = null;
Cons splice = null;
final int limit = args.length - 1;
@@ -1046,38 +872,13 @@
new Primitive(Symbol.NCONC, "&rest lists")
{
@Override
- public LispObject execute()
- {
- return NIL;
- }
- @Override
- public LispObject execute(LispObject arg)
- {
- return arg;
- }
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- if (first == NIL)
- return second;
- if (first instanceof Cons)
- {
- LispObject result = first;
- Cons splice = null;
- while (first instanceof Cons)
- {
- splice = (Cons) first;
- first = splice.cdr;
- }
- splice.cdr = second;
- return result;
- }
- return type_error(first, Symbol.LIST);
- }
- @Override
public LispObject execute(LispObject[] array) throws ConditionThrowable
{
+ if (array.length == 0)
+ return NIL;
+ if (array.length == 1)
+ return array[0];
+
LispObject result = null;
Cons splice = null;
final int limit = array.length - 1;
@@ -1122,34 +923,10 @@
new Primitive(Symbol.EQUALS, "&rest numbers")
{
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
- @Override
- public LispObject execute(LispObject arg)
- {
- return T;
- }
- @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;
- else
- return NIL;
- }
- @Override
public LispObject execute(LispObject[] array) throws ConditionThrowable
{
+ if (array.length == 0)
+ return error(new WrongNumberOfArgumentsException(this));
final int length = array.length;
final LispObject obj = array[0];
for (int i = 1; i < length; i++)
@@ -1611,8 +1388,8 @@
}
if (currentSource == Keyword.TOP_LEVEL)
{
- Symbol.STYLE_WARN.execute(new SimpleString("redefining ~S at top level"),
- arg);
+ Symbol.STYLE_WARN
+ .execute(new LispObject[] { new SimpleString("redefining ~S at top level"), arg });
}
else
@@ -1621,8 +1398,9 @@
thread.bindSpecial(Symbol._PACKAGE_, PACKAGE_CL);
try
{
- Symbol.STYLE_WARN.execute(new SimpleString("redefining ~S in ~S"),
- arg, currentSource);
+ Symbol.STYLE_WARN
+ .execute(new LispObject[] { new SimpleString("redefining ~S in ~S"),
+ arg, currentSource });
}
finally
{
@@ -1656,8 +1434,8 @@
return type_error(name, FUNCTION_NAME);
if (definition instanceof Function)
{
- Symbol.FSET.execute(name, definition, NIL,
- ((Function)definition).getLambdaList());
+ Symbol.FSET.execute(new LispObject[] { name, definition, NIL,
+ ((Function)definition).getLambdaList() });
return name;
}
return type_error(definition, Symbol.FUNCTION);
@@ -2477,95 +2255,15 @@
public static final Primitive FUNCALL =
new Primitive(Symbol.FUNCALL, "function &rest args")
{
- @Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- 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);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- return LispThread.currentThread().execute(first, second, third,
- fourth, fifth);
- }
- @Override
- 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);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- return LispThread.currentThread().execute(first, second, third,
- fourth, fifth, sixth,
- seventh);
- }
- @Override
- public LispObject execute(LispObject first, LispObject second,
- 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);
- }
+ // We don't need to implement the other execute() primitives,
+ // because we're overriding Primitive's default dispatching below
@Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
final int length = args.length - 1; // Number of arguments.
- if (length == 8)
- {
- return LispThread.currentThread().execute(args[0], args[1],
- args[2], args[3],
- args[4], args[5],
- args[6], args[7],
- args[8]);
- }
- else
- {
- LispObject[] newArgs = new LispObject[length];
- System.arraycopy(args, 1, newArgs, 0, length);
- return LispThread.currentThread().execute(args[0], newArgs);
- }
+ LispObject[] newArgs = new LispObject[length];
+ System.arraycopy(args, 1, newArgs, 0, length);
+ return LispThread.currentThread().execute(args[0], newArgs);
}
};
@@ -2574,72 +2272,12 @@
new Primitive(Symbol.APPLY, "function &rest args")
{
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return error(new WrongNumberOfArgumentsException(this));
- }
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- 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();
- switch (length)
- {
- case 0:
- return thread.execute(fun);
- case 1:
- return thread.execute(fun, ((Cons)args).car);
- case 2:
- {
- Cons cons = (Cons) args;
- return thread.execute(fun, cons.car, ((Cons)cons.cdr).car);
- }
- case 3:
- return thread.execute(fun, args.car(), args.cadr(),
- args.cdr().cdr().car());
- default:
- {
- final LispObject[] funArgs = new LispObject[length];
- int j = 0;
- while (args != NIL)
- {
- funArgs[j++] = args.car();
- args = args.cdr();
- }
- return funcall(fun, funArgs, thread);
- }
- }
- }
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- if (third.listp())
- {
- final int numFunArgs = 1 + third.length();
- final LispObject[] funArgs = new LispObject[numFunArgs];
- funArgs[0] = second;
- int j = 1;
- while (third != NIL)
- {
- funArgs[j++] = third.car();
- third = third.cdr();
- }
- return funcall(first, funArgs, LispThread.currentThread());
- }
- return type_error(third, Symbol.LIST);
- }
- @Override
public LispObject execute(final LispObject[] args) throws ConditionThrowable
{
final int numArgs = args.length;
+ if (numArgs < 2)
+ return error(new WrongNumberOfArgumentsException(this));
+
LispObject spread = args[numArgs - 1];
if (spread.listp())
{
@@ -2677,7 +2315,7 @@
cons = (Cons) list;
else
return type_error(list, Symbol.LIST);
- LispObject obj = thread.execute(fun, cons.car);
+ LispObject obj = thread.execute(fun, new LispObject[] { cons.car });
if (splice == null)
{
splice = new Cons(obj, result);
@@ -2705,7 +2343,7 @@
while (list1 != NIL && list2 != NIL)
{
LispObject obj =
- thread.execute(fun, list1.car(), list2.car());
+ thread.execute(fun, new LispObject[] { list1.car(), list2.car() });
if (splice == null)
{
splice = new Cons(obj, result);
@@ -2778,7 +2416,7 @@
cons = (Cons) list;
else
return type_error(list, Symbol.LIST);
- thread.execute(fun, cons.car);
+ thread.execute(fun, new LispObject[] { cons.car });
list = cons.cdr;
}
thread._values = null;
@@ -2793,7 +2431,7 @@
LispObject result = list1;
while (list1 != NIL && list2 != NIL)
{
- thread.execute(fun, list1.car(), list2.car());
+ thread.execute(fun, new LispObject[] { list1.car(), list2.car() });
list1 = ((Cons)list1).cdr;
list2 = ((Cons)list2).cdr;
}
@@ -3423,7 +3061,7 @@
Symbol make_expander_for_macrolet =
PACKAGE_SYS.intern("MAKE-EXPANDER-FOR-MACROLET");
LispObject expander =
- make_expander_for_macrolet.execute(def);
+ make_expander_for_macrolet.execute(new LispObject[] { def });
Closure expansionFunction = new Closure(expander, env);
MacroObject macroObject =
new MacroObject(symbol, expansionFunction);
@@ -4576,7 +4214,7 @@
while (tail instanceof Cons)
{
LispObject candidate = ((Cons)tail).car;
- if (test.execute(item, candidate) != NIL)
+ if (test.execute(new LispObject[] { item, candidate }) != NIL)
return tail;
tail = ((Cons)tail).cdr;
}
@@ -4587,7 +4225,7 @@
while (tail instanceof Cons)
{
LispObject candidate = ((Cons)tail).car;
- if (testNot.execute(item, candidate) == NIL)
+ if (testNot.execute(new LispObject[] { item, candidate }) == NIL)
return tail;
tail = ((Cons)tail).cdr;
}
@@ -4598,15 +4236,15 @@
// key != NIL
while (tail instanceof Cons)
{
- LispObject candidate = key.execute(((Cons)tail).car);
+ LispObject candidate = key.execute(new LispObject[] { ((Cons)tail).car });
if (test != NIL)
{
- if (test.execute(item, candidate) != NIL)
+ if (test.execute(new LispObject[] { item, candidate }) != NIL)
return tail;
}
else
{
- if (testNot.execute(item, candidate) == NIL)
+ if (testNot.execute(new LispObject[] { item, candidate }) == NIL)
return tail;
}
tail = ((Cons)tail).cdr;
@@ -4627,7 +4265,7 @@
throws ConditionThrowable
{
if (first != NIL)
- return LispThread.currentThread().execute(first, second);
+ return LispThread.currentThread().execute(new LispObject[] { first, second });
return second;
}
};
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Profiler.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Profiler.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Profiler.java Mon May 18 14:02:39 2009
@@ -92,7 +92,8 @@
object.setCallCount(0);
if (object instanceof StandardGenericFunction) {
LispObject methods =
- PACKAGE_MOP.intern("GENERIC-FUNCTION-METHODS").execute(object);
+ PACKAGE_MOP.intern("GENERIC-FUNCTION-METHODS")
+ .execute(new LispObject[] { object });
while (methods != NIL) {
StandardMethod method = (StandardMethod) methods.car();
method.getFunction().setCallCount(0);
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/ReaderMacroFunction.java Mon May 18 14:02:39 2009
@@ -62,11 +62,14 @@
}
@Override
- public LispObject execute(LispObject first, LispObject second)
+ public LispObject execute(LispObject[] args)
throws ConditionThrowable
{
- Stream stream = inSynonymOf(first);
- char c = LispCharacter.getValue(second);
+ if (args.length != 2)
+ return error(new WrongNumberOfArgumentsException(this));
+
+ Stream stream = inSynonymOf(args[0]);
+ char c = LispCharacter.getValue(args[1]);
return execute(stream, c);
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/SimpleCondition.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/SimpleCondition.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/SimpleCondition.java Mon May 18 14:02:39 2009
@@ -87,7 +87,7 @@
@Override
public LispObject execute(LispObject arg) throws ConditionThrowable
{
- return Symbol.STD_SLOT_VALUE.execute(arg, Symbol.FORMAT_CONTROL);
+ return Symbol.STD_SLOT_VALUE.execute(new LispObject[] { arg, Symbol.FORMAT_CONTROL });
}
};
@@ -98,7 +98,7 @@
@Override
public LispObject execute(LispObject arg) throws ConditionThrowable
{
- return Symbol.STD_SLOT_VALUE.execute(arg, Symbol.FORMAT_ARGUMENTS);
+ return Symbol.STD_SLOT_VALUE.execute(new LispObject[] { arg, Symbol.FORMAT_ARGUMENTS });
}
};
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/SlimeInputStream.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/SlimeInputStream.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/SlimeInputStream.java Mon May 18 14:02:39 2009
@@ -96,7 +96,8 @@
if (offset >= length) {
try {
ostream.finishOutput();
- s = LispThread.currentThread().execute(f).getStringValue();
+ s = LispThread.currentThread()
+ .execute(f, new LispObject[0]).getStringValue();
}
catch (Throwable t) {
return -1;
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/SlimeOutputStream.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/SlimeOutputStream.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/SlimeOutputStream.java Mon May 18 14:02:39 2009
@@ -130,7 +130,7 @@
if (stringWriter.getBuffer().length() > 0) {
String s = stringWriter.toString();
stringWriter.getBuffer().setLength(0);
- LispThread.currentThread().execute(f, new SimpleString(s));
+ LispThread.currentThread().execute(f, new LispObject[] { new SimpleString(s) });
}
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/SlotClass.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/SlotClass.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/SlotClass.java Mon May 18 14:02:39 2009
@@ -110,7 +110,7 @@
if (c instanceof StandardClass) {
LispObject obj = ((StandardClass)c).getDirectDefaultInitargs();
if (obj != NIL)
- result = Symbol.APPEND.execute(result, obj);
+ result = Symbol.APPEND.execute(new LispObject[] { result, obj });
}
cpl = cpl.cdr();
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/SpecialOperator.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/SpecialOperator.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/SpecialOperator.java Mon May 18 14:02:39 2009
@@ -68,26 +68,22 @@
}
}
- @Override
public LispObject execute() throws ConditionThrowable
{
return error(new UndefinedFunction(getLambdaName()));
}
- @Override
public LispObject execute(LispObject arg) throws ConditionThrowable
{
return error(new UndefinedFunction(getLambdaName()));
}
- @Override
public LispObject execute(LispObject first, LispObject second)
throws ConditionThrowable
{
return error(new UndefinedFunction(getLambdaName()));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third)
throws ConditionThrowable
@@ -95,7 +91,6 @@
return error(new UndefinedFunction(getLambdaName()));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth)
throws ConditionThrowable
@@ -103,7 +98,6 @@
return error(new UndefinedFunction(getLambdaName()));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth)
@@ -112,7 +106,6 @@
return error(new UndefinedFunction(getLambdaName()));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth, LispObject sixth)
@@ -121,7 +114,6 @@
return error(new UndefinedFunction(getLambdaName()));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth, LispObject sixth,
@@ -131,7 +123,6 @@
return error(new UndefinedFunction(getLambdaName()));
}
- @Override
public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth, LispObject sixth,
@@ -144,7 +135,32 @@
@Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
- return error(new UndefinedFunction(getLambdaName()));
+ switch (args.length)
+ {
+ case 0:
+ return execute();
+ case 1:
+ return execute(args[0]);
+ case 2:
+ return execute(args[0], args[1]);
+ case 3:
+ return execute(args[0], args[1], args[2]);
+ case 4:
+ return execute(args[0], args[1], args[2], args[3]);
+ case 5:
+ return execute(args[0], args[1], args[2], args[3], args[4]);
+ case 6:
+ return execute(args[0], args[1], args[2], args[3], args[4],
+ args[5]);
+ case 7:
+ return execute(args[0], args[1], args[2], args[3], args[4],
+ args[5], args[6]);
+ case 8:
+ return execute(args[0], args[1], args[2], args[3], args[4],
+ args[5], args[6], args[7]);
+ default:
+ return error(new UndefinedFunction(getLambdaName()));
+ }
}
@Override
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardClass.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardClass.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardClass.java Mon May 18 14:02:39 2009
@@ -73,11 +73,12 @@
Layout layout = getClassLayout();
if (layout == null)
{
- Symbol.ERROR.execute(Symbol.SIMPLE_ERROR,
+ Symbol.ERROR.execute(
+ new LispObject[] { Symbol.SIMPLE_ERROR,
Keyword.FORMAT_CONTROL,
new SimpleString("No layout for class ~S."),
Keyword.FORMAT_ARGUMENTS,
- list(this));
+ list(this) });
}
return new StandardObject(this, layout.getLength());
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardGenericFunction.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardGenericFunction.java Mon May 18 14:02:39 2009
@@ -125,83 +125,6 @@
}
@Override
- public LispObject execute() throws ConditionThrowable
- {
- return function.execute();
- }
-
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- return function.execute(arg);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- return function.execute(first, second);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- return function.execute(first, second, third);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- throws ConditionThrowable
- {
- return function.execute(first, second, third, fourth);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- return function.execute(first, second, third, fourth,
- fifth);
- }
-
- @Override
- 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);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- return function.execute(first, second, third, fourth,
- fifth, sixth, seventh);
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- 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
{
return function.execute(args);
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardObject.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardObject.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/StandardObject.java Mon May 18 14:02:39 2009
@@ -161,7 +161,7 @@
if (typep(Symbol.CONDITION) != NIL)
{
StringOutputStream stream = new StringOutputStream();
- Symbol.PRINT_OBJECT.execute(this, stream);
+ Symbol.PRINT_OBJECT.execute(new LispObject[] { this, stream });
return stream.getString().getStringValue();
}
return unreadableString(typeOf().writeToString());
@@ -235,8 +235,8 @@
newInstance.layout = tempLayout;
Debug.assertTrue(!layout.isInvalid());
// Call UPDATE-INSTANCE-FOR-REDEFINED-CLASS.
- Symbol.UPDATE_INSTANCE_FOR_REDEFINED_CLASS.execute(this, added,
- discarded, plist);
+ Symbol.UPDATE_INSTANCE_FOR_REDEFINED_CLASS
+ .execute(new LispObject[] { this, added, discarded, plist });
return newLayout;
}
@@ -373,8 +373,9 @@
if (value == UNBOUND_VALUE)
{
LispObject slotName = instance.layout.getSlotNames()[index];
- value = Symbol.SLOT_UNBOUND.execute(instance.getLispClass(),
- instance, slotName);
+ value = Symbol.SLOT_UNBOUND
+ .execute(new LispObject[] { instance.getLispClass(),
+ instance, slotName });
LispThread.currentThread()._values = null;
}
return value;
@@ -423,8 +424,9 @@
// Not found.
final LispThread thread = LispThread.currentThread();
LispObject value =
- thread.execute(Symbol.SLOT_MISSING, instance.getLispClass(),
- instance, second, Symbol.SLOT_BOUNDP);
+ thread.execute(Symbol.SLOT_MISSING,
+ new LispObject[] { instance.getLispClass(),
+ instance, second, Symbol.SLOT_BOUNDP });
// "If SLOT-MISSING is invoked and returns a value, a boolean
// equivalent to its primary value is returned by SLOT-BOUNDP."
thread._values = null;
@@ -452,13 +454,15 @@
// Check for shared slot.
LispObject location = layout.getSharedSlotLocation(slotName);
if (location == null)
- return Symbol.SLOT_MISSING.execute(getLispClass(), this, slotName,
- Symbol.SLOT_VALUE);
+ return Symbol.SLOT_MISSING
+ .execute(new LispObject[] { getLispClass(), this, slotName,
+ Symbol.SLOT_VALUE });
value = location.cdr();
}
if (value == UNBOUND_VALUE)
{
- value = Symbol.SLOT_UNBOUND.execute(getLispClass(), this, slotName);
+ value = Symbol.SLOT_UNBOUND
+ .execute(new LispObject[] { getLispClass(), this, slotName });
LispThread.currentThread()._values = null;
}
return value;
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Stream.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Stream.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Stream.java Mon May 18 14:02:39 2009
@@ -538,7 +538,7 @@
if (handler instanceof ReaderMacroFunction)
return ((ReaderMacroFunction)handler).execute(this, c);
if (handler != null && handler != NIL)
- return handler.execute(this, LispCharacter.getInstance(c));
+ return handler.execute(new LispObject[] { this, LispCharacter.getInstance(c) });
return readToken(c, rt);
}
@@ -596,7 +596,7 @@
Symbol DEFSTRUCT_DEFAULT_CONSTRUCTOR =
PACKAGE_SYS.intern("DEFSTRUCT-DEFAULT-CONSTRUCTOR");
LispObject constructor =
- DEFSTRUCT_DEFAULT_CONSTRUCTOR.getSymbolFunctionOrDie().execute(structure);
+ DEFSTRUCT_DEFAULT_CONSTRUCTOR.getSymbolFunctionOrDie().execute(new LispObject[] { structure });
final int length = args.length();
if ((length % 2) != 0)
return error(new ReaderError("Odd number of keyword arguments following #S: " +
@@ -644,7 +644,7 @@
Symbol DEFSTRUCT_DEFAULT_CONSTRUCTOR =
PACKAGE_SYS.intern("DEFSTRUCT-DEFAULT-CONSTRUCTOR");
LispObject constructor =
- DEFSTRUCT_DEFAULT_CONSTRUCTOR.getSymbolFunctionOrDie().execute(structure);
+ DEFSTRUCT_DEFAULT_CONSTRUCTOR.getSymbolFunctionOrDie().execute(new LispObject[] { structure });
final int length = args.length();
if ((length % 2) != 0)
return error(new ReaderError("Odd number of keyword arguments following #S: " +
@@ -792,8 +792,9 @@
if (fun != NIL)
{
LispObject result =
- thread.execute(fun, this, LispCharacter.getInstance(c),
- (numArg < 0) ? NIL : Fixnum.getInstance(numArg));
+ thread.execute(fun,
+ new LispObject[] { this, LispCharacter.getInstance(c),
+ (numArg < 0) ? NIL : Fixnum.getInstance(numArg) });
LispObject[] values = thread._values;
if (values != null && values.length == 0)
result = null;
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/StructureObject.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/StructureObject.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/StructureObject.java Mon May 18 14:02:39 2009
@@ -403,7 +403,7 @@
Symbol PRINT_RESTART = PACKAGE_SYS.intern("PRINT-RESTART");
LispObject fun = PRINT_RESTART.getSymbolFunction();
StringOutputStream stream = new StringOutputStream();
- thread.execute(fun, this, stream);
+ thread.execute(fun, new LispObject[] { this, stream });
return stream.getString().getStringValue();
}
if (_PRINT_STRUCTURE_.symbolValue(thread) == NIL)
@@ -446,7 +446,7 @@
{
StringOutputStream stream = new StringOutputStream();
thread.execute(Symbol.OUTPUT_OBJECT.getSymbolFunction(),
- slots[i], stream);
+ new LispObject[] { slots[i], stream });
sb.append(stream.getString().getStringValue());
}
else
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Symbol.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Symbol.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Symbol.java Mon May 18 14:02:39 2009
@@ -714,149 +714,6 @@
}
@Override
- public LispObject execute() throws ConditionThrowable
- {
- try
- {
- return function.execute();
- }
- catch (NullPointerException e)
- {
- return handleNPE(e, NIL);
- }
- }
-
- @Override
- public LispObject execute(LispObject arg) throws ConditionThrowable
- {
- try
- {
- return function.execute(arg);
- }
- catch (NullPointerException e)
- {
- return handleNPE(e, list(arg));
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second)
- throws ConditionThrowable
- {
- try
- {
- return function.execute(first, second);
- }
- catch (NullPointerException e)
- {
- return handleNPE(e, list(first, second));
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third)
- throws ConditionThrowable
- {
- try
- {
- return function.execute(first, second, third);
- }
- catch (NullPointerException e)
- {
- return handleNPE(e, list(first, second, third));
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth)
- throws ConditionThrowable
- {
- try
- {
- return function.execute(first, second, third, fourth);
- }
- catch (NullPointerException e)
- {
- return handleNPE(e, list(first, second, third, fourth));
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth)
- throws ConditionThrowable
- {
- try
- {
- return function.execute(first, second, third, fourth, fifth);
- }
- catch (NullPointerException e)
- {
- return handleNPE(e, list(first, second, third, fourth, fifth));
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth)
- throws ConditionThrowable
- {
- try
- {
- return function.execute(first, second, third, fourth, fifth, sixth);
- }
- catch (NullPointerException e)
- {
- return handleNPE(e, list(first, second, third, fourth, fifth,
- sixth));
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh)
- throws ConditionThrowable
- {
- try
- {
- return function.execute(first, second, third, fourth, fifth, sixth,
- seventh);
- }
- catch (NullPointerException e)
- {
- return handleNPE(e,
- list(first, second, third, fourth, fifth, sixth,
- seventh));
- }
- }
-
- @Override
- public LispObject execute(LispObject first, LispObject second,
- LispObject third, LispObject fourth,
- LispObject fifth, LispObject sixth,
- LispObject seventh, LispObject eighth)
- throws ConditionThrowable
- {
- try
- {
- return function.execute(first, second, third, fourth, fifth, sixth,
- seventh, eighth);
- }
- catch (NullPointerException e)
- {
- return handleNPE(e,
- list(first, second, third, fourth, fifth, sixth,
- seventh, eighth));
- }
- }
-
- @Override
public LispObject execute(LispObject[] args) throws ConditionThrowable
{
try
@@ -877,7 +734,7 @@
{
if (function == null)
return LispThread.currentThread().execute(Symbol.UNDEFINED_FUNCTION_CALLED,
- this, args);
+ new LispObject[] { this, args });
Debug.trace(e);
return error(new LispError("Null pointer exception"));
}
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/Time.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/Time.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/Time.java Mon May 18 14:02:39 2009
@@ -86,7 +86,7 @@
long realStart = System.currentTimeMillis();
try
{
- return arg.execute();
+ return arg.execute(new LispObject[0]);
}
finally
{
Modified: branches/fewer-executes/abcl/src/org/armedbear/lisp/ZeroRankArray.java
==============================================================================
--- branches/fewer-executes/abcl/src/org/armedbear/lisp/ZeroRankArray.java (original)
+++ branches/fewer-executes/abcl/src/org/armedbear/lisp/ZeroRankArray.java Mon May 18 14:02:39 2009
@@ -148,7 +148,7 @@
if (data == this && Symbol.PRINT_CIRCLE.symbolValue(thread) != NIL) {
StringOutputStream stream = new StringOutputStream();
thread.execute(Symbol.OUTPUT_OBJECT.getSymbolFunction(),
- data, stream);
+ new LispObject[] { data, stream });
sb.append(stream.getString().getStringValue());
} else
sb.append(data.writeToString());
More information about the armedbear-cvs
mailing list