Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Generated By:JavaCC: Do not edit this line. UCode_UCodeESC_CharStream.java Version 0.7pre6 */
  /* The previous line keeps JavaCC quiet. In fact, the JavaCC generated file
     has been edited to fix some bugs. */
  package com.thaiopensource.relaxng.parse.compact;
  
  
An implementation of interface CharStream, where the stream is assumed to contain 16-bit unicode characters.
 
 public final class UCode_UCodeESC_CharStream {
   public static final boolean staticFlag = false;
 
   static final int hexval(char c) {
     switch (c) {
     case '0':
       return 0;
     case '1':
       return 1;
     case '2':
       return 2;
     case '3':
       return 3;
     case '4':
       return 4;
     case '5':
       return 5;
     case '6':
       return 6;
     case '7':
       return 7;
     case '8':
       return 8;
     case '9':
       return 9;
 
     case 'a':
     case 'A':
       return 10;
     case 'b':
     case 'B':
       return 11;
     case 'c':
     case 'C':
       return 12;
     case 'd':
     case 'D':
       return 13;
     case 'e':
     case 'E':
       return 14;
     case 'f':
     case 'F':
       return 15;
     }
     return -1;
   }
 
   public int bufpos = -1;
   int bufsize;
   int available;
   int tokenBegin;
   private int bufline[];
   private int bufcolumn[];
 
   private int column = 0;
   private int line = 1;
 
   private java.io.Reader inputStream;
   private boolean closed = false;
 
   private boolean prevCharIsLF = false;
 
   private char[] nextCharBuf;
   private char[] buffer;
   private int maxNextCharInd = 0;
   private int nextCharInd = -1;
   private int inBuf = 0;
 
   private final void ExpandBuff(boolean wrapAround) {
     char[] newbuffer = new char[ + 2048];
     int newbufline[] = new int[ + 2048];
     int newbufcolumn[] = new int[ + 2048];
 
     if (wrapAround) {
       System.arraycopy(newbuffer, 0,  - );
       System.arraycopy(, 0, newbuffer,
                         - );
        = newbuffer;
 
       System.arraycopy(newbufline, 0,  - );
       System.arraycopy(, 0, newbufline - );
        = newbufline;
 
       System.arraycopy(newbufcolumn, 0,  - );
      System.arraycopy(, 0, newbufcolumn - );
       = newbufcolumn;
       += ( - );
    }
    else {
      System.arraycopy(newbuffer, 0,  - );
       = newbuffer;
      System.arraycopy(newbufline, 0,  - );
       = newbufline;
      System.arraycopy(newbufcolumn, 0,  - );
       = newbufcolumn;
       -= ;
    }
     = ( += 2048);
     = 0;
  }
  private final void FillBuff() throws EOFException {
    int i;
    if ( == 4096)
       =  = 0;
    if ()
      throw new EOFException();
    try {
      if ((i = .read(, 4096 - )) == -1) {
         = true;
        .close();
        throw new EOFException();
      }
      else
         += i;
    }
    catch (IOException e) {
      throw new BuildException(e);
    }
  }
  private final char ReadChar() throws EOFException {
    if (++ >= )
      FillBuff();
    return [];
  }
  private final char PeekChar() throws EOFException {
    char c = ReadChar();
    --;
    return c;
  }
  public final char BeginToken() throws EOFException {
    if ( > 0) {
      --;
      return [ = ( ==  - 1) ? ( = 0)
              : ++];
    }
     = 0;
     = -1;
    return readChar();
  }
  private final void AdjustBuffSize() {
    if ( == ) {
      if ( > 2048) {
         = 0;
         = ;
      }
      else
        ExpandBuff(false);
    }
    else if ( > )
       = ;
    else if (( - ) < 2048)
      ExpandBuff(true);
    else
       = ;
  }
  private final void UpdateLineColumn(char c) {
    ++;
    if () {
       = false;
       += ( = 1);
    }
    switch (c) {
    case :
       = true;
      break;
    case '\t':
      --;
       += (8 - ( & 07));
      break;
    default :
      break;
    }
    [] = ;
    [] = ;
  }
  private final char NEWLINE_MARKER = '\u0000';
  public final char readChar() throws EOFException {
    if ( > 0) {
      --;
      return [( ==  - 1) ? ( = 0) : ++];
    }
    char c;
    try {
      c = ReadChar();
      switch (c) {
      case '\r':
        c = ;
        try {
          if (PeekChar() == '\n')
            ReadChar();
        }
        catch (EOFException e) {
        }
        break;
      case '\n':
        c = ;
        break;
      case '\t':
        break;
      default:
        if (c >= 0x20) {
          if (Utf16.isSurrogate(c)) {
            if (Utf16.isSurrogate2(c))
              throw new EscapeSyntaxException("illegal_surrogate_pair" + 1);
            if (++ == )
              AdjustBuffSize();
            [] = c;
            // UpdateLineColumn(c);
            try {
              c = ReadChar();
            }
            catch (EOFException e) {
              throw new EscapeSyntaxException("illegal_surrogate_pair" + 1);
            }
            if (!Utf16.isSurrogate2(c))
              throw new EscapeSyntaxException("illegal_surrogate_pair" + 2);
          }
          break;
        }
        // fall through
      case '\uFFFE':
      case '\uFFFF':
        throw new EscapeSyntaxException("illegal_char_code" + 1);
      }
    }
    catch (EOFException e) {
      if ( == -1) {
        if (++ == )
          AdjustBuffSize();
        [] = ;
        [] = ;
      }
      throw e;
    }
    if (++ == )
      AdjustBuffSize();
    [] = c;
    try {
      if (c != '\\' || PeekChar() != 'x')
        return c;
    }
    catch (EOFException e) {
      return c;
    }
    int xCnt = 1;
    for (;;) {
      ReadChar();
      if (++ == )
        AdjustBuffSize();
      [] = 'x';
      UpdateLineColumn('x');
      try {
        c = PeekChar();
      }
      catch (EOFException e) {
        backup(xCnt);
        return '\\';
      }
      if (c == '{') {
        ReadChar();
        ++;
        // backup past the 'x's
         -= xCnt;
        if ( < 0)
           += ;
        break;
      }
      if (c != 'x') {
        backup(xCnt);
        return '\\';
      }
      xCnt++;
    }
    try {
      int scalarValue = hexval(ReadChar());
      ++;
      if (scalarValue < 0)
        throw new EscapeSyntaxException("illegal_hex_digit");
      while ((c = ReadChar()) != '}') {
        ++;
        int n = hexval(c);
        if (n < 0)
          throw new EscapeSyntaxException("illegal_hex_digit");
        scalarValue <<= 4;
        scalarValue |= n;
        if (scalarValue >= 0x110000)
          throw new EscapeSyntaxException("char_code_too_big");
      }
      ++; // for the '}'
      if (scalarValue <= 0xFFFF) {
        c = (char)scalarValue;
        switch (c) {
        case '\n':
        case '\r':
        case '\t':
          break;
        default:
          if (c >= 0x20 && !Utf16.isSurrogate(c))
            break;
          // fall through
        case '\uFFFE':
        case '\uFFFF':
          throw new EscapeSyntaxException("illegal_char_code_ref");
        }
        [] = c;
        return c;
      }
      c = Utf16.surrogate1(scalarValue);
      [] = c;
      int bufpos1 = ;
      if (++ == )
         = 0;
      [] = Utf16.surrogate2(scalarValue);
      [] = [bufpos1];
      [] = [bufpos1];
      backup(1);
      return c;
    }
    catch (EOFException e) {
      throw new EscapeSyntaxException("incomplete_escape");
    }
  }

  

Deprecated:
See also:
getEndColumn()
  public final int getColumn() {
    return [];
  }

  

Deprecated:
See also:
getEndLine()
  public final int getLine() {
    return [];
  }
  public final int getEndColumn() {
    return [];
  }
  public final int getEndLine() {
    return [];
  }
  public final int getBeginColumn() {
    return [];
  }
  public final int getBeginLine() {
    return [];
  }
  public final void backup(int amount) {
     += amount;
    if (( -= amount) < 0)
       += ;
  }
                                   int startlineint startcolumnint buffersize) {
     = dstream;
     = startline;
     = startcolumn - 1;
     =  = buffersize;
     = new char[buffersize];
     = new int[buffersize];
     = new int[buffersize];
     = new char[4096];
    skipBOM();
  }
                                   int startlineint startcolumn) {
    this(dstreamstartlinestartcolumn, 4096);
  }
  public void ReInit(java.io.Reader dstream,
                     int startlineint startcolumnint buffersize) {
     = dstream;
     = false;
     = startline;
     = startcolumn - 1;
    if ( == null || buffersize != .) {
       =  = buffersize;
       = new char[buffersize];
       = new int[buffersize];
       = new int[buffersize];
       = new char[4096];
    }
     = false;
     =  =  = 0;
     =  = -1;
    skipBOM();
  }
  public void ReInit(java.io.Reader dstream,
                     int startlineint startcolumn) {
    ReInit(dstreamstartlinestartcolumn, 4096);
  }
  public UCode_UCodeESC_CharStream(java.io.InputStream dstreamint startline,
                                   int startcolumnint buffersize) {
    this(new java.io.InputStreamReader(dstream), startlinestartcolumn, 4096);
  }
  public UCode_UCodeESC_CharStream(java.io.InputStream dstreamint startline,
                                   int startcolumn) {
    this(dstreamstartlinestartcolumn, 4096);
  }
  public void ReInit(java.io.InputStream dstreamint startline,
                     int startcolumnint buffersize) {
    ReInit(new java.io.InputStreamReader(dstream), startlinestartcolumn, 4096);
  }
  public void ReInit(java.io.InputStream dstreamint startline,
                     int startcolumn) {
    ReInit(dstreamstartlinestartcolumn, 4096);
  }
  static private final char BOM = '\ufeff';
  private void skipBOM() {
    try {
      if (PeekChar() == )
        ReadChar();
    }
    catch (EOFException e) {
    }
  }
  public final String GetImage() {
    if ( >= )
      return new String( -  + 1);
    else
      return new String( - ) +
              new String(, 0,  + 1);
  }
  public final char[] GetSuffix(int len) {
    char[] ret = new char[len];
    if (( + 1) >= len)
      System.arraycopy( - len + 1, ret, 0, len);
    else {
      System.arraycopy( - (len -  - 1), ret, 0,
                       len -  - 1);
      System.arraycopy(, 0, retlen -  - 1,  + 1);
    }
    return ret;
  }
  public void Done() {
     = null;
     = null;
     = null;
     = null;
  }

  
Method to adjust line and column numbers for the start of a token.
  public void adjustBeginLineColumn(int newLineint newCol) {
    int start = ;
    int len;
    if ( >= ) {
      len =  -  +  + 1;
    }
    else {
      len =  -  +  + 1 + ;
    }
    int i = 0, j = 0, k = 0;
    int nextColDiff = 0, columnDiff = 0;
    while (i < len &&
            [j = start % ] == [k = ++start % ]) {
      [j] = newLine;
      nextColDiff = columnDiff + [k] - [j];
      [j] = newCol + columnDiff;
      columnDiff = nextColDiff;
      i++;
    }
    if (i < len) {
      [j] = newLine++;
      [j] = newCol + columnDiff;
      while (i++ < len) {
        if ([j = start % ] != [++start % ])
          [j] = newLine++;
        else
          [j] = newLine;
      }
    }
     = [j];
     = [j];
  }
New to GrepCode? Check out our FAQ X