diff --git a/ChangeLog b/ChangeLog
index 1ab817b12..5d0543192 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+2010-12-16  Richard Frith-Macdonald <rfm@gnu.org>
+
+	* Source/NSRegularExpression.m: Move towards coding standards compliance
+	* Source/GSICUString.m: ditto
+
 2010-12-16  Richard Frith-Macdonald <rfm@gnu.org>
 
 	* configure.ac: Remove redundant/incorrect define of HAVE_ICU.
diff --git a/Source/GSICUString.m b/Source/GSICUString.m
index 7adb77767..c4e811da4 100644
--- a/Source/GSICUString.m
+++ b/Source/GSICUString.m
@@ -1,3 +1,27 @@
+/** Implementation of GSICUString for GNUStep
+
+   Copyright (C) 2010 Free Software Foundation, Inc.
+
+   This file is part of the GNUstep Base Library.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free
+   Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02111 USA.
+
+   $Date: 2010-09-18 16:09:58 +0100 (Sat, 18 Sep 2010) $ $Revision: 31371 $
+   */
+
 #import "common.h"
 #if GS_USE_ICU == 1
 #import "GSICUString.h"
@@ -13,9 +37,10 @@ static const NSUInteger chunkSize = 32;
 /**
  * Returns the number of UTF16 characters in a UText backed by an NSString.
  */
-static int64_t UTextNSStringNativeLength(UText *ut)
+static int64_t
+UTextNSStringNativeLength(UText *ut)
 {
-	return [(NSString*)ut->p length];
+  return [(NSString*)ut->p length];
 }
 
 
@@ -23,152 +48,174 @@ static int64_t UTextNSStringNativeLength(UText *ut)
  * Loads a group of characters into the buffer that can be directly accessed by
  * users of the UText.  This is used for iteration but UText users.
  */
-UBool UTextNSStringAccess(UText *ut, int64_t nativeIndex, UBool forward)
+UBool
+UTextNSStringAccess(UText *ut, int64_t nativeIndex, UBool forward)
 {
-	NSString *str = ut->p;
-	NSUInteger length = [str length];
-	if (nativeIndex >= length) { return FALSE; }
-	// Special case if the chunk already contains this index
-	if (nativeIndex >= ut->chunkNativeStart
-	    && nativeIndex < (ut->chunkNativeStart + ut->chunkLength))
+  NSString	*str = (NSString*)ut->p;
+  NSUInteger	length = [str length];
+  NSRange	r;
+
+  if (nativeIndex >= length)
+    {
+      return FALSE;
+    }
+
+  /* Special case if the chunk already contains this index
+   */
+  if (nativeIndex >= ut->chunkNativeStart
+    && nativeIndex < (ut->chunkNativeStart + ut->chunkLength))
+    {
+      ut->chunkOffset = nativeIndex - ut->chunkNativeStart;
+      return TRUE;
+    }
+  r = NSMakeRange(nativeIndex, chunkSize);
+  forward = TRUE;
+  if (forward)
+    {
+      if (nativeIndex + chunkSize > length)
 	{
-		ut->chunkOffset = nativeIndex - ut->chunkNativeStart;
-		return TRUE;
+	  r.length = length - nativeIndex;
 	}
-	NSRange r = {nativeIndex, chunkSize};
-	forward = TRUE;
-	if (forward)
+    }
+  else
+    {
+      if (nativeIndex - chunkSize > 0)
 	{
-		if (nativeIndex + chunkSize > length)
-		{
-			r.length = length - nativeIndex;
-		}
+	  r.location = nativeIndex - chunkSize;
+	  r.length = chunkSize;
 	}
-	else
+      else
 	{
-		if (nativeIndex - chunkSize > 0)
-		{
-			r.location = nativeIndex - chunkSize;
-			r.length = chunkSize;
-		}
-		else
-		{
-			r.location = 0;
-			r.length = chunkSize - nativeIndex;
-		}
+	  r.location = 0;
+	  r.length = chunkSize - nativeIndex;
 	}
-	[str getCharacters: ut->pExtra range: r];
-	ut->chunkNativeStart = r.location;
-	ut->chunkNativeLimit = r.location + r.length;
-	ut->chunkLength = r.length;
-	ut->chunkOffset = 0;
-	return TRUE;
+    }
+  [str getCharacters: ut->pExtra range: r];
+  ut->chunkNativeStart = r.location;
+  ut->chunkNativeLimit = r.location + r.length;
+  ut->chunkLength = r.length;
+  ut->chunkOffset = 0;
+  return TRUE;
 }
 
 /**
  * Replaces characters in an NSString-backed UText.
  */
-static int32_t UTextNSMutableStringReplace(UText *ut,
-                                           int64_t nativeStart,
-                                           int64_t nativeLimit,
-                                           const UChar *replacementText,
-                                           int32_t replacmentLength,
-                                           UErrorCode *status)
+static int32_t
+UTextNSMutableStringReplace(UText *ut,
+  int64_t nativeStart,
+  int64_t nativeLimit,
+  const UChar *replacementText,
+  int32_t replacmentLength,
+  UErrorCode *status)
 {
-	NSMutableString *str = (NSMutableString*)ut->p;
-	NSRange r = NSMakeRange(nativeStart, nativeLimit-nativeStart);
-	NSString *replacement = [NSString alloc];
-	if (replacmentLength < 0)
-	{
-		replacement = [replacement initWithCString: (const char*)replacementText
-		                                  encoding: NSUTF16StringEncoding];
-	}
-	else
-	{
-		replacement = [replacement initWithCharactersNoCopy: (unichar*)replacementText
-		                                             length: replacmentLength 
-		                                       freeWhenDone: NO];
-	}
-	[str replaceCharactersInRange: r withString: replacement];
+  NSMutableString	*str = (NSMutableString*)ut->p;
+  NSRange		r = NSMakeRange(nativeStart, nativeLimit-nativeStart);
+  NSString		*replacement = [NSString alloc];
 
-	// Setting the chunk length to 0 here forces UTextNSStringAccess to fetch
-	// the data from the string object.
-	ut->chunkLength = 0;
-	UTextNSStringAccess(ut, r.location + [replacement length] + 1, TRUE);
-	ut->chunkOffset++;
-	
-	[replacement release];
-	if (NULL != status)
-	{
-		*status = 0;
-	}
-	return 0;
+  if (replacmentLength < 0)
+    {
+      replacement = [replacement initWithCString: (const char*)replacementText
+					encoding: NSUTF16StringEncoding];
+    }
+  else
+    {
+      replacement = [replacement initWithCharactersNoCopy: (unichar*)replacementText
+						   length: replacmentLength 
+					     freeWhenDone: NO];
+    }
+  [str replaceCharactersInRange: r withString: replacement];
+
+  // Setting the chunk length to 0 here forces UTextNSStringAccess to fetch
+  // the data from the string object.
+  ut->chunkLength = 0;
+  UTextNSStringAccess(ut, r.location + [replacement length] + 1, TRUE);
+  ut->chunkOffset++;
+  
+  [replacement release];
+  if (NULL != status)
+    {
+      *status = 0;
+    }
+  return 0;
 }
 
 /**
  * Reads some characters.  This is roughly analogous to NSString's
  * -getCharacters:range:.
  */
-static int32_t UTextNSStringExtract(UText *ut,
-                                    int64_t nativeStart,
-                                    int64_t nativeLimit,
-                                    UChar *dest,
-                                    int32_t destCapacity,
-                                    UErrorCode *status)
+static int32_t
+UTextNSStringExtract(UText *ut,
+  int64_t nativeStart,
+  int64_t nativeLimit,
+  UChar *dest,
+  int32_t destCapacity,
+  UErrorCode *status)
 {
-	// If we're loading no characters, we are expected to return the number of
-	// characters that we could load if requested.
-	if (destCapacity == 0)
-	{
-		return nativeLimit - nativeStart;
-	}
-	NSString *str = ut->p;
-	NSUInteger length = [str length];
-	if (nativeLimit > length)
-	{
-		nativeLimit = length;
-	}
-	NSRange r = NSMakeRange(nativeStart, nativeLimit - nativeStart );
-	if (destCapacity < r.length)
-	{
-		r.length = destCapacity;
-	}
-	[str getCharacters: dest range: r];
-	if (destCapacity > r.length)
-	{
-		dest[r.length] = 0;
-	}
-	return r.length;
+  NSString	*str;
+  NSUInteger	length;
+  NSRange	r;
+
+  /* If we're loading no characters, we are expected to return the number of
+   * characters that we could load if requested.
+   */
+  if (destCapacity == 0)
+    {
+      return nativeLimit - nativeStart;
+    }
+  str = (NSString*)ut->p;
+  length = [str length];
+  if (nativeLimit > length)
+    {
+      nativeLimit = length;
+    }
+  r = NSMakeRange(nativeStart, nativeLimit - nativeStart );
+  if (destCapacity < r.length)
+    {
+      r.length = destCapacity;
+    }
+  [str getCharacters: dest range: r];
+  if (destCapacity > r.length)
+    {
+      dest[r.length] = 0;
+    }
+  return r.length;
 }
 
 /**
  * Copy or move some characters within a UText.
  */
 void UTextNSStringCopy(UText *ut,
-                       int64_t nativeStart,
-                       int64_t nativeLimit,
-                       int64_t nativeDest,
-                       UBool move,
-                       UErrorCode *status)
+  int64_t nativeStart,
+  int64_t nativeLimit,
+  int64_t nativeDest,
+  UBool move,
+  UErrorCode *status)
 {
-	NSMutableString *str = ut->p;
-	NSUInteger length = [str length];
-	if (nativeLimit > length)
+  NSMutableString	*str = (NSMutableString*)ut->p;
+  NSUInteger		length = [str length];
+  NSRange		r;
+  NSString		*substr;
+
+  if (nativeLimit > length)
+    {
+      nativeLimit = length;
+    }
+  r = NSMakeRange(nativeStart, nativeLimit - nativeStart);
+  substr = [str substringWithRange: r];
+  [str insertString: substr atIndex: nativeDest];
+  if (move)
+    {
+      if (nativeDest < r.location)
 	{
-		nativeLimit = length;
+	  r.location += r.length;
 	}
-	NSRange r = NSMakeRange(nativeStart, nativeLimit - nativeStart);
-	NSString *substr = [str substringWithRange: r];
-	[str insertString: substr atIndex: nativeDest];
-	if (move)
-	{
-		if (nativeDest < r.location)
-		{
-			r.location += r.length;
-		}
-		[str deleteCharactersInRange: r];
-	}
-	if (NULL != status) { *status = 0; }
+      [str deleteCharactersInRange: r];
+    }
+  if (NULL != status)
+    {
+      *status = 0;
+    }
 }
 
 
@@ -177,11 +224,12 @@ void UTextNSStringCopy(UText *ut,
  * be allocated on the stack, or reused by different storage implementations,
  * this does not destroy the UText itself.
  */
-static void UTextNStringClose(UText *ut)
+static void
+UTextNStringClose(UText *ut)
 {
-	ut->chunkContents = NULL;
-	[(NSString*)ut->p release];
-	ut->p = NULL;
+  ut->chunkContents = NULL;
+  [(NSString*)ut->p release];
+  ut->p = NULL;
 }
 
 /**
@@ -190,41 +238,46 @@ static void UTextNStringClose(UText *ut)
  * Typically, this should not actually copy the underlying storage, because it
  * is immutable.
  */
-UText* UTextNSStringClone(UText *dest,
-                          const UText *src,
-                          UBool deep,
-                          UErrorCode *status)
+UText*
+UTextNSStringClone(UText *dest,
+  const UText *src,
+  UBool deep,
+  UErrorCode *status)
 {
-	NSString *str = src->p;
-	if (deep)
-	{
-		str = [[str copy] autorelease];
-	}
-	return UTextInitWithNSString(dest, str);
+  NSString	*str = (NSString*)src->p;
+
+  if (deep)
+    {
+      str = [[str copy] autorelease];
+    }
+  return UTextInitWithNSString(dest, str);
 }
 
 /**
  * Copies the UText object, optionally copying the NSMutableString.
  */
-UText* UTextNSMutableStringClone(UText *dest,
-                                 const UText *src,
-                                 UBool deep,
-                                 UErrorCode *status)
+UText*
+UTextNSMutableStringClone(UText *dest,
+  const UText *src,
+  UBool deep,
+  UErrorCode *status)
 {
-	NSMutableString *str = src->p;
-	if (deep)
-	{
-		str = [str mutableCopy];
-	}
-	return UTextInitWithNSMutableString(dest, str);
+  NSMutableString	*str = (NSMutableString*)src->p;
+
+  if (deep)
+    {
+      str = [str mutableCopy];
+    }
+  return UTextInitWithNSMutableString(dest, str);
 }
 
 /**
  * Returns the index of the current character in the temporary buffer.
  */
-int64_t UTextNSStringMapOffsetToNative(const UText *ut)
+int64_t
+UTextNSStringMapOffsetToNative(const UText *ut)
 {
-	return ut->chunkNativeStart + ut->chunkOffset;
+  return ut->chunkNativeStart + ut->chunkOffset;
 }
 
 /**
@@ -232,18 +285,18 @@ int64_t UTextNSStringMapOffsetToNative(const UText *ut)
  */
 static const UTextFuncs NSStringFuncs = 
 {
-	sizeof(UTextFuncs), // Table size
-	0, 0, 0,            // Reserved
-	UTextNSStringClone,
-	UTextNSStringNativeLength,
-	UTextNSStringAccess,
-	UTextNSStringExtract,
-	0,                  // Replace
-	UTextNSStringCopy,
-	UTextNSStringMapOffsetToNative,
-	0,                // Map to UTF16
-	UTextNStringClose,
-	0, 0, 0             // Spare
+  sizeof(UTextFuncs), // Table size
+  0, 0, 0,            // Reserved
+  UTextNSStringClone,
+  UTextNSStringNativeLength,
+  UTextNSStringAccess,
+  UTextNSStringExtract,
+  0,                  // Replace
+  UTextNSStringCopy,
+  UTextNSStringMapOffsetToNative,
+  0,                // Map to UTF16
+  UTextNStringClose,
+  0, 0, 0             // Spare
 };
 
 /**
@@ -251,131 +304,157 @@ static const UTextFuncs NSStringFuncs =
  */
 static const UTextFuncs NSMutableStringFuncs = 
 {
-	sizeof(UTextFuncs), // Table size
-	0, 0, 0,            // Reserved
-	UTextNSMutableStringClone,
-	UTextNSStringNativeLength,
-	UTextNSStringAccess,
-	UTextNSStringExtract,
-	UTextNSMutableStringReplace,
-	UTextNSStringCopy,
-	UTextNSStringMapOffsetToNative,
-	0,                // Map to UTF16
-	UTextNStringClose,
-	0, 0, 0             // Spare
+  sizeof(UTextFuncs), // Table size
+  0, 0, 0,            // Reserved
+  UTextNSMutableStringClone,
+  UTextNSStringNativeLength,
+  UTextNSStringAccess,
+  UTextNSStringExtract,
+  UTextNSMutableStringReplace,
+  UTextNSStringCopy,
+  UTextNSStringMapOffsetToNative,
+  0,                // Map to UTF16
+  UTextNStringClose,
+  0, 0, 0             // Spare
 };
 
-UText* UTextInitWithNSMutableString(UText *txt, NSMutableString *str)
+UText*
+UTextInitWithNSMutableString(UText *txt, NSMutableString *str)
 {
-	UErrorCode status = 0;
-	txt = utext_setup(txt, chunkSize * sizeof(unichar), &status);
+  UErrorCode status = 0;
 
-	if (U_FAILURE(status)) { return NULL; }
+  txt = utext_setup(txt, chunkSize * sizeof(unichar), &status);
 
-	txt->p = [str retain];
-	txt->pFuncs = &NSMutableStringFuncs;
-	txt->chunkContents = txt->pExtra;
-	txt->nativeIndexingLimit = INT32_MAX;
+  if (U_FAILURE(status))
+    {
+      return NULL;
+    }
 
-	txt->providerProperties = 1<<UTEXT_PROVIDER_WRITABLE;
+  txt->p = [str retain];
+  txt->pFuncs = &NSMutableStringFuncs;
+  txt->chunkContents = txt->pExtra;
+  txt->nativeIndexingLimit = INT32_MAX;
 
-	return txt;
+  txt->providerProperties = 1<<UTEXT_PROVIDER_WRITABLE;
+
+  return txt;
 }
 
-UText* UTextInitWithNSString(UText *txt, NSString *str)
+UText*
+UTextInitWithNSString(UText *txt, NSString *str)
 {
-	UErrorCode status = 0;
-	txt = utext_setup(txt, 64, &status);
+  UErrorCode status = 0;
+  txt = utext_setup(txt, 64, &status);
 
-	if (U_FAILURE(status)) { return NULL; }
+  if (U_FAILURE(status))
+    {
+      return NULL;
+    }
 
-	txt->p = [str retain];
-	txt->pFuncs = &NSStringFuncs;
-	txt->chunkContents = txt->pExtra;
-	txt->nativeIndexingLimit = INT32_MAX;
+  txt->p = [str retain];
+  txt->pFuncs = &NSStringFuncs;
+  txt->chunkContents = txt->pExtra;
+  txt->nativeIndexingLimit = INT32_MAX;
 
-	return txt;
+  return txt;
 }
 
 @implementation GSUTextString
-- init
+- (id) init
 {
-	if (nil == (self = [super init])) { return nil; }
-	UText t = UTEXT_INITIALIZER;
-	memcpy(&txt, &t, sizeof(t));
-	return self;
+  if (nil != (self = [super init]))
+    {
+      UText t = UTEXT_INITIALIZER;
+
+      memcpy(&txt, &t, sizeof(t));
+    }
+  return self;
 }
-- (NSUInteger)length
+
+- (NSUInteger) length
 {
-	return utext_nativeLength(&txt);
+  return utext_nativeLength(&txt);
 }
-- (unichar)characterAtIndex: (NSUInteger)idx
+
+- (unichar) characterAtIndex: (NSUInteger)idx
 {
-	unichar c;
-	[self getCharacters: &c range: NSMakeRange(idx, 1)];
-	return c;
+  unichar c;
+
+  [self getCharacters: &c range: NSMakeRange(idx, 1)];
+  return c;
 }
-- (void)getCharacters: (unichar*)buffer range: (NSRange)r
+
+- (void) getCharacters: (unichar*)buffer range: (NSRange)r
 {
-	UErrorCode status = 0;
-	utext_extract(&txt, r.location, r.location+r.length, buffer, r.length,
-			&status);
-	if (U_FAILURE(status))
-	{
-		_NSRangeExceptionRaise();
-	}
+  UErrorCode status = 0;
+
+  utext_extract(&txt, r.location, r.location+r.length, buffer, r.length,
+    &status);
+  if (U_FAILURE(status))
+    {
+      _NSRangeExceptionRaise();
+    }
 }
-- (void)dealloc
+
+- (void) dealloc
 {
-	utext_close(&txt);
-	[super dealloc];
+  utext_close(&txt);
+  [super dealloc];
 }
 @end
 
 @implementation GSUTextMutableString
-- init
+- (id) init
 {
-	if (nil == (self = [super init])) { return nil; }
-	UText t = UTEXT_INITIALIZER;
-	memcpy(&txt, &t, sizeof(t));
-	return self;
-}
-- (NSUInteger)length
-{
-	return utext_nativeLength(&txt);
-}
-- (unichar)characterAtIndex: (NSUInteger)idx
-{
-	unichar c;
-	[self getCharacters: &c range: NSMakeRange(idx, 1)];
-	return c;
-}
-- (void)getCharacters: (unichar*)buffer range: (NSRange)r
-{
-	UErrorCode status = 0;
-	utext_extract(&txt, r.location, r.location+r.length, buffer, r.length,
-			&status);
-	if (U_FAILURE(status))
-	{
-		_NSRangeExceptionRaise();
-	}
-}
-- (void)replaceCharactersInRange: (NSRange)r
-                      withString: (NSString*)aString
-{
-	NSUInteger size = [aString length];
-	UErrorCode status = 0;
-	TEMP_BUFFER(buffer, size);
-	[aString getCharacters: buffer range: NSMakeRange(0, size)];
+  if (nil != (self = [super init]))
+    {
+      UText t = UTEXT_INITIALIZER;
 
-	utext_replace(&txt, r.location, r.location + r.length, buffer, size,
-			&status);
+      memcpy(&txt, &t, sizeof(t));
+    }
+  return self;
 }
 
-- (void)dealloc
+- (NSUInteger) length
 {
-	utext_close(&txt);
-	[super dealloc];
+  return utext_nativeLength(&txt);
+}
+
+- (unichar) characterAtIndex: (NSUInteger)idx
+{
+  unichar c;
+  [self getCharacters: &c range: NSMakeRange(idx, 1)];
+  return c;
+}
+
+- (void) getCharacters: (unichar*)buffer range: (NSRange)r
+{
+  UErrorCode status = 0;
+
+  utext_extract(&txt, r.location, r.location+r.length, buffer, r.length,
+    &status);
+  if (U_FAILURE(status))
+    {
+      _NSRangeExceptionRaise();
+    }
+}
+
+- (void) replaceCharactersInRange: (NSRange)r
+                       withString: (NSString*)aString
+{
+  NSUInteger	size = [aString length];
+  UErrorCode	status = 0;
+
+  TEMP_BUFFER(buffer, size);
+  [aString getCharacters: buffer range: NSMakeRange(0, size)];
+
+  utext_replace(&txt, r.location, r.location + r.length, buffer, size, &status);
+}
+
+- (void) dealloc
+{
+  utext_close(&txt);
+  [super dealloc];
 }
 @end
 #endif // HAV_ICU
diff --git a/Source/NSRegularExpression.m b/Source/NSRegularExpression.m
index 931ed3647..521d0ac55 100644
--- a/Source/NSRegularExpression.m
+++ b/Source/NSRegularExpression.m
@@ -1,4 +1,29 @@
-#include "common.h"
+/** Implementation of NSRegualrExpression for GNUStep
+
+   Copyright (C) 2010 Free Software Foundation, Inc.
+
+   This file is part of the GNUstep Base Library.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free
+   Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02111 USA.
+
+   $Date: 2010-09-18 16:09:58 +0100 (Sat, 18 Sep 2010) $ $Revision: 31371 $
+   */
+
+#import "common.h"
+
 #if GS_USE_ICU == 1
 #include "unicode/uregex.h"
 #if (U_ICU_VERSION_MAJOR_NUM > 4 || (U_ICU_VERSION_MAJOR_NUM == 4 && U_ICU_VERSION_MINOR_NUM >= 4))
@@ -18,90 +43,105 @@
  * in theory use the libicu values directly (that would be sensible), but that
  * would break any code that didn't correctly use the symbolic constants.
  */
-uint32_t NSRegularExpressionOptionsToURegexpFlags(NSRegularExpressionOptions opts)
+uint32_t
+NSRegularExpressionOptionsToURegexpFlags(NSRegularExpressionOptions opts)
 {
-	uint32_t flags = 0;
-	if (opts & NSRegularExpressionCaseInsensitive)
-	{
-		flags |= UREGEX_CASE_INSENSITIVE;
-	}
-	if (opts & NSRegularExpressionAllowCommentsAndWhitespace)
-	{
-		flags |= UREGEX_COMMENTS;
-	}
-	if (opts & NSRegularExpressionIgnoreMetacharacters)
-	{
-		flags |= UREGEX_LITERAL;
-	}
-	if (opts & NSRegularExpressionDotMatchesLineSeparators)
-	{
-		flags |= UREGEX_DOTALL;
-	}
-	if (opts & NSRegularExpressionAnchorsMatchLines)
-	{
-		flags |= UREGEX_MULTILINE;
-	}
-	if (opts & NSRegularExpressionUseUnixLineSeparators)
-	{
-		flags |= UREGEX_UNIX_LINES;
-	}
-	if (opts & NSRegularExpressionUseUnicodeWordBoundaries)
-	{
-		flags |= UREGEX_UWORD;
-	}
-	return flags;
+  uint32_t flags = 0;
+
+  if (opts & NSRegularExpressionCaseInsensitive)
+    {
+      flags |= UREGEX_CASE_INSENSITIVE;
+    }
+  if (opts & NSRegularExpressionAllowCommentsAndWhitespace)
+    {
+      flags |= UREGEX_COMMENTS;
+    }
+  if (opts & NSRegularExpressionIgnoreMetacharacters)
+    {
+    flags |= UREGEX_LITERAL;
+    }
+  if (opts & NSRegularExpressionDotMatchesLineSeparators)
+    {
+      flags |= UREGEX_DOTALL;
+    }
+  if (opts & NSRegularExpressionAnchorsMatchLines)
+    {
+      flags |= UREGEX_MULTILINE;
+    }
+  if (opts & NSRegularExpressionUseUnixLineSeparators)
+    {
+      flags |= UREGEX_UNIX_LINES;
+    }
+  if (opts & NSRegularExpressionUseUnicodeWordBoundaries)
+    {
+      flags |= UREGEX_UWORD;
+    }
+  return flags;
 }
 
 @implementation NSRegularExpression
-+ (NSRegularExpression*)regularExpressionWithPattern: (NSString*)aPattern
-                                             options: (NSRegularExpressionOptions)opts
-                                               error: (NSError**)e
+
++ (NSRegularExpression*) regularExpressionWithPattern: (NSString*)aPattern
+  options: (NSRegularExpressionOptions)opts
+  error: (NSError**)e
 {
-	return [[[self alloc] initWithPattern: aPattern options: opts error: e] autorelease];
-}
-- initWithPattern: (NSString*)aPattern
-          options: (NSRegularExpressionOptions)opts
-            error: (NSError**)e
-{
-	uint32_t flags = NSRegularExpressionOptionsToURegexpFlags(opts);
-	UText p = UTEXT_INITIALIZER;
-	UParseError pe = {0};
-	UErrorCode s = 0;
-	UTextInitWithNSString(&p, aPattern);
-	regex = uregex_openUText(&p, flags, &pe, &s);
-	utext_close(&p);
-	if (U_FAILURE(s))
-	{
-		// FIXME: Do something sensible with the error parameter.
-		[self release];
-		return nil;
-	}
-	options = opts;
-	return self;
-}
-- (NSString*)pattern
-{
-	UErrorCode s = 0;
-	UText *t = uregex_patternUText(regex, &s);
-	GSUTextString *str = NULL;
-	if (U_FAILURE(s))
-	{
-		return nil;
-	}
-	str = [GSUTextString new];
-	utext_clone(&str->txt, t, FALSE, TRUE, &s);
-	utext_close(t);
-	return [str autorelease];
+  return [[[self alloc] initWithPattern: aPattern
+				options: opts
+				  error: e] autorelease];
 }
 
-static UBool callback(const void *context, int32_t steps)
+- (id) initWithPattern: (NSString*)aPattern
+	       options: (NSRegularExpressionOptions)opts
+		 error: (NSError**)e
 {
-	BOOL stop = NO;
-	GSRegexBlock block = (GSRegexBlock)context;
-	if (NULL == context) { return FALSE; }
-	CALL_BLOCK(block, nil, NSMatchingProgress, &stop);
-	return stop;
+  uint32_t	flags = NSRegularExpressionOptionsToURegexpFlags(opts);
+  UText		p = UTEXT_INITIALIZER;
+  UParseError	pe = {0};
+  UErrorCode	s = 0;
+
+  UTextInitWithNSString(&p, aPattern);
+  regex = uregex_openUText(&p, flags, &pe, &s);
+  utext_close(&p);
+  if (U_FAILURE(s))
+    {
+      // FIXME: Do something sensible with the error parameter.
+      [self release];
+      return nil;
+    }
+  options = opts;
+  return self;
 }
+
+- (NSString*) pattern
+{
+  UErrorCode	s = 0;
+  UText		*t = uregex_patternUText(regex, &s);
+  GSUTextString	*str = NULL;
+
+  if (U_FAILURE(s))
+    {
+      return nil;
+    }
+  str = [GSUTextString new];
+  utext_clone(&str->txt, t, FALSE, TRUE, &s);
+  utext_close(t);
+  return [str autorelease];
+}
+
+static UBool
+callback(const void *context, int32_t steps)
+{
+  BOOL		stop = NO;
+  GSRegexBlock	block = (GSRegexBlock)context;
+
+  if (NULL == context)
+    {
+      return FALSE;
+    }
+  CALL_BLOCK(block, nil, NSMatchingProgress, &stop);
+  return stop;
+}
+
 /**
  * Sets up a libicu regex object for use.  Note: the documentation states that
  * NSRegularExpression must be thread safe.  To accomplish this, we store a
@@ -110,416 +150,474 @@ static UBool callback(const void *context, int32_t steps)
  * NSRegularExpression, is stateful, and sharing this state between threads
  * would break concurrent calls.
  */
-static URegularExpression *setupRegex(URegularExpression *regex,
-                                      NSString *string,
-                                      UText *txt,
-                                      NSMatchingOptions options,
-                                      NSRange range,
-                                      GSRegexBlock block)
+static URegularExpression *
+setupRegex(URegularExpression *regex,
+  NSString *string,
+  UText *txt,
+  NSMatchingOptions options,
+  NSRange range,
+  GSRegexBlock block)
 {
-	UErrorCode s = 0;
-	URegularExpression *r = uregex_clone(regex, &s);
-	if (options & NSMatchingReportProgress)
-	{
-		uregex_setMatchCallback(r, callback, block, &s);
-	}
-	UTextInitWithNSString(txt, string);
-	uregex_setUText(r, txt, &s);
-	uregex_setRegion(r, range.location, range.location+range.length, &s);
-	if (options & NSMatchingWithoutAnchoringBounds)
-	{
-		uregex_useAnchoringBounds(r, FALSE, &s);
-	}
-	if (options & NSMatchingWithTransparentBounds)
-	{
-		uregex_useTransparentBounds(r, TRUE, &s);
-	}
-	if (U_FAILURE(s))
-	{
-		uregex_close(r);
-		return NULL;
-	}
-	return r;
-}
-static uint32_t prepareResult(NSRegularExpression *regex,
-                              URegularExpression *r,
-                              NSRangePointer ranges,
-                              NSUInteger groups,
-                              UErrorCode *s)
-{
-	uint32_t flags = 0;
-	NSUInteger i = 0;
-	for (i = 0 ; i<groups ; i++)
-	{
-		NSUInteger start = uregex_start(r, i, s);
-		NSUInteger end = uregex_end(r, i, s);
-		ranges[i] = NSMakeRange(start, end-start);
-	}
-	if (uregex_hitEnd(r, s))
-	{
-		flags |= NSMatchingHitEnd;
-	}
-	if (uregex_requireEnd(r, s))
-	{
-		flags |= NSMatchingRequiredEnd;
-	}
-	if (0 != *s)
-	{
-		flags |= NSMatchingInternalError;
-	}
-	return flags;
+  UErrorCode		s = 0;
+  URegularExpression	*r = uregex_clone(regex, &s);
+
+  if (options & NSMatchingReportProgress)
+    {
+      uregex_setMatchCallback(r, callback, block, &s);
+    }
+  UTextInitWithNSString(txt, string);
+  uregex_setUText(r, txt, &s);
+  uregex_setRegion(r, range.location, range.location+range.length, &s);
+  if (options & NSMatchingWithoutAnchoringBounds)
+    {
+      uregex_useAnchoringBounds(r, FALSE, &s);
+    }
+  if (options & NSMatchingWithTransparentBounds)
+    {
+      uregex_useTransparentBounds(r, TRUE, &s);
+    }
+  if (U_FAILURE(s))
+    {
+      uregex_close(r);
+      return NULL;
+    }
+  return r;
 }
 
-- (void)enumerateMatchesInString: (NSString*)string
-                         options: (NSMatchingOptions)opts
-                           range: (NSRange)range
-                      usingBlock: (GSRegexBlock)block
+static uint32_t
+prepareResult(NSRegularExpression *regex,
+  URegularExpression *r,
+  NSRangePointer ranges,
+  NSUInteger groups,
+  UErrorCode *s)
 {
-	UErrorCode s = 0;
-	UText txt = UTEXT_INITIALIZER;
-	BOOL stop = NO;
-	URegularExpression *r = setupRegex(regex, string, &txt, opts, range, block);
-	NSUInteger groups = [self numberOfCaptureGroups] + 1;
-	NSRange ranges[groups];
-	// Should this throw some kind of exception?
-	if (NULL == r) { return; }
-	if (opts & NSMatchingAnchored)
-	{
-		if (uregex_lookingAt(r, -1, &s) && (0==s))
-		{
-			// FIXME: Factor all of this out into prepareResult()
-			uint32_t flags = prepareResult(self, r, ranges, groups, &s);
-			NSTextCheckingResult *result =
-				[NSTextCheckingResult regularExpressionCheckingResultWithRanges: ranges
-				                                                          count: groups
-				                                              regularExpression: self];
-			CALL_BLOCK(block, result, flags, &stop);
-		}
-	}
-	else
-	{
-		while (!stop && uregex_findNext(r, &s) && (s == 0))
-		{
-			uint32_t flags = prepareResult(self, r, ranges, groups, &s);
-			NSTextCheckingResult *result =
-				[NSTextCheckingResult regularExpressionCheckingResultWithRanges: ranges
-				                                                          count: groups
-				                                              regularExpression: self];
-			CALL_BLOCK(block, result, flags, &stop);
-		}
-	}
-	if (opts & NSMatchingCompleted)
-	{
-		CALL_BLOCK(block, nil, NSMatchingCompleted, &stop);
-	}
-	utext_close(&txt);
-	uregex_close(r);
+  uint32_t	flags = 0;
+  NSUInteger	i = 0;
+
+  for (i = 0; i < groups; i++)
+    {
+      NSUInteger start = uregex_start(r, i, s);
+      NSUInteger end = uregex_end(r, i, s);
+
+      ranges[i] = NSMakeRange(start, end-start);
+    }
+  if (uregex_hitEnd(r, s))
+    {
+      flags |= NSMatchingHitEnd;
+    }
+  if (uregex_requireEnd(r, s))
+    {
+      flags |= NSMatchingRequiredEnd;
+    }
+  if (0 != *s)
+    {
+      flags |= NSMatchingInternalError;
+    }
+  return flags;
 }
-// The remaining methods are all meant to be wrappers around the primitive
-// method that takes a block argument.  Unfortunately, this is not really
-// possible when compiling with a compiler that doesn't support blocks.
+
+- (void) enumerateMatchesInString: (NSString*)string
+                          options: (NSMatchingOptions)opts
+                            range: (NSRange)range
+                       usingBlock: (GSRegexBlock)block
+{
+  UErrorCode	s = 0;
+  UText		txt = UTEXT_INITIALIZER;
+  BOOL		stop = NO;
+  URegularExpression *r = setupRegex(regex, string, &txt, opts, range, block);
+  NSUInteger	groups = [self numberOfCaptureGroups] + 1;
+  NSRange	ranges[groups];
+
+  // Should this throw some kind of exception?
+  if (NULL == r)
+    {
+      return;
+    }
+  if (opts & NSMatchingAnchored)
+    {
+      if (uregex_lookingAt(r, -1, &s) && (0 == s))
+	{
+	  // FIXME: Factor all of this out into prepareResult()
+	  uint32_t		flags;
+	  NSTextCheckingResult *result;
+
+	  flags = prepareResult(self, r, ranges, groups, &s);
+	  result = [NSTextCheckingResult
+	    regularExpressionCheckingResultWithRanges: ranges
+						count: groups
+				    regularExpression: self];
+	  CALL_BLOCK(block, result, flags, &stop);
+	}
+    }
+  else
+    {
+      while (!stop && uregex_findNext(r, &s) && (0 == s))
+	{
+	  uint32_t		flags;
+	  NSTextCheckingResult	*result;
+
+	  flags = prepareResult(self, r, ranges, groups, &s);
+	  result = [NSTextCheckingResult
+	    regularExpressionCheckingResultWithRanges: ranges
+						count: groups
+				    regularExpression: self];
+	  CALL_BLOCK(block, result, flags, &stop);
+	}
+    }
+  if (opts & NSMatchingCompleted)
+    {
+      CALL_BLOCK(block, nil, NSMatchingCompleted, &stop);
+    }
+  utext_close(&txt);
+  uregex_close(r);
+}
+
+/* The remaining methods are all meant to be wrappers around the primitive
+ * method that takes a block argument.  Unfortunately, this is not really
+ * possible when compiling with a compiler that doesn't support blocks.
+ */
 #if __has_feature(blocks)
-- (NSUInteger)numberOfMatchesInString: (NSString*)string
+- (NSUInteger) numberOfMatchesInString: (NSString*)string
+                               options: (NSMatchingOptions)opts
+                                 range: (NSRange)range
+
+{
+  __block NSUInteger	count = 0;
+
+  opts &= ~NSMatchingReportProgress;
+  opts &= ~NSMatchingReportCompletion;
+
+  GSRegexBlock block =
+    ^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop)
+    {
+      count++;
+    };
+  [self enumerateMatchesInString: string
+			 options: opts
+			   range: range
+		      usingBlock: block];
+  return count;
+}
+
+- (NSTextCheckingResult*) firstMatchInString: (NSString*)string
+                                     options: (NSMatchingOptions)opts
+                                       range: (NSRange)range
+{
+  __block NSTextCheckingResult *r = nil;
+
+  opts &= ~NSMatchingReportProgress;
+  opts &= ~NSMatchingReportCompletion;
+
+  GSRegexBlock block =
+    ^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop)
+    {
+      r = result;
+      *stop = YES;
+    };
+  [self enumerateMatchesInString: string
+			 options: opts
+			   range: range
+		      usingBlock: block];
+  return r;
+}
+
+- (NSArray*) matchesInString: (NSString*)string
+                     options:(NSMatchingOptions)opts
+                       range:(NSRange)range
+{
+  NSMutableArray	*array = [NSMutableArray array];
+
+  opts &= ~NSMatchingReportProgress;
+  opts &= ~NSMatchingReportCompletion;
+
+  GSRegexBlock block =
+    ^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop)
+    {
+      [array addObject: result];
+    };
+  [self enumerateMatchesInString: string
+			 options: opts
+			   range: range
+		      usingBlock: block];
+  return array;
+}
+
+- (NSRange) rangeOfFirstMatchInString: (NSString*)string
                               options: (NSMatchingOptions)opts
                                 range: (NSRange)range
+{
+  __block NSRange r;
 
-{
-	__block NSUInteger count = 0;
-	opts &= ~NSMatchingReportProgress;
-	opts &= ~NSMatchingReportCompletion;
-	GSRegexBlock block =
-		^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop)
-		{
-			count++;
-		};
-	[self enumerateMatchesInString: string
-	                       options: opts
-	                         range: range
-	                    usingBlock: block];
-	return count;
-}
-- (NSTextCheckingResult*)firstMatchInString: (NSString*)string
-                                    options: (NSMatchingOptions)opts
-                                      range: (NSRange)range
-{
-	__block NSTextCheckingResult *r = nil;
-	opts &= ~NSMatchingReportProgress;
-	opts &= ~NSMatchingReportCompletion;
-	GSRegexBlock block =
-		^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop)
-		{
-			r = result;
-			*stop = YES;
-		};
-	[self enumerateMatchesInString: string
-	                       options: opts
-	                         range: range
-	                    usingBlock: block];
-	return r;
-}
-- (NSArray*)matchesInString: (NSString*)string
-                    options:(NSMatchingOptions)opts
-                      range:(NSRange)range
-{
-	NSMutableArray *array = [NSMutableArray array];
-	opts &= ~NSMatchingReportProgress;
-	opts &= ~NSMatchingReportCompletion;
-	GSRegexBlock block =
-		^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop)
-		{
-			[array addObject: result];
-		};
-	[self enumerateMatchesInString: string
-	                       options: opts
-	                         range: range
-	                    usingBlock: block];
-	return array;
-}
-- (NSRange)rangeOfFirstMatchInString: (NSString*)string
-                             options: (NSMatchingOptions)opts
-                               range: (NSRange)range
-{
-	__block NSRange r;
-	opts &= ~NSMatchingReportProgress;
-	opts &= ~NSMatchingReportCompletion;
-	GSRegexBlock block =
-		^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop)
-		{
-			r= [result range];
-			*stop = YES;
-		};
-	[self enumerateMatchesInString: string
-	                       options: opts
-	                         range: range
-	                    usingBlock: block];
-	return r;
+  opts &= ~NSMatchingReportProgress;
+  opts &= ~NSMatchingReportCompletion;
+
+  GSRegexBlock block =
+    ^(NSTextCheckingResult *result, NSMatchingFlags flags, BOOL *stop)
+    {
+      r = [result range];
+      *stop = YES;
+    };
+  [self enumerateMatchesInString: string
+			 options: opts
+			   range: range
+		      usingBlock: block];
+  return r;
 }
+
 #else
 #	warning Your compiler does not support blocks.  NSRegularExpression will deviate from the documented behaviour when subclassing and any code that subclasses NSRegularExpression may break in unexpected ways.  It is strongly recommended that you use a compiler with blocks support.
 #	ifdef __clang__
 #		warning Your compiler would support blocks if you added -fblocks to your OBJCFLAGS
 #	endif
 #define FAKE_BLOCK_HACK(failRet, code) \
-	UErrorCode s = 0;\
-	UText txt = UTEXT_INITIALIZER;\
-	BOOL stop = NO;\
-	URegularExpression *r = setupRegex(regex, string, &txt, opts, range, 0);\
-	if (NULL == r) { return failRet; }\
-	if (opts & NSMatchingAnchored)\
+  UErrorCode s = 0;\
+  UText txt = UTEXT_INITIALIZER;\
+  BOOL stop = NO;\
+  URegularExpression *r = setupRegex(regex, string, &txt, opts, range, 0);\
+  if (NULL == r) { return failRet; }\
+  if (opts & NSMatchingAnchored)\
+    {\
+      if (uregex_lookingAt(r, -1, &s) && (0==s))\
 	{\
-		if (uregex_lookingAt(r, -1, &s) && (0==s))\
-		{\
-			code\
-		}\
+	  code\
 	}\
-	else\
+    }\
+  else\
+    {\
+      while (!stop && uregex_findNext(r, &s) && (s == 0))\
 	{\
-		while (!stop && uregex_findNext(r, &s) && (s == 0))\
-		{\
-			code\
-		}\
+	  code\
 	}\
-	utext_close(&txt);\
-	uregex_close(r);
-- (NSUInteger)numberOfMatchesInString: (NSString*)string
+    }\
+  utext_close(&txt);\
+  uregex_close(r);
+
+- (NSUInteger) numberOfMatchesInString: (NSString*)string
+                               options: (NSMatchingOptions)opts
+                                 range: (NSRange)range
+
+{
+  NSUInteger	count = 0;
+
+  FAKE_BLOCK_HACK(count,
+    {
+      count++;
+    });
+  return count;
+}
+
+- (NSTextCheckingResult*) firstMatchInString: (NSString*)string
+                                     options: (NSMatchingOptions)opts
+                                       range: (NSRange)range
+{
+  NSTextCheckingResult	*result = nil;
+  NSUInteger		groups = [self numberOfCaptureGroups] + 1;
+  NSRange		ranges[groups];
+
+  FAKE_BLOCK_HACK(result,
+    {
+      prepareResult(self, r, ranges, groups, &s);
+      result = [NSTextCheckingResult
+	regularExpressionCheckingResultWithRanges: ranges
+					    count: groups
+				regularExpression: self];
+      stop = YES;
+    });
+  return result;
+}
+
+- (NSArray*) matchesInString: (NSString*)string
+                     options: (NSMatchingOptions)opts
+                       range: (NSRange)range
+{
+  NSMutableArray	*array = [NSMutableArray array];
+  NSUInteger		groups = [self numberOfCaptureGroups] + 1;
+  NSRange		ranges[groups];
+
+  FAKE_BLOCK_HACK(array,
+    {
+      NSTextCheckingResult	*result = NULL;
+
+      prepareResult(self, r, ranges, groups, &s);
+      result = [NSTextCheckingResult
+	regularExpressionCheckingResultWithRanges: ranges
+					    count: groups
+				regularExpression: self];
+      [array addObject: result];
+    });
+  return array;
+}
+
+- (NSRange) rangeOfFirstMatchInString: (NSString*)string
                               options: (NSMatchingOptions)opts
                                 range: (NSRange)range
+{
+  NSRange result = {0,0};
 
-{
-	NSUInteger count = 0;
-	FAKE_BLOCK_HACK(count,
-		{
-			count++;
-		});
-	return count;
-}
-- (NSTextCheckingResult*)firstMatchInString: (NSString*)string
-                                    options: (NSMatchingOptions)opts
-                                      range: (NSRange)range
-{
-	NSTextCheckingResult *result = nil;
-	NSUInteger groups = [self numberOfCaptureGroups] + 1;
-	NSRange ranges[groups];
-	FAKE_BLOCK_HACK(result,
-		{
-			prepareResult(self, r, ranges, groups, &s);
-			result =
-				[NSTextCheckingResult regularExpressionCheckingResultWithRanges: ranges
-				                                                          count: groups
-				                                              regularExpression: self];
-			stop = YES;
-		});
-	return result;
-}
-- (NSArray*)matchesInString: (NSString*)string
-                    options:(NSMatchingOptions)opts
-                      range:(NSRange)range
-{
-	NSMutableArray *array = [NSMutableArray array];
-	NSUInteger groups = [self numberOfCaptureGroups] + 1;
-	NSRange ranges[groups];
-	FAKE_BLOCK_HACK(array,
-		{
-			NSTextCheckingResult *result = NULL;
-			prepareResult(self, r, ranges, groups, &s);
-			result =
-				[NSTextCheckingResult regularExpressionCheckingResultWithRanges: ranges
-				                                                          count: groups
-				                                              regularExpression: self];
-			[array addObject: result];
-		});
-	return array;
-}
-- (NSRange)rangeOfFirstMatchInString: (NSString*)string
-                             options: (NSMatchingOptions)opts
-                               range: (NSRange)range
-{
-	NSRange result = {0,0};
-	FAKE_BLOCK_HACK(result,
-		{
-			prepareResult(self, r, &result, 1, &s);
-			stop = YES;
-		});
-	return result;
+  FAKE_BLOCK_HACK(result,
+    {
+      prepareResult(self, r, &result, 1, &s);
+      stop = YES;
+    });
+  return result;
 }
+
 #endif
-- (NSUInteger)replaceMatchesInString: (NSMutableString*)string
-                             options: (NSMatchingOptions)opts
-                               range: (NSRange)range
-                        withTemplate: (NSString*)template
+
+- (NSUInteger) replaceMatchesInString: (NSMutableString*)string
+                              options: (NSMatchingOptions)opts
+                                range: (NSRange)range
+                         withTemplate: (NSString*)template
 {
-	// FIXME: We're computing a value that is most likely ignored in an
-	// expensive way.
-	NSInteger results = [self numberOfMatchesInString: string
-	                                          options: opts
-	                                            range: range];
-	UErrorCode s = 0;
-	UText txt = UTEXT_INITIALIZER;
-	UText replacement = UTEXT_INITIALIZER;
-	GSUTextString *ret = [GSUTextString new];
-	URegularExpression *r = setupRegex(regex, string, &txt, opts, range, 0);
-	UText *output = NULL;
-	UTextInitWithNSString(&replacement, template);
+  // FIXME: We're computing a value that is most likely ignored in an
+  // expensive way.
+  NSInteger	results = [self numberOfMatchesInString: string
+						options: opts
+						  range: range];
+  UErrorCode	s = 0;
+  UText		txt = UTEXT_INITIALIZER;
+  UText		replacement = UTEXT_INITIALIZER;
+  GSUTextString	*ret = [GSUTextString new];
+  URegularExpression *r = setupRegex(regex, string, &txt, opts, range, 0);
+  UText		*output = NULL;
 
-	output = uregex_replaceAllUText(r, &replacement, NULL, &s);
-	utext_clone(&ret->txt, output, TRUE, TRUE, &s);
-	[string setString: ret];
-	[ret release];
-	uregex_close(r);
+  UTextInitWithNSString(&replacement, template);
 
-	utext_close(&txt);
-	utext_close(output);
-	utext_close(&replacement);
-	return results;
+  output = uregex_replaceAllUText(r, &replacement, NULL, &s);
+  utext_clone(&ret->txt, output, TRUE, TRUE, &s);
+  [string setString: ret];
+  [ret release];
+  uregex_close(r);
+
+  utext_close(&txt);
+  utext_close(output);
+  utext_close(&replacement);
+  return results;
 }
 
-- (NSString*)stringByReplacingMatchesInString: (NSString*)string
-                                      options: (NSMatchingOptions)opts
-                                        range: (NSRange)range
-                                 withTemplate: (NSString*)template
+- (NSString*) stringByReplacingMatchesInString: (NSString*)string
+                                       options: (NSMatchingOptions)opts
+                                         range: (NSRange)range
+                                  withTemplate: (NSString*)template
 {
-	UErrorCode s = 0;
-	UText txt = UTEXT_INITIALIZER;
-	UText replacement = UTEXT_INITIALIZER;
-	UText *output = NULL;
-	GSUTextString *ret = [GSUTextString new];
-	URegularExpression *r = setupRegex(regex, string, &txt, opts, range, 0);
-	UTextInitWithNSString(&replacement, template);
+  UErrorCode	s = 0;
+  UText		txt = UTEXT_INITIALIZER;
+  UText		replacement = UTEXT_INITIALIZER;
+  UText		*output = NULL;
+  GSUTextString	*ret = [GSUTextString new];
+  URegularExpression *r = setupRegex(regex, string, &txt, opts, range, 0);
 
+  UTextInitWithNSString(&replacement, template);
 
-	output = uregex_replaceAllUText(r, &replacement, NULL, &s);
-	utext_clone(&ret->txt, output, TRUE, TRUE, &s);
-	uregex_close(r);
+  output = uregex_replaceAllUText(r, &replacement, NULL, &s);
+  utext_clone(&ret->txt, output, TRUE, TRUE, &s);
+  uregex_close(r);
 
-	utext_close(&txt);
-	utext_close(output);
-	utext_close(&replacement);
-	return ret;
+  utext_close(&txt);
+  utext_close(output);
+  utext_close(&replacement);
+  return ret;
 }
 
-- (NSString*)replacementStringForResult: (NSTextCheckingResult*)result
-                               inString: (NSString*)string
-                                 offset: (NSInteger)offset
-                               template: (NSString*)template
+- (NSString*) replacementStringForResult: (NSTextCheckingResult*)result
+                                inString: (NSString*)string
+                                  offset: (NSInteger)offset
+                                template: (NSString*)template
 {
-	UErrorCode s = 0;
-	UText txt = UTEXT_INITIALIZER;
-	UText replacement = UTEXT_INITIALIZER;
-	UText *output = NULL;
-	GSUTextString *ret = [GSUTextString new];
-	NSRange range = [result range];
-	URegularExpression *r = setupRegex(regex,
-	                                   [string substringWithRange: range],
-	                                   &txt,
-	                                   0,
-	                                   NSMakeRange(0, range.length),
-	                                   0);
-	UTextInitWithNSString(&replacement, template);
+  UErrorCode	s = 0;
+  UText		txt = UTEXT_INITIALIZER;
+  UText		replacement = UTEXT_INITIALIZER;
+  UText		*output = NULL;
+  GSUTextString	*ret = [GSUTextString new];
+  NSRange	range = [result range];
+  URegularExpression *r = setupRegex(regex,
+				     [string substringWithRange: range],
+				     &txt,
+				     0,
+				     NSMakeRange(0, range.length),
+				     0);
 
+  UTextInitWithNSString(&replacement, template);
 
-	output = uregex_replaceFirstUText(r, &replacement, NULL, &s);
-	utext_clone(&ret->txt, output, TRUE, TRUE, &s);
-	uregex_close(r);
+  output = uregex_replaceFirstUText(r, &replacement, NULL, &s);
+  utext_clone(&ret->txt, output, TRUE, TRUE, &s);
+  uregex_close(r);
 
-	utext_close(&txt);
-	utext_close(output);
-	utext_close(&replacement);
-	return ret;
+  utext_close(&txt);
+  utext_close(output);
+  utext_close(&replacement);
+  return ret;
 }
-- (NSRegularExpressionOptions)options
-{
-	return options;
-}
-- (NSUInteger)numberOfCaptureGroups
-{
-	UErrorCode s = 0;
-	return uregex_groupCount(regex, &s);
-}
-- (void)dealloc
-{
-	uregex_close(regex);
-	[super dealloc];
-}
-- (void)encodeWithCoder: (NSCoder*)aCoder
-{
-	if ([aCoder allowsKeyedCoding])
-	{
-		[aCoder encodeInteger: options forKey: @"options"];
-		[aCoder encodeObject: [self pattern] forKey: @"pattern"];
-	}
-	else
-	{
-		[aCoder encodeValueOfObjCType: @encode(NSRegularExpressionOptions) at: &options];
-		[aCoder encodeObject: [self pattern]];
-	}
-}
-- initWithCoder: (NSCoder*)aCoder
-{
-	NSString *pattern;
-	if ([aCoder allowsKeyedCoding])
-	{
-		options = [aCoder decodeIntegerForKey: @"options"];
-		pattern = [aCoder decodeObjectForKey: @"pattern"];
-	}
-	else
-	{
-		[aCoder decodeValueOfObjCType: @encode(NSRegularExpressionOptions) at: &options];
-		pattern = [aCoder decodeObject];
-	}
-	return [self initWithPattern: pattern options: options error: NULL];
-}
-- copyWithZone: (NSZone*)aZone
-{
-	NSRegularExpressionOptions opts = options;
-	UErrorCode s = 0;
-	URegularExpression *r = uregex_clone(regex, &s);
-	if (0 != s) { return nil; }
 
-	self = [[self class] allocWithZone: aZone];
-	if (nil == self) { return nil; }
-	options = opts;
-	regex = r;
-	return self;
+- (NSRegularExpressionOptions) options
+{
+  return options;
+}
+
+- (NSUInteger) numberOfCaptureGroups
+{
+  UErrorCode s = 0;
+  return uregex_groupCount(regex, &s);
+}
+
+- (void) dealloc
+{
+  uregex_close(regex);
+  [super dealloc];
+}
+
+- (void) encodeWithCoder: (NSCoder*)aCoder
+{
+  if ([aCoder allowsKeyedCoding])
+    {
+      [aCoder encodeInteger: options forKey: @"options"];
+      [aCoder encodeObject: [self pattern] forKey: @"pattern"];
+    }
+  else
+    {
+      [aCoder encodeValueOfObjCType: @encode(NSRegularExpressionOptions)
+				 at: &options];
+      [aCoder encodeObject: [self pattern]];
+    }
+}
+
+- (id) initWithCoder: (NSCoder*)aCoder
+{
+  NSString	*pattern;
+
+  if ([aCoder allowsKeyedCoding])
+    {
+      options = [aCoder decodeIntegerForKey: @"options"];
+      pattern = [aCoder decodeObjectForKey: @"pattern"];
+    }
+  else
+    {
+      [aCoder decodeValueOfObjCType: @encode(NSRegularExpressionOptions)
+				 at: &options];
+      pattern = [aCoder decodeObject];
+    }
+  return [self initWithPattern: pattern options: options error: NULL];
+}
+
+- (id) copyWithZone: (NSZone*)aZone
+{
+  NSRegularExpressionOptions	opts = options;
+  UErrorCode			s = 0;
+  URegularExpression		*r = uregex_clone(regex, &s);
+
+  if (0 != s)
+    {
+      return nil;
+    }
+
+  self = [[self class] allocWithZone: aZone];
+  if (nil == self)
+    {
+      return nil;
+    }
+  options = opts;
+  regex = r;
+  return self;
 }
 @end
 #endif //U_ICU_VERSION_MAJOR_NUM > 4 || (U_ICU_VERSION_MAJOR_NUM == 4 && U_ICU_VERSION_MINOR_NUM >= 4))