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