Coverage Report

Coverage Report - org.apache.commons.configuration.plist.SimpleCharStream

Classes in this File

Line Coverage

Branch Coverage

Complexity

SimpleCharStream

38%

71/187

46%

11/24

2,25

 /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 3.0 */
 package org.apache.commons.configuration.plist;
 
 /**
  * An implementation of interface CharStream, where the stream is assumed to
  * contain only ASCII characters (without unicode processing).
  */
 
 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 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 += (8 - (column & 07));
            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, 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 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 3.0 */
2		package org.apache.commons.configuration.plist;
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		class SimpleCharStream
10		{
11		public static final boolean staticFlag = false;
12		int bufsize;
13		int available;
14		int tokenBegin;
15	40	public int bufpos = -1;
16		protected int bufline[];
17		protected int bufcolumn[];
18
19	40	protected int column = 0;
20	40	protected int line = 1;
21
22	40	protected boolean prevCharIsCR = false;
23	40	protected boolean prevCharIsLF = false;
24
25		protected java.io.Reader inputStream;
26
27		protected char[] buffer;
28	40	protected int maxNextCharInd = 0;
29	40	protected int inBuf = 0;
30
31		protected 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	0	}
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		protected void FillBuff() throws java.io.IOException
82		{
83	103	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	0	}
92	0	else if (tokenBegin < 0)
93	0	bufpos = maxNextCharInd = 0;
94		else
95	0	ExpandBuff(false);
96	0	}
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	103	if ((i = inputStream.read(buffer, maxNextCharInd,
108		available - maxNextCharInd)) == -1)
109		{
110	36	inputStream.close();
111	36	throw new java.io.IOException();
112		}
113		else
114	35	maxNextCharInd += i;
115	35	return;
116		}
117	68	catch(java.io.IOException e) {
118	68	--bufpos;
119	68	backup(0);
120	68	if (tokenBegin == -1)
121	68	tokenBegin = bufpos;
122	68	throw e;
123		}
124		}
125
126		public char BeginToken() throws java.io.IOException
127		{
128	14511	tokenBegin = -1;
129	14511	char c = readChar();
130	14443	tokenBegin = bufpos;
131
132	14443	return c;
133		}
134
135		protected void UpdateLineColumn(char c)
136		{
137	25059	column++;
138
139	25059	if (prevCharIsLF)
140		{
141	1387	prevCharIsLF = false;
142	1387	line += (column = 1);
143	1387	}
144	23672	else if (prevCharIsCR)
145		{
146	1419	prevCharIsCR = false;
147	1419	if (c == '\n')
148		{
149	1419	prevCharIsLF = true;
150	1419	}
151		else
152	0	line += (column = 1);
153		}
154
155	25059	switch (c)
156		{
157		case '\r' :
158	1419	prevCharIsCR = true;
159	1419	break;
160		case '\n' :
161	1419	prevCharIsLF = true;
162	1419	break;
163		case '\t' :
164	0	column--;
165	0	column += (8 - (column & 07));
166	0	break;
167		default :
168		break;
169		}
170
171	25059	bufline[bufpos] = line;
172	25059	bufcolumn[bufpos] = column;
173	25059	}
174
175		public char readChar() throws java.io.IOException
176		{
177	26063	if (inBuf > 0)
178		{
179	936	--inBuf;
180
181	936	if (++bufpos == bufsize)
182	0	bufpos = 0;
183
184	936	return buffer[bufpos];
185		}
186
187	25127	if (++bufpos >= maxNextCharInd)
188	103	FillBuff();
189
190	25059	char c = buffer[bufpos];
191
192	25059	UpdateLineColumn(c);
193	25059	return (c);
194		}
195
196		/**
197		* @deprecated
198		* @see #getEndColumn
199		*/
200
201		public int getColumn() {
202	0	return bufcolumn[bufpos];
203		}
204
205		/**
206		* @deprecated
207		* @see #getEndLine
208		*/
209
210		public int getLine() {
211	0	return bufline[bufpos];
212		}
213
214		public int getEndColumn() {
215	3643	return bufcolumn[bufpos];
216		}
217
218		public int getEndLine() {
219	3643	return bufline[bufpos];
220		}
221
222		public int getBeginColumn() {
223	3643	return bufcolumn[tokenBegin];
224		}
225
226		public int getBeginLine() {
227	3643	return bufline[tokenBegin];
228		}
229
230		public void backup(int amount) {
231
232	4643	inBuf += amount;
233	4643	if ((bufpos -= amount) < 0)
234	1	bufpos += bufsize;
235	4643	}
236
237		public SimpleCharStream(java.io.Reader dstream, int startline,
238		int startcolumn, int buffersize)
239	40	{
240	40	inputStream = dstream;
241	40	line = startline;
242	40	column = startcolumn - 1;
243
244	40	available = bufsize = buffersize;
245	40	buffer = new char[buffersize];
246	40	bufline = new int[buffersize];
247	40	bufcolumn = new int[buffersize];
248	40	}
249
250		public SimpleCharStream(java.io.Reader dstream, int startline,
251		int startcolumn)
252		{
253	40	this(dstream, startline, startcolumn, 4096);
254	40	}
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 String GetImage()
322		{
323	1323	if (bufpos >= tokenBegin)
324	1323	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 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.
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	0	}
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		while (i < len &&
374	0	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	0	}
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	0	}
395		}
396
397	0	line = bufline[j];
398	0	column = bufcolumn[j];
399	0	}
400
401		}