Changeset 10132


Ignore:
Timestamp:
10/17/05 15:44:44 (16 years ago)
Author:
piso
Message:

Add thread parameter to Stream.read().

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

Legend:

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

    r9754 r10132  
    33 *
    44 * Copyright (C) 2005 Peter Graves
    5  * $Id: FaslReader.java,v 1.5 2005-08-01 12:38:17 piso Exp $
     5 * $Id: FaslReader.java,v 1.6 2005-10-17 15:44:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    131131        {
    132132            return new Cons(Symbol.QUOTE,
    133                             new Cons(stream.faslRead(true, NIL, true)));
     133                            new Cons(stream.faslRead(true, NIL, true,
     134                                                     LispThread.currentThread())));
    134135        }
    135136    };
     
    376377        {
    377378            return new Cons(Symbol.FUNCTION,
    378                             new Cons(stream.faslRead(true, NIL, true)));
     379                            new Cons(stream.faslRead(true, NIL, true,
     380                                                     LispThread.currentThread())));
    379381        }
    380382    };
  • trunk/j/src/org/armedbear/lisp/Interpreter.java

    r10110 r10132  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Interpreter.java,v 1.91 2005-10-15 16:12:16 piso Exp $
     5 * $Id: Interpreter.java,v 1.92 2005-10-17 15:44:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    154154    public LispObject eval(String s) throws ConditionThrowable
    155155    {
    156         return eval(new StringInputStream(s).read(true, NIL, false));
     156        return eval(new StringInputStream(s).read(true, NIL, false,
     157                                                  LispThread.currentThread()));
    157158    }
    158159
     
    371372                    out._finishOutput();
    372373                    LispObject object =
    373                         getStandardInput().read(false, EOF, false);
     374                        getStandardInput().read(false, EOF, false, thread);
    374375                    if (object == EOF)
    375376                        break;
     
    518519    {
    519520        try {
    520             return new StringInputStream(s).read(true, NIL, false);
     521            return new StringInputStream(s).read(true, NIL, false,
     522                                                 LispThread.currentThread());
    521523        }
    522524        catch (Throwable t) {
     
    531533            initializeJLisp();
    532534        StringInputStream stream = new StringInputStream(s);
    533         LispObject obj = stream.read(false, EOF, false);
     535        final LispThread thread = LispThread.currentThread();
     536        LispObject obj = stream.read(false, EOF, false, thread);
    534537        if (obj == EOF)
    535538            return signal(new EndOfFile(stream));
    536         final LispThread thread = LispThread.currentThread();
    537539        final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    538540        thread.bindSpecial(_DEBUGGER_HOOK_, _DEBUGGER_HOOK_FUNCTION);
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r10116 r10132  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Lisp.java,v 1.397 2005-10-15 17:20:40 piso Exp $
     5 * $Id: Lisp.java,v 1.398 2005-10-17 15:44:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    842842    {
    843843        try {
    844             return new StringInputStream(s).faslRead(true, NIL, false);
     844            return new StringInputStream(s).faslRead(true, NIL, false,
     845                                                     LispThread.currentThread());
    845846        }
    846847        catch (Throwable t) {
  • trunk/j/src/org/armedbear/lisp/LispReader.java

    r9563 r10132  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: LispReader.java,v 1.41 2005-06-30 17:28:17 piso Exp $
     5 * $Id: LispReader.java,v 1.42 2005-10-17 15:44:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    132132        {
    133133            return new Cons(Symbol.QUOTE,
    134                             new Cons(stream.read(true, NIL, true)));
     134                            new Cons(stream.read(true, NIL, true,
     135                                                 LispThread.currentThread())));
    135136        }
    136137    };
     
    246247                                              stream));
    247248            else
    248                 return eval(stream.read(true, NIL, true),
     249                return eval(stream.read(true, NIL, true, thread),
    249250                            new Environment(), thread);
    250251        }
     
    368369        {
    369370            return new Cons(Symbol.FUNCTION,
    370                             new Cons(stream.read(true, NIL, true)));
     371                            new Cons(stream.read(true, NIL, true,
     372                                                 LispThread.currentThread())));
    371373        }
    372374    };
  • trunk/j/src/org/armedbear/lisp/Load.java

    r10106 r10132  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Load.java,v 1.118 2005-10-15 15:49:26 piso Exp $
     5 * $Id: Load.java,v 1.119 2005-10-17 15:44:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    428428            while (true) {
    429429                sourcePositionBinding.value = new Fixnum(in.getOffset());
    430                 LispObject obj = in.read(false, EOF, false);
     430                LispObject obj = in.read(false, EOF, false, thread);
    431431                if (obj == EOF)
    432432                    break;
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r10128 r10132  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitives.java,v 1.831 2005-10-17 03:47:58 piso Exp $
     5 * $Id: Primitives.java,v 1.832 2005-10-17 15:44:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    40734073                                                     thread);
    40744074            else
    4075                 result = in.read(eofError, third, false);
     4075                result = in.read(eofError, third, false, thread);
    40764076            return thread.setValues(result, new Fixnum(in.getOffset()));
    40774077        }
     
    41084108        public LispObject execute() throws ConditionThrowable
    41094109        {
    4110             return checkCharacterInputStream(_STANDARD_INPUT_.symbolValue()).read(true, NIL, false);
    4111         }
    4112         public LispObject execute(LispObject arg) throws ConditionThrowable
    4113         {
    4114             return inSynonymOf(arg).read(true, NIL, false);
    4115         }
    4116         public LispObject execute(LispObject first, LispObject second)
    4117             throws ConditionThrowable
    4118         {
    4119             return inSynonymOf(first).read(second != NIL, NIL, false);
     4110            final LispThread thread = LispThread.currentThread();
     4111            return checkCharacterInputStream(_STANDARD_INPUT_.symbolValue(thread)).read(true, NIL, false, thread);
     4112        }
     4113        public LispObject execute(LispObject arg) throws ConditionThrowable
     4114        {
     4115            final LispThread thread = LispThread.currentThread();
     4116            return inSynonymOf(arg).read(true, NIL, false, thread);
     4117        }
     4118        public LispObject execute(LispObject first, LispObject second)
     4119            throws ConditionThrowable
     4120        {
     4121            final LispThread thread = LispThread.currentThread();
     4122            return inSynonymOf(first).read(second != NIL, NIL, false, thread);
    41204123        }
    41214124        public LispObject execute(LispObject first, LispObject second,
     
    41234126            throws ConditionThrowable
    41244127        {
    4125             return inSynonymOf(first).read(second != NIL, third, false);
     4128            final LispThread thread = LispThread.currentThread();
     4129            return inSynonymOf(first).read(second != NIL, third, false, thread);
    41264130        }
    41274131        public LispObject execute(LispObject first, LispObject second,
     
    41294133            throws ConditionThrowable
    41304134        {
    4131             return inSynonymOf(first).read(second != NIL, third, fourth != NIL);
     4135            final LispThread thread = LispThread.currentThread();
     4136            return inSynonymOf(first).read(second != NIL, third, fourth != NIL,
     4137                                           thread);
    41324138        }
    41334139    };
  • trunk/j/src/org/armedbear/lisp/Stream.java

    r10120 r10132  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Stream.java,v 1.137 2005-10-16 02:03:28 piso Exp $
     5 * $Id: Stream.java,v 1.138 2005-10-17 15:44:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    233233
    234234    public LispObject read(boolean eofError, LispObject eofValue,
    235                            boolean recursive)
    236         throws ConditionThrowable
    237     {
    238         final LispThread thread = LispThread.currentThread();
     235                           boolean recursive, LispThread thread)
     236        throws ConditionThrowable
     237    {
    239238        LispObject result = readPreservingWhitespace(eofError, eofValue,
    240239                                                     recursive, thread);
     
    291290
    292291    public LispObject faslRead(boolean eofError, LispObject eofValue,
    293                                boolean recursive)
    294         throws ConditionThrowable
    295     {
    296         return faslRead(eofError, eofValue, recursive,
    297                         LispThread.currentThread());
    298     }
    299 
    300     public LispObject faslRead(boolean eofError, LispObject eofValue,
    301292                               boolean recursive, LispThread thread)
    302293        throws ConditionThrowable
     
    363354    public LispObject readPathname() throws ConditionThrowable
    364355    {
    365         LispObject obj = read(true, NIL, false);
     356        LispObject obj = read(true, NIL, false, LispThread.currentThread());
    366357        if (obj instanceof AbstractString)
    367358            return Pathname.parseNamestring((AbstractString)obj);
     
    373364    public LispObject faslReadPathname() throws ConditionThrowable
    374365    {
    375         LispObject obj = faslRead(true, NIL, false);
     366        LispObject obj = faslRead(true, NIL, false, LispThread.currentThread());
    376367        if (obj instanceof AbstractString)
    377368            return Pathname.parseNamestring((AbstractString)obj);
     
    400391    {
    401392        final LispThread thread = LispThread.currentThread();
    402         LispObject obj = read(true, NIL, false);
     393        LispObject obj = read(true, NIL, false, thread);
    403394        if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
    404395            return NIL;
     
    513504                    }
    514505                    _unreadChar(nextChar);
    515                     LispObject obj = read(true, NIL, true);
     506                    LispObject obj = read(true, NIL, true, thread);
    516507                    if (requireProperList) {
    517508                        if (!obj.listp())
     
    656647    public LispObject readArray(int rank) throws ConditionThrowable
    657648    {
    658         LispObject obj = read(true, NIL, true);
    659         if (_READ_SUPPRESS_.symbolValue() != NIL)
     649        final LispThread thread = LispThread.currentThread();
     650        LispObject obj = read(true, NIL, true, thread);
     651        if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
    660652            return NIL;
    661653        switch (rank) {
     
    677669    public LispObject faslReadArray(int rank) throws ConditionThrowable
    678670    {
    679         LispObject obj = faslRead(true, NIL, true);
    680         if (_READ_SUPPRESS_.symbolValue() != NIL)
     671        final LispThread thread = LispThread.currentThread();
     672        LispObject obj = faslRead(true, NIL, true, thread);
     673        if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
    681674            return NIL;
    682675        switch (rank) {
     
    698691    public LispObject readComplex() throws ConditionThrowable
    699692    {
    700         LispObject obj = read(true, NIL, true);
    701         if (_READ_SUPPRESS_.symbolValue() != NIL)
     693        final LispThread thread = LispThread.currentThread();
     694        LispObject obj = read(true, NIL, true, thread);
     695        if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
    702696            return NIL;
    703697        if (obj instanceof Cons && obj.length() == 2)
     
    725719    public LispObject faslReadComplex() throws ConditionThrowable
    726720    {
    727         LispObject obj = faslRead(true, NIL, true);
    728         if (_READ_SUPPRESS_.symbolValue() != NIL)
     721        final LispThread thread = LispThread.currentThread();
     722        LispObject obj = faslRead(true, NIL, true, thread);
     723        if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
    729724            return NIL;
    730725        if (obj instanceof Cons && obj.length() == 2)
     
    17351730        public LispObject execute(LispObject arg) throws ConditionThrowable
    17361731        {
    1737             return checkStream(arg).getFilePosition();
     1732            final Stream stream;
     1733            try {
     1734                stream = (Stream) arg;
     1735            }
     1736            catch (ClassCastException e) {
     1737                return signalTypeError(arg, Symbol.STREAM);
     1738            }
     1739            return stream.getFilePosition();
    17381740        }
    17391741        public LispObject execute(LispObject first, LispObject second)
    17401742            throws ConditionThrowable
    17411743        {
    1742             return checkStream(first).setFilePosition(second);
     1744            final Stream stream;
     1745            try {
     1746                stream = (Stream) first;
     1747            }
     1748            catch (ClassCastException e) {
     1749                return signalTypeError(first, Symbol.STREAM);
     1750            }
     1751            return stream.setFilePosition(second);
    17431752        }
    17441753    };
Note: See TracChangeset for help on using the changeset viewer.