Changeset 11991


Ignore:
Timestamp:
06/03/09 20:05:46 (12 years ago)
Author:
vvoutilainen
Message:

Move IOException handling away from reader's tight loops.

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

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java

    r11754 r11991  
    112112                return eofValue;
    113113        }
    114         return _charReady() ? readChar(eofError, eofValue) : NIL;
     114  try
     115    {
     116      return _charReady() ? readChar(eofError, eofValue) : NIL;
     117    }
     118  catch (java.io.IOException e)
     119    {
     120      return error(new StreamError(this, e));
     121    }
    115122    }
    116123
     
    133140    // Returns -1 at end of file.
    134141    @Override
    135     protected int _readChar() throws ConditionThrowable
     142    protected int _readChar() throws ConditionThrowable, java.io.IOException
    136143    {
    137144        int n;
     
    160167
    161168    @Override
    162     protected boolean _charReady() throws ConditionThrowable
     169    protected boolean _charReady() throws ConditionThrowable, java.io.IOException
    163170    {
    164171        if (unreadChar >= 0)
  • trunk/abcl/src/org/armedbear/lisp/EchoStream.java

    r11488 r11991  
    134134    // Returns -1 at end of file.
    135135    @Override
    136     protected int _readChar() throws ConditionThrowable
     136    protected int _readChar() throws ConditionThrowable, java.io.IOException
    137137    {
    138138        int n = in._readChar();
     
    148148
    149149    @Override
    150     protected void _unreadChar(int n) throws ConditionThrowable
     150    protected void _unreadChar(int n) throws ConditionThrowable, java.io.IOException
    151151    {
    152152        in._unreadChar(n);
     
    155155
    156156    @Override
    157     protected boolean _charReady() throws ConditionThrowable
     157    protected boolean _charReady() throws ConditionThrowable, java.io.IOException
    158158    {
    159159        return in._charReady();
  • trunk/abcl/src/org/armedbear/lisp/FaslReader.java

    r11783 r11991  
    4545            throws ConditionThrowable
    4646        {
    47             while (true) {
     47          try
     48            {
     49              while (true) {
    4850                int n = stream._readChar();
    4951                if (n < 0)
    50                     return null;
     52                  return null;
    5153                if (n == '\n')
    52                     return null;
     54                  return null;
     55              }
     56            }
     57          catch (java.io.IOException e)
     58            {
     59              return null;
    5360            }
    5461        }
     
    6673            final Readtable rt = FaslReadtable.getInstance();
    6774            FastStringBuffer sb = new FastStringBuffer();
    68             while (true) {
    69                 int n = stream._readChar();
    70                 if (n < 0) {
     75            try
     76              {
     77                while (true) {
     78                  int n = stream._readChar();
     79                  if (n < 0) {
    7180                    error(new EndOfFile(stream));
    7281                    // Not reached.
    7382                    return null;
    74                 }
    75                 char c = (char) n;
    76                 if (rt.getSyntaxType(c) == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
     83                  }
     84                  char c = (char) n;
     85                  if (rt.getSyntaxType(c) == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
    7786                    // Single escape.
    7887                    n = stream._readChar();
    7988                    if (n < 0) {
     89                      error(new EndOfFile(stream));
     90                      // Not reached.
     91                      return null;
     92                    }
     93                    sb.append((char)n);
     94                    continue;
     95                  }
     96                  if (Utilities.isPlatformWindows) {
     97                    if (c == '\r') {
     98                      n = stream._readChar();
     99                      if (n < 0) {
    80100                        error(new EndOfFile(stream));
    81101                        // Not reached.
    82102                        return null;
     103                      }
     104                      if (n == '\n') {
     105                        sb.append('\n');
     106                      } else {
     107                        // '\r' was not followed by '\n'.
     108                        stream._unreadChar(n);
     109                        sb.append('\r');
     110                      }
     111                      continue;
    83112                    }
    84                     sb.append((char)n);
    85                     continue;
     113                  }
     114                  if (c == terminator)
     115                    break;
     116                  // Default.
     117                  sb.append(c);
    86118                }
    87                 if (Utilities.isPlatformWindows) {
    88                     if (c == '\r') {
    89                         n = stream._readChar();
    90                         if (n < 0) {
    91                             error(new EndOfFile(stream));
    92                             // Not reached.
    93                             return null;
    94                         }
    95                         if (n == '\n') {
    96                             sb.append('\n');
    97                         } else {
    98                             // '\r' was not followed by '\n'.
    99                             stream._unreadChar(n);
    100                             sb.append('\r');
    101                         }
    102                         continue;
    103                     }
    104                 }
    105                 if (c == terminator)
    106                     break;
    107                 // Default.
    108                 sb.append(c);
    109             }
    110             return new SimpleString(sb);
     119                return new SimpleString(sb);
     120              }
     121            catch (java.io.IOException e)
     122              {
     123                return new SimpleString(sb);
     124    //                return null;
     125              }
    111126        }
    112127    };
     
    207222                (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL);
    208223            FastStringBuffer sb = new FastStringBuffer();
    209             while (true) {
    210                 int ch = stream._readChar();
    211                 if (ch < 0)
     224      try
     225        {
     226    while (true) {
     227      int ch = stream._readChar();
     228      if (ch < 0)
    212229                    break;
    213                 char c = (char) ch;
    214                 if (c == '0' || c == '1')
     230      char c = (char) ch;
     231      if (c == '0' || c == '1')
    215232                    sb.append(c);
    216                 else {
     233      else {
    217234                    int syntaxType = rt.getSyntaxType(c);
    218235                    if (syntaxType == Readtable.SYNTAX_TYPE_WHITESPACE ||
    219236                        syntaxType == Readtable.SYNTAX_TYPE_TERMINATING_MACRO) {
    220                         stream._unreadChar(c);
    221                         break;
     237          stream._unreadChar(c);
     238          break;
    222239                    } else if (!suppress) {
    223                         String name = LispCharacter.charToName(c);
    224                         if (name == null)
    225                             name = "#\\" + c;
    226                         error(new ReaderError("Illegal element for bit-vector: " + name,
    227                                                stream));
     240          String name = LispCharacter.charToName(c);
     241          if (name == null)
     242      name = "#\\" + c;
     243          error(new ReaderError("Illegal element for bit-vector: " + name,
     244              stream));
    228245                    }
    229                 }
    230             }
     246      }
     247    }
     248        }
     249      catch (java.io.IOException e)
     250        {
     251    error(new ReaderError("IO error: ",
     252              stream));
     253    return NIL;
     254        }
     255
    231256            if (suppress)
    232257                return NIL;
  • trunk/abcl/src/org/armedbear/lisp/LispReader.java

    r11488 r11991  
    4545            throws ConditionThrowable
    4646        {
    47             while (true) {
     47          try
     48            {
     49              while (true) {
    4850                int n = stream._readChar();
    4951                if (n < 0)
    50                     return null;
     52                  return null;
    5153                if (n == '\n')
    52                     return null;
     54                  return null;
     55              }
     56            }
     57          catch (java.io.IOException e)
     58            {
     59              return null;
    5360            }
    5461        }
     
    6774            final Readtable rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
    6875            FastStringBuffer sb = new FastStringBuffer();
    69             while (true) {
    70                 int n = stream._readChar();
    71                 if (n < 0) {
     76            try
     77              {
     78                while (true) {
     79                  int n = stream._readChar();
     80                  if (n < 0) {
    7281                    error(new EndOfFile(stream));
    7382                    // Not reached.
    7483                    return null;
    75                 }
    76                 char c = (char) n;
    77                 if (rt.getSyntaxType(c) == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
     84                  }
     85                  char c = (char) n;
     86                  if (rt.getSyntaxType(c) == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
    7887                    // Single escape.
    7988                    n = stream._readChar();
    8089                    if (n < 0) {
     90                      error(new EndOfFile(stream));
     91                      // Not reached.
     92                      return null;
     93                    }
     94                    sb.append((char)n);
     95                    continue;
     96                  }
     97                  if (Utilities.isPlatformWindows) {
     98                    if (c == '\r') {
     99                      n = stream._readChar();
     100                      if (n < 0) {
    81101                        error(new EndOfFile(stream));
    82102                        // Not reached.
    83103                        return null;
     104                      }
     105                      if (n == '\n') {
     106                        sb.append('\n');
     107                      } else {
     108                        // '\r' was not followed by '\n'.
     109                        stream._unreadChar(n);
     110                        sb.append('\r');
     111                      }
     112                      continue;
    84113                    }
    85                     sb.append((char)n);
    86                     continue;
     114                  }
     115                  if (c == terminator)
     116                    break;
     117                  // Default.
     118                  sb.append(c);
    87119                }
    88                 if (Utilities.isPlatformWindows) {
    89                     if (c == '\r') {
    90                         n = stream._readChar();
    91                         if (n < 0) {
    92                             error(new EndOfFile(stream));
    93                             // Not reached.
    94                             return null;
    95                         }
    96                         if (n == '\n') {
    97                             sb.append('\n');
    98                         } else {
    99                             // '\r' was not followed by '\n'.
    100                             stream._unreadChar(n);
    101                             sb.append('\r');
    102                         }
    103                         continue;
    104                     }
    105                 }
    106                 if (c == terminator)
    107                     break;
    108                 // Default.
    109                 sb.append(c);
    110             }
     120              }
     121            catch (java.io.IOException e)
     122              {
     123                //error(new EndOfFile(stream));
     124    return new SimpleString(sb);
     125              }
    111126            return new SimpleString(sb);
    112127        }
     
    207222            final boolean suppress = Symbol.READ_SUPPRESS.symbolValue(thread) != NIL;
    208223            FastStringBuffer sb = new FastStringBuffer();
    209             while (true) {
    210                 int ch = stream._readChar();
    211                 if (ch < 0)
     224            try
     225              {
     226                while (true) {
     227                  int ch = stream._readChar();
     228                  if (ch < 0)
    212229                    break;
    213                 char c = (char) ch;
    214                 if (c == '0' || c == '1')
     230                  char c = (char) ch;
     231                  if (c == '0' || c == '1')
    215232                    sb.append(c);
    216                 else {
     233                  else {
    217234                    int syntaxType = rt.getSyntaxType(c);
    218235                    if (syntaxType == Readtable.SYNTAX_TYPE_WHITESPACE ||
    219236                        syntaxType == Readtable.SYNTAX_TYPE_TERMINATING_MACRO) {
    220                         stream._unreadChar(c);
    221                         break;
     237                      stream._unreadChar(c);
     238                      break;
    222239                    } else if (!suppress) {
    223                         String name = LispCharacter.charToName(c);
    224                         if (name == null)
    225                             name = "#\\" + c;
    226                         error(new ReaderError("Illegal element for bit-vector: " + name,
    227                                                stream));
     240                      String name = LispCharacter.charToName(c);
     241                      if (name == null)
     242                        name = "#\\" + c;
     243                      error(new ReaderError("Illegal element for bit-vector: " + name,
     244                                            stream));
    228245                    }
     246                  }
    229247                }
    230             }
     248              }
     249            catch (java.io.IOException e)
     250              {
     251                error(new ReaderError("IO error-vector: ",
     252                                      stream));
     253              }
    231254            if (suppress)
    232255                return NIL;
  • trunk/abcl/src/org/armedbear/lisp/Stream.java

    r11982 r11991  
    399399    if (result != eofValue && !recursive)
    400400      {
    401         if (_charReady())
    402           {
    403             int n = _readChar();
    404             if (n >= 0)
    405               {
    406                 char c = (char) n;
    407                 Readtable rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
    408                 if (!rt.isWhitespace(c))
    409                   _unreadChar(c);
    410               }
     401        try {
     402          if (_charReady())
     403            {
     404              int n = _readChar();
     405              if (n >= 0)
     406                {
     407                  char c = (char) n;
     408                  Readtable rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
     409                  if (!rt.isWhitespace(c))
     410                      _unreadChar(c);
     411                }
     412            }
     413        }
     414        catch (IOException e)
     415          {
     416            return error(new StreamError(this, e));
    411417          }
    412418      }
     
    433439        while (true)
    434440          {
    435             int n = _readChar();
     441            int n = -1;
     442            try
     443              {
     444                n = _readChar();
     445              }
     446            catch (IOException e)
     447              {
     448                error(new StreamError(this, e));
     449              }
    436450            if (n < 0)
    437451              {
     
    468482    throws ConditionThrowable
    469483  {
    470     LispObject result = faslReadPreservingWhitespace(eofError, eofValue,
    471                                                      recursive, thread);
    472     if (result != eofValue && !recursive)
    473       {
    474         if (_charReady())
    475           {
    476             int n = _readChar();
    477             if (n >= 0)
    478               {
    479                 char c = (char) n;
    480                 Readtable rt = FaslReadtable.getInstance();
    481                 if (!rt.isWhitespace(c))
    482                   _unreadChar(c);
    483               }
    484           }
    485       }
    486     if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    487       return NIL;
    488     else
    489       return result;
     484    try
     485      {
     486        LispObject result = faslReadPreservingWhitespace(eofError, eofValue,
     487                                                         recursive, thread);
     488        if (result != eofValue && !recursive)
     489          {
     490            if (_charReady())
     491              {
     492                int n = _readChar();
     493                if (n >= 0)
     494                  {
     495                    char c = (char) n;
     496                    Readtable rt = FaslReadtable.getInstance();
     497                    if (!rt.isWhitespace(c))
     498                        _unreadChar(c);
     499                  }
     500              }
     501          }
     502        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
     503            return NIL;
     504        else
     505            return result;
     506      }
     507    catch (IOException e)
     508      {
     509        return error(new StreamError(this, e));
     510      }
    490511  }
    491512
     
    494515                                                        boolean recursive,
    495516                                                        LispThread thread)
    496     throws ConditionThrowable
     517      throws ConditionThrowable, IOException
    497518  {
    498519    if (recursive)
     
    505526              {
    506527                if (eofError)
    507                   return error(new EndOfFile(this));
     528                    return error(new EndOfFile(this));
    508529                else
    509                   return eofValue;
     530                    return eofValue;
    510531              }
    511532            char c = (char) n;
    512533            if (rt.isWhitespace(c))
    513               continue;
     534                continue;
    514535            LispObject result = processChar(c, rt);
    515536            if (result != null)
    516               return result;
     537                return result;
    517538          }
    518539      }
     
    684705    if (useFaslReadtable)
    685706      rt = FaslReadtable.getInstance();
    686     while (true)
    687       {
    688         if (!useFaslReadtable)
    689           rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
    690         char c = flushWhitespace(rt);
    691         if (c == ')')
    692           {
    693             return first == null ? NIL : first;
    694           }
    695         if (c == '.')
    696           {
    697             int n = _readChar();
    698             if (n < 0)
    699               return error(new EndOfFile(this));
    700             char nextChar = (char) n;
    701             if (isTokenDelimiter(nextChar, rt))
    702               {
    703                 if (last == null)
     707    try
     708      {
     709        while (true)
     710          {
     711            if (!useFaslReadtable)
     712                rt = (Readtable) Symbol.CURRENT_READTABLE.symbolValue(thread);
     713            char c = flushWhitespace(rt);
     714            if (c == ')')
     715              {
     716                return first == null ? NIL : first;
     717              }
     718            if (c == '.')
     719              {
     720                int n = _readChar();
     721                if (n < 0)
     722                    return error(new EndOfFile(this));
     723                char nextChar = (char) n;
     724                if (isTokenDelimiter(nextChar, rt))
    704725                  {
    705                     if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    706                       return NIL;
    707                     else
    708                       return error(new ReaderError("Nothing appears before . in list.",
    709                                                     this));
     726                    if (last == null)
     727                      {
     728                        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
     729                            return NIL;
     730                        else
     731                            return error(new ReaderError("Nothing appears before . in list.",
     732                                                         this));
     733                      }
     734                    _unreadChar(nextChar);
     735                    LispObject obj = read(true, NIL, true, thread);
     736                    if (requireProperList)
     737                      {
     738                        if (!obj.listp())
     739                            error(new ReaderError("The value " +
     740                                                  obj.writeToString() +
     741                                                  " is not of type " +
     742                                                  Symbol.LIST.writeToString() + ".",
     743                                                  this));
     744                      }
     745                    last.cdr = obj;
     746                    continue;
    710747                  }
     748                // normal token beginning with '.'
    711749                _unreadChar(nextChar);
    712                 LispObject obj = read(true, NIL, true, thread);
    713                 if (requireProperList)
    714                   {
    715                     if (!obj.listp())
    716                       error(new ReaderError("The value " +
    717                                              obj.writeToString() +
    718                                              " is not of type " +
    719                                              Symbol.LIST.writeToString() + ".",
    720                                              this));
    721                   }
    722                 last.cdr = obj;
     750              }
     751            LispObject obj = processChar(c, rt);
     752            if (obj == null)
     753              {
     754                // A comment.
    723755                continue;
    724756              }
    725             // normal token beginning with '.'
    726             _unreadChar(nextChar);
    727           }
    728         LispObject obj = processChar(c, rt);
    729         if (obj == null)
    730           {
    731             // A comment.
    732             continue;
    733           }
    734         if (first == null)
    735           {
    736             first = new Cons(obj);
    737             last = first;
    738           }
    739         else
    740           {
    741             Cons newCons = new Cons(obj);
    742             last.cdr = newCons;
    743             last = newCons;
    744           }
     757            if (first == null)
     758              {
     759                first = new Cons(obj);
     760                last = first;
     761              }
     762            else
     763              {
     764                Cons newCons = new Cons(obj);
     765                last.cdr = newCons;
     766                last = newCons;
     767              }
     768          }
     769      }
     770    catch (IOException e)
     771      {
     772        error(new StreamError(this, e));
     773        return null;
    745774      }
    746775  }
     
    768797  {
    769798    int numArg = -1;
    770     char c;
    771     while (true)
    772       {
    773         int n = _readChar();
    774         if (n < 0)
    775           return error(new EndOfFile(this));
    776         c = (char) n;
    777         if (c < '0' || c > '9')
    778           break;
    779         if (numArg < 0)
    780           numArg = 0;
    781         numArg = numArg * 10 + c - '0';
     799    char c = 0;
     800    try
     801      {
     802        while (true)
     803          {
     804            int n = _readChar();
     805            if (n < 0)
     806                return error(new EndOfFile(this));
     807            c = (char) n;
     808            if (c < '0' || c > '9')
     809                break;
     810            if (numArg < 0)
     811                numArg = 0;
     812            numArg = numArg * 10 + c - '0';
     813          }
     814      }
     815    catch (IOException e)
     816      {
     817        error(new StreamError(this, e));
    782818      }
    783819    final LispThread thread = LispThread.currentThread();
     
    810846    throws ConditionThrowable
    811847  {
    812     int n = _readChar();
    813     if (n < 0)
    814       return error(new EndOfFile(this));
    815     char c = (char) n;
    816     FastStringBuffer sb = new FastStringBuffer(c);
    817     while (true)
    818       {
    819         n = _readChar();
    820         if (n < 0)
    821           break;
    822         c = (char) n;
    823         if (rt.isWhitespace(c))
    824           break;
    825         if (c == '(' || c == ')')
    826           {
    827             _unreadChar(c);
    828             break;
    829           }
    830         sb.append(c);
    831       }
    832     if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    833       return NIL;
    834     if (sb.length() == 1)
    835       return LispCharacter.getInstance(sb.charAt(0));
    836     String token = sb.toString();
    837     n = LispCharacter.nameToChar(token);
    838     if (n >= 0)
    839       return LispCharacter.getInstance((char)n);
    840     return error(new LispError("Unrecognized character name: \"" + token + '"'));
    841   }
    842 
    843   public void skipBalancedComment() throws ConditionThrowable
    844   {
    845     while (true)
     848    try
    846849      {
    847850        int n = _readChar();
    848851        if (n < 0)
    849           return;
    850         if (n == '|')
     852            return error(new EndOfFile(this));
     853        char c = (char) n;
     854        FastStringBuffer sb = new FastStringBuffer(c);
     855        while (true)
    851856          {
    852857            n = _readChar();
    853             if (n == '#')
    854               return;
    855             else
    856               _unreadChar(n);
    857           }
    858         else if (n == '#')
    859           {
    860             n = _readChar();
     858            if (n < 0)
     859                break;
     860            c = (char) n;
     861            if (rt.isWhitespace(c))
     862                break;
     863            if (c == '(' || c == ')')
     864              {
     865                _unreadChar(c);
     866                break;
     867              }
     868            sb.append(c);
     869          }
     870        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
     871            return NIL;
     872        if (sb.length() == 1)
     873            return LispCharacter.getInstance(sb.charAt(0));
     874        String token = sb.toString();
     875        n = LispCharacter.nameToChar(token);
     876        if (n >= 0)
     877            return LispCharacter.getInstance((char)n);
     878        return error(new LispError("Unrecognized character name: \"" + token + '"'));
     879      }
     880    catch (IOException e)
     881      {
     882        return error(new StreamError(this, e));
     883      }
     884  }
     885
     886  public void skipBalancedComment() throws ConditionThrowable
     887  {
     888    try
     889      {
     890        while (true)
     891          {
     892            int n = _readChar();
     893            if (n < 0)
     894                return;
    861895            if (n == '|')
    862               skipBalancedComment(); // Nested comment. Recurse!
    863             else
    864               _unreadChar(n);
    865           }
     896              {
     897                n = _readChar();
     898                if (n == '#')
     899                    return;
     900                else
     901                    _unreadChar(n);
     902              }
     903            else if (n == '#')
     904              {
     905                n = _readChar();
     906                if (n == '|')
     907                    skipBalancedComment(); // Nested comment. Recurse!
     908                else
     909                    _unreadChar(n);
     910              }
     911          }
     912      }
     913    catch (IOException e)
     914      {
     915        error(new StreamError(this, e));
    866916      }
    867917  }
     
    9801030  {
    9811031    FastStringBuffer sb = new FastStringBuffer();
    982     while (true)
    983       {
    984         int n = _readChar();
    985         if (n < 0)
    986           {
    987             error(new EndOfFile(this));
    988             // Not reached.
    989             return null;
    990           }
    991         char c = (char) n;
    992         byte syntaxType = rt.getSyntaxType(c);
    993         if (syntaxType == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE)
    994           {
    995             n = _readChar();
     1032    try
     1033      {
     1034        while (true)
     1035          {
     1036            int n = _readChar();
    9961037            if (n < 0)
    9971038              {
     
    10001041                return null;
    10011042              }
    1002             sb.append((char)n);
    1003             continue;
    1004           }
    1005         if (syntaxType == Readtable.SYNTAX_TYPE_MULTIPLE_ESCAPE)
    1006           break;
    1007         sb.append(c);
     1043            char c = (char) n;
     1044            byte syntaxType = rt.getSyntaxType(c);
     1045            if (syntaxType == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE)
     1046              {
     1047                n = _readChar();
     1048                if (n < 0)
     1049                  {
     1050                    error(new EndOfFile(this));
     1051                    // Not reached.
     1052                    return null;
     1053                  }
     1054                sb.append((char)n);
     1055                continue;
     1056              }
     1057            if (syntaxType == Readtable.SYNTAX_TYPE_MULTIPLE_ESCAPE)
     1058                break;
     1059            sb.append(c);
     1060          }
     1061      }
     1062    catch (IOException e)
     1063      {
     1064        error(new StreamError(this, e));
    10081065      }
    10091066    return sb.toString();
     
    11601217        if (syntaxType == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE)
    11611218          {
    1162             int n = _readChar();
     1219            int n = -1;
     1220            try
     1221              {
     1222                n = _readChar();
     1223              }
     1224            catch (IOException e)
     1225              {
     1226                error(new StreamError(this, e));
     1227                return flags;
     1228              }
    11631229            if (n < 0)
    11641230              {
     
    11921258          }
    11931259      }
    1194     while (true)
    1195       {
    1196         int n = _readChar();
    1197         if (n < 0)
    1198           break;
    1199         char c = (char) n;
    1200         if (rt.isWhitespace(c))
    1201           {
    1202             _unreadChar(n);
    1203             break;
    1204           }
    1205         byte syntaxType = rt.getSyntaxType(c);
    1206         if (syntaxType == Readtable.SYNTAX_TYPE_TERMINATING_MACRO)
    1207           {
    1208             _unreadChar(c);
    1209             break;
    1210           }
    1211         rt.checkInvalid(c, this);
    1212         if (syntaxType == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE)
    1213           {
    1214             n = _readChar();
    1215             if (n < 0)
     1260    try {
     1261      while (true)
     1262        {
     1263          int n = _readChar();
     1264          if (n < 0)
    12161265              break;
    1217             sb.append((char)n);
    1218             if (flags == null)
    1219               flags = new BitSet(sb.length());
    1220             flags.set(sb.length() - 1);
    1221             continue;
    1222           }
    1223         if (syntaxType == Readtable.SYNTAX_TYPE_MULTIPLE_ESCAPE)
    1224           {
    1225             int begin = sb.length();
    1226             sb.append(readMultipleEscape(rt));
    1227             int end = sb.length();
    1228             if (flags == null)
    1229               flags = new BitSet(sb.length());
    1230             for (int i = begin; i < end; i++)
    1231               flags.set(i);
    1232             continue;
    1233           }
    1234         if (readtableCase == Keyword.UPCASE)
    1235           c = LispCharacter.toUpperCase(c);
    1236         else if (readtableCase == Keyword.DOWNCASE)
    1237           c = LispCharacter.toLowerCase(c);
    1238         sb.append(c);
    1239       }
     1266          char c = (char) n;
     1267          if (rt.isWhitespace(c))
     1268            {
     1269              _unreadChar(n);
     1270              break;
     1271            }
     1272          byte syntaxType = rt.getSyntaxType(c);
     1273          if (syntaxType == Readtable.SYNTAX_TYPE_TERMINATING_MACRO)
     1274            {
     1275              _unreadChar(c);
     1276              break;
     1277            }
     1278          rt.checkInvalid(c, this);
     1279          if (syntaxType == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE)
     1280            {
     1281              n = _readChar();
     1282              if (n < 0)
     1283                  break;
     1284              sb.append((char)n);
     1285              if (flags == null)
     1286                  flags = new BitSet(sb.length());
     1287              flags.set(sb.length() - 1);
     1288              continue;
     1289            }
     1290          if (syntaxType == Readtable.SYNTAX_TYPE_MULTIPLE_ESCAPE)
     1291            {
     1292              int begin = sb.length();
     1293              sb.append(readMultipleEscape(rt));
     1294              int end = sb.length();
     1295              if (flags == null)
     1296                  flags = new BitSet(sb.length());
     1297              for (int i = begin; i < end; i++)
     1298                  flags.set(i);
     1299              continue;
     1300            }
     1301          if (readtableCase == Keyword.UPCASE)
     1302              c = LispCharacter.toUpperCase(c);
     1303          else if (readtableCase == Keyword.DOWNCASE)
     1304              c = LispCharacter.toLowerCase(c);
     1305          sb.append(c);
     1306        }
     1307    }
     1308    catch (IOException e)
     1309      {
     1310        error(new StreamError(this, e));
     1311        return flags;
     1312      }
     1313
    12401314    return flags;
    12411315  }
     
    15381612  private char flushWhitespace(Readtable rt) throws ConditionThrowable
    15391613  {
    1540     while (true)
    1541       {
    1542         int n = _readChar();
    1543         if (n < 0)
    1544           {
    1545             error(new EndOfFile(this));
    1546             // Not reached.
    1547             return 0;
    1548           }
    1549         char c = (char) n;
    1550         if (!rt.isWhitespace(c))
    1551           return c;
     1614    try
     1615      {
     1616        while (true)
     1617          {
     1618            int n = _readChar();
     1619            if (n < 0)
     1620              {
     1621                error(new EndOfFile(this));
     1622                // Not reached.
     1623                return 0;
     1624              }
     1625            char c = (char) n;
     1626            if (!rt.isWhitespace(c))
     1627                return c;
     1628          }
     1629      }
     1630    catch (IOException e)
     1631      {
     1632        error(new StreamError(this, e));
     1633        return 0;
    15521634      }
    15531635  }
     
    15821664    final LispThread thread = LispThread.currentThread();
    15831665    FastStringBuffer sb = new FastStringBuffer();
    1584     while (true)
    1585       {
    1586         int n = _readChar();
    1587         if (n < 0)
    1588           {
    1589             if (sb.length() == 0)
    1590               {
    1591                 if (eofError)
    1592                   return error(new EndOfFile(this));
    1593                 return thread.setValues(eofValue, T);
    1594               }
    1595             return thread.setValues(new SimpleString(sb), T);
    1596           }
    1597         if (n == '\n')
    1598           return thread.setValues(new SimpleString(sb), NIL);
    1599         else
    1600           sb.append((char)n);
     1666    try
     1667      {
     1668        while (true)
     1669          {
     1670            int n = _readChar();
     1671            if (n < 0)
     1672              {
     1673                if (sb.length() == 0)
     1674                  {
     1675                    if (eofError)
     1676                        return error(new EndOfFile(this));
     1677                    return thread.setValues(eofValue, T);
     1678                  }
     1679                return thread.setValues(new SimpleString(sb), T);
     1680              }
     1681            if (n == '\n')
     1682                return thread.setValues(new SimpleString(sb), NIL);
     1683            else
     1684                sb.append((char)n);
     1685          }
     1686      }
     1687    catch (IOException e)
     1688      {
     1689        return error(new StreamError(this, e));
    16011690      }
    16021691  }
     
    16061695  public LispObject readChar() throws ConditionThrowable
    16071696  {
    1608     int n = _readChar();
    1609     if (n < 0)
    1610       return error(new EndOfFile(this));
    1611     return LispCharacter.getInstance((char)n);
     1697    try
     1698      {
     1699        int n = _readChar();
     1700        if (n < 0)
     1701            return error(new EndOfFile(this));
     1702        return LispCharacter.getInstance((char)n);
     1703      }
     1704    catch (IOException e)
     1705      {
     1706        return error(new StreamError(this, e));
     1707      }
     1708
    16121709  }
    16131710
     
    16151712    throws ConditionThrowable
    16161713  {
    1617     int n = _readChar();
     1714    try
     1715      {
     1716        int n = _readChar();
     1717        if (n < 0)
     1718          {
     1719            if (eofError)
     1720                return error(new EndOfFile(this));
     1721            else
     1722                return eofValue;
     1723          }
     1724        return LispCharacter.getInstance((char)n);
     1725      }
     1726    catch (IOException e)
     1727      {
     1728        return error(new StreamError(this, e));
     1729      }
     1730  }
     1731
     1732  // read-char-no-hang &optional stream eof-error-p eof-value recursive-p => char
     1733  // recursive-p is ignored
     1734  public LispObject readCharNoHang(boolean eofError, LispObject eofValue)
     1735    throws ConditionThrowable
     1736  {
     1737    try
     1738      {
     1739        return _charReady() ? readChar(eofError, eofValue) : NIL;
     1740      }
     1741    catch (IOException e)
     1742      {
     1743        return error(new StreamError(this, e));
     1744      }
     1745  }
     1746
     1747
     1748  // unread-char character &optional input-stream => nil
     1749  public LispObject unreadChar(LispCharacter c) throws ConditionThrowable
     1750  {
     1751    try
     1752      {
     1753        _unreadChar(c.value);
     1754        return NIL;
     1755      }
     1756    catch (IOException e)
     1757      {
     1758        return error(new StreamError(this, e));
     1759      }
     1760  }
     1761
     1762  public LispObject finishOutput() throws ConditionThrowable
     1763  {
     1764    _finishOutput();
     1765    return NIL;
     1766  }
     1767
     1768  // clear-input &optional input-stream => nil
     1769  public LispObject clearInput() throws ConditionThrowable
     1770  {
     1771    _clearInput();
     1772    return NIL;
     1773  }
     1774
     1775  public LispObject getFilePosition() throws ConditionThrowable
     1776  {
     1777    long pos = _getFilePosition();
     1778    return pos >= 0 ? number(pos) : NIL;
     1779  }
     1780
     1781  public LispObject setFilePosition(LispObject arg) throws ConditionThrowable
     1782  {
     1783    return _setFilePosition(arg) ? T : NIL;
     1784  }
     1785
     1786  // close stream &key abort => result
     1787  // Must return true if stream was open, otherwise implementation-dependent.
     1788  public LispObject close(LispObject abort) throws ConditionThrowable
     1789  {
     1790    _close();
     1791    return T;
     1792  }
     1793
     1794  @Override
     1795  public String toString()
     1796  {
     1797    return unreadableString("STREAM");
     1798  }
     1799
     1800  // read-byte stream &optional eof-error-p eof-value => byte
     1801  // Reads an 8-bit byte.
     1802  public LispObject readByte(boolean eofError, LispObject eofValue)
     1803    throws ConditionThrowable
     1804  {
     1805    int n = _readByte();
    16181806    if (n < 0)
    16191807      {
     
    16231811          return eofValue;
    16241812      }
    1625     return LispCharacter.getInstance((char)n);
    1626   }
    1627 
    1628   // read-char-no-hang &optional stream eof-error-p eof-value recursive-p => char
    1629   // recursive-p is ignored
    1630   public LispObject readCharNoHang(boolean eofError, LispObject eofValue)
    1631     throws ConditionThrowable
    1632   {
    1633     return _charReady() ? readChar(eofError, eofValue) : NIL;
    1634   }
    1635 
    1636 
    1637   // unread-char character &optional input-stream => nil
    1638   public LispObject unreadChar(LispCharacter c) throws ConditionThrowable
    1639   {
    1640     _unreadChar(c.value);
    1641     return NIL;
    1642   }
    1643 
    1644   public LispObject finishOutput() throws ConditionThrowable
    1645   {
    1646     _finishOutput();
    1647     return NIL;
    1648   }
    1649 
    1650   // clear-input &optional input-stream => nil
    1651   public LispObject clearInput() throws ConditionThrowable
    1652   {
    1653     _clearInput();
    1654     return NIL;
    1655   }
    1656 
    1657   public LispObject getFilePosition() throws ConditionThrowable
    1658   {
    1659     long pos = _getFilePosition();
    1660     return pos >= 0 ? number(pos) : NIL;
    1661   }
    1662 
    1663   public LispObject setFilePosition(LispObject arg) throws ConditionThrowable
    1664   {
    1665     return _setFilePosition(arg) ? T : NIL;
    1666   }
    1667 
    1668   // close stream &key abort => result
    1669   // Must return true if stream was open, otherwise implementation-dependent.
    1670   public LispObject close(LispObject abort) throws ConditionThrowable
    1671   {
    1672     _close();
    1673     return T;
    1674   }
    1675 
    1676   @Override
    1677   public String toString()
    1678   {
    1679     return unreadableString("STREAM");
    1680   }
    1681 
    1682   // read-byte stream &optional eof-error-p eof-value => byte
    1683   // Reads an 8-bit byte.
    1684   public LispObject readByte(boolean eofError, LispObject eofValue)
    1685     throws ConditionThrowable
    1686   {
    1687     int n = _readByte();
    1688     if (n < 0)
    1689       {
    1690         if (eofError)
    1691           return error(new EndOfFile(this));
    1692         else
    1693           return eofValue;
    1694       }
    16951813    return Fixnum.constants[n];
    16961814  }
     
    17361854    if (pastEnd)
    17371855      return NIL;
    1738    
    1739     if (! _charReady())
    1740       return NIL;
    1741    
    1742     int n = _readChar();
    1743     if (n < 0)
    1744       return NIL;
    1745 
    1746     _unreadChar(n);
    1747    
    1748     return T;
     1856    try
     1857      {
     1858        if (! _charReady())
     1859            return NIL;
     1860       
     1861        int n = _readChar();
     1862        if (n < 0)
     1863            return NIL;
     1864       
     1865        _unreadChar(n);
     1866       
     1867        return T;
     1868      }
     1869    catch (IOException e)
     1870      {
     1871        return error(new StreamError(this, e));
     1872      }
    17491873  }
    17501874
     
    17921916   * @throws org.armedbear.lisp.ConditionThrowable
    17931917   */
    1794   protected int _readChar() throws ConditionThrowable
     1918  protected int _readChar() throws ConditionThrowable, IOException
    17951919  {
    17961920    if (reader == null)
    17971921        streamNotCharacterInputStream();
    17981922
    1799     try
    1800       {
    1801         int n = reader.read();
     1923    int n = reader.read();
     1924   
     1925    if (n < 0) {
     1926        pastEnd = true;
     1927        return -1;
     1928    }
    18021929       
    1803         if (n < 0) {
    1804             pastEnd = true;
    1805             return -1;
     1930    ++offset;
     1931    if (eolStyle == EolStyle.CRLF && n == '\r') {
     1932        n = _readChar();
     1933        if (n != '\n') {
     1934            _unreadChar(n);
     1935            return '\r';
    18061936        }
    1807        
    1808         ++offset;
    1809         if (eolStyle == EolStyle.CRLF && n == '\r') {
    1810             n = _readChar();
    1811             if (n != '\n') {
    1812                 _unreadChar(n);
    1813                 return '\r';
    1814             }
    1815             else
    1816               return '\n';
    1817         }
    1818 
    1819         if (n == eolChar) {
    1820           ++lineNumber;
    1821           return '\n';
    1822         }
    1823 
    1824         return n;
    1825       }
    1826     catch (IOException e)
    1827       {
    1828         error(new StreamError(this, e));
    1829       }
    1830     // Not reached.
    1831     return -1;
     1937        else
     1938            return '\n';
     1939    }
     1940
     1941    if (n == eolChar) {
     1942        ++lineNumber;
     1943        return '\n';
     1944    }
     1945
     1946    return n;
    18321947  }
    18331948
     
    18371952   * @throws org.armedbear.lisp.ConditionThrowable
    18381953   */
    1839   protected void _unreadChar(int n) throws ConditionThrowable
     1954  protected void _unreadChar(int n) throws ConditionThrowable, IOException
    18401955  {
    18411956    if (reader == null)
    18421957        streamNotCharacterInputStream();
    1843 
    1844     try
    1845       {
    1846         reader.unread(n);
    1847         --offset;
    1848         pastEnd = false;
    1849         if (n == eolChar)
    1850           --lineNumber;
    1851       }
    1852     catch (IOException e)
    1853       {
    1854         error(new StreamError(this, e));
    1855       }
    1856   }
     1958    reader.unread(n);
     1959    --offset;
     1960    pastEnd = false;
     1961    if (n == eolChar)
     1962        --lineNumber;
     1963  }
     1964
    18571965
    18581966  /** Returns a boolean indicating input readily available
     
    18611969   * @throws org.armedbear.lisp.ConditionThrowable
    18621970   */
    1863   protected boolean _charReady() throws ConditionThrowable
     1971  protected boolean _charReady() throws ConditionThrowable, IOException
    18641972  {
    18651973    if (reader == null)
    18661974        streamNotCharacterInputStream();
    1867 
    1868     try
    1869       {
    1870         return reader.ready();
    1871       }
    1872     catch (IOException e)
    1873       {
    1874         error(new StreamError(this, e));
    1875       }
    1876     // Not reached.
    1877     return false;
     1975    return reader.ready();
    18781976  }
    18791977
     
    20882186      {
    20892187        int c = 0;
    2090         while (_charReady() && (c >= 0))
    2091           c = _readChar();
     2188        try
     2189          {
     2190            while (_charReady() && (c >= 0))
     2191                c = _readChar();
     2192          }
     2193        catch (IOException e)
     2194          {
     2195            error(new StreamError(this, e));
     2196          }
    20922197      }
    20932198    else if (in != null)
  • trunk/abcl/src/org/armedbear/lisp/SynonymStream.java

    r11754 r11991  
    126126
    127127    @Override
    128     protected int _readChar() throws ConditionThrowable
     128    protected int _readChar() throws ConditionThrowable, java.io.IOException
    129129    {
    130130        return checkStream(symbol.symbolValue())._readChar();
     
    132132
    133133    @Override
    134     protected void _unreadChar(int n) throws ConditionThrowable
     134    protected void _unreadChar(int n) throws ConditionThrowable, java.io.IOException
    135135    {
    136136        checkStream(symbol.symbolValue())._unreadChar(n);
     
    138138
    139139    @Override
    140     protected boolean _charReady() throws ConditionThrowable
     140    protected boolean _charReady() throws ConditionThrowable, java.io.IOException
    141141    {
    142142        return checkStream(symbol.symbolValue())._charReady();
  • trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java

    r11754 r11991  
    121121    // Returns -1 at end of file.
    122122    @Override
    123     protected int _readChar() throws ConditionThrowable
     123    protected int _readChar() throws ConditionThrowable, java.io.IOException
    124124    {
    125125        return in._readChar();
     
    127127
    128128    @Override
    129     protected void _unreadChar(int n) throws ConditionThrowable
     129    protected void _unreadChar(int n) throws ConditionThrowable, java.io.IOException
    130130    {
    131131        in._unreadChar(n);
     
    133133
    134134    @Override
    135     protected boolean _charReady() throws ConditionThrowable
     135    protected boolean _charReady() throws ConditionThrowable, java.io.IOException
    136136    {
    137137        return in._charReady();
Note: See TracChangeset for help on using the changeset viewer.