gt:         bufcolumn = new int[buffersize];
context: package org.apache.velocity.runtime.parser;
  
  import java.io.CharArrayReader;
  import java.io.IOException;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  
  import com.dotmarketing.util.Logger;
  
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.    
   */
  
  /**
   *  NOTE : This class was originally an ASCII_CharStream autogenerated
   *  by Javacc.  It was then modified via changing class name with appropriate
   *  fixes for CTORS, and mods to readChar().
   *
   *  This is safe because we *always* use Reader with this class, and never a
   *  InputStream.  This guarantees that we have a correct stream of 16-bit
   *  chars - all encoding transformations have been done elsewhere, so we
   *  believe that there is no risk in doing this.  Time will tell :)
   */
  
  /**
   * An implementation of interface CharStream, where the stream is assumed to
   * contain only ASCII characters (without unicode processing).
   */
  
  public final class VelocityCharStream
  implements CharStream, Serializable
  {
      private static final long serialVersionUID = 3912314600586227564L;
      public static final boolean staticFlag = false;
      int bufsize;
      private int nextBufExpand;
      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 transient java.io.Reader inputStream;
  
      private char[] buffer;
      private char[] dataForInputStream;
      private int maxNextCharInd = 0;
      private int inBuf = 0;
  
      private final void ExpandBuff(boolean wrapAround)
      {
          char[] newbuffer = new char[bufsize + nextBufExpand];
          int newbufline[] = new int[bufsize + nextBufExpand];
          int newbufcolumn[] = new int[bufsize + nextBufExpand];
  
          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 += nextBufExpand;
          nextBufExpand = bufsize;
          available = bufsize;
          tokenBegin = 0;
      }
  
      private final void FillBuff() throws java.io.IOException
      {
          if (maxNextCharInd == available)
          {
              if (available == bufsize)
              {
                  if (tokenBegin > nextBufExpand)
                  {
                      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) < nextBufExpand)
              {
                  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;
          }
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#BeginToken()
       */
      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;
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#readChar()
       */
      public final char readChar() throws java.io.IOException
      {
          if (inBuf > 0)
          {
              --inBuf;
  
              /*
               *  was : return (char)((char)0xff & buffer[(bufpos == bufsize - 1) ? (bufpos = 0) : ++bufpos]);
               */
              return  buffer[(bufpos == bufsize - 1) ? (bufpos = 0) : ++bufpos];
          }
  
          if (++bufpos >= maxNextCharInd)
          {
              FillBuff();
          }
  
          /*
           *  was : char c = (char)((char)0xff & buffer[bufpos]);
           */
          char c = buffer[bufpos];
  
          UpdateLineColumn(c);
          return (c);
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#getColumn()
       * @deprecated
       */
      public final int getColumn() 
      {
          return bufcolumn[bufpos];
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#getLine()
       * @deprecated
       */
      public final int getLine() 
      {
          return bufline[bufpos];
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#getEndColumn()
       */
      public final int getEndColumn() 
      {
          return bufcolumn[bufpos];
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#getEndLine()
       */
      public final int getEndLine() 
      {
          return bufline[bufpos];
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#getBeginColumn()
       */
      public final int getBeginColumn() 
      {
          return bufcolumn[tokenBegin];
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#getBeginLine()
       */
      public final int getBeginLine() 
      {
          return bufline[tokenBegin];
      }
  
      /**
       * @see org.apache.velocity.runtime.parser.CharStream#backup(int)
       */
      public final void backup(int amount) 
      {
  
          inBuf += amount;
          if ((bufpos -= amount) < 0)
              bufpos += bufsize;
      }
  
      /**
       * @param dstream
       * @param startline
       * @param startcolumn
       * @param buffersize
       */
      public VelocityCharStream(java.io.Reader dstream, int startline,
              int startcolumn, int buffersize)
      {
          inputStream = dstream;
          line = startline;
          column = startcolumn - 1;
  
          available = bufsize = nextBufExpand = buffersize;
          buffer = new char[buffersize];
          bufline = new int[buffersize];
  