-#line 2 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_l.cpp"
+#line 2 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_l.cpp"
-#line 4 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_l.cpp"
+#line 4 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_l.cpp"
#define YY_INT_ALIGNED short int
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
-#define YY_FLEX_SUBMINOR_VERSION 0
+#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
+#ifdef yyget_lval
+#define yyget_lval_ALREADY_DEFINED
+#else
+#define yyget_lval yyget_lval
+#endif
+
+#ifdef yyset_lval
+#define yyset_lval_ALREADY_DEFINED
+#else
+#define yyset_lval yyset_lval
+#endif
+
+#ifdef yyget_lloc
+#define yyget_lloc_ALREADY_DEFINED
+#else
+#define yyget_lloc yyget_lloc
+#endif
+
+#ifdef yyset_lloc
+#define yyset_lloc_ALREADY_DEFINED
+#else
+#define yyset_lloc yyset_lloc
+#endif
+
/* First, we deal with platform-specific or compiler-specific issues. */
/* begin standard C headers. */
#define UINT32_MAX (4294967295U)
#endif
+#ifndef SIZE_MAX
+#define SIZE_MAX (~(size_t)0)
+#endif
+
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
-#ifdef __cplusplus
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
+/* begin standard C++ headers. */
-#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
+/* TODO: this is always defined, so inline it */
#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
#else
-#define yyconst
+#define yynoreturn
#endif
/* Returned upon end-of-file. */
#define YY_NULL 0
-/* Promotes a possibly negative, possibly signed char to an unsigned
- * integer for use as an array index. If the signed char is negative,
- * we want to instead treat it as an 8-bit unsigned char, hence the
- * double cast.
+/* Promotes a possibly negative, possibly signed char to an
+ * integer in range [0..255] for use as an array index.
*/
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
* definition of BEGIN.
*/
#define BEGIN yyg->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 ((yyg->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 ,yyscanner )
-
+#define YY_NEW_FILE yyrestart( yyin , yyscanner )
#define YY_END_OF_BUFFER_CHAR 0
/* Size of default input buffer. */
#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.
+ * 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.
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \
while ( 0 )
-
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
#ifndef YY_STRUCT_YY_BUFFER_STATE
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
- yy_size_t yy_buf_size;
+ int yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
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.
*/
#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
? yyg->yy_buffer_stack[yyg->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 yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
-void yyrestart (FILE *input_file ,yyscan_t yyscanner );
-void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
-void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-void yypop_buffer_state (yyscan_t yyscanner );
-
-static void yyensure_buffer_stack (yyscan_t yyscanner );
-static void yy_load_buffer_state (yyscan_t yyscanner );
-static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
-#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
-YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
-void *yyalloc (yy_size_t ,yyscan_t yyscanner );
-void *yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
-void yyfree (void * ,yyscan_t yyscanner );
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
#define yy_new_buffer yy_create_buffer
-
#define yy_set_interactive(is_interactive) \
{ \
if ( ! YY_CURRENT_BUFFER ){ \
yyensure_buffer_stack (yyscanner); \
YY_CURRENT_BUFFER_LVALUE = \
- yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}
-
#define yy_set_bol(at_bol) \
{ \
if ( ! YY_CURRENT_BUFFER ){\
yyensure_buffer_stack (yyscanner); \
YY_CURRENT_BUFFER_LVALUE = \
- yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
}
-
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
/* Begin user sect3 */
#define yywrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
-
-typedef unsigned char YY_CHAR;
+typedef flex_uint8_t YY_CHAR;
typedef int yy_state_type;
#define yytext_ptr yytext_r
-static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
-static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
-static int yy_get_next_buffer (yyscan_t yyscanner );
-#if defined(__GNUC__) && __GNUC__ >= 3
-__attribute__((__noreturn__))
-#endif
-static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
/* Done after the current pattern has been matched and before the
* corresponding action - sets up yytext.
*/
#define YY_DO_BEFORE_ACTION \
yyg->yytext_ptr = yy_bp; \
- yyleng = (size_t) (yy_cp - yy_bp); \
+ yyleng = (int) (yy_cp - yy_bp); \
yyg->yy_hold_char = *yy_cp; \
*yy_cp = '\0'; \
yyg->yy_c_buf_p = yy_cp;
-
#define YY_NUM_RULES 46
#define YY_END_OF_BUFFER 47
/* This struct is not used in this scanner,
flex_int32_t yy_verify;
flex_int32_t yy_nxt;
};
-static yyconst flex_int16_t yy_accept[132] =
+static const flex_int16_t yy_accept[132] =
{ 0,
0, 0, 0, 0, 0, 0, 47, 45, 12, 11,
8, 16, 17, 13, 45, 18, 35, 44, 36, 41,
0
} ;
-static yyconst YY_CHAR yy_ec[256] =
+static const YY_CHAR yy_ec[256] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1
} ;
-static yyconst YY_CHAR yy_meta[38] =
+static const YY_CHAR yy_meta[38] =
{ 0,
1, 1, 1, 1, 1, 1, 2, 1, 1, 3,
1, 1, 1, 1, 3, 1, 1, 3, 3, 3,
3, 3, 3, 3, 3, 1, 1
} ;
-static yyconst flex_uint16_t yy_base[138] =
+static const flex_int16_t yy_base[138] =
{ 0,
0, 0, 35, 36, 37, 42, 156, 157, 157, 152,
157, 157, 157, 157, 41, 157, 157, 157, 157, 0,
157, 71, 74, 62, 77, 80, 83
} ;
-static yyconst flex_int16_t yy_def[138] =
+static const flex_int16_t yy_def[138] =
{ 0,
131, 1, 132, 132, 133, 133, 131, 131, 131, 131,
131, 131, 131, 131, 131, 131, 131, 131, 131, 134,
0, 131, 131, 131, 131, 131, 131
} ;
-static yyconst flex_uint16_t yy_nxt[195] =
+static const flex_int16_t yy_nxt[195] =
{ 0,
8, 9, 10, 11, 12, 13, 8, 14, 15, 8,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
} ;
-static yyconst flex_int16_t yy_chk[195] =
+static const flex_int16_t yy_chk[195] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
} ;
/* Table of booleans, true if rule could match eol. */
-static yyconst flex_int32_t yy_rule_can_match_eol[47] =
+static const flex_int32_t yy_rule_can_match_eol[47] =
{ 0,
0, 0, 0, 1, 1, 1, 1, 0, 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,
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
-#line 1 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
-#line 2 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 1 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
+#line 2 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
#include <stdio.h>
#include <string>
#include "idlc/ast/tidlc_y.hpp"
#define YY_USER_ACTION yylloc->columns(yyleng);
+#line 576 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_l.cpp"
-#line 576 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_l.cpp"
+#line 578 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_l.cpp"
#define INITIAL 0
#define COMMENT 1
YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
char yy_hold_char;
int yy_n_chars;
- yy_size_t yyleng_r;
+ int yyleng_r;
char *yy_c_buf_p;
int yy_init;
int yy_start;
}; /* end struct yyguts_t */
-static int yy_init_globals (yyscan_t yyscanner );
+static int yy_init_globals ( yyscan_t yyscanner );
/* This must go here because YYSTYPE and YYLTYPE are included
* from bison output in section 1.*/
int yylex_init (yyscan_t* scanner);
-int yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
/* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */
-int yylex_destroy (yyscan_t yyscanner );
+int yylex_destroy ( yyscan_t yyscanner );
-int yyget_debug (yyscan_t yyscanner );
+int yyget_debug ( yyscan_t yyscanner );
-void yyset_debug (int debug_flag ,yyscan_t yyscanner );
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
-YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
-void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
-FILE *yyget_in (yyscan_t yyscanner );
+FILE *yyget_in ( yyscan_t yyscanner );
-void yyset_in (FILE * _in_str ,yyscan_t yyscanner );
+void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
-FILE *yyget_out (yyscan_t yyscanner );
+FILE *yyget_out ( yyscan_t yyscanner );
-void yyset_out (FILE * _out_str ,yyscan_t yyscanner );
+void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
-yy_size_t yyget_leng (yyscan_t yyscanner );
+ int yyget_leng ( yyscan_t yyscanner );
-char *yyget_text (yyscan_t yyscanner );
+char *yyget_text ( yyscan_t yyscanner );
-int yyget_lineno (yyscan_t yyscanner );
+int yyget_lineno ( yyscan_t yyscanner );
-void yyset_lineno (int _line_number ,yyscan_t yyscanner );
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
-int yyget_column (yyscan_t yyscanner );
+int yyget_column ( yyscan_t yyscanner );
-void yyset_column (int _column_no ,yyscan_t yyscanner );
+void yyset_column ( int _column_no , yyscan_t yyscanner );
-YYSTYPE * yyget_lval (yyscan_t yyscanner );
+YYSTYPE * yyget_lval ( yyscan_t yyscanner );
-void yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
+void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
- YYLTYPE *yyget_lloc (yyscan_t yyscanner );
+ YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
- void yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
+ void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
/* Macros after this point can all be overridden by user definitions in
* section 1.
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
-extern "C" int yywrap (yyscan_t yyscanner );
+extern "C" int yywrap ( yyscan_t yyscanner );
#else
-extern int yywrap (yyscan_t yyscanner );
+extern int yywrap ( yyscan_t yyscanner );
#endif
#endif
#ifndef YY_NO_UNPUT
- static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
+ static void yyunput ( int c, char *buf_ptr , yyscan_t yyscanner);
#endif
#ifndef yytext_ptr
-static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif
#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif
#ifndef YY_NO_INPUT
-
#ifdef __cplusplus
-static int yyinput (yyscan_t yyscanner );
+static int yyinput ( yyscan_t yyscanner );
#else
-static int input (yyscan_t yyscanner );
+static int input ( yyscan_t yyscanner );
#endif
#endif
/* This used to be an fputs(), but since the string might contain NUL's,
* we now use fwrite().
*/
-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
#endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
{ \
int c = '*'; \
- size_t n; \
+ int n; \
for ( n = 0; n < max_size && \
(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \
else \
{ \
errno=0; \
- while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
+ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
{ \
if( errno != EINTR) \
{ \
#define YY_DECL_IS_OURS 1
extern int yylex \
- (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
+ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
#define YY_DECL int yylex \
(YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
if ( ! YY_CURRENT_BUFFER ) {
yyensure_buffer_stack (yyscanner);
YY_CURRENT_BUFFER_LVALUE =
- yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
}
- yy_load_buffer_state(yyscanner );
+ yy_load_buffer_state( yyscanner );
}
{
-#line 28 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 28 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
+#line 31 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
std::string comments;
std::string values;
-#line 870 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_l.cpp"
+#line 872 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_l.cpp"
while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
{
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 132 )
- yy_c = yy_meta[(unsigned int) yy_c];
+ yy_c = yy_meta[yy_c];
}
- yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
++yy_cp;
}
while ( yy_base[yy_current_state] != 157 );
if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
{
- yy_size_t yyl;
+ int yyl;
for ( yyl = 0; yyl < yyleng; ++yyl )
if ( yytext[yyl] == '\n' )
-
+
do{ yylineno++;
yycolumn=0;
}while(0)
case 1:
YY_RULE_SETUP
-#line 34 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 35 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ comments += yytext; BEGIN(COMMENT); }
YY_BREAK
case 2:
YY_RULE_SETUP
-#line 35 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 36 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ comments += yytext; yylloc->step(); BEGIN(INITIAL); }
YY_BREAK
case 3:
YY_RULE_SETUP
-#line 36 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 37 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ comments += yytext; comments += "\n"; BEGIN(INITIAL); }
YY_BREAK
case 4:
/* rule 4 can match eol */
YY_RULE_SETUP
-#line 37 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 38 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ comments += yytext; yylloc->step(); BEGIN(INITIAL); }
YY_BREAK
case 5:
/* rule 5 can match eol */
YY_RULE_SETUP
-#line 38 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 39 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ comments += yytext; yylloc->lines(yyleng); }
YY_BREAK
case 6:
/* rule 6 can match eol */
YY_RULE_SETUP
-#line 39 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 40 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ comments += yytext; yylloc->step(); }
YY_BREAK
case YY_STATE_EOF(COMMENT):
-#line 40 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 41 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return 0; }
YY_BREAK
case 7:
/* rule 7 can match eol */
YY_RULE_SETUP
-#line 42 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 43 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ comments += yytext; yylloc->step(); }
YY_BREAK
case 8:
YY_RULE_SETUP
-#line 44 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 45 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ BEGIN(VALUE); }
YY_BREAK
case 9:
YY_RULE_SETUP
-#line 45 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 46 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
BEGIN(INITIAL);
yylval->token = new tidl::Token(values, comments);
case 10:
/* rule 10 can match eol */
YY_RULE_SETUP
-#line 50 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 51 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ values += yytext; yylloc->step(); }
YY_BREAK
case 11:
/* rule 11 can match eol */
YY_RULE_SETUP
-#line 52 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 53 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ yylloc->lines(yyleng); yylloc->step(); }
YY_BREAK
case 12:
/* rule 12 can match eol */
YY_RULE_SETUP
-#line 54 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 55 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
; // ignore all whitespace
YY_BREAK
case 13:
YY_RULE_SETUP
-#line 55 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 56 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_COMMA; }
YY_BREAK
case 14:
YY_RULE_SETUP
-#line 56 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 57 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_BRACE_OPEN; }
YY_BREAK
case 15:
YY_RULE_SETUP
-#line 57 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 58 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_BRACE_CLOSE; }
YY_BREAK
case 16:
YY_RULE_SETUP
-#line 58 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 59 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_LEFT; }
YY_BREAK
case 17:
YY_RULE_SETUP
-#line 59 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 60 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_RIGHT; }
YY_BREAK
case 18:
YY_RULE_SETUP
-#line 60 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 61 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_SEMICOLON; }
YY_BREAK
case 19:
YY_RULE_SETUP
-#line 61 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 62 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_VOID;
YY_BREAK
case 20:
YY_RULE_SETUP
-#line 65 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 66 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_CHAR;
YY_BREAK
case 21:
YY_RULE_SETUP
-#line 69 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 70 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_SHORT;
YY_BREAK
case 22:
YY_RULE_SETUP
-#line 73 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 74 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_INT;
YY_BREAK
case 23:
YY_RULE_SETUP
-#line 77 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 78 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_LONG;
YY_BREAK
case 24:
YY_RULE_SETUP
-#line 81 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 82 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_FLOAT;
YY_BREAK
case 25:
YY_RULE_SETUP
-#line 85 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 86 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_DOUBLE;
YY_BREAK
case 26:
YY_RULE_SETUP
-#line 89 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 90 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_BUNDLE;
YY_BREAK
case 27:
YY_RULE_SETUP
-#line 93 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 94 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_FILE;
YY_BREAK
case 28:
YY_RULE_SETUP
-#line 97 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 98 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_STRING;
YY_BREAK
case 29:
YY_RULE_SETUP
-#line 101 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 102 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_BOOL;
YY_BREAK
case 30:
YY_RULE_SETUP
-#line 105 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 106 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_IN; }
YY_BREAK
case 31:
YY_RULE_SETUP
-#line 106 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 107 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_OUT; }
YY_BREAK
case 32:
YY_RULE_SETUP
-#line 107 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 108 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_REF; }
YY_BREAK
case 33:
YY_RULE_SETUP
-#line 108 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 109 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_ASYNC; }
YY_BREAK
case 34:
YY_RULE_SETUP
-#line 109 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 110 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_DELEGATE; }
YY_BREAK
case 35:
YY_RULE_SETUP
-#line 110 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 111 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_META_OPEN; }
YY_BREAK
case 36:
YY_RULE_SETUP
-#line 111 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 112 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_META_CLOSE; }
YY_BREAK
case 37:
YY_RULE_SETUP
-#line 112 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 113 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_LIST;
YY_BREAK
case 38:
YY_RULE_SETUP
-#line 116 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 117 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_ARRAY;
YY_BREAK
case 39:
YY_RULE_SETUP
-#line 120 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 121 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_STRUCTURE;
YY_BREAK
case 40:
YY_RULE_SETUP
-#line 124 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 125 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_INTERFACE;
YY_BREAK
case 41:
YY_RULE_SETUP
-#line 128 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 129 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_ID;
YY_BREAK
case 42:
YY_RULE_SETUP
-#line 132 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 133 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ // Square Bracket
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_SB_OPEN;
YY_BREAK
case 43:
YY_RULE_SETUP
-#line 136 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 137 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ // Square Bracket
yylval->token = new tidl::Token(yytext, comments);
return yy::parser::token::T_SB_CLOSE;
YY_BREAK
case 44:
YY_RULE_SETUP
-#line 140 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 141 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_EQUAL; }
YY_BREAK
case 45:
YY_RULE_SETUP
-#line 141 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 142 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
{ return yy::parser::token::T_UNKNOWN; }
YY_BREAK
case 46:
YY_RULE_SETUP
-#line 143 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
+#line 144 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
ECHO;
YY_BREAK
-#line 1238 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_l.cpp"
+#line 1240 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_l.cpp"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(VALUE):
yyterminate();
{
yyg->yy_did_buffer_switch_on_eof = 0;
- if ( yywrap(yyscanner ) )
+ if ( yywrap( yyscanner ) )
{
/* Note: because we've taken care in
* yy_get_next_buffer() to have set up
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
char *source = yyg->yytext_ptr;
- yy_size_t number_to_move, i;
+ int number_to_move, i;
int ret_val;
if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
/* Try to read more data. */
/* First move last chars to start of buffer. */
- number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
+ number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
else
{
- yy_size_t num_to_read =
+ int num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
if ( b->yy_is_our_buffer )
{
- yy_size_t new_size = b->yy_buf_size * 2;
+ int new_size = b->yy_buf_size * 2;
if ( new_size <= 0 )
b->yy_buf_size += b->yy_buf_size / 8;
b->yy_ch_buf = (char *)
/* Include room in for 2 EOB chars. */
- yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
+ yyrealloc( (void *) b->yy_ch_buf,
+ (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
}
else
/* Can't grow it, we don't own it. */
- b->yy_ch_buf = 0;
+ b->yy_ch_buf = NULL;
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR(
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
- yyrestart(yyin ,yyscanner);
+ yyrestart( yyin , yyscanner);
}
else
else
ret_val = EOB_ACT_CONTINUE_SCAN;
- if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+ if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
/* Extend the array by 50%, plus the number we really need. */
int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+ (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+ /* "- 2" to take care of EOB's */
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
}
yyg->yy_n_chars += number_to_move;
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 132 )
- yy_c = yy_meta[(unsigned int) yy_c];
+ yy_c = yy_meta[yy_c];
}
- yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
}
return yy_current_state;
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 132 )
- yy_c = yy_meta[(unsigned int) yy_c];
+ yy_c = yy_meta[yy_c];
}
- yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
yy_is_jam = (yy_current_state == 131);
(void)yyg;
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
- yy_size_t number_to_move = yyg->yy_n_chars + 2;
+ int number_to_move = yyg->yy_n_chars + 2;
char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
char *source =
yy_cp += (int) (dest - source);
yy_bp += (int) (dest - source);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
- yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+ yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
else
{ /* need more input */
- yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
+ int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
++yyg->yy_c_buf_p;
switch ( yy_get_next_buffer( yyscanner ) )
*/
/* Reset buffer status. */
- yyrestart(yyin ,yyscanner);
+ yyrestart( yyin , yyscanner);
/*FALLTHROUGH*/
case EOB_ACT_END_OF_FILE:
{
- if ( yywrap(yyscanner ) )
- return EOF;
+ if ( yywrap( yyscanner ) )
+ return 0;
if ( ! yyg->yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
yyg->yy_hold_char = *++yyg->yy_c_buf_p;
if ( c == '\n' )
-
+
do{ yylineno++;
yycolumn=0;
}while(0)
if ( ! YY_CURRENT_BUFFER ){
yyensure_buffer_stack (yyscanner);
YY_CURRENT_BUFFER_LVALUE =
- yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
}
- yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
- yy_load_buffer_state(yyscanner );
+ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+ yy_load_buffer_state( yyscanner );
}
/** Switch to a different input buffer.
}
YY_CURRENT_BUFFER_LVALUE = new_buffer;
- yy_load_buffer_state(yyscanner );
+ yy_load_buffer_state( yyscanner );
/* We don't actually know whether we did this switch during
* EOF (yywrap()) processing, but the only time this flag
{
YY_BUFFER_STATE b;
- b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
- b->yy_buf_size = (yy_size_t)size;
+ 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 ,yyscanner );
+ b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
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 ,yyscanner);
+ yy_init_buffer( b, file , yyscanner);
return b;
}
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
- yyfree((void *) b->yy_ch_buf ,yyscanner );
+ yyfree( (void *) b->yy_ch_buf , yyscanner );
- yyfree((void *) b ,yyscanner );
+ yyfree( (void *) b , yyscanner );
}
/* Initializes or reinitializes a buffer.
int oerrno = errno;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yy_flush_buffer(b ,yyscanner);
+ yy_flush_buffer( b , yyscanner);
b->yy_input_file = file;
b->yy_fill_buffer = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
- yy_load_buffer_state(yyscanner );
+ yy_load_buffer_state( yyscanner );
}
/** Pushes the new state onto the stack. The new state becomes
YY_CURRENT_BUFFER_LVALUE = new_buffer;
/* copied from yy_switch_to_buffer. */
- yy_load_buffer_state(yyscanner );
+ yy_load_buffer_state( yyscanner );
yyg->yy_did_buffer_switch_on_eof = 1;
}
if (!YY_CURRENT_BUFFER)
return;
- yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
+ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
YY_CURRENT_BUFFER_LVALUE = NULL;
if (yyg->yy_buffer_stack_top > 0)
--yyg->yy_buffer_stack_top;
if (YY_CURRENT_BUFFER) {
- yy_load_buffer_state(yyscanner );
+ yy_load_buffer_state( yyscanner );
yyg->yy_did_buffer_switch_on_eof = 1;
}
}
* 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; /* After all that talk, this was set to 1 anyways... */
+ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
(num_to_alloc * sizeof(struct yy_buffer_state*)
, yyscanner);
if ( ! yyg->yy_buffer_stack )
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
+
memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-
+
yyg->yy_buffer_stack_max = num_to_alloc;
yyg->yy_buffer_stack_top = 0;
return;
* @param base the character buffer
* @param size the size in bytes of the character buffer
* @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
+ * @return the newly allocated buffer state object.
*/
YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
{
base[size-2] != YY_END_OF_BUFFER_CHAR ||
base[size-1] != YY_END_OF_BUFFER_CHAR )
/* They forgot to leave room for the EOB's. */
- return 0;
+ return NULL;
- b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
- b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
+ b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
b->yy_buf_pos = b->yy_ch_buf = base;
b->yy_is_our_buffer = 0;
- b->yy_input_file = 0;
+ b->yy_input_file = NULL;
b->yy_n_chars = b->yy_buf_size;
b->yy_is_interactive = 0;
b->yy_at_bol = 1;
b->yy_fill_buffer = 0;
b->yy_buffer_status = YY_BUFFER_NEW;
- yy_switch_to_buffer(b ,yyscanner );
+ yy_switch_to_buffer( b , yyscanner );
return b;
}
* @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 , yyscan_t yyscanner)
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
{
- return yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
+ return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
}
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
* @param yyscanner The scanner object.
* @return the newly allocated buffer state object.
*/
-YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)
+YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
{
YY_BUFFER_STATE b;
char *buf;
yy_size_t n;
- yy_size_t i;
+ int i;
/* Get memory for full buffer, including space for trailing EOB's. */
- n = _yybytes_len + 2;
- buf = (char *) yyalloc(n ,yyscanner );
+ n = (yy_size_t) (_yybytes_len + 2);
+ buf = (char *) yyalloc( n , yyscanner );
if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
- b = yy_scan_buffer(buf,n ,yyscanner);
+ b = yy_scan_buffer( buf, n , yyscanner);
if ( ! b )
YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
#define YY_EXIT_FAILURE 2
#endif
-static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
+static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
- (void) fprintf( stderr, "%s\n", msg );
+ fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
int yyget_lineno (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
+
if (! YY_CURRENT_BUFFER)
return 0;
int yyget_column (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
+
if (! YY_CURRENT_BUFFER)
return 0;
/** Get the length of the current token.
* @param yyscanner The scanner object.
*/
-yy_size_t yyget_leng (yyscan_t yyscanner)
+int yyget_leng (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
return yyleng;
* the ONLY reentrant function that doesn't take the scanner as the last argument.
* That's why we explicitly handle the declaration, instead of using our macros.
*/
-
int yylex_init(yyscan_t* ptr_yy_globals)
-
{
if (ptr_yy_globals == NULL){
errno = EINVAL;
* The user defined value in the first argument will be available to yyalloc in
* the yyextra field.
*/
-
-int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
-
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
{
struct yyguts_t dummy_yyguts;
errno = EINVAL;
return 1;
}
-
+
*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
-
+
if (*ptr_yy_globals == NULL){
errno = ENOMEM;
return 1;
}
-
+
/* By setting to 0xAA, we expose bugs in
yy_init_globals. Leave at 0x00 for releases. */
memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
+
yyset_extra (yy_user_defined, *ptr_yy_globals);
-
+
return yy_init_globals ( *ptr_yy_globals );
}
* This function is called from yylex_destroy(), so don't allocate here.
*/
- yyg->yy_buffer_stack = 0;
+ yyg->yy_buffer_stack = NULL;
yyg->yy_buffer_stack_top = 0;
yyg->yy_buffer_stack_max = 0;
- yyg->yy_c_buf_p = (char *) 0;
+ yyg->yy_c_buf_p = NULL;
yyg->yy_init = 0;
yyg->yy_start = 0;
yyin = stdin;
yyout = stdout;
#else
- yyin = (FILE *) 0;
- yyout = (FILE *) 0;
+ yyin = NULL;
+ yyout = NULL;
#endif
/* For future reference: Set errno on error, since we are called by
/* Pop the buffer stack, destroying each element. */
while(YY_CURRENT_BUFFER){
- yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
+ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
YY_CURRENT_BUFFER_LVALUE = NULL;
yypop_buffer_state(yyscanner);
}
/* Destroy the stack itself. */
- yyfree(yyg->yy_buffer_stack ,yyscanner);
+ yyfree(yyg->yy_buffer_stack , yyscanner);
yyg->yy_buffer_stack = NULL;
/* Destroy the start condition stack. */
- yyfree(yyg->yy_start_stack ,yyscanner );
+ yyfree( yyg->yy_start_stack , yyscanner );
yyg->yy_start_stack = NULL;
/* Reset the globals. This is important in a non-reentrant scanner so the next time
*/
#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
#endif
#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
{
int n;
for ( n = 0; s[n]; ++n )
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
(void)yyg;
- return (void *) malloc( size );
+ return malloc(size);
}
void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
* any pointer type to void*, and deal with argument conversions
* as though doing an assignment.
*/
- return (void *) realloc( (char *) ptr, size );
+ return realloc(ptr, size);
}
void yyfree (void * ptr , yyscan_t yyscanner)
#define YYTABLES_NAME "yytables"
-#line 143 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.ll"
-
+#line 144 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.ll"
-// A Bison parser, made by GNU Bison 3.0.4.
+// A Bison parser, made by GNU Bison 3.5.1.
// Skeleton implementation for Bison GLR parsers in C
-// Copyright (C) 2002-2015 Free Software Foundation, Inc.
+// Copyright (C) 2002-2015, 2018-2020 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
/* C GLR parser skeleton written by Paul Hilfinger. */
+// Undocumented macros, especially those whose name start with YY_,
+// are private implementation details. Do not rely on them.
+
/* Identify Bison output. */
#define YYBISON 1
/* Bison version. */
-#define YYBISON_VERSION "3.0.4"
+#define YYBISON_VERSION "3.5.1"
/* Skeleton name. */
#define YYSKELETON_NAME "glr.cc"
-/* First part of user declarations. */
-#line 1 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:240
+// First part of user prologue.
+#line 1 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
#include <stdio.h>
#include <stdlib.h>
#define lex_scanner ps->Scanner()
-#line 77 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:240
+#line 80 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
+# ifndef YY_CAST
+# ifdef __cplusplus
+# define YY_CAST(Type, Val) static_cast<Type> (Val)
+# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
+# else
+# define YY_CAST(Type, Val) ((Type) (Val))
+# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
+# endif
+# endif
# ifndef YY_NULLPTR
-# if defined __cplusplus && 201103L <= __cplusplus
-# define YY_NULLPTR nullptr
+# if defined __cplusplus
+# if 201103L <= __cplusplus
+# define YY_NULLPTR nullptr
+# else
+# define YY_NULLPTR 0
+# endif
# else
-# define YY_NULLPTR 0
+# define YY_NULLPTR ((void*)0)
# endif
# endif
# endif
;
-/* Copy the second part of user declarations. */
-#line 109 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:263
-/* 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). */
-
-# ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N) \
- do \
- if (N) \
- { \
- (Current).begin = YYRHSLOC (Rhs, 1).begin; \
- (Current).end = YYRHSLOC (Rhs, N).end; \
- } \
- else \
- { \
- (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
- } \
- while (/*CONSTCOND*/ false)
-# endif
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
+// Second part of user prologue.
+#line 125 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
static void yyerror (const yy::parser::location_type *yylocationp, yy::parser& yyparser, tidl::Parser* ps, const char* msg);
-#line 131 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:263
+#line 127 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
+
+#include <stddef.h>
+#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
+ <limits.h> and (if available) <stdint.h> are included
+ so that the code can choose integer types of a good width. */
+
+#ifndef __PTRDIFF_MAX__
+# include <limits.h> /* INFRINGES ON USER NAME SPACE */
+# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_STDINT_H
+# endif
+#endif
+
+/* Narrow types that promote to a signed type and that can represent a
+ signed or unsigned integer of at least N bits. In tables they can
+ save space and decrease cache pressure. Promoting to a signed type
+ helps avoid bugs in integer arithmetic. */
+
+#ifdef __INT_LEAST8_MAX__
+typedef __INT_LEAST8_TYPE__ yytype_int8;
+#elif defined YY_STDINT_H
+typedef int_least8_t yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef __INT_LEAST16_MAX__
+typedef __INT_LEAST16_TYPE__ yytype_int16;
+#elif defined YY_STDINT_H
+typedef int_least16_t yytype_int16;
+#else
+typedef short yytype_int16;
+#endif
+
+#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST8_TYPE__ yytype_uint8;
+#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
+ && UINT_LEAST8_MAX <= INT_MAX)
+typedef uint_least8_t yytype_uint8;
+#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
+typedef unsigned char yytype_uint8;
+#else
+typedef short yytype_uint8;
+#endif
+
+#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST16_TYPE__ yytype_uint16;
+#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
+ && UINT_LEAST16_MAX <= INT_MAX)
+typedef uint_least16_t yytype_uint16;
+#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
+typedef unsigned short yytype_uint16;
+#else
+typedef int yytype_uint16;
+#endif
+
#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# define YYREALLOC realloc
#endif
-#define YYSIZEMAX ((size_t) -1)
+#define YYSIZEMAX \
+ (PTRDIFF_MAX < SIZE_MAX ? PTRDIFF_MAX : YY_CAST (ptrdiff_t, SIZE_MAX))
#ifdef __cplusplus
- typedef bool yybool;
+ typedef bool yybool;
+# define yytrue true
+# define yyfalse false
#else
- typedef unsigned char yybool;
+ /* When we move to stdbool, get rid of the various casts to yybool. */
+ typedef signed char yybool;
+# define yytrue 1
+# define yyfalse 0
#endif
-#define yytrue 1
-#define yyfalse 0
#ifndef YYSETJMP
# include <setjmp.h>
# define YYJMP_BUF jmp_buf
# define YYSETJMP(Env) setjmp (Env)
-/* Pacify clang. */
-# define YYLONGJMP(Env, Val) (longjmp (Env, Val), YYASSERT (0))
+/* Pacify Clang and ICC. */
+# define YYLONGJMP(Env, Val) \
+ do { \
+ longjmp (Env, Val); \
+ YY_ASSERT (0); \
+ } while (yyfalse)
#endif
-#ifndef YY_ATTRIBUTE
-# if (defined __GNUC__ \
- && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
- || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
-# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+#ifndef YY_ATTRIBUTE_PURE
+# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
+# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
-# define YY_ATTRIBUTE(Spec) /* empty */
+# define YY_ATTRIBUTE_PURE
# endif
#endif
-#ifndef YY_ATTRIBUTE_PURE
-# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
-#endif
-
#ifndef YY_ATTRIBUTE_UNUSED
-# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
+# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+# else
+# define YY_ATTRIBUTE_UNUSED
+# endif
#endif
-#if !defined _Noreturn \
- && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
-# if defined _MSC_VER && 1200 <= _MSC_VER
+/* The _Noreturn keyword of C11. */
+#ifndef _Noreturn
+# if (defined __cplusplus \
+ && ((201103 <= __cplusplus && !(__GNUC__ == 4 && __GNUC_MINOR__ == 7)) \
+ || (defined _MSC_VER && 1900 <= _MSC_VER)))
+# define _Noreturn [[noreturn]]
+# elif ((!defined __cplusplus || defined __clang__) \
+ && (201112 <= (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) \
+ || 4 < __GNUC__ + (7 <= __GNUC_MINOR__)))
+ /* _Noreturn works as-is. */
+# elif 2 < __GNUC__ + (8 <= __GNUC_MINOR__) || 0x5110 <= __SUNPRO_C
+# define _Noreturn __attribute__ ((__noreturn__))
+# elif 1200 <= (defined _MSC_VER ? _MSC_VER : 0)
# define _Noreturn __declspec (noreturn)
# else
-# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# define _Noreturn
# endif
#endif
# define YYUSE(E) /* empty */
#endif
-#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized. */
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
_Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
-
-#ifndef YYASSERT
-# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0)))
+#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
+# define YY_IGNORE_USELESS_CAST_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
+# define YY_IGNORE_USELESS_CAST_END \
+ _Pragma ("GCC diagnostic pop")
+#endif
+#ifndef YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_END
#endif
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
+
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 19
/* YYLAST -- Last index in YYTABLE. */
#define YYNNTS 20
/* YYNRULES -- Number of rules. */
#define YYNRULES 70
-/* YYNRULES -- Number of states. */
+/* YYNSTATES -- Number of states. */
#define YYNSTATES 135
/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
#define YYMAXRHS 8
accessed by $0, $-1, etc., in any rule. */
#define YYMAXLEFT 0
-/* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */
-#define YYUNDEFTOK 2
+/* YYMAXUTOK -- Last valid token number (for yychar). */
#define YYMAXUTOK 291
+/* YYFAULTYTOK -- Token number (for yychar) that denotes a
+ syntax_error thrown from the scanner. */
+#define YYFAULTYTOK (YYMAXUTOK + 1)
+/* YYUNDEFTOK -- Symbol number (for yytoken) that denotes an unknown
+ token. */
+#define YYUNDEFTOK 2
-#define YYTRANSLATE(YYX) \
- ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, with out-of-bounds checking. */
+#define YYTRANSLATE(YYX) \
+ (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
-static const unsigned char yytranslate[] =
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex. */
+static const yytype_int8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
#if YYDEBUG
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
-static const unsigned short int yyrline[] =
+static const yytype_int16 yyrline[] =
{
0, 96, 96, 101, 106, 120, 123, 128, 134, 139,
145, 152, 158, 169, 175, 180, 184, 188, 194, 200,
211, 217, 222, 228, 235, 241, 249, 254, 259, 266,
272, 283, 289, 294, 301, 309, 314, 319, 324, 328,
332, 336, 340, 346, 352, 363, 369, 372, 375, 380,
- 383, 387, 393, 396, 402, 405, 417, 420, 424, 428,
- 432, 436, 440, 444, 448, 452, 456, 460, 466, 473,
- 477
+ 383, 387, 393, 396, 402, 405, 418, 421, 425, 429,
+ 433, 437, 441, 445, 449, 453, 457, 461, 467, 474,
+ 478
};
#endif
};
#endif
-#define YYPACT_NINF -67
-#define YYTABLE_NINF -58
+#define YYPACT_NINF (-67)
+#define YYTABLE_NINF (-58)
// YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
// STATE-NUM.
-static const short int yypact[] =
+static const yytype_int16 yypact[] =
{
-4, 24, 45, 21, 10, -4, -67, -67, -67, 69,
296, 5, 87, 336, 13, -67, 49, 6, -67, -67,
// YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
// Performed when YYTABLE does not specify something else to do. Zero
// means the default is an error.
-static const unsigned char yydefact[] =
+static const yytype_int8 yydefact[] =
{
0, 0, 0, 0, 0, 2, 3, 6, 5, 0,
0, 0, 0, 0, 0, 20, 0, 0, 18, 1,
};
// YYPGOTO[NTERM-NUM].
-static const short int yypgoto[] =
+static const yytype_int16 yypgoto[] =
{
-67, -67, -67, 135, -67, -15, -32, -67, 102, -67,
-42, -47, -66, -67, 47, -67, -59, -8, -67, -67
};
// YYDEFGOTO[NTERM-NUM].
-static const signed char yydefgoto[] =
+static const yytype_int8 yydefgoto[] =
{
-1, 4, 5, 6, 7, 37, 38, 17, 18, 8,
47, 48, 94, 95, 96, 97, 49, 50, 40, 41
// YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
// positive, shift that token. If negative, reduce the rule whose
// number is the opposite. If YYTABLE_NINF, syntax error.
-static const short int yytable[] =
+static const yytype_int16 yytable[] =
{
71, 65, 39, 77, 85, 59, 56, 102, 98, 75,
19, 54, 42, 39, 98, 1, 2, 63, 71, 115,
32, 33, 34, 35, 36, 0, 0, 0, 46
};
-static const signed char yycheck[] =
+static const yytype_int8 yycheck[] =
{
47, 43, 10, 1, 63, 37, 21, 73, 67, 51,
0, 5, 7, 21, 73, 19, 20, 13, 65, 12,
// YYSTOS[STATE-NUM] -- The (internal number of the) accessing
// symbol of state STATE-NUM.
-static const unsigned char yystos[] =
+static const yytype_int8 yystos[] =
{
0, 19, 20, 34, 38, 39, 40, 41, 46, 1,
7, 18, 1, 7, 18, 1, 18, 44, 45, 0,
};
// YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
-static const unsigned char yyr1[] =
+static const yytype_int8 yyr1[] =
{
0, 37, 38, 39, 39, 40, 40, 41, 41, 41,
41, 42, 42, 42, 43, 43, 43, 43, 44, 44,
};
// YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
-static const unsigned char yyr2[] =
+static const yytype_int8 yyr2[] =
{
0, 2, 1, 1, 2, 1, 1, 5, 4, 5,
3, 1, 2, 3, 3, 2, 3, 1, 1, 3,
/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */
-static const unsigned char yydprec[] =
+static const yytype_int8 yydprec[] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */
-static const unsigned char yymerger[] =
+static const yytype_int8 yymerger[] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
list of conflicting reductions corresponding to action entry for
state STATE-NUM in yytable. 0 means no conflicts. The list in
yyconfl is terminated by a rule number of 0. */
-static const unsigned char yyconflp[] =
+static const yytype_int8 yyconflp[] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
0, pointed into by YYCONFLP. */
-static const short int yyconfl[] =
+static const short yyconfl[] =
{
0
};
{ \
(Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
} \
- while (/*CONSTCOND*/ false)
+ while (false)
# endif
# define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
# define YYFPRINTF fprintf
# endif
+# define YY_FPRINTF \
+ YY_IGNORE_USELESS_CAST_BEGIN YY_FPRINTF_
+
+# define YY_FPRINTF_(Args) \
+ do { \
+ YYFPRINTF Args; \
+ YY_IGNORE_USELESS_CAST_END \
+ } while (0)
+
+# define YY_DPRINTF \
+ YY_IGNORE_USELESS_CAST_BEGIN YY_DPRINTF_
+
+# define YY_DPRINTF_(Args) \
+ do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+ YY_IGNORE_USELESS_CAST_END \
+ } while (0)
+
/* YY_LOCATION_PRINT -- Print the location on the stream.
This macro was not mandated originally: define only if we know
/* Print *YYLOCP on YYO. Private, do not rely on its existence. */
YY_ATTRIBUTE_UNUSED
-static unsigned
+static int
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
{
- unsigned res = 0;
+ int res = 0;
int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
if (0 <= yylocp->first_line)
{
#endif
-# define YYDPRINTF(Args) \
- do { \
- if (yydebug) \
- YYFPRINTF Args; \
- } while (0)
-
/*--------------------.
| Print this symbol. |
do { \
if (yydebug) \
{ \
- YYFPRINTF (stderr, "%s ", Title); \
+ YY_FPRINTF ((stderr, "%s ", Title)); \
yy_symbol_print (stderr, Type, Value, Location, yyparser, ps); \
- YYFPRINTF (stderr, "\n"); \
+ YY_FPRINTF ((stderr, "\n")); \
} \
} while (0)
int yydebug;
struct yyGLRStack;
-static void yypstack (struct yyGLRStack* yystackp, size_t yyk)
+static void yypstack (struct yyGLRStack* yystackp, ptrdiff_t yyk)
YY_ATTRIBUTE_UNUSED;
static void yypdumpstack (struct yyGLRStack* yystackp)
YY_ATTRIBUTE_UNUSED;
#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
+# define YY_DPRINTF(Args) do {} while (yyfalse)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
#endif /* !YYDEBUG */
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 size_t
+static ptrdiff_t
yytnamerr (char *yyres, const char *yystr)
{
if (*yystr == '"')
{
- size_t yyn = 0;
+ ptrdiff_t yyn = 0;
char const *yyp = yystr;
for (;;)
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
- /* Fall through. */
+ else
+ goto append;
+
+ append:
default:
if (yyres)
yyres[yyn] = *yyp;
do_not_strip_quotes: ;
}
- if (! yyres)
- return strlen (yystr);
-
- return yystpcpy (yyres, yystr) - yyres;
+ if (yyres)
+ return yystpcpy (yyres, yystr) - yyres;
+ else
+ return YY_CAST (ptrdiff_t, strlen (yystr));
}
# endif
#endif /* !YYERROR_VERBOSE */
-/** State numbers, as in LALR(1) machine */
+/** State numbers. */
typedef int yyStateNum;
-/** Rule numbers, as in LALR(1) machine */
+/** Rule numbers. */
typedef int yyRuleNum;
-/** Grammar symbol */
+/** Grammar symbol. */
typedef int yySymbol;
-/** Item references, as in LALR(1) machine */
-typedef short int yyItemNum;
+/** Item references. */
+typedef short yyItemNum;
typedef struct yyGLRState yyGLRState;
typedef struct yyGLRStateSet yyGLRStateSet;
/** Preceding state in this stack */
yyGLRState* yypred;
/** Source position of the last token produced by my symbol */
- size_t yyposn;
+ ptrdiff_t yyposn;
union {
/** First in a chain of alternative reductions producing the
- * non-terminal corresponding to this state, threaded through
+ * nonterminal corresponding to this state, threaded through
* yynext. */
yySemanticOption* yyfirstVal;
/** Semantic value for this state. */
* operation, yylookaheadNeeds[0] is not maintained since it would merely
* duplicate yychar != YYEMPTY. */
yybool* yylookaheadNeeds;
- size_t yysize, yycapacity;
+ ptrdiff_t yysize;
+ ptrdiff_t yycapacity;
};
struct yySemanticOption {
YYJMP_BUF yyexception_buffer;
yyGLRStackItem* yyitems;
yyGLRStackItem* yynextFree;
- size_t yyspaceLeft;
+ ptrdiff_t yyspaceLeft;
yyGLRState* yysplitPoint;
yyGLRState* yylastDeleted;
yyGLRStateSet yytops;
static void yyexpandGLRStack (yyGLRStack* yystackp);
#endif
-static _Noreturn void
+_Noreturn static void
yyFail (yyGLRStack* yystackp, YYLTYPE *yylocp, yy::parser& yyparser, tidl::Parser* ps, const char* yymsg)
{
if (yymsg != YY_NULLPTR)
YYLONGJMP (yystackp->yyexception_buffer, 1);
}
-static _Noreturn void
+_Noreturn static void
yyMemoryExhausted (yyGLRStack* yystackp)
{
YYLONGJMP (yystackp->yyexception_buffer, 2);
static inline const char*
yytokenName (yySymbol yytoken)
{
- if (yytoken == YYEMPTY)
- return "";
-
- return yytname[yytoken];
+ return yytoken == YYEMPTY ? "" : yytname[yytoken];
}
#endif
}
}
+
+/** If yychar is empty, fetch the next token. */
+static inline yySymbol
+yygetToken (int *yycharp, yyGLRStack* yystackp, yy::parser& yyparser, tidl::Parser* ps)
+{
+ yySymbol yytoken;
+ YYUSE (yyparser);
+ YYUSE (ps);
+ if (*yycharp == YYEMPTY)
+ {
+ YY_DPRINTF ((stderr, "Reading a token: "));
+#if YY_EXCEPTIONS
+ try
+ {
+#endif // YY_EXCEPTIONS
+ *yycharp = yylex (&yylval, &yylloc, lex_scanner);
+#if YY_EXCEPTIONS
+ }
+ catch (const yy::parser::syntax_error& yyexc)
+ {
+ YY_DPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));
+ yylloc = yyexc.location;
+ yyerror (&yylloc, yyparser, ps, yyexc.what ());
+ // Map errors caught in the scanner to the undefined token
+ // (YYUNDEFTOK), so that error handling is started.
+ // However, record this with this special value of yychar.
+ *yycharp = YYFAULTYTOK;
+ }
+#endif // YY_EXCEPTIONS
+ }
+ if (*yycharp <= YYEOF)
+ {
+ *yycharp = yytoken = YYEOF;
+ YY_DPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (*yycharp);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
+ return yytoken;
+}
+
/* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in
* YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1.
* For convenience, always return YYLOW1. */
* (@$). Returns yyok for normal return, yyaccept for YYACCEPT,
* yyerr for YYERROR, yyabort for YYABORT. */
static YYRESULTTAG
-yyuserAction (yyRuleNum yyn, size_t yyrhslen, yyGLRStackItem* yyvsp,
+yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
yyGLRStack* yystackp,
YYSTYPE* yyvalp, YYLTYPE *yylocp, yy::parser& yyparser, tidl::Parser* ps)
{
- yybool yynormal YY_ATTRIBUTE_UNUSED = (yystackp->yysplitPoint == YY_NULLPTR);
+ yybool yynormal YY_ATTRIBUTE_UNUSED = yystackp->yysplitPoint == YY_NULLPTR;
int yylow;
YYUSE (yyvalp);
YYUSE (yylocp);
# undef yyclearin
# define yyclearin (yychar = YYEMPTY)
# undef YYFILL
-# define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
+# define YYFILL(N) yyfill (yyvsp, &yylow, (N), yynormal)
# undef YYBACKUP
# define YYBACKUP(Token, Value) \
return yyerror (yylocp, yyparser, ps, YY_("syntax error: cannot back up")), \
*yyvalp = yyval_default;
else
*yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
+ /* Default location. */
YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
+#if YY_EXCEPTIONS
+ typedef yy::parser::syntax_error syntax_error;
+ try
+ {
+#endif // YY_EXCEPTIONS
switch (yyn)
{
- case 2:
-#line 96 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->SetDoc((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.doc));
+ case 2:
+#line 96 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->SetDoc((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.doc));
}
-#line 1096 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1247 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 3:
-#line 101 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 101 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).doc) = new tidl::Document();
- if ((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk) != NULL)
- ((*yyvalp).doc)->AddBlock((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk));
+ if ((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk) != NULL)
+ ((*yyvalp).doc)->AddBlock((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk));
}
-#line 1106 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1257 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 4:
-#line 106 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).doc) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.doc);
-
- if ((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk) != NULL) {
- if (((*yyvalp).doc)->ExistBlock((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk))) {
- ps->ReportError("syntax error. \"Already Exists\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk)->GetLine());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk);
+#line 106 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).doc) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.doc);
+
+ if ((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk) != NULL) {
+ if (((*yyvalp).doc)->ExistBlock((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk))) {
+ ps->ReportError("syntax error. \"Already Exists\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk)->GetLine());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk);
} else {
- ((*yyvalp).doc)->AddBlock((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk));
+ ((*yyvalp).doc)->AddBlock((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.blk));
}
}
}
-#line 1123 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1274 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 5:
-#line 120 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).blk) = (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.interf);
+#line 120 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).blk) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.interf);
}
-#line 1131 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1282 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 6:
-#line 123 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).blk) = (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.structure);
+#line 123 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).blk) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.structure);
}
-#line 1139 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1290 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 7:
-#line 128 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).structure) = new tidl::Structure((((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.elms), (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token)->GetComments(),
- (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yyloc).begin.line);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
+#line 128 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).structure) = new tidl::Structure((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.elms), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token)->GetComments(),
+ (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yyloc).begin.line);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
}
-#line 1150 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1301 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 8:
-#line 134 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error. \"No identifier\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
+#line 134 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error. \"No identifier\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
((*yyvalp).structure) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
}
-#line 1160 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1311 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 9:
-#line 139 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 139 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
ps->ReportError("syntax error. \"Please check it before an open brace.\"",
- (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
+ (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
((*yyvalp).structure) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
}
-#line 1171 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1322 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 10:
-#line 145 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in structure declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
+#line 145 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in structure declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
((*yyvalp).structure) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
}
-#line 1181 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1332 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 11:
-#line 152 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 152 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).elms) = new (std::nothrow) tidl::Elements();
if (((*yyvalp).elms) != nullptr) {
- ((*yyvalp).elms)->Add((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm));
+ ((*yyvalp).elms)->Add((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm));
}
}
-#line 1192 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1343 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 12:
-#line 158 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).elms) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.elms);
- if ((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm) != nullptr) {
- if (((*yyvalp).elms)->Exist((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm))) {
- ps->ReportError("syntax error. \"Already Exists\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm)->GetLine());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm);
+#line 158 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).elms) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.elms);
+ if ((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm) != nullptr) {
+ if (((*yyvalp).elms)->Exist((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm))) {
+ ps->ReportError("syntax error. \"Already Exists\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm)->GetLine());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm);
} else {
- ((*yyvalp).elms)->Add((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm));
+ ((*yyvalp).elms)->Add((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.elm));
}
}
}
-#line 1208 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1359 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 13:
-#line 169 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in elements declarations.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yyloc).begin.line);
- ((*yyvalp).elms) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.elms);
+#line 169 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in elements declarations.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yyloc).begin.line);
+ ((*yyvalp).elms) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.elms);
}
-#line 1217 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1368 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 14:
-#line 175 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).elm) = new tidl::Element((((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.b_type), (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.b_type)->GetComments(),
- (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yyloc).begin.line);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.token);
+#line 175 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).elm) = new tidl::Element((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.b_type), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.b_type)->GetComments(),
+ (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yyloc).begin.line);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.token);
}
-#line 1227 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1378 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 15:
-#line 180 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error. \"No identifier\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
+#line 180 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error. \"No identifier\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
((*yyvalp).elm) = NULL;
}
-#line 1236 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1387 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 16:
-#line 184 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in element declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
+#line 184 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in element declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
((*yyvalp).elm) = NULL;
}
-#line 1245 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1396 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 17:
-#line 188 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in element declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
+#line 188 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in element declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
((*yyvalp).elm) = NULL;
}
-#line 1254 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1405 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 18:
-#line 194 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 194 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).attrs) = new (std::nothrow) tidl::Attributes();
if (((*yyvalp).attrs) != nullptr) {
- ((*yyvalp).attrs)->Add((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr));
+ ((*yyvalp).attrs)->Add((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr));
}
}
-#line 1265 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1416 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 19:
-#line 200 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).attrs) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.attrs);
- if ((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr) != nullptr) {
- if (((*yyvalp).attrs)->Exist((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr))) {
- ps->ReportError("syntax error. \"Already Exist\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr)->GetLine());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr);
+#line 200 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).attrs) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.attrs);
+ if ((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr) != nullptr) {
+ if (((*yyvalp).attrs)->Exist((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr))) {
+ ps->ReportError("syntax error. \"Already Exist\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr)->GetLine());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr);
} else {
- ((*yyvalp).attrs)->Add((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr));
+ ((*yyvalp).attrs)->Add((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.attr));
}
}
}
-#line 1281 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1432 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 20:
-#line 211 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in attributes", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
+#line 211 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in attributes", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
((*yyvalp).attrs) = new tidl::Attributes();
}
-#line 1290 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1441 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 21:
-#line 217 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).attr) = new tidl::Attribute((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yyloc).begin.line);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 217 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).attr) = new tidl::Attribute((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yyloc).begin.line);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1300 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1451 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 22:
-#line 222 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in attribute declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
+#line 222 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in attribute declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
((*yyvalp).attr) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1311 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1462 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 23:
-#line 228 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in attribute declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
+#line 228 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in attribute declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
((*yyvalp).attr) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
}
-#line 1321 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1472 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 24:
-#line 235 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).interf) = new tidl::Interface((((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.decls), (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token)->GetComments(),
- new tidl::Attributes(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yyloc).begin.line);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
+#line 235 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).interf) = new tidl::Interface((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.decls), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token)->GetComments(),
+ new tidl::Attributes(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yyloc).begin.line);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
}
-#line 1332 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1483 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 25:
-#line 241 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).interf) = new tidl::Interface((((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.decls), (((yyGLRStackItem const *)yyvsp)[YYFILL (-7)].yystate.yysemantics.yysval.token)->GetComments(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.attrs),
- (((yyGLRStackItem const *)yyvsp)[YYFILL (-7)].yystate.yyloc).begin.line);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-7)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
+#line 241 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).interf) = new tidl::Interface((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.decls), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-7)].yystate.yysemantics.yysval.token)->GetComments(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.attrs),
+ (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-7)].yystate.yyloc).begin.line);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-7)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
}
-#line 1345 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1496 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 26:
-#line 249 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error. \"No identifier\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
+#line 249 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error. \"No identifier\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
((*yyvalp).interf) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
}
-#line 1355 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1506 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 27:
-#line 254 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in interface declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
+#line 254 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in interface declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
((*yyvalp).interf) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
}
-#line 1365 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1516 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 28:
-#line 259 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in interface declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
+#line 259 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in interface declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
((*yyvalp).interf) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.token);
}
-#line 1375 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1526 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 29:
-#line 266 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 266 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).decls) = new (std::nothrow) tidl::Declarations();
if (((*yyvalp).decls) != nullptr) {
- ((*yyvalp).decls)->Add((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl));
+ ((*yyvalp).decls)->Add((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl));
}
}
-#line 1386 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1537 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 30:
-#line 272 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).decls) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.decls);
- if ((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl) != nullptr) {
- if (((*yyvalp).decls)->Exist((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl))) {
- ps->ReportError("syntax error. \"Already Exists\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl)->GetLine());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl);
+#line 272 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).decls) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.decls);
+ if ((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl) != nullptr) {
+ if (((*yyvalp).decls)->Exist((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl))) {
+ ps->ReportError("syntax error. \"Already Exists\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl)->GetLine());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl);
} else {
- ((*yyvalp).decls)->Add((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl));
+ ((*yyvalp).decls)->Add((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.decl));
}
}
}
-#line 1402 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1553 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 31:
-#line 283 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in methods declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
- ((*yyvalp).decls) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.decls);
+#line 283 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in methods declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
+ ((*yyvalp).decls) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.decls);
}
-#line 1411 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1562 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 32:
-#line 289 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).decl) = new tidl::Declaration((((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.b_type), (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.params), (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.b_type)->GetComments(),
- (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yyloc).begin.line, tidl::Declaration::MethodType::SYNC);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
+#line 289 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).decl) = new tidl::Declaration((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.b_type), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.params), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.b_type)->GetComments(),
+ (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yyloc).begin.line, tidl::Declaration::MethodType::SYNC);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
}
-#line 1421 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1572 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 33:
-#line 294 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).decl) = new tidl::Declaration((((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token)->ToString(),
- new tidl::BaseType("void", (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token)->GetComments()), (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.params),
- (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token)->GetComments(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yyloc).begin.line, tidl::Declaration::MethodType::ASYNC);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
+#line 294 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).decl) = new tidl::Declaration((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token)->ToString(),
+ new tidl::BaseType("void", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token)->GetComments()), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.params),
+ (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token)->GetComments(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yyloc).begin.line, tidl::Declaration::MethodType::ASYNC);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
}
-#line 1433 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1584 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 34:
-#line 301 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).decl) = new tidl::Declaration((((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token)->ToString(),
- new tidl::BaseType("void", (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token)->GetComments()), (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.params),
- (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token)->GetComments(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yyloc).begin.line,
+#line 301 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).decl) = new tidl::Declaration((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token)->ToString(),
+ new tidl::BaseType("void", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token)->GetComments()), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.params),
+ (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token)->GetComments(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yyloc).begin.line,
tidl::Declaration::MethodType::DELEGATE);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-6)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
}
-#line 1446 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1597 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 35:
-#line 309 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in method declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yyloc).begin.line);
+#line 309 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in method declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yyloc).begin.line);
((*yyvalp).decl) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
}
-#line 1456 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1607 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 36:
-#line 314 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in method declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yyloc).begin.line);
+#line 314 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in method declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yyloc).begin.line);
((*yyvalp).decl) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-5)].yystate.yysemantics.yysval.token);
}
-#line 1466 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1617 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 37:
-#line 319 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error. \"No async\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
+#line 319 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error. \"No async\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
((*yyvalp).decl) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yysemantics.yysval.token);
}
-#line 1476 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1627 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 38:
-#line 324 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error. \"No identifier\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
+#line 324 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error. \"No identifier\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yyloc).begin.line);
((*yyvalp).decl) = NULL;
}
-#line 1485 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1636 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 39:
-#line 328 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error. \"No identifier\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yyloc).begin.line);
+#line 328 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error. \"No identifier\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yyloc).begin.line);
((*yyvalp).decl) = NULL;
}
-#line 1494 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1645 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 40:
-#line 332 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error. \"No identifier\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (-4)].yystate.yyloc).begin.line);
+#line 332 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error. \"No identifier\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-4)].yystate.yyloc).begin.line);
((*yyvalp).decl) = NULL;
}
-#line 1503 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1654 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 41:
-#line 336 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in method declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
+#line 336 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in method declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
((*yyvalp).decl) = NULL;
}
-#line 1512 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1663 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 42:
-#line 340 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in method declaration.", (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
+#line 340 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in method declaration.", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
((*yyvalp).decl) = NULL;
}
-#line 1521 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1672 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 43:
-#line 346 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 346 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).params) = new tidl::Parameters();
- if ((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param) != nullptr) {
- ((*yyvalp).params)->Add((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param));
+ if ((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param) != nullptr) {
+ ((*yyvalp).params)->Add((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param));
}
}
-#line 1532 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1683 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 44:
-#line 352 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).params) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.params);
- if ((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param) != nullptr) {
- if (((*yyvalp).params)->Exist((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param))) {
- ps->ReportError("syntax error. \"Already Exists\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param)->GetLine());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param);
+#line 352 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).params) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.params);
+ if ((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param) != nullptr) {
+ if (((*yyvalp).params)->Exist((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param))) {
+ ps->ReportError("syntax error. \"Already Exists\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param)->GetLine());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param);
} else {
- ((*yyvalp).params)->Add((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param));
+ ((*yyvalp).params)->Add((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.param));
}
}
}
-#line 1548 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1699 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 45:
-#line 363 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ps->ReportError("syntax error in parameter list", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
+#line 363 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ps->ReportError("syntax error in parameter list", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
((*yyvalp).params) = new tidl::Parameters();
}
-#line 1557 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1708 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 46:
-#line 369 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 369 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).direction) = new tidl::Token("in", "");
}
-#line 1565 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1716 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 47:
-#line 372 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 372 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).direction) = new tidl::Token("out", "");
}
-#line 1573 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1724 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 48:
-#line 375 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 375 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).direction) = new tidl::Token("ref", "");
}
-#line 1581 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1732 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 49:
-#line 380 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 380 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).param) = nullptr;
}
-#line 1589 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1740 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 50:
-#line 383 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 383 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
((*yyvalp).param) = nullptr;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1598 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1749 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 51:
-#line 387 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).param) = new tidl::Parameter((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.p_type), (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 387 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).param) = new tidl::Parameter((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.p_type), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yyloc).begin.line);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1607 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1758 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 52:
-#line 393 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).p_type) = new tidl::ParameterType((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.b_type));
+#line 393 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).p_type) = new tidl::ParameterType((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.b_type));
}
-#line 1615 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1766 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 53:
-#line 396 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).p_type) = new tidl::ParameterType((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.b_type), (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.direction)->ToString());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.direction);
+#line 396 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).p_type) = new tidl::ParameterType((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.b_type), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.direction)->ToString());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.direction);
}
-#line 1624 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1775 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 54:
-#line 402 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.b_type);
+#line 402 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.b_type);
}
-#line 1632 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1783 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 55:
-#line 405 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
+#line 405 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
if (!ps->IsBetaEnabled()) {
- ps->ReportError("syntax error. \"No identifier\".", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
+ ps->ReportError("syntax error. \"No identifier\".", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
+ ps->ReportError("try to use beta version (-b option).", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yyloc).begin.line);
((*yyvalp).b_type) = NULL;
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
} else {
- ((*yyvalp).b_type) = new tidl::BaseType("file", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+ ((*yyvalp).b_type) = new tidl::BaseType("file", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
}
-#line 1647 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1799 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 56:
-#line 417 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.b_type);
+#line 418 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.b_type);
}
-#line 1655 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1807 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 57:
-#line 420 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("void", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 421 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("void", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1664 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1816 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 58:
-#line 424 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("char", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 425 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("char", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1673 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1825 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 59:
-#line 428 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("short", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 429 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("short", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1682 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1834 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 60:
-#line 432 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("int", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 433 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("int", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1691 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1843 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 61:
-#line 436 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("long", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 437 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("long", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1700 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1852 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 62:
-#line 440 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("float", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 441 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("float", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1709 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1861 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 63:
-#line 444 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("double", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 445 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("double", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1718 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1870 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 64:
-#line 448 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("bundle", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 449 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("bundle", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1727 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1879 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 65:
-#line 452 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("string", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 453 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("string", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1736 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1888 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 66:
-#line 456 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType("bool", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 457 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType("bool", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1745 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1897 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 67:
-#line 460 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments(), true);
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 461 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments(), true);
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1754 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1906 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 68:
-#line 466 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).b_type) = new tidl::BaseType((((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->ToString(), (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->GetComments());
- ((*yyvalp).b_type)->SetMetaType((((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.b_type));
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
+#line 467 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).b_type) = new tidl::BaseType((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->ToString(), (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token)->GetComments());
+ ((*yyvalp).b_type)->SetMetaType((YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.b_type));
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (-3)].yystate.yysemantics.yysval.token);
}
-#line 1764 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1916 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 69:
-#line 473 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).token) = new tidl::Token("list", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 474 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).token) = new tidl::Token("list", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1773 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1925 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
case 70:
-#line 477 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:816
- {
- ((*yyvalp).token) = new tidl::Token("array", (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
- delete (((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
+#line 478 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
+ {
+ ((*yyvalp).token) = new tidl::Token("array", (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token)->GetComments());
+ delete (YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.token);
}
-#line 1782 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1934 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
break;
-#line 1786 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:816
+#line 1938 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
+
default: break;
}
+#if YY_EXCEPTIONS
+ }
+ catch (const syntax_error& yyexc)
+ {
+ YY_DPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));
+ *yylocp = yyexc.location;
+ yyerror (yylocp, yyparser, ps, yyexc.what ());
+ YYERROR;
+ }
+#endif // YY_EXCEPTIONS
return yyok;
# undef yyerrok
if (yydebug)
{
if (yys->yysemantics.yyfirstVal)
- YYFPRINTF (stderr, "%s unresolved", yymsg);
+ YY_FPRINTF ((stderr, "%s unresolved", yymsg));
else
- YYFPRINTF (stderr, "%s incomplete", yymsg);
+ YY_FPRINTF ((stderr, "%s incomplete", yymsg));
YY_SYMBOL_PRINT ("", yystos[yys->yylrState], YY_NULLPTR, &yys->yyloc);
}
#endif
return yyr1[yyrule];
}
-#define yypact_value_is_default(Yystate) \
- (!!((Yystate) == (-67)))
+#define yypact_value_is_default(Yyn) \
+ ((Yyn) == YYPACT_NINF)
/** True iff LR state YYSTATE has only a default reduction (regardless
* of token). */
return yydefact[yystate];
}
-#define yytable_value_is_error(Yytable_value) \
+#define yytable_value_is_error(Yyn) \
0
-/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
+/** The action to take in YYSTATE on seeing YYTOKEN.
* Result R means
* R < 0: Reduce on rule -R.
* R = 0: Error.
* Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list
* of conflicting reductions.
*/
-static inline void
-yygetLRActions (yyStateNum yystate, int yytoken,
- int* yyaction, const short int** yyconflicts)
+static inline int
+yygetLRActions (yyStateNum yystate, yySymbol yytoken, const short** yyconflicts)
{
int yyindex = yypact[yystate] + yytoken;
- if (yypact_value_is_default (yypact[yystate])
+ if (yyisDefaultedState (yystate)
|| yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)
{
- *yyaction = -yydefact[yystate];
*yyconflicts = yyconfl;
+ return -yydefact[yystate];
}
else if (! yytable_value_is_error (yytable[yyindex]))
{
- *yyaction = yytable[yyindex];
*yyconflicts = yyconfl + yyconflp[yyindex];
+ return yytable[yyindex];
}
else
{
- *yyaction = 0;
*yyconflicts = yyconfl + yyconflp[yyindex];
+ return 0;
}
}
* alternative actions for YYSTATE. Assumes that YYRHS comes from
* stack #YYK of *YYSTACKP. */
static void
-yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
+yyaddDeferredAction (yyGLRStack* yystackp, ptrdiff_t yyk, yyGLRState* yystate,
yyGLRState* yyrhs, yyRuleNum yyrule)
{
yySemanticOption* yynewOption =
&yynewGLRStackItem (yystackp, yyfalse)->yyoption;
- YYASSERT (!yynewOption->yyisState);
+ YY_ASSERT (!yynewOption->yyisState);
yynewOption->yystate = yyrhs;
yynewOption->yyrule = yyrule;
if (yystackp->yytops.yylookaheadNeeds[yyk])
{
yyset->yysize = 1;
yyset->yycapacity = 16;
- yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
+ yyset->yystates
+ = YY_CAST (yyGLRState**,
+ YYMALLOC (YY_CAST (size_t, yyset->yycapacity)
+ * sizeof yyset->yystates[0]));
if (! yyset->yystates)
return yyfalse;
yyset->yystates[0] = YY_NULLPTR;
- yyset->yylookaheadNeeds =
- (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
+ yyset->yylookaheadNeeds
+ = YY_CAST (yybool*,
+ YYMALLOC (YY_CAST (size_t, yyset->yycapacity)
+ * sizeof yyset->yylookaheadNeeds[0]));
if (! yyset->yylookaheadNeeds)
{
YYFREE (yyset->yystates);
return yyfalse;
}
+ memset (yyset->yylookaheadNeeds,
+ 0,
+ YY_CAST (size_t, yyset->yycapacity) * sizeof yyset->yylookaheadNeeds[0]);
return yytrue;
}
/** Initialize *YYSTACKP to a single empty stack, with total maximum
* capacity for all stacks of YYSIZE. */
static yybool
-yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
+yyinitGLRStack (yyGLRStack* yystackp, ptrdiff_t yysize)
{
yystackp->yyerrState = 0;
yynerrs = 0;
yystackp->yyspaceLeft = yysize;
- yystackp->yyitems =
- (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]);
+ yystackp->yyitems
+ = YY_CAST (yyGLRStackItem*,
+ YYMALLOC (YY_CAST (size_t, yysize)
+ * sizeof yystackp->yynextFree[0]));
if (!yystackp->yyitems)
return yyfalse;
yystackp->yynextFree = yystackp->yyitems;
#if YYSTACKEXPANDABLE
-# define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
- &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
+# define YYRELOC(YYFROMITEMS, YYTOITEMS, YYX, YYTYPE) \
+ &((YYTOITEMS) \
+ - ((YYFROMITEMS) - YY_REINTERPRET_CAST (yyGLRStackItem*, (YYX))))->YYTYPE
/** If *YYSTACKP is expandable, extend it. WARNING: Pointers into the
stack from outside should be considered invalid after this call.
{
yyGLRStackItem* yynewItems;
yyGLRStackItem* yyp0, *yyp1;
- size_t yynewSize;
- size_t yyn;
- size_t yysize = yystackp->yynextFree - yystackp->yyitems;
+ ptrdiff_t yynewSize;
+ ptrdiff_t yyn;
+ ptrdiff_t yysize = yystackp->yynextFree - yystackp->yyitems;
if (YYMAXDEPTH - YYHEADROOM < yysize)
yyMemoryExhausted (yystackp);
yynewSize = 2*yysize;
if (YYMAXDEPTH < yynewSize)
yynewSize = YYMAXDEPTH;
- yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]);
+ yynewItems
+ = YY_CAST (yyGLRStackItem*,
+ YYMALLOC (YY_CAST (size_t, yynewSize)
+ * sizeof yynewItems[0]));
if (! yynewItems)
yyMemoryExhausted (yystackp);
for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize;
yyn -= 1, yyp0 += 1, yyp1 += 1)
{
*yyp1 = *yyp0;
- if (*(yybool *) yyp0)
+ if (*YY_REINTERPRET_CAST (yybool *, yyp0))
{
yyGLRState* yys0 = &yyp0->yystate;
yyGLRState* yys1 = &yyp1->yystate;
/** Invalidate stack #YYK in *YYSTACKP. */
static inline void
-yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
+yymarkStackDeleted (yyGLRStack* yystackp, ptrdiff_t yyk)
{
if (yystackp->yytops.yystates[yyk] != YY_NULLPTR)
yystackp->yylastDeleted = yystackp->yytops.yystates[yyk];
return;
yystackp->yytops.yystates[0] = yystackp->yylastDeleted;
yystackp->yytops.yysize = 1;
- YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
+ YY_DPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
yystackp->yylastDeleted = YY_NULLPTR;
}
static inline void
yyremoveDeletes (yyGLRStack* yystackp)
{
- size_t yyi, yyj;
+ ptrdiff_t yyi, yyj;
yyi = yyj = 0;
while (yyj < yystackp->yytops.yysize)
{
if (yystackp->yytops.yystates[yyi] == YY_NULLPTR)
{
if (yyi == yyj)
- {
- YYDPRINTF ((stderr, "Removing dead stacks.\n"));
- }
+ YY_DPRINTF ((stderr, "Removing dead stacks.\n"));
yystackp->yytops.yysize -= 1;
}
else
yystackp->yytops.yylookaheadNeeds[yyj] =
yystackp->yytops.yylookaheadNeeds[yyi];
if (yyj != yyi)
- {
- YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
- (unsigned long int) yyi, (unsigned long int) yyj));
- }
+ YY_DPRINTF ((stderr, "Rename stack %ld -> %ld.\n",
+ YY_CAST (long, yyi), YY_CAST (long, yyj)));
yyj += 1;
}
yyi += 1;
* state YYLRSTATE, at input position YYPOSN, with (resolved) semantic
* value *YYVALP and source location *YYLOCP. */
static inline void
-yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
- size_t yyposn,
+yyglrShift (yyGLRStack* yystackp, ptrdiff_t yyk, yyStateNum yylrState,
+ ptrdiff_t yyposn,
YYSTYPE* yyvalp, YYLTYPE* yylocp)
{
yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
* state YYLRSTATE, at input position YYPOSN, with the (unresolved)
* semantic value of YYRHS under the action for YYRULE. */
static inline void
-yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
- size_t yyposn, yyGLRState* yyrhs, yyRuleNum yyrule)
+yyglrShiftDefer (yyGLRStack* yystackp, ptrdiff_t yyk, yyStateNum yylrState,
+ ptrdiff_t yyposn, yyGLRState* yyrhs, yyRuleNum yyrule)
{
yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
- YYASSERT (yynewState->yyisState);
+ YY_ASSERT (yynewState->yyisState);
yynewState->yylrState = yylrState;
yynewState->yyposn = yyposn;
# define YY_REDUCE_PRINT(Args)
#else
# define YY_REDUCE_PRINT(Args) \
-do { \
- if (yydebug) \
- yy_reduce_print Args; \
-} while (0)
+ do { \
+ if (yydebug) \
+ yy_reduce_print Args; \
+ } while (0)
/*----------------------------------------------------------------------.
| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. |
`----------------------------------------------------------------------*/
static inline void
-yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk,
+yy_reduce_print (yybool yynormal, yyGLRStackItem* yyvsp, ptrdiff_t yyk,
yyRuleNum yyrule, yy::parser& yyparser, tidl::Parser* ps)
{
int yynrhs = yyrhsLength (yyrule);
int yylow = 1;
int yyi;
- YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
- (unsigned long int) yyk, yyrule - 1,
- (unsigned long int) yyrline[yyrule]);
+ YY_FPRINTF ((stderr, "Reducing stack %ld by rule %d (line %d):\n",
+ YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule]));
if (! yynormal)
yyfillin (yyvsp, 1, -yynrhs);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
- YYFPRINTF (stderr, " $%d = ", yyi + 1);
+ YY_FPRINTF ((stderr, " $%d = ", yyi + 1));
yy_symbol_print (stderr,
yystos[yyvsp[yyi - yynrhs + 1].yystate.yylrState],
- &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yysval
- , &(((yyGLRStackItem const *)yyvsp)[YYFILL ((yyi + 1) - (yynrhs))].yystate.yyloc) , yyparser, ps);
+ &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yysval,
+ &(YY_CAST (yyGLRStackItem const *, yyvsp)[YYFILL ((yyi + 1) - (yynrhs))].yystate.yyloc) , yyparser, ps);
if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved)
- YYFPRINTF (stderr, " (unresolved)");
- YYFPRINTF (stderr, "\n");
+ YY_FPRINTF ((stderr, " (unresolved)"));
+ YY_FPRINTF ((stderr, "\n"));
}
}
#endif
* and *YYLOCP to the computed location (if any). Return value is as
* for userAction. */
static inline YYRESULTTAG
-yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
+yydoAction (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule,
YYSTYPE* yyvalp, YYLTYPE *yylocp, yy::parser& yyparser, tidl::Parser* ps)
{
int yynrhs = yyrhsLength (yyrule);
if (yystackp->yysplitPoint == YY_NULLPTR)
{
/* Standard special case: single stack. */
- yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
- YYASSERT (yyk == 0);
+ yyGLRStackItem* yyrhs
+ = YY_REINTERPRET_CAST (yyGLRStackItem*, yystackp->yytops.yystates[yyk]);
+ YY_ASSERT (yyk == 0);
yystackp->yynextFree -= yynrhs;
yystackp->yyspaceLeft += yynrhs;
yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
- YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule, yyparser, ps));
+ YY_REDUCE_PRINT ((yytrue, yyrhs, yyk, yyrule, yyparser, ps));
return yyuserAction (yyrule, yynrhs, yyrhs, yystackp,
yyvalp, yylocp, yyparser, ps);
}
else
{
- int yyi;
- yyGLRState* yys;
yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
- yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred
+ yyGLRState* yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred
= yystackp->yytops.yystates[yyk];
+ int yyi;
if (yynrhs == 0)
/* Set default location. */
yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;
for (yyi = 0; yyi < yynrhs; yyi += 1)
{
yys = yys->yypred;
- YYASSERT (yys);
+ YY_ASSERT (yys);
}
yyupdateSplit (yystackp, yys);
yystackp->yytops.yystates[yyk] = yys;
- YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule, yyparser, ps));
+ YY_REDUCE_PRINT ((yyfalse, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule, yyparser, ps));
return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
yystackp, yyvalp, yylocp, yyparser, ps);
}
* added to the options for the existing state's semantic value.
*/
static inline YYRESULTTAG
-yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
+yyglrReduce (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule,
yybool yyforceEval, yy::parser& yyparser, tidl::Parser* ps)
{
- size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
+ ptrdiff_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
if (yyforceEval || yystackp->yysplitPoint == YY_NULLPTR)
{
YYRESULTTAG yyflag = yydoAction (yystackp, yyk, yyrule, &yysval, &yyloc, yyparser, ps);
if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULLPTR)
- {
- YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n",
- (unsigned long int) yyk, yyrule - 1));
- }
+ YY_DPRINTF ((stderr,
+ "Parse on stack %ld rejected by rule %d (line %d).\n",
+ YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule - 1]));
if (yyflag != yyok)
return yyflag;
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
}
else
{
- size_t yyi;
+ ptrdiff_t yyi;
int yyn;
yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk];
yyStateNum yynewLRState;
0 < yyn; yyn -= 1)
{
yys = yys->yypred;
- YYASSERT (yys);
+ YY_ASSERT (yys);
}
yyupdateSplit (yystackp, yys);
yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
- YYDPRINTF ((stderr,
- "Reduced stack %lu by rule #%d; action deferred. "
- "Now in state %d.\n",
- (unsigned long int) yyk, yyrule - 1, yynewLRState));
+ YY_DPRINTF ((stderr,
+ "Reduced stack %ld by rule %d (line %d); action deferred. "
+ "Now in state %d.\n",
+ YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule - 1],
+ yynewLRState));
for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULLPTR)
{
{
yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);
yymarkStackDeleted (yystackp, yyk);
- YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
- (unsigned long int) yyk,
- (unsigned long int) yyi));
+ YY_DPRINTF ((stderr, "Merging stack %ld into stack %ld.\n",
+ YY_CAST (long, yyk), YY_CAST (long, yyi)));
return yyok;
}
yyp = yyp->yypred;
return yyok;
}
-static size_t
-yysplitStack (yyGLRStack* yystackp, size_t yyk)
+static ptrdiff_t
+yysplitStack (yyGLRStack* yystackp, ptrdiff_t yyk)
{
if (yystackp->yysplitPoint == YY_NULLPTR)
{
- YYASSERT (yyk == 0);
+ YY_ASSERT (yyk == 0);
yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];
}
- if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
+ if (yystackp->yytops.yycapacity <= yystackp->yytops.yysize)
{
- yyGLRState** yynewStates;
- yybool* yynewLookaheadNeeds;
-
- yynewStates = YY_NULLPTR;
-
- if (yystackp->yytops.yycapacity
- > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
+ ptrdiff_t state_size = sizeof yystackp->yytops.yystates[0];
+ ptrdiff_t half_max_capacity = YYSIZEMAX / 2 / state_size;
+ if (half_max_capacity < yystackp->yytops.yycapacity)
yyMemoryExhausted (yystackp);
yystackp->yytops.yycapacity *= 2;
- yynewStates =
- (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
- (yystackp->yytops.yycapacity
- * sizeof yynewStates[0]));
- if (yynewStates == YY_NULLPTR)
- yyMemoryExhausted (yystackp);
- yystackp->yytops.yystates = yynewStates;
+ {
+ yyGLRState** yynewStates
+ = YY_CAST (yyGLRState**,
+ YYREALLOC (yystackp->yytops.yystates,
+ (YY_CAST (size_t, yystackp->yytops.yycapacity)
+ * sizeof yynewStates[0])));
+ if (yynewStates == YY_NULLPTR)
+ yyMemoryExhausted (yystackp);
+ yystackp->yytops.yystates = yynewStates;
+ }
- yynewLookaheadNeeds =
- (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
- (yystackp->yytops.yycapacity
- * sizeof yynewLookaheadNeeds[0]));
- if (yynewLookaheadNeeds == YY_NULLPTR)
- yyMemoryExhausted (yystackp);
- yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
+ {
+ yybool* yynewLookaheadNeeds
+ = YY_CAST (yybool*,
+ YYREALLOC (yystackp->yytops.yylookaheadNeeds,
+ (YY_CAST (size_t, yystackp->yytops.yycapacity)
+ * sizeof yynewLookaheadNeeds[0])));
+ if (yynewLookaheadNeeds == YY_NULLPTR)
+ yyMemoryExhausted (yystackp);
+ yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
+ }
}
yystackp->yytops.yystates[yystackp->yytops.yysize]
= yystackp->yytops.yystates[yyk];
yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
= yystackp->yytops.yylookaheadNeeds[yyk];
yystackp->yytops.yysize += 1;
- return yystackp->yytops.yysize-1;
+ return yystackp->yytops.yysize - 1;
}
/** True iff YYY0 and YYY1 represent identical options at the top level.
int yyn;
for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
yyn = yyrhsLength (yyy0->yyrule);
- yyn > 0;
+ 0 < yyn;
yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
{
if (yys0 == yys1)
{
if (0 < yyn)
{
- YYASSERT (yys->yypred);
+ YY_ASSERT (yys->yypred);
YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp, yyparser, ps));
if (! yys->yyresolved)
YYCHK (yyresolveValue (yys, yystackp, yyparser, ps));
yystates[0] = yys;
if (yyx->yystate->yyposn < yys->yyposn + 1)
- YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
- yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
- yyx->yyrule - 1);
+ YY_FPRINTF ((stderr, "%*s%s -> <Rule %d, empty>\n",
+ yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
+ yyx->yyrule - 1));
else
- YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
- yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
- yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1),
- (unsigned long int) yyx->yystate->yyposn);
+ YY_FPRINTF ((stderr, "%*s%s -> <Rule %d, tokens %ld .. %ld>\n",
+ yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
+ yyx->yyrule - 1, YY_CAST (long, yys->yyposn + 1),
+ YY_CAST (long, yyx->yystate->yyposn)));
for (yyi = 1; yyi <= yynrhs; yyi += 1)
{
if (yystates[yyi]->yyresolved)
{
if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
- YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
- yytokenName (yystos[yystates[yyi]->yylrState]));
+ YY_FPRINTF ((stderr, "%*s%s <empty>\n", yyindent+2, "",
+ yytokenName (yystos[yystates[yyi]->yylrState])));
else
- YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
- yytokenName (yystos[yystates[yyi]->yylrState]),
- (unsigned long int) (yystates[yyi-1]->yyposn + 1),
- (unsigned long int) yystates[yyi]->yyposn);
+ YY_FPRINTF ((stderr, "%*s%s <tokens %ld .. %ld>\n", yyindent+2, "",
+ yytokenName (yystos[yystates[yyi]->yylrState]),
+ YY_CAST (long, yystates[yyi-1]->yyposn + 1),
+ YY_CAST (long, yystates[yyi]->yyposn)));
}
else
yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);
YYUSE (yyx1);
#if YYDEBUG
- YYFPRINTF (stderr, "Ambiguity detected.\n");
- YYFPRINTF (stderr, "Option 1,\n");
+ YY_FPRINTF ((stderr, "Ambiguity detected.\n"));
+ YY_FPRINTF ((stderr, "Option 1,\n"));
yyreportTree (yyx0, 2);
- YYFPRINTF (stderr, "\nOption 2,\n");
+ YY_FPRINTF ((stderr, "\nOption 2,\n"));
yyreportTree (yyx1, 2);
- YYFPRINTF (stderr, "\n");
+ YY_FPRINTF ((stderr, "\n"));
#endif
yyerror (yylocp, yyparser, ps, YY_("syntax is ambiguous"));
* ending at YYS1. Has no effect on previously resolved states.
* The first semantic option of a state is always chosen. */
static void
-yyresolveLocations (yyGLRState* yys1, int yyn1,
+yyresolveLocations (yyGLRState *yys1, int yyn1,
yyGLRStack *yystackp, yy::parser& yyparser, tidl::Parser* ps)
{
if (0 < yyn1)
yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
int yynrhs;
yySemanticOption *yyoption = yys1->yysemantics.yyfirstVal;
- YYASSERT (yyoption != YY_NULLPTR);
+ YY_ASSERT (yyoption);
yynrhs = yyrhsLength (yyoption->yyrule);
- if (yynrhs > 0)
+ if (0 < yynrhs)
{
yyGLRState *yys;
int yyn;
yyGLRState *yyprevious = yyoption->yystate;
yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
}
- {
- int yychar_current = yychar;
- YYSTYPE yylval_current = yylval;
- YYLTYPE yylloc_current = yylloc;
- yychar = yyoption->yyrawchar;
- yylval = yyoption->yyval;
- yylloc = yyoption->yyloc;
- YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
- yychar = yychar_current;
- yylval = yylval_current;
- yylloc = yylloc_current;
- }
+ YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
}
}
}
yymerge = yyfalse;
break;
default:
- /* This cannot happen so it is not worth a YYASSERT (yyfalse),
+ /* This cannot happen so it is not worth a YY_ASSERT (yyfalse),
but some compilers complain if the default case is
omitted. */
break;
yyp->yypred = yyr;
yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
- yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
+ yystackp->yynextFree = YY_REINTERPRET_CAST (yyGLRStackItem*, yystackp->yysplitPoint) + 1;
yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
yystackp->yysplitPoint = YY_NULLPTR;
yystackp->yylastDeleted = YY_NULLPTR;
}
static YYRESULTTAG
-yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
- size_t yyposn, YYLTYPE *yylocp, yy::parser& yyparser, tidl::Parser* ps)
+yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk,
+ ptrdiff_t yyposn, YYLTYPE *yylocp, yy::parser& yyparser, tidl::Parser* ps)
{
while (yystackp->yytops.yystates[yyk] != YY_NULLPTR)
{
yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
- YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
- (unsigned long int) yyk, yystate));
+ YY_DPRINTF ((stderr, "Stack %ld Entering state %d\n",
+ YY_CAST (long, yyk), yystate));
- YYASSERT (yystate != YYFINAL);
+ YY_ASSERT (yystate != YYFINAL);
if (yyisDefaultedState (yystate))
{
yyRuleNum yyrule = yydefaultAction (yystate);
if (yyrule == 0)
{
- YYDPRINTF ((stderr, "Stack %lu dies.\n",
- (unsigned long int) yyk));
+ YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk)));
yymarkStackDeleted (yystackp, yyk);
return yyok;
}
yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule], yyparser, ps);
if (yyflag == yyerr)
{
- YYDPRINTF ((stderr,
- "Stack %lu dies "
- "(predicate failure or explicit user error).\n",
- (unsigned long int) yyk));
+ YY_DPRINTF ((stderr,
+ "Stack %ld dies "
+ "(predicate failure or explicit user error).\n",
+ YY_CAST (long, yyk)));
yymarkStackDeleted (yystackp, yyk);
return yyok;
}
}
else
{
- yySymbol yytoken;
- int yyaction;
- const short int* yyconflicts;
-
+ yySymbol yytoken = yygetToken (&yychar, yystackp, yyparser, ps);
+ const short* yyconflicts;
+ const int yyaction = yygetLRActions (yystate, yytoken, &yyconflicts);
yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
- if (yychar == YYEMPTY)
- {
- YYDPRINTF ((stderr, "Reading a token: "));
- yychar = yylex (&yylval, &yylloc, lex_scanner);
- }
-
- 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);
- }
-
- yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
while (*yyconflicts != 0)
{
YYRESULTTAG yyflag;
- size_t yynewStack = yysplitStack (yystackp, yyk);
- YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
- (unsigned long int) yynewStack,
- (unsigned long int) yyk));
+ ptrdiff_t yynewStack = yysplitStack (yystackp, yyk);
+ YY_DPRINTF ((stderr, "Splitting off stack %ld from %ld.\n",
+ YY_CAST (long, yynewStack), YY_CAST (long, yyk)));
yyflag = yyglrReduce (yystackp, yynewStack,
*yyconflicts,
yyimmediate[*yyconflicts], yyparser, ps);
yyposn, yylocp, yyparser, ps));
else if (yyflag == yyerr)
{
- YYDPRINTF ((stderr, "Stack %lu dies.\n",
- (unsigned long int) yynewStack));
+ YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yynewStack)));
yymarkStackDeleted (yystackp, yynewStack);
}
else
break;
else if (yyisErrorAction (yyaction))
{
- YYDPRINTF ((stderr, "Stack %lu dies.\n",
- (unsigned long int) yyk));
+ YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk)));
yymarkStackDeleted (yystackp, yyk);
break;
}
yyimmediate[-yyaction], yyparser, ps);
if (yyflag == yyerr)
{
- YYDPRINTF ((stderr,
- "Stack %lu dies "
- "(predicate failure or explicit user error).\n",
- (unsigned long int) yyk));
+ YY_DPRINTF ((stderr,
+ "Stack %ld dies "
+ "(predicate failure or explicit user error).\n",
+ YY_CAST (long, yyk)));
yymarkStackDeleted (yystackp, yyk);
break;
}
#else
{
yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
- size_t yysize0 = yytnamerr (YY_NULLPTR, yytokenName (yytoken));
- size_t yysize = yysize0;
yybool yysize_overflow = yyfalse;
char* yymsg = YY_NULLPTR;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */
const char *yyformat = YY_NULLPTR;
- /* Arguments of yyformat. */
+ /* Arguments of yyformat: reported tokens (one for the "unexpected",
+ one per "expected"). */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
- /* Number of reported tokens (one for the "unexpected", one per
- "expected"). */
+ /* Actual size of YYARG. */
int yycount = 0;
+ /* Cumulated lengths of YYARG. */
+ ptrdiff_t yysize = 0;
/* There are many possibilities here to consider:
- If this state is a consistent state with a default action, then
if (yytoken != YYEMPTY)
{
int yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
+ ptrdiff_t yysize0 = yytnamerr (YY_NULLPTR, yytokenName (yytoken));
+ yysize = yysize0;
yyarg[yycount++] = yytokenName (yytoken);
if (!yypact_value_is_default (yyn))
{
}
yyarg[yycount++] = yytokenName (yyx);
{
- size_t yysz = yysize + yytnamerr (YY_NULLPTR, yytokenName (yyx));
- yysize_overflow |= yysz < yysize;
- yysize = yysz;
+ ptrdiff_t yysz = yytnamerr (YY_NULLPTR, yytokenName (yyx));
+ if (YYSIZEMAX - yysize < yysz)
+ yysize_overflow = yytrue;
+ else
+ yysize += yysz;
}
}
}
case N: \
yyformat = S; \
break
+ default: /* Avoid compiler warnings. */
YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
}
{
- size_t yysz = yysize + strlen (yyformat);
- yysize_overflow |= yysz < yysize;
- yysize = yysz;
+ /* Don't count the "%s"s in the final size, but reserve room for
+ the terminator. */
+ ptrdiff_t yysz = YY_CAST (ptrdiff_t, strlen (yyformat)) - 2 * yycount + 1;
+ if (YYSIZEMAX - yysize < yysz)
+ yysize_overflow = yytrue;
+ else
+ yysize += yysz;
}
if (!yysize_overflow)
- yymsg = (char *) YYMALLOC (yysize);
+ yymsg = YY_CAST (char *, YYMALLOC (YY_CAST (size_t, yysize)));
if (yymsg)
{
}
else
{
- yyp++;
- yyformat++;
+ ++yyp;
+ ++yyformat;
}
}
yyerror (&yylloc, yyparser, ps, yymsg);
static void
yyrecoverSyntaxError (yyGLRStack* yystackp, yy::parser& yyparser, tidl::Parser* ps)
{
- size_t yyk;
- int yyj;
-
if (yystackp->yyerrState == 3)
/* We just shifted the error token and (perhaps) took some
reductions. Skip tokens until we can proceed. */
while (yytrue)
{
yySymbol yytoken;
+ int yyj;
if (yychar == YYEOF)
yyFail (yystackp, &yylloc, yyparser, ps, YY_NULLPTR);
if (yychar != YYEMPTY)
yytoken = YYTRANSLATE (yychar);
yydestruct ("Error: discarding",
yytoken, &yylval, &yylloc, yyparser, ps);
+ yychar = YYEMPTY;
}
- YYDPRINTF ((stderr, "Reading a token: "));
- yychar = yylex (&yylval, &yylloc, lex_scanner);
- 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);
- }
+ yytoken = yygetToken (&yychar, yystackp, yyparser, ps);
yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
if (yypact_value_is_default (yyj))
return;
}
/* Reduce to one stack. */
- for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
- if (yystackp->yytops.yystates[yyk] != YY_NULLPTR)
- break;
- if (yyk >= yystackp->yytops.yysize)
- yyFail (yystackp, &yylloc, yyparser, ps, YY_NULLPTR);
- for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
- yymarkStackDeleted (yystackp, yyk);
- yyremoveDeletes (yystackp);
- yycompressStack (yystackp);
+ {
+ ptrdiff_t yyk;
+ for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
+ if (yystackp->yytops.yystates[yyk] != YY_NULLPTR)
+ break;
+ if (yyk >= yystackp->yytops.yysize)
+ yyFail (yystackp, &yylloc, yyparser, ps, YY_NULLPTR);
+ for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
+ yymarkStackDeleted (yystackp, yyk);
+ yyremoveDeletes (yystackp);
+ yycompressStack (yystackp);
+ }
/* Now pop stack until we find a state that shifts the error token. */
yystackp->yyerrState = 3;
while (yystackp->yytops.yystates[0] != YY_NULLPTR)
{
yyGLRState *yys = yystackp->yytops.yystates[0];
- yyj = yypact[yys->yylrState];
+ int yyj = yypact[yys->yylrState];
if (! yypact_value_is_default (yyj))
{
yyj += YYTERROR;
&& yyisShiftAction (yytable[yyj]))
{
/* Shift the error token. */
+ int yyaction = yytable[yyj];
/* First adjust its location.*/
YYLTYPE yyerrloc;
yystackp->yyerror_range[2].yystate.yyloc = yylloc;
YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);
- YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
+ YY_SYMBOL_PRINT ("Shifting", yystos[yyaction],
&yylval, &yyerrloc);
- yyglrShift (yystackp, 0, yytable[yyj],
+ yyglrShift (yystackp, 0, yyaction,
yys->yyposn, &yylval, &yyerrloc);
yys = yystackp->yytops.yystates[0];
break;
int yyresult;
yyGLRStack yystack;
yyGLRStack* const yystackp = &yystack;
- size_t yyposn;
+ ptrdiff_t yyposn;
- YYDPRINTF ((stderr, "Starting parse\n"));
+ YY_DPRINTF ((stderr, "Starting parse\n"));
yychar = YYEMPTY;
yylval = yyval_default;
yylloc = yyloc_default;
- /* User initialization code. */
- yylloc.initialize ();
-#line 3261 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:2270
+ // User initialization code.
+yylloc.initialize ();
+#line 3400 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
+
if (! yyinitGLRStack (yystackp, YYINITDEPTH))
goto yyexhaustedlab;
/* Standard mode */
while (yytrue)
{
- yyRuleNum yyrule;
- int yyaction;
- const short int* yyconflicts;
-
yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
- YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+ YY_DPRINTF ((stderr, "Entering state %d\n", yystate));
if (yystate == YYFINAL)
goto yyacceptlab;
if (yyisDefaultedState (yystate))
{
- yyrule = yydefaultAction (yystate);
+ yyRuleNum yyrule = yydefaultAction (yystate);
if (yyrule == 0)
{
- yystack.yyerror_range[1].yystate.yyloc = yylloc;
+ yystack.yyerror_range[1].yystate.yyloc = yylloc;
yyreportSyntaxError (&yystack, yyparser, ps);
goto yyuser_error;
}
}
else
{
- yySymbol yytoken;
- if (yychar == YYEMPTY)
- {
- YYDPRINTF ((stderr, "Reading a token: "));
- yychar = yylex (&yylval, &yylloc, lex_scanner);
- }
-
- 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);
- }
-
- yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
+ yySymbol yytoken = yygetToken (&yychar, yystackp, yyparser, ps);
+ const short* yyconflicts;
+ int yyaction = yygetLRActions (yystate, yytoken, &yyconflicts);
if (*yyconflicts != 0)
break;
if (yyisShiftAction (yyaction))
}
else if (yyisErrorAction (yyaction))
{
- yystack.yyerror_range[1].yystate.yyloc = yylloc;
- yyreportSyntaxError (&yystack, yyparser, ps);
+ yystack.yyerror_range[1].yystate.yyloc = yylloc;
+ /* Don't issue an error message again for exceptions
+ thrown from the scanner. */
+ if (yychar != YYFAULTYTOK)
+ yyreportSyntaxError (&yystack, yyparser, ps);
goto yyuser_error;
}
else
while (yytrue)
{
yySymbol yytoken_to_shift;
- size_t yys;
+ ptrdiff_t yys;
for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
if (yystack.yytops.yysize == 0)
yyFail (&yystack, &yylloc, yyparser, ps, YY_("syntax error"));
YYCHK1 (yyresolveStack (&yystack, yyparser, ps));
- YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
- yystack.yyerror_range[1].yystate.yyloc = yylloc;
+ YY_DPRINTF ((stderr, "Returning to deterministic operation.\n"));
+ yystack.yyerror_range[1].yystate.yyloc = yylloc;
yyreportSyntaxError (&yystack, yyparser, ps);
goto yyuser_error;
}
yyposn += 1;
for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
{
- int yyaction;
- const short int* yyconflicts;
yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState;
- yygetLRActions (yystate, yytoken_to_shift, &yyaction,
+ const short* yyconflicts;
+ int yyaction = yygetLRActions (yystate, yytoken_to_shift,
&yyconflicts);
/* Note that yyconflicts were handled by yyprocessOneStack. */
- YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
+ YY_DPRINTF ((stderr, "On stack %ld, ", YY_CAST (long, yys)));
YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
yyglrShift (&yystack, yys, yyaction, yyposn,
&yylval, &yylloc);
- YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
- (unsigned long int) yys,
- yystack.yytops.yystates[yys]->yylrState));
+ YY_DPRINTF ((stderr, "Stack %ld now in state #%d\n",
+ YY_CAST (long, yys),
+ yystack.yytops.yystates[yys]->yylrState));
}
if (yystack.yytops.yysize == 1)
{
YYCHK1 (yyresolveStack (&yystack, yyparser, ps));
- YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
+ YY_DPRINTF ((stderr, "Returning to deterministic operation.\n"));
yycompressStack (&yystack);
break;
}
goto yyreturn;
yybuglab:
- YYASSERT (yyfalse);
+ YY_ASSERT (yyfalse);
goto yyabortlab;
yyabortlab:
yyGLRState** yystates = yystack.yytops.yystates;
if (yystates)
{
- size_t yysize = yystack.yytops.yysize;
- size_t yyk;
+ ptrdiff_t yysize = yystack.yytops.yysize;
+ ptrdiff_t yyk;
for (yyk = 0; yyk < yysize; yyk += 1)
if (yystates[yyk])
{
while (yystates[yyk])
{
yyGLRState *yys = yystates[yyk];
- yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;
- if (yys->yypred != YY_NULLPTR)
+ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;
+ if (yys->yypred != YY_NULLPTR)
yydestroyGLRState ("Cleanup: popping", yys, yyparser, ps);
yystates[yyk] = yys->yypred;
yystack.yynextFree -= 1;
if (yys->yypred)
{
yy_yypstack (yys->yypred);
- YYFPRINTF (stderr, " -> ");
+ YY_FPRINTF ((stderr, " -> "));
}
- YYFPRINTF (stderr, "%d@%lu", yys->yylrState,
- (unsigned long int) yys->yyposn);
+ YY_FPRINTF ((stderr, "%d@%ld", yys->yylrState, YY_CAST (long, yys->yyposn)));
}
static void
yypstates (yyGLRState* yyst)
{
if (yyst == YY_NULLPTR)
- YYFPRINTF (stderr, "<null>");
+ YY_FPRINTF ((stderr, "<null>"));
else
yy_yypstack (yyst);
- YYFPRINTF (stderr, "\n");
+ YY_FPRINTF ((stderr, "\n"));
}
static void
-yypstack (yyGLRStack* yystackp, size_t yyk)
+yypstack (yyGLRStack* yystackp, ptrdiff_t yyk)
{
yypstates (yystackp->yytops.yystates[yyk]);
}
-#define YYINDEX(YYX) \
- ((YYX) == YY_NULLPTR ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
-
-
static void
yypdumpstack (yyGLRStack* yystackp)
{
+#define YYINDEX(YYX) \
+ YY_CAST (long, \
+ ((YYX) \
+ ? YY_REINTERPRET_CAST (yyGLRStackItem*, (YYX)) - yystackp->yyitems \
+ : -1))
+
yyGLRStackItem* yyp;
- size_t yyi;
for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
{
- YYFPRINTF (stderr, "%3lu. ",
- (unsigned long int) (yyp - yystackp->yyitems));
- if (*(yybool *) yyp)
+ YY_FPRINTF ((stderr, "%3ld. ",
+ YY_CAST (long, yyp - yystackp->yyitems)));
+ if (*YY_REINTERPRET_CAST (yybool *, yyp))
{
- YYASSERT (yyp->yystate.yyisState);
- YYASSERT (yyp->yyoption.yyisState);
- YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
- yyp->yystate.yyresolved, yyp->yystate.yylrState,
- (unsigned long int) yyp->yystate.yyposn,
- (long int) YYINDEX (yyp->yystate.yypred));
+ YY_ASSERT (yyp->yystate.yyisState);
+ YY_ASSERT (yyp->yyoption.yyisState);
+ YY_FPRINTF ((stderr, "Res: %d, LR State: %d, posn: %ld, pred: %ld",
+ yyp->yystate.yyresolved, yyp->yystate.yylrState,
+ YY_CAST (long, yyp->yystate.yyposn),
+ YYINDEX (yyp->yystate.yypred)));
if (! yyp->yystate.yyresolved)
- YYFPRINTF (stderr, ", firstVal: %ld",
- (long int) YYINDEX (yyp->yystate
- .yysemantics.yyfirstVal));
+ YY_FPRINTF ((stderr, ", firstVal: %ld",
+ YYINDEX (yyp->yystate.yysemantics.yyfirstVal)));
}
else
{
- YYASSERT (!yyp->yystate.yyisState);
- YYASSERT (!yyp->yyoption.yyisState);
- YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld",
- yyp->yyoption.yyrule - 1,
- (long int) YYINDEX (yyp->yyoption.yystate),
- (long int) YYINDEX (yyp->yyoption.yynext));
+ YY_ASSERT (!yyp->yystate.yyisState);
+ YY_ASSERT (!yyp->yyoption.yyisState);
+ YY_FPRINTF ((stderr, "Option. rule: %d, state: %ld, next: %ld",
+ yyp->yyoption.yyrule - 1,
+ YYINDEX (yyp->yyoption.yystate),
+ YYINDEX (yyp->yyoption.yynext)));
}
- YYFPRINTF (stderr, "\n");
+ YY_FPRINTF ((stderr, "\n"));
}
- YYFPRINTF (stderr, "Tops:");
- for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
- YYFPRINTF (stderr, "%lu: %ld; ", (unsigned long int) yyi,
- (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
- YYFPRINTF (stderr, "\n");
+
+ YY_FPRINTF ((stderr, "Tops:"));
+ {
+ ptrdiff_t yyi;
+ for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
+ YY_FPRINTF ((stderr, "%ld: %ld; ", YY_CAST (long, yyi),
+ YYINDEX (yystackp->yytops.yystates[yyi])));
+ YY_FPRINTF ((stderr, "\n"));
+ }
+#undef YYINDEX
}
#endif
-#line 483 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc.yy" // glr.c:2584
+#line 484 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc.yy"
#include <ctype.h>
}
-#line 3574 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:2584
+#line 3700 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
/*------------------.
| Report an error. |
}
-
namespace yy {
-#line 3591 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:2584
+#line 3716 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
+
/// Build a parser object.
parser::parser (tidl::Parser* ps_yyarg)
:
yycdebug_ (&std::cerr),
#endif
ps (ps_yyarg)
- {
- }
+ {}
parser::~parser ()
+ {}
+
+ parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW
+ {}
+
+ int
+ parser::operator() ()
{
+ return parse ();
}
int
| Print this symbol. |
`--------------------*/
- inline void
+ void
parser::yy_symbol_value_print_ (int yytype,
const semantic_type* yyvaluep,
const location_type* yylocationp)
{
YYUSE (yylocationp);
YYUSE (yyvaluep);
- std::ostream& yyoutput = debug_stream ();
- std::ostream& yyo = yyoutput;
- YYUSE (yyo);
+ std::ostream& yyo = debug_stream ();
+ std::ostream& yyoutput = yyo;
+ YYUSE (yyoutput);
YYUSE (yytype);
}
}
#endif
-
} // yy
-#line 3672 "/home/hyunho/full-sources/tizen/tidl_thread_proj/tidl/idlc/ast/tidlc_y.cpp" // glr.c:2584
+#line 3804 "/home/upple/tizen/appfw/tidl/idlc/ast/tidlc_y.cpp"
projects / platform / core / appfw / tidl.git / commitdiff