Made closer to the Cactus coding guidelines.

git-svn-id: http://svn.cactuscode.org/arrangements/CactusConnect/HTTPD/trunk@204 1faa4e14-9dd3-4be0-9f0e-ffe519881164

1 files changed, 369 insertions, 299 deletions

diff --git a/src/SString.c b/src/SString.c
index 063b5e5..0a5963e 100644
--- a/src/SString.c
+++ b/src/SString.c
@@ -1,4 +1,4 @@
- /*@@
+/*@@
   @file      SString.c
   @date      02.04.2004
   @author    Steve White
@@ -30,32 +30,32 @@ static void String_HandleSeriousError( SSTRING_ERROR );
 
 typedef struct String_tag
 {
-	size_t	length;
-	SSCHAR	*chars;
-	SSCHAR	line_end[LINE_END_BUFSIZE];
+  size_t  length;
+  SSCHAR  *chars;
+  SSCHAR  line_end[LINE_END_BUFSIZE];
 } String_placeholder;
 
-static SSCHAR	kLineEndChar = '\n';
+static SSCHAR   kLineEndChar = '\n';
 
-static SSBOOL	BufferForThisManyChars( String *s, size_t size );
+static SSBOOL   BufferForThisManyChars( String *s, size_t size );
 
 size_t
 StringLength( const String * s )
 {
-	return s->length;
+  return s->length;
 }
 
 const SSCHAR *
 StringGetBuffer( const String * s )
 {
-	return s->chars;
+  return s->chars;
 }
 
 void
 StringCopyBuffer( const String * s, SSCHAR * buf, size_t bufSize )
 {
-	strncpy( buf, s->chars, bufSize );
-	buf[bufSize-1] = '\0';
+  strncpy( buf, s->chars, bufSize );
+  buf[bufSize-1] = '\0';
 }
 
 /*
@@ -64,43 +64,54 @@ StringCopyBuffer( const String * s, SSCHAR * buf, size_t bufSize )
 SSCHAR
 StringNthChar( const String * s, size_t n )
 {
-	if( n < s->length )
-		return s->chars[n];
-	else
-		return '\0';
+  if( n < s->length )
+  {
+    return s->chars[n];
+  }
+  else
+  {
+    return '\0';
+  }
 }
 
 String *
 String_New()
 {
-	String *s = (String *)calloc( 1, sizeof( String ) );
-	if( s != NULL )
-		BufferForThisManyChars( s, 0 );
-	else
-		String_HandleSeriousError( NEW_NULL_ALLOC );
-		
-	return s;
+  String *s = (String *)calloc( 1, sizeof( String ) );
+  if( s != NULL )
+  {
+    BufferForThisManyChars( s, 0 );
+  }
+  else
+  {
+    String_HandleSeriousError( NEW_NULL_ALLOC );
+  }             
+  return s;
 }
 
 String *
 String_Make( const SSCHAR * c_string )
 {
-	String *s = (String *)calloc( 1, sizeof( String ) );
-	if( s != NULL )
-	{
-		if( c_string != NULL )
-		{
-			size_t len = strlen( c_string );
-			s->chars = strdup( c_string );
-			s->length = len;
-		}
-		else
-			BufferForThisManyChars( s, 0 );
-		s->line_end[0] = kLineEndChar;
-	}
-	else
-		String_HandleSeriousError( MAKE_NULL_ALLOC );
-	return s;
+  String *s = (String *)calloc( 1, sizeof( String ) );
+  if( s != NULL )
+  {
+    if( c_string != NULL )
+    {
+      size_t len = strlen( c_string );
+      s->chars = strdup( c_string );
+      s->length = len;
+    }
+    else
+    {
+      BufferForThisManyChars( s, 0 );
+    }
+    s->line_end[0] = kLineEndChar;
+  }
+  else
+  {
+    String_HandleSeriousError( MAKE_NULL_ALLOC );
+  }
+  return s;
 }
 
 /* note this is a little ambiguous.
@@ -109,60 +120,66 @@ String_Make( const SSCHAR * c_string )
 String *
 String_Copy( const String * other )
 {
-	String *s = StringSetToCString( String_New(),
-			StringGetBuffer( other ) );
-	memcpy( s->line_end, other->line_end, LINE_END_BUFSIZE
-			* sizeof( SSCHAR ) );
-	return s;
+  String *s = StringSetToCString( String_New(),
+                                  StringGetBuffer( other ) );
+  memcpy( s->line_end, other->line_end, LINE_END_BUFSIZE
+          * sizeof( SSCHAR ) );
+  return s;
 }
 
 void
 String_Delete( String * s )
 {
-	if( s != NULL )
-		free( s->chars );
-	free( s );
+  if( s != NULL )
+  {
+    free( s->chars );
+  }
+  free( s );
 }
 
 String *
 StringTruncate( String * s, size_t n )
 {
-	if( n < s->length )
-	{
-		s->chars[n] = '\0';
-		s->length = n;
-	}
-	return s;
+  if( n < s->length )
+  {
+    s->chars[n] = '\0';
+    s->length = n;
+  }
+  return s;
 }
 
 String *
 StringTrimLeading( String * s, size_t n )
 {
-	const size_t orig_len = StringLength( s );
+  const size_t orig_len = StringLength( s );
 
-	if( orig_len > 0 && n > 0 )
-	{
-		const size_t position = MIN( orig_len, n ) - 1;
-		const size_t new_len = orig_len - position;
-		
-		memmove( 0, s->chars + position, new_len );
-		s->chars[new_len] = '\0';
-		s->length = new_len;
-	}
-	return s;
+  if( orig_len > 0 && n > 0 )
+  {
+    const size_t position = MIN( orig_len, n ) - 1;
+    const size_t new_len = orig_len - position;
+                
+    memmove( 0, s->chars + position, new_len );
+    s->chars[new_len] = '\0';
+    s->length = new_len;
+  }
+  return s;
 }
 
 String *
 StringSetNthChar( String * s, size_t n, SSCHAR c )
 {
-	if( n < s->length )
-	{
-		if( c == '\0' )
-			StringTruncate( s, n );
-		else
-			s->chars[n] = c;
-	}
-	return s;
+  if( n < s->length )
+  {
+    if( c == '\0' )
+    {
+      StringTruncate( s, n );
+    }
+    else
+    {
+      s->chars[n] = c;
+    }
+  }
+  return s;
 }
 /* Allocates if there is no buffer
  * Re-allocates (without changing remaining string) if there is a buffer
@@ -172,89 +189,97 @@ StringSetNthChar( String * s, size_t n, SSCHAR c )
 SSBOOL
 BufferForThisManyChars( String *s, size_t size )
 {
-	const size_t	blocksize = sizeof( SSCHAR ) * ( size + 1 );
-
-	if( s->chars == NULL )
-		s->chars = (SSCHAR *)malloc( blocksize );
-	else if( s->length < size )
-		s->chars = (SSCHAR *)realloc( s->chars, blocksize );
-	else if( s->length > ( size << 1 ) ) /* Don't resize if larger
-						but in ballpark */
-	{
-		s->length = 0;
-		s->chars = (SSCHAR *)malloc( blocksize );
-	}
-
-	if( s->chars != NULL )
-	{
-		s->length = size;
-		if( s->chars != NULL )
-			s->chars[size] = '\0';
-	}
-	else
-		String_HandleSeriousError( BUFFER_NULL_ALLOC );
-
-	return s->chars != NULL;
+  const size_t    blocksize = sizeof( SSCHAR ) * ( size + 1 );
+
+  if( s->chars == NULL )
+  {
+    s->chars = (SSCHAR *)malloc( blocksize );
+  }
+  else if( s->length < size )
+  {
+    s->chars = (SSCHAR *)realloc( s->chars, blocksize );
+  }
+  else if( s->length > ( size << 1 ) ) /* Don't resize if larger
+                                          but in ballpark */
+  {
+    s->length = 0;
+    s->chars = (SSCHAR *)malloc( blocksize );
+  }
+
+  if( s->chars != NULL )
+  {
+    s->length = size;
+    if( s->chars != NULL )
+      s->chars[size] = '\0';
+  }
+  else
+  {
+    String_HandleSeriousError( BUFFER_NULL_ALLOC );
+  }
+
+  return s->chars != NULL;
 }
 
 String *
 StringSetToCString( String * s, const SSCHAR *c_string )
 {
-	return StringSetToBuffer( s, c_string, strlen( c_string ) );
+  return StringSetToBuffer( s, c_string, strlen( c_string ) );
 }
 
 size_t
 StringSetNextToken( const String *s, String *token,
-		const SSCHAR *delim, size_t start )
+                    const SSCHAR *delim, size_t start )
 {
-	if( start < s->length )
-	{
-		const size_t	ndelims = strlen( delim );
-		size_t		next = s->length;
-		size_t		d;
+  if( start < s->length )
+  {
+    const size_t    ndelims = strlen( delim );
+    size_t          next = s->length;
+    size_t          d;
 
-		for( d = 0; d < ndelims; d++ )
-		{
-			size_t nextDelim = start;
-			if( StringFindCharFrom( s, delim[d], &nextDelim ) )
-				next = MIN( nextDelim, next ); 
-		}
+    for( d = 0; d < ndelims; d++ )
+    {
+      size_t nextDelim = start;
+      if( StringFindCharFrom( s, delim[d], &nextDelim ) )
+        next = MIN( nextDelim, next ); 
+    }
 
-		StringSetRange( token, s, start, next - start );
+    StringSetRange( token, s, start, next - start );
 
-		return next < s->length ? next + 1 : next;
-	}
-	else
-		return 0;
+    return next < s->length ? next + 1 : next;
+  }
+  else
+  {
+    return 0;
+  }
 }
 
 String *
 StringConcatCString( String * s, const SSCHAR *c_string )
 {
-	const size_t orig_len = s->length;
-	if( BufferForThisManyChars( s, orig_len + strlen( c_string ) ) )
-	{
-		strcpy( s->chars + orig_len, c_string );
-	}
-	return s;
+  const size_t orig_len = s->length;
+  if( BufferForThisManyChars( s, orig_len + strlen( c_string ) ) )
+  {
+    strcpy( s->chars + orig_len, c_string );
+  }
+  return s;
 }
 
 String *
 StringSetToBuffer( String * s, const SSCHAR *buf, size_t len )
 {
-	if( s != NULL && buf != NULL )
-		if( BufferForThisManyChars( s, len ) )
-		{
-			strncpy( s->chars, buf, len );
-			s->chars[ len ] = '\0';
-		}
-	return s;
+  if( s != NULL && buf != NULL )
+    if( BufferForThisManyChars( s, len ) )
+    {
+      strncpy( s->chars, buf, len );
+      s->chars[ len ] = '\0';
+    }
+  return s;
 }
 
 String *
 StringSet( String * s, const String * other )
 {
-	return StringSetToCString( s, StringGetBuffer( other ) );
+  return StringSetToCString( s, StringGetBuffer( other ) );
 }
 /*
  * Take care! What if this String's buffer is the same as the other's?
@@ -266,21 +291,21 @@ StringSet( String * s, const String * other )
  */
 String *
 StringSetRange( String * s, const String * other,
-			size_t first, size_t length )
+                size_t first, size_t length )
 {
-	const size_t	other_length = other->length;
-	const size_t	veryFirst = MIN( first + 1, other_length ) - 1,
-			minLength = MIN( first + length, other_length ),
-			newLength = minLength - veryFirst;
+  const size_t    other_length = other->length;
+  const size_t    veryFirst = MIN( first + 1, other_length ) - 1,
+      minLength = MIN( first + length, other_length ),
+      newLength = minLength - veryFirst;
 
-	return StringSetToBuffer( s, other->chars + veryFirst, newLength );
+  return StringSetToBuffer( s, other->chars + veryFirst, newLength );
 }
 
 String *
 StringSetToPartAfter( String * s, const String * other, size_t position )
 {
-	return StringSetRange( s, other,
-			position + 1, StringLength( other ) - position );
+  return StringSetRange( s, other,
+                         position + 1, StringLength( other ) - position );
 }
 
 /*
@@ -291,102 +316,115 @@ StringSetToPartAfter( String * s, const String * other, size_t position )
 SSBOOL
 StringFindCharFrom( const String *s, SSCHAR theChar, size_t * position )
 {
-	SSCHAR	* charPtr;
+  SSCHAR  * charPtr;
 
-	if( s->length > 0
-	&& position
-	&& *position < s->length
-	&& ( charPtr = (SSCHAR *)strchr( s->chars + *position, theChar ) )
-			!= NULL )
-	{
-		*position = ( charPtr - s->chars ) / sizeof( SSCHAR );
-		return SSTRUE;
-	}
-	return SSFALSE;
+  if( s->length > 0
+      && position
+      && *position < s->length
+      && ( charPtr = (SSCHAR *)strchr( s->chars + *position, theChar ) )
+      != NULL )
+  {
+    *position = ( charPtr - s->chars ) / sizeof( SSCHAR );
+    return SSTRUE;
+  }
+  return SSFALSE;
 }
 
 SSBOOL
 StringFindStringFrom( const String * s, const String * other,
-			size_t * position )
+                      size_t * position )
 {
-	SSCHAR	* charPtr;
+  SSCHAR  * charPtr;
 
-	if( s->length >= other->length
-	&& position
-	&& *position < s->length
-	&& s->length > 0
-	&& other->length > 0
-	&& ( charPtr = (SSCHAR *)strstr( s->chars + *position, other->chars ) )
-			!= NULL )
-	{
-		*position = ( charPtr - s->chars ) / sizeof( SSCHAR );
-		return SSTRUE;
-	}
-	return SSFALSE;
+  if( s->length >= other->length
+      && position
+      && *position < s->length
+      && s->length > 0
+      && other->length > 0
+      && ( charPtr = (SSCHAR *)strstr( s->chars + *position, other->chars ) )
+      != NULL )
+  {
+    *position = ( charPtr - s->chars ) / sizeof( SSCHAR );
+    return SSTRUE;
+  }
+  return SSFALSE;
 }
 
 SSBOOL
 StringEquals( const String * a, const String * b )
 {
-	if( a->length > 0 )
-		return strncmp( a->chars, b->chars, a->length ) == 0;
-	else if( b->length == 0 )
-		return SSTRUE;
-
-	return SSFALSE;
+  if( a->length > 0 )
+  {
+    return strncmp( a->chars, b->chars, a->length ) == 0;
+  }
+  else if( b->length == 0 )
+  {
+    return SSTRUE;
+  }
+  return SSFALSE;
 }
 
 int
 StringCompare( const String * a, const String * b )
 {
-	return StringCompareCString( a, b->chars );
+  return StringCompareCString( a, b->chars );
 }
 
 int
 StringCompareCString( const String * a, const char * b )
 {
-	const size_t	length = MIN( a->length, strlen( b ) );
+  const size_t    length = MIN( a->length, strlen( b ) );
 
-	if( length > 0 )
-		return strncmp( a->chars, b, length );
-	else if( strlen( b ) == 0 )
-		return 0;
-	else		/* b is empty but a isn't */
-		return 1;
+  if( length > 0 )
+  {
+    return strncmp( a->chars, b, length );
+  }
+  else if( strlen( b ) == 0 )
+  {
+    return 0;
+  }
+  else            /* b is empty but a isn't */
+  {
+    return 1;
+  }
 }
 
 String *
 StringInsert( String * s, const String * other, size_t position )
 {
-	const size_t	oldLength = s->length, otherLength = other->length;
-	String		*old = String_Copy( s );
+  const size_t    oldLength = s->length, otherLength = other->length;
+  String          *old = String_Copy( s );
 
-	if( otherLength > 0
-	&& position <= oldLength
-	&& BufferForThisManyChars( s, oldLength + otherLength ) )
-	{
-		if( position != 0 )
-			strncpy( s->chars, old->chars, position );
+  if( otherLength > 0
+      && position <= oldLength
+      && BufferForThisManyChars( s, oldLength + otherLength ) )
+  {
+    if( position != 0 )
+    {
+      strncpy( s->chars, old->chars, position );
+    }
 
-		strncpy( s->chars + position, other->chars, otherLength );
+    strncpy( s->chars + position, other->chars, otherLength );
 
-		if( position < oldLength )
-			strncpy( s->chars + position + otherLength,
-				old->chars + position, oldLength - position );
-		s->chars[s->length] = '\0';
-	}
-	String_Delete( old );
+    if( position < oldLength )
+    {
+      strncpy( s->chars + position + otherLength,
+               old->chars + position, oldLength - position );
+    }
+    s->chars[s->length] = '\0';
+  }
+  String_Delete( old );
 
-	return s;
+  return s;
 }
 
 String *
 StringInsertCString( String * s, const char * c_string, size_t position )
 {
-	String *other = String_Make( c_string );
-	StringInsert( s, other, position );
-	String_Delete( other );
-	return s;
+  String *other = String_Make( c_string );
+  StringInsert( s, other, position );
+  String_Delete( other );
+  return s;
 }
 /*
  * What to do if position is off end of string?  We do nothing
@@ -394,46 +432,46 @@ StringInsertCString( String * s, const char * c_string, size_t position )
 String *
 StringInsertChar( String * s, SSCHAR c, size_t position )
 {
-	if( position <= s->length )
-	{
-		BufferForThisManyChars( s, s->length + 1 );
-		if( position + 2 < s->length )
-		{
-			s->chars[s->length] = '\0';
-			memmove( s->chars + position + 1, s->chars + position,
-					s->length - 1 - position );
-			s->chars[position] = c;
-		}
-	}
-	return s;
+  if( position <= s->length )
+  {
+    BufferForThisManyChars( s, s->length + 1 );
+    if( position + 2 < s->length )
+    {
+      s->chars[s->length] = '\0';
+      memmove( s->chars + position + 1, s->chars + position,
+               s->length - 1 - position );
+      s->chars[position] = c;
+    }
+  }
+  return s;
 }
 
 String *
 StringDeleteChar( String * s, size_t position )
 {
-	return StringDeleteRange( s, position, position );
+  return StringDeleteRange( s, position, position );
 }
 
 String *
 StringDeleteRange( String * s, size_t begin, size_t end )
 {
-	if( begin <= end && end < s->length )
-	{
-		if( end + 1 < s->length )
-		{
-			memmove( s->chars + begin, s->chars + end + 1,
-					( s->length - end ) - 1 );
-		}
-		s->length -= end - begin;
-		s->chars[s->length] = '\0';
-	}
-	return s;
+  if( begin <= end && end < s->length )
+  {
+    if( end + 1 < s->length )
+    {
+      memmove( s->chars + begin, s->chars + end + 1,
+               ( s->length - end ) - 1 );
+    }
+    s->length -= end - begin;
+    s->chars[s->length] = '\0';
+  }
+  return s;
 }
 
 String *
 StringConcat( String * s, const String * other )
 {
-	return StringInsert( s, other, s->length );
+  return StringInsert( s, other, s->length );
 }
 
 /*
@@ -442,67 +480,69 @@ StringConcat( String * s, const String * other )
 void
 StringSetLineEndCharacter( String * s, const SSCHAR *end )
 {
-	strncpy( s->line_end, end, LINE_END_BUFSIZE );
-	s->line_end[LINE_END_BUFSIZE - 1] = '\0';
+  strncpy( s->line_end, end, LINE_END_BUFSIZE );
+  s->line_end[LINE_END_BUFSIZE - 1] = '\0';
 }
 
 String *
 StringReadToEndOfLine( String * s, FILE * file )
 {
-	return StringReadToDelimiter( s, file, kLineEndChar );
+  return StringReadToDelimiter( s, file, kLineEndChar );
 }
 
 String *
 StringReadToDelimiter( String * s, FILE * file, SSCHAR delim )
 {
-	int	next;
+  int     next;
 
-	while( ( next = fgetc( file ) ) != EOF 
-	&& (SSCHAR)next != delim )
-		StringInsertChar( s, (SSCHAR)next, s->length );
+  while( ( next = fgetc( file ) ) != EOF 
+         && (SSCHAR)next != delim )
+  {
+    StringInsertChar( s, (SSCHAR)next, s->length );
+  }
 
-	return s;
+  return s;
 }
 
 void
 StringPrint( const String * s )
 {
-	fprintf( stdout, "%s", s->chars );
+  fprintf( stdout, "%s", s->chars );
 }
 
 void
 StringPrintToFile( const String * s, FILE * file )
 {
-	fprintf( file, "%s", s->chars );
+  fprintf( file, "%s", s->chars );
 }
 
 void
 StringFormatPrint( const String * s, const SSCHAR *format )
 {
-	fprintf( stdout, format, s->chars );
+  fprintf( stdout, format, s->chars );
 }
 
 void
 StringFormatPrintToFile( const String * s, const SSCHAR *format, FILE * file )
 {
-	fprintf( file, format, s->chars );
+  fprintf( file, format, s->chars );
 }
 
 #define DECIMALBUFSIZE 64
 String *
 StringConcatDecimal( String * s, long d )
 {
-	char buf[DECIMALBUFSIZE] = { '\0' };
-	Util_snprintf( buf, sizeof( buf ), "%ld", d );
-	return StringConcatCString( s, buf );
+  char buf[DECIMALBUFSIZE] = { '\0' };
+  Util_snprintf( buf, sizeof( buf ), "%ld", d );
+  return StringConcatCString( s, buf );
 }
 
 String *
 StringConcatDouble( String * s, double d )
 {
-	char buf[DECIMALBUFSIZE] = { '\0' };
-	Util_snprintf( buf, sizeof( buf ), "%f", d );
-	return StringConcatCString( s, buf );
+  char buf[DECIMALBUFSIZE] = { '\0' };
+  Util_snprintf( buf, sizeof( buf ), "%f", d );
+  return StringConcatCString( s, buf );
 }
 /*a
  *
@@ -524,87 +564,117 @@ StringConcatDouble( String * s, double d )
 static void
 addNumericMods( char * format, SSFORMAT f )
 {
-	strcat( format, "%" );
-	if( f & SFMT_LEFT_ALIGN )
-		strcat( format, "-" );
-	if( f & SFMT_PRINT_SIGN )
-		strcat( format, "+" );
-	if( f & SFMT_ADD_SIGN_SPACE )
-		strcat( format, " " );
-	if( f & SFMT_PAD_ZERO )
-		strcat( format, "0" );
-	if( f & SFMT_ALT )
-		strcat( format, "#" );
+  strcat( format, "%" );
+  if( f & SFMT_LEFT_ALIGN )
+  {
+    strcat( format, "-" );
+  }
+  if( f & SFMT_PRINT_SIGN )
+  {
+    strcat( format, "+" );
+  }
+  if( f & SFMT_ADD_SIGN_SPACE )
+  {
+    strcat( format, " " );
+  }
+  if( f & SFMT_PAD_ZERO )
+  {
+    strcat( format, "0" );
+  }
+  if( f & SFMT_ALT )
+  {
+    strcat( format, "#" );
+  }
 }
 #define EMPTYSTRING { '\0' }
 String *
 StringConcatFormattedDecimal( String *s, long int d,
-			int width, int precision, SSINT_FORMAT f )
+                              int width, int precision, SSINT_FORMAT f )
 {
-	char buf[DECIMALBUFSIZE] = EMPTYSTRING;
-	char format[16] = EMPTYSTRING;
-	addNumericMods( format, f );
-	strcat( format, "*.*ld" );
-	Util_snprintf( buf, sizeof( buf ), format, width, precision, d );
-	return StringConcatCString( s, buf );
+  char buf[DECIMALBUFSIZE] = EMPTYSTRING;
+  char format[16] = EMPTYSTRING;
+  addNumericMods( format, f );
+  strcat( format, "*.*ld" );
+  Util_snprintf( buf, sizeof( buf ), format, width, precision, d );
+  return StringConcatCString( s, buf );
 }
 
 String *
 StringConcatFormattedUnsigned( String *s, unsigned long int n,
-			int width, int precision, SSINT_FORMAT f )
-{
-	char buf[DECIMALBUFSIZE] = EMPTYSTRING;
-	char format[16] = EMPTYSTRING;
-	addNumericMods( format, f );
-	strcat( format, "*.*l" );
-	if( f & SFMT_HEX )
-	{
-		if( f & SFMT_LOWERCASE )
-			strcat( format, "x" );
-		else
-			strcat( format, "X" );
-	}
-	else if( f & SFMT_OCTAL )
-		strcat( format, "o" );
-	else
-		strcat( format, "u" );
-	Util_snprintf( buf, sizeof( buf ), format, width, precision, n );
-	return StringConcatCString( s, buf );
+                               int width, int precision, SSINT_FORMAT f )
+{
+  char buf[DECIMALBUFSIZE] = EMPTYSTRING;
+  char format[16] = EMPTYSTRING;
+  addNumericMods( format, f );
+  strcat( format, "*.*l" );
+  if( f & SFMT_HEX )
+  {
+    if( f & SFMT_LOWERCASE )
+    {
+      strcat( format, "x" );
+    }
+    else
+    {
+      strcat( format, "X" );
+    }
+  }
+  else if( f & SFMT_OCTAL )
+  {
+    strcat( format, "o" );
+  }
+  else
+  {
+    strcat( format, "u" );
+  }
+  Util_snprintf( buf, sizeof( buf ), format, width, precision, n );
+  return StringConcatCString( s, buf );
 }
 
 String *
 StringConcatFormattedDouble( String *s, double d,
-			int width, int precision, SSDOUBLE_FORMAT f  )
-{
-	char buf[DECIMALBUFSIZE] = EMPTYSTRING;
-	char format[16] = EMPTYSTRING;
-	addNumericMods( format, f );
-	if( f & SFMT_ALWAYS_POINT )
-		strcat( format, "#" );
-	strcat( format, "*.*" );
-	if( f & SFMT_EXPONENTIAL )
-	{
-		if( f & SFMT_LOWERCASE )
-			strcat( format, "e" );
-		else
-			strcat( format, "E" );
-	}
-	if( f & SFMT_DISCRETIONARY_EXP )
-	{
-		if( f & SFMT_LOWERCASE )
-			strcat( format, "g" );
-		else
-			strcat( format, "G" );
-	}
-	else
-		strcat( format, "f" );
-	Util_snprintf( buf, sizeof( buf ), format, width, precision, d );
-	return StringConcatCString( s, buf );
+                             int width, int precision, SSDOUBLE_FORMAT f  )
+{
+  char buf[DECIMALBUFSIZE] = EMPTYSTRING;
+  char format[16] = EMPTYSTRING;
+  addNumericMods( format, f );
+  if( f & SFMT_ALWAYS_POINT )
+  {
+    strcat( format, "#" );
+  }
+  strcat( format, "*.*" );
+  if( f & SFMT_EXPONENTIAL )
+  {
+    if( f & SFMT_LOWERCASE )
+    {
+      strcat( format, "e" );
+    }
+    else
+    {
+      strcat( format, "E" );
+    }
+  }
+  if( f & SFMT_DISCRETIONARY_EXP )
+  {
+    if( f & SFMT_LOWERCASE )
+    {
+      strcat( format, "g" );
+    }
+    else
+    {
+      strcat( format, "G" );
+    }
+  }
+  else
+  {
+    strcat( format, "f" );
+  }
+  Util_snprintf( buf, sizeof( buf ), format, width, precision, d );
+  return StringConcatCString( s, buf );
 }
 
 void
 String_HandleSeriousError( SSTRING_ERROR e )
 {
-	/* to be filled in on a per-implementation basis */
+  /* to be filled in on a per-implementation basis */
 }