jdk1.7.0_45 search in sublime text for EOFException

Searching 7454 files for "EOFException"

C:\Documents and Settings\Me\My Documents\java source code\com\sun\corba\se\impl\io\IIOPInputStream.java:
   43  import java.io.WriteAbortedException;
   44  import java.io.Externalizable;
   45: import java.io.EOFException;
   46  import java.lang.reflect.*;
   47  import java.util.Vector;
   ..
  932          // of the class attempts to read more data than is present in the
  933          // optional part of the stream for this class, the stream will
  934:         // return -1 for bytewise reads, throw an EOFException for
  935          // primitive data reads, or throw an OptionalDataException
  936          // with the eof field set to true for object reads."
  ...
  941
  942              if (!objectRead)
  943:                 result = new EOFException("No more optional data");
  944              else
  945                  result = createOptionalDataException();

C:\Documents and Settings\Me\My Documents\java source code\com\sun\imageio\plugins\gif\GIFImageReader.java:
   33  import java.io.BufferedInputStream;
   34  import java.io.DataInputStream;
   35: import java.io.EOFException;
   36  import java.io.InputStream;
   37  import java.io.IOException;
   ..
  561                  }
  562              }
  563:         } catch (EOFException e) {
  564              return false;
  565          } catch (IOException e) {

C:\Documents and Settings\Me\My Documents\java source code\com\sun\imageio\plugins\png\PNGImageReader.java:
   38  import java.io.ByteArrayInputStream;
   39  import java.io.DataInputStream;
   40: import java.io.EOFException;
   41  import java.io.InputStream;
   42  import java.io.IOException;
   ..
  214          int count = 0;
  215          while ((maxLen > count++) && ((b = stream.read()) != 0)) {
  216:             if (b == -1) throw new EOFException();
  217              baos.write(b);
  218          }

C:\Documents and Settings\Me\My Documents\java source code\com\sun\org\apache\xerces\internal\impl\XML11EntityScanner.java:
  103       *
  104       * @throws IOException  Thrown if i/o error occurs.
  105:      * @throws EOFException Thrown on end of file.
  106       */
  107      public int peekChar() throws IOException {
  ...
  131       *
  132       * @throws IOException  Thrown if i/o error occurs.
  133:      * @throws EOFException Thrown on end of file.
  134       */
  135      public int scanChar() throws IOException {
  ...
  176       *
  177       * @throws IOException  Thrown if i/o error occurs.
  178:      * @throws EOFException Thrown on end of file.
  179       *
  180       * @see com.sun.org.apache.xerces.internal.util.SymbolTable
  ...
  286       *
  287       * @throws IOException  Thrown if i/o error occurs.
  288:      * @throws EOFException Thrown on end of file.
  289       *
  290       * @see com.sun.org.apache.xerces.internal.util.SymbolTable
  ...
  440       *
  441       * @throws IOException  Thrown if i/o error occurs.
  442:      * @throws EOFException Thrown on end of file.
  443       *
  444       * @see com.sun.org.apache.xerces.internal.util.SymbolTable
  ...
  601       *
  602       * @throws IOException  Thrown if i/o error occurs.
  603:      * @throws EOFException Thrown on end of file.
  604       *
  605       * @see com.sun.org.apache.xerces.internal.util.SymbolTable
  ...
  815       *
  816       * @throws IOException  Thrown if i/o error occurs.
  817:      * @throws EOFException Thrown on end of file.
  818       */
  819      public int scanContent(XMLString content) throws IOException {
  ...
  956       *
  957       * @throws IOException  Thrown if i/o error occurs.
  958:      * @throws EOFException Thrown on end of file.
  959       */
  960      public int scanLiteral(int quote, XMLString content)
  ...
 1102       *
 1103       * @throws IOException  Thrown if i/o error occurs.
 1104:      * @throws EOFException Thrown on end of file.
 1105       */
 1106      public boolean scanData(String delimiter, XMLStringBuffer buffer)
 ....
 1304       *
 1305       * @throws IOException  Thrown if i/o error occurs.
 1306:      * @throws EOFException Thrown on end of file.
 1307       */
 1308      public boolean skipChar(int c) throws IOException {
 ....
 1361       *
 1362       * @throws IOException  Thrown if i/o error occurs.
 1363:      * @throws EOFException Thrown on end of file.
 1364       *
 1365       * @see com.sun.org.apache.xerces.internal.util.XMLChar#isSpace
 ....
 1491       *
 1492       * @throws IOException  Thrown if i/o error occurs.
 1493:      * @throws EOFException Thrown on end of file.
 1494       */
 1495      public boolean skipString(String s) throws IOException {

C:\Documents and Settings\Me\My Documents\java source code\com\sun\org\apache\xerces\internal\impl\XMLDocumentFragmentScannerImpl.java:
   27  import com.sun.xml.internal.stream.dtd.DTDGrammarUtil;
   28
   29: import java.io.EOFException;
   30  import java.io.IOException;
   31  import javax.xml.stream.XMLInputFactory;
   ..
 3149              }
 3150              // premature end of file
 3151:             catch (EOFException e) {
 3152                  endOfFileHook(e);
 3153                  return -1;
 ....
 3245           * is always premature.
 3246           */
 3247:         protected void endOfFileHook(EOFException e)
 3248          throws IOException, XNIException {
 3249

C:\Documents and Settings\Me\My Documents\java source code\com\sun\org\apache\xerces\internal\impl\XMLDocumentScannerImpl.java:
   41  import com.sun.xml.internal.stream.StaxXMLInputSource;
   42  import com.sun.xml.internal.stream.dtd.DTDGrammarUtil;
   43: import java.io.EOFException;
   44  import java.io.IOException;
   45  import javax.xml.stream.XMLInputFactory;
   ..
  573              } else{
  574                  //else we have reached the end of document prematurely
  575:                 //so throw EOFException.
  576:                 throw new java.io.EOFException();
  577              }
  578
  ...
  792
  793              // premature end of file
  794:             catch (EOFException e) {
  795                  reportFatalError("PrematureEOF", null);
  796                  return -1;
  ...
 1016              }
 1017              // premature end of file
 1018:             catch (EOFException e) {
 1019                  reportFatalError("PrematureEOF", null);
 1020                  //xxx  what should be returned here.... ???
 ....
 1193
 1194              // premature end of file
 1195:             catch (EOFException e) {
 1196                  e.printStackTrace();
 1197                  reportFatalError("PrematureEOF", null);
 ....
 1304           * is always premature.
 1305           */
 1306:         protected void endOfFileHook(EOFException e)
 1307          throws IOException, XNIException {
 1308
 ....
 1456                  }//switch
 1457
 1458:             } catch (EOFException e) {
 1459                  // NOTE: This is the only place we're allowed to reach
 1460                  //       the real end of the document stream. Unless the
 ....
 1465                      //throw e;
 1466                  }
 1467:                 //System.out.println("EOFException thrown") ;
 1468                  setScannerState(SCANNER_STATE_TERMINATED);
 1469              }

C:\Documents and Settings\Me\My Documents\java source code\com\sun\org\apache\xerces\internal\impl\XMLDTDScannerImpl.java:
   21  package com.sun.org.apache.xerces.internal.impl;
   22  import com.sun.xml.internal.stream.dtd.nonvalidating.DTDGrammar;
   23: import java.io.EOFException;
   24  import java.io.IOException;
   25
   ..
  639          if (augs != null && Boolean.TRUE.equals(augs.getItem(Constants.LAST_ENTITY))
  640              && ( fMarkUpDepth != 0 || fExtEntityDepth !=0 || fIncludeSectDepth != 0)){
  641:             throw new EOFException();
  642          }
  643

C:\Documents and Settings\Me\My Documents\java source code\com\sun\org\apache\xerces\internal\impl\XMLEntityManager.java:
 1400
 1401          if(fCurrentEntity == null & !documentEntity){
 1402:             throw new EOFException() ;
 1403          }
 1404

C:\Documents and Settings\Me\My Documents\java source code\com\sun\org\apache\xerces\internal\impl\XMLEntityScanner.java:
   21  package com.sun.org.apache.xerces.internal.impl;
   22
   23: import java.io.EOFException;
   24  import java.io.IOException;
   25  import java.util.Locale;
   ..
   84       * To signal the end of the document entity, this exception will be thrown.
   85       */
   86:     private static final EOFException END_OF_DOCUMENT_ENTITY = new EOFException() {
   87          private static final long serialVersionUID = 980337771224675268L;
   88          public Throwable fillInStackTrace() {
   ..
  483       *
  484       * @throws IOException  Thrown if i/o error occurs.
  485:      * @throws EOFException Thrown on end of file.
  486       */
  487      public int peekChar() throws IOException {
  ...
  525       *
  526       * @throws IOException  Thrown if i/o error occurs.
  527:      * @throws EOFException Thrown on end of file.
  528       */
  529      public int scanChar() throws IOException {
  ...
  580       *
  581       * @throws IOException  Thrown if i/o error occurs.
  582:      * @throws EOFException Thrown on end of file.
  583       *
  584       * @see com.sun.org.apache.xerces.internal.util.SymbolTable
  ...
  659       *
  660       * @throws IOException  Thrown if i/o error occurs.
  661:      * @throws EOFException Thrown on end of file.
  662       *
  663       * @see com.sun.org.apache.xerces.internal.util.SymbolTable
  ...
  762       *
  763       * @throws IOException  Thrown if i/o error occurs.
  764:      * @throws EOFException Thrown on end of file.
  765       *
  766       * @see com.sun.org.apache.xerces.internal.util.SymbolTable
  ...
  908       *
  909       * @throws IOException  Thrown if i/o error occurs.
  910:      * @throws EOFException Thrown on end of file.
  911       */
  912      public int scanContent(XMLString content) throws IOException {
  ...
 1060       *
 1061       * @throws IOException  Thrown if i/o error occurs.
 1062:      * @throws EOFException Thrown on end of file.
 1063       */
 1064      public int scanLiteral(int quote, XMLString content)
 ....
 1232       *
 1233       * @throws IOException  Thrown if i/o error occurs.
 1234:      * @throws EOFException Thrown on end of file.
 1235       */
 1236      public boolean scanData(String delimiter, XMLStringBuffer buffer)
 ....
 1412       *
 1413       * @throws IOException  Thrown if i/o error occurs.
 1414:      * @throws EOFException Thrown on end of file.
 1415       */
 1416      public boolean skipChar(int c) throws IOException {
 ....
 1486       *
 1487       * @throws IOException  Thrown if i/o error occurs.
 1488:      * @throws EOFException Thrown on end of file.
 1489       *
 1490       * @see com.sun.org.apache.xerces.internal.util.XMLChar#isSpace
 ....
 1658       *
 1659       * @throws IOException  Thrown if i/o error occurs.
 1660:      * @throws EOFException Thrown on end of file.
 1661       */
 1662      public boolean skipString(String s) throws IOException {
 ....
 2096       *
 2097       * @throws IOException  Thrown if i/o error occurs.
 2098:      * @throws EOFException Thrown on end of file.
 2099       *
 2100       * @see com.sun.org.apache.xerces.internal.util.XMLChar#isSpace

C:\Documents and Settings\Me\My Documents\java source code\com\sun\org\apache\xerces\internal\impl\XMLVersionDetector.java:
   62  package com.sun.org.apache.xerces.internal.impl;
   63
   64: import java.io.EOFException;
   65  import java.io.IOException;
   66
   ..
  232              // premature end of file
  233          }
  234:         catch (EOFException e) {
  235              fErrorReporter.reportError(
  236                  XMLMessageFormatter.XML_DOMAIN,

C:\Documents and Settings\Me\My Documents\java source code\com\sun\org\apache\xerces\internal\impl\dtd\XMLDTDLoader.java:
   62  package com.sun.org.apache.xerces.internal.impl.dtd;
   63
   64: import java.io.EOFException;
   65  import java.io.IOException;
   66  import java.io.StringReader;
   ..
  483              fDTDScanner.setInputSource(source);
  484              fDTDScanner.scanDTDExternalSubset(true);
  485:         } catch (EOFException e) {
  486              // expected behaviour...
  487          }
  ...
  530                  }
  531              }
  532:             catch (EOFException e) {
  533                  // expected behaviour...
  534              }

C:\Documents and Settings\Me\My Documents\java source code\java\io\DataInput.java:
   40   * routines in this interface that if end of
   41   * file is reached before the desired number
   42:  * of bytes has been read, an <code>EOFException</code>
   43   * (which is a kind of <code>IOException</code>)
   44   * is thrown. If any byte cannot be read for
   45   * any reason other than end of file, an <code>IOException</code>
   46:  * other than <code>EOFException</code> is
   47   * thrown. In particular, an <code>IOException</code>
   48   * may be thrown if the input stream has been
   ..
  208       *
  209       * <li>End of
  210:      * file is detected, in which case an <code>EOFException</code>
  211       * is thrown.
  212       *
  213       * <li>An I/O error occurs, in
  214       * which case an <code>IOException</code> other
  215:      * than <code>EOFException</code> is thrown.
  216       * </ul>
  217       * <p>
  ...
  229       *
  230       * @param     b   the buffer into which the data is read.
  231:      * @exception  EOFException  if this stream reaches the end before reading
  232       *               all the bytes.
  233       * @exception  IOException   if an I/O error occurs.
  ...
  250       *
  251       * <li>End of file
  252:      * is detected, in which case an <code>EOFException</code>
  253       * is thrown.
  254       *
  255       * <li>An I/O error occurs, in
  256       * which case an <code>IOException</code> other
  257:      * than <code>EOFException</code> is thrown.
  258       * </ul>
  259       * <p>
  ...
  275       * @param off  an int specifying the offset into the data.
  276       * @param len  an int specifying the number of bytes to read.
  277:      * @exception  EOFException  if this stream reaches the end before reading
  278       *               all the bytes.
  279       * @exception  IOException   if an I/O error occurs.
  ...
  294       * have been skipped is
  295       * only one possibility.
  296:      * This method never throws an <code>EOFException</code>.
  297       * The actual
  298       * number of bytes skipped is returned.
  ...
  313       *
  314       * @return     the <code>boolean</code> value read.
  315:      * @exception  EOFException  if this stream reaches the end before reading
  316       *               all the bytes.
  317       * @exception  IOException   if an I/O error occurs.
  ...
  329       *
  330       * @return     the 8-bit value read.
  331:      * @exception  EOFException  if this stream reaches the end before reading
  332       *               all the bytes.
  333       * @exception  IOException   if an I/O error occurs.
  ...
  349       *
  350       * @return     the unsigned 8-bit value read.
  351:      * @exception  EOFException  if this stream reaches the end before reading
  352       *               all the bytes.
  353       * @exception  IOException   if an I/O error occurs.
  ...
  370       *
  371       * @return     the 16-bit value read.
  372:      * @exception  EOFException  if this stream reaches the end before reading
  373       *               all the bytes.
  374       * @exception  IOException   if an I/O error occurs.
  ...
  393       *
  394       * @return     the unsigned 16-bit value read.
  395:      * @exception  EOFException  if this stream reaches the end before reading
  396       *               all the bytes.
  397       * @exception  IOException   if an I/O error occurs.
  ...
  413       *
  414       * @return     the <code>char</code> value read.
  415:      * @exception  EOFException  if this stream reaches the end before reading
  416       *               all the bytes.
  417       * @exception  IOException   if an I/O error occurs.
  ...
  433       *
  434       * @return     the <code>int</code> value read.
  435:      * @exception  EOFException  if this stream reaches the end before reading
  436       *               all the bytes.
  437       * @exception  IOException   if an I/O error occurs.
  ...
  460       *
  461       * @return     the <code>long</code> value read.
  462:      * @exception  EOFException  if this stream reaches the end before reading
  463       *               all the bytes.
  464       * @exception  IOException   if an I/O error occurs.
  ...
  480       *
  481       * @return     the <code>float</code> value read.
  482:      * @exception  EOFException  if this stream reaches the end before reading
  483       *               all the bytes.
  484       * @exception  IOException   if an I/O error occurs.
  ...
  500       *
  501       * @return     the <code>double</code> value read.
  502:      * @exception  EOFException  if this stream reaches the end before reading
  503       *               all the bytes.
  504       * @exception  IOException   if an I/O error occurs.
  ...
  612       * If end of file is encountered
  613       * at any time during this entire process,
  614:      * then an <code>EOFException</code> is thrown.
  615       * <p>
  616       * After every group has been converted to
  ...
  626       * for reading by this method.
  627       * @return     a Unicode string.
  628:      * @exception  EOFException            if this stream reaches the end
  629       *               before reading all the bytes.
  630       * @exception  IOException             if an I/O error occurs.

C:\Documents and Settings\Me\My Documents\java source code\java\io\DataInputStream.java:
  159       *
  160       * @param      b   the buffer into which the data is read.
  161:      * @exception  EOFException  if this input stream reaches the end before
  162       *             reading all the bytes.
  163       * @exception  IOException   the stream has been closed and the contained
  ...
  181       * @param      off   the start offset of the data.
  182       * @param      len   the number of bytes to read.
  183:      * @exception  EOFException  if this input stream reaches the end before
  184       *               reading all the bytes.
  185       * @exception  IOException   the stream has been closed and the contained
  ...
  195              int count = in.read(b, off + n, len - n);
  196              if (count < 0)
  197:                 throw new EOFException();
  198              n += count;
  199          }
  ...
  233       *
  234       * @return     the <code>boolean</code> value read.
  235:      * @exception  EOFException  if this input stream has reached the end.
  236       * @exception  IOException   the stream has been closed and the contained
  237       *             input stream does not support reading after close, or
  ...
  242          int ch = in.read();
  243          if (ch < 0)
  244:             throw new EOFException();
  245          return (ch != 0);
  246      }
  ...
  256       * @return     the next byte of this input stream as a signed 8-bit
  257       *             <code>byte</code>.
  258:      * @exception  EOFException  if this input stream has reached the end.
  259       * @exception  IOException   the stream has been closed and the contained
  260       *             input stream does not support reading after close, or
  ...
  265          int ch = in.read();
  266          if (ch < 0)
  267:             throw new EOFException();
  268          return (byte)(ch);
  269      }
  ...
  279       * @return     the next byte of this input stream, interpreted as an
  280       *             unsigned 8-bit number.
  281:      * @exception  EOFException  if this input stream has reached the end.
  282       * @exception  IOException   the stream has been closed and the contained
  283       *             input stream does not support reading after close, or
  ...
  288          int ch = in.read();
  289          if (ch < 0)
  290:             throw new EOFException();
  291          return ch;
  292      }
  ...
  302       * @return     the next two bytes of this input stream, interpreted as a
  303       *             signed 16-bit number.
  304:      * @exception  EOFException  if this input stream reaches the end before
  305       *               reading two bytes.
  306       * @exception  IOException   the stream has been closed and the contained
  ...
  313          int ch2 = in.read();
  314          if ((ch1 | ch2) < 0)
  315:             throw new EOFException();
  316          return (short)((ch1 << 8) + (ch2 << 0));
  317      }
  ...
  327       * @return     the next two bytes of this input stream, interpreted as an
  328       *             unsigned 16-bit integer.
  329:      * @exception  EOFException  if this input stream reaches the end before
  330       *             reading two bytes.
  331       * @exception  IOException   the stream has been closed and the contained
  ...
  338          int ch2 = in.read();
  339          if ((ch1 | ch2) < 0)
  340:             throw new EOFException();
  341          return (ch1 << 8) + (ch2 << 0);
  342      }
  ...
  352       * @return     the next two bytes of this input stream, interpreted as a
  353       *             <code>char</code>.
  354:      * @exception  EOFException  if this input stream reaches the end before
  355       *               reading two bytes.
  356       * @exception  IOException   the stream has been closed and the contained
  ...
  363          int ch2 = in.read();
  364          if ((ch1 | ch2) < 0)
  365:             throw new EOFException();
  366          return (char)((ch1 << 8) + (ch2 << 0));
  367      }
  ...
  377       * @return     the next four bytes of this input stream, interpreted as an
  378       *             <code>int</code>.
  379:      * @exception  EOFException  if this input stream reaches the end before
  380       *               reading four bytes.
  381       * @exception  IOException   the stream has been closed and the contained
  ...
  390          int ch4 = in.read();
  391          if ((ch1 | ch2 | ch3 | ch4) < 0)
  392:             throw new EOFException();
  393          return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
  394      }
  ...
  406       * @return     the next eight bytes of this input stream, interpreted as a
  407       *             <code>long</code>.
  408:      * @exception  EOFException  if this input stream reaches the end before
  409       *               reading eight bytes.
  410       * @exception  IOException   the stream has been closed and the contained
  ...
  435       * @return     the next four bytes of this input stream, interpreted as a
  436       *             <code>float</code>.
  437:      * @exception  EOFException  if this input stream reaches the end before
  438       *               reading four bytes.
  439       * @exception  IOException   the stream has been closed and the contained
  ...
  457       * @return     the next eight bytes of this input stream, interpreted as a
  458       *             <code>double</code>.
  459:      * @exception  EOFException  if this input stream reaches the end before
  460       *               reading eight bytes.
  461       * @exception  IOException   the stream has been closed and the contained
  ...
  552       *
  553       * @return     a Unicode string.
  554:      * @exception  EOFException  if this input stream reaches the end before
  555       *               reading all the bytes.
  556       * @exception  IOException   the stream has been closed and the contained
  ...
  577       * @param      in   a data input stream.
  578       * @return     a Unicode string.
  579:      * @exception  EOFException            if the input stream reaches the end
  580       *               before all the bytes.
  581       * @exception  IOException   the stream has been closed and the contained

C:\Documents and Settings\Me\My Documents\java source code\java\io\EOFException.java:
   41   */
   42  public
   43: class EOFException extends IOException {
   44      private static final long serialVersionUID = 6433858223774886977L;
   45
   46      /**
   47:      * Constructs an <code>EOFException</code> with <code>null</code>
   48       * as its error detail message.
   49       */
   50:     public EOFException() {
   51          super();
   52      }
   53
   54      /**
   55:      * Constructs an <code>EOFException</code> with the specified detail
   56       * message. The string <code>s</code> may later be retrieved by the
   57       * <code>{@link java.lang.Throwable#getMessage}</code> method of class
   ..
   60       * @param   s   the detail message.
   61       */
   62:     public EOFException(String s) {
   63          super(s);
   64      }

C:\Documents and Settings\Me\My Documents\java source code\java\io\ObjectInputStream.java:
  135   * end of data in the same way that they would indicate the end of the stream:
  136   * bytewise reads will return -1 as the byte read or number of bytes read, and
  137:  * primitive reads will throw EOFExceptions.  If there is no corresponding
  138   * writeObject method, then the end of default serialized data marks the end of
  139   * the allotted data.
  ...
  143   * data written by the corresponding writeExternal method, object reads will
  144   * throw OptionalDataExceptions with eof set to true, bytewise reads will
  145:  * return -1, and primitive reads will throw EOFExceptions.  Note that this
  146   * behavior does not hold for streams written with the old
  147   * <code>ObjectStreamConstants.PROTOCOL_VERSION_1</code> protocol, in which the
  ...
  899       *
  900       * @return  the boolean read.
  901:      * @throws  EOFException If end of file is reached.
  902       * @throws  IOException If other I/O error has occurred.
  903       */
  ...
  910       *
  911       * @return  the 8 bit byte read.
  912:      * @throws  EOFException If end of file is reached.
  913       * @throws  IOException If other I/O error has occurred.
  914       */
  ...
  921       *
  922       * @return  the 8 bit byte read.
  923:      * @throws  EOFException If end of file is reached.
  924       * @throws  IOException If other I/O error has occurred.
  925       */
  ...
  932       *
  933       * @return  the 16 bit char read.
  934:      * @throws  EOFException If end of file is reached.
  935       * @throws  IOException If other I/O error has occurred.
  936       */
  ...
  943       *
  944       * @return  the 16 bit short read.
  945:      * @throws  EOFException If end of file is reached.
  946       * @throws  IOException If other I/O error has occurred.
  947       */
  ...
  954       *
  955       * @return  the 16 bit short read.
  956:      * @throws  EOFException If end of file is reached.
  957       * @throws  IOException If other I/O error has occurred.
  958       */
  ...
  965       *
  966       * @return  the 32 bit integer read.
  967:      * @throws  EOFException If end of file is reached.
  968       * @throws  IOException If other I/O error has occurred.
  969       */
  ...
  976       *
  977       * @return  the read 64 bit long.
  978:      * @throws  EOFException If end of file is reached.
  979       * @throws  IOException If other I/O error has occurred.
  980       */
  ...
  987       *
  988       * @return  the 32 bit float read.
  989:      * @throws  EOFException If end of file is reached.
  990       * @throws  IOException If other I/O error has occurred.
  991       */
  ...
  998       *
  999       * @return  the 64 bit double read.
 1000:      * @throws  EOFException If end of file is reached.
 1001       * @throws  IOException If other I/O error has occurred.
 1002       */
 ....
 1009       *
 1010       * @param   buf the buffer into which the data is read
 1011:      * @throws  EOFException If end of file is reached.
 1012       * @throws  IOException If other I/O error has occurred.
 1013       */
 ....
 1022       * @param   off the start offset of the data
 1023       * @param   len the maximum number of bytes to read
 1024:      * @throws  EOFException If end of file is reached.
 1025       * @throws  IOException If other I/O error has occurred.
 1026       */
 ....
 2323                  int count = read(b, off + n, len - n);
 2324                  if (count < 0) {
 2325:                     throw new EOFException();
 2326                  }
 2327                  n += count;
 ....
 2513                      }
 2514                  }
 2515:             } catch (EOFException ex) {
 2516                  throw new StreamCorruptedException(
 2517                      "unexpected EOF while reading block data header");
 ....
 2590          /**
 2591           * Peeks at (but does not consume) and returns the next byte value in
 2592:          * the stream, or throws EOFException if end of stream/block data has
 2593           * been reached.
 2594           */
 ....
 2596              int val = peek();
 2597              if (val < 0) {
 2598:                 throw new EOFException();
 2599              }
 2600              return (byte) val;
 ....
 2742                  int n = read(b, off, len, copy);
 2743                  if (n < 0) {
 2744:                     throw new EOFException();
 2745                  }
 2746                  off += n;
 ....
 2756              int v = read();
 2757              if (v < 0) {
 2758:                 throw new EOFException();
 2759              }
 2760              return (v != 0);
 ....
 2764              int v = read();
 2765              if (v < 0) {
 2766:                 throw new EOFException();
 2767              }
 2768              return (byte) v;
 ....
 2772              int v = read();
 2773              if (v < 0) {
 2774:                 throw new EOFException();
 2775              }
 2776              return v;

C:\Documents and Settings\Me\My Documents\java source code\java\io\RandomAccessFile.java:
   48   * It is generally true of all the reading routines in this class that
   49   * if end-of-file is reached before the desired number of bytes has been
   50:  * read, an <code>EOFException</code> (which is a kind of
   51   * <code>IOException</code>) is thrown. If any byte cannot be read for
   52   * any reason other than end-of-file, an <code>IOException</code> other
   53:  * than <code>EOFException</code> is thrown. In particular, an
   54   * <code>IOException</code> may be thrown if the stream has been closed.
   55   *
   ..
  417       *
  418       * @param      b   the buffer into which the data is read.
  419:      * @exception  EOFException  if this file reaches the end before reading
  420       *               all the bytes.
  421       * @exception  IOException   if an I/O error occurs.
  ...
  435       * @param      off   the start offset of the data.
  436       * @param      len   the number of bytes to read.
  437:      * @exception  EOFException  if this file reaches the end before reading
  438       *               all the bytes.
  439       * @exception  IOException   if an I/O error occurs.
  ...
  444              int count = this.read(b, off + n, len - n);
  445              if (count < 0)
  446:                 throw new EOFException();
  447              n += count;
  448          } while (n < len);
  ...
  457       * This may result from any of a number of conditions; reaching end of
  458       * file before <code>n</code> bytes have been skipped is only one
  459:      * possibility. This method never throws an <code>EOFException</code>.
  460       * The actual number of bytes skipped is returned.  If <code>n</code>
  461       * is negative, no bytes are skipped.
  ...
  660       *
  661       * @return     the <code>boolean</code> value read.
  662:      * @exception  EOFException  if this file has reached the end.
  663       * @exception  IOException   if an I/O error occurs.
  664       */
  ...
  666          int ch = this.read();
  667          if (ch < 0)
  668:             throw new EOFException();
  669          return (ch != 0);
  670      }
  ...
  685       * @return     the next byte of this file as a signed eight-bit
  686       *             <code>byte</code>.
  687:      * @exception  EOFException  if this file has reached the end.
  688       * @exception  IOException   if an I/O error occurs.
  689       */
  ...
  691          int ch = this.read();
  692          if (ch < 0)
  693:             throw new EOFException();
  694          return (byte)(ch);
  695      }
  ...
  705       * @return     the next byte of this file, interpreted as an unsigned
  706       *             eight-bit number.
  707:      * @exception  EOFException  if this file has reached the end.
  708       * @exception  IOException   if an I/O error occurs.
  709       */
  ...
  711          int ch = this.read();
  712          if (ch < 0)
  713:             throw new EOFException();
  714          return ch;
  715      }
  ...
  731       * @return     the next two bytes of this file, interpreted as a signed
  732       *             16-bit number.
  733:      * @exception  EOFException  if this file reaches the end before reading
  734       *               two bytes.
  735       * @exception  IOException   if an I/O error occurs.
  ...
  739          int ch2 = this.read();
  740          if ((ch1 | ch2) < 0)
  741:             throw new EOFException();
  742          return (short)((ch1 << 8) + (ch2 << 0));
  743      }
  ...
  759       * @return     the next two bytes of this file, interpreted as an unsigned
  760       *             16-bit integer.
  761:      * @exception  EOFException  if this file reaches the end before reading
  762       *               two bytes.
  763       * @exception  IOException   if an I/O error occurs.
  ...
  767          int ch2 = this.read();
  768          if ((ch1 | ch2) < 0)
  769:             throw new EOFException();
  770          return (ch1 << 8) + (ch2 << 0);
  771      }
  ...
  787       * @return     the next two bytes of this file, interpreted as a
  788       *                  <code>char</code>.
  789:      * @exception  EOFException  if this file reaches the end before reading
  790       *               two bytes.
  791       * @exception  IOException   if an I/O error occurs.
  ...
  795          int ch2 = this.read();
  796          if ((ch1 | ch2) < 0)
  797:             throw new EOFException();
  798          return (char)((ch1 << 8) + (ch2 << 0));
  799      }
  ...
  815       * @return     the next four bytes of this file, interpreted as an
  816       *             <code>int</code>.
  817:      * @exception  EOFException  if this file reaches the end before reading
  818       *               four bytes.
  819       * @exception  IOException   if an I/O error occurs.
  ...
  825          int ch4 = this.read();
  826          if ((ch1 | ch2 | ch3 | ch4) < 0)
  827:             throw new EOFException();
  828          return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
  829      }
  ...
  853       * @return     the next eight bytes of this file, interpreted as a
  854       *             <code>long</code>.
  855:      * @exception  EOFException  if this file reaches the end before reading
  856       *               eight bytes.
  857       * @exception  IOException   if an I/O error occurs.
  ...
  874       * @return     the next four bytes of this file, interpreted as a
  875       *             <code>float</code>.
  876:      * @exception  EOFException  if this file reaches the end before reading
  877       *             four bytes.
  878       * @exception  IOException   if an I/O error occurs.
  ...
  897       * @return     the next eight bytes of this file, interpreted as a
  898       *             <code>double</code>.
  899:      * @exception  EOFException  if this file reaches the end before reading
  900       *             eight bytes.
  901       * @exception  IOException   if an I/O error occurs.
  ...
  979       *
  980       * @return     a Unicode string.
  981:      * @exception  EOFException            if this file reaches the end before
  982       *               reading all the bytes.
  983       * @exception  IOException             if an I/O error occurs.

C:\Documents and Settings\Me\My Documents\java source code\java\security\DigestInputStream.java:
   27
   28  import java.io.IOException;
   29: import java.io.EOFException;
   30  import java.io.InputStream;
   31  import java.io.FilterInputStream;

C:\Documents and Settings\Me\My Documents\java source code\java\security\DigestOutputStream.java:
   27
   28  import java.io.IOException;
   29: import java.io.EOFException;
   30  import java.io.OutputStream;
   31  import java.io.FilterOutputStream;

C:\Documents and Settings\Me\My Documents\java source code\java\util\zip\GZIPInputStream.java:
   30  import java.io.InputStream;
   31  import java.io.IOException;
   32: import java.io.EOFException;
   33
   34  /**
   ..
  262          int b = in.read();
  263          if (b == -1) {
  264:             throw new EOFException();
  265          }
  266          if (b < -1 || b > 255) {
  ...
  282              int len = in.read(tmpbuf, 0, n < tmpbuf.length ? n : tmpbuf.length);
  283              if (len == -1) {
  284:                 throw new EOFException();
  285              }
  286              n -= len;

C:\Documents and Settings\Me\My Documents\java source code\java\util\zip\InflaterInputStream.java:
   29  import java.io.InputStream;
   30  import java.io.IOException;
   31: import java.io.EOFException;
   32
   33  /**
   ..
  238          len = in.read(buf, 0, buf.length);
  239          if (len == -1) {
  240:             throw new EOFException("Unexpected end of ZLIB input stream");
  241          }
  242          inf.setInput(buf, 0, len);

C:\Documents and Settings\Me\My Documents\java source code\java\util\zip\ZipFile.java:
   29  import java.io.InputStream;
   30  import java.io.IOException;
   31: import java.io.EOFException;
   32  import java.io.File;
   33  import java.nio.charset.Charset;
   ..
  411          protected void fill() throws IOException {
  412              if (eof) {
  413:                 throw new EOFException("Unexpected end of ZLIB input stream");
  414              }
  415              len = in.read(buf, 0, buf.length);

C:\Documents and Settings\Me\My Documents\java source code\java\util\zip\ZipInputStream.java:
   28  import java.io.InputStream;
   29  import java.io.IOException;
   30: import java.io.EOFException;
   31  import java.io.PushbackInputStream;
   32  import java.nio.charset.Charset;
   ..
  276          try {
  277              readFully(tmpbuf, 0, LOCHDR);
  278:         } catch (EOFException e) {
  279              return null;
  280          }
  ...
  424              int n = in.read(b, off, len);
  425              if (n == -1) {
  426:                 throw new EOFException();
  427              }
  428              off += n;

C:\Documents and Settings\Me\My Documents\java source code\javax\imageio\stream\FileCacheImageOutputStream.java:
  156       * Sets the current stream position and resets the bit offset to
  157       * 0.  It is legal to seek past the end of the file; an
  158:      * <code>EOFException</code> will be thrown only if a read is
  159       * performed.  The file length will not be increased until a write
  160       * is performed.

C:\Documents and Settings\Me\My Documents\java source code\javax\imageio\stream\FileImageOutputStream.java:
  138       * Sets the current stream position and resets the bit offset to
  139       * 0.  It is legal to seeking past the end of the file; an
  140:      * <code>EOFException</code> will be thrown only if a read is
  141       * performed.  The file length will not be increased until a write
  142       * is performed.

C:\Documents and Settings\Me\My Documents\java source code\javax\imageio\stream\ImageInputStream.java:
  184       * @return a boolean value from the stream.
  185       *
  186:      * @exception EOFException if the end of the stream is reached.
  187       * @exception IOException if an I/O error occurs.
  188       */
  ...
  202       * @return a signed byte value from the stream.
  203       *
  204:      * @exception EOFException if the end of the stream is reached.
  205       * @exception IOException if an I/O error occurs.
  206       */
  ...
  226       * @return an unsigned byte value from the stream.
  227       *
  228:      * @exception EOFException if the end of the stream is reached.
  229       * @exception IOException if an I/O error occurs.
  230       */
  ...
  241       * @return a signed short value from the stream.
  242       *
  243:      * @exception EOFException if the stream reaches the end before
  244       * reading all the bytes.
  245       * @exception IOException if an I/O error occurs.
  ...
  262       * @return an unsigned short value from the stream, as an int.
  263       *
  264:      * @exception EOFException if the stream reaches the end before
  265       * reading all the bytes.
  266       * @exception IOException if an I/O error occurs.
  ...
  279       * @return an unsigned char value from the stream.
  280       *
  281:      * @exception EOFException if the stream reaches the end before
  282       * reading all the bytes.
  283       * @exception IOException if an I/O error occurs.
  ...
  297       * @return a signed int value from the stream.
  298       *
  299:      * @exception EOFException if the stream reaches the end before
  300       * reading all the bytes.
  301       * @exception IOException if an I/O error occurs.
  ...
  317       * @return an unsigned int value from the stream, as a long.
  318       *
  319:      * @exception EOFException if the stream reaches the end before
  320       * reading all the bytes.
  321       * @exception IOException if an I/O error occurs.
  ...
  335       * @return a signed long value from the stream.
  336       *
  337:      * @exception EOFException if the stream reaches the end before
  338       * reading all the bytes.
  339       * @exception IOException if an I/O error occurs.
  ...
  353       * @return a float value from the stream.
  354       *
  355:      * @exception EOFException if the stream reaches the end before
  356       * reading all the bytes.
  357       * @exception IOException if an I/O error occurs.
  ...
  371       * @return a double value from the stream.
  372       *
  373:      * @exception EOFException if the stream reaches the end before
  374       * reading all the bytes.
  375       * @exception IOException if an I/O error occurs.
  ...
  470       *
  471       * <p> If end of file is encountered at any time during this
  472:      * entire process, then an <code>EOFException</code> is thrown.
  473       *
  474       * <p> After every group has been converted to a character by this
  ...
  489       * @return a String read from the stream.
  490       *
  491:      * @exception  EOFException  if this stream reaches the end
  492       * before reading all the bytes.
  493       * @exception  UTFDataFormatException if the bytes do not represent a
  ...
  500       * Reads <code>len</code> bytes from the stream, and stores them
  501       * into <code>b</code> starting at index <code>off</code>.
  502:      * If the end of the stream is reached, an <code>EOFException</code>
  503       * will be thrown.
  504       *
  ...
  515       * @exception NullPointerException if <code>b</code> is
  516       * <code>null</code>.
  517:      * @exception EOFException if the stream reaches the end before
  518       * reading all the bytes.
  519       * @exception IOException if an I/O error occurs.
  ...
  524       * Reads <code>b.length</code> bytes from the stream, and stores them
  525       * into <code>b</code> starting at index <code>0</code>.
  526:      * If the end of the stream is reached, an <code>EOFException</code>
  527       * will be thrown.
  528       *
  ...
  534       * @exception NullPointerException if <code>b</code> is
  535       * <code>null</code>.
  536:      * @exception EOFException if the stream reaches the end before
  537       * reading all the bytes.
  538       * @exception IOException if an I/O error occurs.
  ...
  545       * stores them into <code>s</code> starting at index
  546       * <code>off</code>.  If the end of the stream is reached, an
  547:      * <code>EOFException</code> will be thrown.
  548       *
  549       * <p> The bit offset within the stream is reset to zero before
  ...
  559       * @exception NullPointerException if <code>s</code> is
  560       * <code>null</code>.
  561:      * @exception EOFException if the stream reaches the end before
  562       * reading all the bytes.
  563       * @exception IOException if an I/O error occurs.
  ...
  570       * stores them into <code>c</code> starting at index
  571       * <code>off</code>.  If the end of the stream is reached, an
  572:      * <code>EOFException</code> will be thrown.
  573       *
  574       * <p> The bit offset within the stream is reset to zero before
  ...
  584       * @exception NullPointerException if <code>c</code> is
  585       * <code>null</code>.
  586:      * @exception EOFException if the stream reaches the end before
  587       * reading all the bytes.
  588       * @exception IOException if an I/O error occurs.
  ...
  595       * stores them into <code>i</code> starting at index
  596       * <code>off</code>.  If the end of the stream is reached, an
  597:      * <code>EOFException</code> will be thrown.
  598       *
  599       * <p> The bit offset within the stream is reset to zero before
  ...
  609       * @exception NullPointerException if <code>i</code> is
  610       * <code>null</code>.
  611:      * @exception EOFException if the stream reaches the end before
  612       * reading all the bytes.
  613       * @exception IOException if an I/O error occurs.
  ...
  620       * stores them into <code>l</code> starting at index
  621       * <code>off</code>.  If the end of the stream is reached, an
  622:      * <code>EOFException</code> will be thrown.
  623       *
  624       * <p> The bit offset within the stream is reset to zero before
  ...
  634       * @exception NullPointerException if <code>l</code> is
  635       * <code>null</code>.
  636:      * @exception EOFException if the stream reaches the end before
  637       * reading all the bytes.
  638       * @exception IOException if an I/O error occurs.
  ...
  645       * and stores them into <code>f</code> starting at
  646       * index <code>off</code>.  If the end of the stream is reached,
  647:      * an <code>EOFException</code> will be thrown.
  648       *
  649       * <p> The bit offset within the stream is reset to zero before
  ...
  659       * @exception NullPointerException if <code>f</code> is
  660       * <code>null</code>.
  661:      * @exception EOFException if the stream reaches the end before
  662       * reading all the bytes.
  663       * @exception IOException if an I/O error occurs.
  ...
  670       * and stores them into <code>d</code> starting at
  671       * index <code>off</code>.  If the end of the stream is reached,
  672:      * an <code>EOFException</code> will be thrown.
  673       *
  674       * <p> The bit offset within the stream is reset to zero before
  ...
  684       * @exception NullPointerException if <code>d</code> is
  685       * <code>null</code>.
  686:      * @exception EOFException if the stream reaches the end before
  687       * reading all the bytes.
  688       * @exception IOException if an I/O error occurs.
  ...
  749       * or <code>1</code>.
  750       *
  751:      * @exception EOFException if the stream reaches the end before
  752       * reading all the bits.
  753       * @exception IOException if an I/O error occurs.
  ...
  783       *
  784       * <p> If the end of the stream is encountered before all the bits
  785:      * have been read, an <code>EOFException</code> is thrown.
  786       *
  787       * @param numBits the number of bits to read, as an <code>int</code>
  ...
  792       * @exception IllegalArgumentException if <code>numBits</code>
  793       * is not between 0 and 64, inclusive.
  794:      * @exception EOFException if the stream reaches the end before
  795       * reading all the bits.
  796       * @exception IOException if an I/O error occurs.
  ...
  851       *
  852       * <p> It is legal to seek past the end of the file; an
  853:      * <code>EOFException</code> will be thrown only if a read is
  854       * performed.
  855       *

C:\Documents and Settings\Me\My Documents\java source code\javax\imageio\stream\ImageInputStreamImpl.java:
   27
   28  import java.io.DataInputStream;
   29: import java.io.EOFException;
   30  import java.io.IOException;
   31  import java.nio.ByteOrder;
   ..
  204          int ch = this.read();
  205          if (ch < 0) {
  206:             throw new EOFException();
  207          }
  208          return (ch != 0);
  ...
  212          int ch = this.read();
  213          if (ch < 0) {
  214:             throw new EOFException();
  215          }
  216          return (byte)ch;
  ...
  220          int ch = this.read();
  221          if (ch < 0) {
  222:             throw new EOFException();
  223          }
  224          return ch;
  ...
  227      public short readShort() throws IOException {
  228          if (read(byteBuf, 0, 2) < 0) {
  229:             throw new EOFException();
  230          }
  231
  ...
  249      public int readInt() throws IOException {
  250          if (read(byteBuf, 0, 4) < 0) {
  251:             throw new EOFException();
  252          }
  253
  ...
  351              int nbytes = read(b, off, len);
  352              if (nbytes == -1) {
  353:                 throw new EOFException();
  354              }
  355              off += nbytes;
  ...
  650          int val = read();
  651          if (val == -1) {
  652:             throw new EOFException();
  653          }
  654
  ...
  685              int val = read();
  686              if (val == -1) {
  687:                 throw new EOFException();
  688              }
  689

204 matches across 26 files