Coverage Report

Coverage Report - org.webslinger.ext.wiki.parser.SimpleCharStream

Classes in this File

Line Coverage

Branch Coverage

Complexity

SimpleCharStream

25%

2/8

N/A

1.972

 /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 4.0 */
 package org.webslinger.ext.wiki.parser;
 
 /**
  * An implementation of interface CharStream, where the stream is assumed to
  * contain only ASCII characters (without unicode processing).
  */
 
 public class SimpleCharStream
 {
   public static final boolean staticFlag = false;
   int bufsize;
   int available;
   int tokenBegin;
   public int bufpos = -1;
   protected int bufline[];
   protected int bufcolumn[];
 
   protected int column = 0;
   protected int line = 1;
 
   protected boolean prevCharIsCR = false;
   protected boolean prevCharIsLF = false;
 
   protected java.io.Reader inputStream;
 
   protected char[] buffer;
   protected int maxNextCharInd = 0;
   protected int inBuf = 0;
   protected int tabSize = 8;
 
   protected void setTabSize(int i) { tabSize = i; }
   protected int getTabSize(int i) { return tabSize; }
 
 
   protected void ExpandBuff(boolean wrapAround)
   {
      char[] newbuffer = new char[bufsize + 2048];
      int newbufline[] = new int[bufsize + 2048];
      int newbufcolumn[] = new int[bufsize + 2048];
 
      try
      {
         if (wrapAround)
         {
            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
            System.arraycopy(buffer, 0, newbuffer,
                                              bufsize - tokenBegin, bufpos);
            buffer = newbuffer;
 
            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
            System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
            bufline = newbufline;
 
            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
            System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
            bufcolumn = newbufcolumn;
 
            maxNextCharInd = (bufpos += (bufsize - tokenBegin));
         }
         else
         {
            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
            buffer = newbuffer;
 
            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
            bufline = newbufline;
 
            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
            bufcolumn = newbufcolumn;
 
            maxNextCharInd = (bufpos -= tokenBegin);
         }
      }
      catch (Throwable t)
      {
         throw new Error(t.getMessage());
      }
 
 
      bufsize += 2048;
      available = bufsize;
      tokenBegin = 0;
   }
 
   protected void FillBuff() throws java.io.IOException
   {
      if (maxNextCharInd == available)
      {
         if (available == bufsize)
         {
            if (tokenBegin > 2048)
            {
               bufpos = maxNextCharInd = 0;
               available = tokenBegin;
            }
            else if (tokenBegin < 0)
               bufpos = maxNextCharInd = 0;
            else
               ExpandBuff(false);
         }
         else if (available > tokenBegin)
            available = bufsize;
         else if ((tokenBegin - available) < 2048)
            ExpandBuff(true);
         else
            available = tokenBegin;
      }
 
      int i;
      try {
         if ((i = inputStream.read(buffer, maxNextCharInd,
                                     available - maxNextCharInd)) == -1)
         {
            inputStream.close();
            throw new java.io.IOException();
         }
         else
            maxNextCharInd += i;
         return;
      }
      catch(java.io.IOException e) {
         --bufpos;
         backup(0);
         if (tokenBegin == -1)
            tokenBegin = bufpos;
         throw e;
      }
   }
 
   public char BeginToken() throws java.io.IOException
   {
      tokenBegin = -1;
      char c = readChar();
      tokenBegin = bufpos;
 
      return c;
   }
 
   protected void UpdateLineColumn(char c)
   {
      column++;
 
      if (prevCharIsLF)
      {
         prevCharIsLF = false;
         line += (column = 1);
      }
      else if (prevCharIsCR)
      {
         prevCharIsCR = false;
         if (c == '\n')
         {
            prevCharIsLF = true;
         }
         else
            line += (column = 1);
      }
 
      switch (c)
      {
         case '\r' :
            prevCharIsCR = true;
            break;
         case '\n' :
            prevCharIsLF = true;
            break;
         case '\t' :
            column--;
            column += (tabSize - (column % tabSize));
            break;
         default :
            break;
      }
 
      bufline[bufpos] = line;
      bufcolumn[bufpos] = column;
   }
 
   public char readChar() throws java.io.IOException
   {
      if (inBuf > 0)
      {
         --inBuf;
 
         if (++bufpos == bufsize)
            bufpos = 0;
 
         return buffer[bufpos];
      }
 
      if (++bufpos >= maxNextCharInd)
         FillBuff();
 
      char c = buffer[bufpos];
 
      UpdateLineColumn(c);
      return (c);
   }
 
   /**
    * @deprecated 
    * @see #getEndColumn
    */
 
   public int getColumn() {
      return bufcolumn[bufpos];
   }
 
   /**
    * @deprecated 
    * @see #getEndLine
    */
 
   public int getLine() {
      return bufline[bufpos];
   }
 
   public int getEndColumn() {
      return bufcolumn[bufpos];
   }
 
   public int getEndLine() {
      return bufline[bufpos];
   }
 
   public int getBeginColumn() {
      return bufcolumn[tokenBegin];
   }
 
   public int getBeginLine() {
      return bufline[tokenBegin];
   }
 
   public void backup(int amount) {
 
     inBuf += amount;
     if ((bufpos -= amount) < 0)
        bufpos += bufsize;
   }
 
   public SimpleCharStream(java.io.Reader dstream, int startline,
   int startcolumn, int buffersize)
   {
     inputStream = dstream;
     line = startline;
     column = startcolumn - 1;
 
     available = bufsize = buffersize;
     buffer = new char[buffersize];
     bufline = new int[buffersize];
     bufcolumn = new int[buffersize];
   }
 
   public SimpleCharStream(java.io.Reader dstream, int startline,
                           int startcolumn)
   {
      this(dstream, startline, startcolumn, 4096);
   }
 
   public SimpleCharStream(java.io.Reader dstream)
   {
      this(dstream, 1, 1, 4096);
   }
   public void ReInit(java.io.Reader dstream, int startline,
   int startcolumn, int buffersize)
   {
     inputStream = dstream;
     line = startline;
     column = startcolumn - 1;
 
     if (buffer == null || buffersize != buffer.length)
     {
       available = bufsize = buffersize;
       buffer = new char[buffersize];
       bufline = new int[buffersize];
       bufcolumn = new int[buffersize];
     }
     prevCharIsLF = prevCharIsCR = false;
     tokenBegin = inBuf = maxNextCharInd = 0;
     bufpos = -1;
   }
 
   public void ReInit(java.io.Reader dstream, int startline,
                      int startcolumn)
   {
      ReInit(dstream, startline, startcolumn, 4096);
   }
 
   public void ReInit(java.io.Reader dstream)
   {
      ReInit(dstream, 1, 1, 4096);
   }
   public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
   int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
   {
      this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
   }
 
   public SimpleCharStream(java.io.InputStream dstream, int startline,
   int startcolumn, int buffersize)
   {
      this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
   }
 
   public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
                           int startcolumn) throws java.io.UnsupportedEncodingException
   {
      this(dstream, encoding, startline, startcolumn, 4096);
   }
 
   public SimpleCharStream(java.io.InputStream dstream, int startline,
                           int startcolumn)
   {
      this(dstream, startline, startcolumn, 4096);
   }
 
   public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
   {
      this(dstream, encoding, 1, 1, 4096);
   }
 
   public SimpleCharStream(java.io.InputStream dstream)
   {
      this(dstream, 1, 1, 4096);
   }
 
   public void ReInit(java.io.InputStream dstream, String encoding, int startline,
                           int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
   {
      ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
   }
 
   public void ReInit(java.io.InputStream dstream, int startline,
                           int startcolumn, int buffersize)
   {
      ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
   }
 
   public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
   {
      ReInit(dstream, encoding, 1, 1, 4096);
   }
 
   public void ReInit(java.io.InputStream dstream)
   {
      ReInit(dstream, 1, 1, 4096);
   }
   public void ReInit(java.io.InputStream dstream, String encoding, int startline,
                      int startcolumn) throws java.io.UnsupportedEncodingException
   {
      ReInit(dstream, encoding, startline, startcolumn, 4096);
   }
   public void ReInit(java.io.InputStream dstream, int startline,
                      int startcolumn)
   {
      ReInit(dstream, startline, startcolumn, 4096);
   }
   public String GetImage()
   {
      if (bufpos >= tokenBegin)
         return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
      else
         return new String(buffer, tokenBegin, bufsize - tokenBegin) +
                               new String(buffer, 0, bufpos + 1);
   }
 
   public char[] GetSuffix(int len)
   {
      char[] ret = new char[len];
 
      if ((bufpos + 1) >= len)
         System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
      else
      {
         System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
                                                           len - bufpos - 1);
         System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
      }
 
      return ret;
   }
 
   public void Done()
   {
      buffer = null;
      bufline = null;
      bufcolumn = null;
   }
 
   /**
    * Method to adjust line and column numbers for the start of a token.
    */
   public void adjustBeginLineColumn(int newLine, int newCol)
   {
      int start = tokenBegin;
      int len;
 
      if (bufpos >= tokenBegin)
      {
         len = bufpos - tokenBegin + inBuf + 1;
      }
      else
      {
         len = bufsize - tokenBegin + bufpos + 1 + inBuf;
      }
 
      int i = 0, j = 0, k = 0;
      int nextColDiff = 0, columnDiff = 0;
 
      while (i < len &&
             bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
      {
         bufline[j] = newLine;
         nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
         bufcolumn[j] = newCol + columnDiff;
         columnDiff = nextColDiff;
         i++;
      } 
 
      if (i < len)
      {
         bufline[j] = newLine++;
         bufcolumn[j] = newCol + columnDiff;
 
         while (i++ < len)
         {
            if (bufline[j = start % bufsize] != bufline[++start % bufsize])
               bufline[j] = newLine++;
            else
               bufline[j] = newLine;
         }
      }
 
      line = bufline[j];
      column = bufcolumn[j];
   }
 
 }

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