@@ -1,5 +1,5 @@

 Package: seqbias

-Version: 0.99.3

+Version: 0.99.4

 Date: 25-12-2010

 Title: Estimation of per-position bias in high-throughput sequencing data

 Description: This package implements a model of per-position sequencing bias in

@@ -118,8 +118,7 @@ configure:2948: result: yes

 configure:2948: checking for pow

 configure:2948: gcc -o conftest -g -O2   conftest.c -lz  >&5

 conftest.c:35: warning: conflicting types for built-in function 'pow'

-/tmp/cc2oJinr.o: In function `main':

-/tmp/ccFHWg6Y.o: In function `main':

+/tmp/ccoIQCRB.o: In function `main':

 /home/dcjones/bio/seqbias/conftest.c:46: undefined reference to `pow'

 collect2: ld returned 1 exit status

 configure:2948: $? = 1

@@ -177,11 +176,7 @@ configure:2948: result: no

 configure:2948: checking for sqrt

 configure:2948: gcc -o conftest -g -O2   conftest.c -lz  >&5

 conftest.c:35: warning: conflicting types for built-in function 'sqrt'

-<<<<<<< HEAD

-/tmp/ccFdFAsw.o: In function `main':

-=======

-/tmp/ccgUY6M3.o: In function `main':

->>>>>>> working

+/tmp/ccAAPyGF.o: In function `main':

 /home/dcjones/bio/seqbias/conftest.c:46: undefined reference to `sqrt'

 collect2: ld returned 1 exit status

 configure:2948: $? = 1

@@ -3,8 +3,9 @@ PKG_LIBS+=-lz

 include Makevars.common

-

-OBJECTS = $(SEQBIAS_OBJ) $(SAMTOOLS_OBJ:%=samtools/%) $(YAML_CPP_OBJ:%=yaml-cpp/%)

+OBJECTS = $(SEQBIAS_OBJ) \

+		  $(SAMTOOLS_OBJ:%=samtools/%) \

+		  $(YAML_CPP_OBJ:%=yaml-cpp/%)

 all : $(SHLIB)

@@ -10,7 +10,8 @@ YAML_CPP_OBJ = aliascontent.o conversion.o emitter.o emitterstate.o \

 SEQBIAS_OBJ = sequencing_bias.o kmers.o miscmath.o common.o \

 			  table.o superfasthash.o logger.o seqbias.o \

-			  snprintf.o

+

+GNULIB_OBJ = asprintf.o printf-args.o printf-parse.o vasnprintf.o vasprintf.o

 DFLAGS = -D_USE_KNETFILE -D_FILE_OFFSET_BITS=64

 PKG_CFLAGS  += $(DFLAGS) -Wall

@@ -3,8 +3,9 @@ PKG_LIBS+=@LIBS@

 include Makevars.common

-

-OBJECTS = $(SEQBIAS_OBJ) $(SAMTOOLS_OBJ:%=samtools/%) $(YAML_CPP_OBJ:%=yaml-cpp/%)

+OBJECTS = $(SEQBIAS_OBJ) \

+		  $(SAMTOOLS_OBJ:%=samtools/%) \

+		  $(YAML_CPP_OBJ:%=yaml-cpp/%)

 all : $(SHLIB)

@@ -1,10 +1,13 @@

-PKG_LIBS+=-$(ZLIB_LIBS) -lws2_32

-PKG_CFLAGS+=-D_LARGEFILE64_SOURCE

+PKG_LIBS+=$(ZLIB_LIBS) -lws2_32

+PKG_CFLAGS+=-D_LARGEFILE64_SOURCE -DNEED_ASPRINTF

 include Makevars.common

-OBJECTS = $(SEQBIAS_OBJ) $(SAMTOOLS_OBJ:%=samtools/%) $(YAML_CPP_OBJ:%=yaml-cpp/%)

+OBJECTS = $(SEQBIAS_OBJ) \

+		  $(SAMTOOLS_OBJ:%=samtools/%) \

+		  $(YAML_CPP_OBJ:%=yaml-cpp/%) \

+		  $(GNULIB_OBJ:%=gnulib/%)

 all : $(SHLIB)

new file mode 100644

@@ -0,0 +1,26 @@

+

+

+

+#ifndef ASPRINTF_INC

+#define ASPRINTF_INC

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#ifndef NEED_ASPRINTF

+#include <stdio.h>

+#else

+int asprintf (char **resultp, const char *format, ...);

+/* defined in gnulib/asprintf.c */

+#endif

+

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

+

+

new file mode 100644

@@ -0,0 +1,40 @@

+/* Formatted output to strings.

+   Copyright (C) 1999, 2002, 2006-2007, 2009-2011 Free Software Foundation,

+   Inc.

+

+   This program is free software; you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 2, or (at your option)

+   any later version.

+

+   This program is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+   GNU General Public License for more details.

+

+   You should have received a copy of the GNU General Public License along

+   with this program; if not, write to the Free Software Foundation,

+   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

+

+/*#include <config.h>*/

+

+/* Specification.  */

+#ifdef IN_LIBASPRINTF

+# include "vasprintf.h"

+#else

+# include <stdio.h>

+#endif

+

+#include <stdarg.h>

+

+int

+asprintf (char **resultp, const char *format, ...)

+{

+  va_list args;

+  int result;

+

+  va_start (args, format);

+  result = vasprintf (resultp, format, args);

+  va_end (args);

+  return result;

+}

new file mode 100644

@@ -0,0 +1,188 @@

+/* Decomposed printf argument list.

+   Copyright (C) 1999, 2002-2003, 2005-2007, 2009-2011 Free Software

+   Foundation, Inc.

+

+   This program is free software; you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 2, or (at your option)

+   any later version.

+

+   This program is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+   GNU General Public License for more details.

+

+   You should have received a copy of the GNU General Public License along

+   with this program; if not, write to the Free Software Foundation,

+   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

+

+/* This file can be parametrized with the following macros:

+     ENABLE_UNISTDIO    Set to 1 to enable the unistdio extensions.

+     PRINTF_FETCHARGS   Name of the function to be defined.

+     STATIC             Set to 'static' to declare the function static.  */

+

+#ifndef PRINTF_FETCHARGS

+/*# include <config.h>*/

+#endif

+

+/* Specification.  */

+#ifndef PRINTF_FETCHARGS

+# include "printf-args.h"

+#endif

+

+#ifdef STATIC

+STATIC

+#endif

+int

+PRINTF_FETCHARGS (va_list args, arguments *a)

+{

+  size_t i;

+  argument *ap;

+

+  for (i = 0, ap = &a->arg[0]; i < a->count; i++, ap++)

+    switch (ap->type)

+      {

+      case TYPE_SCHAR:

+        ap->a.a_schar = va_arg (args, /*signed char*/ int);

+        break;

+      case TYPE_UCHAR:

+        ap->a.a_uchar = va_arg (args, /*unsigned char*/ int);

+        break;

+      case TYPE_SHORT:

+        ap->a.a_short = va_arg (args, /*short*/ int);

+        break;

+      case TYPE_USHORT:

+        ap->a.a_ushort = va_arg (args, /*unsigned short*/ int);

+        break;

+      case TYPE_INT:

+        ap->a.a_int = va_arg (args, int);

+        break;

+      case TYPE_UINT:

+        ap->a.a_uint = va_arg (args, unsigned int);

+        break;

+      case TYPE_LONGINT:

+        ap->a.a_longint = va_arg (args, long int);

+        break;

+      case TYPE_ULONGINT:

+        ap->a.a_ulongint = va_arg (args, unsigned long int);

+        break;

+#if HAVE_LONG_LONG_INT

+      case TYPE_LONGLONGINT:

+        ap->a.a_longlongint = va_arg (args, long long int);

+        break;

+      case TYPE_ULONGLONGINT:

+        ap->a.a_ulonglongint = va_arg (args, unsigned long long int);

+        break;

+#endif

+      case TYPE_DOUBLE:

+        ap->a.a_double = va_arg (args, double);

+        break;

+      case TYPE_LONGDOUBLE:

+        ap->a.a_longdouble = va_arg (args, long double);

+        break;

+      case TYPE_CHAR:

+        ap->a.a_char = va_arg (args, int);

+        break;

+#if HAVE_WINT_T

+      case TYPE_WIDE_CHAR:

+        /* Although ISO C 99 7.24.1.(2) says that wint_t is "unchanged by

+           default argument promotions", this is not the case in mingw32,

+           where wint_t is 'unsigned short'.  */

+        ap->a.a_wide_char =

+          (sizeof (wint_t) < sizeof (int)

+           ? (wint_t) va_arg (args, int)

+           : va_arg (args, wint_t));

+        break;

+#endif

+      case TYPE_STRING:

+        ap->a.a_string = va_arg (args, const char *);

+        /* A null pointer is an invalid argument for "%s", but in practice

+           it occurs quite frequently in printf statements that produce

+           debug output.  Use a fallback in this case.  */

+        if (ap->a.a_string == NULL)

+          ap->a.a_string = "(NULL)";

+        break;

+#if HAVE_WCHAR_T

+      case TYPE_WIDE_STRING:

+        ap->a.a_wide_string = va_arg (args, const wchar_t *);

+        /* A null pointer is an invalid argument for "%ls", but in practice

+           it occurs quite frequently in printf statements that produce

+           debug output.  Use a fallback in this case.  */

+        if (ap->a.a_wide_string == NULL)

+          {

+            static const wchar_t wide_null_string[] =

+              {

+                (wchar_t)'(',

+                (wchar_t)'N', (wchar_t)'U', (wchar_t)'L', (wchar_t)'L',

+                (wchar_t)')',

+                (wchar_t)0

+              };

+            ap->a.a_wide_string = wide_null_string;

+          }

+        break;

+#endif

+      case TYPE_POINTER:

+        ap->a.a_pointer = va_arg (args, void *);

+        break;

+      case TYPE_COUNT_SCHAR_POINTER:

+        ap->a.a_count_schar_pointer = va_arg (args, signed char *);

+        break;

+      case TYPE_COUNT_SHORT_POINTER:

+        ap->a.a_count_short_pointer = va_arg (args, short *);

+        break;

+      case TYPE_COUNT_INT_POINTER:

+        ap->a.a_count_int_pointer = va_arg (args, int *);

+        break;

+      case TYPE_COUNT_LONGINT_POINTER:

+        ap->a.a_count_longint_pointer = va_arg (args, long int *);

+        break;

+#if HAVE_LONG_LONG_INT

+      case TYPE_COUNT_LONGLONGINT_POINTER:

+        ap->a.a_count_longlongint_pointer = va_arg (args, long long int *);

+        break;

+#endif

+#if ENABLE_UNISTDIO

+      /* The unistdio extensions.  */

+      case TYPE_U8_STRING:

+        ap->a.a_u8_string = va_arg (args, const uint8_t *);

+        /* A null pointer is an invalid argument for "%U", but in practice

+           it occurs quite frequently in printf statements that produce

+           debug output.  Use a fallback in this case.  */

+        if (ap->a.a_u8_string == NULL)

+          {

+            static const uint8_t u8_null_string[] =

+              { '(', 'N', 'U', 'L', 'L', ')', 0 };

+            ap->a.a_u8_string = u8_null_string;

+          }

+        break;

+      case TYPE_U16_STRING:

+        ap->a.a_u16_string = va_arg (args, const uint16_t *);

+        /* A null pointer is an invalid argument for "%lU", but in practice

+           it occurs quite frequently in printf statements that produce

+           debug output.  Use a fallback in this case.  */

+        if (ap->a.a_u16_string == NULL)

+          {

+            static const uint16_t u16_null_string[] =

+              { '(', 'N', 'U', 'L', 'L', ')', 0 };

+            ap->a.a_u16_string = u16_null_string;

+          }

+        break;

+      case TYPE_U32_STRING:

+        ap->a.a_u32_string = va_arg (args, const uint32_t *);

+        /* A null pointer is an invalid argument for "%llU", but in practice

+           it occurs quite frequently in printf statements that produce

+           debug output.  Use a fallback in this case.  */

+        if (ap->a.a_u32_string == NULL)

+          {

+            static const uint32_t u32_null_string[] =

+              { '(', 'N', 'U', 'L', 'L', ')', 0 };

+            ap->a.a_u32_string = u32_null_string;

+          }

+        break;

+#endif

+      default:

+        /* Unknown type.  */

+        return -1;

+      }

+  return 0;

+}

new file mode 100644

@@ -0,0 +1,159 @@

+/* Decomposed printf argument list.

+   Copyright (C) 1999, 2002-2003, 2006-2007, 2011 Free Software

+   Foundation, Inc.

+

+   This program is free software; you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 2, or (at your option)

+   any later version.

+

+   This program is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+   GNU General Public License for more details.

+

+   You should have received a copy of the GNU General Public License along

+   with this program; if not, write to the Free Software Foundation,

+   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

+

+#ifndef _PRINTF_ARGS_H

+#define _PRINTF_ARGS_H

+

+/* This file can be parametrized with the following macros:

+     ENABLE_UNISTDIO    Set to 1 to enable the unistdio extensions.

+     PRINTF_FETCHARGS   Name of the function to be declared.

+     STATIC             Set to 'static' to declare the function static.  */

+

+/* Default parameters.  */

+#ifndef PRINTF_FETCHARGS

+# define PRINTF_FETCHARGS printf_fetchargs

+#endif

+

+/* Get size_t.  */

+#include <stddef.h>

+

+/* Get wchar_t.  */

+#if HAVE_WCHAR_T

+# include <stddef.h>

+#endif

+

+/* Get wint_t.  */

+#if HAVE_WINT_T

+# include <wchar.h>

+#endif

+

+/* Get va_list.  */

+#include <stdarg.h>

+

+

+/* Argument types */

+typedef enum

+{

+  TYPE_NONE,

+  TYPE_SCHAR,

+  TYPE_UCHAR,

+  TYPE_SHORT,

+  TYPE_USHORT,

+  TYPE_INT,

+  TYPE_UINT,

+  TYPE_LONGINT,

+  TYPE_ULONGINT,

+#if HAVE_LONG_LONG_INT

+  TYPE_LONGLONGINT,

+  TYPE_ULONGLONGINT,

+#endif

+  TYPE_DOUBLE,

+  TYPE_LONGDOUBLE,

+  TYPE_CHAR,

+#if HAVE_WINT_T

+  TYPE_WIDE_CHAR,

+#endif

+  TYPE_STRING,

+#if HAVE_WCHAR_T

+  TYPE_WIDE_STRING,

+#endif

+  TYPE_POINTER,

+  TYPE_COUNT_SCHAR_POINTER,

+  TYPE_COUNT_SHORT_POINTER,

+  TYPE_COUNT_INT_POINTER,

+  TYPE_COUNT_LONGINT_POINTER

+#if HAVE_LONG_LONG_INT

+, TYPE_COUNT_LONGLONGINT_POINTER

+#endif

+#if ENABLE_UNISTDIO

+  /* The unistdio extensions.  */

+, TYPE_U8_STRING

+, TYPE_U16_STRING

+, TYPE_U32_STRING

+#endif

+} arg_type;

+

+/* Polymorphic argument */

+typedef struct

+{

+  arg_type type;

+  union

+  {

+    signed char                 a_schar;

+    unsigned char               a_uchar;

+    short                       a_short;

+    unsigned short              a_ushort;

+    int                         a_int;

+    unsigned int                a_uint;

+    long int                    a_longint;

+    unsigned long int           a_ulongint;

+#if HAVE_LONG_LONG_INT

+    long long int               a_longlongint;

+    unsigned long long int      a_ulonglongint;

+#endif

+    float                       a_float;

+    double                      a_double;

+    long double                 a_longdouble;

+    int                         a_char;

+#if HAVE_WINT_T

+    wint_t                      a_wide_char;

+#endif

+    const char*                 a_string;

+#if HAVE_WCHAR_T

+    const wchar_t*              a_wide_string;

+#endif

+    void*                       a_pointer;

+    signed char *               a_count_schar_pointer;

+    short *                     a_count_short_pointer;

+    int *                       a_count_int_pointer;

+    long int *                  a_count_longint_pointer;

+#if HAVE_LONG_LONG_INT

+    long long int *             a_count_longlongint_pointer;

+#endif

+#if ENABLE_UNISTDIO

+    /* The unistdio extensions.  */

+    const uint8_t *             a_u8_string;

+    const uint16_t *            a_u16_string;

+    const uint32_t *            a_u32_string;

+#endif

+  }

+  a;

+}

+argument;

+

+/* Number of directly allocated arguments (no malloc() needed).  */

+#define N_DIRECT_ALLOC_ARGUMENTS 7

+

+typedef struct

+{

+  size_t count;

+  argument *arg;

+  argument direct_alloc_arg[N_DIRECT_ALLOC_ARGUMENTS];

+}

+arguments;

+

+

+/* Fetch the arguments, putting them into a. */

+#ifdef STATIC

+STATIC

+#else

+extern

+#endif

+int PRINTF_FETCHARGS (va_list args, arguments *a);

+

+#endif /* _PRINTF_ARGS_H */

new file mode 100644

@@ -0,0 +1,639 @@

+/* Formatted output to strings.

+   Copyright (C) 1999-2000, 2002-2003, 2006-2011 Free Software Foundation, Inc.

+

+   This program is free software; you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 2, or (at your option)

+   any later version.

+

+   This program is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+   GNU General Public License for more details.

+

+   You should have received a copy of the GNU General Public License along

+   with this program; if not, write to the Free Software Foundation,

+   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

+

+/* This file can be parametrized with the following macros:

+     CHAR_T             The element type of the format string.

+     CHAR_T_ONLY_ASCII  Set to 1 to enable verification that all characters

+                        in the format string are ASCII.

+     DIRECTIVE          Structure denoting a format directive.

+                        Depends on CHAR_T.

+     DIRECTIVES         Structure denoting the set of format directives of a

+                        format string.  Depends on CHAR_T.

+     PRINTF_PARSE       Function that parses a format string.

+                        Depends on CHAR_T.

+     STATIC             Set to 'static' to declare the function static.

+     ENABLE_UNISTDIO    Set to 1 to enable the unistdio extensions.  */

+

+#ifndef PRINTF_PARSE

+/*# include <config.h>*/

+#endif

+

+/* Specification.  */

+#ifndef PRINTF_PARSE

+# include "printf-parse.h"

+#endif

+

+/* Default parameters.  */

+#ifndef PRINTF_PARSE

+# define PRINTF_PARSE printf_parse

+# define CHAR_T char

+# define DIRECTIVE char_directive

+# define DIRECTIVES char_directives

+#endif

+

+/* Get size_t, NULL.  */

+#include <stddef.h>

+

+/* Get intmax_t.  */

+#if defined IN_LIBINTL || defined IN_LIBASPRINTF

+# if HAVE_STDINT_H_WITH_UINTMAX

+#  include <stdint.h>

+# endif

+# if HAVE_INTTYPES_H_WITH_UINTMAX

+#  include <inttypes.h>

+# endif

+#else

+# include <stdint.h>

+#endif

+

+/* malloc(), realloc(), free().  */

+#include <stdlib.h>

+

+/* memcpy().  */

+#include <string.h>

+

+/* errno.  */

+#include <errno.h>

+

+/* Checked size_t computations.  */

+#include "xsize.h"

+

+#if CHAR_T_ONLY_ASCII

+/* c_isascii().  */

+# include "c-ctype.h"

+#endif

+

+#ifdef STATIC

+STATIC

+#endif

+int

+PRINTF_PARSE (const CHAR_T *format, DIRECTIVES *d, arguments *a)

+{

+  const CHAR_T *cp = format;    /* pointer into format */

+  size_t arg_posn = 0;          /* number of regular arguments consumed */

+  size_t d_allocated;           /* allocated elements of d->dir */

+  size_t a_allocated;           /* allocated elements of a->arg */

+  size_t max_width_length = 0;

+  size_t max_precision_length = 0;

+

+  d->count = 0;

+  d_allocated = N_DIRECT_ALLOC_DIRECTIVES;

+  d->dir = d->direct_alloc_dir;

+

+  a->count = 0;

+  a_allocated = N_DIRECT_ALLOC_ARGUMENTS;

+  a->arg = a->direct_alloc_arg;

+

+#define REGISTER_ARG(_index_,_type_) \

+  {                                                                     \

+    size_t n = (_index_);                                               \

+    if (n >= a_allocated)                                               \

+      {                                                                 \

+        size_t memory_size;                                             \

+        argument *memory;                                               \

+                                                                        \

+        a_allocated = xtimes (a_allocated, 2);                          \

+        if (a_allocated <= n)                                           \

+          a_allocated = xsum (n, 1);                                    \

+        memory_size = xtimes (a_allocated, sizeof (argument));          \

+        if (size_overflow_p (memory_size))                              \

+          /* Overflow, would lead to out of memory.  */                 \

+          goto out_of_memory;                                           \

+        memory = (argument *) (a->arg != a->direct_alloc_arg            \

+                               ? realloc (a->arg, memory_size)          \

+                               : malloc (memory_size));                 \

+        if (memory == NULL)                                             \

+          /* Out of memory.  */                                         \

+          goto out_of_memory;                                           \

+        if (a->arg == a->direct_alloc_arg)                              \

+          memcpy (memory, a->arg, a->count * sizeof (argument));        \

+        a->arg = memory;                                                \

+      }                                                                 \

+    while (a->count <= n)                                               \

+      a->arg[a->count++].type = TYPE_NONE;                              \

+    if (a->arg[n].type == TYPE_NONE)                                    \

+      a->arg[n].type = (_type_);                                        \

+    else if (a->arg[n].type != (_type_))                                \

+      /* Ambiguous type for positional argument.  */                    \

+      goto error;                                                       \

+  }

+

+  while (*cp != '\0')

+    {

+      CHAR_T c = *cp++;

+      if (c == '%')

+        {

+          size_t arg_index = ARG_NONE;

+          DIRECTIVE *dp = &d->dir[d->count]; /* pointer to next directive */

+

+          /* Initialize the next directive.  */

+          dp->dir_start = cp - 1;

+          dp->flags = 0;

+          dp->width_start = NULL;

+          dp->width_end = NULL;

+          dp->width_arg_index = ARG_NONE;

+          dp->precision_start = NULL;

+          dp->precision_end = NULL;

+          dp->precision_arg_index = ARG_NONE;

+          dp->arg_index = ARG_NONE;

+

+          /* Test for positional argument.  */

+          if (*cp >= '0' && *cp <= '9')

+            {

+              const CHAR_T *np;

+

+              for (np = cp; *np >= '0' && *np <= '9'; np++)

+                ;

+              if (*np == '$')

+                {

+                  size_t n = 0;

+

+                  for (np = cp; *np >= '0' && *np <= '9'; np++)

+                    n = xsum (xtimes (n, 10), *np - '0');

+                  if (n == 0)

+                    /* Positional argument 0.  */

+                    goto error;

+                  if (size_overflow_p (n))

+                    /* n too large, would lead to out of memory later.  */

+                    goto error;

+                  arg_index = n - 1;

+                  cp = np + 1;

+                }

+            }

+

+          /* Read the flags.  */

+          for (;;)

+            {

+              if (*cp == '\'')

+                {

+                  dp->flags |= FLAG_GROUP;

+                  cp++;

+                }

+              else if (*cp == '-')

+                {

+                  dp->flags |= FLAG_LEFT;

+                  cp++;

+                }

+              else if (*cp == '+')

+                {

+                  dp->flags |= FLAG_SHOWSIGN;

+                  cp++;

+                }

+              else if (*cp == ' ')

+                {

+                  dp->flags |= FLAG_SPACE;

+                  cp++;

+                }

+              else if (*cp == '#')

+                {

+                  dp->flags |= FLAG_ALT;

+                  cp++;

+                }

+              else if (*cp == '0')

+                {

+                  dp->flags |= FLAG_ZERO;

+                  cp++;

+                }

+#if __GLIBC__ >= 2 && !defined __UCLIBC__

+              else if (*cp == 'I')

+                {

+                  dp->flags |= FLAG_LOCALIZED;

+                  cp++;

+                }

+#endif

+              else

+                break;

+            }

+

+          /* Parse the field width.  */

+          if (*cp == '*')

+            {

+              dp->width_start = cp;

+              cp++;

+              dp->width_end = cp;

+              if (max_width_length < 1)

+                max_width_length = 1;

+

+              /* Test for positional argument.  */

+              if (*cp >= '0' && *cp <= '9')

+                {

+                  const CHAR_T *np;

+

+                  for (np = cp; *np >= '0' && *np <= '9'; np++)

+                    ;

+                  if (*np == '$')

+                    {

+                      size_t n = 0;

+

+                      for (np = cp; *np >= '0' && *np <= '9'; np++)

+                        n = xsum (xtimes (n, 10), *np - '0');

+                      if (n == 0)

+                        /* Positional argument 0.  */

+                        goto error;

+                      if (size_overflow_p (n))

+                        /* n too large, would lead to out of memory later.  */

+                        goto error;

+                      dp->width_arg_index = n - 1;

+                      cp = np + 1;

+                    }

+                }

+              if (dp->width_arg_index == ARG_NONE)

+                {

+                  dp->width_arg_index = arg_posn++;

+                  if (dp->width_arg_index == ARG_NONE)

+                    /* arg_posn wrapped around.  */

+                    goto error;

+                }

+              REGISTER_ARG (dp->width_arg_index, TYPE_INT);

+            }

+          else if (*cp >= '0' && *cp <= '9')

+            {

+              size_t width_length;

+

+              dp->width_start = cp;

+              for (; *cp >= '0' && *cp <= '9'; cp++)

+                ;

+              dp->width_end = cp;

+              width_length = dp->width_end - dp->width_start;

+              if (max_width_length < width_length)

+                max_width_length = width_length;

+            }

+

+          /* Parse the precision.  */

+          if (*cp == '.')

+            {

+              cp++;

+              if (*cp == '*')

+                {

+                  dp->precision_start = cp - 1;

+                  cp++;

+                  dp->precision_end = cp;

+                  if (max_precision_length < 2)

+                    max_precision_length = 2;

+

+                  /* Test for positional argument.  */

+                  if (*cp >= '0' && *cp <= '9')

+                    {

+                      const CHAR_T *np;

+

+                      for (np = cp; *np >= '0' && *np <= '9'; np++)

+                        ;

+                      if (*np == '$')

+                        {

+                          size_t n = 0;

+

+                          for (np = cp; *np >= '0' && *np <= '9'; np++)

+                            n = xsum (xtimes (n, 10), *np - '0');

+                          if (n == 0)

+                            /* Positional argument 0.  */

+                            goto error;

+                          if (size_overflow_p (n))

+                            /* n too large, would lead to out of memory

+                               later.  */

+                            goto error;

+                          dp->precision_arg_index = n - 1;

+                          cp = np + 1;

+                        }

+                    }

+                  if (dp->precision_arg_index == ARG_NONE)

+                    {

+                      dp->precision_arg_index = arg_posn++;

+                      if (dp->precision_arg_index == ARG_NONE)

+                        /* arg_posn wrapped around.  */

+                        goto error;

+                    }

+                  REGISTER_ARG (dp->precision_arg_index, TYPE_INT);

+                }

+              else

+                {

+                  size_t precision_length;

+

+                  dp->precision_start = cp - 1;

+                  for (; *cp >= '0' && *cp <= '9'; cp++)

+                    ;

+                  dp->precision_end = cp;

+                  precision_length = dp->precision_end - dp->precision_start;

+                  if (max_precision_length < precision_length)

+                    max_precision_length = precision_length;

+                }

+            }

+

+          {

+            arg_type type;

+

+            /* Parse argument type/size specifiers.  */

+            {

+              int flags = 0;

+

+              for (;;)

+                {

+                  if (*cp == 'h')

+                    {

+                      flags |= (1 << (flags & 1));

+                      cp++;

+                    }

+                  else if (*cp == 'L')

+                    {

+                      flags |= 4;

+                      cp++;

+                    }

+                  else if (*cp == 'l')

+                    {

+                      flags += 8;

+                      cp++;

+                    }

+                  else if (*cp == 'j')

+                    {

+                      if (sizeof (intmax_t) > sizeof (long))