]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.databoard/src/org/simantics/databoard/parser/SimpleCharStream.java
Customisation for connection creation
[simantics/platform.git] / bundles / org.simantics.databoard / src / org / simantics / databoard / parser / SimpleCharStream.java
1 /*******************************************************************************
2  *  Copyright (c) 2010 Association for Decentralized Information Management in
3  *  Industry THTH ry.
4  *  All rights reserved. This program and the accompanying materials
5  *  are made available under the terms of the Eclipse Public License v1.0
6  *  which accompanies this distribution, and is available at
7  *  http://www.eclipse.org/legal/epl-v10.html
8  *
9  *  Contributors:
10  *      VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.databoard.parser;
13
14 /**
15  * An implementation of interface CharStream, where the stream is assumed to
16  * contain only ASCII characters (without unicode processing).
17  */
18
19 public class SimpleCharStream
20 {
21 /** Whether parser is static. */
22   public static final boolean staticFlag = false;
23   int bufsize;
24   int available;
25   int tokenBegin;
26 /** Position in buffer. */
27   public int bufpos = -1;
28   protected int bufline[];
29   protected int bufcolumn[];
30
31   protected int column = 0;
32   protected int line = 1;
33
34   protected boolean prevCharIsCR = false;
35   protected boolean prevCharIsLF = false;
36
37   protected java.io.Reader inputStream;
38
39   protected char[] buffer;
40   protected int maxNextCharInd = 0;
41   protected int inBuf = 0;
42   protected int tabSize = 8;
43
44   protected void setTabSize(int i) { tabSize = i; }
45   protected int getTabSize(int i) { return tabSize; }
46
47
48   protected void ExpandBuff(boolean wrapAround)
49   {
50     char[] newbuffer = new char[bufsize + 2048];
51     int newbufline[] = new int[bufsize + 2048];
52     int newbufcolumn[] = new int[bufsize + 2048];
53
54     try
55     {
56       if (wrapAround)
57       {
58         System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
59         System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
60         buffer = newbuffer;
61
62         System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
63         System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
64         bufline = newbufline;
65
66         System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
67         System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
68         bufcolumn = newbufcolumn;
69
70         maxNextCharInd = (bufpos += (bufsize - tokenBegin));
71       }
72       else
73       {
74         System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
75         buffer = newbuffer;
76
77         System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
78         bufline = newbufline;
79
80         System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
81         bufcolumn = newbufcolumn;
82
83         maxNextCharInd = (bufpos -= tokenBegin);
84       }
85     }
86     catch (Throwable t)
87     {
88       throw new Error(t.getMessage());
89     }
90
91
92     bufsize += 2048;
93     available = bufsize;
94     tokenBegin = 0;
95   }
96
97   protected void FillBuff() throws java.io.IOException
98   {
99     if (maxNextCharInd == available)
100     {
101       if (available == bufsize)
102       {
103         if (tokenBegin > 2048)
104         {
105           bufpos = maxNextCharInd = 0;
106           available = tokenBegin;
107         }
108         else if (tokenBegin < 0)
109           bufpos = maxNextCharInd = 0;
110         else
111           ExpandBuff(false);
112       }
113       else if (available > tokenBegin)
114         available = bufsize;
115       else if ((tokenBegin - available) < 2048)
116         ExpandBuff(true);
117       else
118         available = tokenBegin;
119     }
120
121     int i;
122     try {
123       if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1)
124       {
125         inputStream.close();
126         throw new java.io.IOException();
127       }
128       else
129         maxNextCharInd += i;
130       return;
131     }
132     catch(java.io.IOException e) {
133       --bufpos;
134       backup(0);
135       if (tokenBegin == -1)
136         tokenBegin = bufpos;
137       throw e;
138     }
139   }
140
141 /** Start. */
142   public char BeginToken() throws java.io.IOException
143   {
144     tokenBegin = -1;
145     char c = readChar();
146     tokenBegin = bufpos;
147
148     return c;
149   }
150
151   protected void UpdateLineColumn(char c)
152   {
153     column++;
154
155     if (prevCharIsLF)
156     {
157       prevCharIsLF = false;
158       line += (column = 1);
159     }
160     else if (prevCharIsCR)
161     {
162       prevCharIsCR = false;
163       if (c == '\n')
164       {
165         prevCharIsLF = true;
166       }
167       else
168         line += (column = 1);
169     }
170
171     switch (c)
172     {
173       case '\r' :
174         prevCharIsCR = true;
175         break;
176       case '\n' :
177         prevCharIsLF = true;
178         break;
179       case '\t' :
180         column--;
181         column += (tabSize - (column % tabSize));
182         break;
183       default :
184         break;
185     }
186
187     bufline[bufpos] = line;
188     bufcolumn[bufpos] = column;
189   }
190
191 /** Read a character. */
192   public char readChar() throws java.io.IOException
193   {
194     if (inBuf > 0)
195     {
196       --inBuf;
197
198       if (++bufpos == bufsize)
199         bufpos = 0;
200
201       return buffer[bufpos];
202     }
203
204     if (++bufpos >= maxNextCharInd)
205       FillBuff();
206
207     char c = buffer[bufpos];
208
209     UpdateLineColumn(c);
210     return c;
211   }
212
213   @Deprecated
214   /**
215    * @deprecated
216    * @see #getEndColumn
217    */
218
219   public int getColumn() {
220     return bufcolumn[bufpos];
221   }
222
223   @Deprecated
224   /**
225    * @deprecated
226    * @see #getEndLine
227    */
228
229   public int getLine() {
230     return bufline[bufpos];
231   }
232
233   /** Get token end column number. */
234   public int getEndColumn() {
235     return bufcolumn[bufpos];
236   }
237
238   /** Get token end line number. */
239   public int getEndLine() {
240      return bufline[bufpos];
241   }
242
243   /** Get token beginning column number. */
244   public int getBeginColumn() {
245     return bufcolumn[tokenBegin];
246   }
247
248   /** Get token beginning line number. */
249   public int getBeginLine() {
250     return bufline[tokenBegin];
251   }
252
253 /** Backup a number of characters. */
254   public void backup(int amount) {
255
256     inBuf += amount;
257     if ((bufpos -= amount) < 0)
258       bufpos += bufsize;
259   }
260
261   /** Constructor. */
262   public SimpleCharStream(java.io.Reader dstream, int startline,
263   int startcolumn, int buffersize)
264   {
265     inputStream = dstream;
266     line = startline;
267     column = startcolumn - 1;
268
269     available = bufsize = buffersize;
270     buffer = new char[buffersize];
271     bufline = new int[buffersize];
272     bufcolumn = new int[buffersize];
273   }
274
275   /** Constructor. */
276   public SimpleCharStream(java.io.Reader dstream, int startline,
277                           int startcolumn)
278   {
279     this(dstream, startline, startcolumn, 4096);
280   }
281
282   /** Constructor. */
283   public SimpleCharStream(java.io.Reader dstream)
284   {
285     this(dstream, 1, 1, 4096);
286   }
287
288   /** Reinitialise. */
289   public void ReInit(java.io.Reader dstream, int startline,
290   int startcolumn, int buffersize)
291   {
292     inputStream = dstream;
293     line = startline;
294     column = startcolumn - 1;
295
296     if (buffer == null || buffersize != buffer.length)
297     {
298       available = bufsize = buffersize;
299       buffer = new char[buffersize];
300       bufline = new int[buffersize];
301       bufcolumn = new int[buffersize];
302     }
303     prevCharIsLF = prevCharIsCR = false;
304     tokenBegin = inBuf = maxNextCharInd = 0;
305     bufpos = -1;
306   }
307
308   /** Reinitialise. */
309   public void ReInit(java.io.Reader dstream, int startline,
310                      int startcolumn)
311   {
312     ReInit(dstream, startline, startcolumn, 4096);
313   }
314
315   /** Reinitialise. */
316   public void ReInit(java.io.Reader dstream)
317   {
318     ReInit(dstream, 1, 1, 4096);
319   }
320   /** Constructor. */
321   public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
322   int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
323   {
324     this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
325   }
326
327   /** Constructor. */
328   public SimpleCharStream(java.io.InputStream dstream, int startline,
329   int startcolumn, int buffersize)
330   {
331     this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
332   }
333
334   /** Constructor. */
335   public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
336                           int startcolumn) throws java.io.UnsupportedEncodingException
337   {
338     this(dstream, encoding, startline, startcolumn, 4096);
339   }
340
341   /** Constructor. */
342   public SimpleCharStream(java.io.InputStream dstream, int startline,
343                           int startcolumn)
344   {
345     this(dstream, startline, startcolumn, 4096);
346   }
347
348   /** Constructor. */
349   public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
350   {
351     this(dstream, encoding, 1, 1, 4096);
352   }
353
354   /** Constructor. */
355   public SimpleCharStream(java.io.InputStream dstream)
356   {
357     this(dstream, 1, 1, 4096);
358   }
359
360   /** Reinitialise. */
361   public void ReInit(java.io.InputStream dstream, String encoding, int startline,
362                           int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
363   {
364     ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
365   }
366
367   /** Reinitialise. */
368   public void ReInit(java.io.InputStream dstream, int startline,
369                           int startcolumn, int buffersize)
370   {
371     ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
372   }
373
374   /** Reinitialise. */
375   public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
376   {
377     ReInit(dstream, encoding, 1, 1, 4096);
378   }
379
380   /** Reinitialise. */
381   public void ReInit(java.io.InputStream dstream)
382   {
383     ReInit(dstream, 1, 1, 4096);
384   }
385   /** Reinitialise. */
386   public void ReInit(java.io.InputStream dstream, String encoding, int startline,
387                      int startcolumn) throws java.io.UnsupportedEncodingException
388   {
389     ReInit(dstream, encoding, startline, startcolumn, 4096);
390   }
391   /** Reinitialise. */
392   public void ReInit(java.io.InputStream dstream, int startline,
393                      int startcolumn)
394   {
395     ReInit(dstream, startline, startcolumn, 4096);
396   }
397   /** Get token literal value. */
398   public String GetImage()
399   {
400     if (bufpos >= tokenBegin)
401       return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
402     else
403       return new String(buffer, tokenBegin, bufsize - tokenBegin) +
404                             new String(buffer, 0, bufpos + 1);
405   }
406
407   /** Get the suffix. */
408   public char[] GetSuffix(int len)
409   {
410     char[] ret = new char[len];
411
412     if ((bufpos + 1) >= len)
413       System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
414     else
415     {
416       System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
417                                                         len - bufpos - 1);
418       System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
419     }
420
421     return ret;
422   }
423
424   /** Reset buffer when finished. */
425   public void Done()
426   {
427     buffer = null;
428     bufline = null;
429     bufcolumn = null;
430   }
431
432   /**
433    * Method to adjust line and column numbers for the start of a token.
434    */
435   public void adjustBeginLineColumn(int newLine, int newCol)
436   {
437     int start = tokenBegin;
438     int len;
439
440     if (bufpos >= tokenBegin)
441     {
442       len = bufpos - tokenBegin + inBuf + 1;
443     }
444     else
445     {
446       len = bufsize - tokenBegin + bufpos + 1 + inBuf;
447     }
448
449     int i = 0, j = 0, k = 0;
450     int nextColDiff = 0, columnDiff = 0;
451
452     while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
453     {
454       bufline[j] = newLine;
455       nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
456       bufcolumn[j] = newCol + columnDiff;
457       columnDiff = nextColDiff;
458       i++;
459     }
460
461     if (i < len)
462     {
463       bufline[j] = newLine++;
464       bufcolumn[j] = newCol + columnDiff;
465
466       while (i++ < len)
467       {
468         if (bufline[j = start % bufsize] != bufline[++start % bufsize])
469           bufline[j] = newLine++;
470         else
471           bufline[j] = newLine;
472       }
473     }
474
475     line = bufline[j];
476     column = bufcolumn[j];
477   }
478
479 }
480 /* JavaCC - OriginalChecksum=a27b2601f30a31b2eea422d3e11ea15d (do not edit this line) */