Coverage Report

Coverage Report - org.apache.commons.el.parser.SimpleCharStream

Classes in this File

Line Coverage

Branch Coverage

Complexity

SimpleCharStream

32%

59/179

24%

14/58

2.321

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