*** empty log message ***
[phpeclipse.git] / net.sourceforge.phpeclipse / src / test / SimpleCharStream.java
1 /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 3.0 */
2 package test;
3
4 /**
5  * An implementation of interface CharStream, where the stream is assumed to
6  * contain only ASCII characters (without unicode processing).
7  */
8
9 public class SimpleCharStream
10 {
11   public static final boolean staticFlag = true;
12   static int bufsize;
13   static int available;
14   static int tokenBegin;
15   static public int bufpos = -1;
16
17   //Added by Matthieu Casanova
18   public static int position = 0;
19
20   static protected int bufline[];
21   static protected int bufcolumn[];
22
23   static protected int column = 0;
24   static protected int line = 1;
25
26   static protected boolean prevCharIsCR = false;
27   static protected boolean prevCharIsLF = false;
28
29   static protected java.io.Reader inputStream;
30
31   static protected char[] buffer;
32   static protected int maxNextCharInd = 0;
33   static protected int inBuf = 0;
34
35   static protected void ExpandBuff(boolean wrapAround)
36   {
37      char[] newbuffer = new char[bufsize + 2048];
38      int newbufline[] = new int[bufsize + 2048];
39      int newbufcolumn[] = new int[bufsize + 2048];
40
41      try
42      {
43         if (wrapAround)
44         {
45            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
46            System.arraycopy(buffer, 0, newbuffer,
47                                              bufsize - tokenBegin, bufpos);
48            buffer = newbuffer;
49
50            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
51            System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
52            bufline = newbufline;
53
54            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
55            System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
56            bufcolumn = newbufcolumn;
57
58            maxNextCharInd = (bufpos += (bufsize - tokenBegin));
59         }
60         else
61         {
62            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
63            buffer = newbuffer;
64
65            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
66            bufline = newbufline;
67
68            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
69            bufcolumn = newbufcolumn;
70
71            maxNextCharInd = (bufpos -= tokenBegin);
72         }
73      }
74      catch (Throwable t)
75      {
76         throw new Error(t.getMessage());
77      }
78
79
80      bufsize += 2048;
81      available = bufsize;
82      tokenBegin = 0;
83   }
84
85   static protected void FillBuff() throws java.io.IOException
86   {
87      if (maxNextCharInd == available)
88      {
89         if (available == bufsize)
90         {
91            if (tokenBegin > 2048)
92            {
93               position += bufpos;
94               bufpos = maxNextCharInd = 0;
95               available = tokenBegin;
96            }
97            else if (tokenBegin < 0) {
98               position += bufpos;
99               bufpos = maxNextCharInd = 0;
100            } else
101               ExpandBuff(false);
102         }
103         else if (available > tokenBegin)
104            available = bufsize;
105         else if ((tokenBegin - available) < 2048)
106            ExpandBuff(true);
107         else
108            available = tokenBegin;
109      }
110
111      int i;
112      try {
113         if ((i = inputStream.read(buffer, maxNextCharInd,
114                                     available - maxNextCharInd)) == -1)
115         {
116            inputStream.close();
117            throw new java.io.IOException();
118         }
119         else {
120            maxNextCharInd += i;
121         }
122         return;
123      }
124      catch(java.io.IOException e) {
125         --bufpos;
126         backup(0);
127         if (tokenBegin == -1)
128            tokenBegin = bufpos;
129         throw e;
130      }
131   }
132
133   static public char BeginToken() throws java.io.IOException
134   {
135      tokenBegin = -1;
136      char c = readChar();
137      tokenBegin = bufpos;
138
139      return c;
140   }
141
142   static protected void UpdateLineColumn(char c)
143   {
144      column++;
145
146      if (prevCharIsLF)
147      {
148         prevCharIsLF = false;
149         line += (column = 1);
150      }
151      else if (prevCharIsCR)
152      {
153         prevCharIsCR = false;
154         if (c == '\n')
155         {
156            prevCharIsLF = true;
157         }
158         else
159            line += (column = 1);
160      }
161
162      switch (c)
163      {
164         case '\r' :
165            prevCharIsCR = true;
166            break;
167         case '\n' :
168            prevCharIsLF = true;
169            break;
170         case '\t' :
171            column--;
172            column += (8 - (column & 07));
173            break;
174         default :
175            break;
176      }
177
178      bufline[bufpos] = line;
179      bufcolumn[bufpos] = column;
180   }
181
182   static public char readChar() throws java.io.IOException
183   {
184      if (inBuf > 0)
185      {
186         --inBuf;
187
188         if (++bufpos == bufsize) {
189            position += bufpos;
190            bufpos = 0;
191         }
192
193         return buffer[bufpos];
194      }
195
196      if (++bufpos >= maxNextCharInd) {
197        FillBuff();
198      }
199
200      char c = buffer[bufpos];
201
202      UpdateLineColumn(c);
203      return (c);
204   }
205
206   /**
207    * @deprecated 
208    * @see #getEndColumn
209    */
210
211   static public int getColumn() {
212      return bufcolumn[bufpos];
213   }
214
215   /**
216    * @deprecated 
217    * @see #getEndLine
218    */
219
220   static public int getLine() {
221      return bufline[bufpos];
222   }
223
224   static public int getEndColumn() {
225      return bufcolumn[bufpos];
226   }
227
228   static public int getEndLine() {
229      return bufline[bufpos];
230   }
231
232   static public int getBeginColumn() {
233      return bufcolumn[tokenBegin];
234   }
235
236   static public int getBeginLine() {
237      return bufline[tokenBegin];
238   }
239
240   static public void backup(int amount) {
241
242     inBuf += amount;
243     if ((bufpos -= amount) < 0)
244        bufpos += bufsize;
245   }
246
247   public SimpleCharStream(java.io.Reader dstream, int startline,
248   int startcolumn, int buffersize)
249   {
250     if (inputStream != null)
251        throw new Error("\n   ERROR: Second call to the constructor of a static SimpleCharStream.  You must\n" +
252        "       either use ReInit() or set the JavaCC option STATIC to false\n" +
253        "       during the generation of this class.");
254     inputStream = dstream;
255     line = startline;
256     column = startcolumn - 1;
257
258     available = bufsize = buffersize;
259     buffer = new char[buffersize];
260     bufline = new int[buffersize];
261     bufcolumn = new int[buffersize];
262   }
263
264   public SimpleCharStream(java.io.Reader dstream, int startline,
265                                                            int startcolumn)
266   {
267      this(dstream, startline, startcolumn, 4096);
268   }
269
270   public SimpleCharStream(java.io.Reader dstream)
271   {
272      this(dstream, 1, 1, 4096);
273   }
274   public void ReInit(java.io.Reader dstream, int startline,
275   int startcolumn, int buffersize)
276   {
277     inputStream = dstream;
278     line = startline;
279     column = startcolumn - 1;
280
281     if (buffer == null || buffersize != buffer.length)
282     {
283       available = bufsize = buffersize;
284       buffer = new char[buffersize];
285       bufline = new int[buffersize];
286       bufcolumn = new int[buffersize];
287     }
288     prevCharIsLF = prevCharIsCR = false;
289     tokenBegin = inBuf = maxNextCharInd = 0;
290     bufpos = -1;
291     position = 0;
292   }
293
294   public void ReInit(java.io.Reader dstream, int startline,
295                                                            int startcolumn)
296   {
297      ReInit(dstream, startline, startcolumn, 4096);
298   }
299
300   public void ReInit(java.io.Reader dstream)
301   {
302      ReInit(dstream, 1, 1, 4096);
303   }
304   public SimpleCharStream(java.io.InputStream dstream, int startline,
305   int startcolumn, int buffersize)
306   {
307      this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
308   }
309
310   public SimpleCharStream(java.io.InputStream dstream, int startline,
311                                                            int startcolumn)
312   {
313      this(dstream, startline, startcolumn, 4096);
314   }
315
316   public SimpleCharStream(java.io.InputStream dstream)
317   {
318      this(dstream, 1, 1, 4096);
319   }
320
321   public void ReInit(java.io.InputStream dstream, int startline,
322                           int startcolumn, int buffersize)
323   {
324      ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
325   }
326
327   public void ReInit(java.io.InputStream dstream)
328   {
329      ReInit(dstream, 1, 1, 4096);
330   }
331   public void ReInit(java.io.InputStream dstream, int startline,
332                                                            int startcolumn)
333   {
334      ReInit(dstream, startline, startcolumn, 4096);
335   }
336   static public String GetImage()
337   {
338      if (bufpos >= tokenBegin)
339         return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
340      else
341         return new String(buffer, tokenBegin, bufsize - tokenBegin) +
342                               new String(buffer, 0, bufpos + 1);
343   }
344
345   static public char[] GetSuffix(int len)
346   {
347      char[] ret = new char[len];
348
349      if ((bufpos + 1) >= len)
350         System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
351      else
352      {
353         System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
354                                                           len - bufpos - 1);
355         System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
356      }
357
358      return ret;
359   }
360
361   static public void Done()
362   {
363      buffer = null;
364      bufline = null;
365      bufcolumn = null;
366   }
367
368   /**
369    * Method to adjust line and column numbers for the start of a token.<BR>
370    */
371   static public void adjustBeginLineColumn(int newLine, int newCol)
372   {
373      int start = tokenBegin;
374      int len;
375
376      if (bufpos >= tokenBegin)
377      {
378         len = bufpos - tokenBegin + inBuf + 1;
379      }
380      else
381      {
382         len = bufsize - tokenBegin + bufpos + 1 + inBuf;
383      }
384
385      int i = 0, j = 0, k = 0;
386      int nextColDiff = 0, columnDiff = 0;
387
388      while (i < len &&
389             bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
390      {
391         bufline[j] = newLine;
392         nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
393         bufcolumn[j] = newCol + columnDiff;
394         columnDiff = nextColDiff;
395         i++;
396      } 
397
398      if (i < len)
399      {
400         bufline[j] = newLine++;
401         bufcolumn[j] = newCol + columnDiff;
402
403         while (i++ < len)
404         {
405            if (bufline[j = start % bufsize] != bufline[++start % bufsize])
406               bufline[j] = newLine++;
407            else
408               bufline[j] = newLine;
409         }
410      }
411
412      line = bufline[j];
413      column = bufcolumn[j];
414   }
415
416   //hack
417   public static int getPosition() {
418     return position + bufpos;
419   }
420 }