Changeset 12602


Ignore:
Timestamp:
04/10/10 21:36:06 (13 years ago)
Author:
ehuelsmann
Message:

Un-duplicate string reading between FaslReader? and LispReader?.

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

Legend:

Unmodified
Added
Removed

  • trunk/abcl/src/org/armedbear/lisp/FaslReader.java

    r12601 r12602  
    4747
    4848        {
    49             final Readtable rt = FaslReadtable.getInstance();
    50             StringBuilder sb = new StringBuilder();
    51             try
    52               {
    53                 while (true) {
    54                   int n = stream._readChar();
    55                   if (n < 0) {
    56                     error(new EndOfFile(stream));
    57                     // Not reached.
    58                     return null;
    59                   }
    60                   char c = (char) n;
    61                   if (rt.getSyntaxType(c) == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
    62                     // Single escape.
    63                     n = stream._readChar();
    64                     if (n < 0) {
    65                       error(new EndOfFile(stream));
    66                       // Not reached.
    67                       return null;
    68                     }
    69                     sb.append((char)n);
    70                     continue;
    71                   }
    72                   if (c == terminator)
    73                     break;
    74                   // Default.
    75                   sb.append(c);
    76                 }
    77                 return new SimpleString(sb);
    78               }
    79             catch (java.io.IOException e)
    80               {
    81                 return new SimpleString(sb);
    82     //                return null;
    83               }
     49            return stream.readString(terminator, Stream.faslReadtable);
    8450        }
    8551    };

  • trunk/abcl/src/org/armedbear/lisp/LispReader.java

    r12601 r12602  
    7373
    7474        {
    75             final LispThread thread = LispThread.currentThread();
    76             final Readtable rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
    77             StringBuilder sb = new StringBuilder();
    78             try
    79               {
    80                 while (true) {
    81                   int n = stream._readChar();
    82                   if (n < 0) {
    83                     error(new EndOfFile(stream));
    84                     // Not reached.
    85                     return null;
    86                   }
    87                   char c = (char) n; // ### BUG: Codepoint conversion
    88                   if (rt.getSyntaxType(c) == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
    89                     // Single escape.
    90                     n = stream._readChar();
    91                     if (n < 0) {
    92                       error(new EndOfFile(stream));
    93                       // Not reached.
    94                       return null;
    95                     }
    96                     sb.append((char)n); // ### BUG: Codepoint conversion
    97                     continue;
    98                   }
    99                   if (c == terminator)
    100                     break;
    101                   // Default.
    102                   sb.append(c);
    103                 }
    104               }
    105             catch (java.io.IOException e)
    106               {
    107                 //error(new EndOfFile(stream));
    108     return new SimpleString(sb);
    109               }
    110             return new SimpleString(sb);
     75            return stream.readString(terminator, Stream.currentReadtable);
    11176        }
    11277    };

  • trunk/abcl/src/org/armedbear/lisp/Stream.java

    r12600 r12602  
    573573                                     obj.writeToString(),
    574574                                     this));
     575    }
     576
     577    public LispObject readString(char terminator, ReadtableAccessor rta)
     578    {
     579      final LispThread thread = LispThread.currentThread();
     580      final Readtable rt = rta.rt(thread);
     581      StringBuilder sb = new StringBuilder();
     582      try
     583      {
     584        while (true) {
     585          int n = _readChar();
     586          if (n < 0) {
     587            error(new EndOfFile(this));
     588            // Not reached.
     589            return null;
     590          }
     591          char c = (char) n; // ### BUG: Codepoint conversion
     592          if (rt.getSyntaxType(c) == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
     593            // Single escape.
     594            n = _readChar();
     595            if (n < 0) {
     596              error(new EndOfFile(this));
     597              // Not reached.
     598              return null;
     599            }
     600            sb.append((char)n); // ### BUG: Codepoint conversion
     601            continue;
     602          }
     603          if (c == terminator)
     604            break;
     605          // Default.
     606          sb.append(c);
     607        }
     608      }
     609      catch (java.io.IOException e)
     610      {
     611        //error(new EndOfFile(stream));
     612        return new SimpleString(sb);
     613      }
     614      return new SimpleString(sb);
    575615    }
    576616
Note: See TracChangeset for help on using the changeset viewer.