← Back to branch summary

~ubuntu-branches/ubuntu/edgy/koffice/edgy-updates

« back to all changes in this revision

Viewing changes to lib/koscript/yacc.cc

  • Committer: Bazaar Package Importer
  • Author(s): Ben Burton
  • Date: 2004-05-09 11:33:00 UTC
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20040509113300-xi5t1z4yxe7n03x7
Tags: upstream-1.3.1
Import upstream version 1.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/koscript/yacc.cc
1
 
 
2
 
/*  A Bison parser, made from yacc.yy
3
 
    by GNU Bison version 1.28  */
 
1
/* A Bison parser, made from yacc.yy
 
2
   by GNU bison 1.35.  */
4
3
 
5
4
#define YYBISON 1  /* Identify Bison output.  */
6
5
 
7
 
#define T_MATCH_LINE    257
8
 
#define T_LINE  258
9
 
#define T_INPUT 259
10
 
#define T_AMPERSAND     260
11
 
#define T_ASTERISK      261
12
 
#define T_CASE  262
13
 
#define T_CHARACTER_LITERAL     263
14
 
#define T_CIRCUMFLEX    264
15
 
#define T_COLON 265
16
 
#define T_COMMA 266
17
 
#define T_CONST 267
18
 
#define T_DEFAULT       268
19
 
#define T_ENUM  269
20
 
#define T_EQUAL 270
21
 
#define T_FALSE 271
22
 
#define T_FLOATING_PT_LITERAL   272
23
 
#define T_GREATER_THAN_SIGN     273
24
 
#define T_IDENTIFIER    274
25
 
#define T_IN    275
26
 
#define T_INOUT 276
27
 
#define T_INTEGER_LITERAL       277
28
 
#define T_LEFT_CURLY_BRACKET    278
29
 
#define T_LEFT_PARANTHESIS      279
30
 
#define T_LEFT_SQUARE_BRACKET   280
31
 
#define T_LESS_THAN_SIGN        281
32
 
#define T_MINUS_SIGN    282
33
 
#define T_OUT   283
34
 
#define T_PERCENT_SIGN  284
35
 
#define T_PLUS_SIGN     285
36
 
#define T_RIGHT_CURLY_BRACKET   286
37
 
#define T_RIGHT_PARANTHESIS     287
38
 
#define T_RIGHT_SQUARE_BRACKET  288
39
 
#define T_SCOPE 289
40
 
#define T_SEMICOLON     290
41
 
#define T_SHIFTLEFT     291
42
 
#define T_SHIFTRIGHT    292
43
 
#define T_SOLIDUS       293
44
 
#define T_STRING_LITERAL        294
45
 
#define T_STRUCT        295
46
 
#define T_SWITCH        296
47
 
#define T_TILDE 297
48
 
#define T_TRUE  298
49
 
#define T_VERTICAL_LINE 299
50
 
#define T_LESS_OR_EQUAL 300
51
 
#define T_GREATER_OR_EQUAL      301
52
 
#define T_ASSIGN        302
53
 
#define T_NOTEQUAL      303
54
 
#define T_MEMBER        304
55
 
#define T_WHILE 305
56
 
#define T_IF    306
57
 
#define T_ELSE  307
58
 
#define T_FOR   308
59
 
#define T_DO    309
60
 
#define T_INCR  310
61
 
#define T_DECR  311
62
 
#define T_MAIN  312
63
 
#define T_FOREACH       313
64
 
#define T_SUBST 314
65
 
#define T_MATCH 315
66
 
#define T_NOT   316
67
 
#define T_RETURN        317
68
 
#define T_IMPORT        318
69
 
#define T_VAR   319
70
 
#define T_CATCH 320
71
 
#define T_TRY   321
72
 
#define T_RAISE 322
73
 
#define T_RANGE 323
74
 
#define T_CELL  324
75
 
#define T_FROM  325
76
 
#define T_PLUS_ASSIGN   326
77
 
#define T_MINUS_ASSIGN  327
78
 
#define T_AND   328
79
 
#define T_OR    329
80
 
#define T_DOLLAR        330
81
 
#define T_UNKNOWN       331
 
6
# define        T_MATCH_LINE    257
 
7
# define        T_LINE  258
 
8
# define        T_INPUT 259
 
9
# define        T_AMPERSAND     260
 
10
# define        T_ASTERISK      261
 
11
# define        T_CASE  262
 
12
# define        T_CHARACTER_LITERAL     263
 
13
# define        T_CIRCUMFLEX    264
 
14
# define        T_COLON 265
 
15
# define        T_COMMA 266
 
16
# define        T_CONST 267
 
17
# define        T_DEFAULT       268
 
18
# define        T_ENUM  269
 
19
# define        T_EQUAL 270
 
20
# define        T_FALSE 271
 
21
# define        T_FLOATING_PT_LITERAL   272
 
22
# define        T_GREATER_THAN_SIGN     273
 
23
# define        T_IDENTIFIER    274
 
24
# define        T_IN    275
 
25
# define        T_INOUT 276
 
26
# define        T_INTEGER_LITERAL       277
 
27
# define        T_LEFT_CURLY_BRACKET    278
 
28
# define        T_LEFT_PARANTHESIS      279
 
29
# define        T_LEFT_SQUARE_BRACKET   280
 
30
# define        T_LESS_THAN_SIGN        281
 
31
# define        T_MINUS_SIGN    282
 
32
# define        T_OUT   283
 
33
# define        T_PERCENT_SIGN  284
 
34
# define        T_PLUS_SIGN     285
 
35
# define        T_RIGHT_CURLY_BRACKET   286
 
36
# define        T_RIGHT_PARANTHESIS     287
 
37
# define        T_RIGHT_SQUARE_BRACKET  288
 
38
# define        T_SCOPE 289
 
39
# define        T_SEMICOLON     290
 
40
# define        T_SHIFTLEFT     291
 
41
# define        T_SHIFTRIGHT    292
 
42
# define        T_SOLIDUS       293
 
43
# define        T_STRING_LITERAL        294
 
44
# define        T_STRUCT        295
 
45
# define        T_SWITCH        296
 
46
# define        T_TILDE 297
 
47
# define        T_TRUE  298
 
48
# define        T_VERTICAL_LINE 299
 
49
# define        T_LESS_OR_EQUAL 300
 
50
# define        T_GREATER_OR_EQUAL      301
 
51
# define        T_ASSIGN        302
 
52
# define        T_NOTEQUAL      303
 
53
# define        T_MEMBER        304
 
54
# define        T_WHILE 305
 
55
# define        T_IF    306
 
56
# define        T_ELSE  307
 
57
# define        T_FOR   308
 
58
# define        T_DO    309
 
59
# define        T_INCR  310
 
60
# define        T_DECR  311
 
61
# define        T_MAIN  312
 
62
# define        T_FOREACH       313
 
63
# define        T_SUBST 314
 
64
# define        T_MATCH 315
 
65
# define        T_NOT   316
 
66
# define        T_RETURN        317
 
67
# define        T_IMPORT        318
 
68
# define        T_VAR   319
 
69
# define        T_CATCH 320
 
70
# define        T_TRY   321
 
71
# define        T_RAISE 322
 
72
# define        T_RANGE 323
 
73
# define        T_CELL  324
 
74
# define        T_FROM  325
 
75
# define        T_PLUS_ASSIGN   326
 
76
# define        T_MINUS_ASSIGN  327
 
77
# define        T_AND   328
 
78
# define        T_OR    329
 
79
# define        T_DOLLAR        330
 
80
# define        T_UNKNOWN       331
82
81
 
83
 
#line 1 "yacc.yy"
 
82
#line 20 "yacc.yy"
84
83
 
85
84
 
86
85
#include "koscript_parsenode.h"
100
99
 
101
100
void kscriptInitFlex( const char *_code, int extension, KLocale* );
102
101
void kscriptInitFlex( int extension, KLocale* );
 
102
void kspread_mode();
103
103
 
104
104
void yyerror( const char *s )
105
105
{
107
107
}
108
108
 
109
109
 
110
 
#line 29 "yacc.yy"
 
110
#line 48 "yacc.yy"
 
111
#ifndef YYSTYPE
111
112
typedef union
112
113
{
113
114
  QString        *ident;
116
117
  QString        *_str;
117
118
  ushort          _char;
118
119
  KScript::Double _float;
119
 
} YYSTYPE;
 
120
} yystype;
 
121
# define YYSTYPE yystype
 
122
# define YYSTYPE_IS_TRIVIAL 1
 
123
#endif
120
124
#ifndef YYDEBUG
121
 
#define YYDEBUG 1
122
 
#endif
123
 
 
124
 
#include <stdio.h>
125
 
 
126
 
#ifndef __cplusplus
127
 
#ifndef __STDC__
128
 
#define const
129
 
#endif
130
 
#endif
131
 
 
132
 
 
133
 
 
134
 
#define YYFINAL         316
 
125
# define YYDEBUG 1
 
126
#endif
 
127
 
 
128
 
 
129
 
 
130
#define YYFINAL         303
135
131
#define YYFLAG          -32768
136
132
#define YYNTBASE        78
137
133
 
138
 
#define YYTRANSLATE(x) ((unsigned)(x) <= 331 ? yytranslate[x] : 121)
139
 
 
140
 
static const char yytranslate[] = {     0,
141
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
142
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
143
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
144
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
145
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
146
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
147
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
148
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
149
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
150
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
151
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
152
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
153
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
154
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
155
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
156
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
157
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
158
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
159
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
160
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
161
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
162
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
163
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
164
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
165
 
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
166
 
     2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
167
 
     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
168
 
    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
169
 
    27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
170
 
    37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
171
 
    47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
172
 
    57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
173
 
    67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
174
 
    77
175
 
};
176
 
 
177
 
#if YYDEBUG != 0
178
 
static const short yyprhs[] = {     0,
179
 
     0,     1,     4,     6,     8,    11,    13,    16,    19,    23,
180
 
    27,    33,    39,    41,    43,    47,    55,    65,    67,    70,
181
 
    74,    78,    82,    84,    88,    90,    94,    96,   100,   104,
182
 
   108,   112,   116,   120,   122,   124,   128,   130,   134,   136,
183
 
   140,   142,   146,   150,   152,   156,   160,   162,   166,   170,
184
 
   174,   177,   180,   183,   186,   188,   193,   198,   202,   207,
185
 
   209,   213,   215,   219,   221,   224,   227,   230,   233,   235,
186
 
   238,   241,   243,   245,   247,   249,   251,   255,   259,   261,
187
 
   263,   265,   267,   269,   271,   273,   275,   278,   282,   285,
188
 
   289,   291,   294,   298,   300,   308,   314,   322,   324,   327,
189
 
   329,   332,   336,   339,   341,   345,   353,   362,   364,   368,
190
 
   371,   376,   379,   382,   383,   385,   387,   390,   393,   399,
191
 
   402,   406,   408,   414,   418,   420,   423,   433,   443,   448,
192
 
   451,   461,   466,   473,   481,   491,   492,   500,   503,   508
193
 
};
194
 
 
195
 
static const short yyrhs[] = {    -1,
196
 
    48,    87,     0,    79,     0,    80,     0,    80,    79,     0,
197
 
    36,     0,   116,    36,     0,   104,    36,     0,   108,    32,
198
 
    36,     0,    64,    20,    36,     0,    71,    20,    64,     7,
199
 
    36,     0,    71,    20,    64,    81,    36,     0,    82,     0,
200
 
    20,     0,    20,    12,    81,     0,    58,    36,    24,    36,
201
 
   111,    32,    36,     0,    58,    25,   109,    33,    36,    24,
202
 
    36,   111,    32,     0,    20,     0,    35,    20,     0,    85,
203
 
    48,    84,     0,    85,    72,    84,     0,    85,    73,    84,
204
 
     0,    85,     0,    86,    75,    85,     0,    86,     0,    87,
205
 
    74,    86,     0,    87,     0,    88,    16,    87,     0,    88,
206
 
    49,    87,     0,    88,    46,    87,     0,    88,    47,    87,
207
 
     0,    88,    27,    87,     0,    88,    19,    87,     0,    88,
208
 
     0,    89,     0,    88,    45,    89,     0,    90,     0,    89,
209
 
    10,    90,     0,    91,     0,    90,     6,    91,     0,    92,
210
 
     0,    91,    38,    92,     0,    91,    37,    92,     0,    93,
211
 
     0,    92,    31,    93,     0,    92,    28,    93,     0,    94,
212
 
     0,    93,     7,    94,     0,    93,    39,    94,     0,    93,
213
 
    30,    94,     0,    28,    95,     0,    31,    95,     0,    43,
214
 
    95,     0,    62,    95,     0,    95,     0,    95,    26,    84,
215
 
    34,     0,    95,    24,    84,    32,     0,    95,    25,    33,
216
 
     0,    95,    25,    96,    33,     0,    97,     0,    84,    12,
217
 
    96,     0,    84,     0,    95,    50,    20,     0,    98,     0,
218
 
    56,    99,     0,    57,    99,     0,    99,    56,     0,    99,
219
 
    57,     0,    99,     0,   100,    61,     0,   100,    60,     0,
220
 
   100,     0,    83,     0,   101,     0,     5,     0,     3,     0,
221
 
    27,    88,    19,     0,    25,    84,    33,     0,    23,     0,
222
 
    70,     0,    69,     0,    40,     0,     9,     0,    18,     0,
223
 
    44,     0,    17,     0,    26,    34,     0,    26,   102,    34,
224
 
     0,    24,    32,     0,    24,   103,    32,     0,     4,     0,
225
 
    76,    23,     0,    84,    12,   102,     0,    84,     0,    25,
226
 
    84,    12,    87,    33,    12,   103,     0,    25,    84,    12,
227
 
    87,    33,     0,    41,    20,    36,    24,    36,   105,    32,
228
 
     0,   106,     0,   106,   105,     0,    36,     0,   108,    32,
229
 
     0,    65,   107,    36,     0,   116,    36,     0,    20,     0,
230
 
    20,    12,   107,     0,    20,    25,    33,    36,    24,    36,
231
 
   111,     0,    20,    25,   109,    33,    36,    24,    36,   111,
232
 
     0,   110,     0,   110,    12,   109,     0,    21,    20,     0,
233
 
    21,    20,    48,    84,     0,    29,    20,     0,    22,    20,
234
 
     0,     0,   112,     0,   113,     0,   113,   112,     0,    84,
235
 
    36,     0,    68,    84,    12,    84,    36,     0,    63,    36,
236
 
     0,    63,    84,    36,     0,   117,     0,    67,    24,   112,
237
 
    32,   114,     0,    24,   112,    32,     0,   115,     0,   115,
238
 
   114,     0,    66,    25,    84,    12,    20,    33,    24,   112,
239
 
    32,     0,    14,    25,    20,    12,    20,    33,    24,   112,
240
 
    32,     0,    13,    20,    48,    87,     0,   119,   120,     0,
241
 
    54,    25,    84,    36,    84,    36,    84,    33,   120,     0,
242
 
    55,   120,   119,    36,     0,    52,    25,    84,    33,   120,
243
 
   118,     0,    59,    25,    20,    12,    84,    33,   120,     0,
244
 
    59,    25,    20,    12,    20,    12,    84,    33,   120,     0,
245
 
     0,    53,    52,    25,    84,    33,   120,   118,     0,    53,
246
 
   120,     0,    51,    25,    84,    33,     0,    24,   111,    32,
247
 
     0
248
 
};
249
 
 
250
 
#endif
251
 
 
252
 
#if YYDEBUG != 0
253
 
static const short yyrline[] = { 0,
254
 
   162,   166,   170,   177,   184,   208,   212,   216,   220,   224,
255
 
   229,   235,   241,   248,   252,   261,   267,   275,   280,   292,
256
 
   296,   300,   304,   311,   315,   322,   326,   333,   337,   341,
257
 
   345,   349,   353,   357,   365,   369,   377,   381,   389,   393,
258
 
   401,   405,   409,   417,   421,   425,   433,   437,   441,   445,
259
 
   453,   457,   461,   465,   469,   476,   480,   484,   488,   492,
260
 
   499,   504,   511,   516,   523,   527,   531,   536,   541,   548,
261
 
   553,   558,   566,   570,   574,   578,   583,   584,   593,   598,
262
 
   603,   608,   613,   618,   623,   628,   633,   637,   641,   645,
263
 
   649,   653,   661,   665,   672,   676,   686,   695,   702,   725,
264
 
   729,   733,   737,   744,   749,   757,   763,   771,   775,   782,
265
 
   787,   792,   797,   805,   809,   816,   820,   828,   832,   836,
266
 
   840,   844,   848,   852,   859,   863,   871,   877,   888,   896,
267
 
   900,   904,   908,   912,   917,   927,   931,   935,   942,   949
268
 
};
269
 
#endif
270
 
 
271
 
 
272
 
#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
273
 
 
274
 
static const char * const yytname[] = {   "$","error","$undefined.","T_MATCH_LINE",
275
 
"T_LINE","T_INPUT","T_AMPERSAND","T_ASTERISK","T_CASE","T_CHARACTER_LITERAL",
276
 
"T_CIRCUMFLEX","T_COLON","T_COMMA","T_CONST","T_DEFAULT","T_ENUM","T_EQUAL",
277
 
"T_FALSE","T_FLOATING_PT_LITERAL","T_GREATER_THAN_SIGN","T_IDENTIFIER","T_IN",
278
 
"T_INOUT","T_INTEGER_LITERAL","T_LEFT_CURLY_BRACKET","T_LEFT_PARANTHESIS","T_LEFT_SQUARE_BRACKET",
279
 
"T_LESS_THAN_SIGN","T_MINUS_SIGN","T_OUT","T_PERCENT_SIGN","T_PLUS_SIGN","T_RIGHT_CURLY_BRACKET",
280
 
"T_RIGHT_PARANTHESIS","T_RIGHT_SQUARE_BRACKET","T_SCOPE","T_SEMICOLON","T_SHIFTLEFT",
281
 
"T_SHIFTRIGHT","T_SOLIDUS","T_STRING_LITERAL","T_STRUCT","T_SWITCH","T_TILDE",
282
 
"T_TRUE","T_VERTICAL_LINE","T_LESS_OR_EQUAL","T_GREATER_OR_EQUAL","T_ASSIGN",
283
 
"T_NOTEQUAL","T_MEMBER","T_WHILE","T_IF","T_ELSE","T_FOR","T_DO","T_INCR","T_DECR",
284
 
"T_MAIN","T_FOREACH","T_SUBST","T_MATCH","T_NOT","T_RETURN","T_IMPORT","T_VAR",
285
 
"T_CATCH","T_TRY","T_RAISE","T_RANGE","T_CELL","T_FROM","T_PLUS_ASSIGN","T_MINUS_ASSIGN",
286
 
"T_AND","T_OR","T_DOLLAR","T_UNKNOWN","specification","definitions","definition",
287
 
"import_list","main","scoped_name","assign_expr","bool_or","bool_and","equal_expr",
288
 
"or_expr","xor_expr","and_expr","shift_expr","add_expr","mult_expr","unary_expr",
289
 
"index_expr","func_call_params","member_expr","incr_expr","match_expr","primary_expr",
290
 
"literal","array_elements","dict_elements","struct_dcl","struct_exports","struct_export",
291
 
"struct_members","func_dcl","func_params","func_param","func_body","func_lines",
292
 
"func_line","catches","single_catch","const_dcl","loops","else","while","loop_body", NULL
293
 
};
294
 
#endif
295
 
 
296
 
static const short yyr1[] = {     0,
297
 
    78,    78,    78,    79,    79,    80,    80,    80,    80,    80,
298
 
    80,    80,    80,    81,    81,    82,    82,    83,    83,    84,
299
 
    84,    84,    84,    85,    85,    86,    86,    87,    87,    87,
300
 
    87,    87,    87,    87,    88,    88,    89,    89,    90,    90,
301
 
    91,    91,    91,    92,    92,    92,    93,    93,    93,    93,
302
 
    94,    94,    94,    94,    94,    95,    95,    95,    95,    95,
303
 
    96,    96,    97,    97,    98,    98,    98,    98,    98,    99,
304
 
    99,    99,   100,   100,   100,   100,   100,   100,   101,   101,
305
 
   101,   101,   101,   101,   101,   101,   101,   101,   101,   101,
306
 
   101,   101,   102,   102,   103,   103,   104,   105,   105,   106,
307
 
   106,   106,   106,   107,   107,   108,   108,   109,   109,   110,
308
 
   110,   110,   110,   111,   111,   112,   112,   113,   113,   113,
309
 
   113,   113,   113,   113,   114,   114,   115,   115,   116,   117,
310
 
   117,   117,   117,   117,   117,   118,   118,   118,   119,   120
311
 
};
312
 
 
313
 
static const short yyr2[] = {     0,
314
 
     0,     2,     1,     1,     2,     1,     2,     2,     3,     3,
315
 
     5,     5,     1,     1,     3,     7,     9,     1,     2,     3,
316
 
     3,     3,     1,     3,     1,     3,     1,     3,     3,     3,
317
 
     3,     3,     3,     1,     1,     3,     1,     3,     1,     3,
318
 
     1,     3,     3,     1,     3,     3,     1,     3,     3,     3,
319
 
     2,     2,     2,     2,     1,     4,     4,     3,     4,     1,
320
 
     3,     1,     3,     1,     2,     2,     2,     2,     1,     2,
321
 
     2,     1,     1,     1,     1,     1,     3,     3,     1,     1,
322
 
     1,     1,     1,     1,     1,     1,     2,     3,     2,     3,
323
 
     1,     2,     3,     1,     7,     5,     7,     1,     2,     1,
324
 
     2,     3,     2,     1,     3,     7,     8,     1,     3,     2,
325
 
     4,     2,     2,     0,     1,     1,     2,     2,     5,     2,
326
 
     3,     1,     5,     3,     1,     2,     9,     9,     4,     2,
327
 
     9,     4,     6,     7,     9,     0,     7,     2,     4,     3
328
 
};
329
 
 
330
 
static const short yydefact[] = {     1,
331
 
     0,     0,     6,     0,     0,     0,     0,     0,     3,     4,
332
 
    13,     0,     0,     0,     0,     0,     0,    76,    91,    75,
333
 
    83,    86,    84,    18,    79,     0,     0,     0,     0,     0,
334
 
     0,     0,    82,     0,    85,     0,     0,     0,    81,    80,
335
 
     0,    73,     2,    34,    35,    37,    39,    41,    44,    47,
336
 
    55,    60,    64,    69,    72,    74,     0,     0,     0,     0,
337
 
     5,     8,     0,     7,     0,     0,     0,     0,     0,     0,
338
 
   108,     0,     0,    89,     0,     0,    23,    25,    27,    87,
339
 
    94,     0,     0,    51,    52,    19,    53,    65,    66,    54,
340
 
    92,     0,     0,     0,     0,     0,     0,     0,     0,     0,
341
 
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
342
 
     0,    67,    68,    71,    70,     0,     0,    10,     0,     9,
343
 
   129,   110,   113,   112,     0,     0,     0,     0,     0,    90,
344
 
    78,     0,     0,     0,     0,     0,     0,    88,    77,    28,
345
 
    33,    32,    36,    30,    31,    29,    38,    40,    43,    42,
346
 
    46,    45,    48,    50,    49,     0,    58,    62,     0,     0,
347
 
    63,     0,   114,     0,    14,     0,     0,     0,     0,   109,
348
 
     0,     0,    20,    21,    22,    24,    26,    93,    57,     0,
349
 
    59,    56,     0,     0,     0,     0,     0,     0,     0,     0,
350
 
     0,     0,     0,     0,   115,   116,   122,     0,    11,     0,
351
 
    12,   111,   114,     0,   100,     0,     0,    98,     0,     0,
352
 
     0,    61,     0,     0,     0,     0,     0,     0,   114,     0,
353
 
     0,   120,     0,     0,     0,   118,     0,   117,   130,    15,
354
 
   106,   114,   104,     0,    97,    99,   101,   103,    96,   114,
355
 
     0,   124,     0,     0,     0,     0,     0,     0,   121,     0,
356
 
     0,    16,   107,     0,   102,     0,     0,   139,     0,     0,
357
 
   140,   132,     0,     0,     0,   105,    95,    17,   136,     0,
358
 
    18,     0,     0,     0,   123,   125,   119,     0,   133,     0,
359
 
     0,     0,     0,     0,   126,     0,   138,     0,     0,   134,
360
 
     0,     0,     0,     0,     0,     0,     0,     0,   131,   135,
361
 
     0,     0,     0,     0,     0,   136,     0,     0,   137,     0,
362
 
     0,   128,   127,     0,     0,     0
363
 
};
364
 
 
365
 
static const short yydefgoto[] = {   314,
366
 
     9,    10,   166,    11,    42,   193,    77,    78,    79,    44,
367
 
    45,    46,    47,    48,    49,    50,    51,   159,    52,    53,
368
 
    54,    55,    56,    82,    75,    12,   207,   208,   234,    13,
369
 
    70,    71,   194,   195,   196,   275,   276,    14,   197,   279,
370
 
   198,   220
371
 
};
372
 
 
373
 
static const short yypact[] = {    72,
374
 
    30,     1,-32768,    37,   412,    13,    57,    67,-32768,    83,
375
 
-32768,   -13,    65,    68,    51,   100,    76,-32768,-32768,-32768,
376
 
-32768,-32768,-32768,-32768,-32768,    20,   412,   247,   412,   522,
377
 
   522,    94,-32768,   522,-32768,   550,   550,   522,-32768,-32768,
378
 
   102,-32768,-32768,   198,   118,   128,   111,   -11,     3,-32768,
379
 
    92,-32768,-32768,    81,    90,-32768,    47,   131,   116,    97,
380
 
-32768,-32768,   132,-32768,   412,   144,   152,   162,   147,   159,
381
 
   173,   170,   412,-32768,   154,   165,     6,   120,   125,-32768,
382
 
   188,   167,    -8,    92,    92,-32768,    92,-32768,-32768,    92,
383
 
-32768,   412,   412,   412,   412,   412,   412,   412,   412,   412,
384
 
   412,   412,   412,   412,   412,   412,   412,   412,   302,   412,
385
 
   182,-32768,-32768,-32768,-32768,   178,   177,-32768,    91,-32768,
386
 
-32768,   155,-32768,-32768,   194,   183,    47,   190,   215,-32768,
387
 
-32768,   412,   412,   412,   412,   412,   412,-32768,-32768,-32768,
388
 
-32768,-32768,   118,-32768,-32768,-32768,   128,   111,   -11,   -11,
389
 
     3,     3,-32768,-32768,-32768,   174,-32768,   216,   197,   200,
390
 
-32768,   195,   153,   196,   223,   201,   412,   202,   217,-32768,
391
 
     5,   412,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   412,
392
 
-32768,-32768,   218,     4,   214,   221,   224,   231,   233,   357,
393
 
   235,   412,   204,   228,-32768,   153,-32768,   231,-32768,   241,
394
 
-32768,-32768,   153,   212,-32768,   242,   236,     5,   237,   227,
395
 
   243,-32768,   244,   412,   245,   412,   412,   412,   153,   232,
396
 
   259,-32768,   248,   153,   273,-32768,   250,-32768,-32768,-32768,
397
 
-32768,   153,   276,   253,-32768,-32768,-32768,-32768,   280,   153,
398
 
     7,-32768,   260,   261,   262,   263,   264,   284,-32768,   265,
399
 
   412,-32768,-32768,   242,-32768,   274,   269,-32768,   231,   412,
400
 
-32768,-32768,   467,    -2,   266,-32768,-32768,-32768,   255,   277,
401
 
   298,   279,   289,   290,-32768,    -2,-32768,   -18,-32768,   412,
402
 
   412,   231,   301,   412,-32768,   293,-32768,   291,   299,-32768,
403
 
   319,   322,   412,   231,   231,   316,   318,   306,-32768,-32768,
404
 
   307,   308,   231,   320,   323,   255,   153,   153,-32768,   311,
405
 
   317,-32768,-32768,   348,   350,-32768
406
 
};
407
 
 
408
 
static const short yypgoto[] = {-32768,
409
 
   341,-32768,   156,-32768,-32768,   -27,   219,   229,    -3,   324,
410
 
   257,   256,   267,    58,    63,    39,   101,   189,-32768,-32768,
411
 
   138,-32768,-32768,   220,   107,-32768,   160,-32768,   119,  -157,
412
 
   -52,-32768,  -117,  -181,-32768,   103,-32768,  -155,-32768,    64,
413
 
   166,  -194
414
 
};
415
 
 
416
 
 
417
 
#define YYLAST          626
418
 
 
419
 
 
420
 
static const short yytable[] = {    76,
421
 
    81,    43,   215,   229,   116,   219,    18,    19,    20,   105,
422
 
   139,   273,    21,   209,   228,   210,   103,     1,   172,   104,
423
 
    22,    23,    62,    24,     2,    16,    25,   184,   214,    28,
424
 
    29,    30,   106,   286,    31,    74,    95,    57,    32,   131,
425
 
   205,   107,   250,    33,    73,   129,    34,    35,    58,    15,
426
 
   209,    74,   210,   132,   185,   186,    17,   187,   188,    36,
427
 
    37,   121,   189,   274,   269,    38,   190,    66,    67,   206,
428
 
   191,   192,    39,    40,   170,    68,    59,   133,   134,    41,
429
 
   156,   158,   160,   287,     1,   231,    60,   290,   140,   141,
430
 
   142,     2,   144,   145,   146,     1,    63,   164,    65,   299,
431
 
   300,   246,     2,    64,   173,   174,   175,     3,   306,    81,
432
 
   165,    72,     4,    86,   253,   108,   109,   110,     3,     5,
433
 
    66,    67,   257,     4,    91,   310,   311,    99,    68,     6,
434
 
    84,    85,    69,   100,    87,     7,   112,   113,    90,   202,
435
 
     6,   111,     8,   153,   154,   155,     7,   101,   102,   114,
436
 
   115,   118,   158,     8,   117,    18,    19,    20,   149,   150,
437
 
   119,    21,   223,   122,   225,   151,   152,   120,   211,    22,
438
 
    23,   123,    24,    88,    89,    25,   184,    27,    28,    29,
439
 
    30,   124,   125,    31,   127,   130,   241,    32,   243,   244,
440
 
   245,   126,    33,   128,   135,    34,    35,   131,   136,   137,
441
 
   138,   161,   167,   185,   186,   179,   187,   188,    36,    37,
442
 
   162,   189,   163,    92,    38,   190,    93,   168,   169,   191,
443
 
   192,    39,    40,   265,    94,   171,   172,   180,    41,   181,
444
 
   183,   199,   270,   182,   200,   272,   201,   203,   216,   226,
445
 
   204,   213,    95,    96,    97,   217,    98,   232,   218,    18,
446
 
    19,    20,   288,   289,   219,    21,   292,   221,   224,   227,
447
 
   165,   233,   238,    22,    23,   298,    24,   235,   237,    25,
448
 
    26,    27,    28,    29,    30,   239,   242,    31,   248,   240,
449
 
    80,    32,   185,   249,   251,   252,    33,   254,   255,    34,
450
 
    35,   256,   258,   259,   261,   263,   264,   260,    73,   262,
451
 
   268,   277,    36,    37,    18,    19,    20,   278,    38,   281,
452
 
    21,   282,   280,   283,   284,    39,    40,   293,    22,    23,
453
 
   291,    24,    41,   294,    25,    26,    27,    28,    29,    30,
454
 
   296,   295,    31,   297,   157,   301,    32,   302,   303,   304,
455
 
   305,    33,   312,   307,    34,    35,   308,   315,   313,   316,
456
 
    61,   143,    83,   176,   147,   230,   178,    36,    37,    18,
457
 
    19,    20,   267,    38,   177,    21,   148,   236,   212,   309,
458
 
    39,    40,   266,    22,    23,     0,    24,    41,   285,    25,
459
 
    26,    27,    28,    29,    30,   247,     0,    31,     0,     0,
460
 
     0,    32,   222,     0,     0,     0,    33,     0,     0,    34,
461
 
    35,     0,     0,     0,     0,     0,     0,     0,     0,     0,
462
 
     0,     0,    36,    37,    18,    19,    20,     0,    38,     0,
463
 
    21,     0,     0,     0,     0,    39,    40,     0,    22,    23,
464
 
     0,    24,    41,     0,    25,    26,    27,    28,    29,    30,
465
 
     0,     0,    31,     0,     0,     0,    32,     0,     0,     0,
466
 
     0,    33,     0,     0,    34,    35,     0,     0,     0,     0,
467
 
     0,     0,     0,     0,     0,     0,     0,    36,    37,    18,
468
 
    19,    20,     0,    38,     0,    21,     0,     0,     0,     0,
469
 
    39,    40,     0,    22,    23,     0,   271,    41,     0,    25,
470
 
    26,    27,    28,    29,    30,     0,     0,    31,     0,     0,
471
 
     0,    32,     0,     0,     0,     0,    33,     0,     0,    34,
472
 
    35,     0,     0,     0,     0,     0,     0,     0,     0,     0,
473
 
     0,     0,    36,    37,    18,    19,    20,     0,    38,     0,
474
 
    21,     0,     0,     0,     0,    39,    40,     0,    22,    23,
475
 
     0,    24,    41,     0,    25,    26,    27,    28,    29,     0,
476
 
     0,     0,    18,    19,    20,     0,    32,     0,    21,     0,
477
 
     0,    33,     0,     0,     0,    35,    22,    23,     0,    24,
478
 
     0,     0,    25,    26,    27,    28,    29,    36,    37,     0,
479
 
     0,     0,     0,     0,    32,     0,     0,     0,     0,    33,
480
 
    39,    40,     0,    35,     0,     0,     0,    41,     0,     0,
481
 
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
482
 
     0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
483
 
     0,     0,     0,     0,     0,    41
484
 
};
485
 
 
486
 
static const short yycheck[] = {    27,
487
 
    28,     5,   184,   198,    57,    24,     3,     4,     5,     7,
488
 
    19,    14,     9,   171,   196,   171,    28,    13,    12,    31,
489
 
    17,    18,    36,    20,    20,    25,    23,    24,    25,    26,
490
 
    27,    28,    30,    52,    31,    32,    45,    25,    35,    33,
491
 
    36,    39,   224,    40,    25,    73,    43,    44,    36,    20,
492
 
   208,    32,   208,    48,    51,    52,    20,    54,    55,    56,
493
 
    57,    65,    59,    66,   259,    62,    63,    21,    22,    65,
494
 
    67,    68,    69,    70,   127,    29,    20,    72,    73,    76,
495
 
   108,   109,   110,   278,    13,   203,    20,   282,    92,    93,
496
 
    94,    20,    96,    97,    98,    13,    32,     7,    48,   294,
497
 
   295,   219,    20,    36,   132,   133,   134,    36,   303,   137,
498
 
    20,    36,    41,    20,   232,    24,    25,    26,    36,    48,
499
 
    21,    22,   240,    41,    23,   307,   308,    10,    29,    58,
500
 
    30,    31,    33,     6,    34,    64,    56,    57,    38,   167,
501
 
    58,    50,    71,   105,   106,   107,    64,    37,    38,    60,
502
 
    61,    36,   180,    71,    24,     3,     4,     5,   101,   102,
503
 
    64,     9,   190,    20,   192,   103,   104,    36,   172,    17,
504
 
    18,    20,    20,    36,    37,    23,    24,    25,    26,    27,
505
 
    28,    20,    36,    31,    12,    32,   214,    35,   216,   217,
506
 
   218,    33,    40,    24,    75,    43,    44,    33,    74,    12,
507
 
    34,    20,    48,    51,    52,    32,    54,    55,    56,    57,
508
 
    33,    59,    36,    16,    62,    63,    19,    24,    36,    67,
509
 
    68,    69,    70,   251,    27,    36,    12,    12,    76,    33,
510
 
    36,    36,   260,    34,    12,   263,    36,    36,    25,    36,
511
 
    24,    24,    45,    46,    47,    25,    49,    36,    25,     3,
512
 
     4,     5,   280,   281,    24,     9,   284,    25,    24,    32,
513
 
    20,    20,    36,    17,    18,   293,    20,    32,    32,    23,
514
 
    24,    25,    26,    27,    28,    33,    32,    31,    20,    36,
515
 
    34,    35,    51,    36,    12,    36,    40,    12,    36,    43,
516
 
    44,    12,    33,    33,    32,    12,    32,    36,    25,    36,
517
 
    32,    36,    56,    57,     3,     4,     5,    53,    62,    12,
518
 
     9,    33,    36,    25,    25,    69,    70,    25,    17,    18,
519
 
    20,    20,    76,    33,    23,    24,    25,    26,    27,    28,
520
 
    12,    33,    31,    12,    33,    20,    35,    20,    33,    33,
521
 
    33,    40,    32,    24,    43,    44,    24,     0,    32,     0,
522
 
    10,    95,    29,   135,    99,   200,   137,    56,    57,     3,
523
 
     4,     5,   256,    62,   136,     9,   100,   208,   180,   306,
524
 
    69,    70,   254,    17,    18,    -1,    20,    76,   276,    23,
525
 
    24,    25,    26,    27,    28,   220,    -1,    31,    -1,    -1,
526
 
    -1,    35,    36,    -1,    -1,    -1,    40,    -1,    -1,    43,
527
 
    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
528
 
    -1,    -1,    56,    57,     3,     4,     5,    -1,    62,    -1,
529
 
     9,    -1,    -1,    -1,    -1,    69,    70,    -1,    17,    18,
530
 
    -1,    20,    76,    -1,    23,    24,    25,    26,    27,    28,
531
 
    -1,    -1,    31,    -1,    -1,    -1,    35,    -1,    -1,    -1,
532
 
    -1,    40,    -1,    -1,    43,    44,    -1,    -1,    -1,    -1,
533
 
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    56,    57,     3,
534
 
     4,     5,    -1,    62,    -1,     9,    -1,    -1,    -1,    -1,
535
 
    69,    70,    -1,    17,    18,    -1,    20,    76,    -1,    23,
536
 
    24,    25,    26,    27,    28,    -1,    -1,    31,    -1,    -1,
537
 
    -1,    35,    -1,    -1,    -1,    -1,    40,    -1,    -1,    43,
538
 
    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
539
 
    -1,    -1,    56,    57,     3,     4,     5,    -1,    62,    -1,
540
 
     9,    -1,    -1,    -1,    -1,    69,    70,    -1,    17,    18,
541
 
    -1,    20,    76,    -1,    23,    24,    25,    26,    27,    -1,
542
 
    -1,    -1,     3,     4,     5,    -1,    35,    -1,     9,    -1,
543
 
    -1,    40,    -1,    -1,    -1,    44,    17,    18,    -1,    20,
544
 
    -1,    -1,    23,    24,    25,    26,    27,    56,    57,    -1,
545
 
    -1,    -1,    -1,    -1,    35,    -1,    -1,    -1,    -1,    40,
546
 
    69,    70,    -1,    44,    -1,    -1,    -1,    76,    -1,    -1,
547
 
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
548
 
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    69,    70,
549
 
    -1,    -1,    -1,    -1,    -1,    76
 
134
/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
 
135
#define YYTRANSLATE(x) ((unsigned)(x) <= 331 ? yytranslate[x] : 122)
 
136
 
 
137
/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
 
138
static const char yytranslate[] =
 
139
{
 
140
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
141
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
142
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
143
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
144
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
145
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
146
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
147
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
148
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
149
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
150
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
151
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
152
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
153
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
154
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
155
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
156
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
157
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
158
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
159
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
160
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
161
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
162
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
163
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
164
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
165
       2,     2,     2,     2,     2,     2,     1,     3,     4,     5,
 
166
       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
 
167
      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
 
168
      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
 
169
      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
 
170
      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
 
171
      56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
 
172
      66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
 
173
      76,    77
 
174
};
 
175
 
 
176
#if YYDEBUG
 
177
static const short yyprhs[] =
 
178
{
 
179
       0,     0,     1,     2,     6,     8,    10,    13,    16,    19,
 
180
      22,    26,    32,    38,    40,    42,    46,    51,    59,    61,
 
181
      64,    68,    72,    76,    78,    82,    84,    88,    90,    94,
 
182
      98,   102,   106,   110,   114,   116,   118,   122,   124,   128,
 
183
     130,   134,   136,   140,   144,   146,   150,   154,   156,   160,
 
184
     164,   168,   171,   174,   177,   180,   182,   187,   192,   196,
 
185
     201,   203,   207,   209,   213,   215,   218,   221,   224,   227,
 
186
     229,   232,   235,   237,   239,   241,   243,   245,   249,   253,
 
187
     255,   257,   259,   261,   263,   265,   267,   269,   272,   276,
 
188
     279,   283,   285,   288,   292,   294,   302,   308,   314,   316,
 
189
     319,   322,   326,   329,   331,   335,   341,   348,   350,   354,
 
190
     357,   362,   365,   368,   369,   371,   373,   376,   379,   385,
 
191
     388,   392,   394,   400,   404,   406,   409,   419,   429,   434,
 
192
     437,   447,   452,   459,   467,   477,   478,   486,   489,   494
 
193
};
 
194
static const short yyrhs[] =
 
195
{
 
196
      -1,     0,    48,    79,    88,     0,    80,     0,    81,     0,
 
197
      81,    80,     0,   117,    36,     0,   105,    36,     0,   109,
 
198
      32,     0,    64,    20,    36,     0,    71,    20,    64,     7,
 
199
      36,     0,    71,    20,    64,    82,    36,     0,    83,     0,
 
200
      20,     0,    20,    12,    82,     0,    58,    24,   112,    32,
 
201
       0,    58,    25,   110,    33,    24,   112,    32,     0,    20,
 
202
       0,    35,    20,     0,    86,    48,    85,     0,    86,    72,
 
203
      85,     0,    86,    73,    85,     0,    86,     0,    87,    75,
 
204
      86,     0,    87,     0,    88,    74,    87,     0,    88,     0,
 
205
      89,    16,    88,     0,    89,    49,    88,     0,    89,    46,
 
206
      88,     0,    89,    47,    88,     0,    89,    27,    88,     0,
 
207
      89,    19,    88,     0,    89,     0,    90,     0,    89,    45,
 
208
      90,     0,    91,     0,    90,    10,    91,     0,    92,     0,
 
209
      91,     6,    92,     0,    93,     0,    92,    38,    93,     0,
 
210
      92,    37,    93,     0,    94,     0,    93,    31,    94,     0,
 
211
      93,    28,    94,     0,    95,     0,    94,     7,    95,     0,
 
212
      94,    39,    95,     0,    94,    30,    95,     0,    28,    96,
 
213
       0,    31,    96,     0,    43,    96,     0,    62,    96,     0,
 
214
      96,     0,    96,    26,    85,    34,     0,    96,    24,    85,
 
215
      32,     0,    96,    25,    33,     0,    96,    25,    97,    33,
 
216
       0,    98,     0,    85,    12,    97,     0,    85,     0,    96,
 
217
      50,    20,     0,    99,     0,    56,   100,     0,    57,   100,
 
218
       0,   100,    56,     0,   100,    57,     0,   100,     0,   101,
 
219
      61,     0,   101,    60,     0,   101,     0,    84,     0,   102,
 
220
       0,     5,     0,     3,     0,    27,    89,    19,     0,    25,
 
221
      85,    33,     0,    23,     0,    70,     0,    69,     0,    40,
 
222
       0,     9,     0,    18,     0,    44,     0,    17,     0,    26,
 
223
      34,     0,    26,   103,    34,     0,    24,    32,     0,    24,
 
224
     104,    32,     0,     4,     0,    76,    23,     0,    85,    12,
 
225
     103,     0,    85,     0,    25,    85,    12,    88,    33,    12,
 
226
     104,     0,    25,    85,    12,    88,    33,     0,    41,    20,
 
227
      24,   106,    32,     0,   107,     0,   107,   106,     0,   109,
 
228
      32,     0,    65,   108,    36,     0,   117,    36,     0,    20,
 
229
       0,    20,    12,   108,     0,    20,    25,    33,    24,   112,
 
230
       0,    20,    25,   110,    33,    24,   112,     0,   111,     0,
 
231
     111,    12,   110,     0,    21,    20,     0,    21,    20,    48,
 
232
      85,     0,    29,    20,     0,    22,    20,     0,     0,   113,
 
233
       0,   114,     0,   114,   113,     0,    85,    36,     0,    68,
 
234
      85,    12,    85,    36,     0,    63,    36,     0,    63,    85,
 
235
      36,     0,   118,     0,    67,    24,   113,    32,   115,     0,
 
236
      24,   113,    32,     0,   116,     0,   116,   115,     0,    66,
 
237
      25,    85,    12,    20,    33,    24,   113,    32,     0,    14,
 
238
      25,    20,    12,    20,    33,    24,   113,    32,     0,    13,
 
239
      20,    48,    88,     0,   120,   121,     0,    54,    25,    85,
 
240
      36,    85,    36,    85,    33,   121,     0,    55,   121,   120,
 
241
      36,     0,    52,    25,    85,    33,   121,   119,     0,    59,
 
242
      25,    20,    12,    85,    33,   121,     0,    59,    25,    20,
 
243
      12,    20,    12,    85,    33,   121,     0,     0,    53,    52,
 
244
      25,    85,    33,   121,   119,     0,    53,   121,     0,    51,
 
245
      25,    85,    33,     0,    24,   112,    32,     0
 
246
};
 
247
 
 
248
#endif
 
249
 
 
250
#if YYDEBUG
 
251
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
 
252
static const short yyrline[] =
 
253
{
 
254
       0,   181,   185,   185,   189,   196,   203,   227,   231,   235,
 
255
     239,   244,   250,   256,   263,   267,   276,   282,   291,   296,
 
256
     308,   312,   316,   320,   327,   331,   338,   342,   349,   353,
 
257
     357,   361,   365,   369,   373,   381,   385,   393,   397,   405,
 
258
     409,   417,   421,   425,   433,   437,   441,   449,   453,   457,
 
259
     461,   469,   473,   477,   481,   485,   492,   496,   500,   504,
 
260
     508,   515,   520,   527,   532,   539,   543,   547,   552,   557,
 
261
     564,   569,   574,   582,   586,   590,   594,   599,   600,   609,
 
262
     614,   619,   624,   629,   634,   639,   644,   649,   653,   657,
 
263
     661,   665,   669,   677,   681,   688,   692,   702,   711,   718,
 
264
     741,   745,   749,   756,   761,   769,   775,   783,   787,   794,
 
265
     799,   804,   809,   817,   821,   828,   832,   840,   844,   848,
 
266
     852,   856,   860,   864,   871,   875,   883,   889,   900,   908,
 
267
     912,   916,   920,   924,   929,   939,   943,   947,   954,   961
 
268
};
 
269
#endif
 
270
 
 
271
 
 
272
#if (YYDEBUG) || defined YYERROR_VERBOSE
 
273
 
 
274
/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
 
275
static const char *const yytname[] =
 
276
{
 
277
  "$", "error", "$undefined.", "T_MATCH_LINE", "T_LINE", "T_INPUT", 
 
278
  "T_AMPERSAND", "T_ASTERISK", "T_CASE", "T_CHARACTER_LITERAL", 
 
279
  "T_CIRCUMFLEX", "T_COLON", "T_COMMA", "T_CONST", "T_DEFAULT", "T_ENUM", 
 
280
  "T_EQUAL", "T_FALSE", "T_FLOATING_PT_LITERAL", "T_GREATER_THAN_SIGN", 
 
281
  "T_IDENTIFIER", "T_IN", "T_INOUT", "T_INTEGER_LITERAL", 
 
282
  "T_LEFT_CURLY_BRACKET", "T_LEFT_PARANTHESIS", "T_LEFT_SQUARE_BRACKET", 
 
283
  "T_LESS_THAN_SIGN", "T_MINUS_SIGN", "T_OUT", "T_PERCENT_SIGN", 
 
284
  "T_PLUS_SIGN", "T_RIGHT_CURLY_BRACKET", "T_RIGHT_PARANTHESIS", 
 
285
  "T_RIGHT_SQUARE_BRACKET", "T_SCOPE", "T_SEMICOLON", "T_SHIFTLEFT", 
 
286
  "T_SHIFTRIGHT", "T_SOLIDUS", "T_STRING_LITERAL", "T_STRUCT", "T_SWITCH", 
 
287
  "T_TILDE", "T_TRUE", "T_VERTICAL_LINE", "T_LESS_OR_EQUAL", 
 
288
  "T_GREATER_OR_EQUAL", "T_ASSIGN", "T_NOTEQUAL", "T_MEMBER", "T_WHILE", 
 
289
  "T_IF", "T_ELSE", "T_FOR", "T_DO", "T_INCR", "T_DECR", "T_MAIN", 
 
290
  "T_FOREACH", "T_SUBST", "T_MATCH", "T_NOT", "T_RETURN", "T_IMPORT", 
 
291
  "T_VAR", "T_CATCH", "T_TRY", "T_RAISE", "T_RANGE", "T_CELL", "T_FROM", 
 
292
  "T_PLUS_ASSIGN", "T_MINUS_ASSIGN", "T_AND", "T_OR", "T_DOLLAR", 
 
293
  "T_UNKNOWN", "specification", "@1", "definitions", "definition", 
 
294
  "import_list", "main", "scoped_name", "assign_expr", "bool_or", 
 
295
  "bool_and", "equal_expr", "or_expr", "xor_expr", "and_expr", 
 
296
  "shift_expr", "add_expr", "mult_expr", "unary_expr", "index_expr", 
 
297
  "func_call_params", "member_expr", "incr_expr", "match_expr", 
 
298
  "primary_expr", "literal", "array_elements", "dict_elements", 
 
299
  "struct_dcl", "struct_exports", "struct_export", "struct_members", 
 
300
  "func_dcl", "func_params", "func_param", "func_body", "func_lines", 
 
301
  "func_line", "catches", "single_catch", "const_dcl", "loops", "else", 
 
302
  "while", "loop_body", 0
 
303
};
 
304
#endif
 
305
 
 
306
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
 
307
static const short yyr1[] =
 
308
{
 
309
       0,    78,    79,    78,    78,    80,    80,    81,    81,    81,
 
310
      81,    81,    81,    81,    82,    82,    83,    83,    84,    84,
 
311
      85,    85,    85,    85,    86,    86,    87,    87,    88,    88,
 
312
      88,    88,    88,    88,    88,    89,    89,    90,    90,    91,
 
313
      91,    92,    92,    92,    93,    93,    93,    94,    94,    94,
 
314
      94,    95,    95,    95,    95,    95,    96,    96,    96,    96,
 
315
      96,    97,    97,    98,    98,    99,    99,    99,    99,    99,
 
316
     100,   100,   100,   101,   101,   101,   101,   101,   101,   102,
 
317
     102,   102,   102,   102,   102,   102,   102,   102,   102,   102,
 
318
     102,   102,   102,   103,   103,   104,   104,   105,   106,   106,
 
319
     107,   107,   107,   108,   108,   109,   109,   110,   110,   111,
 
320
     111,   111,   111,   112,   112,   113,   113,   114,   114,   114,
 
321
     114,   114,   114,   114,   115,   115,   116,   116,   117,   118,
 
322
     118,   118,   118,   118,   118,   119,   119,   119,   120,   121
 
323
};
 
324
 
 
325
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
 
326
static const short yyr2[] =
 
327
{
 
328
       0,     0,     0,     3,     1,     1,     2,     2,     2,     2,
 
329
       3,     5,     5,     1,     1,     3,     4,     7,     1,     2,
 
330
       3,     3,     3,     1,     3,     1,     3,     1,     3,     3,
 
331
       3,     3,     3,     3,     1,     1,     3,     1,     3,     1,
 
332
       3,     1,     3,     3,     1,     3,     3,     1,     3,     3,
 
333
       3,     2,     2,     2,     2,     1,     4,     4,     3,     4,
 
334
       1,     3,     1,     3,     1,     2,     2,     2,     2,     1,
 
335
       2,     2,     1,     1,     1,     1,     1,     3,     3,     1,
 
336
       1,     1,     1,     1,     1,     1,     1,     2,     3,     2,
 
337
       3,     1,     2,     3,     1,     7,     5,     5,     1,     2,
 
338
       2,     3,     2,     1,     3,     5,     6,     1,     3,     2,
 
339
       4,     2,     2,     0,     1,     1,     2,     2,     5,     2,
 
340
       3,     1,     5,     3,     1,     2,     9,     9,     4,     2,
 
341
       9,     4,     6,     7,     9,     0,     7,     2,     4,     3
 
342
};
 
343
 
 
344
/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 
345
   doesn't specify something else to do.  Zero means the default is an
 
346
   error. */
 
347
static const short yydefact[] =
 
348
{
 
349
       1,     0,     0,     0,     2,     0,     0,     0,     4,     5,
 
350
      13,     0,     0,     0,     0,     0,     0,     0,   113,     0,
 
351
       0,     0,     6,     8,     9,     7,     0,     0,     0,     0,
 
352
       0,     0,   107,     0,    76,    91,    75,    83,    86,    84,
 
353
      18,    79,     0,     0,     0,     0,     0,     0,     0,    82,
 
354
       0,    85,     0,     0,     0,    81,    80,     0,    73,     3,
 
355
      34,    35,    37,    39,    41,    44,    47,    55,    60,    64,
 
356
      69,    72,    74,     0,     0,     0,     0,     0,     0,     0,
 
357
       0,     0,     0,    23,    25,    27,     0,   114,   115,   121,
 
358
       0,     0,    10,     0,   128,   109,   112,   111,   113,     0,
 
359
       0,     0,     0,    98,     0,     0,     0,    89,     0,     0,
 
360
      87,    94,     0,     0,    51,    52,    19,    53,    65,    66,
 
361
      54,    92,     0,     0,     0,     0,     0,     0,     0,     0,
 
362
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 
363
       0,     0,    67,    68,    71,    70,     0,     0,     0,     0,
 
364
       0,   113,     0,     0,   119,     0,     0,     0,   117,     0,
 
365
       0,     0,     0,     0,    16,   116,   129,     0,     0,    14,
 
366
       0,     0,   105,   113,   108,   103,     0,    97,    99,   100,
 
367
     102,     0,    90,    78,     0,    88,    77,    28,    33,    32,
 
368
      36,    30,    31,    29,    38,    40,    43,    42,    46,    45,
 
369
      48,    50,    49,     0,    58,    62,     0,     0,    63,     0,
 
370
     123,     0,     0,     0,     0,     0,     0,   120,     0,     0,
 
371
      20,    21,    22,    24,    26,   113,    11,     0,    12,   110,
 
372
     106,     0,   101,     0,    93,    57,     0,    59,    56,   138,
 
373
       0,     0,   139,   131,     0,     0,     0,     0,    15,   104,
 
374
       0,    61,   135,     0,    18,     0,     0,     0,   122,   124,
 
375
     118,    17,    96,     0,   132,     0,     0,     0,     0,     0,
 
376
     125,     0,     0,   137,     0,     0,   133,     0,     0,    95,
 
377
       0,     0,     0,     0,     0,     0,   130,   134,     0,     0,
 
378
       0,     0,     0,   135,     0,     0,   136,     0,     0,   127,
 
379
     126,     0,     0,     0
 
380
};
 
381
 
 
382
static const short yydefgoto[] =
 
383
{
 
384
     301,    17,     8,     9,   170,    10,    58,    82,    83,    84,
 
385
      85,    60,    61,    62,    63,    64,    65,    66,    67,   206,
 
386
      68,    69,    70,    71,    72,   112,   108,    11,   102,   103,
 
387
     176,    12,    31,    32,    86,    87,    88,   258,   259,    13,
 
388
      89,   264,    90,   152
 
389
};
 
390
 
 
391
static const short yypact[] =
 
392
{
 
393
      -4,    21,    -5,    39,-32768,    47,    41,    65,-32768,    10,
 
394
  -32768,    -3,    55,    53,    46,   141,    78,   470,   292,   103,
 
395
      68,    44,-32768,-32768,-32768,-32768,   470,    92,   102,   111,
 
396
     109,   116,   123,    -1,-32768,-32768,-32768,-32768,-32768,-32768,
 
397
  -32768,-32768,   -10,   470,    22,   470,   133,   133,   132,-32768,
 
398
     133,-32768,   580,   580,   133,-32768,-32768,   131,-32768,-32768,
 
399
      74,   151,   169,    -9,    42,     4,-32768,   119,-32768,-32768,
 
400
      26,    79,-32768,   224,   154,   155,   156,   159,   160,   360,
 
401
     162,   470,   148,    27,   112,   117,   163,-32768,   292,-32768,
 
402
     159,   161,-32768,     1,-32768,   140,-32768,-32768,   292,   168,
 
403
     103,   179,   172,    -1,   174,   164,   470,-32768,   175,   177,
 
404
  -32768,   196,   178,    13,   119,   119,-32768,   119,-32768,-32768,
 
405
     119,-32768,   470,   470,   470,   470,   470,   470,   470,   470,
 
406
     470,   470,   470,   470,   470,   470,   470,   470,   470,   415,
 
407
     470,   191,-32768,-32768,-32768,-32768,   470,   181,   470,   470,
 
408
     470,   292,   165,   194,-32768,   182,   292,   203,-32768,   470,
 
409
     470,   470,   470,   470,-32768,-32768,-32768,   193,   183,   209,
 
410
     195,   470,-32768,   292,-32768,   218,   198,-32768,-32768,-32768,
 
411
  -32768,   220,-32768,-32768,   470,-32768,-32768,-32768,-32768,-32768,
 
412
     151,-32768,-32768,-32768,   169,    -9,    42,    42,     4,     4,
 
413
  -32768,-32768,-32768,   204,-32768,   223,   205,   206,-32768,     2,
 
414
  -32768,   210,   212,   217,   207,   221,   234,-32768,   222,   470,
 
415
  -32768,-32768,-32768,-32768,-32768,   292,-32768,   238,-32768,-32768,
 
416
  -32768,   179,-32768,   470,-32768,-32768,   470,-32768,-32768,-32768,
 
417
     159,   470,-32768,-32768,   525,     3,   225,   228,-32768,-32768,
 
418
     229,-32768,   213,   227,   253,   236,   245,   246,-32768,     3,
 
419
  -32768,-32768,   260,     0,-32768,   470,   470,   159,   254,   470,
 
420
  -32768,   248,   252,-32768,   249,   251,-32768,   273,   276,-32768,
 
421
     470,   159,   159,   269,   270,   265,-32768,-32768,   266,   271,
 
422
     159,   278,   279,   213,   292,   292,-32768,   274,   275,-32768,
 
423
  -32768,   305,   308,-32768
 
424
};
 
425
 
 
426
static const short yypgoto[] =
 
427
{
 
428
  -32768,-32768,   302,-32768,    86,-32768,-32768,   -43,   152,   158,
 
429
     -13,   277,   199,   197,   200,    33,    38,    11,    80,    89,
 
430
  -32768,-32768,   114,-32768,-32768,   144,    58,-32768,   230,-32768,
 
431
     100,   -27,   -12,-32768,   -96,   -70,-32768,    75,-32768,   -23,
 
432
  -32768,    45,   185,   -85
 
433
};
 
434
 
 
435
 
 
436
#define YYLAST          656
 
437
 
 
438
 
 
439
static const short yytable[] =
 
440
{
 
441
     109,   111,   172,   147,    59,   166,   104,    91,   168,     1,
 
442
     105,   135,     1,    94,   233,   106,     2,   256,   165,     2,
 
443
      15,   169,   107,     1,   151,    34,    35,    36,   131,   132,
 
444
       2,    37,   186,    23,   136,   183,   155,     3,   157,    38,
 
445
      39,    14,    40,   137,     4,    41,    42,    43,    44,    45,
 
446
      46,     3,   272,    47,     5,   214,   110,    48,   125,    16,
 
447
       6,    20,    49,   181,   101,    50,    51,     7,     5,   257,
 
448
     133,    18,    19,   134,     6,   159,   104,   230,    52,    53,
 
449
     105,     7,   142,   143,    54,    21,   218,    24,   174,    25,
 
450
     122,    55,    56,   123,    26,   203,   205,   207,    57,   160,
 
451
     161,   124,    33,   209,    92,   211,   212,   213,    93,   187,
 
452
     188,   189,    95,   191,   192,   193,   220,   221,   222,   125,
 
453
     126,   127,    96,   128,    27,    28,   114,   115,   229,   247,
 
454
     117,    97,    29,    98,   120,   100,    34,    35,    36,   144,
 
455
     145,   111,    37,   138,   139,   140,   200,   201,   202,    99,
 
456
      38,    39,   116,    40,   121,   252,    41,    42,    43,    44,
 
457
      45,   129,    27,    28,   196,   197,   118,   119,    48,   141,
 
458
      29,   198,   199,    49,    30,   130,   246,    51,   273,   148,
 
459
     149,   150,   276,   151,   158,   153,   156,   162,   171,    52,
 
460
      53,   163,   173,   205,   167,   164,   286,   287,   253,   175,
 
461
     180,   255,    55,    56,   177,   293,   179,   182,   184,    57,
 
462
     183,   208,   185,   210,   216,   219,    74,   225,   217,   226,
 
463
     250,   227,   274,   275,   297,   298,   278,    34,    35,    36,
 
464
     231,   228,   233,    37,   232,   236,   235,   285,   237,   242,
 
465
     238,    38,    39,   239,    40,   240,   244,    41,    73,   146,
 
466
      44,    45,    46,   241,   245,    47,   107,   243,   169,    48,
 
467
     261,   260,   262,   265,    49,   266,   263,    50,    51,   267,
 
468
     268,   269,   271,   106,   277,    74,    75,   280,    76,    77,
 
469
      52,    53,   281,    78,   282,   283,    54,    79,   284,   288,
 
470
     289,    80,    81,    55,    56,    34,    35,    36,   290,   291,
 
471
      57,    37,   294,   295,   292,   302,   299,   300,   303,    38,
 
472
      39,    22,    40,   248,   223,    41,    73,    43,    44,    45,
 
473
      46,   224,   113,    47,   190,   251,   194,    48,   234,   279,
 
474
     195,   249,    49,   178,   270,    50,    51,   215,   296,     0,
 
475
       0,     0,     0,    74,    75,     0,    76,    77,    52,    53,
 
476
       0,    78,     0,     0,    54,    79,     0,     0,     0,    80,
 
477
      81,    55,    56,    34,    35,    36,     0,     0,    57,    37,
 
478
       0,     0,     0,     0,     0,     0,     0,    38,    39,     0,
 
479
      40,     0,     0,    41,    42,    43,    44,    45,    46,     0,
 
480
       0,    47,     0,     0,     0,    48,   154,     0,     0,     0,
 
481
      49,     0,     0,    50,    51,     0,     0,     0,     0,     0,
 
482
       0,     0,     0,     0,     0,     0,    52,    53,    34,    35,
 
483
      36,     0,    54,     0,    37,     0,     0,     0,     0,    55,
 
484
      56,     0,    38,    39,     0,    40,    57,     0,    41,    42,
 
485
      43,    44,    45,    46,     0,     0,    47,     0,   204,     0,
 
486
      48,     0,     0,     0,     0,    49,     0,     0,    50,    51,
 
487
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 
488
       0,    52,    53,    34,    35,    36,     0,    54,     0,    37,
 
489
       0,     0,     0,     0,    55,    56,     0,    38,    39,     0,
 
490
      40,    57,     0,    41,    42,    43,    44,    45,    46,     0,
 
491
       0,    47,     0,     0,     0,    48,     0,     0,     0,     0,
 
492
      49,     0,     0,    50,    51,     0,     0,     0,     0,     0,
 
493
       0,     0,     0,     0,     0,     0,    52,    53,    34,    35,
 
494
      36,     0,    54,     0,    37,     0,     0,     0,     0,    55,
 
495
      56,     0,    38,    39,     0,   254,    57,     0,    41,    42,
 
496
      43,    44,    45,    46,     0,     0,    47,     0,     0,     0,
 
497
      48,     0,     0,     0,     0,    49,     0,     0,    50,    51,
 
498
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 
499
       0,    52,    53,    34,    35,    36,     0,    54,     0,    37,
 
500
       0,     0,     0,     0,    55,    56,     0,    38,    39,     0,
 
501
      40,    57,     0,    41,    42,    43,    44,    45,     0,     0,
 
502
       0,     0,     0,     0,     0,    48,     0,     0,     0,     0,
 
503
      49,     0,     0,     0,    51,     0,     0,     0,     0,     0,
 
504
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 
505
       0,     0,     0,     0,     0,     0,     0,     0,     0,    55,
 
506
      56,     0,     0,     0,     0,     0,    57
 
507
};
 
508
 
 
509
static const short yycheck[] =
 
510
{
 
511
      43,    44,    98,    73,    17,    90,    33,    19,     7,    13,
 
512
      33,     7,    13,    26,    12,    25,    20,    14,    88,    20,
 
513
      25,    20,    32,    13,    24,     3,     4,     5,    37,    38,
 
514
      20,     9,    19,    36,    30,    33,    79,    41,    81,    17,
 
515
      18,    20,    20,    39,    48,    23,    24,    25,    26,    27,
 
516
      28,    41,    52,    31,    58,   151,    34,    35,    45,    20,
 
517
      64,    20,    40,   106,    65,    43,    44,    71,    58,    66,
 
518
      28,    24,    25,    31,    64,    48,   103,   173,    56,    57,
 
519
     103,    71,    56,    57,    62,    20,   156,    32,   100,    36,
 
520
      16,    69,    70,    19,    48,   138,   139,   140,    76,    72,
 
521
      73,    27,    24,   146,    36,   148,   149,   150,    64,   122,
 
522
     123,   124,    20,   126,   127,   128,   159,   160,   161,    45,
 
523
      46,    47,    20,    49,    21,    22,    46,    47,   171,   225,
 
524
      50,    20,    29,    24,    54,    12,     3,     4,     5,    60,
 
525
      61,   184,     9,    24,    25,    26,   135,   136,   137,    33,
 
526
      17,    18,    20,    20,    23,   240,    23,    24,    25,    26,
 
527
      27,    10,    21,    22,   131,   132,    52,    53,    35,    50,
 
528
      29,   133,   134,    40,    33,     6,   219,    44,   263,    25,
 
529
      25,    25,   267,    24,    36,    25,    24,    75,    48,    56,
 
530
      57,    74,    24,   236,    33,    32,   281,   282,   241,    20,
 
531
      36,   244,    69,    70,    32,   290,    32,    32,    12,    76,
 
532
      33,    20,    34,    32,    20,    12,    51,    24,    36,    36,
 
533
     233,    12,   265,   266,   294,   295,   269,     3,     4,     5,
 
534
      12,    36,    12,     9,    36,    12,    32,   280,    33,    32,
 
535
      34,    17,    18,    33,    20,    33,    12,    23,    24,    25,
 
536
      26,    27,    28,    36,    32,    31,    32,    36,    20,    35,
 
537
      32,    36,    33,    36,    40,    12,    53,    43,    44,    33,
 
538
      25,    25,    12,    25,    20,    51,    52,    25,    54,    55,
 
539
      56,    57,    33,    59,    33,    12,    62,    63,    12,    20,
 
540
      20,    67,    68,    69,    70,     3,     4,     5,    33,    33,
 
541
      76,     9,    24,    24,    33,     0,    32,    32,     0,    17,
 
542
      18,     9,    20,   227,   162,    23,    24,    25,    26,    27,
 
543
      28,   163,    45,    31,   125,   236,   129,    35,   184,   271,
 
544
     130,   231,    40,   103,   259,    43,    44,   152,   293,    -1,
 
545
      -1,    -1,    -1,    51,    52,    -1,    54,    55,    56,    57,
 
546
      -1,    59,    -1,    -1,    62,    63,    -1,    -1,    -1,    67,
 
547
      68,    69,    70,     3,     4,     5,    -1,    -1,    76,     9,
 
548
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    17,    18,    -1,
 
549
      20,    -1,    -1,    23,    24,    25,    26,    27,    28,    -1,
 
550
      -1,    31,    -1,    -1,    -1,    35,    36,    -1,    -1,    -1,
 
551
      40,    -1,    -1,    43,    44,    -1,    -1,    -1,    -1,    -1,
 
552
      -1,    -1,    -1,    -1,    -1,    -1,    56,    57,     3,     4,
 
553
       5,    -1,    62,    -1,     9,    -1,    -1,    -1,    -1,    69,
 
554
      70,    -1,    17,    18,    -1,    20,    76,    -1,    23,    24,
 
555
      25,    26,    27,    28,    -1,    -1,    31,    -1,    33,    -1,
 
556
      35,    -1,    -1,    -1,    -1,    40,    -1,    -1,    43,    44,
 
557
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 
558
      -1,    56,    57,     3,     4,     5,    -1,    62,    -1,     9,
 
559
      -1,    -1,    -1,    -1,    69,    70,    -1,    17,    18,    -1,
 
560
      20,    76,    -1,    23,    24,    25,    26,    27,    28,    -1,
 
561
      -1,    31,    -1,    -1,    -1,    35,    -1,    -1,    -1,    -1,
 
562
      40,    -1,    -1,    43,    44,    -1,    -1,    -1,    -1,    -1,
 
563
      -1,    -1,    -1,    -1,    -1,    -1,    56,    57,     3,     4,
 
564
       5,    -1,    62,    -1,     9,    -1,    -1,    -1,    -1,    69,
 
565
      70,    -1,    17,    18,    -1,    20,    76,    -1,    23,    24,
 
566
      25,    26,    27,    28,    -1,    -1,    31,    -1,    -1,    -1,
 
567
      35,    -1,    -1,    -1,    -1,    40,    -1,    -1,    43,    44,
 
568
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 
569
      -1,    56,    57,     3,     4,     5,    -1,    62,    -1,     9,
 
570
      -1,    -1,    -1,    -1,    69,    70,    -1,    17,    18,    -1,
 
571
      20,    76,    -1,    23,    24,    25,    26,    27,    -1,    -1,
 
572
      -1,    -1,    -1,    -1,    -1,    35,    -1,    -1,    -1,    -1,
 
573
      40,    -1,    -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,
 
574
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 
575
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    69,
 
576
      70,    -1,    -1,    -1,    -1,    -1,    76
550
577
};
551
578
/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
552
 
#line 3 "//usr/lib/bison.simple"
553
 
/* This file comes from bison-1.28.  */
 
579
#line 3 "/usr/share/bison/bison.simple"
554
580
 
555
581
/* Skeleton output parser for bison,
556
 
   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 
582
 
 
583
   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
 
584
   Foundation, Inc.
557
585
 
558
586
   This program is free software; you can redistribute it and/or modify
559
587
   it under the terms of the GNU General Public License as published by
575
603
   This special exception was added by the Free Software Foundation
576
604
   in version 1.24 of Bison.  */
577
605
 
578
 
/* This is the parser code that is written into each bison parser
579
 
  when the %semantic_parser declaration is not specified in the grammar.
580
 
  It was written by Richard Stallman by simplifying the hairy parser
581
 
  used when %semantic_parser is specified.  */
582
 
 
583
 
#ifndef YYSTACK_USE_ALLOCA
584
 
#ifdef alloca
585
 
#define YYSTACK_USE_ALLOCA
586
 
#else /* alloca not defined */
587
 
#ifdef __GNUC__
588
 
#define YYSTACK_USE_ALLOCA
589
 
#define alloca __builtin_alloca
590
 
#else /* not GNU C.  */
591
 
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
592
 
#define YYSTACK_USE_ALLOCA
593
 
#include <alloca.h>
594
 
#else /* not sparc */
595
 
/* We think this test detects Watcom and Microsoft C.  */
596
 
/* This used to test MSDOS, but that is a bad idea
597
 
   since that symbol is in the user namespace.  */
598
 
#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
599
 
#if 0 /* No need for malloc.h, which pollutes the namespace;
600
 
         instead, just don't use alloca.  */
601
 
#include <malloc.h>
602
 
#endif
603
 
#else /* not MSDOS, or __TURBOC__ */
604
 
#if defined(_AIX)
605
 
/* I don't know what this was needed for, but it pollutes the namespace.
606
 
   So I turned it off.   rms, 2 May 1997.  */
607
 
/* #include <malloc.h>  */
608
 
 #pragma alloca
609
 
#define YYSTACK_USE_ALLOCA
610
 
#else /* not MSDOS, or __TURBOC__, or _AIX */
611
 
#if 0
612
 
#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
613
 
                 and on HPUX 10.  Eventually we can turn this on.  */
614
 
#define YYSTACK_USE_ALLOCA
615
 
#define alloca __builtin_alloca
616
 
#endif /* __hpux */
617
 
#endif
618
 
#endif /* not _AIX */
619
 
#endif /* not MSDOS, or __TURBOC__ */
620
 
#endif /* not sparc */
621
 
#endif /* not GNU C */
622
 
#endif /* alloca not defined */
623
 
#endif /* YYSTACK_USE_ALLOCA not defined */
624
 
 
625
 
#ifdef YYSTACK_USE_ALLOCA
626
 
#define YYSTACK_ALLOC alloca
627
 
#else
628
 
#define YYSTACK_ALLOC malloc
629
 
#endif
630
 
 
631
 
/* Note: there must be only one dollar sign in this file.
632
 
   It is replaced by the list of actions, each action
633
 
   as one case of the switch.  */
 
606
/* This is the parser code that is written into each bison parser when
 
607
   the %semantic_parser declaration is not specified in the grammar.
 
608
   It was written by Richard Stallman by simplifying the hairy parser
 
609
   used when %semantic_parser is specified.  */
 
610
 
 
611
/* All symbols defined below should begin with yy or YY, to avoid
 
612
   infringing on user name space.  This should be done even for local
 
613
   variables, as they might otherwise be expanded by user macros.
 
614
   There are some unavoidable exceptions within include files to
 
615
   define necessary library symbols; they are noted "INFRINGES ON
 
616
   USER NAME SPACE" below.  */
 
617
 
 
618
#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
 
619
 
 
620
/* The parser invokes alloca or malloc; define the necessary symbols.  */
 
621
 
 
622
# if YYSTACK_USE_ALLOCA
 
623
#  define YYSTACK_ALLOC alloca
 
624
# else
 
625
#  ifndef YYSTACK_USE_ALLOCA
 
626
#   if defined (alloca) || defined (_ALLOCA_H)
 
627
#    define YYSTACK_ALLOC alloca
 
628
#   else
 
629
#    ifdef __GNUC__
 
630
#     define YYSTACK_ALLOC __builtin_alloca
 
631
#    endif
 
632
#   endif
 
633
#  endif
 
634
# endif
 
635
 
 
636
# ifdef YYSTACK_ALLOC
 
637
   /* Pacify GCC's `empty if-body' warning. */
 
638
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 
639
# else
 
640
#  if defined (__STDC__) || defined (__cplusplus)
 
641
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 
642
#   define YYSIZE_T size_t
 
643
#  endif
 
644
#  define YYSTACK_ALLOC malloc
 
645
#  define YYSTACK_FREE free
 
646
# endif
 
647
#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
 
648
 
 
649
 
 
650
#if (! defined (yyoverflow) \
 
651
     && (! defined (__cplusplus) \
 
652
         || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
653
 
 
654
/* A type that is properly aligned for any stack member.  */
 
655
union yyalloc
 
656
{
 
657
  short yyss;
 
658
  YYSTYPE yyvs;
 
659
# if YYLSP_NEEDED
 
660
  YYLTYPE yyls;
 
661
# endif
 
662
};
 
663
 
 
664
/* The size of the maximum gap between one aligned stack and the next.  */
 
665
# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 
666
 
 
667
/* The size of an array large to enough to hold all stacks, each with
 
668
   N elements.  */
 
669
# if YYLSP_NEEDED
 
670
#  define YYSTACK_BYTES(N) \
 
671
     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
 
672
      + 2 * YYSTACK_GAP_MAX)
 
673
# else
 
674
#  define YYSTACK_BYTES(N) \
 
675
     ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
 
676
      + YYSTACK_GAP_MAX)
 
677
# endif
 
678
 
 
679
/* Copy COUNT objects from FROM to TO.  The source and destination do
 
680
   not overlap.  */
 
681
# ifndef YYCOPY
 
682
#  if 1 < __GNUC__
 
683
#   define YYCOPY(To, From, Count) \
 
684
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 
685
#  else
 
686
#   define YYCOPY(To, From, Count)              \
 
687
      do                                        \
 
688
        {                                       \
 
689
          register YYSIZE_T yyi;                \
 
690
          for (yyi = 0; yyi < (Count); yyi++)   \
 
691
            (To)[yyi] = (From)[yyi];            \
 
692
        }                                       \
 
693
      while (0)
 
694
#  endif
 
695
# endif
 
696
 
 
697
/* Relocate STACK from its old location to the new one.  The
 
698
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
 
699
   elements in the stack, and YYPTR gives the new location of the
 
700
   stack.  Advance YYPTR to a properly aligned location for the next
 
701
   stack.  */
 
702
# define YYSTACK_RELOCATE(Stack)                                        \
 
703
    do                                                                  \
 
704
      {                                                                 \
 
705
        YYSIZE_T yynewbytes;                                            \
 
706
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 
707
        Stack = &yyptr->Stack;                                          \
 
708
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
 
709
        yyptr += yynewbytes / sizeof (*yyptr);                          \
 
710
      }                                                                 \
 
711
    while (0)
 
712
 
 
713
#endif
 
714
 
 
715
 
 
716
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 
717
# define YYSIZE_T __SIZE_TYPE__
 
718
#endif
 
719
#if ! defined (YYSIZE_T) && defined (size_t)
 
720
# define YYSIZE_T size_t
 
721
#endif
 
722
#if ! defined (YYSIZE_T)
 
723
# if defined (__STDC__) || defined (__cplusplus)
 
724
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 
725
#  define YYSIZE_T size_t
 
726
# endif
 
727
#endif
 
728
#if ! defined (YYSIZE_T)
 
729
# define YYSIZE_T unsigned int
 
730
#endif
634
731
 
635
732
#define yyerrok         (yyerrstatus = 0)
636
733
#define yyclearin       (yychar = YYEMPTY)
639
736
#define YYACCEPT        goto yyacceptlab
640
737
#define YYABORT         goto yyabortlab
641
738
#define YYERROR         goto yyerrlab1
642
 
/* Like YYERROR except do call yyerror.
643
 
   This remains here temporarily to ease the
644
 
   transition to the new meaning of YYERROR, for GCC.
 
739
/* Like YYERROR except do call yyerror.  This remains here temporarily
 
740
   to ease the transition to the new meaning of YYERROR, for GCC.
645
741
   Once GCC version 2 has supplanted version 1, this can go.  */
646
742
#define YYFAIL          goto yyerrlab
647
743
#define YYRECOVERING()  (!!yyerrstatus)
648
 
#define YYBACKUP(token, value) \
 
744
#define YYBACKUP(Token, Value)                                  \
649
745
do                                                              \
650
746
  if (yychar == YYEMPTY && yylen == 1)                          \
651
 
    { yychar = (token), yylval = (value);                       \
 
747
    {                                                           \
 
748
      yychar = (Token);                                         \
 
749
      yylval = (Value);                                         \
652
750
      yychar1 = YYTRANSLATE (yychar);                           \
653
751
      YYPOPSTACK;                                               \
654
752
      goto yybackup;                                            \
655
753
    }                                                           \
656
754
  else                                                          \
657
 
    { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 
755
    {                                                           \
 
756
      yyerror ("syntax error: cannot back up");                 \
 
757
      YYERROR;                                                  \
 
758
    }                                                           \
658
759
while (0)
659
760
 
660
761
#define YYTERROR        1
661
762
#define YYERRCODE       256
662
763
 
663
 
#ifndef YYPURE
664
 
#define YYLEX           yylex()
665
 
#endif
666
 
 
667
 
#ifdef YYPURE
668
 
#ifdef YYLSP_NEEDED
669
 
#ifdef YYLEX_PARAM
670
 
#define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
671
 
#else
672
 
#define YYLEX           yylex(&yylval, &yylloc)
673
 
#endif
674
 
#else /* not YYLSP_NEEDED */
675
 
#ifdef YYLEX_PARAM
676
 
#define YYLEX           yylex(&yylval, YYLEX_PARAM)
677
 
#else
678
 
#define YYLEX           yylex(&yylval)
679
 
#endif
680
 
#endif /* not YYLSP_NEEDED */
681
 
#endif
682
 
 
683
 
/* If nonreentrant, generate the variables here */
684
 
 
685
 
#ifndef YYPURE
686
 
 
687
 
int     yychar;                 /*  the lookahead symbol                */
688
 
YYSTYPE yylval;                 /*  the semantic value of the           */
689
 
                                /*  lookahead symbol                    */
690
 
 
691
 
#ifdef YYLSP_NEEDED
692
 
YYLTYPE yylloc;                 /*  location data for the lookahead     */
693
 
                                /*  symbol                              */
694
 
#endif
695
 
 
696
 
int yynerrs;                    /*  number of parse errors so far       */
697
 
#endif  /* not YYPURE */
698
 
 
699
 
#if YYDEBUG != 0
700
 
int yydebug;                    /*  nonzero means print parse trace     */
701
 
/* Since this is uninitialized, it does not stop multiple parsers
702
 
   from coexisting.  */
703
 
#endif
704
 
 
705
 
/*  YYINITDEPTH indicates the initial size of the parser's stacks       */
706
 
 
 
764
 
 
765
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
 
766
   are run).
 
767
 
 
768
   When YYLLOC_DEFAULT is run, CURRENT is set the location of the
 
769
   first token.  By default, to implement support for ranges, extend
 
770
   its range to the last symbol.  */
 
771
 
 
772
#ifndef YYLLOC_DEFAULT
 
773
# define YYLLOC_DEFAULT(Current, Rhs, N)        \
 
774
   Current.last_line   = Rhs[N].last_line;      \
 
775
   Current.last_column = Rhs[N].last_column;
 
776
#endif
 
777
 
 
778
 
 
779
/* YYLEX -- calling `yylex' with the right arguments.  */
 
780
 
 
781
#if YYPURE
 
782
# if YYLSP_NEEDED
 
783
#  ifdef YYLEX_PARAM
 
784
#   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
 
785
#  else
 
786
#   define YYLEX                yylex (&yylval, &yylloc)
 
787
#  endif
 
788
# else /* !YYLSP_NEEDED */
 
789
#  ifdef YYLEX_PARAM
 
790
#   define YYLEX                yylex (&yylval, YYLEX_PARAM)
 
791
#  else
 
792
#   define YYLEX                yylex (&yylval)
 
793
#  endif
 
794
# endif /* !YYLSP_NEEDED */
 
795
#else /* !YYPURE */
 
796
# define YYLEX                  yylex ()
 
797
#endif /* !YYPURE */
 
798
 
 
799
 
 
800
/* Enable debugging if requested.  */
 
801
#if YYDEBUG
 
802
 
 
803
# ifndef YYFPRINTF
 
804
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 
805
#  define YYFPRINTF fprintf
 
806
# endif
 
807
 
 
808
# define YYDPRINTF(Args)                        \
 
809
do {                                            \
 
810
  if (yydebug)                                  \
 
811
    YYFPRINTF Args;                             \
 
812
} while (0)
 
813
/* Nonzero means print parse trace.  It is left uninitialized so that
 
814
   multiple parsers can coexist.  */
 
815
int yydebug;
 
816
#else /* !YYDEBUG */
 
817
# define YYDPRINTF(Args)
 
818
#endif /* !YYDEBUG */
 
819
 
 
820
/* YYINITDEPTH -- initial size of the parser's stacks.  */
707
821
#ifndef YYINITDEPTH
708
 
#define YYINITDEPTH 200
 
822
# define YYINITDEPTH 200
709
823
#endif
710
824
 
711
 
/*  YYMAXDEPTH is the maximum size the stacks can grow to
712
 
    (effective only if the built-in stack extension method is used).  */
 
825
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 
826
   if the built-in stack extension method is used).
 
827
 
 
828
   Do not make this value too large; the results are undefined if
 
829
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 
830
   evaluated with infinite-precision integer arithmetic.  */
713
831
 
714
832
#if YYMAXDEPTH == 0
715
 
#undef YYMAXDEPTH
 
833
# undef YYMAXDEPTH
716
834
#endif
717
835
 
718
836
#ifndef YYMAXDEPTH
719
 
#define YYMAXDEPTH 10000
720
 
#endif
721
 
 
722
 
/* Define __yy_memcpy.  Note that the size argument
723
 
   should be passed with type unsigned int, because that is what the non-GCC
724
 
   definitions require.  With GCC, __builtin_memcpy takes an arg
725
 
   of type size_t, but it can handle unsigned int.  */
726
 
 
727
 
#if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
728
 
#define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
729
 
#else                           /* not GNU C or C++ */
730
 
#ifndef __cplusplus
731
 
 
732
 
/* This is the most reliable way to avoid incompatibilities
733
 
   in available built-in functions on various systems.  */
734
 
static void
735
 
__yy_memcpy (to, from, count)
736
 
     char *to;
737
 
     char *from;
738
 
     unsigned int count;
739
 
{
740
 
  register char *f = from;
741
 
  register char *t = to;
742
 
  register int i = count;
743
 
 
744
 
  while (i-- > 0)
745
 
    *t++ = *f++;
746
 
}
747
 
 
748
 
#else /* __cplusplus */
749
 
 
750
 
/* This is the most reliable way to avoid incompatibilities
751
 
   in available built-in functions on various systems.  */
752
 
static void
753
 
__yy_memcpy (char *to, char *from, unsigned int count)
754
 
{
755
 
  register char *t = to;
756
 
  register char *f = from;
757
 
  register int i = count;
758
 
 
759
 
  while (i-- > 0)
760
 
    *t++ = *f++;
761
 
}
762
 
 
763
 
#endif
764
 
#endif
765
 
 
766
 
#line 217 "//usr/lib/bison.simple"
 
837
# define YYMAXDEPTH 10000
 
838
#endif
 
839
 
 
840
#ifdef YYERROR_VERBOSE
 
841
 
 
842
# ifndef yystrlen
 
843
#  if defined (__GLIBC__) && defined (_STRING_H)
 
844
#   define yystrlen strlen
 
845
#  else
 
846
/* Return the length of YYSTR.  */
 
847
static YYSIZE_T
 
848
#   if defined (__STDC__) || defined (__cplusplus)
 
849
yystrlen (const char *yystr)
 
850
#   else
 
851
yystrlen (yystr)
 
852
     const char *yystr;
 
853
#   endif
 
854
{
 
855
  register const char *yys = yystr;
 
856
 
 
857
  while (*yys++ != '\0')
 
858
    continue;
 
859
 
 
860
  return yys - yystr - 1;
 
861
}
 
862
#  endif
 
863
# endif
 
864
 
 
865
# ifndef yystpcpy
 
866
#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 
867
#   define yystpcpy stpcpy
 
868
#  else
 
869
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 
870
   YYDEST.  */
 
871
static char *
 
872
#   if defined (__STDC__) || defined (__cplusplus)
 
873
yystpcpy (char *yydest, const char *yysrc)
 
874
#   else
 
875
yystpcpy (yydest, yysrc)
 
876
     char *yydest;
 
877
     const char *yysrc;
 
878
#   endif
 
879
{
 
880
  register char *yyd = yydest;
 
881
  register const char *yys = yysrc;
 
882
 
 
883
  while ((*yyd++ = *yys++) != '\0')
 
884
    continue;
 
885
 
 
886
  return yyd - 1;
 
887
}
 
888
#  endif
 
889
# endif
 
890
#endif
 
891
 
 
892
#line 315 "/usr/share/bison/bison.simple"
 
893
 
767
894
 
768
895
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
769
896
   into yyparse.  The argument should have type void *.
772
899
   to the proper pointer type.  */
773
900
 
774
901
#ifdef YYPARSE_PARAM
775
 
#ifdef __cplusplus
776
 
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
777
 
#define YYPARSE_PARAM_DECL
778
 
#else /* not __cplusplus */
779
 
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
780
 
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
781
 
#endif /* not __cplusplus */
782
 
#else /* not YYPARSE_PARAM */
783
 
#define YYPARSE_PARAM_ARG
784
 
#define YYPARSE_PARAM_DECL
785
 
#endif /* not YYPARSE_PARAM */
 
902
# if defined (__STDC__) || defined (__cplusplus)
 
903
#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 
904
#  define YYPARSE_PARAM_DECL
 
905
# else
 
906
#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 
907
#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 
908
# endif
 
909
#else /* !YYPARSE_PARAM */
 
910
# define YYPARSE_PARAM_ARG
 
911
# define YYPARSE_PARAM_DECL
 
912
#endif /* !YYPARSE_PARAM */
786
913
 
787
914
/* Prevent warning if -Wstrict-prototypes.  */
788
915
#ifdef __GNUC__
789
 
#ifdef YYPARSE_PARAM
 
916
# ifdef YYPARSE_PARAM
790
917
int yyparse (void *);
791
 
#else
 
918
# else
792
919
int yyparse (void);
793
 
#endif
794
 
#endif
 
920
# endif
 
921
#endif
 
922
 
 
923
/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
 
924
   variables are global, or local to YYPARSE.  */
 
925
 
 
926
#define YY_DECL_NON_LSP_VARIABLES                       \
 
927
/* The lookahead symbol.  */                            \
 
928
int yychar;                                             \
 
929
                                                        \
 
930
/* The semantic value of the lookahead symbol. */       \
 
931
YYSTYPE yylval;                                         \
 
932
                                                        \
 
933
/* Number of parse errors so far.  */                   \
 
934
int yynerrs;
 
935
 
 
936
#if YYLSP_NEEDED
 
937
# define YY_DECL_VARIABLES                      \
 
938
YY_DECL_NON_LSP_VARIABLES                       \
 
939
                                                \
 
940
/* Location data for the lookahead symbol.  */  \
 
941
YYLTYPE yylloc;
 
942
#else
 
943
# define YY_DECL_VARIABLES                      \
 
944
YY_DECL_NON_LSP_VARIABLES
 
945
#endif
 
946
 
 
947
 
 
948
/* If nonreentrant, generate the variables here. */
 
949
 
 
950
#if !YYPURE
 
951
YY_DECL_VARIABLES
 
952
#endif  /* !YYPURE */
795
953
 
796
954
int
797
 
yyparse(YYPARSE_PARAM_ARG)
 
955
yyparse (YYPARSE_PARAM_ARG)
798
956
     YYPARSE_PARAM_DECL
799
957
{
 
958
  /* If reentrant, generate the variables here. */
 
959
#if YYPURE
 
960
  YY_DECL_VARIABLES
 
961
#endif  /* !YYPURE */
 
962
 
800
963
  register int yystate;
801
964
  register int yyn;
 
965
  int yyresult;
 
966
  /* Number of tokens to shift before error messages enabled.  */
 
967
  int yyerrstatus;
 
968
  /* Lookahead token as an internal (translated) token number.  */
 
969
  int yychar1 = 0;
 
970
 
 
971
  /* Three stacks and their tools:
 
972
     `yyss': related to states,
 
973
     `yyvs': related to semantic values,
 
974
     `yyls': related to locations.
 
975
 
 
976
     Refer to the stacks thru separate pointers, to allow yyoverflow
 
977
     to reallocate them elsewhere.  */
 
978
 
 
979
  /* The state stack. */
 
980
  short yyssa[YYINITDEPTH];
 
981
  short *yyss = yyssa;
802
982
  register short *yyssp;
 
983
 
 
984
  /* The semantic value stack.  */
 
985
  YYSTYPE yyvsa[YYINITDEPTH];
 
986
  YYSTYPE *yyvs = yyvsa;
803
987
  register YYSTYPE *yyvsp;
804
 
  int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
805
 
  int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
806
 
 
807
 
  short yyssa[YYINITDEPTH];     /*  the state stack                     */
808
 
  YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
809
 
 
810
 
  short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
811
 
  YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
812
 
 
813
 
#ifdef YYLSP_NEEDED
814
 
  YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 
988
 
 
989
#if YYLSP_NEEDED
 
990
  /* The location stack.  */
 
991
  YYLTYPE yylsa[YYINITDEPTH];
815
992
  YYLTYPE *yyls = yylsa;
816
993
  YYLTYPE *yylsp;
 
994
#endif
817
995
 
818
 
#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 
996
#if YYLSP_NEEDED
 
997
# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
819
998
#else
820
 
#define YYPOPSTACK   (yyvsp--, yyssp--)
821
 
#endif
822
 
 
823
 
  int yystacksize = YYINITDEPTH;
824
 
  int yyfree_stacks = 0;
825
 
 
826
 
#ifdef YYPURE
827
 
  int yychar;
828
 
  YYSTYPE yylval;
829
 
  int yynerrs;
830
 
#ifdef YYLSP_NEEDED
831
 
  YYLTYPE yylloc;
832
 
#endif
833
 
#endif
834
 
 
835
 
  YYSTYPE yyval;                /*  the variable used to return         */
836
 
                                /*  semantic values from the action     */
837
 
                                /*  routines                            */
838
 
 
 
999
# define YYPOPSTACK   (yyvsp--, yyssp--)
 
1000
#endif
 
1001
 
 
1002
  YYSIZE_T yystacksize = YYINITDEPTH;
 
1003
 
 
1004
 
 
1005
  /* The variables used to return semantic value and location from the
 
1006
     action routines.  */
 
1007
  YYSTYPE yyval;
 
1008
#if YYLSP_NEEDED
 
1009
  YYLTYPE yyloc;
 
1010
#endif
 
1011
 
 
1012
  /* When reducing, the number of symbols on the RHS of the reduced
 
1013
     rule. */
839
1014
  int yylen;
840
1015
 
841
 
#if YYDEBUG != 0
842
 
  if (yydebug)
843
 
    fprintf(stderr, "Starting parse\n");
844
 
#endif
 
1016
  YYDPRINTF ((stderr, "Starting parse\n"));
845
1017
 
846
1018
  yystate = 0;
847
1019
  yyerrstatus = 0;
853
1025
     so that they stay on the same level as the state stack.
854
1026
     The wasted elements are never initialized.  */
855
1027
 
856
 
  yyssp = yyss - 1;
 
1028
  yyssp = yyss;
857
1029
  yyvsp = yyvs;
858
 
#ifdef YYLSP_NEEDED
 
1030
#if YYLSP_NEEDED
859
1031
  yylsp = yyls;
860
1032
#endif
861
 
 
862
 
/* Push a new state, which is found in  yystate  .  */
863
 
/* In all cases, when you get here, the value and location stacks
864
 
   have just been pushed. so pushing a state here evens the stacks.  */
865
 
yynewstate:
866
 
 
867
 
  *++yyssp = yystate;
 
1033
  goto yysetstate;
 
1034
 
 
1035
/*------------------------------------------------------------.
 
1036
| yynewstate -- Push a new state, which is found in yystate.  |
 
1037
`------------------------------------------------------------*/
 
1038
 yynewstate:
 
1039
  /* In all cases, when you get here, the value and location stacks
 
1040
     have just been pushed. so pushing a state here evens the stacks.
 
1041
     */
 
1042
  yyssp++;
 
1043
 
 
1044
 yysetstate:
 
1045
  *yyssp = yystate;
868
1046
 
869
1047
  if (yyssp >= yyss + yystacksize - 1)
870
1048
    {
871
 
      /* Give user a chance to reallocate the stack */
872
 
      /* Use copies of these so that the &'s don't force the real ones into memory. */
873
 
      YYSTYPE *yyvs1 = yyvs;
874
 
      short *yyss1 = yyss;
875
 
#ifdef YYLSP_NEEDED
876
 
      YYLTYPE *yyls1 = yyls;
877
 
#endif
878
 
 
879
1049
      /* Get the current used size of the three stacks, in elements.  */
880
 
      int size = yyssp - yyss + 1;
 
1050
      YYSIZE_T yysize = yyssp - yyss + 1;
881
1051
 
882
1052
#ifdef yyoverflow
883
 
      /* Each stack pointer address is followed by the size of
884
 
         the data in use in that stack, in bytes.  */
885
 
#ifdef YYLSP_NEEDED
886
 
      /* This used to be a conditional around just the two extra args,
887
 
         but that might be undefined if yyoverflow is a macro.  */
888
 
      yyoverflow("parser stack overflow",
889
 
                 &yyss1, size * sizeof (*yyssp),
890
 
                 &yyvs1, size * sizeof (*yyvsp),
891
 
                 &yyls1, size * sizeof (*yylsp),
892
 
                 &yystacksize);
893
 
#else
894
 
      yyoverflow("parser stack overflow",
895
 
                 &yyss1, size * sizeof (*yyssp),
896
 
                 &yyvs1, size * sizeof (*yyvsp),
897
 
                 &yystacksize);
898
 
#endif
 
1053
      {
 
1054
        /* Give user a chance to reallocate the stack. Use copies of
 
1055
           these so that the &'s don't force the real ones into
 
1056
           memory.  */
 
1057
        YYSTYPE *yyvs1 = yyvs;
 
1058
        short *yyss1 = yyss;
899
1059
 
900
 
      yyss = yyss1; yyvs = yyvs1;
901
 
#ifdef YYLSP_NEEDED
902
 
      yyls = yyls1;
903
 
#endif
 
1060
        /* Each stack pointer address is followed by the size of the
 
1061
           data in use in that stack, in bytes.  */
 
1062
# if YYLSP_NEEDED
 
1063
        YYLTYPE *yyls1 = yyls;
 
1064
        /* This used to be a conditional around just the two extra args,
 
1065
           but that might be undefined if yyoverflow is a macro.  */
 
1066
        yyoverflow ("parser stack overflow",
 
1067
                    &yyss1, yysize * sizeof (*yyssp),
 
1068
                    &yyvs1, yysize * sizeof (*yyvsp),
 
1069
                    &yyls1, yysize * sizeof (*yylsp),
 
1070
                    &yystacksize);
 
1071
        yyls = yyls1;
 
1072
# else
 
1073
        yyoverflow ("parser stack overflow",
 
1074
                    &yyss1, yysize * sizeof (*yyssp),
 
1075
                    &yyvs1, yysize * sizeof (*yyvsp),
 
1076
                    &yystacksize);
 
1077
# endif
 
1078
        yyss = yyss1;
 
1079
        yyvs = yyvs1;
 
1080
      }
904
1081
#else /* no yyoverflow */
 
1082
# ifndef YYSTACK_RELOCATE
 
1083
      goto yyoverflowlab;
 
1084
# else
905
1085
      /* Extend the stack our own way.  */
906
1086
      if (yystacksize >= YYMAXDEPTH)
907
 
        {
908
 
          yyerror("parser stack overflow");
909
 
          if (yyfree_stacks)
910
 
            {
911
 
              free (yyss);
912
 
              free (yyvs);
913
 
#ifdef YYLSP_NEEDED
914
 
              free (yyls);
915
 
#endif
916
 
            }
917
 
          return 2;
918
 
        }
 
1087
        goto yyoverflowlab;
919
1088
      yystacksize *= 2;
920
1089
      if (yystacksize > YYMAXDEPTH)
921
1090
        yystacksize = YYMAXDEPTH;
922
 
#ifndef YYSTACK_USE_ALLOCA
923
 
      yyfree_stacks = 1;
924
 
#endif
925
 
      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
926
 
      __yy_memcpy ((char *)yyss, (char *)yyss1,
927
 
                   size * (unsigned int) sizeof (*yyssp));
928
 
      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
929
 
      __yy_memcpy ((char *)yyvs, (char *)yyvs1,
930
 
                   size * (unsigned int) sizeof (*yyvsp));
931
 
#ifdef YYLSP_NEEDED
932
 
      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
933
 
      __yy_memcpy ((char *)yyls, (char *)yyls1,
934
 
                   size * (unsigned int) sizeof (*yylsp));
935
 
#endif
 
1091
 
 
1092
      {
 
1093
        short *yyss1 = yyss;
 
1094
        union yyalloc *yyptr =
 
1095
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 
1096
        if (! yyptr)
 
1097
          goto yyoverflowlab;
 
1098
        YYSTACK_RELOCATE (yyss);
 
1099
        YYSTACK_RELOCATE (yyvs);
 
1100
# if YYLSP_NEEDED
 
1101
        YYSTACK_RELOCATE (yyls);
 
1102
# endif
 
1103
# undef YYSTACK_RELOCATE
 
1104
        if (yyss1 != yyssa)
 
1105
          YYSTACK_FREE (yyss1);
 
1106
      }
 
1107
# endif
936
1108
#endif /* no yyoverflow */
937
1109
 
938
 
      yyssp = yyss + size - 1;
939
 
      yyvsp = yyvs + size - 1;
940
 
#ifdef YYLSP_NEEDED
941
 
      yylsp = yyls + size - 1;
 
1110
      yyssp = yyss + yysize - 1;
 
1111
      yyvsp = yyvs + yysize - 1;
 
1112
#if YYLSP_NEEDED
 
1113
      yylsp = yyls + yysize - 1;
942
1114
#endif
943
1115
 
944
 
#if YYDEBUG != 0
945
 
      if (yydebug)
946
 
        fprintf(stderr, "Stack size increased to %d\n", yystacksize);
947
 
#endif
 
1116
      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 
1117
                  (unsigned long int) yystacksize));
948
1118
 
949
1119
      if (yyssp >= yyss + yystacksize - 1)
950
1120
        YYABORT;
951
1121
    }
952
1122
 
953
 
#if YYDEBUG != 0
954
 
  if (yydebug)
955
 
    fprintf(stderr, "Entering state %d\n", yystate);
956
 
#endif
 
1123
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
957
1124
 
958
1125
  goto yybackup;
959
 
 yybackup:
 
1126
 
 
1127
 
 
1128
/*-----------.
 
1129
| yybackup.  |
 
1130
`-----------*/
 
1131
yybackup:
960
1132
 
961
1133
/* Do appropriate processing given the current state.  */
962
1134
/* Read a lookahead token if we need one and don't already have one.  */
975
1147
 
976
1148
  if (yychar == YYEMPTY)
977
1149
    {
978
 
#if YYDEBUG != 0
979
 
      if (yydebug)
980
 
        fprintf(stderr, "Reading a token: ");
981
 
#endif
 
1150
      YYDPRINTF ((stderr, "Reading a token: "));
982
1151
      yychar = YYLEX;
983
1152
    }
984
1153
 
989
1158
      yychar1 = 0;
990
1159
      yychar = YYEOF;           /* Don't call YYLEX any more */
991
1160
 
992
 
#if YYDEBUG != 0
993
 
      if (yydebug)
994
 
        fprintf(stderr, "Now at end of input.\n");
995
 
#endif
 
1161
      YYDPRINTF ((stderr, "Now at end of input.\n"));
996
1162
    }
997
1163
  else
998
1164
    {
999
 
      yychar1 = YYTRANSLATE(yychar);
 
1165
      yychar1 = YYTRANSLATE (yychar);
1000
1166
 
1001
 
#if YYDEBUG != 0
 
1167
#if YYDEBUG
 
1168
     /* We have to keep this `#if YYDEBUG', since we use variables
 
1169
        which are defined only if `YYDEBUG' is set.  */
1002
1170
      if (yydebug)
1003
1171
        {
1004
 
          fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
1005
 
          /* Give the individual parser a way to print the precise meaning
1006
 
             of a token, for further debugging info.  */
1007
 
#ifdef YYPRINT
 
1172
          YYFPRINTF (stderr, "Next token is %d (%s",
 
1173
                     yychar, yytname[yychar1]);
 
1174
          /* Give the individual parser a way to print the precise
 
1175
             meaning of a token, for further debugging info.  */
 
1176
# ifdef YYPRINT
1008
1177
          YYPRINT (stderr, yychar, yylval);
1009
 
#endif
1010
 
          fprintf (stderr, ")\n");
 
1178
# endif
 
1179
          YYFPRINTF (stderr, ")\n");
1011
1180
        }
1012
1181
#endif
1013
1182
    }
1039
1208
    YYACCEPT;
1040
1209
 
1041
1210
  /* Shift the lookahead token.  */
1042
 
 
1043
 
#if YYDEBUG != 0
1044
 
  if (yydebug)
1045
 
    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
1046
 
#endif
 
1211
  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
 
1212
              yychar, yytname[yychar1]));
1047
1213
 
1048
1214
  /* Discard the token being shifted unless it is eof.  */
1049
1215
  if (yychar != YYEOF)
1050
1216
    yychar = YYEMPTY;
1051
1217
 
1052
1218
  *++yyvsp = yylval;
1053
 
#ifdef YYLSP_NEEDED
 
1219
#if YYLSP_NEEDED
1054
1220
  *++yylsp = yylloc;
1055
1221
#endif
1056
1222
 
1057
 
  /* count tokens shifted since error; after three, turn off error status.  */
1058
 
  if (yyerrstatus) yyerrstatus--;
 
1223
  /* Count tokens shifted since error; after three, turn off error
 
1224
     status.  */
 
1225
  if (yyerrstatus)
 
1226
    yyerrstatus--;
1059
1227
 
1060
1228
  yystate = yyn;
1061
1229
  goto yynewstate;
1062
1230
 
1063
 
/* Do the default action for the current state.  */
 
1231
 
 
1232
/*-----------------------------------------------------------.
 
1233
| yydefault -- do the default action for the current state.  |
 
1234
`-----------------------------------------------------------*/
1064
1235
yydefault:
1065
 
 
1066
1236
  yyn = yydefact[yystate];
1067
1237
  if (yyn == 0)
1068
1238
    goto yyerrlab;
1069
 
 
1070
 
/* Do a reduction.  yyn is the number of a rule to reduce with.  */
 
1239
  goto yyreduce;
 
1240
 
 
1241
 
 
1242
/*-----------------------------.
 
1243
| yyreduce -- Do a reduction.  |
 
1244
`-----------------------------*/
1071
1245
yyreduce:
 
1246
  /* yyn is the number of a rule to reduce with.  */
1072
1247
  yylen = yyr2[yyn];
1073
 
  if (yylen > 0)
1074
 
    yyval = yyvsp[1-yylen]; /* implement default value of the action */
1075
 
 
1076
 
#if YYDEBUG != 0
 
1248
 
 
1249
  /* If YYLEN is nonzero, implement the default value of the action:
 
1250
     `$$ = $1'.
 
1251
 
 
1252
     Otherwise, the following line sets YYVAL to the semantic value of
 
1253
     the lookahead token.  This behavior is undocumented and Bison
 
1254
     users should not rely upon it.  Assigning to YYVAL
 
1255
     unconditionally makes the parser a bit smaller, and it avoids a
 
1256
     GCC warning that YYVAL may be used uninitialized.  */
 
1257
  yyval = yyvsp[1-yylen];
 
1258
 
 
1259
#if YYLSP_NEEDED
 
1260
  /* Similarly for the default location.  Let the user run additional
 
1261
     commands if for instance locations are ranges.  */
 
1262
  yyloc = yylsp[1-yylen];
 
1263
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
 
1264
#endif
 
1265
 
 
1266
#if YYDEBUG
 
1267
  /* We have to keep this `#if YYDEBUG', since we use variables which
 
1268
     are defined only if `YYDEBUG' is set.  */
1077
1269
  if (yydebug)
1078
1270
    {
1079
 
      int i;
 
1271
      int yyi;
1080
1272
 
1081
 
      fprintf (stderr, "Reducing via rule %d (line %d), ",
1082
 
               yyn, yyrline[yyn]);
 
1273
      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
 
1274
                 yyn, yyrline[yyn]);
1083
1275
 
1084
1276
      /* Print the symbols being reduced, and their result.  */
1085
 
      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1086
 
        fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1087
 
      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 
1277
      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
 
1278
        YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
 
1279
      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1088
1280
    }
1089
1281
#endif
1090
1282
 
1091
 
 
1092
1283
  switch (yyn) {
1093
1284
 
1094
1285
case 1:
1095
 
#line 163 "yacc.yy"
 
1286
#line 182 "yacc.yy"
1096
1287
{
1097
 
            theParser->setRootNode( NULL );
1098
 
          ;
 
1288
            theParser->setRootNode( NULL );
 
1289
          ;
1099
1290
    break;}
1100
1291
case 2:
1101
 
#line 167 "yacc.yy"
1102
 
{
1103
 
            theParser->setRootNode( yyvsp[0].node );
1104
 
          ;
 
1292
#line 185 "yacc.yy"
 
1293
{ kspread_mode(); ;
1105
1294
    break;}
1106
1295
case 3:
1107
 
#line 171 "yacc.yy"
 
1296
#line 186 "yacc.yy"
1108
1297
{
1109
 
            theParser->setRootNode( new KSParseNode( definitions, yyvsp[0].node ) );
1110
 
          ;
 
1298
            theParser->setRootNode( yyvsp[0].node );
 
1299
          ;
1111
1300
    break;}
1112
1301
case 4:
1113
 
#line 178 "yacc.yy"
 
1302
#line 190 "yacc.yy"
1114
1303
{
1115
 
            if ( yyvsp[0].node != 0 )
1116
 
            {
1117
 
                yyval.node = new KSParseNode( definitions, yyvsp[0].node );
1118
 
            }
1119
 
          ;
 
1304
            theParser->setRootNode( new KSParseNode( definitions, yyvsp[0].node ) );
 
1305
          ;
1120
1306
    break;}
1121
1307
case 5:
1122
 
#line 185 "yacc.yy"
 
1308
#line 197 "yacc.yy"
1123
1309
{
1124
 
            if ( yyvsp[-1].node != 0 && yyvsp[0].node != 0 )
1125
 
            {
1126
 
                yyval.node = new KSParseNode( definitions, yyvsp[-1].node );
1127
 
                yyval.node->setBranch( 2, yyvsp[0].node );
1128
 
            }
1129
 
            else if ( yyvsp[-1].node != 0 )
1130
 
            {
1131
 
                yyval.node = new KSParseNode( definitions, yyvsp[-1].node );
1132
 
            }
1133
 
            else if ( yyvsp[0].node != 0 )
1134
 
            {
1135
 
                yyval.node = new KSParseNode( definitions, yyvsp[0].node );
1136
 
            }
1137
 
            else
1138
 
            {
1139
 
                yyval.node = 0;
1140
 
            }
1141
 
          ;
 
1310
            if ( yyvsp[0].node != 0 )
 
1311
            {
 
1312
                yyval.node = new KSParseNode( definitions, yyvsp[0].node );
 
1313
            }
 
1314
          ;
1142
1315
    break;}
1143
1316
case 6:
1144
 
#line 209 "yacc.yy"
 
1317
#line 204 "yacc.yy"
1145
1318
{
1146
 
            yyval.node = 0;
1147
 
          ;
 
1319
            if ( yyvsp[-1].node != 0 && yyvsp[0].node != 0 )
 
1320
            {
 
1321
                yyval.node = new KSParseNode( definitions, yyvsp[-1].node );
 
1322
                yyval.node->setBranch( 2, yyvsp[0].node );
 
1323
            }
 
1324
            else if ( yyvsp[-1].node != 0 )
 
1325
            {
 
1326
                yyval.node = new KSParseNode( definitions, yyvsp[-1].node );
 
1327
            }
 
1328
            else if ( yyvsp[0].node != 0 )
 
1329
            {
 
1330
                yyval.node = new KSParseNode( definitions, yyvsp[0].node );
 
1331
            }
 
1332
            else
 
1333
            {
 
1334
                yyval.node = 0;
 
1335
            }
 
1336
          ;
1148
1337
    break;}
1149
1338
case 7:
1150
 
#line 213 "yacc.yy"
 
1339
#line 228 "yacc.yy"
1151
1340
{
1152
 
            yyval.node = yyvsp[-1].node;
1153
 
          ;
 
1341
            yyval.node = yyvsp[-1].node;
 
1342
          ;
1154
1343
    break;}
1155
1344
case 8:
1156
 
#line 217 "yacc.yy"
 
1345
#line 232 "yacc.yy"
1157
1346
{
1158
 
            yyval.node = yyvsp[-1].node;
1159
 
          ;
 
1347
            yyval.node = yyvsp[-1].node;
 
1348
          ;
1160
1349
    break;}
1161
1350
case 9:
1162
 
#line 221 "yacc.yy"
 
1351
#line 236 "yacc.yy"
1163
1352
{
1164
 
            yyval.node = yyvsp[-2].node;
1165
 
          ;
 
1353
            yyval.node = yyvsp[-1].node;
 
1354
          ;
1166
1355
    break;}
1167
1356
case 10:
1168
 
#line 225 "yacc.yy"
 
1357
#line 240 "yacc.yy"
1169
1358
{
1170
 
            yyval.node = new KSParseNode( import );
1171
 
            yyval.node->setIdent( yyvsp[-1].ident );
1172
 
          ;
 
1359
            yyval.node = new KSParseNode( import );
 
1360
            yyval.node->setIdent( yyvsp[-1].ident );
 
1361
          ;
1173
1362
    break;}
1174
1363
case 11:
1175
 
#line 230 "yacc.yy"
 
1364
#line 245 "yacc.yy"
1176
1365
{
1177
 
            yyval.node = new KSParseNode( from );
1178
 
            yyval.node->setIdent( yyvsp[-3].ident );
1179
 
            yyval.node->setStringLiteral( QString( "" ) );
1180
 
          ;
 
1366
            yyval.node = new KSParseNode( from );
 
1367
            yyval.node->setIdent( yyvsp[-3].ident );
 
1368
            yyval.node->setStringLiteral( QString( "" ) );
 
1369
          ;
1181
1370
    break;}
1182
1371
case 12:
1183
 
#line 236 "yacc.yy"
 
1372
#line 251 "yacc.yy"
1184
1373
{
1185
 
            yyval.node = new KSParseNode( from );
1186
 
            yyval.node->setIdent( yyvsp[-3].ident );
1187
 
            yyval.node->setStringLiteral( yyvsp[-1]._str );
1188
 
          ;
 
1374
            yyval.node = new KSParseNode( from );
 
1375
            yyval.node->setIdent( yyvsp[-3].ident );
 
1376
            yyval.node->setStringLiteral( yyvsp[-1]._str );
 
1377
          ;
1189
1378
    break;}
1190
1379
case 13:
1191
 
#line 242 "yacc.yy"
 
1380
#line 257 "yacc.yy"
1192
1381
{
1193
 
            yyval.node = yyvsp[0].node;
1194
 
          ;
 
1382
            yyval.node = yyvsp[0].node;
 
1383
          ;
1195
1384
    break;}
1196
1385
case 14:
1197
 
#line 249 "yacc.yy"
 
1386
#line 264 "yacc.yy"
1198
1387
{
1199
 
                yyval._str = yyvsp[0].ident;
1200
 
          ;
 
1388
                yyval._str = yyvsp[0].ident;
 
1389
          ;
1201
1390
    break;}
1202
1391
case 15:
1203
 
#line 253 "yacc.yy"
 
1392
#line 268 "yacc.yy"
1204
1393
{
1205
 
                (*yyvsp[-2].ident) += "/";
1206
 
                (*yyvsp[-2].ident) += (*yyvsp[0]._str);
1207
 
                yyval._str = yyvsp[-2].ident;
1208
 
          ;
 
1394
                (*yyvsp[-2].ident) += "/";
 
1395
                (*yyvsp[-2].ident) += (*yyvsp[0]._str);
 
1396
                yyval._str = yyvsp[-2].ident;
 
1397
          ;
1209
1398
    break;}
1210
1399
case 16:
1211
 
#line 262 "yacc.yy"
 
1400
#line 277 "yacc.yy"
1212
1401
{
1213
 
            yyval.node = new KSParseNode( func_dcl );
1214
 
            yyval.node->setBranch( 2, yyvsp[-2].node );
1215
 
            yyval.node->setIdent( "main" );
1216
 
          ;
 
1402
            yyval.node = new KSParseNode( func_dcl );
 
1403
            yyval.node->setBranch( 2, yyvsp[-1].node );
 
1404
            yyval.node->setIdent( "main" );
 
1405
          ;
1217
1406
    break;}
1218
1407
case 17:
1219
 
#line 268 "yacc.yy"
 
1408
#line 283 "yacc.yy"
1220
1409
{
1221
 
            yyval.node = new KSParseNode( func_dcl, yyvsp[-6].node, yyvsp[-1].node );
1222
 
            yyval.node->setIdent( "main" );
1223
 
          ;
 
1410
            yyval.node = new KSParseNode( func_dcl, yyvsp[-4].node, yyvsp[-1].node );
 
1411
            yyval.node->setIdent( "main" );
 
1412
          ;
1224
1413
    break;}
1225
1414
case 18:
1226
 
#line 276 "yacc.yy"
 
1415
#line 292 "yacc.yy"
1227
1416
{
1228
 
            yyval.node = new KSParseNode( scoped_name );
1229
 
            yyval.node->setIdent( yyvsp[0].ident );
1230
 
          ;
 
1417
            yyval.node = new KSParseNode( scoped_name );
 
1418
            yyval.node->setIdent( yyvsp[0].ident );
 
1419
          ;
1231
1420
    break;}
1232
1421
case 19:
1233
 
#line 281 "yacc.yy"
 
1422
#line 297 "yacc.yy"
1234
1423
{
1235
 
            yyval.node = new KSParseNode( scoped_name );
1236
 
            QString name = "::";
1237
 
            name += *(yyvsp[0].ident);
1238
 
            delete yyvsp[0].ident;
1239
 
            yyval.node->setIdent( name );
1240
 
          ;
 
1424
            yyval.node = new KSParseNode( scoped_name );
 
1425
            QString name = "::";
 
1426
            name += *(yyvsp[0].ident);
 
1427
            delete yyvsp[0].ident;
 
1428
            yyval.node->setIdent( name );
 
1429
          ;
1241
1430
    break;}
1242
1431
case 20:
1243
 
#line 293 "yacc.yy"
 
1432
#line 309 "yacc.yy"
1244
1433
{
1245
 
            yyval.node = new KSParseNode( assign_expr, yyvsp[-2].node, yyvsp[0].node );
1246
 
          ;
 
1434
            yyval.node = new KSParseNode( assign_expr, yyvsp[-2].node, yyvsp[0].node );
 
1435
          ;
1247
1436
    break;}
1248
1437
case 21:
1249
 
#line 297 "yacc.yy"
 
1438
#line 313 "yacc.yy"
1250
1439
{
1251
 
            yyval.node = new KSParseNode( plus_assign, yyvsp[-2].node, yyvsp[0].node );
1252
 
          ;
 
1440
            yyval.node = new KSParseNode( plus_assign, yyvsp[-2].node, yyvsp[0].node );
 
1441
          ;
1253
1442
    break;}
1254
1443
case 22:
1255
 
#line 301 "yacc.yy"
 
1444
#line 317 "yacc.yy"
1256
1445
{
1257
 
            yyval.node = new KSParseNode( minus_assign, yyvsp[-2].node, yyvsp[0].node );
1258
 
          ;
 
1446
            yyval.node = new KSParseNode( minus_assign, yyvsp[-2].node, yyvsp[0].node );
 
1447
          ;
1259
1448
    break;}
1260
1449
case 23:
1261
 
#line 305 "yacc.yy"
 
1450
#line 321 "yacc.yy"
1262
1451
{
1263
 
            yyval.node = yyvsp[0].node;
1264
 
          ;
 
1452
            yyval.node = yyvsp[0].node;
 
1453
          ;
1265
1454
    break;}
1266
1455
case 24:
1267
 
#line 312 "yacc.yy"
 
1456
#line 328 "yacc.yy"
1268
1457
{
1269
 
            yyval.node = new KSParseNode( bool_or, yyvsp[-2].node, yyvsp[0].node );
1270
 
          ;
 
1458
            yyval.node = new KSParseNode( bool_or, yyvsp[-2].node, yyvsp[0].node );
 
1459
          ;
1271
1460
    break;}
1272
1461
case 25:
1273
 
#line 316 "yacc.yy"
 
1462
#line 332 "yacc.yy"
1274
1463
{
1275
 
            yyval.node = yyvsp[0].node;
1276
 
          ;
 
1464
            yyval.node = yyvsp[0].node;
 
1465
          ;
1277
1466
    break;}
1278
1467
case 26:
1279
 
#line 323 "yacc.yy"
 
1468
#line 339 "yacc.yy"
1280
1469
{
1281
 
            yyval.node = new KSParseNode( bool_and, yyvsp[-2].node, yyvsp[0].node );
1282
 
          ;
 
1470
            yyval.node = new KSParseNode( bool_and, yyvsp[-2].node, yyvsp[0].node );
 
1471
          ;
1283
1472
    break;}
1284
1473
case 27:
1285
 
#line 327 "yacc.yy"
 
1474
#line 343 "yacc.yy"
1286
1475
{
1287
 
            yyval.node = yyvsp[0].node;
1288
 
          ;
 
1476
            yyval.node = yyvsp[0].node;
 
1477
          ;
1289
1478
    break;}
1290
1479
case 28:
1291
 
#line 334 "yacc.yy"
 
1480
#line 350 "yacc.yy"
1292
1481
{
1293
 
            yyval.node = new KSParseNode( t_equal, yyvsp[-2].node, yyvsp[0].node );
1294
 
          ;
 
1482
            yyval.node = new KSParseNode( t_equal, yyvsp[-2].node, yyvsp[0].node );
 
1483
          ;
1295
1484
    break;}
1296
1485
case 29:
1297
 
#line 338 "yacc.yy"
 
1486
#line 354 "yacc.yy"
1298
1487
{
1299
 
            yyval.node = new KSParseNode( t_notequal, yyvsp[-2].node, yyvsp[0].node );
1300
 
          ;
 
1488
            yyval.node = new KSParseNode( t_notequal, yyvsp[-2].node, yyvsp[0].node );
 
1489
          ;
1301
1490
    break;}
1302
1491
case 30:
1303
 
#line 342 "yacc.yy"
 
1492
#line 358 "yacc.yy"
1304
1493
{
1305
 
            yyval.node = new KSParseNode( t_less_or_equal, yyvsp[-2].node, yyvsp[0].node );
1306
 
          ;
 
1494
            yyval.node = new KSParseNode( t_less_or_equal, yyvsp[-2].node, yyvsp[0].node );
 
1495
          ;
1307
1496
    break;}
1308
1497
case 31:
1309
 
#line 346 "yacc.yy"
 
1498
#line 362 "yacc.yy"
1310
1499
{
1311
 
            yyval.node = new KSParseNode( t_greater_or_equal, yyvsp[-2].node, yyvsp[0].node );
1312
 
          ;
 
1500
            yyval.node = new KSParseNode( t_greater_or_equal, yyvsp[-2].node, yyvsp[0].node );
 
1501
          ;
1313
1502
    break;}
1314
1503
case 32:
1315
 
#line 350 "yacc.yy"
 
1504
#line 366 "yacc.yy"
1316
1505
{
1317
 
            yyval.node = new KSParseNode( t_less, yyvsp[-2].node, yyvsp[0].node );
1318
 
          ;
 
1506
            yyval.node = new KSParseNode( t_less, yyvsp[-2].node, yyvsp[0].node );
 
1507
          ;
1319
1508
    break;}
1320
1509
case 33:
1321
 
#line 354 "yacc.yy"
 
1510
#line 370 "yacc.yy"
1322
1511
{
1323
 
            yyval.node = new KSParseNode( t_greater, yyvsp[-2].node, yyvsp[0].node );
1324
 
          ;
 
1512
            yyval.node = new KSParseNode( t_greater, yyvsp[-2].node, yyvsp[0].node );
 
1513
          ;
1325
1514
    break;}
1326
1515
case 34:
1327
 
#line 358 "yacc.yy"
 
1516
#line 374 "yacc.yy"
1328
1517
{
1329
 
            yyval.node = yyvsp[0].node;
1330
 
          ;
 
1518
            yyval.node = yyvsp[0].node;
 
1519
          ;
1331
1520
    break;}
1332
1521
case 35:
1333
 
#line 366 "yacc.yy"
 
1522
#line 382 "yacc.yy"
1334
1523
{
1335
 
            yyval.node = yyvsp[0].node;
1336
 
          ;
 
1524
            yyval.node = yyvsp[0].node;
 
1525
          ;
1337
1526
    break;}
1338
1527
case 36:
1339
 
#line 370 "yacc.yy"
 
1528
#line 386 "yacc.yy"
1340
1529
{
1341
 
            yyval.node = new KSParseNode( t_vertical_line, yyvsp[-2].node, yyvsp[0].node );
1342
 
          ;
 
1530
            yyval.node = new KSParseNode( t_vertical_line, yyvsp[-2].node, yyvsp[0].node );
 
1531
          ;
1343
1532
    break;}
1344
1533
case 37:
1345
 
#line 378 "yacc.yy"
 
1534
#line 394 "yacc.yy"
1346
1535
{
1347
 
            yyval.node = yyvsp[0].node;
1348
 
          ;
 
1536
            yyval.node = yyvsp[0].node;
 
1537
          ;
1349
1538
    break;}
1350
1539
case 38:
1351
 
#line 382 "yacc.yy"
 
1540
#line 398 "yacc.yy"
1352
1541
{
1353
 
            yyval.node = new KSParseNode( t_circumflex, yyvsp[-2].node, yyvsp[0].node );
1354
 
          ;
 
1542
            yyval.node = new KSParseNode( t_circumflex, yyvsp[-2].node, yyvsp[0].node );
 
1543
          ;
1355
1544
    break;}
1356
1545
case 39:
1357
 
#line 390 "yacc.yy"
 
1546
#line 406 "yacc.yy"
1358
1547
{
1359
 
            yyval.node = yyvsp[0].node;
1360
 
          ;
 
1548
            yyval.node = yyvsp[0].node;
 
1549
          ;
1361
1550
    break;}
1362
1551
case 40:
1363
 
#line 394 "yacc.yy"
 
1552
#line 410 "yacc.yy"
1364
1553
{
1365
 
            yyval.node = new KSParseNode( t_ampersand, yyvsp[-2].node, yyvsp[0].node );
1366
 
          ;
 
1554
            yyval.node = new KSParseNode( t_ampersand, yyvsp[-2].node, yyvsp[0].node );
 
1555
          ;
1367
1556
    break;}
1368
1557
case 41:
1369
 
#line 402 "yacc.yy"
 
1558
#line 418 "yacc.yy"
1370
1559
{
1371
 
            yyval.node = yyvsp[0].node;
1372
 
          ;
 
1560
            yyval.node = yyvsp[0].node;
 
1561
          ;
1373
1562
    break;}
1374
1563
case 42:
1375
 
#line 406 "yacc.yy"
 
1564
#line 422 "yacc.yy"
1376
1565
{
1377
 
            yyval.node = new KSParseNode( t_shiftright, yyvsp[-2].node, yyvsp[0].node );
1378
 
          ;
 
1566
            yyval.node = new KSParseNode( t_shiftright, yyvsp[-2].node, yyvsp[0].node );
 
1567
          ;
1379
1568
    break;}
1380
1569
case 43:
1381
 
#line 410 "yacc.yy"
 
1570
#line 426 "yacc.yy"
1382
1571
{
1383
 
            yyval.node = new KSParseNode( t_shiftleft, yyvsp[-2].node, yyvsp[0].node );
1384
 
          ;
 
1572
            yyval.node = new KSParseNode( t_shiftleft, yyvsp[-2].node, yyvsp[0].node );
 
1573
          ;
1385
1574
    break;}
1386
1575
case 44:
1387
 
#line 418 "yacc.yy"
 
1576
#line 434 "yacc.yy"
1388
1577
{
1389
 
            yyval.node = yyvsp[0].node;
1390
 
          ;
 
1578
            yyval.node = yyvsp[0].node;
 
1579
          ;
1391
1580
    break;}
1392
1581
case 45:
1393
 
#line 422 "yacc.yy"
 
1582
#line 438 "yacc.yy"
1394
1583
{
1395
 
            yyval.node = new KSParseNode( t_plus_sign, yyvsp[-2].node, yyvsp[0].node );
1396
 
          ;
 
1584
            yyval.node = new KSParseNode( t_plus_sign, yyvsp[-2].node, yyvsp[0].node );
 
1585
          ;
1397
1586
    break;}
1398
1587
case 46:
1399
 
#line 426 "yacc.yy"
 
1588
#line 442 "yacc.yy"
1400
1589
{
1401
 
            yyval.node = new KSParseNode( t_minus_sign, yyvsp[-2].node, yyvsp[0].node );
1402
 
          ;
 
1590
            yyval.node = new KSParseNode( t_minus_sign, yyvsp[-2].node, yyvsp[0].node );
 
1591
          ;
1403
1592
    break;}
1404
1593
case 47:
1405
 
#line 434 "yacc.yy"
 
1594
#line 450 "yacc.yy"
1406
1595
{
1407
 
            yyval.node = yyvsp[0].node;
1408
 
          ;
 
1596
            yyval.node = yyvsp[0].node;
 
1597
          ;
1409
1598
    break;}
1410
1599
case 48:
1411
 
#line 438 "yacc.yy"
 
1600
#line 454 "yacc.yy"
1412
1601
{
1413
 
            yyval.node = new KSParseNode( t_asterik, yyvsp[-2].node, yyvsp[0].node );
1414
 
          ;
 
1602
            yyval.node = new KSParseNode( t_asterik, yyvsp[-2].node, yyvsp[0].node );
 
1603
          ;
1415
1604
    break;}
1416
1605
case 49:
1417
 
#line 442 "yacc.yy"
 
1606
#line 458 "yacc.yy"
1418
1607
{
1419
 
            yyval.node = new KSParseNode( t_solidus, yyvsp[-2].node, yyvsp[0].node );
1420
 
          ;
 
1608
            yyval.node = new KSParseNode( t_solidus, yyvsp[-2].node, yyvsp[0].node );
 
1609
          ;
1421
1610
    break;}
1422
1611
case 50:
1423
 
#line 446 "yacc.yy"
 
1612
#line 462 "yacc.yy"
1424
1613
{
1425
 
            yyval.node = new KSParseNode( t_percent_sign, yyvsp[-2].node, yyvsp[0].node );
1426
 
          ;
 
1614
            yyval.node = new KSParseNode( t_percent_sign, yyvsp[-2].node, yyvsp[0].node );
 
1615
          ;
1427
1616
    break;}
1428
1617
case 51:
1429
 
#line 454 "yacc.yy"
 
1618
#line 470 "yacc.yy"
1430
1619
{
1431
 
            yyval.node = new KSParseNode( t_minus_sign, yyvsp[0].node );
1432
 
          ;
 
1620
            yyval.node = new KSParseNode( t_minus_sign, yyvsp[0].node );
 
1621
          ;
1433
1622
    break;}
1434
1623
case 52:
1435
 
#line 458 "yacc.yy"
 
1624
#line 474 "yacc.yy"
1436
1625
{
1437
 
            yyval.node = new KSParseNode( t_plus_sign, yyvsp[0].node );
1438
 
          ;
 
1626
            yyval.node = new KSParseNode( t_plus_sign, yyvsp[0].node );
 
1627
          ;
1439
1628
    break;}
1440
1629
case 53:
1441
 
#line 462 "yacc.yy"
 
1630
#line 478 "yacc.yy"
1442
1631
{
1443
 
            yyval.node = new KSParseNode( t_tilde, yyvsp[0].node );
1444
 
          ;
 
1632
            yyval.node = new KSParseNode( t_tilde, yyvsp[0].node );
 
1633
          ;
1445
1634
    break;}
1446
1635
case 54:
1447
 
#line 466 "yacc.yy"
 
1636
#line 482 "yacc.yy"
1448
1637
{
1449
 
            yyval.node = new KSParseNode( t_not, yyvsp[0].node );
1450
 
          ;
 
1638
            yyval.node = new KSParseNode( t_not, yyvsp[0].node );
 
1639
          ;
1451
1640
    break;}
1452
1641
case 55:
1453
 
#line 470 "yacc.yy"
 
1642
#line 486 "yacc.yy"
1454
1643
{
1455
 
            yyval.node = yyvsp[0].node;
1456
 
          ;
 
1644
            yyval.node = yyvsp[0].node;
 
1645
          ;
1457
1646
    break;}
1458
1647
case 56:
1459
 
#line 477 "yacc.yy"
 
1648
#line 493 "yacc.yy"
1460
1649
{
1461
 
            yyval.node = new KSParseNode( t_array, yyvsp[-3].node, yyvsp[-1].node );
1462
 
          ;
 
1650
            yyval.node = new KSParseNode( t_array, yyvsp[-3].node, yyvsp[-1].node );
 
1651
          ;
1463
1652
    break;}
1464
1653
case 57:
1465
 
#line 481 "yacc.yy"
 
1654
#line 497 "yacc.yy"
1466
1655
{
1467
 
            yyval.node = new KSParseNode( t_dict, yyvsp[-3].node, yyvsp[-1].node );
1468
 
          ;
 
1656
            yyval.node = new KSParseNode( t_dict, yyvsp[-3].node, yyvsp[-1].node );
 
1657
          ;
1469
1658
    break;}
1470
1659
case 58:
1471
 
#line 485 "yacc.yy"
 
1660
#line 501 "yacc.yy"
1472
1661
{
1473
 
            yyval.node = new KSParseNode( t_func_call, yyvsp[-2].node );
1474
 
          ;
 
1662
            yyval.node = new KSParseNode( t_func_call, yyvsp[-2].node );
 
1663
          ;
1475
1664
    break;}
1476
1665
case 59:
1477
 
#line 489 "yacc.yy"
 
1666
#line 505 "yacc.yy"
1478
1667
{
1479
 
            yyval.node = new KSParseNode( t_func_call, yyvsp[-3].node, yyvsp[-1].node );
1480
 
          ;
 
1668
            yyval.node = new KSParseNode( t_func_call, yyvsp[-3].node, yyvsp[-1].node );
 
1669
          ;
1481
1670
    break;}
1482
1671
case 60:
1483
 
#line 493 "yacc.yy"
 
1672
#line 509 "yacc.yy"
1484
1673
{
1485
 
            yyval.node = yyvsp[0].node;
1486
 
          ;
 
1674
            yyval.node = yyvsp[0].node;
 
1675
          ;
1487
1676
    break;}
1488
1677
case 61:
1489
 
#line 500 "yacc.yy"
 
1678
#line 516 "yacc.yy"
1490
1679
{
1491
 
            yyval.node = new KSParseNode( func_call_params, yyvsp[-2].node, yyvsp[0].node );
1492
 
          ;
 
1680
            yyval.node = new KSParseNode( func_call_params, yyvsp[-2].node, yyvsp[0].node );
 
1681
          ;
1493
1682
    break;}
1494
1683
case 62:
1495
 
#line 505 "yacc.yy"
 
1684
#line 521 "yacc.yy"
1496
1685
{
1497
 
            yyval.node = new KSParseNode( func_call_params, yyvsp[0].node );
1498
 
          ;
 
1686
            yyval.node = new KSParseNode( func_call_params, yyvsp[0].node );
 
1687
          ;
1499
1688
    break;}
1500
1689
case 63:
1501
 
#line 512 "yacc.yy"
 
1690
#line 528 "yacc.yy"
1502
1691
{
1503
 
            yyval.node = new KSParseNode( member_expr, yyvsp[-2].node );
1504
 
            yyval.node->setIdent( yyvsp[0].ident );
1505
 
          ;
 
1692
            yyval.node = new KSParseNode( member_expr, yyvsp[-2].node );
 
1693
            yyval.node->setIdent( yyvsp[0].ident );
 
1694
          ;
1506
1695
    break;}
1507
1696
case 64:
1508
 
#line 517 "yacc.yy"
 
1697
#line 533 "yacc.yy"
1509
1698
{
1510
 
            yyval.node = yyvsp[0].node;
1511
 
          ;
 
1699
            yyval.node = yyvsp[0].node;
 
1700
          ;
1512
1701
    break;}
1513
1702
case 65:
1514
 
#line 524 "yacc.yy"
 
1703
#line 540 "yacc.yy"
1515
1704
{
1516
 
            yyval.node = new KSParseNode( t_incr, yyvsp[0].node );
1517
 
          ;
 
1705
            yyval.node = new KSParseNode( t_incr, yyvsp[0].node );
 
1706
          ;
1518
1707
    break;}
1519
1708
case 66:
1520
 
#line 528 "yacc.yy"
 
1709
#line 544 "yacc.yy"
1521
1710
{
1522
 
            yyval.node = new KSParseNode( t_decr, yyvsp[0].node );
1523
 
          ;
 
1711
            yyval.node = new KSParseNode( t_decr, yyvsp[0].node );
 
1712
          ;
1524
1713
    break;}
1525
1714
case 67:
1526
 
#line 532 "yacc.yy"
 
1715
#line 548 "yacc.yy"
1527
1716
{
1528
 
            /* Setting $1 twice indicates that this is a postfix operator */
1529
 
            yyval.node = new KSParseNode( t_incr, yyvsp[-1].node, yyvsp[-1].node );
1530
 
          ;
 
1717
            /* Setting $1 twice indicates that this is a postfix operator */
 
1718
            yyval.node = new KSParseNode( t_incr, yyvsp[-1].node, yyvsp[-1].node );
 
1719
          ;
1531
1720
    break;}
1532
1721
case 68:
1533
 
#line 537 "yacc.yy"
 
1722
#line 553 "yacc.yy"
1534
1723
{
1535
 
            /* Setting $1 twice indicates that this is a postfix operator */
1536
 
            yyval.node = new KSParseNode( t_decr, yyvsp[-1].node, yyvsp[-1].node );
1537
 
          ;
 
1724
            /* Setting $1 twice indicates that this is a postfix operator */
 
1725
            yyval.node = new KSParseNode( t_decr, yyvsp[-1].node, yyvsp[-1].node );
 
1726
          ;
1538
1727
    break;}
1539
1728
case 69:
1540
 
#line 542 "yacc.yy"
 
1729
#line 558 "yacc.yy"
1541
1730
{
1542
 
            yyval.node = yyvsp[0].node;
1543
 
          ;
 
1731
            yyval.node = yyvsp[0].node;
 
1732
          ;
1544
1733
    break;}
1545
1734
case 70:
1546
 
#line 549 "yacc.yy"
 
1735
#line 565 "yacc.yy"
1547
1736
{
1548
 
            yyval.node = new KSParseNode( t_match, yyvsp[-1].node );
1549
 
            yyval.node->setIdent( yyvsp[0]._str );
1550
 
          ;
 
1737
            yyval.node = new KSParseNode( t_match, yyvsp[-1].node );
 
1738
            yyval.node->setIdent( yyvsp[0]._str );
 
1739
          ;
1551
1740
    break;}
1552
1741
case 71:
1553
 
#line 554 "yacc.yy"
 
1742
#line 570 "yacc.yy"
1554
1743
{
1555
 
            yyval.node = new KSParseNode( t_subst, yyvsp[-1].node );
1556
 
            yyval.node->setIdent( yyvsp[0].ident );
1557
 
          ;
 
1744
            yyval.node = new KSParseNode( t_subst, yyvsp[-1].node );
 
1745
            yyval.node->setIdent( yyvsp[0].ident );
 
1746
          ;
1558
1747
    break;}
1559
1748
case 72:
1560
 
#line 559 "yacc.yy"
 
1749
#line 575 "yacc.yy"
1561
1750
{
1562
 
            yyval.node = yyvsp[0].node;
1563
 
          ;
 
1751
            yyval.node = yyvsp[0].node;
 
1752
          ;
1564
1753
    break;}
1565
1754
case 73:
1566
 
#line 567 "yacc.yy"
 
1755
#line 583 "yacc.yy"
1567
1756
{
1568
 
            yyval.node = yyvsp[0].node;
1569
 
          ;
 
1757
            yyval.node = yyvsp[0].node;
 
1758
          ;
1570
1759
    break;}
1571
1760
case 74:
1572
 
#line 571 "yacc.yy"
 
1761
#line 587 "yacc.yy"
1573
1762
{
1574
 
            yyval.node = yyvsp[0].node;
1575
 
          ;
 
1763
            yyval.node = yyvsp[0].node;
 
1764
          ;
1576
1765
    break;}
1577
1766
case 75:
1578
 
#line 575 "yacc.yy"
 
1767
#line 591 "yacc.yy"
1579
1768
{
1580
 
            yyval.node = new KSParseNode( t_input );
1581
 
          ;
 
1769
            yyval.node = new KSParseNode( t_input );
 
1770
          ;
1582
1771
    break;}
1583
1772
case 76:
1584
 
#line 579 "yacc.yy"
 
1773
#line 595 "yacc.yy"
1585
1774
{
1586
 
            yyval.node = new KSParseNode( t_match_line );
1587
 
            yyval.node->setIdent( yyvsp[0]._str );
1588
 
          ;
 
1775
            yyval.node = new KSParseNode( t_match_line );
 
1776
            yyval.node->setIdent( yyvsp[0]._str );
 
1777
          ;
1589
1778
    break;}
1590
1779
case 77:
1591
 
#line 583 "yacc.yy"
 
1780
#line 599 "yacc.yy"
1592
1781
{ ;
1593
1782
    break;}
1594
1783
case 78:
1595
 
#line 585 "yacc.yy"
 
1784
#line 601 "yacc.yy"
1596
1785
{
1597
 
            yyval.node = yyvsp[-1].node;
1598
 
          ;
 
1786
            yyval.node = yyvsp[-1].node;
 
1787
          ;
1599
1788
    break;}
1600
1789
case 79:
1601
 
#line 594 "yacc.yy"
 
1790
#line 610 "yacc.yy"
1602
1791
{
1603
 
            yyval.node = new KSParseNode( t_integer_literal );
1604
 
            yyval.node->setIntegerLiteral( yyvsp[0]._int );
1605
 
          ;
 
1792
            yyval.node = new KSParseNode( t_integer_literal );
 
1793
            yyval.node->setIntegerLiteral( yyvsp[0]._int );
 
1794
          ;
1606
1795
    break;}
1607
1796
case 80:
1608
 
#line 599 "yacc.yy"
 
1797
#line 615 "yacc.yy"
1609
1798
{
1610
 
            yyval.node = new KSParseNode( t_cell );
1611
 
            yyval.node->setStringLiteral( yyvsp[0]._str );
1612
 
          ;
 
1799
            yyval.node = new KSParseNode( t_cell );
 
1800
            yyval.node->setStringLiteral( yyvsp[0]._str );
 
1801
          ;
1613
1802
    break;}
1614
1803
case 81:
1615
 
#line 604 "yacc.yy"
 
1804
#line 620 "yacc.yy"
1616
1805
{
1617
 
            yyval.node = new KSParseNode( t_range );
1618
 
            yyval.node->setStringLiteral( yyvsp[0]._str );
1619
 
          ;
 
1806
            yyval.node = new KSParseNode( t_range );
 
1807
            yyval.node->setStringLiteral( yyvsp[0]._str );
 
1808
          ;
1620
1809
    break;}
1621
1810
case 82:
1622
 
#line 609 "yacc.yy"
 
1811
#line 625 "yacc.yy"
1623
1812
{
1624
 
            yyval.node = new KSParseNode( t_string_literal );
1625
 
            yyval.node->setStringLiteral( yyvsp[0]._str );
1626
 
          ;
 
1813
            yyval.node = new KSParseNode( t_string_literal );
 
1814
            yyval.node->setStringLiteral( yyvsp[0]._str );
 
1815
          ;
1627
1816
    break;}
1628
1817
case 83:
1629
 
#line 614 "yacc.yy"
 
1818
#line 630 "yacc.yy"
1630
1819
{
1631
 
            yyval.node = new KSParseNode( t_character_literal );
1632
 
            yyval.node->setCharacterLiteral( yyvsp[0]._char );
1633
 
          ;
 
1820
            yyval.node = new KSParseNode( t_character_literal );
 
1821
            yyval.node->setCharacterLiteral( yyvsp[0]._char );
 
1822
          ;
1634
1823
    break;}
1635
1824
case 84:
1636
 
#line 619 "yacc.yy"
 
1825
#line 635 "yacc.yy"
1637
1826
{
1638
 
            yyval.node = new KSParseNode( t_floating_pt_literal );
1639
 
            yyval.node->setFloatingPtLiteral( yyvsp[0]._float );
1640
 
          ;
 
1827
            yyval.node = new KSParseNode( t_floating_pt_literal );
 
1828
            yyval.node->setFloatingPtLiteral( yyvsp[0]._float );
 
1829
          ;
1641
1830
    break;}
1642
1831
case 85:
1643
 
#line 624 "yacc.yy"
 
1832
#line 640 "yacc.yy"
1644
1833
{
1645
 
            yyval.node = new KSParseNode( t_boolean_literal );
1646
 
            yyval.node->setBooleanLiteral( true );
1647
 
          ;
 
1834
            yyval.node = new KSParseNode( t_boolean_literal );
 
1835
            yyval.node->setBooleanLiteral( true );
 
1836
          ;
1648
1837
    break;}
1649
1838
case 86:
1650
 
#line 629 "yacc.yy"
 
1839
#line 645 "yacc.yy"
1651
1840
{
1652
 
            yyval.node = new KSParseNode( t_boolean_literal );
1653
 
            yyval.node->setBooleanLiteral( false );
1654
 
          ;
 
1841
            yyval.node = new KSParseNode( t_boolean_literal );
 
1842
            yyval.node->setBooleanLiteral( false );
 
1843
          ;
1655
1844
    break;}
1656
1845
case 87:
1657
 
#line 634 "yacc.yy"
 
1846
#line 650 "yacc.yy"
1658
1847
{
1659
 
            yyval.node = new KSParseNode( t_array_const );
1660
 
          ;
 
1848
            yyval.node = new KSParseNode( t_array_const );
 
1849
          ;
1661
1850
    break;}
1662
1851
case 88:
1663
 
#line 638 "yacc.yy"
 
1852
#line 654 "yacc.yy"
1664
1853
{
1665
 
            yyval.node = new KSParseNode( t_array_const, yyvsp[-1].node );
1666
 
          ;
 
1854
            yyval.node = new KSParseNode( t_array_const, yyvsp[-1].node );
 
1855
          ;
1667
1856
    break;}
1668
1857
case 89:
1669
 
#line 642 "yacc.yy"
 
1858
#line 658 "yacc.yy"
1670
1859
{
1671
 
            yyval.node = new KSParseNode( t_dict_const );
1672
 
          ;
 
1860
            yyval.node = new KSParseNode( t_dict_const );
 
1861
          ;
1673
1862
    break;}
1674
1863
case 90:
1675
 
#line 646 "yacc.yy"
 
1864
#line 662 "yacc.yy"
1676
1865
{
1677
 
            yyval.node = new KSParseNode( t_dict_const, yyvsp[-1].node );
1678
 
          ;
 
1866
            yyval.node = new KSParseNode( t_dict_const, yyvsp[-1].node );
 
1867
          ;
1679
1868
    break;}
1680
1869
case 91:
1681
 
#line 650 "yacc.yy"
 
1870
#line 666 "yacc.yy"
1682
1871
{
1683
 
            yyval.node = new KSParseNode( t_line );
1684
 
          ;
 
1872
            yyval.node = new KSParseNode( t_line );
 
1873
          ;
1685
1874
    break;}
1686
1875
case 92:
1687
 
#line 654 "yacc.yy"
 
1876
#line 670 "yacc.yy"
1688
1877
{
1689
 
            yyval.node = new KSParseNode( t_regexp_group );
1690
 
            yyval.node->setIntegerLiteral( yyvsp[0]._int );
1691
 
          ;
 
1878
            yyval.node = new KSParseNode( t_regexp_group );
 
1879
            yyval.node->setIntegerLiteral( yyvsp[0]._int );
 
1880
          ;
1692
1881
    break;}
1693
1882
case 93:
1694
 
#line 662 "yacc.yy"
 
1883
#line 678 "yacc.yy"
1695
1884
{
1696
 
            yyval.node = new KSParseNode( t_array_element, yyvsp[-2].node, yyvsp[0].node );
1697
 
          ;
 
1885
            yyval.node = new KSParseNode( t_array_element, yyvsp[-2].node, yyvsp[0].node );
 
1886
          ;
1698
1887
    break;}
1699
1888
case 94:
1700
 
#line 666 "yacc.yy"
 
1889
#line 682 "yacc.yy"
1701
1890
{
1702
 
            yyval.node = new KSParseNode( t_array_element, yyvsp[0].node  );
1703
 
          ;
 
1891
            yyval.node = new KSParseNode( t_array_element, yyvsp[0].node  );
 
1892
          ;
1704
1893
    break;}
1705
1894
case 95:
1706
 
#line 673 "yacc.yy"
 
1895
#line 689 "yacc.yy"
1707
1896
{
1708
 
            yyval.node = new KSParseNode( t_dict_element, yyvsp[-5].node, yyvsp[-3].node, yyvsp[0].node );
1709
 
          ;
 
1897
            yyval.node = new KSParseNode( t_dict_element, yyvsp[-5].node, yyvsp[-3].node, yyvsp[0].node );
 
1898
          ;
1710
1899
    break;}
1711
1900
case 96:
1712
 
#line 677 "yacc.yy"
 
1901
#line 693 "yacc.yy"
1713
1902
{
1714
 
            yyval.node = new KSParseNode( t_dict_element, yyvsp[-3].node, yyvsp[-1].node );
1715
 
          ;
 
1903
            yyval.node = new KSParseNode( t_dict_element, yyvsp[-3].node, yyvsp[-1].node );
 
1904
          ;
1716
1905
    break;}
1717
1906
case 97:
1718
 
#line 687 "yacc.yy"
 
1907
#line 703 "yacc.yy"
1719
1908
{
1720
 
            yyval.node = new KSParseNode( t_struct, yyvsp[-1].node );
1721
 
            yyval.node->setIdent( yyvsp[-5].ident );
1722
 
          ;
 
1909
            yyval.node = new KSParseNode( t_struct, yyvsp[-1].node );
 
1910
            yyval.node->setIdent( yyvsp[-3].ident );
 
1911
          ;
1723
1912
    break;}
1724
1913
case 98:
1725
 
#line 696 "yacc.yy"
 
1914
#line 712 "yacc.yy"
1726
1915
{
1727
 
            if ( yyvsp[0].node != 0 )
1728
 
            {
1729
 
                yyval.node = new KSParseNode( exports, yyvsp[0].node );
1730
 
            }
1731
 
          ;
 
1916
            if ( yyvsp[0].node != 0 )
 
1917
            {
 
1918
                yyval.node = new KSParseNode( exports, yyvsp[0].node );
 
1919
            }
 
1920
          ;
1732
1921
    break;}
1733
1922
case 99:
1734
 
#line 703 "yacc.yy"
 
1923
#line 719 "yacc.yy"
1735
1924
{
1736
 
            if ( yyvsp[-1].node != 0 && yyvsp[0].node != 0 )
1737
 
            {
1738
 
                yyval.node = new KSParseNode( exports, yyvsp[-1].node );
1739
 
                yyval.node->setBranch( 2, yyvsp[0].node );
1740
 
            }
1741
 
            else if ( yyvsp[-1].node != 0 )
1742
 
            {
1743
 
                yyval.node = new KSParseNode( exports, yyvsp[-1].node );
1744
 
            }
1745
 
            else if ( yyvsp[0].node != 0 )
1746
 
            {
1747
 
                yyval.node = new KSParseNode( exports, yyvsp[0].node );
1748
 
            }
1749
 
            else
1750
 
            {
1751
 
                yyval.node = 0;
1752
 
            }
1753
 
          ;
 
1925
            if ( yyvsp[-1].node != 0 && yyvsp[0].node != 0 )
 
1926
            {
 
1927
                yyval.node = new KSParseNode( exports, yyvsp[-1].node );
 
1928
                yyval.node->setBranch( 2, yyvsp[0].node );
 
1929
            }
 
1930
            else if ( yyvsp[-1].node != 0 )
 
1931
            {
 
1932
                yyval.node = new KSParseNode( exports, yyvsp[-1].node );
 
1933
            }
 
1934
            else if ( yyvsp[0].node != 0 )
 
1935
            {
 
1936
                yyval.node = new KSParseNode( exports, yyvsp[0].node );
 
1937
            }
 
1938
            else
 
1939
            {
 
1940
                yyval.node = 0;
 
1941
            }
 
1942
          ;
1754
1943
    break;}
1755
1944
case 100:
1756
 
#line 726 "yacc.yy"
 
1945
#line 742 "yacc.yy"
1757
1946
{
1758
 
            yyval.node = 0;
1759
 
          ;
 
1947
            yyval.node = yyvsp[-1].node;
 
1948
          ;
1760
1949
    break;}
1761
1950
case 101:
1762
 
#line 730 "yacc.yy"
 
1951
#line 746 "yacc.yy"
1763
1952
{
1764
 
            yyval.node = yyvsp[-1].node;
1765
 
          ;
 
1953
            yyval.node = yyvsp[-1].node;
 
1954
          ;
1766
1955
    break;}
1767
1956
case 102:
1768
 
#line 734 "yacc.yy"
 
1957
#line 750 "yacc.yy"
1769
1958
{
1770
 
            yyval.node = yyvsp[-1].node;
1771
 
          ;
 
1959
            yyval.node = yyvsp[-1].node;
 
1960
          ;
1772
1961
    break;}
1773
1962
case 103:
1774
 
#line 738 "yacc.yy"
 
1963
#line 757 "yacc.yy"
1775
1964
{
1776
 
            yyval.node = yyvsp[-1].node;
1777
 
          ;
 
1965
            yyval.node = new KSParseNode( t_struct_members );
 
1966
            yyval.node->setIdent( yyvsp[0].ident );
 
1967
          ;
1778
1968
    break;}
1779
1969
case 104:
1780
 
#line 745 "yacc.yy"
 
1970
#line 762 "yacc.yy"
1781
1971
{
1782
 
            yyval.node = new KSParseNode( t_struct_members );
1783
 
            yyval.node->setIdent( yyvsp[0].ident );
1784
 
          ;
 
1972
            yyval.node = new KSParseNode( t_struct_members, yyvsp[0].node );
 
1973
            yyval.node->setIdent( yyvsp[-2].ident );
 
1974
          ;
1785
1975
    break;}
1786
1976
case 105:
1787
 
#line 750 "yacc.yy"
 
1977
#line 770 "yacc.yy"
1788
1978
{
1789
 
            yyval.node = new KSParseNode( t_struct_members, yyvsp[0].node );
1790
 
            yyval.node->setIdent( yyvsp[-2].ident );
1791
 
          ;
 
1979
            yyval.node = new KSParseNode( func_dcl );
 
1980
            yyval.node->setBranch( 2, yyvsp[0].node );
 
1981
            yyval.node->setIdent( yyvsp[-4].ident );
 
1982
          ;
1792
1983
    break;}
1793
1984
case 106:
1794
 
#line 758 "yacc.yy"
 
1985
#line 776 "yacc.yy"
1795
1986
{
1796
 
            yyval.node = new KSParseNode( func_dcl );
1797
 
            yyval.node->setBranch( 2, yyvsp[0].node );
1798
 
            yyval.node->setIdent( yyvsp[-6].ident );
1799
 
          ;
 
1987
            yyval.node = new KSParseNode( func_dcl, yyvsp[-3].node, yyvsp[0].node );
 
1988
            yyval.node->setIdent( yyvsp[-5].ident );
 
1989
          ;
1800
1990
    break;}
1801
1991
case 107:
1802
 
#line 764 "yacc.yy"
 
1992
#line 784 "yacc.yy"
1803
1993
{
1804
 
            yyval.node = new KSParseNode( func_dcl, yyvsp[-5].node, yyvsp[0].node );
1805
 
            yyval.node->setIdent( yyvsp[-7].ident );
1806
 
          ;
 
1994
            yyval.node = new KSParseNode( func_params, yyvsp[0].node );
 
1995
          ;
1807
1996
    break;}
1808
1997
case 108:
1809
 
#line 772 "yacc.yy"
 
1998
#line 788 "yacc.yy"
1810
1999
{
1811
 
            yyval.node = new KSParseNode( func_params, yyvsp[0].node );
1812
 
          ;
 
2000
            yyval.node = new KSParseNode( func_params, yyvsp[-2].node, yyvsp[0].node );
 
2001
          ;
1813
2002
    break;}
1814
2003
case 109:
1815
 
#line 776 "yacc.yy"
 
2004
#line 795 "yacc.yy"
1816
2005
{
1817
 
            yyval.node = new KSParseNode( func_params, yyvsp[-2].node, yyvsp[0].node );
1818
 
          ;
 
2006
            yyval.node = new KSParseNode( func_param_in );
 
2007
            yyval.node->setIdent( yyvsp[0].ident );
 
2008
          ;
1819
2009
    break;}
1820
2010
case 110:
1821
 
#line 783 "yacc.yy"
 
2011
#line 800 "yacc.yy"
1822
2012
{
1823
 
            yyval.node = new KSParseNode( func_param_in );
1824
 
            yyval.node->setIdent( yyvsp[0].ident );
1825
 
          ;
 
2013
            yyval.node = new KSParseNode( func_param_in, yyvsp[0].node );
 
2014
            yyval.node->setIdent( yyvsp[-2].ident );
 
2015
          ;
1826
2016
    break;}
1827
2017
case 111:
1828
 
#line 788 "yacc.yy"
 
2018
#line 805 "yacc.yy"
1829
2019
{
1830
 
            yyval.node = new KSParseNode( func_param_in, yyvsp[0].node );
1831
 
            yyval.node->setIdent( yyvsp[-2].ident );
1832
 
          ;
 
2020
            yyval.node = new KSParseNode( func_param_out );
 
2021
            yyval.node->setIdent( yyvsp[0].ident );
 
2022
          ;
1833
2023
    break;}
1834
2024
case 112:
1835
 
#line 793 "yacc.yy"
 
2025
#line 810 "yacc.yy"
1836
2026
{
1837
 
            yyval.node = new KSParseNode( func_param_out );
1838
 
            yyval.node->setIdent( yyvsp[0].ident );
1839
 
          ;
 
2027
            yyval.node = new KSParseNode( func_param_inout );
 
2028
            yyval.node->setIdent( yyvsp[0].ident );
 
2029
          ;
1840
2030
    break;}
1841
2031
case 113:
1842
 
#line 798 "yacc.yy"
 
2032
#line 818 "yacc.yy"
1843
2033
{
1844
 
            yyval.node = new KSParseNode( func_param_inout );
1845
 
            yyval.node->setIdent( yyvsp[0].ident );
1846
 
          ;
 
2034
            yyval.node = NULL;
 
2035
          ;
1847
2036
    break;}
1848
2037
case 114:
1849
 
#line 806 "yacc.yy"
 
2038
#line 822 "yacc.yy"
1850
2039
{
1851
 
            yyval.node = NULL;
1852
 
          ;
 
2040
            yyval.node = yyvsp[0].node;
 
2041
          ;
1853
2042
    break;}
1854
2043
case 115:
1855
 
#line 810 "yacc.yy"
 
2044
#line 829 "yacc.yy"
1856
2045
{
1857
 
            yyval.node = yyvsp[0].node;
1858
 
          ;
 
2046
            yyval.node = new KSParseNode( func_lines, yyvsp[0].node );
 
2047
          ;
1859
2048
    break;}
1860
2049
case 116:
1861
 
#line 817 "yacc.yy"
 
2050
#line 833 "yacc.yy"
1862
2051
{
1863
 
            yyval.node = new KSParseNode( func_lines, yyvsp[0].node );
1864
 
          ;
 
2052
            yyval.node = new KSParseNode( func_lines, yyvsp[-1].node );
 
2053
            yyval.node->setBranch( 2, yyvsp[0].node );
 
2054
          ;
1865
2055
    break;}
1866
2056
case 117:
1867
 
#line 821 "yacc.yy"
 
2057
#line 841 "yacc.yy"
1868
2058
{
1869
 
            yyval.node = new KSParseNode( func_lines, yyvsp[-1].node );
1870
 
            yyval.node->setBranch( 2, yyvsp[0].node );
1871
 
          ;
 
2059
            yyval.node = yyvsp[-1].node;
 
2060
          ;
1872
2061
    break;}
1873
2062
case 118:
1874
 
#line 829 "yacc.yy"
 
2063
#line 845 "yacc.yy"
1875
2064
{
1876
 
            yyval.node = yyvsp[-1].node;
1877
 
          ;
 
2065
            yyval.node = new KSParseNode( t_raise, yyvsp[-3].node, yyvsp[-1].node );
 
2066
          ;
1878
2067
    break;}
1879
2068
case 119:
1880
 
#line 833 "yacc.yy"
 
2069
#line 849 "yacc.yy"
1881
2070
{
1882
 
            yyval.node = new KSParseNode( t_raise, yyvsp[-3].node, yyvsp[-1].node );
1883
 
          ;
 
2071
            yyval.node = new KSParseNode( t_return );
 
2072
          ;
1884
2073
    break;}
1885
2074
case 120:
1886
 
#line 837 "yacc.yy"
 
2075
#line 853 "yacc.yy"
1887
2076
{
1888
 
            yyval.node = new KSParseNode( t_return );
1889
 
          ;
 
2077
            yyval.node = new KSParseNode( t_return, yyvsp[-1].node );
 
2078
          ;
1890
2079
    break;}
1891
2080
case 121:
1892
 
#line 841 "yacc.yy"
 
2081
#line 857 "yacc.yy"
1893
2082
{
1894
 
            yyval.node = new KSParseNode( t_return, yyvsp[-1].node );
1895
 
          ;
 
2083
            yyval.node = yyvsp[0].node;
 
2084
          ;
1896
2085
    break;}
1897
2086
case 122:
1898
 
#line 845 "yacc.yy"
 
2087
#line 861 "yacc.yy"
1899
2088
{
1900
 
            yyval.node = yyvsp[0].node;
1901
 
          ;
 
2089
            yyval.node = new KSParseNode( t_try, yyvsp[-2].node, yyvsp[0].node );
 
2090
          ;
1902
2091
    break;}
1903
2092
case 123:
1904
 
#line 849 "yacc.yy"
 
2093
#line 865 "yacc.yy"
1905
2094
{
1906
 
            yyval.node = new KSParseNode( t_try, yyvsp[-2].node, yyvsp[0].node );
1907
 
          ;
 
2095
            yyval.node = new KSParseNode( t_scope, yyvsp[-1].node );
 
2096
          ;
1908
2097
    break;}
1909
2098
case 124:
1910
 
#line 853 "yacc.yy"
 
2099
#line 872 "yacc.yy"
1911
2100
{
1912
 
            yyval.node = new KSParseNode( t_scope, yyvsp[-1].node );
1913
 
          ;
 
2101
            yyval.node = yyvsp[0].node;
 
2102
          ;
1914
2103
    break;}
1915
2104
case 125:
1916
 
#line 860 "yacc.yy"
 
2105
#line 876 "yacc.yy"
1917
2106
{
1918
 
            yyval.node = yyvsp[0].node;
1919
 
          ;
 
2107
            yyval.node = yyvsp[-1].node;
 
2108
            yyval.node->setBranch( 4, yyvsp[0].node );
 
2109
          ;
1920
2110
    break;}
1921
2111
case 126:
1922
 
#line 864 "yacc.yy"
 
2112
#line 885 "yacc.yy"
1923
2113
{
1924
 
            yyval.node = yyvsp[-1].node;
1925
 
            yyval.node->setBranch( 4, yyvsp[0].node );
1926
 
          ;
 
2114
            yyval.node = new KSParseNode( t_catch, yyvsp[-6].node, yyvsp[-1].node );
 
2115
            yyval.node->setIdent( yyvsp[-4].ident );
 
2116
          ;
1927
2117
    break;}
1928
2118
case 127:
1929
 
#line 873 "yacc.yy"
 
2119
#line 891 "yacc.yy"
1930
2120
{
1931
 
            yyval.node = new KSParseNode( t_catch, yyvsp[-6].node, yyvsp[-1].node );
1932
 
            yyval.node->setIdent( yyvsp[-4].ident );
1933
 
          ;
 
2121
            KSParseNode* x = new KSParseNode( scoped_name );
 
2122
            x->setIdent( yyvsp[-6].ident );
 
2123
            yyval.node = new KSParseNode( t_catch_default, x, yyvsp[-1].node );
 
2124
            yyval.node->setIdent( yyvsp[-4].ident );
 
2125
          ;
1934
2126
    break;}
1935
2127
case 128:
1936
 
#line 879 "yacc.yy"
 
2128
#line 901 "yacc.yy"
1937
2129
{
1938
 
            KSParseNode* x = new KSParseNode( scoped_name );
1939
 
            x->setIdent( yyvsp[-6].ident );
1940
 
            yyval.node = new KSParseNode( t_catch_default, x, yyvsp[-1].node );
1941
 
            yyval.node->setIdent( yyvsp[-4].ident );
1942
 
          ;
 
2130
            yyval.node = new KSParseNode( const_dcl, yyvsp[0].node );
 
2131
            yyval.node->setIdent( yyvsp[-2].ident );
 
2132
          ;
1943
2133
    break;}
1944
2134
case 129:
1945
 
#line 889 "yacc.yy"
 
2135
#line 909 "yacc.yy"
1946
2136
{
1947
 
            yyval.node = new KSParseNode( const_dcl, yyvsp[0].node );
1948
 
            yyval.node->setIdent( yyvsp[-2].ident );
1949
 
          ;
 
2137
            yyval.node = new KSParseNode( t_while, yyvsp[-1].node, yyvsp[0].node );
 
2138
          ;
1950
2139
    break;}
1951
2140
case 130:
1952
 
#line 897 "yacc.yy"
 
2141
#line 913 "yacc.yy"
1953
2142
{
1954
 
            yyval.node = new KSParseNode( t_while, yyvsp[-1].node, yyvsp[0].node );
1955
 
          ;
 
2143
            yyval.node = new KSParseNode( t_for, yyvsp[-6].node, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node );
 
2144
          ;
1956
2145
    break;}
1957
2146
case 131:
1958
 
#line 901 "yacc.yy"
 
2147
#line 917 "yacc.yy"
1959
2148
{
1960
 
            yyval.node = new KSParseNode( t_for, yyvsp[-6].node, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node );
1961
 
          ;
 
2149
            yyval.node = new KSParseNode( t_do, yyvsp[-2].node, yyvsp[-1].node );
 
2150
          ;
1962
2151
    break;}
1963
2152
case 132:
1964
 
#line 905 "yacc.yy"
 
2153
#line 921 "yacc.yy"
1965
2154
{
1966
 
            yyval.node = new KSParseNode( t_do, yyvsp[-2].node, yyvsp[-1].node );
1967
 
          ;
 
2155
            yyval.node = new KSParseNode( t_if, yyvsp[-3].node, yyvsp[-1].node, yyvsp[0].node );
 
2156
          ;
1968
2157
    break;}
1969
2158
case 133:
1970
 
#line 909 "yacc.yy"
 
2159
#line 925 "yacc.yy"
1971
2160
{
1972
 
            yyval.node = new KSParseNode( t_if, yyvsp[-3].node, yyvsp[-1].node, yyvsp[0].node );
1973
 
          ;
 
2161
            yyval.node = new KSParseNode( t_foreach, yyvsp[-2].node, yyvsp[0].node );
 
2162
            yyval.node->setIdent( yyvsp[-4].ident );
 
2163
          ;
1974
2164
    break;}
1975
2165
case 134:
1976
 
#line 913 "yacc.yy"
 
2166
#line 930 "yacc.yy"
1977
2167
{
1978
 
            yyval.node = new KSParseNode( t_foreach, yyvsp[-2].node, yyvsp[0].node );
1979
 
            yyval.node->setIdent( yyvsp[-4].ident );
1980
 
          ;
 
2168
            /* We set $9 twice to indicate thet this is the foreach for maps */
 
2169
            yyval.node = new KSParseNode( t_foreach, yyvsp[-2].node, yyvsp[0].node, yyvsp[0].node );
 
2170
            yyval.node->setIdent( yyvsp[-6].ident );
 
2171
            yyval.node->setStringLiteral( yyvsp[-4].ident );
 
2172
          ;
1981
2173
    break;}
1982
2174
case 135:
1983
 
#line 918 "yacc.yy"
 
2175
#line 940 "yacc.yy"
1984
2176
{
1985
 
            /* We set $9 twice to indicate thet this is the foreach for maps */
1986
 
            yyval.node = new KSParseNode( t_foreach, yyvsp[-2].node, yyvsp[0].node, yyvsp[0].node );
1987
 
            yyval.node->setIdent( yyvsp[-6].ident );
1988
 
            yyval.node->setStringLiteral( yyvsp[-4].ident );
1989
 
          ;
 
2177
            yyval.node = NULL;
 
2178
          ;
1990
2179
    break;}
1991
2180
case 136:
1992
 
#line 928 "yacc.yy"
 
2181
#line 944 "yacc.yy"
1993
2182
{
1994
 
            yyval.node = NULL;
1995
 
          ;
 
2183
            yyval.node = new KSParseNode( t_if, yyvsp[-3].node, yyvsp[-1].node, yyvsp[0].node );
 
2184
          ;
1996
2185
    break;}
1997
2186
case 137:
1998
 
#line 932 "yacc.yy"
 
2187
#line 948 "yacc.yy"
1999
2188
{
2000
 
            yyval.node = new KSParseNode( t_if, yyvsp[-3].node, yyvsp[-1].node, yyvsp[0].node );
2001
 
          ;
 
2189
            yyval.node = yyvsp[0].node;
 
2190
          ;
2002
2191
    break;}
2003
2192
case 138:
2004
 
#line 936 "yacc.yy"
 
2193
#line 955 "yacc.yy"
2005
2194
{
2006
 
            yyval.node = yyvsp[0].node;
2007
 
          ;
 
2195
            yyval.node = yyvsp[-1].node;
 
2196
          ;
2008
2197
    break;}
2009
2198
case 139:
2010
 
#line 943 "yacc.yy"
2011
 
{
2012
 
            yyval.node = yyvsp[-1].node;
2013
 
          ;
2014
 
    break;}
2015
 
case 140:
2016
 
#line 950 "yacc.yy"
2017
 
{
2018
 
            yyval.node = new KSParseNode( t_scope, yyvsp[-1].node );
2019
 
          ;
 
2199
#line 962 "yacc.yy"
 
2200
{
 
2201
            yyval.node = new KSParseNode( t_scope, yyvsp[-1].node );
 
2202
          ;
2020
2203
    break;}
2021
2204
}
2022
 
   /* the action file gets copied in in place of this dollarsign */
2023
 
#line 543 "//usr/lib/bison.simple"
 
2205
 
 
2206
#line 705 "/usr/share/bison/bison.simple"
 
2207
 
2024
2208
 
2025
2209
  yyvsp -= yylen;
2026
2210
  yyssp -= yylen;
2027
 
#ifdef YYLSP_NEEDED
 
2211
#if YYLSP_NEEDED
2028
2212
  yylsp -= yylen;
2029
2213
#endif
2030
2214
 
2031
 
#if YYDEBUG != 0
 
2215
#if YYDEBUG
2032
2216
  if (yydebug)
2033
2217
    {
2034
 
      short *ssp1 = yyss - 1;
2035
 
      fprintf (stderr, "state stack now");
2036
 
      while (ssp1 != yyssp)
2037
 
        fprintf (stderr, " %d", *++ssp1);
2038
 
      fprintf (stderr, "\n");
 
2218
      short *yyssp1 = yyss - 1;
 
2219
      YYFPRINTF (stderr, "state stack now");
 
2220
      while (yyssp1 != yyssp)
 
2221
        YYFPRINTF (stderr, " %d", *++yyssp1);
 
2222
      YYFPRINTF (stderr, "\n");
2039
2223
    }
2040
2224
#endif
2041
2225
 
2042
2226
  *++yyvsp = yyval;
2043
 
 
2044
 
#ifdef YYLSP_NEEDED
2045
 
  yylsp++;
2046
 
  if (yylen == 0)
2047
 
    {
2048
 
      yylsp->first_line = yylloc.first_line;
2049
 
      yylsp->first_column = yylloc.first_column;
2050
 
      yylsp->last_line = (yylsp-1)->last_line;
2051
 
      yylsp->last_column = (yylsp-1)->last_column;
2052
 
      yylsp->text = 0;
2053
 
    }
2054
 
  else
2055
 
    {
2056
 
      yylsp->last_line = (yylsp+yylen-1)->last_line;
2057
 
      yylsp->last_column = (yylsp+yylen-1)->last_column;
2058
 
    }
 
2227
#if YYLSP_NEEDED
 
2228
  *++yylsp = yyloc;
2059
2229
#endif
2060
2230
 
2061
 
  /* Now "shift" the result of the reduction.
2062
 
     Determine what state that goes to,
2063
 
     based on the state we popped back to
2064
 
     and the rule number reduced by.  */
 
2231
  /* Now `shift' the result of the reduction.  Determine what state
 
2232
     that goes to, based on the state we popped back to and the rule
 
2233
     number reduced by.  */
2065
2234
 
2066
2235
  yyn = yyr1[yyn];
2067
2236
 
2073
2242
 
2074
2243
  goto yynewstate;
2075
2244
 
2076
 
yyerrlab:   /* here on detecting error */
2077
2245
 
2078
 
  if (! yyerrstatus)
2079
 
    /* If not already recovering from an error, report this error.  */
 
2246
/*------------------------------------.
 
2247
| yyerrlab -- here on detecting error |
 
2248
`------------------------------------*/
 
2249
yyerrlab:
 
2250
  /* If not already recovering from an error, report this error.  */
 
2251
  if (!yyerrstatus)
2080
2252
    {
2081
2253
      ++yynerrs;
2082
2254
 
2085
2257
 
2086
2258
      if (yyn > YYFLAG && yyn < YYLAST)
2087
2259
        {
2088
 
          int size = 0;
2089
 
          char *msg;
2090
 
          int x, count;
 
2260
          YYSIZE_T yysize = 0;
 
2261
          char *yymsg;
 
2262
          int yyx, yycount;
2091
2263
 
2092
 
          count = 0;
2093
 
          /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
2094
 
          for (x = (yyn < 0 ? -yyn : 0);
2095
 
               x < (sizeof(yytname) / sizeof(char *)); x++)
2096
 
            if (yycheck[x + yyn] == x)
2097
 
              size += strlen(yytname[x]) + 15, count++;
2098
 
          msg = (char *) malloc(size + 15);
2099
 
          if (msg != 0)
 
2264
          yycount = 0;
 
2265
          /* Start YYX at -YYN if negative to avoid negative indexes in
 
2266
             YYCHECK.  */
 
2267
          for (yyx = yyn < 0 ? -yyn : 0;
 
2268
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
 
2269
            if (yycheck[yyx + yyn] == yyx)
 
2270
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
 
2271
          yysize += yystrlen ("parse error, unexpected ") + 1;
 
2272
          yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
 
2273
          yymsg = (char *) YYSTACK_ALLOC (yysize);
 
2274
          if (yymsg != 0)
2100
2275
            {
2101
 
              strcpy(msg, "parse error");
 
2276
              char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
 
2277
              yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
2102
2278
 
2103
 
              if (count < 5)
 
2279
              if (yycount < 5)
2104
2280
                {
2105
 
                  count = 0;
2106
 
                  for (x = (yyn < 0 ? -yyn : 0);
2107
 
                       x < (sizeof(yytname) / sizeof(char *)); x++)
2108
 
                    if (yycheck[x + yyn] == x)
 
2281
                  yycount = 0;
 
2282
                  for (yyx = yyn < 0 ? -yyn : 0;
 
2283
                       yyx < (int) (sizeof (yytname) / sizeof (char *));
 
2284
                       yyx++)
 
2285
                    if (yycheck[yyx + yyn] == yyx)
2109
2286
                      {
2110
 
                        strcat(msg, count == 0 ? ", expecting `" : " or `");
2111
 
                        strcat(msg, yytname[x]);
2112
 
                        strcat(msg, "'");
2113
 
                        count++;
 
2287
                        const char *yyq = ! yycount ? ", expecting " : " or ";
 
2288
                        yyp = yystpcpy (yyp, yyq);
 
2289
                        yyp = yystpcpy (yyp, yytname[yyx]);
 
2290
                        yycount++;
2114
2291
                      }
2115
2292
                }
2116
 
              yyerror(msg);
2117
 
              free(msg);
 
2293
              yyerror (yymsg);
 
2294
              YYSTACK_FREE (yymsg);
2118
2295
            }
2119
2296
          else
2120
 
            yyerror ("parse error; also virtual memory exceeded");
 
2297
            yyerror ("parse error; also virtual memory exhausted");
2121
2298
        }
2122
2299
      else
2123
 
#endif /* YYERROR_VERBOSE */
2124
 
        yyerror("parse error");
 
2300
#endif /* defined (YYERROR_VERBOSE) */
 
2301
        yyerror ("parse error");
2125
2302
    }
2126
 
 
2127
2303
  goto yyerrlab1;
2128
 
yyerrlab1:   /* here on error raised explicitly by an action */
2129
 
 
 
2304
 
 
2305
 
 
2306
/*--------------------------------------------------.
 
2307
| yyerrlab1 -- error raised explicitly by an action |
 
2308
`--------------------------------------------------*/
 
2309
yyerrlab1:
2130
2310
  if (yyerrstatus == 3)
2131
2311
    {
2132
 
      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
 
2312
      /* If just tried and failed to reuse lookahead token after an
 
2313
         error, discard it.  */
2133
2314
 
2134
2315
      /* return failure if at end of input */
2135
2316
      if (yychar == YYEOF)
2136
2317
        YYABORT;
2137
 
 
2138
 
#if YYDEBUG != 0
2139
 
      if (yydebug)
2140
 
        fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
2141
 
#endif
2142
 
 
 
2318
      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
 
2319
                  yychar, yytname[yychar1]));
2143
2320
      yychar = YYEMPTY;
2144
2321
    }
2145
2322
 
2146
 
  /* Else will try to reuse lookahead token
2147
 
     after shifting the error token.  */
 
2323
  /* Else will try to reuse lookahead token after shifting the error
 
2324
     token.  */
2148
2325
 
2149
2326
  yyerrstatus = 3;              /* Each real token shifted decrements this */
2150
2327
 
2151
2328
  goto yyerrhandle;
2152
2329
 
2153
 
yyerrdefault:  /* current state does not do anything special for the error token. */
2154
2330
 
 
2331
/*-------------------------------------------------------------------.
 
2332
| yyerrdefault -- current state does not do anything special for the |
 
2333
| error token.                                                       |
 
2334
`-------------------------------------------------------------------*/
 
2335
yyerrdefault:
2155
2336
#if 0
2156
2337
  /* This is wrong; only states that explicitly want error tokens
2157
2338
     should shift them.  */
2158
 
  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
2159
 
  if (yyn) goto yydefault;
 
2339
 
 
2340
  /* If its default is to accept any token, ok.  Otherwise pop it.  */
 
2341
  yyn = yydefact[yystate];
 
2342
  if (yyn)
 
2343
    goto yydefault;
2160
2344
#endif
2161
2345
 
2162
 
yyerrpop:   /* pop the current state because it cannot handle the error token */
2163
2346
 
2164
 
  if (yyssp == yyss) YYABORT;
 
2347
/*---------------------------------------------------------------.
 
2348
| yyerrpop -- pop the current state because it cannot handle the |
 
2349
| error token                                                    |
 
2350
`---------------------------------------------------------------*/
 
2351
yyerrpop:
 
2352
  if (yyssp == yyss)
 
2353
    YYABORT;
2165
2354
  yyvsp--;
2166
2355
  yystate = *--yyssp;
2167
 
#ifdef YYLSP_NEEDED
 
2356
#if YYLSP_NEEDED
2168
2357
  yylsp--;
2169
2358
#endif
2170
2359
 
2171
 
#if YYDEBUG != 0
 
2360
#if YYDEBUG
2172
2361
  if (yydebug)
2173
2362
    {
2174
 
      short *ssp1 = yyss - 1;
2175
 
      fprintf (stderr, "Error: state stack now");
2176
 
      while (ssp1 != yyssp)
2177
 
        fprintf (stderr, " %d", *++ssp1);
2178
 
      fprintf (stderr, "\n");
 
2363
      short *yyssp1 = yyss - 1;
 
2364
      YYFPRINTF (stderr, "Error: state stack now");
 
2365
      while (yyssp1 != yyssp)
 
2366
        YYFPRINTF (stderr, " %d", *++yyssp1);
 
2367
      YYFPRINTF (stderr, "\n");
2179
2368
    }
2180
2369
#endif
2181
2370
 
 
2371
/*--------------.
 
2372
| yyerrhandle.  |
 
2373
`--------------*/
2182
2374
yyerrhandle:
2183
 
 
2184
2375
  yyn = yypact[yystate];
2185
2376
  if (yyn == YYFLAG)
2186
2377
    goto yyerrdefault;
2203
2394
  if (yyn == YYFINAL)
2204
2395
    YYACCEPT;
2205
2396
 
2206
 
#if YYDEBUG != 0
2207
 
  if (yydebug)
2208
 
    fprintf(stderr, "Shifting error token, ");
2209
 
#endif
 
2397
  YYDPRINTF ((stderr, "Shifting error token, "));
2210
2398
 
2211
2399
  *++yyvsp = yylval;
2212
 
#ifdef YYLSP_NEEDED
 
2400
#if YYLSP_NEEDED
2213
2401
  *++yylsp = yylloc;
2214
2402
#endif
2215
2403
 
2216
2404
  yystate = yyn;
2217
2405
  goto yynewstate;
2218
2406
 
2219
 
 yyacceptlab:
2220
 
  /* YYACCEPT comes here.  */
2221
 
  if (yyfree_stacks)
2222
 
    {
2223
 
      free (yyss);
2224
 
      free (yyvs);
2225
 
#ifdef YYLSP_NEEDED
2226
 
      free (yyls);
2227
 
#endif
2228
 
    }
2229
 
  return 0;
2230
 
 
2231
 
 yyabortlab:
2232
 
  /* YYABORT comes here.  */
2233
 
  if (yyfree_stacks)
2234
 
    {
2235
 
      free (yyss);
2236
 
      free (yyvs);
2237
 
#ifdef YYLSP_NEEDED
2238
 
      free (yyls);
2239
 
#endif
2240
 
    }
2241
 
  return 1;
 
2407
 
 
2408
/*-------------------------------------.
 
2409
| yyacceptlab -- YYACCEPT comes here.  |
 
2410
`-------------------------------------*/
 
2411
yyacceptlab:
 
2412
  yyresult = 0;
 
2413
  goto yyreturn;
 
2414
 
 
2415
/*-----------------------------------.
 
2416
| yyabortlab -- YYABORT comes here.  |
 
2417
`-----------------------------------*/
 
2418
yyabortlab:
 
2419
  yyresult = 1;
 
2420
  goto yyreturn;
 
2421
 
 
2422
/*---------------------------------------------.
 
2423
| yyoverflowab -- parser overflow comes here.  |
 
2424
`---------------------------------------------*/
 
2425
yyoverflowlab:
 
2426
  yyerror ("parser stack overflow");
 
2427
  yyresult = 2;
 
2428
  /* Fall through.  */
 
2429
 
 
2430
yyreturn:
 
2431
#ifndef yyoverflow
 
2432
  if (yyss != yyssa)
 
2433
    YYSTACK_FREE (yyss);
 
2434
#endif
 
2435
  return yyresult;
2242
2436
}
2243
 
#line 954 "yacc.yy"
 
2437
#line 966 "yacc.yy"
2244
2438
 
2245
2439
 
2246
2440
void kscriptParse( const char *_code, int extension, KLocale* locale )