Changeset 4094


Ignore:
Timestamp:
09/28/03 14:11:53 (19 years ago)
Author:
piso
Message:
  • Support for new StringInputStream? implementation.
  • readUninternedSymbol(): handle single escapes correctly.
File:
1 edited

Legend:

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

    r3894 r4094  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: CharacterInputStream.java,v 1.50 2003-09-19 14:44:10 piso Exp $
     5 * $Id: CharacterInputStream.java,v 1.51 2003-09-28 14:11:53 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3333{
    3434    private final PushbackReader reader;
    35     private int offset;
    36     private int lineNumber;
     35    protected int offset;
     36    protected int lineNumber;
     37
     38    protected CharacterInputStream()
     39    {
     40        reader = null;
     41    }
    3742
    3843    public CharacterInputStream(InputStream in)
     
    4348    }
    4449
    45     public CharacterInputStream(String s)
    46     {
    47         reader = new PushbackReader(
    48             new BufferedReader(new StringReader(s)),
    49             2);
    50     }
    51 
    5250    public int getOffset()
    5351    {
     
    6159
    6260    public LispObject read(boolean eofError, LispObject eofValue,
    63         boolean recursive) throws ConditionThrowable
     61                           boolean recursive)
     62        throws ConditionThrowable
    6463    {
    6564        try {
    6665            LispObject result = readPreservingWhitespace(eofError, eofValue,
    67                 recursive);
     66                                                         recursive);
    6867            if (result != eofValue && !recursive) {
    69                 if (reader.ready()) {
     68                if (ready()) {
    7069                    int n = read();
    7170                    if (n >= 0) {
     
    8483
    8584    public LispObject readPreservingWhitespace(boolean eofError,
    86         LispObject eofValue, boolean recursive) throws ConditionThrowable
     85                                               LispObject eofValue,
     86                                               boolean recursive)
     87        throws ConditionThrowable
    8788    {
    8889        while (true) {
     
    428429                        throw new ConditionThrowable(new EndOfFileException());
    429430                    c = (char) n;
     431                    if (c == '\\') {
     432                        // Single escape.
     433                        n = read();
     434                        if (n < 0)
     435                            throw new ConditionThrowable(new EndOfFileException());
     436                        sb.append((char)n);
     437                        continue;
     438                    }
    430439                    if (c == '|')
    431                         return new Symbol(sb.toString());
     440                        break;
    432441                    sb.append(c);
    433442                }
    434443            } else {
    435                 sb.append(c);
     444                sb.append(Character.toUpperCase(c));
    436445                while (true) {
    437446                    n = read();
     
    439448                        break;
    440449                    c = (char) n;
     450                    if (c == '\\') {
     451                        // Single escape.
     452                        n = read();
     453                        if (n < 0)
     454                            throw new ConditionThrowable(new EndOfFileException());
     455                        sb.append((char)n);
     456                        continue;
     457                    }
    441458                    if (Character.isWhitespace(c))
    442459                        break;
     
    445462                        break;
    446463                    }
    447                     sb.append(c);
    448                 }
    449                 return new Symbol(sb.toString().toUpperCase());
    450             }
     464                    sb.append(Character.toUpperCase(c));
     465                }
     466            }
     467            return new Symbol(sb.toString());
    451468        }
    452469        catch (IOException e) {
     
    900917    {
    901918        try {
    902             while (reader.ready())
     919            while (ready())
    903920                read();
    904921        }
     
    922939    }
    923940
    924     private int read() throws IOException
     941    protected int read() throws IOException
    925942    {
    926943        int n = reader.read();
     
    931948    }
    932949
    933     private void unread(int n) throws IOException
     950    protected void unread(int n) throws IOException
    934951    {
    935952        reader.unread(n);
     
    938955            --lineNumber;
    939956    }
     957
     958    protected boolean ready() throws IOException
     959    {
     960        return reader.ready();
     961    }
    940962}
Note: See TracChangeset for help on using the changeset viewer.