]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.spreadsheet.graph/src/org/simantics/spreadsheet/graph/parser/SimpleCharStream.java
Improved exception message
[simantics/platform.git] / bundles / org.simantics.spreadsheet.graph / src / org / simantics / spreadsheet / graph / parser / SimpleCharStream.java
1 /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 5.0 */
2 /* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
3 package org.simantics.spreadsheet.graph.parser;
4
5 /**
6  * An implementation of interface CharStream, where the stream is assumed to
7  * contain only ASCII characters (without unicode processing).
8  */
9
10 public class SimpleCharStream
11 {
12 /** Whether parser is static. */
13   public static final boolean staticFlag = false;
14   int bufsize;
15   int available;
16   int tokenBegin;
17 /** Position in buffer. */
18   public int bufpos = -1;
19   protected int bufline[];
20   protected int bufcolumn[];
21
22   protected int column = 0;
23   protected int line = 1;
24
25   protected boolean prevCharIsCR = false;
26   protected boolean prevCharIsLF = false;
27
28   protected java.io.Reader inputStream;
29
30   protected char[] buffer;
31   protected int maxNextCharInd = 0;
32   protected int inBuf = 0;
33   protected int tabSize = 8;
34
35   protected void setTabSize(int i) { tabSize = i; }
36   protected int getTabSize(int i) { return tabSize; }
37
38
39   protected void ExpandBuff(boolean wrapAround)
40   {
41     char[] newbuffer = new char[bufsize + 2048];
42     int newbufline[] = new int[bufsize + 2048];
43     int newbufcolumn[] = new int[bufsize + 2048];
44
45     try
46     {
47       if (wrapAround)
48       {
49         System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
50         System.arraycopy(buffer, 0, newbuffer, 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   protected void FillBuff() throws java.io.IOException
89   {
90     if (maxNextCharInd == available)
91     {
92       if (available == bufsize)
93       {
94         if (tokenBegin > 2048)
95         {
96           bufpos = maxNextCharInd = 0;
97           available = tokenBegin;
98         }
99         else if (tokenBegin < 0)
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, available - maxNextCharInd)) == -1)
115       {
116         inputStream.close();
117         throw new java.io.IOException();
118       }
119       else
120         maxNextCharInd += i;
121       return;
122     }
123     catch(java.io.IOException e) {
124       --bufpos;
125       backup(0);
126       if (tokenBegin == -1)
127         tokenBegin = bufpos;
128       throw e;
129     }
130   }
131
132 /** Start. */
133   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   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 += (tabSize - (column % tabSize));
173         break;
174       default :
175         break;
176     }
177
178     bufline[bufpos] = line;
179     bufcolumn[bufpos] = column;
180   }
181
182 /** Read a character. */
183   public char readChar() throws java.io.IOException
184   {
185     if (inBuf > 0)
186     {
187       --inBuf;
188
189       if (++bufpos == bufsize)
190         bufpos = 0;
191
192       return buffer[bufpos];
193     }
194
195     if (++bufpos >= maxNextCharInd)
196       FillBuff();
197
198     char c = buffer[bufpos];
199
200     UpdateLineColumn(c);
201     return c;
202   }
203
204   @Deprecated
205   /**
206    * @deprecated
207    * @see #getEndColumn
208    */
209
210   public int getColumn() {
211     return bufcolumn[bufpos];
212   }
213
214   @Deprecated
215   /**
216    * @deprecated
217    * @see #getEndLine
218    */
219
220   public int getLine() {
221     return bufline[bufpos];
222   }
223
224   /** Get token end column number. */
225   public int getEndColumn() {
226     return bufcolumn[bufpos];
227   }
228
229   /** Get token end line number. */
230   public int getEndLine() {
231      return bufline[bufpos];
232   }
233
234   /** Get token beginning column number. */
235   public int getBeginColumn() {
236     return bufcolumn[tokenBegin];
237   }
238
239   /** Get token beginning line number. */
240   public int getBeginLine() {
241     return bufline[tokenBegin];
242   }
243
244 /** Backup a number of characters. */
245   public void backup(int amount) {
246
247     inBuf += amount;
248     if ((bufpos -= amount) < 0)
249       bufpos += bufsize;
250   }
251
252   /** Constructor. */
253   public SimpleCharStream(java.io.Reader dstream, int startline,
254   int startcolumn, int buffersize)
255   {
256     inputStream = dstream;
257     line = startline;
258     column = startcolumn - 1;
259
260     available = bufsize = buffersize;
261     buffer = new char[buffersize];
262     bufline = new int[buffersize];
263     bufcolumn = new int[buffersize];
264   }
265
266   /** Constructor. */
267   public SimpleCharStream(java.io.Reader dstream, int startline,
268                           int startcolumn)
269   {
270     this(dstream, startline, startcolumn, 4096);
271   }
272
273   /** Constructor. */
274   public SimpleCharStream(java.io.Reader dstream)
275   {
276     this(dstream, 1, 1, 4096);
277   }
278
279   /** Reinitialise. */
280   public void ReInit(java.io.Reader dstream, int startline,
281   int startcolumn, int buffersize)
282   {
283     inputStream = dstream;
284     line = startline;
285     column = startcolumn - 1;
286
287     if (buffer == null || buffersize != buffer.length)
288     {
289       available = bufsize = buffersize;
290       buffer = new char[buffersize];
291       bufline = new int[buffersize];
292       bufcolumn = new int[buffersize];
293     }
294     prevCharIsLF = prevCharIsCR = false;
295     tokenBegin = inBuf = maxNextCharInd = 0;
296     bufpos = -1;
297   }
298
299   /** Reinitialise. */
300   public void ReInit(java.io.Reader dstream, int startline,
301                      int startcolumn)
302   {
303     ReInit(dstream, startline, startcolumn, 4096);
304   }
305
306   /** Reinitialise. */
307   public void ReInit(java.io.Reader dstream)
308   {
309     ReInit(dstream, 1, 1, 4096);
310   }
311   /** Constructor. */
312   public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
313   int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
314   {
315     this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
316   }
317
318   /** Constructor. */
319   public SimpleCharStream(java.io.InputStream dstream, int startline,
320   int startcolumn, int buffersize)
321   {
322     this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
323   }
324
325   /** Constructor. */
326   public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
327                           int startcolumn) throws java.io.UnsupportedEncodingException
328   {
329     this(dstream, encoding, startline, startcolumn, 4096);
330   }
331
332   /** Constructor. */
333   public SimpleCharStream(java.io.InputStream dstream, int startline,
334                           int startcolumn)
335   {
336     this(dstream, startline, startcolumn, 4096);
337   }
338
339   /** Constructor. */
340   public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
341   {
342     this(dstream, encoding, 1, 1, 4096);
343   }
344
345   /** Constructor. */
346   public SimpleCharStream(java.io.InputStream dstream)
347   {
348     this(dstream, 1, 1, 4096);
349   }
350
351   /** Reinitialise. */
352   public void ReInit(java.io.InputStream dstream, String encoding, int startline,
353                           int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
354   {
355     ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
356   }
357
358   /** Reinitialise. */
359   public void ReInit(java.io.InputStream dstream, int startline,
360                           int startcolumn, int buffersize)
361   {
362     ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
363   }
364
365   /** Reinitialise. */
366   public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
367   {
368     ReInit(dstream, encoding, 1, 1, 4096);
369   }
370
371   /** Reinitialise. */
372   public void ReInit(java.io.InputStream dstream)
373   {
374     ReInit(dstream, 1, 1, 4096);
375   }
376   /** Reinitialise. */
377   public void ReInit(java.io.InputStream dstream, String encoding, int startline,
378                      int startcolumn) throws java.io.UnsupportedEncodingException
379   {
380     ReInit(dstream, encoding, startline, startcolumn, 4096);
381   }
382   /** Reinitialise. */
383   public void ReInit(java.io.InputStream dstream, int startline,
384                      int startcolumn)
385   {
386     ReInit(dstream, startline, startcolumn, 4096);
387   }
388   /** Get token literal value. */
389   public String GetImage()
390   {
391     if (bufpos >= tokenBegin)
392       return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
393     else
394       return new String(buffer, tokenBegin, bufsize - tokenBegin) +
395                             new String(buffer, 0, bufpos + 1);
396   }
397
398   /** Get the suffix. */
399   public char[] GetSuffix(int len)
400   {
401     char[] ret = new char[len];
402
403     if ((bufpos + 1) >= len)
404       System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
405     else
406     {
407       System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
408                                                         len - bufpos - 1);
409       System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
410     }
411
412     return ret;
413   }
414
415   /** Reset buffer when finished. */
416   public void Done()
417   {
418     buffer = null;
419     bufline = null;
420     bufcolumn = null;
421   }
422
423   /**
424    * Method to adjust line and column numbers for the start of a token.
425    */
426   public void adjustBeginLineColumn(int newLine, int newCol)
427   {
428     int start = tokenBegin;
429     int len;
430
431     if (bufpos >= tokenBegin)
432     {
433       len = bufpos - tokenBegin + inBuf + 1;
434     }
435     else
436     {
437       len = bufsize - tokenBegin + bufpos + 1 + inBuf;
438     }
439
440     int i = 0, j = 0, k = 0;
441     int nextColDiff = 0, columnDiff = 0;
442
443     while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
444     {
445       bufline[j] = newLine;
446       nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
447       bufcolumn[j] = newCol + columnDiff;
448       columnDiff = nextColDiff;
449       i++;
450     }
451
452     if (i < len)
453     {
454       bufline[j] = newLine++;
455       bufcolumn[j] = newCol + columnDiff;
456
457       while (i++ < len)
458       {
459         if (bufline[j = start % bufsize] != bufline[++start % bufsize])
460           bufline[j] = newLine++;
461         else
462           bufline[j] = newLine;
463       }
464     }
465
466     line = bufline[j];
467     column = bufcolumn[j];
468   }
469
470 }
471 /* JavaCC - OriginalChecksum=ba0a2636eda0843482e36cc3e9220588 (do not edit this line) */