Changeset 8801


Ignore:
Timestamp:
03/19/05 20:01:06 (16 years ago)
Author:
piso
Message:

Increased +ARG-COUNT-MAX+ from 4 to 6.

Location:
trunk/j/src/org/armedbear/lisp
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/Autoload.java

    r8789 r8801  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Autoload.java,v 1.221 2005-03-18 18:42:31 piso Exp $
     5 * $Id: Autoload.java,v 1.222 2005-03-19 20:00:22 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7676            final LispThread thread = LispThread.currentThread();
    7777            final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    78             int loadDepth = Fixnum.getInt(_LOAD_DEPTH_.symbolValue());
     78            int loadDepth = Fixnum.getValue(_LOAD_DEPTH_.symbolValue());
    7979            thread.bindSpecial(_LOAD_DEPTH_, new Fixnum(++loadDepth));
    8080            try {
     
    126126    }
    127127
    128     public LispObject execute(LispObject[] args) throws ConditionThrowable
    129     {
    130         load();
    131         return getSymbol().execute(args);
    132     }
    133 
    134128    public LispObject execute() throws ConditionThrowable
    135129    {
     
    165159        load();
    166160        return getSymbol().execute(first, second, third, fourth);
     161    }
     162
     163    public LispObject execute(LispObject first, LispObject second,
     164                              LispObject third, LispObject fourth,
     165                              LispObject fifth)
     166        throws ConditionThrowable
     167    {
     168        load();
     169        return getSymbol().execute(first, second, third, fourth, fifth);
     170    }
     171
     172    public LispObject execute(LispObject first, LispObject second,
     173                              LispObject third, LispObject fourth,
     174                              LispObject fifth, LispObject sixth)
     175        throws ConditionThrowable
     176    {
     177        load();
     178        return getSymbol().execute(first, second, third, fourth, fifth, sixth);
     179    }
     180
     181    public LispObject execute(LispObject[] args) throws ConditionThrowable
     182    {
     183        load();
     184        return getSymbol().execute(args);
    167185    }
    168186
  • trunk/j/src/org/armedbear/lisp/Closure.java

    r8665 r8801  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Closure.java,v 1.93 2005-02-28 17:20:54 piso Exp $
     5 * $Id: Closure.java,v 1.94 2005-03-19 20:00:22 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    541541    }
    542542
     543    public LispObject execute(LispObject first, LispObject second,
     544                              LispObject third, LispObject fourth,
     545                              LispObject fifth)
     546        throws ConditionThrowable
     547    {
     548        if (minArgs == 5) {
     549            final LispThread thread = LispThread.currentThread();
     550            SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
     551            Environment ext = new Environment(environment);
     552            if (specials != null) {
     553                for (int i = 0; i < specials.length; i++)
     554                    ext.declareSpecial(specials[i]);
     555            }
     556            bind(requiredParameters[0].var, first, ext);
     557            bind(requiredParameters[1].var, second, ext);
     558            bind(requiredParameters[2].var, third, ext);
     559            bind(requiredParameters[3].var, fourth, ext);
     560            bind(requiredParameters[4].var, fifth, ext);
     561            if (arity != 5) {
     562                if (optionalParameters != null)
     563                    bindOptionalParameterDefaults(ext, thread);
     564                if (restVar != null)
     565                    bind(restVar, NIL, ext);
     566                if (keywordParameters != null)
     567                    bindKeywordParameterDefaults(ext, thread);
     568            }
     569            if (auxVars != null)
     570                bindAuxVars(ext, thread);
     571            LispObject result = NIL;
     572            LispObject prog = body;
     573            try {
     574                while (prog != NIL) {
     575                    result = eval(prog.car(), ext, thread);
     576                    prog = prog.cdr();
     577                }
     578            }
     579            finally {
     580                thread.lastSpecialBinding = lastSpecialBinding;
     581            }
     582            return result;
     583        } else {
     584            LispObject[] args = new LispObject[5];
     585            args[0] = first;
     586            args[1] = second;
     587            args[2] = third;
     588            args[3] = fourth;
     589            args[4] = fifth;
     590            return execute(args);
     591        }
     592    }
     593
     594    public LispObject execute(LispObject first, LispObject second,
     595                              LispObject third, LispObject fourth,
     596                              LispObject fifth, LispObject sixth)
     597        throws ConditionThrowable
     598    {
     599        if (minArgs == 6) {
     600            final LispThread thread = LispThread.currentThread();
     601            SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
     602            Environment ext = new Environment(environment);
     603            if (specials != null) {
     604                for (int i = 0; i < specials.length; i++)
     605                    ext.declareSpecial(specials[i]);
     606            }
     607            bind(requiredParameters[0].var, first, ext);
     608            bind(requiredParameters[1].var, second, ext);
     609            bind(requiredParameters[2].var, third, ext);
     610            bind(requiredParameters[3].var, fourth, ext);
     611            bind(requiredParameters[4].var, fifth, ext);
     612            bind(requiredParameters[5].var, sixth, ext);
     613            if (arity != 6) {
     614                if (optionalParameters != null)
     615                    bindOptionalParameterDefaults(ext, thread);
     616                if (restVar != null)
     617                    bind(restVar, NIL, ext);
     618                if (keywordParameters != null)
     619                    bindKeywordParameterDefaults(ext, thread);
     620            }
     621            if (auxVars != null)
     622                bindAuxVars(ext, thread);
     623            LispObject result = NIL;
     624            LispObject prog = body;
     625            try {
     626                while (prog != NIL) {
     627                    result = eval(prog.car(), ext, thread);
     628                    prog = prog.cdr();
     629                }
     630            }
     631            finally {
     632                thread.lastSpecialBinding = lastSpecialBinding;
     633            }
     634            return result;
     635        } else {
     636            LispObject[] args = new LispObject[6];
     637            args[0] = first;
     638            args[1] = second;
     639            args[2] = third;
     640            args[3] = fourth;
     641            args[4] = fifth;
     642            args[5] = sixth;
     643            return execute(args);
     644        }
     645    }
     646
    543647    public LispObject execute(LispObject[] args) throws ConditionThrowable
    544648    {
  • trunk/j/src/org/armedbear/lisp/ClosureTemplateFunction.java

    r8335 r8801  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: ClosureTemplateFunction.java,v 1.5 2005-01-10 17:46:03 piso Exp $
     5 * $Id: ClosureTemplateFunction.java,v 1.6 2005-03-19 20:00:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6767    }
    6868
     69    public final LispObject execute(LispObject first, LispObject second,
     70                                    LispObject third, LispObject fourth,
     71                                    LispObject fifth)
     72        throws ConditionThrowable
     73    {
     74        return notImplemented();
     75    }
     76
     77    public final LispObject execute(LispObject first, LispObject second,
     78                                    LispObject third, LispObject fourth,
     79                                    LispObject fifth, LispObject sixth)
     80        throws ConditionThrowable
     81    {
     82        return notImplemented();
     83    }
     84
    6985    private static final LispObject notImplemented() throws ConditionThrowable
    7086    {
     
    125141    }
    126142
     143    // Five args.
     144    public LispObject execute(LispObject[] context, LispObject first,
     145                              LispObject second, LispObject third,
     146                              LispObject fourth, LispObject fifth)
     147        throws ConditionThrowable
     148    {
     149        LispObject[] args = new LispObject[5];
     150        args[0] = first;
     151        args[1] = second;
     152        args[2] = third;
     153        args[3] = fourth;
     154        args[4] = fifth;
     155        return execute(context, args);
     156    }
     157
     158    // Six args.
     159    public LispObject execute(LispObject[] context, LispObject first,
     160                              LispObject second, LispObject third,
     161                              LispObject fourth, LispObject fifth,
     162                              LispObject sixth)
     163        throws ConditionThrowable
     164    {
     165        LispObject[] args = new LispObject[6];
     166        args[0] = first;
     167        args[1] = second;
     168        args[2] = third;
     169        args[3] = fourth;
     170        args[4] = fifth;
     171        args[5] = sixth;
     172        return execute(context, args);
     173    }
     174
    127175    // Arg array.
    128176    public LispObject execute(LispObject[] context, LispObject[] args)
  • trunk/j/src/org/armedbear/lisp/CompiledClosure.java

    r8335 r8801  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: CompiledClosure.java,v 1.3 2005-01-10 17:46:03 piso Exp $
     5 * $Id: CompiledClosure.java,v 1.4 2005-03-19 20:00:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6969    }
    7070
     71    public LispObject execute(LispObject first, LispObject second,
     72                              LispObject third, LispObject fourth,
     73                              LispObject fifth)
     74        throws ConditionThrowable
     75    {
     76        return ctf.execute(context, first, second, third, fourth, fifth);
     77    }
     78
     79    public LispObject execute(LispObject first, LispObject second,
     80                              LispObject third, LispObject fourth,
     81                              LispObject fifth, LispObject sixth)
     82        throws ConditionThrowable
     83    {
     84        return ctf.execute(context, first, second, third, fourth, fifth, sixth);
     85    }
     86
    7187    public LispObject execute(LispObject[] args) throws ConditionThrowable
    7288    {
  • trunk/j/src/org/armedbear/lisp/CompiledFunction.java

    r8538 r8801  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: CompiledFunction.java,v 1.31 2005-02-12 02:16:57 piso Exp $
     5 * $Id: CompiledFunction.java,v 1.32 2005-03-19 20:00:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8888    }
    8989
     90    public LispObject execute(LispObject first, LispObject second,
     91                              LispObject third, LispObject fourth,
     92                              LispObject fifth)
     93        throws ConditionThrowable
     94    {
     95        LispObject[] args = new LispObject[5];
     96        args[0] = first;
     97        args[1] = second;
     98        args[2] = third;
     99        args[3] = fourth;
     100        args[4] = fifth;
     101        return execute(args);
     102    }
     103
     104    public LispObject execute(LispObject first, LispObject second,
     105                              LispObject third, LispObject fourth,
     106                              LispObject fifth, LispObject sixth)
     107        throws ConditionThrowable
     108    {
     109        LispObject[] args = new LispObject[6];
     110        args[0] = first;
     111        args[1] = second;
     112        args[2] = third;
     113        args[3] = fourth;
     114        args[4] = fifth;
     115        args[5] = sixth;
     116        return execute(args);
     117    }
     118
    90119    public LispObject execute(LispObject[] args) throws ConditionThrowable
    91120    {
  • trunk/j/src/org/armedbear/lisp/Cons.java

    r8660 r8801  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Cons.java,v 1.54 2005-02-28 02:50:03 piso Exp $
     5 * $Id: Cons.java,v 1.55 2005-03-19 20:00:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    363363    }
    364364
    365     public LispObject execute(LispObject[] args) throws ConditionThrowable
    366     {
    367         if (car == Symbol.LAMBDA) {
    368             Closure closure = new Closure(cdr.car(), cdr.cdr(),
    369                                           new Environment());
    370             return closure.execute(args);
    371         }
    372         return signal(new TypeError(this, list3(Symbol.OR, Symbol.FUNCTION,
    373                                                 Symbol.SYMBOL)));
    374     }
    375 
    376365    public LispObject execute() throws ConditionThrowable
    377366    {
     
    381370            return closure.execute();
    382371        }
    383         return signal(new TypeError(this, list3(Symbol.OR, Symbol.FUNCTION,
    384                                                 Symbol.SYMBOL)));
     372        return signalExecutionError();
    385373    }
    386374
     
    392380            return closure.execute(arg);
    393381        }
    394         return signal(new TypeError(this, list3(Symbol.OR, Symbol.FUNCTION,
    395                                                 Symbol.SYMBOL)));
     382        return signalExecutionError();
    396383    }
    397384
     
    404391            return closure.execute(first, second);
    405392        }
    406         return signal(new TypeError(this, list3(Symbol.OR, Symbol.FUNCTION,
    407                                                 Symbol.SYMBOL)));
     393        return signalExecutionError();
    408394    }
    409395
     
    417403            return closure.execute(first, second, third);
    418404        }
    419         return signal(new TypeError(this, list3(Symbol.OR, Symbol.FUNCTION,
    420                                                 Symbol.SYMBOL)));
     405        return signalExecutionError();
    421406    }
    422407
     
    430415            return closure.execute(first, second, third, fourth);
    431416        }
     417        return signalExecutionError();
     418    }
     419
     420    public LispObject execute(LispObject first, LispObject second,
     421                              LispObject third, LispObject fourth,
     422                              LispObject fifth)
     423        throws ConditionThrowable
     424    {
     425        if (car == Symbol.LAMBDA) {
     426            Closure closure = new Closure(cdr.car(), cdr.cdr(),
     427                                          new Environment());
     428            return closure.execute(first, second, third, fourth, fifth);
     429        }
     430        return signalExecutionError();
     431    }
     432
     433    public LispObject execute(LispObject first, LispObject second,
     434                              LispObject third, LispObject fourth,
     435                              LispObject fifth, LispObject sixth)
     436        throws ConditionThrowable
     437    {
     438        if (car == Symbol.LAMBDA) {
     439            Closure closure = new Closure(cdr.car(), cdr.cdr(),
     440                                          new Environment());
     441            return closure.execute(first, second, third, fourth, fifth, sixth);
     442        }
     443        return signalExecutionError();
     444    }
     445
     446    public LispObject execute(LispObject[] args) throws ConditionThrowable
     447    {
     448        if (car == Symbol.LAMBDA) {
     449            Closure closure = new Closure(cdr.car(), cdr.cdr(),
     450                                          new Environment());
     451            return closure.execute(args);
     452        }
     453        return signalExecutionError();
     454    }
     455
     456    private final LispObject signalExecutionError() throws ConditionThrowable
     457    {
    432458        return signal(new TypeError(this, list3(Symbol.OR, Symbol.FUNCTION,
    433459                                                Symbol.SYMBOL)));
  • trunk/j/src/org/armedbear/lisp/Function.java

    r8664 r8801  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Function.java,v 1.43 2005-02-28 17:19:25 piso Exp $
     5 * $Id: Function.java,v 1.44 2005-03-19 20:00:24 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    156156    }
    157157
     158    public LispObject execute(LispObject first, LispObject second,
     159                              LispObject third, LispObject fourth,
     160                              LispObject fifth)
     161        throws ConditionThrowable
     162    {
     163        return signal(new WrongNumberOfArgumentsException(this));
     164    }
     165
     166    public LispObject execute(LispObject first, LispObject second,
     167                              LispObject third, LispObject fourth,
     168                              LispObject fifth, LispObject sixth)
     169        throws ConditionThrowable
     170    {
     171        return signal(new WrongNumberOfArgumentsException(this));
     172    }
     173
    158174    public LispObject execute(LispObject[] args) throws ConditionThrowable
    159175    {
  • trunk/j/src/org/armedbear/lisp/GenericFunction.java

    r8112 r8801  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: GenericFunction.java,v 1.17 2004-11-06 13:48:30 piso Exp $
     5 * $Id: GenericFunction.java,v 1.18 2005-03-19 20:00:24 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    106106        return LispThread.currentThread().execute(getDiscriminatingFunction(),
    107107                                                  first, second, third, fourth);
     108    }
     109
     110    public LispObject execute(LispObject first, LispObject second,
     111                              LispObject third, LispObject fourth,
     112                              LispObject fifth)
     113        throws ConditionThrowable
     114    {
     115        return LispThread.currentThread().execute(getDiscriminatingFunction(),
     116                                                  first, second, third, fourth,
     117                                                  fifth);
     118    }
     119
     120    public LispObject execute(LispObject first, LispObject second,
     121                              LispObject third, LispObject fourth,
     122                              LispObject fifth, LispObject sixth)
     123        throws ConditionThrowable
     124    {
     125        return LispThread.currentThread().execute(getDiscriminatingFunction(),
     126                                                  first, second, third, fourth,
     127                                                  fifth, sixth);
    108128    }
    109129
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r8792 r8801  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Lisp.java,v 1.328 2005-03-19 14:34:42 piso Exp $
     5 * $Id: Lisp.java,v 1.329 2005-03-19 20:00:25 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    136136                case 4:
    137137                    result = fun.execute(args[0], args[1], args[2], args[3]);
     138                    break;
     139                case 5:
     140                    result = fun.execute(args[0], args[1], args[2], args[3],
     141                                         args[4]);
     142                    break;
     143                case 6:
     144                    result = fun.execute(args[0], args[1], args[2], args[3],
     145                                         args[4], args[5]);
    138146                    break;
    139147                default:
     
    398406            return thread.execute(function, first, second, third, fourth);
    399407        }
    400         // More than 4 arguments.
    401         final int length = args.length() + 4;
     408        LispObject fifth = eval(args.car(), env, thread);
     409        args = args.cdr();
     410        if (args == NIL) {
     411            thread._values = null;
     412            return thread.execute(function, first, second, third, fourth,
     413                                  fifth);
     414        }
     415        LispObject sixth = eval(args.car(), env, thread);
     416        args = args.cdr();
     417        if (args == NIL) {
     418            thread._values = null;
     419            return thread.execute(function, first, second, third, fourth,
     420                                  fifth, sixth);
     421        }
     422        // More than 6 arguments.
     423        final int length = args.length() + 6;
    402424        LispObject[] array = new LispObject[length];
    403425        array[0] = first;
     
    405427        array[2] = third;
    406428        array[3] = fourth;
    407         for (int i = 4; i < length; i++) {
     429        array[4] = fifth;
     430        array[5] = sixth;
     431        for (int i = 6; i < length; i++) {
    408432            array[i] = eval(args.car(), env, thread);
    409433            args = args.cdr();
  • trunk/j/src/org/armedbear/lisp/LispObject.java

    r8653 r8801  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: LispObject.java,v 1.120 2005-02-28 00:55:20 piso Exp $
     5 * $Id: LispObject.java,v 1.121 2005-03-19 20:00:26 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    509509    }
    510510
    511     public LispObject execute(LispObject[] args) throws ConditionThrowable
    512     {
    513         return signal(new TypeError(this, Symbol.FUNCTION));
    514     }
    515 
    516511    public LispObject execute() throws ConditionThrowable
    517512    {
     
    544539    }
    545540
    546     public LispObject execute(LispObject[] args, LispObject[] context)
     541    public LispObject execute(LispObject first, LispObject second,
     542                              LispObject third, LispObject fourth,
     543                              LispObject fifth)
    547544        throws ConditionThrowable
    548545    {
     
    550547    }
    551548
    552     public LispObject execute(LispObject[] args, LispObject[][] context)
     549    public LispObject execute(LispObject first, LispObject second,
     550                              LispObject third, LispObject fourth,
     551                              LispObject fifth, LispObject sixth)
    553552        throws ConditionThrowable
    554553    {
    555554        return signal(new TypeError(this, Symbol.FUNCTION));
     555    }
     556
     557    public LispObject execute(LispObject[] args) throws ConditionThrowable
     558    {
     559        return signal(new TypeError(this, Symbol.FUNCTION));
     560    }
     561
     562    // Used by COMPILE-MULTIPLE-VALUE-CALL.
     563    public LispObject dispatch(LispObject[] args) throws ConditionThrowable
     564    {
     565        switch (args.length) {
     566            case 0:
     567                return execute();
     568            case 1:
     569                return execute(args[0]);
     570            case 2:
     571                return execute(args[0], args[1]);
     572            case 3:
     573                return execute(args[0], args[1], args[2]);
     574            case 4:
     575                return execute(args[0], args[1], args[2], args[3]);
     576            case 5:
     577                return execute(args[0], args[1], args[2], args[3], args[4]);
     578            case 6:
     579                return execute(args[0], args[1], args[2], args[3], args[4],
     580                               args[5]);
     581            default:
     582                return signal(new TypeError(this, Symbol.FUNCTION));
     583        }
    556584    }
    557585
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r8784 r8801  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: LispThread.java,v 1.77 2005-03-17 14:52:44 piso Exp $
     5 * $Id: LispThread.java,v 1.78 2005-03-19 20:00:27 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    641641        try {
    642642            return function.execute(first, second, third, fourth);
     643        }
     644        finally {
     645            if (profiling && sampling) {
     646                if (sampleNow)
     647                    Profiler.sample(this);
     648            }
     649            stack = oldStack;
     650        }
     651    }
     652
     653    public LispObject execute(LispObject function, LispObject first,
     654                              LispObject second, LispObject third,
     655                              LispObject fourth, LispObject fifth)
     656        throws ConditionThrowable
     657    {
     658        LispObject oldStack = stack;
     659        LispObject[] args = new LispObject[5];
     660        args[0] = first;
     661        args[1] = second;
     662        args[2] = third;
     663        args[3] = fourth;
     664        args[4] = fifth;
     665        pushStackFrame(function, args);
     666        try {
     667            return function.execute(first, second, third, fourth, fifth);
     668        }
     669        finally {
     670            if (profiling && sampling) {
     671                if (sampleNow)
     672                    Profiler.sample(this);
     673            }
     674            stack = oldStack;
     675        }
     676    }
     677
     678    public LispObject execute(LispObject function, LispObject first,
     679                              LispObject second, LispObject third,
     680                              LispObject fourth, LispObject fifth,
     681                              LispObject sixth)
     682        throws ConditionThrowable
     683    {
     684        LispObject oldStack = stack;
     685        LispObject[] args = new LispObject[6];
     686        args[0] = first;
     687        args[1] = second;
     688        args[2] = third;
     689        args[3] = fourth;
     690        args[4] = fifth;
     691        args[5] = sixth;
     692        pushStackFrame(function, args);
     693        try {
     694            return function.execute(first, second, third, fourth, fifth, sixth);
    643695        }
    644696        finally {
  • trunk/j/src/org/armedbear/lisp/Load.java

    r8660 r8801  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Load.java,v 1.96 2005-02-28 02:50:03 piso Exp $
     5 * $Id: Load.java,v 1.97 2005-03-19 20:00:27 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    242242    // internal symbol
    243243    private static final Symbol _FASL_VERSION_ =
    244         exportConstant("*FASL-VERSION*", PACKAGE_SYS, new Fixnum(26));
     244        exportConstant("*FASL-VERSION*", PACKAGE_SYS, new Fixnum(27));
    245245
    246246    // ### *fasl-anonymous-package*
  • trunk/j/src/org/armedbear/lisp/MacroObject.java

    r8652 r8801  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: MacroObject.java,v 1.8 2005-02-27 20:10:06 piso Exp $
     5 * $Id: MacroObject.java,v 1.9 2005-03-19 20:00:28 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3838    }
    3939
    40     public LispObject execute(LispObject[] args) throws ConditionThrowable
    41     {
    42         return signal(new UndefinedFunction(name));
    43     }
    44 
    4540    public LispObject execute() throws ConditionThrowable
    4641    {
     
    7368    }
    7469
     70    public LispObject execute(LispObject first, LispObject second,
     71                              LispObject third, LispObject fourth,
     72                              LispObject fifth)
     73        throws ConditionThrowable
     74    {
     75        return signal(new UndefinedFunction(name));
     76    }
     77
     78    public LispObject execute(LispObject first, LispObject second,
     79                              LispObject third, LispObject fourth,
     80                              LispObject fifth, LispObject sixth)
     81        throws ConditionThrowable
     82    {
     83        return signal(new UndefinedFunction(name));
     84    }
     85
     86    public LispObject execute(LispObject[] args) throws ConditionThrowable
     87    {
     88        return signal(new UndefinedFunction(name));
     89    }
     90
    7591    public String writeToString()
    7692    {
  • trunk/j/src/org/armedbear/lisp/Primitive.java

    r8091 r8801  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitive.java,v 1.12 2004-11-03 18:11:53 piso Exp $
     5 * $Id: Primitive.java,v 1.13 2005-03-19 20:00:28 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5959        super(name, pkg, exported, arglist, docstring);
    6060    }
    61    
     61
    6262    public LispObject typeOf()
    6363    {
     
    109109        return execute(args);
    110110    }
     111
     112    public LispObject execute(LispObject first, LispObject second,
     113                              LispObject third, LispObject fourth,
     114                              LispObject fifth)
     115        throws ConditionThrowable
     116    {
     117        LispObject[] args = new LispObject[5];
     118        args[0] = first;
     119        args[1] = second;
     120        args[2] = third;
     121        args[3] = fourth;
     122        args[4] = fifth;
     123        return execute(args);
     124    }
     125
     126    public LispObject execute(LispObject first, LispObject second,
     127                              LispObject third, LispObject fourth,
     128                              LispObject fifth, LispObject sixth)
     129        throws ConditionThrowable
     130    {
     131        LispObject[] args = new LispObject[6];
     132        args[0] = first;
     133        args[1] = second;
     134        args[2] = third;
     135        args[3] = fourth;
     136        args[4] = fifth;
     137        args[5] = sixth;
     138        return execute(args);
     139    }
    111140}
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r8784 r8801  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitives.java,v 1.743 2005-03-17 14:55:00 piso Exp $
     5 * $Id: Primitives.java,v 1.744 2005-03-19 20:00:28 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    24032403                                                      fourth);
    24042404        }
     2405        public LispObject execute(LispObject first, LispObject second,
     2406                                  LispObject third, LispObject fourth,
     2407                                  LispObject fifth)
     2408            throws ConditionThrowable
     2409        {
     2410            return LispThread.currentThread().execute(first, second, third,
     2411                                                      fourth, fifth);
     2412        }
     2413        public LispObject execute(LispObject first, LispObject second,
     2414                                  LispObject third, LispObject fourth,
     2415                                  LispObject fifth, LispObject sixth)
     2416            throws ConditionThrowable
     2417        {
     2418            return LispThread.currentThread().execute(first, second, third,
     2419                                                      fourth, fifth, sixth);
     2420        }
    24052421        public LispObject execute(LispObject[] args) throws ConditionThrowable
    24062422        {
    2407             if (args.length == 5) {
    2408                 return LispThread.currentThread().execute(args[0], args[1],
    2409                                                           args[2], args[3],
    2410                                                           args[4]);
    2411             } else {
    2412                 final int length = args.length - 1; // Number of arguments.
    2413                 LispObject[] newArgs = new LispObject[length];
    2414                 System.arraycopy(args, 1, newArgs, 0, length);
    2415                 return LispThread.currentThread().execute(args[0], newArgs);
    2416             }
     2423            final int length = args.length - 1; // Number of arguments.
     2424            LispObject[] newArgs = new LispObject[length];
     2425            System.arraycopy(args, 1, newArgs, 0, length);
     2426            return LispThread.currentThread().execute(args[0], newArgs);
    24172427        }
    24182428    };
     
    27352745    // ### find-package
    27362746    private static final Primitive FIND_PACKAGE =
    2737         new Primitive("find-package", "name") {
     2747        new Primitive("find-package", "name")
     2748    {
    27382749        public LispObject execute(LispObject arg) throws ConditionThrowable
    27392750        {
     
    37993810                signal(new WrongNumberOfArgumentsException(this));
    38003811            final LispThread thread = LispThread.currentThread();
    3801             int n = Fixnum.getInt(eval(args.car(), env, thread));
     3812            int n = Fixnum.getValue(eval(args.car(), env, thread));
    38023813            if (n < 0)
    38033814                n = 0;
     
    39133924        new Primitive("%read-from-string", PACKAGE_SYS, false)
    39143925    {
    3915         public LispObject execute(LispObject[] args) throws ConditionThrowable
    3916         {
    3917             if (args.length != 6)
    3918                 signal(new WrongNumberOfArgumentsException(this));
    3919             String s = args[0].getStringValue();
    3920             boolean eofError = args[1] != NIL;
    3921             LispObject eofValue = args[2];
    3922             LispObject start = args[3];
    3923             LispObject end = args[4];
    3924             boolean preserveWhitespace = args[5] != NIL;
     3926        public LispObject execute(LispObject first, LispObject second,
     3927                                  LispObject third, LispObject fourth,
     3928                                  LispObject fifth, LispObject sixth)
     3929            throws ConditionThrowable
     3930        {
     3931            String s = first.getStringValue();
     3932            boolean eofError = (second != NIL);
     3933            boolean preserveWhitespace = (sixth != NIL);
    39253934            final int startIndex;
    3926             if (start != NIL)
    3927                 startIndex = Fixnum.getValue(start);
     3935            if (fourth != NIL)
     3936                startIndex = Fixnum.getValue(fourth);
    39283937            else
    39293938                startIndex = 0;
    39303939            final int endIndex;
    3931             if (end != NIL)
    3932                 endIndex = Fixnum.getValue(end);
     3940            if (fifth != NIL)
     3941                endIndex = Fixnum.getValue(fifth);
    39333942            else
    39343943                endIndex = s.length();
     
    39383947            LispObject result;
    39393948            if (preserveWhitespace)
    3940                 result = in.readPreservingWhitespace(eofError, eofValue, false,
     3949                result = in.readPreservingWhitespace(eofError, third, false,
    39413950                                                     thread);
    39423951            else
    3943                 result = in.read(eofError, eofValue, false);
     3952                result = in.read(eofError, third, false);
    39443953            return thread.setValues(result, new Fixnum(in.getOffset()));
    39453954        }
     
    42624271
    42634272    // ### nreverse
    4264     public static final Primitive NREVERSE = new Primitive("nreverse", "sequence")
     4273    public static final Primitive NREVERSE =
     4274        new Primitive("nreverse", "sequence")
    42654275    {
    42664276        public LispObject execute (LispObject arg) throws ConditionThrowable
     
    42724282    // ### nreconc
    42734283    // Adapted from CLISP.
    4274     private static final Primitive NRECONC = new Primitive("nreconc", "list tail")
     4284    private static final Primitive NRECONC =
     4285        new Primitive("nreconc", "list tail")
    42754286    {
    42764287        public LispObject execute(LispObject list, LispObject obj)
     
    44124423    // %member item list key test test-not => tail
    44134424    private static final Primitive _MEMBER =
    4414         new Primitive("%member", PACKAGE_SYS, false) {
    4415         public LispObject execute(LispObject[] args) throws ConditionThrowable
    4416         {
    4417             if (args.length != 5)
    4418                 signal(new WrongNumberOfArgumentsException(this));
    4419             LispObject item = args[0];
    4420             LispObject tail = checkList(args[1]);
    4421             LispObject key = args[2];
     4425        new Primitive("%member", PACKAGE_SYS, false)
     4426    {
     4427        public LispObject execute(LispObject first, LispObject second,
     4428                                  LispObject third, LispObject fourth,
     4429                                  LispObject fifth)
     4430            throws ConditionThrowable
     4431        {
     4432            LispObject item = first;
     4433            LispObject tail = checkList(second);
     4434            LispObject key = third;
    44224435            if (key != NIL) {
    44234436                if (key instanceof Symbol)
    44244437                    key = key.getSymbolFunction();
    44254438                if (!(key instanceof Function || key instanceof GenericFunction))
    4426                     signal(new UndefinedFunction(args[2]));
    4427             }
    4428             LispObject test = args[3];
    4429             LispObject testNot = args[4];
     4439                    signal(new UndefinedFunction(third));
     4440            }
     4441            LispObject test = fourth;
     4442            LispObject testNot = fifth;
    44304443            if (test != NIL && testNot != NIL)
    44314444                signal(new LispError("MEMBER: test and test-not both supplied"));
     
    44364449                    test = test.getSymbolFunction();
    44374450                if (!(test instanceof Function || test instanceof GenericFunction))
    4438                     signal(new UndefinedFunction(args[3]));
     4451                    signal(new UndefinedFunction(fourth));
    44394452            } else if (testNot != NIL) {
    44404453                if (testNot instanceof Symbol)
    44414454                    testNot = testNot.getSymbolFunction();
    44424455                if (!(testNot instanceof Function || testNot instanceof GenericFunction))
    4443                     signal(new UndefinedFunction(args[3]));
     4456                    signal(new UndefinedFunction(fifth));
    44444457            }
    44454458            if (key == NIL && test == EQL) {
  • trunk/j/src/org/armedbear/lisp/SpecialOperator.java

    r8652 r8801  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: SpecialOperator.java,v 1.14 2005-02-27 20:09:23 piso Exp $
     5 * $Id: SpecialOperator.java,v 1.15 2005-03-19 20:00:31 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4747    }
    4848
    49     public LispObject execute(LispObject[] args) throws ConditionThrowable
    50     {
    51         return signal(new UndefinedFunction(getLambdaName()));
    52     }
    53 
    5449    public LispObject execute() throws ConditionThrowable
    5550    {
     
    8277    }
    8378
     79    public LispObject execute(LispObject first, LispObject second,
     80                              LispObject third, LispObject fourth,
     81                              LispObject fifth)
     82        throws ConditionThrowable
     83    {
     84        return signal(new UndefinedFunction(getLambdaName()));
     85    }
     86
     87    public LispObject execute(LispObject first, LispObject second,
     88                              LispObject third, LispObject fourth,
     89                              LispObject fifth, LispObject sixth)
     90        throws ConditionThrowable
     91    {
     92        return signal(new UndefinedFunction(getLambdaName()));
     93    }
     94
     95    public LispObject execute(LispObject[] args) throws ConditionThrowable
     96    {
     97        return signal(new UndefinedFunction(getLambdaName()));
     98    }
     99
    84100    public String toString()
    85101    {
  • trunk/j/src/org/armedbear/lisp/StringFunctions.java

    r8272 r8801  
    22 * StringFunctions.java
    33 *
    4  * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: StringFunctions.java,v 1.33 2004-12-19 18:34:53 piso Exp $
     4 * Copyright (C) 2003-2005 Peter Graves
     5 * $Id: StringFunctions.java,v 1.34 2005-03-19 20:00:31 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2929        new Primitive("%string=", PACKAGE_SYS, false)
    3030    {
    31         public LispObject execute(LispObject[] args) throws ConditionThrowable
    32         {
    33             if (args.length != 6)
    34                 return signal(new WrongNumberOfArgumentsException(this));
    35             char[] array1 = args[0].STRING().getStringChars();
    36             char[] array2 = args[1].STRING().getStringChars();
     31        public LispObject execute(LispObject first, LispObject second,
     32                                  LispObject third, LispObject fourth,
     33                                  LispObject fifth, LispObject sixth)
     34            throws ConditionThrowable
     35        {
     36            char[] array1 = first.STRING().getStringChars();
     37            char[] array2 = second.STRING().getStringChars();
    3738            int start1, end1, start2, end2;
    3839            try {
    39                 start1 = ((Fixnum)args[2]).value;
    40             }
    41             catch (ClassCastException e) {
    42                 return signal(new TypeError(args[2], Symbol.FIXNUM));
    43             }
    44             if (args[3] == NIL) {
     40                start1 = ((Fixnum)third).value;
     41            }
     42            catch (ClassCastException e) {
     43                return signal(new TypeError(third, Symbol.FIXNUM));
     44            }
     45            if (fourth == NIL) {
    4546                end1 = array1.length;
    4647            } else {
    4748                try {
    48                     end1 = ((Fixnum)args[3]).value;
     49                    end1 = ((Fixnum)fourth).value;
    4950                }
    5051                catch (ClassCastException e) {
    51                     return signal(new TypeError(args[3], Symbol.FIXNUM));
    52                 }
    53             }
    54             try {
    55                 start2 = ((Fixnum)args[4]).value;
    56             }
    57             catch (ClassCastException e) {
    58                 return signal(new TypeError(args[4], Symbol.FIXNUM));
    59             }
    60             if (args[5] == NIL) {
     52                    return signal(new TypeError(fourth, Symbol.FIXNUM));
     53                }
     54            }
     55            try {
     56                start2 = ((Fixnum)fifth).value;
     57            }
     58            catch (ClassCastException e) {
     59                return signal(new TypeError(fifth, Symbol.FIXNUM));
     60            }
     61            if (sixth == NIL) {
    6162                end2 = array2.length;
    6263            } else {
    6364                try {
    64                     end2 = ((Fixnum)args[5]).value;
     65                    end2 = ((Fixnum)sixth).value;
    6566                }
    6667                catch (ClassCastException e) {
    67                     return signal(new TypeError(args[5], Symbol.FIXNUM));
     68                    return signal(new TypeError(sixth, Symbol.FIXNUM));
    6869                }
    6970            }
     
    116117            char[] array1 = args[0].STRING().getStringChars();
    117118            char[] array2 = args[1].STRING().getStringChars();
    118             int start1 = Fixnum.getInt(args[2]);
    119             int end1 = Fixnum.getInt(args[3]);
    120             int start2 = Fixnum.getInt(args[4]);
    121             int end2 = Fixnum.getInt(args[5]);
     119            int start1 = Fixnum.getValue(args[2]);
     120            int end1 = Fixnum.getValue(args[3]);
     121            int start2 = Fixnum.getValue(args[4]);
     122            int end2 = Fixnum.getValue(args[5]);
    122123            int i = start1;
    123124            int j = start2;
     
    146147        new Primitive("%string-equal", PACKAGE_SYS, true)
    147148    {
    148         public LispObject execute(LispObject[] args) throws ConditionThrowable
    149         {
    150             if (args.length != 6)
    151                 return signal(new WrongNumberOfArgumentsException(this));
    152             char[] array1 = args[0].STRING().getStringChars();
    153             char[] array2 = args[1].STRING().getStringChars();
    154             int start1 = Fixnum.getInt(args[2]);
    155             int end1 = Fixnum.getInt(args[3]);
    156             int start2 = Fixnum.getInt(args[4]);
    157             int end2 = Fixnum.getInt(args[5]);
     149        public LispObject execute(LispObject first, LispObject second,
     150                                  LispObject third, LispObject fourth,
     151                                  LispObject fifth, LispObject sixth)
     152            throws ConditionThrowable
     153        {
     154            char[] array1 = first.STRING().getStringChars();
     155            char[] array2 = second.STRING().getStringChars();
     156            int start1 = Fixnum.getValue(third);
     157            int end1 = Fixnum.getValue(fourth);
     158            int start2 = Fixnum.getValue(fifth);
     159            int end2 = Fixnum.getValue(sixth);
    158160            if ((end1 - start1) != (end2 - start2))
    159161                return NIL;
     
    185187            char[] array1 = args[0].STRING().getStringChars();
    186188            char[] array2 = args[1].STRING().getStringChars();
    187             int start1 = Fixnum.getInt(args[2]);
    188             int end1 = Fixnum.getInt(args[3]);
    189             int start2 = Fixnum.getInt(args[4]);
    190             int end2 = Fixnum.getInt(args[5]);
     189            int start1 = Fixnum.getValue(args[2]);
     190            int end1 = Fixnum.getValue(args[3]);
     191            int start2 = Fixnum.getValue(args[4]);
     192            int end2 = Fixnum.getValue(args[5]);
    191193            int i = start1;
    192194            int j = start2;
     
    228230            char[] array1 = args[0].STRING().getStringChars();
    229231            char[] array2 = args[1].STRING().getStringChars();
    230             int start1 = Fixnum.getInt(args[2]);
    231             int end1 = Fixnum.getInt(args[3]);
    232             int start2 = Fixnum.getInt(args[4]);
    233             int end2 = Fixnum.getInt(args[5]);
     232            int start1 = Fixnum.getValue(args[2]);
     233            int end1 = Fixnum.getValue(args[3]);
     234            int start2 = Fixnum.getValue(args[4]);
     235            int end2 = Fixnum.getValue(args[5]);
    234236            int i = start1;
    235237            int j = start2;
     
    271273            char[] array1 = args[0].STRING().getStringChars();
    272274            char[] array2 = args[1].STRING().getStringChars();
    273             int start1 = Fixnum.getInt(args[2]);
    274             int end1 = Fixnum.getInt(args[3]);
    275             int start2 = Fixnum.getInt(args[4]);
    276             int end2 = Fixnum.getInt(args[5]);
     275            int start1 = Fixnum.getValue(args[2]);
     276            int end1 = Fixnum.getValue(args[3]);
     277            int start2 = Fixnum.getValue(args[4]);
     278            int end2 = Fixnum.getValue(args[5]);
    277279            int i = start1;
    278280            int j = start2;
     
    312314            char[] array1 = args[0].STRING().getStringChars();
    313315            char[] array2 = args[1].STRING().getStringChars();
    314             int start1 = Fixnum.getInt(args[2]);
    315             int end1 = Fixnum.getInt(args[3]);
    316             int start2 = Fixnum.getInt(args[4]);
    317             int end2 = Fixnum.getInt(args[5]);
     316            int start1 = Fixnum.getValue(args[2]);
     317            int end1 = Fixnum.getValue(args[3]);
     318            int start2 = Fixnum.getValue(args[4]);
     319            int end2 = Fixnum.getValue(args[5]);
    318320            int i = start1;
    319321            int j = start2;
     
    353355            char[] array1 = args[0].STRING().getStringChars();
    354356            char[] array2 = args[1].STRING().getStringChars();
    355             int start1 = Fixnum.getInt(args[2]);
    356             int end1 = Fixnum.getInt(args[3]);
    357             int start2 = Fixnum.getInt(args[4]);
    358             int end2 = Fixnum.getInt(args[5]);
     357            int start1 = Fixnum.getValue(args[2]);
     358            int end1 = Fixnum.getValue(args[3]);
     359            int start2 = Fixnum.getValue(args[4]);
     360            int end2 = Fixnum.getValue(args[5]);
    359361            int i = start1;
    360362            int j = start2;
     
    396398            char[] array1 = args[0].STRING().getStringChars();
    397399            char[] array2 = args[1].STRING().getStringChars();
    398             int start1 = Fixnum.getInt(args[2]);
    399             int end1 = Fixnum.getInt(args[3]);
    400             int start2 = Fixnum.getInt(args[4]);
    401             int end2 = Fixnum.getInt(args[5]);
     400            int start1 = Fixnum.getValue(args[2]);
     401            int end1 = Fixnum.getValue(args[3]);
     402            int start2 = Fixnum.getValue(args[4]);
     403            int end2 = Fixnum.getValue(args[5]);
    402404            int i = start1;
    403405            int j = start2;
     
    439441            char[] array1 = args[0].STRING().getStringChars();
    440442            char[] array2 = args[1].STRING().getStringChars();
    441             int start1 = Fixnum.getInt(args[2]);
    442             int end1 = Fixnum.getInt(args[3]);
    443             int start2 = Fixnum.getInt(args[4]);
    444             int end2 = Fixnum.getInt(args[5]);
     443            int start1 = Fixnum.getValue(args[2]);
     444            int end1 = Fixnum.getValue(args[3]);
     445            int start2 = Fixnum.getValue(args[4]);
     446            int end2 = Fixnum.getValue(args[5]);
    445447            int i = start1;
    446448            int j = start2;
     
    480482            char[] array1 = args[0].STRING().getStringChars();
    481483            char[] array2 = args[1].STRING().getStringChars();
    482             int start1 = Fixnum.getInt(args[2]);
    483             int end1 = Fixnum.getInt(args[3]);
    484             int start2 = Fixnum.getInt(args[4]);
    485             int end2 = Fixnum.getInt(args[5]);
     484            int start1 = Fixnum.getValue(args[2]);
     485            int end1 = Fixnum.getValue(args[3]);
     486            int start2 = Fixnum.getValue(args[4]);
     487            int end2 = Fixnum.getValue(args[5]);
    486488            int i = start1;
    487489            int j = start2;
     
    523525            char[] array1 = args[0].STRING().getStringChars();
    524526            char[] array2 = args[1].STRING().getStringChars();
    525             int start1 = Fixnum.getInt(args[2]);
    526             int end1 = Fixnum.getInt(args[3]);
    527             int start2 = Fixnum.getInt(args[4]);
    528             int end2 = Fixnum.getInt(args[5]);
     527            int start1 = Fixnum.getValue(args[2]);
     528            int end1 = Fixnum.getValue(args[3]);
     529            int start2 = Fixnum.getValue(args[4]);
     530            int end2 = Fixnum.getValue(args[5]);
    529531            int i = start1;
    530532            int j = start2;
     
    558560    {
    559561        public LispObject execute(LispObject first, LispObject second,
    560             LispObject third) throws ConditionThrowable
     562                                  LispObject third)
     563            throws ConditionThrowable
    561564        {
    562565            LispObject s = first.STRING();
     
    592595    {
    593596        public LispObject execute(LispObject first, LispObject second,
    594             LispObject third) throws ConditionThrowable
     597                                  LispObject third) throws
     598        ConditionThrowable
    595599        {
    596600            LispObject s = first.STRING();
     
    626630    {
    627631        public LispObject execute(LispObject first, LispObject second,
    628             LispObject third) throws ConditionThrowable
     632                                  LispObject third)
     633            throws ConditionThrowable
    629634        {
    630635            LispObject s = first.STRING();
     
    672677    {
    673678        public LispObject execute(LispObject first, LispObject second,
    674             LispObject third) throws ConditionThrowable
     679                                  LispObject third)
     680            throws ConditionThrowable
    675681        {
    676682            AbstractString string;
     
    705711    {
    706712        public LispObject execute(LispObject first, LispObject second,
    707             LispObject third) throws ConditionThrowable
     713                                  LispObject third)
     714            throws ConditionThrowable
    708715        {
    709716            AbstractString string;
     
    738745    {
    739746        public LispObject execute(LispObject first, LispObject second,
    740             LispObject third) throws ConditionThrowable
     747                                  LispObject third)
     748            throws ConditionThrowable
    741749        {
    742750            AbstractString string;
  • trunk/j/src/org/armedbear/lisp/Symbol.java

    r8784 r8801  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Symbol.java,v 1.176 2005-03-17 14:58:18 piso Exp $
     5 * $Id: Symbol.java,v 1.177 2005-03-19 20:00:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    819819    }
    820820
    821     public LispObject execute(LispObject[] args) throws ConditionThrowable
    822     {
    823         try {
    824             return function.execute(args);
     821    public LispObject execute() throws ConditionThrowable
     822    {
     823        try {
     824            return function.execute();
    825825        }
    826826        catch (NullPointerException e) {
    827             if (function == null)
    828                 return signal(new UndefinedFunction(this));
    829             Debug.trace(e);
    830             return signal(new LispError("Null pointer exception"));
    831         }
    832     }
    833 
    834     public LispObject execute() throws ConditionThrowable
    835     {
    836         try {
    837             return function.execute();
     827            return signalNPE(e);
     828        }
     829    }
     830
     831    public LispObject execute(LispObject arg) throws ConditionThrowable
     832    {
     833        try {
     834            return function.execute(arg);
    838835        }
    839836        catch (NullPointerException e) {
    840             if (function == null)
    841                 return signal(new UndefinedFunction(this));
    842             Debug.trace(e);
    843             return signal(new LispError("Null pointer exception"));
    844         }
    845     }
    846 
    847     public LispObject execute(LispObject arg) throws ConditionThrowable
    848     {
    849         try {
    850             return function.execute(arg);
     837            return signalNPE(e);
     838        }
     839    }
     840
     841    public LispObject execute(LispObject first, LispObject second)
     842        throws ConditionThrowable
     843    {
     844        try {
     845            return function.execute(first, second);
    851846        }
    852847        catch (NullPointerException e) {
    853             if (function == null)
    854                 return signal(new UndefinedFunction(this));
    855             Debug.trace(e);
    856             return signal(new LispError("Null pointer exception"));
    857         }
    858     }
    859 
    860     public LispObject execute(LispObject first, LispObject second)
    861         throws ConditionThrowable
    862     {
    863         try {
    864             return function.execute(first, second);
    865         }
    866         catch (NullPointerException e) {
    867             if (function == null)
    868                 return signal(new UndefinedFunction(this));
    869             Debug.trace(e);
    870             return signal(new LispError("Null pointer exception"));
     848            return signalNPE(e);
    871849        }
    872850    }
     
    880858        }
    881859        catch (NullPointerException e) {
    882             if (function == null)
    883                 return signal(new UndefinedFunction(this));
    884             Debug.trace(e);
    885             return signal(new LispError("Null pointer exception"));
     860            return signalNPE(e);
    886861        }
    887862    }
     
    895870        }
    896871        catch (NullPointerException e) {
    897             if (function == null)
    898                 return signal(new UndefinedFunction(this));
    899             Debug.trace(e);
    900             return signal(new LispError("Null pointer exception"));
    901         }
     872            return signalNPE(e);
     873        }
     874    }
     875
     876    public LispObject execute(LispObject first, LispObject second,
     877                              LispObject third, LispObject fourth,
     878                              LispObject fifth)
     879        throws ConditionThrowable
     880    {
     881        try {
     882            return function.execute(first, second, third, fourth, fifth);
     883        }
     884        catch (NullPointerException e) {
     885            return signalNPE(e);
     886        }
     887    }
     888
     889    public LispObject execute(LispObject first, LispObject second,
     890                              LispObject third, LispObject fourth,
     891                              LispObject fifth, LispObject sixth)
     892        throws ConditionThrowable
     893    {
     894        try {
     895            return function.execute(first, second, third, fourth, fifth, sixth);
     896        }
     897        catch (NullPointerException e) {
     898            return signalNPE(e);
     899        }
     900    }
     901
     902    public LispObject execute(LispObject[] args) throws ConditionThrowable
     903    {
     904        try {
     905            return function.execute(args);
     906        }
     907        catch (NullPointerException e) {
     908            return signalNPE(e);
     909        }
     910    }
     911
     912    private final LispObject signalNPE(NullPointerException e)
     913        throws ConditionThrowable
     914    {
     915        if (function == null)
     916            return signal(new UndefinedFunction(this));
     917        Debug.trace(e);
     918        return signal(new LispError("Null pointer exception"));
    902919    }
    903920}
  • trunk/j/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java

    r5691 r8801  
    22 * WrongNumberOfArgumentsException.java
    33 *
    4  * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: WrongNumberOfArgumentsException.java,v 1.5 2004-02-04 15:11:32 piso Exp $
     4 * Copyright (C) 2002-2005 Peter Graves
     5 * $Id: WrongNumberOfArgumentsException.java,v 1.6 2005-03-19 20:00:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
  • trunk/j/src/org/armedbear/lisp/jvm.lisp

    r8790 r8801  
    22;;;
    33;;; Copyright (C) 2003-2005 Peter Graves
    4 ;;; $Id: jvm.lisp,v 1.405 2005-03-19 00:47:18 piso Exp $
     4;;; $Id: jvm.lisp,v 1.406 2005-03-19 20:01:06 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    4040
    4141(defparameter *trust-user-type-declarations* t)
     42
     43(defconstant +arg-count-max+ 6)
    4244
    4345(defvar *closure-variables* nil)
     
    27482750    (when (plusp numargs)
    27492751      (let ((must-clear-values nil))
    2750         (cond ((<= numargs 4)
     2752        (cond ((<= numargs +arg-count-max+)
    27512753               (dolist (arg args)
    27522754                 (compile-form arg :target :stack)
     
    27712773
    27722774(defun emit-call-execute (numargs)
    2773   (let ((arg-types (if (<= numargs 4)
     2775  (let ((arg-types (if (<= numargs +arg-count-max+)
    27742776                       (make-list numargs :initial-element +lisp-object+)
    27752777                       (list +lisp-object-array+)))
     
    27782780
    27792781(defun emit-call-thread-execute (numargs)
    2780   (let ((arg-types (if (<= numargs 4)
     2782  (let ((arg-types (if (<= numargs +arg-count-max+)
    27812783                       (make-list (1+ numargs) :initial-element +lisp-object+)
    27822784                       (list +lisp-object+ +lisp-object-array+)))
     
    29322934      (emit 'aload (compiland-closure-register compiland)))
    29332935    (let ((must-clear-values nil))
    2934       (cond ((> (length args) 4)
     2936      (cond ((> (length args) +arg-count-max+)
    29352937             (emit-push-constant-int (length args))
    29362938             (emit 'anewarray "org/armedbear/lisp/LispObject")
     
    29562958    (if *closure-variables*
    29572959        (let* ((arg-count (length args))
    2958                (arg-types (if (<= arg-count 4)
     2960               (arg-types (if (<= arg-count +arg-count-max+)
    29592961                              (list* +lisp-object-array+
    29602962                                     (make-list arg-count :initial-element +lisp-object+))
     
    29642966        ;; No closure variables.
    29652967        (let* ((arg-count (length args))
    2966                (arg-types (if (<= arg-count 4)
     2968               (arg-types (if (<= arg-count +arg-count-max+)
    29672969                              (make-list arg-count :initial-element +lisp-object+)
    29682970                              (list +lisp-object-array+)))
     
    33433345       (emit 'aload function-register)
    33443346       (emit 'aload values-register)
    3345        (emit-invokevirtual +lisp-object-class+ "execute"
     3347       (emit-invokevirtual +lisp-object-class+ "dispatch"
    33463348                           (list +lisp-object-array+) +lisp-object+)
    33473349       (emit-move-from-stack target)))))
     
    51565158      (cond (*closure-variables*
    51575159             (return-from analyze-args
    5158                           (cond ((<= arg-count 4)
     5160                          (cond ((<= arg-count +arg-count-max+)
    51595161                                 (get-descriptor (list* +lisp-object-array+
    51605162                                                        (make-list arg-count :initial-element +lisp-object+))
     
    51665168            (t
    51675169             (return-from analyze-args
    5168                           (cond ((<= arg-count 4)
     5170                          (cond ((<= arg-count +arg-count-max+)
    51695171                                 (get-descriptor (make-list arg-count :initial-element +lisp-object+)
    51705172                                                 +lisp-object+))
     
    51805182      (return-from analyze-args
    51815183                   (get-descriptor (list +lisp-object-array+) +lisp-object+)))
    5182     (cond ((<= arg-count 4)
     5184    (cond ((<= arg-count +arg-count-max+)
    51835185           (get-descriptor (make-list (length args) :initial-element +lisp-object+)
    51845186                            +lisp-object+))
     
    52985300                      (append required-args (list name)
    52995301                              (when supplied-p-var (list supplied-p-var)))))
    5300                 (when (<= (length all-args) 4)
     5302                (when (<= (length all-args) +arg-count-max+)
    53015303                  (dformat t "optional-arg = ~S~%" optional-arg)
    53025304                  (dformat t "supplied-p-var = ~S~%" supplied-p-var)
Note: See TracChangeset for help on using the changeset viewer.