Changeset 13461


Ignore:
Timestamp:
08/11/11 17:01:41 (9 years ago)
Author:
ehuelsmann
Message:

Print expected minimum and maximum argument list lengths in
WrongNumberOfArguments? program errors.

Location:
trunk/abcl/src/org/armedbear/lisp
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java

    r12290 r13461  
    4545        public LispObject execute()
    4646        {
    47             return error(new WrongNumberOfArgumentsException(this));
     47            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    4848        }
    4949        @Override
     
    8080        public LispObject execute()
    8181        {
    82             return error(new WrongNumberOfArgumentsException(this));
     82            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    8383        }
    8484        @Override
     
    130130        public LispObject execute()
    131131        {
    132             return error(new WrongNumberOfArgumentsException(this));
     132            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    133133        }
    134134        @Override
     
    169169        public LispObject execute()
    170170        {
    171             return error(new WrongNumberOfArgumentsException(this));
     171            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    172172        }
    173173        @Override
     
    208208        public LispObject execute()
    209209        {
    210             return error(new WrongNumberOfArgumentsException(this));
     210            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    211211        }
    212212        @Override
     
    246246        public LispObject execute()
    247247        {
    248             return error(new WrongNumberOfArgumentsException(this));
     248            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    249249        }
    250250        @Override
     
    295295        public LispObject execute()
    296296        {
    297             return error(new WrongNumberOfArgumentsException(this));
     297            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    298298        }
    299299        @Override
     
    334334        public LispObject execute()
    335335        {
    336             return error(new WrongNumberOfArgumentsException(this));
     336            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    337337        }
    338338        @Override
  • trunk/abcl/src/org/armedbear/lisp/Closure.java

    r13440 r13461  
    667667        // Fixed arity.
    668668        if (argsLength != arity)
    669           error(new WrongNumberOfArgumentsException(this));
     669          error(new WrongNumberOfArgumentsException(this, arity));
    670670        return args;
    671671      }
    672672    // Not fixed arity.
    673673    if (argsLength < minArgs)
    674       error(new WrongNumberOfArgumentsException(this));
     674      error(new WrongNumberOfArgumentsException(this, minArgs, -1));
    675675    final LispObject[] array = new LispObject[variables.length];
    676676    int index = 0;
     
    926926        // Fixed arity.
    927927        if (argsLength != arity)
    928           error(new WrongNumberOfArgumentsException(this));
     928          error(new WrongNumberOfArgumentsException(this, arity));
    929929        return args;
    930930      }
    931931    // Not fixed arity.
    932932    if (argsLength < minArgs)
    933       error(new WrongNumberOfArgumentsException(this));
     933      error(new WrongNumberOfArgumentsException(this, minArgs, -1));
    934934    final LispObject[] array = new LispObject[variables.length];
    935935    int index = 0;
  • trunk/abcl/src/org/armedbear/lisp/Extensions.java

    r13143 r13461  
    5656    {
    5757      if (args.length() != 2)
    58         return error(new WrongNumberOfArgumentsException(this));
     58        return error(new WrongNumberOfArgumentsException(this, 2));
    5959      return eval(args.cadr(), env, LispThread.currentThread());
    6060    }
  • trunk/abcl/src/org/armedbear/lisp/JHandler.java

    r13015 r13461  
    104104        {
    105105            if (args.length != 5)
    106                 return error(new WrongNumberOfArgumentsException(this));
     106                return error(new WrongNumberOfArgumentsException(this, 5));
    107107            Map<String,Entry> entryTable = null;
    108108            Object object = args[0].javaInstance();
  • trunk/abcl/src/org/armedbear/lisp/JProxy.java

    r12775 r13461  
    200200            int length = args.length;
    201201            if (length != 1) {
    202               return error(new WrongNumberOfArgumentsException(this));
     202              return error(new WrongNumberOfArgumentsException(this, 1));
    203203            }
    204204            if(!(args[0] instanceof Function)) {
     
    216216            int length = args.length;
    217217            if (length != 3) {
    218               return error(new WrongNumberOfArgumentsException(this));
     218              return error(new WrongNumberOfArgumentsException(this, 3));
    219219            }
    220220            if(!(args[0] instanceof Cons)) {
  • trunk/abcl/src/org/armedbear/lisp/Java.java

    r13440 r13461  
    169169    {
    170170        if (args.length < 2 || args.length > 4)
    171             error(new WrongNumberOfArgumentsException(fun));
     171            error(new WrongNumberOfArgumentsException(fun, 2, 4));
    172172        String fieldName = null;
    173173        Class c;
     
    331331        {
    332332            if (args.length < 1)
    333                 error(new WrongNumberOfArgumentsException(this));
     333                error(new WrongNumberOfArgumentsException(this, 1, -1));
    334334            try {
    335335                final Class<?> c = javaClass(args[0]);
     
    383383        {
    384384            if (args.length < 2)
    385                 error(new WrongNumberOfArgumentsException(this));
     385                error(new WrongNumberOfArgumentsException(this, 2, -1));
    386386            final Class<?> c = javaClass(args[0]);
    387387            String methodName = args[1].getStringValue();
     
    436436    {
    437437        if (args.length < 2)
    438             error(new WrongNumberOfArgumentsException(fun));
     438            error(new WrongNumberOfArgumentsException(fun, 2, -1));
    439439        try {
    440440            Method m = null;
     
    546546        {
    547547            if (args.length < 1)
    548                 error(new WrongNumberOfArgumentsException(this));
     548                error(new WrongNumberOfArgumentsException(this, 1, -1));
    549549            LispObject classRef = args[0];
    550550            try {
     
    611611        {
    612612            if (args.length < 2)
    613                 error(new WrongNumberOfArgumentsException(this));
     613                error(new WrongNumberOfArgumentsException(this, 2, -1));
    614614            try {
    615615                Class c = javaClass(args[0]);
     
    631631    {
    632632        if (args.length < 2)
    633             error(new WrongNumberOfArgumentsException(fun));
     633            error(new WrongNumberOfArgumentsException(fun, 2, -1));
    634634        try {
    635635            Object a = args[0].javaInstance();
     
    705705        {
    706706            if (args.length < 3)
    707                 error(new WrongNumberOfArgumentsException(this));
     707                error(new WrongNumberOfArgumentsException(this, 3, -1));
    708708            try {
    709709                Object a = args[0].javaInstance();
     
    793793        public LispObject execute(LispObject[] args) {
    794794            if (args.length < 2) {
    795                 error(new WrongNumberOfArgumentsException(this, 2));
     795                error(new WrongNumberOfArgumentsException(this, 2, -1));
    796796            }
    797797            final LispObject methodArg = args[0];
     
    838838    {
    839839        if (args.length < 2)
    840             error(new WrongNumberOfArgumentsException(fun, 2));
     840            error(new WrongNumberOfArgumentsException(fun, 2, -1));
    841841        try {
    842842            final LispObject methodArg = args[0];
     
    11161116                .execute(new SimpleString("JAVA:MAKE-IMMEDIATE-OBJECT is deprecated."));
    11171117            if (args.length < 1)
    1118                 error(new WrongNumberOfArgumentsException(this));
     1118                error(new WrongNumberOfArgumentsException(this, 1, -1));
    11191119            LispObject object = args[0];
    11201120            if (args.length > 1) {
  • trunk/abcl/src/org/armedbear/lisp/LispThread.java

    r13440 r13461  
    605605    }
    606606
     607    public final Environment setEnv(Environment env) {
     608        return (stack != null) ? stack.setEnv(env) : null;
     609    }
     610
    607611    public void resetStack()
    608612    {
     
    929933    }
    930934
    931     @DocString(name="make-thread", args="function &optional &key name")
     935    @DocString(name="make-thread", args="function &key name")
    932936    private static final Primitive MAKE_THREAD =
    933         new Primitive("make-thread", PACKAGE_THREADS, true, "function &optional &key name")
     937        new Primitive("make-thread", PACKAGE_THREADS, true, "function &key name")
    934938    {
    935939        @Override
     
    938942            final int length = args.length;
    939943            if (length == 0)
    940                 error(new WrongNumberOfArgumentsException(this));
     944                error(new WrongNumberOfArgumentsException(this, 1, -1));
    941945            LispObject name = NIL;
    942946            if (length > 1) {
     
    944948                    error(new ProgramError("Odd number of keyword arguments."));
    945949                if (length > 3)
    946                     error(new WrongNumberOfArgumentsException(this));
     950                    error(new WrongNumberOfArgumentsException(this, -1, 2)); // don't count the keyword itself as an argument
    947951                if (args[1] == Keyword.NAME)
    948952                    name = args[2].STRING();
     
    11161120        {
    11171121            if (args.length < 2)
    1118                 return error(new WrongNumberOfArgumentsException(this));
     1122                return error(new WrongNumberOfArgumentsException(this, 2, -1));
    11191123            final LispThread thread;
    11201124            if (args[0] instanceof LispThread) {
     
    11551159        {
    11561160            if (args.length > 1)
    1157                 return error(new WrongNumberOfArgumentsException(this));
     1161                return error(new WrongNumberOfArgumentsException(this, -1, 1));
    11581162            int limit = args.length > 0 ? Fixnum.getValue(args[0]) : 0;
    11591163            return currentThread().backtrace(limit);
     
    11691173        {
    11701174            if (args.length != 1)
    1171                 return error(new WrongNumberOfArgumentsException(this));
     1175                return error(new WrongNumberOfArgumentsException(this, 1));
    11721176           
    11731177            return checkStackFrame(args[0]).toLispString();
     
    11841188        {
    11851189            if (args.length != 1)
    1186                 return error(new WrongNumberOfArgumentsException(this));
     1190                return error(new WrongNumberOfArgumentsException(this, 1));
    11871191
    11881192            return checkStackFrame(args[0]).toLispList();
     
    12131217        {
    12141218          if (args == NIL)
    1215             return error(new WrongNumberOfArgumentsException(this));
     1219            return error(new WrongNumberOfArgumentsException(this, 1));
    12161220
    12171221          LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java

    r13440 r13461  
    106106        {
    107107            if (args.length == 0 || args.length > 2)
    108                 return error(new WrongNumberOfArgumentsException(this));
     108                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    109109            LispObject symbols = args[0];
    110110            Package pkg =
     
    130130        {
    131131            if (args.length == 0 || args.length > 2)
    132                 return error(new WrongNumberOfArgumentsException(this));
     132                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    133133            LispObject symbols = args[0];
    134134            Package pkg =
     
    154154        {
    155155            if (args.length == 0 || args.length > 2)
    156                 return error(new WrongNumberOfArgumentsException(this));
     156                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    157157            LispObject symbols = args[0];
    158158            Package pkg =
     
    178178        {
    179179            if (args.length == 0 || args.length > 2)
    180                 return error(new WrongNumberOfArgumentsException(this));
     180                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    181181            LispObject symbols = args[0];
    182182            Package pkg =
     
    225225        {
    226226            if (args.length < 1 || args.length > 2)
    227                 return error(new WrongNumberOfArgumentsException(this));
     227                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    228228            Package pkg;
    229229            if (args.length == 2)
     
    252252        {
    253253            if (args.length < 2 || args.length > 3)
    254                 return error(new WrongNumberOfArgumentsException(this));
     254                return error(new WrongNumberOfArgumentsException(this, 2, 3));
    255255            Package pkg = coerceToPackage(args[0]);
    256256            String newName = javaString(args[1]);
     
    280280        {
    281281            if (args.length != 10)
    282                 return error(new WrongNumberOfArgumentsException(this));
     282                return error(new WrongNumberOfArgumentsException(this, 10));
    283283            final String packageName = args[0].getStringValue();
    284284            LispObject nicknames = checkList(args[1]);
  • trunk/abcl/src/org/armedbear/lisp/Pathname.java

    r13460 r13461  
    15391539                return NIL;
    15401540            default:
    1541                 return error(new WrongNumberOfArgumentsException(this));
     1541                return error(new WrongNumberOfArgumentsException(this, 0, 1));
    15421542            }
    15431543        }
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r13446 r13461  
    8383        @Override
    8484        public LispObject execute() {
    85             return error(new WrongNumberOfArgumentsException(this));
     85            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    8686        }
    8787        @Override
     
    113113        @Override
    114114        public LispObject execute() {
    115             return error(new WrongNumberOfArgumentsException(this));
     115            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    116116        }
    117117        @Override
     
    149149        @Override
    150150        public LispObject execute() {
    151             return error(new WrongNumberOfArgumentsException(this));
     151            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    152152        }
    153153        @Override
     
    794794        @Override
    795795        public LispObject execute() {
    796             return error(new WrongNumberOfArgumentsException(this));
     796            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    797797        }
    798798        @Override
     
    840840        {
    841841            if (args == NIL)
    842                 return error(new WrongNumberOfArgumentsException(this));
     842                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    843843            final LispThread thread = LispThread.currentThread();
    844844            if (eval(args.car(), env, thread) != NIL) {
     
    863863        {
    864864            if (args == NIL)
    865                 return error(new WrongNumberOfArgumentsException(this));
     865                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    866866            final LispThread thread = LispThread.currentThread();
    867867            if (eval(args.car(), env, thread) == NIL) {
     
    12451245        @Override
    12461246        public LispObject execute() {
    1247             return error(new WrongNumberOfArgumentsException(this));
     1247            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    12481248        }
    12491249        @Override
     
    12891289        @Override
    12901290        public LispObject execute() {
    1291             return error(new WrongNumberOfArgumentsException(this));
     1291            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    12921292        }
    12931293        @Override
     
    13381338        @Override
    13391339        public LispObject execute() {
    1340             return error(new WrongNumberOfArgumentsException(this));
     1340            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    13411341        }
    13421342        @Override
     
    13801380        @Override
    13811381        public LispObject execute() {
    1382             return error(new WrongNumberOfArgumentsException(this));
     1382            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    13831383        }
    13841384        @Override
     
    14221422        @Override
    14231423        public LispObject execute() {
    1424             return error(new WrongNumberOfArgumentsException(this));
     1424            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    14251425        }
    14261426        @Override
     
    14641464        @Override
    14651465        public LispObject execute() {
    1466             return error(new WrongNumberOfArgumentsException(this));
     1466            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    14671467        }
    14681468        @Override
     
    16251625        public LispObject execute(LispObject[] args) {
    16261626            if (args.length < 1)
    1627                 return error(new WrongNumberOfArgumentsException(this));
     1627                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    16281628            if (args[0] instanceof Condition)
    16291629                return error((Condition)args[0]);
     
    16861686        public LispObject execute(LispObject[] args) {
    16871687            if (args.length < 2)
    1688                 return error(new WrongNumberOfArgumentsException(this));
     1688                return error(new WrongNumberOfArgumentsException(this, 2, -1));
    16891689            LispObject destination = args[0];
    16901690            // Copy remaining arguments.
     
    23002300        public LispObject execute(LispObject[] args) {
    23012301            if (args.length < 1)
    2302                 return error(new WrongNumberOfArgumentsException(this));
     2302                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    23032303            final AbstractArray array;
    23042304            LispObject r = args[0];
     
    23562356        @Override
    23572357        public LispObject execute() {
    2358             return error(new WrongNumberOfArgumentsException(this));
     2358            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    23592359        }
    23602360        @Override
     
    26802680        @Override
    26812681        public LispObject execute() {
    2682             return error(new WrongNumberOfArgumentsException(this));
     2682            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    26832683        }
    26842684        @Override
     
    27732773        @Override
    27742774        public LispObject execute() {
    2775             return error(new WrongNumberOfArgumentsException(this));
    2776         }
    2777         @Override
    2778         public LispObject execute(LispObject arg) {
    2779             return error(new WrongNumberOfArgumentsException(this));
     2775            return error(new WrongNumberOfArgumentsException(this, 2, -1));
     2776        }
     2777        @Override
     2778        public LispObject execute(LispObject arg) {
     2779            return error(new WrongNumberOfArgumentsException(this, 2, -1));
    27802780        }
    27812781        @Override
     
    29112911            final int numArgs = args.length;
    29122912            if (numArgs < 2)
    2913                 return error(new WrongNumberOfArgumentsException(this));
     2913                return error(new WrongNumberOfArgumentsException(this, 2, -1));
    29142914            int commonLength = -1;
    29152915            for (int i = 1; i < numArgs; i++) {
     
    29872987            final int numArgs = args.length;
    29882988            if (numArgs < 2)
    2989                 return error(new WrongNumberOfArgumentsException(this));
     2989                return error(new WrongNumberOfArgumentsException(this, 2, -1));
    29902990            int commonLength = -1;
    29912991            for (int i = 1; i < numArgs; i++) {
     
    31553155        public LispObject execute(LispObject[] args) {
    31563156            if (args.length == 0 || args.length > 2)
    3157                 return error(new WrongNumberOfArgumentsException(this));
     3157                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    31583158            Symbol symbol = checkSymbol(args[0]);
    31593159            Package pkg;
     
    33233323        public LispObject execute(LispObject[] args) {
    33243324            if (args.length < 1 || args.length > 2)
    3325                 return error(new WrongNumberOfArgumentsException(this));
     3325                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    33263326            Package pkg;
    33273327            if (args.length == 2)
     
    36983698        {
    36993699            if (args.length() != 1)
    3700                 return error(new WrongNumberOfArgumentsException(this));
     3700                return error(new WrongNumberOfArgumentsException(this, 1));
    37013701            Binding binding = env.getTagBinding(args.car());
    37023702            if (binding == null)
     
    37213721        {
    37223722            if (args == NIL)
    3723                 return error(new WrongNumberOfArgumentsException(this));
     3723                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    37243724            LispObject tag;
    37253725            tag = checkSymbol(args.car());
     
    37573757            final int length = args.length();
    37583758            if (length < 1 || length > 2)
    3759                 return error(new WrongNumberOfArgumentsException(this));
     3759                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    37603760            Symbol symbol;
    37613761            symbol = checkSymbol(args.car());
     
    37803780        {
    37813781            if (args.length() < 1)
    3782                 return error(new WrongNumberOfArgumentsException(this));
     3782                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    37833783            final LispThread thread = LispThread.currentThread();
    37843784            LispObject tag = eval(args.car(), env, thread);
     
    38143814        {
    38153815            if (args.length() != 2)
    3816                 return error(new WrongNumberOfArgumentsException(this));
     3816                return error(new WrongNumberOfArgumentsException(this, 2));
    38173817            final LispThread thread = LispThread.currentThread();
    38183818            thread.throwToTag(eval(args.car(), env, thread),
     
    39653965        {
    39663966            if (args.length() == 0)
    3967                 return error(new WrongNumberOfArgumentsException(this));
     3967                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    39683968            final LispThread thread = LispThread.currentThread();
    39693969            LispObject result = eval(args.car(), env, thread);
     
    39913991        {
    39923992            if (args.length() == 0)
    3993                 return error(new WrongNumberOfArgumentsException(this));
     3993                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    39943994            final LispThread thread = LispThread.currentThread();
    39953995            LispObject function;
     
    40974097        {
    40984098            if (args.length() != 1)
    4099                 return error(new WrongNumberOfArgumentsException(this));
     4099                return error(new WrongNumberOfArgumentsException(this, 1));
    41004100            final LispThread thread = LispThread.currentThread();
    41014101            LispObject result = eval(((Cons)args).car, env, thread);
     
    41264126        {
    41274127            if (args.length() != 2)
    4128                 return error(new WrongNumberOfArgumentsException(this));
     4128                return error(new WrongNumberOfArgumentsException(this, 2));
    41294129            final LispThread thread = LispThread.currentThread();
    41304130            int n = Fixnum.getValue(eval(args.car(), env, thread));
     
    43924392        @Override
    43934393        public LispObject execute() {
    4394             return error(new WrongNumberOfArgumentsException(this));
     4394            return error(new WrongNumberOfArgumentsException(this, 1, -1));
    43954395        }
    43964396        @Override
  • trunk/abcl/src/org/armedbear/lisp/Readtable.java

    r13442 r13461  
    446446      {
    447447        if (args.length < 1 || args.length > 3)
    448           return error(new WrongNumberOfArgumentsException(this));
     448          return error(new WrongNumberOfArgumentsException(this, 1, 3));
    449449        char dispChar = LispCharacter.getValue(args[0]);
    450450        LispObject non_terminating_p;
     
    473473      {
    474474        if (args.length < 2 || args.length > 3)
    475           return error(new WrongNumberOfArgumentsException(this));
     475          return error(new WrongNumberOfArgumentsException(this, 1, 3));
    476476        char dispChar = LispCharacter.getValue(args[0]);
    477477        char subChar = LispCharacter.getValue(args[1]);
     
    495495      {
    496496        if (args.length < 3 || args.length > 4)
    497           return error(new WrongNumberOfArgumentsException(this));
     497          return error(new WrongNumberOfArgumentsException(this, 3, 4));
    498498        char dispChar = LispCharacter.getValue(args[0]);
    499499        char subChar = LispCharacter.getValue(args[1]);
     
    519519      {
    520520        if (args.length < 2 || args.length > 4)
    521           return error(new WrongNumberOfArgumentsException(this));
     521          return error(new WrongNumberOfArgumentsException(this, 2, 4));
    522522        char toChar = LispCharacter.getValue(args[0]);
    523523        char fromChar = LispCharacter.getValue(args[1]);
  • trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java

    r13440 r13461  
    5151        {
    5252            if (args.cdr() != NIL)
    53                 return error(new WrongNumberOfArgumentsException(this));
     53                return error(new WrongNumberOfArgumentsException(this, 1));
    5454            return args.car();
    5555        }
     
    8181            }
    8282            default:
    83                 return error(new WrongNumberOfArgumentsException(this));
     83                return error(new WrongNumberOfArgumentsException(this, 2, 3));
    8484            }
    8585        }
     
    9898        {
    9999            if (args == NIL)
    100                 return error(new WrongNumberOfArgumentsException(this));
     100                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    101101            return _let(args, env, false);
    102102        }
     
    115115        {
    116116            if (args == NIL)
    117                 return error(new WrongNumberOfArgumentsException(this));
     117                return error(new WrongNumberOfArgumentsException(this, 1, -1));
    118118            return _let(args, env, true);
    119119        }
     
    238238                            LispThread.currentThread());
    239239            default:
    240                 return error(new WrongNumberOfArgumentsException(this));
     240                return error(new WrongNumberOfArgumentsException(this, 1, 2));
    241241            }
    242242        }
     
    379379        {
    380380            if (args.length() != 2)
    381                 return error(new WrongNumberOfArgumentsException(this));
     381                return error(new WrongNumberOfArgumentsException(this, 2));
    382382            LispObject rv = eval(args.cadr(), env, LispThread.currentThread());
    383383
     
    417417        {
    418418            if (args.length() < 2)
    419                 return error(new WrongNumberOfArgumentsException(this));
     419                return error(new WrongNumberOfArgumentsException(this, 2, -1));
    420420            final LispThread thread = LispThread.currentThread();
    421421            final LispObject symbols = checkList(eval(args.car(), env, thread));
  • trunk/abcl/src/org/armedbear/lisp/Stream.java

    r13442 r13461  
    20812081        public LispObject execute(LispObject[] args) {
    20822082            if (args.length > 1)
    2083                 return error(new WrongNumberOfArgumentsException(this));
     2083                return error(new WrongNumberOfArgumentsException(this, -1, 1));
    20842084            final Stream in;
    20852085            if (args.length == 0)
     
    21792179            int length = args.length;
    21802180            if (length < 1 || length > 3)
    2181                 return error(new WrongNumberOfArgumentsException(this));
     2181                return error(new WrongNumberOfArgumentsException(this, 1, 3));
    21822182            final Stream in = checkBinaryInputStream(args[0]);
    21832183            boolean eofError = length > 1 ? (args[1] != NIL) : true;
     
    23522352            int length = args.length;
    23532353            if (length > 4)
    2354                 return error(new WrongNumberOfArgumentsException(this));
     2354                return error(new WrongNumberOfArgumentsException(this, -1, 4));
    23552355            Stream stream =
    23562356                length > 0 ? inSynonymOf(args[0]) : getStandardInput();
     
    24092409            int length = args.length;
    24102410            if (length > 4)
    2411                 error(new WrongNumberOfArgumentsException(this));
     2411                error(new WrongNumberOfArgumentsException(this, -1, 4));
    24122412            Stream stream =
    24132413                length > 0 ? inSynonymOf(args[0]) : getStandardInput();
     
    24282428            int length = args.length;
    24292429            if (length < 1 || length > 3)
    2430                 error(new WrongNumberOfArgumentsException(this));
     2430                error(new WrongNumberOfArgumentsException(this, 1, 3));
    24312431            char c = LispCharacter.getValue(args[0]);
    24322432            Stream stream =
  • trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java

    r13453 r13461  
    3939{
    4040    private Operator operator;
    41     private int expectedArgs;
     41    private int expectedMinArgs;
     42    private int expectedMaxArgs;
    4243    private String message;
    4344
     
    4647    }
    4748
    48     public WrongNumberOfArgumentsException(Operator operator, int expectedArgs) {
     49    public WrongNumberOfArgumentsException(Operator operator, int expectedMin,
     50            int expectedMax) {
    4951        // This is really just an ordinary PROGRAM-ERROR, broken out into its
    5052        // own Java class as a convenience for the implementation.
    5153        super(StandardClass.PROGRAM_ERROR);
    5254        this.operator = operator;
    53   this.expectedArgs = expectedArgs;
     55  this.expectedMinArgs = expectedMinArgs;
     56  this.expectedMaxArgs = expectedMaxArgs;
    5457        setFormatControl(getMessage());
    5558        setFormatArguments(NIL);
     59    }
     60   
     61    public WrongNumberOfArgumentsException(Operator operator, int expectedArgs) {
     62        this(operator, expectedArgs, expectedArgs);
    5663    }
    5764
     
    7582            new StringBuilder("Wrong number of arguments for "
    7683                              + operator.princToString());
    77   if(expectedArgs >= 0) {
     84  if(expectedMinArgs >= 0 || expectedMaxArgs >= 0) {
    7885      sb.append("; ");
    79       sb.append(expectedArgs);
     86           
     87            if (expectedMinArgs == expectedMaxArgs) {
     88                sb.append(expectedMinArgs);
     89            } else if (expectedMaxArgs < 0) {
     90                sb.append("at least ");
     91                sb.append(expectedMinArgs);
     92            } else if (expectedMinArgs < 0) {
     93                sb.append("at most ");
     94                sb.append(expectedMaxArgs);
     95            } else {
     96                sb.append("between ").append(expectedMinArgs);
     97                sb.append(" and ").append(expectedMaxArgs);
     98            }
     99           
    80100      sb.append(" expected");
    81101  }
  • trunk/abcl/src/org/armedbear/lisp/adjust_array.java

    r12288 r13461  
    5050    {
    5151        if (args.length != 10)
    52             return error(new WrongNumberOfArgumentsException(this));
     52            return error(new WrongNumberOfArgumentsException(this, 10));
    5353        AbstractArray array = checkArray(args[0]);
    5454        LispObject dimensions = args[1];
  • trunk/abcl/src/org/armedbear/lisp/make_array.java

    r13119 r13461  
    5050  {
    5151    if (args.length != 9)
    52       return error(new WrongNumberOfArgumentsException(this));
     52      return error(new WrongNumberOfArgumentsException(this, 9));
    5353    LispObject dimensions = args[0];
    5454    LispObject elementType = args[1];
  • trunk/abcl/src/org/armedbear/lisp/peek_char.java

    r12288 r13461  
    5050        int length = args.length;
    5151        if (length > 5)
    52             error(new WrongNumberOfArgumentsException(this));
     52            error(new WrongNumberOfArgumentsException(this, -1, 5));
    5353        LispObject peekType = length > 0 ? args[0] : NIL;
    5454        Stream stream = length > 1 ? inSynonymOf(args[1]) : getStandardInput();
  • trunk/abcl/src/org/armedbear/lisp/room.java

    r12288 r13461  
    4848    {
    4949        if (args.length > 1)
    50             return error(new WrongNumberOfArgumentsException(this));
     50            return error(new WrongNumberOfArgumentsException(this, -1, 1));
    5151        Runtime runtime = Runtime.getRuntime();
    5252        long total = runtime.totalMemory();
Note: See TracChangeset for help on using the changeset viewer.