diff options
| -rw-r--r-- | src/gsoap-3-lex-yacc.patch | 8065 | ||||
| -rw-r--r-- | src/gsoap.mk | 6 |
2 files changed, 8071 insertions, 0 deletions
diff --git a/src/gsoap-3-lex-yacc.patch b/src/gsoap-3-lex-yacc.patch new file mode 100644 index 0000000..5d81786 --- /dev/null +++ b/src/gsoap-3-lex-yacc.patch @@ -0,0 +1,8065 @@ +This file is part of mingw-cross-env. +See doc/index.html or doc/README for further information. + +diff -urN d/gsoap/src/Makefile.in e/gsoap/src/Makefile.in +--- d/gsoap/src/Makefile.in 2010-01-24 11:54:01.000000000 +0100 ++++ e/gsoap/src/Makefile.in 2010-01-24 12:21:23.000000000 +0100 +@@ -202,7 +202,7 @@ + soapcpp2_CFLAGS = $(BISON_DEFINE) $(LEX_DEFINE) $(C_DEBUG_FLAGS) $(SOAPCPP2_IMPORTPATH) -D$(platform) + soapcpp2_LDADD = $(YACC_LIB) $(LEXLIB) + soapcpp2_SOURCES = soapcpp2_yacc.y soapcpp2_lex.l symbol2.c error2.c init2.c soapcpp2.c +-CLEANFILES = *~ soapcpp2_lex.c soapcpp2_yacc.c soapcpp2_yacc.h y.output soapcpp2_yacc.output ++CLEANFILES = *~ + all: all-am + + .SUFFIXES: +diff -urN d/gsoap/src/soapcpp2_lex.c e/gsoap/src/soapcpp2_lex.c +--- d/gsoap/src/soapcpp2_lex.c 1970-01-01 01:00:00.000000000 +0100 ++++ e/gsoap/src/soapcpp2_lex.c 2010-01-24 12:13:25.000000000 +0100 +@@ -0,0 +1,3079 @@ ++ ++#line 3 "soapcpp2_lex.c" ++ ++#define YY_INT_ALIGNED short int ++ ++/* A lexical scanner generated by flex */ ++ ++#define FLEX_SCANNER ++#define YY_FLEX_MAJOR_VERSION 2 ++#define YY_FLEX_MINOR_VERSION 5 ++#define YY_FLEX_SUBMINOR_VERSION 35 ++#if YY_FLEX_SUBMINOR_VERSION > 0 ++#define FLEX_BETA ++#endif ++ ++/* First, we deal with platform-specific or compiler-specific issues. */ ++ ++/* begin standard C headers. */ ++#include <stdio.h> ++#include <string.h> ++#include <errno.h> ++#include <stdlib.h> ++ ++/* end standard C headers. */ ++ ++/* flex integer type definitions */ ++ ++#ifndef FLEXINT_H ++#define FLEXINT_H ++ ++/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ ++ ++#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L ++ ++/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, ++ * if you want the limit (max/min) macros for int types. ++ */ ++#ifndef __STDC_LIMIT_MACROS ++#define __STDC_LIMIT_MACROS 1 ++#endif ++ ++#include <inttypes.h> ++typedef int8_t flex_int8_t; ++typedef uint8_t flex_uint8_t; ++typedef int16_t flex_int16_t; ++typedef uint16_t flex_uint16_t; ++typedef int32_t flex_int32_t; ++typedef uint32_t flex_uint32_t; ++#else ++typedef signed char flex_int8_t; ++typedef short int flex_int16_t; ++typedef int flex_int32_t; ++typedef unsigned char flex_uint8_t; ++typedef unsigned short int flex_uint16_t; ++typedef unsigned int flex_uint32_t; ++#endif /* ! C99 */ ++ ++/* Limits of integral types. */ ++#ifndef INT8_MIN ++#define INT8_MIN (-128) ++#endif ++#ifndef INT16_MIN ++#define INT16_MIN (-32767-1) ++#endif ++#ifndef INT32_MIN ++#define INT32_MIN (-2147483647-1) ++#endif ++#ifndef INT8_MAX ++#define INT8_MAX (127) ++#endif ++#ifndef INT16_MAX ++#define INT16_MAX (32767) ++#endif ++#ifndef INT32_MAX ++#define INT32_MAX (2147483647) ++#endif ++#ifndef UINT8_MAX ++#define UINT8_MAX (255U) ++#endif ++#ifndef UINT16_MAX ++#define UINT16_MAX (65535U) ++#endif ++#ifndef UINT32_MAX ++#define UINT32_MAX (4294967295U) ++#endif ++ ++#endif /* ! FLEXINT_H */ ++ ++#ifdef __cplusplus ++ ++/* The "const" storage-class-modifier is valid. */ ++#define YY_USE_CONST ++ ++#else /* ! __cplusplus */ ++ ++/* C99 requires __STDC__ to be defined as 1. */ ++#if defined (__STDC__) ++ ++#define YY_USE_CONST ++ ++#endif /* defined (__STDC__) */ ++#endif /* ! __cplusplus */ ++ ++#ifdef YY_USE_CONST ++#define yyconst const ++#else ++#define yyconst ++#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. ++ */ ++#define YY_SC_TO_UI(c) ((unsigned int) (unsigned 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_END_OF_BUFFER_CHAR 0 ++ ++/* Size of default input buffer. */ ++#ifndef YY_BUF_SIZE ++#define YY_BUF_SIZE 16384 ++#endif ++ ++/* The state buf must be large enough to hold one state per character in the main buffer. ++ */ ++#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) ++ ++#ifndef YY_TYPEDEF_YY_BUFFER_STATE ++#define YY_TYPEDEF_YY_BUFFER_STATE ++typedef struct yy_buffer_state *YY_BUFFER_STATE; ++#endif ++ ++extern int yyleng; ++ ++extern FILE *yyin, *yyout; ++ ++#define EOB_ACT_CONTINUE_SCAN 0 ++#define EOB_ACT_END_OF_FILE 1 ++#define EOB_ACT_LAST_MATCH 2 ++ ++ /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires ++ * access to the local variable yy_act. Since yyless() is a macro, it would break ++ * existing scanners that call yyless() from OUTSIDE yylex. ++ * One obvious solution it to make yy_act a global. I tried that, and saw ++ * a 5% performance hit in a non-yylineno scanner, because yy_act is ++ * normally declared as a register variable-- so it is not worth it. ++ */ ++ #define YY_LESS_LINENO(n) \ ++ do { \ ++ int yyl;\ ++ for ( yyl = n; yyl < yyleng; ++yyl )\ ++ if ( yytext[yyl] == '\n' )\ ++ --yylineno;\ ++ }while(0) ++ ++/* Return all but the first "n" matched characters back to the input stream. */ ++#define yyless(n) \ ++ do \ ++ { \ ++ /* Undo effects of setting up yytext. */ \ ++ int yyless_macro_arg = (n); \ ++ YY_LESS_LINENO(yyless_macro_arg);\ ++ *yy_cp = (yy_hold_char); \ ++ YY_RESTORE_YY_MORE_OFFSET \ ++ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ ++ 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 ++ { ++ FILE *yy_input_file; ++ ++ char *yy_ch_buf; /* input buffer */ ++ char *yy_buf_pos; /* current position in input buffer */ ++ ++ /* Size of input buffer in bytes, not including room for EOB ++ * characters. ++ */ ++ yy_size_t yy_buf_size; ++ ++ /* Number of characters read into yy_ch_buf, not including EOB ++ * characters. ++ */ ++ int yy_n_chars; ++ ++ /* Whether we "own" the buffer - i.e., we know we created it, ++ * and can realloc() it to grow it, and should free() it to ++ * delete it. ++ */ ++ int yy_is_our_buffer; ++ ++ /* Whether this is an "interactive" input source; if so, and ++ * if we're using stdio for input, then we want to use getc() ++ * instead of fread(), to make sure we stop fetching input after ++ * each newline. ++ */ ++ int yy_is_interactive; ++ ++ /* Whether we're considered to be at the beginning of a line. ++ * If so, '^' rules will be active on the next match, otherwise ++ * not. ++ */ ++ int yy_at_bol; ++ ++ int yy_bs_lineno; /**< The line count. */ ++ int yy_bs_column; /**< The column count. */ ++ ++ /* Whether to try to fill the input buffer when we reach the ++ * end of it. ++ */ ++ int yy_fill_buffer; ++ ++ int yy_buffer_status; ++ ++#define YY_BUFFER_NEW 0 ++#define YY_BUFFER_NORMAL 1 ++ /* When an EOF's been seen but there's still some text to process ++ * then we mark the buffer as YY_EOF_PENDING, to indicate that we ++ * shouldn't try reading from the input source any more. We might ++ * still have a bunch of tokens to match, though, because of ++ * possible backing-up. ++ * ++ * When we actually see the EOF, we change the status to "new" ++ * (via yyrestart()), so that the user can continue scanning by ++ * just pointing yyin at a new input file. ++ */ ++#define YY_BUFFER_EOF_PENDING 2 ++ ++ }; ++#endif /* !YY_STRUCT_YY_BUFFER_STATE */ ++ ++/* Stack of input buffers. */ ++static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ ++static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ ++static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ ++ ++/* We provide macros for accessing buffer states in case in the ++ * future we want to put the buffer states in a more general ++ * "scanner state". ++ * ++ * Returns the top of the stack, or NULL. ++ */ ++#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ++ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ ++ : NULL) ++ ++/* Same as previous macro, but useful when we know that the buffer stack is not ++ * NULL or when we need an lvalue. For internal use only. ++ */ ++#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ++ ++/* yy_hold_char holds the character lost when yytext is formed. */ ++static char yy_hold_char; ++static int yy_n_chars; /* number of characters read into yy_ch_buf */ ++int yyleng; ++ ++/* Points to current character in buffer. */ ++static char *yy_c_buf_p = (char *) 0; ++static int yy_init = 0; /* whether we need to initialize */ ++static int yy_start = 0; /* start state number */ ++ ++/* Flag which is used to allow yywrap()'s to do buffer switches ++ * instead of setting up a fresh yyin. A bit of a hack ... ++ */ ++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 * ); ++ ++#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_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_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ ++ } ++ ++#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) ++ ++/* Begin user sect3 */ ++ ++typedef unsigned char YY_CHAR; ++ ++FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; ++ ++typedef int yy_state_type; ++ ++#define YY_FLEX_LEX_COMPAT ++extern int yylineno; ++ ++int yylineno = 1; ++ ++extern char 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[] ); ++ ++/* 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); \ ++ (yy_hold_char) = *yy_cp; \ ++ *yy_cp = '\0'; \ ++ if ( yyleng + (yy_more_offset) >= YYLMAX ) \ ++ YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \ ++ yy_flex_strncpy( &yytext[(yy_more_offset)], (yytext_ptr), yyleng + 1 ); \ ++ yyleng += (yy_more_offset); \ ++ (yy_prev_more_offset) = (yy_more_offset); \ ++ (yy_more_offset) = 0; \ ++ (yy_c_buf_p) = yy_cp; ++ ++#define YY_NUM_RULES 42 ++#define YY_END_OF_BUFFER 43 ++/* This struct is not used in this scanner, ++ but its presence is necessary. */ ++struct yy_trans_info ++ { ++ flex_int32_t yy_verify; ++ flex_int32_t yy_nxt; ++ }; ++static yyconst flex_int16_t yy_acclist[130] = ++ { 0, ++ 43, 41, 42, 1, 41, 42, 1, 42, 29, 41, ++ 42, 41, 42,16424, 41, 42, 29, 41, 42, 29, ++ 41, 42, 41, 42,16423, 29, 41, 42, 29, 41, ++ 42, 29, 41, 42, 29, 41, 42, 29, 41, 42, ++ 31, 41, 42, 31, 41, 42, 29, 41, 42, 29, ++ 41, 42, 29, 41, 42, 30, 41, 42, 29, 41, ++ 42, 29, 41, 42, 3, 42, 3, 42, 21,16424, ++ 8232, 35,16424, 38, 12, 19, 13,16423, 8231, 34, ++ 16423, 10, 26, 8, 27, 9, 28, 2, 11, 31, ++ 24, 22, 20, 23, 25, 30, 14, 15, 18, 4, ++ ++ 8232, 35, 34, 7, 33, 33, 32, 16, 17, 33, ++ 38, 38, 6, 7, 37, 38, 37, 36, 38, 36, ++ 37, 38, 37, 36, 38, 36, 5, 6, 7 ++ } ; ++ ++static yyconst flex_int16_t yy_accept[133] = ++ { 0, ++ 1, 1, 1, 1, 1, 2, 4, 7, 9, 12, ++ 15, 17, 20, 23, 26, 29, 32, 35, 38, 41, ++ 44, 47, 50, 53, 56, 59, 62, 65, 67, 69, ++ 70, 71, 72, 73, 74, 74, 75, 75, 75, 76, ++ 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, ++ 87, 88, 89, 89, 90, 90, 91, 91, 91, 92, ++ 93, 94, 95, 96, 97, 97, 98, 99, 100, 101, ++ 101, 101, 102, 103, 103, 103, 104, 104, 105, 105, ++ 106, 106, 107, 108, 109, 110, 110, 110, 110, 110, ++ 110, 110, 110, 110, 110, 110, 110, 111, 111, 111, ++ ++ 111, 111, 111, 111, 111, 112, 112, 113, 113, 115, ++ 115, 115, 115, 117, 117, 117, 118, 118, 118, 120, ++ 120, 120, 121, 121, 123, 124, 126, 127, 127, 127, ++ 130, 130 ++ } ; ++ ++static yyconst flex_int32_t yy_ec[256] = ++ { 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, ++ 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, ++ 1, 2, 4, 5, 6, 1, 7, 8, 9, 10, ++ 10, 11, 12, 10, 13, 14, 15, 16, 17, 17, ++ 17, 17, 17, 17, 17, 17, 17, 18, 10, 19, ++ 20, 21, 10, 10, 22, 22, 22, 22, 23, 22, ++ 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, ++ 24, 24, 24, 24, 24, 24, 24, 25, 24, 24, ++ 10, 26, 10, 27, 24, 1, 28, 22, 22, 29, ++ ++ 30, 22, 31, 24, 32, 24, 24, 33, 34, 24, ++ 35, 36, 24, 37, 38, 39, 40, 24, 24, 25, ++ 24, 24, 10, 41, 10, 10, 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, 2, ++ 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 ++ } ; ++ ++static yyconst flex_int32_t yy_meta[42] = ++ { 0, ++ 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 3, 3, 4, 1, 1, ++ 1, 3, 3, 4, 4, 1, 1, 3, 3, 3, ++ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, ++ 1 ++ } ; ++ ++static yyconst flex_int16_t yy_base[147] = ++ { 0, ++ 0, 0, 266, 265, 275, 278, 278, 278, 254, 39, ++ 40, 253, 37, 43, 278, 226, 35, 38, 51, 59, ++ 47, 29, 197, 33, 198, 195, 40, 278, 198, 278, ++ 75, 62, 278, 80, 209, 278, 53, 65, 278, 278, ++ 278, 83, 278, 278, 87, 278, 278, 278, 278, 278, ++ 278, 278, 76, 278, 77, 81, 102, 0, 191, 278, ++ 278, 278, 190, 191, 86, 278, 278, 278, 278, 86, ++ 105, 94, 100, 113, 114, 112, 205, 278, 119, 107, ++ 111, 116, 0, 278, 278, 120, 126, 131, 126, 127, ++ 137, 138, 136, 141, 138, 131, 142, 139, 153, 157, ++ ++ 160, 162, 142, 165, 167, 173, 177, 204, 278, 178, ++ 203, 182, 184, 202, 186, 188, 201, 192, 194, 200, ++ 196, 198, 179, 278, 278, 278, 278, 199, 189, 278, ++ 278, 218, 222, 226, 230, 232, 236, 240, 47, 244, ++ 248, 252, 256, 260, 264, 268 ++ } ; ++ ++static yyconst flex_int16_t yy_def[147] = ++ { 0, ++ 131, 1, 132, 132, 131, 131, 131, 131, 131, 133, ++ 134, 131, 131, 135, 131, 131, 131, 131, 131, 131, ++ 131, 131, 131, 131, 136, 131, 131, 131, 131, 131, ++ 133, 137, 131, 133, 134, 131, 134, 134, 131, 131, ++ 131, 135, 131, 131, 135, 131, 131, 131, 131, 131, ++ 131, 131, 138, 131, 131, 131, 131, 139, 131, 131, ++ 131, 131, 131, 136, 136, 131, 131, 131, 131, 137, ++ 137, 137, 137, 134, 134, 140, 138, 131, 138, 131, ++ 131, 131, 139, 131, 131, 137, 134, 134, 140, 140, ++ 138, 131, 134, 134, 138, 131, 131, 134, 134, 138, ++ ++ 134, 134, 141, 142, 143, 144, 145, 141, 131, 141, ++ 142, 142, 143, 143, 143, 143, 144, 144, 145, 145, ++ 145, 145, 141, 131, 131, 131, 131, 146, 146, 131, ++ 0, 131, 131, 131, 131, 131, 131, 131, 131, 131, ++ 131, 131, 131, 131, 131, 131 ++ } ; ++ ++static yyconst flex_int16_t yy_nxt[320] = ++ { 0, ++ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, ++ 16, 17, 18, 15, 19, 20, 21, 15, 22, 23, ++ 24, 25, 25, 25, 25, 6, 26, 25, 25, 25, ++ 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, ++ 27, 32, 36, 33, 40, 43, 47, 59, 60, 83, ++ 49, 44, 62, 63, 48, 36, 41, 50, 51, 67, ++ 55, 52, 56, 56, 34, 53, 33, 36, 45, 57, ++ 54, 37, 55, 38, 56, 56, 57, 32, 78, 33, ++ 68, 57, 72, 58, 73, 43, 74, 71, 57, 43, ++ 33, 44, 80, 80, 55, 76, 56, 56, 33, 75, ++ ++ 34, 131, 131, 57, 33, 34, 79, 86, 45, 73, ++ 57, 71, 45, 81, 81, 36, 36, 82, 82, 71, ++ 44, 78, 80, 80, 33, 71, 82, 82, 36, 92, ++ 71, 82, 82, 36, 44, 76, 92, 90, 36, 78, ++ 78, 36, 88, 36, 109, 71, 97, 97, 87, 96, ++ 96, 90, 90, 97, 97, 36, 91, 97, 97, 78, ++ 93, 104, 105, 106, 107, 100, 112, 113, 115, 116, ++ 94, 95, 98, 99, 118, 119, 110, 101, 121, 122, ++ 109, 109, 102, 112, 113, 115, 116, 115, 116, 115, ++ 116, 130, 103, 118, 119, 121, 122, 121, 122, 121, ++ ++ 122, 130, 127, 126, 125, 124, 109, 78, 65, 85, ++ 84, 36, 69, 123, 66, 65, 61, 128, 28, 28, ++ 28, 28, 31, 31, 31, 31, 35, 35, 35, 35, ++ 42, 42, 42, 42, 64, 64, 70, 70, 70, 70, ++ 77, 77, 77, 77, 89, 46, 89, 89, 108, 108, ++ 108, 108, 111, 111, 111, 111, 114, 114, 114, 114, ++ 117, 117, 117, 117, 120, 120, 120, 120, 129, 129, ++ 129, 129, 39, 30, 131, 29, 29, 5, 131, 131, ++ 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, ++ 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, ++ ++ 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, ++ 131, 131, 131, 131, 131, 131, 131, 131, 131 ++ } ; ++ ++static yyconst flex_int16_t yy_chk[320] = ++ { 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 10, 11, 10, 13, 14, 17, 22, 22, 139, ++ 18, 14, 24, 24, 17, 37, 13, 18, 18, 27, ++ 21, 19, 21, 21, 10, 19, 32, 38, 14, 21, ++ 19, 11, 20, 11, 20, 20, 21, 31, 53, 31, ++ 27, 20, 34, 20, 34, 42, 37, 32, 20, 45, ++ 70, 42, 55, 55, 56, 45, 56, 56, 72, 38, ++ ++ 31, 65, 65, 56, 73, 34, 53, 71, 42, 71, ++ 56, 70, 45, 57, 57, 74, 75, 57, 57, 72, ++ 76, 79, 80, 80, 86, 73, 81, 81, 87, 80, ++ 71, 82, 82, 88, 89, 90, 80, 76, 93, 91, ++ 95, 98, 75, 94, 103, 86, 96, 96, 74, 92, ++ 92, 89, 90, 92, 92, 99, 79, 97, 97, 100, ++ 87, 101, 101, 102, 102, 95, 104, 104, 105, 105, ++ 88, 91, 93, 94, 106, 106, 103, 98, 107, 107, ++ 110, 123, 99, 112, 112, 113, 113, 115, 115, 116, ++ 116, 129, 100, 118, 118, 119, 119, 121, 121, 122, ++ ++ 122, 128, 120, 117, 114, 111, 108, 77, 64, 63, ++ 59, 35, 29, 110, 26, 25, 23, 123, 132, 132, ++ 132, 132, 133, 133, 133, 133, 134, 134, 134, 134, ++ 135, 135, 135, 135, 136, 136, 137, 137, 137, 137, ++ 138, 138, 138, 138, 140, 16, 140, 140, 141, 141, ++ 141, 141, 142, 142, 142, 142, 143, 143, 143, 143, ++ 144, 144, 144, 144, 145, 145, 145, 145, 146, 146, ++ 146, 146, 12, 9, 5, 4, 3, 131, 131, 131, ++ 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, ++ 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, ++ ++ 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, ++ 131, 131, 131, 131, 131, 131, 131, 131, 131 ++ } ; ++ ++/* Table of booleans, true if rule could match eol. */ ++static yyconst flex_int32_t yy_rule_can_match_eol[43] = ++ { 0, ++1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, ++ 1, 0, 0, }; ++ ++extern int yy_flex_debug; ++int yy_flex_debug = 0; ++ ++static yy_state_type *yy_state_buf=0, *yy_state_ptr=0; ++static char *yy_full_match; ++static int yy_lp; ++static int yy_looking_for_trail_begin = 0; ++static int yy_full_lp; ++static int *yy_full_state; ++#define YY_TRAILING_MASK 0x2000 ++#define YY_TRAILING_HEAD_MASK 0x4000 ++#define REJECT \ ++{ \ ++*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \ ++yy_cp = (yy_full_match); /* restore poss. backed-over text */ \ ++(yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \ ++(yy_state_ptr) = (yy_full_state); /* restore orig. state */ \ ++yy_current_state = *(yy_state_ptr); /* restore curr. state */ \ ++++(yy_lp); \ ++goto find_rule; \ ++} ++ ++static int yy_more_offset = 0; ++static int yy_prev_more_offset = 0; ++#define yymore() ((yy_more_offset) = yy_flex_strlen( yytext )) ++#define YY_NEED_STRLEN ++#define YY_MORE_ADJ 0 ++#define YY_RESTORE_YY_MORE_OFFSET \ ++ { \ ++ (yy_more_offset) = (yy_prev_more_offset); \ ++ yyleng -= (yy_more_offset); \ ++ } ++#ifndef YYLMAX ++#define YYLMAX 8192 ++#endif ++ ++char yytext[YYLMAX]; ++char *yytext_ptr; ++#line 1 "soapcpp2_lex.l" ++/* ++ soapcpp2_lex.l ++ ++ Flex/Lex tokenizer. ++ ++-------------------------------------------------------------------------------- ++gSOAP XML Web services tools ++Copyright (C) 2000-2008, Robert van Engelen, Genivia Inc. All Rights Reserved. ++This part of the software is released under ONE of the following licenses: ++GPL, the gSOAP public license, OR Genivia's license for commercial use. ++-------------------------------------------------------------------------------- ++gSOAP public license. ++ ++The contents of this file are subject to the gSOAP Public License Version 1.3 ++(the "License"); you may not use this file except in compliance with the ++License. You may obtain a copy of the License at ++http://www.cs.fsu.edu/~engelen/soaplicense.html ++Software distributed under the License is distributed on an "AS IS" basis, ++WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License ++for the specific language governing rights and limitations under the License. ++ ++The Initial Developer of the Original Code is Robert A. van Engelen. ++Copyright (C) 2000-2008 Robert A. van Engelen, Genivia inc. All Rights Reserved. ++-------------------------------------------------------------------------------- ++GPL license. ++ ++This program is free software; you can redistribute it and/or modify it under ++the terms of the GNU General Public License as published by the Free Software ++Foundation; either version 2 of the License, or (at your option) any later ++version. ++ ++This program is distributed in the hope that it will be useful, but WITHOUT ANY ++WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A ++PARTICULAR PURPOSE. See the GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License along with ++this program; if not, write to the Free Software Foundation, Inc., 59 Temple ++Place, Suite 330, Boston, MA 02111-1307 USA ++ ++Author contact information: ++engelen@genivia.com / engelen@acm.org ++ ++This program is released under the GPL with the additional exemption that ++compiling, linking, and/or using OpenSSL is allowed. ++-------------------------------------------------------------------------------- ++A commercial use license is available from Genivia, Inc., contact@genivia.com ++-------------------------------------------------------------------------------- ++*/ ++#line 51 "soapcpp2_lex.l" ++#include "soapcpp2.h" ++ ++#ifdef HAVE_CONFIG_H ++#include "soapcpp2_yacc.h" ++#else ++#include "soapcpp2_yacc.tab.h" ++#endif ++ ++#ifdef WITH_BISON ++YYSTYPE yylval; ++#undef YY_INPUT ++#define YY_INPUT(buf, result, max_size) \ ++ { \ ++ int c = getc(yyin); \ ++ result = (c == EOF) ? YY_NULL : (buf[0] = c, 1); \ ++ } ++#endif ++ ++#ifndef WITH_LEX ++#define MAX_IMPORT_DEPTH 16 ++static struct importlist { struct importlist *next; char name[1]; } *importlist = NULL; ++static char fnstk[MAX_IMPORT_DEPTH][1024]; ++static int lnstk[MAX_IMPORT_DEPTH]; ++static char *imstk[MAX_IMPORT_DEPTH]; ++static YY_BUFFER_STATE instk[MAX_IMPORT_DEPTH]; ++#endif ++int imports = 0; ++char *imported = NULL; ++static void check_id(const char*); ++static Token install_id(); ++static Token install_int(); ++static Token install_hex(); ++static Token install_num(); ++static Token install_chr(); ++static Token install_str(); ++static Token install_pragma(); ++static void directive(), option(); ++static Token error_chr(); ++static Token error_str(); ++static int convchar(int*); ++static int hexchar(int*); ++static int octchar(int*); ++static void module(const char *name, const char *fullname); ++static void import(const char *file); ++static int magic(const char *name); ++ ++#line 728 "soapcpp2_lex.c" ++ ++#define INITIAL 0 ++#define MLCOMMENT 1 ++ ++#ifndef YY_NO_UNISTD_H ++/* Special case for "unistd.h", since it is non-ANSI. We include it way ++ * down here because we want the user's section 1 to have been scanned first. ++ * The user has a chance to override it with an option. ++ */ ++#include <unistd.h> ++#endif ++ ++#ifndef YY_EXTRA_TYPE ++#define YY_EXTRA_TYPE void * ++#endif ++ ++static int yy_init_globals (void ); ++ ++/* Accessor methods to globals. ++ These are made visible to non-reentrant scanners for convenience. */ ++ ++int yylex_destroy (void ); ++ ++int yyget_debug (void ); ++ ++void yyset_debug (int debug_flag ); ++ ++YY_EXTRA_TYPE yyget_extra (void ); ++ ++void yyset_extra (YY_EXTRA_TYPE user_defined ); ++ ++FILE *yyget_in (void ); ++ ++void yyset_in (FILE * in_str ); ++ ++FILE *yyget_out (void ); ++ ++void yyset_out (FILE * out_str ); ++ ++int yyget_leng (void ); ++ ++char *yyget_text (void ); ++ ++int yyget_lineno (void ); ++ ++void yyset_lineno (int line_number ); ++ ++/* Macros after this point can all be overridden by user definitions in ++ * section 1. ++ */ ++ ++#ifndef YY_SKIP_YYWRAP ++#ifdef __cplusplus ++extern "C" int yywrap (void ); ++#else ++extern int yywrap (void ); ++#endif ++#endif ++ ++ static void yyunput (int c,char *buf_ptr ); ++ ++#ifndef yytext_ptr ++static void yy_flex_strncpy (char *,yyconst char *,int ); ++#endif ++ ++#ifdef YY_NEED_STRLEN ++static int yy_flex_strlen (yyconst char * ); ++#endif ++ ++#ifndef YY_NO_INPUT ++ ++#ifdef __cplusplus ++static int yyinput (void ); ++#else ++static int input (void ); ++#endif ++ ++#endif ++ ++/* Amount of stuff to slurp up with each read. */ ++#ifndef YY_READ_BUF_SIZE ++#define YY_READ_BUF_SIZE 8192 ++#endif ++ ++/* Copy whatever the last rule matched to the standard output. */ ++#ifndef ECHO ++/* This used to be an fputs(), but since the string might contain NUL's, ++ * we now use fwrite(). ++ */ ++#define ECHO fwrite( yytext, yyleng, 1, yyout ) ++#endif ++ ++/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, ++ * is returned in "result". ++ */ ++#ifndef YY_INPUT ++#define YY_INPUT(buf,result,max_size) \ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ ++ { \ ++ int c = '*'; \ ++ int n; \ ++ for ( n = 0; n < max_size && \ ++ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ ++ buf[n] = (char) c; \ ++ if ( c == '\n' ) \ ++ buf[n++] = (char) c; \ ++ if ( c == EOF && ferror( yyin ) ) \ ++ YY_FATAL_ERROR( "input in flex scanner failed" ); \ ++ result = n; \ ++ } \ ++ else \ ++ { \ ++ errno=0; \ ++ while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ ++ { \ ++ if( errno != EINTR) \ ++ { \ ++ YY_FATAL_ERROR( "input in flex scanner failed" ); \ ++ break; \ ++ } \ ++ errno=0; \ ++ clearerr(yyin); \ ++ } \ ++ }\ ++\ ++ ++#endif ++ ++/* No semi-colon after return; correct usage is to write "yyterminate();" - ++ * we don't want an extra ';' after the "return" because that will cause ++ * some compilers to complain about unreachable statements. ++ */ ++#ifndef yyterminate ++#define yyterminate() return YY_NULL ++#endif ++ ++/* Number of entries by which start-condition stack grows. */ ++#ifndef YY_START_STACK_INCR ++#define YY_START_STACK_INCR 25 ++#endif ++ ++/* Report a fatal error. */ ++#ifndef YY_FATAL_ERROR ++#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ++#endif ++ ++/* end tables serialization structures and prototypes */ ++ ++/* Default declaration of generated scanner - a define so the user can ++ * easily add parameters. ++ */ ++#ifndef YY_DECL ++#define YY_DECL_IS_OURS 1 ++ ++extern int yylex (void); ++ ++#define YY_DECL int yylex (void) ++#endif /* !YY_DECL */ ++ ++/* Code executed at the beginning of each rule, after yytext and yyleng ++ * have been set up. ++ */ ++#ifndef YY_USER_ACTION ++#define YY_USER_ACTION ++#endif ++ ++/* Code executed at the end of each rule. */ ++#ifndef YY_BREAK ++#define YY_BREAK break; ++#endif ++ ++#define YY_RULE_SETUP \ ++ YY_USER_ACTION ++ ++/** The main scanner function which does all the work. ++ */ ++YY_DECL ++{ ++ register yy_state_type yy_current_state; ++ register char *yy_cp, *yy_bp; ++ register int yy_act; ++ ++#line 109 "soapcpp2_lex.l" ++ ++#line 913 "soapcpp2_lex.c" ++ ++ if ( !(yy_init) ) ++ { ++ (yy_init) = 1; ++ ++#ifdef YY_USER_INIT ++ YY_USER_INIT; ++#endif ++ ++ /* Create the reject buffer large enough to save one state per allowed character. */ ++ if ( ! (yy_state_buf) ) ++ (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE ); ++ if ( ! (yy_state_buf) ) ++ YY_FATAL_ERROR( "out of dynamic memory in yylex()" ); ++ ++ if ( ! (yy_start) ) ++ (yy_start) = 1; /* first start state */ ++ ++ if ( ! yyin ) ++ yyin = stdin; ++ ++ if ( ! yyout ) ++ yyout = stdout; ++ ++ if ( ! YY_CURRENT_BUFFER ) { ++ yyensure_buffer_stack (); ++ YY_CURRENT_BUFFER_LVALUE = ++ yy_create_buffer(yyin,YY_BUF_SIZE ); ++ } ++ ++ yy_load_buffer_state( ); ++ } ++ ++ while ( 1 ) /* loops until end-of-file is reached */ ++ { ++ yy_cp = (yy_c_buf_p); ++ ++ /* Support of yytext. */ ++ *yy_cp = (yy_hold_char); ++ ++ /* yy_bp points to the position in yy_ch_buf of the start of ++ * the current run. ++ */ ++ yy_bp = yy_cp; ++ ++ yy_current_state = (yy_start); ++ ++ (yy_state_ptr) = (yy_state_buf); ++ *(yy_state_ptr)++ = yy_current_state; ++ ++yy_match: ++ do ++ { ++ register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; ++ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ++ { ++ yy_current_state = (int) yy_def[yy_current_state]; ++ if ( yy_current_state >= 132 ) ++ yy_c = yy_meta[(unsigned int) yy_c]; ++ } ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ *(yy_state_ptr)++ = yy_current_state; ++ ++yy_cp; ++ } ++ while ( yy_base[yy_current_state] != 278 ); ++ ++yy_find_action: ++ yy_current_state = *--(yy_state_ptr); ++ (yy_lp) = yy_accept[yy_current_state]; ++find_rule: /* we branch to this label when backing up */ ++ for ( ; ; ) /* until we find what rule we matched */ ++ { ++ if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] ) ++ { ++ yy_act = yy_acclist[(yy_lp)]; ++ if ( yy_act & YY_TRAILING_HEAD_MASK || ++ (yy_looking_for_trail_begin) ) ++ { ++ if ( yy_act == (yy_looking_for_trail_begin) ) ++ { ++ (yy_looking_for_trail_begin) = 0; ++ yy_act &= ~YY_TRAILING_HEAD_MASK; ++ break; ++ } ++ } ++ else if ( yy_act & YY_TRAILING_MASK ) ++ { ++ (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK; ++ (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK; ++ (yy_full_match) = yy_cp; ++ (yy_full_state) = (yy_state_ptr); ++ (yy_full_lp) = (yy_lp); ++ } ++ else ++ { ++ (yy_full_match) = yy_cp; ++ (yy_full_state) = (yy_state_ptr); ++ (yy_full_lp) = (yy_lp); ++ break; ++ } ++ ++(yy_lp); ++ goto find_rule; ++ } ++ --yy_cp; ++ yy_current_state = *--(yy_state_ptr); ++ (yy_lp) = yy_accept[yy_current_state]; ++ } ++ ++ YY_DO_BEFORE_ACTION; ++ ++ if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ++ { ++ int yyl; ++ for ( yyl = (yy_prev_more_offset); yyl < yyleng; ++yyl ) ++ if ( yytext[yyl] == '\n' ) ++ ++ yylineno++; ++; ++ } ++ ++do_action: /* This label is used only to access EOF actions. */ ++ ++ switch ( yy_act ) ++ { /* beginning of action switch */ ++case 1: ++/* rule 1 can match eol */ ++YY_RULE_SETUP ++#line 110 "soapcpp2_lex.l" ++{ /* skip white space */ } ++ YY_BREAK ++case 2: ++YY_RULE_SETUP ++#line 111 "soapcpp2_lex.l" ++{ BEGIN(MLCOMMENT); } ++ YY_BREAK ++case 3: ++/* rule 3 can match eol */ ++YY_RULE_SETUP ++#line 112 "soapcpp2_lex.l" ++{ } ++ YY_BREAK ++case 4: ++YY_RULE_SETUP ++#line 113 "soapcpp2_lex.l" ++{ BEGIN(INITIAL); } ++ YY_BREAK ++case YY_STATE_EOF(MLCOMMENT): ++#line 114 "soapcpp2_lex.l" ++{ execerror("Unclosed multiline comment at the end of file"); } ++ YY_BREAK ++case 5: ++/* rule 5 can match eol */ ++YY_RULE_SETUP ++#line 115 "soapcpp2_lex.l" ++{ option(); } ++ YY_BREAK ++case 6: ++/* rule 6 can match eol */ ++YY_RULE_SETUP ++#line 116 "soapcpp2_lex.l" ++{ directive(); } ++ YY_BREAK ++case 7: ++/* rule 7 can match eol */ ++YY_RULE_SETUP ++#line 117 "soapcpp2_lex.l" ++{ /* skip single line comment */ } ++ YY_BREAK ++case 8: ++YY_RULE_SETUP ++#line 118 "soapcpp2_lex.l" ++{ return PA; } ++ YY_BREAK ++case 9: ++YY_RULE_SETUP ++#line 119 "soapcpp2_lex.l" ++{ return NA; } ++ YY_BREAK ++case 10: ++YY_RULE_SETUP ++#line 120 "soapcpp2_lex.l" ++{ return TA; } ++ YY_BREAK ++case 11: ++YY_RULE_SETUP ++#line 121 "soapcpp2_lex.l" ++{ return DA; } ++ YY_BREAK ++case 12: ++YY_RULE_SETUP ++#line 122 "soapcpp2_lex.l" ++{ return MA; } ++ YY_BREAK ++case 13: ++YY_RULE_SETUP ++#line 123 "soapcpp2_lex.l" ++{ return AA; } ++ YY_BREAK ++case 14: ++YY_RULE_SETUP ++#line 124 "soapcpp2_lex.l" ++{ return XA; } ++ YY_BREAK ++case 15: ++YY_RULE_SETUP ++#line 125 "soapcpp2_lex.l" ++{ return OA; } ++ YY_BREAK ++case 16: ++YY_RULE_SETUP ++#line 126 "soapcpp2_lex.l" ++{ return LA; } ++ YY_BREAK ++case 17: ++YY_RULE_SETUP ++#line 127 "soapcpp2_lex.l" ++{ return RA; } ++ YY_BREAK ++case 18: ++YY_RULE_SETUP ++#line 128 "soapcpp2_lex.l" ++{ return OR; } ++ YY_BREAK ++case 19: ++YY_RULE_SETUP ++#line 129 "soapcpp2_lex.l" ++{ return AN; } ++ YY_BREAK ++case 20: ++YY_RULE_SETUP ++#line 130 "soapcpp2_lex.l" ++{ return EQ; } ++ YY_BREAK ++case 21: ++YY_RULE_SETUP ++#line 131 "soapcpp2_lex.l" ++{ return NE; } ++ YY_BREAK ++case 22: ++YY_RULE_SETUP ++#line 132 "soapcpp2_lex.l" ++{ return LE; } ++ YY_BREAK ++case 23: ++YY_RULE_SETUP ++#line 133 "soapcpp2_lex.l" ++{ return GE; } ++ YY_BREAK ++case 24: ++YY_RULE_SETUP ++#line 134 "soapcpp2_lex.l" ++{ return LS; } ++ YY_BREAK ++case 25: ++YY_RULE_SETUP ++#line 135 "soapcpp2_lex.l" ++{ return RS; } ++ YY_BREAK ++case 26: ++YY_RULE_SETUP ++#line 136 "soapcpp2_lex.l" ++{ return PP; } ++ YY_BREAK ++case 27: ++YY_RULE_SETUP ++#line 137 "soapcpp2_lex.l" ++{ return NN; } ++ YY_BREAK ++case 28: ++YY_RULE_SETUP ++#line 138 "soapcpp2_lex.l" ++{ return AR; } ++ YY_BREAK ++case 29: ++YY_RULE_SETUP ++#line 139 "soapcpp2_lex.l" ++{ return yytext[0]; } ++ YY_BREAK ++case 30: ++YY_RULE_SETUP ++#line 140 "soapcpp2_lex.l" ++{ return install_id(); } ++ YY_BREAK ++case 31: ++YY_RULE_SETUP ++#line 141 "soapcpp2_lex.l" ++{ return install_int(); } ++ YY_BREAK ++case 32: ++YY_RULE_SETUP ++#line 142 "soapcpp2_lex.l" ++{ return install_hex(); } ++ YY_BREAK ++case 33: ++YY_RULE_SETUP ++#line 143 "soapcpp2_lex.l" ++{ return install_num(); } ++ YY_BREAK ++case 34: ++YY_RULE_SETUP ++#line 144 "soapcpp2_lex.l" ++{ return install_chr(); } ++ YY_BREAK ++case 35: ++/* rule 35 can match eol */ ++YY_RULE_SETUP ++#line 145 "soapcpp2_lex.l" ++{ return install_str(); } ++ YY_BREAK ++case 36: ++/* rule 36 can match eol */ ++YY_RULE_SETUP ++#line 146 "soapcpp2_lex.l" ++{ char *s, *t, buf[1024]; ++ s = strchr(yytext, '"'); ++ if (!s) ++ t = yytext+7; ++ else ++ { strcpy(buf, s+1); ++ s = strchr(buf, '"'); ++ *s = '\0'; ++ t = strchr(s+1, '"'); ++ if (t) ++ { t++; ++ s = strchr(t+1, '"'); ++ if (s) ++ *s = '\0'; ++ } ++ } ++ module(buf, t); ++ } ++ YY_BREAK ++case 37: ++/* rule 37 can match eol */ ++YY_RULE_SETUP ++#line 164 "soapcpp2_lex.l" ++{ char *s, buf[1024]; ++ s = strchr(yytext, '"'); ++ if (s) ++ { strcpy(buf, s+1); ++ s = strchr(buf, '"'); ++ *s = '\0'; ++ import(buf); ++ } ++ else ++ lexerror("Invalid import directive"); ++ } ++ YY_BREAK ++case 38: ++/* rule 38 can match eol */ ++YY_RULE_SETUP ++#line 175 "soapcpp2_lex.l" ++{ return install_pragma(); } ++ YY_BREAK ++case 39: ++/* rule 39 can match eol */ ++YY_RULE_SETUP ++#line 176 "soapcpp2_lex.l" ++{ return error_chr(); } ++ YY_BREAK ++case 40: ++/* rule 40 can match eol */ ++YY_RULE_SETUP ++#line 177 "soapcpp2_lex.l" ++{ return error_str(); } ++ YY_BREAK ++case 41: ++YY_RULE_SETUP ++#line 178 "soapcpp2_lex.l" ++{ lexerror("Skipping unknown symbol"); } ++ YY_BREAK ++case YY_STATE_EOF(INITIAL): ++#line 179 "soapcpp2_lex.l" ++{ /* when Lex complains: remove this line and below */ ++#ifndef WITH_LEX ++ if (--imports < 0) ++ yyterminate(); ++ else ++ { yy_delete_buffer(YY_CURRENT_BUFFER); ++ yy_switch_to_buffer(instk[imports]); ++ strcpy(filename, fnstk[imports]); ++ yylineno = lnstk[imports]; ++ imported = imstk[imports]; ++ } ++#endif ++ } ++ YY_BREAK ++case 42: ++YY_RULE_SETUP ++#line 192 "soapcpp2_lex.l" ++ECHO; ++ YY_BREAK ++#line 1306 "soapcpp2_lex.c" ++ ++ case YY_END_OF_BUFFER: ++ { ++ /* Amount of text matched not including the EOB char. */ ++ int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; ++ ++ /* Undo the effects of YY_DO_BEFORE_ACTION. */ ++ *yy_cp = (yy_hold_char); ++ YY_RESTORE_YY_MORE_OFFSET ++ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ++ { ++ /* We're scanning a new file or input source. It's ++ * possible that this happened because the user ++ * just pointed yyin at a new source and called ++ * yylex(). If so, then we have to assure ++ * consistency between YY_CURRENT_BUFFER and our ++ * globals. Here is the right place to do so, because ++ * this is the first action (other than possibly a ++ * back-up) that will match for the new input source. ++ */ ++ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ++ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ++ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ++ } ++ ++ /* Note that here we test for yy_c_buf_p "<=" to the position ++ * of the first EOB in the buffer, since yy_c_buf_p will ++ * already have been incremented past the NUL character ++ * (since all states make transitions on EOB to the ++ * end-of-buffer state). Contrast this with the test ++ * in input(). ++ */ ++ if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) ++ { /* This was really a NUL. */ ++ yy_state_type yy_next_state; ++ ++ (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; ++ ++ yy_current_state = yy_get_previous_state( ); ++ ++ /* Okay, we're now positioned to make the NUL ++ * transition. We couldn't have ++ * yy_get_previous_state() go ahead and do it ++ * for us because it doesn't know how to deal ++ * with the possibility of jamming (and we don't ++ * want to build jamming into it because then it ++ * will run more slowly). ++ */ ++ ++ yy_next_state = yy_try_NUL_trans( yy_current_state ); ++ ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ++ ++ if ( yy_next_state ) ++ { ++ /* Consume the NUL. */ ++ yy_cp = ++(yy_c_buf_p); ++ yy_current_state = yy_next_state; ++ goto yy_match; ++ } ++ ++ else ++ { ++ yy_cp = (yy_c_buf_p); ++ goto yy_find_action; ++ } ++ } ++ ++ else switch ( yy_get_next_buffer( ) ) ++ { ++ case EOB_ACT_END_OF_FILE: ++ { ++ (yy_did_buffer_switch_on_eof) = 0; ++ ++ if ( yywrap( ) ) ++ { ++ /* Note: because we've taken care in ++ * yy_get_next_buffer() to have set up ++ * yytext, we can now set up ++ * yy_c_buf_p so that if some total ++ * hoser (like flex itself) wants to ++ * call the scanner after we return the ++ * YY_NULL, it'll still work - another ++ * YY_NULL will get returned. ++ */ ++ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ++ ++ yy_act = YY_STATE_EOF(YY_START); ++ goto do_action; ++ } ++ ++ else ++ { ++ if ( ! (yy_did_buffer_switch_on_eof) ) ++ YY_NEW_FILE; ++ } ++ break; ++ } ++ ++ case EOB_ACT_CONTINUE_SCAN: ++ (yy_c_buf_p) = ++ (yytext_ptr) + yy_amount_of_matched_text; ++ ++ yy_current_state = yy_get_previous_state( ); ++ ++ yy_cp = (yy_c_buf_p); ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ++ goto yy_match; ++ ++ case EOB_ACT_LAST_MATCH: ++ (yy_c_buf_p) = ++ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; ++ ++ yy_current_state = yy_get_previous_state( ); ++ ++ yy_cp = (yy_c_buf_p); ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ++ goto yy_find_action; ++ } ++ break; ++ } ++ ++ default: ++ YY_FATAL_ERROR( ++ "fatal flex scanner internal error--no action found" ); ++ } /* end of action switch */ ++ } /* end of scanning one token */ ++} /* end of yylex */ ++ ++/* yy_get_next_buffer - try to read in a new buffer ++ * ++ * Returns a code representing an action: ++ * EOB_ACT_LAST_MATCH - ++ * EOB_ACT_CONTINUE_SCAN - continue scanning from current position ++ * EOB_ACT_END_OF_FILE - end of file ++ */ ++static int yy_get_next_buffer (void) ++{ ++ register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ++ register char *source = (yytext_ptr); ++ register int number_to_move, i; ++ int ret_val; ++ ++ if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) ++ YY_FATAL_ERROR( ++ "fatal flex scanner internal error--end of buffer missed" ); ++ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ++ { /* Don't try to fill the buffer, so this is an EOF. */ ++ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) ++ { ++ /* We matched a single character, the EOB, so ++ * treat this as a final EOF. ++ */ ++ return EOB_ACT_END_OF_FILE; ++ } ++ ++ else ++ { ++ /* We matched some text prior to the EOB, first ++ * process it. ++ */ ++ return EOB_ACT_LAST_MATCH; ++ } ++ } ++ ++ /* Try to read more data. */ ++ ++ /* First move last chars to start of buffer. */ ++ number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; ++ ++ for ( i = 0; i < number_to_move; ++i ) ++ *(dest++) = *(source++); ++ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ++ /* don't do the read, it's not guaranteed to return an EOF, ++ * just force an EOF ++ */ ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; ++ ++ else ++ { ++ int num_to_read = ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ++ ++ while ( num_to_read <= 0 ) ++ { /* Not enough room in the buffer - grow it. */ ++ ++ YY_FATAL_ERROR( ++"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); ++ ++ } ++ ++ if ( num_to_read > YY_READ_BUF_SIZE ) ++ num_to_read = YY_READ_BUF_SIZE; ++ ++ /* 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_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ++ } ++ ++ if ( (yy_n_chars) == 0 ) ++ { ++ if ( number_to_move == YY_MORE_ADJ ) ++ { ++ ret_val = EOB_ACT_END_OF_FILE; ++ yyrestart(yyin ); ++ } ++ ++ else ++ { ++ ret_val = EOB_ACT_LAST_MATCH; ++ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ++ YY_BUFFER_EOF_PENDING; ++ } ++ } ++ ++ else ++ ret_val = EOB_ACT_CONTINUE_SCAN; ++ ++ if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ++ /* Extend the array by 50%, plus the number we really need. */ ++ yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); ++ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ++ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ++ } ++ ++ (yy_n_chars) += number_to_move; ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ++ ++ (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ++ ++ return ret_val; ++} ++ ++/* yy_get_previous_state - get the state just before the EOB char was reached */ ++ ++ static yy_state_type yy_get_previous_state (void) ++{ ++ register yy_state_type yy_current_state; ++ register char *yy_cp; ++ ++ yy_current_state = (yy_start); ++ ++ (yy_state_ptr) = (yy_state_buf); ++ *(yy_state_ptr)++ = yy_current_state; ++ ++ 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); ++ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ++ { ++ yy_current_state = (int) yy_def[yy_current_state]; ++ if ( yy_current_state >= 132 ) ++ yy_c = yy_meta[(unsigned int) yy_c]; ++ } ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ *(yy_state_ptr)++ = yy_current_state; ++ } ++ ++ return yy_current_state; ++} ++ ++/* yy_try_NUL_trans - try to make a transition on the NUL character ++ * ++ * synopsis ++ * next_state = yy_try_NUL_trans( current_state ); ++ */ ++ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) ++{ ++ register int yy_is_jam; ++ ++ register YY_CHAR yy_c = 1; ++ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ++ { ++ yy_current_state = (int) yy_def[yy_current_state]; ++ if ( yy_current_state >= 132 ) ++ yy_c = yy_meta[(unsigned int) yy_c]; ++ } ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ yy_is_jam = (yy_current_state == 131); ++ if ( ! yy_is_jam ) ++ *(yy_state_ptr)++ = yy_current_state; ++ ++ return yy_is_jam ? 0 : yy_current_state; ++} ++ ++ static void yyunput (int c, register char * yy_bp ) ++{ ++ register char *yy_cp; ++ ++ yy_cp = (yy_c_buf_p); ++ ++ /* undo effects of setting up yytext */ ++ *yy_cp = (yy_hold_char); ++ ++ 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[ ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; ++ register char *source = ++ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; ++ ++ while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ++ *--dest = *--source; ++ ++ 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; ++ ++ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) ++ YY_FATAL_ERROR( "flex scanner push-back overflow" ); ++ } ++ ++ *--yy_cp = (char) c; ++ ++ if ( c == '\n' ){ ++ --yylineno; ++ } ++ ++ (yytext_ptr) = yy_bp; ++ (yy_hold_char) = *yy_cp; ++ (yy_c_buf_p) = yy_cp; ++} ++ ++#ifndef YY_NO_INPUT ++#ifdef __cplusplus ++ static int yyinput (void) ++#else ++ static int input (void) ++#endif ++ ++{ ++ int c; ++ ++ *(yy_c_buf_p) = (yy_hold_char); ++ ++ if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) ++ { ++ /* yy_c_buf_p now points to the character we want to return. ++ * If this occurs *before* the EOB characters, then it's a ++ * valid NUL; if not, then we've hit the end of the buffer. ++ */ ++ if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) ++ /* This was really a NUL. */ ++ *(yy_c_buf_p) = '\0'; ++ ++ else ++ { /* need more input */ ++ int offset = (yy_c_buf_p) - (yytext_ptr); ++ ++(yy_c_buf_p); ++ ++ switch ( yy_get_next_buffer( ) ) ++ { ++ case EOB_ACT_LAST_MATCH: ++ /* This happens because yy_g_n_b() ++ * sees that we've accumulated a ++ * token and flags that we need to ++ * try matching the token before ++ * proceeding. But for input(), ++ * there's no matching to consider. ++ * So convert the EOB_ACT_LAST_MATCH ++ * to EOB_ACT_END_OF_FILE. ++ */ ++ ++ /* Reset buffer status. */ ++ yyrestart(yyin ); ++ ++ /*FALLTHROUGH*/ ++ ++ case EOB_ACT_END_OF_FILE: ++ { ++ if ( yywrap( ) ) ++ return EOF; ++ ++ if ( ! (yy_did_buffer_switch_on_eof) ) ++ YY_NEW_FILE; ++#ifdef __cplusplus ++ return yyinput(); ++#else ++ return input(); ++#endif ++ } ++ ++ case EOB_ACT_CONTINUE_SCAN: ++ (yy_c_buf_p) = (yytext_ptr) + offset; ++ break; ++ } ++ } ++ } ++ ++ c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ ++ *(yy_c_buf_p) = '\0'; /* preserve yytext */ ++ (yy_hold_char) = *++(yy_c_buf_p); ++ ++ if ( c == '\n' ) ++ ++ yylineno++; ++; ++ ++ return c; ++} ++#endif /* ifndef YY_NO_INPUT */ ++ ++/** Immediately switch to a different input stream. ++ * @param input_file A readable stream. ++ * ++ * @note This function does not reset the start condition to @c INITIAL . ++ */ ++ void yyrestart (FILE * input_file ) ++{ ++ ++ if ( ! YY_CURRENT_BUFFER ){ ++ yyensure_buffer_stack (); ++ YY_CURRENT_BUFFER_LVALUE = ++ yy_create_buffer(yyin,YY_BUF_SIZE ); ++ } ++ ++ yy_init_buffer(YY_CURRENT_BUFFER,input_file ); ++ yy_load_buffer_state( ); ++} ++ ++/** Switch to a different input buffer. ++ * @param new_buffer The new input buffer. ++ * ++ */ ++ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) ++{ ++ ++ /* TODO. We should be able to replace this entire function body ++ * with ++ * yypop_buffer_state(); ++ * yypush_buffer_state(new_buffer); ++ */ ++ yyensure_buffer_stack (); ++ if ( YY_CURRENT_BUFFER == new_buffer ) ++ return; ++ ++ if ( YY_CURRENT_BUFFER ) ++ { ++ /* Flush out information for old buffer. */ ++ *(yy_c_buf_p) = (yy_hold_char); ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ++ } ++ ++ YY_CURRENT_BUFFER_LVALUE = new_buffer; ++ yy_load_buffer_state( ); ++ ++ /* We don't actually know whether we did this switch during ++ * EOF (yywrap()) processing, but the only time this flag ++ * is looked at is after yywrap() is called, so it's safe ++ * to go ahead and always set it. ++ */ ++ (yy_did_buffer_switch_on_eof) = 1; ++} ++ ++static void yy_load_buffer_state (void) ++{ ++ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ++ (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ++ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ++ (yy_hold_char) = *(yy_c_buf_p); ++} ++ ++/** Allocate and initialize an input buffer state. ++ * @param file A readable stream. ++ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. ++ * ++ * @return the allocated buffer state. ++ */ ++ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) ++{ ++ YY_BUFFER_STATE b; ++ ++ b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); ++ if ( ! b ) ++ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ++ ++ b->yy_buf_size = size; ++ ++ /* yy_ch_buf has to be 2 characters longer than the size given because ++ * we need to put in 2 end-of-buffer characters. ++ */ ++ b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); ++ if ( ! b->yy_ch_buf ) ++ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ++ ++ b->yy_is_our_buffer = 1; ++ ++ yy_init_buffer(b,file ); ++ ++ return b; ++} ++ ++/** Destroy the buffer. ++ * @param b a buffer created with yy_create_buffer() ++ * ++ */ ++ void yy_delete_buffer (YY_BUFFER_STATE b ) ++{ ++ ++ if ( ! b ) ++ return; ++ ++ if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ++ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ++ ++ if ( b->yy_is_our_buffer ) ++ yyfree((void *) b->yy_ch_buf ); ++ ++ yyfree((void *) b ); ++} ++ ++#ifndef __cplusplus ++extern int isatty (int ); ++#endif /* __cplusplus */ ++ ++/* Initializes or reinitializes a buffer. ++ * This function is sometimes called more than once on the same buffer, ++ * such as during a yyrestart() or at EOF. ++ */ ++ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) ++ ++{ ++ int oerrno = errno; ++ ++ yy_flush_buffer(b ); ++ ++ b->yy_input_file = file; ++ b->yy_fill_buffer = 1; ++ ++ /* If b is the current buffer, then yy_init_buffer was _probably_ ++ * called from yyrestart() or through yy_get_next_buffer. ++ * In that case, we don't want to reset the lineno or column. ++ */ ++ if (b != YY_CURRENT_BUFFER){ ++ b->yy_bs_lineno = 1; ++ b->yy_bs_column = 0; ++ } ++ ++ b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ++ ++ errno = oerrno; ++} ++ ++/** Discard all buffered characters. On the next scan, YY_INPUT will be called. ++ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. ++ * ++ */ ++ void yy_flush_buffer (YY_BUFFER_STATE b ) ++{ ++ if ( ! b ) ++ return; ++ ++ b->yy_n_chars = 0; ++ ++ /* We always need two end-of-buffer characters. The first causes ++ * a transition to the end-of-buffer state. The second causes ++ * a jam in that state. ++ */ ++ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ++ b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ++ ++ b->yy_buf_pos = &b->yy_ch_buf[0]; ++ ++ b->yy_at_bol = 1; ++ b->yy_buffer_status = YY_BUFFER_NEW; ++ ++ if ( b == YY_CURRENT_BUFFER ) ++ yy_load_buffer_state( ); ++} ++ ++/** Pushes the new state onto the stack. The new state becomes ++ * the current state. This function will allocate the stack ++ * if necessary. ++ * @param new_buffer The new state. ++ * ++ */ ++void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) ++{ ++ if (new_buffer == NULL) ++ return; ++ ++ yyensure_buffer_stack(); ++ ++ /* This block is copied from yy_switch_to_buffer. */ ++ if ( YY_CURRENT_BUFFER ) ++ { ++ /* Flush out information for old buffer. */ ++ *(yy_c_buf_p) = (yy_hold_char); ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ++ } ++ ++ /* Only push if top exists. Otherwise, replace top. */ ++ if (YY_CURRENT_BUFFER) ++ (yy_buffer_stack_top)++; ++ YY_CURRENT_BUFFER_LVALUE = new_buffer; ++ ++ /* copied from yy_switch_to_buffer. */ ++ yy_load_buffer_state( ); ++ (yy_did_buffer_switch_on_eof) = 1; ++} ++ ++/** Removes and deletes the top of the stack, if present. ++ * The next element becomes the new top. ++ * ++ */ ++void yypop_buffer_state (void) ++{ ++ if (!YY_CURRENT_BUFFER) ++ return; ++ ++ yy_delete_buffer(YY_CURRENT_BUFFER ); ++ YY_CURRENT_BUFFER_LVALUE = NULL; ++ if ((yy_buffer_stack_top) > 0) ++ --(yy_buffer_stack_top); ++ ++ if (YY_CURRENT_BUFFER) { ++ yy_load_buffer_state( ); ++ (yy_did_buffer_switch_on_eof) = 1; ++ } ++} ++ ++/* Allocates the stack if it does not exist. ++ * Guarantees space for at least one push. ++ */ ++static void yyensure_buffer_stack (void) ++{ ++ int num_to_alloc; ++ ++ if (!(yy_buffer_stack)) { ++ ++ /* First allocation is just for 2 elements, since we don't know if this ++ * scanner will even need a stack. We use 2 instead of 1 to avoid an ++ * immediate realloc on the next call. ++ */ ++ num_to_alloc = 1; ++ (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc ++ (num_to_alloc * sizeof(struct yy_buffer_state*) ++ ); ++ if ( ! (yy_buffer_stack) ) ++ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ++ ++ memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); ++ ++ (yy_buffer_stack_max) = num_to_alloc; ++ (yy_buffer_stack_top) = 0; ++ return; ++ } ++ ++ if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ ++ ++ /* Increase the buffer to prepare for a possible push. */ ++ int grow_size = 8 /* arbitrary grow size */; ++ ++ num_to_alloc = (yy_buffer_stack_max) + grow_size; ++ (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ++ ((yy_buffer_stack), ++ num_to_alloc * sizeof(struct yy_buffer_state*) ++ ); ++ if ( ! (yy_buffer_stack) ) ++ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ++ ++ /* zero only the new slots.*/ ++ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); ++ (yy_buffer_stack_max) = num_to_alloc; ++ } ++} ++ ++/** Setup the input buffer state to scan directly from a user-specified character buffer. ++ * @param base the character buffer ++ * @param size the size in bytes of the character buffer ++ * ++ * @return the newly allocated buffer state object. ++ */ ++YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) ++{ ++ YY_BUFFER_STATE b; ++ ++ if ( size < 2 || ++ base[size-2] != YY_END_OF_BUFFER_CHAR || ++ base[size-1] != YY_END_OF_BUFFER_CHAR ) ++ /* They forgot to leave room for the EOB's. */ ++ return 0; ++ ++ b = (YY_BUFFER_STATE) 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_pos = b->yy_ch_buf = base; ++ b->yy_is_our_buffer = 0; ++ b->yy_input_file = 0; ++ 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 ); ++ ++ return b; ++} ++ ++/** Setup the input buffer state to scan a string. The next call to yylex() will ++ * scan from a @e copy of @a str. ++ * @param yystr a NUL-terminated string to scan ++ * ++ * @return the newly allocated buffer state object. ++ * @note If you want to scan bytes that may contain NUL values, then use ++ * yy_scan_bytes() instead. ++ */ ++YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) ++{ ++ ++ return yy_scan_bytes(yystr,strlen(yystr) ); ++} ++ ++/** Setup the input buffer state to scan the given bytes. The next call to yylex() will ++ * scan from a @e copy of @a bytes. ++ * @param bytes the byte buffer to scan ++ * @param len the number of bytes in the buffer pointed to by @a bytes. ++ * ++ * @return the newly allocated buffer state object. ++ */ ++YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) ++{ ++ YY_BUFFER_STATE b; ++ char *buf; ++ yy_size_t n; ++ int i; ++ ++ /* Get memory for full buffer, including space for trailing EOB's. */ ++ n = _yybytes_len + 2; ++ buf = (char *) yyalloc(n ); ++ if ( ! buf ) ++ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ++ ++ for ( i = 0; i < _yybytes_len; ++i ) ++ buf[i] = yybytes[i]; ++ ++ buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ++ ++ b = yy_scan_buffer(buf,n ); ++ if ( ! b ) ++ YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ++ ++ /* It's okay to grow etc. this buffer, and we should throw it ++ * away when we're done. ++ */ ++ b->yy_is_our_buffer = 1; ++ ++ return b; ++} ++ ++#ifndef YY_EXIT_FAILURE ++#define YY_EXIT_FAILURE 2 ++#endif ++ ++static void yy_fatal_error (yyconst char* msg ) ++{ ++ (void) fprintf( stderr, "%s\n", msg ); ++ exit( YY_EXIT_FAILURE ); ++} ++ ++/* Redefine yyless() so it works in section 3 code. */ ++ ++#undef yyless ++#define yyless(n) \ ++ do \ ++ { \ ++ /* Undo effects of setting up yytext. */ \ ++ int yyless_macro_arg = (n); \ ++ YY_LESS_LINENO(yyless_macro_arg);\ ++ yytext[yyleng] = (yy_hold_char); \ ++ (yy_c_buf_p) = yytext + yyless_macro_arg; \ ++ (yy_hold_char) = *(yy_c_buf_p); \ ++ *(yy_c_buf_p) = '\0'; \ ++ yyleng = yyless_macro_arg; \ ++ } \ ++ while ( 0 ) ++ ++/* Accessor methods (get/set functions) to struct members. */ ++ ++/** Get the current line number. ++ * ++ */ ++int yyget_lineno (void) ++{ ++ ++ return yylineno; ++} ++ ++/** Get the input stream. ++ * ++ */ ++FILE *yyget_in (void) ++{ ++ return yyin; ++} ++ ++/** Get the output stream. ++ * ++ */ ++FILE *yyget_out (void) ++{ ++ return yyout; ++} ++ ++/** Get the length of the current token. ++ * ++ */ ++int yyget_leng (void) ++{ ++ return yyleng; ++} ++ ++/** Get the current token. ++ * ++ */ ++ ++char *yyget_text (void) ++{ ++ return yytext; ++} ++ ++/** Set the current line number. ++ * @param line_number ++ * ++ */ ++void yyset_lineno (int line_number ) ++{ ++ ++ yylineno = line_number; ++} ++ ++/** Set the input stream. This does not discard the current ++ * input buffer. ++ * @param in_str A readable stream. ++ * ++ * @see yy_switch_to_buffer ++ */ ++void yyset_in (FILE * in_str ) ++{ ++ yyin = in_str ; ++} ++ ++void yyset_out (FILE * out_str ) ++{ ++ yyout = out_str ; ++} ++ ++int yyget_debug (void) ++{ ++ return yy_flex_debug; ++} ++ ++void yyset_debug (int bdebug ) ++{ ++ yy_flex_debug = bdebug ; ++} ++ ++static int yy_init_globals (void) ++{ ++ /* Initialization is the same as for the non-reentrant scanner. ++ * This function is called from yylex_destroy(), so don't allocate here. ++ */ ++ ++ /* We do not touch yylineno unless the option is enabled. */ ++ yylineno = 1; ++ ++ (yy_buffer_stack) = 0; ++ (yy_buffer_stack_top) = 0; ++ (yy_buffer_stack_max) = 0; ++ (yy_c_buf_p) = (char *) 0; ++ (yy_init) = 0; ++ (yy_start) = 0; ++ ++ (yy_state_buf) = 0; ++ (yy_state_ptr) = 0; ++ (yy_full_match) = 0; ++ (yy_lp) = 0; ++ ++/* Defined in main.c */ ++#ifdef YY_STDINIT ++ yyin = stdin; ++ yyout = stdout; ++#else ++ yyin = (FILE *) 0; ++ yyout = (FILE *) 0; ++#endif ++ ++ /* For future reference: Set errno on error, since we are called by ++ * yylex_init() ++ */ ++ return 0; ++} ++ ++/* yylex_destroy is for both reentrant and non-reentrant scanners. */ ++int yylex_destroy (void) ++{ ++ ++ /* Pop the buffer stack, destroying each element. */ ++ while(YY_CURRENT_BUFFER){ ++ yy_delete_buffer(YY_CURRENT_BUFFER ); ++ YY_CURRENT_BUFFER_LVALUE = NULL; ++ yypop_buffer_state(); ++ } ++ ++ /* Destroy the stack itself. */ ++ yyfree((yy_buffer_stack) ); ++ (yy_buffer_stack) = NULL; ++ ++ yyfree ( (yy_state_buf) ); ++ (yy_state_buf) = NULL; ++ ++ /* Reset the globals. This is important in a non-reentrant scanner so the next time ++ * yylex() is called, initialization will occur. */ ++ yy_init_globals( ); ++ ++ return 0; ++} ++ ++/* ++ * Internal utility routines. ++ */ ++ ++#ifndef yytext_ptr ++static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) ++{ ++ register int i; ++ for ( i = 0; i < n; ++i ) ++ s1[i] = s2[i]; ++} ++#endif ++ ++#ifdef YY_NEED_STRLEN ++static int yy_flex_strlen (yyconst char * s ) ++{ ++ register int n; ++ for ( n = 0; s[n]; ++n ) ++ ; ++ ++ return n; ++} ++#endif ++ ++void *yyalloc (yy_size_t size ) ++{ ++ return (void *) 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 ++ * because both ANSI C and C++ allow castless assignment from ++ * any pointer type to void*, and deal with argument conversions ++ * as though doing an assignment. ++ */ ++ return (void *) realloc( (char *) ptr, size ); ++} ++ ++void yyfree (void * ptr ) ++{ ++ free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ ++} ++ ++#define YYTABLES_NAME "yytables" ++ ++#line 192 "soapcpp2_lex.l" ++ ++ ++ ++/* ++ install_id - lookup identifier in symbol table. If found, return token ++ and symbol table entry. If not found, create entry in symbol table and ++ return ID token. ++*/ ++static Token ++install_id() ++{ Symbol *p = lookup(yytext); ++ if (!p) ++ { int i, flag = 0; ++ p = install(yytext, ID); ++ /* [_](x|X)(m|M)(l|L)__ is OK */ ++ /* [_](x|X)(m|M)(l|L).* is not OK */ ++ /* .*__(x|X)(m|M)(l|L) is not OK */ ++ /* .*::(x|X)(m|M)(l|L) is not OK */ ++ for (i = 0; i < yyleng; i++) ++ { if ((yytext[i] == '_' && yytext[i+1] == '_') ++ || (yytext[i] == ':' && yytext[i+1] == ':')) ++ { flag = 1; ++ check_id(yytext + i + 2); ++ } ++ } ++ if (!flag && strcmp(yytext, "XML")) ++ check_id(yytext); ++ } ++ yylval.sym = p; ++ return p->token; ++} ++ ++/* ++ check_id - check for (x|X)(m|M)(l|L) ++*/ ++static void ++check_id(const char *s) ++{ while (*s == '_') ++ s++; ++ if ((s[0] == 'x' || s[0] == 'X') ++ && (s[1] == 'm' || s[1] == 'M') ++ && (s[2] == 'l' || s[2] == 'L')) ++ { sprintf(errbuf, "identifier '%s' starts with or embeds illegal '%3.3s' character sequence (for enum constants: please ignore this warning)", yytext, s); ++ semwarn(errbuf); ++ } ++} ++ ++/* ++ install_int - convert digits to integer and return LNG token. ++*/ ++static Token ++install_int() ++{ ++ sscanf(yytext, SOAP_ULONG_FORMAT, &yylval.i); ++ return LNG; ++} ++ ++/* ++ install_hex - convert hexadecimal digits to integer and return LNG ++*/ ++static Token ++install_hex() ++{ ++ sscanf(yytext, SOAP_XLONG_FORMAT, &yylval.i); ++ return LNG; ++} ++ ++/* ++ install_num - convert digits to floating point number and return DBL ++*/ ++static Token ++install_num() ++{ sscanf(yytext, "%lf", &yylval.r); ++ return DBL; ++} ++ ++/* ++ install_chr - convert character constant and return CHR. ++*/ ++static Token ++install_chr() ++{ int i = 2; ++ if (yytext[1] == '\\') ++ yylval.c = convchar(&i); ++ else yylval.c = yytext[i-1]; ++ if (yytext[i] != '\'') ++ lexerror("Illegal character constant"); ++ return CHR; ++} ++ ++/* ++ install_str - convert and store string in memory. Return STR. ++*/ ++static Token ++install_str() ++{ int i, j = 0; ++ yylval.s = emalloc(yyleng-1); /* yyleng = length(yytext) */ ++ for (i = 1; i < yyleng-1; i++) ++ if (yytext[i] == '\\') ++ { if (yytext[++i] != '\n') ++ { yylval.s[j++] = convchar(&i); ++ i--; ++ } ++ } ++ else ++ yylval.s[j++] = yytext[i]; ++ yylval.s[j] = '\0'; ++ return STR; ++} ++ ++/* ++ install_pragma - store pragma in string. Return PRAGMA. ++*/ ++static Token ++install_pragma() ++{ yylval.s = emalloc(yyleng); /* yyleng = length(yytext) */ ++ strncpy(yylval.s, yytext, strlen(yytext)-1); ++ yylval.s[strlen(yytext)-1] = '\0'; ++ return PRAGMA; ++} ++ ++static void directive() ++{ int i, j, k; ++ char *s; ++ Service *sp; ++ Method *m; ++ Data *d; ++ int service; ++ for (i = 7; yytext[i]; i++) ++ if (yytext[i] > 32) ++ break; ++ for (j = i; yytext[j]; j++) ++ if (yytext[j] <= 32) ++ break; ++ if (i == j) ++ return; ++ s = (char*)emalloc(j-i+1); ++ for (k = 0; k < j-i; k++) ++ { s[k] = yytext[k+i]; ++ if (s[k] == '_') ++ s[k] = '-'; ++ } ++ s[k] = '\0'; ++ for (sp = services; sp; sp = sp->next) ++ if (!strcmp(sp->ns, s)) ++ break; ++ if (!sp) ++ { sp = (Service*)emalloc(sizeof(Service)); ++ sp->next = services; ++ sp->ns = s; ++ sp->name = NULL; ++ sp->porttype = NULL; ++ sp->portname = NULL; ++ sp->binding = NULL; ++ sp->definitions = NULL; ++ sp->transport = NULL; ++ sp->URL = NULL; ++ sp->URI = NULL; ++ sp->WSDL = NULL; ++ sp->style = NULL; ++ sp->encoding = NULL; ++ sp->elementForm = NULL; ++ sp->attributeForm = NULL; ++ sp->executable = NULL; ++ sp->import = NULL; ++ sp->documentation = NULL; ++ sp->list = NULL; ++ sp->data = NULL; ++ services = sp; ++ } ++ for (i = j; yytext[i]; i++) ++ if (yytext[i] > 32) ++ break; ++ if (!strncmp(yytext+i, "service", 7) || !strncmp(yytext+i, "schema", 6)) ++ { service = strncmp(yytext+i, "schema", 6); ++ for (i += 7; yytext[i]; i++) ++ if (yytext[i] > 32) ++ break; ++ for (j = i; yytext[j]; j++) ++ if (yytext[j] <= 32) ++ break; ++ for (; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] <= 32) ++ break; ++ /* ++ if (j == k) ++ return; ++ */ ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ if (!strncmp(yytext+i, "name:", 5)) ++ { sp->name = s; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ sp->documentation = s; ++ } ++ else if (!strncmp(yytext+i, "type:", 5)) ++ sp->porttype = s; ++ else if (!strncmp(yytext+i, "portType:", 9)) ++ sp->porttype = s; ++ else if (!strncmp(yytext+i, "portName:", 9)) ++ sp->portname = s; ++ else if (!strncmp(yytext+i, "binding:", 8)) ++ sp->binding = s; ++ else if (!strncmp(yytext+i, "definitions:", 12)) ++ sp->definitions = s; ++ else if (!strncmp(yytext+i, "documentation:", 14)) ++ { for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ sp->documentation = s; ++ } ++ else if (!strncmp(yytext+i, "transport:", 10)) ++ sp->transport = s; ++ else if (!strncmp(yytext+i, "location:", 9) || !strncmp(yytext+i, "port:", 5)) ++ { if (sp->URL) ++ { char *t = (char*)emalloc(strlen(sp->URL) + strlen(s) + 2); ++ strcpy(t, sp->URL); ++ strcat(t, " "); ++ strcat(t, s); ++ sp->URL = t; ++ } ++ else ++ sp->URL = s; ++ if (!service && !sp->import) ++ sp->import = s; ++ } ++ else if (!strncmp(yytext+i, "executable:", 11)) ++ sp->executable = s; ++ else if (!strncmp(yytext+i, "namespace:", 10)) ++ { if (service) ++ { if (!sp->URI) ++ sp->URI = s; ++ sp->WSDL = s; ++ } ++ else if (!strcmp(sp->ns, "SOAP-ENV")) ++ { if (vflag) ++ semwarn("option -1 or -2 overrides SOAP-ENV namespace"); ++ else ++ envURI = s; ++ sp->URI = envURI; ++ } ++ else if (!strcmp(sp->ns, "SOAP-ENC")) ++ { if (vflag) ++ semwarn("option -1 or -2 overrides SOAP-ENC namespace"); ++ else ++ encURI = s; ++ sp->URI = encURI = s; ++ } ++ else ++ sp->URI = s; ++ } ++ else if (!strncmp(yytext+i, "form:", 5)) ++ { sp->elementForm = s; ++ sp->attributeForm = s; ++ } ++ else if (!strncmp(yytext+i, "elementForm:", 12)) ++ sp->elementForm = s; ++ else if (!strncmp(yytext+i, "attributeForm:", 14)) ++ sp->attributeForm = s; ++ else if (!strncmp(yytext+i, "import:", 7)) ++ { if (!sp->URI) ++ sp->URI = s; ++ sp->import = s; ++ } ++ else if (!strncmp(yytext+i, "encoding:", 9)) ++ { if (!strcmp(s, "encoded")) ++ sp->encoding = ""; ++ else ++ sp->encoding = s; ++ } ++ else if (!strncmp(yytext+i, "style:", 6)) ++ sp->style = s; ++ else if (!strncmp(yytext+i, "method-style:", 13)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = STYLE; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-encoding:", 16)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = ENCODING; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ if (strcmp(s, "encoded")) ++ m->part = s; ++ else ++ m->part = ""; ++ } ++ else if (!strncmp(yytext+i, "method-response-encoding:", 25)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = RESPONSE_ENCODING; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ if (strcmp(s, "encoded")) ++ m->part = s; ++ else ++ m->part = ""; ++ } ++ else if (!strncmp(yytext+i, "method-documentation:", 21)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = COMMENT; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-action:", 14)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = ACTION; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-response-action:", 23)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = RESPONSE_ACTION; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-mime-type:", 17)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = MIMEIN | MIMEOUT; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] <= 32) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-input-mime-type:", 23)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = MIMEIN; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] <= 32) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-output-mime-type:", 24)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = MIMEOUT; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] <= 32) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-header-part:", 19)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = HDRIN | HDROUT; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] <= 32) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-input-header-part:", 25)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = HDRIN; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] <= 32) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-output-header-part:", 26)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = HDROUT; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] <= 32) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "method-fault:", 13)) ++ { m = (Method*)emalloc(sizeof(Method)); ++ m->name = s; ++ m->mess = FAULT; ++ m->part = NULL; ++ m->next = sp->list; ++ sp->list = m; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] <= 32) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ m->part = s; ++ } ++ else if (!strncmp(yytext+i, "type-documentation:", 19)) ++ { d = (Data*)emalloc(sizeof(Data)); ++ d->name = s; ++ d->part = NULL; ++ d->next = sp->data; ++ sp->data = d; ++ for (j = k; yytext[j]; j++) ++ if (yytext[j] > 32) ++ break; ++ for (k = j; yytext[k]; k++) ++ if (yytext[k] == 10 || yytext[k] == 13) ++ break; ++ if (j == k) ++ return; ++ s = (char*)emalloc(k-j+1); ++ strncpy(s, yytext+j, k-j); ++ s[k-j] = '\0'; ++ d->part = s; ++ } ++ else ++ { sprintf(errbuf, "unrecognized gsoap directive: %s", yytext+i); ++ semwarn(errbuf); ++ } ++ } ++ else ++ { sprintf(errbuf, "unrecognized gsoap directive: %s", yytext); ++ semwarn(errbuf); ++ } ++} ++ ++static void option() ++{ int i; ++ if (imports) ++ { sprintf(errbuf, "options directive: %s ignored in imported file(s)", yytext); ++ semwarn(errbuf); ++ return; ++ } ++ for (i = 10; yytext[i]; i++) ++ if (yytext[i] > 32) ++ break; ++ for (; yytext[i]; i++) ++ switch (yytext[i]) ++ { case 'c': ++ cflag = 1; ++ break; ++ case 'e': ++ eflag = 1; ++ break; ++ case 'n': ++ nflag = 1; ++ break; ++ case 'l': ++ lflag = 1; ++ break; ++ case 't': ++ tflag = 1; ++ break; ++ case 'w': ++ wflag = 1; ++ break; ++ default: ++ if (yytext[i] <= 32) ++ return; ++ } ++} ++ ++/* ++ error_chr - lexical error in character constant. Return character 0 to ++ allow parsing to continue ++*/ ++static Token ++error_chr() ++{ lexerror("Ending-' missing in character constant"); ++ yylval.c = '\0'; ++ return CHR; ++} ++ ++/* ++ error_str - lexical error in string. Return empty string to allow ++ parsing to continue ++*/ ++static Token ++error_str() ++{ lexerror("Ending-\" missing in string"); ++ yylval.s = ""; ++ return STR; ++} ++ ++/* ++ Character conversion functions ++*/ ++static int ++convchar(int *p) ++{ switch (yytext[(*p)++]) ++ { case 'a': return '\a'; ++ case 'b': return '\b'; ++ case 'f': return '\f'; ++ case 'n': return '\n'; ++ case 'r': return '\r'; ++ case 't': return '\t'; ++ case 'v': return '\v'; ++ case 'x': return hexchar(p); ++ case '0': ++ case '1': ++ case '2': ++ case '3': ++ case '4': ++ case '5': ++ case '6': ++ case '7': (*p)--; ++ return octchar(p); ++ default: return yytext[*p-1]; ++ } ++} ++ ++static int ++hexchar(int *p) ++{ int i, d, c = 0; ++ for (i = 0; isxdigit(d = yytext[*p]) && i < 2; i++) ++ { c = (c << 4) + (d <= '9' ? d - '0' : toupper(d) - '7'); ++ (*p)++; ++ } ++ return c; ++} ++ ++static int ++octchar(int *p) ++{ int i, d, c = 0; ++ for (i = 0; (d = yytext[*p]) >= '0' && d <= '7' && i < 3; i++) ++ { c = (c << 3) + d - '0'; ++ (*p)++; ++ } ++ return c; ++} ++ ++static void module(const char *name, const char *fullname) ++{ if (!fullname) ++ fullname = name; ++ if (imports) ++ { Pragma **pp; ++ char *s = emalloc(strlen(fullname)+15); ++ sprintf(s, "#include \"%sH.h\"", fullname); ++ for (pp = &pragmas; *pp; pp = &(*pp)->next) ++ if (!strcmp((*pp)->pragma, s)) ++ break; ++ if (!*pp) ++ { *pp = (Pragma*)emalloc(sizeof(Pragma)); ++ (*pp)->pragma = s; ++ (*pp)->next = NULL; ++ } ++ imported = (char*)emalloc(strlen(fullname)+1); ++ strcpy(imported, fullname); ++ fprintf(stderr, "Importing module '%s'\n\n", fullname); ++ } ++ else ++ { lflag = 1; ++ typeNO = magic(name); ++ prefix = (char*)emalloc(strlen(fullname)+1); ++ strcpy(prefix, fullname); ++ fprintf(stderr, "Compiling module '%s' (magic number = %d)\n\n", fullname, typeNO); ++ } ++} ++ ++static int magic(const char *name) ++{ size_t i; ++ int n; ++ if (strlen(name) > 4) ++ semerror("#module name length must not exceed four characters"); ++ n = 0; ++ for (i = 0; i < strlen(name); i++) ++ if (name[i] >= 'a' && name[i] <= 'z') ++ n = 26*n + name[i] - 'a'; ++ else if (name[i] >= 'A' && name[i] <= 'Z') ++ n = 26*n + name[i] - 'A'; ++ else ++ semerror("#module name must be alphabetic and the length must not exceed four characters.\nUse '#module name longname' for longer names."); ++ return 4699*n + 153424; ++} ++ ++#ifdef WITH_LEX ++static void import(const char *file) ++{ execerror("Cannot #import: soapcpp2 not compiled with flex"); ++} ++#else ++static void import(const char *file) ++{ char buf[1024]; ++ struct importlist *p; ++ for (p = importlist; p; p = p->next) ++ if (!strcmp(p->name, file)) ++ return; ++ if (imports >= MAX_IMPORT_DEPTH) ++ execerror("Imports nested too deep"); ++ instk[imports] = YY_CURRENT_BUFFER; ++ strcpy(fnstk[imports], filename); ++ lnstk[imports] = yylineno; ++ imstk[imports] = imported; ++ /* imported = NULL; this is useful to change the semantics of #import to NOT consider non-module imports to be part of the current module */ ++ imports++; ++ if (!(yyin = fopen(file, "r"))) ++ { if (importpath) ++ { char *s, *t; ++ s = importpath; ++ do ++ { t = strstr(s, SOAP_PATHSEP); ++ if (t) ++ { if (t - s >= sizeof(buf)) ++ t = s + sizeof(buf) - 1; ++ strncpy(buf, s, t - s); ++ buf[t - s] = '\0'; ++ s = t + sizeof(SOAP_PATHSEP) - 1; ++ } ++ else ++ { strcpy(buf, s); ++ s = NULL; ++ } ++ strcat(buf, "/"); ++ strcat(buf, file); ++ yyin = fopen(buf, "r"); ++ } ++ while (s && !yyin); ++ } ++ if (!yyin) ++ { sprintf(errbuf, "#import: Cannot open file \"%s\" for reading.\nHint: use option -I<path> (you can define multiple paths separated with '"SOAP_PATHSEP"')", file); ++ execerror(errbuf); ++ } ++ } ++ p = (struct importlist*)malloc(sizeof(struct importlist) + strlen(file)); /* has already + 1 byte size */ ++ strcpy(p->name, file); ++ p->next = importlist; ++ importlist = p; ++ strcpy(filename, file); ++ yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE)); ++} ++#endif ++ +diff -urN d/gsoap/src/soapcpp2_yacc.c e/gsoap/src/soapcpp2_yacc.c +--- d/gsoap/src/soapcpp2_yacc.c 1970-01-01 01:00:00.000000000 +0100 ++++ e/gsoap/src/soapcpp2_yacc.c 2010-01-24 11:59:51.000000000 +0100 +@@ -0,0 +1,4716 @@ ++/* A Bison parser, made by GNU Bison 2.3. */ ++ ++/* 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 { ++ PRAGMA = 258, ++ AUTO = 259, ++ DOUBLE = 260, ++ INT = 261, ++ STRUCT = 262, ++ BREAK = 263, ++ ELSE = 264, ++ LONG = 265, ++ SWITCH = 266, ++ CASE = 267, ++ ENUM = 268, ++ REGISTER = 269, ++ TYPEDEF = 270, ++ CHAR = 271, ++ EXTERN = 272, ++ RETURN = 273, ++ UNION = 274, ++ CONST = 275, ++ FLOAT = 276, ++ SHORT = 277, ++ UNSIGNED = 278, ++ CONTINUE = 279, ++ FOR = 280, ++ SIGNED = 281, ++ VOID = 282, ++ DEFAULT = 283, ++ GOTO = 284, ++ SIZEOF = 285, ++ VOLATILE = 286, ++ DO = 287, ++ IF = 288, ++ STATIC = 289, ++ WHILE = 290, ++ CLASS = 291, ++ PRIVATE = 292, ++ PROTECTED = 293, ++ PUBLIC = 294, ++ VIRTUAL = 295, ++ INLINE = 296, ++ OPERATOR = 297, ++ LLONG = 298, ++ BOOL = 299, ++ CFALSE = 300, ++ CTRUE = 301, ++ WCHAR = 302, ++ TIME = 303, ++ USING = 304, ++ NAMESPACE = 305, ++ ULLONG = 306, ++ MUSTUNDERSTAND = 307, ++ SIZE = 308, ++ FRIEND = 309, ++ TEMPLATE = 310, ++ EXPLICIT = 311, ++ TYPENAME = 312, ++ RESTRICT = 313, ++ null = 314, ++ NONE = 315, ++ ID = 316, ++ LAB = 317, ++ TYPE = 318, ++ LNG = 319, ++ DBL = 320, ++ CHR = 321, ++ STR = 322, ++ RA = 323, ++ LA = 324, ++ OA = 325, ++ XA = 326, ++ AA = 327, ++ MA = 328, ++ DA = 329, ++ TA = 330, ++ NA = 331, ++ PA = 332, ++ OR = 333, ++ AN = 334, ++ NE = 335, ++ EQ = 336, ++ GE = 337, ++ LE = 338, ++ RS = 339, ++ LS = 340, ++ AR = 341, ++ PP = 342, ++ NN = 343 ++ }; ++#endif ++/* Tokens. */ ++#define PRAGMA 258 ++#define AUTO 259 ++#define DOUBLE 260 ++#define INT 261 ++#define STRUCT 262 ++#define BREAK 263 ++#define ELSE 264 ++#define LONG 265 ++#define SWITCH 266 ++#define CASE 267 ++#define ENUM 268 ++#define REGISTER 269 ++#define TYPEDEF 270 ++#define CHAR 271 ++#define EXTERN 272 ++#define RETURN 273 ++#define UNION 274 ++#define CONST 275 ++#define FLOAT 276 ++#define SHORT 277 ++#define UNSIGNED 278 ++#define CONTINUE 279 ++#define FOR 280 ++#define SIGNED 281 ++#define VOID 282 ++#define DEFAULT 283 ++#define GOTO 284 ++#define SIZEOF 285 ++#define VOLATILE 286 ++#define DO 287 ++#define IF 288 ++#define STATIC 289 ++#define WHILE 290 ++#define CLASS 291 ++#define PRIVATE 292 ++#define PROTECTED 293 ++#define PUBLIC 294 ++#define VIRTUAL 295 ++#define INLINE 296 ++#define OPERATOR 297 ++#define LLONG 298 ++#define BOOL 299 ++#define CFALSE 300 ++#define CTRUE 301 ++#define WCHAR 302 ++#define TIME 303 ++#define USING 304 ++#define NAMESPACE 305 ++#define ULLONG 306 ++#define MUSTUNDERSTAND 307 ++#define SIZE 308 ++#define FRIEND 309 ++#define TEMPLATE 310 ++#define EXPLICIT 311 ++#define TYPENAME 312 ++#define RESTRICT 313 ++#define null 314 ++#define NONE 315 ++#define ID 316 ++#define LAB 317 ++#define TYPE 318 ++#define LNG 319 ++#define DBL 320 ++#define CHR 321 ++#define STR 322 ++#define RA 323 ++#define LA 324 ++#define OA 325 ++#define XA 326 ++#define AA 327 ++#define MA 328 ++#define DA 329 ++#define TA 330 ++#define NA 331 ++#define PA 332 ++#define OR 333 ++#define AN 334 ++#define NE 335 ++#define EQ 336 ++#define GE 337 ++#define LE 338 ++#define RS 339 ++#define LS 340 ++#define AR 341 ++#define PP 342 ++#define NN 343 ++ ++ ++ ++ ++/* Copy the first part of user declarations. */ ++#line 61 "soapcpp2_yacc.y" ++ ++ ++#include "soapcpp2.h" ++ ++#ifdef WIN32 ++#ifndef __STDC__ ++#define __STDC__ ++#endif ++#define YYINCLUDED_STDLIB_H ++#ifdef WIN32_WITHOUT_SOLARIS_FLEX ++extern int soapcpp2lex(); ++#else ++extern int yylex(); ++#endif ++#else ++extern int yylex(); ++#endif ++ ++extern int is_XML(Tnode*); ++ ++#define MAXNEST 16 /* max. nesting depth of scopes */ ++ ++struct Scope ++{ Table *table; ++ Entry *entry; ++ Node node; ++ LONG64 val; ++ int offset; ++ Bool grow; /* true if offset grows with declarations */ ++ Bool mask; /* true if enum is mask */ ++} stack[MAXNEST], /* stack of tables and offsets */ ++ *sp; /* current scope stack pointer */ ++ ++Table *classtable = (Table*)0, ++ *enumtable = (Table*)0, ++ *typetable = (Table*)0, ++ *booltable = (Table*)0, ++ *templatetable = (Table*)0; ++ ++char *namespaceid = NULL; ++int transient = 0; ++int permission = 0; ++int custom_header = 1; ++int custom_fault = 1; ++Pragma *pragmas = NULL; ++Tnode *qname = NULL; ++Tnode *xml = NULL; ++ ++/* function prototypes for support routine section */ ++static Entry *undefined(Symbol*); ++static Tnode *mgtype(Tnode*, Tnode*); ++static Node op(const char*, Node, Node), iop(const char*, Node, Node), relop(const char*, Node, Node); ++static void mkscope(Table*, int), enterscope(Table*, int), exitscope(); ++static int integer(Tnode*), real(Tnode*), numeric(Tnode*); ++static void add_soap(), add_XML(), add_qname(), add_header(Table*), add_fault(Table*), add_response(Entry*, Entry*), add_result(Tnode*); ++extern char *c_storage(Storage), *c_type(Tnode*), *c_ident(Tnode*); ++extern int is_primitive_or_string(Tnode*), is_stdstr(Tnode*), is_binary(Tnode*), is_external(Tnode*), is_mutable(Tnode*); ++ ++/* Temporaries used in semantic rules */ ++int i; ++char *s, *s1, *s2; ++Symbol *sym; ++Entry *p, *q; ++Tnode *t; ++Node tmp, c; ++Pragma **pp; ++ ++ ++ ++/* 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 135 "soapcpp2_yacc.y" ++{ Symbol *sym; ++ LONG64 i; ++ double r; ++ char c; ++ char *s; ++ Tnode *typ; ++ Storage sto; ++ Node rec; ++ Entry *e; ++} ++/* Line 187 of yacc.c. */ ++#line 352 "soapcpp2_yacc.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 365 "soapcpp2_yacc.c" ++ ++#ifdef short ++# undef short ++#endif ++ ++#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 <stddef.h> /* INFRINGES ON USER NAME SPACE */ ++# define YYSIZE_T size_t ++# else ++# define YYSIZE_T unsigned int ++# endif ++#endif ++ ++#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) ++ ++#ifndef YY_ ++# if YYENABLE_NLS ++# if ENABLE_NLS ++# include <libintl.h> /* 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 */ ++#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) ++#else ++static int ++YYID (i) ++ int i; ++#endif ++{ ++ return i; ++} ++#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 <alloca.h> /* INFRINGES ON USER NAME SPACE */ ++# elif defined _AIX ++# define YYSTACK_ALLOC __alloca ++# elif defined _MSC_VER ++# include <malloc.h> /* 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 <stdlib.h> /* 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 <stdlib.h> /* 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)) ++ ++#endif ++ ++/* YYFINAL -- State number of the termination state. */ ++#define YYFINAL 3 ++/* YYLAST -- Last index in YYTABLE. */ ++#define YYLAST 1011 ++ ++/* YYNTOKENS -- Number of terminals. */ ++#define YYNTOKENS 113 ++/* YYNNTS -- Number of nonterminals. */ ++#define YYNNTS 61 ++/* YYNRULES -- Number of rules. */ ++#define YYNRULES 229 ++/* YYNRULES -- Number of states. */ ++#define YYNSTATES 357 ++ ++/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ ++#define YYUNDEFTOK 2 ++#define YYMAXUTOK 343 ++ ++#define YYTRANSLATE(YYX) \ ++ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) ++ ++/* 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, 108, 2, 2, 2, 99, 86, 2, ++ 110, 111, 97, 95, 68, 96, 2, 98, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 81, 105, ++ 89, 69, 90, 80, 112, 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, 106, 2, 107, 85, 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, 103, 84, 104, 109, 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, 11, 12, 13, 14, ++ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, ++ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, ++ 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, ++ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, ++ 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, ++ 65, 66, 67, 70, 71, 72, 73, 74, 75, 76, ++ 77, 78, 79, 82, 83, 87, 88, 91, 92, 93, ++ 94, 100, 101, 102 ++}; ++ ++#if YYDEBUG ++/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in ++ YYRHS. */ ++static const yytype_uint16 yyprhs[] = ++{ ++ 0, 0, 3, 6, 7, 13, 15, 16, 19, 22, ++ 24, 27, 29, 31, 33, 34, 38, 43, 48, 53, ++ 58, 60, 62, 63, 64, 65, 67, 70, 74, 77, ++ 80, 84, 89, 95, 98, 100, 102, 104, 107, 110, ++ 113, 116, 119, 122, 125, 128, 131, 134, 137, 140, ++ 143, 146, 149, 152, 155, 158, 161, 164, 167, 170, ++ 173, 176, 179, 182, 185, 188, 191, 194, 197, 200, ++ 203, 206, 210, 214, 217, 219, 223, 231, 232, 233, ++ 235, 237, 241, 248, 249, 251, 255, 260, 261, 264, ++ 267, 269, 271, 274, 277, 279, 281, 283, 285, 287, ++ 289, 291, 293, 295, 297, 299, 301, 303, 305, 307, ++ 315, 321, 327, 335, 337, 341, 347, 353, 356, 359, ++ 365, 372, 375, 378, 385, 392, 401, 404, 407, 409, ++ 414, 417, 420, 423, 425, 427, 430, 433, 436, 438, ++ 441, 442, 443, 444, 445, 447, 448, 450, 452, 454, ++ 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, ++ 476, 477, 479, 480, 483, 484, 486, 487, 490, 493, ++ 494, 499, 503, 505, 506, 509, 511, 514, 518, 523, ++ 527, 528, 530, 532, 535, 538, 542, 544, 550, 552, ++ 554, 558, 560, 562, 566, 568, 570, 574, 578, 582, ++ 586, 590, 594, 598, 602, 606, 610, 614, 618, 622, ++ 626, 630, 634, 636, 639, 642, 645, 648, 651, 654, ++ 659, 661, 665, 667, 669, 671, 673, 675, 677, 679 ++}; ++ ++/* YYRHS -- A `-1'-separated list of the rules' RHS. */ ++static const yytype_int16 yyrhs[] = ++{ ++ 114, 0, -1, 115, 116, -1, -1, 50, 61, 103, ++ 117, 104, -1, 117, -1, -1, 117, 118, -1, 126, ++ 105, -1, 119, -1, 1, 105, -1, 121, -1, 122, ++ -1, 3, -1, -1, 126, 105, 120, -1, 37, 81, ++ 123, 120, -1, 38, 81, 124, 120, -1, 39, 81, ++ 125, 120, -1, 121, 120, 122, 120, -1, 106, -1, ++ 107, -1, -1, -1, -1, 140, -1, 140, 127, -1, ++ 140, 128, 133, -1, 131, 133, -1, 132, 133, -1, ++ 126, 68, 127, -1, 126, 68, 128, 133, -1, 157, ++ 61, 159, 161, 160, -1, 157, 130, -1, 61, -1, ++ 63, -1, 61, -1, 42, 108, -1, 42, 109, -1, ++ 42, 69, -1, 42, 79, -1, 42, 78, -1, 42, ++ 77, -1, 42, 76, -1, 42, 75, -1, 42, 74, ++ -1, 42, 73, -1, 42, 72, -1, 42, 71, -1, ++ 42, 70, -1, 42, 82, -1, 42, 83, -1, 42, ++ 84, -1, 42, 85, -1, 42, 86, -1, 42, 88, ++ -1, 42, 87, -1, 42, 89, -1, 42, 92, -1, ++ 42, 90, -1, 42, 91, -1, 42, 94, -1, 42, ++ 93, -1, 42, 95, -1, 42, 96, -1, 42, 97, ++ -1, 42, 98, -1, 42, 99, -1, 42, 101, -1, ++ 42, 102, -1, 42, 100, -1, 42, 106, 107, -1, ++ 42, 110, 111, -1, 42, 139, -1, 63, -1, 156, ++ 109, 63, -1, 134, 110, 152, 135, 111, 154, 155, ++ -1, -1, -1, 136, -1, 137, -1, 137, 68, 136, ++ -1, 141, 157, 138, 159, 161, 160, -1, -1, 61, ++ -1, 141, 157, 158, -1, 141, 157, 61, 158, -1, ++ -1, 153, 140, -1, 142, 140, -1, 153, -1, 142, ++ -1, 153, 141, -1, 142, 141, -1, 27, -1, 44, ++ -1, 16, -1, 47, -1, 22, -1, 6, -1, 10, ++ -1, 43, -1, 51, -1, 53, -1, 21, -1, 5, ++ -1, 26, -1, 23, -1, 48, -1, 55, 89, 146, ++ 129, 90, 36, 129, -1, 36, 103, 148, 120, 104, ++ -1, 144, 103, 148, 120, 104, -1, 144, 81, 147, ++ 103, 148, 120, 104, -1, 144, -1, 144, 81, 147, ++ -1, 7, 103, 148, 120, 104, -1, 143, 103, 148, ++ 120, 104, -1, 7, 61, -1, 7, 63, -1, 19, ++ 103, 149, 120, 104, -1, 19, 129, 103, 149, 120, ++ 104, -1, 19, 61, -1, 19, 63, -1, 13, 103, ++ 148, 126, 151, 104, -1, 145, 103, 148, 126, 151, ++ 104, -1, 13, 97, 129, 103, 150, 126, 151, 104, ++ -1, 13, 61, -1, 13, 63, -1, 63, -1, 63, ++ 89, 139, 90, -1, 7, 129, -1, 36, 129, -1, ++ 13, 129, -1, 36, -1, 57, -1, 38, 147, -1, ++ 37, 147, -1, 39, 147, -1, 63, -1, 7, 61, ++ -1, -1, -1, -1, -1, 68, -1, -1, 4, -1, ++ 14, -1, 34, -1, 56, -1, 17, -1, 15, -1, ++ 40, -1, 20, -1, 54, -1, 41, -1, 52, -1, ++ 18, -1, 112, -1, 31, -1, -1, 20, -1, -1, ++ 69, 64, -1, -1, 40, -1, -1, 157, 97, -1, ++ 157, 86, -1, -1, 106, 165, 107, 158, -1, 106, ++ 107, 158, -1, 158, -1, -1, 69, 165, -1, 162, ++ -1, 162, 163, -1, 162, 163, 81, -1, 162, 163, ++ 81, 163, -1, 162, 81, 163, -1, -1, 67, -1, ++ 64, -1, 95, 64, -1, 96, 64, -1, 164, 68, ++ 164, -1, 165, -1, 168, 80, 166, 81, 165, -1, ++ 167, -1, 164, -1, 168, 82, 169, -1, 169, -1, ++ 167, -1, 170, 83, 171, -1, 171, -1, 169, -1, ++ 171, 84, 171, -1, 171, 85, 171, -1, 171, 86, ++ 171, -1, 171, 88, 171, -1, 171, 87, 171, -1, ++ 171, 89, 171, -1, 171, 92, 171, -1, 171, 90, ++ 171, -1, 171, 91, 171, -1, 171, 94, 171, -1, ++ 171, 93, 171, -1, 171, 95, 171, -1, 171, 96, ++ 171, -1, 171, 97, 171, -1, 171, 98, 171, -1, ++ 171, 99, 171, -1, 172, -1, 108, 172, -1, 109, ++ 172, -1, 96, 172, -1, 95, 172, -1, 97, 172, ++ -1, 86, 172, -1, 30, 110, 139, 111, -1, 173, ++ -1, 110, 164, 111, -1, 61, -1, 64, -1, 59, ++ -1, 65, -1, 66, -1, 67, -1, 45, -1, 46, ++ -1 ++}; ++ ++/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ ++static const yytype_uint16 yyrline[] = ++{ ++ 0, 208, 208, 224, 238, 240, 242, 248, 250, 251, ++ 252, 259, 260, 262, 285, 288, 290, 292, 294, 296, ++ 299, 302, 305, 308, 311, 314, 315, 316, 318, 319, ++ 320, 321, 324, 431, 447, 448, 450, 451, 452, 453, ++ 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, ++ 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, ++ 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ++ 484, 485, 486, 487, 498, 508, 525, 583, 585, 586, ++ 588, 589, 591, 670, 677, 692, 694, 697, 701, 711, ++ 758, 764, 768, 778, 825, 826, 827, 828, 829, 830, ++ 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, ++ 848, 870, 881, 900, 903, 916, 938, 957, 972, 987, ++ 1010, 1030, 1045, 1060, 1082, 1101, 1120, 1128, 1136, 1154, ++ 1164, 1181, 1200, 1217, 1218, 1220, 1221, 1222, 1223, 1230, ++ 1232, 1239, 1247, 1253, 1254, 1256, 1264, 1265, 1266, 1267, ++ 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1280, ++ 1282, 1283, 1285, 1286, 1288, 1289, 1291, 1292, 1299, 1304, ++ 1306, 1319, 1323, 1331, 1332, 1343, 1348, 1353, 1358, 1363, ++ 1369, 1370, 1372, 1373, 1374, 1383, 1384, 1387, 1392, 1395, ++ 1398, 1401, 1403, 1406, 1409, 1411, 1414, 1415, 1416, 1417, ++ 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, ++ 1428, 1429, 1430, 1433, 1438, 1443, 1453, 1454, 1461, 1465, ++ 1470, 1473, 1474, 1481, 1485, 1489, 1493, 1497, 1501, 1505 ++}; ++#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", "PRAGMA", "AUTO", "DOUBLE", "INT", ++ "STRUCT", "BREAK", "ELSE", "LONG", "SWITCH", "CASE", "ENUM", "REGISTER", ++ "TYPEDEF", "CHAR", "EXTERN", "RETURN", "UNION", "CONST", "FLOAT", ++ "SHORT", "UNSIGNED", "CONTINUE", "FOR", "SIGNED", "VOID", "DEFAULT", ++ "GOTO", "SIZEOF", "VOLATILE", "DO", "IF", "STATIC", "WHILE", "CLASS", ++ "PRIVATE", "PROTECTED", "PUBLIC", "VIRTUAL", "INLINE", "OPERATOR", ++ "LLONG", "BOOL", "CFALSE", "CTRUE", "WCHAR", "TIME", "USING", ++ "NAMESPACE", "ULLONG", "MUSTUNDERSTAND", "SIZE", "FRIEND", "TEMPLATE", ++ "EXPLICIT", "TYPENAME", "RESTRICT", "null", "NONE", "ID", "LAB", "TYPE", ++ "LNG", "DBL", "CHR", "STR", "','", "'='", "RA", "LA", "OA", "XA", "AA", ++ "MA", "DA", "TA", "NA", "PA", "'?'", "':'", "OR", "AN", "'|'", "'^'", ++ "'&'", "NE", "EQ", "'<'", "'>'", "GE", "LE", "RS", "LS", "'+'", "'-'", ++ "'*'", "'/'", "'%'", "AR", "PP", "NN", "'{'", "'}'", "';'", "'['", "']'", ++ "'!'", "'~'", "'('", "')'", "'@'", "$accept", "prog", "s1", "exts", ++ "exts1", "ext", "pragma", "decls", "t1", "t2", "t3", "t4", "t5", "dclrs", ++ "dclr", "fdclr", "id", "name", "constr", "destr", "func", "fname", ++ "fargso", "fargs", "farg", "arg", "texp", "spec", "tspec", "type", ++ "struct", "class", "enum", "tname", "base", "s2", "s3", "s4", "s5", "s6", ++ "store", "constobj", "abstract", "virtual", "ptrs", "array", "arrayck", ++ "init", "occurs", "patt", "cint", "expr", "cexp", "qexp", "oexp", "obex", ++ "aexp", "abex", "rexp", "lexp", "pexp", 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, 266, 267, 268, 269, 270, 271, 272, 273, 274, ++ 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, ++ 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, ++ 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, ++ 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, ++ 315, 316, 317, 318, 319, 320, 321, 322, 44, 61, ++ 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, ++ 63, 58, 333, 334, 124, 94, 38, 335, 336, 60, ++ 62, 337, 338, 339, 340, 43, 45, 42, 47, 37, ++ 341, 342, 343, 123, 125, 59, 91, 93, 33, 126, ++ 40, 41, 64 ++}; ++# endif ++ ++/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ ++static const yytype_uint8 yyr1[] = ++{ ++ 0, 113, 114, 115, 116, 116, 117, 117, 118, 118, ++ 118, 118, 118, 119, 120, 120, 120, 120, 120, 120, ++ 121, 122, 123, 124, 125, 126, 126, 126, 126, 126, ++ 126, 126, 127, 128, 129, 129, 130, 130, 130, 130, ++ 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, ++ 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, ++ 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, ++ 130, 130, 130, 130, 131, 132, 133, 134, 135, 135, ++ 136, 136, 137, 138, 138, 139, 139, 140, 140, 140, ++ 141, 141, 141, 141, 142, 142, 142, 142, 142, 142, ++ 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, ++ 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, ++ 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, ++ 143, 144, 145, 146, 146, 147, 147, 147, 147, 147, ++ 148, 149, 150, 151, 151, 152, 153, 153, 153, 153, ++ 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, ++ 154, 154, 155, 155, 156, 156, 157, 157, 157, 158, ++ 158, 158, 159, 160, 160, 161, 161, 161, 161, 161, ++ 162, 162, 163, 163, 163, 164, 164, 165, 165, 166, ++ 167, 167, 168, 169, 169, 170, 171, 171, 171, 171, ++ 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, ++ 171, 171, 171, 172, 172, 172, 172, 172, 172, 172, ++ 172, 173, 173, 173, 173, 173, 173, 173, 173, 173 ++}; ++ ++/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ ++static const yytype_uint8 yyr2[] = ++{ ++ 0, 2, 2, 0, 5, 1, 0, 2, 2, 1, ++ 2, 1, 1, 1, 0, 3, 4, 4, 4, 4, ++ 1, 1, 0, 0, 0, 1, 2, 3, 2, 2, ++ 3, 4, 5, 2, 1, 1, 1, 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, 3, 3, 2, 1, 3, 7, 0, 0, 1, ++ 1, 3, 6, 0, 1, 3, 4, 0, 2, 2, ++ 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, ++ 5, 5, 7, 1, 3, 5, 5, 2, 2, 5, ++ 6, 2, 2, 6, 6, 8, 2, 2, 1, 4, ++ 2, 2, 2, 1, 1, 2, 2, 2, 1, 2, ++ 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 0, 1, 0, 2, 0, 1, 0, 2, 2, 0, ++ 4, 3, 1, 0, 2, 1, 2, 3, 4, 3, ++ 0, 1, 1, 2, 2, 3, 1, 5, 1, 1, ++ 3, 1, 1, 3, 1, 1, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 1, 2, 2, 2, 2, 2, 2, 4, ++ 1, 3, 1, 1, 1, 1, 1, 1, 1, 1 ++}; ++ ++/* 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[] = ++{ ++ 3, 0, 6, 1, 0, 2, 0, 0, 0, 13, ++ 146, 105, 99, 0, 100, 0, 147, 151, 96, 150, ++ 157, 0, 153, 104, 98, 107, 106, 94, 159, 148, ++ 0, 152, 155, 101, 95, 97, 108, 102, 156, 103, ++ 154, 0, 149, 128, 20, 21, 158, 7, 9, 11, ++ 12, 0, 77, 77, 166, 87, 0, 113, 0, 87, ++ 0, 6, 10, 117, 118, 140, 130, 126, 127, 0, ++ 140, 132, 121, 122, 141, 0, 34, 35, 140, 131, ++ 0, 0, 166, 8, 28, 0, 29, 26, 77, 0, ++ 152, 128, 89, 140, 0, 140, 140, 88, 0, 0, ++ 87, 0, 87, 87, 141, 87, 133, 134, 0, 0, ++ 166, 91, 90, 30, 77, 145, 27, 0, 169, 168, ++ 167, 33, 87, 0, 0, 0, 0, 138, 114, 87, ++ 87, 75, 4, 0, 0, 0, 0, 87, 0, 142, ++ 143, 0, 87, 0, 0, 129, 169, 93, 92, 31, ++ 78, 39, 49, 48, 47, 46, 45, 44, 43, 42, ++ 41, 40, 50, 51, 52, 53, 54, 56, 55, 57, ++ 59, 60, 58, 62, 61, 63, 64, 65, 66, 67, ++ 70, 68, 69, 0, 37, 38, 0, 73, 0, 172, ++ 180, 0, 139, 136, 135, 137, 140, 0, 143, 22, ++ 23, 24, 115, 0, 87, 87, 166, 0, 119, 0, ++ 110, 0, 169, 85, 0, 79, 80, 166, 71, 72, ++ 0, 228, 229, 224, 222, 223, 225, 226, 227, 0, ++ 0, 0, 0, 169, 0, 0, 0, 0, 188, 0, ++ 191, 0, 194, 212, 220, 181, 173, 175, 116, 87, ++ 111, 0, 87, 87, 87, 87, 15, 143, 123, 120, ++ 0, 86, 160, 0, 83, 0, 218, 216, 215, 217, ++ 171, 213, 214, 0, 186, 169, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 32, 182, 0, 0, ++ 0, 176, 0, 124, 16, 17, 18, 19, 0, 109, ++ 161, 162, 81, 84, 169, 0, 0, 221, 170, 189, ++ 0, 190, 193, 196, 197, 198, 200, 199, 201, 203, ++ 204, 202, 206, 205, 207, 208, 209, 210, 211, 174, ++ 179, 183, 184, 177, 112, 125, 0, 76, 180, 219, ++ 185, 0, 178, 163, 173, 187, 82 ++}; ++ ++/* YYDEFGOTO[NTERM-NUM]. */ ++static const yytype_int16 yydefgoto[] = ++{ ++ -1, 1, 2, 5, 6, 47, 48, 136, 137, 50, ++ 252, 253, 254, 138, 113, 114, 66, 121, 52, 53, ++ 84, 85, 214, 215, 216, 314, 109, 54, 110, 55, ++ 56, 57, 58, 108, 128, 100, 103, 205, 207, 150, ++ 59, 311, 347, 60, 89, 189, 190, 296, 246, 247, ++ 301, 273, 274, 320, 238, 239, 240, 241, 242, 243, ++ 244 ++}; ++ ++/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing ++ STATE-NUM. */ ++#define YYPACT_NINF -283 ++static const yytype_int16 yypact[] = ++{ ++ -283, 20, -29, -283, -30, -283, 206, -14, -7, -283, ++ -283, -283, -283, -3, -283, 2, -283, -283, -283, -283, ++ -283, 9, -283, -283, -283, -283, -283, -283, -283, -283, ++ 29, -8, -283, -283, -283, -283, -283, -283, -283, -283, ++ -283, 45, -283, 14, -283, -283, -283, -283, -283, -283, ++ -283, 8, -283, -283, 15, 889, 36, 30, 50, 889, ++ 46, -283, -283, 53, 58, -283, -283, 53, 58, -17, ++ -283, -283, 53, 58, -283, 59, -283, -283, -283, -283, ++ 79, 889, -283, -283, -283, 54, -283, -283, -283, -18, ++ -283, 76, -283, -283, 18, -283, -283, -283, 122, 316, ++ 643, 85, 826, 643, -283, 643, -283, -283, -17, 118, ++ -283, 889, 889, -283, -283, -283, -283, 425, -80, -283, ++ -283, -283, 643, 153, 18, 18, 18, -283, 112, 643, ++ 826, -283, -283, 136, 137, 149, 127, 752, 16, -283, ++ 170, 135, 643, 139, 151, -283, -33, -283, -283, -283, ++ 889, -283, -283, -283, -283, -283, -283, -283, -283, -283, ++ -283, -283, -283, -283, -283, -283, -283, -283, -283, -283, ++ -283, -283, -283, -283, -283, -283, -283, -283, -283, -283, ++ -283, -283, -283, 144, -283, -283, 133, -283, 21, -283, ++ 185, 152, -283, -283, -283, -283, -283, 159, 170, -283, ++ -283, -283, -283, 148, 534, 826, 160, 161, -283, 162, ++ -283, 232, 164, -283, 180, -283, 203, -283, -283, -283, ++ 163, -283, -283, -283, -283, -283, -283, -283, -283, 901, ++ 901, 901, 901, 164, 901, 901, 901, 165, 22, 55, ++ 214, 217, 191, -283, -283, -283, 233, 27, -283, 643, ++ -283, 197, 534, 534, 534, 534, -283, 170, -283, -283, ++ -17, -283, 284, 889, -38, 889, -283, -283, -283, -283, ++ -283, -283, -283, -49, -283, 164, 901, 901, 901, 901, ++ 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, ++ 901, 901, 901, 901, 901, 901, -283, -283, 31, 241, ++ 242, 226, 204, -283, -283, -283, -283, -283, 205, -283, ++ -283, 245, -283, -283, 164, 199, 901, -283, -283, 248, ++ 243, 214, 191, 300, 512, 525, 52, 52, 97, 97, ++ 97, 97, 106, 106, 100, 100, -283, -283, -283, -283, ++ -283, -283, -283, 31, -283, -283, 261, -283, 185, -283, ++ -283, 901, -283, -283, 233, -283, -283 ++}; ++ ++/* YYPGOTO[NTERM-NUM]. */ ++static const yytype_int16 yypgoto[] = ++{ ++ -283, -283, -283, -283, 266, -283, -283, -95, 7, 125, ++ -283, -283, -283, -5, 286, 287, -15, -283, -283, -283, ++ -36, -283, -283, 81, -283, -283, -113, -10, -100, -79, ++ -283, -283, -283, -283, 110, -56, 244, -283, -180, -283, ++ -76, -283, -283, -283, -103, -137, 32, -9, 1, -283, ++ -282, -247, -185, -283, -283, -283, 74, -283, -111, 64, ++ -283 ++}; ++ ++/* 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 -196 ++static const yytype_int16 yytable[] = ++{ ++ 71, 51, 111, 237, 187, 112, 75, 146, 141, 213, ++ 143, 147, 148, 49, 102, 79, 340, 86, 251, 316, ++ 3, 4, 105, 313, 117, 123, 188, 191, 212, 319, ++ -36, 7, 111, 111, 197, 112, 112, 122, 111, 129, ++ 130, 112, 203, 118, 76, 92, 77, 209, 119, 97, ++ 217, 220, 116, 119, 101, 124, 125, 126, 63, 120, ++ 64, 352, 317, 67, 120, 68, 221, 222, 119, 350, ++ 72, 111, 73, 188, 112, 261, 82, 308, 149, 120, ++ 223, 127, 224, -25, 82, 225, 226, 227, 228, 61, ++ 76, 297, 77, 144, 51, 297, 270, 140, 62, 69, ++ 65, -165, -192, 81, -192, 70, 49, 229, 298, 256, ++ 339, 94, 74, 83, 264, 106, 230, 231, 232, -25, ++ -25, 204, 299, 300, -74, 198, 299, 300, 233, 234, ++ 235, 236, 78, 95, 80, 276, 107, 277, 318, 93, ++ 249, 284, 285, 286, 287, 288, 289, 290, 291, 292, ++ 293, 294, 315, 96, 302, 98, -34, 304, 305, 306, ++ 307, -35, 104, 217, 115, 81, 355, 322, 323, 324, ++ 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, ++ 335, 336, 337, 338, 111, 131, 111, 112, 139, 112, ++ 288, 289, 290, 291, 292, 293, 294, 292, 293, 294, ++ 257, 290, 291, 292, 293, 294, -5, 8, 145, 9, ++ 10, 11, 12, 13, 192, 196, 14, 199, 200, 15, ++ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, ++ 201, 202, 26, 27, 193, 194, 195, 28, 206, 208, ++ 29, 211, 30, 210, 219, 309, 31, 32, -87, 33, ++ 34, 218, 245, 35, 36, 45, 248, 37, 38, 39, ++ 40, 41, 42, 250, -144, 258, 259, -87, 260, 43, ++ 188, 263, 275, 265, -87, 279, 280, 281, 282, 283, ++ 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, ++ 294, 262, -87, 266, 267, 268, 269, -195, 271, 272, ++ 278, 303, 295, -87, 310, 341, 342, 343, 344, 345, ++ 349, -87, 44, 45, 346, -164, 316, 8, 46, 9, ++ 10, 11, 12, 13, 351, 353, 14, 99, 255, 15, ++ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, ++ 87, 88, 26, 27, 312, 356, 348, 28, 142, 354, ++ 29, 321, 30, 0, 0, 0, 31, 32, -87, 33, ++ 34, 0, 0, 35, 36, 0, 0, 37, 38, 39, ++ 40, 41, 42, 0, 0, 0, 0, -87, 0, 43, ++ 0, 0, 0, 0, -87, 280, 281, 282, 283, 284, ++ 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, ++ 0, 0, -87, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, -87, 0, 0, 0, 0, 0, 0, ++ 132, -87, 44, 45, 0, -164, 0, 0, 46, 10, ++ 11, 12, 13, 0, 0, 14, 0, 0, 15, 16, ++ 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, ++ 0, 26, 27, 0, 0, 0, 28, 0, 0, 29, ++ 0, 30, 0, 0, 0, 90, 32, 0, 33, 34, ++ 0, 0, 35, 36, 0, 0, 37, 38, 39, 40, ++ 41, 42, 0, 0, 0, 0, 0, 0, 91, 0, ++ 0, 0, 0, 0, 151, 152, 153, 154, 155, 156, ++ 157, 158, 159, 160, 161, 0, 0, 162, 163, 164, ++ 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, ++ 175, 176, 177, 178, 179, 180, 181, 182, 0, 0, ++ 0, 183, 0, 184, 185, 186, 0, 46, 10, 11, ++ 12, 13, 0, 0, 14, 0, 0, 15, 16, 17, ++ 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, ++ 26, 27, 0, 0, 0, 28, 0, 0, 29, 0, ++ 30, 133, 134, 135, 31, 32, 0, 33, 34, 0, ++ 0, 35, 36, 0, 0, 37, 38, 39, 40, 41, ++ 42, 0, 0, 0, 0, 0, 0, 43, 281, 282, ++ 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, ++ 293, 294, 282, 283, 284, 285, 286, 287, 288, 289, ++ 290, 291, 292, 293, 294, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, -14, 0, ++ 44, -14, 0, -164, 0, 0, 46, 10, 11, 12, ++ 13, 0, 0, 14, 0, 0, 15, 16, 17, 18, ++ 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, ++ 27, 0, 0, 0, 28, 0, 0, 29, 0, 30, ++ 133, 134, 135, 31, 32, 0, 33, 34, 0, 0, ++ 35, 36, 0, 0, 37, 38, 39, 40, 41, 42, ++ 0, 0, 0, 0, 0, 0, 43, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, -14, 0, 44, ++ 0, 0, -164, 0, 0, 46, 10, 11, 12, 13, ++ 0, 0, 14, 0, 0, 15, 16, 17, 18, 19, ++ 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, ++ 0, 0, 0, 28, 0, 0, 29, 0, 30, 133, ++ 134, 135, 31, 32, 0, 33, 34, 0, 0, 35, ++ 36, 0, 0, 37, 38, 39, 40, 41, 42, 0, ++ 0, 0, 0, 0, 0, 43, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 10, 11, 12, 13, 0, 0, 14, 0, 0, 15, ++ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, ++ 0, 0, 26, 27, 0, 0, 0, 28, 44, -14, ++ 29, -164, 30, 0, 46, 0, 31, 32, 0, 33, ++ 34, 0, 0, 35, 36, 0, 0, 37, 38, 39, ++ 40, 41, 42, 0, 0, 0, 0, 0, 0, 43, ++ 0, 0, 0, 10, 11, 12, 13, 0, 0, 14, ++ 0, 0, 15, 16, 17, 18, 19, 20, 21, 22, ++ 23, 24, 25, 0, 0, 26, 27, 0, 0, 0, ++ 28, 0, 0, 29, 0, 30, 0, 0, 0, 90, ++ 32, 220, 33, 34, 0, -164, 35, 36, 46, 0, ++ 37, 38, 39, 40, 41, 42, 221, 222, 0, 0, ++ 0, 0, 91, 0, 0, 0, 0, 0, 0, 0, ++ 223, 0, 224, 0, 0, 225, 226, 227, 228, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 229, 0, 0, ++ 0, 0, 0, 0, 0, 0, 230, 231, 232, 0, ++ 0, 46, 0, 0, 0, 0, 0, 0, 0, 234, ++ 235, 236 ++}; ++ ++static const yytype_int16 yycheck[] = ++{ ++ 15, 6, 81, 188, 117, 81, 21, 110, 103, 146, ++ 105, 111, 112, 6, 70, 30, 298, 53, 198, 68, ++ 0, 50, 78, 61, 42, 7, 106, 122, 61, 276, ++ 110, 61, 111, 112, 129, 111, 112, 93, 117, 95, ++ 96, 117, 137, 61, 61, 55, 63, 142, 86, 59, ++ 150, 30, 88, 86, 69, 37, 38, 39, 61, 97, ++ 63, 343, 111, 61, 97, 63, 45, 46, 86, 316, ++ 61, 150, 63, 106, 150, 212, 68, 257, 114, 97, ++ 59, 63, 61, 68, 68, 64, 65, 66, 67, 103, ++ 61, 64, 63, 108, 99, 64, 233, 102, 105, 97, ++ 103, 109, 80, 89, 82, 103, 99, 86, 81, 204, ++ 295, 81, 103, 105, 217, 36, 95, 96, 97, 104, ++ 105, 105, 95, 96, 110, 130, 95, 96, 107, 108, ++ 109, 110, 103, 103, 89, 80, 57, 82, 275, 103, ++ 196, 89, 90, 91, 92, 93, 94, 95, 96, 97, ++ 98, 99, 265, 103, 249, 109, 103, 252, 253, 254, ++ 255, 103, 103, 263, 110, 89, 351, 278, 279, 280, ++ 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, ++ 291, 292, 293, 294, 263, 63, 265, 263, 103, 265, ++ 93, 94, 95, 96, 97, 98, 99, 97, 98, 99, ++ 205, 95, 96, 97, 98, 99, 0, 1, 90, 3, ++ 4, 5, 6, 7, 61, 103, 10, 81, 81, 13, ++ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, ++ 81, 104, 26, 27, 124, 125, 126, 31, 68, 104, ++ 34, 90, 36, 104, 111, 260, 40, 41, 42, 43, ++ 44, 107, 67, 47, 48, 107, 104, 51, 52, 53, ++ 54, 55, 56, 104, 104, 104, 104, 61, 36, 63, ++ 106, 68, 107, 110, 68, 84, 85, 86, 87, 88, ++ 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, ++ 99, 111, 86, 229, 230, 231, 232, 83, 234, 235, ++ 83, 104, 69, 97, 20, 64, 64, 81, 104, 104, ++ 111, 105, 106, 107, 69, 109, 68, 1, 112, 3, ++ 4, 5, 6, 7, 81, 64, 10, 61, 203, 13, ++ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, ++ 54, 54, 26, 27, 263, 354, 314, 31, 104, 348, ++ 34, 277, 36, -1, -1, -1, 40, 41, 42, 43, ++ 44, -1, -1, 47, 48, -1, -1, 51, 52, 53, ++ 54, 55, 56, -1, -1, -1, -1, 61, -1, 63, ++ -1, -1, -1, -1, 68, 85, 86, 87, 88, 89, ++ 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, ++ -1, -1, 86, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, 97, -1, -1, -1, -1, -1, -1, ++ 104, 105, 106, 107, -1, 109, -1, -1, 112, 4, ++ 5, 6, 7, -1, -1, 10, -1, -1, 13, 14, ++ 15, 16, 17, 18, 19, 20, 21, 22, 23, -1, ++ -1, 26, 27, -1, -1, -1, 31, -1, -1, 34, ++ -1, 36, -1, -1, -1, 40, 41, -1, 43, 44, ++ -1, -1, 47, 48, -1, -1, 51, 52, 53, 54, ++ 55, 56, -1, -1, -1, -1, -1, -1, 63, -1, ++ -1, -1, -1, -1, 69, 70, 71, 72, 73, 74, ++ 75, 76, 77, 78, 79, -1, -1, 82, 83, 84, ++ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, ++ 95, 96, 97, 98, 99, 100, 101, 102, -1, -1, ++ -1, 106, -1, 108, 109, 110, -1, 112, 4, 5, ++ 6, 7, -1, -1, 10, -1, -1, 13, 14, 15, ++ 16, 17, 18, 19, 20, 21, 22, 23, -1, -1, ++ 26, 27, -1, -1, -1, 31, -1, -1, 34, -1, ++ 36, 37, 38, 39, 40, 41, -1, 43, 44, -1, ++ -1, 47, 48, -1, -1, 51, 52, 53, 54, 55, ++ 56, -1, -1, -1, -1, -1, -1, 63, 86, 87, ++ 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, ++ 98, 99, 87, 88, 89, 90, 91, 92, 93, 94, ++ 95, 96, 97, 98, 99, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 104, -1, ++ 106, 107, -1, 109, -1, -1, 112, 4, 5, 6, ++ 7, -1, -1, 10, -1, -1, 13, 14, 15, 16, ++ 17, 18, 19, 20, 21, 22, 23, -1, -1, 26, ++ 27, -1, -1, -1, 31, -1, -1, 34, -1, 36, ++ 37, 38, 39, 40, 41, -1, 43, 44, -1, -1, ++ 47, 48, -1, -1, 51, 52, 53, 54, 55, 56, ++ -1, -1, -1, -1, -1, -1, 63, -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, 104, -1, 106, ++ -1, -1, 109, -1, -1, 112, 4, 5, 6, 7, ++ -1, -1, 10, -1, -1, 13, 14, 15, 16, 17, ++ 18, 19, 20, 21, 22, 23, -1, -1, 26, 27, ++ -1, -1, -1, 31, -1, -1, 34, -1, 36, 37, ++ 38, 39, 40, 41, -1, 43, 44, -1, -1, 47, ++ 48, -1, -1, 51, 52, 53, 54, 55, 56, -1, ++ -1, -1, -1, -1, -1, 63, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ 4, 5, 6, 7, -1, -1, 10, -1, -1, 13, ++ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, ++ -1, -1, 26, 27, -1, -1, -1, 31, 106, 107, ++ 34, 109, 36, -1, 112, -1, 40, 41, -1, 43, ++ 44, -1, -1, 47, 48, -1, -1, 51, 52, 53, ++ 54, 55, 56, -1, -1, -1, -1, -1, -1, 63, ++ -1, -1, -1, 4, 5, 6, 7, -1, -1, 10, ++ -1, -1, 13, 14, 15, 16, 17, 18, 19, 20, ++ 21, 22, 23, -1, -1, 26, 27, -1, -1, -1, ++ 31, -1, -1, 34, -1, 36, -1, -1, -1, 40, ++ 41, 30, 43, 44, -1, 109, 47, 48, 112, -1, ++ 51, 52, 53, 54, 55, 56, 45, 46, -1, -1, ++ -1, -1, 63, -1, -1, -1, -1, -1, -1, -1, ++ 59, -1, 61, -1, -1, 64, 65, 66, 67, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 86, -1, -1, ++ -1, -1, -1, -1, -1, -1, 95, 96, 97, -1, ++ -1, 112, -1, -1, -1, -1, -1, -1, -1, 108, ++ 109, 110 ++}; ++ ++/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing ++ symbol of state STATE-NUM. */ ++static const yytype_uint8 yystos[] = ++{ ++ 0, 114, 115, 0, 50, 116, 117, 61, 1, 3, ++ 4, 5, 6, 7, 10, 13, 14, 15, 16, 17, ++ 18, 19, 20, 21, 22, 23, 26, 27, 31, 34, ++ 36, 40, 41, 43, 44, 47, 48, 51, 52, 53, ++ 54, 55, 56, 63, 106, 107, 112, 118, 119, 121, ++ 122, 126, 131, 132, 140, 142, 143, 144, 145, 153, ++ 156, 103, 105, 61, 63, 103, 129, 61, 63, 97, ++ 103, 129, 61, 63, 103, 129, 61, 63, 103, 129, ++ 89, 89, 68, 105, 133, 134, 133, 127, 128, 157, ++ 40, 63, 140, 103, 81, 103, 103, 140, 109, 117, ++ 148, 129, 148, 149, 103, 148, 36, 57, 146, 139, ++ 141, 142, 153, 127, 128, 110, 133, 42, 61, 86, ++ 97, 130, 148, 7, 37, 38, 39, 63, 147, 148, ++ 148, 63, 104, 37, 38, 39, 120, 121, 126, 103, ++ 126, 120, 149, 120, 129, 90, 157, 141, 141, 133, ++ 152, 69, 70, 71, 72, 73, 74, 75, 76, 77, ++ 78, 79, 82, 83, 84, 85, 86, 87, 88, 89, ++ 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, ++ 100, 101, 102, 106, 108, 109, 110, 139, 106, 158, ++ 159, 120, 61, 147, 147, 147, 103, 120, 126, 81, ++ 81, 81, 104, 120, 105, 150, 68, 151, 104, 120, ++ 104, 90, 61, 158, 135, 136, 137, 141, 107, 111, ++ 30, 45, 46, 59, 61, 64, 65, 66, 67, 86, ++ 95, 96, 97, 107, 108, 109, 110, 165, 167, 168, ++ 169, 170, 171, 172, 173, 67, 161, 162, 104, 148, ++ 104, 151, 123, 124, 125, 122, 120, 126, 104, 104, ++ 36, 158, 111, 68, 157, 110, 172, 172, 172, 172, ++ 158, 172, 172, 164, 165, 107, 80, 82, 83, 84, ++ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, ++ 95, 96, 97, 98, 99, 69, 160, 64, 81, 95, ++ 96, 163, 120, 104, 120, 120, 120, 120, 151, 129, ++ 20, 154, 136, 61, 138, 139, 68, 111, 158, 164, ++ 166, 169, 171, 171, 171, 171, 171, 171, 171, 171, ++ 171, 171, 171, 171, 171, 171, 171, 171, 171, 165, ++ 163, 64, 64, 81, 104, 104, 69, 155, 159, 111, ++ 164, 81, 163, 64, 161, 165, 160 ++}; ++ ++#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 () ++#endif ++ ++/* Enable debugging if requested. */ ++#if YYDEBUG ++ ++# ifndef YYFPRINTF ++# include <stdio.h> /* 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. | ++`----------*/ ++ ++#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 () ++ ++#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")); ++ ++ 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 208 "soapcpp2_yacc.y" ++ { if (lflag) ++ { custom_header = 0; ++ custom_fault = 0; ++ } ++ else ++ { add_header(sp->table); ++ add_fault(sp->table); ++ } ++ compile(sp->table); ++ freetable(classtable); ++ freetable(enumtable); ++ freetable(typetable); ++ freetable(booltable); ++ freetable(templatetable); ++ } ++ break; ++ ++ case 3: ++#line 224 "soapcpp2_yacc.y" ++ { classtable = mktable((Table*)0); ++ enumtable = mktable((Table*)0); ++ typetable = mktable((Table*)0); ++ booltable = mktable((Table*)0); ++ templatetable = mktable((Table*)0); ++ p = enter(booltable, lookup("false")); ++ p->info.typ = mkint(); ++ p->info.val.i = 0; ++ p = enter(booltable, lookup("true")); ++ p->info.typ = mkint(); ++ p->info.val.i = 1; ++ mkscope(mktable(mktable((Table*)0)), 0); ++ } ++ break; ++ ++ case 4: ++#line 239 "soapcpp2_yacc.y" ++ { namespaceid = (yyvsp[(2) - (5)].sym)->name; } ++ break; ++ ++ case 5: ++#line 240 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 6: ++#line 242 "soapcpp2_yacc.y" ++ { add_soap(); ++ if (!lflag) ++ { add_qname(); ++ add_XML(); ++ } ++ } ++ break; ++ ++ case 7: ++#line 248 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 8: ++#line 250 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 9: ++#line 251 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 10: ++#line 252 "soapcpp2_yacc.y" ++ { synerror("input before ; skipped"); ++ while (sp > stack) ++ { freetable(sp->table); ++ exitscope(); ++ } ++ yyerrok; ++ } ++ break; ++ ++ case 11: ++#line 259 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 12: ++#line 260 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 13: ++#line 262 "soapcpp2_yacc.y" ++ { if ((yyvsp[(1) - (1)].s)[1] >= 'a' && (yyvsp[(1) - (1)].s)[1] <= 'z') ++ { for (pp = &pragmas; *pp; pp = &(*pp)->next) ++ ; ++ *pp = (Pragma*)emalloc(sizeof(Pragma)); ++ (*pp)->pragma = (char*)emalloc(strlen((yyvsp[(1) - (1)].s))+1); ++ strcpy((*pp)->pragma, (yyvsp[(1) - (1)].s)); ++ (*pp)->next = NULL; ++ } ++ else if ((i = atoi((yyvsp[(1) - (1)].s)+2)) > 0) ++ yylineno = i; ++ else ++ { sprintf(errbuf, "directive '%s' ignored (use #import to import files and/or use option -i)", (yyvsp[(1) - (1)].s)); ++ semwarn(errbuf); ++ } ++ } ++ break; ++ ++ case 14: ++#line 285 "soapcpp2_yacc.y" ++ { transient &= ~6; ++ permission = 0; ++ } ++ break; ++ ++ case 15: ++#line 289 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 16: ++#line 291 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 17: ++#line 293 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 18: ++#line 295 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 19: ++#line 297 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 20: ++#line 299 "soapcpp2_yacc.y" ++ { transient |= 1; ++ } ++ break; ++ ++ case 21: ++#line 302 "soapcpp2_yacc.y" ++ { transient &= ~1; ++ } ++ break; ++ ++ case 22: ++#line 305 "soapcpp2_yacc.y" ++ { permission = Sprivate; ++ } ++ break; ++ ++ case 23: ++#line 308 "soapcpp2_yacc.y" ++ { permission = Sprotected; ++ } ++ break; ++ ++ case 24: ++#line 311 "soapcpp2_yacc.y" ++ { permission = 0; ++ } ++ break; ++ ++ case 25: ++#line 314 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 26: ++#line 315 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 27: ++#line 317 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 28: ++#line 318 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 29: ++#line 319 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 30: ++#line 320 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 31: ++#line 322 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 32: ++#line 325 "soapcpp2_yacc.y" ++ { if (((yyvsp[(3) - (5)].rec).sto & Stypedef) && sp->table->level == GLOBAL) ++ { if (((yyvsp[(3) - (5)].rec).typ->type != Tstruct && (yyvsp[(3) - (5)].rec).typ->type != Tunion && (yyvsp[(3) - (5)].rec).typ->type != Tenum) || strcmp((yyvsp[(2) - (5)].sym)->name, (yyvsp[(3) - (5)].rec).typ->id->name)) ++ { p = enter(typetable, (yyvsp[(2) - (5)].sym)); ++ p->info.typ = mksymtype((yyvsp[(3) - (5)].rec).typ, (yyvsp[(2) - (5)].sym)); ++ if ((yyvsp[(3) - (5)].rec).sto & Sextern) ++ p->info.typ->transient = -1; ++ else ++ p->info.typ->transient = (yyvsp[(3) - (5)].rec).typ->transient; ++ p->info.sto = (yyvsp[(3) - (5)].rec).sto; ++ p->info.typ->pattern = (yyvsp[(4) - (5)].rec).pattern; ++ if ((yyvsp[(4) - (5)].rec).minOccurs != -1) ++ { p->info.typ->minLength = (yyvsp[(4) - (5)].rec).minOccurs; ++ } ++ if ((yyvsp[(4) - (5)].rec).maxOccurs > 1) ++ p->info.typ->maxLength = (yyvsp[(4) - (5)].rec).maxOccurs; ++ } ++ (yyvsp[(2) - (5)].sym)->token = TYPE; ++ } ++ else ++ { p = enter(sp->table, (yyvsp[(2) - (5)].sym)); ++ p->info.typ = (yyvsp[(3) - (5)].rec).typ; ++ p->info.sto = ((yyvsp[(3) - (5)].rec).sto | permission); ++ if ((yyvsp[(5) - (5)].rec).hasval) ++ { p->info.hasval = True; ++ switch ((yyvsp[(3) - (5)].rec).typ->type) ++ { case Tchar: ++ case Tuchar: ++ case Tshort: ++ case Tushort: ++ case Tint: ++ case Tuint: ++ case Tlong: ++ case Tulong: ++ case Tllong: ++ case Tullong: ++ case Tenum: ++ case Ttime: ++ if ((yyvsp[(5) - (5)].rec).typ->type == Tint || (yyvsp[(5) - (5)].rec).typ->type == Tchar || (yyvsp[(5) - (5)].rec).typ->type == Tenum) ++ sp->val = p->info.val.i = (yyvsp[(5) - (5)].rec).val.i; ++ else ++ { semerror("type error in initialization constant"); ++ p->info.hasval = False; ++ } ++ break; ++ case Tfloat: ++ case Tdouble: ++ case Tldouble: ++ if ((yyvsp[(5) - (5)].rec).typ->type == Tfloat || (yyvsp[(5) - (5)].rec).typ->type == Tdouble || (yyvsp[(5) - (5)].rec).typ->type == Tldouble) ++ p->info.val.r = (yyvsp[(5) - (5)].rec).val.r; ++ else if ((yyvsp[(5) - (5)].rec).typ->type == Tint) ++ p->info.val.r = (double)(yyvsp[(5) - (5)].rec).val.i; ++ else ++ { semerror("type error in initialization constant"); ++ p->info.hasval = False; ++ } ++ break; ++ default: ++ if ((yyvsp[(3) - (5)].rec).typ->type == Tpointer ++ && ((Tnode*)(yyvsp[(3) - (5)].rec).typ->ref)->type == Tchar ++ && (yyvsp[(5) - (5)].rec).typ->type == Tpointer ++ && ((Tnode*)(yyvsp[(5) - (5)].rec).typ->ref)->type == Tchar) ++ p->info.val.s = (yyvsp[(5) - (5)].rec).val.s; ++ else if ((yyvsp[(3) - (5)].rec).typ->type == Tpointer ++ && ((Tnode*)(yyvsp[(3) - (5)].rec).typ->ref)->id == lookup("std::string")) ++ p->info.val.s = (yyvsp[(5) - (5)].rec).val.s; ++ else if ((yyvsp[(3) - (5)].rec).typ->id == lookup("std::string")) ++ p->info.val.s = (yyvsp[(5) - (5)].rec).val.s; ++ else if ((yyvsp[(3) - (5)].rec).typ->type == Tpointer ++ && (yyvsp[(5) - (5)].rec).typ->type == Tint ++ && (yyvsp[(5) - (5)].rec).val.i == 0) ++ p->info.val.i = 0; ++ else ++ { semerror("type error in initialization constant"); ++ p->info.hasval = False; ++ } ++ break; ++ } ++ } ++ else ++ p->info.val.i = sp->val; ++ if ((yyvsp[(4) - (5)].rec).minOccurs < 0) ++ { if (((yyvsp[(3) - (5)].rec).sto & Sattribute) || (yyvsp[(3) - (5)].rec).typ->type == Tpointer || (yyvsp[(3) - (5)].rec).typ->type == Ttemplate || !strncmp((yyvsp[(2) - (5)].sym)->name, "__size", 6)) ++ p->info.minOccurs = 0; ++ else ++ p->info.minOccurs = 1; ++ } ++ else ++ p->info.minOccurs = (yyvsp[(4) - (5)].rec).minOccurs; ++ p->info.maxOccurs = (yyvsp[(4) - (5)].rec).maxOccurs; ++ if (sp->mask) ++ sp->val <<= 1; ++ else ++ sp->val++; ++ p->info.offset = sp->offset; ++ if ((yyvsp[(3) - (5)].rec).sto & Sextern) ++ p->level = GLOBAL; ++ else if ((yyvsp[(3) - (5)].rec).sto & Stypedef) ++ ; ++ else if (sp->grow) ++ sp->offset += p->info.typ->width; ++ else if (p->info.typ->width > sp->offset) ++ sp->offset = p->info.typ->width; ++ } ++ sp->entry = p; ++ } ++ break; ++ ++ case 33: ++#line 431 "soapcpp2_yacc.y" ++ { if ((yyvsp[(1) - (2)].rec).sto & Stypedef) ++ { sprintf(errbuf, "invalid typedef qualifier for '%s'", (yyvsp[(2) - (2)].sym)->name); ++ semwarn(errbuf); ++ } ++ p = enter(sp->table, (yyvsp[(2) - (2)].sym)); ++ p->info.typ = (yyvsp[(1) - (2)].rec).typ; ++ p->info.sto = (yyvsp[(1) - (2)].rec).sto; ++ p->info.hasval = False; ++ p->info.offset = sp->offset; ++ if (sp->grow) ++ sp->offset += p->info.typ->width; ++ else if (p->info.typ->width > sp->offset) ++ sp->offset = p->info.typ->width; ++ sp->entry = p; ++ } ++ break; ++ ++ case 34: ++#line 447 "soapcpp2_yacc.y" ++ { (yyval.sym) = (yyvsp[(1) - (1)].sym); } ++ break; ++ ++ case 35: ++#line 448 "soapcpp2_yacc.y" ++ { (yyval.sym) = (yyvsp[(1) - (1)].sym); } ++ break; ++ ++ case 36: ++#line 450 "soapcpp2_yacc.y" ++ { (yyval.sym) = (yyvsp[(1) - (1)].sym); } ++ break; ++ ++ case 37: ++#line 451 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator!"); } ++ break; ++ ++ case 38: ++#line 452 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator~"); } ++ break; ++ ++ case 39: ++#line 453 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator="); } ++ break; ++ ++ case 40: ++#line 454 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator+="); } ++ break; ++ ++ case 41: ++#line 455 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator-="); } ++ break; ++ ++ case 42: ++#line 456 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator*="); } ++ break; ++ ++ case 43: ++#line 457 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator/="); } ++ break; ++ ++ case 44: ++#line 458 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator%="); } ++ break; ++ ++ case 45: ++#line 459 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator&="); } ++ break; ++ ++ case 46: ++#line 460 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator^="); } ++ break; ++ ++ case 47: ++#line 461 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator|="); } ++ break; ++ ++ case 48: ++#line 462 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator<<="); } ++ break; ++ ++ case 49: ++#line 463 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator>>="); } ++ break; ++ ++ case 50: ++#line 464 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator||"); } ++ break; ++ ++ case 51: ++#line 465 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator&&"); } ++ break; ++ ++ case 52: ++#line 466 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator|"); } ++ break; ++ ++ case 53: ++#line 467 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator^"); } ++ break; ++ ++ case 54: ++#line 468 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator&"); } ++ break; ++ ++ case 55: ++#line 469 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator=="); } ++ break; ++ ++ case 56: ++#line 470 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator!="); } ++ break; ++ ++ case 57: ++#line 471 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator<"); } ++ break; ++ ++ case 58: ++#line 472 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator<="); } ++ break; ++ ++ case 59: ++#line 473 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator>"); } ++ break; ++ ++ case 60: ++#line 474 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator>="); } ++ break; ++ ++ case 61: ++#line 475 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator<<"); } ++ break; ++ ++ case 62: ++#line 476 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator>>"); } ++ break; ++ ++ case 63: ++#line 477 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator+"); } ++ break; ++ ++ case 64: ++#line 478 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator-"); } ++ break; ++ ++ case 65: ++#line 479 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator*"); } ++ break; ++ ++ case 66: ++#line 480 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator/"); } ++ break; ++ ++ case 67: ++#line 481 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator%"); } ++ break; ++ ++ case 68: ++#line 482 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator++"); } ++ break; ++ ++ case 69: ++#line 483 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator--"); } ++ break; ++ ++ case 70: ++#line 484 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator->"); } ++ break; ++ ++ case 71: ++#line 485 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator[]"); } ++ break; ++ ++ case 72: ++#line 486 "soapcpp2_yacc.y" ++ { (yyval.sym) = lookup("operator()"); } ++ break; ++ ++ case 73: ++#line 487 "soapcpp2_yacc.y" ++ { s1 = c_storage((yyvsp[(2) - (2)].rec).sto); ++ s2 = c_type((yyvsp[(2) - (2)].rec).typ); ++ s = (char*)emalloc(strlen(s1) + strlen(s2) + 10); ++ strcpy(s, "operator "); ++ strcat(s, s1); ++ strcat(s, s2); ++ (yyval.sym) = lookup(s); ++ if (!(yyval.sym)) ++ (yyval.sym) = install(s, ID); ++ } ++ break; ++ ++ case 74: ++#line 498 "soapcpp2_yacc.y" ++ { if (!(p = entry(classtable, (yyvsp[(1) - (1)].sym)))) ++ semerror("invalid constructor"); ++ sp->entry = enter(sp->table, (yyvsp[(1) - (1)].sym)); ++ sp->entry->info.typ = mknone(); ++ sp->entry->info.sto = Snone; ++ sp->entry->info.offset = sp->offset; ++ sp->node.typ = mkvoid(); ++ sp->node.sto = Snone; ++ } ++ break; ++ ++ case 75: ++#line 509 "soapcpp2_yacc.y" ++ { if (!(p = entry(classtable, (yyvsp[(3) - (3)].sym)))) ++ semerror("invalid destructor"); ++ s = (char*)emalloc(strlen((yyvsp[(3) - (3)].sym)->name) + 2); ++ strcpy(s, "~"); ++ strcat(s, (yyvsp[(3) - (3)].sym)->name); ++ sym = lookup(s); ++ if (!sym) ++ sym = install(s, ID); ++ sp->entry = enter(sp->table, sym); ++ sp->entry->info.typ = mknone(); ++ sp->entry->info.sto = (yyvsp[(1) - (3)].sto); ++ sp->entry->info.offset = sp->offset; ++ sp->node.typ = mkvoid(); ++ sp->node.sto = Snone; ++ } ++ break; ++ ++ case 76: ++#line 526 "soapcpp2_yacc.y" ++ { if ((yyvsp[(1) - (7)].e)->level == GLOBAL) ++ { if (!((yyvsp[(1) - (7)].e)->info.sto & Sextern) && sp->entry && sp->entry->info.typ->type == Tpointer && ((Tnode*)sp->entry->info.typ->ref)->type == Tchar) ++ { sprintf(errbuf, "last output parameter of remote method function prototype '%s' is a pointer to a char which will only return one byte: use char** instead to return a string", (yyvsp[(1) - (7)].e)->sym->name); ++ semwarn(errbuf); ++ } ++ if ((yyvsp[(1) - (7)].e)->info.sto & Sextern) ++ (yyvsp[(1) - (7)].e)->info.typ = mkmethod((yyvsp[(1) - (7)].e)->info.typ, sp->table); ++ else if (sp->entry && (sp->entry->info.typ->type == Tpointer || sp->entry->info.typ->type == Treference || sp->entry->info.typ->type == Tarray || is_transient(sp->entry->info.typ))) ++ { if ((yyvsp[(1) - (7)].e)->info.typ->type == Tint) ++ { sp->entry->info.sto = (Storage)((int)sp->entry->info.sto | (int)Sreturn); ++ (yyvsp[(1) - (7)].e)->info.typ = mkfun(sp->entry); ++ (yyvsp[(1) - (7)].e)->info.typ->id = (yyvsp[(1) - (7)].e)->sym; ++ if (!is_transient(sp->entry->info.typ)) ++ { if (!is_response(sp->entry->info.typ)) ++ { if (!is_XML(sp->entry->info.typ)) ++ add_response((yyvsp[(1) - (7)].e), sp->entry); ++ } ++ else ++ add_result(sp->entry->info.typ); ++ } ++ } ++ else ++ { sprintf(errbuf, "return type of remote method function prototype '%s' must be integer", (yyvsp[(1) - (7)].e)->sym->name); ++ semerror(errbuf); ++ } ++ } ++ else ++ { sprintf(errbuf, "last output parameter of remote method function prototype '%s' is a return parameter and must be a pointer or reference", (yyvsp[(1) - (7)].e)->sym->name); ++ semerror(errbuf); ++ } ++ if (!((yyvsp[(1) - (7)].e)->info.sto & Sextern)) ++ { unlinklast(sp->table); ++ if ((p = entry(classtable, (yyvsp[(1) - (7)].e)->sym))) ++ { if (p->info.typ->ref) ++ { sprintf(errbuf, "remote method name clash: struct/class '%s' already declared at line %d", (yyvsp[(1) - (7)].e)->sym->name, p->lineno); ++ semerror(errbuf); ++ } ++ else ++ { p->info.typ->ref = sp->table; ++ p->info.typ->width = sp->offset; ++ } ++ } ++ else ++ { p = enter(classtable, (yyvsp[(1) - (7)].e)->sym); ++ p->info.typ = mkstruct(sp->table, sp->offset); ++ p->info.typ->id = (yyvsp[(1) - (7)].e)->sym; ++ } ++ } ++ } ++ else if ((yyvsp[(1) - (7)].e)->level == INTERNAL) ++ { (yyvsp[(1) - (7)].e)->info.typ = mkmethod((yyvsp[(1) - (7)].e)->info.typ, sp->table); ++ (yyvsp[(1) - (7)].e)->info.sto = (Storage)((int)(yyvsp[(1) - (7)].e)->info.sto | (int)(yyvsp[(6) - (7)].sto) | (int)(yyvsp[(7) - (7)].sto)); ++ transient &= ~1; ++ } ++ exitscope(); ++ } ++ break; ++ ++ case 77: ++#line 583 "soapcpp2_yacc.y" ++ { (yyval.e) = sp->entry; } ++ break; ++ ++ case 78: ++#line 585 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 79: ++#line 586 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 80: ++#line 588 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 81: ++#line 589 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 82: ++#line 592 "soapcpp2_yacc.y" ++ { if ((yyvsp[(4) - (6)].rec).sto & Stypedef) ++ semwarn("typedef in function argument"); ++ p = enter(sp->table, (yyvsp[(3) - (6)].sym)); ++ p->info.typ = (yyvsp[(4) - (6)].rec).typ; ++ p->info.sto = (yyvsp[(4) - (6)].rec).sto; ++ if ((yyvsp[(5) - (6)].rec).minOccurs < 0) ++ { if (((yyvsp[(4) - (6)].rec).sto & Sattribute) || (yyvsp[(4) - (6)].rec).typ->type == Tpointer) ++ p->info.minOccurs = 0; ++ else ++ p->info.minOccurs = 1; ++ } ++ else ++ p->info.minOccurs = (yyvsp[(5) - (6)].rec).minOccurs; ++ p->info.maxOccurs = (yyvsp[(5) - (6)].rec).maxOccurs; ++ if ((yyvsp[(6) - (6)].rec).hasval) ++ { p->info.hasval = True; ++ switch ((yyvsp[(4) - (6)].rec).typ->type) ++ { case Tchar: ++ case Tuchar: ++ case Tshort: ++ case Tushort: ++ case Tint: ++ case Tuint: ++ case Tlong: ++ case Tulong: ++ case Tenum: ++ case Ttime: ++ if ((yyvsp[(6) - (6)].rec).typ->type == Tint || (yyvsp[(6) - (6)].rec).typ->type == Tchar || (yyvsp[(6) - (6)].rec).typ->type == Tenum) ++ sp->val = p->info.val.i = (yyvsp[(6) - (6)].rec).val.i; ++ else ++ { semerror("type error in initialization constant"); ++ p->info.hasval = False; ++ } ++ break; ++ case Tfloat: ++ case Tdouble: ++ case Tldouble: ++ if ((yyvsp[(6) - (6)].rec).typ->type == Tfloat || (yyvsp[(6) - (6)].rec).typ->type == Tdouble || (yyvsp[(6) - (6)].rec).typ->type == Tldouble) ++ p->info.val.r = (yyvsp[(6) - (6)].rec).val.r; ++ else if ((yyvsp[(6) - (6)].rec).typ->type == Tint) ++ p->info.val.r = (double)(yyvsp[(6) - (6)].rec).val.i; ++ else ++ { semerror("type error in initialization constant"); ++ p->info.hasval = False; ++ } ++ break; ++ default: ++ if ((yyvsp[(4) - (6)].rec).typ->type == Tpointer ++ && ((Tnode*)(yyvsp[(4) - (6)].rec).typ->ref)->type == Tchar ++ && (yyvsp[(6) - (6)].rec).typ->type == Tpointer ++ && ((Tnode*)(yyvsp[(6) - (6)].rec).typ->ref)->type == Tchar) ++ p->info.val.s = (yyvsp[(6) - (6)].rec).val.s; ++ else if ((yyvsp[(4) - (6)].rec).typ->type == Tpointer ++ && ((Tnode*)(yyvsp[(4) - (6)].rec).typ->ref)->id == lookup("std::string")) ++ p->info.val.s = (yyvsp[(6) - (6)].rec).val.s; ++ else if ((yyvsp[(4) - (6)].rec).typ->id == lookup("std::string")) ++ p->info.val.s = (yyvsp[(6) - (6)].rec).val.s; ++ else if ((yyvsp[(4) - (6)].rec).typ->type == Tpointer ++ && (yyvsp[(6) - (6)].rec).typ->type == Tint ++ && (yyvsp[(6) - (6)].rec).val.i == 0) ++ p->info.val.i = 0; ++ else ++ { semerror("type error in initialization constant"); ++ p->info.hasval = False; ++ } ++ break; ++ } ++ } ++ p->info.offset = sp->offset; ++ if ((yyvsp[(4) - (6)].rec).sto & Sextern) ++ p->level = GLOBAL; ++ else if (sp->grow) ++ sp->offset += p->info.typ->width; ++ else if (p->info.typ->width > sp->offset) ++ sp->offset = p->info.typ->width; ++ sp->entry = p; ++ } ++ break; ++ ++ case 83: ++#line 670 "soapcpp2_yacc.y" ++ { if (sp->table->level != PARAM) ++ (yyval.sym) = gensymidx("param", (int)++sp->val); ++ else if (eflag) ++ (yyval.sym) = gensymidx("_param", (int)++sp->val); ++ else ++ (yyval.sym) = gensym("_param"); ++ } ++ break; ++ ++ case 84: ++#line 677 "soapcpp2_yacc.y" ++ { if (vflag != 1 && *(yyvsp[(1) - (1)].sym)->name == '_' && sp->table->level == GLOBAL) ++ { sprintf(errbuf, "SOAP 1.2 does not support anonymous parameters '%s'", (yyvsp[(1) - (1)].sym)->name); ++ semwarn(errbuf); ++ } ++ (yyval.sym) = (yyvsp[(1) - (1)].sym); ++ } ++ break; ++ ++ case 85: ++#line 693 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(3) - (3)].rec); } ++ break; ++ ++ case 86: ++#line 695 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(4) - (4)].rec); } ++ break; ++ ++ case 87: ++#line 697 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkint(); ++ (yyval.rec).sto = Snone; ++ sp->node = (yyval.rec); ++ } ++ break; ++ ++ case 88: ++#line 701 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ (yyval.rec).sto = (Storage)((int)(yyvsp[(1) - (2)].sto) | (int)(yyvsp[(2) - (2)].rec).sto); ++ if (((yyval.rec).sto & Sattribute) && !is_primitive_or_string((yyvsp[(2) - (2)].rec).typ) && !is_stdstr((yyvsp[(2) - (2)].rec).typ) && !is_binary((yyvsp[(2) - (2)].rec).typ) && !is_external((yyvsp[(2) - (2)].rec).typ)) ++ { semwarn("invalid attribute type"); ++ (yyval.rec).sto &= ~Sattribute; ++ } ++ sp->node = (yyval.rec); ++ if ((yyvsp[(1) - (2)].sto) & Sextern) ++ transient = 0; ++ } ++ break; ++ ++ case 89: ++#line 711 "soapcpp2_yacc.y" ++ { if ((yyvsp[(1) - (2)].typ)->type == Tint) ++ switch ((yyvsp[(2) - (2)].rec).typ->type) ++ { case Tchar: (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; break; ++ case Tshort: (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; break; ++ case Tint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tlong: (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; break; ++ case Tllong: (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; break; ++ default: semwarn("illegal use of 'signed'"); ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ } ++ else if ((yyvsp[(1) - (2)].typ)->type == Tuint) ++ switch ((yyvsp[(2) - (2)].rec).typ->type) ++ { case Tchar: (yyval.rec).typ = mkuchar(); break; ++ case Tshort: (yyval.rec).typ = mkushort(); break; ++ case Tint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tlong: (yyval.rec).typ = mkulong(); break; ++ case Tllong: (yyval.rec).typ = mkullong(); break; ++ default: semwarn("illegal use of 'unsigned'"); ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ } ++ else if ((yyvsp[(1) - (2)].typ)->type == Tlong) ++ switch ((yyvsp[(2) - (2)].rec).typ->type) ++ { case Tint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tlong: (yyval.rec).typ = mkllong(); break; ++ case Tuint: (yyval.rec).typ = mkulong(); break; ++ case Tulong: (yyval.rec).typ = mkullong(); break; ++ case Tdouble: (yyval.rec).typ = mkldouble(); break; ++ default: semwarn("illegal use of 'long'"); ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ } ++ else if ((yyvsp[(1) - (2)].typ)->type == Tulong) ++ switch ((yyvsp[(2) - (2)].rec).typ->type) ++ { case Tint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tlong: (yyval.rec).typ = mkullong(); break; ++ case Tuint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tulong: (yyval.rec).typ = mkullong(); break; ++ default: semwarn("illegal use of 'long'"); ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ } ++ else if ((yyvsp[(2) - (2)].rec).typ->type == Tint) ++ (yyval.rec).typ = (yyvsp[(1) - (2)].typ); ++ else ++ semwarn("invalid type (missing ';'?)"); ++ (yyval.rec).sto = (yyvsp[(2) - (2)].rec).sto; ++ sp->node = (yyval.rec); ++ } ++ break; ++ ++ case 90: ++#line 758 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkint(); ++ (yyval.rec).sto = (yyvsp[(1) - (1)].sto); ++ sp->node = (yyval.rec); ++ if ((yyvsp[(1) - (1)].sto) & Sextern) ++ transient = 0; ++ } ++ break; ++ ++ case 91: ++#line 764 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = (yyvsp[(1) - (1)].typ); ++ (yyval.rec).sto = Snone; ++ sp->node = (yyval.rec); ++ } ++ break; ++ ++ case 92: ++#line 768 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ (yyval.rec).sto = (Storage)((int)(yyvsp[(1) - (2)].sto) | (int)(yyvsp[(2) - (2)].rec).sto); ++ if (((yyval.rec).sto & Sattribute) && !is_primitive_or_string((yyvsp[(2) - (2)].rec).typ) && !is_stdstr((yyvsp[(2) - (2)].rec).typ) && !is_binary((yyvsp[(2) - (2)].rec).typ) && !is_external((yyvsp[(2) - (2)].rec).typ)) ++ { semwarn("invalid attribute type"); ++ (yyval.rec).sto &= ~Sattribute; ++ } ++ sp->node = (yyval.rec); ++ if ((yyvsp[(1) - (2)].sto) & Sextern) ++ transient = 0; ++ } ++ break; ++ ++ case 93: ++#line 778 "soapcpp2_yacc.y" ++ { if ((yyvsp[(1) - (2)].typ)->type == Tint) ++ switch ((yyvsp[(2) - (2)].rec).typ->type) ++ { case Tchar: (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; break; ++ case Tshort: (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; break; ++ case Tint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tlong: (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; break; ++ case Tllong: (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; break; ++ default: semwarn("illegal use of 'signed'"); ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ } ++ else if ((yyvsp[(1) - (2)].typ)->type == Tuint) ++ switch ((yyvsp[(2) - (2)].rec).typ->type) ++ { case Tchar: (yyval.rec).typ = mkuchar(); break; ++ case Tshort: (yyval.rec).typ = mkushort(); break; ++ case Tint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tlong: (yyval.rec).typ = mkulong(); break; ++ case Tllong: (yyval.rec).typ = mkullong(); break; ++ default: semwarn("illegal use of 'unsigned'"); ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ } ++ else if ((yyvsp[(1) - (2)].typ)->type == Tlong) ++ switch ((yyvsp[(2) - (2)].rec).typ->type) ++ { case Tint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tlong: (yyval.rec).typ = mkllong(); break; ++ case Tuint: (yyval.rec).typ = mkulong(); break; ++ case Tulong: (yyval.rec).typ = mkullong(); break; ++ case Tdouble: (yyval.rec).typ = mkldouble(); break; ++ default: semwarn("illegal use of 'long'"); ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ } ++ else if ((yyvsp[(1) - (2)].typ)->type == Tulong) ++ switch ((yyvsp[(2) - (2)].rec).typ->type) ++ { case Tint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tlong: (yyval.rec).typ = mkullong(); break; ++ case Tuint: (yyval.rec).typ = (yyvsp[(1) - (2)].typ); break; ++ case Tulong: (yyval.rec).typ = mkullong(); break; ++ default: semwarn("illegal use of 'long'"); ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ } ++ else if ((yyvsp[(2) - (2)].rec).typ->type == Tint) ++ (yyval.rec).typ = (yyvsp[(1) - (2)].typ); ++ else ++ semwarn("invalid type"); ++ (yyval.rec).sto = (yyvsp[(2) - (2)].rec).sto; ++ sp->node = (yyval.rec); ++ } ++ break; ++ ++ case 94: ++#line 825 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkvoid(); } ++ break; ++ ++ case 95: ++#line 826 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkbool(); } ++ break; ++ ++ case 96: ++#line 827 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkchar(); } ++ break; ++ ++ case 97: ++#line 828 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkwchart(); } ++ break; ++ ++ case 98: ++#line 829 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkshort(); } ++ break; ++ ++ case 99: ++#line 830 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkint(); } ++ break; ++ ++ case 100: ++#line 831 "soapcpp2_yacc.y" ++ { (yyval.typ) = mklong(); } ++ break; ++ ++ case 101: ++#line 832 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkllong(); } ++ break; ++ ++ case 102: ++#line 833 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkullong(); } ++ break; ++ ++ case 103: ++#line 834 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkulong(); } ++ break; ++ ++ case 104: ++#line 835 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkfloat(); } ++ break; ++ ++ case 105: ++#line 836 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkdouble(); } ++ break; ++ ++ case 106: ++#line 837 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkint(); } ++ break; ++ ++ case 107: ++#line 838 "soapcpp2_yacc.y" ++ { (yyval.typ) = mkuint(); } ++ break; ++ ++ case 108: ++#line 839 "soapcpp2_yacc.y" ++ { (yyval.typ) = mktimet(); } ++ break; ++ ++ case 109: ++#line 841 "soapcpp2_yacc.y" ++ { if (!(p = entry(templatetable, (yyvsp[(7) - (7)].sym)))) ++ { p = enter(templatetable, (yyvsp[(7) - (7)].sym)); ++ p->info.typ = mktemplate(NULL, (yyvsp[(7) - (7)].sym)); ++ (yyvsp[(7) - (7)].sym)->token = TYPE; ++ } ++ (yyval.typ) = p->info.typ; ++ } ++ break; ++ ++ case 110: ++#line 849 "soapcpp2_yacc.y" ++ { sym = gensym("_Struct"); ++ sprintf(errbuf, "anonymous class will be named '%s'", sym->name); ++ semwarn(errbuf); ++ if ((p = entry(classtable, sym))) ++ { if (p->info.typ->ref || p->info.typ->type != Tclass) ++ { sprintf(errbuf, "class '%s' already declared at line %d", sym->name, p->lineno); ++ semerror(errbuf); ++ } ++ } ++ else ++ { p = enter(classtable, sym); ++ p->info.typ = mkclass((Table*)0, 0); ++ } ++ sym->token = TYPE; ++ sp->table->sym = sym; ++ p->info.typ->ref = sp->table; ++ p->info.typ->width = sp->offset; ++ p->info.typ->id = sym; ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 111: ++#line 871 "soapcpp2_yacc.y" ++ { p = reenter(classtable, (yyvsp[(1) - (5)].e)->sym); ++ sp->table->sym = p->sym; ++ p->info.typ->ref = sp->table; ++ p->info.typ->width = sp->offset; ++ p->info.typ->id = p->sym; ++ if (p->info.typ->base) ++ sp->table->prev = (Table*)entry(classtable, p->info.typ->base)->info.typ->ref; ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 112: ++#line 882 "soapcpp2_yacc.y" ++ { p = reenter(classtable, (yyvsp[(1) - (7)].e)->sym); ++ sp->table->sym = p->sym; ++ if (!(yyvsp[(3) - (7)].e)) ++ semerror("invalid base class"); ++ else ++ { sp->table->prev = (Table*)(yyvsp[(3) - (7)].e)->info.typ->ref; ++ if (!sp->table->prev && !(yyvsp[(3) - (7)].e)->info.typ->transient) ++ { sprintf(errbuf, "class '%s' has incomplete type", (yyvsp[(3) - (7)].e)->sym->name); ++ semerror(errbuf); ++ } ++ p->info.typ->base = (yyvsp[(3) - (7)].e)->info.typ->id; ++ } ++ p->info.typ->ref = sp->table; ++ p->info.typ->width = sp->offset; ++ p->info.typ->id = p->sym; ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 113: ++#line 900 "soapcpp2_yacc.y" ++ { (yyvsp[(1) - (1)].e)->info.typ->id = (yyvsp[(1) - (1)].e)->sym; ++ (yyval.typ) = (yyvsp[(1) - (1)].e)->info.typ; ++ } ++ break; ++ ++ case 114: ++#line 904 "soapcpp2_yacc.y" ++ { if (!(yyvsp[(3) - (3)].e)) ++ semerror("invalid base class"); ++ else ++ { if (!(yyvsp[(3) - (3)].e)->info.typ->ref && !(yyvsp[(3) - (3)].e)->info.typ->transient) ++ { sprintf(errbuf, "class '%s' has incomplete type", (yyvsp[(3) - (3)].e)->sym->name); ++ semerror(errbuf); ++ } ++ (yyvsp[(1) - (3)].e)->info.typ->base = (yyvsp[(3) - (3)].e)->info.typ->id; ++ } ++ (yyvsp[(1) - (3)].e)->info.typ->id = (yyvsp[(1) - (3)].e)->sym; ++ (yyval.typ) = (yyvsp[(1) - (3)].e)->info.typ; ++ } ++ break; ++ ++ case 115: ++#line 917 "soapcpp2_yacc.y" ++ { sym = gensym("_Struct"); ++ sprintf(errbuf, "anonymous struct will be named '%s'", sym->name); ++ semwarn(errbuf); ++ if ((p = entry(classtable, sym))) ++ { if (p->info.typ->ref || p->info.typ->type != Tstruct) ++ { sprintf(errbuf, "struct '%s' already declared at line %d", sym->name, p->lineno); ++ semerror(errbuf); ++ } ++ else ++ { p->info.typ->ref = sp->table; ++ p->info.typ->width = sp->offset; ++ } ++ } ++ else ++ { p = enter(classtable, sym); ++ p->info.typ = mkstruct(sp->table, sp->offset); ++ } ++ p->info.typ->id = sym; ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 116: ++#line 939 "soapcpp2_yacc.y" ++ { if ((p = entry(classtable, (yyvsp[(1) - (5)].e)->sym)) && p->info.typ->ref) ++ { if (is_mutable(p->info.typ)) ++ { if (merge((Table*)p->info.typ->ref, sp->table)) ++ { sprintf(errbuf, "member name clash in struct '%s' declared at line %d", (yyvsp[(1) - (5)].e)->sym->name, p->lineno); ++ semerror(errbuf); ++ } ++ p->info.typ->width += sp->offset; ++ } ++ } ++ else ++ { p = reenter(classtable, (yyvsp[(1) - (5)].e)->sym); ++ p->info.typ->ref = sp->table; ++ p->info.typ->width = sp->offset; ++ p->info.typ->id = p->sym; ++ } ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 117: ++#line 957 "soapcpp2_yacc.y" ++ { if ((p = entry(classtable, (yyvsp[(2) - (2)].sym)))) ++ { if (p->info.typ->type == Tstruct) ++ (yyval.typ) = p->info.typ; ++ else ++ { sprintf(errbuf, "'struct %s' redeclaration (line %d)", (yyvsp[(2) - (2)].sym)->name, p->lineno); ++ semerror(errbuf); ++ (yyval.typ) = mkint(); ++ } ++ } ++ else ++ { p = enter(classtable, (yyvsp[(2) - (2)].sym)); ++ (yyval.typ) = p->info.typ = mkstruct((Table*)0, 0); ++ p->info.typ->id = (yyvsp[(2) - (2)].sym); ++ } ++ } ++ break; ++ ++ case 118: ++#line 972 "soapcpp2_yacc.y" ++ { if ((p = entry(classtable, (yyvsp[(2) - (2)].sym)))) ++ { if (p->info.typ->type == Tstruct) ++ (yyval.typ) = p->info.typ; ++ else ++ { sprintf(errbuf, "'struct %s' redeclaration (line %d)", (yyvsp[(2) - (2)].sym)->name, p->lineno); ++ semerror(errbuf); ++ (yyval.typ) = mkint(); ++ } ++ } ++ else ++ { p = enter(classtable, (yyvsp[(2) - (2)].sym)); ++ (yyval.typ) = p->info.typ = mkstruct((Table*)0, 0); ++ p->info.typ->id = (yyvsp[(2) - (2)].sym); ++ } ++ } ++ break; ++ ++ case 119: ++#line 988 "soapcpp2_yacc.y" ++ { sym = gensym("_Union"); ++ sprintf(errbuf, "anonymous union will be named '%s'", sym->name); ++ semwarn(errbuf); ++ (yyval.typ) = mkunion(sp->table, sp->offset); ++ if ((p = entry(classtable, sym))) ++ { if ((Table*) p->info.typ->ref) ++ { sprintf(errbuf, "union or struct '%s' already declared at line %d", sym->name, p->lineno); ++ semerror(errbuf); ++ } ++ else ++ { p->info.typ->ref = sp->table; ++ p->info.typ->width = sp->offset; ++ } ++ } ++ else ++ { p = enter(classtable, sym); ++ p->info.typ = mkunion(sp->table, sp->offset); ++ } ++ p->info.typ->id = sym; ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 120: ++#line 1011 "soapcpp2_yacc.y" ++ { if ((p = entry(classtable, (yyvsp[(2) - (6)].sym)))) ++ { if (p->info.typ->ref || p->info.typ->type != Tunion) ++ { sprintf(errbuf, "union '%s' already declared at line %d", (yyvsp[(2) - (6)].sym)->name, p->lineno); ++ semerror(errbuf); ++ } ++ else ++ { p = reenter(classtable, (yyvsp[(2) - (6)].sym)); ++ p->info.typ->ref = sp->table; ++ p->info.typ->width = sp->offset; ++ } ++ } ++ else ++ { p = enter(classtable, (yyvsp[(2) - (6)].sym)); ++ p->info.typ = mkunion(sp->table, sp->offset); ++ } ++ p->info.typ->id = (yyvsp[(2) - (6)].sym); ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 121: ++#line 1030 "soapcpp2_yacc.y" ++ { if ((p = entry(classtable, (yyvsp[(2) - (2)].sym)))) ++ { if (p->info.typ->type == Tunion) ++ (yyval.typ) = p->info.typ; ++ else ++ { sprintf(errbuf, "'union %s' redeclaration (line %d)", (yyvsp[(2) - (2)].sym)->name, p->lineno); ++ semerror(errbuf); ++ (yyval.typ) = mkint(); ++ } ++ } ++ else ++ { p = enter(classtable, (yyvsp[(2) - (2)].sym)); ++ (yyval.typ) = p->info.typ = mkunion((Table*) 0, 0); ++ p->info.typ->id = (yyvsp[(2) - (2)].sym); ++ } ++ } ++ break; ++ ++ case 122: ++#line 1045 "soapcpp2_yacc.y" ++ { if ((p = entry(classtable, (yyvsp[(2) - (2)].sym)))) ++ { if (p->info.typ->type == Tunion) ++ (yyval.typ) = p->info.typ; ++ else ++ { sprintf(errbuf, "'union %s' redeclaration (line %d)", (yyvsp[(2) - (2)].sym)->name, p->lineno); ++ semerror(errbuf); ++ (yyval.typ) = mkint(); ++ } ++ } ++ else ++ { p = enter(classtable, (yyvsp[(2) - (2)].sym)); ++ (yyval.typ) = p->info.typ = mkunion((Table*) 0, 0); ++ p->info.typ->id = (yyvsp[(2) - (2)].sym); ++ } ++ } ++ break; ++ ++ case 123: ++#line 1061 "soapcpp2_yacc.y" ++ { sym = gensym("_Enum"); ++ sprintf(errbuf, "anonymous enum will be named '%s'", sym->name); ++ semwarn(errbuf); ++ if ((p = entry(enumtable, sym))) ++ { if ((Table*) p->info.typ->ref) ++ { sprintf(errbuf, "enum '%s' already declared at line %d", sym->name, p->lineno); ++ semerror(errbuf); ++ } ++ else ++ { p->info.typ->ref = sp->table; ++ p->info.typ->width = 4; /* 4 = enum */ ++ } ++ } ++ else ++ { p = enter(enumtable, sym); ++ p->info.typ = mkenum(sp->table); ++ } ++ p->info.typ->id = sym; ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 124: ++#line 1083 "soapcpp2_yacc.y" ++ { if ((p = entry(enumtable, (yyvsp[(1) - (6)].e)->sym))) ++ { if ((Table*) p->info.typ->ref) ++ { sprintf(errbuf, "enum '%s' already declared at line %d", (yyvsp[(1) - (6)].e)->sym->name, p->lineno); ++ semerror(errbuf); ++ } ++ else ++ { p->info.typ->ref = sp->table; ++ p->info.typ->width = 4; /* 4 = enum */ ++ } ++ } ++ else ++ { p = enter(enumtable, (yyvsp[(1) - (6)].e)->sym); ++ p->info.typ = mkenum(sp->table); ++ } ++ p->info.typ->id = (yyvsp[(1) - (6)].e)->sym; ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 125: ++#line 1102 "soapcpp2_yacc.y" ++ { if ((p = entry(enumtable, (yyvsp[(3) - (8)].sym)))) ++ { if (p->info.typ->ref) ++ { sprintf(errbuf, "enum '%s' already declared at line %d", (yyvsp[(3) - (8)].sym)->name, p->lineno); ++ semerror(errbuf); ++ } ++ else ++ { p->info.typ->ref = sp->table; ++ p->info.typ->width = 8; /* 8 = mask */ ++ } ++ } ++ else ++ { p = enter(enumtable, (yyvsp[(3) - (8)].sym)); ++ p->info.typ = mkmask(sp->table); ++ } ++ p->info.typ->id = (yyvsp[(3) - (8)].sym); ++ (yyval.typ) = p->info.typ; ++ exitscope(); ++ } ++ break; ++ ++ case 126: ++#line 1120 "soapcpp2_yacc.y" ++ { if ((p = entry(enumtable, (yyvsp[(2) - (2)].sym)))) ++ (yyval.typ) = p->info.typ; ++ else ++ { p = enter(enumtable, (yyvsp[(2) - (2)].sym)); ++ (yyval.typ) = p->info.typ = mkenum((Table*)0); ++ p->info.typ->id = (yyvsp[(2) - (2)].sym); ++ } ++ } ++ break; ++ ++ case 127: ++#line 1128 "soapcpp2_yacc.y" ++ { if ((p = entry(enumtable, (yyvsp[(2) - (2)].sym)))) ++ (yyval.typ) = p->info.typ; ++ else ++ { p = enter(enumtable, (yyvsp[(2) - (2)].sym)); ++ (yyval.typ) = p->info.typ = mkenum((Table*)0); ++ p->info.typ->id = (yyvsp[(2) - (2)].sym); ++ } ++ } ++ break; ++ ++ case 128: ++#line 1136 "soapcpp2_yacc.y" ++ { if ((p = entry(typetable, (yyvsp[(1) - (1)].sym)))) ++ (yyval.typ) = p->info.typ; ++ else if ((p = entry(classtable, (yyvsp[(1) - (1)].sym)))) ++ (yyval.typ) = p->info.typ; ++ else if ((p = entry(enumtable, (yyvsp[(1) - (1)].sym)))) ++ (yyval.typ) = p->info.typ; ++ else if ((yyvsp[(1) - (1)].sym) == lookup("std::string") || (yyvsp[(1) - (1)].sym) == lookup("std::wstring")) ++ { p = enter(classtable, (yyvsp[(1) - (1)].sym)); ++ (yyval.typ) = p->info.typ = mkclass((Table*)0, 0); ++ p->info.typ->id = (yyvsp[(1) - (1)].sym); ++ p->info.typ->transient = -2; ++ } ++ else ++ { sprintf(errbuf, "unknown type '%s'", (yyvsp[(1) - (1)].sym)->name); ++ semerror(errbuf); ++ (yyval.typ) = mkint(); ++ } ++ } ++ break; ++ ++ case 129: ++#line 1155 "soapcpp2_yacc.y" ++ { if ((p = entry(templatetable, (yyvsp[(1) - (4)].sym)))) ++ (yyval.typ) = mktemplate((yyvsp[(3) - (4)].rec).typ, (yyvsp[(1) - (4)].sym)); ++ else ++ { sprintf(errbuf, "invalid template '%s'", (yyvsp[(1) - (4)].sym)->name); ++ semerror(errbuf); ++ (yyval.typ) = mkint(); ++ } ++ } ++ break; ++ ++ case 130: ++#line 1164 "soapcpp2_yacc.y" ++ { if ((p = entry(classtable, (yyvsp[(2) - (2)].sym)))) ++ { if (p->info.typ->ref) ++ { if (!is_mutable(p->info.typ)) ++ { sprintf(errbuf, "struct '%s' already declared at line %d", (yyvsp[(2) - (2)].sym)->name, p->lineno); ++ semerror(errbuf); ++ } ++ } ++ else ++ p = reenter(classtable, (yyvsp[(2) - (2)].sym)); ++ } ++ else ++ { p = enter(classtable, (yyvsp[(2) - (2)].sym)); ++ p->info.typ = mkstruct((Table*)0, 0); ++ } ++ (yyval.e) = p; ++ } ++ break; ++ ++ case 131: ++#line 1181 "soapcpp2_yacc.y" ++ { if ((p = entry(classtable, (yyvsp[(2) - (2)].sym)))) ++ { if (p->info.typ->ref) ++ { if (!is_mutable(p->info.typ)) ++ { sprintf(errbuf, "class '%s' already declared at line %d", (yyvsp[(2) - (2)].sym)->name, p->lineno); ++ semerror(errbuf); ++ } ++ } ++ else ++ p = reenter(classtable, (yyvsp[(2) - (2)].sym)); ++ } ++ else ++ { p = enter(classtable, (yyvsp[(2) - (2)].sym)); ++ p->info.typ = mkclass((Table*)0, 0); ++ p->info.typ->id = p->sym; ++ } ++ (yyvsp[(2) - (2)].sym)->token = TYPE; ++ (yyval.e) = p; ++ } ++ break; ++ ++ case 132: ++#line 1200 "soapcpp2_yacc.y" ++ { if ((p = entry(enumtable, (yyvsp[(2) - (2)].sym)))) ++ { if (p->info.typ->ref) ++ { sprintf(errbuf, "enum '%s' already declared at line %d", (yyvsp[(2) - (2)].sym)->name, p->lineno); ++ semerror(errbuf); ++ } ++ /* ++ else ++ p = reenter(classtable, $2); ++ */ ++ } ++ else ++ { p = enter(enumtable, (yyvsp[(2) - (2)].sym)); ++ p->info.typ = mkenum(0); ++ } ++ (yyval.e) = p; ++ } ++ break; ++ ++ case 133: ++#line 1217 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 134: ++#line 1218 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 135: ++#line 1220 "soapcpp2_yacc.y" ++ { (yyval.e) = (yyvsp[(2) - (2)].e); } ++ break; ++ ++ case 136: ++#line 1221 "soapcpp2_yacc.y" ++ { (yyval.e) = (yyvsp[(2) - (2)].e); } ++ break; ++ ++ case 137: ++#line 1222 "soapcpp2_yacc.y" ++ { (yyval.e) = (yyvsp[(2) - (2)].e); } ++ break; ++ ++ case 138: ++#line 1223 "soapcpp2_yacc.y" ++ { (yyval.e) = entry(classtable, (yyvsp[(1) - (1)].sym)); ++ if (!(yyval.e)) ++ { p = entry(typetable, (yyvsp[(1) - (1)].sym)); ++ if (p && (p->info.typ->type == Tclass || p->info.typ->type == Tstruct)) ++ (yyval.e) = p; ++ } ++ } ++ break; ++ ++ case 139: ++#line 1230 "soapcpp2_yacc.y" ++ { (yyval.e) = entry(classtable, (yyvsp[(2) - (2)].sym)); } ++ break; ++ ++ case 140: ++#line 1232 "soapcpp2_yacc.y" ++ { if (transient == -2) ++ transient = 0; ++ permission = 0; ++ enterscope(mktable(NULL), 0); ++ sp->entry = NULL; ++ } ++ break; ++ ++ case 141: ++#line 1239 "soapcpp2_yacc.y" ++ { if (transient == -2) ++ transient = 0; ++ permission = 0; ++ enterscope(mktable(NULL), 0); ++ sp->entry = NULL; ++ sp->grow = False; ++ } ++ break; ++ ++ case 142: ++#line 1247 "soapcpp2_yacc.y" ++ { enterscope(mktable(NULL), 0); ++ sp->entry = NULL; ++ sp->mask = True; ++ sp->val = 1; ++ } ++ break; ++ ++ case 143: ++#line 1253 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 144: ++#line 1254 "soapcpp2_yacc.y" ++ { } ++ break; ++ ++ case 145: ++#line 1256 "soapcpp2_yacc.y" ++ { if (sp->table->level == INTERNAL) ++ transient |= 1; ++ permission = 0; ++ enterscope(mktable(NULL), 0); ++ sp->entry = NULL; ++ sp->table->level = PARAM; ++ } ++ break; ++ ++ case 146: ++#line 1264 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sauto; } ++ break; ++ ++ case 147: ++#line 1265 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sregister; } ++ break; ++ ++ case 148: ++#line 1266 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sstatic; } ++ break; ++ ++ case 149: ++#line 1267 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sexplicit; } ++ break; ++ ++ case 150: ++#line 1268 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sextern; transient = 1; } ++ break; ++ ++ case 151: ++#line 1269 "soapcpp2_yacc.y" ++ { (yyval.sto) = Stypedef; } ++ break; ++ ++ case 152: ++#line 1270 "soapcpp2_yacc.y" ++ { (yyval.sto) = Svirtual; } ++ break; ++ ++ case 153: ++#line 1271 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sconst; } ++ break; ++ ++ case 154: ++#line 1272 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sfriend; } ++ break; ++ ++ case 155: ++#line 1273 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sinline; } ++ break; ++ ++ case 156: ++#line 1274 "soapcpp2_yacc.y" ++ { (yyval.sto) = SmustUnderstand; } ++ break; ++ ++ case 157: ++#line 1275 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sreturn; } ++ break; ++ ++ case 158: ++#line 1276 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sattribute; ++ if (eflag) ++ semwarn("SOAP RPC encoding does not support XML attributes"); ++ } ++ break; ++ ++ case 159: ++#line 1280 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sextern; transient = -2; } ++ break; ++ ++ case 160: ++#line 1282 "soapcpp2_yacc.y" ++ { (yyval.sto) = Snone; } ++ break; ++ ++ case 161: ++#line 1283 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sconstobj; } ++ break; ++ ++ case 162: ++#line 1285 "soapcpp2_yacc.y" ++ { (yyval.sto) = Snone; } ++ break; ++ ++ case 163: ++#line 1286 "soapcpp2_yacc.y" ++ { (yyval.sto) = Sabstract; } ++ break; ++ ++ case 164: ++#line 1288 "soapcpp2_yacc.y" ++ { (yyval.sto) = Snone; } ++ break; ++ ++ case 165: ++#line 1289 "soapcpp2_yacc.y" ++ { (yyval.sto) = Svirtual; } ++ break; ++ ++ case 166: ++#line 1291 "soapcpp2_yacc.y" ++ { (yyval.rec) = tmp = sp->node; } ++ break; ++ ++ case 167: ++#line 1292 "soapcpp2_yacc.y" ++ { /* handle const pointers, such as const char* */ ++ if (/*tmp.typ->type == Tchar &&*/ (tmp.sto & Sconst)) ++ tmp.sto = (tmp.sto & ~Sconst) | Sconstptr; ++ tmp.typ = mkpointer(tmp.typ); ++ tmp.typ->transient = transient; ++ (yyval.rec) = tmp; ++ } ++ break; ++ ++ case 168: ++#line 1299 "soapcpp2_yacc.y" ++ { tmp.typ = mkreference(tmp.typ); ++ tmp.typ->transient = transient; ++ (yyval.rec) = tmp; ++ } ++ break; ++ ++ case 169: ++#line 1304 "soapcpp2_yacc.y" ++ { (yyval.rec) = tmp; /* tmp is inherited */ ++ } ++ break; ++ ++ case 170: ++#line 1307 "soapcpp2_yacc.y" ++ { if ((yyvsp[(4) - (4)].rec).typ->type == Tchar) ++ { sprintf(errbuf, "char["SOAP_LONG_FORMAT"] will be encoded as an array of "SOAP_LONG_FORMAT" bytes: use char* for strings", (yyvsp[(2) - (4)].rec).val.i, (yyvsp[(2) - (4)].rec).val.i); ++ semwarn(errbuf); ++ } ++ if ((yyvsp[(2) - (4)].rec).hasval && (yyvsp[(2) - (4)].rec).typ->type == Tint && (yyvsp[(2) - (4)].rec).val.i > 0 && (yyvsp[(4) - (4)].rec).typ->width > 0) ++ (yyval.rec).typ = mkarray((yyvsp[(4) - (4)].rec).typ, (int) (yyvsp[(2) - (4)].rec).val.i * (yyvsp[(4) - (4)].rec).typ->width); ++ else ++ { (yyval.rec).typ = mkarray((yyvsp[(4) - (4)].rec).typ, 0); ++ semerror("undetermined array size"); ++ } ++ (yyval.rec).sto = (yyvsp[(4) - (4)].rec).sto; ++ } ++ break; ++ ++ case 171: ++#line 1319 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkpointer((yyvsp[(3) - (3)].rec).typ); /* zero size array = pointer */ ++ (yyval.rec).sto = (yyvsp[(3) - (3)].rec).sto; ++ } ++ break; ++ ++ case 172: ++#line 1323 "soapcpp2_yacc.y" ++ { if ((yyvsp[(1) - (1)].rec).typ->type == Tstruct || (yyvsp[(1) - (1)].rec).typ->type == Tclass) ++ if (!(yyvsp[(1) - (1)].rec).typ->ref && !(yyvsp[(1) - (1)].rec).typ->transient && !((yyvsp[(1) - (1)].rec).sto & Stypedef)) ++ { sprintf(errbuf, "struct/class '%s' has incomplete type", (yyvsp[(1) - (1)].rec).typ->id->name); ++ semerror(errbuf); ++ } ++ (yyval.rec) = (yyvsp[(1) - (1)].rec); ++ } ++ break; ++ ++ case 173: ++#line 1331 "soapcpp2_yacc.y" ++ { (yyval.rec).hasval = False; } ++ break; ++ ++ case 174: ++#line 1332 "soapcpp2_yacc.y" ++ { if ((yyvsp[(2) - (2)].rec).hasval) ++ { (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ (yyval.rec).hasval = True; ++ (yyval.rec).val = (yyvsp[(2) - (2)].rec).val; ++ } ++ else ++ { (yyval.rec).hasval = False; ++ semerror("initialization expression not constant"); ++ } ++ } ++ break; ++ ++ case 175: ++#line 1344 "soapcpp2_yacc.y" ++ { (yyval.rec).minOccurs = -1; ++ (yyval.rec).maxOccurs = 1; ++ (yyval.rec).pattern = (yyvsp[(1) - (1)].s); ++ } ++ break; ++ ++ case 176: ++#line 1349 "soapcpp2_yacc.y" ++ { (yyval.rec).minOccurs = (long)(yyvsp[(2) - (2)].i); ++ (yyval.rec).maxOccurs = 1; ++ (yyval.rec).pattern = (yyvsp[(1) - (2)].s); ++ } ++ break; ++ ++ case 177: ++#line 1354 "soapcpp2_yacc.y" ++ { (yyval.rec).minOccurs = (long)(yyvsp[(2) - (3)].i); ++ (yyval.rec).maxOccurs = 1; ++ (yyval.rec).pattern = (yyvsp[(1) - (3)].s); ++ } ++ break; ++ ++ case 178: ++#line 1359 "soapcpp2_yacc.y" ++ { (yyval.rec).minOccurs = (long)(yyvsp[(2) - (4)].i); ++ (yyval.rec).maxOccurs = (long)(yyvsp[(4) - (4)].i); ++ (yyval.rec).pattern = (yyvsp[(1) - (4)].s); ++ } ++ break; ++ ++ case 179: ++#line 1364 "soapcpp2_yacc.y" ++ { (yyval.rec).minOccurs = -1; ++ (yyval.rec).maxOccurs = (long)(yyvsp[(3) - (3)].i); ++ (yyval.rec).pattern = (yyvsp[(1) - (3)].s); ++ } ++ break; ++ ++ case 180: ++#line 1369 "soapcpp2_yacc.y" ++ { (yyval.s) = NULL; } ++ break; ++ ++ case 181: ++#line 1370 "soapcpp2_yacc.y" ++ { (yyval.s) = (yyvsp[(1) - (1)].s); } ++ break; ++ ++ case 182: ++#line 1372 "soapcpp2_yacc.y" ++ { (yyval.i) = (yyvsp[(1) - (1)].i); } ++ break; ++ ++ case 183: ++#line 1373 "soapcpp2_yacc.y" ++ { (yyval.i) = (yyvsp[(2) - (2)].i); } ++ break; ++ ++ case 184: ++#line 1374 "soapcpp2_yacc.y" ++ { (yyval.i) = -(yyvsp[(2) - (2)].i); } ++ break; ++ ++ case 185: ++#line 1383 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(3) - (3)].rec); } ++ break; ++ ++ case 186: ++#line 1384 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(1) - (1)].rec); } ++ break; ++ ++ case 187: ++#line 1388 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = (yyvsp[(3) - (5)].rec).typ; ++ (yyval.rec).sto = Snone; ++ (yyval.rec).hasval = False; ++ } ++ break; ++ ++ case 189: ++#line 1395 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(1) - (1)].rec); } ++ break; ++ ++ case 190: ++#line 1398 "soapcpp2_yacc.y" ++ { (yyval.rec).hasval = False; ++ (yyval.rec).typ = mkint(); ++ } ++ break; ++ ++ case 191: ++#line 1401 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(1) - (1)].rec); } ++ break; ++ ++ case 192: ++#line 1403 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(1) - (1)].rec); } ++ break; ++ ++ case 193: ++#line 1406 "soapcpp2_yacc.y" ++ { (yyval.rec).hasval = False; ++ (yyval.rec).typ = mkint(); ++ } ++ break; ++ ++ case 194: ++#line 1409 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(1) - (1)].rec); } ++ break; ++ ++ case 195: ++#line 1411 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(1) - (1)].rec); } ++ break; ++ ++ case 196: ++#line 1414 "soapcpp2_yacc.y" ++ { (yyval.rec) = iop("|", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 197: ++#line 1415 "soapcpp2_yacc.y" ++ { (yyval.rec) = iop("^", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 198: ++#line 1416 "soapcpp2_yacc.y" ++ { (yyval.rec) = iop("&", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 199: ++#line 1417 "soapcpp2_yacc.y" ++ { (yyval.rec) = relop("==", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 200: ++#line 1418 "soapcpp2_yacc.y" ++ { (yyval.rec) = relop("!=", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 201: ++#line 1419 "soapcpp2_yacc.y" ++ { (yyval.rec) = relop("<", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 202: ++#line 1420 "soapcpp2_yacc.y" ++ { (yyval.rec) = relop("<=", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 203: ++#line 1421 "soapcpp2_yacc.y" ++ { (yyval.rec) = relop(">", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 204: ++#line 1422 "soapcpp2_yacc.y" ++ { (yyval.rec) = relop(">=", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 205: ++#line 1423 "soapcpp2_yacc.y" ++ { (yyval.rec) = iop("<<", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 206: ++#line 1424 "soapcpp2_yacc.y" ++ { (yyval.rec) = iop(">>", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 207: ++#line 1425 "soapcpp2_yacc.y" ++ { (yyval.rec) = op("+", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 208: ++#line 1426 "soapcpp2_yacc.y" ++ { (yyval.rec) = op("-", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 209: ++#line 1427 "soapcpp2_yacc.y" ++ { (yyval.rec) = op("*", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 210: ++#line 1428 "soapcpp2_yacc.y" ++ { (yyval.rec) = op("/", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 211: ++#line 1429 "soapcpp2_yacc.y" ++ { (yyval.rec) = iop("%", (yyvsp[(1) - (3)].rec), (yyvsp[(3) - (3)].rec)); } ++ break; ++ ++ case 212: ++#line 1430 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(1) - (1)].rec); } ++ break; ++ ++ case 213: ++#line 1433 "soapcpp2_yacc.y" ++ { if ((yyvsp[(2) - (2)].rec).hasval) ++ (yyval.rec).val.i = !(yyvsp[(2) - (2)].rec).val.i; ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ (yyval.rec).hasval = (yyvsp[(2) - (2)].rec).hasval; ++ } ++ break; ++ ++ case 214: ++#line 1438 "soapcpp2_yacc.y" ++ { if ((yyvsp[(2) - (2)].rec).hasval) ++ (yyval.rec).val.i = ~(yyvsp[(2) - (2)].rec).val.i; ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ (yyval.rec).hasval = (yyvsp[(2) - (2)].rec).hasval; ++ } ++ break; ++ ++ case 215: ++#line 1443 "soapcpp2_yacc.y" ++ { if ((yyvsp[(2) - (2)].rec).hasval) { ++ if (integer((yyvsp[(2) - (2)].rec).typ)) ++ (yyval.rec).val.i = -(yyvsp[(2) - (2)].rec).val.i; ++ else if (real((yyvsp[(2) - (2)].rec).typ)) ++ (yyval.rec).val.r = -(yyvsp[(2) - (2)].rec).val.r; ++ else typerror("string?"); ++ } ++ (yyval.rec).typ = (yyvsp[(2) - (2)].rec).typ; ++ (yyval.rec).hasval = (yyvsp[(2) - (2)].rec).hasval; ++ } ++ break; ++ ++ case 216: ++#line 1453 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(2) - (2)].rec); } ++ break; ++ ++ case 217: ++#line 1454 "soapcpp2_yacc.y" ++ { if ((yyvsp[(2) - (2)].rec).typ->type == Tpointer) { ++ (yyval.rec).typ = (Tnode*) (yyvsp[(2) - (2)].rec).typ->ref; ++ } else ++ typerror("dereference of non-pointer type"); ++ (yyval.rec).sto = Snone; ++ (yyval.rec).hasval = False; ++ } ++ break; ++ ++ case 218: ++#line 1461 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkpointer((yyvsp[(2) - (2)].rec).typ); ++ (yyval.rec).sto = Snone; ++ (yyval.rec).hasval = False; ++ } ++ break; ++ ++ case 219: ++#line 1466 "soapcpp2_yacc.y" ++ { (yyval.rec).hasval = True; ++ (yyval.rec).typ = mkint(); ++ (yyval.rec).val.i = (yyvsp[(3) - (4)].rec).typ->width; ++ } ++ break; ++ ++ case 220: ++#line 1470 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(1) - (1)].rec); } ++ break; ++ ++ case 221: ++#line 1473 "soapcpp2_yacc.y" ++ { (yyval.rec) = (yyvsp[(2) - (3)].rec); } ++ break; ++ ++ case 222: ++#line 1474 "soapcpp2_yacc.y" ++ { if ((p = enumentry((yyvsp[(1) - (1)].sym))) == (Entry*) 0) ++ p = undefined((yyvsp[(1) - (1)].sym)); ++ else ++ (yyval.rec).hasval = True; ++ (yyval.rec).typ = p->info.typ; ++ (yyval.rec).val = p->info.val; ++ } ++ break; ++ ++ case 223: ++#line 1481 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkint(); ++ (yyval.rec).hasval = True; ++ (yyval.rec).val.i = (yyvsp[(1) - (1)].i); ++ } ++ break; ++ ++ case 224: ++#line 1485 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkint(); ++ (yyval.rec).hasval = True; ++ (yyval.rec).val.i = 0; ++ } ++ break; ++ ++ case 225: ++#line 1489 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkfloat(); ++ (yyval.rec).hasval = True; ++ (yyval.rec).val.r = (yyvsp[(1) - (1)].r); ++ } ++ break; ++ ++ case 226: ++#line 1493 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkchar(); ++ (yyval.rec).hasval = True; ++ (yyval.rec).val.i = (yyvsp[(1) - (1)].c); ++ } ++ break; ++ ++ case 227: ++#line 1497 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkstring(); ++ (yyval.rec).hasval = True; ++ (yyval.rec).val.s = (yyvsp[(1) - (1)].s); ++ } ++ break; ++ ++ case 228: ++#line 1501 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkbool(); ++ (yyval.rec).hasval = True; ++ (yyval.rec).val.i = 0; ++ } ++ break; ++ ++ case 229: ++#line 1505 "soapcpp2_yacc.y" ++ { (yyval.rec).typ = mkbool(); ++ (yyval.rec).hasval = True; ++ (yyval.rec).val.i = 1; ++ } ++ break; ++ ++ ++/* Line 1267 of yacc.c. */ ++#line 4143 "soapcpp2_yacc.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; ++ } ++ } ++#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 (yyn == YYFINAL) ++ YYACCEPT; ++ ++ *++yyvsp = yylval; ++ ++ ++ /* Shift the error token. */ ++ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); ++ ++ yystate = yyn; ++ goto yynewstate; ++ ++ ++/*-------------------------------------. ++| yyacceptlab -- YYACCEPT comes here. | ++`-------------------------------------*/ ++yyacceptlab: ++ yyresult = 0; ++ goto yyreturn; ++ ++/*-----------------------------------. ++| yyabortlab -- YYABORT comes here. | ++`-----------------------------------*/ ++yyabortlab: ++ yyresult = 1; ++ goto yyreturn; ++ ++#ifndef yyoverflow ++/*-------------------------------------------------. ++| yyexhaustedlab -- memory exhaustion comes here. | ++`-------------------------------------------------*/ ++yyexhaustedlab: ++ yyerror (YY_("memory exhausted")); ++ yyresult = 2; ++ /* Fall through. */ ++#endif ++ ++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); ++#endif ++ /* Make sure YYID is used. */ ++ return YYID (yyresult); ++} ++ ++ ++#line 1511 "soapcpp2_yacc.y" ++ ++ ++/* ++ * ??? ++ */ ++int ++yywrap() ++{ return 1; ++} ++ ++/******************************************************************************\ ++ ++ Support routines ++ ++\******************************************************************************/ ++ ++static Node ++op(const char *op, Node p, Node q) ++{ Node r; ++ Tnode *typ; ++ r.typ = p.typ; ++ r.sto = Snone; ++ if (p.hasval && q.hasval) { ++ if (integer(p.typ) && integer(q.typ)) ++ switch (op[0]) { ++ case '|': r.val.i = p.val.i | q.val.i; break; ++ case '^': r.val.i = p.val.i ^ q.val.i; break; ++ case '&': r.val.i = p.val.i & q.val.i; break; ++ case '<': r.val.i = p.val.i << q.val.i; break; ++ case '>': r.val.i = p.val.i >> q.val.i; break; ++ case '+': r.val.i = p.val.i + q.val.i; break; ++ case '-': r.val.i = p.val.i - q.val.i; break; ++ case '*': r.val.i = p.val.i * q.val.i; break; ++ case '/': r.val.i = p.val.i / q.val.i; break; ++ case '%': r.val.i = p.val.i % q.val.i; break; ++ default: typerror(op); ++ } ++ else if (real(p.typ) && real(q.typ)) ++ switch (op[0]) { ++ case '+': r.val.r = p.val.r + q.val.r; break; ++ case '-': r.val.r = p.val.r - q.val.r; break; ++ case '*': r.val.r = p.val.r * q.val.r; break; ++ case '/': r.val.r = p.val.r / q.val.r; break; ++ default: typerror(op); ++ } ++ else semerror("illegal constant operation"); ++ r.hasval = True; ++ } else { ++ typ = mgtype(p.typ, q.typ); ++ r.hasval = False; ++ } ++ return r; ++} ++ ++static Node ++iop(const char *iop, Node p, Node q) ++{ if (integer(p.typ) && integer(q.typ)) ++ return op(iop, p, q); ++ typerror("integer operands only"); ++ return p; ++} ++ ++static Node ++relop(const char *op, Node p, Node q) ++{ Node r; ++ Tnode *typ; ++ r.typ = mkint(); ++ r.sto = Snone; ++ r.hasval = False; ++ if (p.typ->type != Tpointer || p.typ != q.typ) ++ typ = mgtype(p.typ, q.typ); ++ return r; ++} ++ ++/******************************************************************************\ ++ ++ Scope management ++ ++\******************************************************************************/ ++ ++/* ++mkscope - initialize scope stack with a new table and offset ++*/ ++static void ++mkscope(Table *table, int offset) ++{ sp = stack-1; ++ enterscope(table, offset); ++} ++ ++/* ++enterscope - enter a new scope by pushing a new table and offset on the stack ++*/ ++static void ++enterscope(Table *table, int offset) ++{ if (++sp == stack+MAXNEST) ++ execerror("maximum scope depth exceeded"); ++ sp->table = table; ++ sp->val = 0; ++ sp->offset = offset; ++ sp->grow = True; /* by default, offset grows */ ++ sp->mask = False; ++} ++ ++/* ++exitscope - exit a scope by popping the table and offset from the stack ++*/ ++static void ++exitscope() ++{ check(sp-- != stack, "exitscope() has no matching enterscope()"); ++} ++ ++/******************************************************************************\ ++ ++ Undefined symbol ++ ++\******************************************************************************/ ++ ++static Entry* ++undefined(Symbol *sym) ++{ Entry *p; ++ sprintf(errbuf, "undefined identifier '%s'", sym->name); ++ semwarn(errbuf); ++ p = enter(sp->table, sym); ++ p->level = GLOBAL; ++ p->info.typ = mkint(); ++ p->info.sto = Sextern; ++ p->info.hasval = False; ++ return p; ++} ++ ++/* ++mgtype - return most general type among two numerical types ++*/ ++Tnode* ++mgtype(Tnode *typ1, Tnode *typ2) ++{ if (numeric(typ1) && numeric(typ2)) { ++ if (typ1->type < typ2->type) ++ return typ2; ++ } else typerror("non-numeric type"); ++ return typ1; ++} ++ ++/******************************************************************************\ ++ ++ Type checks ++ ++\******************************************************************************/ ++ ++static int ++integer(Tnode *typ) ++{ switch (typ->type) { ++ case Tchar: ++ case Tshort: ++ case Tint: ++ case Tlong: return True; ++ default: break; ++ } ++ return False; ++} ++ ++static int ++real(Tnode *typ) ++{ switch (typ->type) { ++ case Tfloat: ++ case Tdouble: ++ case Tldouble: return True; ++ default: break; ++ } ++ return False; ++} ++ ++static int ++numeric(Tnode *typ) ++{ return integer(typ) || real(typ); ++} ++ ++static void ++add_fault(Table *gt) ++{ Table *t; ++ Entry *p1, *p2, *p3, *p4; ++ Symbol *s1, *s2, *s3, *s4; ++ imported = NULL; ++ s1 = lookup("SOAP_ENV__Code"); ++ p1 = entry(classtable, s1); ++ if (!p1 || !p1->info.typ->ref) ++ { t = mktable((Table*)0); ++ if (!p1) ++ { p1 = enter(classtable, s1); ++ p1->info.typ = mkstruct(t, 3*4); ++ p1->info.typ->id = s1; ++ } ++ else ++ p1->info.typ->ref = t; ++ p2 = enter(t, lookup("SOAP_ENV__Value")); ++ p2->info.typ = qname; ++ p2->info.minOccurs = 0; ++ p2 = enter(t, lookup("SOAP_ENV__Subcode")); ++ p2->info.typ = mkpointer(p1->info.typ); ++ p2->info.minOccurs = 0; ++ } ++ s2 = lookup("SOAP_ENV__Detail"); ++ p2 = entry(classtable, s2); ++ if (!p2 || !p2->info.typ->ref) ++ { t = mktable((Table*)0); ++ if (!p2) ++ { p2 = enter(classtable, s2); ++ p2->info.typ = mkstruct(t, 3*4); ++ p2->info.typ->id = s2; ++ } ++ else ++ p2->info.typ->ref = t; ++ p3 = enter(t, lookup("__type")); ++ p3->info.typ = mkint(); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, lookup("fault")); ++ p3->info.typ = mkpointer(mkvoid()); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, lookup("__any")); ++ p3->info.typ = xml; ++ p3->info.minOccurs = 0; ++ custom_fault = 0; ++ } ++ s4 = lookup("SOAP_ENV__Reason"); ++ p4 = entry(classtable, s4); ++ if (!p4 || !p4->info.typ->ref) ++ { t = mktable((Table*)0); ++ if (!p4) ++ { p4 = enter(classtable, s4); ++ p4->info.typ = mkstruct(t, 4); ++ p4->info.typ->id = s4; ++ } ++ else ++ p4->info.typ->ref = t; ++ p3 = enter(t, lookup("SOAP_ENV__Text")); ++ p3->info.typ = mkstring(); ++ p3->info.minOccurs = 0; ++ } ++ s3 = lookup("SOAP_ENV__Fault"); ++ p3 = entry(classtable, s3); ++ if (!p3 || !p3->info.typ->ref) ++ { t = mktable(NULL); ++ if (!p3) ++ { p3 = enter(classtable, s3); ++ p3->info.typ = mkstruct(t, 9*4); ++ p3->info.typ->id = s3; ++ } ++ else ++ p3->info.typ->ref = t; ++ p3 = enter(t, lookup("faultcode")); ++ p3->info.typ = qname; ++ p3->info.minOccurs = 0; ++ p3 = enter(t, lookup("faultstring")); ++ p3->info.typ = mkstring(); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, lookup("faultactor")); ++ p3->info.typ = mkstring(); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, lookup("detail")); ++ p3->info.typ = mkpointer(p2->info.typ); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, s1); ++ p3->info.typ = mkpointer(p1->info.typ); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, s4); ++ p3->info.typ = mkpointer(p4->info.typ); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, lookup("SOAP_ENV__Node")); ++ p3->info.typ = mkstring(); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, lookup("SOAP_ENV__Role")); ++ p3->info.typ = mkstring(); ++ p3->info.minOccurs = 0; ++ p3 = enter(t, lookup("SOAP_ENV__Detail")); ++ p3->info.typ = mkpointer(p2->info.typ); ++ p3->info.minOccurs = 0; ++ } ++} ++ ++static void ++add_soap() ++{ Symbol *s = lookup("soap"); ++ p = enter(classtable, s); ++ p->info.typ = mkstruct(NULL, 0); ++ p->info.typ->transient = -2; ++ p->info.typ->id = s; ++} ++ ++static void ++add_XML() ++{ Symbol *s = lookup("_XML"); ++ p = enter(typetable, s); ++ xml = p->info.typ = mksymtype(mkstring(), s); ++ p->info.sto = Stypedef; ++} ++ ++static void ++add_qname() ++{ Symbol *s = lookup("_QName"); ++ p = enter(typetable, s); ++ qname = p->info.typ = mksymtype(mkstring(), s); ++ p->info.sto = Stypedef; ++} ++ ++static void ++add_header(Table *gt) ++{ Table *t; ++ Entry *p; ++ Symbol *s = lookup("SOAP_ENV__Header"); ++ imported = NULL; ++ p = entry(classtable, s); ++ if (!p || !p->info.typ->ref) ++ { t = mktable((Table*)0); ++ if (!p) ++ p = enter(classtable, s); ++ p->info.typ = mkstruct(t, 0); ++ p->info.typ->id = s; ++ custom_header = 0; ++ } ++} ++ ++static void ++add_response(Entry *fun, Entry *ret) ++{ Table *t; ++ Entry *p, *q; ++ Symbol *s; ++ size_t n = strlen(fun->sym->name); ++ char *r = (char*)emalloc(n+9); ++ strcpy(r, fun->sym->name); ++ strcat(r, "Response"); ++ if (!(s = lookup(r))) ++ s = install(r, ID); ++ free(r); ++ t = mktable((Table*)0); ++ q = enter(t, ret->sym); ++ q->info = ret->info; ++ if (q->info.typ->type == Treference) ++ q->info.typ = (Tnode*)q->info.typ->ref; ++ p = enter(classtable, s); ++ p->info.typ = mkstruct(t, 4); ++ p->info.typ->id = s; ++ fun->info.typ->response = p; ++} ++ ++static void ++add_result(Tnode *typ) ++{ Entry *p; ++ if (!typ->ref || !((Tnode*)typ->ref)->ref) ++ { semwarn("response struct/class must be declared before used in function prototype"); ++ return; ++ } ++ for (p = ((Table*)((Tnode*)typ->ref)->ref)->list; p; p = p->next) ++ if (p->info.sto & Sreturn) ++ return; ++ for (p = ((Table*)((Tnode*)typ->ref)->ref)->list; p; p = p->next) ++ { if (p->info.typ->type != Tfun && !(p->info.sto & Sattribute) && !is_transient(p->info.typ) && !(p->info.sto & (Sprivate|Sprotected))) ++ p->info.sto = (Storage)((int)p->info.sto | (int)Sreturn); ++ return; ++ } ++} ++ +diff -urN d/gsoap/src/soapcpp2_yacc.h e/gsoap/src/soapcpp2_yacc.h +--- d/gsoap/src/soapcpp2_yacc.h 1970-01-01 01:00:00.000000000 +0100 ++++ e/gsoap/src/soapcpp2_yacc.h 2010-01-24 11:59:32.000000000 +0100 +@@ -0,0 +1,243 @@ ++/* A Bison parser, made by GNU Bison 2.3. */ ++ ++/* Skeleton interface 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. */ ++ ++/* Tokens. */ ++#ifndef YYTOKENTYPE ++# define YYTOKENTYPE ++ /* Put the tokens into the symbol table, so that GDB and other debuggers ++ know about them. */ ++ enum yytokentype { ++ PRAGMA = 258, ++ AUTO = 259, ++ DOUBLE = 260, ++ INT = 261, ++ STRUCT = 262, ++ BREAK = 263, ++ ELSE = 264, ++ LONG = 265, ++ SWITCH = 266, ++ CASE = 267, ++ ENUM = 268, ++ REGISTER = 269, ++ TYPEDEF = 270, ++ CHAR = 271, ++ EXTERN = 272, ++ RETURN = 273, ++ UNION = 274, ++ CONST = 275, ++ FLOAT = 276, ++ SHORT = 277, ++ UNSIGNED = 278, ++ CONTINUE = 279, ++ FOR = 280, ++ SIGNED = 281, ++ VOID = 282, ++ DEFAULT = 283, ++ GOTO = 284, ++ SIZEOF = 285, ++ VOLATILE = 286, ++ DO = 287, ++ IF = 288, ++ STATIC = 289, ++ WHILE = 290, ++ CLASS = 291, ++ PRIVATE = 292, ++ PROTECTED = 293, ++ PUBLIC = 294, ++ VIRTUAL = 295, ++ INLINE = 296, ++ OPERATOR = 297, ++ LLONG = 298, ++ BOOL = 299, ++ CFALSE = 300, ++ CTRUE = 301, ++ WCHAR = 302, ++ TIME = 303, ++ USING = 304, ++ NAMESPACE = 305, ++ ULLONG = 306, ++ MUSTUNDERSTAND = 307, ++ SIZE = 308, ++ FRIEND = 309, ++ TEMPLATE = 310, ++ EXPLICIT = 311, ++ TYPENAME = 312, ++ RESTRICT = 313, ++ null = 314, ++ NONE = 315, ++ ID = 316, ++ LAB = 317, ++ TYPE = 318, ++ LNG = 319, ++ DBL = 320, ++ CHR = 321, ++ STR = 322, ++ RA = 323, ++ LA = 324, ++ OA = 325, ++ XA = 326, ++ AA = 327, ++ MA = 328, ++ DA = 329, ++ TA = 330, ++ NA = 331, ++ PA = 332, ++ OR = 333, ++ AN = 334, ++ NE = 335, ++ EQ = 336, ++ GE = 337, ++ LE = 338, ++ RS = 339, ++ LS = 340, ++ AR = 341, ++ PP = 342, ++ NN = 343 ++ }; ++#endif ++/* Tokens. */ ++#define PRAGMA 258 ++#define AUTO 259 ++#define DOUBLE 260 ++#define INT 261 ++#define STRUCT 262 ++#define BREAK 263 ++#define ELSE 264 ++#define LONG 265 ++#define SWITCH 266 ++#define CASE 267 ++#define ENUM 268 ++#define REGISTER 269 ++#define TYPEDEF 270 ++#define CHAR 271 ++#define EXTERN 272 ++#define RETURN 273 ++#define UNION 274 ++#define CONST 275 ++#define FLOAT 276 ++#define SHORT 277 ++#define UNSIGNED 278 ++#define CONTINUE 279 ++#define FOR 280 ++#define SIGNED 281 ++#define VOID 282 ++#define DEFAULT 283 ++#define GOTO 284 ++#define SIZEOF 285 ++#define VOLATILE 286 ++#define DO 287 ++#define IF 288 ++#define STATIC 289 ++#define WHILE 290 ++#define CLASS 291 ++#define PRIVATE 292 ++#define PROTECTED 293 ++#define PUBLIC 294 ++#define VIRTUAL 295 ++#define INLINE 296 ++#define OPERATOR 297 ++#define LLONG 298 ++#define BOOL 299 ++#define CFALSE 300 ++#define CTRUE 301 ++#define WCHAR 302 ++#define TIME 303 ++#define USING 304 ++#define NAMESPACE 305 ++#define ULLONG 306 ++#define MUSTUNDERSTAND 307 ++#define SIZE 308 ++#define FRIEND 309 ++#define TEMPLATE 310 ++#define EXPLICIT 311 ++#define TYPENAME 312 ++#define RESTRICT 313 ++#define null 314 ++#define NONE 315 ++#define ID 316 ++#define LAB 317 ++#define TYPE 318 ++#define LNG 319 ++#define DBL 320 ++#define CHR 321 ++#define STR 322 ++#define RA 323 ++#define LA 324 ++#define OA 325 ++#define XA 326 ++#define AA 327 ++#define MA 328 ++#define DA 329 ++#define TA 330 ++#define NA 331 ++#define PA 332 ++#define OR 333 ++#define AN 334 ++#define NE 335 ++#define EQ 336 ++#define GE 337 ++#define LE 338 ++#define RS 339 ++#define LS 340 ++#define AR 341 ++#define PP 342 ++#define NN 343 ++ ++ ++ ++ ++#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED ++typedef union YYSTYPE ++#line 135 "soapcpp2_yacc.y" ++{ Symbol *sym; ++ LONG64 i; ++ double r; ++ char c; ++ char *s; ++ Tnode *typ; ++ Storage sto; ++ Node rec; ++ Entry *e; ++} ++/* Line 1489 of yacc.c. */ ++#line 236 "soapcpp2_yacc.h" ++ YYSTYPE; ++# define yystype YYSTYPE /* obsolescent; will be withdrawn */ ++# define YYSTYPE_IS_DECLARED 1 ++# define YYSTYPE_IS_TRIVIAL 1 ++#endif ++ ++extern YYSTYPE yylval; ++ diff --git a/src/gsoap.mk b/src/gsoap.mk index 91e92f9..4808560 100644 --- a/src/gsoap.mk +++ b/src/gsoap.mk @@ -32,6 +32,12 @@ define $(PKG)_BUILD # automake --add-missing # autoconf + # gsoap-3-lex-yacc.patch + # Tarball does not supply lex- and yacc-generated sources. + # This patch supplies them because mingw-cross-env does not + # require yacc or flex. + # These files must survive "make clean". + # Native build to get tools wsdl2h and soapcpp2 cd '$(1)' && ./configure |