CRLF Terminated Reader : Reader « File « Java Tutorial

 * Licensed to the Apache Software Foundation (ASF) under one   *
 * or more contributor license agreements.  See the NOTICE file *
 * distributed with this work for additional information        *
 * regarding copyright ownership.  The ASF licenses this file   *
 * to you under the Apache License, Version 2.0 (the            *
 * "License"); you may not use this file except in compliance   *
 * with the License.  You may obtain a copy of the License at   *
 *                                                              *
 *                 *
 *                                                              *
 * Unless required by applicable law or agreed to in writing,   *
 * software distributed under the License is distributed on an  *
 * KIND, either express or implied.  See the License for the    *
 * specific language governing permissions and limitations      *
 * under the License.                                           *


 * A Reader for use with SMTP or other protocols in which lines
 * must end with CRLF.  Extends Reader and overrides its 
 * readLine() method.  The Reader readLine() method cannot
 * serve for SMTP because it ends lines with either CR or LF alone. 
public class CRLFTerminatedReader extends Reader {

    public class TerminationException extends IOException {
        private int where;
        public TerminationException(int where) {
            this.where = where;

        public TerminationException(String s, int where) {
            this.where = where;

        public int position() {
            return where;

    public class LineLengthExceededException extends IOException {
        public LineLengthExceededException(String s) {

     * Constructs this CRLFTerminatedReader.
     * @param in an InputStream
     * @param charsetName the String name of a supported charset.  
     * "ASCII" is common here.
     * @throws UnsupportedEncodingException if the named charset
     * is not supported
    InputStream in;

    public CRLFTerminatedReader(InputStream in) { = in;

    public CRLFTerminatedReader(InputStream in, String enc) throws UnsupportedEncodingException {

    private StringBuffer lineBuffer = new StringBuffer();
    private final int
            EOF = -1,
            CR  = 13,
            LF  = 10;

    private int tainted = -1;

     * Read a line of text which is terminated by CRLF.  The concluding
     * CRLF characters are not returned with the String, but if either CR
     * or LF appears in the text in any other sequence it is returned
     * in the String like any other character.  Some characters at the 
     * end of the stream may be lost if they are in a "line" not
     * terminated by CRLF.
     * @return either a String containing the contents of a 
     * line which must end with CRLF, or null if the end of the 
     * stream has been reached, possibly discarding some characters 
     * in a line not terminated with CRLF. 
     * @throws IOException if an I/O error occurs.
    public String readLine() throws IOException{

        //start with the StringBuffer empty
        lineBuffer.delete(0, lineBuffer.length());

        /* This boolean tells which state we are in,
         * depending upon whether or not we got a CR
         * in the preceding read().
        boolean cr_just_received = false;

        // Until we add support for specifying a maximum line lenth as
        // a Service Extension, limit lines to 2K, which is twice what
        // RFC 2821 requires.
        while (lineBuffer.length() <= 2048) {
            int inChar = read();

            if (!cr_just_received){
                //the most common case, somewhere before the end of a line
                switch (inChar){
                    case CR  :  cr_just_received = true;
                    case EOF :  return null;   // premature EOF -- discards data(?)
                    case LF  :  //the normal ending of a line
                        if (tainted == -1) tainted = lineBuffer.length();
                        // intentional fall-through
                    default  :  lineBuffer.append((char)inChar);
                // CR has been received, we may be at end of line
                switch (inChar){
                    case LF  :  // LF without a preceding CR
                        if (tainted != -1) {
                            int pos = tainted;
                            tainted = -1;
                            throw new TerminationException("\"bare\" CR or LF in data stream", pos);
                        return lineBuffer.toString();
                    case EOF :  return null;   // premature EOF -- discards data(?)
                    case CR  :  //we got two (or more) CRs in a row
                        if (tainted == -1) tainted = lineBuffer.length();
                    default  :  //we got some other character following a CR
                        if (tainted == -1) tainted = lineBuffer.length();
                        cr_just_received = false;
        throw new LineLengthExceededException("Exceeded maximum line length");
    }//method readLine()

    public int read() throws IOException {

    public boolean ready() throws IOException {
    return in.available() > 0;

    public int read(char cbuf[], int  off, int  len) throws IOException {
    byte [] temp = new byte[len];
    int result =, 0, len);
    for (int i=0;i<result;i++) cbuf[i] = (char) temp[i];
    return result;

    public void close() throws IOException {

11.29.1.Read and return the entire contents of the supplied Reader. This method always closes the reader when finished reading.
11.29.2.Read from Reader and write to Writer until there is no more input from reader.
11.29.3.Reads characters available from the Reader and returns these characters as a String object.
11.29.4.Transfers all characters that can be read from one Reader to another Reader
11.29.5.Writes all characters from a Reader to a file using the default character encoding.
11.29.6.convert Reader to InputStream
11.29.7.Compare the contents of two Readers to determine if they are equal or not.
11.29.8.An InputStream backed by a Reader
11.29.9.Reader: Reading Text (Characters)
11.29.10.UTF8 Reader
11.29.11.CRLF Terminated Reader