/src/libodraw/libodraw/libodraw_cue_parser.c

Source (jump to first uncovered line)
/* 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    libodraw_cue_scanner_parse
#endif /* yyparse */

#ifndef yylex
#define yylex      libodraw_cue_scanner_lex
#endif /* yylex */

#ifndef yyerror
#define yyerror    libodraw_cue_scanner_error
#endif /* yyerror */

#ifndef yychar
#define yychar     libodraw_cue_scanner_char
#endif /* yychar */

#ifndef yyval
#define yyval      libodraw_cue_scanner_val
#endif /* yyval */

#ifndef yylval
#define yylval     libodraw_cue_scanner_lval
#endif /* yylval */

#ifndef yydebug
#define yydebug    libodraw_cue_scanner_debug
#endif /* yydebug */

#ifndef yynerrs
#define yynerrs    libodraw_cue_scanner_nerrs
#endif /* yynerrs */

#ifndef yyerrflag
#define yyerrflag  libodraw_cue_scanner_errflag
#endif /* yyerrflag */

#ifndef yylhs
#define yylhs      libodraw_cue_scanner_lhs
#endif /* yylhs */

#ifndef yylen
#define yylen      libodraw_cue_scanner_len
#endif /* yylen */

#ifndef yydefred
#define yydefred   libodraw_cue_scanner_defred
#endif /* yydefred */

#ifndef yydgoto
#define yydgoto    libodraw_cue_scanner_dgoto
#endif /* yydgoto */

#ifndef yysindex
#define yysindex   libodraw_cue_scanner_sindex
#endif /* yysindex */

#ifndef yyrindex
#define yyrindex   libodraw_cue_scanner_rindex
#endif /* yyrindex */

#ifndef yygindex
#define yygindex   libodraw_cue_scanner_gindex
#endif /* yygindex */

#ifndef yytable
#define yytable    libodraw_cue_scanner_table
#endif /* yytable */

#ifndef yycheck
#define yycheck    libodraw_cue_scanner_check
#endif /* yycheck */

#ifndef yyname
#define yyname     libodraw_cue_scanner_name
#endif /* yyname */

#ifndef yyrule
#define yyrule     libodraw_cue_scanner_rule
#endif /* yyrule */
#define YYPREFIX "libodraw_cue_scanner_"

#define YYPURE 0

/*
 * CUE parser functions
 *
 * Copyright (C) 2010-2024, 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 <narrow_string.h>
#include <types.h>

#if defined( HAVE_STDLIB_H ) || defined( WINAPI )
#include <stdlib.h>
#endif

#include "libodraw_definitions.h"
#include "libodraw_handle.h"
#include "libodraw_libcerror.h"
#include "libodraw_libcnotify.h"
#include "libodraw_types.h"

#define YYMALLOC  libodraw_cue_scanner_alloc
#define YYREALLOC libodraw_cue_scanner_realloc
#define YYFREE    libodraw_cue_scanner_free

#define YYLEX_PARAM NULL
#define YYPARSE_PARAM parser_state

#if defined( HAVE_DEBUG_OUTPUT )
#define libodraw_cue_parser_rule_print( string ) \
  if( libcnotify_verbose != 0 ) libcnotify_printf( "libodraw_cue_parser: rule: %s\n", string )
#else
#define libodraw_cue_parser_rule_print( string )
#endif

#if !defined( CD_SECS )
/* seconds per minute */
#define CD_SECS     60
#endif

#if !defined( CD_FRAMES )
/* frames per second */
#define CD_FRAMES   75
#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 cue_string_value
  {
    /* The string data
     */
          const char *data;

    /* The string length
     */
    size_t length;

  } string_value;
} YYSTYPE;
#endif /* !YYSTYPE_IS_DECLARED */

typedef struct libodraw_cue_parser_state libodraw_cue_parser_state_t;

struct libodraw_cue_parser_state
{
  /* The file
   */
  libodraw_handle_t *handle;

  /* The error
   */
  libcerror_error_t **error;

  /* The previous file index
   */
  int previous_file_index;

  /* The current file index
   */
  int current_file_index;

  /* The file type
   */
  uint8_t file_type;

  /* Value to indicate a new file command was issued
   */
  uint8_t new_file;

  /* The previous file sector
   */
  uint64_t previous_file_sector;

  /* The file sector
   */
  uint64_t file_sector;

  /* The previous session start sector
   */
  uint64_t previous_session_start_sector;

  /* The previous lead-out start sector
   */
  uint64_t previous_lead_out_start_sector;

  /* The previous track start sector
   */
  uint64_t previous_track_start_sector;

  /* The current start sector
   */
  uint64_t current_start_sector;

  /* The session number of sectors
   */
  uint64_t session_number_of_sectors;

  /* The lead-out number of sectors
   */
  uint64_t lead_out_number_of_sectors;

  /* The track number of sectors
   */
  uint64_t track_number_of_sectors;

  /* The previous track type
   */
  uint8_t previous_track_type;

  /* The current track type
   */
  uint8_t current_track_type;

  /* The previous session
   */
  int previous_session;

  /* The current session
   */
  int current_session;

  /* The previous lead-out
   */
  int previous_lead_out;

  /* The current lead-out
   */
  int current_lead_out;

  /* The previous track
   */
  int previous_track;

  /* The current track
   */
  int current_track;

  /* The previous index
   */
  int previous_index;

  /* The current index
   */
  int current_index;
};

typedef size_t yy_size_t;
typedef struct yy_buffer_state* YY_BUFFER_STATE;

extern \
int libodraw_cue_scanner_suppress_error;

extern \
int libodraw_cue_scanner_lex_destroy(
     void );

extern \
void *libodraw_cue_scanner_alloc(
       yy_size_t size );

extern \
void *libodraw_cue_scanner_realloc(
       void *buffer,
       yy_size_t size );

extern \
void libodraw_cue_scanner_free(
      void *buffer );

extern \
int libodraw_cue_scanner_lex(
     void *user_data );

extern \
void libodraw_cue_scanner_error(
      void *parser_state,
      const char *error_string );

extern \
YY_BUFFER_STATE libodraw_cue_scanner__scan_buffer(
                 char *buffer,
                 yy_size_t buffer_size );

extern \
void libodraw_cue_scanner__delete_buffer(
      YY_BUFFER_STATE buffer_state );

extern \
size_t libodraw_cue_scanner_buffer_offset;

static char *libodraw_cue_parser_function = "libodraw_cue_parser";

int libodraw_cue_parser_parse_number(
     const char *token,
     size_t token_size,
     int *number,
     libcerror_error_t **error );

int libodraw_cue_parser_parse_msf(
     const char *token,
     size_t token_size,
     uint64_t *lba,
     libcerror_error_t **error );

int libodraw_cue_parser_parse_track_type(
     const char *token,
     size_t token_size,
     uint8_t *track_type,
     libcerror_error_t **error );

int libodraw_cue_parser_parse_buffer(
     libodraw_handle_t *handle,
     const 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 CUE_END_OF_LINE 257
#define CUE_SEMI_COLON 258
#define CUE_2DIGIT 259
#define CUE_CATALOG_NUMBER 260
#define CUE_ISRC_CODE 261
#define CUE_KEYWORD_STRING 262
#define CUE_MSF 263
#define CUE_STRING 264
#define CUE_CATALOG 265
#define CUE_CD_DA 266
#define CUE_CD_ROM 267
#define CUE_CD_ROM_XA 268
#define CUE_CD_TEXT 269
#define CUE_CDTEXTFILE 270
#define CUE_COPY 271
#define CUE_DATAFILE 272
#define CUE_FLAGS 273
#define CUE_FOUR_CHANNEL_AUDIO 274
#define CUE_FILE 275
#define CUE_INDEX 276
#define CUE_ISRC 277
#define CUE_NO_COPY 278
#define CUE_NO_PRE_EMPHASIS 279
#define CUE_POSTGAP 280
#define CUE_PRE_EMPHASIS 281
#define CUE_PREGAP 282
#define CUE_REMARK 283
#define CUE_TRACK 284
#define CUE_TWO_CHANNEL_AUDIO 285
#define CUE_CDTEXT_ARRANGER 286
#define CUE_CDTEXT_COMPOSER 287
#define CUE_CDTEXT_DISC_ID 288
#define CUE_CDTEXT_GENRE 289
#define CUE_CDTEXT_MESSAGE 290
#define CUE_CDTEXT_PERFORMER 291
#define CUE_CDTEXT_SIZE_INFO 292
#define CUE_CDTEXT_SONGWRITER 293
#define CUE_CDTEXT_TITLE 294
#define CUE_CDTEXT_TOC_INFO1 295
#define CUE_CDTEXT_TOC_INFO2 296
#define CUE_CDTEXT_UPC_EAN 297
#define CUE_REMARK_LEAD_OUT 298
#define CUE_REMARK_ORIGINAL_MEDIA_TYPE 299
#define CUE_REMARK_RUN_OUT 300
#define CUE_REMARK_SESSION 301
#define CUE_UNDEFINED 302
#define YYERRCODE 256
typedef short YYINT;
static const YYINT libodraw_cue_scanner_lhs[] = {        -1,
    0,    0,    1,    1,    2,    2,    2,    2,    3,    3,
   10,   10,   10,   10,    4,    4,   15,   16,   16,   21,
   21,   21,   18,   18,   22,   22,   22,   22,   22,   22,
   19,   19,   26,   26,   26,   20,   20,   28,   28,   28,
   28,   28,   28,   28,   28,   28,   28,   28,    6,   12,
   37,   37,   37,   37,   37,   37,   37,   37,   37,   37,
   37,   37,    7,    8,    9,   11,    5,   23,   38,   38,
   27,   29,   30,   31,   24,   32,   33,   34,   35,   25,
   36,   13,   13,   13,   13,   13,   39,   40,   41,   44,
   42,   43,   17,   17,   14,
};
static const YYINT libodraw_cue_scanner_len[] = {         2,
    4,    5,    0,    1,    0,    1,    1,    1,    0,    2,
    1,    1,    1,    1,    0,    2,    5,    0,    2,    1,
    1,    1,    0,    2,    1,    1,    1,    1,    1,    1,
    0,    2,    1,    1,    1,    0,    2,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    3,    3,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    2,    2,    2,    3,    4,    3,    0,    2,
    4,    2,    4,    2,    3,    2,    2,    3,    2,    3,
    2,    1,    1,    1,    1,    1,    3,    3,    3,    1,
    3,    3,    3,    4,    1,
};
static const YYINT libodraw_cue_scanner_defred[] = {      0,
    0,    0,    0,    4,    0,   95,    0,    0,    0,    0,
    0,   51,   52,   53,   54,   55,   56,   57,   58,   59,
   60,   61,   62,    0,    0,    0,    0,    0,    0,    6,
    7,    8,    0,   11,   12,   13,   14,    0,   82,   83,
   84,   85,   86,    0,   49,   63,   64,   65,    0,    0,
    0,    0,    0,    0,    0,    0,   10,    0,    0,   66,
   87,   88,   91,   92,    1,   20,   21,   22,    0,    0,
    0,    0,    0,   50,   89,   16,    0,    0,   19,    0,
    2,    0,    0,    0,    0,    0,   25,   29,   30,    0,
    0,   26,   27,   28,   67,    0,   93,    0,    0,    0,
    0,    0,   34,   35,    0,    0,   33,   24,   94,   70,
   68,   75,   80,    0,    0,    0,    0,    0,    0,    0,
    0,    0,   38,   47,   48,   17,    0,   39,   40,   41,
   42,   43,   44,   45,   46,   32,    0,   72,    0,   74,
   76,   77,    0,   79,   81,   37,   71,    0,   78,   73,
};
static const YYINT libodraw_cue_scanner_dgoto[] = {       2,
    3,   28,   29,   65,   66,    4,   30,   31,   32,   33,
   34,   35,   36,   37,   69,   70,   78,   90,  105,  126,
   71,   91,   92,   93,   94,  106,  107,  127,  128,  129,
  130,  131,  132,  133,  134,  135,   38,   99,   39,   40,
   41,   42,   43,   44,
};
static const YYINT libodraw_cue_scanner_sindex[] = {   -258,
 -251,    0, -152,    0, -247,    0, -245, -244, -241, -243,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0, -246, -239, -238, -240,  -62, -234,    0,
    0,    0,  -62,    0,    0,    0,    0, -229,    0,    0,
    0,    0,    0, -220,    0,    0,    0,    0, -214, -212,
 -211, -210, -209, -231, -227,  -62,    0, -208, -204,    0,
    0,    0,    0,    0,    0,    0,    0,    0, -231, -228,
 -231, -201, -231,    0,    0,    0, -254, -107,    0, -199,
    0, -200, -194, -191, -189, -190,    0,    0,    0,  -35,
 -107,    0,    0,    0,    0, -179,    0, -191, -178, -177,
 -172, -153,    0,    0, -197,  -35,    0,    0,    0,    0,
    0,    0,    0, -156, -149, -155, -147, -146, -145, -150,
 -140, -138,    0,    0,    0,    0, -197,    0,    0,    0,
    0,    0,    0,    0,    0,    0, -137,    0, -142,    0,
    0,    0, -135,    0,    0,    0,    0, -134,    0,    0,
};
static const YYINT libodraw_cue_scanner_rindex[] = {      1,
    0,    0,    2,    0,    0,    0,    0,    0,    0,    0,
 -132,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   30,    0,    0,
    0,    0,   30,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   24,    0,   30,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   24,    0,
 -159,    0,   24,    0,    0,    0,    0,   59,    0,    0,
    0,    0,    0, -131,    0,    0,    0,    0,    0,   32,
   59,    0,    0,    0,    0,    0,    0, -131,    0,    0,
    0,    0,    0,    0,   57,   32,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,   57,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
};
static const YYINT libodraw_cue_scanner_gindex[] = {      0,
    0,    0,  -22,  -69,   98,    0,    0,    0,    0,    0,
    0,  -63,  -51,  -40,    0,   58,    0,   37,   26,    3,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   35,    0,    0,
    0,    0,    0,    0,
};
#define YYTABLESIZE 344
static const YYINT libodraw_cue_scanner_table[] = {      76,
    3,    5,   67,   81,   82,   54,    1,   83,    5,   45,
   57,   46,   47,   68,   87,   48,   50,   67,   53,   67,
   49,   67,   51,   15,   52,    6,   88,   87,   68,    9,
   68,   31,   68,   73,   58,   59,   72,   89,  103,   88,
   55,  123,   60,   55,   61,   62,   63,   64,   74,  104,
   89,   11,   75,  124,  103,   77,   36,   95,   23,    6,
   80,   96,   97,  123,  125,  104,   24,   25,   26,   27,
   98,  100,  101,  115,  116,  124,  117,  109,  111,  112,
  118,  119,  120,  121,  113,   11,  125,  122,   12,   13,
   14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
   24,   25,   26,   27,    6,  114,  137,  138,  139,  140,
  141,  142,  143,    7,    8,    9,  144,   10,  145,  147,
  148,  149,  150,   90,   18,   69,   56,  108,   79,  146,
   11,  136,  110,   12,   13,   14,   15,   16,   17,   18,
   19,   20,   21,   22,   23,   24,   25,   26,   27,    6,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,   84,    0,    0,    0,   85,
    0,    0,    0,    0,   86,   11,    0,    0,   12,   13,
   14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
   24,   25,   26,   27,    6,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   10,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   11,    6,    0,   12,   13,   14,   15,   16,   17,   18,
   19,   20,   21,   22,   23,   24,   25,   26,   27,    0,
  102,    0,    0,    0,    0,    0,    0,   11,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    3,    0,    0,
    0,    0,   24,   25,   26,   27,    3,    3,    3,    0,
    3,    0,    0,    0,    0,    3,    5,    0,    0,    0,
    0,    0,    0,    3,    3,    5,    3,    3,    3,    3,
    3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
    3,    3,   31,   31,    9,   31,   31,   18,    0,   31,
   31,   31,   31,    9,    0,   31,   31,   31,   31,   31,
   31,   31,   31,   31,   31,   31,   31,   31,   31,   23,
   23,   36,   23,   23,   23,    0,   23,   23,   23,   23,
   36,    0,   23,   23,
};
static const YYINT libodraw_cue_scanner_check[] = {      69,
    0,    0,   54,   73,  259,   28,  265,  262,  260,  257,
   33,  257,  257,   54,   78,  257,  263,   69,  259,   71,
  264,   73,  262,    0,  263,  257,   78,   91,   69,    0,
   71,    0,   73,   56,  264,  256,  264,   78,   90,   91,
  275,  105,  257,  275,  257,  257,  257,  257,  257,   90,
   91,  283,  257,  105,  106,  284,    0,  257,    0,  257,
  262,  262,  257,  127,  105,  106,  298,  299,  300,  301,
  262,  261,  263,  271,  272,  127,  274,  257,  257,  257,
  278,  279,  280,  281,  257,  283,  127,  285,  286,  287,
  288,  289,  290,  291,  292,  293,  294,  295,  296,  297,
  298,  299,  300,  301,  257,  259,  263,  257,  264,  257,
  257,  257,  263,  266,  267,  268,  257,  270,  257,  257,
  263,  257,  257,  256,  284,  257,   29,   91,   71,  127,
  283,  106,   98,  286,  287,  288,  289,  290,  291,  292,
  293,  294,  295,  296,  297,  298,  299,  300,  301,  257,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,  273,   -1,   -1,   -1,  277,
   -1,   -1,   -1,   -1,  282,  283,   -1,   -1,  286,  287,
  288,  289,  290,  291,  292,  293,  294,  295,  296,  297,
  298,  299,  300,  301,  257,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  270,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  283,  257,   -1,  286,  287,  288,  289,  290,  291,  292,
  293,  294,  295,  296,  297,  298,  299,  300,  301,   -1,
  276,   -1,   -1,   -1,   -1,   -1,   -1,  283,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,   -1,
   -1,   -1,  298,  299,  300,  301,  266,  267,  268,   -1,
  270,   -1,   -1,   -1,   -1,  275,  275,   -1,   -1,   -1,
   -1,   -1,   -1,  283,  284,  284,  286,  287,  288,  289,
  290,  291,  292,  293,  294,  295,  296,  297,  298,  299,
  300,  301,  271,  272,  275,  274,  275,  284,   -1,  278,
  279,  280,  281,  284,   -1,  284,  285,  286,  287,  288,
  289,  290,  291,  292,  293,  294,  295,  296,  297,  271,
  272,  275,  274,  275,  276,   -1,  278,  279,  280,  281,
  284,   -1,  284,  285,
};
#define YYFINAL 2
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 302
#define YYUNDFTOKEN 349
#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
#if YYDEBUG
static const char *const libodraw_cue_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,"CUE_END_OF_LINE",
"CUE_SEMI_COLON","CUE_2DIGIT","CUE_CATALOG_NUMBER","CUE_ISRC_CODE",
"CUE_KEYWORD_STRING","CUE_MSF","CUE_STRING","CUE_CATALOG","CUE_CD_DA",
"CUE_CD_ROM","CUE_CD_ROM_XA","CUE_CD_TEXT","CUE_CDTEXTFILE","CUE_COPY",
"CUE_DATAFILE","CUE_FLAGS","CUE_FOUR_CHANNEL_AUDIO","CUE_FILE","CUE_INDEX",
"CUE_ISRC","CUE_NO_COPY","CUE_NO_PRE_EMPHASIS","CUE_POSTGAP","CUE_PRE_EMPHASIS",
"CUE_PREGAP","CUE_REMARK","CUE_TRACK","CUE_TWO_CHANNEL_AUDIO",
"CUE_CDTEXT_ARRANGER","CUE_CDTEXT_COMPOSER","CUE_CDTEXT_DISC_ID",
"CUE_CDTEXT_GENRE","CUE_CDTEXT_MESSAGE","CUE_CDTEXT_PERFORMER",
"CUE_CDTEXT_SIZE_INFO","CUE_CDTEXT_SONGWRITER","CUE_CDTEXT_TITLE",
"CUE_CDTEXT_TOC_INFO1","CUE_CDTEXT_TOC_INFO2","CUE_CDTEXT_UPC_EAN",
"CUE_REMARK_LEAD_OUT","CUE_REMARK_ORIGINAL_MEDIA_TYPE","CUE_REMARK_RUN_OUT",
"CUE_REMARK_SESSION","CUE_UNDEFINED",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,"illegal-symbol",
};
static const char *const libodraw_cue_scanner_rule[] = {
"$accept : cue_main",
"cue_main : cue_header_item cue_session_type cue_main_items cue_main_tracks",
"cue_main : cue_header_item cue_main_items cue_file cue_main_items cue_main_tracks",
"cue_header_item :",
"cue_header_item : cue_catalog",
"cue_session_type :",
"cue_session_type : cue_cd_da",
"cue_session_type : cue_cd_rom",
"cue_session_type : cue_cd_rom_xa",
"cue_main_items :",
"cue_main_items : cue_main_item cue_main_items",
"cue_main_item : cue_cdtextfile",
"cue_main_item : cue_cdtext",
"cue_main_item : cue_remark_item",
"cue_main_item : cue_empty_line",
"cue_main_tracks :",
"cue_main_tracks : cue_main_track cue_main_tracks",
"cue_main_track : cue_main_track_preceding_items cue_track cue_main_track_leading_items cue_main_track_index_items cue_main_track_trailing_items",
"cue_main_track_preceding_items :",
"cue_main_track_preceding_items : cue_main_track_preceding_item cue_main_track_preceding_items",
"cue_main_track_preceding_item : cue_file",
"cue_main_track_preceding_item : cue_remark_item",
"cue_main_track_preceding_item : cue_empty_line",
"cue_main_track_leading_items :",
"cue_main_track_leading_items : cue_main_track_leading_item cue_main_track_leading_items",
"cue_main_track_leading_item : cue_cdtext",
"cue_main_track_leading_item : cue_flags",
"cue_main_track_leading_item : cue_isrc",
"cue_main_track_leading_item : cue_pregap",
"cue_main_track_leading_item : cue_remark_item",
"cue_main_track_leading_item : cue_empty_line",
"cue_main_track_index_items :",
"cue_main_track_index_items : cue_main_track_index_item cue_main_track_index_items",
"cue_main_track_index_item : cue_index",
"cue_main_track_index_item : cue_remark_item",
"cue_main_track_index_item : cue_empty_line",
"cue_main_track_trailing_items :",
"cue_main_track_trailing_items : cue_main_track_trailing_item cue_main_track_trailing_items",
"cue_main_track_trailing_item : cue_cdtext",
"cue_main_track_trailing_item : cue_copy",
"cue_main_track_trailing_item : cue_datafile",
"cue_main_track_trailing_item : cue_four_channel_audio",
"cue_main_track_trailing_item : cue_no_copy",
"cue_main_track_trailing_item : cue_no_pre_emphasis",
"cue_main_track_trailing_item : cue_postgap",
"cue_main_track_trailing_item : cue_pre_emphasis",
"cue_main_track_trailing_item : cue_two_channel_audio",
"cue_main_track_trailing_item : cue_remark_item",
"cue_main_track_trailing_item : cue_empty_line",
"cue_catalog : CUE_CATALOG CUE_CATALOG_NUMBER CUE_END_OF_LINE",
"cue_cdtext : cue_cdtext_type CUE_STRING CUE_END_OF_LINE",
"cue_cdtext_type : CUE_CDTEXT_ARRANGER",
"cue_cdtext_type : CUE_CDTEXT_COMPOSER",
"cue_cdtext_type : CUE_CDTEXT_DISC_ID",
"cue_cdtext_type : CUE_CDTEXT_GENRE",
"cue_cdtext_type : CUE_CDTEXT_MESSAGE",
"cue_cdtext_type : CUE_CDTEXT_PERFORMER",
"cue_cdtext_type : CUE_CDTEXT_SIZE_INFO",
"cue_cdtext_type : CUE_CDTEXT_SONGWRITER",
"cue_cdtext_type : CUE_CDTEXT_TITLE",
"cue_cdtext_type : CUE_CDTEXT_TOC_INFO1",
"cue_cdtext_type : CUE_CDTEXT_TOC_INFO2",
"cue_cdtext_type : CUE_CDTEXT_UPC_EAN",
"cue_cd_da : CUE_CD_DA CUE_END_OF_LINE",
"cue_cd_rom : CUE_CD_ROM CUE_END_OF_LINE",
"cue_cd_rom_xa : CUE_CD_ROM_XA CUE_END_OF_LINE",
"cue_cdtextfile : CUE_CDTEXTFILE CUE_STRING CUE_END_OF_LINE",
"cue_file : CUE_FILE CUE_STRING CUE_KEYWORD_STRING CUE_END_OF_LINE",
"cue_flags : CUE_FLAGS cue_flags_types CUE_END_OF_LINE",
"cue_flags_types :",
"cue_flags_types : CUE_KEYWORD_STRING cue_flags_types",
"cue_index : CUE_INDEX CUE_2DIGIT CUE_MSF CUE_END_OF_LINE",
"cue_copy : CUE_COPY CUE_END_OF_LINE",
"cue_datafile : CUE_DATAFILE CUE_STRING CUE_MSF CUE_END_OF_LINE",
"cue_four_channel_audio : CUE_FOUR_CHANNEL_AUDIO CUE_END_OF_LINE",
"cue_isrc : CUE_ISRC CUE_ISRC_CODE CUE_END_OF_LINE",
"cue_no_copy : CUE_NO_COPY CUE_END_OF_LINE",
"cue_no_pre_emphasis : CUE_NO_PRE_EMPHASIS CUE_END_OF_LINE",
"cue_postgap : CUE_POSTGAP CUE_MSF CUE_END_OF_LINE",
"cue_pre_emphasis : CUE_PRE_EMPHASIS CUE_END_OF_LINE",
"cue_pregap : CUE_PREGAP CUE_MSF CUE_END_OF_LINE",
"cue_two_channel_audio : CUE_TWO_CHANNEL_AUDIO CUE_END_OF_LINE",
"cue_remark_item : cue_lead_out",
"cue_remark_item : cue_original_media_type",
"cue_remark_item : cue_remark",
"cue_remark_item : cue_run_out",
"cue_remark_item : cue_session",
"cue_lead_out : CUE_REMARK_LEAD_OUT CUE_MSF CUE_END_OF_LINE",
"cue_original_media_type : CUE_REMARK_ORIGINAL_MEDIA_TYPE CUE_KEYWORD_STRING CUE_END_OF_LINE",
"cue_remark : cue_remark_start error CUE_END_OF_LINE",
"cue_remark_start : CUE_REMARK",
"cue_run_out : CUE_REMARK_RUN_OUT CUE_MSF CUE_END_OF_LINE",
"cue_session : CUE_REMARK_SESSION CUE_2DIGIT CUE_END_OF_LINE",
"cue_track : CUE_TRACK CUE_KEYWORD_STRING CUE_END_OF_LINE",
"cue_track : CUE_TRACK CUE_2DIGIT CUE_KEYWORD_STRING CUE_END_OF_LINE",
"cue_empty_line : CUE_END_OF_LINE",

};
#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;

/* Parses a number
 * Returns 1 if successful or -1 on error
 */
int libodraw_cue_parser_parse_number(
     const char *token,
     size_t token_size,
     int *number,
     libcerror_error_t **error )
{
  static char *function = "libodraw_cue_parser_parse_number";
  int safe_number       = 0;

  if( token == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid token.",
     function );

    return( -1 );
  }
  if( ( token_size < 1 )
   || ( token_size > 2 ) )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
     "%s: invalid token size value out of bounds.",
     function );

    return( -1 );
  }
  if( number == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid number.",
     function );

    return( -1 );
  }
  if( ( token[ 0 ] < '0' )
   || ( token[ 0 ] > '9' ) )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
     "%s: unsupported first digit of number token.",
     function );

    return( -1 );
  }
  safe_number = token[ 0 ] - '0';

  if( token_size == 2 )
  {
    safe_number *= 10;

    if( ( token[ 1 ] < '0' )
     || ( token[ 1 ] > '9' ) )
    {
      libcerror_error_set(
       error,
       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
       LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
       "%s: unsupported second digit of number token.",
       function );

      return( -1 );
    }
    safe_number += token[ 1 ] - '0';
  }
  *number = safe_number;

  return( 1 );
}

/* Parses a MFS (minutes:seconds:frames) value and converts it into a logical block address (LBA)
 * Returns 1 if successful or -1 on error
 */
int libodraw_cue_parser_parse_msf(
     const char *token,
     size_t token_size,
     uint64_t *lba,
     libcerror_error_t **error )
{
  static char *function = "libodraw_cue_parser_parse_msf";
  uint64_t safe_lba     = 0;

  if( token == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid token.",
     function );

    return( -1 );
  }
  if( token_size != 8 )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
     "%s: invalid token size value out of bounds.",
     function );

    return( -1 );
  }
  if( lba == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid LBA.",
     function );

    return( -1 );
  }
  if( ( token[ 0 ] < '0' )
   || ( token[ 0 ] > '9' )
   || ( token[ 1 ] < '0' )
   || ( token[ 1 ] > '9' )
   || ( token[ 2 ] != ':' )
   || ( token[ 3 ] < '0' )
   || ( token[ 3 ] > '9' )
   || ( token[ 4 ] < '0' )
   || ( token[ 4 ] > '9' )
   || ( token[ 5 ] != ':' )
   || ( token[ 6 ] < '0' )
   || ( token[ 6 ] > '9' )
   || ( token[ 7 ] < '0' )
   || ( token[ 7 ] > '9' ) )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
     "%s: unsupported MSF token.",
     function );

    return( -1 );
  }
  /* Note that the MSF are relative, so there is no need for the MSF offset correction
   */
        safe_lba  = ( ( token[ 0 ] - '0' ) * 10 ) + ( token[ 1 ] - '0' ); \
        safe_lba *= CD_SECS; \
        safe_lba += ( ( token[ 3 ] - '0' ) * 10 ) + ( token[ 4 ] - '0' ); \
        safe_lba *= CD_FRAMES; \
        safe_lba += ( ( token[ 6 ] - '0' ) * 10 ) + ( token[ 7 ] - '0' );

  *lba = safe_lba;

  return( 1 );
}

/* Parses a track type
 * Returns 1 if successful or -1 on error
 */
int libodraw_cue_parser_parse_track_type(
     const char *token,
     size_t token_size,
     uint8_t *track_type,
     libcerror_error_t **error )
{
  static char *function = "libodraw_cue_parser_parse_track_type";

  if( token == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid token.",
     function );

    return( -1 );
  }
  if( token_size < 1 )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
     "%s: invalid token size value out of bounds.",
     function );

    return( -1 );
  }
  if( track_type == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid track type.",
     function );

    return( -1 );
  }
  *track_type = LIBODRAW_TRACK_TYPE_UNKNOWN;

  if( token_size == 3 )
  {
    if( narrow_string_compare(
         token,
         "CDG",
         3 ) == 0 )
    {
      *track_type = LIBODRAW_TRACK_TYPE_CDG;
    }
  }
  else if( token_size == 5 )
  {
    if( narrow_string_compare(
         token,
         "AUDIO",
         5 ) == 0 )
    {
      *track_type = LIBODRAW_TRACK_TYPE_AUDIO;
    }
  }
  else if( token_size == 8 )
  {
    if( narrow_string_compare(
         token,
         "CDI",
         3 ) == 0 )
    {
      if( token[ 3 ] == '/' )
      {
        if( narrow_string_compare(
             &( token[ 4 ] ),
             "2336",
             4 ) == 0 )
        {
           *track_type = LIBODRAW_TRACK_TYPE_CDI_2336;
        }
        else if( narrow_string_compare(
            &( token[ 4 ] ),
            "2352",
            4 ) == 0 )
        {
           *track_type = LIBODRAW_TRACK_TYPE_CDI_2352;
        }
      }
    }
  }
  else if( token_size == 9 )
  {
    if( narrow_string_compare(
         token,
         "MODE1_RAW",
         9 ) == 0 )
    {
      *track_type = LIBODRAW_TRACK_TYPE_MODE1_2352;
    }
    else if( narrow_string_compare(
              token,
              "MODE2_RAW",
              9 ) == 0 )
    {
      *track_type = LIBODRAW_TRACK_TYPE_MODE2_2352;
    }
  }
  else if( token_size == 10 )
  {
    if( narrow_string_compare(
         token,
         "MODE",
         4 ) == 0 )
    {
      if( token[ 5 ] == '/' )
      {
        if( token[ 4 ] == '1' )
        {
          if( narrow_string_compare(
               &( token[ 6 ] ),
               "2048",
               4 ) == 0 )
          {
             *track_type = LIBODRAW_TRACK_TYPE_MODE1_2048;
          }
          else if( narrow_string_compare(
              &( token[ 6 ] ),
              "2352",
              4 ) == 0 )
          {
             *track_type = LIBODRAW_TRACK_TYPE_MODE1_2352;
          }
        }
        else if( token[ 4 ] == '2' )
        {
          if( narrow_string_compare(
               &( token[ 6 ] ),
               "2048",
               4 ) == 0 )
          {
             *track_type = LIBODRAW_TRACK_TYPE_MODE2_2048;
          }
          else if( narrow_string_compare(
              &( token[ 6 ] ),
              "2324",
              4 ) == 0 )
          {
             *track_type = LIBODRAW_TRACK_TYPE_MODE2_2324;
          }
          else if( narrow_string_compare(
              &( token[ 6 ] ),
              "2336",
              4 ) == 0 )
          {
             *track_type = LIBODRAW_TRACK_TYPE_MODE2_2336;
          }
          else if( narrow_string_compare(
              &( token[ 6 ] ),
              "2352",
              4 ) == 0 )
          {
             *track_type = LIBODRAW_TRACK_TYPE_MODE2_2352;
          }
        }
      }
    }
  }
  return( 1 );
}

/* Parses a CUE file
 * Returns 1 if successful or -1 on error
 */
int libodraw_cue_parser_parse_buffer(
     libodraw_handle_t *handle,
     const uint8_t *buffer,
     size_t buffer_size,
     libcerror_error_t **error )
{
  libodraw_cue_parser_state_t parser_state;
  
  static char *function        = "libodraw_cue_parser_parse_buffer";
  YY_BUFFER_STATE buffer_state = NULL;
  size_t buffer_offset         = 0;
  int result                   = -1;

  if( buffer == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid buffer.",
     function );

    return( -1 );
  }
  if( buffer_size >= 3 )
  {
    if( ( buffer[ 0 ] == 0x0ef )
     && ( buffer[ 1 ] == 0x0bb )
     && ( buffer[ 2 ] == 0x0bf ) )
    {
      buffer_offset = 3;
    }
  }
  buffer_state = libodraw_cue_scanner__scan_buffer(
                  (char *) &( buffer[ buffer_offset ] ),
                  buffer_size - buffer_offset );

  libodraw_cue_scanner_buffer_offset = (size_t) buffer_offset;

  if( buffer_state != NULL )
  {
    parser_state.handle                         = handle;
    parser_state.error                          = error;
    parser_state.previous_file_index            = -1;
    parser_state.current_file_index             = -1;
    parser_state.file_type                      = 0;
    parser_state.previous_file_sector           = 0;
    parser_state.file_sector                    = 0;
    parser_state.previous_session_start_sector  = 0;
    parser_state.previous_lead_out_start_sector = 0;
    parser_state.previous_track_start_sector    = 0;
    parser_state.current_start_sector           = 0;
    parser_state.session_number_of_sectors      = 0;
    parser_state.lead_out_number_of_sectors     = 0;
    parser_state.track_number_of_sectors        = 0;
    parser_state.previous_track_type            = 0;
    parser_state.current_track_type             = 0;
    parser_state.previous_session               = 0;
    parser_state.current_session                = 0;
    parser_state.previous_lead_out              = 0;
    parser_state.current_lead_out               = 0;
    parser_state.previous_track                 = 0;
    parser_state.current_track                  = 0;
    parser_state.previous_index                 = 0;
    parser_state.current_index                  = 0;

    if( libodraw_cue_scanner_parse(
         &parser_state ) == 0 )
    {
      result = 1;
    }
    libodraw_cue_scanner__delete_buffer(
     buffer_state );

    if( parser_state.current_session > 0 )
    {
      if( libodraw_handle_append_session(
           parser_state.handle,
           parser_state.previous_session_start_sector,
           0,
           parser_state.error ) != 1 )
      {
        libcerror_error_set(
         parser_state.error,
         LIBCERROR_ERROR_DOMAIN_RUNTIME,
         LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
         "%s: unable to append session.",
         function );

        result = -1;
      }
    }
    if( parser_state.current_lead_out > parser_state.previous_lead_out )
    {
      if( libodraw_handle_append_lead_out(
           parser_state.handle,
           parser_state.previous_lead_out_start_sector,
           0,
           parser_state.error ) != 1 )
      {
        libcerror_error_set(
         parser_state.error,
         LIBCERROR_ERROR_DOMAIN_RUNTIME,
         LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
         "%s: unable to append lead-out.",
         function );

        result = -1;
      }
    }
    if( parser_state.current_track > 0 )
    {
      if( parser_state.previous_file_index < 0 )
      {
        parser_state.file_sector = parser_state.previous_track_start_sector;

        parser_state.previous_file_index += 1;
      }
      parser_state.previous_file_sector = parser_state.previous_track_start_sector
                                        - parser_state.file_sector;

      if( libodraw_handle_append_track(
           parser_state.handle,
           parser_state.previous_track_start_sector,
           0,
           parser_state.current_track_type,
           parser_state.current_file_index,
           parser_state.previous_file_sector,
           parser_state.error ) != 1 )
      {
        libcerror_error_set(
         parser_state.error,
         LIBCERROR_ERROR_DOMAIN_RUNTIME,
         LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
         "%s: unable to append track.",
         function );

        result = -1;
      }
    }
  }
  libodraw_cue_scanner_lex_destroy();

  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 49:
  {
    libodraw_cue_parser_rule_print(
     "cue_catalog" );
  }
break;
case 50:
  {
    libodraw_cue_parser_rule_print(
     "cue_cdtext" );
  }
break;
case 63:
  {
    libodraw_cue_parser_rule_print(
     "cue_cd_da" );
  }
break;
case 64:
  {
    libodraw_cue_parser_rule_print(
     "cue_cd_rom" );
  }
break;
case 65:
  {
    libodraw_cue_parser_rule_print(
     "cue_cd_rom_xa" );
  }
break;
case 66:
  {
    libodraw_cue_parser_rule_print(
     "cue_cdtextfile" );
  }
break;
case 67:
  {
    libodraw_cue_parser_rule_print(
     "cue_file" );

    if( yystack.l_mark[-2].string_value.data == NULL )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
       "%s: invalid filename.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( yystack.l_mark[-1].string_value.data == NULL )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
       "%s: invalid file type.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->file_type = LIBODRAW_FILE_TYPE_UNKNOWN;

    if( yystack.l_mark[-1].string_value.length == 3 )
    {
      if( narrow_string_compare(
           yystack.l_mark[-1].string_value.data,
           "MP3",
           3 ) == 0 )
      {
        ( (libodraw_cue_parser_state_t *) parser_state )->file_type = LIBODRAW_FILE_TYPE_AUDIO_MPEG1_LAYER3;
      }
    }
    else if( yystack.l_mark[-1].string_value.length == 4 )
    {
      if( narrow_string_compare(
           yystack.l_mark[-1].string_value.data,
           "AIFF",
           4 ) == 0 )
      {
        ( (libodraw_cue_parser_state_t *) parser_state )->file_type = LIBODRAW_FILE_TYPE_AUDIO_AIFF;
      }
      else if( narrow_string_compare(
                yystack.l_mark[-1].string_value.data,
                "WAVE",
                4 ) == 0 )
      {
        ( (libodraw_cue_parser_state_t *) parser_state )->file_type = LIBODRAW_FILE_TYPE_AUDIO_WAVE;
      }
    }
    else if( yystack.l_mark[-1].string_value.length == 6 )
    {
      if( narrow_string_compare(
           yystack.l_mark[-1].string_value.data,
           "BINARY",
           6 ) == 0 )
      {
        ( (libodraw_cue_parser_state_t *) parser_state )->file_type = LIBODRAW_FILE_TYPE_BINARY_LITTLE_ENDIAN;
      }
    }
    else if( yystack.l_mark[-1].string_value.length == 8 )
    {
      if( narrow_string_compare(
           yystack.l_mark[-1].string_value.data,
           "MOTOROLA",
           8 ) == 0 )
      {
        ( (libodraw_cue_parser_state_t *) parser_state )->file_type = LIBODRAW_FILE_TYPE_BINARY_BIG_ENDIAN;
      }
    }
    if( libodraw_handle_append_data_file(
         ( (libodraw_cue_parser_state_t *) parser_state )->handle,
         yystack.l_mark[-2].string_value.data,
         yystack.l_mark[-2].string_value.length,
         ( (libodraw_cue_parser_state_t *) parser_state )->file_type,
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
       "%s: unable to append data file.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->current_file_index += 1;
  }
break;
case 68:
  {
    libodraw_cue_parser_rule_print(
     "cue_flags" );
  }
break;
case 71:
  {
    libodraw_cue_parser_rule_print(
     "cue_index" );

    ( (libodraw_cue_parser_state_t *) parser_state )->previous_index = ( (libodraw_cue_parser_state_t *) parser_state )->current_index;

    if( libodraw_cue_parser_parse_number(
         yystack.l_mark[-2].string_value.data,
         yystack.l_mark[-2].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->current_index ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse index number.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( ( ( (libodraw_cue_parser_state_t *) parser_state )->current_index != 0 )
     && ( ( (libodraw_cue_parser_state_t *) parser_state )->current_index != ( ( (libodraw_cue_parser_state_t *) parser_state )->previous_index + 1 ) ) )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
       "%s: unsupported index number - values are not sequential.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( libodraw_cue_parser_parse_msf(
         yystack.l_mark[-1].string_value.data,
         yystack.l_mark[-1].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse index MSF.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    /* The MSF can be relative to the start of the file
     */
    if( ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector != 0 )
    {
      if( ( ( (libodraw_cue_parser_state_t *) parser_state )->current_index == 0 )
       || ( ( (libodraw_cue_parser_state_t *) parser_state )->current_index == 1 ) )
      {
        if( ( ( (libodraw_cue_parser_state_t *) parser_state )->session_number_of_sectors == 0 )
         || ( ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_type == LIBODRAW_TRACK_TYPE_AUDIO ) )
        {
          if( ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector < ( (libodraw_cue_parser_state_t *) parser_state )->previous_session_start_sector )
          {
            libcerror_error_set(
             ( (libodraw_cue_parser_state_t *) parser_state )->error,
             LIBCERROR_ERROR_DOMAIN_RUNTIME,
             LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
             "%s: invalid session start sector value precedes previous.",
             libodraw_cue_parser_function );

            YYABORT;
          }
          ( (libodraw_cue_parser_state_t *) parser_state )->session_number_of_sectors = ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector
                                                                                      - ( (libodraw_cue_parser_state_t *) parser_state )->previous_session_start_sector;
        }
        if( ( ( (libodraw_cue_parser_state_t *) parser_state )->lead_out_number_of_sectors == 0 )
         || ( ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_type == LIBODRAW_TRACK_TYPE_AUDIO ) )
        {
          if( ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector < ( (libodraw_cue_parser_state_t *) parser_state )->previous_lead_out_start_sector )
          {
            libcerror_error_set(
             ( (libodraw_cue_parser_state_t *) parser_state )->error,
             LIBCERROR_ERROR_DOMAIN_RUNTIME,
             LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
             "%s: invalid lead-out start sector value precedes previous.",
             libodraw_cue_parser_function );

            YYABORT;
          }
          ( (libodraw_cue_parser_state_t *) parser_state )->lead_out_number_of_sectors = ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector
                                                                                       - ( (libodraw_cue_parser_state_t *) parser_state )->previous_lead_out_start_sector;
        }
      }
      if( ( (libodraw_cue_parser_state_t *) parser_state )->current_index == 1 )
      {
        if( ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors == 0 )
        {
          if( ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector < ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector )
          {
            libcerror_error_set(
             ( (libodraw_cue_parser_state_t *) parser_state )->error,
             LIBCERROR_ERROR_DOMAIN_RUNTIME,
             LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
             "%s: invalid track start sector value precedes previous.",
             libodraw_cue_parser_function );

            YYABORT;
          }
          ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors = ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector
                                                                                    - ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector;
        }
      }
    }
    if( ( (libodraw_cue_parser_state_t *) parser_state )->current_index == 1 )
    {
      if( ( (libodraw_cue_parser_state_t *) parser_state )->current_session > 1 )
      {
        if( libodraw_handle_append_session(
             ( (libodraw_cue_parser_state_t *) parser_state )->handle,
             ( (libodraw_cue_parser_state_t *) parser_state )->previous_session_start_sector,
             ( (libodraw_cue_parser_state_t *) parser_state )->session_number_of_sectors,
             ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
        {
          libcerror_error_set(
           ( (libodraw_cue_parser_state_t *) parser_state )->error,
           LIBCERROR_ERROR_DOMAIN_RUNTIME,
           LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
           "%s: unable to append session.",
           libodraw_cue_parser_function );

          YYABORT;
        }
        ( (libodraw_cue_parser_state_t *) parser_state )->previous_session_start_sector = ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector;
        ( (libodraw_cue_parser_state_t *) parser_state )->session_number_of_sectors     = 0;
      }
      if( ( (libodraw_cue_parser_state_t *) parser_state )->current_lead_out > ( (libodraw_cue_parser_state_t *) parser_state )->previous_lead_out )
      {
        if( libodraw_handle_append_lead_out(
             ( (libodraw_cue_parser_state_t *) parser_state )->handle,
             ( (libodraw_cue_parser_state_t *) parser_state )->previous_lead_out_start_sector,
             ( (libodraw_cue_parser_state_t *) parser_state )->lead_out_number_of_sectors,
             ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
        {
          libcerror_error_set(
           ( (libodraw_cue_parser_state_t *) parser_state )->error,
           LIBCERROR_ERROR_DOMAIN_RUNTIME,
           LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
           "%s: unable to append lead-out.",
           libodraw_cue_parser_function );

          YYABORT;
        }
        ( (libodraw_cue_parser_state_t *) parser_state )->previous_lead_out          = ( (libodraw_cue_parser_state_t *) parser_state )->current_lead_out;
        ( (libodraw_cue_parser_state_t *) parser_state )->lead_out_number_of_sectors = 0;
      }
      if( ( (libodraw_cue_parser_state_t *) parser_state )->current_track > 1 )
      {
        if( ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_index < 0 )
        {
          ( (libodraw_cue_parser_state_t *) parser_state )->file_sector = ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector;

          ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_index += 1;
        }
        ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_sector = ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector
                                                                               - ( (libodraw_cue_parser_state_t *) parser_state )->file_sector;

        if( libodraw_handle_append_track(
             ( (libodraw_cue_parser_state_t *) parser_state )->handle,
             ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector,
             ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors,
             ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_type,
             ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_index,
             ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_sector,
             ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
        {
          libcerror_error_set(
           ( (libodraw_cue_parser_state_t *) parser_state )->error,
           LIBCERROR_ERROR_DOMAIN_RUNTIME,
           LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
           "%s: unable to append track.",
           libodraw_cue_parser_function );

          YYABORT;
        }
        if( ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_index < ( (libodraw_cue_parser_state_t *) parser_state )->current_file_index )
        {
          ( (libodraw_cue_parser_state_t *) parser_state )->file_sector = ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector;

          ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_index += 1;
        }
        ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector = ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector;
        ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors     = 0;
      }
    }
  }
break;
case 72:
  {
    libodraw_cue_parser_rule_print(
     "cue_copy" );
  }
break;
case 73:
  {
    libodraw_cue_parser_rule_print(
     "cue_datafile" );

    if( yystack.l_mark[-2].string_value.data == NULL )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
       LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
       "%s: invalid filename.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( libodraw_cue_parser_parse_msf(
         yystack.l_mark[-1].string_value.data,
         yystack.l_mark[-1].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse datafile MSF.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->file_type = LIBODRAW_FILE_TYPE_BINARY_LITTLE_ENDIAN;

    if( libodraw_handle_append_data_file(
         ( (libodraw_cue_parser_state_t *) parser_state )->handle,
         yystack.l_mark[-2].string_value.data,
         yystack.l_mark[-2].string_value.length,
         ( (libodraw_cue_parser_state_t *) parser_state )->file_type,
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
       "%s: unable to append data file.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_index < 0 )
    {
      ( (libodraw_cue_parser_state_t *) parser_state )->file_sector = ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector;

      ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_index += 1;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_sector = ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector
                                                                           - ( (libodraw_cue_parser_state_t *) parser_state )->file_sector;

    if( libodraw_handle_append_track(
         ( (libodraw_cue_parser_state_t *) parser_state )->handle,
         ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector,
         ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors,
         ( (libodraw_cue_parser_state_t *) parser_state )->current_track_type,
         ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_index,
         ( (libodraw_cue_parser_state_t *) parser_state )->previous_file_sector,
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
       "%s: unable to append track.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->current_file_index += 1;
  }
break;
case 74:
  {
    libodraw_cue_parser_rule_print(
     "cue_four_channel_audio" );
  }
break;
case 75:
  {
    libodraw_cue_parser_rule_print(
     "cue_isrc" );
  }
break;
case 76:
  {
    libodraw_cue_parser_rule_print(
     "cue_no_copy" );
  }
break;
case 77:
  {
    libodraw_cue_parser_rule_print(
     "cue_no_pre_emphasis" );
  }
break;
case 78:
  {
    libodraw_cue_parser_rule_print(
     "cue_postgap" );
  }
break;
case 79:
  {
    libodraw_cue_parser_rule_print(
     "cue_pre_emphasis" );
  }
break;
case 80:
  {
    libodraw_cue_parser_rule_print(
     "cue_pregap" );
  }
break;
case 81:
  {
    libodraw_cue_parser_rule_print(
     "cue_two_channel_audio" );
  }
break;
case 87:
  {
    libodraw_cue_parser_rule_print(
     "cue_lead_out" );

    if( libodraw_cue_parser_parse_msf(
         yystack.l_mark[-1].string_value.data,
         yystack.l_mark[-1].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->previous_lead_out_start_sector ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse lead-out MSF.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors == 0 )
    {
      if( ( (libodraw_cue_parser_state_t *) parser_state )->previous_lead_out_start_sector < ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector )
      {
        libcerror_error_set(
         ( (libodraw_cue_parser_state_t *) parser_state )->error,
         LIBCERROR_ERROR_DOMAIN_RUNTIME,
         LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
         "%s: invalid lead-out start sector value precedes previous track start sector.",
         libodraw_cue_parser_function );

        YYABORT;
      }
      ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors = ( (libodraw_cue_parser_state_t *) parser_state )->previous_lead_out_start_sector
                                                                                - ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->current_lead_out += 1;
  }
break;
case 88:
  {
    libodraw_cue_parser_rule_print(
     "cue_original_media_type" );
  }
break;
case 89:
  {
    libodraw_cue_parser_rule_print(
     "cue_remark" );

    libodraw_cue_scanner_suppress_error = 0;
  }
break;
case 90:
  {
    /* The build-in rule error will gobble up all the tokens until the end-of-line
     * because these are no syntax errors suppress the error output
     */
    libodraw_cue_scanner_suppress_error = 1;
  }
break;
case 91:
  {
    libodraw_cue_parser_rule_print(
     "cue_run_out" );

    if( libodraw_cue_parser_parse_msf(
         yystack.l_mark[-1].string_value.data,
         yystack.l_mark[-1].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse run-out MSF.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors == 0 )
    {
      if( ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector < ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector )
      {
        libcerror_error_set(
         ( (libodraw_cue_parser_state_t *) parser_state )->error,
         LIBCERROR_ERROR_DOMAIN_RUNTIME,
         LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
         "%s: invalid track start sector value precedes previous.",
         libodraw_cue_parser_function );

        YYABORT;
      }
      ( (libodraw_cue_parser_state_t *) parser_state )->track_number_of_sectors = ( (libodraw_cue_parser_state_t *) parser_state )->current_start_sector
                                            - ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_start_sector;
    }
  }
break;
case 92:
  {
    libodraw_cue_parser_rule_print(
     "cue_session" );

    ( (libodraw_cue_parser_state_t *) parser_state )->previous_session = ( (libodraw_cue_parser_state_t *) parser_state )->current_session;

    if( libodraw_cue_parser_parse_number(
         yystack.l_mark[-1].string_value.data,
         yystack.l_mark[-1].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->current_session ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse session number.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( ( ( (libodraw_cue_parser_state_t *) parser_state )->current_session != 0 )
     && ( ( (libodraw_cue_parser_state_t *) parser_state )->current_session != ( ( (libodraw_cue_parser_state_t *) parser_state )->previous_session + 1 ) ) )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
       "%s: unsupported session number - values are not sequential.",
       libodraw_cue_parser_function );

      YYABORT;
    }
  }
break;
case 93:
  {
    libodraw_cue_parser_rule_print(
     "cue_track" );

    if( ( (libodraw_cue_parser_state_t *) parser_state )->current_track != 0 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
       "%s: unsupported track number - only single track supported.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_type = ( (libodraw_cue_parser_state_t *) parser_state )->current_track_type;

    if( libodraw_cue_parser_parse_track_type(
         yystack.l_mark[-1].string_value.data,
         yystack.l_mark[-1].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->current_track_type ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse track type.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->previous_index = 0;
    ( (libodraw_cue_parser_state_t *) parser_state )->current_index  = 0;
  }
break;
case 94:
  {
    libodraw_cue_parser_rule_print(
     "cue_track" );

    ( (libodraw_cue_parser_state_t *) parser_state )->previous_track = ( (libodraw_cue_parser_state_t *) parser_state )->current_track;

    if( libodraw_cue_parser_parse_number(
         yystack.l_mark[-2].string_value.data,
         yystack.l_mark[-2].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->current_track ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse track number.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    if( ( ( (libodraw_cue_parser_state_t *) parser_state )->current_track != 0 )
     && ( ( (libodraw_cue_parser_state_t *) parser_state )->current_track != ( ( (libodraw_cue_parser_state_t *) parser_state )->previous_track + 1 ) ) )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
       "%s: unsupported track number - values are not sequential.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->previous_track_type = ( (libodraw_cue_parser_state_t *) parser_state )->current_track_type;

    if( libodraw_cue_parser_parse_track_type(
         yystack.l_mark[-1].string_value.data,
         yystack.l_mark[-1].string_value.length,
         &( ( (libodraw_cue_parser_state_t *) parser_state )->current_track_type ),
         ( (libodraw_cue_parser_state_t *) parser_state )->error ) != 1 )
    {
      libcerror_error_set(
       ( (libodraw_cue_parser_state_t *) parser_state )->error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_SET_FAILED,
       "%s: unable to parse track type.",
       libodraw_cue_parser_function );

      YYABORT;
    }
    ( (libodraw_cue_parser_state_t *) parser_state )->previous_index = 0;
    ( (libodraw_cue_parser_state_t *) parser_state )->current_index  = 0;
  }
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);
}

Coverage Report

Created: 2024-10-02 06:58