/**

Pattern parentPattern;

/**

int[] groups;

/**

int from, to;

/**

int lookbehindTo;

/**

CharSequence text;

/**

static final int ENDANCHOR = 1;

static final int NOANCHOR = 0;

int acceptMode = NOANCHOR;

/**

int first = -1, last = 0;

/**

int oldLast = -1;

/**

int lastAppendPosition = 0;

/**

int[] locals;

/**

IntHashSet[] localsPos;

/**

boolean hitEnd;

/**

boolean requireEnd;

/**

boolean transparentBounds = false;

/**

boolean anchoringBounds = true;

/**

int modCount;

/**

Matcher() {

}

/**

Matcher(Pattern parent, CharSequence text) {

this.parentPattern = parent;

this.text = text;

// Allocate state storage

int parentGroupCount = Math.max(parent.capturingGroupCount, 10);

groups = new int[parentGroupCount * 2];

locals = new int[parent.localCount];

localsPos = new IntHashSet[parent.localTCNCount];

// Put fields into initial states

reset();

}

/**

public Pattern pattern() {

return parentPattern;

}

/**

public MatchResult toMatchResult() {

return toMatchResult(text.toString());

}

private MatchResult toMatchResult(String text) {

return new ImmutableMatchResult(this.first,

this.last,

groupCount(),

this.groups.clone(),

text);

}

private static class ImmutableMatchResult implements MatchResult {

private final int first;

private final int last;

private final int[] groups;

private final int groupCount;

private final String text;

ImmutableMatchResult(int first, int last, int groupCount,

int groups[], String text)

{

this.first = first;

this.last = last;

this.groupCount = groupCount;

this.groups = groups;

this.text = text;

}

@Override

public int start() {

checkMatch();

return first;

}

@Override

public int start(int group) {

checkMatch();

if (group < 0 || group > groupCount)

throw new IndexOutOfBoundsException("No group " + group);

return groups[group * 2];

}

@Override

public int end() {

checkMatch();

return last;

}

@Override

public int end(int group) {

checkMatch();

if (group < 0 || group > groupCount)

throw new IndexOutOfBoundsException("No group " + group);

return groups[group * 2 + 1];

}

@Override

public int groupCount() {

return groupCount;

}

@Override

public String group() {

checkMatch();

return group(0);

}

@Override

public String group(int group) {

checkMatch();

if (group < 0 || group > groupCount)

throw new IndexOutOfBoundsException("No group " + group);

if ((groups[group*2] == -1) || (groups[group*2+1] == -1))

return null;

return text.subSequence(groups[group * 2], groups[group * 2 + 1]).toString();

}

private void checkMatch() {

if (first < 0)

throw new IllegalStateException("No match found");

}

}

/**

public Matcher usePattern(Pattern newPattern) {

if (newPattern == null)

throw new IllegalArgumentException("Pattern cannot be null");

parentPattern = newPattern;

// Reallocate state storage

int parentGroupCount = Math.max(newPattern.capturingGroupCount, 10);

groups = new int[parentGroupCount * 2];

locals = new int[newPattern.localCount];

for (int i = 0; i < groups.length; i++)

groups[i] = -1;

for (int i = 0; i < locals.length; i++)

locals[i] = -1;

localsPos = new IntHashSet[parentPattern.localTCNCount];

modCount++;

return this;

}

/**

public Matcher reset() {

first = -1;

last = 0;

oldLast = -1;

for(int i=0; i<groups.length; i++)

groups[i] = -1;

for(int i=0; i<locals.length; i++)

locals[i] = -1;

for (int i = 0; i < localsPos.length; i++) {

if (localsPos[i] != null)

localsPos[i].clear();

}

lastAppendPosition = 0;

from = 0;

to = getTextLength();

modCount++;

return this;

}

/**

public Matcher reset(CharSequence input) {

text = input;

return reset();

}

/**

public int start() {

if (first < 0)

throw new IllegalStateException("No match available");

return first;

}

/**

public int start(int group) {

if (first < 0)

throw new IllegalStateException("No match available");

if (group < 0 || group > groupCount())

throw new IndexOutOfBoundsException("No group " + group);

return groups[group * 2];

}

/**

public int start(String name) {

return groups[getMatchedGroupIndex(name) * 2];

}

/**

public int end() {

if (first < 0)

throw new IllegalStateException("No match available");

return last;

}

/**

public int end(int group) {

if (first < 0)

throw new IllegalStateException("No match available");

if (group < 0 || group > groupCount())

throw new IndexOutOfBoundsException("No group " + group);

return groups[group * 2 + 1];

}

/**

public int end(String name) {

return groups[getMatchedGroupIndex(name) * 2 + 1];

}

/**

public String group() {

return group(0);

}

/**

public String group(int group) {

if (first < 0)

throw new IllegalStateException("No match found");

if (group < 0 || group > groupCount())

throw new IndexOutOfBoundsException("No group " + group);

if ((groups[group*2] == -1) || (groups[group*2+1] == -1))

return null;

return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();

}

/**

public String group(String name) {

int group = getMatchedGroupIndex(name);

if ((groups[group*2] == -1) || (groups[group*2+1] == -1))

return null;

return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();

}

/**

public int groupCount() {

return parentPattern.capturingGroupCount - 1;

}

/**

public boolean matches() {

return match(from, ENDANCHOR);

}

/**

public boolean find() {

int nextSearchIndex = last;

if (nextSearchIndex == first)

nextSearchIndex++;

// If next search starts before region, start it at region

if (nextSearchIndex < from)

nextSearchIndex = from;

// If next search starts beyond region then it fails

if (nextSearchIndex > to) {

for (int i = 0; i < groups.length; i++)

groups[i] = -1;

return false;

}

return search(nextSearchIndex);

}

/**

public boolean find(int start) {

int limit = getTextLength();

if ((start < 0) || (start > limit))

throw new IndexOutOfBoundsException("Illegal start index");

reset();

return search(start);

}

/**

public boolean lookingAt() {

return match(from, NOANCHOR);

}

/**

public static String quoteReplacement(String s) {

if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))

return s;

StringBuilder sb = new StringBuilder();

for (int i=0; i<s.length(); i++) {

char c = s.charAt(i);

if (c == '\\' || c == '$') {

sb.append('\\');

}

sb.append(c);

}

return sb.toString();

}

/**

public Matcher appendReplacement(StringBuffer sb, String replacement) {

// If no match, return error

if (first < 0)

throw new IllegalStateException("No match available");

StringBuilder result = new StringBuilder();

appendExpandedReplacement(replacement, result);

// Append the intervening text

sb.append(text, lastAppendPosition, first);

// Append the match substitution

sb.append(result);

lastAppendPosition = last;

modCount++;

return this;

}

/**

public Matcher appendReplacement(StringBuilder sb, String replacement) {

// If no match, return error

if (first < 0)

throw new IllegalStateException("No match available");

StringBuilder result = new StringBuilder();

appendExpandedReplacement(replacement, result);

// Append the intervening text

sb.append(text, lastAppendPosition, first);