Changeset 4791


Ignore:
Timestamp:
11/16/03 18:36:25 (18 years ago)
Author:
piso
Message:

setValues()

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

Legend:

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

    r4632 r4791  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: CharacterInputStream.java,v 1.56 2003-11-03 16:07:54 piso Exp $
     5 * $Id: CharacterInputStream.java,v 1.57 2003-11-16 18:28:49 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    880880                        return eofValue;
    881881                    }
    882                     LispObject[] values = new LispObject[2];
    883                     values[0] = new LispString(sb.toString());
    884                     values[1] = T; // Missing newline.
    885                     LispThread.currentThread().setValues(values);
    886                     return values[0];
     882                    return LispThread.currentThread().setValues(new LispString(sb.toString()),
     883                                                                T);
    887884                }
    888885                switch (n) {
    889886                    case '\n': {
    890                         LispObject[] values = new LispObject[2];
    891                         values[0] = new LispString(sb.toString());
    892                         values[1] = NIL;
    893                         LispThread.currentThread().setValues(values);
    894                         return values[0];
     887                        return LispThread.currentThread().setValues(new LispString(sb.toString()),
     888                                                                    NIL);
    895889                    }
    896890                    default:
  • trunk/j/src/org/armedbear/lisp/HashTable.java

    r4177 r4791  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: HashTable.java,v 1.23 2003-10-02 17:14:06 piso Exp $
     5 * $Id: HashTable.java,v 1.24 2003-11-16 18:33:25 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9898        throws ConditionThrowable
    9999    {
    100         LispObject[] values = new LispObject[2];
    101100        LispObject value = (LispObject) get(key);
     101        final LispObject presentp;
    102102        if (value == null) {
    103103            value = defaultValue;
    104             values[1] = NIL;
     104            presentp = NIL;
    105105        } else
    106             values[1] = T;
    107         values[0] = value;
    108         LispThread.currentThread().setValues(values);
    109         return value;
     106            presentp = T;
     107        return LispThread.currentThread().setValues(value, presentp);
    110108    }
    111109
  • trunk/j/src/org/armedbear/lisp/LispFloat.java

    r4575 r4791  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispFloat.java,v 1.50 2003-10-30 08:17:14 asimon Exp $
     5 * $Id: LispFloat.java,v 1.51 2003-11-16 18:30:38 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    315315    {
    316316        final LispThread thread = LispThread.currentThread();
    317         LispObject[] values = new LispObject[2];
    318317        if (obj instanceof Fixnum) {
    319318            long divisor = ((Fixnum)obj).getValue();
    320319            double quotient = value / divisor;
    321320            double remainder = value % divisor;
    322             if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE) {
    323                 values[0] = new Fixnum((int)quotient);
    324                 values[1] = new LispFloat(remainder);
    325                 thread.setValues(values);
    326                 return values[0];
    327             }
     321            if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE)
     322                return thread.setValues(new Fixnum((int)quotient),
     323                                        new LispFloat(remainder));
    328324        }
    329325        if (obj instanceof LispFloat) {
     
    332328            if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE) {
    333329                int q = (int) quotient;
    334                 values[0] = new Fixnum(q);
    335                 values[1] = new LispFloat(value - q * divisor);
    336                 thread.setValues(values);
    337                 return values[0];
     330                return thread.setValues(new Fixnum(q),
     331                                        new LispFloat(value - q * divisor));
    338332            }
    339333            // We need to convert the quotient to a bignum.
     
    356350            LispObject product = result.multiplyBy(obj);
    357351            LispObject remainder = subtract(product);
    358             values[0] = result;
    359             values[1] = remainder;
    360             thread.setValues(values);
    361             return values[0];
     352            return thread.setValues(result, remainder);
    362353        }
    363354        throw new ConditionThrowable(new LispError("LispFloat.truncate(): not implemented: " + obj.typeOf()));
     
    378369    // integer-decode-float float => significand, exponent, integer-sign
    379370    private static final Primitive1 INTEGER_DECODE_FLOAT =
    380         new Primitive1("integer-decode-float") {
     371        new Primitive1("integer-decode-float")
     372    {
    381373        public LispObject execute(LispObject arg) throws ConditionThrowable
    382374        {
     
    395387                Fixnum exponent = new Fixnum(e - 1075);
    396388                Fixnum sign = new Fixnum(s);
    397                 values[0] = significand;
    398                 values[1] = exponent;
    399                 values[2] = sign;
    400                 LispThread.currentThread().setValues(values);
    401                 return values[0];
     389                return LispThread.currentThread().setValues(significand,
     390                                                            exponent,
     391                                                            sign);
    402392            }
    403393            throw new ConditionThrowable(new TypeError(arg, "float"));
  • trunk/j/src/org/armedbear/lisp/Package.java

    r3929 r4791  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Package.java,v 1.47 2003-09-20 17:02:05 piso Exp $
     5 * $Id: Package.java,v 1.48 2003-11-16 18:35:25 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    144144    {
    145145        final LispThread thread = LispThread.currentThread();
    146         LispObject[] values = new LispObject[2];
    147146        // Look in external and internal symbols of this package.
    148147        Symbol symbol = (Symbol) externalSymbols.get(name);
    149         if (symbol != null) {
    150             values[0] = symbol;
    151             values[1] = Keyword.EXTERNAL;
    152             thread.setValues(values);
    153             return symbol;
    154         }
     148        if (symbol != null)
     149            return thread.setValues(symbol, Keyword.EXTERNAL);
    155150        symbol = (Symbol) internalSymbols.get(name);
    156         if (symbol != null) {
    157             values[0] = symbol;
    158             values[1] = Keyword.INTERNAL;
    159             thread.setValues(values);
    160             return symbol;
    161         }
     151        if (symbol != null)
     152            return thread.setValues(symbol, Keyword.INTERNAL);
    162153        // Look in external symbols of used packages.
    163154        for (Iterator it = useList.iterator(); it.hasNext();) {
    164155            Package pkg = (Package) it.next();
    165156            symbol = pkg.findExternalSymbol(name);
    166             if (symbol != null) {
    167                 values[0] = symbol;
    168                 values[1] = Keyword.INHERITED;
    169                 thread.setValues(values);
    170                 return symbol;
    171             }
     157            if (symbol != null)
     158                return thread.setValues(symbol, Keyword.INHERITED);
    172159        }
    173160        // Not found.
    174         values[0] = NIL;
    175         values[1] = NIL;
    176         thread.setValues(values);
    177         return NIL;
     161        return thread.setValues(NIL, NIL);
    178162    }
    179163
     
    250234    public synchronized Symbol intern(String name, LispThread thread)
    251235    {
    252         LispObject[] values = new LispObject[2];
    253236        // Look in external and internal symbols of this package.
    254237        Symbol symbol = (Symbol) externalSymbols.get(name);
    255         if (symbol != null) {
    256             values[0] = symbol;
    257             values[1] = Keyword.EXTERNAL;
    258             thread.setValues(values);
    259             return symbol;
    260         }
     238        if (symbol != null)
     239            return (Symbol) thread.setValues(symbol, Keyword.EXTERNAL);
    261240        symbol = (Symbol) internalSymbols.get(name);
    262         if (symbol != null) {
    263             values[0] = symbol;
    264             values[1] = Keyword.INTERNAL;
    265             thread.setValues(values);
    266             return symbol;
    267         }
     241        if (symbol != null)
     242            return (Symbol) thread.setValues(symbol, Keyword.INTERNAL);
    268243        // Look in external symbols of used packages.
    269244        for (Iterator it = useList.iterator(); it.hasNext();) {
    270245            Package pkg = (Package) it.next();
    271246            symbol = pkg.findExternalSymbol(name);
    272             if (symbol != null) {
    273                 values[0] = symbol;
    274                 values[1] = Keyword.INHERITED;
    275                 thread.setValues(values);
    276                 return symbol;
    277             }
     247            if (symbol != null)
     248                return (Symbol) thread.setValues(symbol, Keyword.INHERITED);
    278249        }
    279250        // Not found.
    280         symbol = addSymbol(name);
    281         values[0] = symbol;
    282         values[1] = NIL;
    283         thread.setValues(values);
    284         return symbol;
     251        return (Symbol) thread.setValues(addSymbol(name), NIL);
    285252    }
    286253
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r4782 r4791  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitives.java,v 1.499 2003-11-16 15:32:58 piso Exp $
     5 * $Id: Primitives.java,v 1.500 2003-11-16 18:36:25 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    21302130        public LispObject execute(LispObject arg) throws ConditionThrowable
    21312131        {
    2132             LispObject[] values = new LispObject[3];
     2132            final LispObject value1, value2;
    21332133            Function function = checkFunction(arg);
    21342134            String name = function.getName();
    2135             values[2] = name != null ? new LispString(name) : NIL;
     2135            final LispObject value3 = name != null ? new LispString(name) : NIL;
    21362136            if (function instanceof Closure) {
    21372137                Closure closure = (Closure) function;
     
    21392139                expr = new Cons(closure.getParameterList(), expr);
    21402140                expr = new Cons(Symbol.LAMBDA, expr);
    2141                 values[0] = expr;
     2141                value1 = expr;
    21422142                Environment env = closure.getEnvironment();
    21432143                if (env == null || env.isEmpty())
    2144                     values[1] = NIL;
     2144                    value2 = NIL;
    21452145                else
    2146                     values[1] = T;
     2146                    value2 = T;
    21472147            } else
    2148                 values[0] = values[1] = NIL;
    2149             LispThread.currentThread().setValues(values);
    2150             return values[0];
     2148                value1 = value2 = NIL;
     2149            return LispThread.currentThread().setValues(value1, value2, value3);
    21512150        }
    21522151    };
     
    36363635            else
    36373636                result = in.read(eofError, eofValue, false);
    3638             LispObject[] values = new LispObject[2];
    3639             values[0] = result;
    3640             values[1] = new Fixnum(in.getOffset());
    3641             LispThread.currentThread().setValues(values);
    3642             return result;
     3637            return LispThread.currentThread().setValues(result,
     3638                                                        new Fixnum(in.getOffset()));
    36433639        }
    36443640    };
     
    43004296            Function function = coerceToFunction(arg);
    43014297            LispObject arglist = function.getArglist();
    4302             LispObject[] values = new LispObject[2];
     4298            final LispObject value1, value2;
    43034299            if (arglist != null) {
    4304                 values[0] = arglist;
    4305                 values[1] = T;
     4300                value1 = arglist;
     4301                value2 = T;
    43064302            } else {
    4307                 values[0] = NIL;
    4308                 values[1] = NIL;
    4309             }
    4310             LispThread.currentThread().setValues(values);
    4311             return values[0];
     4303                value1 = NIL;
     4304                value2 = NIL;
     4305            }
     4306            return LispThread.currentThread().setValues(value1, value2);
    43124307        }
    43134308    };
Note: See TracChangeset for help on using the changeset viewer.