/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.xml.internal.dtdparser;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import java.io.CharConversionException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.io.UnsupportedEncodingException;

import java.net.URL;

import java.util.Locale;

/**

 * This is how the parser talks to its input entities, of all kinds.

 * The entities are in a stack.

 * <P> For internal entities, the character arrays are referenced here,

 * and read from as needed (they're read-only).  External entities have

 * mutable buffers, that are read into as needed.

 * <P> <em>Note:</em> This maps CRLF (and CR) to LF without regard for

 * whether it's in an external (parsed) entity or not.  The XML 1.0 spec

 * is inconsistent in explaining EOL handling; this is the sensible way.

 *

 * @author David Brownell

 * @author Janet Koenig

 * @version 1.4 00/08/05

 */

public class InputEntity {

    private int start, finish;

    private char buf [];

    private int lineNumber = 1;

    private boolean returnedFirstHalf = false;

    private boolean maybeInCRLF = false;

    // name of entity (never main document or unnamed DTD PE)

    private String name;

    private InputEntity next;

    // for system and public IDs in diagnostics

    private InputSource input;

    // this is a buffer; some buffers can be replenished.

    private Reader reader;

    private boolean isClosed;

    private DTDEventListener errHandler;

    private Locale locale;

    private StringBuffer rememberedText;

    private int startRemember;

    // record if this is a PE, so endParsedEntity won't be called

    private boolean isPE;

    // InputStreamReader throws an internal per-read exception, so

    // we minimize reads.  We also add a byte to compensate for the

    // "ungetc" byte we keep, so that our downstream reads are as

    // nicely sized as we can make them.

    final private static int BUFSIZ = 8 * 1024 + 1;

    final private static char newline [] = {'\n'};

    public static InputEntity getInputEntity(DTDEventListener h, Locale l) {

        InputEntity retval = new InputEntity();

        retval.errHandler = h;

        retval.locale = l;

        return retval;

    }

    private InputEntity() {

    }

    //

    // predicate:  return true iff this is an internal entity reader,

    // and so may safely be "popped" as needed.  external entities have

    // syntax to uphold; internal parameter entities have at most validity

    // constraints to monitor.  also, only external entities get decent

    // location diagnostics.

    //

    public boolean isInternal() {

        return reader == null;

    }

    //

    // predicate:  return true iff this is the toplevel document

    //

    public boolean isDocument() {

        return next == null;

    }

    //

    // predicate:  return true iff this is a PE expansion (so that

    // LexicalEventListner.endParsedEntity won't be called)

    //

    public boolean isParameterEntity() {

        return isPE;

    }

    //

    // return name of current entity

    //

    public String getName() {

        return name;

    }

    //

    // use this for an external parsed entity

    //

    public void init(InputSource in, String name, InputEntity stack,

                     boolean isPE)

            throws IOException, SAXException {

        input = in;

        this.isPE = isPE;

        reader = in.getCharacterStream();

        if (reader == null) {

            InputStream bytes = in.getByteStream();

            if (bytes == null)

            else if (in.getEncoding() != null)

            else

                reader = XmlReader.createReader(in.getByteStream());

        }

        next = stack;

        buf = new char[BUFSIZ];

        this.name = name;

        checkRecursion(stack);

    }

    //

    // use this for an internal parsed entity; buffer is readonly

    //

    public void init(char b [], String name, InputEntity stack, boolean isPE)

            throws SAXException {

        next = stack;

        finish = b.length;

        this.name = name;

        this.isPE = isPE;

        checkRecursion(stack);

    }

    private void checkRecursion(InputEntity stack)

            throws SAXException {

        if (stack == null)

            return;

        for (stack = stack.next; stack != null; stack = stack.next) {

            if (stack.name != null && stack.name.equals(name))

                fatal("P-069", new Object[]{name});

        }

    }

    public InputEntity pop() throws IOException {

        // caller has ensured there's nothing left to read

        close();

        return next;

    }

    /**

     * returns true iff there's no more data to consume ...

     */

    public boolean isEOF() throws IOException, SAXException {

        // called to ensure WF-ness of included entities and to pop

        // input entities appropriately ... EOF is not always legal.

        if (start >= finish) {

            fillbuf();

            return start >= finish;

        } else

            return false;

    }

    /**

     * Returns the name of the encoding in use, else null; the name

     * returned is in as standard a form as we can get.

     */

    public String getEncoding() {

        if (reader == null)

            return null;

        if (reader instanceof XmlReader)

            return ((XmlReader) reader).getEncoding();

        // XXX prefer a java2std() call to normalize names...

        if (reader instanceof InputStreamReader)

            return ((InputStreamReader) reader).getEncoding();

        return null;

    }

    /**

     * returns the next name char, or NUL ... faster than getc(),

     * and the common "name or nmtoken must be next" case won't

     * need ungetc().

     */

    public char getNameChar() throws IOException, SAXException {

        if (finish <= start)

            fillbuf();

        if (finish > start) {

            char c = buf[start++];

            if (XmlChars.isNameChar(c))

                return c;

            start--;

        }

        return 0;

    }

    /**

     * gets the next Java character -- might be part of an XML

     * text character represented by a surrogate pair, or be

     * the end of the entity.

     */

    public char getc() throws IOException, SAXException {

        if (finish <= start)

            fillbuf();

        if (finish > start) {

            char c = buf[start++];

            // [2] Char ::= #x0009 | #x000A | #x000D

            //            | [#x0020-#xD7FF]

            //            | [#xE000-#xFFFD]

            // plus surrogate _pairs_ representing [#x10000-#x10ffff]

            if (returnedFirstHalf) {

                if (c >= 0xdc00 && c <= 0xdfff) {

                    returnedFirstHalf = false;

                    return c;

                } else

                    fatal("P-070", new Object[]{Integer.toHexString(c)});

            }

            if ((c >= 0x0020 && c <= 0xD7FF)

                    || c == 0x0009

                    // no surrogates!

                    || (c >= 0xE000 && c <= 0xFFFD))

                return c;

            //

            // CRLF and CR are both line ends; map both to LF, and

            // keep line count correct.

            //

            else if (c == '\r' && !isInternal()) {

                maybeInCRLF = true;

                c = getc();

                if (c != '\n')

                    ungetc();

                maybeInCRLF = false;

                lineNumber++;

                return '\n';

            } else if (c == '\n' || c == '\r') { // LF, or 2nd char in CRLF

                if (!isInternal() && !maybeInCRLF)

                    lineNumber++;

                return c;

            }

            // surrogates...

            if (c >= 0xd800 && c < 0xdc00) {

                returnedFirstHalf = true;

                return c;

            }

            fatal("P-071", new Object[]{Integer.toHexString(c)});

        }

        throw new EndOfInputException();

    }

    /**

     * lookahead one character

     */

    public boolean peekc(char c) throws IOException, SAXException {

        if (finish <= start)

            fillbuf();

        if (finish > start) {

            if (buf[start] == c) {

                start++;

                return true;

            } else

                return false;

        }

        return false;

    }

    /**

     * two character pushback is guaranteed

     */

    public void ungetc() {

        if (start == 0)

            throw new InternalError("ungetc");

        start--;

        if (buf[start] == '\n' || buf[start] == '\r') {

            if (!isInternal())

                lineNumber--;

        } else if (returnedFirstHalf)

            returnedFirstHalf = false;

    }

    /**

     * optional grammatical whitespace (discarded)

     */

    public boolean maybeWhitespace()

            throws IOException, SAXException {

        char c;

        boolean isSpace = false;

        boolean sawCR = false;

        // [3] S ::= #20 | #09 | #0D | #0A

        for (; ;) {

            if (finish <= start)

                fillbuf();

            if (finish <= start)

                return isSpace;

            c = buf[start++];

            if (c == 0x20 || c == 0x09 || c == '\n' || c == '\r') {

                isSpace = true;

                //

                // CR, LF are line endings ... CLRF is one, not two!

                //

                if ((c == '\n' || c == '\r') && !isInternal()) {

                    if (!(c == '\n' && sawCR)) {

                        lineNumber++;

                        sawCR = false;

                    }

                    if (c == '\r')

                        sawCR = true;

                }

            } else {

                start--;

                return isSpace;

            }

        }

    }

    /**

     * normal content; whitespace in markup may be handled

     * specially if the parser uses the content model.

     * <P> content terminates with markup delimiter characters,

     * namely ampersand (&) and left angle bracket (<).

     * <P> the document handler's characters() method is called

     * on all the content found

     */

    public boolean parsedContent(DTDEventListener docHandler

                                 /*ElementValidator validator*/)

            throws IOException, SAXException {

        // [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)

        int first;        // first char to return

        int last;        // last char to return

        boolean sawContent;    // sent any chars?

        char c;

        // deliver right out of the buffer, until delimiter, EOF,

        // or error, refilling as we go

        for (first = last = start, sawContent = false; ; last++) {

            // buffer empty?

            if (last >= finish) {

                if (last > first) {

//            validator.text ();

                    docHandler.characters(buf, first, last - first);

                    sawContent = true;

                    start = last;

                }

                if (isEOF())    // calls fillbuf

                    return sawContent;

                first = start;

                last = first - 1;    // incremented in loop

                continue;

            }

            c = buf[last];

            //

            // pass most chars through ASAP; this inlines the code of

            // [2] !XmlChars.isChar(c) leaving only characters needing

            // special treatment ... line ends, surrogates, and:

            //    0x0026 == '&'

            //    0x003C == '<'

            //    0x005D == ']'

            // Comparisons ordered for speed on 'typical' text

            //

            if ((c > 0x005D && c <= 0xD7FF)    // a-z and more

                    || (c < 0x0026 && c >= 0x0020)    // space & punct

                    || (c > 0x003C && c < 0x005D)    // A-Z & punct

                    || (c > 0x0026 && c < 0x003C)    // 0-9 & punct

                    || c == 0x0009

                    || (c >= 0xE000 && c <= 0xFFFD)

            )

                continue;

            // terminate on markup delimiters

            if (c == '<' || c == '&')

                break;

            // count lines

            if (c == '\n') {

                if (!isInternal())

                    lineNumber++;

                continue;

            }

            // External entities get CR, CRLF --> LF mapping

            // Internal ones got it already, and we can't repeat

            // else we break char ref handling!!

            if (c == '\r') {

                if (isInternal())

                    continue;

                docHandler.characters(buf, first, last - first);

                docHandler.characters(newline, 0, 1);

                sawContent = true;

                lineNumber++;

                if (finish > (last + 1)) {

                    if (buf[last + 1] == '\n')

                        last++;

                } else {    // CR at end of buffer

// XXX case not yet handled:  CRLF here will look like two lines

                }

                first = start = last + 1;

                continue;

            }

            // ']]>' is a WF error -- must fail if we see it

            if (c == ']') {

                switch (finish - last) {

                // for suspicious end-of-buffer cases, get more data

                // into the buffer to rule out this sequence.

                case 2:

                    if (buf[last + 1] != ']')

                        continue;

                    // FALLTHROUGH

                case 1:

                    if (reader == null || isClosed)

                        continue;

                    if (last == first)

                        throw new InternalError("fillbuf");

                    last--;

                    if (last > first) {

//            validator.text ();

                        docHandler.characters(buf, first, last - first);

                        sawContent = true;

                        start = last;

                    }

                    fillbuf();

                    first = last = start;

                    continue;

                    // otherwise any "]]>" would be buffered, and we can

                    // see right away if that's what we have

                default:

                    if (buf[last + 1] == ']' && buf[last + 2] == '>')

                        fatal("P-072", null);

                    continue;

                }

            }

            // correctly paired surrogates are OK

            if (c >= 0xd800 && c <= 0xdfff) {

                if ((last + 1) >= finish) {

                    if (last > first) {

//            validator.text ();

                        docHandler.characters(buf, first, last - first);

                        sawContent = true;

                        start = last + 1;

                    }

                    if (isEOF()) {    // calls fillbuf

                        fatal("P-081",

                                new Object[]{Integer.toHexString(c)});

                    }

                    first = start;

                    last = first;