gdb(1), kgdb(1): Makefile framework updates for version 7.6.1
authorJohn Marino <draco@marino.st>
Sat, 5 Oct 2013 17:41:17 +0000 (19:41 +0200)
committerJohn Marino <draco@marino.st>
Sat, 5 Oct 2013 22:53:03 +0000 (00:53 +0200)
The updates for gdb(1) were straight-forwards and mainly consisted of
header updates although the gnu internal library is new, as well as
a new function for libiberty.  The main work was getting kgdb(1) to
work with libgdb.  As is typically, a lot of internal changes occurred
withing gdb that rendered kgdb broken (and unbuildable).  After much
angst, kgdb works with gdb 7.6.1.

35 files changed:
gnu/usr.bin/gdb/Makefile
gnu/usr.bin/gdb/Makefile.inc
gnu/usr.bin/gdb/gdb/Makefile
gnu/usr.bin/gdb/gdb/ada-lex.c
gnu/usr.bin/gdb/gdb/doc/GDBvn.texi
gnu/usr.bin/gdb/gdbtui/Makefile
gnu/usr.bin/gdb/kgdb/Makefile
gnu/usr.bin/gdb/kgdb/kgdb.c
gnu/usr.bin/gdb/kgdb/kgdb.h
gnu/usr.bin/gdb/kgdb/kld.c
gnu/usr.bin/gdb/kgdb/kthr.c
gnu/usr.bin/gdb/kgdb/trgt.c
gnu/usr.bin/gdb/kgdb/trgt_i386.c
gnu/usr.bin/gdb/kgdb/trgt_x86_64.c
gnu/usr.bin/gdb/libbfd/Makefile
gnu/usr.bin/gdb/libbfd/bfdver.h
gnu/usr.bin/gdb/libbfd/config.h
gnu/usr.bin/gdb/libdecnumber/gstdint.h
gnu/usr.bin/gdb/libgdb/Makefile
gnu/usr.bin/gdb/libgdb/Makefile.x86_64
gnu/usr.bin/gdb/libgdb/config.h
gnu/usr.bin/gdb/libgdb/freebsd-uthread.c [deleted file]
gnu/usr.bin/gdb/libgdb/gstdint.h
gnu/usr.bin/gdb/libgdb/jit-reader.h
gnu/usr.bin/gdb/libgnu/Makefile [new file with mode: 0644]
gnu/usr.bin/gdb/libgnu/alloca.h [new file with mode: 0644]
gnu/usr.bin/gdb/libgnu/config.h [new file with mode: 0644]
gnu/usr.bin/gdb/libgnu/configmake.h [new file with mode: 0644]
gnu/usr.bin/gdb/libgnu/fnmatch.h [new file with mode: 0644]
gnu/usr.bin/gdb/libgnu/string.h [new file with mode: 0644]
gnu/usr.bin/gdb/libgnu/wchar.h [new file with mode: 0644]
gnu/usr.bin/gdb/libgnu/wctype.h [new file with mode: 0644]
gnu/usr.bin/gdb/libiberty/Makefile
gnu/usr.bin/gdb/libiberty/config.h
gnu/usr.bin/gdb/libopcodes/config.h

index d644b64..da5c840 100644 (file)
@@ -1,4 +1,4 @@
-SUBDIR=        libbfd libiberty libopcodes libdecnumber libreadline
+SUBDIR=        libbfd libiberty libgnu libopcodes libdecnumber libreadline
 SUBDIR+=       libgdb gdb kgdb gdbtui
 
 .include <bsd.subdir.mk>
index 50c1460..561cf6a 100644 (file)
@@ -6,5 +6,6 @@ GDBLIBS+=       ${.OBJDIR}/../libbfd/libbfd.a
 GDBLIBS+=      ${.OBJDIR}/../libiberty/libiberty.a
 GDBLIBS+=      ${.OBJDIR}/../libdecnumber/libdecnumber.a
 GDBLIBS+=      ${.OBJDIR}/../libgdb/libgdb.a
+GDBLIBS+=      ${.OBJDIR}/../libgnu/libgnu.a
 
 .include "../Makefile.inc"
index e0be1ed..15ae7f3 100644 (file)
@@ -7,14 +7,15 @@ CFLAGS+= -I${BASEDIR}/gdb/common -I${.CURDIR}/../libbfd
 CFLAGS+= -I${.OBJDIR}/../libbfd
 
 DPADD=  ${GDBLIBS}
-DPADD+= ${LIBNCURSES} ${LIBM} ${LIBZ} ${LIBKVM}
+DPADD+= ${LIBNCURSES} ${LIBM} ${LIBZ} ${LIBKVM} ${LIBLZMA}
 LDADD=  -L../libgdb -lgdb
 LDADD+= -L../libreadline -lreadline
 LDADD+= -L../libopcodes -lopcodes
 LDADD+= -L../libbfd -lbfd
 LDADD+= -L../libiberty -liberty
 LDADD+= -L../libdecnumber -ldecnumber
-LDADD+= -lncurses -lm -lz -lkvm
+LDADD+= -L../libgnu -lgnu
+LDADD+= -lncurses -lm -lz -lkvm -llzma
 
 SUBDIR=        doc
 
index 92cd92c..1eaadb6 100644 (file)
 #line 2 "ada-lex.c"
-/* A lexical scanner generated by flex */
 
-/* Scanner skeleton version:
- * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
- */
+#line 4 "ada-lex.c"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
 
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 35
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
 
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
 #include <stdio.h>
-#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
 
+/* end standard C headers. */
 
-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
-#ifdef c_plusplus
-#ifndef __cplusplus
-#define __cplusplus
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+#endif /* ! C99 */
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
 #endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
 #endif
 
+#endif /* ! FLEXINT_H */
 
 #ifdef __cplusplus
 
-#include <stdlib.h>
-
-/* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
-
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
 #else  /* ! __cplusplus */
 
-#if __STDC__
+/* C99 requires __STDC__ to be defined as 1. */
+#if defined (__STDC__)
 
-#define YY_USE_PROTOS
 #define YY_USE_CONST
 
-#endif /* __STDC__ */
+#endif /* defined (__STDC__) */
 #endif /* ! __cplusplus */
 
-#ifdef __TURBOC__
- #pragma warn -rch
- #pragma warn -use
-#include <io.h>
-#include <stdlib.h>
-#define YY_USE_CONST
-#define YY_USE_PROTOS
-#endif
-
 #ifdef YY_USE_CONST
 #define yyconst const
 #else
 #define yyconst
 #endif
 
-
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
-#else
-#define YY_PROTO(proto) ()
-#endif
-
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
-#define BEGIN yy_start = 1 + 2 *
+#define BEGIN (yy_start) = 1 + 2 *
 
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
-#define YY_START ((yy_start - 1) / 2)
+#define YY_START (((yy_start) - 1) / 2)
 #define YYSTATE YY_START
 
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( yyin )
+#define YY_NEW_FILE yyrestart(yyin  )
 
 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
 #define YY_BUF_SIZE 16384
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
 
 extern int yyleng;
+
 extern FILE *yyin, *yyout;
 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
 
-/* The funky do-while in the following #define is used to turn the definition
- * int a single C statement (which needs a semi-colon terminator).  This
- * avoids problems with code like:
- *
- *     if ( condition_holds )
- *             yyless( 5 );
- *     else
- *             do_something_else();
- *
- * Prior to using the do-while the compiler would get upset at the
- * "else" because it interpreted the "if" statement as being all
- * done when it reached the ';' after the yyless() call.
- */
-
-/* Return all but the first 'n' matched characters back to the input stream. */
-
+    #define YY_LESS_LINENO(n)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
        do \
                { \
                /* Undo effects of setting up yytext. */ \
-               *yy_cp = yy_hold_char; \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               *yy_cp = (yy_hold_char); \
                YY_RESTORE_YY_MORE_OFFSET \
-               yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+               (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
                } \
        while ( 0 )
 
-#define unput(c) yyunput( c, yytext_ptr )
-
-/* The following is because we cannot portably get our hands on size_t
- * (without autoconf's help, which isn't available because we want
- * flex-generated scanners to compile on their own).
- */
-typedef unsigned int yy_size_t;
+#define unput(c) yyunput( c, (yytext_ptr)  )
 
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
 
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
        {
        FILE *yy_input_file;
@@ -178,12 +222,16 @@ struct yy_buffer_state
         */
        int yy_at_bol;
 
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
        /* Whether to try to fill the input buffer when we reach the
         * end of it.
         */
        int yy_fill_buffer;
 
        int yy_buffer_status;
+
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
        /* When an EOF's been seen but there's still some text to process
@@ -197,28 +245,38 @@ struct yy_buffer_state
         * just pointing yyin at a new input file.
         */
 #define YY_BUFFER_EOF_PENDING 2
+
        };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
-static YY_BUFFER_STATE yy_current_buffer = 0;
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
  * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
  */
-#define YY_CURRENT_BUFFER yy_current_buffer
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
 
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 
 /* yy_hold_char holds the character lost when yytext is formed. */
 static char yy_hold_char;
-
 static int yy_n_chars;         /* number of characters read into yy_ch_buf */
-
-
 int yyleng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;                /* whether we need to initialize */
+static int yy_init = 0;                /* whether we need to initialize */
 static int yy_start = 0;       /* start state number */
 
 /* Flag which is used to allow yywrap()'s to do buffer switches
@@ -226,92 +284,119 @@ static int yy_start = 0; /* start state number */
  */
 static int yy_did_buffer_switch_on_eof;
 
-void yyrestart YY_PROTO(( FILE *input_file ));
+void yyrestart (FILE *input_file  );
+void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
+void yy_delete_buffer (YY_BUFFER_STATE b  );
+void yy_flush_buffer (YY_BUFFER_STATE b  );
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state (void );
 
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
-void yy_load_buffer_state YY_PROTO(( void ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+static void yyensure_buffer_stack (void );
+static void yy_load_buffer_state (void );
+static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 
-static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
-static void *yyxrealloc YY_PROTO(( void *, yy_size_t ));
-static void yy_flex_free YY_PROTO(( void * ));
+YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
+
+void *yyalloc (yy_size_t  );
+void *yyxrealloc (void *,yy_size_t  );
+void yyfree (void *  );
 
 #define yy_new_buffer yy_create_buffer
 
 #define yy_set_interactive(is_interactive) \
        { \
-       if ( ! yy_current_buffer ) \
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-       yy_current_buffer->yy_is_interactive = is_interactive; \
+       if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }
 
 #define yy_set_bol(at_bol) \
        { \
-       if ( ! yy_current_buffer ) \
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-       yy_current_buffer->yy_at_bol = at_bol; \
+       if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }
 
-#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
 
 typedef unsigned char YY_CHAR;
+
 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+
 typedef int yy_state_type;
+
+extern int yylineno;
+
+int yylineno = 1;
+
 extern char *yytext;
 #define yytext_ptr yytext
 
-static yy_state_type yy_get_previous_state YY_PROTO(( void ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
-static int yy_get_next_buffer YY_PROTO(( void ));
-static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+static yy_state_type yy_get_previous_state (void );
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
+static int yy_get_next_buffer (void );
+static void yy_fatal_error (yyconst char msg[]  );
 
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
  */
 #define YY_DO_BEFORE_ACTION \
-       yytext_ptr = yy_bp; \
-       yyleng = (int) (yy_cp - yy_bp); \
-       yy_hold_char = *yy_cp; \
+       (yytext_ptr) = yy_bp; \
+       yyleng = (size_t) (yy_cp - yy_bp); \
+       (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
-       yy_c_buf_p = yy_cp;
+       (yy_c_buf_p) = yy_cp;
 
-#define YY_NUM_RULES 54
-#define YY_END_OF_BUFFER 55
-static yyconst short int yy_accept[196] =
+#define YY_NUM_RULES 55
+#define YY_END_OF_BUFFER 56
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
+static yyconst flex_int16_t yy_accept[207] =
     {   0,
-        0,    0,    0,    0,   55,   53,    1,    1,   15,   52,
-       42,   53,   44,   45,   42,   43,   42,   42,   42,    4,
-        4,   42,   42,   42,   42,   51,   48,   48,   48,   48,
-       48,   48,   48,   48,   48,   48,   48,   41,    0,   14,
-        0,   52,    0,    0,    0,    0,    0,    0,    0,   36,
-        2,    0,   35,    0,   47,   47,   38,    0,    0,    4,
-        0,    0,   50,   37,   39,    0,   34,   40,    0,    0,
-       48,    0,   48,   48,   48,   48,   48,   16,   21,   48,
-       48,   48,   48,   26,   48,   48,   48,   48,   48,   48,
-        0,   14,    0,   12,   12,    0,   33,    2,    0,   47,
-
-       47,    0,    9,    0,    3,    7,    0,   48,    0,    0,
-        0,   48,   18,   19,   48,   48,   22,   23,   24,   48,
-       48,   28,   48,   48,   48,   48,   30,    0,    0,    0,
-        0,    0,    0,   47,   46,    6,    0,    0,    9,    0,
+        0,    0,    0,    0,   56,   54,    1,    1,   15,   53,
+       43,   54,   45,   46,   43,   44,   43,   43,   43,    4,
+        4,   43,   43,   43,   43,   52,   49,   49,   49,   49,
+       49,   49,   49,   49,   49,   49,   49,   42,    0,   14,
+        0,   53,    0,    0,    0,    0,    0,    0,    0,   37,
+        2,    0,   36,    0,   48,   48,   39,    0,    0,    4,
+        0,    0,   51,   38,   40,    0,   35,   41,    0,    0,
+       49,    0,   49,   49,   49,   49,   49,   16,   22,   49,
+       49,   49,   49,   27,   49,   49,   49,   49,   49,   49,
+        0,   14,    0,   12,   12,   34,    0,    2,    0,   48,
+
+       48,    0,    9,    0,    3,    7,    0,   49,    0,    0,
+        0,   49,   19,   20,   49,   49,   23,   24,   25,   49,
+       49,   29,   49,   49,   49,   49,   31,    0,    0,    0,
+        0,    0,    0,   48,   47,    6,    0,    0,    9,    0,
         3,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,   48,   20,   48,   25,   48,   17,   29,
-       48,   31,    0,   49,    0,    0,    0,    0,   48,    0,
-        0,    0,    0,    0,    0,    0,   32,   48,   48,    0,
-        0,    5,   11,    0,    8,   27,    0,    5,    0,    8,
-       13,    0,   10,   10,    0
+        0,    0,    0,   49,   21,   49,   26,   49,   17,   30,
+       49,   32,    0,   50,    0,    0,    0,    0,   49,    0,
+        0,    0,    0,    0,    0,    0,    0,   33,   49,   49,
+        0,    0,    5,   11,    0,    8,    0,    0,    0,    0,
+        0,    0,   28,   49,    0,    5,    0,    8,    0,    0,
 
+       13,    0,   18,   10,   10,    0
     } ;
 
-static yyconst int yy_ec[256] =
+static yyconst flex_int32_t yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -319,14 +404,14 @@ static yyconst int yy_ec[256] =
         1,    4,    5,    6,    7,    8,    5,    9,   10,   11,
        12,   13,   14,   15,   16,   17,   18,   19,   20,   20,
        20,   20,   20,   20,   20,   20,   20,   21,   22,   23,
-       24,   25,    5,   26,   30,   31,   32,   33,   34,   35,
-       36,   37,   38,   36,   39,   40,   41,   42,   43,   36,
-       36,   44,   45,   46,   47,   36,   48,   49,   36,   36,
-       27,    5,   28,    5,   29,    5,   30,   31,   32,   33,
-
-       34,   35,   36,   37,   38,   36,   39,   40,   41,   42,
-       43,   36,   36,   44,   45,   46,   47,   36,   48,   49,
-       36,   36,   26,   22,   26,    5,    1,    1,    1,    1,
+       24,   25,    5,   26,   27,   28,   29,   30,   31,   32,
+       33,   34,   35,   33,   36,   37,   38,   39,   40,   33,
+       33,   41,   42,   43,   44,   33,   45,   46,   33,   33,
+       47,    5,   48,    5,   49,    5,   50,   51,   29,   52,
+
+       53,   54,   33,   55,   56,   33,   57,   58,   59,   60,
+       61,   33,   33,   62,   63,   64,   65,   33,   66,   67,
+       33,   33,   26,   22,   26,    5,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -343,260 +428,379 @@ static yyconst int yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst int yy_meta[50] =
+static yyconst flex_int32_t yy_meta[68] =
     {   0,
         1,    2,    3,    4,    5,    6,    7,    8,    5,    9,
         5,    5,    5,    5,    5,    5,   10,    5,   11,   11,
-        5,    5,   12,   13,   14,    5,    5,    5,   15,   16,
-       16,   16,   16,   16,   16,   17,   17,   17,   17,   17,
-       17,   17,   17,   17,   17,   17,   17,   17,   17
+        5,    5,   12,   13,   14,    5,   15,   15,   15,   15,
+       15,   15,   16,   16,   16,   16,   16,   16,   16,   16,
+       16,   16,   16,   16,   16,   16,    5,    5,   17,   15,
+       15,   15,   15,   15,   16,   16,   16,   16,   16,   16,
+       16,   16,   16,   16,   16,   16,   16
     } ;
 
-static yyconst short int yy_base[217] =
+static yyconst flex_int16_t yy_base[229] =
     {   0,
-        0,    0,  622,  615,  620,  759,  759,  759,   44,    0,
-      759,   71,  759,  759,  606,  759,  601,  119,  591,  118,
-      124,   30,  590,  588,  588,  759,   53,  152,   22,   97,
-       98,  103,  117,  119,   27,  140,  137,  194,  151,  759,
-      160,    0,  242,  601,  594,  593,  592,  120,  282,  759,
-        0,  330,  759,    0,    0,  560,  759,    0,   40,  329,
-      171,    0,  759,  759,  759,  574,  759,  759,  171,  245,
-      759,  336,  150,  219,  223,  226,  227,  162,  228,  262,
-      263,  310,  266,  265,  313,  268,  312,  330,  320,  334,
-      572,  569,  366,  377,  759,  380,  547,    0,  530,    0,
-
-      501,  169,  363,   46,  365,    0,  503,  386,  402,  417,
-        0,  417,  335,  344,  412,  387,  360,  386,  406,  413,
-      431,  407,  425,  408,  437,  438,  421,  518,    0,  472,
-      497,  475,  474,  759,    0,  456,    0,  246,  458,  284,
-      462,  451,  403,  464,  477,  478,  454,  408,  402,  392,
-      390,  364,  376,  509,  455,  483,  458,  485,  473,  489,
-      491,  492,  367,  759,  387,  516,  366,   48,  535,  326,
-      312,  270,  220,  219,  207,  164,  501,  509,  511,  144,
-      282,  527,   98,  117,  529,  519,   42,  540,  321,  543,
-      562,  403,  548,  551,  759,  580,  590,  606,  611,  627,
-
-      644,  647,  654,  487,  562,  661,  677,  689,  695,  706,
-      708,  724,  563,  565,  731,  742
+        0,    0,  649,  638,  646, 1252, 1252, 1252,   62,    0,
+     1252,  109, 1252, 1252,  623, 1252,  619,  175,  606,  174,
+      180,   48,  604,  592,  590, 1252,  204,   71,  214,  186,
+      235,  244,  304,  256,   39,  368,   40,  430,  179, 1252,
+      195,    0,  602,  595,  592,  585,  574,  497,   72, 1252,
+        0,  273, 1252,    0,   39,    0, 1252,    0,   66,  262,
+       75,    0, 1252, 1252, 1252,  557, 1252, 1252,  284,  300,
+     1252,  322,  329,  349,  358,  377,  339,  396,  412,  563,
+      566,  575,  584,  587,  569,  596,  623,  616,  576,  617,
+      571,  568,  334,  380, 1252,  562,  677,    0,  403,    0,
+
+       40,   89,  642,   71,  163,    0,  401,  672,  401,  723,
+        0,  708,  741,  750,  637,  776,  785,  794,  797,  806,
+      775,  827,  831,  843,  818,  819,  883,  415,    0,  712,
+      399,  885,  352, 1252,    0,  191,    0,  202,  772,  170,
+      243,  334,  222,  244,  247,  259,  766,   47,  209,  216,
+      203,  251,  302,  892,  916,  890,  942,  715,  946,  958,
+      930,  974,  274, 1252,   93,  344,  278,  310,  979,  256,
+      264,  337,  270,  274,  352,  355,  215,  984,  995, 1000,
+      299,  354,  589,  355,  223,  603,  209,  204,  198,  189,
+      174,  101, 1004, 1016,   92,  634,  411,  644,  872, 1021,
+
+      717,  373, 1252,  793,  832, 1252, 1055, 1065, 1081, 1086,
+     1102, 1119, 1136, 1139, 1146,  339,  560, 1153, 1169, 1181,
+     1186, 1197, 1200, 1216,  634,  645, 1223, 1234
     } ;
 
-static yyconst short int yy_def[217] =
+static yyconst flex_int16_t yy_def[229] =
     {   0,
-      195,    1,    1,    1,  195,  195,  195,  195,  196,  197,
-      195,  195,  195,  195,  195,  195,  195,  198,  195,  195,
-      195,  195,  199,  195,  195,  195,  200,  200,   28,   28,
-       28,   28,   28,   28,   28,   28,   28,  195,  196,  195,
-      196,  197,   38,   38,   38,   43,  195,   43,   43,  195,
-      201,  198,  195,  202,  203,  203,  195,  204,  195,  195,
-      195,  205,  195,  195,  195,  206,  195,  195,  195,  195,
-      195,  207,   28,   28,   28,   28,   28,   28,   28,   28,
-       28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
-       49,  208,  195,  195,  195,   43,   49,  201,  209,  203,
-
-      203,  210,  195,  195,  195,  205,  206,  195,  207,  195,
-      211,  212,   28,   28,   28,   28,   28,   28,   28,   28,
-       28,   28,   28,   28,   28,   28,   28,  195,  213,  195,
-      195,   43,  209,  195,  203,  195,  214,  210,  195,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-      195,  195,  215,  212,   28,   28,   28,   28,   28,   28,
-       28,   28,  195,  195,   43,  195,  216,  195,  195,  195,
-      195,  195,  195,  195,  195,  215,   28,   28,   28,   43,
-      195,  195,  195,  216,  195,   28,   43,  195,  195,  195,
-      195,  195,  195,  195,    0,  195,  195,  195,  195,  195,
-
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-      195,  195,  195,  195,  195,  195
+      206,    1,    1,    1,  206,  206,  206,  206,  207,  208,
+      206,  206,  206,  206,  206,  206,  206,  209,  206,  206,
+      206,  206,  210,  206,  206,  206,  211,  211,  211,  211,
+      211,  211,  211,  211,   33,  211,   33,  206,  207,  206,
+      207,  208,  212,   38,   38,  212,  206,  206,  212,  206,
+      213,  209,  206,  214,  215,  215,  206,  216,  206,  206,
+      206,  217,  206,  206,  206,  218,  206,  206,  206,  206,
+      206,  219,  211,  211,  211,  211,  211,  211,  211,  211,
+      211,  211,  211,  211,   36,  211,  211,   36,   33,   36,
+       48,  220,  206,  206,  206,   48,  212,  213,  221,  215,
+
+      215,  222,  206,  206,  206,  217,  218,  206,  219,  206,
+      223,  224,  211,  211,   33,  211,  211,  211,  211,  211,
+       33,  211,  211,  211,   33,   33,  211,  206,  225,  206,
+      206,   97,  221,  206,  215,  206,  226,  222,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  227,  224,  211,   33,  211,   36,  211,  211,
+       36,  211,  206,  206,  212,  206,  228,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  227,  211,  211,  211,
+      212,  206,  206,  206,  228,  206,  206,  206,  206,  206,
+      206,  206,  211,  211,  212,  206,  206,  206,  206,  206,
+
+      206,  206,  206,  206,  206,    0,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206
     } ;
 
-static yyconst short int yy_nxt[809] =
+static yyconst flex_int16_t yy_nxt[1320] =
     {   0,
         6,    7,    8,    7,    6,    9,    6,   10,   11,   12,
        13,   14,   15,   11,   16,   17,   18,   19,   20,   21,
-       22,   11,   23,   24,   25,   26,   11,   11,   27,   28,
-       27,   27,   27,   29,   30,   27,   27,   31,   27,   27,
-       32,   33,   34,   35,   27,   36,   27,   27,   37,   40,
-       63,  191,   73,   64,   69,   69,   70,   73,  103,  103,
-       86,   76,   71,   73,  105,  105,  185,  185,   73,   72,
-       41,   43,   44,   44,   45,   46,   46,   46,   46,   46,
-       47,   46,   46,   46,   46,   46,   46,   46,   46,   46,
-       46,   46,   46,   46,   46,   46,   46,   48,   46,   46,
-
-       49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
-       49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
-       52,   52,   52,  183,   58,   96,   77,   73,   73,   94,
-       58,  189,   78,   73,   59,   53,   60,   60,   73,   79,
-       59,   54,   60,   60,   73,   80,   60,   73,   56,   73,
-       81,   61,   60,   69,   69,   70,   40,   61,   73,   82,
-       73,   71,   84,   83,   85,   92,   62,   73,   72,   87,
-       73,  187,   69,   69,   69,  136,   88,   41,   73,   90,
-       73,   73,   74,   89,  104,  137,   41,   72,  169,  105,
-      105,   73,   73,   75,   43,   44,   44,   44,   43,   43,
-
-       43,   43,   43,   73,   43,   43,   43,   43,   43,   43,
+       22,   11,   23,   24,   25,   26,   27,   28,   28,   28,
+       29,   30,   28,   28,   31,   28,   28,   32,   33,   34,
+       35,   28,   36,   28,   28,   37,   11,   11,   28,   27,
+       28,   28,   29,   30,   28,   31,   28,   28,   32,   33,
+       34,   35,   28,   36,   28,   28,   37,   40,   63,   86,
+       73,   64,   69,   69,   70,  101,  135,   97,   73,   90,
+       71,   94,   73,   73,  103,  103,  172,   72,  104,  105,
+      105,   86,   73,  105,  105,  136,  101,  135,  181,   73,
+
+       90,  201,   93,   73,   73,  137,  169,  172,   41,   43,
+       44,   44,   45,   46,   46,   46,   46,   46,   47,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   49,   46,   46,   48,   48,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   48,   52,   52,   52,  169,
+       58,  141,  141,  168,   40,  168,   58,   69,   69,   70,
+       59,   53,   60,   60,  169,   71,   59,   54,   60,   60,
+
+       92,   55,   72,  169,   61,   69,   69,   70,  136,  169,
+       61,  141,   77,   71,  169,   69,   69,   70,  137,   62,
+       72,  166,   60,   71,   55,   41,   61,  169,   60,  184,
+       72,   74,   61,  175,  142,   77,   69,   69,   70,  169,
+       62,   41,   75,  166,   71,   69,   69,   70,  173,  169,
+       76,   72,  169,   71,   74,  175,  174,   69,   69,   70,
+       72,  141,  141,   75,  169,   71,   78,  142,   58,  173,
+      142,   76,   72,   79,   52,   52,   52,  174,   59,  169,
+       60,   60,  142,   80,  184,   69,   69,   69,   78,  206,
+      176,  141,   61,  188,   79,   54,   84,  187,   85,   55,
+
+       72,   69,   69,   70,   80,   69,   69,   70,   93,   71,
+       60,  176,  190,   71,   61,  188,   72,   84,  187,   85,
+       72,   39,   55,  109,  109,  109,  169,  110,  186,  186,
+       69,   69,   70,  190,   81,  130,  130,  130,   71,  169,
+       69,   69,   70,   82,  111,   72,  195,   83,   71,  102,
+       69,   69,   70,  102,  131,   72,   81,  182,   71,   69,
+       69,   70,  183,  183,   82,   72,  189,   71,   83,   69,
+       69,   70,  183,  183,   72,  116,  134,   71,   69,   69,
+       70,  130,  130,  130,   72,  197,   71,  114,  189,  191,
+      113,  204,  204,   72,   87,  192,  116,   69,   69,   70,
+
+      131,   88,  109,  109,  109,   71,  110,  197,   89,  114,
+      191,  113,   72,   69,   69,   70,  192,   87,  115,  164,
+      163,   71,   88,  111,  202,  108,  202,  134,   72,   89,
+       43,   44,   44,   44,   43,   43,   43,   43,   43,  115,
        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
-       43,   43,   43,   91,   91,   91,   91,   91,   91,   91,
+       43,   43,   43,   43,   43,   43,   91,   91,   91,   91,
+       91,   91,   91,   91,   91,   91,   91,   91,   91,   91,
+       91,   91,   91,   91,   91,   91,   43,   43,   43,   91,
        91,   91,   91,   91,   91,   91,   91,   91,   91,   91,
-       91,   91,   91,   43,   43,   43,   69,   69,   70,   73,
-      142,   93,  136,   73,   71,  114,   73,   73,   73,  142,
-       73,   72,  137,  113,   73,  142,  116,   73,   73,   73,
-      115,   43,   43,   43,   43,   43,   43,   43,   43,   43,
+       91,   91,   91,   91,   91,   91,   91,   43,   43,   43,
+
+       43,   43,   43,   43,   43,   43,   94,   43,   43,   43,
+       43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
+       43,   43,   43,   96,   96,   96,   96,   96,   96,   96,
+       96,   96,   96,   96,   96,   96,   96,   96,   96,   96,
+       96,   96,   96,   43,   43,   43,   96,   96,   96,   96,
+       96,   96,   96,   96,   96,   96,   96,   96,   96,   96,
+       96,   96,   96,   96,   69,   69,   70,   69,   69,   70,
+      106,   93,   71,  128,  106,   71,   69,   69,   70,   72,
+       93,  108,   72,   95,   71,   69,   69,   70,   69,   69,
+       70,   72,  117,   71,   94,   73,   71,   69,   69,   70,
+
+       72,   94,  121,   72,   93,   71,   73,  196,  196,   73,
+      118,   93,   72,   68,  117,   73,   67,  119,   73,  126,
+      120,  198,  198,  121,   69,   69,   70,   65,   73,   57,
+       73,  118,   71,  122,   51,   50,   73,  196,  119,   72,
+      126,  120,   73,   73,  128,  206,  124,   38,  128,   73,
+       73,  198,  196,  196,  122,  167,  125,  127,   38,  167,
+      139,  139,  198,  198,  123,   73,   73,  155,  124,  206,
+       73,   73,  140,   69,   69,   70,   73,  125,  127,  206,
+       73,   71,  196,  206,  206,  123,   93,  206,   72,  155,
+      139,  206,  198,  206,  140,  132,  132,   73,  206,  206,
+
+      206,   73,  206,  132,  132,  132,  132,  132,  132,   69,
+       69,   70,  206,  130,  130,  130,  206,   71,  130,  130,
+      130,  206,  206,  206,   72,  206,  132,  132,  132,  132,
+      132,  142,  131,  206,  206,  143,  142,  131,  142,  206,
+      144,   73,   69,   69,   70,  145,  142,  146,   73,  147,
+       71,   69,   69,   70,  206,  179,  206,   72,  206,   71,
+      148,  149,  150,  151,   73,  206,   72,  206,  152,   73,
+      206,  206,  147,  206,  206,  206,  179,   69,   69,   70,
+      206,  148,  149,  150,  151,   71,   69,   69,   70,  152,
+      139,  139,   72,  170,   71,   69,   69,   70,   69,   69,
+
+       70,   72,  140,   71,  171,  158,   71,   69,   69,   70,
+       72,  205,  205,   72,   73,   71,  170,  156,   73,  206,
+      139,  206,   72,  206,  140,  171,  206,  158,   69,   69,
+       70,  206,   69,   69,   70,   73,   71,  206,  156,   73,
+       71,  205,  157,   72,   69,   69,   70,   72,  161,  162,
+      205,  205,   71,  206,  206,  206,  206,   73,   73,   72,
+      206,   73,   73,  157,  206,  206,  159,  206,  206,  206,
+      161,  162,  206,  199,  199,  199,  206,  206,   73,   73,
+      205,  160,   73,   73,   69,   69,   70,  159,   72,  206,
+      203,  203,   71,   69,   69,   70,  206,  206,  206,   72,
+
+      206,   71,  160,  165,  165,  206,  206,  206,   72,  206,
+      206,  165,  165,  165,  165,  165,  165,   69,   69,   70,
+      178,  206,  206,  206,  206,   71,  206,  206,  206,   73,
+      206,  206,   72,   73,  165,  165,  165,  165,  165,  206,
+      206,  206,  178,   69,   69,   70,  206,   69,   69,   70,
+       73,   71,  206,  206,   73,   71,  180,  206,   72,   69,
+       69,   70,   72,   73,  206,  206,  206,   71,  206,  206,
+       73,  206,  206,  206,   72,   69,   69,   70,  206,  180,
+       69,   69,   70,   71,   73,   69,   69,   70,   71,  206,
+       72,   73,  206,   71,  206,   72,   69,   69,   70,  206,
+
+       72,   69,   69,   70,   71,   69,   69,   70,  206,   71,
+      206,   72,  206,   71,  206,  206,   72,  199,  199,  200,
+       72,  206,  199,  199,  200,   71,  206,  206,  206,  194,
+       71,  206,   72,  206,  206,  206,  193,   72,  206,  203,
+      203,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  194,  206,  206,  206,  206,  206,  193,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   42,  206,  206,   42,  206,  206,  206,   42,
+       42,   42,   56,   56,   56,  206,  206,  206,  206,  206,
+       56,  206,   56,  206,  206,   56,   56,   56,   66,  206,
+
+       66,   66,   66,   73,   73,   73,  206,  206,  206,  206,
+       73,   73,   73,  206,  206,  206,   73,   73,   73,   43,
        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
-       43,   94,   73,   73,  117,   73,   73,  168,   73,  168,
-
-      182,  182,  142,   73,   73,  120,   73,   73,  122,   73,
-      118,   97,   97,   97,   97,   97,   97,   97,   97,   97,
-       97,   97,   97,   97,   97,   97,   97,   97,   97,   97,
-       97,   52,   52,   52,  192,   58,  192,  109,  109,  109,
-       73,  110,   73,   73,  142,   59,  195,   60,   60,  121,
-       73,   73,   54,   73,   73,  119,  123,   60,  111,   56,
-       73,   73,   61,  124,   73,   73,  126,  130,  130,  130,
-      142,   73,  183,  125,   73,   73,   73,  127,  130,  130,
-      130,  139,  139,  141,  141,   73,  131,   69,   69,   70,
-       73,  139,  180,  141,   39,   71,  140,  131,  132,  132,
-
-      169,   73,   72,  109,  109,  109,  175,  110,  169,  132,
-      132,  132,  132,  132,  132,  142,   73,   73,   69,   69,
-       70,  193,  193,  174,  111,  142,   71,   73,   73,  143,
-      142,  156,  142,   72,  144,  142,   73,   73,   73,  145,
-      142,  146,   73,   73,  173,  155,  147,   73,   73,  160,
-      172,   73,  157,   73,   73,   73,  169,  148,  149,  150,
-      151,   73,   73,  159,  158,  152,   73,   73,   73,  169,
-      161,  162,   73,  130,  130,  130,  139,  139,   73,   73,
-      141,  141,  169,  169,  170,   73,  139,  142,   73,  166,
-      141,  140,  131,  165,  165,  171,   73,  102,  134,   73,
-
-      142,  142,  102,   73,  165,  165,  165,  165,  165,  165,
-       69,   69,   70,   73,   73,   73,  177,  164,   71,   73,
-      179,   73,   73,  163,   73,   72,   73,  108,  178,  181,
-       73,   73,   73,   73,  182,  182,   69,   69,   70,   73,
-      135,   73,   73,  159,   71,  188,  188,  190,  190,   73,
-       73,   72,   73,  186,  134,  188,   93,  190,  188,  188,
-       73,  190,  190,  130,  130,  130,  194,  194,  188,  194,
-      194,  190,  106,  128,  128,  167,  194,  106,  128,  194,
-      167,   93,  131,   39,   39,   39,   39,   39,   39,   39,
-       39,   39,   39,   39,   39,   39,   39,   42,  108,  101,
-
-       42,   95,   94,   94,   42,   42,   42,   55,   55,   55,
-       93,   68,   67,   65,   57,   55,   51,   55,   50,  195,
-       55,   55,   55,   66,   38,   66,   66,   66,   73,   73,
-       73,   38,  195,  195,  195,   73,   73,   73,  195,  195,
-      195,   73,   73,   73,   98,   98,  195,   98,   98,   98,
+       43,   43,   43,   43,   43,   43,   98,   98,  206,   98,
        98,   98,   98,   98,   98,   98,   98,   98,   98,   98,
-       98,   99,   99,   99,  100,  195,  195,  195,  100,  100,
-      100,  107,  195,  195,  107,  107,  107,  107,  112,  112,
-      112,  195,  112,  195,  195,  195,  195,  195,  112,  195,
-      195,  112,  112,  112,  129,  195,  195,  195,  195,  129,
-
-      195,  195,  195,  195,  129,  133,  195,  195,  133,  133,
-      133,  133,  138,  195,  195,  138,  138,  195,  195,  195,
-      138,  138,  153,  153,  153,  154,  154,  154,  195,  195,
-      195,  195,  154,  154,  154,  195,  195,  195,  154,  154,
-      154,  176,  195,  195,  176,  176,  176,  176,  184,  195,
-      195,  195,  184,  195,  195,  195,  184,  184,    5,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-
-      195,  195,  195,  195,  195,  195,  195,  195
+       98,   98,   98,   99,   99,   99,  100,  206,  206,  206,
+      100,  100,  100,  107,  206,  206,  107,  107,  107,  107,
+      112,  112,  112,  206,  112,  206,  206,  206,  206,  206,
+      112,  206,  206,  112,  112,  112,  129,  206,  206,  206,
+      206,  129,  206,  206,  206,  129,  133,  206,  206,  133,
+
+      133,  133,  133,  138,  206,  206,  138,  138,  206,  206,
+      206,  138,  206,  138,  153,  153,  153,  154,  154,  154,
+      206,  206,  206,  206,  154,  154,  154,  206,  206,  206,
+      154,  154,  154,  177,  206,  206,  177,  177,  177,  177,
+      185,  206,  206,  206,  185,  206,  206,  206,  185,  206,
+      185,    5,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206
     } ;
 
-static yyconst short int yy_chk[809] =
+static yyconst flex_int16_t yy_chk[1320] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    9,
-       22,  187,   29,   22,   27,   27,   27,   35,   59,   59,
-       35,   29,   27,   29,  104,  104,  168,  168,   35,   27,
-        9,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    9,   22,   35,
+       37,   22,   28,   28,   28,   55,  101,   49,   35,   37,
+       28,   49,   35,   37,   59,   59,  148,   28,   61,  104,
+      104,   35,   37,   61,   61,  102,   55,  101,  165,   35,
+
+       37,  195,  165,   35,   37,  102,  192,  148,    9,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
-
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
-       18,   18,   18,  184,   20,   48,   30,   30,   31,   48,
-       21,  183,   31,   32,   20,   18,   20,   20,   30,   31,
-       21,   18,   21,   21,   32,   32,   20,   33,   18,   34,
-       33,   20,   21,   28,   28,   28,   39,   21,   33,   33,
-       34,   28,   34,   33,   34,   41,   20,   37,   28,   36,
-       36,  180,   69,   69,   69,  102,   36,   39,   37,   37,
-       73,   36,   28,   36,   61,  102,   41,   69,  176,   61,
-       61,   73,   78,   28,   38,   38,   38,   38,   38,   38,
-
-       38,   38,   38,   78,   38,   38,   38,   38,   38,   38,
+       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   18,   18,   18,  191,
+       20,  105,  105,  140,   39,  140,   21,   30,   30,   30,
+       20,   18,   20,   20,  190,   30,   21,   18,   21,   21,
+
+       41,   18,   30,  189,   20,   27,   27,   27,  138,  188,
+       21,  105,   30,   27,  187,   29,   29,   29,  138,   20,
+       27,  136,   20,   29,   18,   39,   20,  143,   21,  185,
+       29,   27,   21,  151,  143,   30,   31,   31,   31,  177,
+       20,   41,   27,  136,   31,   32,   32,   32,  149,  144,
+       29,   31,  145,   32,   27,  151,  150,   34,   34,   34,
+       32,  141,  141,   27,  146,   34,   31,  144,   60,  149,
+      145,   29,   34,   31,   52,   52,   52,  150,   60,  174,
+       60,   60,  146,   32,  167,   69,   69,   69,   31,   52,
+      152,  141,   60,  171,   31,   52,   34,  170,   34,   52,
+
+       69,   70,   70,   70,   32,   33,   33,   33,  181,   70,
+       60,  152,  173,   33,   60,  171,   70,   34,  170,   34,
+       33,  163,   52,   72,   72,   72,  153,   72,  168,  168,
+       73,   73,   73,  173,   33,   93,   93,   93,   73,  142,
+       77,   77,   77,   33,   72,   73,  181,   33,   77,  216,
+       74,   74,   74,  216,   93,   77,   33,  166,   74,   75,
+       75,   75,  166,  166,   33,   74,  172,   75,   33,   36,
+       36,   36,  182,  182,   75,   77,  133,   36,   76,   76,
+       76,   94,   94,   94,   36,  184,   76,   75,  172,  175,
+       74,  202,  202,   76,   36,  176,   77,   78,   78,   78,
+
+       94,   36,  109,  109,  109,   78,  109,  184,   36,   75,
+      175,   74,   78,   79,   79,   79,  176,   36,   76,  131,
+      128,   79,   36,  109,  197,  107,  197,   99,   79,   36,
+       38,   38,   38,   38,   38,   38,   38,   38,   38,   76,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-       38,   38,   38,   43,   43,   43,   70,   70,   70,   74,
-      175,   43,  138,   75,   70,   75,   76,   77,   79,  174,
-       74,   70,  138,   74,   75,  173,   77,   76,   77,   79,
-       76,   43,   43,   43,   43,   43,   43,   43,   43,   43,
-       43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
-       43,   49,   80,   81,   80,   84,   83,  140,   86,  140,
-
-      181,  181,  172,   80,   81,   83,   84,   83,   86,   86,
-       81,   49,   49,   49,   49,   49,   49,   49,   49,   49,
-       49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
-       49,   52,   52,   52,  189,   60,  189,   72,   72,   72,
-       82,   72,   87,   85,  171,   60,   52,   60,   60,   85,
-       89,   82,   52,   87,   85,   82,   87,   60,   72,   52,
-       88,   89,   60,   88,   90,  113,   89,   93,   93,   93,
-      170,   88,  167,   88,  114,   90,  113,   90,   94,   94,
-       94,  103,  103,  105,  105,  114,   93,  108,  108,  108,
-      117,  103,  165,  105,  163,  108,  103,   94,   96,   96,
-
-      153,  117,  108,  109,  109,  109,  152,  109,  143,   96,
-       96,   96,   96,   96,   96,  143,  118,  116,  112,  112,
-      112,  192,  192,  151,  109,  110,  112,  118,  116,  110,
-      110,  116,  110,  112,  110,  150,  119,  122,  124,  110,
-      110,  110,  115,  120,  149,  115,  110,  119,  122,  124,
-      148,  127,  120,  115,  120,  123,  142,  110,  110,  110,
-      110,  121,  127,  123,  121,  110,  123,  125,  126,  144,
-      125,  126,  121,  130,  130,  130,  139,  139,  125,  126,
-      141,  141,  145,  146,  147,  155,  139,  144,  157,  136,
-      141,  139,  130,  132,  132,  147,  155,  204,  133,  157,
-
-      145,  146,  204,  159,  132,  132,  132,  132,  132,  132,
-      154,  154,  154,  156,  159,  158,  156,  131,  154,  160,
-      161,  161,  162,  128,  156,  154,  158,  107,  158,  166,
-      160,  177,  161,  162,  166,  166,  169,  169,  169,  178,
-      101,  179,  177,  179,  169,  182,  182,  185,  185,  186,
-      178,  169,  179,  178,   99,  182,   97,  185,  188,  188,
-      186,  190,  190,  191,  191,  191,  193,  193,  188,  194,
-      194,  190,  205,  213,   92,  214,  193,  205,  213,  194,
-      214,   91,  191,  196,  196,  196,  196,  196,  196,  196,
-      196,  196,  196,  196,  196,  196,  196,  197,   66,   56,
-
-      197,   47,   46,   45,  197,  197,  197,  198,  198,  198,
-       44,   25,   24,   23,   19,  198,   17,  198,   15,    5,
-      198,  198,  198,  199,    4,  199,  199,  199,  200,  200,
-      200,    3,    0,    0,    0,  200,  200,  200,    0,    0,
-        0,  200,  200,  200,  201,  201,    0,  201,  201,  201,
-      201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
-      201,  202,  202,  202,  203,    0,    0,    0,  203,  203,
-      203,  206,    0,    0,  206,  206,  206,  206,  207,  207,
-      207,    0,  207,    0,    0,    0,    0,    0,  207,    0,
-        0,  207,  207,  207,  208,    0,    0,    0,    0,  208,
-
-        0,    0,    0,    0,  208,  209,    0,    0,  209,  209,
-      209,  209,  210,    0,    0,  210,  210,    0,    0,    0,
-      210,  210,  211,  211,  211,  212,  212,  212,    0,    0,
-        0,    0,  212,  212,  212,    0,    0,    0,  212,  212,
-      212,  215,    0,    0,  215,  215,  215,  215,  216,    0,
-        0,    0,  216,    0,    0,    0,  216,  216,  195,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-      195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
-
-      195,  195,  195,  195,  195,  195,  195,  195
+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
+       38,   38,   38,   38,   38,   38,   38,   48,   48,   48,
+
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   80,   80,   80,   81,   81,   81,
+      217,   96,   80,   92,  217,   81,   82,   82,   82,   80,
+       91,   66,   81,   47,   82,   83,   83,   83,   84,   84,
+       84,   82,   80,   83,   46,   85,   84,   86,   86,   86,
+
+       83,   45,   85,   84,   44,   86,   89,  183,  183,   85,
+       81,   43,   86,   25,   80,   89,   24,   82,   85,   89,
+       83,  186,  186,   85,   87,   87,   87,   23,   89,   19,
+       85,   81,   87,   86,   17,   15,   89,  183,   82,   87,
+       89,   83,   88,   90,  225,    5,   88,    4,  225,   88,
+       90,  186,  196,  196,   86,  226,   88,   90,    3,  226,
+      103,  103,  198,  198,   87,   88,   90,  115,   88,    0,
+       88,   90,  103,  108,  108,  108,  115,   88,   90,    0,
+      115,  108,  196,    0,    0,   87,   97,    0,  108,  115,
+      103,    0,  198,    0,  103,   97,   97,  115,    0,    0,
+
+        0,  115,    0,   97,   97,   97,   97,   97,   97,  112,
+      112,  112,    0,  130,  130,  130,    0,  112,  201,  201,
+      201,    0,    0,    0,  112,    0,   97,   97,   97,   97,
+       97,  110,  130,    0,    0,  110,  110,  201,  110,    0,
+      110,  158,  113,  113,  113,  110,  110,  110,  158,  110,
+      113,  114,  114,  114,    0,  158,    0,  113,    0,  114,
+      110,  110,  110,  110,  158,    0,  114,    0,  110,  158,
+        0,    0,  110,    0,    0,    0,  158,  116,  116,  116,
+        0,  110,  110,  110,  110,  116,  117,  117,  117,  110,
+      139,  139,  116,  147,  117,  118,  118,  118,  119,  119,
+
+      119,  117,  139,  118,  147,  121,  119,  120,  120,  120,
+      118,  204,  204,  119,  121,  120,  147,  116,  121,    0,
+      139,    0,  120,    0,  139,  147,    0,  121,  122,  122,
+      122,    0,  123,  123,  123,  121,  122,    0,  116,  121,
+      123,  204,  120,  122,  124,  124,  124,  123,  125,  126,
+      205,  205,  124,    0,    0,    0,    0,  125,  126,  124,
+        0,  125,  126,  120,    0,    0,  123,    0,    0,    0,
+      125,  126,    0,  199,  199,  199,    0,    0,  125,  126,
+      205,  124,  125,  126,  127,  127,  127,  123,  199,    0,
+      199,  199,  127,  154,  154,  154,    0,    0,    0,  127,
+
+        0,  154,  124,  132,  132,    0,    0,    0,  154,    0,
+        0,  132,  132,  132,  132,  132,  132,  155,  155,  155,
+      156,    0,    0,    0,    0,  155,    0,    0,    0,  156,
+        0,    0,  155,  156,  132,  132,  132,  132,  132,    0,
+        0,    0,  156,  157,  157,  157,    0,  159,  159,  159,
+      156,  157,    0,    0,  156,  159,  161,    0,  157,  160,
+      160,  160,  159,  161,    0,    0,    0,  160,    0,    0,
+      161,    0,    0,    0,  160,  162,  162,  162,    0,  161,
+      169,  169,  169,  162,  161,  178,  178,  178,  169,    0,
+      162,  161,    0,  178,    0,  169,  179,  179,  179,    0,
+
+      178,  180,  180,  180,  179,  193,  193,  193,    0,  180,
+        0,  179,    0,  193,    0,    0,  180,  194,  194,  194,
+      193,    0,  200,  200,  200,  194,    0,    0,    0,  180,
+      200,    0,  194,    0,    0,    0,  179,  200,    0,  200,
+      200,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,  180,    0,    0,    0,    0,    0,  179,  207,  207,
+      207,  207,  207,  207,  207,  207,  207,  207,  207,  207,
+      207,  207,  208,    0,    0,  208,    0,    0,    0,  208,
+      208,  208,  209,  209,  209,    0,    0,    0,    0,    0,
+      209,    0,  209,    0,    0,  209,  209,  209,  210,    0,
+
+      210,  210,  210,  211,  211,  211,    0,    0,    0,    0,
+      211,  211,  211,    0,    0,    0,  211,  211,  211,  212,
+      212,  212,  212,  212,  212,  212,  212,  212,  212,  212,
+      212,  212,  212,  212,  212,  212,  213,  213,    0,  213,
+      213,  213,  213,  213,  213,  213,  213,  213,  213,  213,
+      213,  213,  213,  214,  214,  214,  215,    0,    0,    0,
+      215,  215,  215,  218,    0,    0,  218,  218,  218,  218,
+      219,  219,  219,    0,  219,    0,    0,    0,    0,    0,
+      219,    0,    0,  219,  219,  219,  220,    0,    0,    0,
+        0,  220,    0,    0,    0,  220,  221,    0,    0,  221,
+
+      221,  221,  221,  222,    0,    0,  222,  222,    0,    0,
+        0,  222,    0,  222,  223,  223,  223,  224,  224,  224,
+        0,    0,    0,    0,  224,  224,  224,    0,    0,    0,
+      224,  224,  224,  227,    0,    0,  227,  227,  227,  227,
+      228,    0,    0,    0,  228,    0,    0,    0,  228,    0,
+      228,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+
+      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
+      206,  206,  206,  206,  206,  206,  206,  206,  206
     } ;
 
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
 
+extern int yy_flex_debug;
+int yy_flex_debug = 0;
+
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
  */
@@ -606,10 +810,8 @@ static char *yy_last_accepting_cpos;
 #define YY_RESTORE_YY_MORE_OFFSET
 char *yytext;
 #line 1 "ada-lex.l"
-#define INITIAL 0
 /* FLEX lexer for Ada expressions, for GDB.
-   Copyright (C) 1994, 1997-1998, 2000-2003, 2007-2012 Free Software
-   Foundation, Inc.
+   Copyright (C) 1994-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -631,7 +833,7 @@ char *yytext;
 /* the global pointer lexptr.  It returns a syntactic category for */
 /* each successive token and places a semantic value into yylval */
 /* (ada-lval), defined by the parser.   */
-#line 44 "ada-lex.l"
+#line 43 "ada-lex.l"
 
 #define NUMERAL_WIDTH 256
 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
@@ -645,6 +847,7 @@ static int processReal (const char *);
 static struct stoken processId (const char *, int);
 static int processAttribute (const char *);
 static int find_dot_all (const char *);
+static void rewind_to_char (int);
 
 #undef YY_DECL
 #define YY_DECL static int yylex ( void )
@@ -666,9 +869,54 @@ static int find_dot_all (const char *);
 
 static int find_dot_all (const char *);
 
+
+#line 874 "ada-lex.c"
+
+#define INITIAL 0
 #define BEFORE_QUAL_QUOTE 1
 
-#line 672 "ada-lex.c"
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+static int yy_init_globals (void );
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy (void );
+
+int yyget_debug (void );
+
+void yyset_debug (int debug_flag  );
+
+YY_EXTRA_TYPE yyget_extra (void );
+
+void yyset_extra (YY_EXTRA_TYPE user_defined  );
+
+FILE *yyget_in (void );
+
+void yyset_in  (FILE * in_str  );
+
+FILE *yyget_out (void );
+
+void yyset_out  (FILE * out_str  );
+
+int yyget_leng (void );
+
+char *yyget_text (void );
+
+int yyget_lineno (void );
+
+void yyset_lineno (int line_number  );
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -676,65 +924,30 @@ static int find_dot_all (const char *);
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
-extern "C" int yywrap YY_PROTO(( void ));
+extern "C" int yywrap (void );
 #else
-extern int yywrap YY_PROTO(( void ));
+extern int yywrap (void );
 #endif
 #endif
 
-#ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO(( int c, char *buf_ptr ));
-#endif
-
+    static void yyunput (int c,char *buf_ptr  );
+    
 #ifndef yytext_ptr
-static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+static void yy_flex_strncpy (char *,yyconst char *,int );
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+static int yy_flex_strlen (yyconst char * );
 #endif
 
 #ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput YY_PROTO(( void ));
-#else
-static int input YY_PROTO(( void ));
-#endif
-#endif
-
-#if YY_STACK_USED
-static int yy_start_stack_ptr = 0;
-static int yy_start_stack_depth = 0;
-static int *yy_start_stack = 0;
-#ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO(( int new_state ));
-#endif
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO(( void ));
-#endif
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state YY_PROTO(( void ));
-#endif
 
+#ifdef __cplusplus
+static int yyinput (void );
 #else
-#define YY_NO_PUSH_STATE 1
-#define YY_NO_POP_STATE 1
-#define YY_NO_TOP_STATE 1
+static int input (void );
 #endif
 
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
-#else
-#if __STDC__
-#ifndef __cplusplus
-#include <stdlib.h>
-#endif
-#else
-/* Just try to get by without declaring the routines.  This will fail
- * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
- * or sizeof(void*) != sizeof(int).
- */
-#endif
 #endif
 
 /* Amount of stuff to slurp up with each read. */
@@ -743,12 +956,11 @@ YY_MALLOC_DECL
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
-
 #ifndef ECHO
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
@@ -756,9 +968,10 @@ YY_MALLOC_DECL
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
-       if ( yy_current_buffer->yy_is_interactive ) \
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
                { \
-               int c = '*', n; \
+               int c = '*'; \
+               unsigned n; \
                for ( n = 0; n < max_size && \
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
                        buf[n] = (char) c; \
@@ -768,9 +981,22 @@ YY_MALLOC_DECL
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
                result = n; \
                } \
-       else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
-                 && ferror( yyin ) ) \
-               YY_FATAL_ERROR( "input in flex scanner failed" );
+       else \
+               { \
+               errno=0; \
+               while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
+                       { \
+                       if( errno != EINTR) \
+                               { \
+                               YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                               break; \
+                               } \
+                       errno=0; \
+                       clearerr(yyin); \
+                       } \
+               }\
+\
+
 #endif
 
 /* No semi-colon after return; correct usage is to write "yyterminate();" -
@@ -791,12 +1017,18 @@ YY_MALLOC_DECL
 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 #endif
 
+/* end tables serialization structures and prototypes */
+
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
 #ifndef YY_DECL
-#define YY_DECL int yylex YY_PROTO(( void ))
-#endif
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (void);
+
+#define YY_DECL int yylex (void)
+#endif /* !YY_DECL */
 
 /* Code executed at the beginning of each rule, after yytext and yyleng
  * have been set up.
@@ -813,27 +1045,29 @@ YY_MALLOC_DECL
 #define YY_RULE_SETUP \
        YY_USER_ACTION
 
+/** The main scanner function which does all the work.
+ */
 YY_DECL
-       {
+{
        register yy_state_type yy_current_state;
-       register char *yy_cp = NULL, *yy_bp = NULL;
+       register char *yy_cp, *yy_bp;
        register int yy_act;
-
+    
 #line 84 "ada-lex.l"
 
 
-#line 826 "ada-lex.c"
+#line 1060 "ada-lex.c"
 
-       if ( yy_init )
+       if ( !(yy_init) )
                {
-               yy_init = 0;
+               (yy_init) = 1;
 
 #ifdef YY_USER_INIT
                YY_USER_INIT;
 #endif
 
-               if ( ! yy_start )
-                       yy_start = 1;   /* first start state */
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */
 
                if ( ! yyin )
                        yyin = stdin;
@@ -841,71 +1075,72 @@ YY_DECL
                if ( ! yyout )
                        yyout = stdout;
 
-               if ( ! yy_current_buffer )
-                       yy_current_buffer =
-                               yy_create_buffer( yyin, YY_BUF_SIZE );
+               if ( ! YY_CURRENT_BUFFER ) {
+                       yyensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               yy_create_buffer(yyin,YY_BUF_SIZE );
+               }
 
-               yy_load_buffer_state();
+               yy_load_buffer_state( );
                }
 
        while ( 1 )             /* loops until end-of-file is reached */
                {
-               yy_cp = yy_c_buf_p;
+               yy_cp = (yy_c_buf_p);
 
                /* Support of yytext. */
-               *yy_cp = yy_hold_char;
+               *yy_cp = (yy_hold_char);
 
                /* yy_bp points to the position in yy_ch_buf of the start of
                 * the current run.
                 */
                yy_bp = yy_cp;
 
-               yy_current_state = yy_start;
+               yy_current_state = (yy_start);
 yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                        if ( yy_accept[yy_current_state] )
                                {
-                               yy_last_accepting_state = yy_current_state;
-                               yy_last_accepting_cpos = yy_cp;
+                               (yy_last_accepting_state) = yy_current_state;
+                               (yy_last_accepting_cpos) = yy_cp;
                                }
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
                                yy_current_state = (int) yy_def[yy_current_state];
-                               if ( yy_current_state >= 196 )
+                               if ( yy_current_state >= 207 )
                                        yy_c = yy_meta[(unsigned int) yy_c];
                                }
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                        ++yy_cp;
                        }
-               while ( yy_base[yy_current_state] != 759 );
+               while ( yy_base[yy_current_state] != 1252 );
 
 yy_find_action:
                yy_act = yy_accept[yy_current_state];
                if ( yy_act == 0 )
                        { /* have to back up */
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
                        yy_act = yy_accept[yy_current_state];
                        }
 
                YY_DO_BEFORE_ACTION;
 
-
 do_action:     /* This label is used only to access EOF actions. */
 
-
                switch ( yy_act )
        { /* beginning of action switch */
                        case 0: /* must back up */
                        /* undo the effects of YY_DO_BEFORE_ACTION */
-                       *yy_cp = yy_hold_char;
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
+                       *yy_cp = (yy_hold_char);
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
                        goto yy_find_action;
 
 case 1:
+/* rule 1 can match eol */
 YY_RULE_SETUP
 #line 86 "ada-lex.l"
 { }
@@ -1026,88 +1261,93 @@ case 16:
 YY_RULE_SETUP
 #line 160 "ada-lex.l"
 {
-                 while (*lexptr != 'i' && *lexptr != 'I')
-                   lexptr -= 1;
-                 yyrestart(NULL);
+                  rewind_to_char ('i');
                  return 0;
                }
        YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 167 "ada-lex.l"
+#line 165 "ada-lex.l"
 {
-                  /* This keyword signals the end of the expression and
-                     will be processed separately.  */
-                 while (*lexptr != 't' && *lexptr != 'T')
-                   lexptr--;
-                 yyrestart(NULL);
+                  rewind_to_char ('t');
                  return 0;
                }
        YY_BREAK
-/* ADA KEYWORDS */
 case 18:
+/* rule 18 can match eol */
 YY_RULE_SETUP
-#line 178 "ada-lex.l"
-{ return ABS; }
+#line 170 "ada-lex.l"
+{
+                  /* This keyword signals the end of the expression and
+                     will be processed separately.  */
+                  rewind_to_char ('t');
+                 return 0;
+               }
        YY_BREAK
+/* ADA KEYWORDS */
 case 19:
 YY_RULE_SETUP
 #line 179 "ada-lex.l"
-{ return _AND_; }
+{ return ABS; }
        YY_BREAK
 case 20:
 YY_RULE_SETUP
 #line 180 "ada-lex.l"
-{ return ELSE; }
+{ return _AND_; }
        YY_BREAK
 case 21:
 YY_RULE_SETUP
 #line 181 "ada-lex.l"
-{ return IN; }
+{ return ELSE; }
        YY_BREAK
 case 22:
 YY_RULE_SETUP
 #line 182 "ada-lex.l"
-{ return MOD; }
+{ return IN; }
        YY_BREAK
 case 23:
 YY_RULE_SETUP
 #line 183 "ada-lex.l"
-{ return NEW; }
+{ return MOD; }
        YY_BREAK
 case 24:
 YY_RULE_SETUP
 #line 184 "ada-lex.l"
-{ return NOT; }
+{ return NEW; }
        YY_BREAK
 case 25:
 YY_RULE_SETUP
 #line 185 "ada-lex.l"
-{ return NULL_PTR; }
+{ return NOT; }
        YY_BREAK
 case 26:
 YY_RULE_SETUP
 #line 186 "ada-lex.l"
-{ return OR; }
+{ return NULL_PTR; }
        YY_BREAK
 case 27:
 YY_RULE_SETUP
 #line 187 "ada-lex.l"
-{ return OTHERS; }
+{ return OR; }
        YY_BREAK
 case 28:
 YY_RULE_SETUP
 #line 188 "ada-lex.l"
-{ return REM; }
+{ return OTHERS; }
        YY_BREAK
 case 29:
 YY_RULE_SETUP
 #line 189 "ada-lex.l"
-{ return THEN; }
+{ return REM; }
        YY_BREAK
 case 30:
 YY_RULE_SETUP
 #line 190 "ada-lex.l"
+{ return THEN; }
+       YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 191 "ada-lex.l"
 { return XOR; }
        YY_BREAK
 /* BOOLEAN "KEYWORDS" */
@@ -1115,93 +1355,92 @@ YY_RULE_SETUP
     However, the boolean type is no longer represented as an enum, so True
     and False are no longer defined in symbol tables.  We compromise by
     making them keywords (when bare). */
-case 31:
+case 32:
 YY_RULE_SETUP
-#line 199 "ada-lex.l"
+#line 200 "ada-lex.l"
 { return TRUEKEYWORD; }
        YY_BREAK
-case 32:
+case 33:
 YY_RULE_SETUP
-#line 200 "ada-lex.l"
+#line 201 "ada-lex.l"
 { return FALSEKEYWORD; }
        YY_BREAK
 /* ATTRIBUTES */
-case 33:
+case 34:
+/* rule 34 can match eol */
 YY_RULE_SETUP
-#line 204 "ada-lex.l"
+#line 205 "ada-lex.l"
 { return processAttribute (yytext+1); }
        YY_BREAK
 /* PUNCTUATION */
-case 34:
-YY_RULE_SETUP
-#line 208 "ada-lex.l"
-{ return ARROW; }
-       YY_BREAK
 case 35:
 YY_RULE_SETUP
 #line 209 "ada-lex.l"
-{ return DOTDOT; }
+{ return ARROW; }
        YY_BREAK
 case 36:
 YY_RULE_SETUP
 #line 210 "ada-lex.l"
-{ return STARSTAR; }
+{ return DOTDOT; }
        YY_BREAK
 case 37:
 YY_RULE_SETUP
 #line 211 "ada-lex.l"
-{ return ASSIGN; }
+{ return STARSTAR; }
        YY_BREAK
 case 38:
 YY_RULE_SETUP
 #line 212 "ada-lex.l"
-{ return NOTEQUAL; }
+{ return ASSIGN; }
        YY_BREAK
 case 39:
 YY_RULE_SETUP
 #line 213 "ada-lex.l"
-{ return LEQ; }
+{ return NOTEQUAL; }
        YY_BREAK
 case 40:
 YY_RULE_SETUP
 #line 214 "ada-lex.l"
-{ return GEQ; }
+{ return LEQ; }
        YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 216 "ada-lex.l"
-{ BEGIN INITIAL; return '\''; }
+#line 215 "ada-lex.l"
+{ return GEQ; }
        YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 218 "ada-lex.l"
-{ return yytext[0]; }
+#line 217 "ada-lex.l"
+{ BEGIN INITIAL; return '\''; }
        YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 220 "ada-lex.l"
+#line 219 "ada-lex.l"
+{ return yytext[0]; }
+       YY_BREAK
+case 44:
+YY_RULE_SETUP
+#line 221 "ada-lex.l"
 { if (paren_depth == 0 && comma_terminates)
                    {
-                     lexptr -= 1;
-                     yyrestart(NULL);
+                     rewind_to_char (',');
                      return 0;
                    }
                  else
                    return ',';
                }
        YY_BREAK
-case 44:
+case 45:
 YY_RULE_SETUP
 #line 230 "ada-lex.l"
 { paren_depth += 1; return '('; }
        YY_BREAK
-case 45:
+case 46:
 YY_RULE_SETUP
 #line 231 "ada-lex.l"
 { if (paren_depth == 0)
                    {
-                     lexptr -= 1;
-                     yyrestart(NULL);
+                     rewind_to_char (')');
                      return 0;
                    }
                  else
@@ -1211,22 +1450,25 @@ YY_RULE_SETUP
                    }
                }
        YY_BREAK
-case 46:
+case 47:
+/* rule 47 can match eol */
 YY_RULE_SETUP
-#line 244 "ada-lex.l"
+#line 243 "ada-lex.l"
 { return DOT_ALL; }
        YY_BREAK
-case 47:
+case 48:
+/* rule 48 can match eol */
 YY_RULE_SETUP
-#line 246 "ada-lex.l"
+#line 245 "ada-lex.l"
 {
                  yylval.sval = processId (yytext+1, yyleng-1);
                  return DOT_ID;
                }
        YY_BREAK
-case 48:
+case 49:
+/* rule 49 can match eol */
 YY_RULE_SETUP
-#line 251 "ada-lex.l"
+#line 250 "ada-lex.l"
 {
                   int all_posn = find_dot_all (yytext);
 
@@ -1242,29 +1484,30 @@ YY_RULE_SETUP
                }
        YY_BREAK
 /* GDB EXPRESSION CONSTRUCTS  */
-case 49:
+case 50:
+/* rule 50 can match eol */
 YY_RULE_SETUP
-#line 268 "ada-lex.l"
+#line 267 "ada-lex.l"
 {
                   yyless (yyleng - 2);
                  yylval.sval = processId (yytext, yyleng);
                  return NAME;
                }
        YY_BREAK
-case 50:
+case 51:
 YY_RULE_SETUP
-#line 274 "ada-lex.l"
+#line 273 "ada-lex.l"
 { return COLONCOLON; }
        YY_BREAK
-case 51:
+case 52:
 YY_RULE_SETUP
-#line 276 "ada-lex.l"
+#line 275 "ada-lex.l"
 { return yytext[0]; }
        YY_BREAK
 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
-case 52:
+case 53:
 YY_RULE_SETUP
-#line 280 "ada-lex.l"
+#line 279 "ada-lex.l"
 {
                  yylval.sval.ptr = yytext;
                  yylval.sval.length = yyleng;
@@ -1272,17 +1515,17 @@ YY_RULE_SETUP
                }
        YY_BREAK
 /* CATCH-ALL ERROR CASE */
-case 53:
+case 54:
 YY_RULE_SETUP
-#line 288 "ada-lex.l"
+#line 287 "ada-lex.l"
 { error (_("Invalid character '%s' in expression."), yytext); }
        YY_BREAK
-case 54:
+case 55:
 YY_RULE_SETUP
-#line 289 "ada-lex.l"
+#line 288 "ada-lex.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
        YY_BREAK
-#line 1286 "ada-lex.c"
+#line 1529 "ada-lex.c"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
        yyterminate();
@@ -1290,26 +1533,26 @@ case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
        case YY_END_OF_BUFFER:
                {
                /* Amount of text matched not including the EOB char. */
-               int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+               int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 
                /* Undo the effects of YY_DO_BEFORE_ACTION. */
-               *yy_cp = yy_hold_char;
+               *yy_cp = (yy_hold_char);
                YY_RESTORE_YY_MORE_OFFSET
 
-               if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+               if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
                        {
                        /* We're scanning a new file or input source.  It's
                         * possible that this happened because the user
                         * just pointed yyin at a new source and called
                         * yylex().  If so, then we have to assure
-                        * consistency between yy_current_buffer and our
+                        * consistency between YY_CURRENT_BUFFER and our
                         * globals.  Here is the right place to do so, because
                         * this is the first action (other than possibly a
                         * back-up) that will match for the new input source.
                         */
-                       yy_n_chars = yy_current_buffer->yy_n_chars;
-                       yy_current_buffer->yy_input_file = yyin;
-                       yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+                       YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
                        }
 
                /* Note that here we test for yy_c_buf_p "<=" to the position
@@ -1319,13 +1562,13 @@ case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
                 * end-of-buffer state).  Contrast this with the test
                 * in input().
                 */
-               if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+               if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        { /* This was really a NUL. */
                        yy_state_type yy_next_state;
 
-                       yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+                       (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 
-                       yy_current_state = yy_get_previous_state();
+                       yy_current_state = yy_get_previous_state(  );
 
                        /* Okay, we're now positioned to make the NUL
                         * transition.  We couldn't have
@@ -1338,30 +1581,30 @@ case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
 
                        yy_next_state = yy_try_NUL_trans( yy_current_state );
 
-                       yy_bp = yytext_ptr + YY_MORE_ADJ;
+                       yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
                        if ( yy_next_state )
                                {
                                /* Consume the NUL. */
-                               yy_cp = ++yy_c_buf_p;
+                               yy_cp = ++(yy_c_buf_p);
                                yy_current_state = yy_next_state;
                                goto yy_match;
                                }
 
                        else
                                {
-                               yy_cp = yy_c_buf_p;
+                               yy_cp = (yy_c_buf_p);
                                goto yy_find_action;
                                }
                        }
 
-               else switch ( yy_get_next_buffer() )
+               else switch ( yy_get_next_buffer(  ) )
                        {
                        case EOB_ACT_END_OF_FILE:
                                {
-                               yy_did_buffer_switch_on_eof = 0;
+                               (yy_did_buffer_switch_on_eof) = 0;
 
-                               if ( yywrap() )
+                               if ( yywrap( ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
@@ -1372,7 +1615,7 @@ case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
                                         * YY_NULL, it'll still work - another
                                         * YY_NULL will get returned.
                                         */
-                                       yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+                                       (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 
                                        yy_act = YY_STATE_EOF(YY_START);
                                        goto do_action;
@@ -1380,30 +1623,30 @@ case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
 
                                else
                                        {
-                                       if ( ! yy_did_buffer_switch_on_eof )
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
                                        }
                                break;
                                }
 
                        case EOB_ACT_CONTINUE_SCAN:
-                               yy_c_buf_p =
-                                       yytext_ptr + yy_amount_of_matched_text;
+                               (yy_c_buf_p) =
+                                       (yytext_ptr) + yy_amount_of_matched_text;
 
-                               yy_current_state = yy_get_previous_state();
+                               yy_current_state = yy_get_previous_state(  );
 
-                               yy_cp = yy_c_buf_p;
-                               yy_bp = yytext_ptr + YY_MORE_ADJ;
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_match;
 
                        case EOB_ACT_LAST_MATCH:
-                               yy_c_buf_p =
-                               &yy_current_buffer->yy_ch_buf[yy_n_chars];
+                               (yy_c_buf_p) =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 
-                               yy_current_state = yy_get_previous_state();
+                               yy_current_state = yy_get_previous_state(  );
 
-                               yy_cp = yy_c_buf_p;
-                               yy_bp = yytext_ptr + YY_MORE_ADJ;
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_find_action;
                        }
                break;
@@ -1414,8 +1657,7 @@ case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
                        "fatal flex scanner internal error--no action found" );
        } /* end of action switch */
                } /* end of scanning one token */
-       } /* end of yylex */
-
+} /* end of yylex */
 
 /* yy_get_next_buffer - try to read in a new buffer
  *
@@ -1424,21 +1666,20 @@ case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  *     EOB_ACT_END_OF_FILE - end of file
  */
-
-static int yy_get_next_buffer()
-       {
-       register char *dest = yy_current_buffer->yy_ch_buf;
-       register char *source = yytext_ptr;
+static int yy_get_next_buffer (void)
+{
+       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       register char *source = (yytext_ptr);
        register int number_to_move, i;
        int ret_val;
 
-       if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+       if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
                YY_FATAL_ERROR(
                "fatal flex scanner internal error--end of buffer missed" );
 
-       if ( yy_current_buffer->yy_fill_buffer == 0 )
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
                { /* Don't try to fill the buffer, so this is an EOF. */
-               if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+               if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
                        {
                        /* We matched a single character, the EOB, so
                         * treat this as a final EOF.
@@ -1458,34 +1699,30 @@ static int yy_get_next_buffer()
        /* Try to read more data. */
 
        /* First move last chars to start of buffer. */
-       number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+       number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
 
        for ( i = 0; i < number_to_move; ++i )
                *(dest++) = *(source++);
 
-       if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
                /* don't do the read, it's not guaranteed to return an EOF,
                 * just force an EOF
                 */
-               yy_current_buffer->yy_n_chars = yy_n_chars = 0;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
 
        else
                {
-               int num_to_read =
-                       yy_current_buffer->yy_buf_size - number_to_move - 1;
+                       int num_to_read =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
                while ( num_to_read <= 0 )
                        { /* Not enough room in the buffer - grow it. */
-#ifdef YY_USES_REJECT
-                       YY_FATAL_ERROR(
-"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
-#else
 
                        /* just a shorter name for the current buffer */
-                       YY_BUFFER_STATE b = yy_current_buffer;
+                       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
                        int yy_c_buf_p_offset =
-                               (int) (yy_c_buf_p - b->yy_ch_buf);
+                               (int) ((yy_c_buf_p) - b->yy_ch_buf);
 
                        if ( b->yy_is_our_buffer )
                                {
@@ -1498,8 +1735,7 @@ static int yy_get_next_buffer()
 
                                b->yy_ch_buf = (char *)
                                        /* Include room in for 2 EOB chars. */
-                                       yyxrealloc( (void *) b->yy_ch_buf,
-                                                        b->yy_buf_size + 2 );
+                                       yyxrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                                }
                        else
                                /* Can't grow it, we don't own it. */
@@ -1509,35 +1745,35 @@ static int yy_get_next_buffer()
                                YY_FATAL_ERROR(
                                "fatal error - scanner input buffer overflow" );
 
-                       yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+                       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-                       num_to_read = yy_current_buffer->yy_buf_size -
+                       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                                                number_to_move - 1;
-#endif
+
                        }
 
                if ( num_to_read > YY_READ_BUF_SIZE )
                        num_to_read = YY_READ_BUF_SIZE;
 
                /* Read in more data. */
-               YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-                       yy_n_chars, num_to_read );
+               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+                       (yy_n_chars), (size_t) num_to_read );
 
-               yy_current_buffer->yy_n_chars = yy_n_chars;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
 
-       if ( yy_n_chars == 0 )
+       if ( (yy_n_chars) == 0 )
                {
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
-                       yyrestart( yyin );
+                       yyrestart(yyin  );
                        }
 
                else
                        {
                        ret_val = EOB_ACT_LAST_MATCH;
-                       yy_current_buffer->yy_buffer_status =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                                YY_BUFFER_EOF_PENDING;
                        }
                }
@@ -1545,153 +1781,145 @@ static int yy_get_next_buffer()
        else
                ret_val = EOB_ACT_CONTINUE_SCAN;
 
-       yy_n_chars += number_to_move;
-       yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-       yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+       if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+               /* Extend the array by 50%, plus the number we really need. */
+               yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+               YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyxrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
+               if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+                       YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+       }
 
-       yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+       (yy_n_chars) += number_to_move;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
 
-       return ret_val;
-       }
+       (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
+       return ret_val;
+}
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
-static yy_state_type yy_get_previous_state()
-       {
+    static yy_state_type yy_get_previous_state (void)
+{
        register yy_state_type yy_current_state;
        register char *yy_cp;
+    
+       yy_current_state = (yy_start);
 
-       yy_current_state = yy_start;
-
-       for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+       for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
                {
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
                if ( yy_accept[yy_current_state] )
                        {
-                       yy_last_accepting_state = yy_current_state;
-                       yy_last_accepting_cpos = yy_cp;
+                       (yy_last_accepting_state) = yy_current_state;
+                       (yy_last_accepting_cpos) = yy_cp;
                        }
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                        {
                        yy_current_state = (int) yy_def[yy_current_state];
-                       if ( yy_current_state >= 196 )
+                       if ( yy_current_state >= 207 )
                                yy_c = yy_meta[(unsigned int) yy_c];
                        }
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                }
 
        return yy_current_state;
-       }
-
+}
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
  *     next_state = yy_try_NUL_trans( current_state );
  */
-
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
-#else
-static yy_state_type yy_try_NUL_trans( yy_current_state )
-yy_state_type yy_current_state;
-#endif
-       {
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
        register int yy_is_jam;
-       register char *yy_cp = yy_c_buf_p;
+       register char *yy_cp = (yy_c_buf_p);
 
        register YY_CHAR yy_c = 1;
        if ( yy_accept[yy_current_state] )
                {
-               yy_last_accepting_state = yy_current_state;
-               yy_last_accepting_cpos = yy_cp;
+               (yy_last_accepting_state) = yy_current_state;
+               (yy_last_accepting_cpos) = yy_cp;
                }
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = (int) yy_def[yy_current_state];
-               if ( yy_current_state >= 196 )
+               if ( yy_current_state >= 207 )
                        yy_c = yy_meta[(unsigned int) yy_c];
                }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-       yy_is_jam = (yy_current_state == 195);
+       yy_is_jam = (yy_current_state == 206);
 
        return yy_is_jam ? 0 : yy_current_state;
-       }
-
+}
 
-#ifndef YY_NO_UNPUT
-#ifdef YY_USE_PROTOS
-static void yyunput( int c, register char *yy_bp )
-#else
-static void yyunput( c, yy_bp )
-int c;
-register char *yy_bp;
-#endif
-       {
-       register char *yy_cp = yy_c_buf_p;
+    static void yyunput (int c, register char * yy_bp )
+{
+       register char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
 
        /* undo effects of setting up yytext */
-       *yy_cp = yy_hold_char;
+       *yy_cp = (yy_hold_char);
 
-       if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+       if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                { /* need to shift things up to make room */
                /* +2 for EOB chars. */
-               register int number_to_move = yy_n_chars + 2;
-               register char *dest = &yy_current_buffer->yy_ch_buf[
-                                       yy_current_buffer->yy_buf_size + 2];
+               register int number_to_move = (yy_n_chars) + 2;
+               register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+                                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
                register char *source =
-                               &yy_current_buffer->yy_ch_buf[number_to_move];
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 
-               while ( source > yy_current_buffer->yy_ch_buf )
+               while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
                        *--dest = *--source;
 
                yy_cp += (int) (dest - source);
                yy_bp += (int) (dest - source);
-               yy_current_buffer->yy_n_chars =
-                       yy_n_chars = yy_current_buffer->yy_buf_size;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 
-               if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+               if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
                }
 
        *--yy_cp = (char) c;
 
-
-       yytext_ptr = yy_bp;
-       yy_hold_char = *yy_cp;
-       yy_c_buf_p = yy_cp;
-       }
-#endif /* ifndef YY_NO_UNPUT */
-
+       (yytext_ptr) = yy_bp;
+       (yy_hold_char) = *yy_cp;
+       (yy_c_buf_p) = yy_cp;
+}
 
 #ifndef YY_NO_INPUT
 #ifdef __cplusplus
-static int yyinput()
+    static int yyinput (void)
 #else
-static int input()
+    static int input  (void)
 #endif
-       {
-       int c;
 
-       *yy_c_buf_p = yy_hold_char;
+{
+       int c;
+    
+       *(yy_c_buf_p) = (yy_hold_char);
 
-       if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+       if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
                {
                /* yy_c_buf_p now points to the character we want to return.
                 * If this occurs *before* the EOB characters, then it's a
                 * valid NUL; if not, then we've hit the end of the buffer.
                 */
-               if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+               if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        /* This was really a NUL. */
-                       *yy_c_buf_p = '\0';
+                       *(yy_c_buf_p) = '\0';
 
                else
                        { /* need more input */
-                       int offset = yy_c_buf_p - yytext_ptr;
-                       ++yy_c_buf_p;
+                       int offset = (yy_c_buf_p) - (yytext_ptr);
+                       ++(yy_c_buf_p);
 
-                       switch ( yy_get_next_buffer() )
+                       switch ( yy_get_next_buffer(  ) )
                                {
                                case EOB_ACT_LAST_MATCH:
                                        /* This happens because yy_g_n_b()
@@ -1705,16 +1933,16 @@ static int input()
                                         */
 
                                        /* Reset buffer status. */
-                                       yyrestart( yyin );
+                                       yyrestart(yyin );
 
-                                       /* fall through */
+                                       /*FALLTHROUGH*/
 
                                case EOB_ACT_END_OF_FILE:
                                        {
-                                       if ( yywrap() )
+                                       if ( yywrap( ) )
                                                return EOF;
 
-                                       if ( ! yy_did_buffer_switch_on_eof )
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
 #ifdef __cplusplus
                                        return yyinput();
@@ -1724,90 +1952,92 @@ static int input()
                                        }
 
                                case EOB_ACT_CONTINUE_SCAN:
-                                       yy_c_buf_p = yytext_ptr + offset;
+                                       (yy_c_buf_p) = (yytext_ptr) + offset;
                                        break;
                                }
                        }
                }
 
-       c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
-       *yy_c_buf_p = '\0';     /* preserve yytext */
-       yy_hold_char = *++yy_c_buf_p;
-
+       c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
+       *(yy_c_buf_p) = '\0';   /* preserve yytext */
+       (yy_hold_char) = *++(yy_c_buf_p);
 
        return c;
-       }
-#endif /* YY_NO_INPUT */
-
-#ifdef YY_USE_PROTOS
-void yyrestart( FILE *input_file )
-#else
-void yyrestart( input_file )
-FILE *input_file;
-#endif
-       {
-       if ( ! yy_current_buffer )
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+}
+#endif /* ifndef YY_NO_INPUT */
 
-       yy_init_buffer( yy_current_buffer, input_file );
-       yy_load_buffer_state();
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file )
+{
+    
+       if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack ();
+               YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer(yyin,YY_BUF_SIZE );
        }
 
+       yy_init_buffer(YY_CURRENT_BUFFER,input_file );
+       yy_load_buffer_state( );
+}
 
-#ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
-#else
-void yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
-#endif
-       {
-       if ( yy_current_buffer == new_buffer )
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              yypop_buffer_state();
+        *              yypush_buffer_state(new_buffer);
+     */
+       yyensure_buffer_stack ();
+       if ( YY_CURRENT_BUFFER == new_buffer )
                return;
 
-       if ( yy_current_buffer )
+       if ( YY_CURRENT_BUFFER )
                {
                /* Flush out information for old buffer. */
-               *yy_c_buf_p = yy_hold_char;
-               yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-               yy_current_buffer->yy_n_chars = yy_n_chars;
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
 
-       yy_current_buffer = new_buffer;
-       yy_load_buffer_state();
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       yy_load_buffer_state( );
 
        /* We don't actually know whether we did this switch during
         * EOF (yywrap()) processing, but the only time this flag
         * is looked at is after yywrap() is called, so it's safe
         * to go ahead and always set it.
         */
-       yy_did_buffer_switch_on_eof = 1;
-       }
-
-
-#ifdef YY_USE_PROTOS
-void yy_load_buffer_state( void )
-#else
-void yy_load_buffer_state()
-#endif
-       {
-       yy_n_chars = yy_current_buffer->yy_n_chars;
-       yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-       yyin = yy_current_buffer->yy_input_file;
-       yy_hold_char = *yy_c_buf_p;
-       }
+       (yy_did_buffer_switch_on_eof) = 1;
+}
 
+static void yy_load_buffer_state  (void)
+{
+       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+       (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+       yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       (yy_hold_char) = *(yy_c_buf_p);
+}
 
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
-#else
-YY_BUFFER_STATE yy_create_buffer( file, size )
-FILE *file;
-int size;
-#endif
-       {
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
+{
        YY_BUFFER_STATE b;
-
-       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+    
+       b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
@@ -1816,75 +2046,75 @@ int size;
        /* yy_ch_buf has to be 2 characters longer than the size given because
         * we need to put in 2 end-of-buffer characters.
         */
-       b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+       b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
        if ( ! b->yy_ch_buf )
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
        b->yy_is_our_buffer = 1;
 
-       yy_init_buffer( b, file );
+       yy_init_buffer(b,file );
 
        return b;
-       }
-
+}
 
-#ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b )
-#else
-void yy_delete_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-       {
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * 
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b )
+{
+    
        if ( ! b )
                return;
 
-       if ( b == yy_current_buffer )
-               yy_current_buffer = (YY_BUFFER_STATE) 0;
+       if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+               YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
        if ( b->yy_is_our_buffer )
-               yy_flex_free( (void *) b->yy_ch_buf );
-
-       yy_flex_free( (void *) b );
-       }
+               yyfree((void *) b->yy_ch_buf  );
 
+       yyfree((void *) b  );
+}
 
+#ifndef __cplusplus
+extern int isatty (int );
+#endif /* __cplusplus */
+    
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
 
-#ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
-#else
-void yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
-FILE *file;
-#endif
-
-
-       {
-       yy_flush_buffer( b );
+{
+       int oerrno = errno;
+    
+       yy_flush_buffer(b );
 
        b->yy_input_file = file;
        b->yy_fill_buffer = 1;
 
-#if YY_ALWAYS_INTERACTIVE
-       b->yy_is_interactive = 1;
-#else
-#if YY_NEVER_INTERACTIVE
-       b->yy_is_interactive = 0;
-#else
-       b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-#endif
-#endif
-       }
-
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
 
-#ifdef YY_USE_PROTOS
-void yy_flush_buffer( YY_BUFFER_STATE b )
-#else
-void yy_flush_buffer( b )
-YY_BUFFER_STATE b;
-#endif
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+       errno = oerrno;
+}
 
-       {
-       if ( ! b )
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b )
+{
+       if ( ! b )
                return;
 
        b->yy_n_chars = 0;
@@ -1901,29 +2131,125 @@ YY_BUFFER_STATE b;
        b->yy_at_bol = 1;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       if ( b == yy_current_buffer )
-               yy_load_buffer_state();
+       if ( b == YY_CURRENT_BUFFER )
+               yy_load_buffer_state( );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+       if (new_buffer == NULL)
+               return;
+
+       yyensure_buffer_stack();
+
+       /* This block is copied from yy_switch_to_buffer. */
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       /* Only push if top exists. Otherwise, replace top. */
+       if (YY_CURRENT_BUFFER)
+               (yy_buffer_stack_top)++;
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+       /* copied from yy_switch_to_buffer. */
+       yy_load_buffer_state( );
+       (yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  
+ */
+void yypop_buffer_state (void)
+{
+       if (!YY_CURRENT_BUFFER)
+               return;
+
+       yy_delete_buffer(YY_CURRENT_BUFFER );
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if ((yy_buffer_stack_top) > 0)
+               --(yy_buffer_stack_top);
+
+       if (YY_CURRENT_BUFFER) {
+               yy_load_buffer_state( );
+               (yy_did_buffer_switch_on_eof) = 1;
        }
+}
 
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (void)
+{
+       int num_to_alloc;
+    
+       if (!(yy_buffer_stack)) {
+
+               /* First allocation is just for 2 elements, since we don't know if this
+                * scanner will even need a stack. We use 2 instead of 1 to avoid an
+                * immediate xrealloc on the next call.
+         */
+               num_to_alloc = 1;
+               (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+                                                                 
+               memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+                               
+               (yy_buffer_stack_max) = num_to_alloc;
+               (yy_buffer_stack_top) = 0;
+               return;
+       }
 
-#ifndef YY_NO_SCAN_BUFFER
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
-#else
-YY_BUFFER_STATE yy_scan_buffer( base, size )
-char *base;
-yy_size_t size;
-#endif
-       {
-       YY_BUFFER_STATE b;
+       if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+               /* Increase the buffer to prepare for a possible push. */
+               int grow_size = 8 /* arbitrary grow size */;
+
+               num_to_alloc = (yy_buffer_stack_max) + grow_size;
+               (yy_buffer_stack) = (struct yy_buffer_state**)yyxrealloc
+                                                               ((yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+               /* zero only the new slots.*/
+               memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+               (yy_buffer_stack_max) = num_to_alloc;
+       }
+}
 
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * 
+ * @return the newly allocated buffer state object. 
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
+{
+       YY_BUFFER_STATE b;
+    
        if ( size < 2 ||
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
             base[size-1] != YY_END_OF_BUFFER_CHAR )
                /* They forgot to leave room for the EOB's. */
                return 0;
 
-       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+       b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 
@@ -1937,56 +2263,51 @@ yy_size_t size;
        b->yy_fill_buffer = 0;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       yy_switch_to_buffer( b );
+       yy_switch_to_buffer( );
 
        return b;
-       }
-#endif
-
-
-#ifndef YY_NO_SCAN_STRING
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
-#else
-YY_BUFFER_STATE yy_scan_string( yy_str )
-yyconst char *yy_str;
-#endif
-       {
-       int len;
-       for ( len = 0; yy_str[len]; ++len )
-               ;
-
-       return yy_scan_bytes( yy_str, len );
-       }
-#endif
+}
 
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * 
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
+{
+    
+       return yy_scan_bytes(yystr,strlen(yystr) );
+}
 
-#ifndef YY_NO_SCAN_BYTES
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
-#else
-YY_BUFFER_STATE yy_scan_bytes( bytes, len )
-yyconst char *bytes;
-int len;
-#endif
-       {
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param bytes the byte buffer to scan
+ * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
+{
        YY_BUFFER_STATE b;
        char *buf;
        yy_size_t n;
        int i;
-
+    
        /* Get memory for full buffer, including space for trailing EOB's. */
-       n = len + 2;
-       buf = (char *) yy_flex_alloc( n );
+       n = _yybytes_len + 2;
+       buf = (char *) yyalloc(n  );
        if ( ! buf )
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 
-       for ( i = 0; i < len; ++i )
-               buf[i] = bytes[i];
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
 
-       buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-       b = yy_scan_buffer( buf, n );
+       b = yy_scan_buffer(buf,n );
        if ( ! b )
                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
@@ -1996,148 +2317,196 @@ int len;
        b->yy_is_our_buffer = 1;
 
        return b;
-       }
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
 #endif
 
+static void yy_fatal_error (yyconst char* msg )
+{
+       (void) fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );
+}
 
-#ifndef YY_NO_PUSH_STATE
-#ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state )
-#else
-static void yy_push_state( new_state )
-int new_state;
-#endif
-       {
-       if ( yy_start_stack_ptr >= yy_start_stack_depth )
-               {
-               yy_size_t new_size;
+/* Redefine yyless() so it works in section 3 code. */
 
-               yy_start_stack_depth += YY_START_STACK_INCR;
-               new_size = yy_start_stack_depth * sizeof( int );
+#undef yyless
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               yytext[yyleng] = (yy_hold_char); \
+               (yy_c_buf_p) = yytext + yyless_macro_arg; \
+               (yy_hold_char) = *(yy_c_buf_p); \
+               *(yy_c_buf_p) = '\0'; \
+               yyleng = yyless_macro_arg; \
+               } \
+       while ( 0 )
 
-               if ( ! yy_start_stack )
-                       yy_start_stack = (int *) yy_flex_alloc( new_size );
+/* Accessor  methods (get/set functions) to struct members. */
 
-               else
-                       yy_start_stack = (int *) yyxrealloc(
-                                       (void *) yy_start_stack, new_size );
+/** Get the current line number.
+ * 
+ */
+int yyget_lineno  (void)
+{
+        
+    return yylineno;
+}
 
-               if ( ! yy_start_stack )
-                       YY_FATAL_ERROR(
-                       "out of memory expanding start-condition stack" );
-               }
+/** Get the input stream.
+ * 
+ */
+FILE *yyget_in  (void)
+{
+        return yyin;
+}
 
-       yy_start_stack[yy_start_stack_ptr++] = YY_START;
+/** Get the output stream.
+ * 
+ */
+FILE *yyget_out  (void)
+{
+        return yyout;
+}
 
-       BEGIN(new_state);
-       }
-#endif
+/** Get the length of the current token.
+ * 
+ */
+int yyget_leng  (void)
+{
+        return yyleng;
+}
 
+/** Get the current token.
+ * 
+ */
 
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state()
-       {
-       if ( --yy_start_stack_ptr < 0 )
-               YY_FATAL_ERROR( "start-condition stack underflow" );
+char *yyget_text  (void)
+{
+        return yytext;
+}
 
-       BEGIN(yy_start_stack[yy_start_stack_ptr]);
-       }
-#endif
+/** Set the current line number.
+ * @param line_number
+ * 
+ */
+void yyset_lineno (int  line_number )
+{
+    
+    yylineno = line_number;
+}
 
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * 
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  in_str )
+{
+        yyin = in_str ;
+}
 
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state()
-       {
-       return yy_start_stack[yy_start_stack_ptr - 1];
-       }
-#endif
+void yyset_out (FILE *  out_str )
+{
+        yyout = out_str ;
+}
 
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
+int yyget_debug  (void)
+{
+        return yy_flex_debug;
+}
+
+void yyset_debug (int  bdebug )
+{
+        yy_flex_debug = bdebug ;
+}
 
-#ifdef YY_USE_PROTOS
-static void yy_fatal_error( yyconst char msg[] )
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    (yy_buffer_stack) = 0;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = (char *) 0;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
 #else
-static void yy_fatal_error( msg )
-char msg[];
+    yyin = (FILE *) 0;
+    yyout = (FILE *) 0;
 #endif
-       {
-       (void) fprintf( stderr, "%s\n", msg );
-       exit( YY_EXIT_FAILURE );
-       }
 
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
 
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+       while(YY_CURRENT_BUFFER){
+               yy_delete_buffer(YY_CURRENT_BUFFER  );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               yypop_buffer_state();
+       }
 
-/* Redefine yyless() so it works in section 3 code. */
+       /* Destroy the stack itself. */
+       yyfree((yy_buffer_stack) );
+       (yy_buffer_stack) = NULL;
 
-#undef yyless
-#define yyless(n) \
-       do \
-               { \
-               /* Undo effects of setting up yytext. */ \
-               yytext[yyleng] = yy_hold_char; \
-               yy_c_buf_p = yytext + n; \
-               yy_hold_char = *yy_c_buf_p; \
-               *yy_c_buf_p = '\0'; \
-               yyleng = n; \
-               } \
-       while ( 0 )
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( );
 
+    return 0;
+}
 
-/* Internal utility routines. */
+/*
+ * Internal utility routines.
+ */
 
 #ifndef yytext_ptr
-#ifdef YY_USE_PROTOS
-static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
-#else
-static void yy_flex_strncpy( s1, s2, n )
-char *s1;
-yyconst char *s2;
-int n;
-#endif
-       {
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
+{
        register int i;
        for ( i = 0; i < n; ++i )
                s1[i] = s2[i];
-       }
+}
 #endif
 
 #ifdef YY_NEED_STRLEN
-#ifdef YY_USE_PROTOS
-static int yy_flex_strlen( yyconst char *s )
-#else
-static int yy_flex_strlen( s )
-yyconst char *s;
-#endif
-       {
+static int yy_flex_strlen (yyconst char * s )
+{
        register int n;
        for ( n = 0; s[n]; ++n )
                ;
 
        return n;
-       }
+}
 #endif
 
-
-#ifdef YY_USE_PROTOS
-static void *yy_flex_alloc( yy_size_t size )
-#else
-static void *yy_flex_alloc( size )
-yy_size_t size;
-#endif
-       {
+void *yyalloc (yy_size_t  size )
+{
        return (void *) xmalloc( size );
-       }
+}
 
-#ifdef YY_USE_PROTOS
-static void *yyxrealloc( void *ptr, yy_size_t size )
-#else
-static void *yyxrealloc( ptr, size )
-void *ptr;
-yy_size_t size;
-#endif
-       {
+void *yyxrealloc  (void * ptr, yy_size_t  size )
+{
        /* The cast to (char *) in the following accommodates both
         * implementations that use char* generic pointers, and those
         * that use void* generic pointers.  It works with the latter
@@ -2146,26 +2515,17 @@ yy_size_t size;
         * as though doing an assignment.
         */
        return (void *) xrealloc( (char *) ptr, size );
-       }
+}
 
-#ifdef YY_USE_PROTOS
-static void yy_flex_free( void *ptr )
-#else
-static void yy_flex_free( ptr )
-void *ptr;
-#endif
-       {
-       xfree( ptr );
-       }
+void yyfree (void * ptr )
+{
+       xfree( (char *) ptr );  /* see yyxrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 288 "ada-lex.l"
 
-#if YY_MAIN
-int main()
-       {
-       yylex();
-       return 0;
-       }
-#endif
-#line 289 "ada-lex.l"
 
 
 #include <ctype.h>
@@ -2173,7 +2533,7 @@ int main()
 
 /* Initialize the lexer for processing new expression. */
 
-void
+static void
 lexer_init (FILE *inp)
 {
   BEGIN INITIAL;
@@ -2290,7 +2650,9 @@ processReal (const char *num0)
 
 
 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym.  The
-   resulting string is valid until the next call to ada_parse.  It differs
+   resulting string is valid until the next call to ada_parse.  If
+   NAME0 contains the substring "___", it is assumed to be already
+   encoded and the resulting name is equal to it.  Otherwise, it differs
    from NAME0 in that:
     + Characters between '...' or <...> are transfered verbatim to 
       yylval.ssym.
@@ -2310,8 +2672,18 @@ processId (const char *name0, int len)
   int i0, i;
   struct stoken result;
 
+  result.ptr = name;
   while (len > 0 && isspace (name0[len-1]))
     len -= 1;
+
+  if (strstr (name0, "___") != NULL)
+    {
+      strncpy (name, name0, len);
+      name[len] = '\000';
+      result.length = len;
+      return result;
+    }
+
   i = i0 = 0;
   while (i0 < len)
     {
@@ -2351,7 +2723,6 @@ processId (const char *name0, int len)
     }
   name[i] = '\000';
 
-  result.ptr = name;
   result.length = i;
   return result;
 }
@@ -2486,6 +2857,23 @@ processAttribute (const char *str)
   return attributes[k].code;
 }
 
+/* Back up lexptr by yyleng and then to the rightmost occurrence of
+   character CH, case-folded (there must be one).  WARNING: since
+   lexptr points to the next input character that Flex has not yet
+   transferred to its internal buffer, the use of this function
+   depends on the assumption that Flex calls YY_INPUT only when it is
+   logically necessary to do so (thus, there is no reading ahead
+   farther than needed to identify the next token.)  */
+
+static void
+rewind_to_char (int ch)
+{
+  lexptr -= yyleng;
+  while (toupper (*lexptr) != toupper (ch))
+    lexptr -= 1;
+  yyrestart (NULL);
+}
+
 int
 yywrap(void)
 {
@@ -2498,3 +2886,4 @@ dummy_function ada_flex_use[] =
 { 
   (dummy_function) yyunput
 };
+
index b5ec985..91ce4e6 100644 (file)
@@ -1,4 +1,4 @@
-@set GDBVN 7.4.1
+@set GDBVN 7.6.1
 @set VERSION_PACKAGE (GDB)
 @set BUGURL @uref{http://www.gnu.org/software/gdb/bugs/}
 @set BUGURL_DEFAULT
index 6190cfb..a3158da 100644 (file)
@@ -1,20 +1,3 @@
-#PROG= gdbtui
-#
-#SRCS= tui-main.c
-#
-#CFLAGS+= -I${.OBJDIR}/../libgdb -I${.CURDIR}/../libgdb -I${BASEDIR}/include
-#CFLAGS+= -I${BASEDIR}/bfd -I${BASEDIR}/gdb -I${BASEDIR}/gdb/common
-#CFLAGS+= -I${BASEDIR}/gdb/config
-#CFLAGS+= -I${.CURDIR}/../libbfd -I${.OBJDIR}/../libbfd
-#
-#DPADD=        ${GDBLIBS}
-#DPADD+=       ${LIBEDIT} ${LIBKVM} ${LIBTERMCAP} ${LIBM} ${LIBZ}
-#LDADD=        -L../libgdb -lgdb -L../libbfd -lbfd -L../libopcodes -lopcodes -L../libiberty -liberty
-#LDADD+=       -L../libdecnumber -ldecnumber
-#LDADD+=       -ledit -ltermcap -lm -lz
-#
-#.PATH:        ${BASEDIR}/gdb ${BASEDIR}/gdb/tui
-
 SCRIPTS=       gdbtui
 NOMAN=
 
index 0528b1d..11fca10 100644 (file)
@@ -7,14 +7,15 @@ CFLAGS+= -I${.OBJDIR}/../libbfd -I${BASEDIR}/gdb/common
 CFLAGS+= -D_KERNEL_STRUCTURES
 
 DPADD=  ${GDBLIBS}
-DPADD+= ${LIBNCURSES} ${LIBM} ${LIBZ} ${LIBKVM}
+DPADD+= ${LIBNCURSES} ${LIBM} ${LIBZ} ${LIBKVM} ${LIBLZMA}
 LDADD=  -L../libgdb -lgdb
 LDADD+= -L../libreadline -lreadline
 LDADD+= -L../libopcodes -lopcodes
 LDADD+= -L../libbfd -lbfd
 LDADD+= -L../libiberty -liberty
 LDADD+= -L../libdecnumber -ldecnumber
-LDADD+= -lncurses -lm -lz -lkvm
+LDADD+= -L../libgnu -lgnu
+LDADD+= -lncurses -lm -lz -lkvm -llzma
 
 WARNS?=        2
 
index 48fa27a..5c2f8bc 100644 (file)
@@ -62,7 +62,7 @@
 #include <ui-file.h>
 #include <bfd.h>
 #include <gdbcore.h>
-#include <wrapper.h>
+#include <exceptions.h>
 #include <observer.h>
 #include <arch-utils.h>
 
@@ -179,6 +179,38 @@ kgdb_new_objfile(struct objfile *objfile)
        }
 }
 
+int
+gdb_parse_exp_1 (const char **stringptr, struct block *block, int comma,
+                struct expression **expression)
+{
+  volatile struct gdb_exception except;
+  CORE_ADDR pc = 0;
+
+  TRY_CATCH (except, RETURN_MASK_ERROR)
+    {
+      *expression = parse_exp_1 (stringptr, pc ,block, comma);
+    }
+
+  if (except.reason < 0)
+    return 0;
+  return 1;
+}
+
+int
+gdb_evaluate_expression (struct expression *exp, struct value **value)
+{
+  volatile struct gdb_exception except;
+
+  TRY_CATCH (except, RETURN_MASK_ERROR)
+    {
+      *value = evaluate_expression(exp);
+    }
+
+  if (except.reason < 0)
+    return 0;
+  return 1;
+}
+
 /*
  * Parse an expression and return its value.  If 'quiet' is true, then
  * any error messages from the parser are masked.
@@ -190,7 +222,7 @@ kgdb_parse_1(const char *exp, int quiet)
        struct cleanup *old_chain;
        struct expression *expr;
        struct value *val;
-       char *s;
+       const char *s;
        CORE_ADDR n;
 
        old_stderr = gdb_stderr;
@@ -198,7 +230,7 @@ kgdb_parse_1(const char *exp, int quiet)
                gdb_stderr = parse_gdberr;
        n = 0;
        s = xstrdup(exp);
-       old_chain = make_cleanup(xfree, s);
+       old_chain = make_cleanup(xfree, (char*)s);
        if (gdb_parse_exp_1(&s, NULL, 0, &expr) && *s == '\0') {
                make_cleanup(free_current_contents, &expr);
                if (gdb_evaluate_expression(expr, &val))
index 35b4d86..945fe65 100644 (file)
@@ -40,9 +40,9 @@ struct kthr {
        uintptr_t       kstack;
        uintptr_t       pcb;
        uintptr_t       gd;
-       int             tid;
+       CORE_ADDR       tid;
        int             pid;
-       int             lwpid;
+       long            lwpid;
 };
 
 extern struct kthr *curkthr;
@@ -51,20 +51,20 @@ void initialize_kld_target(void);
 void initialize_kgdb_target(void);
 void kgdb_dmesg(void);
 void kgdb_trgt_fetch_registers(struct target_ops *, struct regcache *, int);
-void kld_init(void);
+void kld_init(struct gdbarch *);
 void kld_new_objfile(struct objfile *);
 
 extern const struct frame_unwind kgdb_trgt_trapframe_unwind;
 
 struct kthr *kgdb_thr_first(void);
 struct kthr *kgdb_thr_init(void);
-struct kthr *kgdb_thr_lookup_tid(int);
+struct kthr *kgdb_thr_lookup_tid(CORE_ADDR);
 struct kthr *kgdb_thr_lookup_pid(int);
 struct kthr *kgdb_thr_lookup_paddr(uintptr_t);
 struct kthr *kgdb_thr_lookup_taddr(uintptr_t);
 struct kthr *kgdb_thr_next(struct kthr *);
 struct kthr *kgdb_thr_select(struct kthr *);
-char        *kgdb_thr_extra_thread_info(int);
+char        *kgdb_thr_extra_thread_info(CORE_ADDR);
 char        *kgdb_thr_pid_to_str(ptid_t);
 
 CORE_ADDR kgdb_lookup(const char *sym);
index 3fd5d37..c7857cb 100644 (file)
@@ -238,7 +238,7 @@ load_kld (char *path, CORE_ADDR base_addr, int from_tty)
        if (bfd == NULL)
                error("\"%s\": can't open: %s", path,
                    bfd_errmsg(bfd_get_error()));
-       cleanup = make_cleanup_bfd_close(bfd);
+       cleanup = make_cleanup_bfd_unref(bfd);
 
        if (!bfd_check_format(bfd, bfd_object))
                error("\%s\": not an object file", path);
@@ -488,10 +488,10 @@ load_klds_stub (void *arg)
 }
 
 void
-kld_init (void)
+kld_init (struct gdbarch *kgdbarch)
 {
        /* XXX hack, needs to go into an abi init function */
-       set_solib_ops(get_current_arch(), &kld_so_ops);
+       set_solib_ops(kgdbarch, &kld_so_ops);
 
        kld_new_objfile(NULL);
        catch_errors(load_klds_stub, NULL, NULL, RETURN_MASK_ALL);
index 2635b3c..26086ad 100644 (file)
 #include "kgdb.h"
 
 static CORE_ADDR dumppcb;
-static int dumptid;
+static CORE_ADDR dumptid;
 
 static struct kthr *first;
 struct kthr *curkthr;
 
+#define LIVESYS_DUMPTID        10
+
 CORE_ADDR
 kgdb_lookup(const char *sym)
 {
@@ -111,7 +113,7 @@ kgdb_thr_init(void)
                 * cpu0's curthread.
                 *
                 * Actually we don't even know if we were dumped
-                * or if we are life.  Find out by querying "dumping".
+                * or if we are live.  Find out by querying "dumping".
                 */
                int dumping = 0;
 
@@ -121,10 +123,10 @@ kgdb_thr_init(void)
                        kvm_read(kvm, prvspace +
                                 offsetof(struct privatespace, mdglobaldata),
                                 &gd, sizeof(struct mdglobaldata));
-                       dumptid = (intptr_t)gd.mi.gd_curthread;
+                       dumptid = (CORE_ADDR)gd.mi.gd_curthread;
                } else {
                        /* We must be a live system */
-                       dumptid = -1;
+                       dumptid = LIVESYS_DUMPTID;
                }
        }
 
@@ -144,7 +146,7 @@ kgdb_thr_init(void)
                        kt = malloc(sizeof(*kt));
                        kt->next = first;
                        kt->kaddr = addr;
-                       kt->tid = addr;         /* XXX do we have tids? */
+                       kt->tid = addr;
                        kt->pcb = (kt->tid == dumptid) ? dumppcb :
                            (uintptr_t)td.td_pcb;
                        kt->kstack = (uintptr_t)td.td_kstack;
@@ -188,7 +190,7 @@ kgdb_thr_init(void)
 }
 
 struct kthr *
-kgdb_thr_lookup_tid(int tid)
+kgdb_thr_lookup_tid(CORE_ADDR tid)
 {
        struct kthr *kt;
 
@@ -248,17 +250,26 @@ kgdb_thr_select(struct kthr *kt)
 }
 
 char *
-kgdb_thr_extra_thread_info(int tid)
+kgdb_thr_extra_thread_info(CORE_ADDR tid)
 {
-#if 0  /* XXX: Doesn't do anything, obsolete? */
+#if 0 /* Information already provided */
        struct kthr *kt;
        static char buf[64];
+       struct proc *p;
+       char comm[MAXCOMLEN + 1];
 
        kt = kgdb_thr_lookup_tid(tid);
        if (kt == NULL)
                return (NULL);
 
-       buf[0] = 0;
+       snprintf(buf, sizeof(buf), "PID=%d", kt->pid);
+       p = (struct proc *)kt->paddr;
+       if (kvm_read(kvm, (uintptr_t)&p->p_comm[0], &comm, sizeof(comm)) ==
+               sizeof(comm)) {
+               strlcat(buf, ": ", sizeof(buf));
+               strlcat(buf, comm, sizeof(buf));
+       }
+       return (buf);
 #endif
        return (NULL);
 }
@@ -271,7 +282,7 @@ kgdb_thr_pid_to_str(ptid_t ptid)
        struct proc *p;
        struct thread *t;
        static char buf[64];
-       int tid;
+       CORE_ADDR tid;
 
        tid = ptid_get_tid(ptid);
        if (tid == 0)
@@ -289,7 +300,7 @@ kgdb_thr_pid_to_str(ptid_t ptid)
 
                if (tid != 0)
                        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
-                                "/%d", kt->lwpid);
+                                "/%ld", kt->lwpid);
 
                p = (struct proc *)kt->paddr;
                if (kvm_read(kvm, (uintptr_t)&p->p_comm[0], &comm, sizeof(comm)) !=
index cab72ec..fc1f248 100644 (file)
@@ -51,6 +51,7 @@
 #include <target.h>
 #include <ui-out.h>
 #include <observer.h>
+#include <arch-utils.h>
 
 #include "kgdb.h"
 
@@ -92,6 +93,8 @@ kgdb_trgt_open(char *filename, int from_tty)
        kvm_t *nkvm;
        char *temp;
        int first_inferior = 1;
+       struct gdbarch_info info;
+       struct gdbarch *kgdbarch;
 
        target_preopen (from_tty);
        if (!filename)
@@ -126,6 +129,18 @@ kgdb_trgt_open(char *filename, int from_tty)
 
        kgdb_dmesg();
 
+       gdbarch_info_init (&info);
+#if defined (__i386__)
+       info.bfd_arch_info = bfd_scan_arch ("i386");
+#elif defined (__x86_64__)
+       info.bfd_arch_info = bfd_scan_arch ("i386:x86-64");
+#else
+#error platform not recognized
+#endif
+       info.byte_order = BFD_ENDIAN_LITTLE;
+       gdbarch_info_fill (&info);
+       kgdbarch = gdbarch_find_by_info (info);
+
        init_thread_list();
        kt = kgdb_thr_init();
        while (kt != NULL) {
@@ -134,33 +149,36 @@ kgdb_trgt_open(char *filename, int from_tty)
                        first_inferior = 0;
                        inf8 = current_inferior();
                        inf8->pid = kt->pid;
+                       inf8->attach_flag = 1;
                        inferior_appeared (inf8, kt->pid);
                        pspace = current_program_space;
                        pspace->ebfd = 0;
                        pspace->ebfd_mtime = 0;
                      } else {                    
                        inf8 = add_inferior(kt->pid);
+                       inf8->attach_flag = 0;
                        pspace = add_program_space(new_address_space());
                        pspace->symfile_object_file = symfile_objfile;
                        pspace->objfiles = object_files;
                      }
                      inf8->pspace = pspace;
                      inf8->aspace = pspace->aspace;
+                     inf8->fake_pid_p = 0;
+                     inf8->gdbarch = kgdbarch;
                 }
-               add_thread(ptid_build(kt->pid, 0, kt->tid));
+               add_thread(ptid_build(kt->pid, kt->lwpid, kt->tid));
                kt = kgdb_thr_next(kt);
        }
        if (curkthr != 0)
-               inferior_ptid = ptid_build(curkthr->pid, 0, curkthr->tid);
+               inferior_ptid = ptid_build(curkthr->pid, curkthr->lwpid,
+                       curkthr->tid);
 
-       frame_unwind_prepend_unwinder(get_frame_arch(get_current_frame()), &kgdb_trgt_trapframe_unwind);
+       frame_unwind_prepend_unwinder(kgdbarch, &kgdb_trgt_trapframe_unwind);
 
-       /* XXX: fetch registers? */
-       kld_init();
+       kld_init(kgdbarch);
        reinit_frame_cache();
        select_frame (get_current_frame());
-       print_stack_frame(get_selected_frame(NULL),
-         frame_relative_level(get_selected_frame(NULL)), 1);
+       print_stack_frame(get_selected_frame(NULL), 0, SRC_AND_LOC);
 }
 
 static void
@@ -261,13 +279,13 @@ static void
 kgdb_switch_to_thread(struct kthr *thr)
 {
        char buf[16];
-       int thread_id;
+       CORE_ADDR thread_id;
        char *err;
 
-       thread_id = pid_to_thread_id(ptid_build(thr->pid, 0, thr->tid));
+       thread_id = thr->tid;
        if (thread_id == 0)
                error ("invalid tid");
-       snprintf(buf, sizeof(buf), "%d", thread_id);
+       snprintf(buf, sizeof(buf), "%lu", thread_id);
        if (!gdb_thread_select(current_uiout, buf, &err))
                error ("%s", err);
 }
index 91791b9..2034e7b 100644 (file)
@@ -272,7 +272,7 @@ static struct kgdb_frame_cache *
 kgdb_trgt_frame_cache(struct frame_info *next_frame, void **this_cache)
 {
        struct kgdb_frame_cache *cache;
-       char *pname;
+       const char *pname;
 
        cache = *this_cache;
        if (cache == NULL) {
@@ -389,7 +389,7 @@ kgdb_trgt_trapframe_sniffer(const struct frame_unwind *self,
                            struct frame_info *next_frame,
                            void **this_prologue_cache)
 {
-       char *pname;
+       const char *pname;
        CORE_ADDR pc;
 
        pc = get_frame_address_in_block(next_frame);
index 8681e3b..7a96770 100644 (file)
@@ -155,7 +155,7 @@ static struct kgdb_frame_cache *
 kgdb_trgt_frame_cache(struct frame_info *next_frame, void **this_cache)
 {
        struct kgdb_frame_cache *cache;
-       char *pname;
+       const char *pname;
 
        cache = *this_cache;
        if (cache == NULL) {
@@ -249,7 +249,7 @@ kgdb_trgt_trapframe_sniffer(const struct frame_unwind *self,
                            struct frame_info *next_frame,
                            void **this_prologue_cache)
 {
-       char *pname;
+       const char *pname;
        CORE_ADDR pc;
 
        pc = get_frame_address_in_block(next_frame);
index 52e9177..b3594b4 100644 (file)
@@ -15,7 +15,7 @@ SRCS= archive.c archures.c bfd.c bfdio.c bfdwin.c \
        opncls.c reloc.c section.c syms.c targets.c hash.c \
        linker.c srec.c binary.c tekhex.c ihex.c stabs.c \
        stab-syms.c merge.c dwarf2.c simple.c compress.c \
-       verilog.c
+       verilog.c elf-nacl.c
 
 SRCS+=         targmatch.h elf32-target.h elf64-target.h
 CLEANFILES+=   elf64-target.h elf32-target.h targmatch.h
index 12eab7c..7fae32f 100644 (file)
@@ -1,4 +1,4 @@
-#define BFD_VERSION_DATE 20111213
-#define BFD_VERSION 222510000
-#define BFD_VERSION_STRING  "(GNU Binutils) " "2.22.51.20111213"
+#define BFD_VERSION_DATE 20130312
+#define BFD_VERSION 223520000
+#define BFD_VERSION_STRING  "(GNU Binutils) " "2.23.52.20130312"
 #define REPORT_BUGS_TO "<http://www.sourceware.org/bugzilla/>"
index ac9743c..77f469f 100644 (file)
@@ -1,6 +1,8 @@
 /* config.h.  Generated from config.in by configure.  */
 /* config.in.  Generated from configure.in by autoheader.  */
 
+#define __CONFIG_H__ 1
+
 /* Name of host specific core header file to include in elf.c. */
 /* #undef CORE_HEADER */
 
 /* Define if <sys/procfs.h> has win32_pstatus_t. */
 /* #undef HAVE_WIN32_PSTATUS_T */
 
+/* Define to 1 if you have the <windows.h> header file. */
+/* #undef HAVE_WINDOWS_H */
+
 /* Define to 1 if you have the <zlib.h> header file. */
 #define HAVE_ZLIB_H 1
 
 #define PACKAGE_BUGREPORT ""
 
 /* Define to the full name of this package. */
-#define PACKAGE_NAME ""
+#define PACKAGE_NAME "bfd"
 
 /* Define to the full name and version of this package. */
-#define PACKAGE_STRING ""
+#define PACKAGE_STRING "bfd 2.23.52"
 
 /* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME ""
+#define PACKAGE_TARNAME "bfd"
 
 /* Define to the home page for this package. */
 #define PACKAGE_URL ""
 
 /* Define to the version of this package. */
-#define PACKAGE_VERSION ""
+#define PACKAGE_VERSION "2.23.52"
 
 /* The size of `char', as computed by sizeof. */
 /* #undef SIZEOF_CHAR */
 #define SIZEOF_VOID_P 4
 #elif defined(__x86_64__)
 #define SIZEOF_VOID_P 8
-#else
-#error Unsupported platform
 #endif
 
 /* Define to 1 if you have the ANSI C header files. */
 
 
 /* Version number of package */
-#define VERSION "2.22.51"
+#define VERSION "2.23.52"
 
 /* Number of bits in a file offset, on hosts where this is settable. */
 /* #undef _FILE_OFFSET_BITS */
index 5d32f9f..0349507 100644 (file)
@@ -1,4 +1,4 @@
-/* generated for  gcc (DragonFly) 4.4.7 2012.03.13 */
+/* generated for  cc 4.7.3 [DragonFly] Release/2013-04-11 */
 
 #ifndef GCC_GENERATED_STDINT_H
 #define GCC_GENERATED_STDINT_H 1
index 0b584c7..79f15ca 100644 (file)
@@ -17,8 +17,6 @@ CFLAGS+= -I${CONTRIBDIR} -I${CONTRIBDIR}/common
 CFLAGS+= -I${BASEDIR}/libdecnumber
 CFLAGS+= -I${.CURDIR}/../libbfd -I${.OBJDIR}/../libbfd
 CFLAGS+= -I${BASEDIR} 
-CFLAGS+= -DTARGET_SYSTEM_ROOT='"/"' -DTARGET_SYSTEM_ROOT_RELOCATABLE=0
-CFLAGS+= -DBINDIR='"/usr/bin"'
 CFLAGS+= -DMACHINE_ARCH='"${MACHINE_ARCH}"'
 CFLAGS+= -DTARGET_ARCH='"${TARGET_ARCH}"'
 CFLAGS+= -DVERSION_STRING='"${VERSION}"'
@@ -35,10 +33,12 @@ SRCS+=      \
        version.c \
        annotate.c \
        addrmap.c \
-       auxv.c \
+       auto-load.c auxv.c \
+       agent.c \
        bfd-target.c \
-       blockframe.c breakpoint.c findvar.c regcache.c \
-       charset.c continuations.c disasm.c dummy-frame.c dfp.c \
+       blockframe.c breakpoint.c break-catch-sig.c \
+       findvar.c regcache.c cleanups.c \
+       charset.c continuations.c corelow.c disasm.c dummy-frame.c dfp.c \
        source.c value.c eval.c valops.c valarith.c valprint.c printcmd.c \
        block.c symtab.c psymtab.c symfile.c symmisc.c linespec.c dictionary.c \
        infcall.c \
@@ -48,11 +48,13 @@ SRCS+=      \
        filesystem.c \
        inf-child.c \
        interps.c \
+       minidebug.c \
        main.c \
        macrotab.c macrocmd.c macroexp.c macroscope.c \
        mi-common.c \
        event-loop.c event-top.c inf-loop.c completer.c \
-       gdbarch.c arch-utils.c gdbtypes.c osabi.c copying.c \
+       gdbarch.c arch-utils.c gdbtypes.c gdb_bfd.c gdb_obstack.c \
+       osabi.c copying.c \
        memattr.c mem-break.c target.c parse.c language.c buildsym.c \
        findcmd.c \
        std-regs.c \
@@ -63,9 +65,10 @@ SRCS+=       \
        dwarf2read.c mipsread.c stabsread.c corefile.c \
        dwarf2expr.c dwarf2loc.c dwarf2-frame.c dwarf2-frame-tailcall.c \
        ada-lang.c c-lang.c d-lang.c f-lang.c objc-lang.c \
-       ada-tasks.c \
+       ada-tasks.c ada-varobj.c \
        ui-out.c cli-out.c \
-       varobj.c vec.c wrapper.c \
+       varobj.c vec.c \
+       go-lang.c go-valprint.c go-typeprint.c \
        jv-lang.c jv-valprint.c jv-typeprint.c \
        m2-lang.c opencl-lang.c p-lang.c p-typeprint.c p-valprint.c \
        sentinel-frame.c \
@@ -88,9 +91,10 @@ SRCS+=       \
        prologue-value.c memory-map.c memrange.c \
        xml-support.c xml-syscall.c xml-utils.c \
        target-descriptions.c target-memory.c xml-tdesc.c xml-builtin.c \
-       inferior.c osdata.c gdb_usleep.c record.c gcore.c \
-       jit.c progspace.c skip.c \
-       common-utils.c buffer.c ptid.c gdb-dlfcn.c
+       inferior.c osdata.c gdb_usleep.c record.c record-full.c gcore.c \
+       gdb_vecs.c jit.c progspace.c skip.c probe.c \
+       common-utils.c buffer.c ptid.c gdb-dlfcn.c common-agent.c \
+       format.c registry.c btrace.c record-btrace.c
 
 # TSOBS
 SRCS+= inflow.c
@@ -99,7 +103,8 @@ SRCS+=       inflow.c
 SRCS+= ser-base.c ser-unix.c ser-pipe.c ser-tcp.c
 
 # REMOTE_OBS
-SRCS+= remote.c dcache.c tracepoint.c ax-general.c ax-gdb.c remote-fileio.c
+SRCS+= remote.c dcache.c tracepoint.c ax-general.c ax-gdb.c \
+       remote-fileio.c remote-notif.c
 
 # SUBDIR_CLI_OBS
 SRCS+=  cli-dump.c \
@@ -109,9 +114,10 @@ SRCS+=  cli-dump.c \
 
 # SUBDIR_MI_OBS
 SRCS+= mi-out.c mi-console.c \
-       mi-cmds.c mi-cmd-env.c mi-cmd-var.c mi-cmd-break.c mi-cmd-stack.c \
-       mi-cmd-file.c mi-cmd-disas.c mi-symbol-cmds.c mi-cmd-target.c \
-       mi-interp.c \
+       mi-cmds.c mi-cmd-catch.c mi-cmd-env.c \
+       mi-cmd-var.c mi-cmd-break.c mi-cmd-stack.c \
+       mi-cmd-file.c mi-cmd-disas.c mi-symbol-cmds.c \
+       mi-cmd-target.c mi-cmd-info.c mi-interp.c \
        mi-main.c mi-parse.c mi-getopt.c
 
 # PYTHON OBJS
@@ -121,14 +127,13 @@ SRCS+=    python.c \
        py-prettyprint.c 
 
 # CONFIG_OBS
-SRCS+= elfread.c posix-hdep.c
+SRCS+= elfread.c posix-hdep.c stap-probe.c
 
 # SUBDIR_TUI_OBS
 SRCS+= tui-command.c \
        tui-data.c \
        tui-disasm.c \
        tui-file.c \
-       tui.c \
        tui-hooks.c \
        tui-interp.c \
        tui-io.c \
@@ -140,15 +145,16 @@ SRCS+=    tui-command.c \
        tui-win.c \
        tui-windata.c \
        tui-wingeneral.c \
-       tui-winsource.c
+       tui-winsource.c \
+       tui.c
 
 # YYOBJ
 SRCS+= c-exp.y \
        cp-name-parser.y \
-       objc-exp.y \
        ada-exp.y \
        jv-exp.y \
        f-exp.y \
+       go-exp.y \
        m2-exp.y \
        p-exp.y
 
@@ -161,11 +167,8 @@ XMLFILES= \
        library-list-svr4.dtd \
        osdata.dtd \
        threads.dtd \
-       traceframe-info.dtd
-
-# kernel-debugger
-#SRCS+=        freebsd-uthread.c
-#SRCS+=        kthr.c trgt.c trgt_${MACHINE_ARCH}.c
+       traceframe-info.dtd \
+       btrace.dtd
 
 DPADD= ${LIBEDIT} ${LIBKVM} ${LIBTERMCAP} ${LIBM}
 DPADD+=        ../libbfd/libbfd.a ../libopcodes/libopcodes.a ../libiberty/libiberty.a
@@ -175,11 +178,13 @@ LDADD+=   -L../libbfd -lbfd -L../libopcodes -lopcodes -L../libiberty -liberty
 .include "Makefile.${TARGET_ARCH}"
 
 init.c: ${SRCS:Ninit.c} Makefile
-       echo '#include "defs.h"' > ${.TARGET}
-       echo '#include "call-cmds.h"' >> ${.TARGET}
+       echo '/* Do not modify this file.  */' > ${.TARGET}
+       echo '/* It is created automatically by the Makefile.  */' >> ${.TARGET}
+       echo '#include "defs.h"      /* For initialize_file_ftype.  */' >> ${.TARGET}
+       echo 'extern void initialize_all_files(void);' >> ${.TARGET}
        sed -n -e 's/^_initialize_\([a-z_0-9A-Z]*\).*/extern initialize_file_ftype _initialize_\1;/p' ${.ALLSRC:M*.c} >> ${.TARGET}
        echo 'void' >> ${.TARGET}
-       echo 'initialize_all_files(void)' >> ${.TARGET}
+       echo 'initialize_all_files (void)' >> ${.TARGET}
        echo '{' >> ${.TARGET}
        sed -n -e 's/^_initialize_\([a-z_0-9A-Z]*\).*/  _initialize_\1 ();/p' ${.ALLSRC:M*.c} >> ${.TARGET}
        echo '}' >> ${.TARGET}
@@ -190,7 +195,13 @@ xml-builtin.c: feature_to_c.sh ${XMLFILES}
        rm -f ${.TARGET}
        sh ${CONTRIBDIR}/features/feature_to_c.sh ${.TARGET} ${.ALLSRC:M*.dtd}
 
-CLEANFILES+=   xml-builtin.c
+beforedepend:
+       cp ${CONTRIBDIR}/common/agent.c ${.OBJDIR}/common-agent.c
+       mkdir -p ${.OBJDIR}/build-gnulib
+       cp ${.CURDIR}/../libgnu/config.h ${.OBJDIR}/build-gnulib
+
+CLEANFILES+=   xml-builtin.c common-agent.c
+CLEANDIRS+=    build-gnulib
 
 # observer.inc can't be included in SRCS, it would duplicate the entry in OBJS
 observer.h: observer.sh observer.inc doc/observer.texi
index d9b034d..26d7196 100644 (file)
@@ -6,5 +6,5 @@ SRCS+=  amd64-tdep.c amd64dfly-tdep.c i386-tdep.c i387-tdep.c i386bsd-tdep.c \
 # NATDEPFILES
 SRCS+= fork-child.c inf-ptrace.c \
        fbsd-nat.c amd64-nat.c amd64bsd-nat.c amd64dfly-nat.c \
-       gcore.c
+       i386-nat.c gcore.c
 .endif
index b3c190f..0fca2e6 100644 (file)
@@ -1,30 +1,17 @@
 /* config.h.  Generated from config.in by configure.  */
 /* config.in.  Generated from configure.ac by autoheader.  */
 
-/* Define if the compiler is building for multiple architectures of Apple
-   platforms at once. */
-/* #undef AA_APPLE_UNIVERSAL_BUILD */
-
 /* Define if building universal (internal helper macro) */
 /* #undef AC_APPLE_UNIVERSAL_BUILD */
 
-/* Define to the number of bits in type 'ptrdiff_t'. */
-/* #undef BITSIZEOF_PTRDIFF_T */
-
-/* Define to the number of bits in type 'sig_atomic_t'. */
-/* #undef BITSIZEOF_SIG_ATOMIC_T */
-
-/* Define to the number of bits in type 'size_t'. */
-/* #undef BITSIZEOF_SIZE_T */
+/* Directories from which to load auto-loaded scripts. */
+#define AUTO_LOAD_DIR ":/usr/share/auto-load"
 
-/* Define to the number of bits in type 'wchar_t'. */
-/* #undef BITSIZEOF_WCHAR_T */
+/* Directories safe to hold auto-loaded files. */
+#define AUTO_LOAD_SAFE_PATH ":/usr/local/share/auto-load"
 
-/* Define to the number of bits in type 'wint_t'. */
-/* #undef BITSIZEOF_WINT_T */
-
-/* Define to 1 if the compiler supports long long. */
-#define CC_HAS_LONG_LONG 1
+/* Directory of programs. */
+#define BINDIR "/usr/bin"
 
 /* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
    systems. This function is required for `alloca.c' support on those systems.
 /* Define to be a string naming the default host character set. */
 #define GDB_DEFAULT_HOST_CHARSET "UTF-8"
 
-/* Host double floatformat */
+#if defined(__i386__)
+#define GDB_HOST_DOUBLE_FORMAT &floatformat_ieee_double_little
+#define GDB_HOST_FLOAT_FORMAT &floatformat_ieee_single_little
+#define GDB_HOST_LONG_DOUBLE_FORMAT &floatformat_i387_ext
+#elif defined(__x86_64__)
 #define GDB_HOST_DOUBLE_FORMAT 0
-
-/* Host float floatformat */
 #define GDB_HOST_FLOAT_FORMAT 0
-
-/* Host long double floatformat */
 #define GDB_HOST_LONG_DOUBLE_FORMAT 0
+#endif
 
 /* nativefile */
 /* #undef GDB_NM_FILE */
 /* Define to the default OS ABI for this configuration. */
 #define GDB_OSABI_DEFAULT GDB_OSABI_DRAGONFLY
 
-/* Define to 1 when the gnulib module memchr should be tested. */
-#define GNULIB_TEST_MEMCHR 1
-
-/* Define to 1 when the gnulib module memmem should be tested. */
-#define GNULIB_TEST_MEMMEM 1
-
 /* Define to 1 if you have `alloca', as a function or macro. */
 #define HAVE_ALLOCA 1
 
    */
 /* #undef HAVE_ALLOCA_H */
 
-/* Define to 1 if you have the <bp-sym.h> header file. */
-/* #undef HAVE_BP_SYM_H */
-
 /* Define to 1 if you have the `btowc' function. */
 #define HAVE_BTOWC 1
 
 /* Define to 1 if you have the `canonicalize_file_name' function. */
 /* #undef HAVE_CANONICALIZE_FILE_NAME */
 
-/* Define to 1 if you have the <ctype.h> header file. */
-#define HAVE_CTYPE_H 1
-
 /* Define to 1 if you have the <cursesX.h> header file. */
 /* #undef HAVE_CURSESX_H */
 
    */
 #define HAVE_DECL_MALLOC 1
 
-/* Define to 1 if you have the declaration of `memmem', and to 0 if you don't.
-   */
-#define HAVE_DECL_MEMMEM 1
-
 /* Define to 1 if you have the declaration of `ptrace', and to 0 if you don't.
    */
 #define HAVE_DECL_PTRACE 1
 /* Define to 1 if you have the `getuid' function. */
 #define HAVE_GETUID 1
 
-/* Define to 1 if you have the <gnu/libc-version.h> header file. */
-/* #undef HAVE_GNU_LIBC_VERSION_H */
-
 /* Define if <sys/procfs.h> has gregset_t. */
 #define HAVE_GREGSET_T 1
 
 /* Define to 1 if you have the `libiconvlist' function. */
 /* #undef HAVE_LIBICONVLIST */
 
+/* Define if you have the lzma library. */
+#define HAVE_LIBLZMA 1
+
 /* Define to 1 if you have the `m' library (-lm). */
 #define HAVE_LIBM 1
 
+/* Define to 1 if you have the `mcheck' library (-lmcheck). */
+/* #undef HAVE_LIBMCHECK */
+
 /* Define if Python 2.4 is being used. */
 /* #undef HAVE_LIBPYTHON2_4 */
 
 /* Define if Python 2.7 is being used. */
 /* #undef HAVE_LIBPYTHON2_7 */
 
-/* Define if libunwind library is being used. */
-/* #undef HAVE_LIBUNWIND */
-
-/* Define to 1 if you have the <libunwind.h> header file. */
-/* #undef HAVE_LIBUNWIND_H */
-
 /* Define to 1 if you have the <libunwind-ia64.h> header file. */
 /* #undef HAVE_LIBUNWIND_IA64_H */
 
 /* Define to 1 if you have the <link.h> header file. */
 #define HAVE_LINK_H 1
 
+/* Define to 1 if you have the <linux/perf_event.h> header file. */
+/* #undef HAVE_LINUX_PERF_EVENT_H */
+
 /* Define to 1 if you have the <locale.h> header file. */
 #define HAVE_LOCALE_H 1
 
 /* Define to 1 if the compiler supports long double. */
 #define HAVE_LONG_DOUBLE 1
 
-/* Define to 1 if the system has the type `long long int'. */
-#define HAVE_LONG_LONG_INT 1
+/* Define to 1 if you have the `lstat' function. */
+#define HAVE_LSTAT 1
 
 /* Define if <sys/procfs.h> has lwpid_t. */
 #define HAVE_LWPID_T 1
 /* Define to 1 if you have the <machine/reg.h> header file. */
 #define HAVE_MACHINE_REG_H 1
 
-/* Define to 1 if mmap()'s MAP_ANONYMOUS flag is available after including
-   config.h and <sys/mman.h>. */
-#define HAVE_MAP_ANONYMOUS 1
-
-/* Define to 1 if you have the `memchr' function. */
-#define HAVE_MEMCHR 1
-
-/* Define to 1 if you have the `memmem' function. */
-#define HAVE_MEMMEM 1
-
 /* Define to 1 if you have the <memory.h> header file. */
 #define HAVE_MEMORY_H 1
 
 /* Define to 1 if you have the `monstartup' function. */
 #define HAVE_MONSTARTUP 1
 
-/* Define to 1 if you have the `mprotect' function. */
-#define HAVE_MPROTECT 1
-
 /* Define to 1 if you have the <ncurses.h> header file. */
 #define HAVE_NCURSES_H 1
 
 /* Define to 1 if you have the `posix_madvise' function. */
 #define HAVE_POSIX_MADVISE 1
 
+/* Define to 1 if you have the `pread' function. */
+#define HAVE_PREAD 1
+
 /* Define to 1 if you have the `pread64' function. */
 /* #undef HAVE_PREAD64 */
 
 /* Define if sys/ptrace.h defines the PT_GETXMMREGS request. */
 /* #undef HAVE_PT_GETXMMREGS */
 
+/* Define to 1 if you have the `pwrite' function. */
+#define HAVE_PWRITE 1
+
 /* Define if Python interpreter is being linked in. */
 /* #undef HAVE_PYTHON */
 
-/* Define to 1 if btowc is declared even after undefining macros. */
-#define HAVE_RAW_DECL_BTOWC 1
-
-/* Define to 1 if mbrlen is declared even after undefining macros. */
-#define HAVE_RAW_DECL_MBRLEN 1
-
-/* Define to 1 if mbrtowc is declared even after undefining macros. */
-#define HAVE_RAW_DECL_MBRTOWC 1
-
-/* Define to 1 if mbsinit is declared even after undefining macros. */
-#define HAVE_RAW_DECL_MBSINIT 1
-
-/* Define to 1 if mbsnrtowcs is declared even after undefining macros. */
-/* #undef HAVE_RAW_DECL_MBSNRTOWCS */
-
-/* Define to 1 if mbsrtowcs is declared even after undefining macros. */
-#define HAVE_RAW_DECL_MBSRTOWCS 1
-
-/* Define to 1 if memmem is declared even after undefining macros. */
-#define HAVE_RAW_DECL_MEMMEM 1
-
-/* Define to 1 if mempcpy is declared even after undefining macros. */
-#define HAVE_RAW_DECL_MEMPCPY 1
-
-/* Define to 1 if memrchr is declared even after undefining macros. */
-#define HAVE_RAW_DECL_MEMRCHR 1
-
-/* Define to 1 if rawmemchr is declared even after undefining macros. */
-/* #undef HAVE_RAW_DECL_RAWMEMCHR */
-
-/* Define to 1 if stpcpy is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STPCPY 1
-
-/* Define to 1 if stpncpy is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STPNCPY 1
-
-/* Define to 1 if strcasestr is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRCASESTR 1
-
-/* Define to 1 if strchrnul is declared even after undefining macros. */
-/* #undef HAVE_RAW_DECL_STRCHRNUL */
-
-/* Define to 1 if strdup is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRDUP 1
-
-/* Define to 1 if strncat is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRNCAT 1
-
-/* Define to 1 if strndup is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRNDUP 1
-
-/* Define to 1 if strnlen is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRNLEN 1
-
-/* Define to 1 if strpbrk is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRPBRK 1
-
-/* Define to 1 if strsep is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRSEP 1
-
-/* Define to 1 if strsignal is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRSIGNAL 1
-
-/* Define to 1 if strtok_r is declared even after undefining macros. */
-#define HAVE_RAW_DECL_STRTOK_R 1
-
-/* Define to 1 if strverscmp is declared even after undefining macros. */
-/* #undef HAVE_RAW_DECL_STRVERSCMP */
-
-/* Define to 1 if wcrtomb is declared even after undefining macros. */
-#define HAVE_RAW_DECL_WCRTOMB 1
-
-/* Define to 1 if wcsnrtombs is declared even after undefining macros. */
-/* #undef HAVE_RAW_DECL_WCSNRTOMBS */
-
-/* Define to 1 if wcsrtombs is declared even after undefining macros. */
-#define HAVE_RAW_DECL_WCSRTOMBS 1
-
-/* Define to 1 if wctob is declared even after undefining macros. */
-#define HAVE_RAW_DECL_WCTOB 1
-
-/* Define to 1 if wcwidth is declared even after undefining macros. */
-#define HAVE_RAW_DECL_WCWIDTH 1
+/* Define to 1 if you have the `readlink' function. */
+#define HAVE_READLINK 1
 
 /* Define to 1 if you have the `realpath' function. */
 #define HAVE_REALPATH 1
 /* Define to 1 if you have the <signal.h> header file. */
 #define HAVE_SIGNAL_H 1
 
-/* Define to 1 if 'sig_atomic_t' is a signed integer type. */
-/* #undef HAVE_SIGNED_SIG_ATOMIC_T */
-
-/* Define to 1 if 'wchar_t' is a signed integer type. */
-/* #undef HAVE_SIGNED_WCHAR_T */
-
-/* Define to 1 if 'wint_t' is a signed integer type. */
-/* #undef HAVE_SIGNED_WINT_T */
-
 /* Define to 1 if you have the `sigprocmask' function. */
 #define HAVE_SIGPROCMASK 1
 
 /* Define to 1 if `struct thread' is a member of `td_pcb'. */
 /* #undef HAVE_STRUCT_THREAD_TD_PCB */
 
+/* Define to 1 if `struct user_regs_struct' is a member of `fs_base'. */
+/* #undef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE */
+
+/* Define to 1 if `struct user_regs_struct' is a member of `gs_base'. */
+/* #undef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE */
+
 /* Define to 1 if you have the `syscall' function. */
 #define HAVE_SYSCALL 1
 
-/* Define to 1 if you have the <sys/bitypes.h> header file. */
-/* #undef HAVE_SYS_BITYPES_H */
-
 /* Define to 1 if you have the <sys/debugreg.h> header file. */
 /* #undef HAVE_SYS_DEBUGREG_H */
 
 /* Define to 1 if you have the <sys/filio.h> header file. */
 #define HAVE_SYS_FILIO_H 1
 
-/* Define to 1 if you have the <sys/inttypes.h> header file. */
-/* #undef HAVE_SYS_INTTYPES_H */
-
 /* Define to 1 if you have the <sys/ioctl.h> header file. */
 #define HAVE_SYS_IOCTL_H 1
 
-/* Define to 1 if you have the <sys/mman.h> header file. */
-#define HAVE_SYS_MMAN_H 1
-
 /* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
    */
 /* #undef HAVE_SYS_NDIR_H */
 /* Define to 1 if you have the <sys/select.h> header file. */
 #define HAVE_SYS_SELECT_H 1
 
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#define HAVE_SYS_SOCKET_H 1
+
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #define HAVE_SYS_STAT_H 1
 
 /* Define to 1 if you have the <sys/types.h> header file. */
 #define HAVE_SYS_TYPES_H 1
 
+/* Define to 1 if you have the <sys/un.h> header file. */
+#define HAVE_SYS_UN_H 1
+
 /* Define to 1 if you have the <sys/user.h> header file. */
 #define HAVE_SYS_USER_H 1
 
 /* Define if using Solaris thread debugging. */
 /* #undef HAVE_THREAD_DB_LIB */
 
-/* Define to 1 if you have the <time.h> header file. */
-#define HAVE_TIME_H 1
-
 /* Define if you support the tkill syscall. */
 /* #undef HAVE_TKILL_SYSCALL */
 
 /* Define to 1 if you have the <unistd.h> header file. */
 #define HAVE_UNISTD_H 1
 
-/* Define to 1 if the system has the type `unsigned long long int'. */
-#define HAVE_UNSIGNED_LONG_LONG_INT 1
-
 /* Define to 1 if you have the `vfork' function. */
 #define HAVE_VFORK 1
 
 /* Define to 1 if you have the `wborder' function. */
 #define HAVE_WBORDER 1
 
-/* Define to 1 if you have the <wchar.h> header file. */
-#define HAVE_WCHAR_H 1
-
-/* Define if you have the 'wchar_t' type. */
-#define HAVE_WCHAR_T 1
-
-/* Define if you have the 'wint_t' type. */
-#define HAVE_WINT_T 1
-
 /* Define to 1 if `fork' works. */
 #define HAVE_WORKING_FORK 1
 
    moved. */
 #define JIT_READER_DIR_RELOCATABLE 1
 
-/* Define to a substitute value for mmap()'s MAP_ANONYMOUS flag. */
-#define MAP_ANONYMOUS MAP_ANON
-
 /* Define if you want to use new multi-fd /proc interface (replaces
    HAVE_MULTIPLE_PROC_FDS as well as other macros). */
 /* #undef NEW_PROC_API */
 /* Define as the return type of ptrace. */
 #define PTRACE_TYPE_RET int
 
-/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
-   'ptrdiff_t'. */
-/* #undef PTRDIFF_T_SUFFIX */
-
 /* Define if the python directory should be relocated when GDB is moved. */
 /* #undef PYTHON_PATH_RELOCATABLE */
 
 /* Define to 1 if the `setpgrp' function takes no argument. */
 /* #undef SETPGRP_VOID */
 
-/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
-   'sig_atomic_t'. */
-/* #undef SIG_ATOMIC_T_SUFFIX */
-
 /* The size of `long', as computed by sizeof. */
 /* #undef SIZEOF_LONG */
 
 /* The size of `unsigned __int128', as computed by sizeof. */
 #define SIZEOF_UNSIGNED___INT128 0
 
-/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
-   'size_t'. */
-/* #undef SIZE_T_SUFFIX */
-
 /* If using the C implementation of alloca, define if you know the
    direction of stack growth for your system; otherwise it will be
    automatically deduced at runtime.
        STACK_DIRECTION = 0 => direction of growth unknown */
 /* #undef STACK_DIRECTION */
 
-/* Define to 1 if the `S_IS*' macros in <sys/stat.h> do not work properly. */
-/* #undef STAT_MACROS_BROKEN */
-
 /* Define to 1 if you have the ANSI C header files. */
 #define STDC_HEADERS 1
 
    moved. */
 #define SYSTEM_GDBINIT_RELOCATABLE 0
 
+/* search for usr/lib et al within DIR */
+#define TARGET_SYSTEM_ROOT "/"
+
+/* Define if the sysroot directory should be relocated when GDB is moved. */
+#define TARGET_SYSTEM_ROOT_RELOCATABLE 0
+
 /* Define if <thread_db.h> has the TD_NOTALLOC error code. */
 /* #undef THREAD_DB_HAS_TD_NOTALLOC */
 
 /* Define to 1 if the regex included in libiberty should be used. */
 #define USE_INCLUDED_REGEX 1
 
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable threading extensions on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+
+
 /* Define if we should use the Windows API, instead of the POSIX API. On
    Windows, we use the Windows API when building for MinGW, but the POSIX API
    when building for Cygwin. */
 /* #undef USE_WIN32API */
 
-/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
-   'wchar_t'. */
-/* #undef WCHAR_T_SUFFIX */
-
-/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
-   'wint_t'. */
-/* #undef WINT_T_SUFFIX */
-
 /* Define if --with-python provides a path, either directly or via
    python-config.py --exec-prefix. */
 /* #undef WITH_PYTHON_PATH */
 /* Define if <sys/link.h> has link_map32 (solaris sparc-64 target) */
 /* #undef _SYSCALL32 */
 
-/* Define to 500 only on HP-UX. */
-/* #undef _XOPEN_SOURCE */
-
-/* Enable extensions on AIX 3, Interix.  */
-#ifndef _ALL_SOURCE
-# define _ALL_SOURCE 1
-#endif
-/* Enable GNU extensions on systems that have them.  */
-#ifndef _GNU_SOURCE
-# define _GNU_SOURCE 1
-#endif
-/* Enable threading extensions on Solaris.  */
-#ifndef _POSIX_PTHREAD_SEMANTICS
-# define _POSIX_PTHREAD_SEMANTICS 1
-#endif
-/* Enable extensions on HP NonStop.  */
-#ifndef _TANDEM_SOURCE
-# define _TANDEM_SOURCE 1
-#endif
-/* Enable general extensions on Solaris.  */
-#ifndef __EXTENSIONS__
-# define __EXTENSIONS__ 1
-#endif
-
-
 /* Define to empty if `const' does not conform to ANSI C. */
 /* #undef const */
 
 /* #undef inline */
 #endif
 
-/* Work around a bug in Apple GCC 4.0.1 build 5465: In C99 mode, it supports
-   the ISO C 99 semantics of 'extern inline' (unlike the GNU C semantics of
-   earlier versions), but does not display it by setting __GNUC_STDC_INLINE__.
-   __APPLE__ && __MACH__ test for MacOS X.
-   __APPLE_CC__ tests for the Apple compiler and its version.
-   __STDC_VERSION__ tests for the C99 mode.  */
-#if defined __APPLE__ && defined __MACH__ && __APPLE_CC__ >= 5465 && !defined __cplusplus && __STDC_VERSION__ >= 199901L && !defined __GNUC_STDC_INLINE__
-# define __GNUC_STDC_INLINE__ 1
-#endif
-
 /* Define to `int' if <sys/types.h> does not define. */
 /* #undef pid_t */
 
-/* Define to the equivalent of the C99 'restrict' keyword, or to
-   nothing if this is not supported.  Do not define if restrict is
-   supported directly.  */
-#define restrict __restrict
-/* Work around a bug in Sun C++: it does not support _Restrict or
-   __restrict__, even though the corresponding Sun C compiler ends up with
-   "#define restrict _Restrict" or "#define restrict __restrict__" in the
-   previous line.  Perhaps some future version of Sun C++ will work with
-   restrict; if so, hopefully it defines __RESTRICT like Sun C does.  */
-#if defined __SUNPRO_CC && !defined __RESTRICT
-# define _Restrict
-# define __restrict__
-#endif
-
-/* Define as a marker that can be attached to declarations that might not
-    be used.  This helps to reduce warnings, such as from
-    GCC -Wunused-parameter.  */
-#if __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
-# define _GL_UNUSED __attribute__ ((__unused__))
-#else
-# define _GL_UNUSED
-#endif
-/* The name _UNUSED_PARAMETER_ is an earlier spelling, although the name
-   is a misnomer outside of parameter lists.  */
-#define _UNUSED_PARAMETER_ _GL_UNUSED
-
-
 /* Define as `fork' if `vfork' does not work. */
 /* #undef vfork */
diff --git a/gnu/usr.bin/gdb/libgdb/freebsd-uthread.c b/gnu/usr.bin/gdb/libgdb/freebsd-uthread.c
deleted file mode 100644 (file)
index e22cf0e..0000000
+++ /dev/null
@@ -1,1020 +0,0 @@
-/* Low level interface for debugging FreeBSD user threads for GDB, the GNU debugger.
-   Copyright 1996, 1999 Free Software Foundation, Inc.
-
-This file is part of GDB.
-
-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 of the License, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
-/* $FreeBSD: ports/devel/gdb6/files/freebsd-uthread.c,v 1.2 2004/06/20 18:45:36 obrien Exp $ */
-
-/* This module implements a sort of half target that sits between the
-   machine-independent parts of GDB and the ptrace interface (infptrace.c) to
-   provide access to the FreeBSD user-mode thread implementation.
-
-   FreeBSD threads are true user-mode threads, which are invoked via
-   the pthread_* interfaces.  These are mostly implemented in
-   user-space, with all thread context kept in various structures that
-   live in the user's heap.  For the most part, the kernel has no
-   knowlege of these threads.
-
-   Based largely on hpux-thread.c
-
-   */
-
-
-#include "defs.h"
-#include <sys/queue.h>
-#include <signal.h>
-#include <setjmp.h>
-#include <string.h>
-#include "gdbthread.h"
-#include "target.h"
-#include "inferior.h"
-#include <fcntl.h>
-#include <ucontext.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include "gdbcore.h"
-#include "regcache.h"
-
-extern int child_suppress_run;
-extern struct target_ops child_ops; /* target vector for inftarg.c */
-
-extern void _initialize_freebsd_uthread PARAMS ((void));
-
-/* Set to true while we are part-way through attaching */
-static int freebsd_uthread_attaching;
-
-static int freebsd_uthread_active = 0;
-static CORE_ADDR P_thread_list;
-static CORE_ADDR P_thread_run;
-static CORE_ADDR P_thread_kern_thread;
-
-/* Pointer to the next function on the objfile event chain.  */
-static void (*target_new_objfile_chain) (struct objfile *objfile);
-
-static void freebsd_uthread_resume PARAMS ((ptid_t pid, int step,
-                                       enum target_signal signo));
-
-static void init_freebsd_uthread_ops PARAMS ((void));
-
-static struct target_ops freebsd_uthread_ops;
-\f
-static ptid_t find_active_ptid PARAMS ((void));
-
-struct cached_pthread {
-  u_int64_t            uniqueid;
-  int                  state;
-  CORE_ADDR            name;
-  union {
-    ucontext_t uc;
-    jmp_buf    jb;
-  }                    ctx;
-};
-
-static ptid_t cached_ptid;
-static struct cached_pthread cached_pthread;
-static CORE_ADDR cached_pthread_addr;
-
-LIST_HEAD(idmaplist, idmap);
-
-struct idmap {
-    LIST_ENTRY(idmap)  link;
-    u_int64_t          uniqueid;
-    int                        tid;
-};
-
-#define MAPHASH_SIZE   257
-#define TID_MIN                1
-#define TID_MAX                16383
-
-static int tid_to_hash[TID_MAX + 1];           /* set to map_hash index */
-static struct idmaplist map_hash[MAPHASH_SIZE];
-static int next_free_tid = TID_MIN;            /* first available tid */
-static int last_free_tid = TID_MIN;            /* first unavailable */
-
-static CORE_ADDR P_thread_next_offset;
-static CORE_ADDR P_thread_uniqueid_offset;
-static CORE_ADDR P_thread_state_offset;
-static CORE_ADDR P_thread_name_offset;
-static CORE_ADDR P_thread_ctx_offset;
-static CORE_ADDR P_thread_PS_RUNNING_value;
-static CORE_ADDR P_thread_PS_DEAD_value;
-
-static int next_offset;
-static int uniqueid_offset;
-static int state_offset;
-static int name_offset;
-static int ctx_offset;
-static int PS_RUNNING_value;
-static int PS_DEAD_value;
-
-#define UNIQUEID_HASH(id)      (id % MAPHASH_SIZE)
-#define TID_ADD1(tid)          (((tid) + 1) == TID_MAX + 1 \
-                                ? TID_MIN : (tid) + 1)
-#define IS_TID_FREE(tid)       (tid_to_hash[tid] == -1)
-
-static int
-get_new_tid(int h)
-{
-  int tid = next_free_tid;
-
-  tid_to_hash[tid] = h;
-  next_free_tid = TID_ADD1(next_free_tid);
-  if (next_free_tid == last_free_tid)
-    {
-      int i;
-
-      for (i = last_free_tid; TID_ADD1(i) != last_free_tid; i = TID_ADD1(i))
-       if (IS_TID_FREE(i))
-         break;
-      if (TID_ADD1(i) == last_free_tid)
-       {
-         error("too many threads");
-         return 0;
-       }
-      next_free_tid = i;
-      for (i = TID_ADD1(i); IS_TID_FREE(i); i = TID_ADD1(i))
-       ;
-      last_free_tid = i;
-    }
-
-  return tid;
-}
-
-static ptid_t
-find_ptid(u_int64_t uniqueid)
-{
-  int h = UNIQUEID_HASH(uniqueid);
-  struct idmap *im;
-
-  LIST_FOREACH(im, &map_hash[h], link)
-    if (im->uniqueid == uniqueid)
-      return MERGEPID(PIDGET(inferior_ptid), im->tid);
-
-  im = xmalloc(sizeof(struct idmap));
-  im->uniqueid = uniqueid;
-  im->tid = get_new_tid(h);
-  LIST_INSERT_HEAD(&map_hash[h], im, link);
-
-  return MERGEPID(PIDGET(inferior_ptid), im->tid);
-}
-
-static void
-free_ptid(ptid_t ptid)
-{
-  int tid = TIDGET(ptid);
-  int h = tid_to_hash[tid];
-  struct idmap *im;
-
-  if (!tid) return;
-
-  LIST_FOREACH(im, &map_hash[h], link)
-    if (im->tid == tid)
-      break;
-
-  if (!im) return;
-
-  LIST_REMOVE(im, link);
-  tid_to_hash[tid] = -1;
-  free(im);
-}
-
-#define READ_OFFSET(field) read_memory(P_thread_##field##_offset,      \
-                                      (char *) &field##_offset,        \
-                                      sizeof(field##_offset))
-
-#define READ_VALUE(name) read_memory(P_thread_##name##_value,  \
-                                    (char *) &name##_value,    \
-                                    sizeof(name##_value))
-
-static void
-read_thread_offsets (void)
-{
-  READ_OFFSET(next);
-  READ_OFFSET(uniqueid);
-  READ_OFFSET(state);
-  READ_OFFSET(name);
-  READ_OFFSET(ctx);
-
-  READ_VALUE(PS_RUNNING);
-  READ_VALUE(PS_DEAD);
-}
-
-#define READ_FIELD(ptr, T, field, result) \
-  read_memory ((ptr) + field##_offset, (char *) &(result), sizeof result)
-
-static u_int64_t
-read_pthread_uniqueid (CORE_ADDR ptr)
-{
-  u_int64_t uniqueid;
-  READ_FIELD(ptr, u_int64_t, uniqueid, uniqueid);
-  return uniqueid;
-}
-
-static CORE_ADDR
-read_pthread_next (CORE_ADDR ptr)
-{
-  CORE_ADDR next;
-  READ_FIELD(ptr, CORE_ADDR, next, next);
-  return next;
-}
-
-static void
-read_cached_pthread (CORE_ADDR ptr, struct cached_pthread *cache)
-{
-  READ_FIELD(ptr, u_int64_t,   uniqueid,       cache->uniqueid);
-  READ_FIELD(ptr, int,         state,          cache->state);
-  READ_FIELD(ptr, CORE_ADDR,   name,           cache->name);
-  READ_FIELD(ptr, ucontext_t,  ctx,            cache->ctx);
-}
-
-static ptid_t
-find_active_ptid (void)
-{
-  CORE_ADDR ptr;
-
-  read_memory ((CORE_ADDR)P_thread_run,
-              (char *)&ptr,
-              sizeof ptr);
-
-  return find_ptid(read_pthread_uniqueid(ptr));
-}
-
-static CORE_ADDR find_pthread_addr PARAMS ((ptid_t ptid));
-static struct cached_pthread * find_pthread PARAMS ((ptid_t ptid));
-
-static CORE_ADDR
-find_pthread_addr (ptid_t ptid)
-{
-  CORE_ADDR ptr;
-
-  if (ptid_equal(ptid, cached_ptid))
-    return cached_pthread_addr;
-
-  read_memory ((CORE_ADDR)P_thread_list,
-              (char *)&ptr,
-              sizeof ptr);
-
-  while (ptr != 0)
-    {
-      if (ptid_equal(find_ptid(read_pthread_uniqueid(ptr)), ptid))
-       {
-         cached_ptid = ptid;
-         cached_pthread_addr = ptr;
-         read_cached_pthread(ptr, &cached_pthread);
-         return ptr;
-       }
-      ptr = read_pthread_next(ptr);
-    }
-
-  return 0;
-}
-
-static struct cached_pthread *
-find_pthread (ptid_t ptid)
-{
-  CORE_ADDR ptr;
-
-  if (ptid_equal(ptid, cached_ptid))
-    return &cached_pthread;
-
-  read_memory ((CORE_ADDR)P_thread_list,
-              (char *)&ptr,
-              sizeof ptr);
-
-  /*
-   * uthreads might not be initialized yet, so we have to use the
-   * kernel thread instead.
-   */
-  if (ptr == 0)
-         ptr = P_thread_kern_thread;
-
-  while (ptr != 0)
-    {
-      if (ptid_equal(find_ptid(read_pthread_uniqueid(ptr)), ptid))
-       {
-         cached_ptid = ptid;
-         cached_pthread_addr = ptr;
-         read_cached_pthread(ptr, &cached_pthread);
-         return &cached_pthread;
-       }
-      ptr = read_pthread_next(ptr);
-    }
-
-#if 0
-  error ("Can't find pthread %d,%d", PIDGET(ptid), TIDGET(ptid));
-#endif
-  return NULL;
-}
-
-\f
-/* Most target vector functions from here on actually just pass through to
-   inftarg.c, as they don't need to do anything specific for threads.  */
-
-/* ARGSUSED */
-static void
-freebsd_uthread_open (char *arg, int from_tty)
-{
-  child_ops.to_open (arg, from_tty);
-}
-
-/* Attach to process PID, then initialize for debugging it
-   and wait for the trace-trap that results from attaching.  */
-
-static void
-freebsd_uthread_attach (char *args, int from_tty)
-{
-  child_ops.to_attach (args, from_tty);
-  push_target (&freebsd_uthread_ops);
-  freebsd_uthread_attaching = 1;
-}
-
-/* After an attach, see if the target is threaded */
-
-static void
-freebsd_uthread_post_attach (int pid)
-{
-  if (freebsd_uthread_active)
-    {
-      read_thread_offsets ();
-      inferior_ptid = find_active_ptid ();
-      add_thread (inferior_ptid);
-    }
-  else
-    {
-      unpush_target (&freebsd_uthread_ops);
-      push_target (&child_ops);
-    }
-
-  freebsd_uthread_attaching = 0;
-}
-
-/* Take a program previously attached to and detaches it.
-   The program resumes execution and will no longer stop
-   on signals, etc.  We'd better not have left any breakpoints
-   in the program or it'll die when it hits one.  For this
-   to work, it may be necessary for the process to have been
-   previously attached.  It *might* work if the program was
-   started via the normal ptrace (PTRACE_TRACEME).  */
-
-static void
-freebsd_uthread_detach (char *args, int from_tty)
-{
-  child_ops.to_detach (args, from_tty);
-}
-
-/* Resume execution of process PID.  If STEP is nozero, then
-   just single step it.  If SIGNAL is nonzero, restart it with that
-   signal activated.  We may have to convert pid from a thread-id to an LWP id
-   for procfs.  */
-
-static void
-freebsd_uthread_resume (ptid_t ptid, int step, enum target_signal signo)
-{
-  if (freebsd_uthread_attaching)
-    {
-      child_ops.to_resume (ptid, step, signo);
-      return;
-    }
-
-  child_ops.to_resume (ptid, step, signo);
-  cached_ptid = MERGEPID(0, 0);
-}
-
-/* Wait for any threads to stop.  We may have to convert PID from a thread id
-   to a LWP id, and vice versa on the way out.  */
-
-static ptid_t
-freebsd_uthread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
-{
-  ptid_t rtnval;
-
-  if (freebsd_uthread_attaching)
-    {
-      return child_ops.to_wait (ptid, ourstatus);
-    }
-
-  rtnval = child_ops.to_wait (ptid, ourstatus);
-
-  if (PIDGET(rtnval) >= 0)
-    {
-      rtnval = find_active_ptid ();
-      if (!in_thread_list (rtnval))
-       add_thread (rtnval);
-    }
-
-  return rtnval;
-}
-
-/* XXX: this needs to be selected by target, not [build] host */
-#ifdef __i386__
-
-#include "i386-tdep.h"
-
-static char sigmap[I386_SSE_NUM_REGS] = /* map reg to sigcontext  */
-{
-  12,                          /* eax */
-  11,                          /* ecx */
-  10,                          /* edx */
-  9,                           /* ebx */
-  8,                           /* esp */
-  7,                           /* ebp */
-  6,                           /* esi */
-  5,                           /* edi */
-  15,                          /* eip */
-  17,                          /* eflags */
-  16,                          /* cs */
-  19,                          /* ss */
-  4,                           /* ds */
-  3,                           /* es */
-  2,                           /* fs */
-  1,                           /* gs */
-  -1, -1, -1, -1, -1, -1, -1,  /* st0-st7 */
-  -1, -1, -1, -1, -1, -1, -1,  /* fctrl-fop */
-  -1, -1, -1, -1, -1, -1, -1,  /* xmm0-xmm7 */
-  -1,                          /* mxcsr */
-};
-
-static char jmpmap[I386_SSE_NUM_REGS] = /* map reg to jmp_buf */
-{
-  6,                           /* eax */
-  -1,                          /* ecx */
-  -1,                          /* edx */
-  1,                           /* ebx */
-  2,                           /* esp */
-  3,                           /* ebp */
-  4,                           /* esi */
-  5,                           /* edi */
-  0,                           /* eip */
-  -1,                          /* eflags */
-  -1,                          /* cs */
-  -1,                          /* ss */
-  -1,                          /* ds */
-  -1,                          /* es */
-  -1,                          /* fs */
-  -1,                          /* gs */
-  -1, -1, -1, -1, -1, -1, -1,  /* st0-st7 */
-  -1, -1, -1, -1, -1, -1, -1,  /* fctrl-fop */
-  -1, -1, -1, -1, -1, -1, -1,  /* xmm0-xmm7 */
-  -1,                          /* mxcsr */
-};
-
-#endif
-
-#ifdef __x86_64__
-
-#include "amd64-tdep.h"
-
-// XXX:DEO     not fully ported from i386 yet!!
-
-
-#define AMD64_NUM_REGS_TOTAL   57
-
-static char sigmap[AMD64_NUM_REGS_TOTAL] = /* map reg to sigcontext  */
-{
-  7,                           /* %rax */
-  8,                           /* %rbx */
-  4,                           /* %rcx */
-  3,                           /* %rdx */
-  2,                           /* %rsi */
-  1,                           /* %rdi */
-  9,                           /* %rbp */
-  23,                          /* %rsp */
-  5,                           /* %r8 */
-  6,                           /* %r9 */
-  10,                          /* %r10 */
-  11,                          /* %r11 */
-  12,                          /* %r12 */
-  13,                          /* %r13 */
-  14,                          /* %r14 */
-  15,                          /* %r15 */
-  20,                          /* %rip */
-  18,                          /* %eflags */
-  21, 24, -1, -1, -1, -1,      /* %cs - %gs */
-  -1, -1, -1, -1, -1 -1, -1, -1,/* %st0 - %st7 */
-  -1, -1, -1, -1, -1 -1, -1, -1,/* %fctrl - %fop */
-  -1, -1, -1, -1, -1 -1, -1, -1,/* %xmm0 - %xmm7 */
-  -1, -1, -1, -1, -1 -1, -1, -1,/* %xmm8 - %xmm15 */
-  -1,                          /* %mxcsr */
-};
-
-static char jmpmap[AMD64_NUM_REGS_TOTAL] = /* map reg to jmp_buf */
-{
-  -1,                          /* %rax */
-  1,                           /* %rbx */
-  -1,                          /* %rcx */
-  -1,                          /* %rdx */
-  -1,                          /* %rsi */
-  -1,                          /* %rdi */
-  3,                           /* %rbp */
-  2,                           /* %rsp */
-  -1,                          /* %r8 */
-  -1,                          /* %r9 */
-  -1,                          /* %r10 */
-  -1,                          /* %r11 */
-  4,                           /* %r12 */
-  5,                           /* %r13 */
-  6,                           /* %r14 */
-  7,                           /* %r15 */
-  0,                           /* %rip */
-  -1,                          /* %eflags */
-  -1, -1, -1, -1, -1, -1,      /* %cs - %gs */
-  -1, -1, -1, -1, -1 -1, -1, -1,/* %st0 - %st7 */
-  -1, -1, -1, -1, -1 -1, -1, -1,/* %fctrl - %fop */
-  -1, -1, -1, -1, -1 -1, -1, -1,/* %xmm0 - %xmm7 */
-  -1, -1, -1, -1, -1 -1, -1, -1,/* %xmm8 - %xmm15 */
-  -1,                          /* %mxcsr */
-};
-
-#endif
-
-#ifdef __alpha__
-
-#include "alpha-tdep.h"
-
-static char sigmap[ALPHA_NUM_REGS] =   /* map reg to sigcontext  */
-{
-  1,  2,  3,  4,  5,  6,  7,  8,  /* v0 - t6 */
-  9,  10, 11, 12, 13, 14, 15, 16, /* t7 - fp */
-  17, 18, 19, 20, 21, 22, 23, 24, /* a0 - t9 */
-  25, 26, 27, 28, 29, 30, 31, 32, /* t10 - zero */
-  38, 39, 40, 41, 42, 43, 44, 45, /* f0 - f7 */
-  46, 47, 48, 49, 50, 51, 52, 53, /* f8 - f15 */
-  54, 55, 56, 57, 58, 59, 60, 61, /* f16 - f23 */
-  62, 63, 64, 65, 66, 67, 68, 69, /* f24 - f31 */
-  33, -1                         /* pc, vfp */
-};
-static char jmpmap[ALPHA_NUM_REGS] = {
-  4,  5,  6,  7,  8,  9,  10, 11, /* v0 - t6 */
-  12, 13, 14, 15, 16, 17, 18, 19, /* t7 - fp */
-  20, 21, 22, 23, 24, 25, 26, 27, /* a0 - t9 */
-  28, 29, 30, 31, 32, 33, 34, 35, /* t10 - zero */
-  37, 38, 39, 40, 41, 42, 43, 44, /* f0 - f7 */
-  45, 46, 47, 48, 49, 50, 51, 52, /* f8 - f15 */
-  53, 54, 55, 56, 57, 58, 59, 60, /* f16 - f23 */
-  61, 62, 63, 64, 65, 66, 67, 68, /* f24 - f31 */
-  2,  -1,                        /* pc, vfp */
-};
-
-#endif
-
-#ifdef __sparc64__
-
-static char sigmap[125] =      /* map reg to sigcontext  */
-{
-  -1
-};
-static char jmpmap[125] = {
-  -1
-};
-
-#endif
-
-static void
-freebsd_uthread_fetch_registers (int regno)
-{
-  struct cached_pthread *thread;
-  int active;
-  int first_regno, last_regno;
-  register_t *regbase;
-  char *regmap;
-
-  if (freebsd_uthread_attaching || TIDGET(inferior_ptid) == 0)
-    {
-      child_ops.to_fetch_registers (regno);
-      return;
-    }
-
-  thread = find_pthread (inferior_ptid);
-  active = (ptid_equal(inferior_ptid, find_active_ptid()));
-
-  if (active)
-    {
-      child_ops.to_fetch_registers (regno);
-      return;
-    }
-
-  if (regno == -1)
-    {
-      first_regno = 0;
-      last_regno = NUM_REGS - 1;
-    }
-  else
-    {
-      first_regno = regno;
-      last_regno = regno;
-    }
-
-  regbase = (register_t*) &thread->ctx.jb[0];
-  regmap = jmpmap;
-
-  for (regno = first_regno; regno <= last_regno; regno++)
-    {
-      if (regmap[regno] == -1)
-       child_ops.to_fetch_registers (regno);
-      else
-       if (thread)
-         supply_register (regno, (char*) &regbase[regmap[regno]]);
-       else
-         supply_register (regno, NULL);
-    }
-}
-
-static void
-freebsd_uthread_store_registers (int regno)
-{
-  struct cached_pthread *thread;
-  CORE_ADDR ptr;
-  int first_regno, last_regno;
-  u_int32_t *regbase;
-  char *regmap;
-
-  if (freebsd_uthread_attaching)
-    {
-      child_ops.to_store_registers (regno);
-      return;
-    }
-
-  thread = find_pthread (inferior_ptid);
-
-  if (thread->state == PS_RUNNING_value)
-    {
-      child_ops.to_store_registers (regno);
-      return;
-    }
-
-  if (regno == -1)
-    {
-      first_regno = 0;
-      last_regno = NUM_REGS - 1;
-    }
-  else
-    {
-      first_regno = regno;
-      last_regno = regno;
-    }
-
-  regbase = (u_int32_t*) &thread->ctx.jb[0];
-  regmap = jmpmap;
-
-  ptr = find_pthread_addr (inferior_ptid);
-  for (regno = first_regno; regno <= last_regno; regno++)
-    {
-      if (regmap[regno] == -1)
-       child_ops.to_store_registers (regno);
-      else
-       {
-         u_int32_t *reg = &regbase[regmap[regno]];
-         int off;
-
-         /* Hang onto cached value */
-/*DEO:XXX*/
-         memcpy(reg, deprecated_registers /*regcache_collect ()*/+ DEPRECATED_REGISTER_BYTE (regno),
-                DEPRECATED_REGISTER_RAW_SIZE (regno));
-
-         /* And push out to inferior */
-         off = (char *) reg - (char *) thread;
-         write_memory (ptr + off, 
-/*DEO:XXX*/
-                       deprecated_registers /*regcache_collect ()*/+ DEPRECATED_REGISTER_BYTE (regno),
-                       DEPRECATED_REGISTER_RAW_SIZE (regno));
-       }
-    }
-}
-
-/* Get ready to modify the registers array.  On machines which store
-   individual registers, this doesn't need to do anything.  On machines
-   which store all the registers in one fell swoop, this makes sure
-   that registers contains all the registers from the program being
-   debugged.  */
-
-static void
-freebsd_uthread_prepare_to_store (void)
-{
-  child_ops.to_prepare_to_store ();
-}
-
-static int
-freebsd_uthread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
-                            int dowrite, struct mem_attrib *attrib,
-                            struct target_ops *target)
-{
-  return child_ops.to_xfer_memory (memaddr, myaddr, len, dowrite,
-                                  attrib, target);
-}
-
-/* Print status information about what we're accessing.  */
-
-static void
-freebsd_uthread_files_info (struct target_ops *ignore)
-{
-  child_ops.to_files_info (ignore);
-}
-
-static void
-freebsd_uthread_kill_inferior (void)
-{
-  child_ops.to_kill ();
-}
-
-static void
-freebsd_uthread_notice_signals (ptid_t ptid)
-{
-  child_ops.to_notice_signals (ptid);
-}
-
-/* Fork an inferior process, and start debugging it with /proc.  */
-
-static void
-freebsd_uthread_create_inferior (char *exec_file, char *allargs, char **env,
-                                int from_tty)
-{
-  child_ops.to_create_inferior (exec_file, allargs, env, from_tty);
-
-  if (PIDGET(inferior_ptid) && freebsd_uthread_active)
-    {
-      read_thread_offsets ();
-      push_target (&freebsd_uthread_ops);
-      inferior_ptid = find_active_ptid ();
-      add_thread (inferior_ptid);
-    }
-}
-
-/* This routine is called to find out if the inferior is using threads.
-   We check for the _thread_run and _thread_list globals. */
-
-void
-freebsd_uthread_new_objfile (struct objfile *objfile)
-{
-  struct minimal_symbol *ms;
-
-  if (!objfile)
-    {
-      freebsd_uthread_active = 0;
-      return;
-    }
-
-  ms = lookup_minimal_symbol ("_thread_run", NULL, objfile);
-
-  if (!ms)
-    return;
-
-  P_thread_run = SYMBOL_VALUE_ADDRESS (ms);
-
-  ms = lookup_minimal_symbol ("_thread_list", NULL, objfile);
-
-  if (!ms)
-    return;
-
-  P_thread_list = SYMBOL_VALUE_ADDRESS (ms);
-
-  ms = lookup_minimal_symbol ("_thread_kern_thread", NULL, objfile);
-
-  if (!ms)
-    return;
-
-  P_thread_kern_thread = SYMBOL_VALUE_ADDRESS (ms);
-
-#define OFFSET_SYM(field)      "_thread_" #field "_offset"
-#define LOOKUP_OFFSET(field)                                           \
-  do {                                                                 \
-      ms = lookup_minimal_symbol (OFFSET_SYM(field), NULL, objfile);   \
-      if (!ms)                                                         \
-       return;                                                         \
-      P_thread_##field##_offset = SYMBOL_VALUE_ADDRESS (ms);           \
-  } while (0);
-
-#define VALUE_SYM(name)                "_thread_" #name "_value"
-#define LOOKUP_VALUE(name)                                             \
-  do {                                                                 \
-       ms = lookup_minimal_symbol (VALUE_SYM(name), NULL, objfile);    \
-      if (!ms)                                                         \
-       return;                                                         \
-      P_thread_##name##_value = SYMBOL_VALUE_ADDRESS (ms);             \
-  } while (0);
-
-  LOOKUP_OFFSET(next);
-  LOOKUP_OFFSET(uniqueid);
-  LOOKUP_OFFSET(state);
-  LOOKUP_OFFSET(name);
-  LOOKUP_OFFSET(ctx);
-
-  LOOKUP_VALUE(PS_RUNNING);
-  LOOKUP_VALUE(PS_DEAD);
-
-  freebsd_uthread_active = 1;
-}
-
-/* Clean up after the inferior dies.  */
-
-static void
-freebsd_uthread_mourn_inferior ()
-{
-  child_ops.to_mourn_inferior ();
-  unpush_target (&freebsd_uthread_ops);
-}
-
-/* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
-
-static int
-freebsd_uthread_can_run ()
-{
-  return child_suppress_run;
-}
-
-static int
-freebsd_uthread_thread_alive (ptid_t ptid)
-{
-  struct cached_pthread *thread;
-  int ret = 0;
-
-  if (freebsd_uthread_attaching)
-    return 1;
-
-  /*
-   * We can get called from child_ops.to_wait() which passes the underlying
-   * pid (without a thread number).
-   */
-  if (TIDGET(ptid) == 0)
-    return 1;
-
-  if (find_pthread_addr (ptid) != 0)
-    {
-      thread = find_pthread (ptid);
-      ret = (thread->state != PS_DEAD_value);
-    }
-
-  if (!ret)
-    free_ptid(ptid);
-
-  return ret;
-}
-
-static void
-freebsd_uthread_stop (void)
-{
-  child_ops.to_stop ();
-}
-
-static void
-freebsd_uthread_find_new_threads (void)
-{
-  CORE_ADDR ptr;
-  int state;
-  u_int64_t uniqueid;
-
-  read_memory ((CORE_ADDR)P_thread_list,
-              (char *)&ptr,
-              sizeof ptr);
-
-  while (ptr != 0)
-    {
-      READ_FIELD(ptr, int, state, state);
-      READ_FIELD(ptr, u_int64_t, uniqueid, uniqueid);
-      if (state != PS_DEAD_value &&
-         !in_thread_list (find_ptid(uniqueid)))
-       add_thread (find_ptid(uniqueid));
-      ptr = read_pthread_next(ptr);
-    }
-}
-
-/* MUST MATCH enum pthread_state */
-static const char *statenames[] = {
-  "RUNNING",
-  "SIGTHREAD",
-  "MUTEX_WAIT",
-  "COND_WAIT",
-  "FDLR_WAIT",
-  "FDLW_WAIT",
-  "FDR_WAIT",
-  "FDW_WAIT",
-  "POLL_WAIT",
-  "FILE_WAIT",
-  "SELECT_WAIT",
-  "SLEEP_WAIT",
-  "WAIT_WAIT",
-  "SIGSUSPEND",
-  "SIGWAIT",
-  "SPINBLOCK",
-  "JOIN",
-  "SUSPENDED",
-  "DEAD",
-  "DEADLOCK",
-};
-
-#if 0
-
-static int
-freebsd_uthread_get_thread_info (ref, selection, info)
-     gdb_threadref *ref;
-     int selection;
-     struct gdb_ext_thread_info *info;
-{
-  int pid = *ref;
-  struct cached_pthread *thread = find_pthread (pid);
-  struct cleanup *old_chain;
-
-  old_chain = save_inferior_pid ();
-  inferior_pid = main_pid;
-
-  memset(&info->threadid, 0, OPAQUETHREADBYTES);
-
-  memcpy(&info->threadid, ref, sizeof *ref);
-  info->active = thread->state == PS_RUNNING_value;
-  strcpy(info->display, statenames[thread->state]);
-  if (thread->name)
-    read_memory ((CORE_ADDR) thread->name, info->shortname, 32);
-  else
-    strcpy(info->shortname, "");
-
-  do_cleanups (old_chain);
-  return (0);
-}
-
-#endif
-
-char *
-freebsd_uthread_pid_to_str (ptid_t ptid)
-{
-  static char buf[30];
-
-  if (DEPRECATED_STREQ (current_target.to_shortname, "freebsd-uthreads"))
-    sprintf (buf, "Process %d, Thread %ld",
-            PIDGET(ptid), TIDGET(ptid));
-  else
-    sprintf (buf, "Process %d", PIDGET(ptid));
-
-  return buf;
-}
-
-\f
-static void
-init_freebsd_uthread_ops ()
-{
-  freebsd_uthread_ops.to_shortname = "freebsd-uthreads";
-  freebsd_uthread_ops.to_longname = "FreeBSD uthreads";
-  freebsd_uthread_ops.to_doc = "FreeBSD user threads support.";
-  freebsd_uthread_ops.to_open = freebsd_uthread_open;
-  freebsd_uthread_ops.to_attach = freebsd_uthread_attach;
-  freebsd_uthread_ops.to_post_attach = freebsd_uthread_post_attach;
-  freebsd_uthread_ops.to_detach = freebsd_uthread_detach;
-  freebsd_uthread_ops.to_resume = freebsd_uthread_resume;
-  freebsd_uthread_ops.to_wait = freebsd_uthread_wait;
-  freebsd_uthread_ops.to_fetch_registers = freebsd_uthread_fetch_registers;
-  freebsd_uthread_ops.to_store_registers = freebsd_uthread_store_registers;
-  freebsd_uthread_ops.to_prepare_to_store = freebsd_uthread_prepare_to_store;
-  freebsd_uthread_ops.to_xfer_memory = freebsd_uthread_xfer_memory;
-  freebsd_uthread_ops.to_files_info = freebsd_uthread_files_info;
-  freebsd_uthread_ops.to_insert_breakpoint = memory_insert_breakpoint;
-  freebsd_uthread_ops.to_remove_breakpoint = memory_remove_breakpoint;
-  freebsd_uthread_ops.to_terminal_init = terminal_init_inferior;
-  freebsd_uthread_ops.to_terminal_inferior = terminal_inferior;
-  freebsd_uthread_ops.to_terminal_ours_for_output = terminal_ours_for_output;
-  freebsd_uthread_ops.to_terminal_ours = terminal_ours;
-  freebsd_uthread_ops.to_terminal_info = child_terminal_info;
-  freebsd_uthread_ops.to_kill = freebsd_uthread_kill_inferior;
-  freebsd_uthread_ops.to_create_inferior = freebsd_uthread_create_inferior;
-  freebsd_uthread_ops.to_mourn_inferior = freebsd_uthread_mourn_inferior;
-  freebsd_uthread_ops.to_can_run = freebsd_uthread_can_run;
-  freebsd_uthread_ops.to_notice_signals = freebsd_uthread_notice_signals;
-  freebsd_uthread_ops.to_thread_alive = freebsd_uthread_thread_alive;
-  freebsd_uthread_ops.to_stop = freebsd_uthread_stop;
-  freebsd_uthread_ops.to_stratum = process_stratum;
-  freebsd_uthread_ops.to_has_all_memory = 1;
-  freebsd_uthread_ops.to_has_memory = 1;
-  freebsd_uthread_ops.to_has_stack = 1;
-  freebsd_uthread_ops.to_has_registers = 1;
-  freebsd_uthread_ops.to_has_execution = 1;
-  freebsd_uthread_ops.to_has_thread_control = 0;
-  freebsd_uthread_ops.to_magic = OPS_MAGIC;
-  freebsd_uthread_ops.to_find_new_threads = freebsd_uthread_find_new_threads;
-  freebsd_uthread_ops.to_pid_to_str = freebsd_uthread_pid_to_str;
-#if 0
-  freebsd_uthread_vec.get_thread_info = freebsd_uthread_get_thread_info;
-#endif
-}
-
-void
-_initialize_freebsd_uthread ()
-{
-  init_freebsd_uthread_ops ();
-  add_target (&freebsd_uthread_ops);
-
-  target_new_objfile_chain = deprecated_target_new_objfile_hook;
-  deprecated_target_new_objfile_hook = freebsd_uthread_new_objfile;
-
-  child_suppress_run = 1;
-}
index 4435ec1..0349507 100644 (file)
@@ -1,4 +1,4 @@
-/* generated for  gcc (DragonFly) 4.4.5 */
+/* generated for  cc 4.7.3 [DragonFly] Release/2013-04-11 */
 
 #ifndef GCC_GENERATED_STDINT_H
 #define GCC_GENERATED_STDINT_H 1
index f96cbe0..72a7d21 100644 (file)
@@ -1,6 +1,6 @@
 /* JIT declarations for GDB, the GNU Debugger.
 
-   Copyright (C) 2011-2012 Free Software Foundation, Inc.
+   Copyright (C) 2011-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -36,6 +36,7 @@ extern "C" {
 #ifdef __cplusplus
 #define GDB_DECLARE_GPL_COMPATIBLE_READER       \
   extern "C" {                                  \
+  extern int plugin_is_GPL_compatible (void);   \
   extern int plugin_is_GPL_compatible (void)    \
   {                                             \
     return 0;                                   \
@@ -44,7 +45,8 @@ extern "C" {
 
 #else
 
-#define GDB_DECLARE_GPL_COMPATIBLE_READER
+#define GDB_DECLARE_GPL_COMPATIBLE_READER       \
+  extern int plugin_is_GPL_compatible (void);   \
   extern int plugin_is_GPL_compatible (void)    \
   {                                             \
     return 0;                                   \
diff --git a/gnu/usr.bin/gdb/libgnu/Makefile b/gnu/usr.bin/gdb/libgnu/Makefile
new file mode 100644 (file)
index 0000000..7c50a45
--- /dev/null
@@ -0,0 +1,12 @@
+.include "../Makefile.inc"
+
+LIB=   gnu
+INTERNALLIB=   YES
+
+SRCS=  fnmatch.c localcharset.c memmem.c strnlen1.c wctype-h.c
+
+.PATH: ${BASEDIR}/gdb/gnulib/import
+
+CFLAGS+=       -I${.CURDIR} -I${.OBJDIR} -I${BASEDIR}/gdb/gnulib/import
+
+.include <bsd.lib.mk>
diff --git a/gnu/usr.bin/gdb/libgnu/alloca.h b/gnu/usr.bin/gdb/libgnu/alloca.h
new file mode 100644 (file)
index 0000000..a0d618b
--- /dev/null
@@ -0,0 +1,64 @@
+/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
+/* Memory allocation on the stack.
+
+   Copyright (C) 1995, 1999, 2001-2004, 2006-2012 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 3, 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, see
+   <http://www.gnu.org/licenses/>.
+  */
+
+/* Avoid using the symbol _ALLOCA_H here, as Bison assumes _ALLOCA_H
+   means there is a real alloca function.  */
+#ifndef _GL_ALLOCA_H
+#define _GL_ALLOCA_H
+
+/* alloca (N) returns a pointer to N bytes of memory
+   allocated on the stack, which will last until the function returns.
+   Use of alloca should be avoided:
+     - inside arguments of function calls - undefined behaviour,
+     - in inline functions - the allocation may actually last until the
+       calling function returns,
+     - for huge N (say, N >= 65536) - you never know how large (or small)
+       the stack is, and when the stack cannot fulfill the memory allocation
+       request, the program just crashes.
+ */
+
+#ifndef alloca
+# ifdef __GNUC__
+#  define alloca __builtin_alloca
+# elif defined _AIX
+#  define alloca __alloca
+# elif defined _MSC_VER
+#  include <malloc.h>
+#  define alloca _alloca
+# elif defined __DECC && defined __VMS
+#  define alloca __ALLOCA
+# elif defined __TANDEM && defined _TNS_E_TARGET
+#  ifdef  __cplusplus
+extern "C"
+#  endif
+void *_alloca (unsigned short);
+#  pragma intrinsic (_alloca)
+#  define alloca _alloca
+# else
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C"
+#  endif
+void *alloca (size_t);
+# endif
+#endif
+
+#endif /* _GL_ALLOCA_H */
diff --git a/gnu/usr.bin/gdb/libgnu/config.h b/gnu/usr.bin/gdb/libgnu/config.h
new file mode 100644 (file)
index 0000000..c76031e
--- /dev/null
@@ -0,0 +1,639 @@
+/* config.h.  Generated from config.in by configure.  */
+/* config.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to the number of bits in type 'ptrdiff_t'. */
+/* #undef BITSIZEOF_PTRDIFF_T */
+
+/* Define to the number of bits in type 'sig_atomic_t'. */
+/* #undef BITSIZEOF_SIG_ATOMIC_T */
+
+/* Define to the number of bits in type 'size_t'. */
+/* #undef BITSIZEOF_SIZE_T */
+
+/* Define to the number of bits in type 'wchar_t'. */
+/* #undef BITSIZEOF_WCHAR_T */
+
+/* Define to the number of bits in type 'wint_t'. */
+/* #undef BITSIZEOF_WINT_T */
+
+/* Define to one of '_getb67', 'GETB67', 'getb67' for Cray-2 and Cray-YMP
+   systems. This function is required for 'alloca.c' support on those systems.
+   */
+/* #undef CRAY_STACKSEG_END */
+
+/* Define to 1 if using 'alloca.c'. */
+/* #undef C_ALLOCA */
+
+/* Define to 1 when the gnulib module mbrtowc should be tested. */
+#define GNULIB_TEST_MBRTOWC 1
+
+/* Define to 1 when the gnulib module mbsinit should be tested. */
+#define GNULIB_TEST_MBSINIT 1
+
+/* Define to 1 when the gnulib module mbsrtowcs should be tested. */
+#define GNULIB_TEST_MBSRTOWCS 1
+
+/* Define to 1 when the gnulib module memchr should be tested. */
+#define GNULIB_TEST_MEMCHR 1
+
+/* Define to 1 when the gnulib module memmem should be tested. */
+#define GNULIB_TEST_MEMMEM 1
+
+/* Define to 1 if you have 'alloca' after including <alloca.h>, a header that
+   may be supplied by this distribution. */
+#define HAVE_ALLOCA 1
+
+/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
+   */
+/* #undef HAVE_ALLOCA_H */
+
+/* Define to 1 if you have the <bp-sym.h> header file. */
+/* #undef HAVE_BP_SYM_H */
+
+/* Define to 1 if you have the 'btowc' function. */
+#define HAVE_BTOWC 1
+
+/* Define to 1 if you have the declaration of `getc_unlocked', and to 0 if you
+   don't. */
+#define HAVE_DECL_GETC_UNLOCKED 1
+
+/* Define to 1 if you have the declaration of `isblank', and to 0 if you
+   don't. */
+#define HAVE_DECL_ISBLANK 1
+
+/* Define to 1 if you have the declaration of `mbrtowc', and to 0 if you
+   don't. */
+/* #undef HAVE_DECL_MBRTOWC */
+
+/* Define to 1 if you have the declaration of `mbsinit', and to 0 if you
+   don't. */
+/* #undef HAVE_DECL_MBSINIT */
+
+/* Define to 1 if you have the declaration of `mbsrtowcs', and to 0 if you
+   don't. */
+/* #undef HAVE_DECL_MBSRTOWCS */
+
+/* Define to 1 if you have the declaration of `memmem', and to 0 if you don't.
+   */
+#define HAVE_DECL_MEMMEM 1
+
+/* Define to 1 if you have the declaration of `towlower', and to 0 if you
+   don't. */
+/* #undef HAVE_DECL_TOWLOWER */
+
+/* Define to 1 if you have the <features.h> header file. */
+/* #undef HAVE_FEATURES_H */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the 'isblank' function. */
+#define HAVE_ISBLANK 1
+
+/* Define to 1 if you have the 'iswcntrl' function. */
+#define HAVE_ISWCNTRL 1
+
+/* Define to 1 if you have the 'iswctype' function. */
+#define HAVE_ISWCTYPE 1
+
+/* Define if you have <langinfo.h> and nl_langinfo(CODESET). */
+#define HAVE_LANGINFO_CODESET 1
+
+/* Define to 1 if the system has the type 'long long int'. */
+#define HAVE_LONG_LONG_INT 1
+
+/* Define to 1 if mmap()'s MAP_ANONYMOUS flag is available after including
+   config.h and <sys/mman.h>. */
+#define HAVE_MAP_ANONYMOUS 1
+
+/* Define to 1 if you have the 'mbrtowc' function. */
+#define HAVE_MBRTOWC 1
+
+/* Define to 1 if you have the 'mbsinit' function. */
+#define HAVE_MBSINIT 1
+
+/* Define to 1 if you have the 'mbsrtowcs' function. */
+#define HAVE_MBSRTOWCS 1
+
+/* Define to 1 if <wchar.h> declares mbstate_t. */
+#define HAVE_MBSTATE_T 1
+
+/* Define to 1 if you have the `memmem' function. */
+#define HAVE_MEMMEM 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the 'mempcpy' function. */
+#define HAVE_MEMPCPY 1
+
+/* Define to 1 if you have the 'mprotect' function. */
+#define HAVE_MPROTECT 1
+
+/* Define to 1 if btowc is declared even after undefining macros. */
+#define HAVE_RAW_DECL_BTOWC 1
+
+/* Define to 1 if ffsl is declared even after undefining macros. */
+#define HAVE_RAW_DECL_FFSL 1
+
+/* Define to 1 if ffsll is declared even after undefining macros. */
+#define HAVE_RAW_DECL_FFSLL 1
+
+/* Define to 1 if imaxabs is declared even after undefining macros. */
+#define HAVE_RAW_DECL_IMAXABS 1
+
+/* Define to 1 if imaxdiv is declared even after undefining macros. */
+#define HAVE_RAW_DECL_IMAXDIV 1
+
+/* Define to 1 if iswctype is declared even after undefining macros. */
+#define HAVE_RAW_DECL_ISWCTYPE 1
+
+/* Define to 1 if mbrlen is declared even after undefining macros. */
+#define HAVE_RAW_DECL_MBRLEN 1
+
+/* Define to 1 if mbrtowc is declared even after undefining macros. */
+#define HAVE_RAW_DECL_MBRTOWC 1
+
+/* Define to 1 if mbsinit is declared even after undefining macros. */
+#define HAVE_RAW_DECL_MBSINIT 1
+
+/* Define to 1 if mbsnrtowcs is declared even after undefining macros. */
+#define HAVE_RAW_DECL_MBSNRTOWCS 1
+
+/* Define to 1 if mbsrtowcs is declared even after undefining macros. */
+#define HAVE_RAW_DECL_MBSRTOWCS 1
+
+/* Define to 1 if memmem is declared even after undefining macros. */
+#define HAVE_RAW_DECL_MEMMEM 1
+
+/* Define to 1 if mempcpy is declared even after undefining macros. */
+#define HAVE_RAW_DECL_MEMPCPY 1
+
+/* Define to 1 if memrchr is declared even after undefining macros. */
+#define HAVE_RAW_DECL_MEMRCHR 1
+
+/* Define to 1 if rawmemchr is declared even after undefining macros. */
+/* #undef HAVE_RAW_DECL_RAWMEMCHR */
+
+/* Define to 1 if stpcpy is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STPCPY 1
+
+/* Define to 1 if stpncpy is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STPNCPY 1
+
+/* Define to 1 if strcasestr is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRCASESTR 1
+
+/* Define to 1 if strchrnul is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRCHRNUL 1
+
+/* Define to 1 if strdup is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRDUP 1
+
+/* Define to 1 if strerror_r is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRERROR_R 1
+
+/* Define to 1 if strncat is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRNCAT 1
+
+/* Define to 1 if strndup is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRNDUP 1
+
+/* Define to 1 if strnlen is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRNLEN 1
+
+/* Define to 1 if strpbrk is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRPBRK 1
+
+/* Define to 1 if strsep is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRSEP 1
+
+/* Define to 1 if strsignal is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRSIGNAL 1
+
+/* Define to 1 if strtoimax is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRTOIMAX 1
+
+/* Define to 1 if strtok_r is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRTOK_R 1
+
+/* Define to 1 if strtoumax is declared even after undefining macros. */
+#define HAVE_RAW_DECL_STRTOUMAX 1
+
+/* Define to 1 if strverscmp is declared even after undefining macros. */
+/* #undef HAVE_RAW_DECL_STRVERSCMP */
+
+/* Define to 1 if towctrans is declared even after undefining macros. */
+#define HAVE_RAW_DECL_TOWCTRANS 1
+
+/* Define to 1 if wcpcpy is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCPCPY 1
+
+/* Define to 1 if wcpncpy is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCPNCPY 1
+
+/* Define to 1 if wcrtomb is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCRTOMB 1
+
+/* Define to 1 if wcscasecmp is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSCASECMP 1
+
+/* Define to 1 if wcscat is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSCAT 1
+
+/* Define to 1 if wcschr is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSCHR 1
+
+/* Define to 1 if wcscmp is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSCMP 1
+
+/* Define to 1 if wcscoll is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSCOLL 1
+
+/* Define to 1 if wcscpy is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSCPY 1
+
+/* Define to 1 if wcscspn is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSCSPN 1
+
+/* Define to 1 if wcsdup is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSDUP 1
+
+/* Define to 1 if wcslen is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSLEN 1
+
+/* Define to 1 if wcsncasecmp is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSNCASECMP 1
+
+/* Define to 1 if wcsncat is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSNCAT 1
+
+/* Define to 1 if wcsncmp is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSNCMP 1
+
+/* Define to 1 if wcsncpy is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSNCPY 1
+
+/* Define to 1 if wcsnlen is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSNLEN 1
+
+/* Define to 1 if wcsnrtombs is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSNRTOMBS 1
+
+/* Define to 1 if wcspbrk is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSPBRK 1
+
+/* Define to 1 if wcsrchr is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSRCHR 1
+
+/* Define to 1 if wcsrtombs is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSRTOMBS 1
+
+/* Define to 1 if wcsspn is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSSPN 1
+
+/* Define to 1 if wcsstr is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSSTR 1
+
+/* Define to 1 if wcstok is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSTOK 1
+
+/* Define to 1 if wcswidth is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSWIDTH 1
+
+/* Define to 1 if wcsxfrm is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCSXFRM 1
+
+/* Define to 1 if wctob is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCTOB 1
+
+/* Define to 1 if wctrans is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCTRANS 1
+
+/* Define to 1 if wctype is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCTYPE 1
+
+/* Define to 1 if wcwidth is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WCWIDTH 1
+
+/* Define to 1 if wmemchr is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WMEMCHR 1
+
+/* Define to 1 if wmemcmp is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WMEMCMP 1
+
+/* Define to 1 if wmemcpy is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WMEMCPY 1
+
+/* Define to 1 if wmemmove is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WMEMMOVE 1
+
+/* Define to 1 if wmemset is declared even after undefining macros. */
+#define HAVE_RAW_DECL_WMEMSET 1
+
+/* Define to 1 if 'sig_atomic_t' is a signed integer type. */
+/* #undef HAVE_SIGNED_SIG_ATOMIC_T */
+
+/* Define to 1 if 'wchar_t' is a signed integer type. */
+/* #undef HAVE_SIGNED_WCHAR_T */
+
+/* Define to 1 if 'wint_t' is a signed integer type. */
+/* #undef HAVE_SIGNED_WINT_T */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the 'symlink' function. */
+#define HAVE_SYMLINK 1
+
+/* Define to 1 if you have the <sys/bitypes.h> header file. */
+/* #undef HAVE_SYS_BITYPES_H */
+
+/* Define to 1 if you have the <sys/inttypes.h> header file. */
+/* #undef HAVE_SYS_INTTYPES_H */
+
+/* Define to 1 if you have the <sys/mman.h> header file. */
+#define HAVE_SYS_MMAN_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the `towlower' function. */
+#define HAVE_TOWLOWER 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if the system has the type 'unsigned long long int'. */
+#define HAVE_UNSIGNED_LONG_LONG_INT 1
+
+/* Define to 1 if you have the <wchar.h> header file. */
+#define HAVE_WCHAR_H 1
+
+/* Define if you have the 'wchar_t' type. */
+#define HAVE_WCHAR_T 1
+
+/* Define to 1 if you have the <wctype.h> header file. */
+#define HAVE_WCTYPE_H 1
+
+/* Define if you have the 'wint_t' type. */
+#define HAVE_WINT_T 1
+
+/* Define to 1 if you have the 'wmemchr' function. */
+#define HAVE_WMEMCHR 1
+
+/* Define to 1 if you have the 'wmemcpy' function. */
+#define HAVE_WMEMCPY 1
+
+/* Define to 1 if you have the 'wmempcpy' function. */
+/* #undef HAVE_WMEMPCPY */
+
+/* Define to 1 if O_NOATIME works. */
+#define HAVE_WORKING_O_NOATIME 0
+
+/* Define to 1 if O_NOFOLLOW works. */
+#define HAVE_WORKING_O_NOFOLLOW 1
+
+/* Define to 1 if the system has the type `_Bool'. */
+#define HAVE__BOOL 1
+
+/* Define to a substitute value for mmap()'s MAP_ANONYMOUS flag. */
+#define MAP_ANONYMOUS MAP_ANON
+
+/* Define if the mbrtowc function has the NULL pwc argument bug. */
+/* #undef MBRTOWC_NULL_ARG1_BUG */
+
+/* Define if the mbrtowc function has the NULL string argument bug. */
+/* #undef MBRTOWC_NULL_ARG2_BUG */
+
+/* Define if the mbrtowc function does not return 0 for a NUL character. */
+/* #undef MBRTOWC_NUL_RETVAL_BUG */
+
+/* Define if the mbrtowc function returns a wrong return value. */
+/* #undef MBRTOWC_RETVAL_BUG */
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* Define if <inttypes.h> exists and defines unusable PRI* macros. */
+/* #undef PRI_MACROS_BROKEN */
+
+/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
+   'ptrdiff_t'. */
+/* #undef PTRDIFF_T_SUFFIX */
+
+/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
+   'sig_atomic_t'. */
+/* #undef SIG_ATOMIC_T_SUFFIX */
+
+/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
+   'size_t'. */
+/* #undef SIZE_T_SUFFIX */
+
+/* If using the C implementation of alloca, define if you know the
+   direction of stack growth for your system; otherwise it will be
+   automatically deduced at runtime.
+        STACK_DIRECTION > 0 => grows toward higher addresses
+        STACK_DIRECTION < 0 => grows toward lower addresses
+        STACK_DIRECTION = 0 => direction of growth unknown */
+/* #undef STACK_DIRECTION */
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
+   'wchar_t'. */
+/* #undef WCHAR_T_SUFFIX */
+
+/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
+   'wint_t'. */
+/* #undef WINT_T_SUFFIX */
+
+/* Define to 1 if on MINIX. */
+/* #undef _MINIX */
+
+/* The _Noreturn keyword of C11.  */
+#if ! (defined _Noreturn \
+       || (defined __STDC_VERSION__ && 201112 <= __STDC_VERSION__))
+# if (3 <= __GNUC__ || (__GNUC__ == 2 && 8 <= __GNUC_MINOR__) \
+      || 0x5110 <= __SUNPRO_C)
+#  define _Noreturn __attribute__ ((__noreturn__))
+# elif defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn
+# endif
+#endif
+
+
+/* Define to 2 if the system does not provide POSIX.1 features except with
+   this defined. */
+/* #undef _POSIX_1_SOURCE */
+
+/* Define to 1 if you need to in order for 'stat' and other things to work. */
+/* #undef _POSIX_SOURCE */
+
+/* Define to 500 only on HP-UX. */
+/* #undef _XOPEN_SOURCE */
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable general extensions on Mac OS X.  */
+#ifndef _DARWIN_C_SOURCE
+# define _DARWIN_C_SOURCE 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable threading extensions on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+
+
+/* _GL_INLINE is a portable alternative to ISO C99 plain 'inline'.
+   _GL_EXTERN_INLINE is a portable alternative to 'extern inline'.
+   _GL_INLINE_HEADER_BEGIN contains useful stuff to put
+     in an include file, before uses of _GL_INLINE.
+     It suppresses GCC's bogus "no previous prototype for 'FOO'" diagnostic,
+     when FOO is an inline function in the header; see
+     <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=54113>.
+   _GL_INLINE_HEADER_END contains useful stuff to put
+     in the same include file, after uses of _GL_INLINE.
+
+   Suppress the use of extern inline on Apple's platforms,
+   as Libc-825.25 (2012-09-19) is incompatible with it; see
+   <http://lists.gnu.org/archive/html/bug-gnulib/2012-12/msg00023.html>.
+   Perhaps Apple will fix this some day.  */
+#if ((__GNUC__ \
+      ? defined __GNUC_STDC_INLINE__ && __GNUC_STDC_INLINE__ \
+      : 199901L <= __STDC_VERSION__) \
+     && !defined __APPLE__)
+# define _GL_INLINE inline
+# define _GL_EXTERN_INLINE extern inline
+#elif 2 < __GNUC__ + (7 <= __GNUC_MINOR__) && !defined __APPLE__
+# if __GNUC_GNU_INLINE__
+   /* __gnu_inline__ suppresses a GCC 4.2 diagnostic.  */
+#  define _GL_INLINE extern inline __attribute__ ((__gnu_inline__))
+# else
+#  define _GL_INLINE extern inline
+# endif
+# define _GL_EXTERN_INLINE extern
+#else
+# define _GL_INLINE static _GL_UNUSED
+# define _GL_EXTERN_INLINE static _GL_UNUSED
+#endif
+
+#if 4 < __GNUC__ + (6 <= __GNUC_MINOR__)
+# if defined __GNUC_STDC_INLINE__ && __GNUC_STDC_INLINE__
+#  define _GL_INLINE_HEADER_CONST_PRAGMA
+# else
+#  define _GL_INLINE_HEADER_CONST_PRAGMA \
+     _Pragma ("GCC diagnostic ignored \"-Wsuggest-attribute=const\"")
+# endif
+# define _GL_INLINE_HEADER_BEGIN \
+    _Pragma ("GCC diagnostic push") \
+    _Pragma ("GCC diagnostic ignored \"-Wmissing-prototypes\"") \
+    _Pragma ("GCC diagnostic ignored \"-Wmissing-declarations\"") \
+    _GL_INLINE_HEADER_CONST_PRAGMA
+# define _GL_INLINE_HEADER_END \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define _GL_INLINE_HEADER_BEGIN
+# define _GL_INLINE_HEADER_END
+#endif
+
+/* Define to a replacement function name for fnmatch(). */
+#define fnmatch gnu_fnmatch
+
+/* Work around a bug in Apple GCC 4.0.1 build 5465: In C99 mode, it supports
+   the ISO C 99 semantics of 'extern inline' (unlike the GNU C semantics of
+   earlier versions), but does not display it by setting __GNUC_STDC_INLINE__.
+   __APPLE__ && __MACH__ test for Mac OS X.
+   __APPLE_CC__ tests for the Apple compiler and its version.
+   __STDC_VERSION__ tests for the C99 mode.  */
+#if defined __APPLE__ && defined __MACH__ && __APPLE_CC__ >= 5465 && !defined __cplusplus && __STDC_VERSION__ >= 199901L && !defined __GNUC_STDC_INLINE__
+# define __GNUC_STDC_INLINE__ 1
+#endif
+
+/* Define to a type if <wchar.h> does not define. */
+/* #undef mbstate_t */
+
+/* Define to the equivalent of the C99 'restrict' keyword, or to
+   nothing if this is not supported.  Do not define if restrict is
+   supported directly.  */
+#define restrict __restrict
+/* Work around a bug in Sun C++: it does not support _Restrict or
+   __restrict__, even though the corresponding Sun C compiler ends up with
+   "#define restrict _Restrict" or "#define restrict __restrict__" in the
+   previous line.  Perhaps some future version of Sun C++ will work with
+   restrict; if so, hopefully it defines __RESTRICT like Sun C does.  */
+#if defined __SUNPRO_CC && !defined __RESTRICT
+# define _Restrict
+# define __restrict__
+#endif
+
+/* Define as a marker that can be attached to declarations that might not
+    be used.  This helps to reduce warnings, such as from
+    GCC -Wunused-parameter.  */
+#if __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
+# define _GL_UNUSED __attribute__ ((__unused__))
+#else
+# define _GL_UNUSED
+#endif
+/* The name _UNUSED_PARAMETER_ is an earlier spelling, although the name
+   is a misnomer outside of parameter lists.  */
+#define _UNUSED_PARAMETER_ _GL_UNUSED
+
+/* The __pure__ attribute was added in gcc 2.96.  */
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
+# define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
+#else
+# define _GL_ATTRIBUTE_PURE /* empty */
+#endif
+
+/* The __const__ attribute was added in gcc 2.95.  */
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
+# define _GL_ATTRIBUTE_CONST __attribute__ ((__const__))
+#else
+# define _GL_ATTRIBUTE_CONST /* empty */
+#endif
+
diff --git a/gnu/usr.bin/gdb/libgnu/configmake.h b/gnu/usr.bin/gdb/libgnu/configmake.h
new file mode 100644 (file)
index 0000000..da78b65
--- /dev/null
@@ -0,0 +1,27 @@
+/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
+#define PREFIX "/usr"
+#define EXEC_PREFIX "/usr"
+#define BINDIR "/usr/bin"
+#define SBINDIR "/usr/sbin"
+#define LIBEXECDIR "/usr/libexec"
+#define DATAROOTDIR "/usr/share"
+#define DATADIR "/usr/share"
+#define SYSCONFDIR "/usr/etc"
+#define SHAREDSTATEDIR "/usr/com"
+#define LOCALSTATEDIR "/usr/var"
+#define INCLUDEDIR "/usr/include"
+#define OLDINCLUDEDIR "/usr/include"
+#define DOCDIR "/usr/share/doc/"
+#define INFODIR "/usr/info"
+#define HTMLDIR "/usr/share/doc/"
+#define DVIDIR "/usr/share/doc/"
+#define PDFDIR "/usr/share/doc/"
+#define PSDIR "/usr/share/doc/"
+#define LIBDIR "/usr/lib"
+#define LISPDIR "/usr/share/emacs/site-lisp"
+#define LOCALEDIR "/usr/sharee"
+#define MANDIR "/usr/man"
+#define PKGDATADIR "/usr/share/libgnu"
+#define PKGINCLUDEDIR "/usr/include/libgnu"
+#define PKGLIBDIR "/usr/lib/libgnu"
+#define PKGLIBEXECDIR "/usr/libexec/libgnu"
diff --git a/gnu/usr.bin/gdb/libgnu/fnmatch.h b/gnu/usr.bin/gdb/libgnu/fnmatch.h
new file mode 100644 (file)
index 0000000..778042a
--- /dev/null
@@ -0,0 +1,78 @@
+/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
+/* Copyright (C) 1991-1993, 1996-1999, 2001-2003, 2005, 2007, 2009-2012 Free
+   Software Foundation, Inc.
+
+   This file is part of the GNU C Library.
+
+   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 3, 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, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef _FNMATCH_H
+#define _FNMATCH_H      1
+
+/* The definition of _GL_ARG_NONNULL is copied here.  */
+/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
+   that the values passed as arguments n, ..., m must be non-NULL pointers.
+   n = 1 stands for the first argument, n = 2 for the second argument etc.  */
+#ifndef _GL_ARG_NONNULL
+# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
+#  define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
+# else
+#  define _GL_ARG_NONNULL(params)
+# endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* We #undef these before defining them because some losing systems
+   (HP-UX A.08.07 for example) define these in <unistd.h>.  */
+#undef  FNM_PATHNAME
+#undef  FNM_NOESCAPE
+#undef  FNM_PERIOD
+
+/* Bits set in the FLAGS argument to 'fnmatch'.  */
+#define FNM_PATHNAME    (1 << 0) /* No wildcard can ever match '/'.  */
+#define FNM_NOESCAPE    (1 << 1) /* Backslashes don't quote special chars.  */
+#define FNM_PERIOD      (1 << 2) /* Leading '.' is matched only explicitly.  */
+
+#if !defined _POSIX_C_SOURCE || _POSIX_C_SOURCE < 2 || defined _GNU_SOURCE
+# define FNM_FILE_NAME   FNM_PATHNAME   /* Preferred GNU name.  */
+# define FNM_LEADING_DIR (1 << 3)       /* Ignore '/...' after a match.  */
+# define FNM_CASEFOLD    (1 << 4)       /* Compare without regard to case.  */
+# define FNM_EXTMATCH    (1 << 5)       /* Use ksh-like extended matching. */
+#endif
+
+/* Value returned by 'fnmatch' if STRING does not match PATTERN.  */
+#define FNM_NOMATCH     1
+
+/* This value is returned if the implementation does not support
+   'fnmatch'.  Since this is not the case here it will never be
+   returned but the conformance test suites still require the symbol
+   to be defined.  */
+#ifdef _XOPEN_SOURCE
+# define FNM_NOSYS      (-1)
+#endif
+
+/* Match NAME against the file name pattern PATTERN,
+   returning zero if it matches, FNM_NOMATCH if not.  */
+extern int fnmatch (const char *__pattern, const char *__name,
+                    int __flags)
+     _GL_ARG_NONNULL ((1, 2));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* fnmatch.h */
diff --git a/gnu/usr.bin/gdb/libgnu/string.h b/gnu/usr.bin/gdb/libgnu/string.h
new file mode 100644 (file)
index 0000000..375e4f2
--- /dev/null
@@ -0,0 +1,1341 @@
+/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
+/* A GNU-like <string.h>.
+
+   Copyright (C) 1995-1996, 2001-2012 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 3, 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, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef _GL_STRING_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+
+/* The include_next requires a split double-inclusion guard.  */
+#include_next <string.h>
+
+#ifndef _GL_STRING_H
+#define _GL_STRING_H
+
+/* NetBSD 5.0 mis-defines NULL.  */
+#include <stddef.h>
+
+/* MirBSD defines mbslen as a macro.  */
+#if 0 && defined __MirBSD__
+# include <wchar.h>
+#endif
+
+/* The __attribute__ feature is available in gcc versions 2.5 and later.
+   The attribute __pure__ was added in gcc 2.96.  */
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
+# define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
+#else
+# define _GL_ATTRIBUTE_PURE /* empty */
+#endif
+
+/* NetBSD 5.0 declares strsignal in <unistd.h>, not in <string.h>.  */
+/* But in any case avoid namespace pollution on glibc systems.  */
+#if (0 || defined GNULIB_POSIXCHECK) && defined __NetBSD__ \
+    && ! defined __GLIBC__
+# include <unistd.h>
+#endif
+
+/* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
+#ifndef _GL_CXXDEFS_H
+#define _GL_CXXDEFS_H
+
+/* The three most frequent use cases of these macros are:
+
+   * For providing a substitute for a function that is missing on some
+     platforms, but is declared and works fine on the platforms on which
+     it exists:
+
+       #if @GNULIB_FOO@
+       # if !@HAVE_FOO@
+       _GL_FUNCDECL_SYS (foo, ...);
+       # endif
+       _GL_CXXALIAS_SYS (foo, ...);
+       _GL_CXXALIASWARN (foo);
+       #elif defined GNULIB_POSIXCHECK
+       ...
+       #endif
+
+   * For providing a replacement for a function that exists on all platforms,
+     but is broken/insufficient and needs to be replaced on some platforms:
+
+       #if @GNULIB_FOO@
+       # if @REPLACE_FOO@
+       #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+       #   undef foo
+       #   define foo rpl_foo
+       #  endif
+       _GL_FUNCDECL_RPL (foo, ...);
+       _GL_CXXALIAS_RPL (foo, ...);
+       # else
+       _GL_CXXALIAS_SYS (foo, ...);
+       # endif
+       _GL_CXXALIASWARN (foo);
+       #elif defined GNULIB_POSIXCHECK
+       ...
+       #endif
+
+   * For providing a replacement for a function that exists on some platforms
+     but is broken/insufficient and needs to be replaced on some of them and
+     is additionally either missing or undeclared on some other platforms:
+
+       #if @GNULIB_FOO@
+       # if @REPLACE_FOO@
+       #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+       #   undef foo
+       #   define foo rpl_foo
+       #  endif
+       _GL_FUNCDECL_RPL (foo, ...);
+       _GL_CXXALIAS_RPL (foo, ...);
+       # else
+       #  if !@HAVE_FOO@   or   if !@HAVE_DECL_FOO@
+       _GL_FUNCDECL_SYS (foo, ...);
+       #  endif
+       _GL_CXXALIAS_SYS (foo, ...);
+       # endif
+       _GL_CXXALIASWARN (foo);
+       #elif defined GNULIB_POSIXCHECK
+       ...
+       #endif
+*/
+
+/* _GL_EXTERN_C declaration;
+   performs the declaration with C linkage.  */
+#if defined __cplusplus
+# define _GL_EXTERN_C extern "C"
+#else
+# define _GL_EXTERN_C extern
+#endif
+
+/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);
+   declares a replacement function, named rpl_func, with the given prototype,
+   consisting of return type, parameters, and attributes.
+   Example:
+     _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)
+                                  _GL_ARG_NONNULL ((1)));
+ */
+#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \
+  _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)
+#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \
+  _GL_EXTERN_C rettype rpl_func parameters_and_attributes
+
+/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);
+   declares the system function, named func, with the given prototype,
+   consisting of return type, parameters, and attributes.
+   Example:
+     _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)
+                                  _GL_ARG_NONNULL ((1)));
+ */
+#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \
+  _GL_EXTERN_C rettype func parameters_and_attributes
+
+/* _GL_CXXALIAS_RPL (func, rettype, parameters);
+   declares a C++ alias called GNULIB_NAMESPACE::func
+   that redirects to rpl_func, if GNULIB_NAMESPACE is defined.
+   Example:
+     _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));
+ */
+#define _GL_CXXALIAS_RPL(func,rettype,parameters) \
+  _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
+    namespace GNULIB_NAMESPACE                                \
+    {                                                         \
+      rettype (*const func) parameters = ::rpl_func;          \
+    }                                                         \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);
+   is like  _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);
+   except that the C function rpl_func may have a slightly different
+   declaration.  A cast is used to silence the "invalid conversion" error
+   that would otherwise occur.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
+    namespace GNULIB_NAMESPACE                                     \
+    {                                                              \
+      rettype (*const func) parameters =                           \
+        reinterpret_cast<rettype(*)parameters>(::rpl_func);        \
+    }                                                              \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIAS_SYS (func, rettype, parameters);
+   declares a C++ alias called GNULIB_NAMESPACE::func
+   that redirects to the system provided function func, if GNULIB_NAMESPACE
+   is defined.
+   Example:
+     _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));
+ */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+  /* If we were to write
+       rettype (*const func) parameters = ::func;
+     like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls
+     better (remove an indirection through a 'static' pointer variable),
+     but then the _GL_CXXALIASWARN macro below would cause a warning not only
+     for uses of ::func but also for uses of GNULIB_NAMESPACE::func.  */
+# define _GL_CXXALIAS_SYS(func,rettype,parameters) \
+    namespace GNULIB_NAMESPACE                     \
+    {                                              \
+      static rettype (*func) parameters = ::func;  \
+    }                                              \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_SYS(func,rettype,parameters) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);
+   is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
+   except that the C function func may have a slightly different declaration.
+   A cast is used to silence the "invalid conversion" error that would
+   otherwise occur.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
+    namespace GNULIB_NAMESPACE                          \
+    {                                                   \
+      static rettype (*func) parameters =               \
+        reinterpret_cast<rettype(*)parameters>(::func); \
+    }                                                   \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);
+   is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
+   except that the C function is picked among a set of overloaded functions,
+   namely the one with rettype2 and parameters2.  Two consecutive casts
+   are used to silence the "cannot find a match" and "invalid conversion"
+   errors that would otherwise occur.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+  /* The outer cast must be a reinterpret_cast.
+     The inner cast: When the function is defined as a set of overloaded
+     functions, it works as a static_cast<>, choosing the designated variant.
+     When the function is defined as a single variant, it works as a
+     reinterpret_cast<>. The parenthesized cast syntax works both ways.  */
+# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
+    namespace GNULIB_NAMESPACE                                                \
+    {                                                                         \
+      static rettype (*func) parameters =                                     \
+        reinterpret_cast<rettype(*)parameters>(                               \
+          (rettype2(*)parameters2)(::func));                                  \
+    }                                                                         \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIASWARN (func);
+   causes a warning to be emitted when ::func is used but not when
+   GNULIB_NAMESPACE::func is used.  func must be defined without overloaded
+   variants.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIASWARN(func) \
+   _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)
+# define _GL_CXXALIASWARN_1(func,namespace) \
+   _GL_CXXALIASWARN_2 (func, namespace)
+/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
+   we enable the warning only when not optimizing.  */
+# if !__OPTIMIZE__
+#  define _GL_CXXALIASWARN_2(func,namespace) \
+    _GL_WARN_ON_USE (func, \
+                     "The symbol ::" #func " refers to the system function. " \
+                     "Use " #namespace "::" #func " instead.")
+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
+#  define _GL_CXXALIASWARN_2(func,namespace) \
+     extern __typeof__ (func) func
+# else
+#  define _GL_CXXALIASWARN_2(func,namespace) \
+     _GL_EXTERN_C int _gl_cxxalias_dummy
+# endif
+#else
+# define _GL_CXXALIASWARN(func) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);
+   causes a warning to be emitted when the given overloaded variant of ::func
+   is used but not when GNULIB_NAMESPACE::func is used.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
+   _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \
+                        GNULIB_NAMESPACE)
+# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \
+   _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)
+/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
+   we enable the warning only when not optimizing.  */
+# if !__OPTIMIZE__
+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
+    _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \
+                         "The symbol ::" #func " refers to the system function. " \
+                         "Use " #namespace "::" #func " instead.")
+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
+     extern __typeof__ (func) func
+# else
+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
+     _GL_EXTERN_C int _gl_cxxalias_dummy
+# endif
+#else
+# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+#endif /* _GL_CXXDEFS_H */
+
+/* The definition of _GL_ARG_NONNULL is copied here.  */
+/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
+   that the values passed as arguments n, ..., m must be non-NULL pointers.
+   n = 1 stands for the first argument, n = 2 for the second argument etc.  */
+#ifndef _GL_ARG_NONNULL
+# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
+#  define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
+# else
+#  define _GL_ARG_NONNULL(params)
+# endif
+#endif
+
+/* The definition of _GL_WARN_ON_USE is copied here.  */
+#ifndef _GL_WARN_ON_USE
+
+# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
+/* A compiler attribute is available in gcc versions 4.3.0 and later.  */
+#  define _GL_WARN_ON_USE(function, message) \
+extern __typeof__ (function) function __attribute__ ((__warning__ (message)))
+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
+/* Verify the existence of the function.  */
+#  define _GL_WARN_ON_USE(function, message) \
+extern __typeof__ (function) function
+# else /* Unsupported.  */
+#  define _GL_WARN_ON_USE(function, message) \
+_GL_WARN_EXTERN_C int _gl_warn_on_use
+# endif
+#endif
+
+/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")
+   is like _GL_WARN_ON_USE (function, "string"), except that the function is
+   declared with the given prototype, consisting of return type, parameters,
+   and attributes.
+   This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does
+   not work in this case.  */
+#ifndef _GL_WARN_ON_USE_CXX
+# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
+extern rettype function parameters_and_attributes \
+     __attribute__ ((__warning__ (msg)))
+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
+/* Verify the existence of the function.  */
+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
+extern rettype function parameters_and_attributes
+# else /* Unsupported.  */
+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
+_GL_WARN_EXTERN_C int _gl_warn_on_use
+# endif
+#endif
+
+/* _GL_WARN_EXTERN_C declaration;
+   performs the declaration with C linkage.  */
+#ifndef _GL_WARN_EXTERN_C
+# if defined __cplusplus
+#  define _GL_WARN_EXTERN_C extern "C"
+# else
+#  define _GL_WARN_EXTERN_C extern
+# endif
+#endif
+
+
+/* Find the index of the least-significant set bit.  */
+#if 0
+# if !1
+_GL_FUNCDECL_SYS (ffsl, int, (long int i));
+# endif
+_GL_CXXALIAS_SYS (ffsl, int, (long int i));
+_GL_CXXALIASWARN (ffsl);
+#elif defined GNULIB_POSIXCHECK
+# undef ffsl
+# if HAVE_RAW_DECL_FFSL
+_GL_WARN_ON_USE (ffsl, "ffsl is not portable - use the ffsl module");
+# endif
+#endif
+
+
+/* Find the index of the least-significant set bit.  */
+#if 0
+# if !1
+_GL_FUNCDECL_SYS (ffsll, int, (long long int i));
+# endif
+_GL_CXXALIAS_SYS (ffsll, int, (long long int i));
+_GL_CXXALIASWARN (ffsll);
+#elif defined GNULIB_POSIXCHECK
+# undef ffsll
+# if HAVE_RAW_DECL_FFSLL
+_GL_WARN_ON_USE (ffsll, "ffsll is not portable - use the ffsll module");
+# endif
+#endif
+
+
+/* Return the first instance of C within N bytes of S, or NULL.  */
+#if 1
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define memchr rpl_memchr
+#  endif
+_GL_FUNCDECL_RPL (memchr, void *, (void const *__s, int __c, size_t __n)
+                                  _GL_ATTRIBUTE_PURE
+                                  _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_RPL (memchr, void *, (void const *__s, int __c, size_t __n));
+# else
+#  if ! 1
+_GL_FUNCDECL_SYS (memchr, void *, (void const *__s, int __c, size_t __n)
+                                  _GL_ATTRIBUTE_PURE
+                                  _GL_ARG_NONNULL ((1)));
+#  endif
+  /* On some systems, this function is defined as an overloaded function:
+       extern "C" { const void * std::memchr (const void *, int, size_t); }
+       extern "C++" { void * std::memchr (void *, int, size_t); }  */
+_GL_CXXALIAS_SYS_CAST2 (memchr,
+                        void *, (void const *__s, int __c, size_t __n),
+                        void const *, (void const *__s, int __c, size_t __n));
+# endif
+# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
+     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
+_GL_CXXALIASWARN1 (memchr, void *, (void *__s, int __c, size_t __n));
+_GL_CXXALIASWARN1 (memchr, void const *,
+                   (void const *__s, int __c, size_t __n));
+# else
+_GL_CXXALIASWARN (memchr);
+# endif
+#elif defined GNULIB_POSIXCHECK
+# undef memchr
+/* Assume memchr is always declared.  */
+_GL_WARN_ON_USE (memchr, "memchr has platform-specific bugs - "
+                 "use gnulib module memchr for portability" );
+#endif
+
+/* Return the first occurrence of NEEDLE in HAYSTACK.  */
+#if 1
+# if 1
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define memmem rpl_memmem
+#  endif
+_GL_FUNCDECL_RPL (memmem, void *,
+                  (void const *__haystack, size_t __haystack_len,
+                   void const *__needle, size_t __needle_len)
+                  _GL_ATTRIBUTE_PURE
+                  _GL_ARG_NONNULL ((1, 3)));
+_GL_CXXALIAS_RPL (memmem, void *,
+                  (void const *__haystack, size_t __haystack_len,
+                   void const *__needle, size_t __needle_len));
+# else
+#  if ! 1
+_GL_FUNCDECL_SYS (memmem, void *,
+                  (void const *__haystack, size_t __haystack_len,
+                   void const *__needle, size_t __needle_len)
+                  _GL_ATTRIBUTE_PURE
+                  _GL_ARG_NONNULL ((1, 3)));
+#  endif
+_GL_CXXALIAS_SYS (memmem, void *,
+                  (void const *__haystack, size_t __haystack_len,
+                   void const *__needle, size_t __needle_len));
+# endif
+_GL_CXXALIASWARN (memmem);
+#elif defined GNULIB_POSIXCHECK
+# undef memmem
+# if HAVE_RAW_DECL_MEMMEM
+_GL_WARN_ON_USE (memmem, "memmem is unportable and often quadratic - "
+                 "use gnulib module memmem-simple for portability, "
+                 "and module memmem for speed" );
+# endif
+#endif
+
+/* Copy N bytes of SRC to DEST, return pointer to bytes after the
+   last written byte.  */
+#if 0
+# if ! 1
+_GL_FUNCDECL_SYS (mempcpy, void *,
+                  (void *restrict __dest, void const *restrict __src,
+                   size_t __n)
+                  _GL_ARG_NONNULL ((1, 2)));
+# endif
+_GL_CXXALIAS_SYS (mempcpy, void *,
+                  (void *restrict __dest, void const *restrict __src,
+                   size_t __n));
+_GL_CXXALIASWARN (mempcpy);
+#elif defined GNULIB_POSIXCHECK
+# undef mempcpy
+# if HAVE_RAW_DECL_MEMPCPY
+_GL_WARN_ON_USE (mempcpy, "mempcpy is unportable - "
+                 "use gnulib module mempcpy for portability");
+# endif
+#endif
+
+/* Search backwards through a block for a byte (specified as an int).  */
+#if 0
+# if ! 1
+_GL_FUNCDECL_SYS (memrchr, void *, (void const *, int, size_t)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1)));
+# endif
+  /* On some systems, this function is defined as an overloaded function:
+       extern "C++" { const void * std::memrchr (const void *, int, size_t); }
+       extern "C++" { void * std::memrchr (void *, int, size_t); }  */
+_GL_CXXALIAS_SYS_CAST2 (memrchr,
+                        void *, (void const *, int, size_t),
+                        void const *, (void const *, int, size_t));
+# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
+     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
+_GL_CXXALIASWARN1 (memrchr, void *, (void *, int, size_t));
+_GL_CXXALIASWARN1 (memrchr, void const *, (void const *, int, size_t));
+# else
+_GL_CXXALIASWARN (memrchr);
+# endif
+#elif defined GNULIB_POSIXCHECK
+# undef memrchr
+# if HAVE_RAW_DECL_MEMRCHR
+_GL_WARN_ON_USE (memrchr, "memrchr is unportable - "
+                 "use gnulib module memrchr for portability");
+# endif
+#endif
+
+/* Find the first occurrence of C in S.  More efficient than
+   memchr(S,C,N), at the expense of undefined behavior if C does not
+   occur within N bytes.  */
+#if 0
+# if ! 1
+_GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in)
+                                     _GL_ATTRIBUTE_PURE
+                                     _GL_ARG_NONNULL ((1)));
+# endif
+  /* On some systems, this function is defined as an overloaded function:
+       extern "C++" { const void * std::rawmemchr (const void *, int); }
+       extern "C++" { void * std::rawmemchr (void *, int); }  */
+_GL_CXXALIAS_SYS_CAST2 (rawmemchr,
+                        void *, (void const *__s, int __c_in),
+                        void const *, (void const *__s, int __c_in));
+# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
+     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
+_GL_CXXALIASWARN1 (rawmemchr, void *, (void *__s, int __c_in));
+_GL_CXXALIASWARN1 (rawmemchr, void const *, (void const *__s, int __c_in));
+# else
+_GL_CXXALIASWARN (rawmemchr);
+# endif
+#elif defined GNULIB_POSIXCHECK
+# undef rawmemchr
+# if HAVE_RAW_DECL_RAWMEMCHR
+_GL_WARN_ON_USE (rawmemchr, "rawmemchr is unportable - "
+                 "use gnulib module rawmemchr for portability");
+# endif
+#endif
+
+/* Copy SRC to DST, returning the address of the terminating '\0' in DST.  */
+#if 0
+# if ! 1
+_GL_FUNCDECL_SYS (stpcpy, char *,
+                  (char *restrict __dst, char const *restrict __src)
+                  _GL_ARG_NONNULL ((1, 2)));
+# endif
+_GL_CXXALIAS_SYS (stpcpy, char *,
+                  (char *restrict __dst, char const *restrict __src));
+_GL_CXXALIASWARN (stpcpy);
+#elif defined GNULIB_POSIXCHECK
+# undef stpcpy
+# if HAVE_RAW_DECL_STPCPY
+_GL_WARN_ON_USE (stpcpy, "stpcpy is unportable - "
+                 "use gnulib module stpcpy for portability");
+# endif
+#endif
+
+/* Copy no more than N bytes of SRC to DST, returning a pointer past the
+   last non-NUL byte written into DST.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef stpncpy
+#   define stpncpy rpl_stpncpy
+#  endif
+_GL_FUNCDECL_RPL (stpncpy, char *,
+                  (char *restrict __dst, char const *restrict __src,
+                   size_t __n)
+                  _GL_ARG_NONNULL ((1, 2)));
+_GL_CXXALIAS_RPL (stpncpy, char *,
+                  (char *restrict __dst, char const *restrict __src,
+                   size_t __n));
+# else
+#  if ! 1
+_GL_FUNCDECL_SYS (stpncpy, char *,
+                  (char *restrict __dst, char const *restrict __src,
+                   size_t __n)
+                  _GL_ARG_NONNULL ((1, 2)));
+#  endif
+_GL_CXXALIAS_SYS (stpncpy, char *,
+                  (char *restrict __dst, char const *restrict __src,
+                   size_t __n));
+# endif
+_GL_CXXALIASWARN (stpncpy);
+#elif defined GNULIB_POSIXCHECK
+# undef stpncpy
+# if HAVE_RAW_DECL_STPNCPY
+_GL_WARN_ON_USE (stpncpy, "stpncpy is unportable - "
+                 "use gnulib module stpncpy for portability");
+# endif
+#endif
+
+#if defined GNULIB_POSIXCHECK
+/* strchr() does not work with multibyte strings if the locale encoding is
+   GB18030 and the character to be searched is a digit.  */
+# undef strchr
+/* Assume strchr is always declared.  */
+_GL_WARN_ON_USE (strchr, "strchr cannot work correctly on character strings "
+                 "in some multibyte locales - "
+                 "use mbschr if you care about internationalization");
+#endif
+
+/* Find the first occurrence of C in S or the final NUL byte.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define strchrnul rpl_strchrnul
+#  endif
+_GL_FUNCDECL_RPL (strchrnul, char *, (const char *__s, int __c_in)
+                                     _GL_ATTRIBUTE_PURE
+                                     _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_RPL (strchrnul, char *,
+                  (const char *str, int ch));
+# else
+#  if ! 1
+_GL_FUNCDECL_SYS (strchrnul, char *, (char const *__s, int __c_in)
+                                     _GL_ATTRIBUTE_PURE
+                                     _GL_ARG_NONNULL ((1)));
+#  endif
+  /* On some systems, this function is defined as an overloaded function:
+       extern "C++" { const char * std::strchrnul (const char *, int); }
+       extern "C++" { char * std::strchrnul (char *, int); }  */
+_GL_CXXALIAS_SYS_CAST2 (strchrnul,
+                        char *, (char const *__s, int __c_in),
+                        char const *, (char const *__s, int __c_in));
+# endif
+# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
+     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
+_GL_CXXALIASWARN1 (strchrnul, char *, (char *__s, int __c_in));
+_GL_CXXALIASWARN1 (strchrnul, char const *, (char const *__s, int __c_in));
+# else
+_GL_CXXALIASWARN (strchrnul);
+# endif
+#elif defined GNULIB_POSIXCHECK
+# undef strchrnul
+# if HAVE_RAW_DECL_STRCHRNUL
+_GL_WARN_ON_USE (strchrnul, "strchrnul is unportable - "
+                 "use gnulib module strchrnul for portability");
+# endif
+#endif
+
+/* Duplicate S, returning an identical malloc'd string.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef strdup
+#   define strdup rpl_strdup
+#  endif
+_GL_FUNCDECL_RPL (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_RPL (strdup, char *, (char const *__s));
+# else
+#  if defined __cplusplus && defined GNULIB_NAMESPACE && defined strdup
+    /* strdup exists as a function and as a macro.  Get rid of the macro.  */
+#   undef strdup
+#  endif
+#  if !(1 || defined strdup)
+_GL_FUNCDECL_SYS (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));
+#  endif
+_GL_CXXALIAS_SYS (strdup, char *, (char const *__s));
+# endif
+_GL_CXXALIASWARN (strdup);
+#elif defined GNULIB_POSIXCHECK
+# undef strdup
+# if HAVE_RAW_DECL_STRDUP
+_GL_WARN_ON_USE (strdup, "strdup is unportable - "
+                 "use gnulib module strdup for portability");
+# endif
+#endif
+
+/* Append no more than N characters from SRC onto DEST.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef strncat
+#   define strncat rpl_strncat
+#  endif
+_GL_FUNCDECL_RPL (strncat, char *, (char *dest, const char *src, size_t n)
+                                   _GL_ARG_NONNULL ((1, 2)));
+_GL_CXXALIAS_RPL (strncat, char *, (char *dest, const char *src, size_t n));
+# else
+_GL_CXXALIAS_SYS (strncat, char *, (char *dest, const char *src, size_t n));
+# endif
+_GL_CXXALIASWARN (strncat);
+#elif defined GNULIB_POSIXCHECK
+# undef strncat
+# if HAVE_RAW_DECL_STRNCAT
+_GL_WARN_ON_USE (strncat, "strncat is unportable - "
+                 "use gnulib module strncat for portability");
+# endif
+#endif
+
+/* Return a newly allocated copy of at most N bytes of STRING.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef strndup
+#   define strndup rpl_strndup
+#  endif
+_GL_FUNCDECL_RPL (strndup, char *, (char const *__string, size_t __n)
+                                   _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_RPL (strndup, char *, (char const *__string, size_t __n));
+# else
+#  if ! 1
+_GL_FUNCDECL_SYS (strndup, char *, (char const *__string, size_t __n)
+                                   _GL_ARG_NONNULL ((1)));
+#  endif
+_GL_CXXALIAS_SYS (strndup, char *, (char const *__string, size_t __n));
+# endif
+_GL_CXXALIASWARN (strndup);
+#elif defined GNULIB_POSIXCHECK
+# undef strndup
+# if HAVE_RAW_DECL_STRNDUP
+_GL_WARN_ON_USE (strndup, "strndup is unportable - "
+                 "use gnulib module strndup for portability");
+# endif
+#endif
+
+/* Find the length (number of bytes) of STRING, but scan at most
+   MAXLEN bytes.  If no '\0' terminator is found in that many bytes,
+   return MAXLEN.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef strnlen
+#   define strnlen rpl_strnlen
+#  endif
+_GL_FUNCDECL_RPL (strnlen, size_t, (char const *__string, size_t __maxlen)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_RPL (strnlen, size_t, (char const *__string, size_t __maxlen));
+# else
+#  if ! 1
+_GL_FUNCDECL_SYS (strnlen, size_t, (char const *__string, size_t __maxlen)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1)));
+#  endif
+_GL_CXXALIAS_SYS (strnlen, size_t, (char const *__string, size_t __maxlen));
+# endif
+_GL_CXXALIASWARN (strnlen);
+#elif defined GNULIB_POSIXCHECK
+# undef strnlen
+# if HAVE_RAW_DECL_STRNLEN
+_GL_WARN_ON_USE (strnlen, "strnlen is unportable - "
+                 "use gnulib module strnlen for portability");
+# endif
+#endif
+
+#if defined GNULIB_POSIXCHECK
+/* strcspn() assumes the second argument is a list of single-byte characters.
+   Even in this simple case, it does not work with multibyte strings if the
+   locale encoding is GB18030 and one of the characters to be searched is a
+   digit.  */
+# undef strcspn
+/* Assume strcspn is always declared.  */
+_GL_WARN_ON_USE (strcspn, "strcspn cannot work correctly on character strings "
+                 "in multibyte locales - "
+                 "use mbscspn if you care about internationalization");
+#endif
+
+/* Find the first occurrence in S of any character in ACCEPT.  */
+#if 0
+# if ! 1
+_GL_FUNCDECL_SYS (strpbrk, char *, (char const *__s, char const *__accept)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1, 2)));
+# endif
+  /* On some systems, this function is defined as an overloaded function:
+       extern "C" { const char * strpbrk (const char *, const char *); }
+       extern "C++" { char * strpbrk (char *, const char *); }  */
+_GL_CXXALIAS_SYS_CAST2 (strpbrk,
+                        char *, (char const *__s, char const *__accept),
+                        const char *, (char const *__s, char const *__accept));
+# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
+     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
+_GL_CXXALIASWARN1 (strpbrk, char *, (char *__s, char const *__accept));
+_GL_CXXALIASWARN1 (strpbrk, char const *,
+                   (char const *__s, char const *__accept));
+# else
+_GL_CXXALIASWARN (strpbrk);
+# endif
+# if defined GNULIB_POSIXCHECK
+/* strpbrk() assumes the second argument is a list of single-byte characters.
+   Even in this simple case, it does not work with multibyte strings if the
+   locale encoding is GB18030 and one of the characters to be searched is a
+   digit.  */
+#  undef strpbrk
+_GL_WARN_ON_USE (strpbrk, "strpbrk cannot work correctly on character strings "
+                 "in multibyte locales - "
+                 "use mbspbrk if you care about internationalization");
+# endif
+#elif defined GNULIB_POSIXCHECK
+# undef strpbrk
+# if HAVE_RAW_DECL_STRPBRK
+_GL_WARN_ON_USE (strpbrk, "strpbrk is unportable - "
+                 "use gnulib module strpbrk for portability");
+# endif
+#endif
+
+#if defined GNULIB_POSIXCHECK
+/* strspn() assumes the second argument is a list of single-byte characters.
+   Even in this simple case, it cannot work with multibyte strings.  */
+# undef strspn
+/* Assume strspn is always declared.  */
+_GL_WARN_ON_USE (strspn, "strspn cannot work correctly on character strings "
+                 "in multibyte locales - "
+                 "use mbsspn if you care about internationalization");
+#endif
+
+#if defined GNULIB_POSIXCHECK
+/* strrchr() does not work with multibyte strings if the locale encoding is
+   GB18030 and the character to be searched is a digit.  */
+# undef strrchr
+/* Assume strrchr is always declared.  */
+_GL_WARN_ON_USE (strrchr, "strrchr cannot work correctly on character strings "
+                 "in some multibyte locales - "
+                 "use mbsrchr if you care about internationalization");
+#endif
+
+/* Search the next delimiter (char listed in DELIM) starting at *STRINGP.
+   If one is found, overwrite it with a NUL, and advance *STRINGP
+   to point to the next char after it.  Otherwise, set *STRINGP to NULL.
+   If *STRINGP was already NULL, nothing happens.
+   Return the old value of *STRINGP.
+
+   This is a variant of strtok() that is multithread-safe and supports
+   empty fields.
+
+   Caveat: It modifies the original string.
+   Caveat: These functions cannot be used on constant strings.
+   Caveat: The identity of the delimiting character is lost.
+   Caveat: It doesn't work with multibyte strings unless all of the delimiter
+           characters are ASCII characters < 0x30.
+
+   See also strtok_r().  */
+#if 0
+# if ! 1
+_GL_FUNCDECL_SYS (strsep, char *,
+                  (char **restrict __stringp, char const *restrict __delim)
+                  _GL_ARG_NONNULL ((1, 2)));
+# endif
+_GL_CXXALIAS_SYS (strsep, char *,
+                  (char **restrict __stringp, char const *restrict __delim));
+_GL_CXXALIASWARN (strsep);
+# if defined GNULIB_POSIXCHECK
+#  undef strsep
+_GL_WARN_ON_USE (strsep, "strsep cannot work correctly on character strings "
+                 "in multibyte locales - "
+                 "use mbssep if you care about internationalization");
+# endif
+#elif defined GNULIB_POSIXCHECK
+# undef strsep
+# if HAVE_RAW_DECL_STRSEP
+_GL_WARN_ON_USE (strsep, "strsep is unportable - "
+                 "use gnulib module strsep for portability");
+# endif
+#endif
+
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define strstr rpl_strstr
+#  endif
+_GL_FUNCDECL_RPL (strstr, char *, (const char *haystack, const char *needle)
+                                  _GL_ATTRIBUTE_PURE
+                                  _GL_ARG_NONNULL ((1, 2)));
+_GL_CXXALIAS_RPL (strstr, char *, (const char *haystack, const char *needle));
+# else
+  /* On some systems, this function is defined as an overloaded function:
+       extern "C++" { const char * strstr (const char *, const char *); }
+       extern "C++" { char * strstr (char *, const char *); }  */
+_GL_CXXALIAS_SYS_CAST2 (strstr,
+                        char *, (const char *haystack, const char *needle),
+                        const char *, (const char *haystack, const char *needle));
+# endif
+# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
+     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
+_GL_CXXALIASWARN1 (strstr, char *, (char *haystack, const char *needle));
+_GL_CXXALIASWARN1 (strstr, const char *,
+                   (const char *haystack, const char *needle));
+# else
+_GL_CXXALIASWARN (strstr);
+# endif
+#elif defined GNULIB_POSIXCHECK
+/* strstr() does not work with multibyte strings if the locale encoding is
+   different from UTF-8:
+   POSIX says that it operates on "strings", and "string" in POSIX is defined
+   as a sequence of bytes, not of characters.  */
+# undef strstr
+/* Assume strstr is always declared.  */
+_GL_WARN_ON_USE (strstr, "strstr is quadratic on many systems, and cannot "
+                 "work correctly on character strings in most "
+                 "multibyte locales - "
+                 "use mbsstr if you care about internationalization, "
+                 "or use strstr if you care about speed");
+#endif
+
+/* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive
+   comparison.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define strcasestr rpl_strcasestr
+#  endif
+_GL_FUNCDECL_RPL (strcasestr, char *,
+                  (const char *haystack, const char *needle)
+                  _GL_ATTRIBUTE_PURE
+                  _GL_ARG_NONNULL ((1, 2)));
+_GL_CXXALIAS_RPL (strcasestr, char *,
+                  (const char *haystack, const char *needle));
+# else
+#  if ! 1
+_GL_FUNCDECL_SYS (strcasestr, char *,
+                  (const char *haystack, const char *needle)
+                  _GL_ATTRIBUTE_PURE
+                  _GL_ARG_NONNULL ((1, 2)));
+#  endif
+  /* On some systems, this function is defined as an overloaded function:
+       extern "C++" { const char * strcasestr (const char *, const char *); }
+       extern "C++" { char * strcasestr (char *, const char *); }  */
+_GL_CXXALIAS_SYS_CAST2 (strcasestr,
+                        char *, (const char *haystack, const char *needle),
+                        const char *, (const char *haystack, const char *needle));
+# endif
+# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
+     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
+_GL_CXXALIASWARN1 (strcasestr, char *, (char *haystack, const char *needle));
+_GL_CXXALIASWARN1 (strcasestr, const char *,
+                   (const char *haystack, const char *needle));
+# else
+_GL_CXXALIASWARN (strcasestr);
+# endif
+#elif defined GNULIB_POSIXCHECK
+/* strcasestr() does not work with multibyte strings:
+   It is a glibc extension, and glibc implements it only for unibyte
+   locales.  */
+# undef strcasestr
+# if HAVE_RAW_DECL_STRCASESTR
+_GL_WARN_ON_USE (strcasestr, "strcasestr does work correctly on character "
+                 "strings in multibyte locales - "
+                 "use mbscasestr if you care about "
+                 "internationalization, or use c-strcasestr if you want "
+                 "a locale independent function");
+# endif
+#endif
+
+/* Parse S into tokens separated by characters in DELIM.
+   If S is NULL, the saved pointer in SAVE_PTR is used as
+   the next starting point.  For example:
+        char s[] = "-abc-=-def";
+        char *sp;
+        x = strtok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
+        x = strtok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
+        x = strtok_r(NULL, "=", &sp);   // x = NULL
+                // s = "abc\0-def\0"
+
+   This is a variant of strtok() that is multithread-safe.
+
+   For the POSIX documentation for this function, see:
+   http://www.opengroup.org/susv3xsh/strtok.html
+
+   Caveat: It modifies the original string.
+   Caveat: These functions cannot be used on constant strings.
+   Caveat: The identity of the delimiting character is lost.
+   Caveat: It doesn't work with multibyte strings unless all of the delimiter
+           characters are ASCII characters < 0x30.
+
+   See also strsep().  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef strtok_r
+#   define strtok_r rpl_strtok_r
+#  endif
+_GL_FUNCDECL_RPL (strtok_r, char *,
+                  (char *restrict s, char const *restrict delim,
+                   char **restrict save_ptr)
+                  _GL_ARG_NONNULL ((2, 3)));
+_GL_CXXALIAS_RPL (strtok_r, char *,
+                  (char *restrict s, char const *restrict delim,
+                   char **restrict save_ptr));
+# else
+#  if 0 || defined GNULIB_POSIXCHECK
+#   undef strtok_r
+#  endif
+#  if ! 1
+_GL_FUNCDECL_SYS (strtok_r, char *,
+                  (char *restrict s, char const *restrict delim,
+                   char **restrict save_ptr)
+                  _GL_ARG_NONNULL ((2, 3)));
+#  endif
+_GL_CXXALIAS_SYS (strtok_r, char *,
+                  (char *restrict s, char const *restrict delim,
+                   char **restrict save_ptr));
+# endif
+_GL_CXXALIASWARN (strtok_r);
+# if defined GNULIB_POSIXCHECK
+_GL_WARN_ON_USE (strtok_r, "strtok_r cannot work correctly on character "
+                 "strings in multibyte locales - "
+                 "use mbstok_r if you care about internationalization");
+# endif
+#elif defined GNULIB_POSIXCHECK
+# undef strtok_r
+# if HAVE_RAW_DECL_STRTOK_R
+_GL_WARN_ON_USE (strtok_r, "strtok_r is unportable - "
+                 "use gnulib module strtok_r for portability");
+# endif
+#endif
+
+
+/* The following functions are not specified by POSIX.  They are gnulib
+   extensions.  */
+
+#if 0
+/* Return the number of multibyte characters in the character string STRING.
+   This considers multibyte characters, unlike strlen, which counts bytes.  */
+# ifdef __MirBSD__  /* MirBSD defines mbslen as a macro.  Override it.  */
+#  undef mbslen
+# endif
+# if 0  /* AIX, OSF/1, MirBSD define mbslen already in libc.  */
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define mbslen rpl_mbslen
+#  endif
+_GL_FUNCDECL_RPL (mbslen, size_t, (const char *string)
+                                  _GL_ATTRIBUTE_PURE
+                                  _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_RPL (mbslen, size_t, (const char *string));
+# else
+_GL_FUNCDECL_SYS (mbslen, size_t, (const char *string)
+                                  _GL_ATTRIBUTE_PURE
+                                  _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_SYS (mbslen, size_t, (const char *string));
+# endif
+_GL_CXXALIASWARN (mbslen);
+#endif
+
+#if 0
+/* Return the number of multibyte characters in the character string starting
+   at STRING and ending at STRING + LEN.  */
+_GL_EXTERN_C size_t mbsnlen (const char *string, size_t len)
+     _GL_ATTRIBUTE_PURE
+     _GL_ARG_NONNULL ((1));
+#endif
+
+#if 0
+/* Locate the first single-byte character C in the character string STRING,
+   and return a pointer to it.  Return NULL if C is not found in STRING.
+   Unlike strchr(), this function works correctly in multibyte locales with
+   encodings such as GB18030.  */
+# if defined __hpux
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define mbschr rpl_mbschr /* avoid collision with HP-UX function */
+#  endif
+_GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c)
+                                  _GL_ATTRIBUTE_PURE
+                                  _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c));
+# else
+_GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c)
+                                  _GL_ATTRIBUTE_PURE
+                                  _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c));
+# endif
+_GL_CXXALIASWARN (mbschr);
+#endif
+
+#if 0
+/* Locate the last single-byte character C in the character string STRING,
+   and return a pointer to it.  Return NULL if C is not found in STRING.
+   Unlike strrchr(), this function works correctly in multibyte locales with
+   encodings such as GB18030.  */
+# if defined __hpux || defined __INTERIX
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define mbsrchr rpl_mbsrchr /* avoid collision with system function */
+#  endif
+_GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c));
+# else
+_GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1)));
+_GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c));
+# endif
+_GL_CXXALIASWARN (mbsrchr);
+#endif
+
+#if 0
+/* Find the first occurrence of the character string NEEDLE in the character
+   string HAYSTACK.  Return NULL if NEEDLE is not found in HAYSTACK.
+   Unlike strstr(), this function works correctly in multibyte locales with
+   encodings different from UTF-8.  */
+_GL_EXTERN_C char * mbsstr (const char *haystack, const char *needle)
+     _GL_ATTRIBUTE_PURE
+     _GL_ARG_NONNULL ((1, 2));
+#endif
+
+#if 0
+/* Compare the character strings S1 and S2, ignoring case, returning less than,
+   equal to or greater than zero if S1 is lexicographically less than, equal to
+   or greater than S2.
+   Note: This function may, in multibyte locales, return 0 for strings of
+   different lengths!
+   Unlike strcasecmp(), this function works correctly in multibyte locales.  */
+_GL_EXTERN_C int mbscasecmp (const char *s1, const char *s2)
+     _GL_ATTRIBUTE_PURE
+     _GL_ARG_NONNULL ((1, 2));
+#endif
+
+#if 0
+/* Compare the initial segment of the character string S1 consisting of at most
+   N characters with the initial segment of the character string S2 consisting
+   of at most N characters, ignoring case, returning less than, equal to or
+   greater than zero if the initial segment of S1 is lexicographically less
+   than, equal to or greater than the initial segment of S2.
+   Note: This function may, in multibyte locales, return 0 for initial segments
+   of different lengths!
+   Unlike strncasecmp(), this function works correctly in multibyte locales.
+   But beware that N is not a byte count but a character count!  */
+_GL_EXTERN_C int mbsncasecmp (const char *s1, const char *s2, size_t n)
+     _GL_ATTRIBUTE_PURE
+     _GL_ARG_NONNULL ((1, 2));
+#endif
+
+#if 0
+/* Compare the initial segment of the character string STRING consisting of
+   at most mbslen (PREFIX) characters with the character string PREFIX,
+   ignoring case.  If the two match, return a pointer to the first byte
+   after this prefix in STRING.  Otherwise, return NULL.
+   Note: This function may, in multibyte locales, return non-NULL if STRING
+   is of smaller length than PREFIX!
+   Unlike strncasecmp(), this function works correctly in multibyte
+   locales.  */
+_GL_EXTERN_C char * mbspcasecmp (const char *string, const char *prefix)
+     _GL_ATTRIBUTE_PURE
+     _GL_ARG_NONNULL ((1, 2));
+#endif
+
+#if 0
+/* Find the first occurrence of the character string NEEDLE in the character
+   string HAYSTACK, using case-insensitive comparison.
+   Note: This function may, in multibyte locales, return success even if
+   strlen (haystack) < strlen (needle) !
+   Unlike strcasestr(), this function works correctly in multibyte locales.  */
+_GL_EXTERN_C char * mbscasestr (const char *haystack, const char *needle)
+     _GL_ATTRIBUTE_PURE
+     _GL_ARG_NONNULL ((1, 2));
+#endif
+
+#if 0
+/* Find the first occurrence in the character string STRING of any character
+   in the character string ACCEPT.  Return the number of bytes from the
+   beginning of the string to this occurrence, or to the end of the string
+   if none exists.
+   Unlike strcspn(), this function works correctly in multibyte locales.  */
+_GL_EXTERN_C size_t mbscspn (const char *string, const char *accept)
+     _GL_ATTRIBUTE_PURE
+     _GL_ARG_NONNULL ((1, 2));
+#endif
+
+#if 0
+/* Find the first occurrence in the character string STRING of any character
+   in the character string ACCEPT.  Return the pointer to it, or NULL if none
+   exists.
+   Unlike strpbrk(), this function works correctly in multibyte locales.  */
+# if defined __hpux
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */
+#  endif
+_GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1, 2)));
+_GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept));
+# else
+_GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1, 2)));
+_GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept));
+# endif
+_GL_CXXALIASWARN (mbspbrk);
+#endif
+
+#if 0
+/* Find the first occurrence in the character string STRING of any character
+   not in the character string REJECT.  Return the number of bytes from the
+   beginning of the string to this occurrence, or to the end of the string
+   if none exists.
+   Unlike strspn(), this function works correctly in multibyte locales.  */
+_GL_EXTERN_C size_t mbsspn (const char *string, const char *reject)
+     _GL_ATTRIBUTE_PURE
+     _GL_ARG_NONNULL ((1, 2));
+#endif
+
+#if 0
+/* Search the next delimiter (multibyte character listed in the character
+   string DELIM) starting at the character string *STRINGP.
+   If one is found, overwrite it with a NUL, and advance *STRINGP to point
+   to the next multibyte character after it.  Otherwise, set *STRINGP to NULL.
+   If *STRINGP was already NULL, nothing happens.
+   Return the old value of *STRINGP.
+
+   This is a variant of mbstok_r() that supports empty fields.
+
+   Caveat: It modifies the original string.
+   Caveat: These functions cannot be used on constant strings.
+   Caveat: The identity of the delimiting character is lost.
+
+   See also mbstok_r().  */
+_GL_EXTERN_C char * mbssep (char **stringp, const char *delim)
+     _GL_ARG_NONNULL ((1, 2));
+#endif
+
+#if 0
+/* Parse the character string STRING into tokens separated by characters in
+   the character string DELIM.
+   If STRING is NULL, the saved pointer in SAVE_PTR is used as
+   the next starting point.  For example:
+        char s[] = "-abc-=-def";
+        char *sp;
+        x = mbstok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
+        x = mbstok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
+        x = mbstok_r(NULL, "=", &sp);   // x = NULL
+                // s = "abc\0-def\0"
+
+   Caveat: It modifies the original string.
+   Caveat: These functions cannot be used on constant strings.
+   Caveat: The identity of the delimiting character is lost.
+
+   See also mbssep().  */
+_GL_EXTERN_C char * mbstok_r (char *string, const char *delim, char **save_ptr)
+     _GL_ARG_NONNULL ((2, 3));
+#endif
+
+/* Map any int, typically from errno, into an error message.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef strerror
+#   define strerror rpl_strerror
+#  endif
+_GL_FUNCDECL_RPL (strerror, char *, (int));
+_GL_CXXALIAS_RPL (strerror, char *, (int));
+# else
+_GL_CXXALIAS_SYS (strerror, char *, (int));
+# endif
+_GL_CXXALIASWARN (strerror);
+#elif defined GNULIB_POSIXCHECK
+# undef strerror
+/* Assume strerror is always declared.  */
+_GL_WARN_ON_USE (strerror, "strerror is unportable - "
+                 "use gnulib module strerror to guarantee non-NULL result");
+#endif
+
+/* Map any int, typically from errno, into an error message.  Multithread-safe.
+   Uses the POSIX declaration, not the glibc declaration.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef strerror_r
+#   define strerror_r rpl_strerror_r
+#  endif
+_GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen)
+                                   _GL_ARG_NONNULL ((2)));
+_GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen)
+                                   _GL_ARG_NONNULL ((2)));
+#  endif
+_GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen));
+# endif
+# if 1
+_GL_CXXALIASWARN (strerror_r);
+# endif
+#elif defined GNULIB_POSIXCHECK
+# undef strerror_r
+# if HAVE_RAW_DECL_STRERROR_R
+_GL_WARN_ON_USE (strerror_r, "strerror_r is unportable - "
+                 "use gnulib module strerror_r-posix for portability");
+# endif
+#endif
+
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   define strsignal rpl_strsignal
+#  endif
+_GL_FUNCDECL_RPL (strsignal, char *, (int __sig));
+_GL_CXXALIAS_RPL (strsignal, char *, (int __sig));
+# else
+#  if ! 1
+_GL_FUNCDECL_SYS (strsignal, char *, (int __sig));
+#  endif
+/* Need to cast, because on Cygwin 1.5.x systems, the return type is
+   'const char *'.  */
+_GL_CXXALIAS_SYS_CAST (strsignal, char *, (int __sig));
+# endif
+_GL_CXXALIASWARN (strsignal);
+#elif defined GNULIB_POSIXCHECK
+# undef strsignal
+# if HAVE_RAW_DECL_STRSIGNAL
+_GL_WARN_ON_USE (strsignal, "strsignal is unportable - "
+                 "use gnulib module strsignal for portability");
+# endif
+#endif
+
+#if 0
+# if !1
+_GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *)
+                                   _GL_ATTRIBUTE_PURE
+                                   _GL_ARG_NONNULL ((1, 2)));
+# endif
+_GL_CXXALIAS_SYS (strverscmp, int, (const char *, const char *));
+_GL_CXXALIASWARN (strverscmp);
+#elif defined GNULIB_POSIXCHECK
+# undef strverscmp
+# if HAVE_RAW_DECL_STRVERSCMP
+_GL_WARN_ON_USE (strverscmp, "strverscmp is unportable - "
+                 "use gnulib module strverscmp for portability");
+# endif
+#endif
+
+
+#endif /* _GL_STRING_H */
+#endif /* _GL_STRING_H */
diff --git a/gnu/usr.bin/gdb/libgnu/wchar.h b/gnu/usr.bin/gdb/libgnu/wchar.h
new file mode 100644 (file)
index 0000000..487cd1e
--- /dev/null
@@ -0,0 +1,1340 @@
+/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
+/* A substitute for ISO C99 <wchar.h>, for platforms that have issues.
+
+   Copyright (C) 2007-2012 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 3, 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, see <http://www.gnu.org/licenses/>.  */
+
+/* Written by Eric Blake.  */
+
+/*
+ * ISO C 99 <wchar.h> for platforms that have issues.
+ * <http://www.opengroup.org/susv3xbd/wchar.h.html>
+ *
+ * For now, this just ensures proper prerequisite inclusion order and
+ * the declaration of wcwidth().
+ */
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+
+#if defined __need_mbstate_t || defined __need_wint_t || (defined __hpux && ((defined _INTTYPES_INCLUDED && !defined strtoimax) || defined _GL_JUST_INCLUDE_SYSTEM_WCHAR_H)) || defined _GL_ALREADY_INCLUDING_WCHAR_H
+/* Special invocation convention:
+   - Inside glibc and uClibc header files.
+   - On HP-UX 11.00 we have a sequence of nested includes
+     <wchar.h> -> <stdlib.h> -> <stdint.h>, and the latter includes <wchar.h>,
+     once indirectly <stdint.h> -> <sys/types.h> -> <inttypes.h> -> <wchar.h>
+     and once directly.  In both situations 'wint_t' is not yet defined,
+     therefore we cannot provide the function overrides; instead include only
+     the system's <wchar.h>.
+   - On IRIX 6.5, similarly, we have an include <wchar.h> -> <wctype.h>, and
+     the latter includes <wchar.h>.  But here, we have no way to detect whether
+     <wctype.h> is completely included or is still being included.  */
+
+#include_next <wchar.h>
+
+#else
+/* Normal invocation convention.  */
+
+#ifndef _GL_WCHAR_H
+
+#define _GL_ALREADY_INCLUDING_WCHAR_H
+
+#if 0
+# include <features.h> /* for __GLIBC__ */
+#endif
+
+/* Tru64 with Desktop Toolkit C has a bug: <stdio.h> must be included before
+   <wchar.h>.
+   BSD/OS 4.0.1 has a bug: <stddef.h>, <stdio.h> and <time.h> must be
+   included before <wchar.h>.
+   In some builds of uClibc, <wchar.h> is nonexistent and wchar_t is defined
+   by <stddef.h>.
+   But avoid namespace pollution on glibc systems.  */
+#if !(defined __GLIBC__ && !defined __UCLIBC__)
+# include <stddef.h>
+#endif
+#ifndef __GLIBC__
+# include <stdio.h>
+# include <time.h>
+#endif
+
+/* Include the original <wchar.h> if it exists.
+   Some builds of uClibc lack it.  */
+/* The include_next requires a split double-inclusion guard.  */
+#if 1
+# include_next <wchar.h>
+#endif
+
+#undef _GL_ALREADY_INCLUDING_WCHAR_H
+
+#ifndef _GL_WCHAR_H
+#define _GL_WCHAR_H
+
+/* The __attribute__ feature is available in gcc versions 2.5 and later.
+   The attribute __pure__ was added in gcc 2.96.  */
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
+# define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
+#else
+# define _GL_ATTRIBUTE_PURE /* empty */
+#endif
+
+/* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
+#ifndef _GL_CXXDEFS_H
+#define _GL_CXXDEFS_H
+
+/* The three most frequent use cases of these macros are:
+
+   * For providing a substitute for a function that is missing on some
+     platforms, but is declared and works fine on the platforms on which
+     it exists:
+
+       #if @GNULIB_FOO@
+       # if !@HAVE_FOO@
+       _GL_FUNCDECL_SYS (foo, ...);
+       # endif
+       _GL_CXXALIAS_SYS (foo, ...);
+       _GL_CXXALIASWARN (foo);
+       #elif defined GNULIB_POSIXCHECK
+       ...
+       #endif
+
+   * For providing a replacement for a function that exists on all platforms,
+     but is broken/insufficient and needs to be replaced on some platforms:
+
+       #if @GNULIB_FOO@
+       # if @REPLACE_FOO@
+       #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+       #   undef foo
+       #   define foo rpl_foo
+       #  endif
+       _GL_FUNCDECL_RPL (foo, ...);
+       _GL_CXXALIAS_RPL (foo, ...);
+       # else
+       _GL_CXXALIAS_SYS (foo, ...);
+       # endif
+       _GL_CXXALIASWARN (foo);
+       #elif defined GNULIB_POSIXCHECK
+       ...
+       #endif
+
+   * For providing a replacement for a function that exists on some platforms
+     but is broken/insufficient and needs to be replaced on some of them and
+     is additionally either missing or undeclared on some other platforms:
+
+       #if @GNULIB_FOO@
+       # if @REPLACE_FOO@
+       #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+       #   undef foo
+       #   define foo rpl_foo
+       #  endif
+       _GL_FUNCDECL_RPL (foo, ...);
+       _GL_CXXALIAS_RPL (foo, ...);
+       # else
+       #  if !@HAVE_FOO@   or   if !@HAVE_DECL_FOO@
+       _GL_FUNCDECL_SYS (foo, ...);
+       #  endif
+       _GL_CXXALIAS_SYS (foo, ...);
+       # endif
+       _GL_CXXALIASWARN (foo);
+       #elif defined GNULIB_POSIXCHECK
+       ...
+       #endif
+*/
+
+/* _GL_EXTERN_C declaration;
+   performs the declaration with C linkage.  */
+#if defined __cplusplus
+# define _GL_EXTERN_C extern "C"
+#else
+# define _GL_EXTERN_C extern
+#endif
+
+/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);
+   declares a replacement function, named rpl_func, with the given prototype,
+   consisting of return type, parameters, and attributes.
+   Example:
+     _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)
+                                  _GL_ARG_NONNULL ((1)));
+ */
+#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \
+  _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)
+#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \
+  _GL_EXTERN_C rettype rpl_func parameters_and_attributes
+
+/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);
+   declares the system function, named func, with the given prototype,
+   consisting of return type, parameters, and attributes.
+   Example:
+     _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)
+                                  _GL_ARG_NONNULL ((1)));
+ */
+#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \
+  _GL_EXTERN_C rettype func parameters_and_attributes
+
+/* _GL_CXXALIAS_RPL (func, rettype, parameters);
+   declares a C++ alias called GNULIB_NAMESPACE::func
+   that redirects to rpl_func, if GNULIB_NAMESPACE is defined.
+   Example:
+     _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));
+ */
+#define _GL_CXXALIAS_RPL(func,rettype,parameters) \
+  _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
+    namespace GNULIB_NAMESPACE                                \
+    {                                                         \
+      rettype (*const func) parameters = ::rpl_func;          \
+    }                                                         \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);
+   is like  _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);
+   except that the C function rpl_func may have a slightly different
+   declaration.  A cast is used to silence the "invalid conversion" error
+   that would otherwise occur.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
+    namespace GNULIB_NAMESPACE                                     \
+    {                                                              \
+      rettype (*const func) parameters =                           \
+        reinterpret_cast<rettype(*)parameters>(::rpl_func);        \
+    }                                                              \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIAS_SYS (func, rettype, parameters);
+   declares a C++ alias called GNULIB_NAMESPACE::func
+   that redirects to the system provided function func, if GNULIB_NAMESPACE
+   is defined.
+   Example:
+     _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));
+ */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+  /* If we were to write
+       rettype (*const func) parameters = ::func;
+     like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls
+     better (remove an indirection through a 'static' pointer variable),
+     but then the _GL_CXXALIASWARN macro below would cause a warning not only
+     for uses of ::func but also for uses of GNULIB_NAMESPACE::func.  */
+# define _GL_CXXALIAS_SYS(func,rettype,parameters) \
+    namespace GNULIB_NAMESPACE                     \
+    {                                              \
+      static rettype (*func) parameters = ::func;  \
+    }                                              \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_SYS(func,rettype,parameters) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);
+   is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
+   except that the C function func may have a slightly different declaration.
+   A cast is used to silence the "invalid conversion" error that would
+   otherwise occur.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
+    namespace GNULIB_NAMESPACE                          \
+    {                                                   \
+      static rettype (*func) parameters =               \
+        reinterpret_cast<rettype(*)parameters>(::func); \
+    }                                                   \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);
+   is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
+   except that the C function is picked among a set of overloaded functions,
+   namely the one with rettype2 and parameters2.  Two consecutive casts
+   are used to silence the "cannot find a match" and "invalid conversion"
+   errors that would otherwise occur.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+  /* The outer cast must be a reinterpret_cast.
+     The inner cast: When the function is defined as a set of overloaded
+     functions, it works as a static_cast<>, choosing the designated variant.
+     When the function is defined as a single variant, it works as a
+     reinterpret_cast<>. The parenthesized cast syntax works both ways.  */
+# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
+    namespace GNULIB_NAMESPACE                                                \
+    {                                                                         \
+      static rettype (*func) parameters =                                     \
+        reinterpret_cast<rettype(*)parameters>(                               \
+          (rettype2(*)parameters2)(::func));                                  \
+    }                                                                         \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#else
+# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIASWARN (func);
+   causes a warning to be emitted when ::func is used but not when
+   GNULIB_NAMESPACE::func is used.  func must be defined without overloaded
+   variants.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIASWARN(func) \
+   _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)
+# define _GL_CXXALIASWARN_1(func,namespace) \
+   _GL_CXXALIASWARN_2 (func, namespace)
+/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
+   we enable the warning only when not optimizing.  */
+# if !__OPTIMIZE__
+#  define _GL_CXXALIASWARN_2(func,namespace) \
+    _GL_WARN_ON_USE (func, \
+                     "The symbol ::" #func " refers to the system function. " \
+                     "Use " #namespace "::" #func " instead.")
+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
+#  define _GL_CXXALIASWARN_2(func,namespace) \
+     extern __typeof__ (func) func
+# else
+#  define _GL_CXXALIASWARN_2(func,namespace) \
+     _GL_EXTERN_C int _gl_cxxalias_dummy
+# endif
+#else
+# define _GL_CXXALIASWARN(func) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);
+   causes a warning to be emitted when the given overloaded variant of ::func
+   is used but not when GNULIB_NAMESPACE::func is used.  */
+#if defined __cplusplus && defined GNULIB_NAMESPACE
+# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
+   _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \
+                        GNULIB_NAMESPACE)
+# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \
+   _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)
+/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
+   we enable the warning only when not optimizing.  */
+# if !__OPTIMIZE__
+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
+    _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \
+                         "The symbol ::" #func " refers to the system function. " \
+                         "Use " #namespace "::" #func " instead.")
+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
+     extern __typeof__ (func) func
+# else
+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
+     _GL_EXTERN_C int _gl_cxxalias_dummy
+# endif
+#else
+# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
+    _GL_EXTERN_C int _gl_cxxalias_dummy
+#endif
+
+#endif /* _GL_CXXDEFS_H */
+
+/* The definition of _GL_ARG_NONNULL is copied here.  */
+/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
+   that the values passed as arguments n, ..., m must be non-NULL pointers.
+   n = 1 stands for the first argument, n = 2 for the second argument etc.  */
+#ifndef _GL_ARG_NONNULL
+# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
+#  define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
+# else
+#  define _GL_ARG_NONNULL(params)
+# endif
+#endif
+
+/* The definition of _GL_WARN_ON_USE is copied here.  */
+#ifndef _GL_WARN_ON_USE
+
+# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
+/* A compiler attribute is available in gcc versions 4.3.0 and later.  */
+#  define _GL_WARN_ON_USE(function, message) \
+extern __typeof__ (function) function __attribute__ ((__warning__ (message)))
+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
+/* Verify the existence of the function.  */
+#  define _GL_WARN_ON_USE(function, message) \
+extern __typeof__ (function) function
+# else /* Unsupported.  */
+#  define _GL_WARN_ON_USE(function, message) \
+_GL_WARN_EXTERN_C int _gl_warn_on_use
+# endif
+#endif
+
+/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")
+   is like _GL_WARN_ON_USE (function, "string"), except that the function is
+   declared with the given prototype, consisting of return type, parameters,
+   and attributes.
+   This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does
+   not work in this case.  */
+#ifndef _GL_WARN_ON_USE_CXX
+# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
+extern rettype function parameters_and_attributes \
+     __attribute__ ((__warning__ (msg)))
+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
+/* Verify the existence of the function.  */
+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
+extern rettype function parameters_and_attributes
+# else /* Unsupported.  */
+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
+_GL_WARN_EXTERN_C int _gl_warn_on_use
+# endif
+#endif
+
+/* _GL_WARN_EXTERN_C declaration;
+   performs the declaration with C linkage.  */
+#ifndef _GL_WARN_EXTERN_C
+# if defined __cplusplus
+#  define _GL_WARN_EXTERN_C extern "C"
+# else
+#  define _GL_WARN_EXTERN_C extern
+# endif
+#endif
+
+
+/* Define wint_t and WEOF.  (Also done in wctype.in.h.)  */
+#if !1 && !defined wint_t
+# define wint_t int
+# ifndef WEOF
+#  define WEOF -1
+# endif
+#else
+/* MSVC defines wint_t as 'unsigned short' in <crtdefs.h>.
+   This is too small: ISO C 99 section 7.24.1.(2) says that wint_t must be
+   "unchanged by default argument promotions".  Override it.  */
+# if defined _MSC_VER
+#  if !GNULIB_defined_wint_t
+#   include <crtdefs.h>
+typedef unsigned int rpl_wint_t;
+#   undef wint_t
+#   define wint_t rpl_wint_t
+#   define GNULIB_defined_wint_t 1
+#  endif
+# endif
+# ifndef WEOF
+#  define WEOF ((wint_t) -1)
+# endif
+#endif
+
+
+/* Override mbstate_t if it is too small.
+   On IRIX 6.5, sizeof (mbstate_t) == 1, which is not sufficient for
+   implementing mbrtowc for encodings like UTF-8.  */
+#if !(1 && 1) || 0
+# if !GNULIB_defined_mbstate_t
+typedef int rpl_mbstate_t;
+#  undef mbstate_t
+#  define mbstate_t rpl_mbstate_t
+#  define GNULIB_defined_mbstate_t 1
+# endif
+#endif
+
+
+/* Convert a single-byte character to a wide character.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef btowc
+#   define btowc rpl_btowc
+#  endif
+_GL_FUNCDECL_RPL (btowc, wint_t, (int c) _GL_ATTRIBUTE_PURE);
+_GL_CXXALIAS_RPL (btowc, wint_t, (int c));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (btowc, wint_t, (int c) _GL_ATTRIBUTE_PURE);
+#  endif
+_GL_CXXALIAS_SYS (btowc, wint_t, (int c));
+# endif
+_GL_CXXALIASWARN (btowc);
+#elif defined GNULIB_POSIXCHECK
+# undef btowc
+# if HAVE_RAW_DECL_BTOWC
+_GL_WARN_ON_USE (btowc, "btowc is unportable - "
+                 "use gnulib module btowc for portability");
+# endif
+#endif
+
+
+/* Convert a wide character to a single-byte character.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef wctob
+#   define wctob rpl_wctob
+#  endif
+_GL_FUNCDECL_RPL (wctob, int, (wint_t wc) _GL_ATTRIBUTE_PURE);
+_GL_CXXALIAS_RPL (wctob, int, (wint_t wc));
+# else
+#  if !defined wctob && !1
+/* wctob is provided by gnulib, or wctob exists but is not declared.  */
+_GL_FUNCDECL_SYS (wctob, int, (wint_t wc) _GL_ATTRIBUTE_PURE);
+#  endif
+_GL_CXXALIAS_SYS (wctob, int, (wint_t wc));
+# endif
+_GL_CXXALIASWARN (wctob);
+#elif defined GNULIB_POSIXCHECK
+# undef wctob
+# if HAVE_RAW_DECL_WCTOB
+_GL_WARN_ON_USE (wctob, "wctob is unportable - "
+                 "use gnulib module wctob for portability");
+# endif
+#endif
+
+
+/* Test whether *PS is in the initial state.  */
+#if 1
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef mbsinit
+#   define mbsinit rpl_mbsinit
+#  endif
+_GL_FUNCDECL_RPL (mbsinit, int, (const mbstate_t *ps));
+_GL_CXXALIAS_RPL (mbsinit, int, (const mbstate_t *ps));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (mbsinit, int, (const mbstate_t *ps));
+#  endif
+_GL_CXXALIAS_SYS (mbsinit, int, (const mbstate_t *ps));
+# endif
+_GL_CXXALIASWARN (mbsinit);
+#elif defined GNULIB_POSIXCHECK
+# undef mbsinit
+# if HAVE_RAW_DECL_MBSINIT
+_GL_WARN_ON_USE (mbsinit, "mbsinit is unportable - "
+                 "use gnulib module mbsinit for portability");
+# endif
+#endif
+
+
+/* Convert a multibyte character to a wide character.  */
+#if 1
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef mbrtowc
+#   define mbrtowc rpl_mbrtowc
+#  endif
+_GL_FUNCDECL_RPL (mbrtowc, size_t,
+                  (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps));
+_GL_CXXALIAS_RPL (mbrtowc, size_t,
+                  (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (mbrtowc, size_t,
+                  (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps));
+#  endif
+_GL_CXXALIAS_SYS (mbrtowc, size_t,
+                  (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps));
+# endif
+_GL_CXXALIASWARN (mbrtowc);
+#elif defined GNULIB_POSIXCHECK
+# undef mbrtowc
+# if HAVE_RAW_DECL_MBRTOWC
+_GL_WARN_ON_USE (mbrtowc, "mbrtowc is unportable - "
+                 "use gnulib module mbrtowc for portability");
+# endif
+#endif
+
+
+/* Recognize a multibyte character.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef mbrlen
+#   define mbrlen rpl_mbrlen
+#  endif
+_GL_FUNCDECL_RPL (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps));
+_GL_CXXALIAS_RPL (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps));
+#  endif
+_GL_CXXALIAS_SYS (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps));
+# endif
+_GL_CXXALIASWARN (mbrlen);
+#elif defined GNULIB_POSIXCHECK
+# undef mbrlen
+# if HAVE_RAW_DECL_MBRLEN
+_GL_WARN_ON_USE (mbrlen, "mbrlen is unportable - "
+                 "use gnulib module mbrlen for portability");
+# endif
+#endif
+
+
+/* Convert a string to a wide string.  */
+#if 1
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef mbsrtowcs
+#   define mbsrtowcs rpl_mbsrtowcs
+#  endif
+_GL_FUNCDECL_RPL (mbsrtowcs, size_t,
+                  (wchar_t *dest, const char **srcp, size_t len, mbstate_t *ps)
+                  _GL_ARG_NONNULL ((2)));
+_GL_CXXALIAS_RPL (mbsrtowcs, size_t,
+                  (wchar_t *dest, const char **srcp, size_t len,
+                   mbstate_t *ps));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (mbsrtowcs, size_t,
+                  (wchar_t *dest, const char **srcp, size_t len, mbstate_t *ps)
+                  _GL_ARG_NONNULL ((2)));
+#  endif
+_GL_CXXALIAS_SYS (mbsrtowcs, size_t,
+                  (wchar_t *dest, const char **srcp, size_t len,
+                   mbstate_t *ps));
+# endif
+_GL_CXXALIASWARN (mbsrtowcs);
+#elif defined GNULIB_POSIXCHECK
+# undef mbsrtowcs
+# if HAVE_RAW_DECL_MBSRTOWCS
+_GL_WARN_ON_USE (mbsrtowcs, "mbsrtowcs is unportable - "
+                 "use gnulib module mbsrtowcs for portability");
+# endif
+#endif
+
+
+/* Convert a string to a wide string.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef mbsnrtowcs
+#   define mbsnrtowcs rpl_mbsnrtowcs
+#  endif
+_GL_FUNCDECL_RPL (mbsnrtowcs, size_t,
+                  (wchar_t *dest, const char **srcp, size_t srclen, size_t len,
+                   mbstate_t *ps)
+                  _GL_ARG_NONNULL ((2)));
+_GL_CXXALIAS_RPL (mbsnrtowcs, size_t,
+                  (wchar_t *dest, const char **srcp, size_t srclen, size_t len,
+                   mbstate_t *ps));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (mbsnrtowcs, size_t,
+                  (wchar_t *dest, const char **srcp, size_t srclen, size_t len,
+                   mbstate_t *ps)
+                  _GL_ARG_NONNULL ((2)));
+#  endif
+_GL_CXXALIAS_SYS (mbsnrtowcs, size_t,
+                  (wchar_t *dest, const char **srcp, size_t srclen, size_t len,
+                   mbstate_t *ps));
+# endif
+_GL_CXXALIASWARN (mbsnrtowcs);
+#elif defined GNULIB_POSIXCHECK
+# undef mbsnrtowcs
+# if HAVE_RAW_DECL_MBSNRTOWCS
+_GL_WARN_ON_USE (mbsnrtowcs, "mbsnrtowcs is unportable - "
+                 "use gnulib module mbsnrtowcs for portability");
+# endif
+#endif
+
+
+/* Convert a wide character to a multibyte character.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef wcrtomb
+#   define wcrtomb rpl_wcrtomb
+#  endif
+_GL_FUNCDECL_RPL (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps));
+_GL_CXXALIAS_RPL (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps));
+#  endif
+_GL_CXXALIAS_SYS (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps));
+# endif
+_GL_CXXALIASWARN (wcrtomb);
+#elif defined GNULIB_POSIXCHECK
+# undef wcrtomb
+# if HAVE_RAW_DECL_WCRTOMB
+_GL_WARN_ON_USE (wcrtomb, "wcrtomb is unportable - "
+                 "use gnulib module wcrtomb for portability");
+# endif
+#endif
+
+
+/* Convert a wide string to a string.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef wcsrtombs
+#   define wcsrtombs rpl_wcsrtombs
+#  endif
+_GL_FUNCDECL_RPL (wcsrtombs, size_t,
+                  (char *dest, const wchar_t **srcp, size_t len, mbstate_t *ps)
+                  _GL_ARG_NONNULL ((2)));
+_GL_CXXALIAS_RPL (wcsrtombs, size_t,
+                  (char *dest, const wchar_t **srcp, size_t len,
+                   mbstate_t *ps));
+# else
+#  if !1
+_GL_FUNCDECL_SYS (wcsrtombs, size_t,
+                  (char *dest, const wchar_t **srcp, size_t len, mbstate_t *ps)
+                  _GL_ARG_NONNULL ((2)));
+#  endif
+_GL_CXXALIAS_SYS (wcsrtombs, size_t,
+                  (char *dest, const wchar_t **srcp, size_t len,
+                   mbstate_t *ps));
+# endif
+_GL_CXXALIASWARN (wcsrtombs);
+#elif defined GNULIB_POSIXCHECK
+# undef wcsrtombs
+# if HAVE_RAW_DECL_WCSRTOMBS
+_GL_WARN_ON_USE (wcsrtombs, "wcsrtombs is unportable - "
+                 "use gnulib module wcsrtombs for portability");
+# endif
+#endif
+
+
+/* Convert a wide string to a string.  */
+#if 0
+# if 0
+#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+#   undef wcsnrtombs
+#   define wcsnrtombs rpl_wcsnrtombs
+#  endif
+_GL_FUNCDECL_RPL (wcsnrtombs, size_t,
+                  (char *dest, const wchar_t **srcp, size_t srclen, size_t len,
+                 &