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