2008-09-01 Andrew John Hughes <gnu_andrew@member.fsf.org>

	* gnu/java/util/regex/BacktrackStack.java,
	* gnu/java/util/regex/CharIndexed.java,
	* gnu/java/util/regex/CharIndexedCharArray.java,
	* gnu/java/util/regex/CharIndexedCharSequence.java,
	* gnu/java/util/regex/CharIndexedInputStream.java,
	* gnu/java/util/regex/CharIndexedString.java,
	* gnu/java/util/regex/CharIndexedStringBuffer.java,
	* gnu/java/util/regex/RE.java,
	* gnu/java/util/regex/REException.java,
	* gnu/java/util/regex/REFilterInputStream.java,
	* gnu/java/util/regex/REMatch.java,
	* gnu/java/util/regex/REMatchEnumeration.java,
	* gnu/java/util/regex/RESyntax.java,
	* gnu/java/util/regex/REToken.java,
	* gnu/java/util/regex/RETokenAny.java,
	* gnu/java/util/regex/RETokenBackRef.java,
	* gnu/java/util/regex/RETokenChar.java,
	* gnu/java/util/regex/RETokenEnd.java,
	* gnu/java/util/regex/RETokenEndOfPreviousMatch.java,
	* gnu/java/util/regex/RETokenEndSub.java,
	* gnu/java/util/regex/RETokenIndependent.java,
	* gnu/java/util/regex/RETokenLookAhead.java,
	* gnu/java/util/regex/RETokenLookBehind.java,
	* gnu/java/util/regex/RETokenNamedProperty.java,
	* gnu/java/util/regex/RETokenOneOf.java,
	* gnu/java/util/regex/RETokenPOSIX.java,
	* gnu/java/util/regex/RETokenRange.java,
	* gnu/java/util/regex/RETokenRepeated.java,
	* gnu/java/util/regex/RETokenStart.java,
	* gnu/java/util/regex/RETokenWordBoundary.java,
	* gnu/java/util/regex/UncheckedRE.java:
	Fix indentation.

1 files changed, 200 insertions, 145 deletions

diff --git a/gnu/java/util/regex/RETokenOneOf.java b/gnu/java/util/regex/RETokenOneOf.java
index 06c8985b9..fcae3c2d1 100644
--- a/gnu/java/util/regex/RETokenOneOf.java
+++ b/gnu/java/util/regex/RETokenOneOf.java
@@ -44,14 +44,15 @@ import java.util.ArrayList;
 import java.util.Deque;
 import java.util.List;
 
-final class RETokenOneOf extends REToken {
-  private final List<REToken> options;
+final class RETokenOneOf extends REToken
+{
+  private final List < REToken > options;
   private boolean negative;
   // True if this RETokenOneOf is supposed to match only one character,
   // which is typically the case of a character class expression.
   private boolean matchesOneChar;
 
-  private final List<Object> addition;
+  private final List < Object > addition;
   // This ArrayList addition is used to store nested character classes.
   // For example, if the original expression is
   //    [2-7a-c[f-k][m-z]&&[^p-v][st]]
@@ -78,200 +79,254 @@ final class RETokenOneOf extends REToken {
   // e.g. \d --> new RETokenOneOf("0123456789",false, ..)
   //      \D --> new RETokenOneOf("0123456789",true, ..)
 
-  RETokenOneOf(int subIndex, String optionsStr, boolean negative, boolean insens) {
-    super(subIndex);
-    options = new ArrayList<REToken>();
+    RETokenOneOf (int subIndex, String optionsStr, boolean negative,
+		  boolean insens)
+  {
+    super (subIndex);
+    options = new ArrayList < REToken > ();
     this.negative = negative;
-    for (int i = 0; i < optionsStr.length(); i++)
-      options.add(new RETokenChar(subIndex,optionsStr.charAt(i),insens));
+    for (int i = 0; i < optionsStr.length (); i++)
+      options.add (new RETokenChar (subIndex, optionsStr.charAt (i), insens));
     matchesOneChar = true;
     addition = null;
   }
 
-  RETokenOneOf(int subIndex, List<REToken> options, boolean negative) {
-    this(subIndex, options, null, negative);
+  RETokenOneOf (int subIndex, List < REToken > options, boolean negative)
+  {
+    this (subIndex, options, null, negative);
   }
 
-  RETokenOneOf(int subIndex, List<REToken> options, List<Object> addition,
-	       boolean negative) {
-    super(subIndex);
+  RETokenOneOf (int subIndex, List < REToken > options,
+		List < Object > addition, boolean negative)
+  {
+    super (subIndex);
     this.options = options;
     this.addition = addition;
     this.negative = negative;
     matchesOneChar = (negative || addition != null);
   }
 
-  int getMinimumLength() {
-    if (matchesOneChar) return 1;
+  int getMinimumLength ()
+  {
+    if (matchesOneChar)
+      return 1;
     int min = Integer.MAX_VALUE;
     int x;
-    for (REToken t : options) {
-      if ((x = t.getMinimumLength()) < min)
-	min = x;
-    }
+  for (REToken t:options)
+      {
+	if ((x = t.getMinimumLength ()) < min)
+	  min = x;
+      }
     return min;
   }
 
-  int getMaximumLength() {
-    if (matchesOneChar) return 1;
+  int getMaximumLength ()
+  {
+    if (matchesOneChar)
+      return 1;
     int max = 0;
     int x;
-    for (REToken t : options) {
-      if ((x = t.getMaximumLength()) > max)
-	max = x;
-    }
+  for (REToken t:options)
+      {
+	if ((x = t.getMaximumLength ()) > max)
+	  max = x;
+      }
     return max;
   }
 
-    boolean match(CharIndexed input, REMatch mymatch) {
-      setHitEnd(input, mymatch);
-      if (matchesOneChar) return matchOneChar(input, mymatch);
-      else return matchOneRE(input, mymatch);
-    }
+  boolean match (CharIndexed input, REMatch mymatch)
+  {
+    setHitEnd (input, mymatch);
+    if (matchesOneChar)
+      return matchOneChar (input, mymatch);
+    else
+      return matchOneRE (input, mymatch);
+  }
 
-    boolean matchOneChar(CharIndexed input, REMatch mymatch) {
-      REMatch tryMatch;
-      boolean tryOnly;
-      if (addition == null) {
-	  tryMatch = mymatch;
-	  tryOnly = false;
+  boolean matchOneChar (CharIndexed input, REMatch mymatch)
+  {
+    REMatch tryMatch;
+    boolean tryOnly;
+    if (addition == null)
+      {
+	tryMatch = mymatch;
+	tryOnly = false;
       }
-      else {
-	  tryMatch = (REMatch) mymatch.clone();
-	  tryOnly = true;
+    else
+      {
+	tryMatch = (REMatch) mymatch.clone ();
+	tryOnly = true;
       }
-      boolean b = negative ?
-        matchN(input, tryMatch, tryOnly) :
-        matchP(input, tryMatch, tryOnly);
-      if (addition == null) return b;
+    boolean b = negative ?
+      matchN (input, tryMatch, tryOnly) : matchP (input, tryMatch, tryOnly);
+    if (addition == null)
+      return b;
 
-      final Deque<Boolean> stack = new ArrayDeque<Boolean>();
-      stack.push(new Boolean(b));
-      for (Object obj : addition) {
-	if (obj instanceof REToken) {
-	  b = ((REToken)obj).match(input, (REMatch)mymatch.clone());
-	  stack.push(new Boolean(b));
-	}
-	else if (obj instanceof Boolean) {
-	  stack.push((Boolean) obj);
-	}
-	else if (obj.equals("|")) {
-	  b = stack.pop();
-	  b = stack.pop() || b;
-	  stack.push(new Boolean(b));
-	}
-	else if (obj.equals("&")) {
-	  b = stack.pop();
-	  b = stack.pop() && b;
-	  stack.push(new Boolean(b));
-	}
-	else {
-	  throw new RuntimeException("Invalid object found");
-	}
+    final Deque < Boolean > stack = new ArrayDeque < Boolean > ();
+    stack.push (new Boolean (b));
+  for (Object obj:addition)
+      {
+	if (obj instanceof REToken)
+	  {
+	    b = ((REToken) obj).match (input, (REMatch) mymatch.clone ());
+	    stack.push (new Boolean (b));
+	  }
+	else if (obj instanceof Boolean)
+	  {
+	    stack.push ((Boolean) obj);
+	  }
+	else if (obj.equals ("|"))
+	  {
+	    b = stack.pop ();
+	    b = stack.pop () || b;
+	    stack.push (new Boolean (b));
+	  }
+	else if (obj.equals ("&"))
+	  {
+	    b = stack.pop ();
+	    b = stack.pop () && b;
+	    stack.push (new Boolean (b));
+	  }
+	else
+	  {
+	    throw new RuntimeException ("Invalid object found");
+	  }
       }
-      if (stack.pop()) {
-        ++mymatch.index;
-        return next(input, mymatch);
+    if (stack.pop ())
+      {
+	++mymatch.index;
+	return next (input, mymatch);
       }
-      return false;
-    }
+    return false;
+  }
 
-    private boolean matchN(CharIndexed input, REMatch mymatch, boolean tryOnly) {
-      if (input.charAt(mymatch.index) == CharIndexed.OUT_OF_BOUNDS) 
-        return false;
+  private boolean matchN (CharIndexed input, REMatch mymatch, boolean tryOnly)
+  {
+    if (input.charAt (mymatch.index) == CharIndexed.OUT_OF_BOUNDS)
+      return false;
 
-      for (REToken tk : options) {
-	REMatch tryMatch = (REMatch) mymatch.clone();
-	if (tk.match(input, tryMatch)) { // match was successful
+  for (REToken tk:options)
+      {
+	REMatch tryMatch = (REMatch) mymatch.clone ();
+	if (tk.match (input, tryMatch))
+	  {			// match was successful
 	    return false;
-	} // is a match
-      } // try next option
+	  }			// is a match
+      }				// try next option
 
-      if (tryOnly) return true;
-      ++mymatch.index;
-      return next(input, mymatch);
-    }
+    if (tryOnly)
+      return true;
+    ++mymatch.index;
+    return next (input, mymatch);
+  }
 
-    private boolean matchP(CharIndexed input, REMatch mymatch, boolean tryOnly) {
-      for (REToken tk : options) {
-	REMatch tryMatch = (REMatch) mymatch.clone();
-	if (tk.match(input, tryMatch)) { // match was successful
-	  if (tryOnly) return true;
-	  if (next(input, tryMatch)) {
-	      mymatch.assignFrom(tryMatch);
+  private boolean matchP (CharIndexed input, REMatch mymatch, boolean tryOnly)
+  {
+  for (REToken tk:options)
+      {
+	REMatch tryMatch = (REMatch) mymatch.clone ();
+	if (tk.match (input, tryMatch))
+	  {			// match was successful
+	    if (tryOnly)
 	      return true;
+	    if (next (input, tryMatch))
+	      {
+		mymatch.assignFrom (tryMatch);
+		return true;
+	      }
 	  }
-	}
       }
-      return false;
-    }
+    return false;
+  }
 
-  private boolean matchOneRE(CharIndexed input, REMatch mymatch) {
-      REMatch newMatch = findMatch(input, mymatch);
-      if (newMatch != null) {
-	  mymatch.assignFrom(newMatch);
-	  return true;
+  private boolean matchOneRE (CharIndexed input, REMatch mymatch)
+  {
+    REMatch newMatch = findMatch (input, mymatch);
+    if (newMatch != null)
+      {
+	mymatch.assignFrom (newMatch);
+	return true;
       }
-      return false;	
+    return false;
   }
 
-  REMatch findMatch(CharIndexed input, REMatch mymatch) {
-      if (matchesOneChar) return super.findMatch(input, mymatch);
-      return findMatch(input, mymatch, 0);
+  REMatch findMatch (CharIndexed input, REMatch mymatch)
+  {
+    if (matchesOneChar)
+      return super.findMatch (input, mymatch);
+    return findMatch (input, mymatch, 0);
   }
 
-  REMatch backtrack(CharIndexed input, REMatch mymatch, Object param) {
-      return findMatch(input, mymatch, ((Integer)param).intValue());
+  REMatch backtrack (CharIndexed input, REMatch mymatch, Object param)
+  {
+    return findMatch (input, mymatch, ((Integer) param).intValue ());
   }
 
-  private REMatch findMatch(CharIndexed input, REMatch mymatch, int optionIndex) {
-      for (int i = optionIndex; i < options.size(); i++) {
-          REToken tk = options.get(i);
-	  tk = (REToken) tk.clone();
-	  tk.chain(getNext());
-          REMatch tryMatch = (REMatch) mymatch.clone();
-          if (tryMatch.backtrackStack == null) {
-            tryMatch.backtrackStack = new BacktrackStack();
+  private REMatch findMatch (CharIndexed input, REMatch mymatch,
+			     int optionIndex)
+  {
+    for (int i = optionIndex; i < options.size (); i++)
+      {
+	REToken tk = options.get (i);
+	tk = (REToken) tk.clone ();
+	tk.chain (getNext ());
+	REMatch tryMatch = (REMatch) mymatch.clone ();
+	if (tryMatch.backtrackStack == null)
+	  {
+	    tryMatch.backtrackStack = new BacktrackStack ();
 	  }
-	  boolean stackPushed = false;
-	  if (i + 1 < options.size()) {
-            tryMatch.backtrackStack.push(new BacktrackStack.Backtrack(
-              this, input, mymatch, i + 1));
+	boolean stackPushed = false;
+	if (i + 1 < options.size ())
+	  {
+	    tryMatch.backtrackStack.push (new BacktrackStack.
+					  Backtrack (this, input, mymatch,
+						     i + 1));
 	    stackPushed = true;
-          }
-	  if (tk.match(input, tryMatch))
-	    {
-	      return tryMatch;
-	    }
-	  if (stackPushed) tryMatch.backtrackStack.pop();
+	  }
+	if (tk.match (input, tryMatch))
+	  {
+	    return tryMatch;
+	  }
+	if (stackPushed)
+	  tryMatch.backtrackStack.pop ();
       }
-      return null; 
+    return null;
   }
 
-  boolean returnsFixedLengthMatches() { return matchesOneChar; }
+  boolean returnsFixedLengthMatches ()
+  {
+    return matchesOneChar;
+  }
 
-  int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
-      if (!matchesOneChar)
-          return super.findFixedLengthMatches(input, mymatch, max);
-      int numRepeats = 0;
-      REMatch m = (REMatch) mymatch.clone();
-      REToken tk = (REToken) this.clone();
-      tk.chain(null);
-      while (true) {
-	  if (numRepeats >= max) break;
-          m = tk.findMatch(input, m);
-          if (m == null) break;
-          numRepeats++;
+  int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
+  {
+    if (!matchesOneChar)
+      return super.findFixedLengthMatches (input, mymatch, max);
+    int numRepeats = 0;
+    REMatch m = (REMatch) mymatch.clone ();
+    REToken tk = (REToken) this.clone ();
+    tk.chain (null);
+    while (true)
+      {
+	if (numRepeats >= max)
+	  break;
+	m = tk.findMatch (input, m);
+	if (m == null)
+	  break;
+	numRepeats++;
       }
-      return numRepeats;
+    return numRepeats;
   }
 
-  void dump(CPStringBuilder os) {
-    os.append(negative ? "[^" : "(?:");
-    for (int i = 0; i < options.size(); i++) {
-      if (!negative && (i > 0)) os.append('|');
-      options.get(i).dumpAll(os);
-    }
-    os.append(negative ? ']' : ')');
-  }  
+  void dump (CPStringBuilder os)
+  {
+    os.append (negative ? "[^" : "(?:");
+    for (int i = 0; i < options.size (); i++)
+      {
+	if (!negative && (i > 0))
+	  os.append ('|');
+	options.get (i).dumpAll (os);
+      }
+    os.append (negative ? ']' : ')');
+  }
 }