simplecharstream.java

反ajax原代码

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   SimpleCharStream.java

package com.laoer.bbscs.lucene.html;

import java.io.*;

public class SimpleCharStream
{

    public static final boolean staticFlag = false;
    int bufsize;
    int available;
    int tokenBegin;
    public int bufpos;
    protected int bufline[];
    protected int bufcolumn[];
    protected int column;
    protected int line;
    protected boolean prevCharIsCR;
    protected boolean prevCharIsLF;
    protected Reader inputStream;
    protected char buffer[];
    protected int maxNextCharInd;
    protected int inBuf;

    protected void ExpandBuff(boolean wrapAround)
    {
        char newbuffer[] = new char[bufsize + 2048];
        int newbufline[] = new int[bufsize + 2048];
        int newbufcolumn[] = new int[bufsize + 2048];
        try
        {
            if(wrapAround)
            {
                System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
                System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
                buffer = newbuffer;
                System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
                System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
                bufline = newbufline;
                System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
                System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
                bufcolumn = newbufcolumn;
                maxNextCharInd = bufpos += bufsize - tokenBegin;
            } else
            {
                System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
                buffer = newbuffer;
                System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
                bufline = newbufline;
                System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
                bufcolumn = newbufcolumn;
                maxNextCharInd = bufpos -= tokenBegin;
            }
        }
        catch(Throwable t)
        {
            throw new Error(t.getMessage());
        }
        bufsize += 2048;
        available = bufsize;
        tokenBegin = 0;
    }

    protected void FillBuff()
        throws IOException
    {
        if(maxNextCharInd == available)
            if(available == bufsize)
            {
                if(tokenBegin > 2048)
                {
                    bufpos = maxNextCharInd = 0;
                    available = tokenBegin;
                } else
                if(tokenBegin < 0)
                    bufpos = maxNextCharInd = 0;
                else
                    ExpandBuff(false);
            } else
            if(available > tokenBegin)
                available = bufsize;
            else
            if(tokenBegin - available < 2048)
                ExpandBuff(true);
            else
                available = tokenBegin;
        int i;
        try
        {
            if((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1)
            {
                inputStream.close();
                throw new IOException();
            } else
            {
                maxNextCharInd += i;
                return;
            }
        }
        catch(IOException e)
        {
            bufpos--;
            backup(0);
            if(tokenBegin == -1)
                tokenBegin = bufpos;
            throw e;
        }
    }

    public char BeginToken()
        throws IOException
    {
        tokenBegin = -1;
        char c = readChar();
        tokenBegin = bufpos;
        return c;
    }

    protected void UpdateLineColumn(char c)
    {
        column++;
        if(prevCharIsLF)
        {
            prevCharIsLF = false;
            line += column = 1;
        } else
        if(prevCharIsCR)
        {
            prevCharIsCR = false;
            if(c == '\n')
                prevCharIsLF = true;
            else
                line += column = 1;
        }
        switch(c)
        {
        case 13: // '\r'
            prevCharIsCR = true;
            break;

        case 10: // '\n'
            prevCharIsLF = true;
            break;

        case 9: // '\t'
            column--;
            column += 8 - (column & 0x7);
            break;
        }
        bufline[bufpos] = line;
        bufcolumn[bufpos] = column;
    }

    public char readChar()
        throws IOException
    {
        if(inBuf > 0)
        {
            inBuf--;
            if(++bufpos == bufsize)
                bufpos = 0;
            return buffer[bufpos];
        }
        if(++bufpos >= maxNextCharInd)
            FillBuff();
        char c = buffer[bufpos];
        UpdateLineColumn(c);
        return c;
    }

    public int getColumn()
    {
        return bufcolumn[bufpos];
    }

    public int getLine()
    {
        return bufline[bufpos];
    }

    public int getEndColumn()
    {
        return bufcolumn[bufpos];
    }

    public int getEndLine()
    {
        return bufline[bufpos];
    }

    public int getBeginColumn()
    {
        return bufcolumn[tokenBegin];
    }

    public int getBeginLine()
    {
        return bufline[tokenBegin];
    }

    public void backup(int amount)
    {
        inBuf += amount;
        if((bufpos -= amount) < 0)
            bufpos += bufsize;
    }

    public SimpleCharStream(Reader dstream, int startline, int startcolumn, int buffersize)
    {
        bufpos = -1;
        column = 0;
        line = 1;
        prevCharIsCR = false;
        prevCharIsLF = false;
        maxNextCharInd = 0;
        inBuf = 0;
        inputStream = dstream;
        line = startline;
        column = startcolumn - 1;
        available = bufsize = buffersize;
        buffer = new char[buffersize];
        bufline = new int[buffersize];
        bufcolumn = new int[buffersize];
    }

    public SimpleCharStream(Reader dstream, int startline, int startcolumn)
    {
        this(dstream, startline, startcolumn, 4096);
    }

    public SimpleCharStream(Reader dstream)
    {
        this(dstream, 1, 1, 4096);
    }

    public void ReInit(Reader dstream, int startline, int startcolumn, int buffersize)
    {
        inputStream = dstream;
        line = startline;
        column = startcolumn - 1;
        if(buffer == null || buffersize != buffer.length)
        {
            available = bufsize = buffersize;
            buffer = new char[buffersize];
            bufline = new int[buffersize];
            bufcolumn = new int[buffersize];
        }
        prevCharIsLF = prevCharIsCR = false;
        tokenBegin = inBuf = maxNextCharInd = 0;
        bufpos = -1;
    }

    public void ReInit(Reader dstream, int startline, int startcolumn)
    {
        ReInit(dstream, startline, startcolumn, 4096);
    }

    public void ReInit(Reader dstream)
    {
        ReInit(dstream, 1, 1, 4096);
    }

    public SimpleCharStream(InputStream dstream, int startline, int startcolumn, int buffersize)
    {
        this(((Reader) (new InputStreamReader(dstream))), startline, startcolumn, 4096);
    }

    public SimpleCharStream(InputStream dstream, int startline, int startcolumn)
    {
        this(dstream, startline, startcolumn, 4096);
    }

    public SimpleCharStream(InputStream dstream)
    {
        this(dstream, 1, 1, 4096);
    }

    public void ReInit(InputStream dstream, int startline, int startcolumn, int buffersize)
    {
        ReInit(((Reader) (new InputStreamReader(dstream))), startline, startcolumn, 4096);
    }

    public void ReInit(InputStream dstream)
    {
        ReInit(dstream, 1, 1, 4096);
    }

    public void ReInit(InputStream dstream, int startline, int startcolumn)
    {
        ReInit(dstream, startline, startcolumn, 4096);
    }

    public String GetImage()
    {
        if(bufpos >= tokenBegin)
            return new String(buffer, tokenBegin, (bufpos - tokenBegin) + 1);
        else
            return new String(buffer, tokenBegin, bufsize - tokenBegin) + new String(buffer, 0, bufpos + 1);
    }

    public char[] GetSuffix(int len)
    {
        char ret[] = new char[len];
        if(bufpos + 1 >= len)
        {
            System.arraycopy(buffer, (bufpos - len) + 1, ret, 0, len);
        } else
        {
            System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, len - bufpos - 1);
            System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
        }
        return ret;
    }

    public void Done()
    {
        buffer = null;
        bufline = null;
        bufcolumn = null;
    }

    public void adjustBeginLineColumn(int newLine, int newCol)
    {
        int start = tokenBegin;
        int len;
        if(bufpos >= tokenBegin)
            len = (bufpos - tokenBegin) + inBuf + 1;
        else
            len = (bufsize - tokenBegin) + bufpos + 1 + inBuf;
        int i = 0;
        int j = 0;
        int k = 0;
        int nextColDiff = 0;
        int columnDiff = 0;
        for(; i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize]; i++)
        {
            bufline[j] = newLine;
            nextColDiff = (columnDiff + bufcolumn[k]) - bufcolumn[j];
            bufcolumn[j] = newCol + columnDiff;
            columnDiff = nextColDiff;
        }

        if(i < len)
        {
            bufline[j] = newLine++;
            bufcolumn[j] = newCol + columnDiff;
            while(i++ < len) 
                if(bufline[j = start % bufsize] != bufline[++start % bufsize])
                    bufline[j] = newLine++;
                else
                    bufline[j] = newLine;
        }
        line = bufline[j];
        column = bufcolumn[j];
    }
}