Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/trio.c

 /*************************************************************************
  *
  * $Id$
  *
  * Copyright (C) 1998 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 81 matching lines @@
 #if !defined(TRIO_COMPILER_SUPPORTS_C99)
 # define isblank(x) (((x)==32) || ((x)==9))
 #endif
 #if defined(TRIO_COMPILER_ANCIENT)
 # include <varargs.h>
 #else
 # include <stdarg.h>
 #endif
 #include <stddef.h>
 
-#ifdef HAVE_ERRNO_H
+#if defined( HAVE_ERRNO_H ) || defined( __VMS )
 #include <errno.h>
 #endif
 
 #ifndef NULL
 # define NULL 0
 #endif
 #define NIL ((char)0)
 #ifndef FALSE
 # define FALSE (1 == 0)
 # define TRUE (! FALSE)
 #endif
 #define BOOLEAN_T int
 
 /* mincore() can be used for debugging purposes */
 #define VALID(x) (NULL != (x))
 
 #if TRIO_ERRORS
   /*
    * Encode the error code and the position. This is decoded
    * with TRIO_ERROR_CODE and TRIO_ERROR_POSITION.
    */
 # define TRIO_ERROR_RETURN(x,y) (- ((x) + ((y) << 8)))
 #else
 # define TRIO_ERROR_RETURN(x,y) (-1)
 #endif
 
+#ifndef VA_LIST_IS_ARRAY
+#define TRIO_VA_LIST_PTR        va_list *
+#define TRIO_VA_LIST_ADDR(l)    (&(l))
+#define TRIO_VA_LIST_DEREF(l)   (*(l))
+#else
+#define TRIO_VA_LIST_PTR        va_list
+#define TRIO_VA_LIST_ADDR(l)    (l)
+#define TRIO_VA_LIST_DEREF(l)   (l)
+#endif
+
 typedef unsigned long trio_flags_t;
 
 
 /*************************************************************************
  * Platform specific definitions
  */
-#if defined(TRIO_PLATFORM_UNIX)
+#if defined(TRIO_PLATFORM_UNIX) || defined(TRIO_PLATFORM_OS400)
 # include <unistd.h>
 # include <signal.h>
 # include <locale.h>
 # define USE_LOCALE
 #endif /* TRIO_PLATFORM_UNIX */
 #if defined(TRIO_PLATFORM_VMS)
 # include <unistd.h>
 #endif
 #if defined(TRIO_PLATFORM_WIN32)
 # if defined(_WIN32_WCE)
@@ skipping 55 matching lines @@
 typedef unsigned long long int trio_ulonglong_t;
 #elif defined(TRIO_COMPILER_SUPPORTS_MSVC_INT)
 typedef signed __int64 trio_longlong_t;
 typedef unsigned __int64 trio_ulonglong_t;
 #else
 typedef TRIO_SIGNED long int trio_longlong_t;
 typedef unsigned long int trio_ulonglong_t;
 #endif
 
 /* Maximal and fixed integer types */
-#if defined(TRIO_COMPILER_SUPPORTS_C99)
+#if defined(TRIO_COMPILER_SUPPORTS_C99) && !defined( __VMS )
 # include <stdint.h>
 typedef intmax_t trio_intmax_t;
 typedef uintmax_t trio_uintmax_t;
 typedef int8_t trio_int8_t;
 typedef int16_t trio_int16_t;
 typedef int32_t trio_int32_t;
 typedef int64_t trio_int64_t;
-#elif defined(TRIO_COMPILER_SUPPORTS_UNIX98)
+#elif defined(TRIO_COMPILER_SUPPORTS_UNIX98) || defined( __VMS )
 # include <inttypes.h>
+#ifdef __VMS
+typedef long long int          intmax_t;
+typedef unsigned long long int uintmax_t;
+#endif
 typedef intmax_t trio_intmax_t;
 typedef uintmax_t trio_uintmax_t;
 typedef int8_t trio_int8_t;
 typedef int16_t trio_int16_t;
 typedef int32_t trio_int32_t;
 typedef int64_t trio_int64_t;
 #elif defined(TRIO_COMPILER_SUPPORTS_MSVC_INT)
 typedef trio_longlong_t trio_intmax_t;
 typedef trio_ulonglong_t trio_uintmax_t;
 typedef __int8 trio_int8_t;
@@ skipping 69 matching lines @@
 #define POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(trio_pointer_t) * CHAR_BIT / 4)
 
 /* Infinite and Not-A-Number for floating-point */
 #define INFINITE_LOWER "inf"
 #define INFINITE_UPPER "INF"
 #define LONG_INFINITE_LOWER "infinite"
 #define LONG_INFINITE_UPPER "INFINITE"
 #define NAN_LOWER "nan"
 #define NAN_UPPER "NAN"
 
+#if !defined(HAVE_ISASCII) && !defined(isascii)
+#ifndef __VMS
+# define isascii(x) ((unsigned int)(x) < 128)
+#endif
+#endif
+
 /* Various constants */
 enum {
   TYPE_PRINT = 1,
   TYPE_SCAN  = 2,
 
   /* Flags. FLAGS_LAST must be less than ULONG_MAX */
   FLAGS_NEW                 = 0,
   FLAGS_STICKY              = 1,
   FLAGS_SPACE               = 2 * FLAGS_STICKY,
   FLAGS_SHOWSIGN            = 2 * FLAGS_SPACE,
@@ skipping 49 matching lines @@
   BASE_HEX     = 16,
 
   /* Maximal number of allowed parameters */
   MAX_PARAMETERS = 64,
   /* Maximal number of characters in class */
   MAX_CHARACTER_CLASS = UCHAR_MAX + 1,
 
   /* Maximal string lengths for user-defined specifiers */
   MAX_USER_NAME = 64,
   MAX_USER_DATA = 256,
-  
+
   /* Maximal length of locale separator strings */
   MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX,
   /* Maximal number of integers in grouping */
   MAX_LOCALE_GROUPS = 64,
 
   /* Initial size of asprintf buffer */
   DYNAMIC_START_SIZE = 32
 };
 
 #define NO_GROUPING ((int)CHAR_MAX)
@@ skipping 623 matching lines @@
  * Find registered user-defined specifier.
  * The prev argument is used for optimization only.
  */
 TRIO_PRIVATE trio_userdef_t *
 TrioFindNamespace
 TRIO_ARGS2((name, prev),
            TRIO_CONST char *name,
            trio_userdef_t **prev)
 {
   trio_userdef_t *def;
-  
+
   if (internalEnterCriticalRegion)
     (void)internalEnterCriticalRegion(NULL);
-  
+
   for (def = internalUserDef; def; def = def->next)
     {
       /* Case-sensitive string comparison */
       if (trio_equal_case(def->name, name))
         break;
-      
+
       if (prev)
         *prev = def;
     }
-  
+
   if (internalLeaveCriticalRegion)
     (void)internalLeaveCriticalRegion(NULL);
-  
+
   return def;
 }
 #endif
 
 /*************************************************************************
  * TrioPower
  *
  * Description:
  *  Calculate pow(base, exponent), where number and exponent are integers.
  */
@@ skipping 106 matching lines @@
  *
  * Description:
  *  Parse the format string
  */
 TRIO_PRIVATE int
 TrioParse
 TRIO_ARGS5((type, format, parameters, arglist, argarray),
            int type,
            TRIO_CONST char *format,
            trio_parameter_t *parameters,
-           va_list *arglist,
+           TRIO_VA_LIST_PTR arglist,
            trio_pointer_t *argarray)
 {
   /* Count the number of times a parameter is referenced */
   unsigned short usedEntries[MAX_PARAMETERS];
   /* Parameter counters */
   int parameterPosition;
   int currentParam;
   int maxParam = -1;
   /* Utility variables */
   trio_flags_t flags;
@@ skipping 16 matching lines @@
 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
   int charlen;
 #endif
   int save_errno;
   int i = -1;
   int num;
   char *tmpformat;
 
   /* One and only one of arglist and argarray must be used */
   assert((arglist != NULL) ^ (argarray != NULL));
-  
+
   /*
    * The 'parameters' array is not initialized, but we need to
    * know which entries we have used.
    */
   memset(usedEntries, 0, sizeof(usedEntries));
 
   save_errno = errno;
   index = 0;
   parameterPosition = 0;
 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
   (void)mblen(NULL, 0);
 #endif
-  
+
   while (format[index])
     {
 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
       if (! isascii(format[index]))
         {
           /*
            * Multibyte characters cannot be legal specifiers or
            * modifiers, so we skip over them.
            */
           charlen = mblen(&format[index], MB_LEN_MAX);
@@ skipping 57 matching lines @@
                   break;
 
                 case QUALIFIER_DOT:
                   if (dots == 0) /* Precision */
                     {
                       dots++;
 
                       /* Skip if no precision */
                       if (QUALIFIER_DOT == format[index])
                         break;
-                      
+
                       /* After the first dot we have the precision */
                       flags |= FLAGS_PRECISION;
                       if ((QUALIFIER_STAR == format[index])
 #if defined(QUALIFIER_PARAM)
                           || (QUALIFIER_PARAM == format[index])
 #endif
                           )
                         {
                           index++;
                           flags |= FLAGS_PRECISION_PARAMETER;
@@ skipping 24 matching lines @@
                         {
                           precision = trio_to_long(&format[index],
                                                    &tmpformat,
                                                    BASE_DECIMAL);
                           index = (int)(tmpformat - format);
                         }
                     }
                   else if (dots == 1) /* Base */
                     {
                       dots++;
-                      
+
                       /* After the second dot we have the base */
                       flags |= FLAGS_BASE;
                       if ((QUALIFIER_STAR == format[index])
 #if defined(QUALIFIER_PARAM)
                           || (QUALIFIER_PARAM == format[index])
 #endif
                           )
                         {
                           index++;
                           flags |= FLAGS_BASE_PARAMETER;
@@ skipping 178 matching lines @@
                       varsize = sizeof(trio_int16_t);
                       index += 2;
                     }
                   else if (format[index] == '8')
                     {
                       varsize = sizeof(trio_int8_t);
                       index++;
                     }
                   else
                     return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
-                  
+
                   flags |= FLAGS_FIXED_SIZE;
                   break;
 #endif
 
 #if defined(QUALIFIER_WIDECHAR)
                 case QUALIFIER_WIDECHAR:
                   flags |= FLAGS_WIDECHAR;
                   break;
 #endif
 
 #if defined(QUALIFIER_SIZE_T_UPPER)
                 case QUALIFIER_SIZE_T_UPPER:
                   break;
 #endif
 
 #if defined(QUALIFIER_QUOTE)
                 case QUALIFIER_QUOTE:
                   flags |= FLAGS_QUOTE;
                   break;
 #endif
 
 #if defined(QUALIFIER_STICKY)
                 case QUALIFIER_STICKY:
                   flags |= FLAGS_STICKY;
                   gotSticky = TRUE;
                   break;
 #endif
-                  
+
 #if defined(QUALIFIER_VARSIZE)
                 case QUALIFIER_VARSIZE:
                   flags |= FLAGS_VARSIZE_PARAMETER;
                   parameterPosition++;
                   if (positional)
                     varsize = parameterPosition;
                   else
                     {
                       varsize = currentParam;
                       currentParam = varsize + 1;
@@ skipping 44 matching lines @@
               base = pos++;
             }
           if (flags & FLAGS_VARSIZE_PARAMETER)
             {
               usedEntries[varsize] += 1;
               parameters[pos].type = FORMAT_PARAMETER;
               parameters[pos].flags = 0;
               indices[varsize] = pos;
               varsize = pos++;
             }
-          
+
           indices[currentParam] = pos;
-          
+
           switch (format[index++])
             {
 #if defined(SPECIFIER_CHAR_UPPER)
             case SPECIFIER_CHAR_UPPER:
               flags |= FLAGS_WIDECHAR;
               /* FALLTHROUGH */
 #endif
             case SPECIFIER_CHAR:
               if (flags & FLAGS_LONG)
                 flags |= FLAGS_WIDECHAR;
@@ skipping 38 matching lines @@
                           if (--depth <= 0)
                             {
                               index++;
                               break;
                             }
                         }
                       index++;
                     }
                 }
               break;
-              
+
             case SPECIFIER_INTEGER:
               parameters[pos].type = FORMAT_INT;
               break;
-              
+
             case SPECIFIER_UNSIGNED:
               flags |= FLAGS_UNSIGNED;
               parameters[pos].type = FORMAT_INT;
               break;
 
             case SPECIFIER_DECIMAL:
               /* Disable base modifier */
               flags &= ~FLAGS_BASE_PARAMETER;
               base = BASE_DECIMAL;
               parameters[pos].type = FORMAT_INT;
@@ skipping 79 matching lines @@
             case SPECIFIER_ERRNO:
               parameters[pos].type = FORMAT_ERRNO;
               break;
 #endif
 
 #if defined(SPECIFIER_USER_DEFINED_BEGIN)
             case SPECIFIER_USER_DEFINED_BEGIN:
               {
                 unsigned int max;
                 int without_namespace = TRUE;
-                
+
                 parameters[pos].type = FORMAT_USER_DEFINED;
                 parameters[pos].user_name[0] = NIL;
                 tmpformat = (char *)&format[index];
-              
+
                 while ((ch = format[index]))
                   {
                     index++;
                     if (ch == SPECIFIER_USER_DEFINED_END)
                       {
                         if (without_namespace)
                           {
                             /* We must get the handle first */
                             parameters[pos].type = FORMAT_PARAMETER;
                             parameters[pos].indexAfterSpecifier = index;
@@ skipping 27 matching lines @@
                                       max,
                                       tmpformat);
                         tmpformat = (char *)&format[index];
                       }
                   }
                 if (ch != SPECIFIER_USER_DEFINED_END)
                   return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
               }
               break;
 #endif /* defined(SPECIFIER_USER_DEFINED_BEGIN) */
-              
+
             default:
               /* Bail out completely to make the error more obvious */
               return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
             }
 
           /*  Count the number of times this entry has been used */
           usedEntries[currentParam] += 1;
-          
+
           /* Find last sticky parameters */
           if (gotSticky && !(flags & FLAGS_STICKY))
             {
               for (i = pos - 1; i >= 0; i--)
                 {
                   if (parameters[i].type == FORMAT_PARAMETER)
                     continue;
                   if ((parameters[i].flags & FLAGS_STICKY) &&
                       (parameters[i].type == parameters[pos].type))
                     {
                       /* Do not overwrite current qualifiers */
                       flags |= (parameters[i].flags & (unsigned long)~FLAGS_STICKY);
                       if (width == NO_WIDTH)
                         width = parameters[i].width;
                       if (precision == NO_PRECISION)
                         precision = parameters[i].precision;
                       if (base == NO_BASE)
                         base = parameters[i].base;
                       break;
                     }
                 }
             }
-          
+
           parameters[pos].indexAfterSpecifier = index;
           parameters[pos].flags = flags;
           parameters[pos].width = width;
           parameters[pos].precision = precision;
           parameters[pos].base = (base == NO_BASE) ? BASE_DECIMAL : base;
           parameters[pos].varsize = varsize;
           pos++;
-          
+
           if (! positional)
             parameterPosition++;
-          
+
         } /* if identifier */
-      
+
     } /* while format characters left */
 
   for (num = 0; num <= maxParam; num++)
     {
       if (usedEntries[num] != 1)
         {
           if (usedEntries[num] == 0) /* gap detected */
             return TRIO_ERROR_RETURN(TRIO_EGAP, num);
           else /* double references detected */
             return TRIO_ERROR_RETURN(TRIO_EDBLREF, num);
         }
-      
+
       i = indices[num];
 
       /*
        * FORMAT_PARAMETERS are only present if they must be read,
        * so it makes no sense to check the ignore flag (besides,
        * the flags variable is not set for that particular type)
        */
       if ((parameters[i].type != FORMAT_PARAMETER) &&
           (parameters[i].flags & FLAGS_IGNORE))
         continue; /* for all arguments */
@@ skipping 19 matching lines @@
        *  intmax_t
        */
       switch (parameters[i].type)
         {
         case FORMAT_GROUP:
         case FORMAT_STRING:
 #if TRIO_WIDECHAR
           if (flags & FLAGS_WIDECHAR)
             {
               parameters[i].data.wstring = (argarray == NULL)
-                ? va_arg(*arglist, trio_wchar_t *)
+                ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_wchar_t *)
                 : (trio_wchar_t *)(argarray[num]);
             }
           else
 #endif
             {
               parameters[i].data.string = (argarray == NULL)
-                ? va_arg(*arglist, char *)
+                ? va_arg(TRIO_VA_LIST_DEREF(arglist), char *)
                 : (char *)(argarray[num]);
             }
           break;
 
 #if defined(FORMAT_USER_DEFINED)
         case FORMAT_USER_DEFINED:
 #endif
         case FORMAT_POINTER:
         case FORMAT_COUNT:
         case FORMAT_UNKNOWN:
           parameters[i].data.pointer = (argarray == NULL)
-            ? va_arg(*arglist, trio_pointer_t )
+            ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t )
             : argarray[num];
           break;
 
         case FORMAT_CHAR:
         case FORMAT_INT:
           if (TYPE_SCAN == type)
             {
               if (argarray == NULL)
-                parameters[i].data.pointer = 
-                  (trio_pointer_t)va_arg(*arglist, trio_pointer_t);
+                parameters[i].data.pointer =
+                  (trio_pointer_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t);
               else
                 {
                   if (parameters[i].type == FORMAT_CHAR)
                     parameters[i].data.pointer =
                       (trio_pointer_t)((char *)argarray[num]);
                   else if (parameters[i].flags & FLAGS_SHORT)
                     parameters[i].data.pointer =
                       (trio_pointer_t)((short *)argarray[num]);
                   else
                     parameters[i].data.pointer =
@@ skipping 18 matching lines @@
                        * big-endian, then this will fail.
                        */
                       varsize = (int)parameters[parameters[i].varsize].data.number.as_unsigned;
                     }
                   else
                     {
                       /* Used for the I<bits> modifiers */
                       varsize = parameters[i].varsize;
                     }
                   parameters[i].flags &= ~FLAGS_ALL_VARSIZES;
-                  
+
                   if (varsize <= (int)sizeof(int))
                     ;
                   else if (varsize <= (int)sizeof(long))
                     parameters[i].flags |= FLAGS_LONG;
 #if defined(QUALIFIER_INTMAX_T)
                   else if (varsize <= (int)sizeof(trio_longlong_t))
                     parameters[i].flags |= FLAGS_QUAD;
                   else
                     parameters[i].flags |= FLAGS_INTMAX_T;
 #else
                   else
                     parameters[i].flags |= FLAGS_QUAD;
 #endif
                 }
 #endif /* defined(QUALIFIER_VARSIZE) */
 #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
               if (parameters[i].flags & FLAGS_SIZE_T)
                 parameters[i].data.number.as_unsigned = (argarray == NULL)
-                  ? (trio_uintmax_t)va_arg(*arglist, size_t)
+                  ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), size_t)
                   : (trio_uintmax_t)(*((size_t *)argarray[num]));
               else
 #endif
 #if defined(QUALIFIER_PTRDIFF_T)
               if (parameters[i].flags & FLAGS_PTRDIFF_T)
                 parameters[i].data.number.as_unsigned = (argarray == NULL)
-                  ? (trio_uintmax_t)va_arg(*arglist, ptrdiff_t)
+                  ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), ptrdiff_t)
                   : (trio_uintmax_t)(*((ptrdiff_t *)argarray[num]));
               else
 #endif
 #if defined(QUALIFIER_INTMAX_T)
               if (parameters[i].flags & FLAGS_INTMAX_T)
                 parameters[i].data.number.as_unsigned = (argarray == NULL)
-                  ? (trio_uintmax_t)va_arg(*arglist, trio_intmax_t)
+                  ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_intmax_t)
                   : (trio_uintmax_t)(*((trio_intmax_t *)argarray[num]));
               else
 #endif
               if (parameters[i].flags & FLAGS_QUAD)
                 parameters[i].data.number.as_unsigned = (argarray == NULL)
-                  ? (trio_uintmax_t)va_arg(*arglist, trio_ulonglong_t)
+                  ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_ulonglong_t)
                   : (trio_uintmax_t)(*((trio_ulonglong_t *)argarray[num]));
               else if (parameters[i].flags & FLAGS_LONG)
                 parameters[i].data.number.as_unsigned = (argarray == NULL)
-                  ? (trio_uintmax_t)va_arg(*arglist, long)
+                  ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), long)
                   : (trio_uintmax_t)(*((long *)argarray[num]));
               else
                 {
                   if (argarray == NULL)
-                    parameters[i].data.number.as_unsigned = (trio_uintmax_t)va_arg(*arglist, int);
+                    parameters[i].data.number.as_unsigned = (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), int);
                   else
                     {
                       if (parameters[i].type == FORMAT_CHAR)
                         parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((char *)argarray[num]));
                       else if (parameters[i].flags & FLAGS_SHORT)
                         parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((short *)argarray[num]));
                       else
                         parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((int *)argarray[num]));
                     }
                 }
             }
           break;
 
         case FORMAT_PARAMETER:
           /*
            * The parameter for the user-defined specifier is a pointer,
            * whereas the rest (width, precision, base) uses an integer.
            */
           if (parameters[i].flags & FLAGS_USER_DEFINED)
             parameters[i].data.pointer = (argarray == NULL)
-              ? va_arg(*arglist, trio_pointer_t )
+              ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t )
               : argarray[num];
           else
             parameters[i].data.number.as_unsigned = (argarray == NULL)
-              ? (trio_uintmax_t)va_arg(*arglist, int)
+              ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), int)
               : (trio_uintmax_t)(*((int *)argarray[num]));
           break;
 
         case FORMAT_DOUBLE:
           if (TYPE_SCAN == type)
             {
               if (parameters[i].flags & FLAGS_LONGDOUBLE)
                 parameters[i].data.longdoublePointer = (argarray == NULL)
-                  ? va_arg(*arglist, trio_long_double_t *)
+                  ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_long_double_t *)
                   : (trio_long_double_t *)argarray[num];
               else
                 {
                   if (parameters[i].flags & FLAGS_LONG)
                     parameters[i].data.doublePointer = (argarray == NULL)
-                      ? va_arg(*arglist, double *)
+                      ? va_arg(TRIO_VA_LIST_DEREF(arglist), double *)
                       : (double *)argarray[num];
                   else
                     parameters[i].data.doublePointer = (argarray == NULL)
-                      ? (double *)va_arg(*arglist, float *)
+                      ? (double *)va_arg(TRIO_VA_LIST_DEREF(arglist), float *)
                       : (double *)((float *)argarray[num]);
                 }
             }
           else
             {
               if (parameters[i].flags & FLAGS_LONGDOUBLE)
                 parameters[i].data.longdoubleNumber = (argarray == NULL)
-                  ? va_arg(*arglist, trio_long_double_t)
+                  ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_long_double_t)
                   : (trio_long_double_t)(*((trio_long_double_t *)argarray[num]));
               else
                 {
                   if (argarray == NULL)
                     parameters[i].data.longdoubleNumber =
-                      (trio_long_double_t)va_arg(*arglist, double);
+                      (trio_long_double_t)va_arg(TRIO_VA_LIST_DEREF(arglist), double);
                   else
                     {
                       if (parameters[i].flags & FLAGS_SHORT)
                         parameters[i].data.longdoubleNumber =
                           (trio_long_double_t)(*((float *)argarray[num]));
                       else
                         parameters[i].data.longdoubleNumber =
                           (trio_long_double_t)(*((double *)argarray[num]));
                     }
                 }
@@ skipping 77 matching lines @@
       if (isNegative)
         number = -((trio_intmax_t)number);
     }
 
   if (flags & FLAGS_QUAD)
     number &= (trio_ulonglong_t)-1;
   else if (flags & FLAGS_LONG)
     number &= (unsigned long)-1;
   else
     number &= (unsigned int)-1;
-  
+
   /* Build number */
   pointer = bufferend = &buffer[sizeof(buffer) - 1];
   *pointer-- = NIL;
   for (i = 1; i < (int)sizeof(buffer); i++)
     {
       *pointer-- = digits[number % base];
       number /= base;
       if (number == 0)
         break;
 
@@ skipping 26 matching lines @@
       precision -= (bufferend - pointer) - 1;
       if (precision < 0)
         precision = 0;
       flags |= FLAGS_NILPADDING;
     }
 
   /* Calculate padding */
   count = (! ((flags & FLAGS_LEFTADJUST) || (precision == NO_PRECISION)))
     ? precision
     : 0;
-  
+
   /* Adjust width further */
   if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
     width--;
   if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)
     {
       switch (base)
         {
         case BASE_BINARY:
         case BASE_HEX:
           width -= 2;
@@ skipping 214 matching lines @@
            int width)
 {
   int size;
   int i;
   int ch;
   char *string;
   char buffer[MB_LEN_MAX + 1];
 
   if (width == NO_WIDTH)
     width = sizeof(buffer);
-  
+
   size = wctomb(buffer, wch);
   if ((size <= 0) || (size > width) || (buffer[0] == NIL))
     return 0;
 
   string = buffer;
   i = size;
   while ((width >= i) && (width-- > 0) && (i-- > 0))
     {
       /* The ctype parameters must be an unsigned char (or EOF) */
       ch = (int)((unsigned char)(*string++));
@@ skipping 21 matching lines @@
 {
   int length;
   int size;
 
   assert(VALID(self));
   assert(VALID(self->OutStream));
 
 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
   (void)mblen(NULL, 0);
 #endif
-  
+
   if (wstring == NULL)
     {
       TrioWriteString(self, NULL, flags, width, precision);
       return;
     }
-  
+
   if (NO_PRECISION == precision)
     {
       length = INT_MAX;
     }
   else
     {
       length = precision;
       width -= length;
     }
 
@@ skipping 74 matching lines @@
   TRIO_CONST char *digits;
   char *groupingPointer;
   int i;
   int index;
   BOOLEAN_T hasOnlyZeroes;
   int zeroes = 0;
   register int trailingZeroes;
   BOOLEAN_T keepTrailingZeroes;
   BOOLEAN_T keepDecimalPoint;
   trio_long_double_t epsilon;
-  
+
   assert(VALID(self));
   assert(VALID(self->OutStream));
   assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));
 
   /* Determine sign and look for special quantities */
   switch (trio_fpclassify_and_signbit(number, &isNegative))
     {
     case TRIO_FP_NAN:
       TrioWriteString(self,
                       (flags & FLAGS_UPPER)
                       ? NAN_UPPER
                       : NAN_LOWER,
                       flags, width, precision);
       return;
-      
+
     case TRIO_FP_INFINITE:
       if (isNegative)
         {
           /* Negative infinity */
           TrioWriteString(self,
                           (flags & FLAGS_UPPER)
                           ? "-" INFINITE_UPPER
                           : "-" INFINITE_LOWER,
                           flags, width, precision);
           return;
         }
       else
         {
           /* Positive infinity */
           TrioWriteString(self,
                           (flags & FLAGS_UPPER)
                           ? INFINITE_UPPER
                           : INFINITE_LOWER,
                           flags, width, precision);
           return;
         }
 
     default:
       /* Finitude */
       break;
     }
-  
+
   /* Normal numbers */
   if (flags & FLAGS_LONGDOUBLE)
     {
       baseDigits = (base == 10)
         ? LDBL_DIG
         : (int)floor(LDBL_MANT_DIG / TrioLogarithmBase(base));
       epsilon = LDBL_EPSILON;
     }
   else if (flags & FLAGS_SHORT)
     {
@@ skipping 27 matching lines @@
       if (isHex)
         {
           keepTrailingZeroes = FALSE;
           precision = FLT_MANT_DIG;
         }
       else
         {
           precision = FLT_DIG;
         }
     }
-  
+
   if (isNegative)
     number = -number;
 
   if (isHex)
     flags |= FLAGS_FLOAT_E;
-  
+
   if (flags & FLAGS_FLOAT_G)
     {
       if (precision == 0)
         precision = 1;
 
       if ((number < 1.0E-4) || (number > powl(base,
                                               (trio_long_double_t)precision)))
         {
           /* Use scientific notation */
           flags |= FLAGS_FLOAT_E;
@@ skipping 32 matching lines @@
           uExponent = (isExponentNegative) ? -exponent : exponent;
           if (isHex)
             uExponent *= 4; /* log16(2) */
           /* No thousand separators */
           flags &= ~FLAGS_QUOTE;
         }
     }
 
   integerNumber = floorl(number);
   fractionNumber = number - integerNumber;
-  
+
   /*
    * Truncated number.
    *
    * Precision is number of significant digits for FLOAT_G
    * and number of fractional digits for others.
    */
   integerDigits = (integerNumber > epsilon)
     ? 1 + (int)TrioLogarithm(integerNumber, base)
     : 1;
   fractionDigits = ((flags & FLAGS_FLOAT_G) && (zeroes == 0))
     ? precision - integerDigits
     : zeroes + precision;
 
   dblFractionBase = TrioPower(base, fractionDigits);
-  
+
   workNumber = number + 0.5 / dblFractionBase;
   if (floorl(number) != floorl(workNumber))
     {
       if (flags & FLAGS_FLOAT_E)
         {
           /* Adjust if number was rounded up one digit (ie. 0.99 to 1.00) */
           exponent++;
           isExponentNegative = (exponent < 0);
           uExponent = (isExponentNegative) ? -exponent : exponent;
           if (isHex)
@@ skipping 32 matching lines @@
           integerThreshold = integerDigits;
           fractionThreshold = fractionDigits - integerThreshold;
           fractionAdjust = 1.0;
         }
     }
   else
     {
       integerThreshold = INT_MAX;
       fractionThreshold = INT_MAX;
     }
-  
+
   /*
    * Calculate expected width.
    *  sign + integer part + thousands separators + decimal point
    *  + fraction + exponent
    */
   fractionAdjust /= dblFractionBase;
   hasOnlyZeroes = (floorl((fractionNumber + fractionAdjust) * dblFractionBase) < epsilon);
   keepDecimalPoint = ( (flags & FLAGS_ALTERNATIVE) ||
                        !((precision == 0) ||
                          (!keepTrailingZeroes && hasOnlyZeroes)) );
@@ skipping 15 matching lines @@
     + ((flags & FLAGS_QUOTE)
        ? TrioCalcThousandSeparatorLength(integerDigits)
        : 0);
   if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
     expectedWidth += sizeof("-") - 1;
   if (exponentDigits > 0)
     expectedWidth += exponentDigits +
       ((requireTwoDigitExponent ? sizeof("E+0") : sizeof("E+")) - 1);
   if (isHex)
     expectedWidth += sizeof("0X") - 1;
-  
+
   /* Output prefixing */
   if (flags & FLAGS_NILPADDING)
     {
       /* Leading zeros must be after sign */
       if (isNegative)
         self->OutStream(self, '-');
       else if (flags & FLAGS_SHOWSIGN)
         self->OutStream(self, '+');
       else if (flags & FLAGS_SPACE)
         self->OutStream(self, ' ');
@@ skipping 25 matching lines @@
       else if (flags & FLAGS_SHOWSIGN)
         self->OutStream(self, '+');
       else if (flags & FLAGS_SPACE)
         self->OutStream(self, ' ');
       if (isHex)
         {
           self->OutStream(self, '0');
           self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
         }
     }
-  
+
   /* Output the integer part and thousand separators */
   dblIntegerBase = 1.0 / TrioPower(base, integerDigits - 1);
   for (i = 0; i < integerDigits; i++)
     {
       workNumber = floorl(((integerNumber + integerAdjust) * dblIntegerBase));
       if (i > integerThreshold)
         {
           /* Beyond accuracy */
           self->OutStream(self, digits[0]);
         }
       else
         {
           self->OutStream(self, digits[(int)fmodl(workNumber, dblBase)]);
         }
       dblIntegerBase *= dblBase;
-      
+
       if (((flags & (FLAGS_FLOAT_E | FLAGS_QUOTE)) == FLAGS_QUOTE)
           && TrioFollowedBySeparator(integerDigits - i))
         {
           for (groupingPointer = internalThousandSeparator;
                *groupingPointer != NIL;
                groupingPointer++)
             {
               self->OutStream(self, *groupingPointer);
             }
         }
     }
-  
+
   /* Insert decimal point and build the fraction part */
   trailingZeroes = 0;
 
   if (keepDecimalPoint)
     {
       if (internalDecimalPoint)
         {
           self->OutStream(self, internalDecimalPoint);
         }
       else
@@ skipping 28 matching lines @@
               while (trailingZeroes > 0)
                 {
                   /* Not trailing zeroes after all */
                   self->OutStream(self, digits[0]);
                   trailingZeroes--;
                 }
               self->OutStream(self, digits[index]);
             }
         }
     }
-  
+
   if (keepTrailingZeroes)
     {
       while (trailingZeroes > 0)
         {
           self->OutStream(self, digits[0]);
           trailingZeroes--;
         }
     }
-  
+
   /* Output exponent */
   if (exponentDigits > 0)
     {
       self->OutStream(self,
                       isHex
                       ? ((flags & FLAGS_UPPER) ? 'P' : 'p')
                       : ((flags & FLAGS_UPPER) ? 'E' : 'e'));
       self->OutStream(self, (isExponentNegative) ? '-' : '+');
 
       /* The exponent must contain at least two digits */
@@ skipping 36 matching lines @@
   int charlen;
 #endif
   int i;
   TRIO_CONST char *string;
   trio_pointer_t pointer;
   trio_flags_t flags;
   int width;
   int precision;
   int base;
   int index;
-  
+
   index = 0;
   i = 0;
 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
   (void)mblen(NULL, 0);
 #endif
-  
+
   while (format[index])
     {
 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
       if (! isascii(format[index]))
         {
           charlen = mblen(&format[index], MB_LEN_MAX);
           /*
            * Only valid multibyte characters are handled here. Invalid
            * multibyte characters (charlen == -1) are handled as normal
            * characters.
@@ skipping 13 matching lines @@
           if (CHAR_IDENTIFIER == format[index + 1])
             {
               data->OutStream(data, CHAR_IDENTIFIER);
               index += 2;
             }
           else
             {
               /* Skip the parameter entries */
               while (parameters[i].type == FORMAT_PARAMETER)
                 i++;
-              
+
               flags = parameters[i].flags;
 
               /* Find width */
               width = parameters[i].width;
               if (flags & FLAGS_WIDTH_PARAMETER)
                 {
                   /* Get width from parameter list */
                   width = (int)parameters[width].data.number.as_signed;
                   if (width < 0)
                     {
                       /*
                        * A negative width is the same as the - flag and
                        * a positive width.
                        */
                       flags |= FLAGS_LEFTADJUST;
                       flags &= ~FLAGS_NILPADDING;
                       width = -width;
                     }
                 }
-              
+
               /* Find precision */
               if (flags & FLAGS_PRECISION)
                 {
                   precision = parameters[i].precision;
                   if (flags & FLAGS_PRECISION_PARAMETER)
                     {
                       /* Get precision from parameter list */
                       precision = (int)parameters[precision].data.number.as_signed;
                       if (precision < 0)
                         {
@@ skipping 10 matching lines @@
                   precision = NO_PRECISION;
                 }
 
               /* Find base */
               base = parameters[i].base;
               if (flags & FLAGS_BASE_PARAMETER)
                 {
                   /* Get base from parameter list */
                   base = (int)parameters[base].data.number.as_signed;
                 }
-              
+
               switch (parameters[i].type)
                 {
                 case FORMAT_CHAR:
                   if (flags & FLAGS_QUOTE)
                     data->OutStream(data, CHAR_QUOTE);
                   if (! (flags & FLAGS_LEFTADJUST))
                     {
                       while (--width > 0)
                         data->OutStream(data, CHAR_ADJUST);
                     }
@@ skipping 59 matching lines @@
                                       parameters[i].data.string,
                                       flags,
                                       width,
                                       precision);
                     }
                   break; /* FORMAT_STRING */
 
                 case FORMAT_POINTER:
                   {
                     trio_reference_t reference;
-                    
+
                     reference.data = data;
                     reference.parameter = &parameters[i];
                     trio_print_pointer(&reference, parameters[i].data.pointer);
                   }
                   break; /* FORMAT_POINTER */
 
                 case FORMAT_COUNT:
                   pointer = parameters[i].data.pointer;
                   if (NULL != pointer)
                     {
@@ skipping 82 matching lines @@
                         def = TrioFindNamespace(parameters[i].user_name, NULL);
                       }
                     if (def) {
                       reference.data = data;
                       reference.parameter = &parameters[i];
                       def->callback(&reference);
                     }
                   }
                   break;
 #endif /* defined(FORMAT_USER_DEFINED) */
-                  
+
                 default:
                   break;
                 } /* switch parameter type */
 
               /* Prepare for next */
               index = parameters[i].indexAfterSpecifier;
               i++;
             }
         }
       else /* not identifier */
         {
           data->OutStream(data, format[index++]);
         }
     }
   return data->processed;
 }
 
 /*************************************************************************
  * TrioFormatRef
  */
 TRIO_PRIVATE int
 TrioFormatRef
 TRIO_ARGS4((reference, format, arglist, argarray),
            trio_reference_t *reference,
            TRIO_CONST char *format,
-           va_list *arglist,
+           TRIO_VA_LIST_PTR arglist,
            trio_pointer_t *argarray)
 {
   int status;
   trio_parameter_t parameters[MAX_PARAMETERS];
 
   status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray);
   if (status < 0)
     return status;
 
   status = TrioFormatProcess(reference->data, format, parameters);
   if (reference->data->error != 0)
     {
       status = reference->data->error;
     }
   return status;
 }
 
 /*************************************************************************
  * TrioFormat
  */
 TRIO_PRIVATE int
 TrioFormat
 TRIO_ARGS6((destination, destinationSize, OutStream, format, arglist, argarray),
            trio_pointer_t destination,
            size_t destinationSize,
            void (*OutStream) TRIO_PROTO((trio_class_t *, int)),
            TRIO_CONST char *format,
-           va_list *arglist,
+           TRIO_VA_LIST_PTR arglist,
            trio_pointer_t *argarray)
 {
   int status;
   trio_class_t data;
   trio_parameter_t parameters[MAX_PARAMETERS];
 
   assert(VALID(OutStream));
   assert(VALID(format));
 
   memset(&data, 0, sizeof(data));
@@ skipping 135 matching lines @@
 TRIO_PRIVATE void
 TrioOutStreamStringMax
 TRIO_ARGS2((self, output),
            trio_class_t *self,
            int output)
 {
   char **buffer;
 
   assert(VALID(self));
   assert(VALID(self->location));
-  
+
   buffer = (char **)self->location;
 
   if (self->processed < self->max)
     {
       **buffer = (char)output;
       (*buffer)++;
       self->committed++;
     }
   self->processed++;
 }
@@ skipping 47 matching lines @@
 TRIO_PUBLIC int
 trio_printf
 TRIO_VARGS2((format, va_alist),
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
-  status = TrioFormat(stdout, 0, TrioOutStreamFile, format, &args, NULL);
+  status = TrioFormat(stdout, 0, TrioOutStreamFile, format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 /**
    Print to standard output stream.
 
    @param format Formatting string.
    @param args Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
 trio_vprintf
 TRIO_ARGS2((format, args),
            TRIO_CONST char *format,
            va_list args)
 {
   assert(VALID(format));
 
-  return TrioFormat(stdout, 0, TrioOutStreamFile, format, &args, NULL);
+  return TrioFormat(stdout, 0, TrioOutStreamFile, format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 /**
    Print to standard output stream.
 
    @param format Formatting string.
    @param args Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
@@ skipping 24 matching lines @@
 TRIO_VARGS3((file, format, va_alist),
             FILE *file,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(file));
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
-  status = TrioFormat(file, 0, TrioOutStreamFile, format, &args, NULL);
+  status = TrioFormat(file, 0, TrioOutStreamFile, format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 /**
    Print to file.
 
    @param file File pointer.
    @param format Formatting string.
    @param args Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
 trio_vfprintf
 TRIO_ARGS3((file, format, args),
            FILE *file,
            TRIO_CONST char *format,
            va_list args)
 {
   assert(VALID(file));
   assert(VALID(format));
-  
-  return TrioFormat(file, 0, TrioOutStreamFile, format, &args, NULL);
+
+  return TrioFormat(file, 0, TrioOutStreamFile, format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 /**
    Print to file.
 
    @param file File pointer.
    @param format Formatting string.
    @param args Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
 trio_fprintfv
 TRIO_ARGS3((file, format, args),
            FILE *file,
            TRIO_CONST char *format,
            trio_pointer_t * args)
 {
   assert(VALID(file));
   assert(VALID(format));
-  
+
   return TrioFormat(file, 0, TrioOutStreamFile, format, NULL, args);
 }
 
 /*************************************************************************
  * dprintf
  */
 
 /**
    Print to file descriptor.
 
    @param fd File descriptor.
    @param format Formatting string.
    @param ... Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
 trio_dprintf
 TRIO_VARGS3((fd, format, va_alist),
             int fd,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
-  status = TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, &args, NULL);
+  status = TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 /**
    Print to file descriptor.
 
    @param fd File descriptor.
    @param format Formatting string.
    @param args Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
 trio_vdprintf
 TRIO_ARGS3((fd, format, args),
            int fd,
            TRIO_CONST char *format,
            va_list args)
 {
   assert(VALID(format));
-  
-  return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, &args, NULL);
+
+  return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 /**
    Print to file descriptor.
 
    @param fd File descriptor.
    @param format Formatting string.
    @param args Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
 trio_dprintfv
 TRIO_ARGS3((fd, format, args),
            int fd,
            TRIO_CONST char *format,
            trio_pointer_t *args)
 {
   assert(VALID(format));
-  
+
   return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, NULL, args);
 }
 
 /*************************************************************************
  * cprintf
  */
 TRIO_PUBLIC int
 trio_cprintf
 TRIO_VARGS4((stream, closure, format, va_alist),
             trio_outstream_t stream,
             trio_pointer_t closure,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
   trio_custom_t data;
 
   assert(VALID(stream));
   assert(VALID(format));
 
   TRIO_VA_START(args, format);
   data.stream.out = stream;
   data.closure = closure;
-  status = TrioFormat(&data, 0, TrioOutStreamCustom, format, &args, NULL);
+  status = TrioFormat(&data, 0, TrioOutStreamCustom, format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 TRIO_PUBLIC int
 trio_vcprintf
 TRIO_ARGS4((stream, closure, format, args),
            trio_outstream_t stream,
            trio_pointer_t closure,
            TRIO_CONST char *format,
            va_list args)
 {
   trio_custom_t data;
 
   assert(VALID(stream));
   assert(VALID(format));
 
   data.stream.out = stream;
   data.closure = closure;
-  return TrioFormat(&data, 0, TrioOutStreamCustom, format, &args, NULL);
+  return TrioFormat(&data, 0, TrioOutStreamCustom, format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 TRIO_PUBLIC int
 trio_cprintfv
 TRIO_ARGS4((stream, closure, format, args),
            trio_outstream_t stream,
            trio_pointer_t closure,
            TRIO_CONST char *format,
            void **args)
 {
@@ skipping 24 matching lines @@
 TRIO_VARGS3((buffer, format, va_alist),
             char *buffer,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(buffer));
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
-  status = TrioFormat(&buffer, 0, TrioOutStreamString, format, &args, NULL);
+  status = TrioFormat(&buffer, 0, TrioOutStreamString, format, TRIO_VA_LIST_ADDR(args), NULL);
   *buffer = NIL; /* Terminate with NIL character */
   TRIO_VA_END(args);
   return status;
 }
 
 /**
    Print to string.
 
    @param buffer Output string.
    @param format Formatting string.
    @param args Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
 trio_vsprintf
 TRIO_ARGS3((buffer, format, args),
            char *buffer,
            TRIO_CONST char *format,
            va_list args)
 {
   int status;
 
   assert(VALID(buffer));
   assert(VALID(format));
 
-  status = TrioFormat(&buffer, 0, TrioOutStreamString, format, &args, NULL);
+  status = TrioFormat(&buffer, 0, TrioOutStreamString, format, TRIO_VA_LIST_ADDR(args), NULL);
   *buffer = NIL;
   return status;
 }
 
 /**
    Print to string.
 
    @param buffer Output string.
    @param format Formatting string.
    @param args Arguments.
@@ skipping 38 matching lines @@
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(buffer));
   assert(VALID(format));
 
   TRIO_VA_START(args, format);
   status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,
-                      TrioOutStreamStringMax, format, &args, NULL);
+                      TrioOutStreamStringMax, format, TRIO_VA_LIST_ADDR(args), NULL);
   if (max > 0)
     *buffer = NIL;
   TRIO_VA_END(args);
   return status;
 }
 
 /**
    Print at most @p max characters to string.
 
    @param buffer Output string.
    @param max Maximum number of characters to print.
    @param format Formatting string.
    @param args Arguments.
    @return Number of printed characters.
  */
 TRIO_PUBLIC int
 trio_vsnprintf
 TRIO_ARGS4((buffer, max, format, args),
            char *buffer,
            size_t max,
            TRIO_CONST char *format,
            va_list args)
 {
   int status;
 
   assert(VALID(buffer));
   assert(VALID(format));
 
   status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,
-                      TrioOutStreamStringMax, format, &args, NULL);
+                      TrioOutStreamStringMax, format, TRIO_VA_LIST_ADDR(args), NULL);
   if (max > 0)
     *buffer = NIL;
   return status;
 }
 
 /**
    Print at most @p max characters to string.
 
    @param buffer Output string.
    @param max Maximum number of characters to print.
@@ skipping 40 matching lines @@
 
   TRIO_VA_START(args, format);
 
   assert(VALID(buffer));
   assert(VALID(format));
 
   buf_len = trio_length(buffer);
   buffer = &buffer[buf_len];
 
   status = TrioFormat(&buffer, max - 1 - buf_len,
-                      TrioOutStreamStringMax, format, &args, NULL);
+                      TrioOutStreamStringMax, format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   *buffer = NIL;
   return status;
 }
 
 TRIO_PUBLIC int
 trio_vsnprintfcat
 TRIO_ARGS4((buffer, max, format, args),
            char *buffer,
            size_t max,
            TRIO_CONST char *format,
            va_list args)
 {
   int status;
   size_t buf_len;
-  
+
   assert(VALID(buffer));
   assert(VALID(format));
 
   buf_len = trio_length(buffer);
   buffer = &buffer[buf_len];
   status = TrioFormat(&buffer, max - 1 - buf_len,
-                      TrioOutStreamStringMax, format, &args, NULL);
+                      TrioOutStreamStringMax, format, TRIO_VA_LIST_ADDR(args), NULL);
   *buffer = NIL;
   return status;
 }
 
 /*************************************************************************
  * trio_aprintf
  */
 
 /* Deprecated */
 TRIO_PUBLIC char *
 trio_aprintf
 TRIO_VARGS2((format, va_alist),
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   va_list args;
   trio_string_t *info;
   char *result = NULL;
 
   assert(VALID(format));
-  
+
   info = trio_xstring_duplicate("");
   if (info)
     {
       TRIO_VA_START(args, format);
       (void)TrioFormat(info, 0, TrioOutStreamStringDynamic,
-                       format, &args, NULL);
+                       format, TRIO_VA_LIST_ADDR(args), NULL);
       TRIO_VA_END(args);
 
       trio_string_terminate(info);
       result = trio_string_extract(info);
       trio_string_destroy(info);
     }
   return result;
 }
 
 /* Deprecated */
 TRIO_PUBLIC char *
 trio_vaprintf
 TRIO_ARGS2((format, args),
            TRIO_CONST char *format,
            va_list args)
 {
   trio_string_t *info;
   char *result = NULL;
-  
+
   assert(VALID(format));
-  
+
   info = trio_xstring_duplicate("");
   if (info)
     {
       (void)TrioFormat(info, 0, TrioOutStreamStringDynamic,
-                       format, &args, NULL);
+                       format, TRIO_VA_LIST_ADDR(args), NULL);
       trio_string_terminate(info);
       result = trio_string_extract(info);
       trio_string_destroy(info);
     }
   return result;
 }
 
 TRIO_PUBLIC int
 trio_asprintf
 TRIO_VARGS3((result, format, va_alist),
             char **result,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   va_list args;
   int status;
   trio_string_t *info;
 
   assert(VALID(format));
 
   *result = NULL;
-  
+
   info = trio_xstring_duplicate("");
   if (info == NULL)
     {
       status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
     }
   else
     {
       TRIO_VA_START(args, format);
       status = TrioFormat(info, 0, TrioOutStreamStringDynamic,
-                          format, &args, NULL);
+                          format, TRIO_VA_LIST_ADDR(args), NULL);
       TRIO_VA_END(args);
       if (status >= 0)
         {
           trio_string_terminate(info);
           *result = trio_string_extract(info);
         }
       trio_string_destroy(info);
     }
   return status;
 }
 
 TRIO_PUBLIC int
 trio_vasprintf
 TRIO_ARGS3((result, format, args),
            char **result,
            TRIO_CONST char *format,
            va_list args)
 {
   int status;
   trio_string_t *info;
-  
+
   assert(VALID(format));
 
   *result = NULL;
-  
+
   info = trio_xstring_duplicate("");
   if (info == NULL)
     {
       status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
     }
   else
     {
       status = TrioFormat(info, 0, TrioOutStreamStringDynamic,
-                          format, &args, NULL);
+                          format, TRIO_VA_LIST_ADDR(args), NULL);
       if (status >= 0)
         {
           trio_string_terminate(info);
           *result = trio_string_extract(info);
         }
       trio_string_destroy(info);
     }
   return status;
 }
 
@@ skipping 19 matching lines @@
  * trio_register
  */
 
 /**
    Register new user-defined specifier.
 
    @param callback
    @param name
    @return Handle.
  */
-TRIO_PUBLIC trio_pointer_t 
+TRIO_PUBLIC trio_pointer_t
 trio_register
 TRIO_ARGS2((callback, name),
            trio_callback_t callback,
            TRIO_CONST char *name)
 {
   trio_userdef_t *def;
   trio_userdef_t *prev = NULL;
 
   if (callback == NULL)
     return NULL;
 
   if (name)
     {
       /* Handle built-in namespaces */
       if (name[0] == ':')
         {
           if (trio_equal(name, ":enter"))
             {
               internalEnterCriticalRegion = callback;
             }
           else if (trio_equal(name, ":leave"))
             {
               internalLeaveCriticalRegion = callback;
             }
           return NULL;
         }
-      
+
       /* Bail out if namespace is too long */
       if (trio_length(name) >= MAX_USER_NAME)
         return NULL;
-      
+
       /* Bail out if namespace already is registered */
       def = TrioFindNamespace(name, &prev);
       if (def)
         return NULL;
     }
-  
+
   def = (trio_userdef_t *)TRIO_MALLOC(sizeof(trio_userdef_t));
   if (def)
     {
       if (internalEnterCriticalRegion)
         (void)internalEnterCriticalRegion(NULL);
-      
+
       if (name)
         {
           /* Link into internal list */
           if (prev == NULL)
             internalUserDef = def;
           else
             prev->next = def;
         }
       /* Initialize */
       def->callback = callback;
@@ skipping 24 matching lines @@
 
   assert(VALID(self));
 
   if (self->name)
     {
       def = TrioFindNamespace(self->name, &prev);
       if (def)
         {
           if (internalEnterCriticalRegion)
             (void)internalEnterCriticalRegion(NULL);
-          
+
           if (prev == NULL)
             internalUserDef = NULL;
           else
             prev->next = def->next;
-          
+
           if (internalLeaveCriticalRegion)
             (void)internalLeaveCriticalRegion(NULL);
         }
       trio_destroy(self->name);
     }
   TRIO_FREE(self);
 }
 
 /*************************************************************************
  * trio_get_format [public]
  */
 TRIO_CONST char *
 trio_get_format
 TRIO_ARGS1((ref),
            trio_pointer_t ref)
 {
 #if defined(FORMAT_USER_DEFINED)
   assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);
 #endif
-  
+
   return (((trio_reference_t *)ref)->parameter->user_data);
 }
 
 /*************************************************************************
  * trio_get_argument [public]
  */
-trio_pointer_t 
+trio_pointer_t
 trio_get_argument
 TRIO_ARGS1((ref),
            trio_pointer_t ref)
 {
 #if defined(FORMAT_USER_DEFINED)
   assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);
 #endif
-  
+
   return ((trio_reference_t *)ref)->parameter->data.pointer;
 }
 
 /*************************************************************************
  * trio_get_width / trio_set_width [public]
  */
 int
 trio_get_width
 TRIO_ARGS1((ref),
            trio_pointer_t ref)
@@ skipping 511 matching lines @@
 trio_print_ref
 TRIO_VARGS3((ref, format, va_alist),
             trio_pointer_t ref,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list arglist;
 
   assert(VALID(format));
-  
+
   TRIO_VA_START(arglist, format);
-  status = TrioFormatRef((trio_reference_t *)ref, format, &arglist, NULL);
+  status = TrioFormatRef((trio_reference_t *)ref, format, TRIO_VA_LIST_ADDR(arglist), NULL);
   TRIO_VA_END(arglist);
   return status;
 }
 
 /*************************************************************************
  * trio_vprint_ref [public]
  */
 int
 trio_vprint_ref
 TRIO_ARGS3((ref, format, arglist),
            trio_pointer_t ref,
            TRIO_CONST char *format,
            va_list arglist)
 {
   assert(VALID(format));
-  
-  return TrioFormatRef((trio_reference_t *)ref, format, &arglist, NULL);
+
+  return TrioFormatRef((trio_reference_t *)ref, format, TRIO_VA_LIST_ADDR(arglist), NULL);
 }
 
 /*************************************************************************
  * trio_printv_ref [public]
  */
 int
 trio_printv_ref
 TRIO_ARGS3((ref, format, argarray),
            trio_pointer_t ref,
            TRIO_CONST char *format,
            trio_pointer_t *argarray)
 {
   assert(VALID(format));
-  
+
   return TrioFormatRef((trio_reference_t *)ref, format, NULL, argarray);
 }
 
 #endif /* TRIO_EXTENSION */
 
 /*************************************************************************
  * trio_print_pointer [public]
  */
 void
 trio_print_pointer
@@ skipping 228 matching lines @@
       index++;
     }
   /* Collect characters */
   for (ch = format[index];
        (ch != SPECIFIER_UNGROUP) && (ch != NIL);
        ch = format[++index])
     {
       switch (ch)
         {
         case QUALIFIER_MINUS: /* Scanlist ranges */
-          
+
           /*
            * Both C99 and UNIX98 describes ranges as implementation-
            * defined.
            *
            * We support the following behaviour (although this may
            * change as we become wiser)
            * - only increasing ranges, ie. [a-b] but not [b-a]
            * - transitive ranges, ie. [a-b-c] == [a-c]
            * - trailing minus, ie. [a-] is interpreted as an 'a'
            *   and a '-'
            * - duplicates (although we can easily convert these
            *   into errors)
            */
           range_begin = format[index - 1];
           range_end = format[++index];
           if (range_end == SPECIFIER_UNGROUP)
             {
               /* Trailing minus is included */
               characterclass[(int)ch]++;
               ch = range_end;
               break; /* for */
             }
           if (range_end == NIL)
             return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
           if (range_begin > range_end)
             return TRIO_ERROR_RETURN(TRIO_ERANGE, index);
-            
+
           for (i = (int)range_begin; i <= (int)range_end; i++)
             characterclass[i]++;
-            
+
           ch = range_end;
           break;
-          
+
 #if TRIO_EXTENSION
 
         case SPECIFIER_GROUP:
-          
+
           switch (format[index + 1])
             {
             case QUALIFIER_DOT: /* Collating symbol */
               /*
                * FIXME: This will be easier to implement when multibyte
                * characters have been implemented. Until now, we ignore
                * this feature.
                */
               for (i = index + 2; ; i++)
                 {
                   if (format[i] == NIL)
                     /* Error in syntax */
                     return -1;
                   else if (format[i] == QUALIFIER_DOT)
                     break; /* for */
                 }
               if (format[++i] != SPECIFIER_UNGROUP)
                 return -1;
-              
+
               index = i;
               break;
-          
+
             case QUALIFIER_EQUAL: /* Equivalence class expressions */
               {
                 unsigned int j;
                 unsigned int k;
-            
+
                 if (internalCollationUnconverted)
                   {
                     /* Lazy evaluation of collation array */
                     TrioGetCollation();
                     internalCollationUnconverted = FALSE;
                   }
                 for (i = index + 2; ; i++)
                   {
                     if (format[i] == NIL)
                       /* Error in syntax */
                       return -1;
                     else if (format[i] == QUALIFIER_EQUAL)
                       break; /* for */
                     else
                       {
                         /* Mark any equivalent character */
                         k = (unsigned int)format[i];
                         for (j = 0; internalCollationArray[k][j] != NIL; j++)
                           characterclass[(int)internalCollationArray[k][j]]++;
                       }
                   }
                 if (format[++i] != SPECIFIER_UNGROUP)
                   return -1;
-                
+
                 index = i;
               }
               break;
-          
+
             case QUALIFIER_COLON: /* Character class expressions */
-          
+
               if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1,
                                  &format[index]))
                 {
                   for (i = 0; i < MAX_CHARACTER_CLASS; i++)
                     if (isalnum(i))
                       characterclass[i]++;
                   index += sizeof(CLASS_ALNUM) - 1;
                 }
               else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1,
                                       &format[index]))
@@ skipping 79 matching lines @@
                 {
                   characterclass[(int)ch]++;
                 }
               break;
 
             default:
               characterclass[(int)ch]++;
               break;
             }
           break;
-          
+
 #endif /* TRIO_EXTENSION */
-          
+
         default:
           characterclass[(int)ch]++;
           break;
         }
     }
   return 0;
 }
 
 /*************************************************************************
  * TrioReadNumber
@@ skipping 25 matching lines @@
     {
       /* Lazy evaluation of digits array */
       memset(internalDigitArray, -1, sizeof(internalDigitArray));
       for (j = 0; j < (int)sizeof(internalDigitsLower) - 1; j++)
         {
           internalDigitArray[(int)internalDigitsLower[j]] = j;
           internalDigitArray[(int)internalDigitsUpper[j]] = j;
         }
       internalDigitsUnconverted = FALSE;
     }
-  
+
   TrioSkipWhitespaces(self);
-  
+
   if (!(flags & FLAGS_UNSIGNED))
     {
       /* Leading sign */
       if (self->current == '+')
         {
           self->InStream(self, NULL);
         }
       else if (self->current == '-')
         {
           self->InStream(self, NULL);
           isNegative = TRUE;
         }
     }
-  
+
   count = self->processed;
-  
+
   if (flags & FLAGS_ALTERNATIVE)
     {
       switch (base)
         {
         case NO_BASE:
         case BASE_OCTAL:
         case BASE_HEX:
         case BASE_BINARY:
           if (self->current == '0')
             {
@@ skipping 40 matching lines @@
 
               self->InStream(self, NULL);
             }
           if (internalThousandSeparator[j])
             break; /* Mismatch */
           else
             continue; /* Match */
         }
       else
         break;
-            
+
       number *= base;
       number += digit;
       gotNumber = TRUE; /* we need at least one digit */
 
       self->InStream(self, NULL);
     }
 
   /* Was anything read at all? */
   if (!gotNumber)
     return FALSE;
-  
+
   if (target)
     *target = (isNegative) ? -((trio_intmax_t)number) : number;
   return TRUE;
 }
 
 /*************************************************************************
  * TrioReadChar
  */
 TRIO_PRIVATE int
 TrioReadChar
 TRIO_ARGS4((self, target, flags, width),
            trio_class_t *self,
            char *target,
            trio_flags_t flags,
            int width)
 {
   int i;
   char ch;
   trio_uintmax_t number;
-  
+
   assert(VALID(self));
   assert(VALID(self->InStream));
 
   for (i = 0;
        (self->current != EOF) && (i < width);
        i++)
     {
       ch = (char)self->current;
       self->InStream(self, NULL);
       if ((flags & FLAGS_ALTERNATIVE) && (ch == CHAR_BACKSLASH))
@@ skipping 24 matching lines @@
                     return 0;
                   ch = (char)number;
                 }
               else
                 {
                   ch = (char)self->current;
                 }
               break;
             }
         }
-      
+
       if (target)
         target[i] = ch;
     }
   return i + 1;
 }
 
 /*************************************************************************
  * TrioReadString
  */
 TRIO_PRIVATE BOOLEAN_T
 TrioReadString
 TRIO_ARGS4((self, target, flags, width),
            trio_class_t *self,
            char *target,
            trio_flags_t flags,
            int width)
 {
   int i;
-  
+
   assert(VALID(self));
   assert(VALID(self->InStream));
 
   TrioSkipWhitespaces(self);
-    
+
   /*
    * Continue until end of string is reached, a whitespace is encountered,
    * or width is exceeded
    */
   for (i = 0;
        ((width == NO_WIDTH) || (i < width)) &&
        (! ((self->current == EOF) || isspace(self->current)));
        i++)
     {
       if (TrioReadChar(self, (target ? &target[i] : 0), flags, 1) == 0)
@@ skipping 15 matching lines @@
            trio_wchar_t *target,
            trio_flags_t flags,
            int width)
 {
   int i;
   int j;
   int size;
   int amount = 0;
   trio_wchar_t wch;
   char buffer[MB_LEN_MAX + 1];
-  
+
   assert(VALID(self));
   assert(VALID(self->InStream));
 
   for (i = 0;
        (self->current != EOF) && (i < width);
        i++)
     {
       if (isascii(self->current))
         {
           if (TrioReadChar(self, buffer, flags, 1) == 0)
@@ skipping 36 matching lines @@
 TRIO_PRIVATE BOOLEAN_T
 TrioReadWideString
 TRIO_ARGS4((self, target, flags, width),
            trio_class_t *self,
            trio_wchar_t *target,
            trio_flags_t flags,
            int width)
 {
   int i;
   int size;
-  
+
   assert(VALID(self));
   assert(VALID(self->InStream));
 
   TrioSkipWhitespaces(self);
 
 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
   (void)mblen(NULL, 0);
 #endif
-  
+
   /*
    * Continue until end of string is reached, a whitespace is encountered,
    * or width is exceeded
    */
   for (i = 0;
        ((width == NO_WIDTH) || (i < width)) &&
        (! ((self->current == EOF) || isspace(self->current)));
        )
     {
       size = TrioReadWideChar(self, &target[i], flags, 1);
@@ skipping 17 matching lines @@
 TrioReadGroup
 TRIO_ARGS5((self, target, characterclass, flags, width),
            trio_class_t *self,
            char *target,
            int *characterclass,
            trio_flags_t flags,
            int width)
 {
   int ch;
   int i;
-  
+
   assert(VALID(self));
   assert(VALID(self->InStream));
 
   ch = self->current;
   for (i = 0;
        ((width == NO_WIDTH) || (i < width)) &&
        (! ((ch == EOF) ||
            (((flags & FLAGS_EXCLUDE) != 0) ^ (characterclass[ch] == 0))));
        i++)
     {
       if (target)
         target[i] = (char)ch;
       self->InStream(self, &ch);
     }
-  
+
   if (target)
     target[i] = NIL;
   return TRUE;
 }
 
 /*************************************************************************
  * TrioReadDouble
  *
  * FIXME:
  *  add long double
  *  handle base
  */
 TRIO_PRIVATE BOOLEAN_T
 TrioReadDouble
 TRIO_ARGS4((self, target, flags, width),
            trio_class_t *self,
            trio_pointer_t target,
            trio_flags_t flags,
            int width)
 {
   int ch;
   char doubleString[512];
   int index = 0;
   int start;
   int j;
   BOOLEAN_T isHex = FALSE;
 
   doubleString[0] = 0;
-  
+
   if ((width == NO_WIDTH) || (width > (int)sizeof(doubleString) - 1))
     width = sizeof(doubleString) - 1;
-  
+
   TrioSkipWhitespaces(self);
-  
+
   /*
    * Read entire double number from stream. trio_to_double requires
    * a string as input, but InStream can be anything, so we have to
    * collect all characters.
    */
   ch = self->current;
   if ((ch == '+') || (ch == '-'))
     {
       doubleString[index++] = (char)ch;
       self->InStream(self, &ch);
@@ skipping 65 matching lines @@
     case '0':
       doubleString[index++] = (char)ch;
       self->InStream(self, &ch);
       if (trio_to_upper(ch) == 'X')
         {
           isHex = TRUE;
           doubleString[index++] = (char)ch;
           self->InStream(self, &ch);
         }
       break;
-      
+
     default:
       break;
     }
-  
+
   while ((ch != EOF) && (index - start < width))
     {
       /* Integer part */
       if (isHex ? isxdigit(ch) : isdigit(ch))
         {
           doubleString[index++] = (char)ch;
           self->InStream(self, &ch);
         }
       else if (flags & FLAGS_QUOTE)
         {
@@ skipping 39 matching lines @@
               doubleString[index++] = (char)ch;
               self->InStream(self, &ch);
             }
         }
     }
 
   if ((index == start) || (*doubleString == NIL))
     return FALSE;
 
   doubleString[index] = 0;
-  
+
   if (flags & FLAGS_LONGDOUBLE)
     {
       *((trio_long_double_t *)target) = trio_to_long_double(doubleString, NULL);
     }
   else
     {
       *((double *)target) = trio_to_double(doubleString, NULL);
     }
   return TRUE;
 }
 
 /*************************************************************************
  * TrioReadPointer
  */
 TRIO_PRIVATE BOOLEAN_T
 TrioReadPointer
 TRIO_ARGS3((self, target, flags),
            trio_class_t *self,
            trio_pointer_t *target,
            trio_flags_t flags)
 {
   trio_uintmax_t number;
   char buffer[sizeof(internalNullString)];
 
   flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);
-  
+
   if (TrioReadNumber(self,
                      &number,
                      flags,
                      POINTER_WIDTH,
                      BASE_HEX))
     {
       /*
        * The strange assignment of number is a workaround for a compiler
        * warning
        */
       if (target)
         *target = (char *)0 + number;
       return TRUE;
     }
   else if (TrioReadString(self,
                           (flags & FLAGS_IGNORE)
                           ? NULL
                           : buffer,
                           0,
                           sizeof(internalNullString) - 1))
-    {  
+    {
       if (trio_equal_case(buffer, internalNullString))
         {
           if (target)
             *target = NULL;
           return TRUE;
         }
     }
   return FALSE;
 }
 
@@ skipping 43 matching lines @@
                   if (ch != format[index + cnt])
                     {
                       return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
                     }
                   data->InStream(data, &ch);
                 }
               continue; /* while characters left in formatting string */
             }
         }
 #endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
-      
+
       if ((EOF == ch) && (parameters[i].type != FORMAT_COUNT))
         {
           return (assignment > 0) ? assignment : EOF;
         }
-      
+
       if (CHAR_IDENTIFIER == format[index])
         {
           if (CHAR_IDENTIFIER == format[index + 1])
             {
               /* Two % in format matches one % in input stream */
               if (CHAR_IDENTIFIER == ch)
                 {
                   data->InStream(data, &ch);
                   index += 2;
                   continue; /* while format chars left */
                 }
               else
                 return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
             }
 
           /* Skip the parameter entries */
           while (parameters[i].type == FORMAT_PARAMETER)
             i++;
-          
+
           flags = parameters[i].flags;
           /* Find width */
           width = parameters[i].width;
           if (flags & FLAGS_WIDTH_PARAMETER)
             {
               /* Get width from parameter list */
               width = (int)parameters[width].data.number.as_signed;
             }
           /* Find base */
           base = parameters[i].base;
           if (flags & FLAGS_BASE_PARAMETER)
             {
               /* Get base from parameter list */
               base = (int)parameters[base].data.number.as_signed;
             }
-          
+
           switch (parameters[i].type)
             {
             case FORMAT_INT:
               {
                 trio_uintmax_t number;
 
                 if (0 == base)
                   base = BASE_DECIMAL;
 
                 if (!TrioReadNumber(data,
@@ skipping 27 matching lines @@
                       *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)number;
                     else if (flags & FLAGS_LONG)
                       *(long int *)pointer = (long int)number;
                     else if (flags & FLAGS_SHORT)
                       *(short int *)pointer = (short int)number;
                     else
                       *(int *)pointer = (int)number;
                   }
               }
               break; /* FORMAT_INT */
-              
+
             case FORMAT_STRING:
 #if TRIO_WIDECHAR
               if (flags & FLAGS_WIDECHAR)
                 {
                   if (!TrioReadWideString(data,
                                           (flags & FLAGS_IGNORE)
                                           ? NULL
                                           : parameters[i].data.wstring,
                                           flags,
                                           width))
@@ skipping 43 matching lines @@
                 int characterclass[MAX_CHARACTER_CLASS + 1];
                 int rc;
 
                 /* Skip over modifiers */
                 while (format[index] != SPECIFIER_GROUP)
                   {
                     index++;
                   }
                 /* Skip over group specifier */
                 index++;
-                
+
                 memset(characterclass, 0, sizeof(characterclass));
                 rc = TrioGetCharacterClass(format,
                                            &index,
                                            &flags,
                                            characterclass);
                 if (rc < 0)
                   return rc;
 
                 if (!TrioReadGroup(data,
                                    (flags & FLAGS_IGNORE)
@@ skipping 41 matching lines @@
                   else if (flags & FLAGS_SHORT)
                     {
                       *(short int *)pointer = (short int)count;
                     }
                   else
                     {
                       *(int *)pointer = (int)count;
                     }
                 }
               break; /* FORMAT_COUNT */
-              
+
             case FORMAT_CHAR:
 #if TRIO_WIDECHAR
               if (flags & FLAGS_WIDECHAR)
                 {
                   if (TrioReadWideChar(data,
                                        (flags & FLAGS_IGNORE)
                                        ? NULL
                                        : parameters[i].data.wstring,
                                        flags,
                                        (width == NO_WIDTH) ? 1 : width) == 0)
@@ skipping 41 matching lines @@
             {
               /* Whitespaces may match any amount of whitespaces */
               ch = TrioSkipWhitespaces(data);
             }
           else if (ch == format[index])
             {
               data->InStream(data, &ch);
             }
           else
             return assignment;
-          
+
           index++;
         }
     }
   return assignment;
 }
 
 /*************************************************************************
  * TrioScan
  */
 TRIO_PRIVATE int
 TrioScan
 TRIO_ARGS6((source, sourceSize, InStream, format, arglist, argarray),
            trio_pointer_t source,
            size_t sourceSize,
            void (*InStream) TRIO_PROTO((trio_class_t *, int *)),
            TRIO_CONST char *format,
-           va_list *arglist,
+           TRIO_VA_LIST_PTR arglist,
            trio_pointer_t *argarray)
 {
   int status;
   trio_parameter_t parameters[MAX_PARAMETERS];
   trio_class_t data;
 
   assert(VALID(InStream));
   assert(VALID(format));
 
   memset(&data, 0, sizeof(data));
   data.InStream = InStream;
   data.location = (trio_pointer_t)source;
   data.max = sourceSize;
   data.error = 0;
 
 #if defined(USE_LOCALE)
   if (NULL == internalLocaleValues)
     {
       TrioSetLocale();
     }
 #endif
-  
+
   status = TrioParse(TYPE_SCAN, format, parameters, arglist, argarray);
   if (status < 0)
     return status;
 
   status = TrioScanProcess(&data, format, parameters);
   if (data.error != 0)
     {
       status = data.error;
     }
   return status;
 }
 
 /*************************************************************************
  * TrioInStreamFile
  */
 TRIO_PRIVATE void
 TrioInStreamFile
 TRIO_ARGS2((self, intPointer),
            trio_class_t *self,
            int *intPointer)
 {
-  FILE *file = (FILE *)self->location;
+  FILE *file;
 
   assert(VALID(self));
+  assert(VALID(self->location));
   assert(VALID(file));
 
+  file = (FILE *)self->location;
+
   self->current = fgetc(file);
   if (self->current == EOF)
     {
       self->error = (ferror(file))
         ? TRIO_ERROR_RETURN(TRIO_ERRNO, 0)
         : TRIO_ERROR_RETURN(TRIO_EOF, 0);
     }
   else
     {
       self->processed++;
       self->committed++;
     }
-  
+
   if (VALID(intPointer))
     {
       *intPointer = self->current;
     }
 }
 
 /*************************************************************************
  * TrioInStreamFileDescriptor
  */
 TRIO_PRIVATE void
 TrioInStreamFileDescriptor
 TRIO_ARGS2((self, intPointer),
            trio_class_t *self,
            int *intPointer)
 {
-  int fd = *((int *)self->location);
+  int fd;
   int size;
   unsigned char input;
 
   assert(VALID(self));
+  assert(VALID(self->location));
+
+  fd = *((int *)self->location);
 
   size = read(fd, &input, sizeof(char));
   if (size == -1)
     {
       self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
       self->current = EOF;
     }
   else
     {
       self->current = (size == 0) ? EOF : input;
     }
   if (self->current != EOF)
     {
       self->committed++;
       self->processed++;
     }
-  
+
   if (VALID(intPointer))
     {
       *intPointer = self->current;
     }
 }
 
 /*************************************************************************
  * TrioInStreamCustom
  */
 TRIO_PRIVATE void
 TrioInStreamCustom
 TRIO_ARGS2((self, intPointer),
            trio_class_t *self,
            int *intPointer)
 {
   trio_custom_t *data;
-  
+
   assert(VALID(self));
   assert(VALID(self->location));
 
   data = (trio_custom_t *)self->location;
 
   self->current = (data->stream.in == NULL)
     ? NIL
     : (data->stream.in)(data->closure);
-  
+
   if (self->current == NIL)
     {
       self->current = EOF;
     }
   else
     {
       self->processed++;
       self->committed++;
     }
-  
+
   if (VALID(intPointer))
     {
       *intPointer = self->current;
     }
 }
 
 /*************************************************************************
  * TrioInStreamString
  */
 TRIO_PRIVATE void
@@ skipping 12 matching lines @@
   if (self->current == NIL)
     {
       self->current = EOF;
     }
   else
     {
       (*buffer)++;
       self->processed++;
       self->committed++;
     }
-  
+
   if (VALID(intPointer))
     {
       *intPointer = self->current;
     }
 }
 
 /*************************************************************************
  *
  * Formatted scanning functions
  *
@@ skipping 20 matching lines @@
 TRIO_PUBLIC int
 trio_scanf
 TRIO_VARGS2((format, va_alist),
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
   status = TrioScan((trio_pointer_t)stdin, 0,
                     TrioInStreamFile,
-                    format, &args, NULL);
+                    format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 TRIO_PUBLIC int
 trio_vscanf
 TRIO_ARGS2((format, args),
            TRIO_CONST char *format,
            va_list args)
 {
   assert(VALID(format));
-  
+
   return TrioScan((trio_pointer_t)stdin, 0,
                   TrioInStreamFile,
-                  format, &args, NULL);
+                  format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 TRIO_PUBLIC int
 trio_scanfv
 TRIO_ARGS2((format, args),
            TRIO_CONST char *format,
            trio_pointer_t *args)
 {
   assert(VALID(format));
-  
+
   return TrioScan((trio_pointer_t)stdin, 0,
                   TrioInStreamFile,
                   format, NULL, args);
 }
 
 /*************************************************************************
  * fscanf
  */
 TRIO_PUBLIC int
 trio_fscanf
 TRIO_VARGS3((file, format, va_alist),
             FILE *file,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(file));
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
   status = TrioScan((trio_pointer_t)file, 0,
                     TrioInStreamFile,
-                    format, &args, NULL);
+                    format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 TRIO_PUBLIC int
 trio_vfscanf
 TRIO_ARGS3((file, format, args),
            FILE *file,
            TRIO_CONST char *format,
            va_list args)
 {
   assert(VALID(file));
   assert(VALID(format));
-  
+
   return TrioScan((trio_pointer_t)file, 0,
                   TrioInStreamFile,
-                  format, &args, NULL);
+                  format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 TRIO_PUBLIC int
 trio_fscanfv
 TRIO_ARGS3((file, format, args),
            FILE *file,
            TRIO_CONST char *format,
            trio_pointer_t *args)
 {
   assert(VALID(file));
   assert(VALID(format));
-  
+
   return TrioScan((trio_pointer_t)file, 0,
                   TrioInStreamFile,
                   format, NULL, args);
 }
 
 /*************************************************************************
  * dscanf
  */
 TRIO_PUBLIC int
 trio_dscanf
 TRIO_VARGS3((fd, format, va_alist),
             int fd,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
   status = TrioScan((trio_pointer_t)&fd, 0,
                     TrioInStreamFileDescriptor,
-                    format, &args, NULL);
+                    format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 TRIO_PUBLIC int
 trio_vdscanf
 TRIO_ARGS3((fd, format, args),
            int fd,
            TRIO_CONST char *format,
            va_list args)
 {
   assert(VALID(format));
-  
+
   return TrioScan((trio_pointer_t)&fd, 0,
                   TrioInStreamFileDescriptor,
-                  format, &args, NULL);
+                  format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 TRIO_PUBLIC int
 trio_dscanfv
 TRIO_ARGS3((fd, format, args),
            int fd,
            TRIO_CONST char *format,
            trio_pointer_t *args)
 {
   assert(VALID(format));
-  
+
   return TrioScan((trio_pointer_t)&fd, 0,
                   TrioInStreamFileDescriptor,
                   format, NULL, args);
 }
 
 /*************************************************************************
  * cscanf
  */
 TRIO_PUBLIC int
 trio_cscanf
 TRIO_VARGS4((stream, closure, format, va_alist),
             trio_instream_t stream,
             trio_pointer_t closure,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
   trio_custom_t data;
 
   assert(VALID(stream));
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
   data.stream.in = stream;
   data.closure = closure;
-  status = TrioScan(&data, 0, TrioInStreamCustom, format, &args, NULL);
+  status = TrioScan(&data, 0, TrioInStreamCustom, format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 TRIO_PUBLIC int
 trio_vcscanf
 TRIO_ARGS4((stream, closure, format, args),
            trio_instream_t stream,
            trio_pointer_t closure,
            TRIO_CONST char *format,
            va_list args)
 {
   trio_custom_t data;
-  
+
   assert(VALID(stream));
   assert(VALID(format));
 
   data.stream.in = stream;
   data.closure = closure;
-  return TrioScan(&data, 0, TrioInStreamCustom, format, &args, NULL);
+  return TrioScan(&data, 0, TrioInStreamCustom, format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 TRIO_PUBLIC int
 trio_cscanfv
 TRIO_ARGS4((stream, closure, format, args),
            trio_instream_t stream,
            trio_pointer_t closure,
            TRIO_CONST char *format,
            trio_pointer_t *args)
 {
   trio_custom_t data;
-  
+
   assert(VALID(stream));
   assert(VALID(format));
 
   data.stream.in = stream;
   data.closure = closure;
   return TrioScan(&data, 0, TrioInStreamCustom, format, NULL, args);
 }
 
 /*************************************************************************
  * sscanf
  */
 TRIO_PUBLIC int
 trio_sscanf
 TRIO_VARGS3((buffer, format, va_alist),
             TRIO_CONST char *buffer,
             TRIO_CONST char *format,
             TRIO_VA_DECL)
 {
   int status;
   va_list args;
 
   assert(VALID(buffer));
   assert(VALID(format));
-  
+
   TRIO_VA_START(args, format);
   status = TrioScan((trio_pointer_t)&buffer, 0,
                     TrioInStreamString,
-                    format, &args, NULL);
+                    format, TRIO_VA_LIST_ADDR(args), NULL);
   TRIO_VA_END(args);
   return status;
 }
 
 TRIO_PUBLIC int
 trio_vsscanf
 TRIO_ARGS3((buffer, format, args),
            TRIO_CONST char *buffer,
            TRIO_CONST char *format,
            va_list args)
 {
   assert(VALID(buffer));
   assert(VALID(format));
-  
+
   return TrioScan((trio_pointer_t)&buffer, 0,
                   TrioInStreamString,
-                  format, &args, NULL);
+                  format, TRIO_VA_LIST_ADDR(args), NULL);
 }
 
 TRIO_PUBLIC int
 trio_sscanfv
 TRIO_ARGS3((buffer, format, args),
            TRIO_CONST char *buffer,
            TRIO_CONST char *format,
            trio_pointer_t *args)
 {
   assert(VALID(buffer));
   assert(VALID(format));
-  
+
   return TrioScan((trio_pointer_t)&buffer, 0,
                   TrioInStreamString,
                   format, NULL, args);
 }
 
 /** @} End of Scanf documentation module */
 
 /*************************************************************************
  * trio_strerror
  */
@@ skipping 18 matching lines @@
     case TRIO_ENOMEM:
       return "Out of memory";
     case TRIO_ERANGE:
       return "Invalid range";
     case TRIO_ECUSTOM:
       return "Custom error";
     default:
       return "Unknown";
     }
 }