/**

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;

private Map<String, Integer> namedGroups;

/**

Matcher() {

}

/**

Matcher(Pattern parent, CharSequence text) {

this.parentPattern = parent;

this.text = text;

// Allocate state storage

groups = new int[parent.capturingGroupCount * 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() {

int minStart;

String capturedText;

if (hasMatch()) {

minStart = minStart();

capturedText = text.subSequence(minStart, maxEnd()).toString();

} else {

minStart = -1;

capturedText = null;

}

return new ImmutableMatchResult(first, last, groupCount(),

groups.clone(), capturedText,

namedGroups(), minStart);

}

private int minStart() {

int r = text.length();

for (int group = 0; group <= groupCount(); ++group) {

int start = groups[group * 2];

if (start >= 0) {

r = Math.min(r, start);

}

}

return r;

}

private int maxEnd() {

int r = 0;

for (int group = 0; group <= groupCount(); ++group) {

int end = groups[group * 2 + 1];

if (end >= 0) {

r = Math.max(r, end);

}

}

return r;

}

private static class ImmutableMatchResult implements MatchResult {

private final int first;

private final int last;

private final int groupCount;

private final int[] groups;

private final String text;

private final Map<String, Integer> namedGroups;

private final int minStart;

ImmutableMatchResult(int first, int last, int groupCount,

int[] groups, String text,

Map<String, Integer> namedGroups, int minStart) {

this.first = first;

this.last = last;

this.groupCount = groupCount;

this.groups = groups;

this.text = text;

this.namedGroups = namedGroups;

this.minStart = minStart;

}

@Override

public int start() {

checkMatch();

return first;

}

@Override

public int start(int group) {

checkMatch();

checkGroup(group);

return groups[group * 2];

}

@Override

public int end() {

checkMatch();

return last;

}

@Override

public int end(int group) {

checkMatch();

checkGroup(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();

checkGroup(group);

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

return null;

return text.substring(groups[group * 2] - minStart, groups[group * 2 + 1] - minStart);

}

@Override

public Map<String, Integer> namedGroups() {

return namedGroups;

}

@Override

public boolean hasMatch() {

return first >= 0;

}

private void checkGroup(int group) {

if (group < 0 || group > groupCount)

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

}

private void checkMatch() {

if (!hasMatch())

throw new IllegalStateException("No match found");

}

}

/**

public Matcher usePattern(Pattern newPattern) {

if (newPattern == null)

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

parentPattern = newPattern;

namedGroups = null;

// Reallocate state storage

groups = new int[newPattern.capturingGroupCount * 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() {

checkMatch();

return first;

}

/**

public int start(int group) {

checkMatch();

checkGroup(group);

return groups[group * 2];

}

/**

public int start(String name) {

return groups[getMatchedGroupIndex(name) * 2];

}

/**

public int end() {

checkMatch();

return last;

}

/**

public int end(int group) {

checkMatch();

checkGroup(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) {

checkMatch();

checkGroup(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) {

checkMatch();

int curLen = sb.length();

try {

// Append the intervening text

sb.append(text, lastAppendPosition, first);

// Append the match substitution

appendExpandedReplacement(sb, replacement);

} catch (IllegalArgumentException e) {

sb.setLength(curLen);

throw e;

}

lastAppendPosition = last;

modCount++;

return this;

}

/**