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