new file mode 100644
@@ -0,0 +1,42 @@
+From 6347e1b9da2140acdd55e3e7ac1199456793e17c Mon Sep 17 00:00:00 2001
+From: Thomas Kuehne <thomas@kuehne.cn>
+Date: Sat, 11 Dec 2021 20:56:00 +0000
+Subject: [PATCH] Fix return type of main function
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Fixes:
+xmlif/xmlif.l:242:1: warning: return type defaults to ‘int’ [-Wimplicit-int]
+ 242 | main(int argc, char *argv[])
+ | ^~~~
+
+Signed-off-by: Thomas Kuehne <thomas@kuehne.cn>
+Signed-off-by: Martin Jansa <martin.jansa@gmail.com>
+Upstream-Status: Backport [v0.0.29 https://pagure.io/xmlto/c/8e34f087bf410bcc5fe445933d6ad9bae54f24b5?branch=master]
+---
+ xmlif/xmlif.l | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/xmlif/xmlif.l b/xmlif/xmlif.l
+index ac42136..78a62bc 100644
+--- a/xmlif/xmlif.l
++++ b/xmlif/xmlif.l
+@@ -239,7 +239,7 @@ WS [ \t\n]*
+
+ int yywrap() {exit(0);};
+
+-main(int argc, char *argv[])
++int main(int argc, char *argv[])
+ {
+ int i;
+
+@@ -265,7 +265,7 @@ main(int argc, char *argv[])
+ exit(1);
+ }
+
+- yylex();
++ return yylex();
+ }
+
+ /*
new file mode 100644
@@ -0,0 +1,1259 @@
+From 32376c053733c6c0ebaca3c25c0725509342fdf3 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Ond=C5=99ej=20Sloup?= <osloup@redhat.com>
+Date: Thu, 11 Apr 2024 18:09:37 +0200
+Subject: [PATCH] Regenerate the xmlif.c and update xmlif.l to comply with the
+ new version of flex and gcc
+
+Removes warnings in the build process
+Signed-off-by: Martin Jansa <martin.jansa@gmail.com>
+Upstream-Status: Backport [v0.0.29 https://pagure.io/xmlto/c/32376c053733c6c0ebaca3c25c0725509342fdf3?branch=master]
+---
+ xmlif/xmlif.c | 449 ++++++++++++++++++++++++++------------------------
+ xmlif/xmlif.l | 2 +-
+ 2 files changed, 232 insertions(+), 219 deletions(-)
+
+diff --git a/xmlif/xmlif.c b/xmlif/xmlif.c
+index 50aa1bc..1b87a9e 100644
+--- a/xmlif/xmlif.c
++++ b/xmlif/xmlif.c
+@@ -1,3 +1,4 @@
++#line 1 "xmlif/xmlif.c"
+
+ #line 3 "xmlif/xmlif.c"
+
+@@ -7,8 +8,8 @@
+
+ #define FLEX_SCANNER
+ #define YY_FLEX_MAJOR_VERSION 2
+-#define YY_FLEX_MINOR_VERSION 5
+-#define YY_FLEX_SUBMINOR_VERSION 37
++#define YY_FLEX_MINOR_VERSION 6
++#define YY_FLEX_SUBMINOR_VERSION 4
+ #if YY_FLEX_SUBMINOR_VERSION > 0
+ #define FLEX_BETA
+ #endif
+@@ -83,65 +84,61 @@ typedef unsigned int flex_uint32_t;
+ #define UINT32_MAX (4294967295U)
+ #endif
+
++#ifndef SIZE_MAX
++#define SIZE_MAX (~(size_t)0)
++#endif
++
+ #endif /* ! C99 */
+
+ #endif /* ! FLEXINT_H */
+
+-#ifdef __cplusplus
+-
+-/* The "const" storage-class-modifier is valid. */
+-#define YY_USE_CONST
+-
+-#else /* ! __cplusplus */
+-
+-/* C99 requires __STDC__ to be defined as 1. */
+-#if defined (__STDC__)
+-
+-#define YY_USE_CONST
+-
+-#endif /* defined (__STDC__) */
+-#endif /* ! __cplusplus */
++/* begin standard C++ headers. */
+
+-#ifdef YY_USE_CONST
++/* TODO: this is always defined, so inline it */
+ #define yyconst const
++
++#if defined(__GNUC__) && __GNUC__ >= 3
++#define yynoreturn __attribute__((__noreturn__))
+ #else
+-#define yyconst
++#define yynoreturn
+ #endif
+
+ /* Returned upon end-of-file. */
+ #define YY_NULL 0
+
+-/* Promotes a possibly negative, possibly signed char to an unsigned
+- * integer for use as an array index. If the signed char is negative,
+- * we want to instead treat it as an 8-bit unsigned char, hence the
+- * double cast.
++/* Promotes a possibly negative, possibly signed char to an
++ * integer in range [0..255] for use as an array index.
+ */
+-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
++#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+ /* Enter a start condition. This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+ #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 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
++#ifdef __ia64__
++/* On IA-64, the buffer size is 16k, not 8k.
++ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
++ * Ditto for the __ia64__ case accordingly.
++ */
++#define YY_BUF_SIZE 32768
++#else
+ #define YY_BUF_SIZE 16384
++#endif /* __ia64__ */
+ #endif
+
+ /* The state buf must be large enough to hold one state per character in the main buffer.
+@@ -158,15 +155,16 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
+ typedef size_t yy_size_t;
+ #endif
+
+-extern yy_size_t yyleng;
++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
+-
++
+ #define YY_LESS_LINENO(n)
++ #define YY_LINENO_REWIND_TO(ptr)
+
+ /* Return all but the first "n" matched characters back to the input stream. */
+ #define yyless(n) \
+@@ -181,7 +179,6 @@ extern FILE *yyin, *yyout;
+ YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+ } \
+ while ( 0 )
+-
+ #define unput(c) yyunput( c, (yytext_ptr) )
+
+ #ifndef YY_STRUCT_YY_BUFFER_STATE
+@@ -196,12 +193,12 @@ struct yy_buffer_state
+ /* Size of input buffer in bytes, not including room for EOB
+ * characters.
+ */
+- yy_size_t yy_buf_size;
++ int yy_buf_size;
+
+ /* Number of characters read into yy_ch_buf, not including EOB
+ * characters.
+ */
+- yy_size_t yy_n_chars;
++ int yy_n_chars;
+
+ /* Whether we "own" the buffer - i.e., we know we created it,
+ * and can realloc() it to grow it, and should free() it to
+@@ -224,7 +221,7 @@ struct yy_buffer_state
+
+ 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.
+ */
+@@ -252,7 +249,7 @@ struct yy_buffer_state
+ /* 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. */
++static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< 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
+@@ -263,7 +260,6 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
+ #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.
+ */
+@@ -271,11 +267,11 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
+
+ /* yy_hold_char holds the character lost when yytext is formed. */
+ static char yy_hold_char;
+-static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
+-yy_size_t yyleng;
++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 char *yy_c_buf_p = NULL;
+ static int yy_init = 0; /* whether we need to initialize */
+ static int yy_start = 0; /* start state number */
+
+@@ -284,82 +280,78 @@ static int yy_start = 0; /* start state number */
+ */
+ static int yy_did_buffer_switch_on_eof;
+
+-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 );
+-
+-static void yyensure_buffer_stack (void );
+-static void yy_load_buffer_state (void );
+-static void yy_init_buffer (YY_BUFFER_STATE b,FILE *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 );
+
+-#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 );
++#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
+
+-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,yy_size_t len );
++YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
++YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
++YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
+
+-void *yyalloc (yy_size_t );
+-void *yyrealloc (void *,yy_size_t );
+-void yyfree (void * );
++void *yyalloc ( yy_size_t );
++void *yyrealloc ( void *, yy_size_t );
++void yyfree ( void * );
+
+ #define yy_new_buffer yy_create_buffer
+-
+ #define yy_set_interactive(is_interactive) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){ \
+ yyensure_buffer_stack (); \
+ YY_CURRENT_BUFFER_LVALUE = \
+- yy_create_buffer(yyin,YY_BUF_SIZE ); \
++ 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 ){\
+ yyensure_buffer_stack (); \
+ YY_CURRENT_BUFFER_LVALUE = \
+- yy_create_buffer(yyin,YY_BUF_SIZE ); \
++ yy_create_buffer( yyin, YY_BUF_SIZE ); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+ }
+-
+ #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+ /* Begin user sect3 */
++typedef flex_uint8_t YY_CHAR;
+
+-typedef unsigned char YY_CHAR;
+-
+-FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
++FILE *yyin = NULL, *yyout = NULL;
+
+-typedef yyconst struct yy_trans_info *yy_state_type;
++typedef const struct yy_trans_info *yy_state_type;
+
+ extern int yylineno;
+-
+ int yylineno = 1;
+
+ extern char *yytext;
++#ifdef yytext_ptr
++#undef yytext_ptr
++#endif
+ #define yytext_ptr yytext
+
+-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[] );
++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 yynoreturn yy_fatal_error ( const 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 = (size_t) (yy_cp - yy_bp); \
++ yyleng = (int) (yy_cp - yy_bp); \
+ (yy_hold_char) = *yy_cp; \
+ *yy_cp = '\0'; \
+ (yy_c_buf_p) = yy_cp;
+-
+ #define YY_NUM_RULES 13
+ #define YY_END_OF_BUFFER 14
+ struct yy_trans_info
+@@ -367,7 +359,7 @@ struct yy_trans_info
+ flex_int16_t yy_verify;
+ flex_int16_t yy_nxt;
+ };
+-static yyconst struct yy_trans_info yy_transition[3478] =
++static const struct yy_trans_info yy_transition[3478] =
+ {
+ { 0, 0 }, { 0,3222 }, { 0, 0 }, { 0,3220 }, { 1,1548 },
+ { 2,1548 }, { 3,1548 }, { 4,1548 }, { 5,1548 }, { 6,1548 },
+@@ -1079,7 +1071,7 @@ static yyconst struct yy_trans_info yy_transition[3478] =
+ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
+ { 0, 0 }, { 0, 0 }, { 257, 14 }, { 1, 0 }, };
+
+-static yyconst struct yy_trans_info *yy_start_state_list[7] =
++static const struct yy_trans_info *yy_start_state_list[7] =
+ {
+ &yy_transition[1],
+ &yy_transition[3],
+@@ -1145,13 +1137,14 @@ char *yytext;
+ */
+ #include <string.h>
+ #include <stdlib.h>
++#include <strings.h>
+
+ #define TRUE 1
+ #define FALSE 0
+
+ static char **selections; /* selection tokens */
+ static int nselections; /* number of selections */
+-static ifsense; /* sense of last `if' or unless seen */
++static int ifsense; /* sense of last `if' or unless seen */
+ static char *attribute; /* last attribute scanned */
+
+ struct stack_t {
+@@ -1301,8 +1294,9 @@ static void process_else()
+ }
+
+
++#line 1297 "xmlif/xmlif.c"
+
+-#line 1306 "xmlif/xmlif.c"
++#line 1299 "xmlif/xmlif.c"
+
+ #define INITIAL 0
+ #define attrib 1
+@@ -1320,36 +1314,36 @@ static void process_else()
+ #define YY_EXTRA_TYPE void *
+ #endif
+
+-static int yy_init_globals (void );
++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 yylex_destroy ( void );
+
+-int yyget_debug (void );
++int yyget_debug ( void );
+
+-void yyset_debug (int debug_flag );
++void yyset_debug ( int debug_flag );
+
+-YY_EXTRA_TYPE yyget_extra (void );
++YY_EXTRA_TYPE yyget_extra ( void );
+
+-void yyset_extra (YY_EXTRA_TYPE user_defined );
++void yyset_extra ( YY_EXTRA_TYPE user_defined );
+
+-FILE *yyget_in (void );
++FILE *yyget_in ( void );
+
+-void yyset_in (FILE * in_str );
++void yyset_in ( FILE * _in_str );
+
+-FILE *yyget_out (void );
++FILE *yyget_out ( void );
+
+-void yyset_out (FILE * out_str );
++void yyset_out ( FILE * _out_str );
+
+-yy_size_t yyget_leng (void );
++ int yyget_leng ( void );
+
+-char *yyget_text (void );
++char *yyget_text ( void );
+
+-int yyget_lineno (void );
++int yyget_lineno ( void );
+
+-void yyset_lineno (int line_number );
++void yyset_lineno ( int _line_number );
+
+ /* Macros after this point can all be overridden by user definitions in
+ * section 1.
+@@ -1357,35 +1351,43 @@ void yyset_lineno (int line_number );
+
+ #ifndef YY_SKIP_YYWRAP
+ #ifdef __cplusplus
+-extern "C" int yywrap (void );
++extern "C" int yywrap ( void );
+ #else
+-extern int yywrap (void );
++extern int yywrap ( void );
+ #endif
+ #endif
+
+- static void yyunput (int c,char *buf_ptr );
++#ifndef YY_NO_UNPUT
++
++ static void yyunput ( int c, char *buf_ptr );
+
++#endif
++
+ #ifndef yytext_ptr
+-static void yy_flex_strncpy (char *,yyconst char *,int );
++static void yy_flex_strncpy ( char *, const char *, int );
+ #endif
+
+ #ifdef YY_NEED_STRLEN
+-static int yy_flex_strlen (yyconst char * );
++static int yy_flex_strlen ( const char * );
+ #endif
+
+ #ifndef YY_NO_INPUT
+-
+ #ifdef __cplusplus
+-static int yyinput (void );
++static int yyinput ( void );
+ #else
+-static int input (void );
++static int input ( void );
+ #endif
+
+ #endif
+
+ /* Amount of stuff to slurp up with each read. */
+ #ifndef YY_READ_BUF_SIZE
++#ifdef __ia64__
++/* On IA-64, the buffer size is 16k, not 8k */
++#define YY_READ_BUF_SIZE 16384
++#else
+ #define YY_READ_BUF_SIZE 8192
++#endif /* __ia64__ */
+ #endif
+
+ /* Copy whatever the last rule matched to the standard output. */
+@@ -1393,7 +1395,7 @@ static int input (void );
+ /* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
++#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+ #endif
+
+ /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
+@@ -1402,7 +1404,7 @@ static int input (void );
+ #ifndef YY_INPUT
+ #define YY_INPUT(buf,result,max_size) \
+ errno=0; \
+- while ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
++ while ( (result = (int) read( fileno(yyin), buf, (yy_size_t) max_size )) < 0 ) \
+ { \
+ if( errno != EINTR) \
+ { \
+@@ -1456,7 +1458,7 @@ extern int yylex (void);
+
+ /* Code executed at the end of each rule. */
+ #ifndef YY_BREAK
+-#define YY_BREAK break;
++#define YY_BREAK /*LINTED*/break;
+ #endif
+
+ #define YY_RULE_SETUP \
+@@ -1466,14 +1468,10 @@ extern int yylex (void);
+ */
+ YY_DECL
+ {
+- register yy_state_type yy_current_state;
+- register char *yy_cp, *yy_bp;
+- register int yy_act;
++ yy_state_type yy_current_state;
++ char *yy_cp, *yy_bp;
++ int yy_act;
+
+-#line 207 "xmlif/xmlif.l"
+-
+-#line 1476 "xmlif/xmlif.c"
+-
+ if ( !(yy_init) )
+ {
+ (yy_init) = 1;
+@@ -1494,13 +1492,18 @@ YY_DECL
+ if ( ! YY_CURRENT_BUFFER ) {
+ yyensure_buffer_stack ();
+ YY_CURRENT_BUFFER_LVALUE =
+- yy_create_buffer(yyin,YY_BUF_SIZE );
++ yy_create_buffer( yyin, YY_BUF_SIZE );
+ }
+
+- yy_load_buffer_state( );
++ yy_load_buffer_state( );
+ }
+
+- while ( 1 ) /* loops until end-of-file is reached */
++ {
++#line 208 "xmlif/xmlif.l"
++
++#line 1504 "xmlif/xmlif.c"
++
++ while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
+ {
+ yy_cp = (yy_c_buf_p);
+
+@@ -1515,12 +1518,12 @@ YY_DECL
+ yy_current_state = yy_start_state_list[(yy_start)];
+ yy_match:
+ {
+- register yyconst struct yy_trans_info *yy_trans_info;
++ const struct yy_trans_info *yy_trans_info;
+
+- register YY_CHAR yy_c;
++ YY_CHAR yy_c;
+
+ for ( yy_c = YY_SC_TO_UI(*yy_cp);
+- (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->
++ (yy_trans_info = &yy_current_state[yy_c])->
+ yy_verify == yy_c;
+ yy_c = YY_SC_TO_UI(*++yy_cp) )
+ {
+@@ -1553,58 +1556,58 @@ do_action: /* This label is used only to access EOF actions. */
+ case 1:
+ /* rule 1 can match eol */
+ YY_RULE_SETUP
+-#line 208 "xmlif/xmlif.l"
++#line 209 "xmlif/xmlif.l"
+ {BEGIN(attrib); ifsense = FALSE; push_level();}
+ YY_BREAK
+ case 2:
+ /* rule 2 can match eol */
+ YY_RULE_SETUP
+-#line 209 "xmlif/xmlif.l"
++#line 210 "xmlif/xmlif.l"
+ {BEGIN(attrib); ifsense = TRUE; push_level();}
+ YY_BREAK
+ case 3:
+ /* rule 3 can match eol */
+ YY_RULE_SETUP
+-#line 210 "xmlif/xmlif.l"
++#line 211 "xmlif/xmlif.l"
+ {BEGIN(attrib); ifsense = FALSE;}
+ YY_BREAK
+ case 4:
+ /* rule 4 can match eol */
+ YY_RULE_SETUP
+-#line 211 "xmlif/xmlif.l"
++#line 212 "xmlif/xmlif.l"
+ {BEGIN(attrib); ifsense = TRUE;}
+ YY_BREAK
+ case 5:
+ /* rule 5 can match eol */
+ YY_RULE_SETUP
+-#line 212 "xmlif/xmlif.l"
++#line 213 "xmlif/xmlif.l"
+ {process_else();}
+ YY_BREAK
+ case 6:
+ /* rule 6 can match eol */
+ YY_RULE_SETUP
+-#line 214 "xmlif/xmlif.l"
++#line 215 "xmlif/xmlif.l"
+ {pop_level();}
+ YY_BREAK
+ case 7:
+ YY_RULE_SETUP
+-#line 216 "xmlif/xmlif.l"
++#line 217 "xmlif/xmlif.l"
+ {stash_attribute(yytext);}
+ YY_BREAK
+ case 8:
+ YY_RULE_SETUP
+-#line 217 "xmlif/xmlif.l"
++#line 218 "xmlif/xmlif.l"
+ {BEGIN(val);}
+ YY_BREAK
+ case 9:
+ YY_RULE_SETUP
+-#line 218 "xmlif/xmlif.l"
++#line 219 "xmlif/xmlif.l"
+ {BEGIN(INITIAL); end_attribute();}
+ YY_BREAK
+ case 10:
+ /* rule 10 can match eol */
+ YY_RULE_SETUP
+-#line 219 "xmlif/xmlif.l"
++#line 220 "xmlif/xmlif.l"
+ {
+ yytext[strlen(yytext)-1]='\0';
+ process_value(yytext+1);
+@@ -1613,7 +1616,7 @@ YY_RULE_SETUP
+ YY_BREAK
+ case 11:
+ YY_RULE_SETUP
+-#line 224 "xmlif/xmlif.l"
++#line 225 "xmlif/xmlif.l"
+ {
+ fprintf(stderr,
+ "xmlif: > where value expected\n");
+@@ -1622,7 +1625,7 @@ YY_RULE_SETUP
+ YY_BREAK
+ case 12:
+ YY_RULE_SETUP
+-#line 230 "xmlif/xmlif.l"
++#line 231 "xmlif/xmlif.l"
+ {
+ if (!end->suppressed)
+ putchar(yytext[0]);
+@@ -1630,10 +1633,10 @@ YY_RULE_SETUP
+ YY_BREAK
+ case 13:
+ YY_RULE_SETUP
+-#line 235 "xmlif/xmlif.l"
++#line 236 "xmlif/xmlif.l"
+ ECHO;
+ YY_BREAK
+-#line 1637 "xmlif/xmlif.c"
++#line 1639 "xmlif/xmlif.c"
+ case YY_STATE_EOF(INITIAL):
+ case YY_STATE_EOF(attrib):
+ case YY_STATE_EOF(val):
+@@ -1713,7 +1716,7 @@ case YY_STATE_EOF(val):
+ {
+ (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
+@@ -1766,6 +1769,7 @@ case YY_STATE_EOF(val):
+ "fatal flex scanner internal error--no action found" );
+ } /* end of action switch */
+ } /* end of scanning one token */
++ } /* end of user's declarations */
+ } /* end of yylex */
+
+ /* yy_get_next_buffer - try to read in a new buffer
+@@ -1777,9 +1781,9 @@ case YY_STATE_EOF(val):
+ */
+ 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;
++ char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
++ char *source = (yytext_ptr);
++ int number_to_move, i;
+ int ret_val;
+
+ if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+@@ -1808,7 +1812,7 @@ static int yy_get_next_buffer (void)
+ /* 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++);
+@@ -1821,7 +1825,7 @@ static int yy_get_next_buffer (void)
+
+ else
+ {
+- yy_size_t num_to_read =
++ int num_to_read =
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+ while ( num_to_read <= 0 )
+@@ -1835,7 +1839,7 @@ static int yy_get_next_buffer (void)
+
+ if ( b->yy_is_our_buffer )
+ {
+- yy_size_t new_size = b->yy_buf_size * 2;
++ int new_size = b->yy_buf_size * 2;
+
+ if ( new_size <= 0 )
+ b->yy_buf_size += b->yy_buf_size / 8;
+@@ -1844,11 +1848,12 @@ static int yy_get_next_buffer (void)
+
+ b->yy_ch_buf = (char *)
+ /* Include room in for 2 EOB chars. */
+- yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
++ yyrealloc( (void *) b->yy_ch_buf,
++ (yy_size_t) (b->yy_buf_size + 2) );
+ }
+ else
+ /* Can't grow it, we don't own it. */
+- b->yy_ch_buf = 0;
++ b->yy_ch_buf = NULL;
+
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR(
+@@ -1876,7 +1881,7 @@ static int yy_get_next_buffer (void)
+ if ( number_to_move == YY_MORE_ADJ )
+ {
+ ret_val = EOB_ACT_END_OF_FILE;
+- yyrestart(yyin );
++ yyrestart( yyin );
+ }
+
+ else
+@@ -1890,12 +1895,15 @@ static int yy_get_next_buffer (void)
+ else
+ ret_val = EOB_ACT_CONTINUE_SCAN;
+
+- if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
++ if (((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 *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
++ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
++ (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
+ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
++ /* "- 2" to take care of EOB's */
++ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+ }
+
+ (yy_n_chars) += number_to_move;
+@@ -1911,8 +1919,8 @@ static int yy_get_next_buffer (void)
+
+ static yy_state_type yy_get_previous_state (void)
+ {
+- register yy_state_type yy_current_state;
+- register char *yy_cp;
++ yy_state_type yy_current_state;
++ char *yy_cp;
+
+ yy_current_state = yy_start_state_list[(yy_start)];
+
+@@ -1936,11 +1944,11 @@ static int yy_get_next_buffer (void)
+ */
+ 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);
++ int yy_is_jam;
++ char *yy_cp = (yy_c_buf_p);
+
+- register int yy_c = 256;
+- register yyconst struct yy_trans_info *yy_trans_info;
++ int yy_c = 256;
++ const struct yy_trans_info *yy_trans_info;
+
+ yy_trans_info = &yy_current_state[(unsigned int) yy_c];
+ yy_current_state += yy_trans_info->yy_nxt;
+@@ -1958,9 +1966,11 @@ static int yy_get_next_buffer (void)
+ return yy_is_jam ? 0 : yy_current_state;
+ }
+
+- static void yyunput (int c, register char * yy_bp )
++#ifndef YY_NO_UNPUT
++
++ static void yyunput (int c, char * yy_bp )
+ {
+- register char *yy_cp;
++ char *yy_cp;
+
+ yy_cp = (yy_c_buf_p);
+
+@@ -1970,10 +1980,10 @@ static int yy_get_next_buffer (void)
+ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+ { /* need to shift things up to make room */
+ /* +2 for EOB chars. */
+- register yy_size_t number_to_move = (yy_n_chars) + 2;
+- register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
++ int number_to_move = (yy_n_chars) + 2;
++ char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+- register char *source =
++ char *source =
+ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+ while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+@@ -1982,7 +1992,7 @@ static int yy_get_next_buffer (void)
+ yy_cp += (int) (dest - source);
+ yy_bp += (int) (dest - source);
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+- (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
++ (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+ YY_FATAL_ERROR( "flex scanner push-back overflow" );
+@@ -1995,6 +2005,8 @@ static int yy_get_next_buffer (void)
+ (yy_c_buf_p) = yy_cp;
+ }
+
++#endif
++
+ #ifndef YY_NO_INPUT
+ #ifdef __cplusplus
+ static int yyinput (void)
+@@ -2019,7 +2031,7 @@ static int yy_get_next_buffer (void)
+
+ else
+ { /* need more input */
+- yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
++ int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
+ ++(yy_c_buf_p);
+
+ switch ( yy_get_next_buffer( ) )
+@@ -2036,14 +2048,14 @@ static int yy_get_next_buffer (void)
+ */
+
+ /* Reset buffer status. */
+- yyrestart(yyin );
++ yyrestart( yyin );
+
+ /*FALLTHROUGH*/
+
+ case EOB_ACT_END_OF_FILE:
+ {
+- if ( yywrap( ) )
+- return EOF;
++ if ( yywrap( ) )
++ return 0;
+
+ if ( ! (yy_did_buffer_switch_on_eof) )
+ YY_NEW_FILE;
+@@ -2080,11 +2092,11 @@ static int yy_get_next_buffer (void)
+ if ( ! YY_CURRENT_BUFFER ){
+ yyensure_buffer_stack ();
+ YY_CURRENT_BUFFER_LVALUE =
+- yy_create_buffer(yyin,YY_BUF_SIZE );
++ yy_create_buffer( yyin, YY_BUF_SIZE );
+ }
+
+- yy_init_buffer(YY_CURRENT_BUFFER,input_file );
+- yy_load_buffer_state( );
++ yy_init_buffer( YY_CURRENT_BUFFER, input_file );
++ yy_load_buffer_state( );
+ }
+
+ /** Switch to a different input buffer.
+@@ -2112,7 +2124,7 @@ static int yy_get_next_buffer (void)
+ }
+
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+- yy_load_buffer_state( );
++ yy_load_buffer_state( );
+
+ /* We don't actually know whether we did this switch during
+ * EOF (yywrap()) processing, but the only time this flag
+@@ -2140,7 +2152,7 @@ static void yy_load_buffer_state (void)
+ {
+ YY_BUFFER_STATE b;
+
+- b = (YY_BUFFER_STATE) yyalloc(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()" );
+
+@@ -2149,13 +2161,13 @@ static void yy_load_buffer_state (void)
+ /* 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 *) yyalloc(b->yy_buf_size + 2 );
++ b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (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;
+ }
+@@ -2174,9 +2186,9 @@ static void yy_load_buffer_state (void)
+ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+ if ( b->yy_is_our_buffer )
+- yyfree((void *) b->yy_ch_buf );
++ yyfree( (void *) b->yy_ch_buf );
+
+- yyfree((void *) b );
++ yyfree( (void *) b );
+ }
+
+ /* Initializes or reinitializes a buffer.
+@@ -2188,7 +2200,7 @@ static void yy_load_buffer_state (void)
+ {
+ int oerrno = errno;
+
+- yy_flush_buffer(b );
++ yy_flush_buffer( b );
+
+ b->yy_input_file = file;
+ b->yy_fill_buffer = 1;
+@@ -2231,7 +2243,7 @@ static void yy_load_buffer_state (void)
+ b->yy_buffer_status = YY_BUFFER_NEW;
+
+ if ( b == YY_CURRENT_BUFFER )
+- yy_load_buffer_state( );
++ yy_load_buffer_state( );
+ }
+
+ /** Pushes the new state onto the stack. The new state becomes
+@@ -2262,7 +2274,7 @@ void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+ /* copied from yy_switch_to_buffer. */
+- yy_load_buffer_state( );
++ yy_load_buffer_state( );
+ (yy_did_buffer_switch_on_eof) = 1;
+ }
+
+@@ -2281,7 +2293,7 @@ void yypop_buffer_state (void)
+ --(yy_buffer_stack_top);
+
+ if (YY_CURRENT_BUFFER) {
+- yy_load_buffer_state( );
++ yy_load_buffer_state( );
+ (yy_did_buffer_switch_on_eof) = 1;
+ }
+ }
+@@ -2299,15 +2311,15 @@ static void yyensure_buffer_stack (void)
+ * scanner will even need a stack. We use 2 instead of 1 to avoid an
+ * immediate realloc on the next call.
+ */
+- num_to_alloc = 1;
++ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+ (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;
+@@ -2316,7 +2328,7 @@ static void yyensure_buffer_stack (void)
+ 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 */;
++ yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+ num_to_alloc = (yy_buffer_stack_max) + grow_size;
+ (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
+@@ -2336,7 +2348,7 @@ static void yyensure_buffer_stack (void)
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ *
+- * @return the newly allocated buffer state object.
++ * @return the newly allocated buffer state object.
+ */
+ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
+ {
+@@ -2346,23 +2358,23 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
+ 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;
++ return NULL;
+
+- b = (YY_BUFFER_STATE) yyalloc(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()" );
+
+- b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
++ b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
+ b->yy_buf_pos = b->yy_ch_buf = base;
+ b->yy_is_our_buffer = 0;
+- b->yy_input_file = 0;
++ b->yy_input_file = NULL;
+ b->yy_n_chars = b->yy_buf_size;
+ b->yy_is_interactive = 0;
+ b->yy_at_bol = 1;
+ b->yy_fill_buffer = 0;
+ b->yy_buffer_status = YY_BUFFER_NEW;
+
+- yy_switch_to_buffer(b );
++ yy_switch_to_buffer( b );
+
+ return b;
+ }
+@@ -2375,10 +2387,10 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
+ * @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 )
++YY_BUFFER_STATE yy_scan_string (const char * yystr )
+ {
+
+- return yy_scan_bytes(yystr,strlen(yystr) );
++ return yy_scan_bytes( yystr, (int) strlen(yystr) );
+ }
+
+ /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+@@ -2388,7 +2400,7 @@ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
+ *
+ * @return the newly allocated buffer state object.
+ */
+-YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
++YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
+ {
+ YY_BUFFER_STATE b;
+ char *buf;
+@@ -2396,8 +2408,8 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len
+ int i;
+
+ /* Get memory for full buffer, including space for trailing EOB's. */
+- n = _yybytes_len + 2;
+- buf = (char *) yyalloc(n );
++ n = (yy_size_t) (_yybytes_len + 2);
++ buf = (char *) yyalloc( n );
+ if ( ! buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+@@ -2406,7 +2418,7 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len
+
+ 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()" );
+
+@@ -2422,9 +2434,9 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len
+ #define YY_EXIT_FAILURE 2
+ #endif
+
+-static void yy_fatal_error (yyconst char* msg )
++static void yynoreturn yy_fatal_error (const char* msg )
+ {
+- (void) fprintf( stderr, "%s\n", msg );
++ fprintf( stderr, "%s\n", msg );
+ exit( YY_EXIT_FAILURE );
+ }
+
+@@ -2452,7 +2464,7 @@ static void yy_fatal_error (yyconst char* msg )
+ */
+ int yyget_lineno (void)
+ {
+-
++
+ return yylineno;
+ }
+
+@@ -2475,7 +2487,7 @@ FILE *yyget_out (void)
+ /** Get the length of the current token.
+ *
+ */
+-yy_size_t yyget_leng (void)
++int yyget_leng (void)
+ {
+ return yyleng;
+ }
+@@ -2490,29 +2502,29 @@ char *yyget_text (void)
+ }
+
+ /** Set the current line number.
+- * @param line_number
++ * @param _line_number line number
+ *
+ */
+-void yyset_lineno (int line_number )
++void yyset_lineno (int _line_number )
+ {
+
+- yylineno = line_number;
++ yylineno = _line_number;
+ }
+
+ /** Set the input stream. This does not discard the current
+ * input buffer.
+- * @param in_str A readable stream.
++ * @param _in_str A readable stream.
+ *
+ * @see yy_switch_to_buffer
+ */
+-void yyset_in (FILE * in_str )
++void yyset_in (FILE * _in_str )
+ {
+- yyin = in_str ;
++ yyin = _in_str ;
+ }
+
+-void yyset_out (FILE * out_str )
++void yyset_out (FILE * _out_str )
+ {
+- yyout = out_str ;
++ yyout = _out_str ;
+ }
+
+ int yyget_debug (void)
+@@ -2520,9 +2532,9 @@ int yyget_debug (void)
+ return yy_flex_debug;
+ }
+
+-void yyset_debug (int bdebug )
++void yyset_debug (int _bdebug )
+ {
+- yy_flex_debug = bdebug ;
++ yy_flex_debug = _bdebug ;
+ }
+
+ static int yy_init_globals (void)
+@@ -2531,10 +2543,10 @@ static int yy_init_globals (void)
+ * This function is called from yylex_destroy(), so don't allocate here.
+ */
+
+- (yy_buffer_stack) = 0;
++ (yy_buffer_stack) = NULL;
+ (yy_buffer_stack_top) = 0;
+ (yy_buffer_stack_max) = 0;
+- (yy_c_buf_p) = (char *) 0;
++ (yy_c_buf_p) = NULL;
+ (yy_init) = 0;
+ (yy_start) = 0;
+
+@@ -2543,8 +2555,8 @@ static int yy_init_globals (void)
+ yyin = stdin;
+ yyout = stdout;
+ #else
+- yyin = (FILE *) 0;
+- yyout = (FILE *) 0;
++ yyin = NULL;
++ yyout = NULL;
+ #endif
+
+ /* For future reference: Set errno on error, since we are called by
+@@ -2559,7 +2571,7 @@ int yylex_destroy (void)
+
+ /* Pop the buffer stack, destroying each element. */
+ while(YY_CURRENT_BUFFER){
+- yy_delete_buffer(YY_CURRENT_BUFFER );
++ yy_delete_buffer( YY_CURRENT_BUFFER );
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ yypop_buffer_state();
+ }
+@@ -2580,18 +2592,19 @@ int yylex_destroy (void)
+ */
+
+ #ifndef yytext_ptr
+-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
++static void yy_flex_strncpy (char* s1, const char * s2, int n )
+ {
+- register int i;
++
++ int i;
+ for ( i = 0; i < n; ++i )
+ s1[i] = s2[i];
+ }
+ #endif
+
+ #ifdef YY_NEED_STRLEN
+-static int yy_flex_strlen (yyconst char * s )
++static int yy_flex_strlen (const char * s )
+ {
+- register int n;
++ int n;
+ for ( n = 0; s[n]; ++n )
+ ;
+
+@@ -2601,11 +2614,12 @@ static int yy_flex_strlen (yyconst char * s )
+
+ void *yyalloc (yy_size_t size )
+ {
+- return (void *) malloc( size );
++ return malloc(size);
+ }
+
+ void *yyrealloc (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
+@@ -2613,26 +2627,25 @@ void *yyrealloc (void * ptr, yy_size_t size )
+ * any pointer type to void*, and deal with argument conversions
+ * as though doing an assignment.
+ */
+- return (void *) realloc( (char *) ptr, size );
++ return realloc(ptr, size);
+ }
+
+ void yyfree (void * ptr )
+ {
+- free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
++ free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
+ }
+
+ #define YYTABLES_NAME "yytables"
+
+-#line 235 "xmlif/xmlif.l"
+-
++#line 236 "xmlif/xmlif.l"
+
+ #include <string.h>
+
+ #include "config.h"
+
+-int yywrap() {exit(0);};
++int yywrap() {exit(0);}
+
+-main(int argc, char *argv[])
++int main(int argc, char *argv[])
+ {
+ int i;
+
+@@ -2658,7 +2671,7 @@ main(int argc, char *argv[])
+ exit(1);
+ }
+
+- yylex();
++ return yylex();
+ }
+
+ /*
+diff --git a/xmlif/xmlif.l b/xmlif/xmlif.l
+index 294fbc7..560508e 100644
+--- a/xmlif/xmlif.l
++++ b/xmlif/xmlif.l
+@@ -203,7 +203,7 @@ WS [ \t\n]*
+
+ %x attrib val
+
+-%option batch never-interactive fast 8bit
++%option batch never-interactive fast 8bit yywrap
+
+ %%
+ <INITIAL>\<\?xmlif{WS}if{WS}not{WS} {BEGIN(attrib); ifsense = FALSE; push_level();}
new file mode 100644
@@ -0,0 +1,33 @@
+From 1375e2df75530cd198bd16ac3de38e2b0d126276 Mon Sep 17 00:00:00 2001
+From: Thomas Kuehne <thomas@kuehne.cn>
+Date: Sat, 11 Dec 2021 21:10:41 +0100
+Subject: [PATCH] fix -Wimplicit-int for ifsense
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+fixes:
+xmlif/xmlif.l:46:8: warning: type defaults to ‘int’ in declaration of ‘ifsense’ [-Wimplicit-int]
+ 46 | static ifsense; /* sense of last `if' or unless seen */
+ | ^~~~~~~
+
+Signed-off-by: Thomas Kuehne <thomas@kuehne.cn>
+Signed-off-by: Martin Jansa <martin.jansa@gmail.com>
+Upstream-Status: Backport [v0.0.29 https://pagure.io/xmlto/c/1375e2df75530cd198bd16ac3de38e2b0d126276?branch=master
+---
+ xmlif/xmlif.l | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/xmlif/xmlif.l b/xmlif/xmlif.l
+index ac42136..6e5970e 100644
+--- a/xmlif/xmlif.l
++++ b/xmlif/xmlif.l
+@@ -43,7 +43,7 @@
+
+ static char **selections; /* selection tokens */
+ static int nselections; /* number of selections */
+-static ifsense; /* sense of last `if' or unless seen */
++static int ifsense; /* sense of last `if' or unless seen */
+ static char *attribute; /* last attribute scanned */
+
+ struct stack_t {
@@ -8,6 +8,9 @@ LIC_FILES_CHKSUM = "file://COPYING;md5=59530bdf33659b29e73d4adb9f9f6552"
SRC_URI = "https://releases.pagure.org/xmlto/xmlto-${PV}.tar.gz \
file://configure.in-drop-the-test-of-xmllint-and-xsltproc.patch \
+ file://0001-Fix-return-type-of-main-function.patch \
+ file://0001-fix-Wimplicit-int-for-ifsense.patch \
+ file://0001-Regenerate-the-xmlif.c-and-update-xmlif.l-to-comply-.patch \
"
SRC_URI[md5sum] = "a1fefad9d83499a15576768f60f847c6"
SRC_URI[sha256sum] = "2f986b7c9a0e9ac6728147668e776d405465284e13c74d4146c9cbc51fd8aad3"
@@ -36,6 +39,13 @@ BBCLASSEXTEND = "native"
EXTRA_OECONF:append = " BASH=/bin/bash GCP=/bin/cp XMLLINT=xmllint XSLTPROC=xsltproc"
+do_configure:prepend() {
+ # make sure xmlif.c is newer than xmlif.l after do_patch (order of
+ # .patch files in SRC_URI isn't enough) to prevent regenerating it
+ # with flex-native which isn't in DEPENDS
+ touch ${S}/xmlif/xmlif.c
+}
+
do_install:append:class-native() {
create_wrapper ${D}${bindir}/xmlto XML_CATALOG_FILES=${sysconfdir}/xml/catalog
}