001    package railo.runtime.sql.old;
002    
003    import java.io.IOException;
004    import java.io.InputStream;
005    import java.io.InputStreamReader;
006    import java.io.Reader;
007    
008    public final class SimpleCharStream
009    {
010    
011        private final void ExpandBuff(boolean flag)
012        {
013            char ac[] = new char[bufsize + 2048];
014            int ai[] = new int[bufsize + 2048];
015            int ai1[] = new int[bufsize + 2048];
016            try
017            {
018                if(flag)
019                {
020                    System.arraycopy(buffer, tokenBegin, ac, 0, bufsize - tokenBegin);
021                    System.arraycopy(buffer, 0, ac, bufsize - tokenBegin, bufpos);
022                    buffer = ac;
023                    System.arraycopy(bufline, tokenBegin, ai, 0, bufsize - tokenBegin);
024                    System.arraycopy(bufline, 0, ai, bufsize - tokenBegin, bufpos);
025                    bufline = ai;
026                    System.arraycopy(bufcolumn, tokenBegin, ai1, 0, bufsize - tokenBegin);
027                    System.arraycopy(bufcolumn, 0, ai1, bufsize - tokenBegin, bufpos);
028                    bufcolumn = ai1;
029                    maxNextCharInd = bufpos += bufsize - tokenBegin;
030                } else
031                {
032                    System.arraycopy(buffer, tokenBegin, ac, 0, bufsize - tokenBegin);
033                    buffer = ac;
034                    System.arraycopy(bufline, tokenBegin, ai, 0, bufsize - tokenBegin);
035                    bufline = ai;
036                    System.arraycopy(bufcolumn, tokenBegin, ai1, 0, bufsize - tokenBegin);
037                    bufcolumn = ai1;
038                    maxNextCharInd = bufpos -= tokenBegin;
039                }
040            }
041            catch(Throwable throwable)
042            {
043                throw new Error(throwable.getMessage());
044            }
045            bufsize += 2048;
046            available = bufsize;
047            tokenBegin = 0;
048        }
049    
050        private final void FillBuff()
051            throws IOException
052        {
053            if(maxNextCharInd == available)
054                if(available == bufsize)
055                {
056                    if(tokenBegin > 2048)
057                    {
058                        bufpos = maxNextCharInd = 0;
059                        available = tokenBegin;
060                    } else
061                    if(tokenBegin < 0)
062                        bufpos = maxNextCharInd = 0;
063                    else
064                        ExpandBuff(false);
065                } else
066                if(available > tokenBegin)
067                    available = bufsize;
068                else
069                if(tokenBegin - available < 2048)
070                    ExpandBuff(true);
071                else
072                    available = tokenBegin;
073            int i;
074            try
075            {
076                if((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1)
077                {
078                    inputStream.close();
079                    throw new IOException();
080                } 
081                maxNextCharInd += i;
082                return;
083            }
084            catch(IOException ioexception)
085            {
086                bufpos--;
087                backup(0);
088                if(tokenBegin == -1)
089                    tokenBegin = bufpos;
090                throw ioexception;
091            }
092        }
093    
094        public final char BeginToken()
095            throws IOException
096        {
097            tokenBegin = -1;
098            char c = readChar();
099            tokenBegin = bufpos;
100            return c;
101        }
102    
103        private final void UpdateLineColumn(char c)
104        {
105            column++;
106            if(prevCharIsLF)
107            {
108                prevCharIsLF = false;
109                line += column = 1;
110            } else
111            if(prevCharIsCR)
112            {
113                prevCharIsCR = false;
114                if(c == '\n')
115                    prevCharIsLF = true;
116                else
117                    line += column = 1;
118            }
119            switch(c)
120            {
121            case 13: // '\r'
122                prevCharIsCR = true;
123                break;
124    
125            case 10: // '\n'
126                prevCharIsLF = true;
127                break;
128    
129            case 9: // '\t'
130                column--;
131                column += 8 - (column & 7);
132                break;
133            }
134            bufline[bufpos] = line;
135            bufcolumn[bufpos] = column;
136        }
137    
138        public final char readChar()
139            throws IOException
140        {
141            if(inBuf > 0)
142            {
143                inBuf--;
144                if(++bufpos == bufsize)
145                    bufpos = 0;
146                return buffer[bufpos];
147            }
148            if(++bufpos >= maxNextCharInd)
149                FillBuff();
150            char c = buffer[bufpos];
151            UpdateLineColumn(c);
152            return c;
153        }
154    
155        /**
156         * @deprecated Method getColumn is deprecated
157         */
158    
159        public final int getColumn()
160        {
161            return bufcolumn[bufpos];
162        }
163    
164        /**
165         * @deprecated Method getLine is deprecated
166         */
167    
168        public final int getLine()
169        {
170            return bufline[bufpos];
171        }
172    
173        public final int getEndColumn()
174        {
175            return bufcolumn[bufpos];
176        }
177    
178        public final int getEndLine()
179        {
180            return bufline[bufpos];
181        }
182    
183        public final int getBeginColumn()
184        {
185            return bufcolumn[tokenBegin];
186        }
187    
188        public final int getBeginLine()
189        {
190            return bufline[tokenBegin];
191        }
192    
193        public final void backup(int i)
194        {
195            inBuf += i;
196            if((bufpos -= i) < 0)
197                bufpos += bufsize;
198        }
199    
200        public SimpleCharStream(Reader reader, int i, int j, int k)
201        {
202            bufpos = -1;
203            column = 0;
204            line = 1;
205            prevCharIsCR = false;
206            prevCharIsLF = false;
207            maxNextCharInd = 0;
208            inBuf = 0;
209            inputStream = reader;
210            line = i;
211            column = j - 1;
212            available = bufsize = k;
213            buffer = new char[k];
214            bufline = new int[k];
215            bufcolumn = new int[k];
216        }
217    
218        public SimpleCharStream(Reader reader, int i, int j)
219        {
220            this(reader, i, j, 4096);
221        }
222    
223        public SimpleCharStream(Reader reader)
224        {
225            this(reader, 1, 1, 4096);
226        }
227    
228        public void ReInit(Reader reader, int i, int j, int k)
229        {
230            inputStream = reader;
231            line = i;
232            column = j - 1;
233            if(buffer == null || k != buffer.length)
234            {
235                available = bufsize = k;
236                buffer = new char[k];
237                bufline = new int[k];
238                bufcolumn = new int[k];
239            }
240            prevCharIsLF = prevCharIsCR = false;
241            tokenBegin = inBuf = maxNextCharInd = 0;
242            bufpos = -1;
243        }
244    
245        public void ReInit(Reader reader, int i, int j)
246        {
247            ReInit(reader, i, j, 4096);
248        }
249    
250        public void ReInit(Reader reader)
251        {
252            ReInit(reader, 1, 1, 4096);
253        }
254    
255        public SimpleCharStream(InputStream inputstream, int i, int j, int k)
256        {
257            this(( (new InputStreamReader(inputstream))), i, j, 4096);
258        }
259    
260        public SimpleCharStream(InputStream inputstream, int i, int j)
261        {
262            this(inputstream, i, j, 4096);
263        }
264    
265        public SimpleCharStream(InputStream inputstream)
266        {
267            this(inputstream, 1, 1, 4096);
268        }
269    
270        public void ReInit(InputStream inputstream, int i, int j, int k)
271        {
272            ReInit(( (new InputStreamReader(inputstream))), i, j, 4096);
273        }
274    
275        public void ReInit(InputStream inputstream)
276        {
277            ReInit(inputstream, 1, 1, 4096);
278        }
279    
280        public void ReInit(InputStream inputstream, int i, int j)
281        {
282            ReInit(inputstream, i, j, 4096);
283        }
284    
285        public final String GetImage()
286        {
287            if(bufpos >= tokenBegin)
288                return new String(buffer, tokenBegin, (bufpos - tokenBegin) + 1);
289            return new String(buffer, tokenBegin, bufsize - tokenBegin) + new String(buffer, 0, bufpos + 1);
290        }
291    
292        public final char[] GetSuffix(int i)
293        {
294            char ac[] = new char[i];
295            if(bufpos + 1 >= i)
296            {
297                System.arraycopy(buffer, (bufpos - i) + 1, ac, 0, i);
298            } else
299            {
300                System.arraycopy(buffer, bufsize - (i - bufpos - 1), ac, 0, i - bufpos - 1);
301                System.arraycopy(buffer, 0, ac, i - bufpos - 1, bufpos + 1);
302            }
303            return ac;
304        }
305    
306        public void Done()
307        {
308            buffer = null;
309            bufline = null;
310            bufcolumn = null;
311        }
312    
313        public void adjustBeginLineColumn(int i, int j)
314        {
315            int k = tokenBegin;
316            int l;
317            if(bufpos >= tokenBegin)
318                l = (bufpos - tokenBegin) + inBuf + 1;
319            else
320                l = (bufsize - tokenBegin) + bufpos + 1 + inBuf;
321            int i1 = 0;
322            int j1 = 0;
323            boolean flag = false;
324            boolean flag1 = false;
325            int i2 = 0;
326            int k1;
327            for(; i1 < l && bufline[j1 = k % bufsize] == bufline[k1 = ++k % bufsize]; i1++)
328            {
329                bufline[j1] = i;
330                int l1 = (i2 + bufcolumn[k1]) - bufcolumn[j1];
331                bufcolumn[j1] = j + i2;
332                i2 = l1;
333            }
334    
335            if(i1 < l)
336            {
337                bufline[j1] = i++;
338                bufcolumn[j1] = j + i2;
339                while(i1++ < l) 
340                    if(bufline[j1 = k % bufsize] != bufline[++k % bufsize])
341                        bufline[j1] = i++;
342                    else
343                        bufline[j1] = i;
344            }
345            line = bufline[j1];
346            column = bufcolumn[j1];
347        }
348    
349        public static final boolean staticFlag = false;
350        int bufsize;
351        int available;
352        int tokenBegin;
353        public int bufpos;
354        private int bufline[];
355        private int bufcolumn[];
356        private int column;
357        private int line;
358        private boolean prevCharIsCR;
359        private boolean prevCharIsLF;
360        private Reader inputStream;
361        private char buffer[];
362        private int maxNextCharInd;
363        private int inBuf;
364    }