KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > lowagie > text > pdf > codec > postscript > JavaCharStream


1 /* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 2.1 */
2 package com.lowagie.text.pdf.codec.postscript;
3
4 /**
5  * An implementation of interface CharStream, where the stream is assumed to
6  * contain only ASCII characters (with java-like unicode escape processing).
7  */

8
9 public final class JavaCharStream
10 {
11   public static final boolean staticFlag = false;
12   static final int hexval(char c) throws java.io.IOException {
13     switch(c)
14     {
15        case '0' :
16           return 0;
17        case '1' :
18           return 1;
19        case '2' :
20           return 2;
21        case '3' :
22           return 3;
23        case '4' :
24           return 4;
25        case '5' :
26           return 5;
27        case '6' :
28           return 6;
29        case '7' :
30           return 7;
31        case '8' :
32           return 8;
33        case '9' :
34           return 9;
35
36        case 'a' :
37        case 'A' :
38           return 10;
39        case 'b' :
40        case 'B' :
41           return 11;
42        case 'c' :
43        case 'C' :
44           return 12;
45        case 'd' :
46        case 'D' :
47           return 13;
48        case 'e' :
49        case 'E' :
50           return 14;
51        case 'f' :
52        case 'F' :
53           return 15;
54     }
55
56     throw new java.io.IOException(); // Should never come here
57
}
58
59   public int bufpos = -1;
60   int bufsize;
61   int available;
62   int tokenBegin;
63   private int bufline[];
64   private int bufcolumn[];
65
66   private int column = 0;
67   private int line = 1;
68
69   private boolean prevCharIsCR = false;
70   private boolean prevCharIsLF = false;
71
72   private java.io.Reader inputStream;
73
74   private char[] nextCharBuf;
75   private char[] buffer;
76   private int maxNextCharInd = 0;
77   private int nextCharInd = -1;
78   private int inBuf = 0;
79
80   private final void ExpandBuff(boolean wrapAround)
81   {
82      char[] newbuffer = new char[bufsize + 2048];
83      int newbufline[] = new int[bufsize + 2048];
84      int newbufcolumn[] = new int[bufsize + 2048];
85
86      try
87      {
88         if (wrapAround)
89         {
90            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
91            System.arraycopy(buffer, 0, newbuffer,
92                                              bufsize - tokenBegin, bufpos);
93            buffer = newbuffer;
94
95            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
96            System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
97            bufline = newbufline;
98
99            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
100            System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
101            bufcolumn = newbufcolumn;
102
103            bufpos += (bufsize - tokenBegin);
104         }
105         else
106         {
107            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
108            buffer = newbuffer;
109
110            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
111            bufline = newbufline;
112
113            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
114            bufcolumn = newbufcolumn;
115
116            bufpos -= tokenBegin;
117         }
118      }
119      catch (Throwable t)
120      {
121         throw new Error(t.getMessage());
122      }
123
124      available = (bufsize += 2048);
125      tokenBegin = 0;
126   }
127
128   private final void FillBuff() throws java.io.IOException
129   {
130      int i;
131      if (maxNextCharInd == 4096)
132         maxNextCharInd = nextCharInd = 0;
133
134      try {
135         if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
136                                             4096 - maxNextCharInd)) == -1)
137         {
138            inputStream.close();
139            throw new java.io.IOException();
140         }
141         else
142            maxNextCharInd += i;
143         return;
144      }
145      catch(java.io.IOException e) {
146         if (bufpos != 0)
147         {
148            --bufpos;
149            backup(0);
150         }
151         else
152         {
153            bufline[bufpos] = line;
154            bufcolumn[bufpos] = column;
155         }
156         throw e;
157      }
158   }
159
160   private final char ReadByte() throws java.io.IOException
161   {
162      if (++nextCharInd >= maxNextCharInd)
163         FillBuff();
164
165      return nextCharBuf[nextCharInd];
166   }
167
168   public final char BeginToken() throws java.io.IOException
169   {
170      if (inBuf > 0)
171      {
172         --inBuf;
173
174         if (++bufpos == bufsize)
175            bufpos = 0;
176
177         tokenBegin = bufpos;
178         return buffer[bufpos];
179      }
180
181      tokenBegin = 0;
182      bufpos = -1;
183
184      return readChar();
185   }
186
187   private final void AdjustBuffSize()
188   {
189      if (available == bufsize)
190      {
191         if (tokenBegin > 2048)
192         {
193            bufpos = 0;
194            available = tokenBegin;
195         }
196         else
197            ExpandBuff(false);
198      }
199      else if (available > tokenBegin)
200         available = bufsize;
201      else if ((tokenBegin - available) < 2048)
202         ExpandBuff(true);
203      else
204         available = tokenBegin;
205   }
206
207   private final void UpdateLineColumn(char c)
208   {
209      column++;
210
211      if (prevCharIsLF)
212      {
213         prevCharIsLF = false;
214         line += (column = 1);
215      }
216      else if (prevCharIsCR)
217      {
218         prevCharIsCR = false;
219         if (c == '\n')
220         {
221            prevCharIsLF = true;
222         }
223         else
224            line += (column = 1);
225      }
226
227      switch (c)
228      {
229         case '\r' :
230            prevCharIsCR = true;
231            break;
232         case '\n' :
233            prevCharIsLF = true;
234            break;
235         case '\t' :
236            column--;
237            column += (8 - (column & 07));
238            break;
239         default :
240            break;
241      }
242
243      bufline[bufpos] = line;
244      bufcolumn[bufpos] = column;
245   }
246
247   public final char readChar() throws java.io.IOException
248   {
249      if (inBuf > 0)
250      {
251         --inBuf;
252
253         if (++bufpos == bufsize)
254            bufpos = 0;
255
256         return buffer[bufpos];
257      }
258
259      char c;
260
261      if (++bufpos == available)
262         AdjustBuffSize();
263
264      if ((buffer[bufpos] = c = ReadByte()) == '\\')
265      {
266         UpdateLineColumn(c);
267
268         int backSlashCnt = 1;
269
270         for (;;) // Read all the backslashes
271
{
272            if (++bufpos == available)
273               AdjustBuffSize();
274
275            try
276            {
277               if ((buffer[bufpos] = c = ReadByte()) != '\\')
278               {
279                  UpdateLineColumn(c);
280                  // found a non-backslash char.
281
if ((c == 'u') && ((backSlashCnt & 1) == 1))
282                  {
283                     if (--bufpos < 0)
284                        bufpos = bufsize - 1;
285
286                     break;
287                  }
288
289                  backup(backSlashCnt);
290                  return '\\';
291               }
292            }
293            catch(java.io.IOException e)
294            {
295               if (backSlashCnt > 1)
296                  backup(backSlashCnt);
297
298               return '\\';
299            }
300
301            UpdateLineColumn(c);
302            backSlashCnt++;
303         }
304
305         // Here, we have seen an odd number of backslash's followed by a 'u'
306
try
307         {
308            while ((c = ReadByte()) == 'u')
309               ++column;
310
311            buffer[bufpos] = c = (char)(hexval(c) << 12 |
312                                        hexval(ReadByte()) << 8 |
313                                        hexval(ReadByte()) << 4 |
314                                        hexval(ReadByte()));
315
316            column += 4;
317         }
318         catch(java.io.IOException e)
319         {
320            throw new Error("Invalid escape character at line " + line +
321                                          " column " + column + ".");
322         }
323
324         if (backSlashCnt == 1)
325            return c;
326         else
327         {
328            backup(backSlashCnt - 1);
329            return '\\';
330         }
331      }
332      else
333      {
334         UpdateLineColumn(c);
335         return (c);
336      }
337   }
338
339   /**
340    * @deprecated
341    * @see #getEndColumn
342    */

343
344   public final int getColumn() {
345      return bufcolumn[bufpos];
346   }
347
348   /**
349    * @deprecated
350    * @see #getEndLine
351    */

352
353   public final int getLine() {
354      return bufline[bufpos];
355   }
356
357   public final int getEndColumn() {
358      return bufcolumn[bufpos];
359   }
360
361   public final int getEndLine() {
362      return bufline[bufpos];
363   }
364
365   public final int getBeginColumn() {
366      return bufcolumn[tokenBegin];
367   }
368
369   public final int getBeginLine() {
370      return bufline[tokenBegin];
371   }
372
373   public final void backup(int amount) {
374
375     inBuf += amount;
376     if ((bufpos -= amount) < 0)
377        bufpos += bufsize;
378   }
379
380   public JavaCharStream(java.io.Reader dstream,
381                  int startline, int startcolumn, int buffersize)
382   {
383     inputStream = dstream;
384     line = startline;
385     column = startcolumn - 1;
386
387     available = bufsize = buffersize;
388     buffer = new char[buffersize];
389     bufline = new int[buffersize];
390     bufcolumn = new int[buffersize];
391     nextCharBuf = new char[4096];
392   }
393
394   public JavaCharStream(java.io.Reader dstream,
395                                         int startline, int startcolumn)
396   {
397      this(dstream, startline, startcolumn, 4096);
398   }
399
400   public JavaCharStream(java.io.Reader dstream)
401   {
402      this(dstream, 1, 1, 4096);
403   }
404   public void ReInit(java.io.Reader dstream,
405                  int startline, int startcolumn, int buffersize)
406   {
407     inputStream = dstream;
408     line = startline;
409     column = startcolumn - 1;
410
411     if (buffer == null || buffersize != buffer.length)
412     {
413       available = bufsize = buffersize;
414       buffer = new char[buffersize];
415       bufline = new int[buffersize];
416       bufcolumn = new int[buffersize];
417       nextCharBuf = new char[4096];
418     }
419     prevCharIsLF = prevCharIsCR = false;
420     tokenBegin = inBuf = maxNextCharInd = 0;
421     nextCharInd = bufpos = -1;
422   }
423
424   public void ReInit(java.io.Reader dstream,
425                                         int startline, int startcolumn)
426   {
427      ReInit(dstream, startline, startcolumn, 4096);
428   }
429
430   public void ReInit(java.io.Reader dstream)
431   {
432      ReInit(dstream, 1, 1, 4096);
433   }
434   public JavaCharStream(java.io.InputStream dstream, int startline,
435   int startcolumn, int buffersize)
436   {
437      this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
438   }
439
440   public JavaCharStream(java.io.InputStream dstream, int startline,
441                                                            int startcolumn)
442   {
443      this(dstream, startline, startcolumn, 4096);
444   }
445
446   public JavaCharStream(java.io.InputStream dstream)
447   {
448      this(dstream, 1, 1, 4096);
449   }
450
451   public void ReInit(java.io.InputStream dstream, int startline,
452   int startcolumn, int buffersize)
453   {
454      ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
455   }
456   public void ReInit(java.io.InputStream dstream, int startline,
457                                                            int startcolumn)
458   {
459      ReInit(dstream, startline, startcolumn, 4096);
460   }
461   public void ReInit(java.io.InputStream dstream)
462   {
463      ReInit(dstream, 1, 1, 4096);
464   }
465
466   public final String GetImage()
467   {
468      if (bufpos >= tokenBegin)
469         return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
470      else
471         return new String(buffer, tokenBegin, bufsize - tokenBegin) +
472                               new String(buffer, 0, bufpos + 1);
473   }
474
475   public final char[] GetSuffix(int len)
476   {
477      char[] ret = new char[len];
478
479      if ((bufpos + 1) >= len)
480         System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
481      else
482      {
483         System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
484                                                           len - bufpos - 1);
485         System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
486      }
487
488      return ret;
489   }
490
491   public void Done()
492   {
493      nextCharBuf = null;
494      buffer = null;
495      bufline = null;
496      bufcolumn = null;
497   }
498
499   /**
500    * Method to adjust line and column numbers for the start of a token.<BR>
501    */

502   public void adjustBeginLineColumn(int newLine, int newCol)
503   {
504      int start = tokenBegin;
505      int len;
506
507      if (bufpos >= tokenBegin)
508      {
509         len = bufpos - tokenBegin + inBuf + 1;
510      }
511      else
512      {
513         len = bufsize - tokenBegin + bufpos + 1 + inBuf;
514      }
515
516      int i = 0, j = 0, k = 0;
517      int nextColDiff = 0, columnDiff = 0;
518
519      while (i < len &&
520             bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
521      {
522         bufline[j] = newLine;
523         nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
524         bufcolumn[j] = newCol + columnDiff;
525         columnDiff = nextColDiff;
526         i++;
527      }
528
529      if (i < len)
530      {
531         bufline[j] = newLine++;
532         bufcolumn[j] = newCol + columnDiff;
533
534         while (i++ < len)
535         {
536            if (bufline[j = start % bufsize] != bufline[++start % bufsize])
537               bufline[j] = newLine++;
538            else
539               bufline[j] = newLine;
540         }
541      }
542
543      line = bufline[j];
544      column = bufcolumn[j];
545   }
546
547 }
548
Popular Tags