Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/triostr.c

 /*************************************************************************
  *
  * $Id$
  *
  * Copyright (C) 2001 Bjorn Reese and Daniel Stenberg.
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
@@ skipping 34 matching lines @@
 # define NIL ((char)0)
 #endif
 #if !defined(FALSE)
 # define FALSE (1 == 0)
 # define TRUE (! FALSE)
 #endif
 #if !defined(BOOLEAN_T)
 # define BOOLEAN_T int
 #endif
 
-#if defined(TRIO_COMPILER_SUPPORTS_C99)
+#ifdef __VMS
+# define USE_STRTOD
+#elif defined(TRIO_COMPILER_SUPPORTS_C99)
 # define USE_STRTOD
 # define USE_STRTOF
 #elif defined(TRIO_COMPILER_MSVC)
 # define USE_STRTOD
 #endif
 
 #if defined(TRIO_PLATFORM_UNIX)
 # define USE_STRCASECMP
 # define USE_STRNCASECMP
 # if defined(TRIO_PLATFORM_SUNOS)
 #  define USE_SYS_ERRLIST
 # else
 #  define USE_STRERROR
 # endif
 # if defined(TRIO_PLATFORM_QNX)
 #  define strcasecmp(x,y) stricmp(x,y)
 #  define strncasecmp(x,y,n) strnicmp(x,y,n)
 # endif
 #elif defined(TRIO_PLATFORM_WIN32)
 # define USE_STRCASECMP
 # if defined(_WIN32_WCE)
 #  define strcasecmp(x,y) _stricmp(x,y)
 # else
 #  define strcasecmp(x,y) strcmpi(x,y)
 # endif
+#elif defined(TRIO_PLATFORM_OS400)
+# define USE_STRCASECMP
+# define USE_STRNCASECMP
+# include <strings.h>
 #endif
 
 #if !(defined(TRIO_PLATFORM_SUNOS))
 # define USE_TOLOWER
 # define USE_TOUPPER
 #endif
 
 /*************************************************************************
  * Structures
  */
@@ skipping 67 matching lines @@
 TRIO_ARGS1((string),
            TRIO_CONST char *string)
 {
   return strlen(string);
 }
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Append @p source at the end of @p target.
-   
+
    @param target Target string.
    @param source Source string.
    @return Boolean value indicating success or failure.
-   
+
    @pre @p target must point to a memory chunk with sufficient room to
    contain the @p target string and @p source string.
    @pre No boundary checking is performed, so insufficient memory will
    result in a buffer overrun.
    @post @p target will be zero terminated.
 */
 TRIO_STRING_PUBLIC int
 trio_append
 TRIO_ARGS2((target, source),
            char *target,
            TRIO_CONST char *source)
 {
   assert(target);
   assert(source);
-  
+
   return (strcat(target, source) != NULL);
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 #if !defined(TRIO_MINIMAL)
 /**
    Append at most @p max characters from @p source to @p target.
-   
+
    @param target Target string.
    @param max Maximum number of characters to append.
    @param source Source string.
    @return Boolean value indicating success or failure.
-   
+
    @pre @p target must point to a memory chuck with sufficient room to
    contain the @p target string and the @p source string (at most @p max
    characters).
    @pre No boundary checking is performed, so insufficient memory will
    result in a buffer overrun.
    @post @p target will be zero terminated.
 */
 TRIO_STRING_PUBLIC int
 trio_append_max
 TRIO_ARGS3((target, max, source),
            char *target,
            size_t max,
            TRIO_CONST char *source)
 {
   size_t length;
-  
+
   assert(target);
   assert(source);
 
   length = trio_length(target);
-  
+
   if (max > length)
     {
       strncat(target, source, max - length - 1);
     }
   return TRUE;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Determine if a string contains a substring.
 
    @param string String to be searched.
    @param substring String to be found.
    @return Boolean value indicating success or failure.
 */
 TRIO_STRING_PUBLIC int
 trio_contains
 TRIO_ARGS2((string, substring),
            TRIO_CONST char *string,
            TRIO_CONST char *substring)
 {
   assert(string);
   assert(substring);
-  
+
   return (0 != strstr(string, substring));
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Copy @p source to @p target.
-   
+
    @param target Target string.
    @param source Source string.
    @return Boolean value indicating success or failure.
-   
+
    @pre @p target must point to a memory chunk with sufficient room to
    contain the @p source string.
    @pre No boundary checking is performed, so insufficient memory will
    result in a buffer overrun.
    @post @p target will be zero terminated.
 */
 TRIO_STRING_PUBLIC int
 trio_copy
 TRIO_ARGS2((target, source),
            char *target,
            TRIO_CONST char *source)
 {
   assert(target);
   assert(source);
-     
+
   (void)strcpy(target, source);
   return TRUE;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 /**
    Copy at most @p max characters from @p source to @p target.
-   
+
    @param target Target string.
    @param max Maximum number of characters to append.
    @param source Source string.
    @return Boolean value indicating success or failure.
-   
+
    @pre @p target must point to a memory chunk with sufficient room to
    contain the @p source string (at most @p max characters).
    @pre No boundary checking is performed, so insufficient memory will
    result in a buffer overrun.
    @post @p target will be zero terminated.
 */
 TRIO_STRING_PUBLIC int
 trio_copy_max
 TRIO_ARGS3((target, max, source),
            char *target,
@@ skipping 29 matching lines @@
   if (target)
     {
       trio_copy_max(target, size, source);
     }
   return target;
 }
 
 
 /**
    Duplicate @p source.
-   
+
    @param source Source string.
    @return A copy of the @p source string.
-   
+
    @post @p target will be zero terminated.
 */
 TRIO_STRING_PUBLIC char *
 trio_duplicate
 TRIO_ARGS1((source),
            TRIO_CONST char *source)
 {
   return TrioDuplicateMax(source, trio_length(source));
 }
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Duplicate at most @p max characters of @p source.
-   
+
    @param source Source string.
    @param max Maximum number of characters to duplicate.
    @return A copy of the @p source string.
-   
+
    @post @p target will be zero terminated.
 */
 TRIO_STRING_PUBLIC char *
 trio_duplicate_max TRIO_ARGS2((source, max),
                               TRIO_CONST char *source,
                               size_t max)
 {
   size_t length;
 
   assert(source);
   assert(max > 0);
 
   length = trio_length(source);
   if (length > max)
     {
       length = max;
     }
   return TrioDuplicateMax(source, length);
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 /**
    Compare if two strings are equal.
-   
+
    @param first First string.
    @param second Second string.
    @return Boolean indicating whether the two strings are equal or not.
-   
+
    Case-insensitive comparison.
 */
 TRIO_STRING_PUBLIC int
 trio_equal
 TRIO_ARGS2((first, second),
            TRIO_CONST char *first,
            TRIO_CONST char *second)
 {
   assert(first);
   assert(second);
@@ skipping 14 matching lines @@
         }
       return ((*first == NIL) && (*second == NIL));
 #endif
     }
   return FALSE;
 }
 
 
 /**
    Compare if two strings are equal.
-   
+
    @param first First string.
    @param second Second string.
    @return Boolean indicating whether the two strings are equal or not.
-   
+
    Case-sensitive comparison.
 */
 TRIO_STRING_PUBLIC int
 trio_equal_case
 TRIO_ARGS2((first, second),
            TRIO_CONST char *first,
            TRIO_CONST char *second)
 {
   assert(first);
   assert(second);
 
   if ((first != NULL) && (second != NULL))
     {
       return (0 == strcmp(first, second));
     }
   return FALSE;
 }
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Compare if two strings up until the first @p max characters are equal.
-   
+
    @param first First string.
    @param max Maximum number of characters to compare.
    @param second Second string.
    @return Boolean indicating whether the two strings are equal or not.
-   
+
    Case-sensitive comparison.
 */
 TRIO_STRING_PUBLIC int
 trio_equal_case_max
 TRIO_ARGS3((first, max, second),
            TRIO_CONST char *first,
            size_t max,
            TRIO_CONST char *second)
 {
   assert(first);
   assert(second);
 
   if ((first != NULL) && (second != NULL))
     {
       return (0 == strncmp(first, second, max));
     }
   return FALSE;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 /**
    Compare if two strings are equal.
-   
+
    @param first First string.
    @param second Second string.
    @return Boolean indicating whether the two strings are equal or not.
 
    Collating characters are considered equal.
 */
 TRIO_STRING_PUBLIC int
 trio_equal_locale
 TRIO_ARGS2((first, second),
            TRIO_CONST char *first,
            TRIO_CONST char *second)
 {
   assert(first);
   assert(second);
 
 #if defined(LC_COLLATE)
   return (strcoll(first, second) == 0);
 #else
   return trio_equal(first, second);
 #endif
 }
 
 
 /**
    Compare if two strings up until the first @p max characters are equal.
-   
+
    @param first First string.
    @param max Maximum number of characters to compare.
    @param second Second string.
    @return Boolean indicating whether the two strings are equal or not.
-   
+
    Case-insensitive comparison.
 */
 TRIO_STRING_PUBLIC int
 trio_equal_max
 TRIO_ARGS3((first, max, second),
            TRIO_CONST char *first,
            size_t max,
            TRIO_CONST char *second)
 {
   assert(first);
@@ skipping 28 matching lines @@
 
    @param error_number Error number.
    @return Textual description of @p error_number.
 */
 TRIO_STRING_PUBLIC TRIO_CONST char *
 trio_error
 TRIO_ARGS1((error_number),
            int error_number)
 {
 #if defined(USE_STRERROR)
-  
+
   return strerror(error_number);
 
 #elif defined(USE_SYS_ERRLIST)
 
   extern char *sys_errlist[];
   extern int sys_nerr;
 
   return ((error_number < 0) || (error_number >= sys_nerr))
     ? "unknown"
     : sys_errlist[error_number];
- 
+
 #else
-  
+
   return "unknown";
-  
+
 #endif
 }
 
 
 #if !defined(TRIO_MINIMAL) && !defined(_WIN32_WCE)
 /**
    Format the date/time according to @p format.
 
    @param target Target string.
    @param max Maximum number of characters to format.
    @param format Formatting string.
    @param datetime Date/time structure.
    @return Number of formatted characters.
 
    The formatting string accepts the same specifiers as the standard C
    function strftime.
 */
 TRIO_STRING_PUBLIC size_t
 trio_format_date_max
 TRIO_ARGS4((target, max, format, datetime),
            char *target,
            size_t max,
            TRIO_CONST char *format,
            TRIO_CONST struct tm *datetime)
 {
   assert(target);
   assert(format);
   assert(datetime);
   assert(max > 0);
-  
+
   return strftime(target, max, format, datetime);
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Calculate a hash value for a string.
 
    @param string String to be calculated on.
    @param type Hash function.
    @return Calculated hash value.
 
    @p type can be one of the following
    @li @c TRIO_HASH_PLAIN Plain hash function.
 */
 TRIO_STRING_PUBLIC unsigned long
 trio_hash
 TRIO_ARGS2((string, type),
            TRIO_CONST char *string,
            int type)
 {
   unsigned long value = 0L;
   char ch;
 
   assert(string);
-  
+
   switch (type)
     {
     case TRIO_HASH_PLAIN:
       while ( (ch = *string++) != NIL )
         {
           value *= 31;
           value += (unsigned long)ch;
         }
       break;
     default:
@@ skipping 68 matching lines @@
 
 #if !defined(TRIO_MINIMAL)
 /**
    Compare two strings using wildcards.
 
    @param string String to be searched.
    @param pattern Pattern, including wildcards, to search for.
    @return Boolean value indicating success or failure.
 
    Case-insensitive comparison.
-   
+
    The following wildcards can be used
    @li @c * Match any number of characters.
    @li @c ? Match a single character.
 */
 TRIO_STRING_PUBLIC int
 trio_match
 TRIO_ARGS2((string, pattern),
            TRIO_CONST char *string,
            TRIO_CONST char *pattern)
 {
   assert(string);
   assert(pattern);
-  
+
   for (; ('*' != *pattern); ++pattern, ++string)
     {
       if (NIL == *string)
         {
           return (NIL == *pattern);
         }
       if ((trio_to_upper((int)*string) != trio_to_upper((int)*pattern))
           && ('?' != *pattern))
         {
           return FALSE;
         }
     }
   /* two-line patch to prevent *too* much recursiveness: */
   while ('*' == pattern[1])
     pattern++;
 
   do
     {
       if ( trio_match(string, &pattern[1]) )
         {
           return TRUE;
         }
     }
   while (*string++);
-  
+
   return FALSE;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Compare two strings using wildcards.
 
    @param string String to be searched.
    @param pattern Pattern, including wildcards, to search for.
    @return Boolean value indicating success or failure.
 
    Case-sensitive comparison.
-   
+
    The following wildcards can be used
    @li @c * Match any number of characters.
    @li @c ? Match a single character.
 */
 TRIO_STRING_PUBLIC int
 trio_match_case
 TRIO_ARGS2((string, pattern),
            TRIO_CONST char *string,
            TRIO_CONST char *pattern)
 {
   assert(string);
   assert(pattern);
-  
+
   for (; ('*' != *pattern); ++pattern, ++string)
     {
       if (NIL == *string)
         {
           return (NIL == *pattern);
         }
       if ((*string != *pattern)
           && ('?' != *pattern))
         {
           return FALSE;
         }
     }
   /* two-line patch to prevent *too* much recursiveness: */
   while ('*' == pattern[1])
     pattern++;
 
   do
     {
       if ( trio_match_case(string, &pattern[1]) )
         {
           return TRUE;
         }
     }
   while (*string++);
-  
+
   return FALSE;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Execute a function on each character in string.
 
    @param target Target string.
    @param source Source string.
    @param Function Function to be executed.
    @return Number of processed characters.
 */
 TRIO_STRING_PUBLIC size_t
 trio_span_function
 TRIO_ARGS3((target, source, Function),
            char *target,
            TRIO_CONST char *source,
            int (*Function) TRIO_PROTO((int)))
 {
   size_t count = 0;
 
   assert(target);
   assert(source);
   assert(Function);
-  
+
   while (*source != NIL)
     {
       *target++ = Function(*source++);
       count++;
     }
   return count;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
@@ skipping 36 matching lines @@
            TRIO_CONST char *string,
            size_t max,
            TRIO_CONST char *substring)
 {
   size_t count;
   size_t size;
   char *result = NULL;
 
   assert(string);
   assert(substring);
-  
+
   size = trio_length(substring);
   if (size <= max)
     {
       for (count = 0; count <= max - size; count++)
         {
           if (trio_equal_max(substring, size, &string[count]))
             {
               result = (char *)&string[count];
               break;
             }
@@ skipping 14 matching lines @@
 
    @warning @p string will be destroyed.
 */
 TRIO_STRING_PUBLIC char *
 trio_tokenize
 TRIO_ARGS2((string, delimiters),
            char *string,
            TRIO_CONST char *delimiters)
 {
   assert(delimiters);
-  
+
   return strtok(string, delimiters);
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 /**
    Convert string to floating-point number.
 
    @param source String to be converted.
    @param endp Pointer to end of the converted string.
@@ skipping 114 matching lines @@
           if ((*source == '+') || (*source == '-'))
             source++;
           while (isdigit((int)*source))
             {
               exponent *= (int)base;
               exponent += (*source - '0');
               source++;
             }
         }
     }
-  
+
   value = integer + fraction;
   if (exponent != 0)
     {
       if (isExponentNegative)
         value /= pow(base, (double)exponent);
       else
         value *= pow(base, (double)exponent);
     }
   if (isNegative)
     value = -value;
@@ skipping 61 matching lines @@
 */
 TRIO_STRING_PUBLIC long
 trio_to_long
 TRIO_ARGS3((string, endp, base),
            TRIO_CONST char *string,
            char **endp,
            int base)
 {
   assert(string);
   assert((base >= 2) && (base <= 36));
-  
+
   return strtol(string, endp, base);
 }
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Convert one alphabetic letter to lower-case.
 
    @param source The letter to be converted.
    @return The converted letter.
 */
 TRIO_STRING_PUBLIC int
 trio_to_lower
 TRIO_ARGS1((source),
            int source)
 {
 #if defined(USE_TOLOWER)
-  
+
   return tolower(source);
-  
+
 #else
 
   /* Does not handle locales or non-contiguous alphabetic characters */
   return ((source >= (int)'A') && (source <= (int)'Z'))
     ? source - 'A' + 'a'
     : source;
-  
+
 #endif
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 #if !defined(TRIO_MINIMAL)
 /**
    Convert string to unsigned integer.
 
    @param string String to be converted.
    @param endp Pointer to end of converted string.
    @param base Radix number of number.
 */
 TRIO_STRING_PUBLIC unsigned long
 trio_to_unsigned_long
 TRIO_ARGS3((string, endp, base),
            TRIO_CONST char *string,
            char **endp,
            int base)
 {
   assert(string);
   assert((base >= 2) && (base <= 36));
-  
+
   return strtoul(string, endp, base);
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 /**
    Convert one alphabetic letter to upper-case.
 
    @param source The letter to be converted.
    @return The converted letter.
 */
 TRIO_STRING_PUBLIC int
 trio_to_upper
 TRIO_ARGS1((source),
            int source)
 {
 #if defined(USE_TOUPPER)
-  
+
   return toupper(source);
-  
+
 #else
 
   /* Does not handle locales or non-contiguous alphabetic characters */
   return ((source >= (int)'a') && (source <= (int)'z'))
     ? source - 'a' + 'A'
     : source;
-  
+
 #endif
 }
 
 #if !defined(TRIO_MINIMAL)
 /**
    Convert the alphabetic letters in the string to upper-case.
 
    @param target The string to be converted.
    @return The number of processed characters (converted or not).
 */
@@ skipping 23 matching lines @@
     @{
 */
 
 /*
  * TrioStringAlloc
  */
 TRIO_STRING_PRIVATE trio_string_t *
 TrioStringAlloc(TRIO_NOARGS)
 {
   trio_string_t *self;
-  
+
   self = (trio_string_t *)TRIO_MALLOC(sizeof(trio_string_t));
   if (self)
     {
       self->content = NULL;
       self->length = 0;
       self->allocated = 0;
     }
   return self;
 }
 
@@ skipping 10 matching lines @@
            trio_string_t *self,
            size_t delta)
 {
   BOOLEAN_T status = FALSE;
   char *new_content;
   size_t new_size;
 
   new_size = (delta == 0)
     ? ( (self->allocated == 0) ? 1 : self->allocated * 2 )
     : self->allocated + delta;
-  
+
   new_content = (char *)TRIO_REALLOC(self->content, new_size);
   if (new_content)
     {
       self->content = new_content;
       self->allocated = new_size;
       status = TRUE;
     }
   return status;
 }
 
@@ skipping 16 matching lines @@
   return (self->allocated < length)
     ? TrioStringGrow(self, length - self->allocated)
     : TRUE;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Create a new dynamic string.
-   
+
    @param initial_size Initial size of the buffer.
    @return Newly allocated dynamic string, or NULL if memory allocation failed.
 */
 TRIO_STRING_PUBLIC trio_string_t *
 trio_string_create
 TRIO_ARGS1((initial_size),
            int initial_size)
 {
   trio_string_t *self;
 
@@ skipping 12 matching lines @@
           self = NULL;
         }
     }
   return self;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 /**
    Deallocate the dynamic string and its contents.
-   
+
    @param self Dynamic string
 */
 TRIO_STRING_PUBLIC void
 trio_string_destroy
 TRIO_ARGS1((self),
            trio_string_t *self)
 {
   assert(self);
-  
+
   if (self)
     {
       trio_destroy(self->content);
       TRIO_FREE(self);
     }
 }
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Get a pointer to the content.
-   
+
    @param self Dynamic string.
    @param offset Offset into content.
    @return Pointer to the content.
-   
+
    @p Offset can be zero, positive, or negative. If @p offset is zero,
    then the start of the content will be returned. If @p offset is positive,
    then a pointer to @p offset number of characters from the beginning of the
    content is returned. If @p offset is negative, then a pointer to @p offset
    number of characters from the ending of the string, starting at the
    terminating zero, is returned.
 */
 TRIO_STRING_PUBLIC char *
 trio_string_get
 TRIO_ARGS2((self, offset),
            trio_string_t *self,
            int offset)
 {
   char *result = NULL;
-  
+
   assert(self);
 
   if (self->content != NULL)
     {
       if (self->length == 0)
         {
           (void)trio_string_length(self);
         }
       if (offset >= 0)
         {
@@ skipping 12 matching lines @@
         }
       result = &(self->content[offset]);
     }
   return result;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 /**
    Extract the content.
-   
+
    @param self Dynamic String
    @return Content of dynamic string.
-   
+
    The content is removed from the dynamic string. This enables destruction
    of the dynamic string without deallocation of the content.
 */
 TRIO_STRING_PUBLIC char *
 trio_string_extract
 TRIO_ARGS1((self),
            trio_string_t *self)
 {
   char *result;
-  
+
   assert(self);
 
   result = self->content;
   /* FIXME: Allocate new empty buffer? */
   self->content = NULL;
   self->length = self->allocated = 0;
   return result;
 }
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Set the content of the dynamic string.
-   
+
    @param self Dynamic String
    @param buffer The new content.
-   
+
    Sets the content of the dynamic string to a copy @p buffer.
    An existing content will be deallocated first, if necessary.
-   
+
    @remark
    This function will make a copy of @p buffer.
    You are responsible for deallocating @p buffer yourself.
 */
 TRIO_STRING_PUBLIC void
 trio_xstring_set
 TRIO_ARGS2((self, buffer),
            trio_string_t *self,
            char *buffer)
 {
@@ skipping 27 matching lines @@
 TRIO_ARGS1((self),
            trio_string_t *self)
 {
   trio_xstring_append_char(self, 0);
 }
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Append the second string to the first.
-   
+
    @param self Dynamic string to be modified.
    @param other Dynamic string to copy from.
    @return Boolean value indicating success or failure.
 */
 TRIO_STRING_PUBLIC int
 trio_string_append
 TRIO_ARGS2((self, other),
            trio_string_t *self,
            trio_string_t *other)
 {
   size_t length;
-  
+
   assert(self);
   assert(other);
 
   length = self->length + other->length;
   if (!TrioStringGrowTo(self, length))
     goto error;
   trio_copy(&self->content[self->length], other->content);
   self->length = length;
   return TRUE;
-  
+
  error:
   return FALSE;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 #if !defined(TRIO_MINIMAL)
 /*
  * trio_xstring_append
  */
 TRIO_STRING_PUBLIC int
 trio_xstring_append
 TRIO_ARGS2((self, other),
            trio_string_t *self,
            TRIO_CONST char *other)
 {
   size_t length;
-  
+
   assert(self);
   assert(other);
 
   length = self->length + trio_length(other);
   if (!TrioStringGrowTo(self, length))
     goto error;
   trio_copy(&self->content[self->length], other);
   self->length = length;
   return TRUE;
-  
+
  error:
   return FALSE;
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 
 /*
  * trio_xstring_append_char
  */
 TRIO_STRING_PUBLIC int
 trio_xstring_append_char
 TRIO_ARGS2((self, character),
            trio_string_t *self,
            char character)
 {
   assert(self);
 
   if ((int)self->length >= trio_string_size(self))
     {
       if (!TrioStringGrow(self, 0))
         goto error;
     }
   self->content[self->length] = character;
   self->length++;
   return TRUE;
-  
+
  error:
   return FALSE;
 }
 
 
 #if !defined(TRIO_MINIMAL)
 /**
    Search for the first occurrence of second parameter in the first.
-   
+
    @param self Dynamic string to be modified.
    @param other Dynamic string to copy from.
    @return Boolean value indicating success or failure.
 */
 TRIO_STRING_PUBLIC int
 trio_string_contains
 TRIO_ARGS2((self, other),
            trio_string_t *self,
            trio_string_t *other)
 {
@@ skipping 64 matching lines @@
 #if !defined(TRIO_MINIMAL)
 /*
  * trio_string_duplicate
  */
 TRIO_STRING_PUBLIC trio_string_t *
 trio_string_duplicate
 TRIO_ARGS1((other),
            trio_string_t *other)
 {
   trio_string_t *self;
-  
+
   assert(other);
 
   self = TrioStringAlloc();
   if (self)
     {
       self->content = TrioDuplicateMax(other->content, other->length);
       if (self->content)
         {
           self->length = other->length;
           self->allocated = self->length + 1;
@@ skipping 10 matching lines @@
 
 /*
  * trio_xstring_duplicate
  */
 TRIO_STRING_PUBLIC trio_string_t *
 trio_xstring_duplicate
 TRIO_ARGS1((other),
            TRIO_CONST char *other)
 {
   trio_string_t *self;
-  
+
   assert(other);
 
   self = TrioStringAlloc();
   if (self)
     {
       self->content = TrioDuplicateMax(other, trio_length(other));
       if (self->content)
         {
           self->length = trio_length(self->content);
           self->allocated = self->length + 1;
@@ skipping 361 matching lines @@
 TRIO_ARGS1((self),
            trio_string_t *self)
 {
   assert(self);
 
   return trio_upper(self->content);
 }
 #endif /* !defined(TRIO_MINIMAL) */
 
 /** @} End of DynamicStrings */