Mercurial > hg > Members > nobuyasu > SampleSource

comparison Bison-Flex/BasicCompiler-StackBase/script-parser.cc @ 0:db40c85cad7a default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
upload sample source
author nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date Mon, 09 May 2011 03:11:59 +0900
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:db40c85cad7a
1 /* A Bison parser, made by GNU Bison 2.3. */
2
3 /* Skeleton implementation for Bison LALR(1) parsers in C++
4
5 Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 /* As a special exception, you may create a larger work that contains
23 part or all of the Bison parser skeleton and distribute that work
24 under terms of your choice, so long as that work isn't itself a
25 parser generator using the skeleton or a modified version thereof
26 as a parser skeleton. Alternatively, if you modify or redistribute
27 the parser skeleton itself, you may (at your option) remove this
28 special exception, which will cause the skeleton and the resulting
29 Bison output files to be licensed under the GNU General Public
30 License without this special exception.
31
32 This special exception was added by the Free Software Foundation in
33 version 2.2 of Bison. */
34
35
36 #include "script-parser.hh"
37
38 /* User implementation prologue. */
39 #line 36 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
40
41 #include "compiler.h"
42
43
44 /* Line 317 of lalr1.cc. */
45 #line 46 "script-parser.cc"
46
47 #ifndef YY_
48 # if YYENABLE_NLS
49 # if ENABLE_NLS
50 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
51 # define YY_(msgid) dgettext ("bison-runtime", msgid)
52 # endif
53 # endif
54 # ifndef YY_
55 # define YY_(msgid) msgid
56 # endif
57 #endif
58
59 /* Suppress unused-variable warnings by "using" E. */
60 #define YYUSE(e) ((void) (e))
61
62 /* A pseudo ostream that takes yydebug_ into account. */
63 # define YYCDEBUG \
64 for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false) \
65 (*yycdebug_)
66
67 /* Enable debugging if requested. */
68 #if YYDEBUG
69
70 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
71 do { \
72 if (yydebug_) \
73 { \
74 *yycdebug_ << Title << ' '; \
75 yy_symbol_print_ ((Type), (Value), (Location)); \
76 *yycdebug_ << std::endl; \
77 } \
78 } while (false)
79
80 # define YY_REDUCE_PRINT(Rule) \
81 do { \
82 if (yydebug_) \
83 yy_reduce_print_ (Rule); \
84 } while (false)
85
86 # define YY_STACK_PRINT() \
87 do { \
88 if (yydebug_) \
89 yystack_print_ (); \
90 } while (false)
91
92 #else /* !YYDEBUG */
93
94 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
95 # define YY_REDUCE_PRINT(Rule)
96 # define YY_STACK_PRINT()
97
98 #endif /* !YYDEBUG */
99
100 #define YYACCEPT goto yyacceptlab
101 #define YYABORT goto yyabortlab
102 #define YYERROR goto yyerrorlab
103
104 namespace yy
105 {
106 #if YYERROR_VERBOSE
107
108 /* Return YYSTR after stripping away unnecessary quotes and
109 backslashes, so that it's suitable for yyerror. The heuristic is
110 that double-quoting is unnecessary unless the string contains an
111 apostrophe, a comma, or backslash (other than backslash-backslash).
112 YYSTR is taken from yytname. */
113 std::string
114 script_parser::yytnamerr_ (const char *yystr)
115 {
116 if (*yystr == '"')
117 {
118 std::string yyr = "";
119 char const *yyp = yystr;
120
121 for (;;)
122 switch (*++yyp)
123 {
124 case '\'':
125 case ',':
126 goto do_not_strip_quotes;
127
128 case '\\':
129 if (*++yyp != '\\')
130 goto do_not_strip_quotes;
131 /* Fall through. */
132 default:
133 yyr += *yyp;
134 break;
135
136 case '"':
137 return yyr;
138 }
139 do_not_strip_quotes: ;
140 }
141
142 return yystr;
143 }
144
145 #endif
146
147 /// Build a parser object.
148 script_parser::script_parser (compiler& driver_yyarg)
149 : yydebug_ (false),
150 yycdebug_ (&std::cerr),
151 driver (driver_yyarg)
152 {
153 }
154
155 script_parser::~script_parser ()
156 {
157 }
158
159 #if YYDEBUG
160 /*--------------------------------.
161 | Print this symbol on YYOUTPUT. |
162 `--------------------------------*/
163
164 inline void
165 script_parser::yy_symbol_value_print_ (int yytype,
166 const semantic_type* yyvaluep, const location_type* yylocationp)
167 {
168 YYUSE (yylocationp);
169 YYUSE (yyvaluep);
170 switch (yytype)
171 {
172 default:
173 break;
174 }
175 }
176
177
178 void
179 script_parser::yy_symbol_print_ (int yytype,
180 const semantic_type* yyvaluep, const location_type* yylocationp)
181 {
182 *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
183 << ' ' << yytname_[yytype] << " ("
184 << *yylocationp << ": ";
185 yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
186 *yycdebug_ << ')';
187 }
188 #endif /* ! YYDEBUG */
189
190 void
191 script_parser::yydestruct_ (const char* yymsg,
192 int yytype, semantic_type* yyvaluep, location_type* yylocationp)
193 {
194 YYUSE (yylocationp);
195 YYUSE (yymsg);
196 YYUSE (yyvaluep);
197
198 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
199
200 switch (yytype)
201 {
202 case 4: /* "\"identifier\"" */
203 #line 68 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
204 { delete (yyvaluep->sval); };
205 #line 206 "script-parser.cc"
206 break;
207 case 39: /* "assign" */
208 #line 71 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
209 { delete (yyvaluep->assign); };
210 #line 211 "script-parser.cc"
211 break;
212 case 40: /* "comp_expr" */
213 #line 74 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
214 { delete (yyvaluep->expr); };
215 #line 216 "script-parser.cc"
216 break;
217 case 41: /* "expr" */
218 #line 73 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
219 { delete (yyvaluep->expr); };
220 #line 221 "script-parser.cc"
221 break;
222 case 42: /* "value" */
223 #line 72 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
224 { delete (yyvaluep->expr); };
225 #line 226 "script-parser.cc"
226 break;
227 case 43: /* "args" */
228 #line 70 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
229 { delete (yyvaluep->args); };
230 #line 231 "script-parser.cc"
231 break;
232
233 default:
234 break;
235 }
236 }
237
238 void
239 script_parser::yypop_ (unsigned int n)
240 {
241 yystate_stack_.pop (n);
242 yysemantic_stack_.pop (n);
243 yylocation_stack_.pop (n);
244 }
245
246 std::ostream&
247 script_parser::debug_stream () const
248 {
249 return *yycdebug_;
250 }
251
252 void
253 script_parser::set_debug_stream (std::ostream& o)
254 {
255 yycdebug_ = &o;
256 }
257
258
259 script_parser::debug_level_type
260 script_parser::debug_level () const
261 {
262 return yydebug_;
263 }
264
265 void
266 script_parser::set_debug_level (debug_level_type l)
267 {
268 yydebug_ = l;
269 }
270
271
272 int
273 script_parser::parse ()
274 {
275 /// Look-ahead and look-ahead in internal form.
276 int yychar = yyempty_;
277 int yytoken = 0;
278
279 /* State. */
280 int yyn;
281 int yylen = 0;
282 int yystate = 0;
283
284 /* Error handling. */
285 int yynerrs_ = 0;
286 int yyerrstatus_ = 0;
287
288 /// Semantic value of the look-ahead.
289 semantic_type yylval;
290 /// Location of the look-ahead.
291 location_type yylloc;
292 /// The locations where the error started and ended.
293 location yyerror_range[2];
294
295 /// $$.
296 semantic_type yyval;
297 /// @$.
298 location_type yyloc;
299
300 int yyresult;
301
302 YYCDEBUG << "Starting parse" << std::endl;
303
304
305 /* User initialization code. */
306 #line 20 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
307 {
308 // ロケーション初期化
309 yylloc.begin.filename = yylloc.end.filename = &driver.get_filename();
310 }
311 /* Line 555 of yacc.c. */
312 #line 313 "script-parser.cc"
313 /* Initialize the stacks. The initial state will be pushed in
314 yynewstate, since the latter expects the semantical and the
315 location values to have been already stored, initialize these
316 stacks with a primary value. */
317 yystate_stack_ = state_stack_type (0);
318 yysemantic_stack_ = semantic_stack_type (0);
319 yylocation_stack_ = location_stack_type (0);
320 yysemantic_stack_.push (yylval);
321 yylocation_stack_.push (yylloc);
322
323 /* New state. */
324 yynewstate:
325 yystate_stack_.push (yystate);
326 YYCDEBUG << "Entering state " << yystate << std::endl;
327 goto yybackup;
328
329 /* Backup. */
330 yybackup:
331
332 /* Try to take a decision without look-ahead. */
333 yyn = yypact_[yystate];
334 if (yyn == yypact_ninf_)
335 goto yydefault;
336
337 /* Read a look-ahead token. */
338 if (yychar == yyempty_)
339 {
340 YYCDEBUG << "Reading a token: ";
341 yychar = yylex (&yylval, &yylloc, driver);
342 }
343
344
345 /* Convert token to internal form. */
346 if (yychar <= yyeof_)
347 {
348 yychar = yytoken = yyeof_;
349 YYCDEBUG << "Now at end of input." << std::endl;
350 }
351 else
352 {
353 yytoken = yytranslate_ (yychar);
354 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
355 }
356
357 /* If the proper action on seeing token YYTOKEN is to reduce or to
358 detect an error, take that action. */
359 yyn += yytoken;
360 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
361 goto yydefault;
362
363 /* Reduce or error. */
364 yyn = yytable_[yyn];
365 if (yyn <= 0)
366 {
367 if (yyn == 0 || yyn == yytable_ninf_)
368 goto yyerrlab;
369 yyn = -yyn;
370 goto yyreduce;
371 }
372
373 /* Accept? */
374 if (yyn == yyfinal_)
375 goto yyacceptlab;
376
377 /* Shift the look-ahead token. */
378 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
379
380 /* Discard the token being shifted unless it is eof. */
381 if (yychar != yyeof_)
382 yychar = yyempty_;
383
384 yysemantic_stack_.push (yylval);
385 yylocation_stack_.push (yylloc);
386
387 /* Count tokens shifted since error; after three, turn off error
388 status. */
389 if (yyerrstatus_)
390 --yyerrstatus_;
391
392 yystate = yyn;
393 goto yynewstate;
394
395 /*-----------------------------------------------------------.
396 | yydefault -- do the default action for the current state. |
397 `-----------------------------------------------------------*/
398 yydefault:
399 yyn = yydefact_[yystate];
400 if (yyn == 0)
401 goto yyerrlab;
402 goto yyreduce;
403
404 /*-----------------------------.
405 | yyreduce -- Do a reduction. |
406 `-----------------------------*/
407 yyreduce:
408 yylen = yyr2_[yyn];
409 /* If YYLEN is nonzero, implement the default value of the action:
410 `$$ = $1'. Otherwise, use the top of the stack.
411
412 Otherwise, the following line sets YYVAL to garbage.
413 This behavior is undocumented and Bison
414 users should not rely upon it. */
415 if (yylen)
416 yyval = yysemantic_stack_[yylen - 1];
417 else
418 yyval = yysemantic_stack_[0];
419
420 {
421 slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
422 YYLLOC_DEFAULT (yyloc, slice, yylen);
423 }
424 YY_REDUCE_PRINT (yyn);
425 switch (yyn)
426 {
427 case 6:
428 #line 90 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
429 { driver.EndStatement((yylocation_stack_[(1) - (1)])); ;}
430 break;
431
432 case 7:
433 #line 91 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
434 { driver.AssignStatement((yylocation_stack_[(1) - (1)]), (yysemantic_stack_[(1) - (1)].assign)); ;}
435 break;
436
437 case 8:
438 #line 92 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
439 { driver.IfStatement((yylocation_stack_[(3) - (1)]), (yysemantic_stack_[(3) - (2)].expr)); ;}
440 break;
441
442 case 9:
443 #line 93 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
444 { driver.ElseStatement((yylocation_stack_[(1) - (1)])); ;}
445 break;
446
447 case 10:
448 #line 94 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
449 { driver.EndifStatement((yylocation_stack_[(1) - (1)])); ;}
450 break;
451
452 case 11:
453 #line 95 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
454 { driver.ForStatement((yylocation_stack_[(6) - (1)]), (yysemantic_stack_[(6) - (2)].assign), (yysemantic_stack_[(6) - (4)].expr), (yysemantic_stack_[(6) - (6)].expr)); ;}
455 break;
456
457 case 12:
458 #line 96 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
459 { driver.ForStatement((yylocation_stack_[(4) - (1)]), (yysemantic_stack_[(4) - (2)].assign), (yysemantic_stack_[(4) - (4)].expr), NULL); ;}
460 break;
461
462 case 13:
463 #line 97 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
464 { driver.NextStatement((yylocation_stack_[(1) - (1)])); ;}
465 break;
466
467 case 14:
468 #line 98 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
469 { driver.WhileStatement((yylocation_stack_[(2) - (1)]), (yysemantic_stack_[(2) - (2)].expr)); ;}
470 break;
471
472 case 15:
473 #line 99 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
474 { driver.WendStatement((yylocation_stack_[(1) - (1)])); ;}
475 break;
476
477 case 16:
478 #line 100 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
479 { driver.PrintStatement((yylocation_stack_[(2) - (1)]), (yysemantic_stack_[(2) - (2)].args)); ;}
480 break;
481
482 case 18:
483 #line 104 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
484 { (yyval.assign) = new CAssign((yylocation_stack_[(3) - (1)]), '=', (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
485 break;
486
487 case 19:
488 #line 107 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
489 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_EQ, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
490 break;
491
492 case 20:
493 #line 108 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
494 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_NE, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
495 break;
496
497 case 21:
498 #line 109 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
499 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_GT, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
500 break;
501
502 case 22:
503 #line 110 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
504 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_GE, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
505 break;
506
507 case 23:
508 #line 111 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
509 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_LT, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
510 break;
511
512 case 24:
513 #line 112 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
514 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_LE, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
515 break;
516
517 case 25:
518 #line 115 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
519 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_MINUS, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
520 break;
521
522 case 26:
523 #line 116 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
524 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_PLUS, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
525 break;
526
527 case 27:
528 #line 117 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
529 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_TIMES, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
530 break;
531
532 case 28:
533 #line 118 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
534 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_DIVIDE, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
535 break;
536
537 case 29:
538 #line 119 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
539 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(3) - (1)]), OP_MOD, (yysemantic_stack_[(3) - (1)].expr), (yysemantic_stack_[(3) - (3)].expr)); ;}
540 break;
541
542 case 30:
543 #line 120 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
544 { (yyval.expr) = CNode::MakeNode(driver, (yylocation_stack_[(2) - (1)]), OP_NEG, (yysemantic_stack_[(2) - (2)].expr)); ;}
545 break;
546
547 case 31:
548 #line 121 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
549 { (yyval.expr) = (yysemantic_stack_[(3) - (2)].expr); ;}
550 break;
551
552 case 32:
553 #line 122 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
554 { (yyval.expr) = (yysemantic_stack_[(1) - (1)].expr); ;}
555 break;
556
557 case 33:
558 #line 123 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
559 { (yyval.expr) = new CNode((yylocation_stack_[(1) - (1)]), OP_CONST, (yysemantic_stack_[(1) - (1)].ival)); ;}
560 break;
561
562 case 34:
563 #line 124 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
564 { (yyval.expr) = new CNode((yylocation_stack_[(4) - (1)]), OP_RANDFUNC, (yysemantic_stack_[(4) - (3)].expr)); ;}
565 break;
566
567 case 35:
568 #line 127 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
569 { (yyval.expr) = new CValueNode((yylocation_stack_[(1) - (1)]), (yysemantic_stack_[(1) - (1)].sval)); ;}
570 break;
571
572 case 36:
573 #line 130 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
574 { (yyval.args) = new CArgs((yylocation_stack_[(1) - (1)]), (yysemantic_stack_[(1) - (1)].expr)); ;}
575 break;
576
577 case 37:
578 #line 131 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
579 { (yyval.args) = (yysemantic_stack_[(3) - (1)].args)->Add((yylocation_stack_[(3) - (3)]), (yysemantic_stack_[(3) - (3)].expr)); ;}
580 break;
581
582
583 /* Line 675 of lalr1.cc. */
584 #line 585 "script-parser.cc"
585 default: break;
586 }
587 YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
588
589 yypop_ (yylen);
590 yylen = 0;
591 YY_STACK_PRINT ();
592
593 yysemantic_stack_.push (yyval);
594 yylocation_stack_.push (yyloc);
595
596 /* Shift the result of the reduction. */
597 yyn = yyr1_[yyn];
598 yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
599 if (0 <= yystate && yystate <= yylast_
600 && yycheck_[yystate] == yystate_stack_[0])
601 yystate = yytable_[yystate];
602 else
603 yystate = yydefgoto_[yyn - yyntokens_];
604 goto yynewstate;
605
606 /*------------------------------------.
607 | yyerrlab -- here on detecting error |
608 `------------------------------------*/
609 yyerrlab:
610 /* If not already recovering from an error, report this error. */
611 if (!yyerrstatus_)
612 {
613 ++yynerrs_;
614 error (yylloc, yysyntax_error_ (yystate, yytoken));
615 }
616
617 yyerror_range[0] = yylloc;
618 if (yyerrstatus_ == 3)
619 {
620 /* If just tried and failed to reuse look-ahead token after an
621 error, discard it. */
622
623 if (yychar <= yyeof_)
624 {
625 /* Return failure if at end of input. */
626 if (yychar == yyeof_)
627 YYABORT;
628 }
629 else
630 {
631 yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
632 yychar = yyempty_;
633 }
634 }
635
636 /* Else will try to reuse look-ahead token after shifting the error
637 token. */
638 goto yyerrlab1;
639
640
641 /*---------------------------------------------------.
642 | yyerrorlab -- error raised explicitly by YYERROR. |
643 `---------------------------------------------------*/
644 yyerrorlab:
645
646 /* Pacify compilers like GCC when the user code never invokes
647 YYERROR and the label yyerrorlab therefore never appears in user
648 code. */
649 if (false)
650 goto yyerrorlab;
651
652 yyerror_range[0] = yylocation_stack_[yylen - 1];
653 /* Do not reclaim the symbols of the rule which action triggered
654 this YYERROR. */
655 yypop_ (yylen);
656 yylen = 0;
657 yystate = yystate_stack_[0];
658 goto yyerrlab1;
659
660 /*-------------------------------------------------------------.
661 | yyerrlab1 -- common code for both syntax error and YYERROR. |
662 `-------------------------------------------------------------*/
663 yyerrlab1:
664 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
665
666 for (;;)
667 {
668 yyn = yypact_[yystate];
669 if (yyn != yypact_ninf_)
670 {
671 yyn += yyterror_;
672 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
673 {
674 yyn = yytable_[yyn];
675 if (0 < yyn)
676 break;
677 }
678 }
679
680 /* Pop the current state because it cannot handle the error token. */
681 if (yystate_stack_.height () == 1)
682 YYABORT;
683
684 yyerror_range[0] = yylocation_stack_[0];
685 yydestruct_ ("Error: popping",
686 yystos_[yystate],
687 &yysemantic_stack_[0], &yylocation_stack_[0]);
688 yypop_ ();
689 yystate = yystate_stack_[0];
690 YY_STACK_PRINT ();
691 }
692
693 if (yyn == yyfinal_)
694 goto yyacceptlab;
695
696 yyerror_range[1] = yylloc;
697 // Using YYLLOC is tempting, but would change the location of
698 // the look-ahead. YYLOC is available though.
699 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
700 yysemantic_stack_.push (yylval);
701 yylocation_stack_.push (yyloc);
702
703 /* Shift the error token. */
704 YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
705 &yysemantic_stack_[0], &yylocation_stack_[0]);
706
707 yystate = yyn;
708 goto yynewstate;
709
710 /* Accept. */
711 yyacceptlab:
712 yyresult = 0;
713 goto yyreturn;
714
715 /* Abort. */
716 yyabortlab:
717 yyresult = 1;
718 goto yyreturn;
719
720 yyreturn:
721 if (yychar != yyeof_ && yychar != yyempty_)
722 yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
723
724 /* Do not reclaim the symbols of the rule which action triggered
725 this YYABORT or YYACCEPT. */
726 yypop_ (yylen);
727 while (yystate_stack_.height () != 1)
728 {
729 yydestruct_ ("Cleanup: popping",
730 yystos_[yystate_stack_[0]],
731 &yysemantic_stack_[0],
732 &yylocation_stack_[0]);
733 yypop_ ();
734 }
735
736 return yyresult;
737 }
738
739 // Generate an error message.
740 std::string
741 script_parser::yysyntax_error_ (int yystate, int tok)
742 {
743 std::string res;
744 YYUSE (yystate);
745 #if YYERROR_VERBOSE
746 int yyn = yypact_[yystate];
747 if (yypact_ninf_ < yyn && yyn <= yylast_)
748 {
749 /* Start YYX at -YYN if negative to avoid negative indexes in
750 YYCHECK. */
751 int yyxbegin = yyn < 0 ? -yyn : 0;
752
753 /* Stay within bounds of both yycheck and yytname. */
754 int yychecklim = yylast_ - yyn + 1;
755 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
756 int count = 0;
757 for (int x = yyxbegin; x < yyxend; ++x)
758 if (yycheck_[x + yyn] == x && x != yyterror_)
759 ++count;
760
761 // FIXME: This method of building the message is not compatible
762 // with internationalization. It should work like yacc.c does it.
763 // That is, first build a string that looks like this:
764 // "syntax error, unexpected %s or %s or %s"
765 // Then, invoke YY_ on this string.
766 // Finally, use the string as a format to output
767 // yytname_[tok], etc.
768 // Until this gets fixed, this message appears in English only.
769 res = "syntax error, unexpected ";
770 res += yytnamerr_ (yytname_[tok]);
771 if (count < 5)
772 {
773 count = 0;
774 for (int x = yyxbegin; x < yyxend; ++x)
775 if (yycheck_[x + yyn] == x && x != yyterror_)
776 {
777 res += (!count++) ? ", expecting " : " or ";
778 res += yytnamerr_ (yytname_[x]);
779 }
780 }
781 }
782 else
783 #endif
784 res = YY_("syntax error");
785 return res;
786 }
787
788
789 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
790 STATE-NUM. */
791 const signed char script_parser::yypact_ninf_ = -23;
792 const signed char
793 script_parser::yypact_[] =
794 {
795 85, -23, -23, -23, 19, -23, -23, -3, -23, 19,
796 -23, -23, 19, 66, -23, -7, -23, -22, -23, -14,
797 19, 19, 8, 38, -23, 9, -23, 103, 4, -23,
798 -23, -23, 19, 19, -23, 86, -23, 19, 19, 19,
799 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
800 103, 91, -23, 103, 103, 103, 103, -20, -20, -23,
801 -23, -23, 103, 103, -11, 103, -23, 19, 103
802 };
803
804 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
805 doesn't specify something else to do. Zero means the default is an
806 error. */
807 const unsigned char
808 script_parser::yydefact_[] =
809 {
810 0, 17, 35, 5, 0, 9, 10, 0, 13, 0,
811 15, 6, 0, 0, 2, 0, 7, 0, 33, 0,
812 0, 0, 0, 0, 32, 0, 14, 36, 16, 1,
813 3, 4, 0, 0, 30, 0, 8, 0, 0, 0,
814 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
815 18, 0, 31, 19, 20, 22, 24, 26, 25, 27,
816 28, 29, 21, 23, 12, 37, 34, 0, 11
817 };
818
819 /* YYPGOTO[NTERM-NUM]. */
820 const signed char
821 script_parser::yypgoto_[] =
822 {
823 -23, -23, 27, -23, 34, 39, -12, 3, -23
824 };
825
826 /* YYDEFGOTO[NTERM-NUM]. */
827 const signed char
828 script_parser::yydefgoto_[] =
829 {
830 -1, 13, 14, 15, 16, 22, 23, 24, 28
831 };
832
833 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
834 positive, shift that token. If negative, reduce the rule which
835 number is the opposite. If zero, do what YYDEFACT says. */
836 const signed char script_parser::yytable_ninf_ = -1;
837 const unsigned char
838 script_parser::yytable_[] =
839 {
840 27, 2, 31, 17, 43, 44, 45, 32, 34, 35,
841 17, 41, 42, 43, 44, 45, 17, 67, 33, 36,
842 50, 51, 18, 2, 48, 53, 54, 55, 56, 57,
843 58, 59, 60, 61, 62, 63, 64, 65, 49, 19,
844 30, 25, 20, 37, 38, 39, 40, 0, 26, 0,
845 0, 21, 0, 0, 0, 68, 0, 0, 0, 0,
846 41, 42, 43, 44, 45, 0, 29, 1, 46, 47,
847 2, 0, 0, 0, 0, 3, 4, 0, 5, 6,
848 7, 0, 8, 9, 10, 11, 1, 12, 0, 2,
849 0, 0, 0, 0, 3, 4, 0, 5, 6, 7,
850 0, 8, 9, 10, 11, 0, 12, 0, 41, 42,
851 43, 44, 45, 41, 42, 43, 44, 45, 0, 52,
852 0, 0, 0, 0, 66, 41, 42, 43, 44, 45
853 };
854
855 /* YYCHECK. */
856 const signed char
857 script_parser::yycheck_[] =
858 {
859 12, 4, 9, 0, 24, 25, 26, 29, 20, 21,
860 7, 22, 23, 24, 25, 26, 13, 28, 32, 11,
861 32, 33, 3, 4, 15, 37, 38, 39, 40, 41,
862 42, 43, 44, 45, 46, 47, 48, 49, 34, 20,
863 13, 7, 23, 5, 6, 7, 8, -1, 9, -1,
864 -1, 32, -1, -1, -1, 67, -1, -1, -1, -1,
865 22, 23, 24, 25, 26, -1, 0, 1, 30, 31,
866 4, -1, -1, -1, -1, 9, 10, -1, 12, 13,
867 14, -1, 16, 17, 18, 19, 1, 21, -1, 4,
868 -1, -1, -1, -1, 9, 10, -1, 12, 13, 14,
869 -1, 16, 17, 18, 19, -1, 21, -1, 22, 23,
870 24, 25, 26, 22, 23, 24, 25, 26, -1, 33,
871 -1, -1, -1, -1, 33, 22, 23, 24, 25, 26
872 };
873
874 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
875 symbol of state STATE-NUM. */
876 const unsigned char
877 script_parser::yystos_[] =
878 {
879 0, 1, 4, 9, 10, 12, 13, 14, 16, 17,
880 18, 19, 21, 36, 37, 38, 39, 42, 3, 20,
881 23, 32, 40, 41, 42, 39, 40, 41, 43, 0,
882 37, 9, 29, 32, 41, 41, 11, 5, 6, 7,
883 8, 22, 23, 24, 25, 26, 30, 31, 15, 34,
884 41, 41, 33, 41, 41, 41, 41, 41, 41, 41,
885 41, 41, 41, 41, 41, 41, 33, 28, 41
886 };
887
888 #if YYDEBUG
889 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
890 to YYLEX-NUM. */
891 const unsigned short int
892 script_parser::yytoken_number_[] =
893 {
894 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
895 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
896 275, 276, 43, 45, 42, 47, 37, 277, 278, 61,
897 62, 60, 40, 41, 44
898 };
899 #endif
900
901 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
902 const unsigned char
903 script_parser::yyr1_[] =
904 {
905 0, 35, 36, 36, 37, 37, 38, 38, 38, 38,
906 38, 38, 38, 38, 38, 38, 38, 38, 39, 40,
907 40, 40, 40, 40, 40, 41, 41, 41, 41, 41,
908 41, 41, 41, 41, 41, 42, 43, 43
909 };
910
911 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
912 const unsigned char
913 script_parser::yyr2_[] =
914 {
915 0, 2, 1, 2, 2, 1, 1, 1, 3, 1,
916 1, 6, 4, 1, 2, 1, 2, 1, 3, 3,
917 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
918 2, 3, 1, 1, 4, 1, 1, 3
919 };
920
921 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
922 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
923 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
924 const char*
925 const script_parser::yytname_[] =
926 {
927 "\"end of file\"", "error", "$undefined", "\"ival\"", "\"identifier\"",
928 "\"==\"", "\"!=\"", "\">=\"", "\"<=\"", "\"\\n\"", "\"if\"", "\"then\"",
929 "\"else\"", "\"endif\"", "\"for\"", "\"to\"", "\"next\"", "\"while\"",
930 "\"wend\"", "\"end\"", "\"rand\"", "\"print\"", "'+'", "'-'", "'*'",
931 "'/'", "'%'", "NEG", "\"step\"", "'='", "'>'", "'<'", "'('", "')'",
932 "','", "$accept", "unit", "states", "statement", "assign", "comp_expr",
933 "expr", "value", "args", 0
934 };
935 #endif
936
937 #if YYDEBUG
938 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
939 const script_parser::rhs_number_type
940 script_parser::yyrhs_[] =
941 {
942 36, 0, -1, 37, -1, 36, 37, -1, 38, 9,
943 -1, 9, -1, 19, -1, 39, -1, 10, 40, 11,
944 -1, 12, -1, 13, -1, 14, 39, 15, 41, 28,
945 41, -1, 14, 39, 15, 41, -1, 16, -1, 17,
946 40, -1, 18, -1, 21, 43, -1, 1, -1, 42,
947 29, 41, -1, 41, 5, 41, -1, 41, 6, 41,
948 -1, 41, 30, 41, -1, 41, 7, 41, -1, 41,
949 31, 41, -1, 41, 8, 41, -1, 41, 23, 41,
950 -1, 41, 22, 41, -1, 41, 24, 41, -1, 41,
951 25, 41, -1, 41, 26, 41, -1, 23, 41, -1,
952 32, 41, 33, -1, 42, -1, 3, -1, 20, 32,
953 41, 33, -1, 4, -1, 41, -1, 43, 34, 41,
954 -1
955 };
956
957 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
958 YYRHS. */
959 const unsigned char
960 script_parser::yyprhs_[] =
961 {
962 0, 0, 3, 5, 8, 11, 13, 15, 17, 21,
963 23, 25, 32, 37, 39, 42, 44, 47, 49, 53,
964 57, 61, 65, 69, 73, 77, 81, 85, 89, 93,
965 97, 100, 104, 106, 108, 113, 115, 117
966 };
967
968 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
969 const unsigned char
970 script_parser::yyrline_[] =
971 {
972 0, 82, 82, 83, 86, 87, 90, 91, 92, 93,
973 94, 95, 96, 97, 98, 99, 100, 101, 104, 107,
974 108, 109, 110, 111, 112, 115, 116, 117, 118, 119,
975 120, 121, 122, 123, 124, 127, 130, 131
976 };
977
978 // Print the state stack on the debug stream.
979 void
980 script_parser::yystack_print_ ()
981 {
982 *yycdebug_ << "Stack now";
983 for (state_stack_type::const_iterator i = yystate_stack_.begin ();
984 i != yystate_stack_.end (); ++i)
985 *yycdebug_ << ' ' << *i;
986 *yycdebug_ << std::endl;
987 }
988
989 // Report on the debug stream that the rule \a yyrule is going to be reduced.
990 void
991 script_parser::yy_reduce_print_ (int yyrule)
992 {
993 unsigned int yylno = yyrline_[yyrule];
994 int yynrhs = yyr2_[yyrule];
995 /* Print the symbols being reduced, and their result. */
996 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
997 << " (line " << yylno << "), ";
998 /* The symbols being reduced. */
999 for (int yyi = 0; yyi < yynrhs; yyi++)
1000 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1001 yyrhs_[yyprhs_[yyrule] + yyi],
1002 &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
1003 &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
1004 }
1005 #endif // YYDEBUG
1006
1007 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1008 script_parser::token_number_type
1009 script_parser::yytranslate_ (int t)
1010 {
1011 static
1012 const token_number_type
1013 translate_table[] =
1014 {
1015 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1016 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1017 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1018 2, 2, 2, 2, 2, 2, 2, 26, 2, 2,
1019 32, 33, 24, 22, 34, 23, 2, 25, 2, 2,
1020 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1021 31, 29, 30, 2, 2, 2, 2, 2, 2, 2,
1022 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1023 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1024 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1025 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1026 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1027 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1028 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1029 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1030 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1031 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1032 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1033 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1034 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1035 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1036 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1037 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1038 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1039 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1040 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1041 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1042 15, 16, 17, 18, 19, 20, 21, 27, 28
1043 };
1044 if ((unsigned int) t <= yyuser_token_number_max_)
1045 return translate_table[t];
1046 else
1047 return yyundef_token_;
1048 }
1049
1050 const int script_parser::yyeof_ = 0;
1051 const int script_parser::yylast_ = 129;
1052 const int script_parser::yynnts_ = 9;
1053 const int script_parser::yyempty_ = -2;
1054 const int script_parser::yyfinal_ = 29;
1055 const int script_parser::yyterror_ = 1;
1056 const int script_parser::yyerrcode_ = 256;
1057 const int script_parser::yyntokens_ = 35;
1058
1059 const unsigned int script_parser::yyuser_token_number_max_ = 278;
1060 const script_parser::token_number_type script_parser::yyundef_token_ = 2;
1061
1062 } // namespace yy
1063
1064 #line 134 "d:\\Work\\ScriptEngine\\Sample Source\\Bison-Flex\\BasicCompiler-StackBase\\script-parser.yy"
1065
1066 void yy::script_parser::error(const yy::script_parser::location_type& l, const std::string& m)
1067 {
1068 driver.error(l, m);
1069 }
1070