diff --git a/external/external_build.cmake b/external/external_build.cmake index 5a66138..8bb063c 100644 --- a/external/external_build.cmake +++ b/external/external_build.cmake @@ -30,7 +30,7 @@ IF(INTERNAL_GENGETOPT) ENDIF(INTERNAL_GENGETOPT) IF(INTERNAL_HDF5) - SET(HDF5_URL "https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.10/hdf5-1.10.5/src/hdf5-1.10.5.tar.gz" CACHE STRING "URL to download HDF5 from") + SET(HDF5_URL "https://github.com/HDFGroup/hdf5/releases/download/hdf5_1.14.6/hdf5-1.14.6.tar.gz" CACHE STRING "URL to download HDF5 from") mark_as_advanced(HDF5_URL) ENDIF(INTERNAL_HDF5) @@ -104,7 +104,7 @@ if (INTERNAL_HDF5) DOWNLOAD_DIR ${VIDE_DOWNLOAD_CACHE} PREFIX ${BUILD_PREFIX}/hdf5-prefix URL ${HDF5_URL} - URL_HASH MD5=e115eeb66e944fa7814482415dd21cc4 + URL_HASH SHA256=e4defbac30f50d64e1556374aa49e574417c9e72c6b1de7a4ff88c4b1bea6e9b CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${EXT_INSTALL} -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} diff --git a/external/patch_sdf b/external/patch_sdf index b41345c..cb5f708 100644 --- a/external/patch_sdf +++ b/external/patch_sdf @@ -1,31 +1,29 @@ ---- SDF.h 2014-06-04 07:22:26.000000000 +0200 -+++ SDF.h.new 2014-06-04 10:06:18.521116967 +0200 -@@ -85,7 +85,7 @@ - int SDFswap(SDF *hdr); - int SDFnoswap(SDF *hdr); - int SDFisswapping(SDF *hdr); --int SDFsetmaxbufsz(int new); -+int SDFsetmaxbufsz(int); - int SDFrdvecs(SDF *hdr, ... - /* char *name, int n, void *address, int stride, - ... , -@@ -113,10 +113,10 @@ +Only in : byteswap.o +Only in : libSDF.a +Only in : obstack.o +Only in : SDFcvt +Only in : SDFcvt.o +diff -ru SDFfuncs.c SDFfuncs.c +--- SDFfuncs.c 2014-06-04 07:22:26.000000000 +0200 ++++ SDFfuncs.c 2025-03-09 08:11:44.309081633 +0100 +@@ -44,10 +44,12 @@ + char SDFerrstring[256]; + extern int SDFyyparse(void); - /* These four are harder to write than one might guess. */ - /* They're in the library to avoid duplicating code. */ --int SDFgetint(SDF *sdfp, char *name, int *value); --int SDFgetint64(SDF *sdfp, char *name, int64_t *value); --int SDFgetfloat(SDF *sdfp, char *name, float *value); --int SDFgetdouble(SDF *sdfp, char *name, double *value); -+int SDFgetint(SDF *sdfp, const char *name, int *value); -+int SDFgetint64(SDF *sdfp, const char *name, int64_t *value); -+int SDFgetfloat(SDF *sdfp, const char *name, float *value); -+int SDFgetdouble(SDF *sdfp, const char *name, double *value); - int SDFgetstring(SDF *sdfp, const char *name, char *string, int size); ++extern int Msg_on(int); ++ + int SDFdebug(int level) + { + sdf_debug = level; +- Msg_on(level); ++ return Msg_on(level); + } - void SDFwrite(const char *filename, int64_t gnobj, int64_t nobj, ---- SDFget.c.old 2014-06-04 10:17:16.380531163 +0200 -+++ SDFget.c 2014-06-04 10:17:40.991953383 +0200 + /* This is a non-guaranteed way to test if a file is SDF or not. */ +Only in : SDFfuncs.o +diff -ru SDFget.c SDFget.c +--- SDFget.c 2014-06-04 07:22:26.000000000 +0200 ++++ SDFget.c 2025-03-09 08:01:48.425419419 +0100 @@ -22,7 +22,7 @@ /* I'll resist the temptation to make one macro to cover all these cases */ /* Should we check for loss of precision in float too? */ @@ -62,3 +60,4390 @@ { int int_value; float float_value; +Only in : SDFget.o +diff -ru SDF.h SDF.h +--- SDF.h 2014-06-04 07:22:26.000000000 +0200 ++++ SDF.h 2025-03-09 08:01:48.425224813 +0100 +@@ -85,7 +85,7 @@ + int SDFswap(SDF *hdr); + int SDFnoswap(SDF *hdr); + int SDFisswapping(SDF *hdr); +-int SDFsetmaxbufsz(int new); ++int SDFsetmaxbufsz(int); + int SDFrdvecs(SDF *hdr, ... + /* char *name, int n, void *address, int stride, + ... , +@@ -113,10 +113,10 @@ + + /* These four are harder to write than one might guess. */ + /* They're in the library to avoid duplicating code. */ +-int SDFgetint(SDF *sdfp, char *name, int *value); +-int SDFgetint64(SDF *sdfp, char *name, int64_t *value); +-int SDFgetfloat(SDF *sdfp, char *name, float *value); +-int SDFgetdouble(SDF *sdfp, char *name, double *value); ++int SDFgetint(SDF *sdfp, const char *name, int *value); ++int SDFgetint64(SDF *sdfp, const char *name, int64_t *value); ++int SDFgetfloat(SDF *sdfp, const char *name, float *value); ++int SDFgetdouble(SDF *sdfp, const char *name, double *value); + int SDFgetstring(SDF *sdfp, const char *name, char *string, int size); + + void SDFwrite(const char *filename, int64_t gnobj, int64_t nobj, +Only in : SDFhdrio.o +diff -ru SDF-lex.c SDF-lex.c +--- SDF-lex.c 2014-06-04 07:22:26.000000000 +0200 ++++ SDF-lex.c 2025-03-09 08:09:50.486883002 +0100 +@@ -1,15 +1,16 @@ +-#line 2 "SDF-lex.c" ++#line 1 "SDF-lex.c" + +-#line 4 "SDF-lex.c" ++#line 3 "SDF-lex.c" + ++#define yylex SDFyylex + #define YY_INT_ALIGNED short int + + /* A lexical scanner generated by flex */ + + #define FLEX_SCANNER + #define YY_FLEX_MAJOR_VERSION 2 +-#define YY_FLEX_MINOR_VERSION 5 +-#define YY_FLEX_SUBMINOR_VERSION 35 ++#define YY_FLEX_MINOR_VERSION 6 ++#define YY_FLEX_SUBMINOR_VERSION 4 + #if YY_FLEX_SUBMINOR_VERSION > 0 + #define FLEX_BETA + #endif +@@ -54,7 +55,6 @@ + typedef unsigned char flex_uint8_t; + typedef unsigned short int flex_uint16_t; + typedef unsigned int flex_uint32_t; +-#endif /* ! C99 */ + + /* Limits of integral types. */ + #ifndef INT8_MIN +@@ -85,63 +85,61 @@ + #define UINT32_MAX (4294967295U) + #endif + +-#endif /* ! FLEXINT_H */ +- +-#ifdef __cplusplus +- +-/* The "const" storage-class-modifier is valid. */ +-#define YY_USE_CONST +- +-#else /* ! __cplusplus */ ++#ifndef SIZE_MAX ++#define SIZE_MAX (~(size_t)0) ++#endif + +-/* C99 requires __STDC__ to be defined as 1. */ +-#if defined (__STDC__) ++#endif /* ! C99 */ + +-#define YY_USE_CONST ++#endif /* ! FLEXINT_H */ + +-#endif /* defined (__STDC__) */ +-#endif /* ! __cplusplus */ ++/* begin standard C++ headers. */ + +-#ifdef YY_USE_CONST ++/* TODO: this is always defined, so inline it */ + #define yyconst const ++ ++#if defined(__GNUC__) && __GNUC__ >= 3 ++#define yynoreturn __attribute__((__noreturn__)) + #else +-#define yyconst ++#define yynoreturn + #endif + + /* Returned upon end-of-file. */ + #define YY_NULL 0 + +-/* Promotes a possibly negative, possibly signed char to an unsigned +- * integer for use as an array index. If the signed char is negative, +- * we want to instead treat it as an 8-bit unsigned char, hence the +- * double cast. ++/* Promotes a possibly negative, possibly signed char to an ++ * integer in range [0..255] for use as an array index. + */ +-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ++#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + + /* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ + #define BEGIN (yy_start) = 1 + 2 * +- + /* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ + #define YY_START (((yy_start) - 1) / 2) + #define YYSTATE YY_START +- + /* Action number for EOF rule of a given start state. */ + #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +- + /* Special action meaning "start processing a new file". */ +-#define YY_NEW_FILE yyrestart(yyin ) +- ++#define YY_NEW_FILE yyrestart( yyin ) + #define YY_END_OF_BUFFER_CHAR 0 + + /* Size of default input buffer. */ + #ifndef YY_BUF_SIZE ++#ifdef __ia64__ ++/* On IA-64, the buffer size is 16k, not 8k. ++ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. ++ * Ditto for the __ia64__ case accordingly. ++ */ ++#define YY_BUF_SIZE 32768 ++#else + #define YY_BUF_SIZE 16384 ++#endif /* __ia64__ */ + #endif + + /* The state buf must be large enough to hold one state per character in the main buffer. +@@ -153,6 +151,11 @@ + typedef struct yy_buffer_state *YY_BUFFER_STATE; + #endif + ++#ifndef YY_TYPEDEF_YY_SIZE_T ++#define YY_TYPEDEF_YY_SIZE_T ++typedef size_t yy_size_t; ++#endif ++ + extern int yyleng; + + extern FILE *yyin, *yyout; +@@ -160,8 +163,9 @@ + #define EOB_ACT_CONTINUE_SCAN 0 + #define EOB_ACT_END_OF_FILE 1 + #define EOB_ACT_LAST_MATCH 2 +- ++ + #define YY_LESS_LINENO(n) ++ #define YY_LINENO_REWIND_TO(ptr) + + /* Return all but the first "n" matched characters back to the input stream. */ + #define yyless(n) \ +@@ -176,14 +180,8 @@ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +- + #define unput(c) yyunput( c, (yytext_ptr) ) + +-#ifndef YY_TYPEDEF_YY_SIZE_T +-#define YY_TYPEDEF_YY_SIZE_T +-typedef size_t yy_size_t; +-#endif +- + #ifndef YY_STRUCT_YY_BUFFER_STATE + #define YY_STRUCT_YY_BUFFER_STATE + struct yy_buffer_state +@@ -196,7 +194,7 @@ + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ +- yy_size_t yy_buf_size; ++ int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. +@@ -224,7 +222,7 @@ + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ +- ++ + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ +@@ -252,7 +250,7 @@ + /* Stack of input buffers. */ + static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ + static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +-static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ ++static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ + + /* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general +@@ -263,7 +261,6 @@ + #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +- + /* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +@@ -275,7 +272,7 @@ + int yyleng; + + /* Points to current character in buffer. */ +-static char *yy_c_buf_p = (char *) 0; ++static char *yy_c_buf_p = NULL; + static int yy_init = 0; /* whether we need to initialize */ + static int yy_start = 0; /* start state number */ + +@@ -284,80 +281,77 @@ + */ + static int yy_did_buffer_switch_on_eof; + +-void yyrestart (FILE *input_file ); +-void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); +-YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); +-void yy_delete_buffer (YY_BUFFER_STATE b ); +-void yy_flush_buffer (YY_BUFFER_STATE b ); +-void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); +-void yypop_buffer_state (void ); +- +-static void yyensure_buffer_stack (void ); +-static void yy_load_buffer_state (void ); +-static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); +- +-#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) +- +-YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); +-YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); +-YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); +- +-void *yyalloc (yy_size_t ); +-void *yyrealloc (void *,yy_size_t ); +-void yyfree (void * ); ++void yyrestart ( FILE *input_file ); ++void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); ++YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); ++void yy_delete_buffer ( YY_BUFFER_STATE b ); ++void yy_flush_buffer ( YY_BUFFER_STATE b ); ++void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); ++void yypop_buffer_state ( void ); ++ ++static void yyensure_buffer_stack ( void ); ++static void yy_load_buffer_state ( void ); ++static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); ++#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) ++ ++YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); ++YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); ++YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); ++ ++void *yyalloc ( yy_size_t ); ++void *yyrealloc ( void *, yy_size_t ); ++void yyfree ( void * ); + + #define yy_new_buffer yy_create_buffer +- + #define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ +- yy_create_buffer(yyin,YY_BUF_SIZE ); \ ++ yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +- + #define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ +- yy_create_buffer(yyin,YY_BUF_SIZE ); \ ++ yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +- + #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +-typedef unsigned char YY_CHAR; ++typedef flex_uint8_t YY_CHAR; + +-FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; ++FILE *yyin = NULL, *yyout = NULL; + + typedef int yy_state_type; + + extern int yylineno; +- + int yylineno = 1; + + extern char *yytext; ++#ifdef yytext_ptr ++#undef yytext_ptr ++#endif + #define yytext_ptr yytext + +-static yy_state_type yy_get_previous_state (void ); +-static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); +-static int yy_get_next_buffer (void ); +-static void yy_fatal_error (yyconst char msg[] ); ++static yy_state_type yy_get_previous_state ( void ); ++static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); ++static int yy_get_next_buffer ( void ); ++static void yynoreturn yy_fatal_error ( const char* msg ); + + /* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ + #define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ +- yyleng = (size_t) (yy_cp - yy_bp); \ ++ yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; +- + #define YY_NUM_RULES 26 + #define YY_END_OF_BUFFER 27 + /* This struct is not used in this scanner, +@@ -367,7 +361,7 @@ + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +-static yyconst flex_int16_t yy_accept[119] = ++static const flex_int16_t yy_accept[119] = + { 0, + 0, 0, 27, 25, 3, 3, 25, 2, 25, 24, + 25, 25, 23, 23, 16, 16, 16, 16, 16, 16, +@@ -384,7 +378,7 @@ + 14, 1, 1, 1, 1, 1, 1, 0 + } ; + +-static yyconst flex_int32_t yy_ec[256] = ++static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, +@@ -416,7 +410,7 @@ + 1, 1, 1, 1, 1 + } ; + +-static yyconst flex_int32_t yy_meta[52] = ++static const YY_CHAR yy_meta[52] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 3, + 1, 4, 4, 4, 4, 4, 1, 1, 5, 5, +@@ -426,7 +420,7 @@ + 1 + } ; + +-static yyconst flex_int16_t yy_base[125] = ++static const flex_int16_t yy_base[125] = + { 0, + 0, 0, 281, 282, 282, 282, 276, 253, 42, 282, + 47, 272, 54, 55, 0, 228, 239, 233, 235, 232, +@@ -444,7 +438,7 @@ + 217, 218, 221, 226 + } ; + +-static yyconst flex_int16_t yy_def[125] = ++static const flex_int16_t yy_def[125] = + { 0, + 118, 1, 118, 118, 118, 118, 119, 120, 118, 118, + 118, 118, 118, 121, 122, 122, 122, 122, 122, 122, +@@ -462,7 +456,7 @@ + 118, 118, 118, 118 + } ; + +-static yyconst flex_int16_t yy_nxt[334] = ++static const flex_int16_t yy_nxt[334] = + { 0, + 4, 5, 6, 7, 8, 4, 9, 10, 9, 11, + 12, 13, 14, 14, 14, 14, 10, 10, 15, 15, +@@ -503,7 +497,7 @@ + 118, 118, 118 + } ; + +-static yyconst flex_int16_t yy_chk[334] = ++static const flex_int16_t yy_chk[334] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +@@ -599,7 +593,8 @@ + #else /* Not FLEX_SCANNER */ + void SDFlexprepare(void){} + #endif +-#line 603 "SDF-lex.c" ++#line 596 "SDF-lex.c" ++#line 597 "SDF-lex.c" + + #define INITIAL 0 + +@@ -615,36 +610,36 @@ + #define YY_EXTRA_TYPE void * + #endif + +-static int yy_init_globals (void ); ++static int yy_init_globals ( void ); + + /* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +-int yylex_destroy (void ); ++int yylex_destroy ( void ); + +-int yyget_debug (void ); ++int yyget_debug ( void ); + +-void yyset_debug (int debug_flag ); ++void yyset_debug ( int debug_flag ); + +-YY_EXTRA_TYPE yyget_extra (void ); ++YY_EXTRA_TYPE yyget_extra ( void ); + +-void yyset_extra (YY_EXTRA_TYPE user_defined ); ++void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +-FILE *yyget_in (void ); ++FILE *yyget_in ( void ); + +-void yyset_in (FILE * in_str ); ++void yyset_in ( FILE * _in_str ); + +-FILE *yyget_out (void ); ++FILE *yyget_out ( void ); + +-void yyset_out (FILE * out_str ); ++void yyset_out ( FILE * _out_str ); + +-int yyget_leng (void ); ++ int yyget_leng ( void ); + +-char *yyget_text (void ); ++char *yyget_text ( void ); + +-int yyget_lineno (void ); ++int yyget_lineno ( void ); + +-void yyset_lineno (int line_number ); ++void yyset_lineno ( int _line_number ); + + /* Macros after this point can all be overridden by user definitions in + * section 1. +@@ -652,35 +647,43 @@ + + #ifndef YY_SKIP_YYWRAP + #ifdef __cplusplus +-extern "C" int yywrap (void ); ++extern "C" int yywrap ( void ); + #else +-extern int yywrap (void ); ++extern int yywrap ( void ); + #endif + #endif + +- static void yyunput (int c,char *buf_ptr ); ++#ifndef YY_NO_UNPUT ++ ++ static void yyunput ( int c, char *buf_ptr ); + ++#endif ++ + #ifndef yytext_ptr +-static void yy_flex_strncpy (char *,yyconst char *,int ); ++static void yy_flex_strncpy ( char *, const char *, int ); + #endif + + #ifdef YY_NEED_STRLEN +-static int yy_flex_strlen (yyconst char * ); ++static int yy_flex_strlen ( const char * ); + #endif + + #ifndef YY_NO_INPUT +- + #ifdef __cplusplus +-static int yyinput (void ); ++static int yyinput ( void ); + #else +-static int input (void ); ++static int input ( void ); + #endif + + #endif + + /* Amount of stuff to slurp up with each read. */ + #ifndef YY_READ_BUF_SIZE ++#ifdef __ia64__ ++/* On IA-64, the buffer size is 16k, not 8k */ ++#define YY_READ_BUF_SIZE 16384 ++#else + #define YY_READ_BUF_SIZE 8192 ++#endif /* __ia64__ */ + #endif + + /* Copy whatever the last rule matched to the standard output. */ +@@ -688,7 +691,7 @@ + /* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +-#define ECHO fwrite( yytext, yyleng, 1, yyout ) ++#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) + #endif + + /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, +@@ -712,7 +715,7 @@ + else \ + { \ + errno=0; \ +- while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ ++ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ +@@ -767,7 +770,7 @@ + + /* Code executed at the end of each rule. */ + #ifndef YY_BREAK +-#define YY_BREAK break; ++#define YY_BREAK /*LINTED*/break; + #endif + + #define YY_RULE_SETUP \ +@@ -777,14 +780,10 @@ + */ + YY_DECL + { +- register yy_state_type yy_current_state; +- register char *yy_cp, *yy_bp; +- register int yy_act; ++ yy_state_type yy_current_state; ++ char *yy_cp, *yy_bp; ++ int yy_act; + +-#line 52 "SDF-lex.l" +- +-#line 787 "SDF-lex.c" +- + if ( !(yy_init) ) + { + (yy_init) = 1; +@@ -805,13 +804,18 @@ + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = +- yy_create_buffer(yyin,YY_BUF_SIZE ); ++ yy_create_buffer( yyin, YY_BUF_SIZE ); + } + +- yy_load_buffer_state( ); ++ yy_load_buffer_state( ); + } + +- while ( 1 ) /* loops until end-of-file is reached */ ++ { ++#line 52 "SDF-lex.l" ++ ++#line 816 "SDF-lex.c" ++ ++ while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + +@@ -827,7 +831,7 @@ + yy_match: + do + { +- register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; ++ YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; +@@ -837,9 +841,9 @@ + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 119 ) +- yy_c = yy_meta[(unsigned int) yy_c]; ++ yy_c = yy_meta[yy_c]; + } +- yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_current_state != 118 ); +@@ -1030,7 +1034,7 @@ + #line 120 "SDF-lex.l" + ECHO; + YY_BREAK +-#line 1034 "SDF-lex.c" ++#line 1037 "SDF-lex.c" + case YY_STATE_EOF(INITIAL): + yyterminate(); + +@@ -1109,7 +1113,7 @@ + { + (yy_did_buffer_switch_on_eof) = 0; + +- if ( yywrap( ) ) ++ if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up +@@ -1162,6 +1166,7 @@ + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ ++ } /* end of user's declarations */ + } /* end of yylex */ + + /* yy_get_next_buffer - try to read in a new buffer +@@ -1173,9 +1178,9 @@ + */ + static int yy_get_next_buffer (void) + { +- register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; +- register char *source = (yytext_ptr); +- register int number_to_move, i; ++ char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ++ char *source = (yytext_ptr); ++ int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) +@@ -1204,7 +1209,7 @@ + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ +- number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; ++ number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); +@@ -1224,7 +1229,7 @@ + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ +- YY_BUFFER_STATE b = YY_CURRENT_BUFFER; ++ YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); +@@ -1240,11 +1245,12 @@ + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ +- yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); ++ yyrealloc( (void *) b->yy_ch_buf, ++ (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ +- b->yy_ch_buf = 0; ++ b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( +@@ -1262,7 +1268,7 @@ + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), +- (yy_n_chars), (size_t) num_to_read ); ++ (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } +@@ -1272,7 +1278,7 @@ + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; +- yyrestart(yyin ); ++ yyrestart( yyin ); + } + + else +@@ -1286,12 +1292,15 @@ + else + ret_val = EOB_ACT_CONTINUE_SCAN; + +- if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ++ if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ +- yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); +- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); ++ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ++ (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ++ /* "- 2" to take care of EOB's */ ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; +@@ -1307,14 +1316,14 @@ + + static yy_state_type yy_get_previous_state (void) + { +- register yy_state_type yy_current_state; +- register char *yy_cp; ++ yy_state_type yy_current_state; ++ char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { +- register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ++ YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; +@@ -1324,9 +1333,9 @@ + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 119 ) +- yy_c = yy_meta[(unsigned int) yy_c]; ++ yy_c = yy_meta[yy_c]; + } +- yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +@@ -1339,10 +1348,10 @@ + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) + { +- register int yy_is_jam; +- register char *yy_cp = (yy_c_buf_p); ++ int yy_is_jam; ++ char *yy_cp = (yy_c_buf_p); + +- register YY_CHAR yy_c = 1; ++ YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; +@@ -1352,17 +1361,19 @@ + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 119 ) +- yy_c = yy_meta[(unsigned int) yy_c]; ++ yy_c = yy_meta[yy_c]; + } +- yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 118); + +- return yy_is_jam ? 0 : yy_current_state; ++ return yy_is_jam ? 0 : yy_current_state; + } + +- static void yyunput (int c, register char * yy_bp ) ++#ifndef YY_NO_UNPUT ++ ++ static void yyunput (int c, char * yy_bp ) + { +- register char *yy_cp; ++ char *yy_cp; + + yy_cp = (yy_c_buf_p); + +@@ -1372,10 +1383,10 @@ + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ +- register int number_to_move = (yy_n_chars) + 2; +- register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ ++ int number_to_move = (yy_n_chars) + 2; ++ char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; +- register char *source = ++ char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) +@@ -1384,7 +1395,7 @@ + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = +- (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; ++ (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); +@@ -1397,6 +1408,8 @@ + (yy_c_buf_p) = yy_cp; + } + ++#endif ++ + #ifndef YY_NO_INPUT + #ifdef __cplusplus + static int yyinput (void) +@@ -1421,7 +1434,7 @@ + + else + { /* need more input */ +- int offset = (yy_c_buf_p) - (yytext_ptr); ++ int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) +@@ -1438,14 +1451,14 @@ + */ + + /* Reset buffer status. */ +- yyrestart(yyin ); ++ yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { +- if ( yywrap( ) ) +- return EOF; ++ if ( yywrap( ) ) ++ return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +@@ -1482,11 +1495,11 @@ + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = +- yy_create_buffer(yyin,YY_BUF_SIZE ); ++ yy_create_buffer( yyin, YY_BUF_SIZE ); + } + +- yy_init_buffer(YY_CURRENT_BUFFER,input_file ); +- yy_load_buffer_state( ); ++ yy_init_buffer( YY_CURRENT_BUFFER, input_file ); ++ yy_load_buffer_state( ); + } + + /** Switch to a different input buffer. +@@ -1514,7 +1527,7 @@ + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; +- yy_load_buffer_state( ); ++ yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag +@@ -1542,7 +1555,7 @@ + { + YY_BUFFER_STATE b; + +- b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); ++ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + +@@ -1551,13 +1564,13 @@ + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ +- b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); ++ b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + +- yy_init_buffer(b,file ); ++ yy_init_buffer( b, file ); + + return b; + } +@@ -1576,9 +1589,9 @@ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) +- yyfree((void *) b->yy_ch_buf ); ++ yyfree( (void *) b->yy_ch_buf ); + +- yyfree((void *) b ); ++ yyfree( (void *) b ); + } + + /* Initializes or reinitializes a buffer. +@@ -1590,7 +1603,7 @@ + { + int oerrno = errno; + +- yy_flush_buffer(b ); ++ yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; +@@ -1633,7 +1646,7 @@ + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) +- yy_load_buffer_state( ); ++ yy_load_buffer_state( ); + } + + /** Pushes the new state onto the stack. The new state becomes +@@ -1664,7 +1677,7 @@ + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ +- yy_load_buffer_state( ); ++ yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } + +@@ -1683,7 +1696,7 @@ + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { +- yy_load_buffer_state( ); ++ yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } + } +@@ -1693,7 +1706,7 @@ + */ + static void yyensure_buffer_stack (void) + { +- int num_to_alloc; ++ yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + +@@ -1701,15 +1714,15 @@ + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ +- num_to_alloc = 1; ++ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); +- ++ + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); +- ++ + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; +@@ -1718,7 +1731,7 @@ + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ +- int grow_size = 8 /* arbitrary grow size */; ++ yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc +@@ -1738,7 +1751,7 @@ + * @param base the character buffer + * @param size the size in bytes of the character buffer + * +- * @return the newly allocated buffer state object. ++ * @return the newly allocated buffer state object. + */ + YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) + { +@@ -1748,23 +1761,23 @@ + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ +- return 0; ++ return NULL; + +- b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); ++ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + +- b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ ++ b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; +- b->yy_input_file = 0; ++ b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + +- yy_switch_to_buffer(b ); ++ yy_switch_to_buffer( b ); + + return b; + } +@@ -1777,20 +1790,20 @@ + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +-YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) ++YY_BUFFER_STATE yy_scan_string (const char * yystr ) + { + +- return yy_scan_bytes(yystr,strlen(yystr) ); ++ return yy_scan_bytes( yystr, (int) strlen(yystr) ); + } + + /** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. +- * @param bytes the byte buffer to scan +- * @param len the number of bytes in the buffer pointed to by @a bytes. ++ * @param yybytes the byte buffer to scan ++ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +-YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) ++YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) + { + YY_BUFFER_STATE b; + char *buf; +@@ -1798,8 +1811,8 @@ + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ +- n = _yybytes_len + 2; +- buf = (char *) yyalloc(n ); ++ n = (yy_size_t) (_yybytes_len + 2); ++ buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + +@@ -1808,7 +1821,7 @@ + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + +- b = yy_scan_buffer(buf,n ); ++ b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + +@@ -1824,9 +1837,9 @@ + #define YY_EXIT_FAILURE 2 + #endif + +-static void yy_fatal_error (yyconst char* msg ) ++static void yynoreturn yy_fatal_error (const char* msg ) + { +- (void) fprintf( stderr, "%s\n", msg ); ++ fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + +@@ -1854,7 +1867,7 @@ + */ + int yyget_lineno (void) + { +- ++ + return yylineno; + } + +@@ -1892,29 +1905,29 @@ + } + + /** Set the current line number. +- * @param line_number ++ * @param _line_number line number + * + */ +-void yyset_lineno (int line_number ) ++void yyset_lineno (int _line_number ) + { + +- yylineno = line_number; ++ yylineno = _line_number; + } + + /** Set the input stream. This does not discard the current + * input buffer. +- * @param in_str A readable stream. ++ * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +-void yyset_in (FILE * in_str ) ++void yyset_in (FILE * _in_str ) + { +- yyin = in_str ; ++ yyin = _in_str ; + } + +-void yyset_out (FILE * out_str ) ++void yyset_out (FILE * _out_str ) + { +- yyout = out_str ; ++ yyout = _out_str ; + } + + int yyget_debug (void) +@@ -1922,9 +1935,9 @@ + return yy_flex_debug; + } + +-void yyset_debug (int bdebug ) ++void yyset_debug (int _bdebug ) + { +- yy_flex_debug = bdebug ; ++ yy_flex_debug = _bdebug ; + } + + static int yy_init_globals (void) +@@ -1933,10 +1946,10 @@ + * This function is called from yylex_destroy(), so don't allocate here. + */ + +- (yy_buffer_stack) = 0; ++ (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; +- (yy_c_buf_p) = (char *) 0; ++ (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +@@ -1945,8 +1958,8 @@ + yyin = stdin; + yyout = stdout; + #else +- yyin = (FILE *) 0; +- yyout = (FILE *) 0; ++ yyin = NULL; ++ yyout = NULL; + #endif + + /* For future reference: Set errno on error, since we are called by +@@ -1961,7 +1974,7 @@ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ +- yy_delete_buffer(YY_CURRENT_BUFFER ); ++ yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } +@@ -1982,18 +1995,19 @@ + */ + + #ifndef yytext_ptr +-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) ++static void yy_flex_strncpy (char* s1, const char * s2, int n ) + { +- register int i; ++ ++ int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } + #endif + + #ifdef YY_NEED_STRLEN +-static int yy_flex_strlen (yyconst char * s ) ++static int yy_flex_strlen (const char * s ) + { +- register int n; ++ int n; + for ( n = 0; s[n]; ++n ) + ; + +@@ -2003,11 +2017,12 @@ + + void *yyalloc (yy_size_t size ) + { +- return (void *) malloc( size ); ++ return malloc(size); + } + + void *yyrealloc (void * ptr, yy_size_t size ) + { ++ + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter +@@ -2015,12 +2030,12 @@ + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ +- return (void *) realloc( (char *) ptr, size ); ++ return realloc(ptr, size); + } + + void yyfree (void * ptr ) + { +- free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ ++ free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ + } + + #define YYTABLES_NAME "yytables" +diff -ru SDF-parse.c SDF-parse.c +--- SDF-parse.c 2014-06-04 07:22:26.000000000 +0200 ++++ SDF-parse.c 2025-03-09 08:10:56.549541070 +0100 +@@ -1,97 +1,26 @@ +-/* A Bison parser, made by GNU Bison 2.3. */ ++/* 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 2 ++#define YYMINOR 0 ++#define YYPATCH 20240109 ++ ++#define YYEMPTY (-1) ++#define yyclearin (yychar = YYEMPTY) ++#define yyerrok (yyerrflag = 0) ++#define YYRECOVERING() (yyerrflag != 0) ++#define YYENOMEM (-2) ++#define YYEOF 0 ++#undef YYBTYACC ++#define YYBTYACC 0 ++#define YYDEBUGSTR YYPREFIX "debug" ++#define YYPREFIX "yy" + +-/* Skeleton implementation for Bison's Yacc-like parsers in C +- +- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 +- Free Software Foundation, Inc. +- +- This program is free software; you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation; either version 2, or (at your option) +- any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License +- along with this program; if not, write to the Free Software +- Foundation, Inc., 51 Franklin Street, Fifth Floor, +- Boston, MA 02110-1301, USA. */ +- +-/* As a special exception, you may create a larger work that contains +- part or all of the Bison parser skeleton and distribute that work +- under terms of your choice, so long as that work isn't itself a +- parser generator using the skeleton or a modified version thereof +- as a parser skeleton. Alternatively, if you modify or redistribute +- the parser skeleton itself, you may (at your option) remove this +- special exception, which will cause the skeleton and the resulting +- Bison output files to be licensed under the GNU General Public +- License without this special exception. +- +- This special exception was added by the Free Software Foundation in +- version 2.2 of Bison. */ +- +-/* C LALR(1) parser skeleton written by Richard Stallman, by +- simplifying the original so-called "semantic" parser. */ +- +-/* All symbols defined below should begin with yy or YY, to avoid +- infringing on user name space. This should be done even for local +- variables, as they might otherwise be expanded by user macros. +- There are some unavoidable exceptions within include files to +- define necessary library symbols; they are noted "INFRINGES ON +- USER NAME SPACE" below. */ +- +-/* Identify Bison output. */ +-#define YYBISON 1 +- +-/* Bison version. */ +-#define YYBISON_VERSION "2.3" +- +-/* Skeleton name. */ +-#define YYSKELETON_NAME "yacc.c" +- +-/* Pure parsers. */ + #define YYPURE 0 + +-/* Using locations. */ +-#define YYLSP_NEEDED 0 +- +- +- +-/* Tokens. */ +-#ifndef YYTOKENTYPE +-# define YYTOKENTYPE +- /* Put the tokens into the symbol table, so that GDB and other debuggers +- know about them. */ +- enum yytokentype { +- STRUCT = 258, +- NAME = 259, +- TYPE = 260, +- CONST = 261, +- VALUEPARAM = 262, +- PARAMETER = 263, +- EOHDR = 264, +- LEXERROR = 265 +- }; +-#endif +-/* Tokens. */ +-#define STRUCT 258 +-#define NAME 259 +-#define TYPE 260 +-#define CONST 261 +-#define VALUEPARAM 262 +-#define PARAMETER 263 +-#define EOHDR 264 +-#define LEXERROR 265 +- +- +- +- +-/* Copy the first part of user declarations. */ +-#line 1 "SDF-parse.y" +- ++#line 2 "SDF-parse.y" + /* + SDF Library for reading Self-Describing Files + Copyright (C) 1991,1992 John K. Salmon +@@ -138,6 +67,8 @@ + #endif + extern void yyerror(char *fmt, ...); + ++extern int SDFyylex(); ++ + + static enum SDF_type_enum curtype; + static blk_descrip_t cur_blk; +@@ -160,30 +91,14 @@ + static const_t convert_const(const_t *cp, enum SDF_type_enum type); + static int finish_parse(void); + +- +- +-/* Enabling traces. */ +-#ifndef YYDEBUG +-# define YYDEBUG 0 +-#endif +- +-/* Enabling verbose error messages. */ +-#ifdef YYERROR_VERBOSE +-# undef YYERROR_VERBOSE +-# define YYERROR_VERBOSE 1 +-#else +-# define YYERROR_VERBOSE 0 +-#endif +- +-/* Enabling the token table. */ +-#ifndef YYTOKEN_TABLE +-# define YYTOKEN_TABLE 0 +-#endif +- +-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +-typedef union YYSTYPE +-#line 84 "SDF-parse.y" +-{ ++#ifdef YYSTYPE ++#undef YYSTYPE_IS_DECLARED ++#define YYSTYPE_IS_DECLARED 1 ++#endif ++#ifndef YYSTYPE_IS_DECLARED ++#define YYSTYPE_IS_DECLARED 1 ++#line 86 "SDF-parse.y" ++typedef union YYSTYPE{ + enum SDF_type_enum type; + enum value_param_enum valueparam; + char *string; +@@ -192,1617 +107,351 @@ + dcl_list_t dcl_list; + one_dcl_t one_dcl; + const_list_t const_list; +-} +-/* Line 187 of yacc.c. */ +-#line 198 "SDF-parse.c" +- YYSTYPE; +-# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +-# define YYSTYPE_IS_DECLARED 1 +-# define YYSTYPE_IS_TRIVIAL 1 +-#endif +- +- +- +-/* Copy the second part of user declarations. */ +- +- +-/* Line 216 of yacc.c. */ +-#line 211 "SDF-parse.c" +- +-#ifdef short +-# undef short +-#endif ++} YYSTYPE; ++#endif /* !YYSTYPE_IS_DECLARED */ ++#line 113 "SDF-parse.c" + +-#ifdef YYTYPE_UINT8 +-typedef YYTYPE_UINT8 yytype_uint8; +-#else +-typedef unsigned char yytype_uint8; +-#endif +- +-#ifdef YYTYPE_INT8 +-typedef YYTYPE_INT8 yytype_int8; +-#elif (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-typedef signed char yytype_int8; +-#else +-typedef short int yytype_int8; +-#endif +- +-#ifdef YYTYPE_UINT16 +-typedef YYTYPE_UINT16 yytype_uint16; +-#else +-typedef unsigned short int yytype_uint16; +-#endif +- +-#ifdef YYTYPE_INT16 +-typedef YYTYPE_INT16 yytype_int16; +-#else +-typedef short int yytype_int16; +-#endif +- +-#ifndef YYSIZE_T +-# ifdef __SIZE_TYPE__ +-# define YYSIZE_T __SIZE_TYPE__ +-# elif defined size_t +-# define YYSIZE_T size_t +-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-# include /* INFRINGES ON USER NAME SPACE */ +-# define YYSIZE_T size_t ++/* compatibility with bison */ ++#ifdef YYPARSE_PARAM ++/* compatibility with FreeBSD */ ++# ifdef YYPARSE_PARAM_TYPE ++# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) + # else +-# define YYSIZE_T unsigned int ++# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) + # endif +-#endif +- +-#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) +- +-#ifndef YY_ +-# if YYENABLE_NLS +-# if ENABLE_NLS +-# include /* INFRINGES ON USER NAME SPACE */ +-# define YY_(msgid) dgettext ("bison-runtime", msgid) +-# endif +-# endif +-# ifndef YY_ +-# define YY_(msgid) msgid +-# endif +-#endif +- +-/* Suppress unused-variable warnings by "using" E. */ +-#if ! defined lint || defined __GNUC__ +-# define YYUSE(e) ((void) (e)) + #else +-# define YYUSE(e) /* empty */ ++# define YYPARSE_DECL() yyparse(void) + #endif + +-/* Identity function, used to suppress warnings about constant conditions. */ +-#ifndef lint +-# define YYID(n) (n) +-#else +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static int +-YYID (int i) ++/* Parameters sent to lex. */ ++#ifdef YYLEX_PARAM ++# define YYLEX_DECL() yylex(void *YYLEX_PARAM) ++# define YYLEX yylex(YYLEX_PARAM) + #else +-static int +-YYID (i) +- int i; +-#endif +-{ +- return i; +-} ++# define YYLEX_DECL() yylex(void) ++# define YYLEX yylex() + #endif + +-#if ! defined yyoverflow || YYERROR_VERBOSE +- +-/* The parser invokes alloca or malloc; define the necessary symbols. */ +- +-# ifdef YYSTACK_USE_ALLOCA +-# if YYSTACK_USE_ALLOCA +-# ifdef __GNUC__ +-# define YYSTACK_ALLOC __builtin_alloca +-# elif defined __BUILTIN_VA_ARG_INCR +-# include /* INFRINGES ON USER NAME SPACE */ +-# elif defined _AIX +-# define YYSTACK_ALLOC __alloca +-# elif defined _MSC_VER +-# include /* INFRINGES ON USER NAME SPACE */ +-# define alloca _alloca +-# else +-# define YYSTACK_ALLOC alloca +-# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-# include /* INFRINGES ON USER NAME SPACE */ +-# ifndef _STDLIB_H +-# define _STDLIB_H 1 +-# endif +-# endif +-# endif +-# endif +-# endif +- +-# ifdef YYSTACK_ALLOC +- /* Pacify GCC's `empty if-body' warning. */ +-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +-# ifndef YYSTACK_ALLOC_MAXIMUM +- /* The OS might guarantee only one guard page at the bottom of the stack, +- and a page size can be as small as 4096 bytes. So we cannot safely +- invoke alloca (N) if N exceeds 4096. Use a slightly smaller number +- to allow for a few compiler-allocated temporary stack slots. */ +-# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +-# endif +-# else +-# define YYSTACK_ALLOC YYMALLOC +-# define YYSTACK_FREE YYFREE +-# ifndef YYSTACK_ALLOC_MAXIMUM +-# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +-# endif +-# if (defined __cplusplus && ! defined _STDLIB_H \ +- && ! ((defined YYMALLOC || defined malloc) \ +- && (defined YYFREE || defined free))) +-# include /* INFRINGES ON USER NAME SPACE */ +-# ifndef _STDLIB_H +-# define _STDLIB_H 1 +-# endif +-# endif +-# ifndef YYMALLOC +-# define YYMALLOC malloc +-# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +-# endif +-# endif +-# ifndef YYFREE +-# define YYFREE free +-# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-void free (void *); /* INFRINGES ON USER NAME SPACE */ +-# endif +-# endif +-# endif +-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ +- +- +-#if (! defined yyoverflow \ +- && (! defined __cplusplus \ +- || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) +- +-/* A type that is properly aligned for any stack member. */ +-union yyalloc +-{ +- yytype_int16 yyss; +- YYSTYPE yyvs; +- }; +- +-/* The size of the maximum gap between one aligned stack and the next. */ +-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) +- +-/* The size of an array large to enough to hold all stacks, each with +- N elements. */ +-# define YYSTACK_BYTES(N) \ +- ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ +- + YYSTACK_GAP_MAXIMUM) +- +-/* Copy COUNT objects from FROM to TO. The source and destination do +- not overlap. */ +-# ifndef YYCOPY +-# if defined __GNUC__ && 1 < __GNUC__ +-# define YYCOPY(To, From, Count) \ +- __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +-# else +-# define YYCOPY(To, From, Count) \ +- do \ +- { \ +- YYSIZE_T yyi; \ +- for (yyi = 0; yyi < (Count); yyi++) \ +- (To)[yyi] = (From)[yyi]; \ +- } \ +- while (YYID (0)) +-# endif +-# endif +- +-/* Relocate STACK from its old location to the new one. The +- local variables YYSIZE and YYSTACKSIZE give the old and new number of +- elements in the stack, and YYPTR gives the new location of the +- stack. Advance YYPTR to a properly aligned location for the next +- stack. */ +-# define YYSTACK_RELOCATE(Stack) \ +- do \ +- { \ +- YYSIZE_T yynewbytes; \ +- YYCOPY (&yyptr->Stack, Stack, yysize); \ +- Stack = &yyptr->Stack; \ +- yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ +- yyptr += yynewbytes / sizeof (*yyptr); \ +- } \ +- while (YYID (0)) +- ++#if !(defined(yylex) || defined(YYSTATE)) ++int YYLEX_DECL(); + #endif + +-/* YYFINAL -- State number of the termination state. */ +-#define YYFINAL 13 +-/* YYLAST -- Last index in YYTABLE. */ +-#define YYLAST 44 +- +-/* YYNTOKENS -- Number of terminals. */ +-#define YYNTOKENS 18 +-/* YYNNTS -- Number of nonterminals. */ +-#define YYNNTS 12 +-/* YYNRULES -- Number of rules. */ +-#define YYNRULES 26 +-/* YYNRULES -- Number of states. */ +-#define YYNSTATES 48 +- +-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +-#define YYUNDEFTOK 2 +-#define YYMAXUTOK 265 ++/* Parameters sent to yyerror. */ ++#ifndef YYERROR_DECL ++#define YYERROR_DECL() yyerror(const char *s) ++#endif ++#ifndef YYERROR_CALL ++#define YYERROR_CALL(msg) yyerror(msg) ++#endif + +-#define YYTRANSLATE(YYX) \ +- ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) ++extern int YYPARSE_DECL(); + +-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +-static const yytype_uint8 yytranslate[] = +-{ +- 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 17, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 11, +- 2, 12, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 13, 2, 14, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 15, 2, 16, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, +- 5, 6, 7, 8, 9, 10 ++#define STRUCT 257 ++#define NAME 258 ++#define TYPE 259 ++#define CONST 260 ++#define VALUEPARAM 261 ++#define PARAMETER 262 ++#define EOHDR 263 ++#define LEXERROR 264 ++#define YYERRCODE 256 ++typedef int YYINT; ++static const YYINT yylhs[] = { -1, ++ 0, 0, 0, 8, 8, 9, 9, 9, 1, 1, ++ 1, 1, 7, 7, 10, 6, 5, 5, 2, 2, ++ 2, 3, 3, 4, 4, + }; +- +-#if YYDEBUG +-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in +- YYRHS. */ +-static const yytype_uint8 yyprhs[] = +-{ +- 0, 0, 3, 5, 8, 10, 12, 15, 18, 23, +- 29, 31, 37, 46, 54, 56, 60, 61, 65, 67, +- 71, 73, 78, 82, 84, 88, 90 ++static const YYINT yylen[] = { 2, ++ 1, 2, 1, 1, 2, 2, 4, 5, 1, 5, ++ 8, 7, 1, 3, 0, 3, 1, 3, 1, 4, ++ 3, 1, 3, 1, 3, + }; +- +-/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +-static const yytype_int8 yyrhs[] = +-{ +- 19, 0, -1, 20, -1, 20, 9, -1, 10, -1, +- 21, -1, 20, 21, -1, 22, 11, -1, 22, 12, +- 28, 11, -1, 8, 7, 12, 6, 11, -1, 24, +- -1, 3, 15, 23, 11, 16, -1, 3, 15, 23, +- 11, 16, 13, 6, 14, -1, 3, 15, 23, 11, +- 16, 13, 14, -1, 24, -1, 23, 11, 24, -1, +- -1, 5, 25, 26, -1, 27, -1, 26, 17, 27, +- -1, 4, -1, 4, 13, 6, 14, -1, 4, 13, +- 14, -1, 6, -1, 15, 29, 16, -1, 6, -1, +- 29, 17, 6, -1 ++static const YYINT yydefred[] = { 0, ++ 0, 15, 0, 3, 0, 0, 9, 0, 4, 0, ++ 0, 0, 6, 0, 2, 5, 13, 0, 0, 17, ++ 0, 0, 22, 0, 0, 0, 0, 0, 0, 24, ++ 0, 7, 0, 14, 0, 21, 18, 8, 23, 0, ++ 0, 20, 25, 0, 12, 11, + }; +- +-/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +-static const yytype_uint8 yyrline[] = +-{ +- 0, 95, 95, 96, 97, 100, 101, 104, 105, 106, +- 109, 110, 111, 120, 124, 125, 137, 137, 140, 146, +- 154, 155, 164, 167, 173, 176, 182 ++#if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) ++static const YYINT yystos[] = { 0, ++ 257, 259, 262, 264, 266, 267, 272, 274, 275, 123, ++ 276, 261, 59, 61, 263, 275, 272, 273, 258, 268, ++ 271, 61, 260, 123, 269, 59, 91, 44, 260, 260, ++ 270, 59, 125, 272, 260, 93, 268, 59, 125, 44, ++ 91, 93, 260, 260, 93, 93, + }; +-#endif +- +-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. +- First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +-static const char *const yytname[] = +-{ +- "$end", "error", "$undefined", "STRUCT", "NAME", "TYPE", "CONST", +- "VALUEPARAM", "PARAMETER", "EOHDR", "LEXERROR", "';'", "'='", "'['", +- "']'", "'{'", "'}'", "','", "$accept", "hdr", "hdr1", "stmt", +- "declaration", "many_typed_dcl_list", "typed_dcl_list", "@1", +- "comma_sep_dcls", "dcl1", "const_lst", "comma_sep_consts", 0 +-}; +-#endif +- +-# ifdef YYPRINT +-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to +- token YYLEX-NUM. */ +-static const yytype_uint16 yytoknum[] = +-{ +- 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, +- 265, 59, 61, 91, 93, 123, 125, 44 ++#endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ ++static const YYINT yydgoto[] = { 5, ++ 6, 20, 25, 31, 21, 7, 18, 8, 9, 11, + }; +-# endif +- +-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +-static const yytype_uint8 yyr1[] = +-{ +- 0, 18, 19, 19, 19, 20, 20, 21, 21, 21, +- 22, 22, 22, 22, 23, 23, 25, 24, 26, 26, +- 27, 27, 27, 28, 28, 29, 29 ++static const YYINT yysindex[] = { -251, ++ -114, 0, -243, 0, 0, -42, 0, -247, 0, -245, ++ -237, -33, 0, -121, 0, 0, 0, -30, -61, 0, ++ -13, -228, 0, -227, -25, -122, -93, -237, -24, 0, ++ -40, 0, -55, 0, -56, 0, 0, 0, 0, -222, ++ -92, 0, 0, -54, 0, 0, + }; +- +-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +-static const yytype_uint8 yyr2[] = +-{ +- 0, 2, 1, 2, 1, 1, 2, 2, 4, 5, +- 1, 5, 8, 7, 1, 3, 0, 3, 1, 3, +- 1, 4, 3, 1, 3, 1, 3 ++static const YYINT yyrindex[] = { 0, ++ 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, -39, 0, ++ -35, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, -34, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, + }; +- +-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state +- STATE-NUM when YYTABLE doesn't specify something else to do. Zero +- means the default is an error. */ +-static const yytype_uint8 yydefact[] = +-{ +- 0, 0, 16, 0, 4, 0, 2, 5, 0, 10, +- 0, 0, 0, 1, 3, 6, 7, 0, 0, 14, +- 20, 17, 18, 0, 23, 0, 0, 0, 0, 0, +- 0, 25, 0, 8, 11, 15, 0, 22, 19, 9, +- 24, 0, 0, 21, 26, 0, 13, 12 ++#if YYBTYACC ++static const YYINT yycindex[] = { 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, + }; +- +-/* YYDEFGOTO[NTERM-NUM]. */ +-static const yytype_int8 yydefgoto[] = +-{ +- -1, 5, 6, 7, 8, 18, 9, 11, 21, 22, +- 26, 32 +-}; +- +-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing +- STATE-NUM. */ +-#define YYPACT_NINF -14 +-static const yytype_int8 yypact[] = +-{ +- 13, -13, -14, 2, -14, 5, 17, -14, 16, -14, +- 10, 6, 7, -14, -14, -14, -14, -2, 18, -14, +- 11, 14, -14, 24, -14, 26, 22, -4, -3, 6, +- 23, -14, -9, -14, 25, -14, 21, -14, -14, -14, +- -14, 30, 0, -14, -14, 27, -14, -14 +-}; +- +-/* YYPGOTO[NTERM-NUM]. */ +-static const yytype_int8 yypgoto[] = +-{ +- -14, -14, -14, 31, -14, -14, -10, -14, -14, 15, +- -14, -14 ++#endif ++static const YYINT yygindex[] = { 0, ++ 0, 13, 0, 0, 0, -3, 0, 0, 34, 0, + }; +- +-/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If +- positive, shift that token. If negative, reduce the rule which +- number is the opposite. If zero, do what YYDEFACT says. +- If YYTABLE_NINF, syntax error. */ +-#define YYTABLE_NINF -1 +-static const yytype_uint8 yytable[] = +-{ +- 19, 2, 10, 36, 24, 13, 45, 40, 41, 12, +- 20, 37, 34, 25, 46, 2, 1, 35, 2, 23, +- 1, 3, 2, 4, 28, 3, 14, 16, 17, 27, +- 30, 29, 31, 33, 39, 43, 44, 15, 42, 0, +- 0, 47, 0, 0, 38 ++#define YYTABLESIZE 168 ++static const YYINT yytable[] = { 36, ++ 45, 24, 33, 40, 19, 1, 17, 2, 10, 1, ++ 3, 2, 4, 2, 3, 15, 13, 12, 14, 19, ++ 19, 19, 34, 16, 10, 16, 10, 22, 26, 27, ++ 28, 29, 30, 32, 38, 41, 42, 43, 46, 1, ++ 37, 16, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 2, 0, 23, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 35, 44, + }; +- +-static const yytype_int8 yycheck[] = +-{ +- 10, 5, 15, 6, 6, 0, 6, 16, 17, 7, +- 4, 14, 16, 15, 14, 5, 3, 27, 5, 12, +- 3, 8, 5, 10, 13, 8, 9, 11, 12, 11, +- 6, 17, 6, 11, 11, 14, 6, 6, 13, -1, +- -1, 14, -1, -1, 29 ++static const YYINT yycheck[] = { 93, ++ 93, 123, 125, 44, 44, 257, 10, 259, 123, 257, ++ 262, 259, 264, 259, 262, 263, 59, 261, 61, 59, ++ 258, 61, 26, 59, 59, 61, 61, 61, 59, 91, ++ 44, 260, 260, 59, 59, 91, 93, 260, 93, 0, ++ 28, 8, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 125, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 259, -1, 260, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 260, 260, + }; +- +-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing +- symbol of state STATE-NUM. */ +-static const yytype_uint8 yystos[] = +-{ +- 0, 3, 5, 8, 10, 19, 20, 21, 22, 24, +- 15, 25, 7, 0, 9, 21, 11, 12, 23, 24, +- 4, 26, 27, 12, 6, 15, 28, 11, 13, 17, +- 6, 6, 29, 11, 16, 24, 6, 14, 27, 11, +- 16, 17, 13, 14, 6, 6, 14, 14 ++#if YYBTYACC ++static const YYINT yyctable[] = { -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, + }; +- +-#define yyerrok (yyerrstatus = 0) +-#define yyclearin (yychar = YYEMPTY) +-#define YYEMPTY (-2) +-#define YYEOF 0 +- +-#define YYACCEPT goto yyacceptlab +-#define YYABORT goto yyabortlab +-#define YYERROR goto yyerrorlab +- +- +-/* Like YYERROR except do call yyerror. This remains here temporarily +- to ease the transition to the new meaning of YYERROR, for GCC. +- Once GCC version 2 has supplanted version 1, this can go. */ +- +-#define YYFAIL goto yyerrlab +- +-#define YYRECOVERING() (!!yyerrstatus) +- +-#define YYBACKUP(Token, Value) \ +-do \ +- if (yychar == YYEMPTY && yylen == 1) \ +- { \ +- yychar = (Token); \ +- yylval = (Value); \ +- yytoken = YYTRANSLATE (yychar); \ +- YYPOPSTACK (1); \ +- goto yybackup; \ +- } \ +- else \ +- { \ +- yyerror (YY_("syntax error: cannot back up")); \ +- YYERROR; \ +- } \ +-while (YYID (0)) +- +- +-#define YYTERROR 1 +-#define YYERRCODE 256 +- +- +-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. +- If N is 0, then set CURRENT to the empty location which ends +- the previous symbol: RHS[0] (always defined). */ +- +-#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +-#ifndef YYLLOC_DEFAULT +-# define YYLLOC_DEFAULT(Current, Rhs, N) \ +- do \ +- if (YYID (N)) \ +- { \ +- (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ +- (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ +- (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ +- (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ +- } \ +- else \ +- { \ +- (Current).first_line = (Current).last_line = \ +- YYRHSLOC (Rhs, 0).last_line; \ +- (Current).first_column = (Current).last_column = \ +- YYRHSLOC (Rhs, 0).last_column; \ +- } \ +- while (YYID (0)) + #endif +- +- +-/* YY_LOCATION_PRINT -- Print the location on the stream. +- This macro was not mandated originally: define only if we know +- we won't break user code: when these are the locations we know. */ +- +-#ifndef YY_LOCATION_PRINT +-# if YYLTYPE_IS_TRIVIAL +-# define YY_LOCATION_PRINT(File, Loc) \ +- fprintf (File, "%d.%d-%d.%d", \ +- (Loc).first_line, (Loc).first_column, \ +- (Loc).last_line, (Loc).last_column) +-# else +-# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +-# endif +-#endif +- +- +-/* YYLEX -- calling `yylex' with the right arguments. */ +- +-#ifdef YYLEX_PARAM +-# define YYLEX yylex (YYLEX_PARAM) +-#else +-# define YYLEX yylex () ++#define YYFINAL 5 ++#ifndef YYDEBUG ++#define YYDEBUG 0 + #endif +- +-/* Enable debugging if requested. */ ++#define YYMAXTOKEN 264 ++#define YYUNDFTOKEN 277 ++#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) + #if YYDEBUG ++static const char *const yyname[] = { + +-# ifndef YYFPRINTF +-# include /* INFRINGES ON USER NAME SPACE */ +-# define YYFPRINTF fprintf +-# endif +- +-# define YYDPRINTF(Args) \ +-do { \ +- if (yydebug) \ +- YYFPRINTF Args; \ +-} while (YYID (0)) +- +-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +-do { \ +- if (yydebug) \ +- { \ +- YYFPRINTF (stderr, "%s ", Title); \ +- yy_symbol_print (stderr, \ +- Type, Value); \ +- YYFPRINTF (stderr, "\n"); \ +- } \ +-} while (YYID (0)) +- +- +-/*--------------------------------. +-| Print this symbol on YYOUTPUT. | +-`--------------------------------*/ +- +-/*ARGSUSED*/ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +-#else +-static void +-yy_symbol_value_print (yyoutput, yytype, yyvaluep) +- FILE *yyoutput; +- int yytype; +- YYSTYPE const * const yyvaluep; +-#endif +-{ +- if (!yyvaluep) +- return; +-# ifdef YYPRINT +- if (yytype < YYNTOKENS) +- YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +-# else +- YYUSE (yyoutput); +-# endif +- switch (yytype) +- { +- default: +- break; +- } +-} +- +- +-/*--------------------------------. +-| Print this symbol on YYOUTPUT. | +-`--------------------------------*/ +- +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +-#else +-static void +-yy_symbol_print (yyoutput, yytype, yyvaluep) +- FILE *yyoutput; +- int yytype; +- YYSTYPE const * const yyvaluep; +-#endif +-{ +- if (yytype < YYNTOKENS) +- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); +- else +- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); +- +- yy_symbol_value_print (yyoutput, yytype, yyvaluep); +- YYFPRINTF (yyoutput, ")"); +-} +- +-/*------------------------------------------------------------------. +-| yy_stack_print -- Print the state stack from its BOTTOM up to its | +-| TOP (included). | +-`------------------------------------------------------------------*/ +- +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) +-#else +-static void +-yy_stack_print (bottom, top) +- yytype_int16 *bottom; +- yytype_int16 *top; +-#endif +-{ +- YYFPRINTF (stderr, "Stack now"); +- for (; bottom <= top; ++bottom) +- YYFPRINTF (stderr, " %d", *bottom); +- YYFPRINTF (stderr, "\n"); +-} +- +-# define YY_STACK_PRINT(Bottom, Top) \ +-do { \ +- if (yydebug) \ +- yy_stack_print ((Bottom), (Top)); \ +-} while (YYID (0)) +- +- +-/*------------------------------------------------. +-| Report that the YYRULE is going to be reduced. | +-`------------------------------------------------*/ +- +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yy_reduce_print (YYSTYPE *yyvsp, int yyrule) +-#else +-static void +-yy_reduce_print (yyvsp, yyrule) +- YYSTYPE *yyvsp; +- int yyrule; +-#endif +-{ +- int yynrhs = yyr2[yyrule]; +- int yyi; +- unsigned long int yylno = yyrline[yyrule]; +- YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", +- yyrule - 1, yylno); +- /* The symbols being reduced. */ +- for (yyi = 0; yyi < yynrhs; yyi++) +- { +- fprintf (stderr, " $%d = ", yyi + 1); +- yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], +- &(yyvsp[(yyi + 1) - (yynrhs)]) +- ); +- fprintf (stderr, "\n"); +- } +-} +- +-# define YY_REDUCE_PRINT(Rule) \ +-do { \ +- if (yydebug) \ +- yy_reduce_print (yyvsp, Rule); \ +-} while (YYID (0)) +- +-/* Nonzero means print parse trace. It is left uninitialized so that +- multiple parsers can coexist. */ +-int yydebug; +-#else /* !YYDEBUG */ +-# define YYDPRINTF(Args) +-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +-# define YY_STACK_PRINT(Bottom, Top) +-# define YY_REDUCE_PRINT(Rule) +-#endif /* !YYDEBUG */ +- +- +-/* YYINITDEPTH -- initial size of the parser's stacks. */ +-#ifndef YYINITDEPTH +-# define YYINITDEPTH 200 +-#endif +- +-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only +- if the built-in stack extension method is used). +- +- Do not make this value too large; the results are undefined if +- YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) +- evaluated with infinite-precision integer arithmetic. */ +- +-#ifndef YYMAXDEPTH +-# define YYMAXDEPTH 10000 +-#endif +- +- +- +-#if YYERROR_VERBOSE +- +-# ifndef yystrlen +-# if defined __GLIBC__ && defined _STRING_H +-# define yystrlen strlen +-# else +-/* Return the length of YYSTR. */ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static YYSIZE_T +-yystrlen (const char *yystr) +-#else +-static YYSIZE_T +-yystrlen (yystr) +- const char *yystr; +-#endif +-{ +- YYSIZE_T yylen; +- for (yylen = 0; yystr[yylen]; yylen++) +- continue; +- return yylen; +-} +-# endif +-# endif +- +-# ifndef yystpcpy +-# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +-# define yystpcpy stpcpy +-# else +-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in +- YYDEST. */ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static char * +-yystpcpy (char *yydest, const char *yysrc) +-#else +-static char * +-yystpcpy (yydest, yysrc) +- char *yydest; +- const char *yysrc; +-#endif +-{ +- char *yyd = yydest; +- const char *yys = yysrc; +- +- while ((*yyd++ = *yys++) != '\0') +- continue; +- +- return yyd - 1; +-} +-# endif +-# endif +- +-# ifndef yytnamerr +-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary +- quotes and backslashes, so that it's suitable for yyerror. The +- heuristic is that double-quoting is unnecessary unless the string +- contains an apostrophe, a comma, or backslash (other than +- backslash-backslash). YYSTR is taken from yytname. If YYRES is +- null, do not copy; instead, return the length of what the result +- would have been. */ +-static YYSIZE_T +-yytnamerr (char *yyres, const char *yystr) +-{ +- if (*yystr == '"') +- { +- YYSIZE_T yyn = 0; +- char const *yyp = yystr; +- +- for (;;) +- switch (*++yyp) +- { +- case '\'': +- case ',': +- goto do_not_strip_quotes; +- +- case '\\': +- if (*++yyp != '\\') +- goto do_not_strip_quotes; +- /* Fall through. */ +- default: +- if (yyres) +- yyres[yyn] = *yyp; +- yyn++; +- break; +- +- case '"': +- if (yyres) +- yyres[yyn] = '\0'; +- return yyn; +- } +- do_not_strip_quotes: ; +- } +- +- if (! yyres) +- return yystrlen (yystr); +- +- return yystpcpy (yyres, yystr) - yyres; +-} +-# endif +- +-/* Copy into YYRESULT an error message about the unexpected token +- YYCHAR while in state YYSTATE. Return the number of bytes copied, +- including the terminating null byte. If YYRESULT is null, do not +- copy anything; just return the number of bytes that would be +- copied. As a special case, return 0 if an ordinary "syntax error" +- message will do. Return YYSIZE_MAXIMUM if overflow occurs during +- size calculation. */ +-static YYSIZE_T +-yysyntax_error (char *yyresult, int yystate, int yychar) +-{ +- int yyn = yypact[yystate]; +- +- if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) +- return 0; +- else +- { +- int yytype = YYTRANSLATE (yychar); +- YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); +- YYSIZE_T yysize = yysize0; +- YYSIZE_T yysize1; +- int yysize_overflow = 0; +- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; +- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; +- int yyx; +- +-# if 0 +- /* This is so xgettext sees the translatable formats that are +- constructed on the fly. */ +- YY_("syntax error, unexpected %s"); +- YY_("syntax error, unexpected %s, expecting %s"); +- YY_("syntax error, unexpected %s, expecting %s or %s"); +- YY_("syntax error, unexpected %s, expecting %s or %s or %s"); +- YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +-# endif +- char *yyfmt; +- char const *yyf; +- static char const yyunexpected[] = "syntax error, unexpected %s"; +- static char const yyexpecting[] = ", expecting %s"; +- static char const yyor[] = " or %s"; +- char yyformat[sizeof yyunexpected +- + sizeof yyexpecting - 1 +- + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) +- * (sizeof yyor - 1))]; +- char const *yyprefix = yyexpecting; +- +- /* Start YYX at -YYN if negative to avoid negative indexes in +- YYCHECK. */ +- int yyxbegin = yyn < 0 ? -yyn : 0; +- +- /* Stay within bounds of both yycheck and yytname. */ +- int yychecklim = YYLAST - yyn + 1; +- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; +- int yycount = 1; +- +- yyarg[0] = yytname[yytype]; +- yyfmt = yystpcpy (yyformat, yyunexpected); +- +- for (yyx = yyxbegin; yyx < yyxend; ++yyx) +- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) +- { +- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) +- { +- yycount = 1; +- yysize = yysize0; +- yyformat[sizeof yyunexpected - 1] = '\0'; +- break; +- } +- yyarg[yycount++] = yytname[yyx]; +- yysize1 = yysize + yytnamerr (0, yytname[yyx]); +- yysize_overflow |= (yysize1 < yysize); +- yysize = yysize1; +- yyfmt = yystpcpy (yyfmt, yyprefix); +- yyprefix = yyor; +- } +- +- yyf = YY_(yyformat); +- yysize1 = yysize + yystrlen (yyf); +- yysize_overflow |= (yysize1 < yysize); +- yysize = yysize1; +- +- if (yysize_overflow) +- return YYSIZE_MAXIMUM; +- +- if (yyresult) +- { +- /* Avoid sprintf, as that infringes on the user's name space. +- Don't have undefined behavior even if the translation +- produced a string with the wrong number of "%s"s. */ +- char *yyp = yyresult; +- int yyi = 0; +- while ((*yyp = *yyf) != '\0') +- { +- if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) +- { +- yyp += yytnamerr (yyp, yyarg[yyi++]); +- yyf += 2; +- } +- else +- { +- yyp++; +- yyf++; +- } +- } +- } +- return yysize; +- } +-} +-#endif /* YYERROR_VERBOSE */ +- +- +-/*-----------------------------------------------. +-| Release the memory associated to this symbol. | +-`-----------------------------------------------*/ +- +-/*ARGSUSED*/ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +-#else +-static void +-yydestruct (yymsg, yytype, yyvaluep) +- const char *yymsg; +- int yytype; +- YYSTYPE *yyvaluep; +-#endif +-{ +- YYUSE (yyvaluep); +- +- if (!yymsg) +- yymsg = "Deleting"; +- YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); +- +- switch (yytype) +- { +- +- default: +- break; +- } +-} +- +- +-/* Prevent warnings from -Wmissing-prototypes. */ +- +-#ifdef YYPARSE_PARAM +-#if defined __STDC__ || defined __cplusplus +-int yyparse (void *YYPARSE_PARAM); +-#else +-int yyparse (); +-#endif +-#else /* ! YYPARSE_PARAM */ +-#if defined __STDC__ || defined __cplusplus +-int yyparse (void); +-#else +-int yyparse (); +-#endif +-#endif /* ! YYPARSE_PARAM */ +- +- +- +-/* The look-ahead symbol. */ +-int yychar; +- +-/* The semantic value of the look-ahead symbol. */ +-YYSTYPE yylval; +- +-/* Number of syntax errors so far. */ +-int yynerrs; +- +- +- +-/*----------. +-| yyparse. | +-`----------*/ ++"$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, ++0,0,0,0,0,0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,"';'",0,"'='",0,0,0,0,0,0,0,0,0, ++0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'['",0,"']'",0,0,0,0,0,0,0,0,0,0,0,0,0, ++0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, ++0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, ++0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, ++0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"error", ++"STRUCT","NAME","TYPE","CONST","VALUEPARAM","PARAMETER","EOHDR","LEXERROR", ++"$accept","hdr","declaration","dcl1","const_lst","comma_sep_consts", ++"comma_sep_dcls","typed_dcl_list","many_typed_dcl_list","hdr1","stmt","$$1", ++"illegal-symbol", ++}; ++static const char *const yyrule[] = { ++"$accept : hdr", ++"hdr : hdr1", ++"hdr : hdr1 EOHDR", ++"hdr : LEXERROR", ++"hdr1 : stmt", ++"hdr1 : hdr1 stmt", ++"stmt : declaration ';'", ++"stmt : declaration '=' const_lst ';'", ++"stmt : PARAMETER VALUEPARAM '=' CONST ';'", ++"declaration : typed_dcl_list", ++"declaration : STRUCT '{' many_typed_dcl_list ';' '}'", ++"declaration : STRUCT '{' many_typed_dcl_list ';' '}' '[' CONST ']'", ++"declaration : STRUCT '{' many_typed_dcl_list ';' '}' '[' ']'", ++"many_typed_dcl_list : typed_dcl_list", ++"many_typed_dcl_list : many_typed_dcl_list ';' typed_dcl_list", ++"$$1 :", ++"typed_dcl_list : TYPE $$1 comma_sep_dcls", ++"comma_sep_dcls : dcl1", ++"comma_sep_dcls : comma_sep_dcls ',' dcl1", ++"dcl1 : NAME", ++"dcl1 : NAME '[' CONST ']'", ++"dcl1 : NAME '[' ']'", ++"const_lst : CONST", ++"const_lst : '{' comma_sep_consts '}'", ++"comma_sep_consts : CONST", ++"comma_sep_consts : comma_sep_consts ',' CONST", + +-#ifdef YYPARSE_PARAM +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-int +-yyparse (void *YYPARSE_PARAM) +-#else +-int +-yyparse (YYPARSE_PARAM) +- void *YYPARSE_PARAM; ++}; + #endif +-#else /* ! YYPARSE_PARAM */ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-int +-yyparse (void) +-#else +-int +-yyparse () + ++#if YYDEBUG ++int yydebug; + #endif +-#endif +-{ +- +- int yystate; +- int yyn; +- int yyresult; +- /* Number of tokens to shift before error messages enabled. */ +- int yyerrstatus; +- /* Look-ahead token as an internal (translated) token number. */ +- int yytoken = 0; +-#if YYERROR_VERBOSE +- /* Buffer for error messages, and its allocated size. */ +- char yymsgbuf[128]; +- char *yymsg = yymsgbuf; +- YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +-#endif +- +- /* Three stacks and their tools: +- `yyss': related to states, +- `yyvs': related to semantic values, +- `yyls': related to locations. +- +- Refer to the stacks thru separate pointers, to allow yyoverflow +- to reallocate them elsewhere. */ +- +- /* The state stack. */ +- yytype_int16 yyssa[YYINITDEPTH]; +- yytype_int16 *yyss = yyssa; +- yytype_int16 *yyssp; +- +- /* The semantic value stack. */ +- YYSTYPE yyvsa[YYINITDEPTH]; +- YYSTYPE *yyvs = yyvsa; +- YYSTYPE *yyvsp; +- +- +- +-#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) +- +- YYSIZE_T yystacksize = YYINITDEPTH; +- +- /* The variables used to return semantic value and location from the +- action routines. */ +- YYSTYPE yyval; +- +- +- /* The number of symbols on the RHS of the reduced rule. +- Keep to zero when no symbol should be popped. */ +- int yylen = 0; + +- YYDPRINTF ((stderr, "Starting parse\n")); ++int yyerrflag; ++int yychar; ++YYSTYPE yyval; ++YYSTYPE yylval; ++int yynerrs; + +- yystate = 0; +- yyerrstatus = 0; +- yynerrs = 0; +- yychar = YYEMPTY; /* Cause a token to be read. */ +- +- /* Initialize stack pointers. +- Waste one element of value and location stack +- so that they stay on the same level as the state stack. +- The wasted elements are never initialized. */ +- +- yyssp = yyss; +- yyvsp = yyvs; +- +- goto yysetstate; +- +-/*------------------------------------------------------------. +-| yynewstate -- Push a new state, which is found in yystate. | +-`------------------------------------------------------------*/ +- yynewstate: +- /* In all cases, when you get here, the value and location stacks +- have just been pushed. So pushing a state here evens the stacks. */ +- yyssp++; +- +- yysetstate: +- *yyssp = yystate; +- +- if (yyss + yystacksize - 1 <= yyssp) +- { +- /* Get the current used size of the three stacks, in elements. */ +- YYSIZE_T yysize = yyssp - yyss + 1; +- +-#ifdef yyoverflow +- { +- /* Give user a chance to reallocate the stack. Use copies of +- these so that the &'s don't force the real ones into +- memory. */ +- YYSTYPE *yyvs1 = yyvs; +- yytype_int16 *yyss1 = yyss; +- +- +- /* Each stack pointer address is followed by the size of the +- data in use in that stack, in bytes. This used to be a +- conditional around just the two extra args, but that might +- be undefined if yyoverflow is a macro. */ +- yyoverflow (YY_("memory exhausted"), +- &yyss1, yysize * sizeof (*yyssp), +- &yyvs1, yysize * sizeof (*yyvsp), +- +- &yystacksize); +- +- yyss = yyss1; +- yyvs = yyvs1; +- } +-#else /* no yyoverflow */ +-# ifndef YYSTACK_RELOCATE +- goto yyexhaustedlab; +-# else +- /* Extend the stack our own way. */ +- if (YYMAXDEPTH <= yystacksize) +- goto yyexhaustedlab; +- yystacksize *= 2; +- if (YYMAXDEPTH < yystacksize) +- yystacksize = YYMAXDEPTH; +- +- { +- yytype_int16 *yyss1 = yyss; +- union yyalloc *yyptr = +- (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); +- if (! yyptr) +- goto yyexhaustedlab; +- YYSTACK_RELOCATE (yyss); +- YYSTACK_RELOCATE (yyvs); +- +-# undef YYSTACK_RELOCATE +- if (yyss1 != yyssa) +- YYSTACK_FREE (yyss1); +- } +-# endif +-#endif /* no yyoverflow */ +- +- yyssp = yyss + yysize - 1; +- yyvsp = yyvs + yysize - 1; +- +- +- YYDPRINTF ((stderr, "Stack size increased to %lu\n", +- (unsigned long int) yystacksize)); +- +- if (yyss + yystacksize - 1 <= yyssp) +- YYABORT; +- } +- +- YYDPRINTF ((stderr, "Entering state %d\n", yystate)); +- +- goto yybackup; +- +-/*-----------. +-| yybackup. | +-`-----------*/ +-yybackup: +- +- /* Do appropriate processing given the current state. Read a +- look-ahead token if we need one and don't already have one. */ +- +- /* First try to decide what to do without reference to look-ahead token. */ +- yyn = yypact[yystate]; +- if (yyn == YYPACT_NINF) +- goto yydefault; +- +- /* Not known => get a look-ahead token if don't already have one. */ +- +- /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ +- if (yychar == YYEMPTY) +- { +- YYDPRINTF ((stderr, "Reading a token: ")); +- yychar = YYLEX; +- } +- +- if (yychar <= YYEOF) +- { +- yychar = yytoken = YYEOF; +- YYDPRINTF ((stderr, "Now at end of input.\n")); +- } +- else +- { +- yytoken = YYTRANSLATE (yychar); +- YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); +- } +- +- /* If the proper action on seeing token YYTOKEN is to reduce or to +- detect an error, take that action. */ +- yyn += yytoken; +- if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) +- goto yydefault; +- yyn = yytable[yyn]; +- if (yyn <= 0) +- { +- if (yyn == 0 || yyn == YYTABLE_NINF) +- goto yyerrlab; +- yyn = -yyn; +- goto yyreduce; +- } +- +- if (yyn == YYFINAL) +- YYACCEPT; +- +- /* Count tokens shifted since error; after three, turn off error +- status. */ +- if (yyerrstatus) +- yyerrstatus--; +- +- /* Shift the look-ahead token. */ +- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); +- +- /* Discard the shifted token unless it is eof. */ +- if (yychar != YYEOF) +- yychar = YYEMPTY; +- +- yystate = yyn; +- *++yyvsp = yylval; +- +- goto yynewstate; +- +- +-/*-----------------------------------------------------------. +-| yydefault -- do the default action for the current state. | +-`-----------------------------------------------------------*/ +-yydefault: +- yyn = yydefact[yystate]; +- if (yyn == 0) +- goto yyerrlab; +- goto yyreduce; +- +- +-/*-----------------------------. +-| yyreduce -- Do a reduction. | +-`-----------------------------*/ +-yyreduce: +- /* yyn is the number of a rule to reduce with. */ +- yylen = yyr2[yyn]; +- +- /* If YYLEN is nonzero, implement the default value of the action: +- `$$ = $1'. +- +- Otherwise, the following line sets YYVAL to garbage. +- This behavior is undocumented and Bison +- users should not rely upon it. Assigning to YYVAL +- unconditionally makes the parser a bit smaller, and it avoids a +- GCC warning that YYVAL may be used uninitialized. */ +- yyval = yyvsp[1-yylen]; +- +- +- YY_REDUCE_PRINT (yyn); +- switch (yyn) +- { +- case 2: +-#line 95 "SDF-parse.y" +- {if(finish_parse()) YYERROR;} +- break; +- +- case 3: +-#line 96 "SDF-parse.y" +- {if(finish_parse()) YYERROR; else YYACCEPT;} +- break; +- +- case 4: +-#line 97 "SDF-parse.y" +- {YYERROR;} +- break; +- +- case 7: +-#line 104 "SDF-parse.y" +- {if(data_dcl((yyvsp[(1) - (2)].declaration))) YYERROR;} +- break; +- +- case 8: +-#line 105 "SDF-parse.y" +- {if(const_dcl((yyvsp[(1) - (4)].declaration), (yyvsp[(3) - (4)].const_list))) YYERROR;} +- break; +- +- case 9: +-#line 106 "SDF-parse.y" +- {if(do_value_param((yyvsp[(2) - (5)].valueparam), (yyvsp[(4) - (5)].constant))) YYERROR;} +- break; +- +- case 10: +-#line 109 "SDF-parse.y" +- {(yyval.declaration).dcl_list = (yyvsp[(1) - (1)].dcl_list); (yyval.declaration).Nrec = 1;} +- break; +- +- case 11: +-#line 110 "SDF-parse.y" +- {(yyval.declaration).dcl_list=(yyvsp[(3) - (5)].dcl_list); (yyval.declaration).Nrec=1;} +- break; +- +- case 12: +-#line 112 "SDF-parse.y" +- { +- if( (yyvsp[(7) - (8)].constant).type != SDF_INT64 ){ +- yyerror("Expected integer constant"); +- YYERROR; +- }else{ +- (yyval.declaration).dcl_list = (yyvsp[(3) - (8)].dcl_list); (yyval.declaration).Nrec = (yyvsp[(7) - (8)].constant).u.int64val; +- } +- } +- break; +- +- case 13: +-#line 121 "SDF-parse.y" +- { (yyval.declaration).dcl_list = (yyvsp[(3) - (7)].dcl_list); (yyval.declaration).Nrec = 0;} +- break; +- +- case 14: +-#line 124 "SDF-parse.y" +- {(yyval.dcl_list) = (yyvsp[(1) - (1)].dcl_list);} +- break; +- +- case 15: +-#line 126 "SDF-parse.y" +- { +- int sz; +- +- (yyval.dcl_list).ndcl = (yyvsp[(1) - (3)].dcl_list).ndcl + (yyvsp[(3) - (3)].dcl_list).ndcl; +- (yyval.dcl_list).obs = (yyvsp[(1) - (3)].dcl_list).obs; +- sz = obstack_object_size(&(yyvsp[(3) - (3)].dcl_list).obs); +- (void)obstack_grow(&(yyval.dcl_list).obs, obstack_finish(&(yyvsp[(3) - (3)].dcl_list).obs), sz); +- (void)obstack_free(&(yyvsp[(3) - (3)].dcl_list).obs, NULL); +- } +- break; +- +- case 16: +-#line 137 "SDF-parse.y" +- {curtype = (yyvsp[(1) - (1)].type);} +- break; +- +- case 17: +-#line 137 "SDF-parse.y" +- {(yyval.dcl_list) = (yyvsp[(3) - (3)].dcl_list);} +- break; +- +- case 18: +-#line 141 "SDF-parse.y" +- { +- obstack_begin(&(yyval.dcl_list).obs, 16*sizeof((yyvsp[(1) - (1)].one_dcl))); +- (yyval.dcl_list).ndcl = 1; +- (void)obstack_grow(&(yyval.dcl_list).obs, &(yyvsp[(1) - (1)].one_dcl), sizeof((yyvsp[(1) - (1)].one_dcl))); +- } +- break; +- +- case 19: +-#line 147 "SDF-parse.y" +- { +- (yyval.dcl_list) = (yyvsp[(1) - (3)].dcl_list); +- (yyval.dcl_list).ndcl += 1; +- (void)obstack_grow(&(yyval.dcl_list).obs, &(yyvsp[(3) - (3)].one_dcl), sizeof((yyvsp[(3) - (3)].one_dcl))); +- } +- break; +- +- case 20: +-#line 154 "SDF-parse.y" +- {(yyval.one_dcl).name = (yyvsp[(1) - (1)].string); (yyval.one_dcl).type = curtype; (yyval.one_dcl).arrcnt = 1;} +- break; +- +- case 21: +-#line 156 "SDF-parse.y" +- { +- if( (yyvsp[(3) - (4)].constant).type != SDF_INT64 ){ +- yyerror("Expected integer constant"); +- YYERROR; +- }else{ +- (yyval.one_dcl).name = (yyvsp[(1) - (4)].string); (yyval.one_dcl).type = curtype; (yyval.one_dcl).arrcnt = (yyvsp[(3) - (4)].constant).u.int64val; +- } +- } +- break; +- +- case 22: +-#line 164 "SDF-parse.y" +- {(yyval.one_dcl).name=(yyvsp[(1) - (3)].string); (yyval.one_dcl).type=curtype; (yyval.one_dcl).arrcnt = 0;} +- break; +- +- case 23: +-#line 168 "SDF-parse.y" +- { +- (yyval.const_list).nconst = 1; +- obstack_begin(&(yyval.const_list).obs, 16*sizeof((yyvsp[(1) - (1)].constant))); +- (void)obstack_grow(&(yyval.const_list).obs, &(yyvsp[(1) - (1)].constant), sizeof((yyvsp[(1) - (1)].constant))); +- } +- break; +- +- case 24: +-#line 173 "SDF-parse.y" +- {(yyval.const_list) = (yyvsp[(2) - (3)].const_list);} +- break; +- +- case 25: +-#line 177 "SDF-parse.y" +- { +- (yyval.const_list).nconst = 1; +- obstack_begin(&(yyval.const_list).obs, 16*sizeof((yyvsp[(1) - (1)].constant))); +- (void)obstack_grow(&(yyval.const_list).obs, &(yyvsp[(1) - (1)].constant), sizeof((yyvsp[(1) - (1)].constant))); +- } +- break; +- +- case 26: +-#line 183 "SDF-parse.y" +- { +- (yyval.const_list) = (yyvsp[(1) - (3)].const_list); +- (yyval.const_list).nconst += 1; +- (void)obstack_grow(&(yyval.const_list).obs, &(yyvsp[(3) - (3)].constant), sizeof((yyvsp[(3) - (3)].constant))); +- } +- break; +- +- +-/* Line 1267 of yacc.c. */ +-#line 1591 "SDF-parse.c" +- default: break; +- } +- YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); +- +- YYPOPSTACK (yylen); +- yylen = 0; +- YY_STACK_PRINT (yyss, yyssp); +- +- *++yyvsp = yyval; +- +- +- /* Now `shift' the result of the reduction. Determine what state +- that goes to, based on the state we popped back to and the rule +- number reduced by. */ +- +- yyn = yyr1[yyn]; +- +- yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; +- if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) +- yystate = yytable[yystate]; +- else +- yystate = yydefgoto[yyn - YYNTOKENS]; +- +- goto yynewstate; +- +- +-/*------------------------------------. +-| yyerrlab -- here on detecting error | +-`------------------------------------*/ +-yyerrlab: +- /* If not already recovering from an error, report this error. */ +- if (!yyerrstatus) +- { +- ++yynerrs; +-#if ! YYERROR_VERBOSE +- yyerror (YY_("syntax error")); +-#else +- { +- YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); +- if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) +- { +- YYSIZE_T yyalloc = 2 * yysize; +- if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) +- yyalloc = YYSTACK_ALLOC_MAXIMUM; +- if (yymsg != yymsgbuf) +- YYSTACK_FREE (yymsg); +- yymsg = (char *) YYSTACK_ALLOC (yyalloc); +- if (yymsg) +- yymsg_alloc = yyalloc; +- else +- { +- yymsg = yymsgbuf; +- yymsg_alloc = sizeof yymsgbuf; +- } +- } +- +- if (0 < yysize && yysize <= yymsg_alloc) +- { +- (void) yysyntax_error (yymsg, yystate, yychar); +- yyerror (yymsg); +- } +- else +- { +- yyerror (YY_("syntax error")); +- if (yysize != 0) +- goto yyexhaustedlab; +- } +- } ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++YYLTYPE yyloc; /* position returned by actions */ ++YYLTYPE yylloc; /* position from the lexer */ + #endif +- } +- +- +- +- if (yyerrstatus == 3) +- { +- /* If just tried and failed to reuse look-ahead token after an +- error, discard it. */ +- +- if (yychar <= YYEOF) +- { +- /* Return failure if at end of input. */ +- if (yychar == YYEOF) +- YYABORT; +- } +- else +- { +- yydestruct ("Error: discarding", +- yytoken, &yylval); +- yychar = YYEMPTY; +- } +- } +- +- /* Else will try to reuse look-ahead token after shifting the error +- token. */ +- goto yyerrlab1; +- + +-/*---------------------------------------------------. +-| yyerrorlab -- error raised explicitly by YYERROR. | +-`---------------------------------------------------*/ +-yyerrorlab: +- +- /* Pacify compilers like GCC when the user code never invokes +- YYERROR and the label yyerrorlab therefore never appears in user +- code. */ +- if (/*CONSTCOND*/ 0) +- goto yyerrorlab; +- +- /* Do not reclaim the symbols of the rule which action triggered +- this YYERROR. */ +- YYPOPSTACK (yylen); +- yylen = 0; +- YY_STACK_PRINT (yyss, yyssp); +- yystate = *yyssp; +- goto yyerrlab1; +- +- +-/*-------------------------------------------------------------. +-| yyerrlab1 -- common code for both syntax error and YYERROR. | +-`-------------------------------------------------------------*/ +-yyerrlab1: +- yyerrstatus = 3; /* Each real token shifted decrements this. */ +- +- for (;;) +- { +- yyn = yypact[yystate]; +- if (yyn != YYPACT_NINF) +- { +- yyn += YYTERROR; +- if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) +- { +- yyn = yytable[yyn]; +- if (0 < yyn) +- break; +- } +- } +- +- /* Pop the current state because it cannot handle the error token. */ +- if (yyssp == yyss) +- YYABORT; +- +- +- yydestruct ("Error: popping", +- yystos[yystate], yyvsp); +- YYPOPSTACK (1); +- yystate = *yyssp; +- YY_STACK_PRINT (yyss, yyssp); +- } ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++#ifndef YYLLOC_DEFAULT ++#define YYLLOC_DEFAULT(loc, rhs, n) \ ++do \ ++{ \ ++ if (n == 0) \ ++ { \ ++ (loc).first_line = YYRHSLOC(rhs, 0).last_line; \ ++ (loc).first_column = YYRHSLOC(rhs, 0).last_column; \ ++ (loc).last_line = YYRHSLOC(rhs, 0).last_line; \ ++ (loc).last_column = YYRHSLOC(rhs, 0).last_column; \ ++ } \ ++ else \ ++ { \ ++ (loc).first_line = YYRHSLOC(rhs, 1).first_line; \ ++ (loc).first_column = YYRHSLOC(rhs, 1).first_column; \ ++ (loc).last_line = YYRHSLOC(rhs, n).last_line; \ ++ (loc).last_column = YYRHSLOC(rhs, n).last_column; \ ++ } \ ++} while (0) ++#endif /* YYLLOC_DEFAULT */ ++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ ++#if YYBTYACC ++ ++#ifndef YYLVQUEUEGROWTH ++#define YYLVQUEUEGROWTH 32 ++#endif ++#endif /* YYBTYACC */ ++ ++/* 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 ++ ++#ifndef YYINITSTACKSIZE ++#define YYINITSTACKSIZE 200 ++#endif ++ ++typedef struct { ++ unsigned stacksize; ++ YYINT *s_base; ++ YYINT *s_mark; ++ YYINT *s_last; ++ YYSTYPE *l_base; ++ YYSTYPE *l_mark; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ YYLTYPE *p_base; ++ YYLTYPE *p_mark; ++#endif ++} YYSTACKDATA; ++#if YYBTYACC ++ ++struct YYParseState_s ++{ ++ struct YYParseState_s *save; /* Previously saved parser state */ ++ YYSTACKDATA yystack; /* saved parser stack */ ++ int state; /* saved parser state */ ++ int errflag; /* saved error recovery status */ ++ int lexeme; /* saved index of the conflict lexeme in the lexical queue */ ++ YYINT ctry; /* saved index in yyctable[] for this conflict */ ++}; ++typedef struct YYParseState_s YYParseState; ++#endif /* YYBTYACC */ ++/* variables for the parser stack */ ++static YYSTACKDATA yystack; ++#if YYBTYACC + +- if (yyn == YYFINAL) +- YYACCEPT; ++/* Current parser state */ ++static YYParseState *yyps = 0; + +- *++yyvsp = yylval; ++/* yypath != NULL: do the full parse, starting at *yypath parser state. */ ++static YYParseState *yypath = 0; + ++/* Base of the lexical value queue */ ++static YYSTYPE *yylvals = 0; + +- /* Shift the error token. */ +- YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); ++/* Current position at lexical value queue */ ++static YYSTYPE *yylvp = 0; + +- yystate = yyn; +- goto yynewstate; ++/* End position of lexical value queue */ ++static YYSTYPE *yylve = 0; + ++/* The last allocated position at the lexical value queue */ ++static YYSTYPE *yylvlim = 0; + +-/*-------------------------------------. +-| yyacceptlab -- YYACCEPT comes here. | +-`-------------------------------------*/ +-yyacceptlab: +- yyresult = 0; +- goto yyreturn; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++/* Base of the lexical position queue */ ++static YYLTYPE *yylpsns = 0; + +-/*-----------------------------------. +-| yyabortlab -- YYABORT comes here. | +-`-----------------------------------*/ +-yyabortlab: +- yyresult = 1; +- goto yyreturn; ++/* Current position at lexical position queue */ ++static YYLTYPE *yylpp = 0; + +-#ifndef yyoverflow +-/*-------------------------------------------------. +-| yyexhaustedlab -- memory exhaustion comes here. | +-`-------------------------------------------------*/ +-yyexhaustedlab: +- yyerror (YY_("memory exhausted")); +- yyresult = 2; +- /* Fall through. */ +-#endif ++/* End position of lexical position queue */ ++static YYLTYPE *yylpe = 0; + +-yyreturn: +- if (yychar != YYEOF && yychar != YYEMPTY) +- yydestruct ("Cleanup: discarding lookahead", +- yytoken, &yylval); +- /* Do not reclaim the symbols of the rule which action triggered +- this YYABORT or YYACCEPT. */ +- YYPOPSTACK (yylen); +- YY_STACK_PRINT (yyss, yyssp); +- while (yyssp != yyss) +- { +- yydestruct ("Cleanup: popping", +- yystos[*yyssp], yyvsp); +- YYPOPSTACK (1); +- } +-#ifndef yyoverflow +- if (yyss != yyssa) +- YYSTACK_FREE (yyss); +-#endif +-#if YYERROR_VERBOSE +- if (yymsg != yymsgbuf) +- YYSTACK_FREE (yymsg); ++/* The last allocated position at the lexical position queue */ ++static YYLTYPE *yylplim = 0; + #endif +- /* Make sure YYID is used. */ +- return YYID (yyresult); +-} + ++/* Current position at lexical token queue */ ++static YYINT *yylexp = 0; + +-#line 190 "SDF-parse.y" +- ++static YYINT *yylexemes = 0; ++#endif /* YYBTYACC */ ++#line 193 "SDF-parse.y" + static int SDFlineno; + + static const char *Dataname, *Hdrname; +@@ -2357,4 +1006,1065 @@ + but linking against fileno() and isatty() can be annoying. */ + #define YY_ALWAYS_INTERACTIVE 1 + #include "SDF-lex.c" ++#line 1010 "SDF-parse.c" ++ ++/* For use in generated program */ ++#define yydepth (int)(yystack.s_mark - yystack.s_base) ++#if YYBTYACC ++#define yytrial (yyps->save) ++#endif /* YYBTYACC */ ++ ++#if YYDEBUG ++#include /* needed for printf */ ++#endif ++ ++#include /* needed for malloc, etc */ ++#include /* 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 defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ YYLTYPE *newps; ++#endif ++ ++ 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; ++ ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); ++ if (newps == 0) ++ return YYENOMEM; ++ ++ data->p_base = newps; ++ data->p_mark = newps + i; ++#endif ++ ++ data->stacksize = newsize; ++ data->s_last = data->s_base + newsize - 1; ++ ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); ++#endif ++ return 0; ++} ++ ++#if YYPURE || defined(YY_NO_LEAKS) ++static void yyfreestack(YYSTACKDATA *data) ++{ ++ free(data->s_base); ++ free(data->l_base); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ free(data->p_base); ++#endif ++ memset(data, 0, sizeof(*data)); ++} ++#else ++#define yyfreestack(data) /* nothing */ ++#endif /* YYPURE || defined(YY_NO_LEAKS) */ ++#if YYBTYACC ++ ++static YYParseState * ++yyNewState(unsigned size) ++{ ++ YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); ++ if (p == NULL) return NULL; ++ ++ p->yystack.stacksize = size; ++ if (size == 0) ++ { ++ p->yystack.s_base = NULL; ++ p->yystack.l_base = NULL; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ p->yystack.p_base = NULL; ++#endif ++ return p; ++ } ++ p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); ++ if (p->yystack.s_base == NULL) return NULL; ++ p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); ++ if (p->yystack.l_base == NULL) return NULL; ++ memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); ++ if (p->yystack.p_base == NULL) return NULL; ++ memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); ++#endif ++ ++ return p; ++} ++ ++static void ++yyFreeState(YYParseState *p) ++{ ++ yyfreestack(&p->yystack); ++ free(p); ++} ++#endif /* YYBTYACC */ ++ ++#define YYABORT goto yyabort ++#define YYREJECT goto yyabort ++#define YYACCEPT goto yyaccept ++#define YYERROR goto yyerrlab ++#if YYBTYACC ++#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) ++#define YYVALID_NESTED do { if (yyps->save && \ ++ yyps->save->save == 0) goto yyvalid; } while(0) ++#endif /* YYBTYACC */ ++ ++int ++YYPARSE_DECL() ++{ ++ int yym, yyn, yystate, yyresult; ++#if YYBTYACC ++ int yynewerrflag; ++ YYParseState *yyerrctx = NULL; ++#endif /* YYBTYACC */ ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */ ++#endif ++#if YYDEBUG ++ const char *yys; ++ ++ if ((yys = getenv("YYDEBUG")) != 0) ++ { ++ yyn = *yys; ++ if (yyn >= '0' && yyn <= '9') ++ yydebug = yyn - '0'; ++ } ++ if (yydebug) ++ fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); ++#endif ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); ++#endif ++ ++#if YYBTYACC ++ yyps = yyNewState(0); if (yyps == 0) goto yyenomem; ++ yyps->save = 0; ++#endif /* YYBTYACC */ ++ yym = 0; ++ /* yyn is set below */ ++ 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; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yystack.p_mark = yystack.p_base; ++#endif ++ yystate = 0; ++ *yystack.s_mark = 0; ++ ++yyloop: ++ if ((yyn = yydefred[yystate]) != 0) goto yyreduce; ++ if (yychar < 0) ++ { ++#if YYBTYACC ++ do { ++ if (yylvp < yylve) ++ { ++ /* we're currently re-reading tokens */ ++ yylval = *yylvp++; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylloc = *yylpp++; ++#endif ++ yychar = *yylexp++; ++ break; ++ } ++ if (yyps->save) ++ { ++ /* in trial mode; save scanner results for future parse attempts */ ++ if (yylvp == yylvlim) ++ { /* Enlarge lexical value queue */ ++ size_t p = (size_t) (yylvp - yylvals); ++ size_t s = (size_t) (yylvlim - yylvals); ++ ++ s += YYLVQUEUEGROWTH; ++ if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; ++ if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; ++#endif ++ yylvp = yylve = yylvals + p; ++ yylvlim = yylvals + s; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpp = yylpe = yylpsns + p; ++ yylplim = yylpsns + s; ++#endif ++ yylexp = yylexemes + p; ++ } ++ *yylexp = (YYINT) YYLEX; ++ *yylvp++ = yylval; ++ yylve++; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ *yylpp++ = yylloc; ++ yylpe++; ++#endif ++ yychar = *yylexp++; ++ break; ++ } ++ /* normal operation, no conflict encountered */ ++#endif /* YYBTYACC */ ++ yychar = YYLEX; ++#if YYBTYACC ++ } while (0); ++#endif /* YYBTYACC */ ++ if (yychar < 0) yychar = YYEOF; ++#if YYDEBUG ++ if (yydebug) ++ { ++ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; ++ fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", ++ YYDEBUGSTR, yydepth, yystate, yychar, yys); ++#ifdef YYSTYPE_TOSTRING ++#if YYBTYACC ++ if (!yytrial) ++#endif /* YYBTYACC */ ++ fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); ++#endif ++ fputc('\n', stderr); ++ } ++#endif ++ } ++#if YYBTYACC ++ ++ /* Do we have a conflict? */ ++ if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && ++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) ++ { ++ YYINT ctry; ++ ++ if (yypath) ++ { ++ YYParseState *save; ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", ++ YYDEBUGSTR, yydepth, yystate); ++#endif ++ /* Switch to the next conflict context */ ++ save = yypath; ++ yypath = save->save; ++ save->save = NULL; ++ ctry = save->ctry; ++ if (save->state != yystate) YYABORT; ++ yyFreeState(save); ++ ++ } ++ else ++ { ++ ++ /* Unresolved conflict - start/continue trial parse */ ++ YYParseState *save; ++#if YYDEBUG ++ if (yydebug) ++ { ++ fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); ++ if (yyps->save) ++ fputs("ALREADY in conflict, continuing trial parse.\n", stderr); ++ else ++ fputs("Starting trial parse.\n", stderr); ++ } ++#endif ++ save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); ++ if (save == NULL) goto yyenomem; ++ save->save = yyps->save; ++ save->state = yystate; ++ save->errflag = yyerrflag; ++ save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); ++ memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); ++ save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); ++ memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); ++ memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); ++#endif ++ ctry = yytable[yyn]; ++ if (yyctable[ctry] == -1) ++ { ++#if YYDEBUG ++ if (yydebug && yychar >= YYEOF) ++ fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); ++#endif ++ ctry++; ++ } ++ save->ctry = ctry; ++ if (yyps->save == NULL) ++ { ++ /* If this is a first conflict in the stack, start saving lexemes */ ++ if (!yylexemes) ++ { ++ yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); ++ if (yylexemes == NULL) goto yyenomem; ++ yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); ++ if (yylvals == NULL) goto yyenomem; ++ yylvlim = yylvals + YYLVQUEUEGROWTH; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); ++ if (yylpsns == NULL) goto yyenomem; ++ yylplim = yylpsns + YYLVQUEUEGROWTH; ++#endif ++ } ++ if (yylvp == yylve) ++ { ++ yylvp = yylve = yylvals; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpp = yylpe = yylpsns; ++#endif ++ yylexp = yylexemes; ++ if (yychar >= YYEOF) ++ { ++ *yylve++ = yylval; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ *yylpe++ = yylloc; ++#endif ++ *yylexp = (YYINT) yychar; ++ yychar = YYEMPTY; ++ } ++ } ++ } ++ if (yychar >= YYEOF) ++ { ++ yylvp--; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpp--; ++#endif ++ yylexp--; ++ yychar = YYEMPTY; ++ } ++ save->lexeme = (int) (yylvp - yylvals); ++ yyps->save = save; ++ } ++ if (yytable[yyn] == ctry) ++ { ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", ++ YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); ++#endif ++ if (yychar < 0) ++ { ++ yylvp++; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpp++; ++#endif ++ yylexp++; ++ } ++ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) ++ goto yyoverflow; ++ yystate = yyctable[ctry]; ++ *++yystack.s_mark = (YYINT) yystate; ++ *++yystack.l_mark = yylval; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ *++yystack.p_mark = yylloc; ++#endif ++ yychar = YYEMPTY; ++ if (yyerrflag > 0) --yyerrflag; ++ goto yyloop; ++ } ++ else ++ { ++ yyn = yyctable[ctry]; ++ goto yyreduce; ++ } ++ } /* End of code dealing with conflicts */ ++#endif /* YYBTYACC */ ++ if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && ++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) ++ { ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", ++ YYDEBUGSTR, yydepth, 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; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ *++yystack.p_mark = yylloc; ++#endif ++ yychar = YYEMPTY; ++ if (yyerrflag > 0) --yyerrflag; ++ goto yyloop; ++ } ++ if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && ++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) ++ { ++ yyn = yytable[yyn]; ++ goto yyreduce; ++ } ++ if (yyerrflag != 0) goto yyinrecovery; ++#if YYBTYACC ++ ++ yynewerrflag = 1; ++ goto yyerrhandler; ++ goto yyerrlab; /* redundant goto avoids 'unused label' warning */ ++ ++yyerrlab: ++ /* explicit YYERROR from an action -- pop the rhs of the rule reduced ++ * before looking for error recovery */ ++ yystack.s_mark -= yym; ++ yystate = *yystack.s_mark; ++ yystack.l_mark -= yym; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yystack.p_mark -= yym; ++#endif ++ ++ yynewerrflag = 0; ++yyerrhandler: ++ while (yyps->save) ++ { ++ int ctry; ++ YYParseState *save = yyps->save; ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", ++ YYDEBUGSTR, yydepth, yystate, yyps->save->state, ++ (int)(yylvp - yylvals - yyps->save->lexeme)); ++#endif ++ /* Memorize most forward-looking error state in case it's really an error. */ ++ if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) ++ { ++ /* Free old saved error context state */ ++ if (yyerrctx) yyFreeState(yyerrctx); ++ /* Create and fill out new saved error context state */ ++ yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); ++ if (yyerrctx == NULL) goto yyenomem; ++ yyerrctx->save = yyps->save; ++ yyerrctx->state = yystate; ++ yyerrctx->errflag = yyerrflag; ++ yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); ++ memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); ++ yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); ++ memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); ++ memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); ++#endif ++ yyerrctx->lexeme = (int) (yylvp - yylvals); ++ } ++ yylvp = yylvals + save->lexeme; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpp = yylpsns + save->lexeme; ++#endif ++ yylexp = yylexemes + save->lexeme; ++ yychar = YYEMPTY; ++ yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); ++ memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); ++ yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); ++ memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); ++ memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); ++#endif ++ ctry = ++save->ctry; ++ yystate = save->state; ++ /* We tried shift, try reduce now */ ++ if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; ++ yyps->save = save->save; ++ save->save = NULL; ++ yyFreeState(save); ++ ++ /* Nothing left on the stack -- error */ ++ if (!yyps->save) ++ { ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", ++ YYPREFIX, yydepth); ++#endif ++ /* Restore state as it was in the most forward-advanced error */ ++ yylvp = yylvals + yyerrctx->lexeme; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpp = yylpsns + yyerrctx->lexeme; ++#endif ++ yylexp = yylexemes + yyerrctx->lexeme; ++ yychar = yylexp[-1]; ++ yylval = yylvp[-1]; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylloc = yylpp[-1]; ++#endif ++ yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); ++ memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); ++ yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); ++ memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); ++ memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); ++#endif ++ yystate = yyerrctx->state; ++ yyFreeState(yyerrctx); ++ yyerrctx = NULL; ++ } ++ yynewerrflag = 1; ++ } ++ if (yynewerrflag == 0) goto yyinrecovery; ++#endif /* YYBTYACC */ ++ ++ YYERROR_CALL("syntax error"); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */ ++#endif ++ ++#if !YYBTYACC ++ goto yyerrlab; /* redundant goto avoids 'unused label' warning */ ++yyerrlab: ++#endif ++ ++yynerrs; + ++yyinrecovery: ++ if (yyerrflag < 3) ++ { ++ yyerrflag = 3; ++ for (;;) ++ { ++ if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && ++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) ++ { ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", ++ YYDEBUGSTR, yydepth, *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; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ /* lookahead position is error end position */ ++ yyerror_loc_range[2] = yylloc; ++ YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ ++ *++yystack.p_mark = yyloc; ++#endif ++ goto yyloop; ++ } ++ else ++ { ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", ++ YYDEBUGSTR, yydepth, *yystack.s_mark); ++#endif ++ if (yystack.s_mark <= yystack.s_base) goto yyabort; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ /* the current TOS position is the error start position */ ++ yyerror_loc_range[1] = *yystack.p_mark; ++#endif ++#if defined(YYDESTRUCT_CALL) ++#if YYBTYACC ++ if (!yytrial) ++#endif /* YYBTYACC */ ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ YYDESTRUCT_CALL("error: discarding state", ++ yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); ++#else ++ YYDESTRUCT_CALL("error: discarding state", ++ yystos[*yystack.s_mark], yystack.l_mark); ++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ ++#endif /* defined(YYDESTRUCT_CALL) */ ++ --yystack.s_mark; ++ --yystack.l_mark; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ --yystack.p_mark; ++#endif ++ } ++ } ++ } ++ else ++ { ++ if (yychar == YYEOF) goto yyabort; ++#if YYDEBUG ++ if (yydebug) ++ { ++ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; ++ fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", ++ YYDEBUGSTR, yydepth, yystate, yychar, yys); ++ } ++#endif ++#if defined(YYDESTRUCT_CALL) ++#if YYBTYACC ++ if (!yytrial) ++#endif /* YYBTYACC */ ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); ++#else ++ YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); ++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ ++#endif /* defined(YYDESTRUCT_CALL) */ ++ yychar = YYEMPTY; ++ goto yyloop; ++ } ++ ++yyreduce: ++ yym = yylen[yyn]; ++#if YYDEBUG ++ if (yydebug) ++ { ++ fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", ++ YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); ++#ifdef YYSTYPE_TOSTRING ++#if YYBTYACC ++ if (!yytrial) ++#endif /* YYBTYACC */ ++ if (yym > 0) ++ { ++ int i; ++ fputc('<', stderr); ++ for (i = yym; i > 0; i--) ++ { ++ if (i != yym) fputs(", ", stderr); ++ fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], ++ yystack.l_mark[1-i]), stderr); ++ } ++ fputc('>', stderr); ++ } ++#endif ++ fputc('\n', stderr); ++ } ++#endif ++ if (yym > 0) ++ yyval = yystack.l_mark[1-yym]; ++ else ++ memset(&yyval, 0, sizeof yyval); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ ++ /* Perform position reduction */ ++ memset(&yyloc, 0, sizeof(yyloc)); ++#if YYBTYACC ++ if (!yytrial) ++#endif /* YYBTYACC */ ++ { ++ YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym); ++ /* just in case YYERROR is invoked within the action, save ++ the start of the rhs as the error start position */ ++ yyerror_loc_range[1] = yystack.p_mark[1-yym]; ++ } ++#endif ++ ++ switch (yyn) ++ { ++case 1: ++#line 97 "SDF-parse.y" ++ {if(finish_parse()) YYERROR;} ++#line 1683 "SDF-parse.c" ++break; ++case 2: ++#line 98 "SDF-parse.y" ++ {if(finish_parse()) YYERROR; else YYACCEPT;} ++#line 1688 "SDF-parse.c" ++break; ++case 3: ++#line 99 "SDF-parse.y" ++ {YYERROR;} ++#line 1693 "SDF-parse.c" ++break; ++case 6: ++#line 106 "SDF-parse.y" ++ {if(data_dcl(yystack.l_mark[-1].declaration)) YYERROR;} ++#line 1698 "SDF-parse.c" ++break; ++case 7: ++#line 107 "SDF-parse.y" ++ {if(const_dcl(yystack.l_mark[-3].declaration, yystack.l_mark[-1].const_list)) YYERROR;} ++#line 1703 "SDF-parse.c" ++break; ++case 8: ++#line 108 "SDF-parse.y" ++ {if(do_value_param(yystack.l_mark[-3].valueparam, yystack.l_mark[-1].constant)) YYERROR;} ++#line 1708 "SDF-parse.c" ++break; ++case 9: ++#line 111 "SDF-parse.y" ++ {yyval.declaration.dcl_list = yystack.l_mark[0].dcl_list; yyval.declaration.Nrec = 1;} ++#line 1713 "SDF-parse.c" ++break; ++case 10: ++#line 112 "SDF-parse.y" ++ {yyval.declaration.dcl_list=yystack.l_mark[-2].dcl_list; yyval.declaration.Nrec=1;} ++#line 1718 "SDF-parse.c" ++break; ++case 11: ++#line 114 "SDF-parse.y" ++ { ++ if( yystack.l_mark[-1].constant.type != SDF_INT64 ){ ++ yyerror("Expected integer constant"); ++ YYERROR; ++ }else{ ++ yyval.declaration.dcl_list = yystack.l_mark[-5].dcl_list; yyval.declaration.Nrec = yystack.l_mark[-1].constant.u.int64val; ++ } ++ } ++#line 1730 "SDF-parse.c" ++break; ++case 12: ++#line 123 "SDF-parse.y" ++ { yyval.declaration.dcl_list = yystack.l_mark[-4].dcl_list; yyval.declaration.Nrec = 0;} ++#line 1735 "SDF-parse.c" ++break; ++case 13: ++#line 126 "SDF-parse.y" ++ {yyval.dcl_list = yystack.l_mark[0].dcl_list;} ++#line 1740 "SDF-parse.c" ++break; ++case 14: ++#line 128 "SDF-parse.y" ++ { ++ int sz; ++ ++ yyval.dcl_list.ndcl = yystack.l_mark[-2].dcl_list.ndcl + yystack.l_mark[0].dcl_list.ndcl; ++ yyval.dcl_list.obs = yystack.l_mark[-2].dcl_list.obs; ++ sz = obstack_object_size(&yystack.l_mark[0].dcl_list.obs); ++ (void)obstack_grow(&yyval.dcl_list.obs, obstack_finish(&yystack.l_mark[0].dcl_list.obs), sz); ++ (void)obstack_free(&yystack.l_mark[0].dcl_list.obs, NULL); ++ } ++#line 1753 "SDF-parse.c" ++break; ++case 15: ++#line 139 "SDF-parse.y" ++ {curtype = yystack.l_mark[0].type;} ++#line 1758 "SDF-parse.c" ++break; ++case 16: ++#line 139 "SDF-parse.y" ++ {yyval.dcl_list = yystack.l_mark[0].dcl_list;} ++#line 1763 "SDF-parse.c" ++break; ++case 17: ++#line 143 "SDF-parse.y" ++ { ++ obstack_begin(&yyval.dcl_list.obs, 16*sizeof(yystack.l_mark[0].one_dcl)); ++ yyval.dcl_list.ndcl = 1; ++ (void)obstack_grow(&yyval.dcl_list.obs, &yystack.l_mark[0].one_dcl, sizeof(yystack.l_mark[0].one_dcl)); ++ } ++#line 1772 "SDF-parse.c" ++break; ++case 18: ++#line 149 "SDF-parse.y" ++ { ++ yyval.dcl_list = yystack.l_mark[-2].dcl_list; ++ yyval.dcl_list.ndcl += 1; ++ (void)obstack_grow(&yyval.dcl_list.obs, &yystack.l_mark[0].one_dcl, sizeof(yystack.l_mark[0].one_dcl)); ++ } ++#line 1781 "SDF-parse.c" ++break; ++case 19: ++#line 156 "SDF-parse.y" ++ {yyval.one_dcl.name = yystack.l_mark[0].string; yyval.one_dcl.type = curtype; yyval.one_dcl.arrcnt = 1;} ++#line 1786 "SDF-parse.c" ++break; ++case 20: ++#line 158 "SDF-parse.y" ++ { ++ if( yystack.l_mark[-1].constant.type != SDF_INT64 ){ ++ yyerror("Expected integer constant"); ++ YYERROR; ++ }else{ ++ yyval.one_dcl.name = yystack.l_mark[-3].string; yyval.one_dcl.type = curtype; yyval.one_dcl.arrcnt = yystack.l_mark[-1].constant.u.int64val; ++ } ++ } ++#line 1798 "SDF-parse.c" ++break; ++case 21: ++#line 166 "SDF-parse.y" ++ {yyval.one_dcl.name=yystack.l_mark[-2].string; yyval.one_dcl.type=curtype; yyval.one_dcl.arrcnt = 0;} ++#line 1803 "SDF-parse.c" ++break; ++case 22: ++#line 170 "SDF-parse.y" ++ { ++ yyval.const_list.nconst = 1; ++ obstack_begin(&yyval.const_list.obs, 16*sizeof(yystack.l_mark[0].constant)); ++ (void)obstack_grow(&yyval.const_list.obs, &yystack.l_mark[0].constant, sizeof(yystack.l_mark[0].constant)); ++ } ++#line 1812 "SDF-parse.c" ++break; ++case 23: ++#line 175 "SDF-parse.y" ++ {yyval.const_list = yystack.l_mark[-1].const_list;} ++#line 1817 "SDF-parse.c" ++break; ++case 24: ++#line 179 "SDF-parse.y" ++ { ++ yyval.const_list.nconst = 1; ++ obstack_begin(&yyval.const_list.obs, 16*sizeof(yystack.l_mark[0].constant)); ++ (void)obstack_grow(&yyval.const_list.obs, &yystack.l_mark[0].constant, sizeof(yystack.l_mark[0].constant)); ++ } ++#line 1826 "SDF-parse.c" ++break; ++case 25: ++#line 185 "SDF-parse.y" ++ { ++ yyval.const_list = yystack.l_mark[-2].const_list; ++ yyval.const_list.nconst += 1; ++ (void)obstack_grow(&yyval.const_list.obs, &yystack.l_mark[0].constant, sizeof(yystack.l_mark[0].constant)); ++ } ++#line 1835 "SDF-parse.c" ++break; ++#line 1837 "SDF-parse.c" ++ default: ++ break; ++ } ++ yystack.s_mark -= yym; ++ yystate = *yystack.s_mark; ++ yystack.l_mark -= yym; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yystack.p_mark -= yym; ++#endif ++ yym = yylhs[yyn]; ++ if (yystate == 0 && yym == 0) ++ { ++#if YYDEBUG ++ if (yydebug) ++ { ++ fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); ++#ifdef YYSTYPE_TOSTRING ++#if YYBTYACC ++ if (!yytrial) ++#endif /* YYBTYACC */ ++ fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); ++#endif ++ fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); ++ } ++#endif ++ yystate = YYFINAL; ++ *++yystack.s_mark = YYFINAL; ++ *++yystack.l_mark = yyval; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ *++yystack.p_mark = yyloc; ++#endif ++ if (yychar < 0) ++ { ++#if YYBTYACC ++ do { ++ if (yylvp < yylve) ++ { ++ /* we're currently re-reading tokens */ ++ yylval = *yylvp++; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylloc = *yylpp++; ++#endif ++ yychar = *yylexp++; ++ break; ++ } ++ if (yyps->save) ++ { ++ /* in trial mode; save scanner results for future parse attempts */ ++ if (yylvp == yylvlim) ++ { /* Enlarge lexical value queue */ ++ size_t p = (size_t) (yylvp - yylvals); ++ size_t s = (size_t) (yylvlim - yylvals); ++ ++ s += YYLVQUEUEGROWTH; ++ if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) ++ goto yyenomem; ++ if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) ++ goto yyenomem; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) ++ goto yyenomem; ++#endif ++ yylvp = yylve = yylvals + p; ++ yylvlim = yylvals + s; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpp = yylpe = yylpsns + p; ++ yylplim = yylpsns + s; ++#endif ++ yylexp = yylexemes + p; ++ } ++ *yylexp = (YYINT) YYLEX; ++ *yylvp++ = yylval; ++ yylve++; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ *yylpp++ = yylloc; ++ yylpe++; ++#endif ++ yychar = *yylexp++; ++ break; ++ } ++ /* normal operation, no conflict encountered */ ++#endif /* YYBTYACC */ ++ yychar = YYLEX; ++#if YYBTYACC ++ } while (0); ++#endif /* YYBTYACC */ ++ if (yychar < 0) yychar = YYEOF; ++#if YYDEBUG ++ if (yydebug) ++ { ++ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; ++ fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", ++ YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); ++ } ++#endif ++ } ++ if (yychar == YYEOF) goto yyaccept; ++ goto yyloop; ++ } ++ if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && ++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) ++ yystate = yytable[yyn]; ++ else ++ yystate = yydgoto[yym]; ++#if YYDEBUG ++ if (yydebug) ++ { ++ fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); ++#ifdef YYSTYPE_TOSTRING ++#if YYBTYACC ++ if (!yytrial) ++#endif /* YYBTYACC */ ++ fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); ++#endif ++ fprintf(stderr, "shifting from state %d to state %d\n", *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; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ *++yystack.p_mark = yyloc; ++#endif ++ goto yyloop; ++#if YYBTYACC ++ ++ /* Reduction declares that this path is valid. Set yypath and do a full parse */ ++yyvalid: ++ if (yypath) YYABORT; ++ while (yyps->save) ++ { ++ YYParseState *save = yyps->save; ++ yyps->save = save->save; ++ save->save = yypath; ++ yypath = save; ++ } ++#if YYDEBUG ++ if (yydebug) ++ fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", ++ YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); ++#endif ++ if (yyerrctx) ++ { ++ yyFreeState(yyerrctx); ++ yyerrctx = NULL; ++ } ++ yylvp = yylvals + yypath->lexeme; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yylpp = yylpsns + yypath->lexeme; ++#endif ++ yylexp = yylexemes + yypath->lexeme; ++ yychar = YYEMPTY; ++ yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); ++ memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); ++ yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); ++ memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); ++ memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); ++#endif ++ yystate = yypath->state; ++ goto yyloop; ++#endif /* YYBTYACC */ ++ ++yyoverflow: ++ YYERROR_CALL("yacc stack overflow"); ++#if YYBTYACC ++ goto yyabort_nomem; ++yyenomem: ++ YYERROR_CALL("memory exhausted"); ++yyabort_nomem: ++#endif /* YYBTYACC */ ++ yyresult = 2; ++ goto yyreturn; ++ ++yyabort: ++ yyresult = 1; ++ goto yyreturn; ++ ++yyaccept: ++#if YYBTYACC ++ if (yyps->save) goto yyvalid; ++#endif /* YYBTYACC */ ++ yyresult = 0; ++ ++yyreturn: ++#if defined(YYDESTRUCT_CALL) ++ if (yychar != YYEOF && yychar != YYEMPTY) ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); ++#else ++ YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); ++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ ++ ++ { ++ YYSTYPE *pv; ++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) ++ YYLTYPE *pp; ++ ++ for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) ++ YYDESTRUCT_CALL("cleanup: discarding state", ++ yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); ++#else ++ for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) ++ YYDESTRUCT_CALL("cleanup: discarding state", ++ yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); ++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ ++ } ++#endif /* defined(YYDESTRUCT_CALL) */ ++ ++#if YYBTYACC ++ if (yyerrctx) ++ { ++ yyFreeState(yyerrctx); ++ yyerrctx = NULL; ++ } ++ while (yyps) ++ { ++ YYParseState *save = yyps; ++ yyps = save->save; ++ save->save = NULL; ++ yyFreeState(save); ++ } ++ while (yypath) ++ { ++ YYParseState *save = yypath; ++ yypath = save->save; ++ save->save = NULL; ++ yyFreeState(save); ++ } ++#endif /* YYBTYACC */ ++ yyfreestack(&yystack); ++ return (yyresult); ++} +Only in : SDF-parse.o +diff -ru SDF-parse.y SDF-parse.y +--- SDF-parse.y 2014-06-04 07:22:26.000000000 +0200 ++++ SDF-parse.y 2025-03-09 08:10:24.189787382 +0100 +@@ -45,6 +45,8 @@ + #endif + extern void yyerror(char *fmt, ...); + ++extern int SDFyylex(); ++ + + static enum SDF_type_enum curtype; + static blk_descrip_t cur_blk; +Only in : SDFwrite.o +Only in : txttoSDF +Only in : txttoSDF.o +Only in : utils.o +Only in : version.c +Only in : version.o +Only in : version.proto