else if (unit.bk && (unit.ch == 'B') && syntax.get(RESyntax.RE_STRING_ANCHORS)) {	  addToken(currentToken);	  currentToken = new RETokenWordBoundary(subIndex, RETokenWordBoundary.BEGIN | RETokenWordBoundary.END, true);      }             // DIGIT OPERATOR      //  \d if RE_CHAR_CLASS_ESCAPES is set            else if (unit.bk && (unit.ch == 'd') && syntax.get(RESyntax.RE_CHAR_CLASS_ESCAPES)) {	addToken(currentToken);	currentToken = new RETokenPOSIX(subIndex,RETokenPOSIX.DIGIT,insens,false);      }      // NON-DIGIT OPERATOR      //  \D	else if (unit.bk && (unit.ch == 'D') && syntax.get(RESyntax.RE_CHAR_CLASS_ESCAPES)) {	  addToken(currentToken);	  currentToken = new RETokenPOSIX(subIndex,RETokenPOSIX.DIGIT,insens,true);	}	// NEWLINE ESCAPE        //  \n	else if (unit.bk && (unit.ch == 'n')) {	  addToken(currentToken);	  currentToken = new RETokenChar(subIndex,'\n',false);	}	// RETURN ESCAPE        //  \r	else if (unit.bk && (unit.ch == 'r')) {	  addToken(currentToken);	  currentToken = new RETokenChar(subIndex,'\r',false);	}	// WHITESPACE OPERATOR        //  \s if RE_CHAR_CLASS_ESCAPES is set	else if (unit.bk && (unit.ch == 's') && syntax.get(RESyntax.RE_CHAR_CLASS_ESCAPES)) {	  addToken(currentToken);	  currentToken = new RETokenPOSIX(subIndex,RETokenPOSIX.SPACE,insens,false);	}	// NON-WHITESPACE OPERATOR        //  \S	else if (unit.bk && (unit.ch == 'S') && syntax.get(RESyntax.RE_CHAR_CLASS_ESCAPES)) {	  addToken(currentToken);	  currentToken = new RETokenPOSIX(subIndex,RETokenPOSIX.SPACE,insens,true);	}	// TAB ESCAPE        //  \t	else if (unit.bk && (unit.ch == 't')) {	  addToken(currentToken);	  currentToken = new RETokenChar(subIndex,'\t',false);	}	// ALPHANUMERIC OPERATOR        //  \w	else if (unit.bk && (unit.ch == 'w') && syntax.get(RESyntax.RE_CHAR_CLASS_ESCAPES)) {	  addToken(currentToken);	  currentToken = new RETokenPOSIX(subIndex,RETokenPOSIX.ALNUM,insens,false);	}	// NON-ALPHANUMERIC OPERATOR        //  \W	else if (unit.bk && (unit.ch == 'W') && syntax.get(RESyntax.RE_CHAR_CLASS_ESCAPES)) {	  addToken(currentToken);	  currentToken = new RETokenPOSIX(subIndex,RETokenPOSIX.ALNUM,insens,true);	}	// END OF STRING OPERATOR        //  \Z	else if (unit.bk && (unit.ch == 'Z') && syntax.get(RESyntax.RE_STRING_ANCHORS)) {	  addToken(currentToken);	  currentToken = new RETokenEnd(subIndex,null);	}	// NON-SPECIAL CHARACTER (or escape to make literal)        //  c | \* for example	else {  // not a special character	  addToken(currentToken);	  currentToken = new RETokenChar(subIndex,unit.ch,insens);	}       } // end while    // Add final buffered token and an EndSub marker    addToken(currentToken);          if (branches != null) {	branches.addElement(new RE(firstToken,lastToken,numSubs,subIndex,minimumLength));	branches.trimToSize(); // compact the Vector	minimumLength = 0;	firstToken = lastToken = null;	addToken(new RETokenOneOf(subIndex,branches,false));    }     else addToken(new RETokenEndSub(subIndex));  }  private static int getCharUnit(char[] input, int index, CharUnit unit) throws REException {    unit.ch = input[index++];    if (unit.bk = (unit.ch == '\\'))      if (index < input.length)	unit.ch = input[index++];      else throw new REException(getLocalizedMessage("ends.with.backslash"),REException.REG_ESCAPE,index);    return index;  }  /**   * Checks if the regular expression matches the input in its entirety.   *   * @param input The input text.   */  public boolean isMatch(Object input) {    return isMatch(input,0,0);  }    /**   * Checks if the input string, starting from index, is an exact match of   * this regular expression.   *   * @param input The input text.   * @param index The offset index at which the search should be begin.   */  public boolean isMatch(Object input,int index) {    return isMatch(input,index,0);  }    /**   * Checks if the input, starting from index and using the specified   * execution flags, is an exact match of this regular expression.   *   * @param input The input text.   * @param index The offset index at which the search should be begin.   * @param eflags The logical OR of any execution flags above.   */  public boolean isMatch(Object input,int index,int eflags) {    return isMatchImpl(makeCharIndexed(input,index),index,eflags);  }  private boolean isMatchImpl(CharIndexed input, int index, int eflags) {    if (firstToken == null)  // Trivial case      return (input.charAt(0) == CharIndexed.OUT_OF_BOUNDS);    REMatch m = new REMatch(numSubs, index, eflags);    if (firstToken.match(input, m)) {	while (m != null) {	    if (input.charAt(m.index) == CharIndexed.OUT_OF_BOUNDS) {		return true;	    }	    m = m.next;	}    }    return false;  }      /**   * Returns the maximum number of subexpressions in this regular expression.   * If the expression contains branches, the value returned will be the   * maximum subexpressions in any of the branches.   */  public int getNumSubs() {    return numSubs;  }  // Overrides REToken.setUncle  void setUncle(REToken uncle) {      if (lastToken != null) {	  lastToken.setUncle(uncle);      } else super.setUncle(uncle); // to deal with empty subexpressions  }  // Overrides REToken.chain  boolean chain(REToken next) {    super.chain(next);    setUncle(next);    return true;  }  /**   * Returns the minimum number of characters that could possibly   * constitute a match of this regular expression.   */  public int getMinimumLength() {      return minimumLength;  }  /**   * Returns an array of all matches found in the input.   *   * If the regular expression allows the empty string to match, it will   * substitute matches at all positions except the end of the input.   *   * @param input The input text.   * @return a non-null (but possibly zero-length) array of matches   */  public REMatch[] getAllMatches(Object input) {    return getAllMatches(input,0,0);  }  /**   * Returns an array of all matches found in the input,   * beginning at the specified index position.   *   * If the regular expression allows the empty string to match, it will   * substitute matches at all positions except the end of the input.   *   * @param input The input text.   * @param index The offset index at which the search should be begin.   * @return a non-null (but possibly zero-length) array of matches   */  public REMatch[] getAllMatches(Object input, int index) {    return getAllMatches(input,index,0);  }  /**   * Returns an array of all matches found in the input string,   * beginning at the specified index position and using the specified   * execution flags.   *   * If the regular expression allows the empty string to match, it will   * substitute matches at all positions except the end of the input.   *   * @param input The input text.   * @param index The offset index at which the search should be begin.   * @param eflags The logical OR of any execution flags above.   * @return a non-null (but possibly zero-length) array of matches   */  public REMatch[] getAllMatches(Object input, int index, int eflags) {    return getAllMatchesImpl(makeCharIndexed(input,index),index,eflags);  }  // this has been changed since 1.03 to be non-overlapping matches  private REMatch[] getAllMatchesImpl(CharIndexed input, int index, int eflags) {    Vector all = new Vector();    REMatch m = null;    while ((m = getMatchImpl(input,index,eflags,null)) != null) {      all.addElement(m);      index = m.getEndIndex();      if (m.end[0] == 0) {   // handle pathological case of zero-length match	index++;	input.move(1);      } else {	input.move(m.end[0]);      }      if (!input.isValid()) break;    }    REMatch[] mset = new REMatch[all.size()];    all.copyInto(mset);    return mset;  }      /* Implements abstract method REToken.match() */    boolean match(CharIndexed input, REMatch mymatch) { 	if (firstToken == null) return next(input, mymatch);	// Note the start of this subexpression	mymatch.start[subIndex] = mymatch.index;	return firstToken.match(input, mymatch);    }    /**   * Returns the first match found in the input.  If no match is found,   * null is returned.   *   * @param input The input text.   * @return An REMatch instance referencing the match, or null if none.   */  public REMatch getMatch(Object input) {    return getMatch(input,0,0);  }    /**   * Returns the first match found in the input, beginning   * the search at the specified index.  If no match is found,   * returns null.   *   * @param input The input text.   * @param index The offset within the text to begin looking for a match.   * @return An REMatch instance referencing the match, or null if none.   */  public REMatch getMatch(Object input, int index) {    return getMatch(input,index,0);  }    /**   * Returns the first match found in the input, beginning   * the search at the specified index, and using the specified   * execution flags.  If no match is found, returns null.   *   * @param input The input text.   * @param index The offset index at which the search should be begin.   * @param eflags The logical OR of any execution flags above.   * @return An REMatch instance referencing the match, or null if none.   */  public REMatch getMatch(Object input, int index, int eflags) {    return getMatch(input,index,eflags,null);  }  /**   * Returns the first match found in the input, beginning the search   * at the specified index, and using the specified execution flags.   * If no match is found, returns null.  If a StringBuffer is   * provided and is non-null, the contents of the input text from the   * index to the beginning of the match (or to the end of the input,   * if there is no match) are appended to the StringBuffer.   *   * @param input The input text.   * @param index The offset index at which the search should be begin.   * @param eflags The logical OR of any execution flags above.   * @param buffer The StringBuffer to save pre-match text in.   * @return An REMatch instance referencing the match, or null if none.  */  public REMatch getMatch(Object input, int index, int eflags, StringBuffer buffer) {    return getMatchImpl(makeCharIndexed(input,index),index,eflags,buffer);  }  REMatch getMatchImpl(CharIndexed input, int anchor, int eflags, StringBuffer buffer) {      // Create a new REMatch to hold results      REMatch mymatch = new REMatch(numSubs, anchor, eflags);      do {	  // Optimization: check if anchor + minimumLength > length	  if (minimumLength == 0 || input.charAt(minimumLength-1) != CharIndexed.OUT_OF_BOUNDS) {	      if (match(input, mymatch)) {		  // Find longest match of them all to observe leftmost longest		  REMatch longest = mymatch;		  while ((mymatch = mymatch.next) != null) {		      if (mymatch.index > longest.index) {			  longest = mymatch;