Coverage Report

Coverage Report - org.webmacro.parser.BackupCharStream

Classes in this File

Line Coverage

Branch Coverage

Complexity

BackupCharStream

80%

105/131

76%

43/56

2.296

BackupCharStream$Buffer

90%

20/22

N/A

2.296

 /* Generated By:JavaCC: Do not edit this line. ASCII_CharStream.java Version 0.7pre6 */
 
 package org.webmacro.parser;
 
 /**
  * An implementation of interface CharStream.
  * Modified extensively by Brian Goetz (Oct 2000) to support being able to
  * back up in the buffer.
  * Modified to support Unicode input.
  * Convenience one-arg constructor provided.
  */
 
 public final class BackupCharStream implements CharStream
 {
 
     private static final class Buffer
     {
 
         int size;
         int dataLen, curPos;
         char[] buffer;
         int[] bufline, bufcolumn;
 
         public Buffer (int n)
         {
             size = n;
             dataLen = 0;
             curPos = -1;
             buffer = new char[n];
             bufline = new int[n];
             bufcolumn = new int[n];
         }
 
         public void expand (int n)
         {
             char[] newbuffer = new char[size + n];
             int newbufline[] = new int[size + n];
             int newbufcolumn[] = new int[size + n];
 
             try
             {
                 System.arraycopy(buffer, 0, newbuffer, 0, size);
                 buffer = newbuffer;
                 System.arraycopy(bufline, 0, newbufline, 0, size);
                 bufline = newbufline;
                 System.arraycopy(bufcolumn, 0, newbufcolumn, 0, size);
                 bufcolumn = newbufcolumn;
             }
             catch (Throwable t)
             {
                 throw new Error(t.getMessage());
             }
 
             size += n;
         }
     }
 
     private Buffer bufA, bufB, curBuf, otherBuf, tokenBeginBuf;
     private int tokenBeginPos;
     private int backupChars;
 
     public static final boolean staticFlag = false;
 
     private int column = 0;
     private int line = 1;
     private boolean prevCharIsCR = false;
     private boolean prevCharIsLF = false;
 
     private java.io.Reader inputStream;
     private boolean inputStreamClosed = false;
 
     private final void swapBuf ()
     {
         Buffer tmp = curBuf;
         curBuf = otherBuf;
         otherBuf = tmp;
     }
 
     private final void FillBuff () throws java.io.IOException
     {
         // Buffer fill logic:
         // If there is at least 2K left in this buffer, just read some more
         // Otherwise, if we're processing a token and it either
         // (a) starts in the other buffer (meaning it's filled both part of
         //     the other buffer and some of this one, or
         // (b) starts in the first 2K of this buffer (meaning its taken up
         //     most of this buffer
         // we expand this buffer.  Otherwise, we swap buffers.
         // This guarantees we will be able to back up at least 2K characters.
         if (curBuf.size - curBuf.dataLen < 2048)
         {
             if (tokenBeginPos >= 0
                     && ((tokenBeginBuf == curBuf && tokenBeginPos < 2048)
                     || tokenBeginBuf != curBuf))
             {
                 curBuf.expand(2048);
             }
             else
             {
                 swapBuf();
                 curBuf.curPos = curBuf.dataLen = 0;
             }
         }
 
         try
         {
             int i = inputStream.read(curBuf.buffer, curBuf.dataLen,
                     curBuf.size - curBuf.dataLen);
             if (i == -1)
             {
                 inputStream.close();
                 inputStreamClosed = true;
                 throw new java.io.IOException();
             }
             else
                 curBuf.dataLen += i;
             return;
         }
         catch (java.io.IOException e)
         {
             if (curBuf.curPos > 0)
                 --curBuf.curPos;
             if (tokenBeginPos == -1)
             {
                 tokenBeginPos = curBuf.curPos;
                 tokenBeginBuf = curBuf;
             }
             if (e.getClass().getName().equals("sun.io.MalformedInputException"))
             {
                 // it's an ugly hack, but we want to pass this exception
                 // through the JavaCC parser, since it has a bad
                 // exception handling
                 throw new ParserRuntimeException("MalformedInput", e);
             }
             throw e;
         }
     }
 
     public final char BeginToken () throws java.io.IOException
     {
         tokenBeginPos = -1;
         char c = readChar();
         tokenBeginBuf = curBuf;
         tokenBeginPos = curBuf.curPos;
 
         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;
         }
 
         curBuf.bufline[curBuf.curPos] = line;
         curBuf.bufcolumn[curBuf.curPos] = column;
     }
 
     public final char readChar () throws java.io.IOException
     {
         // When we hit the end of the buffer, if we're backing up, we just
         // swap, if we're not, we fill.
         if (++curBuf.curPos >= curBuf.dataLen)
         {
             if (backupChars > 0)
             {
                 --curBuf.curPos;
                 swapBuf();
             }
             else
                 FillBuff();
         }
         ;
 
         // Don't mask off the high byte
         char c = curBuf.buffer[curBuf.curPos];
 
         // No need to update line numbers if we've already processed this char
         if (backupChars > 0)
             --backupChars;
         else
             UpdateLineColumn(c);
 
         return (c);
     }
 
     /**
      * @deprecated
      * @see #getEndColumn
      */
 
     public final int getColumn ()
     {
         return curBuf.bufcolumn[curBuf.curPos];
     }
 
     /**
      * @deprecated
      * @see #getEndLine
      */
 
     public final int getLine ()
     {
         return curBuf.bufline[curBuf.curPos];
     }
 
     public final int getEndColumn ()
     {
         return curBuf.bufcolumn[curBuf.curPos];
     }
 
     public final int getEndLine ()
     {
         return curBuf.bufline[curBuf.curPos];
     }
 
     public final int getBeginColumn ()
     {
         return tokenBeginBuf.bufcolumn[tokenBeginPos];
     }
 
     public final int getBeginLine ()
     {
         return tokenBeginBuf.bufline[tokenBeginPos];
     }
 
     public final void backup (int amount)
     {
         backupChars += amount;
         if (curBuf.curPos - amount < 0)
         {
             int addlChars = amount - (inputStreamClosed ? 0 : 1) - curBuf.curPos;
             curBuf.curPos = 0;
             swapBuf();
             curBuf.curPos = curBuf.dataLen - addlChars - 1;
         }
         else
         {
             curBuf.curPos -= amount;
         }
     }
 
     public BackupCharStream (java.io.Reader dstream)
     {
         this(dstream, 1, 1, 4096);
     }
 
     public BackupCharStream (java.io.Reader dstream, int startline,
                              int startcolumn, int buffersize)
     {
         ReInit(dstream, startline, startcolumn, buffersize);
     }
 
     public BackupCharStream (java.io.Reader dstream, int startline,
                              int startcolumn)
     {
         this(dstream, startline, startcolumn, 4096);
     }
 
     public void ReInit (java.io.Reader dstream, int startline,
                         int startcolumn, int buffersize)
     {
         inputStream = dstream;
         inputStreamClosed = false;
         line = startline;
         column = startcolumn - 1;
 
         if (bufA == null || bufA.size != buffersize)
             bufA = new Buffer(buffersize);
         if (bufB == null || bufB.size != buffersize)
             bufB = new Buffer(buffersize);
         curBuf = bufA;
         otherBuf = bufB;
         curBuf.curPos = otherBuf.dataLen = -1;
         curBuf.dataLen = otherBuf.dataLen = 0;
 
         prevCharIsLF = prevCharIsCR = false;
         tokenBeginPos = -1;
         tokenBeginBuf = null;
         backupChars = 0;
     }
 
     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 BackupCharStream (java.io.InputStream dstream, int startline,
                              int startcolumn, int buffersize)
     {
         this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
     }
 
     public BackupCharStream (java.io.InputStream dstream, int startline,
                              int startcolumn)
     {
         this(dstream, startline, startcolumn, 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, int startline,
                         int startcolumn)
     {
         ReInit(dstream, startline, startcolumn, 4096);
     }
 
     public final String GetImage ()
     {
         String ret;
 
         if (tokenBeginBuf == curBuf)
         {
             ret = new String(curBuf.buffer, tokenBeginPos,
                     curBuf.curPos - tokenBeginPos + 1);
         }
         else
         {
             ret = new String(otherBuf.buffer, tokenBeginPos,
                     otherBuf.dataLen - tokenBeginPos);
             if (curBuf.curPos < curBuf.dataLen)
                 ret += new String(curBuf.buffer, 0, curBuf.curPos + 1);
         }
 
         return ret;
     }
 
     public final char[] GetSuffix (int len)
     {
         char[] ret = new char[len];
 
         if ((curBuf.curPos + 1) >= len)
             System.arraycopy(curBuf.buffer, curBuf.curPos - len + 1, ret, 0, len);
         else
         {
             if (otherBuf.dataLen >= len - curBuf.curPos - 1)
                 System.arraycopy(otherBuf.buffer,
                         otherBuf.dataLen - (len - curBuf.curPos - 1), ret, 0,
                         len - curBuf.curPos - 1);
             System.arraycopy(curBuf.buffer, 0, ret, len - curBuf.curPos - 1,
                     curBuf.curPos + 1);
         }
 
         return null;
     }
 
     public void Done ()
     {
         bufA = bufB = curBuf = otherBuf = null;
     }
 
 }
 

1		/* Generated By:JavaCC: Do not edit this line. ASCII_CharStream.java Version 0.7pre6 */
2
3		package org.webmacro.parser;
4
5		/**
6		* An implementation of interface CharStream.
7		* Modified extensively by Brian Goetz (Oct 2000) to support being able to
8		* back up in the buffer.
9		* Modified to support Unicode input.
10		* Convenience one-arg constructor provided.
11		*/
12
13		public final class BackupCharStream implements CharStream
14		{
15
16		private static final class Buffer
17		{
18
19		int size;
20		int dataLen, curPos;
21		char[] buffer;
22		int[] bufline, bufcolumn;
23
24		public Buffer (int n)
25	3532	{
26	3532	size = n;
27	3532	dataLen = 0;
28	3532	curPos = -1;
29	3532	buffer = new char[n];
30	3532	bufline = new int[n];
31	3532	bufcolumn = new int[n];
32	3532	}
33
34		public void expand (int n)
35		{
36	8	char[] newbuffer = new char[size + n];
37	8	int newbufline[] = new int[size + n];
38	8	int newbufcolumn[] = new int[size + n];
39
40		try
41		{
42	8	System.arraycopy(buffer, 0, newbuffer, 0, size);
43	8	buffer = newbuffer;
44	8	System.arraycopy(bufline, 0, newbufline, 0, size);
45	8	bufline = newbufline;
46	8	System.arraycopy(bufcolumn, 0, newbufcolumn, 0, size);
47	8	bufcolumn = newbufcolumn;
48		}
49	0	catch (Throwable t)
50		{
51	0	throw new Error(t.getMessage());
52	8	}
53
54	8	size += n;
55	8	}
56		}
57
58		private Buffer bufA, bufB, curBuf, otherBuf, tokenBeginBuf;
59		private int tokenBeginPos;
60		private int backupChars;
61
62		public static final boolean staticFlag = false;
63
64	1766	private int column = 0;
65	1766	private int line = 1;
66	1766	private boolean prevCharIsCR = false;
67	1766	private boolean prevCharIsLF = false;
68
69		private java.io.Reader inputStream;
70	1766	private boolean inputStreamClosed = false;
71
72		private final void swapBuf ()
73		{
74	2820	Buffer tmp = curBuf;
75	2820	curBuf = otherBuf;
76	2820	otherBuf = tmp;
77	2820	}
78
79		private final void FillBuff () throws java.io.IOException
80		{
81		// Buffer fill logic:
82		// If there is at least 2K left in this buffer, just read some more
83		// Otherwise, if we're processing a token and it either
84		// (a) starts in the other buffer (meaning it's filled both part of
85		// the other buffer and some of this one, or
86		// (b) starts in the first 2K of this buffer (meaning its taken up
87		// most of this buffer
88		// we expand this buffer. Otherwise, we swap buffers.
89		// This guarantees we will be able to back up at least 2K characters.
90	6477	if (curBuf.size - curBuf.dataLen < 2048)
91		{
92	1058	if (tokenBeginPos >= 0
93		&& ((tokenBeginBuf == curBuf && tokenBeginPos < 2048)
94		\|\| tokenBeginBuf != curBuf))
95		{
96	8	curBuf.expand(2048);
97		}
98		else
99		{
100	1050	swapBuf();
101	1050	curBuf.curPos = curBuf.dataLen = 0;
102		}
103		}
104
105		try
106		{
107	6477	int i = inputStream.read(curBuf.buffer, curBuf.dataLen,
108		curBuf.size - curBuf.dataLen);
109	4410	if (i == -1)
110		{
111	1766	inputStream.close();
112	1766	inputStreamClosed = true;
113	1766	throw new java.io.IOException();
114		}
115		else
116	2644	curBuf.dataLen += i;
117	2644	return;
118		}
119	3833	catch (java.io.IOException e)
120		{
121	3833	if (curBuf.curPos > 0)
122	3659	--curBuf.curPos;
123	3833	if (tokenBeginPos == -1)
124		{
125	3243	tokenBeginPos = curBuf.curPos;
126	3243	tokenBeginBuf = curBuf;
127		}
128	3833	if (e.getClass().getName().equals("sun.io.MalformedInputException"))
129		{
130		// it's an ugly hack, but we want to pass this exception
131		// through the JavaCC parser, since it has a bad
132		// exception handling
133	0	throw new ParserRuntimeException("MalformedInput", e);
134		}
135	3833	throw e;
136		}
137		}
138
139		public final char BeginToken () throws java.io.IOException
140		{
141	1558341	tokenBeginPos = -1;
142	1558341	char c = readChar();
143	1555106	tokenBeginBuf = curBuf;
144	1555106	tokenBeginPos = curBuf.curPos;
145
146	1555106	return c;
147		}
148
149		private final void UpdateLineColumn (char c)
150		{
151	4187491	column++;
152
153	4187491	if (prevCharIsLF)
154		{
155	68994	prevCharIsLF = false;
156	68994	line += (column = 1);
157		}
158	4118497	else if (prevCharIsCR)
159		{
160	491	prevCharIsCR = false;
161	491	if (c == '\n')
162		{
163	366	prevCharIsLF = true;
164		}
165		else
166	125	line += (column = 1);
167		}
168
169	4187491	switch (c)
170		{
171		case '\r':
172	492	prevCharIsCR = true;
173	492	break;
174		case '\n':
175	69259	prevCharIsLF = true;
176	69259	break;
177		case '\t':
178	3123	column--;
179	3123	column += (8 - (column & 07));
180	3123	break;
181		default :
182		break;
183		}
184
185	4187491	curBuf.bufline[curBuf.curPos] = line;
186	4187491	curBuf.bufcolumn[curBuf.curPos] = column;
187	4187491	}
188
189		public final char readChar () throws java.io.IOException
190		{
191		// When we hit the end of the buffer, if we're backing up, we just
192		// swap, if we're not, we fill.
193	8035572	if (++curBuf.curPos >= curBuf.dataLen)
194		{
195	7344	if (backupChars > 0)
196		{
197	867	--curBuf.curPos;
198	867	swapBuf();
199		}
200		else
201	6477	FillBuff();
202		}
203		;
204
205		// Don't mask off the high byte
206	8031739	char c = curBuf.buffer[curBuf.curPos];
207
208		// No need to update line numbers if we've already processed this char
209	8031739	if (backupChars > 0)
210	3844248	--backupChars;
211		else
212	4187491	UpdateLineColumn(c);
213
214	8031739	return (c);
215		}
216
217		/**
218		* @deprecated
219		* @see #getEndColumn
220		*/
221
222		public final int getColumn ()
223		{
224	0	return curBuf.bufcolumn[curBuf.curPos];
225		}
226
227		/**
228		* @deprecated
229		* @see #getEndLine
230		*/
231
232		public final int getLine ()
233		{
234	0	return curBuf.bufline[curBuf.curPos];
235		}
236
237		public final int getEndColumn ()
238		{
239	116830	return curBuf.bufcolumn[curBuf.curPos];
240		}
241
242		public final int getEndLine ()
243		{
244	116830	return curBuf.bufline[curBuf.curPos];
245		}
246
247		public final int getBeginColumn ()
248		{
249	116830	return tokenBeginBuf.bufcolumn[tokenBeginPos];
250		}
251
252		public final int getBeginLine ()
253		{
254	116830	return tokenBeginBuf.bufline[tokenBeginPos];
255		}
256
257		public final void backup (int amount)
258		{
259	1519693	backupChars += amount;
260	1519693	if (curBuf.curPos - amount < 0)
261		{
262	903	int addlChars = amount - (inputStreamClosed ? 0 : 1) - curBuf.curPos;
263	903	curBuf.curPos = 0;
264	903	swapBuf();
265	903	curBuf.curPos = curBuf.dataLen - addlChars - 1;
266	903	}
267		else
268		{
269	1518790	curBuf.curPos -= amount;
270		}
271	1519693	}
272
273		public BackupCharStream (java.io.Reader dstream)
274		{
275	1766	this(dstream, 1, 1, 4096);
276	1766	}
277
278		public BackupCharStream (java.io.Reader dstream, int startline,
279		int startcolumn, int buffersize)
280	1766	{
281	1766	ReInit(dstream, startline, startcolumn, buffersize);
282	1766	}
283
284		public BackupCharStream (java.io.Reader dstream, int startline,
285		int startcolumn)
286		{
287	0	this(dstream, startline, startcolumn, 4096);
288	0	}
289
290		public void ReInit (java.io.Reader dstream, int startline,
291		int startcolumn, int buffersize)
292		{
293	1766	inputStream = dstream;
294	1766	inputStreamClosed = false;
295	1766	line = startline;
296	1766	column = startcolumn - 1;
297
298	1766	if (bufA == null \|\| bufA.size != buffersize)
299	1766	bufA = new Buffer(buffersize);
300	1766	if (bufB == null \|\| bufB.size != buffersize)
301	1766	bufB = new Buffer(buffersize);
302	1766	curBuf = bufA;
303	1766	otherBuf = bufB;
304	1766	curBuf.curPos = otherBuf.dataLen = -1;
305	1766	curBuf.dataLen = otherBuf.dataLen = 0;
306
307	1766	prevCharIsLF = prevCharIsCR = false;
308	1766	tokenBeginPos = -1;
309	1766	tokenBeginBuf = null;
310	1766	backupChars = 0;
311	1766	}
312
313		public void ReInit (java.io.Reader dstream, int startline,
314		int startcolumn)
315		{
316	0	ReInit(dstream, startline, startcolumn, 4096);
317	0	}
318
319		public void ReInit (java.io.Reader dstream)
320		{
321	0	ReInit(dstream, 1, 1, 4096);
322	0	}
323
324		public BackupCharStream (java.io.InputStream dstream, int startline,
325		int startcolumn, int buffersize)
326		{
327	0	this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
328	0	}
329
330		public BackupCharStream (java.io.InputStream dstream, int startline,
331		int startcolumn)
332		{
333	0	this(dstream, startline, startcolumn, 4096);
334	0	}
335
336		public void ReInit (java.io.InputStream dstream, int startline,
337		int startcolumn, int buffersize)
338		{
339	0	ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn,
340		4096);
341	0	}
342
343		public void ReInit (java.io.InputStream dstream, int startline,
344		int startcolumn)
345		{
346	0	ReInit(dstream, startline, startcolumn, 4096);
347	0	}
348
349		public final String GetImage ()
350		{
351		String ret;
352
353	63990	if (tokenBeginBuf == curBuf)
354		{
355	63958	ret = new String(curBuf.buffer, tokenBeginPos,
356		curBuf.curPos - tokenBeginPos + 1);
357		}
358		else
359		{
360	32	ret = new String(otherBuf.buffer, tokenBeginPos,
361		otherBuf.dataLen - tokenBeginPos);
362	32	if (curBuf.curPos < curBuf.dataLen)
363	2	ret += new String(curBuf.buffer, 0, curBuf.curPos + 1);
364		}
365
366	63990	return ret;
367		}
368
369		public final char[] GetSuffix (int len)
370		{
371	0	char[] ret = new char[len];
372
373	0	if ((curBuf.curPos + 1) >= len)
374	0	System.arraycopy(curBuf.buffer, curBuf.curPos - len + 1, ret, 0, len);
375		else
376		{
377	0	if (otherBuf.dataLen >= len - curBuf.curPos - 1)
378	0	System.arraycopy(otherBuf.buffer,
379		otherBuf.dataLen - (len - curBuf.curPos - 1), ret, 0,
380		len - curBuf.curPos - 1);
381	0	System.arraycopy(curBuf.buffer, 0, ret, len - curBuf.curPos - 1,
382		curBuf.curPos + 1);
383		}
384
385	0	return null;
386		}
387
388		public void Done ()
389		{
390	0	bufA = bufB = curBuf = otherBuf = null;
391	0	}
392
393		}
394