/* original parser id follows */

/* yysccsid[] = "@(#)yaccpar  1.9 (Berkeley) 02/21/93" */

/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */

#define YYBYACC 1

#define YYMAJOR 1

#define YYMINOR 9

#define YYPATCH 20140715

#define YYEMPTY        (-1)

#define yyclearin      (yychar = YYEMPTY)

#define yyerrok        (yyerrflag = 0)

#define YYRECOVERING() (yyerrflag != 0)

#define YYENOMEM       (-2)

#define YYEOF          0

#ifndef yyparse

#define yyparse    libphdi_xml_scanner_parse

#endif /* yyparse */

#ifndef yylex

#define yylex      libphdi_xml_scanner_lex

#endif /* yylex */

#ifndef yyerror

#define yyerror    libphdi_xml_scanner_error

#endif /* yyerror */

#ifndef yychar

#define yychar     libphdi_xml_scanner_char

#endif /* yychar */

#ifndef yyval

#define yyval      libphdi_xml_scanner_val

#endif /* yyval */

#ifndef yylval

#define yylval     libphdi_xml_scanner_lval

#endif /* yylval */

#ifndef yydebug

#define yydebug    libphdi_xml_scanner_debug

#endif /* yydebug */

#ifndef yynerrs

#define yynerrs    libphdi_xml_scanner_nerrs

#endif /* yynerrs */

#ifndef yyerrflag

#define yyerrflag  libphdi_xml_scanner_errflag

#endif /* yyerrflag */

#ifndef yylhs

#define yylhs      libphdi_xml_scanner_lhs

#endif /* yylhs */

#ifndef yylen

#define yylen      libphdi_xml_scanner_len

#endif /* yylen */

#ifndef yydefred

#define yydefred   libphdi_xml_scanner_defred

#endif /* yydefred */

#ifndef yydgoto

#define yydgoto    libphdi_xml_scanner_dgoto

#endif /* yydgoto */

#ifndef yysindex

#define yysindex   libphdi_xml_scanner_sindex

#endif /* yysindex */

#ifndef yyrindex

#define yyrindex   libphdi_xml_scanner_rindex

#endif /* yyrindex */

#ifndef yygindex

#define yygindex   libphdi_xml_scanner_gindex

#endif /* yygindex */

#ifndef yytable

#define yytable    libphdi_xml_scanner_table

#endif /* yytable */

#ifndef yycheck

#define yycheck    libphdi_xml_scanner_check

#endif /* yycheck */

#ifndef yyname

#define yyname     libphdi_xml_scanner_name

#endif /* yyname */

#ifndef yyrule

#define yyrule     libphdi_xml_scanner_rule

#endif /* yyrule */

#define YYPREFIX "libphdi_xml_scanner_"

#define YYPURE 0

/*

 * XML parser functions

 *

 * Copyright (C) 2015-2025, Joachim Metz <joachim.metz@gmail.com>

 *

 * Refer to AUTHORS for acknowledgements.

 *

 * This program is free software: you can redistribute it and/or modify

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

 * the Free Software Foundation, either version 3 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 Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

 */

#include <common.h>

#include <memory.h>

#include <narrow_string.h>

#include <types.h>

#if defined( HAVE_STDLIB_H ) || defined( WINAPI )

#include <stdlib.h>

#endif

#include "libphdi_disk_descriptor_xml_file.h"

#include "libphdi_libcerror.h"

#include "libphdi_libcnotify.h"

#include "libphdi_types.h"

#include "libphdi_xml_tag.h"

#define YYMALLOC  libphdi_xml_scanner_alloc

#define YYREALLOC libphdi_xml_scanner_realloc

#define YYFREE    libphdi_xml_scanner_free

#define YYLEX_PARAM NULL

#define YYPARSE_PARAM parser_state

#if defined( HAVE_DEBUG_OUTPUT )

#define libphdi_xml_parser_rule_print( string ) \

  if( libcnotify_verbose != 0 ) libcnotify_printf( "libphdi_xml_parser: rule: %s\n", string )

#else

#define libphdi_xml_parser_rule_print( string )

#endif

#ifdef YYSTYPE

#undef  YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED 1

#endif

#ifndef YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED 1

typedef union

{

        /* The numeric value

         */

        uint32_t numeric_value;

        /* The string value

         */

  struct xml_plist_string_value

  {

    /* The string data

     */

          const char *data;

    /* The string length

     */

    size_t length;

  } string_value;

} YYSTYPE;

#endif /* !YYSTYPE_IS_DECLARED */

typedef struct libphdi_xml_parser_state libphdi_xml_parser_state_t;

struct libphdi_xml_parser_state

{

  /* The disk descriptor XML file

   */

  libphdi_disk_descriptor_xml_file_t *disk_descriptor_xml_file;

  /* The error

   */

  libcerror_error_t **error;

  /* The root XML tag

   */

  libphdi_xml_tag_t *root_tag;

  /* The current XML tag

   */

  libphdi_xml_tag_t *current_tag;

  /* The parent XML tag

   */

  libphdi_xml_tag_t *parent_tag;

};

typedef size_t yy_size_t;

typedef struct yy_buffer_state* YY_BUFFER_STATE;

extern \

int libphdi_xml_scanner_suppress_error;

extern \

int libphdi_xml_scanner_lex_destroy(

     void );

extern \

void *libphdi_xml_scanner_alloc(

       yy_size_t size );

extern \

void *libphdi_xml_scanner_realloc(

       void *buffer,

       yy_size_t size );

extern \

void *libphdi_xml_scanner_free(

       void *buffer );

extern \

int libphdi_xml_scanner_lex(

     void *user_data );

extern \

void libphdi_xml_scanner_error(

      void *parser_state,

      const char *error_string );

extern \

YY_BUFFER_STATE libphdi_xml_scanner__scan_buffer(

                 char *buffer,

                 yy_size_t buffer_size );

extern \

void libphdi_xml_scanner__delete_buffer(

      YY_BUFFER_STATE buffer_state );

extern \

size_t libphdi_xml_scanner_buffer_offset;

static char *libphdi_xml_parser_function = "libphdi_xml_parser";

int libphdi_xml_parser_parse_buffer(

     libphdi_disk_descriptor_xml_file_t *disk_descriptor_xml_file,

     uint8_t *buffer,

     size_t buffer_size,

     libcerror_error_t **error );

/* compatibility with bison */

#ifdef YYPARSE_PARAM

/* compatibility with FreeBSD */

# ifdef YYPARSE_PARAM_TYPE

#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)

# else

#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)

# endif

#else

# define YYPARSE_DECL() yyparse(void * parser_state)

#endif

/* Parameters sent to lex. */

#ifdef YYLEX_PARAM

# define YYLEX_DECL() yylex(void *YYLEX_PARAM)

# define YYLEX yylex(YYLEX_PARAM)

#else

# define YYLEX_DECL() yylex((void *)  NULL)

# define YYLEX yylex(NULL)

#endif

/* Parameters sent to yyerror. */

#ifndef YYERROR_DECL

#define YYERROR_DECL() yyerror(void * parser_state, const char *s)

#endif

#ifndef YYERROR_CALL

#define YYERROR_CALL(msg) yyerror(parser_state, msg)

#endif

extern int YYPARSE_DECL();

#define XML_ATTRIBUTE_ASSIGN 257

#define XML_COMMENT 258

#define XML_DOCTYPE 259

#define XML_PROLOGUE 260

#define XML_TAG_END 261

#define XML_TAG_END_SINGLE 262

#define XML_UNDEFINED 263

#define XML_ATTRIBUTE_NAME 264

#define XML_ATTRIBUTE_VALUE 265

#define XML_TAG_CLOSE 266

#define XML_TAG_CONTENT 267

#define XML_TAG_OPEN_START 268

#define YYERRCODE 256

typedef short YYINT;

static const YYINT libphdi_xml_scanner_lhs[] = {         -1,

    0,    1,    1,    2,    2,    4,    4,    6,    6,    6,

    9,    3,    8,    5,    7,   10,   10,   11,

};

static const YYINT libphdi_xml_scanner_len[] = {          2,

    5,    0,    1,    0,    1,    0,    2,    3,    3,    1,

    1,    3,    3,    1,    1,    0,    2,    3,

};

static const YYINT libphdi_xml_scanner_defred[] = {       0,

    3,    0,    0,    5,    0,   11,    0,    0,    0,    0,

    0,   10,    0,    0,    0,    0,   15,    0,    0,   14,

    1,    7,    0,    0,   12,   17,    8,    9,   13,   18,

};

static const YYINT libphdi_xml_scanner_dgoto[] = {        2,

    3,    5,    9,   10,   21,   11,   19,   12,   13,   15,

   16,

};

static const YYINT libphdi_xml_scanner_sindex[] = {    -258,

    0,    0, -243,    0, -260,    0, -260, -247, -261, -248,

 -260,    0, -247, -238, -241, -247,    0, -248, -248,    0,

    0,    0, -251, -244,    0,    0,    0,    0,    0,    0,

};

static const YYINT libphdi_xml_scanner_rindex[] = {    -259,

    0,    0, -246,    0,    0,    0, -242, -236, -242,    0,

 -242,    0, -249,    0,    0, -249,    0,    0,    0,    0,

    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,

};

static const YYINT libphdi_xml_scanner_gindex[] = {       0,

    0,    0,   18,   -6,   -4,    0,    0,    0,   21,  -12,

    0,

};

#define YYTABLESIZE 26

static const YYINT libphdi_xml_scanner_table[] = {        2,

   23,    1,   18,   26,   22,   17,    6,    6,    2,   25,

   29,   16,   16,   27,   28,    4,   14,   20,   24,   25,

   30,    4,    7,    6,   16,    8,

};

static const YYINT libphdi_xml_scanner_check[] = {      259,

   13,  260,    9,   16,   11,  267,  268,  268,  268,  261,

  262,  261,  262,   18,   19,  259,  264,  266,  257,  261,

  265,  268,    5,  266,  261,    5,

};

#define YYFINAL 2

#ifndef YYDEBUG

#define YYDEBUG 0

#endif

#define YYMAXTOKEN 268

#define YYUNDFTOKEN 282

#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))

#if YYDEBUG

static const char *const libphdi_xml_scanner_name[] = {

"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"XML_ATTRIBUTE_ASSIGN",

"XML_COMMENT","XML_DOCTYPE","XML_PROLOGUE","XML_TAG_END","XML_TAG_END_SINGLE",

"XML_UNDEFINED","XML_ATTRIBUTE_NAME","XML_ATTRIBUTE_VALUE","XML_TAG_CLOSE",

"XML_TAG_CONTENT","XML_TAG_OPEN_START",0,0,0,0,0,0,0,0,0,0,0,0,0,

"illegal-symbol",

};

static const char *const libphdi_xml_scanner_rule[] = {

"$accept : xml_plist_main",

"xml_plist_main : xml_prologue xml_doctype xml_tag_open xml_tags xml_tag_close",

"xml_prologue :",

"xml_prologue : XML_PROLOGUE",

"xml_doctype :",

"xml_doctype : XML_DOCTYPE",

"xml_tags :",

"xml_tags : xml_tag xml_tags",

"xml_tag : xml_tag_open xml_tags xml_tag_close",

"xml_tag : xml_tag_open xml_tag_content xml_tag_close",

"xml_tag : xml_tag_single",

"xml_tag_open_start : XML_TAG_OPEN_START",

"xml_tag_open : xml_tag_open_start xml_attributes XML_TAG_END",

"xml_tag_single : xml_tag_open_start xml_attributes XML_TAG_END_SINGLE",

"xml_tag_close : XML_TAG_CLOSE",

"xml_tag_content : XML_TAG_CONTENT",

"xml_attributes :",

"xml_attributes : xml_attribute xml_attributes",

"xml_attribute : XML_ATTRIBUTE_NAME XML_ATTRIBUTE_ASSIGN XML_ATTRIBUTE_VALUE",

};

#endif

int      yydebug;

int      yynerrs;

int      yyerrflag;

int      yychar;

YYSTYPE  yyval;

YYSTYPE  yylval;

/* define the initial stack-sizes */

#ifdef YYSTACKSIZE

#undef YYMAXDEPTH

#define YYMAXDEPTH  YYSTACKSIZE

#else

#ifdef YYMAXDEPTH

#define YYSTACKSIZE YYMAXDEPTH

#else

#define YYSTACKSIZE 10000

#define YYMAXDEPTH  10000

#endif

#endif

#define YYINITSTACKSIZE 200

typedef struct {

    unsigned stacksize;

    YYINT    *s_base;

    YYINT    *s_mark;

    YYINT    *s_last;

    YYSTYPE  *l_base;

    YYSTYPE  *l_mark;

} YYSTACKDATA;

/* variables for the parser stack */

static YYSTACKDATA yystack;

int libphdi_xml_parser_parse_buffer(

     libphdi_disk_descriptor_xml_file_t *disk_descriptor_xml_file,

     uint8_t *buffer,

     size_t buffer_size,

     libcerror_error_t **error )

{

  libphdi_xml_parser_state_t parser_state;

  YY_BUFFER_STATE buffer_state = NULL;

  static char *function        = "libphdi_xml_parser_parse_buffer";

  int result                   = -1;

  buffer_state = libphdi_xml_scanner__scan_buffer(

                  (char *) buffer,

                  buffer_size );

  libphdi_xml_scanner_buffer_offset = 0;

  if( buffer_state != NULL )

  {

    parser_state.disk_descriptor_xml_file = disk_descriptor_xml_file;

    parser_state.error                    = error;

    parser_state.root_tag                 = NULL;

    parser_state.current_tag              = NULL;

    parser_state.parent_tag               = NULL;

    if( libphdi_xml_scanner_parse(

         &parser_state ) == 0 )

    {

      if( libphdi_disk_descriptor_xml_file_set_root_tag(

           disk_descriptor_xml_file,

           parser_state.root_tag,

           error ) != 1 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_GET_FAILED,

         "%s: unable to set root tag.",

         function );

        result = -1;

      }

      else

      {

        parser_state.root_tag = NULL;

        result = 1;

      }

    }

    libphdi_xml_scanner__delete_buffer(

     buffer_state );

  }

  libphdi_xml_scanner_lex_destroy();

  if( parser_state.root_tag != NULL )

  {

    libphdi_xml_tag_free(

     &( parser_state.root_tag ),

     NULL );

  }

  return( result );

}

#if YYDEBUG

#include <stdio.h>    /* needed for printf */

#endif

#include <stdlib.h> /* needed for malloc, etc */

#include <string.h> /* needed for memset */

/* allocate initial stack or double stack size, up to YYMAXDEPTH */

static int yygrowstack(YYSTACKDATA *data)

{

    int i;

    unsigned newsize;

    YYINT *newss;

    YYSTYPE *newvs;

    if ((newsize = data->stacksize) == 0)

        newsize = YYINITSTACKSIZE;

    else if (newsize >= YYMAXDEPTH)

        return YYENOMEM;

    else if ((newsize *= 2) > YYMAXDEPTH)

        newsize = YYMAXDEPTH;

    i = (int) (data->s_mark - data->s_base);

    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));

    if (newss == 0)

        return YYENOMEM;

    data->s_base = newss;

    data->s_mark = newss + i;

    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));

    if (newvs == 0)

        return YYENOMEM;

    data->l_base = newvs;

    data->l_mark = newvs + i;

    data->stacksize = newsize;

    data->s_last = data->s_base + newsize - 1;

    return 0;

}

#if YYPURE || defined(YY_NO_LEAKS)

static void yyfreestack(YYSTACKDATA *data)

{

    free(data->s_base);

    free(data->l_base);

    memset(data, 0, sizeof(*data));

}

#else

#define yyfreestack(data) /* nothing */

#endif

#define YYABORT  goto yyabort

#define YYREJECT goto yyabort

#define YYACCEPT goto yyaccept

#define YYERROR  goto yyerrlab

int

YYPARSE_DECL()

{

    int yym, yyn, yystate;

#if YYDEBUG

    const char *yys;

    if ((yys = getenv("YYDEBUG")) != 0)

    {

        yyn = *yys;

        if (yyn >= '0' && yyn <= '9')

            yydebug = yyn - '0';

    }

#endif

    yynerrs = 0;

    yyerrflag = 0;

    yychar = YYEMPTY;

    yystate = 0;

#if YYPURE

    memset(&yystack, 0, sizeof(yystack));

#endif

    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;

    yystack.s_mark = yystack.s_base;

    yystack.l_mark = yystack.l_base;

    yystate = 0;

    *yystack.s_mark = 0;

yyloop:

    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;

    if (yychar < 0)

    {

        if ((yychar = YYLEX) < 0) yychar = YYEOF;

#if YYDEBUG

        if (yydebug)

        {

            yys = yyname[YYTRANSLATE(yychar)];

            printf("%sdebug: state %d, reading %d (%s)\n",

                    YYPREFIX, yystate, yychar, yys);

        }

#endif

    }

    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&

            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

    {

#if YYDEBUG

        if (yydebug)

            printf("%sdebug: state %d, shifting to state %d\n",

                    YYPREFIX, yystate, yytable[yyn]);

#endif

        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)

        {

            goto yyoverflow;

        }

        yystate = yytable[yyn];

        *++yystack.s_mark = yytable[yyn];

        *++yystack.l_mark = yylval;

        yychar = YYEMPTY;

        if (yyerrflag > 0)  --yyerrflag;

        goto yyloop;

    }

    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&

            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

    {

        yyn = yytable[yyn];

        goto yyreduce;

    }

    if (yyerrflag) goto yyinrecovery;

    YYERROR_CALL("syntax error");

    goto yyerrlab;

yyerrlab:

    ++yynerrs;

yyinrecovery:

    if (yyerrflag < 3)

    {

        yyerrflag = 3;

        for (;;)

        {

            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&

                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)

            {

#if YYDEBUG

                if (yydebug)

                    printf("%sdebug: state %d, error recovery shifting\

 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);

#endif

                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)

                {

                    goto yyoverflow;

                }

                yystate = yytable[yyn];

                *++yystack.s_mark = yytable[yyn];

                *++yystack.l_mark = yylval;

                goto yyloop;

            }

            else

            {

#if YYDEBUG

                if (yydebug)

                    printf("%sdebug: error recovery discarding state %d\n",

                            YYPREFIX, *yystack.s_mark);

#endif

                if (yystack.s_mark <= yystack.s_base) goto yyabort;

                --yystack.s_mark;

                --yystack.l_mark;

            }

        }

    }

    else

    {

        if (yychar == YYEOF) goto yyabort;

#if YYDEBUG

        if (yydebug)

        {

            yys = yyname[YYTRANSLATE(yychar)];

            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",

                    YYPREFIX, yystate, yychar, yys);

        }

#endif

        yychar = YYEMPTY;

        goto yyloop;

    }

yyreduce:

#if YYDEBUG

    if (yydebug)

        printf("%sdebug: state %d, reducing by rule %d (%s)\n",

                YYPREFIX, yystate, yyn, yyrule[yyn]);

#endif

    yym = yylen[yyn];

    if (yym)

        yyval = yystack.l_mark[1-yym];

    else

        memset(&yyval, 0, sizeof yyval);

    switch (yyn)

    {

case 11:

  {

    libphdi_xml_parser_rule_print(

     "xml_tag_open_start" );

    if( yystack.l_mark[0].string_value.data == NULL )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

       "%s: invalid tag name.",

       libphdi_xml_parser_function );

      YYABORT;

    }

    ( (libphdi_xml_parser_state_t *) parser_state )->current_tag = NULL;

    if( libphdi_xml_tag_initialize(

         &( ( (libphdi_xml_parser_state_t *) parser_state )->current_tag ),

         (uint8_t *) yystack.l_mark[0].string_value.data,

         yystack.l_mark[0].string_value.length,

         ( (libphdi_xml_parser_state_t *) parser_state )->error ) != 1 )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

       "%s: unable to create XML tag.",

       libphdi_xml_parser_function );

      YYABORT;

    }

    if( ( (libphdi_xml_parser_state_t *) parser_state )->root_tag == NULL )

    {

      ( (libphdi_xml_parser_state_t *) parser_state )->root_tag = ( (libphdi_xml_parser_state_t *) parser_state )->current_tag;

    }

    else

    {

      if( libphdi_xml_tag_append_element(

           ( (libphdi_xml_parser_state_t *) parser_state )->parent_tag,

           ( (libphdi_xml_parser_state_t *) parser_state )->current_tag,

           ( (libphdi_xml_parser_state_t *) parser_state )->error ) != 1 )

      {

        libcerror_error_set(

         ( (libphdi_xml_parser_state_t *) parser_state )->error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,

         "%s: unable to append attribute.",

         libphdi_xml_parser_function );

        YYABORT;

      }

    }

    ( (libphdi_xml_parser_state_t *) parser_state )->parent_tag = ( (libphdi_xml_parser_state_t *) parser_state )->current_tag;

  }

break;

case 13:

  {

    libphdi_xml_parser_rule_print(

     "xml_tag_single" );

    if( ( (libphdi_xml_parser_state_t *) parser_state )->current_tag == NULL )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

       "%s: invalid current tag.",

       libphdi_xml_parser_function );

      YYABORT;

    }

    ( (libphdi_xml_parser_state_t *) parser_state )->parent_tag  = ( (libphdi_xml_parser_state_t *) parser_state )->current_tag->parent_tag;

    ( (libphdi_xml_parser_state_t *) parser_state )->current_tag = ( (libphdi_xml_parser_state_t *) parser_state )->parent_tag;

  }

break;

case 14:

  {

    libphdi_xml_parser_rule_print(

     "xml_tag_close" );

    if( yystack.l_mark[0].string_value.data == NULL )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

       "%s: invalid tag name.",

       libphdi_xml_parser_function );

      YYABORT;

    }

    if( ( (libphdi_xml_parser_state_t *) parser_state )->current_tag == NULL )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

       "%s: invalid current tag.",

       libphdi_xml_parser_function );

      YYABORT;

    }

    if( ( ( (libphdi_xml_parser_state_t *) parser_state )->current_tag->name_size != ( yystack.l_mark[0].string_value.length + 1 ) )

     || ( narrow_string_compare(

           ( (libphdi_xml_parser_state_t *) parser_state )->current_tag->name,

           yystack.l_mark[0].string_value.data,

           yystack.l_mark[0].string_value.length ) != 0 ) )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

       "%s: mismatch in tag name (%s != %s).",

       libphdi_xml_parser_function,

       ( (libphdi_xml_parser_state_t *) parser_state )->current_tag->name,

       yystack.l_mark[0].string_value.data );

      YYABORT;

    }

    ( (libphdi_xml_parser_state_t *) parser_state )->parent_tag  = ( (libphdi_xml_parser_state_t *) parser_state )->current_tag->parent_tag;

    ( (libphdi_xml_parser_state_t *) parser_state )->current_tag = ( (libphdi_xml_parser_state_t *) parser_state )->parent_tag;

  }

break;

case 15:

  {

    libphdi_xml_parser_rule_print(

     "xml_tag_content" );

    if( yystack.l_mark[0].string_value.data == NULL )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

       "%s: invalid attribute value.",

       libphdi_xml_parser_function );

      YYABORT;

    }

    if( libphdi_xml_tag_set_value(

         ( (libphdi_xml_parser_state_t *) parser_state )->current_tag,

         (uint8_t *) yystack.l_mark[0].string_value.data,

         yystack.l_mark[0].string_value.length,

         ( (libphdi_xml_parser_state_t *) parser_state )->error ) != 1 )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_SET_FAILED,

       "%s: unable to set value.",

       libphdi_xml_parser_function );

      YYABORT;

    }

  }

break;

case 18:

  {

    libphdi_xml_parser_rule_print(

     "xml_attribute" );

    if( yystack.l_mark[-2].string_value.data == NULL )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

       "%s: invalid attribute name.",

       libphdi_xml_parser_function );

      YYABORT;

    }

    if( yystack.l_mark[0].string_value.data == NULL )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

       "%s: invalid attribute value.",

       libphdi_xml_parser_function );

      YYABORT;

    }

    if( libphdi_xml_tag_append_attribute(

         ( (libphdi_xml_parser_state_t *) parser_state )->current_tag,

         (uint8_t *) yystack.l_mark[-2].string_value.data,

         yystack.l_mark[-2].string_value.length,

         (uint8_t *) yystack.l_mark[0].string_value.data,

         yystack.l_mark[0].string_value.length,

         ( (libphdi_xml_parser_state_t *) parser_state )->error ) != 1 )

    {

      libcerror_error_set(

       ( (libphdi_xml_parser_state_t *) parser_state )->error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,

       "%s: unable to append attribute.",

       libphdi_xml_parser_function );

      YYABORT;

    }

  }

break;

    }

    yystack.s_mark -= yym;

    yystate = *yystack.s_mark;

    yystack.l_mark -= yym;

    yym = yylhs[yyn];

    if (yystate == 0 && yym == 0)

    {

#if YYDEBUG

        if (yydebug)

            printf("%sdebug: after reduction, shifting from state 0 to\

 state %d\n", YYPREFIX, YYFINAL);

#endif

        yystate = YYFINAL;

        *++yystack.s_mark = YYFINAL;

        *++yystack.l_mark = yyval;

        if (yychar < 0)

        {

            if ((yychar = YYLEX) < 0) yychar = YYEOF;

#if YYDEBUG

            if (yydebug)

            {

                yys = yyname[YYTRANSLATE(yychar)];

                printf("%sdebug: state %d, reading %d (%s)\n",

                        YYPREFIX, YYFINAL, yychar, yys);

            }

#endif

        }

        if (yychar == YYEOF) goto yyaccept;

        goto yyloop;

    }

    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&

            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)

        yystate = yytable[yyn];

    else

        yystate = yydgoto[yym];

#if YYDEBUG

    if (yydebug)

        printf("%sdebug: after reduction, shifting from state %d \

to state %d\n", YYPREFIX, *yystack.s_mark, yystate);

#endif

    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)

    {

        goto yyoverflow;

    }

    *++yystack.s_mark = (YYINT) yystate;

    *++yystack.l_mark = yyval;

    goto yyloop;

yyoverflow:

    YYERROR_CALL("yacc stack overflow");

yyabort:

    yyfreestack(&yystack);

    return (1);

yyaccept:

    yyfreestack(&yystack);

    return (0);

}