Line data Source code
1 : // A Bison parser, made by GNU Bison 3.0.4.
2 :
3 : // Skeleton implementation for Bison LALR(1) parsers in C++
4 :
5 : // Copyright (C) 2002-2015 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 3 of the License, or
10 : // (at your option) 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, see <http://www.gnu.org/licenses/>.
19 :
20 : // As a special exception, you may create a larger work that contains
21 : // part or all of the Bison parser skeleton and distribute that work
22 : // under terms of your choice, so long as that work isn't itself a
23 : // parser generator using the skeleton or a modified version thereof
24 : // as a parser skeleton. Alternatively, if you modify or redistribute
25 : // the parser skeleton itself, you may (at your option) remove this
26 : // special exception, which will cause the skeleton and the resulting
27 : // Bison output files to be licensed under the GNU General Public
28 : // License without this special exception.
29 :
30 : // This special exception was added by the Free Software Foundation in
31 : // version 2.2 of Bison.
32 :
33 : // Take the name prefix into account.
34 : #define yylex gspnlex
35 :
36 : // First part of user declarations.
37 :
38 : #line 39 "Gspn-parser.cc" // lalr1.cc:404
39 :
40 : # ifndef YY_NULLPTR
41 : # if defined __cplusplus && 201103L <= __cplusplus
42 : # define YY_NULLPTR nullptr
43 : # else
44 : # define YY_NULLPTR 0
45 : # endif
46 : # endif
47 :
48 : #include "Gspn-parser.hh"
49 :
50 : // User implementation prologue.
51 :
52 : #line 53 "Gspn-parser.cc" // lalr1.cc:412
53 : // Unqualified %code blocks.
54 : #line 44 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:413
55 :
56 : #include "Gspn-Reader.hpp"
57 : #include <set>
58 : #include <vector>
59 :
60 : vector<string> Par;
61 : std::string distrib;
62 : Eval Evaluate;
63 :
64 :
65 : int NbServers;
66 : bool SingleService;
67 : bool MarkingDependent;
68 : bool AgeMemory;
69 :
70 :
71 :
72 : #line 73 "Gspn-parser.cc" // lalr1.cc:413
73 :
74 :
75 : #ifndef YY_
76 : # if defined YYENABLE_NLS && YYENABLE_NLS
77 : # if ENABLE_NLS
78 : # include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
79 : # define YY_(msgid) dgettext ("bison-runtime", msgid)
80 : # endif
81 : # endif
82 : # ifndef YY_
83 : # define YY_(msgid) msgid
84 : # endif
85 : #endif
86 :
87 : #define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
88 : /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
89 : If N is 0, then set CURRENT to the empty location which ends
90 : the previous symbol: RHS[0] (always defined). */
91 :
92 : # ifndef YYLLOC_DEFAULT
93 : # define YYLLOC_DEFAULT(Current, Rhs, N) \
94 : do \
95 : if (N) \
96 : { \
97 : (Current).begin = YYRHSLOC (Rhs, 1).begin; \
98 : (Current).end = YYRHSLOC (Rhs, N).end; \
99 : } \
100 : else \
101 : { \
102 : (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
103 : } \
104 : while (/*CONSTCOND*/ false)
105 : # endif
106 :
107 :
108 : // Suppress unused-variable warnings by "using" E.
109 : #define YYUSE(E) ((void) (E))
110 :
111 : // Enable debugging if requested.
112 : #if YYDEBUG
113 :
114 : // A pseudo ostream that takes yydebug_ into account.
115 : # define YYCDEBUG if (yydebug_) (*yycdebug_)
116 :
117 : # define YY_SYMBOL_PRINT(Title, Symbol) \
118 : do { \
119 : if (yydebug_) \
120 : { \
121 : *yycdebug_ << Title << ' '; \
122 : yy_print_ (*yycdebug_, Symbol); \
123 : *yycdebug_ << std::endl; \
124 : } \
125 : } while (false)
126 :
127 : # define YY_REDUCE_PRINT(Rule) \
128 : do { \
129 : if (yydebug_) \
130 : yy_reduce_print_ (Rule); \
131 : } while (false)
132 :
133 : # define YY_STACK_PRINT() \
134 : do { \
135 : if (yydebug_) \
136 : yystack_print_ (); \
137 : } while (false)
138 :
139 : #else // !YYDEBUG
140 :
141 : # define YYCDEBUG if (false) std::cerr
142 : # define YY_SYMBOL_PRINT(Title, Symbol) YYUSE(Symbol)
143 : # define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
144 : # define YY_STACK_PRINT() static_cast<void>(0)
145 :
146 : #endif // !YYDEBUG
147 :
148 : #define yyerrok (yyerrstatus_ = 0)
149 : #define yyclearin (yyla.clear ())
150 :
151 : #define YYACCEPT goto yyacceptlab
152 : #define YYABORT goto yyabortlab
153 : #define YYERROR goto yyerrorlab
154 : #define YYRECOVERING() (!!yyerrstatus_)
155 :
156 :
157 : namespace gspn {
158 : #line 159 "Gspn-parser.cc" // lalr1.cc:479
159 :
160 : /* Return YYSTR after stripping away unnecessary quotes and
161 : backslashes, so that it's suitable for yyerror. The heuristic is
162 : that double-quoting is unnecessary unless the string contains an
163 : apostrophe, a comma, or backslash (other than backslash-backslash).
164 : YYSTR is taken from yytname. */
165 : std::string
166 0 : Gspn_parser::yytnamerr_ (const char *yystr)
167 : {
168 0 : if (*yystr == '"')
169 : {
170 0 : std::string yyr = "";
171 0 : char const *yyp = yystr;
172 :
173 : for (;;)
174 0 : switch (*++yyp)
175 : {
176 : case '\'':
177 : case ',':
178 0 : goto do_not_strip_quotes;
179 :
180 : case '\\':
181 0 : if (*++yyp != '\\')
182 0 : goto do_not_strip_quotes;
183 : // Fall through.
184 : default:
185 0 : yyr += *yyp;
186 0 : break;
187 :
188 : case '"':
189 0 : return yyr;
190 : }
191 : do_not_strip_quotes: ;
192 : }
193 :
194 0 : return yystr;
195 : }
196 :
197 :
198 : /// Build a parser object.
199 11 : Gspn_parser::Gspn_parser (Gspn_Reader& Reader_yyarg)
200 : :
201 : #if YYDEBUG
202 : yydebug_ (false),
203 : yycdebug_ (&std::cerr),
204 : #endif
205 11 : Reader (Reader_yyarg)
206 11 : {}
207 :
208 11 : Gspn_parser::~Gspn_parser ()
209 11 : {}
210 :
211 :
212 : /*---------------.
213 : | Symbol types. |
214 : `---------------*/
215 :
216 : inline
217 : Gspn_parser::syntax_error::syntax_error (const location_type& l, const std::string& m)
218 : : std::runtime_error (m)
219 : , location (l)
220 : {}
221 :
222 : // basic_symbol.
223 : template <typename Base>
224 : inline
225 7040 : Gspn_parser::basic_symbol<Base>::basic_symbol ()
226 7040 : : value ()
227 7040 : {}
228 :
229 : template <typename Base>
230 : inline
231 5333 : Gspn_parser::basic_symbol<Base>::basic_symbol (const basic_symbol& other)
232 : : Base (other)
233 : , value ()
234 5333 : , location (other.location)
235 : {
236 5333 : value = other.value;
237 5333 : }
238 :
239 :
240 : template <typename Base>
241 : inline
242 : Gspn_parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const semantic_type& v, const location_type& l)
243 : : Base (t)
244 : , value (v)
245 : , location (l)
246 : {}
247 :
248 :
249 : /// Constructor for valueless symbols.
250 : template <typename Base>
251 : inline
252 3670 : Gspn_parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const location_type& l)
253 : : Base (t)
254 : , value ()
255 3670 : , location (l)
256 3670 : {}
257 :
258 : template <typename Base>
259 : inline
260 16043 : Gspn_parser::basic_symbol<Base>::~basic_symbol ()
261 : {
262 16043 : clear ();
263 16043 : }
264 :
265 : template <typename Base>
266 : inline
267 : void
268 16043 : Gspn_parser::basic_symbol<Base>::clear ()
269 : {
270 16043 : Base::clear ();
271 16043 : }
272 :
273 : template <typename Base>
274 : inline
275 : bool
276 3864 : Gspn_parser::basic_symbol<Base>::empty () const
277 : {
278 3864 : return Base::type_get () == empty_symbol;
279 : }
280 :
281 : template <typename Base>
282 : inline
283 : void
284 5333 : Gspn_parser::basic_symbol<Base>::move (basic_symbol& s)
285 : {
286 5333 : super_type::move(s);
287 5333 : value = s.value;
288 5333 : location = s.location;
289 5333 : }
290 :
291 : // by_type.
292 : inline
293 11 : Gspn_parser::by_type::by_type ()
294 11 : : type (empty_symbol)
295 11 : {}
296 :
297 : inline
298 : Gspn_parser::by_type::by_type (const by_type& other)
299 : : type (other.type)
300 : {}
301 :
302 : inline
303 : Gspn_parser::by_type::by_type (token_type t)
304 : : type (yytranslate_ (t))
305 : {}
306 :
307 : inline
308 : void
309 11 : Gspn_parser::by_type::clear ()
310 : {
311 11 : type = empty_symbol;
312 11 : }
313 :
314 : inline
315 : void
316 : Gspn_parser::by_type::move (by_type& that)
317 : {
318 : type = that.type;
319 : that.clear ();
320 : }
321 :
322 : inline
323 : int
324 11570 : Gspn_parser::by_type::type_get () const
325 : {
326 11570 : return type;
327 : }
328 :
329 :
330 : // by_state.
331 : inline
332 7029 : Gspn_parser::by_state::by_state ()
333 7029 : : state (empty_state)
334 7029 : {}
335 :
336 : inline
337 5333 : Gspn_parser::by_state::by_state (const by_state& other)
338 5333 : : state (other.state)
339 5333 : {}
340 :
341 : inline
342 : void
343 21365 : Gspn_parser::by_state::clear ()
344 : {
345 21365 : state = empty_state;
346 21365 : }
347 :
348 : inline
349 : void
350 5333 : Gspn_parser::by_state::move (by_state& that)
351 : {
352 5333 : state = that.state;
353 5333 : that.clear ();
354 5333 : }
355 :
356 : inline
357 3670 : Gspn_parser::by_state::by_state (state_type s)
358 3670 : : state (s)
359 3670 : {}
360 :
361 : inline
362 : Gspn_parser::symbol_number_type
363 22 : Gspn_parser::by_state::type_get () const
364 : {
365 22 : if (state == empty_state)
366 0 : return empty_symbol;
367 : else
368 22 : return yystos_[state];
369 : }
370 :
371 : inline
372 7029 : Gspn_parser::stack_symbol_type::stack_symbol_type ()
373 7029 : {}
374 :
375 :
376 : inline
377 3670 : Gspn_parser::stack_symbol_type::stack_symbol_type (state_type s, symbol_type& that)
378 3670 : : super_type (s, that.location)
379 : {
380 3670 : value = that.value;
381 : // that is emptied.
382 3670 : that.type = empty_symbol;
383 3670 : }
384 :
385 : inline
386 : Gspn_parser::stack_symbol_type&
387 : Gspn_parser::stack_symbol_type::operator= (const stack_symbol_type& that)
388 : {
389 : state = that.state;
390 : value = that.value;
391 : location = that.location;
392 : return *this;
393 : }
394 :
395 :
396 : template <typename Base>
397 : inline
398 : void
399 22 : Gspn_parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
400 : {
401 22 : if (yymsg)
402 22 : YY_SYMBOL_PRINT (yymsg, yysym);
403 :
404 : // User destructor.
405 22 : switch (yysym.type_get ())
406 : {
407 : case 3: // str
408 :
409 : #line 115 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:614
410 : { delete (yysym.value.name); }
411 : #line 412 "Gspn-parser.cc" // lalr1.cc:614
412 0 : break;
413 :
414 :
415 : default:
416 22 : break;
417 : }
418 22 : }
419 :
420 : #if YYDEBUG
421 : template <typename Base>
422 : void
423 0 : Gspn_parser::yy_print_ (std::ostream& yyo,
424 : const basic_symbol<Base>& yysym) const
425 : {
426 0 : std::ostream& yyoutput = yyo;
427 : YYUSE (yyoutput);
428 0 : symbol_number_type yytype = yysym.type_get ();
429 : // Avoid a (spurious) G++ 4.8 warning about "array subscript is
430 : // below array bounds".
431 0 : if (yysym.empty ())
432 0 : std::abort ();
433 0 : yyo << (yytype < yyntokens_ ? "token" : "nterm")
434 0 : << ' ' << yytname_[yytype] << " ("
435 0 : << yysym.location << ": ";
436 0 : switch (yytype)
437 : {
438 : case 3: // str
439 :
440 : #line 114 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:636
441 : { debug_stream () << *(yysym.value.name); }
442 : #line 443 "Gspn-parser.cc" // lalr1.cc:636
443 0 : break;
444 :
445 : case 5: // rval
446 :
447 : #line 118 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:636
448 : { debug_stream () << (yysym.value.RealVal); }
449 : #line 450 "Gspn-parser.cc" // lalr1.cc:636
450 0 : break;
451 :
452 : case 6: // ival
453 :
454 : #line 117 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:636
455 : { debug_stream () << (yysym.value.IntVal); }
456 : #line 457 "Gspn-parser.cc" // lalr1.cc:636
457 0 : break;
458 :
459 :
460 : default:
461 0 : break;
462 : }
463 0 : yyo << ')';
464 0 : }
465 : #endif
466 :
467 : inline
468 : void
469 3670 : Gspn_parser::yypush_ (const char* m, state_type s, symbol_type& sym)
470 : {
471 7340 : stack_symbol_type t (s, sym);
472 3670 : yypush_ (m, t);
473 3670 : }
474 :
475 : inline
476 : void
477 5333 : Gspn_parser::yypush_ (const char* m, stack_symbol_type& s)
478 : {
479 5333 : if (m)
480 3659 : YY_SYMBOL_PRINT (m, s);
481 5333 : yystack_.push (s);
482 5333 : }
483 :
484 : inline
485 : void
486 1696 : Gspn_parser::yypop_ (unsigned int n)
487 : {
488 1696 : yystack_.pop (n);
489 1696 : }
490 :
491 : #if YYDEBUG
492 : std::ostream&
493 0 : Gspn_parser::debug_stream () const
494 : {
495 0 : return *yycdebug_;
496 : }
497 :
498 : void
499 0 : Gspn_parser::set_debug_stream (std::ostream& o)
500 : {
501 0 : yycdebug_ = &o;
502 0 : }
503 :
504 :
505 : Gspn_parser::debug_level_type
506 0 : Gspn_parser::debug_level () const
507 : {
508 0 : return yydebug_;
509 : }
510 :
511 : void
512 11 : Gspn_parser::set_debug_level (debug_level_type l)
513 : {
514 11 : yydebug_ = l;
515 11 : }
516 : #endif // YYDEBUG
517 :
518 : inline Gspn_parser::state_type
519 1663 : Gspn_parser::yy_lr_goto_state_ (state_type yystate, int yysym)
520 : {
521 1663 : int yyr = yypgoto_[yysym - yyntokens_] + yystate;
522 1663 : if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
523 868 : return yytable_[yyr];
524 : else
525 795 : return yydefgoto_[yysym - yyntokens_];
526 : }
527 :
528 : inline bool
529 5322 : Gspn_parser::yy_pact_value_is_default_ (int yyvalue)
530 : {
531 5322 : return yyvalue == yypact_ninf_;
532 : }
533 :
534 : inline bool
535 0 : Gspn_parser::yy_table_value_is_error_ (int yyvalue)
536 : {
537 0 : return yyvalue == yytable_ninf_;
538 : }
539 :
540 : int
541 11 : Gspn_parser::parse ()
542 : {
543 : // State.
544 : int yyn;
545 : /// Length of the RHS of the rule being reduced.
546 11 : int yylen = 0;
547 :
548 : // Error handling.
549 11 : int yynerrs_ = 0;
550 11 : int yyerrstatus_ = 0;
551 :
552 : /// The lookahead symbol.
553 22 : symbol_type yyla;
554 :
555 : /// The locations where the error started and ended.
556 22 : stack_symbol_type yyerror_range[3];
557 :
558 : /// The return value of parse ().
559 : int yyresult;
560 :
561 : // FIXME: This shoud be completely indented. It is not yet to
562 : // avoid gratuitous conflicts when merging into the master branch.
563 : try
564 : {
565 11 : YYCDEBUG << "Starting parse" << std::endl;
566 :
567 :
568 : /* Initialize the stack. The initial state will be set in
569 : yynewstate, since the latter expects the semantical and the
570 : location values to have been already stored, initialize these
571 : stacks with a primary value. */
572 11 : yystack_.clear ();
573 11 : yypush_ (YY_NULLPTR, 0, yyla);
574 :
575 : // A new symbol was pushed on the stack.
576 : yynewstate:
577 5333 : YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
578 :
579 : // Accept?
580 5333 : if (yystack_[0].state == yyfinal_)
581 11 : goto yyacceptlab;
582 :
583 5322 : goto yybackup;
584 :
585 : // Backup.
586 : yybackup:
587 :
588 : // Try to take a decision without lookahead.
589 5322 : yyn = yypact_[yystack_[0].state];
590 5322 : if (yy_pact_value_is_default_ (yyn))
591 1469 : goto yydefault;
592 :
593 : // Read a lookahead token.
594 3853 : if (yyla.empty ())
595 : {
596 3659 : YYCDEBUG << "Reading a token: ";
597 : try
598 : {
599 3659 : yyla.type = yytranslate_ (yylex (&yyla.value, &yyla.location, Reader));
600 : }
601 0 : catch (const syntax_error& yyexc)
602 : {
603 0 : error (yyexc);
604 0 : goto yyerrlab1;
605 : }
606 : }
607 3853 : YY_SYMBOL_PRINT ("Next token is", yyla);
608 :
609 : /* If the proper action on seeing token YYLA.TYPE is to reduce or
610 : to detect an error, take that action. */
611 3853 : yyn += yyla.type_get ();
612 3853 : if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ())
613 194 : goto yydefault;
614 :
615 : // Reduce or error.
616 3659 : yyn = yytable_[yyn];
617 3659 : if (yyn <= 0)
618 : {
619 0 : if (yy_table_value_is_error_ (yyn))
620 0 : goto yyerrlab;
621 0 : yyn = -yyn;
622 0 : goto yyreduce;
623 : }
624 :
625 : // Count tokens shifted since error; after three, turn off error status.
626 3659 : if (yyerrstatus_)
627 0 : --yyerrstatus_;
628 :
629 : // Shift the lookahead token.
630 3659 : yypush_ ("Shifting", yyn, yyla);
631 3659 : goto yynewstate;
632 :
633 : /*-----------------------------------------------------------.
634 : | yydefault -- do the default action for the current state. |
635 : `-----------------------------------------------------------*/
636 : yydefault:
637 1663 : yyn = yydefact_[yystack_[0].state];
638 1663 : if (yyn == 0)
639 0 : goto yyerrlab;
640 1663 : goto yyreduce;
641 :
642 : /*-----------------------------.
643 : | yyreduce -- Do a reduction. |
644 : `-----------------------------*/
645 : yyreduce:
646 1663 : yylen = yyr2_[yyn];
647 : {
648 3326 : stack_symbol_type yylhs;
649 1663 : yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);
650 : /* If YYLEN is nonzero, implement the default value of the
651 : action: '$$ = $1'. Otherwise, use the top of the stack.
652 :
653 : Otherwise, the following line sets YYLHS.VALUE to garbage.
654 : This behavior is undocumented and Bison users should not rely
655 : upon it. */
656 1663 : if (yylen)
657 1663 : yylhs.value = yystack_[yylen - 1].value;
658 : else
659 0 : yylhs.value = yystack_[0].value;
660 :
661 : // Compute the default @$.
662 : {
663 1663 : slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
664 1663 : YYLLOC_DEFAULT (yylhs.location, slice, yylen);
665 : }
666 :
667 : // Perform the reduction.
668 1663 : YY_REDUCE_PRINT (yyn);
669 : try
670 : {
671 1663 : switch (yyn)
672 : {
673 : case 2:
674 : #line 130 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
675 : { sprintf((yylhs.value.expression),"%d",(yystack_[0].value.IntVal));}
676 : #line 677 "Gspn-parser.cc" // lalr1.cc:859
677 233 : break;
678 :
679 : case 3:
680 : #line 131 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
681 : {
682 : if(Reader.spn->PlacesId.find(*(yystack_[0].value.name))!=Reader.spn->PlacesId.end())
683 : {std::ostringstream s; s<<" Marking.P->_PL_"<< (yystack_[0].value.name)->c_str() <<" ";
684 : sprintf((yylhs.value.expression), "%s",(s.str()).c_str());
685 : }
686 : else if(Reader.spn->IntConstant.find(*(yystack_[0].value.name))!=Reader.spn->IntConstant.end())
687 : {std::ostringstream s; s<<Reader.spn->IntConstant[*(yystack_[0].value.name)];
688 : sprintf((yylhs.value.expression), "%s",(s.str()).c_str());
689 :
690 : }
691 : else{cout<<"'"<<*(yystack_[0].value.name)<<"' has not been declared"<<endl;YYABORT;}}
692 : #line 693 "Gspn-parser.cc" // lalr1.cc:859
693 8 : break;
694 :
695 : case 4:
696 : #line 142 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
697 : {snprintf((yylhs.value.expression),BUFF_SIZE,"( %s )", (yystack_[1].value.expression)); }
698 : #line 699 "Gspn-parser.cc" // lalr1.cc:859
699 0 : break;
700 :
701 : case 5:
702 : #line 143 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
703 : {snprintf((yylhs.value.expression),BUFF_SIZE,"%s + %s", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
704 : #line 705 "Gspn-parser.cc" // lalr1.cc:859
705 0 : break;
706 :
707 : case 6:
708 : #line 144 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
709 : {snprintf((yylhs.value.expression),BUFF_SIZE,"%s - %s", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
710 : #line 711 "Gspn-parser.cc" // lalr1.cc:859
711 0 : break;
712 :
713 : case 7:
714 : #line 145 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
715 : {snprintf((yylhs.value.expression),BUFF_SIZE,"%s * %s", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
716 : #line 717 "Gspn-parser.cc" // lalr1.cc:859
717 0 : break;
718 :
719 : case 8:
720 : #line 146 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
721 : {snprintf((yylhs.value.expression),BUFF_SIZE,"pow(%s , %s)", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
722 : #line 723 "Gspn-parser.cc" // lalr1.cc:859
723 0 : break;
724 :
725 : case 9:
726 : #line 147 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
727 : {snprintf((yylhs.value.expression),BUFF_SIZE,"floor( %s )", (yystack_[1].value.expression)); }
728 : #line 729 "Gspn-parser.cc" // lalr1.cc:859
729 0 : break;
730 :
731 : case 10:
732 : #line 148 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
733 : {snprintf((yylhs.value.expression),BUFF_SIZE,"floor( %s /double(%s)", (yystack_[3].value.expression),(yystack_[1].value.expression)); }
734 : #line 735 "Gspn-parser.cc" // lalr1.cc:859
735 0 : break;
736 :
737 : case 11:
738 : #line 149 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
739 : {snprintf((yylhs.value.expression),BUFF_SIZE,"min(%s , %s)", (yystack_[3].value.expression), (yystack_[1].value.expression)); }
740 : #line 741 "Gspn-parser.cc" // lalr1.cc:859
741 0 : break;
742 :
743 : case 12:
744 : #line 150 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
745 : {snprintf((yylhs.value.expression),BUFF_SIZE,"max(%s , %s)", (yystack_[3].value.expression), (yystack_[1].value.expression)); }
746 : #line 747 "Gspn-parser.cc" // lalr1.cc:859
747 0 : break;
748 :
749 : case 13:
750 : #line 153 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
751 : {sprintf((yylhs.value.expression), "%f",(yystack_[0].value.RealVal));}
752 : #line 753 "Gspn-parser.cc" // lalr1.cc:859
753 28 : break;
754 :
755 : case 14:
756 : #line 154 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
757 : {snprintf((yylhs.value.expression),BUFF_SIZE,"%d",(yystack_[0].value.IntVal));}
758 : #line 759 "Gspn-parser.cc" // lalr1.cc:859
759 168 : break;
760 :
761 : case 15:
762 : #line 155 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
763 : {
764 : if(Reader.spn->PlacesId.find(*(yystack_[0].value.name))!=Reader.spn->PlacesId.end())
765 : {std::ostringstream s; s<<" Marking.P->_PL_"<<(yystack_[0].value.name)->c_str()<<" ";
766 : snprintf((yylhs.value.expression),BUFF_SIZE, "%s",(s.str()).c_str());
767 : }
768 : else if(Reader.spn->RealConstant.find(*(yystack_[0].value.name))!=Reader.spn->RealConstant.end())
769 : {std::ostringstream s; s<<Reader.spn->RealConstant[*(yystack_[0].value.name)];
770 : snprintf((yylhs.value.expression),BUFF_SIZE, "%s",(s.str()).c_str());
771 : }
772 : else{cout<<"'"<<*(yystack_[0].value.name)<<"' has not been declared"<<endl;YYABORT;}}
773 : #line 774 "Gspn-parser.cc" // lalr1.cc:859
774 46 : break;
775 :
776 : case 16:
777 : #line 165 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
778 : {snprintf((yylhs.value.expression),BUFF_SIZE,"( %s )", (yystack_[1].value.expression)); }
779 : #line 780 "Gspn-parser.cc" // lalr1.cc:859
780 0 : break;
781 :
782 : case 17:
783 : #line 166 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
784 : {snprintf((yylhs.value.expression),BUFF_SIZE,"%s /double(%s)", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
785 : #line 786 "Gspn-parser.cc" // lalr1.cc:859
786 0 : break;
787 :
788 : case 18:
789 : #line 167 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
790 : {snprintf((yylhs.value.expression),BUFF_SIZE,"%s + %s", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
791 : #line 792 "Gspn-parser.cc" // lalr1.cc:859
792 0 : break;
793 :
794 : case 19:
795 : #line 168 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
796 : {snprintf((yylhs.value.expression),BUFF_SIZE,"%s - %s", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
797 : #line 798 "Gspn-parser.cc" // lalr1.cc:859
798 0 : break;
799 :
800 : case 20:
801 : #line 169 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
802 : {snprintf((yylhs.value.expression),BUFF_SIZE,"%s * %s", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
803 : #line 804 "Gspn-parser.cc" // lalr1.cc:859
804 12 : break;
805 :
806 : case 21:
807 : #line 170 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
808 : {snprintf((yylhs.value.expression),BUFF_SIZE,"pow(%s , %s)", (yystack_[2].value.expression), (yystack_[0].value.expression)); }
809 : #line 810 "Gspn-parser.cc" // lalr1.cc:859
810 0 : break;
811 :
812 : case 22:
813 : #line 171 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
814 : {snprintf((yylhs.value.expression),BUFF_SIZE,"floor( %s )", (yystack_[1].value.expression)); }
815 : #line 816 "Gspn-parser.cc" // lalr1.cc:859
816 0 : break;
817 :
818 : case 23:
819 : #line 172 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
820 : {snprintf((yylhs.value.expression),BUFF_SIZE,"min(%s , %s)", (yystack_[3].value.expression), (yystack_[1].value.expression)); }
821 : #line 822 "Gspn-parser.cc" // lalr1.cc:859
822 0 : break;
823 :
824 : case 24:
825 : #line 173 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
826 : {snprintf((yylhs.value.expression),BUFF_SIZE,"max(%s , %s)", (yystack_[3].value.expression), (yystack_[1].value.expression)); }
827 : #line 828 "Gspn-parser.cc" // lalr1.cc:859
828 0 : break;
829 :
830 : case 33:
831 : #line 192 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
832 : {if(Reader.spn->RealConstant.find(*(yystack_[3].value.name))!=Reader.spn->RealConstant.end())
833 : {cout<<"Constant "<<*(yystack_[3].value.name)<<" already defined."<<endl; YYABORT;}
834 : else {string st=(yystack_[1].value.expression);
835 : if (Reader.P.constants.count(*(yystack_[3].value.name))>0)st = Reader.P.constants[*(yystack_[3].value.name)];
836 :
837 : Evaluate.parse(st);
838 : Reader.spn->IntConstant[*(yystack_[3].value.name)]=Evaluate.IntResult;
839 : Reader.spn->RealConstant[*(yystack_[3].value.name)]=Evaluate.RealResult;}
840 : }
841 : #line 842 "Gspn-parser.cc" // lalr1.cc:859
842 11 : break;
843 :
844 : case 34:
845 : #line 202 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
846 : {if(Reader.spn->RealConstant.find(*(yystack_[3].value.name))!=Reader.spn->RealConstant.end())
847 : {cout<<"Constant "<<*(yystack_[3].value.name)<<" already defined."<<endl; YYABORT;}
848 : else {string st=(yystack_[1].value.expression);
849 : if (Reader.P.constants.count(*(yystack_[3].value.name))>0)st = Reader.P.constants[*(yystack_[3].value.name)];
850 : Evaluate.parse(st);
851 : Reader.spn->RealConstant[*(yystack_[3].value.name)]=Evaluate.RealResult;}
852 : }
853 : #line 854 "Gspn-parser.cc" // lalr1.cc:859
854 24 : break;
855 :
856 : case 37:
857 : #line 213 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
858 : {Reader.spn->pl=(yystack_[1].value.IntVal);
859 :
860 : }
861 : #line 862 "Gspn-parser.cc" // lalr1.cc:859
862 11 : break;
863 :
864 : case 38:
865 : #line 216 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
866 : {if(Reader.spn->IntConstant.find(*(yystack_[1].value.name))==Reader.spn->IntConstant.end())
867 : {
868 : std::cout<<*(yystack_[1].value.name)<<" was not declared"<<std::endl;
869 : YYABORT;
870 : }
871 : Reader.spn->pl=Reader.spn->IntConstant[*(yystack_[1].value.name)];
872 :
873 : }
874 : #line 875 "Gspn-parser.cc" // lalr1.cc:859
875 0 : break;
876 :
877 : case 39:
878 : #line 225 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
879 : {Reader.spn->tr=(yystack_[1].value.IntVal);
880 :
881 : }
882 : #line 883 "Gspn-parser.cc" // lalr1.cc:859
883 11 : break;
884 :
885 : case 40:
886 : #line 228 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
887 : {if(Reader.spn->IntConstant.find(*(yystack_[1].value.name))==Reader.spn->IntConstant.end())
888 : {
889 : std::cout<<*(yystack_[1].value.name)<<" was not declared"<<std::endl;
890 : YYABORT;
891 : }
892 : Reader.spn->tr=Reader.spn->IntConstant[*(yystack_[1].value.name)];
893 :
894 : }
895 : #line 896 "Gspn-parser.cc" // lalr1.cc:859
896 0 : break;
897 :
898 : case 41:
899 : #line 237 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
900 : {
901 : if(Reader.spn->PlacesId.size()!=Reader.spn->pl){
902 : std::cout<<"Place label missing or redeclared, expected:"<< Reader.spn->pl <<"; found: "<< Reader.spn->PlacesId.size() <<std::endl;
903 : YYABORT;
904 : }
905 :
906 : //Reader.spn->Marking= vector<string>(Reader.spn->pl, " ");
907 :
908 : MarkingDependent=false;
909 : AgeMemory=false;
910 :
911 :
912 : }
913 : #line 914 "Gspn-parser.cc" // lalr1.cc:859
914 11 : break;
915 :
916 : case 42:
917 : #line 251 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
918 : {
919 : //cout << "New place name:" << *$1 << endl;
920 : place p;
921 : p.name = *(yystack_[0].value.name);
922 : p.id = Reader.spn->placeStruct.size();
923 : Reader.spn->placeStruct.push_back(p);
924 : int sz=Reader.spn->PlacesId.size();
925 : Reader.spn->PlacesId[*(yystack_[0].value.name)]=sz;
926 : }
927 : #line 928 "Gspn-parser.cc" // lalr1.cc:859
928 11 : break;
929 :
930 : case 43:
931 : #line 260 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
932 : {
933 : //cout << "New place name:" << *$3 << endl;
934 :
935 : place p;
936 : p.name = *(yystack_[0].value.name);
937 : p.id = Reader.spn->placeStruct.size();
938 : Reader.spn->placeStruct.push_back(p);
939 : int sz=Reader.spn->PlacesId.size();
940 : Reader.spn->PlacesId[*(yystack_[0].value.name)]=sz;
941 : }
942 : #line 943 "Gspn-parser.cc" // lalr1.cc:859
943 49 : break;
944 :
945 : case 44:
946 : #line 271 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
947 : {
948 : if(Reader.spn->TransList.size()!=Reader.spn->tr){
949 : std::cout<<"Transition label missing or redeclared, expected:"<< Reader.spn->tr <<"; found: "<< Reader.spn->TransList.size() << endl;
950 : YYABORT;
951 : }
952 :
953 : }
954 : #line 955 "Gspn-parser.cc" // lalr1.cc:859
955 11 : break;
956 :
957 : case 45:
958 : #line 279 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
959 : {Reader.spn->TransList.insert(*(yystack_[0].value.name));
960 : /*int sz=Reader.spn->TransId.size();
961 : Reader.spn->TransId[*$1]=sz;*/
962 :
963 : }
964 : #line 965 "Gspn-parser.cc" // lalr1.cc:859
965 11 : break;
966 :
967 : case 46:
968 : #line 284 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
969 : {Reader.spn->TransList.insert(*(yystack_[0].value.name));
970 : /*int sz=Reader.spn->TransId.size();
971 : Reader.spn->TransId[*$3]=sz;*/
972 :
973 : }
974 : #line 975 "Gspn-parser.cc" // lalr1.cc:859
975 62 : break;
976 :
977 : case 49:
978 : #line 294 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
979 : {}
980 : #line 981 "Gspn-parser.cc" // lalr1.cc:859
981 11 : break;
982 :
983 : case 52:
984 : #line 300 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
985 : { if(Reader.spn->PlacesId.find(*(yystack_[4].value.name))==Reader.spn->PlacesId.end())
986 : {cout<<"'"<<*(yystack_[4].value.name)<<"' has not been declared"<<endl;
987 : YYABORT;
988 : }
989 : string st=(yystack_[2].value.expression);
990 : if(Evaluate.parse(st)){
991 : std::cout<<"Initial Marking is not marking dependent"<<std::endl;
992 : YYABORT;
993 : }
994 : stringstream ss;
995 : ss << Evaluate.IntResult;
996 : Reader.spn->placeStruct[Reader.spn->PlacesId[*(yystack_[4].value.name)]].Marking=ss.str();
997 : Reader.spn->placeStruct[Reader.spn->PlacesId[*(yystack_[4].value.name)]].initMarking=vector<coloredToken>(1, coloredToken(ss.str()));
998 : }
999 : #line 1000 "Gspn-parser.cc" // lalr1.cc:859
1000 60 : break;
1001 :
1002 : case 54:
1003 : #line 318 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1004 : {}
1005 : #line 1006 "Gspn-parser.cc" // lalr1.cc:859
1006 11 : break;
1007 :
1008 : case 55:
1009 : #line 319 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1010 : {}
1011 : #line 1012 "Gspn-parser.cc" // lalr1.cc:859
1012 62 : break;
1013 :
1014 : case 56:
1015 : #line 321 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1016 : {
1017 : if(Reader.spn->TransList.find(*(yystack_[8].value.name))==Reader.spn->TransList.end())
1018 : {
1019 : std::cout<<"Transition: "<<*(yystack_[8].value.name)<<" was not declared"<<std::endl;
1020 : YYABORT;
1021 : }
1022 : transition *trans = new transition();
1023 : trans->name = (yystack_[8].value.name)->c_str();
1024 : trans->type = Timed;
1025 : trans->dist.name = distrib;
1026 : for(auto &s:Par)trans->dist.Param.push_back(expr(s));
1027 : trans->priority = expr(string((yystack_[4].value.expression)));
1028 : trans->weight = expr(string((yystack_[2].value.expression)));
1029 : trans->singleService = true;
1030 : trans->markingDependant = false;
1031 : trans->ageMemory = false;
1032 : trans->nbServers = 1;
1033 : trans->id = Reader.spn->transitionStruct.size();
1034 : int sz=Reader.spn->TransId.size();
1035 : Reader.spn->TransId[*(yystack_[8].value.name)]=sz;
1036 : Reader.spn->transitionStruct.push_back(*trans);
1037 :
1038 : Par.clear();
1039 : }
1040 : #line 1041 "Gspn-parser.cc" // lalr1.cc:859
1041 2 : break;
1042 :
1043 : case 57:
1044 : #line 345 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1045 : {
1046 : if(Reader.spn->TransList.find(*(yystack_[10].value.name))==Reader.spn->TransList.end())
1047 : {
1048 : std::cout<<"Transition: "<<*(yystack_[10].value.name)<<" was not declared"<<std::endl;
1049 : YYABORT;
1050 : }
1051 : transition *trans = new transition();
1052 : trans->name = (yystack_[10].value.name)->c_str();
1053 : trans->type = Timed;
1054 : trans->dist.name = distrib;
1055 : for(auto &s:Par)trans->dist.Param.push_back(expr(s));
1056 : trans->priority = *(yystack_[6].value.expression);
1057 : trans->weight = *(yystack_[4].value.expression);
1058 : trans->singleService = true;
1059 : trans->markingDependant = false;
1060 : trans->ageMemory = AgeMemory;
1061 : trans->nbServers = 1;
1062 : trans->id = Reader.spn->transitionStruct.size();
1063 : int sz=Reader.spn->TransId.size();
1064 : Reader.spn->TransId[*(yystack_[10].value.name)]=sz;
1065 : Reader.spn->transitionStruct.push_back(*trans);
1066 :
1067 : Par.clear();
1068 : AgeMemory=false;
1069 : }
1070 : #line 1071 "Gspn-parser.cc" // lalr1.cc:859
1071 0 : break;
1072 :
1073 : case 58:
1074 : #line 370 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1075 : {
1076 : if(Reader.spn->TransList.find(*(yystack_[13].value.name))==Reader.spn->TransList.end())
1077 : {
1078 : std::cout<<"Transition: "<<*(yystack_[13].value.name)<<" was not declared"<<std::endl;
1079 : YYABORT;
1080 : }
1081 : if(!SingleService) MarkingDependent=true;
1082 : string st=(yystack_[9].value.expression);
1083 : vector<string> v(1);
1084 : if(Evaluate.parse(st))
1085 : {MarkingDependent=true;v[0]=st;
1086 : }
1087 : else{ if (Evaluate.RealResult<= 0 ) {
1088 : cout << "In exponential distribution Lambda > 0" << endl;
1089 : YYABORT;
1090 : }
1091 : std::ostringstream s;s<<Evaluate.RealResult;
1092 : v[0]=s.str();
1093 : Par.clear();
1094 : }
1095 :
1096 : transition *trans = new transition();
1097 : trans->name = (yystack_[13].value.name)->c_str();
1098 : trans->type = Timed;
1099 : trans->dist.name = "EXPONENTIAL";
1100 : for(auto &s:v)trans->dist.Param.push_back(expr(s));
1101 : trans->priority = expr(string((yystack_[6].value.expression)));
1102 : trans->weight = expr(string((yystack_[4].value.expression)));
1103 : trans->singleService = SingleService;
1104 : trans->markingDependant = MarkingDependent;
1105 : trans->ageMemory = false;
1106 : trans->nbServers = NbServers;
1107 : trans->id = Reader.spn->transitionStruct.size();
1108 : int sz=Reader.spn->TransId.size();
1109 : Reader.spn->TransId[*(yystack_[13].value.name)]=sz;
1110 : Reader.spn->transitionStruct.push_back(*trans);
1111 :
1112 : Par.clear();
1113 : MarkingDependent=false;
1114 :
1115 : }
1116 : #line 1117 "Gspn-parser.cc" // lalr1.cc:859
1117 56 : break;
1118 :
1119 : case 59:
1120 : #line 412 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1121 : {
1122 : if(Reader.spn->TransList.find(*(yystack_[15].value.name))==Reader.spn->TransList.end())
1123 : {
1124 : std::cout<<"Transition: "<<*(yystack_[15].value.name)<<" was not declared"<<std::endl;
1125 : YYABORT;
1126 : }
1127 :
1128 : if(!SingleService) MarkingDependent=true;
1129 : string st=(yystack_[11].value.expression);
1130 : vector<string> v(1);
1131 : if(Evaluate.parse(st))
1132 : {MarkingDependent=true;v[0]=st;
1133 : }
1134 : else{ if (Evaluate.RealResult<= 0 ) {
1135 : cout << "In exponential distribution Lambda > 0" << endl;
1136 : YYABORT;
1137 : }
1138 : std::ostringstream s;s<<Evaluate.RealResult;
1139 : v[0]=s.str();
1140 : }
1141 :
1142 : transition *trans = new transition();
1143 : trans->name= (yystack_[15].value.name)->c_str();
1144 : trans->type = Timed;
1145 : trans->dist.name = "EXPONENTIAL";
1146 : for(auto &s:v)trans->dist.Param.push_back(expr(s));
1147 : trans->priority = expr(string((yystack_[8].value.expression)));
1148 : trans->weight = expr(string((yystack_[6].value.expression)));
1149 : trans->singleService = SingleService;
1150 : trans->markingDependant = MarkingDependent;
1151 : trans->ageMemory = AgeMemory;
1152 : trans->nbServers = NbServers;
1153 : trans->id = Reader.spn->transitionStruct.size();
1154 : Reader.spn->transitionStruct.push_back(*trans);
1155 : int sz=Reader.spn->TransId.size();
1156 : Reader.spn->TransId[*(yystack_[15].value.name)]=sz;
1157 : MarkingDependent=false;
1158 : AgeMemory=false;
1159 : Par.clear();
1160 : }
1161 : #line 1162 "Gspn-parser.cc" // lalr1.cc:859
1162 0 : break;
1163 :
1164 : case 60:
1165 : #line 453 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1166 : {
1167 : if(Reader.spn->TransList.find(*(yystack_[8].value.name))==Reader.spn->TransList.end())
1168 : {
1169 : std::cout<<"Transition: "<<*(yystack_[8].value.name)<<" was not declared"<<std::endl;
1170 : YYABORT;
1171 : }
1172 :
1173 : transition *trans = new transition();
1174 : trans->name = (yystack_[8].value.name)->c_str();
1175 : trans->type = unTimed;
1176 : trans->dist.name = "IMMEDIATE";
1177 : trans->priority = expr(string((yystack_[4].value.expression)));
1178 : trans->weight = expr(string((yystack_[2].value.expression)));
1179 : trans->singleService = true;
1180 : trans->markingDependant = false;
1181 : trans->ageMemory = false;
1182 : trans->nbServers = 1;
1183 : trans->id = Reader.spn->transitionStruct.size();
1184 : int sz=Reader.spn->TransId.size();
1185 : Reader.spn->TransId[*(yystack_[8].value.name)]=sz;
1186 : Reader.spn->transitionStruct.push_back(*trans);
1187 : Par.clear();
1188 : }
1189 : #line 1190 "Gspn-parser.cc" // lalr1.cc:859
1190 15 : break;
1191 :
1192 : case 61:
1193 : #line 482 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1194 : {string st=(yystack_[0].value.expression);
1195 : if(Evaluate.parse(st))
1196 : {cout<<"Weight is not marking dependent: '"<<st<<"'"<<endl;YYABORT; }
1197 : else{ if(Evaluate.RealResult<0)
1198 : {cout<<"Weight is a positive value: '"<<st<<"'"<<endl; YYABORT;}
1199 : else{std::ostringstream s;s<<Evaluate.RealResult;
1200 : sprintf((yylhs.value.expression), "%s",(s.str()).c_str());
1201 : }
1202 : }
1203 : }
1204 : #line 1205 "Gspn-parser.cc" // lalr1.cc:859
1205 73 : break;
1206 :
1207 : case 62:
1208 : #line 493 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1209 : {string st=(yystack_[0].value.expression);
1210 : if(Evaluate.parse(st))
1211 : {cout<<"Priority is not marking dependent: '"<<st<<"'"<<endl;YYABORT; }
1212 : else{ if(Evaluate.RealResult<0)
1213 : {cout<<"Priority is a positive value: '"<<st<<"'"<<endl; YYABORT;}
1214 : else{std::ostringstream s;s<<Evaluate.RealResult;
1215 : sprintf((yylhs.value.expression), "%s",(s.str()).c_str());
1216 : }
1217 : }
1218 : }
1219 : #line 1220 "Gspn-parser.cc" // lalr1.cc:859
1220 73 : break;
1221 :
1222 : case 63:
1223 : #line 504 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1224 : {SingleService=true; NbServers=1;}
1225 : #line 1226 "Gspn-parser.cc" // lalr1.cc:859
1226 56 : break;
1227 :
1228 : case 64:
1229 : #line 505 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1230 : {SingleService=false;NbServers=INT_MAX;}
1231 : #line 1232 "Gspn-parser.cc" // lalr1.cc:859
1232 0 : break;
1233 :
1234 : case 65:
1235 : #line 506 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1236 : {NbServers= (yystack_[1].value.IntVal);
1237 : if(NbServers<1)
1238 : { cout<<"Number of servers should be at least one"<<endl;
1239 : YYABORT;
1240 : }
1241 : if(NbServers==1) SingleService=true;
1242 : else {SingleService=false;}
1243 :
1244 :
1245 : }
1246 : #line 1247 "Gspn-parser.cc" // lalr1.cc:859
1247 0 : break;
1248 :
1249 : case 66:
1250 : #line 516 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1251 : {
1252 : if(Reader.spn->IntConstant.find(*(yystack_[1].value.name))!=Reader.spn->IntConstant.end()){
1253 : NbServers=Reader.spn->IntConstant[*(yystack_[1].value.name)];
1254 : if(NbServers<1)
1255 : { cout<<"Number of servers should be at least one"<<endl;
1256 : YYABORT;
1257 : }
1258 : if(NbServers==1) SingleService=true;
1259 : else {SingleService=false;}
1260 : }
1261 : else{cout<<*(yystack_[1].value.name)<<" not defined or not defined like an integer constant "<<endl;}
1262 :
1263 : }
1264 : #line 1265 "Gspn-parser.cc" // lalr1.cc:859
1265 0 : break;
1266 :
1267 : case 67:
1268 : #line 530 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1269 : {AgeMemory=true;}
1270 : #line 1271 "Gspn-parser.cc" // lalr1.cc:859
1271 0 : break;
1272 :
1273 : case 68:
1274 : #line 531 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1275 : {AgeMemory=false;}
1276 : #line 1277 "Gspn-parser.cc" // lalr1.cc:859
1277 0 : break;
1278 :
1279 : case 69:
1280 : #line 534 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1281 : {
1282 : distrib=*(yystack_[3].value.name);
1283 : int np=Par.size();
1284 : switch (Reader.IndexDist[distrib]) {
1285 : case UNIFORM:
1286 : {
1287 : if (np != 2){
1288 : cout << "Uniform distribution has two parameters: min and max where 0<=min<max" << endl;
1289 : YYABORT;
1290 : }
1291 : double p1,p2;
1292 : string st=Par[0];
1293 : Evaluate.parse(st);p1=Evaluate.RealResult;
1294 : st=Par[1];
1295 : Evaluate.parse(st);p2=Evaluate.RealResult;
1296 : if ((p1>=p2) || (p1<0)) {
1297 : cout << "In uniform distribution 0 <= min< max " << endl;
1298 : YYABORT;
1299 : }
1300 : break;
1301 : }
1302 :
1303 : case EXPONENTIAL:
1304 : {
1305 : if (np != 1) {
1306 : cout << "exponential distribution has one parameter: Lambda > 0, got "<< np << " parameters "<< distrib <<"[";
1307 : for(const auto &x : Par) cout << x << ", ";
1308 : cout << "]" << endl;
1309 : YYABORT;
1310 : }
1311 :
1312 : double p1;
1313 : string st=Par[0];
1314 : Evaluate.parse(st);p1=Evaluate.RealResult;
1315 : if (p1<= 0 ) {
1316 : cout << "In exponential distribution Lambda > 0" << endl;
1317 : YYABORT;
1318 : }
1319 : break;
1320 : }
1321 :
1322 : case DETERMINISTIC:
1323 : {
1324 : if (np != 1) {
1325 : cout << "Deterministic distribution has one parameter: T >= 0" << endl;
1326 : YYABORT;
1327 : }
1328 :
1329 : double p1;
1330 : string st=Par[0];
1331 : Evaluate.parse(st);p1=Evaluate.RealResult;
1332 : if (p1<0 ) {
1333 : cout << "In Deterministic distribution Lambda > 0" << endl;
1334 : YYABORT;
1335 : }
1336 : break;
1337 : }
1338 :
1339 : case LOGNORMAL:
1340 : {
1341 : if (np != 2) {
1342 : cout << "Lognormal distribution has two parameters: mu and sigma^2, where mu > 0 sigma^2 > 0" << endl;
1343 : YYABORT;
1344 : }
1345 :
1346 : double p1,p2;
1347 : string st=Par[0];
1348 : Evaluate.parse(st);p1=Evaluate.RealResult;
1349 : st=Par[1];
1350 : Evaluate.parse(st);p2=Evaluate.RealResult;
1351 : if ((p1<=0) || (p2<=0)) {
1352 : cout << "In Lognormal distribution mu > 0 sigma^2 > 0" << endl;
1353 : YYABORT;
1354 : }
1355 : break;
1356 : }
1357 :
1358 : case TRIANGLE:
1359 : {
1360 : if (np != 3) {
1361 : cout << "Triangle distribution has three parameters: 0 <= b <= c <= a" << endl;
1362 : YYABORT;
1363 : }
1364 : double p1,p2,p3;
1365 : string st=Par[0];
1366 : Evaluate.parse(st);p1=Evaluate.RealResult;
1367 : st=Par[1];
1368 : Evaluate.parse(st);p2=Evaluate.RealResult;
1369 : st=Par[2];
1370 : Evaluate.parse(st);p3=Evaluate.RealResult;
1371 : if ((p1<0) || (p2<p1) || (p3<p2)) {
1372 : cout << "In Triangle distribution: 0 <= b <= c<= a" << endl;
1373 : YYABORT;
1374 : }
1375 :
1376 :
1377 : break;
1378 : }
1379 :
1380 : case GEOMETRIC:
1381 : {
1382 : if (np != 2) {
1383 : cout << "Geometric distribution has two parameters: 0 <= p <= 1 (probability of success) and T > 0 (duration of one step)" << endl;
1384 : YYABORT;
1385 : }
1386 : double p1,p2;
1387 : string st=Par[0];
1388 : Evaluate.parse(st);p1=Evaluate.RealResult;
1389 : st=Par[1];
1390 : Evaluate.parse(st);p2=Evaluate.RealResult;
1391 : if ((p1<0) || (p1>1) || p2<=0) {
1392 : cout << "In Geometric distribution 0 <= p <= 1 (probability of success) and T > 0 (duration of one step)" << endl;
1393 : YYABORT;
1394 : }
1395 : break;
1396 : }
1397 : case ERLANG:
1398 : {
1399 : if (np != 2) {
1400 : cout << "Erlang distribution has two parameters: Shape and Rate, where Shape is a positive integer and Rate > 0" << endl;
1401 : YYABORT;
1402 : }
1403 :
1404 :
1405 : string st=Par[0];
1406 : Evaluate.parse(st);
1407 : if(Evaluate.RealResult != Evaluate.IntResult || Evaluate.IntResult < 1){
1408 : cout << "In Erlang distribution Shape is a positive integer" << endl;
1409 : YYABORT;
1410 : }
1411 :
1412 : st=Par[1];
1413 : Evaluate.parse(st);
1414 : if (Evaluate.RealResult<=0) {
1415 : cout << "In Erlang distribution Rate > 0" << endl;
1416 : YYABORT;
1417 : }
1418 : break;
1419 : }
1420 : case GAMMA:
1421 : {
1422 : if (np != 2) {
1423 : cout << "Gamma distribution has two parameters: Shape>0 and Scale>0" << endl;
1424 : YYABORT;
1425 : }
1426 :
1427 :
1428 : string st=Par[0];
1429 : Evaluate.parse(st);
1430 : if(Evaluate.RealResult<=0){
1431 : cout << "In Gamma distribution Shape > 0" << endl;
1432 : YYABORT;
1433 : }
1434 :
1435 : st=Par[1];
1436 : Evaluate.parse(st);
1437 : if (Evaluate.RealResult<=0) {
1438 : cout << "In Gamma distribution Scale > 0" << endl;
1439 : YYABORT;
1440 : }
1441 : break;
1442 : }
1443 :
1444 :
1445 : default: cout << "\nUnknown distribution !" << endl;
1446 : YYABORT;
1447 :
1448 : }
1449 : }
1450 : #line 1451 "Gspn-parser.cc" // lalr1.cc:859
1451 2 : break;
1452 :
1453 : case 72:
1454 : #line 711 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1455 : {string st=(yystack_[0].value.expression);
1456 : if(Evaluate.parse(st))
1457 : {cout<<"The exponential distribution is the only marking dependent distribution: '"<<st<<"'"<<endl;YYABORT; }
1458 : else{std::ostringstream s;s<<Evaluate.RealResult;
1459 : Par.push_back(s.str());
1460 : }
1461 : }
1462 : #line 1463 "Gspn-parser.cc" // lalr1.cc:859
1463 4 : break;
1464 :
1465 : case 73:
1466 : #line 720 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1467 : {}
1468 : #line 1469 "Gspn-parser.cc" // lalr1.cc:859
1469 11 : break;
1470 :
1471 : case 74:
1472 : #line 722 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1473 : {}
1474 : #line 1475 "Gspn-parser.cc" // lalr1.cc:859
1475 11 : break;
1476 :
1477 : case 75:
1478 : #line 723 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1479 : {}
1480 : #line 1481 "Gspn-parser.cc" // lalr1.cc:859
1481 75 : break;
1482 :
1483 : case 76:
1484 : #line 725 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1485 : {
1486 : if(Reader.spn->PlacesId.find(*(yystack_[6].value.name))==Reader.spn->PlacesId.end())
1487 : {
1488 : std::cout<<"Place: "<<*(yystack_[6].value.name)<<" was not declared"<<std::endl;
1489 : YYABORT;
1490 : }
1491 : if(Reader.spn->TransList.find(*(yystack_[4].value.name))==Reader.spn->TransList.end())
1492 : {
1493 : std::cout<<"Transition: "<<*(yystack_[4].value.name)<<" was not declared"<<std::endl;
1494 : YYABORT;
1495 : }
1496 : string st=(yystack_[2].value.expression);
1497 :
1498 : if(Evaluate.parse(st)){
1499 : Reader.spn->inArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[4].value.name)],Reader.spn->PlacesId[*(yystack_[6].value.name)]), arc(st)));
1500 : }else Reader.spn->inArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[4].value.name)],Reader.spn->PlacesId[*(yystack_[6].value.name)]),arc(Evaluate.IntResult)));
1501 :
1502 : }
1503 : #line 1504 "Gspn-parser.cc" // lalr1.cc:859
1504 85 : break;
1505 :
1506 : case 77:
1507 : #line 743 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1508 : {
1509 : if(Reader.spn->PlacesId.find(*(yystack_[4].value.name))==Reader.spn->PlacesId.end())
1510 : {
1511 : std::cout<<"Place: "<<*(yystack_[4].value.name)<<" was not declared"<<std::endl;
1512 : YYABORT;
1513 : }
1514 : if(Reader.spn->TransList.find(*(yystack_[2].value.name))==Reader.spn->TransList.end())
1515 : {
1516 : std::cout<<"Transition: "<<*(yystack_[2].value.name)<<" was not declared"<<std::endl;
1517 : YYABORT;
1518 : }
1519 : Reader.spn->inArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[2].value.name)],Reader.spn->PlacesId[*(yystack_[4].value.name)]),arc(1)));
1520 :
1521 : }
1522 : #line 1523 "Gspn-parser.cc" // lalr1.cc:859
1523 1 : break;
1524 :
1525 : case 78:
1526 : #line 758 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1527 : {}
1528 : #line 1529 "Gspn-parser.cc" // lalr1.cc:859
1529 11 : break;
1530 :
1531 : case 79:
1532 : #line 760 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1533 : {}
1534 : #line 1535 "Gspn-parser.cc" // lalr1.cc:859
1535 11 : break;
1536 :
1537 : case 80:
1538 : #line 761 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1539 : {}
1540 : #line 1541 "Gspn-parser.cc" // lalr1.cc:859
1541 75 : break;
1542 :
1543 : case 81:
1544 : #line 763 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1545 : {
1546 : if(Reader.spn->TransList.find(*(yystack_[6].value.name))==Reader.spn->TransList.end())
1547 : {
1548 : std::cout<<"Transition: "<<*(yystack_[6].value.name)<<" was not declared"<<std::endl;
1549 : YYABORT;
1550 : }
1551 : if(Reader.spn->PlacesId.find(*(yystack_[4].value.name))==Reader.spn->PlacesId.end())
1552 : {
1553 : std::cout<<"Place: "<<*(yystack_[4].value.name)<<" was not declared"<<std::endl;
1554 : YYABORT;
1555 : }
1556 : string st=(yystack_[2].value.expression);
1557 :
1558 : if(Evaluate.parse(st)){
1559 : Reader.spn->outArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[6].value.name)],Reader.spn->PlacesId[*(yystack_[4].value.name)]),arc(st)));
1560 : }
1561 : else Reader.spn->outArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[6].value.name)],Reader.spn->PlacesId[*(yystack_[4].value.name)]),arc(Evaluate.IntResult)));
1562 :
1563 : }
1564 : #line 1565 "Gspn-parser.cc" // lalr1.cc:859
1565 85 : break;
1566 :
1567 : case 82:
1568 : #line 782 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1569 : {
1570 : if(Reader.spn->TransList.find(*(yystack_[4].value.name))==Reader.spn->TransList.end())
1571 : {
1572 : std::cout<<"Transition: "<<*(yystack_[4].value.name)<<" was not declared"<<std::endl;
1573 : YYABORT;
1574 : }
1575 : if(Reader.spn->PlacesId.find(*(yystack_[2].value.name))==Reader.spn->PlacesId.end())
1576 : {
1577 : std::cout<<"Place: "<<*(yystack_[2].value.name)<<" was not declared"<<std::endl;
1578 : YYABORT;
1579 : }
1580 : Reader.spn->outArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[4].value.name)],Reader.spn->PlacesId[*(yystack_[2].value.name)]),arc(1)));
1581 : }
1582 : #line 1583 "Gspn-parser.cc" // lalr1.cc:859
1583 1 : break;
1584 :
1585 : case 83:
1586 : #line 798 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1587 : {}
1588 : #line 1589 "Gspn-parser.cc" // lalr1.cc:859
1589 0 : break;
1590 :
1591 : case 84:
1592 : #line 800 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1593 : {}
1594 : #line 1595 "Gspn-parser.cc" // lalr1.cc:859
1595 0 : break;
1596 :
1597 : case 85:
1598 : #line 801 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1599 : {}
1600 : #line 1601 "Gspn-parser.cc" // lalr1.cc:859
1601 0 : break;
1602 :
1603 : case 86:
1604 : #line 803 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1605 : {
1606 : if(Reader.spn->PlacesId.find(*(yystack_[6].value.name))==Reader.spn->PlacesId.end())
1607 : {
1608 : std::cout<<"Place: "<<*(yystack_[6].value.name)<<" was not declared"<<std::endl;
1609 : YYABORT;
1610 : }
1611 : if(Reader.spn->TransList.find(*(yystack_[4].value.name))==Reader.spn->TransList.end())
1612 : {
1613 : std::cout<<"Transition: "<<*(yystack_[4].value.name)<<" was not declared"<<std::endl;
1614 : YYABORT;
1615 : }
1616 : string st=(yystack_[2].value.expression);
1617 :
1618 : if(Evaluate.parse(st)){
1619 : Reader.spn->inhibArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[4].value.name)],Reader.spn->PlacesId[*(yystack_[6].value.name)]),arc(st)));
1620 : }
1621 : else Reader.spn->inhibArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[4].value.name)],Reader.spn->PlacesId[*(yystack_[6].value.name)]),arc(Evaluate.IntResult)));
1622 :
1623 : }
1624 : #line 1625 "Gspn-parser.cc" // lalr1.cc:859
1625 0 : break;
1626 :
1627 : case 87:
1628 : #line 823 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:859
1629 : {
1630 : if(Reader.spn->PlacesId.find(*(yystack_[4].value.name))==Reader.spn->PlacesId.end())
1631 : {
1632 : std::cout<<"Place: "<<*(yystack_[4].value.name)<<" was not declared"<<std::endl;
1633 : YYABORT;
1634 : }
1635 : if(Reader.spn->TransList.find(*(yystack_[2].value.name))==Reader.spn->TransList.end())
1636 : {
1637 : std::cout<<"Transition: "<<*(yystack_[2].value.name)<<" was not declared"<<std::endl;
1638 : YYABORT;
1639 : }
1640 : Reader.spn->inhibArcsStruct.insert(make_pair<pair<size_t,size_t>,arc>(Reader.spn->arckey(Reader.spn->TransId[*(yystack_[2].value.name)],Reader.spn->PlacesId[*(yystack_[4].value.name)]),arc(1)));
1641 :
1642 : }
1643 : #line 1644 "Gspn-parser.cc" // lalr1.cc:859
1644 0 : break;
1645 :
1646 :
1647 : #line 1648 "Gspn-parser.cc" // lalr1.cc:859
1648 : default:
1649 165 : break;
1650 : }
1651 : }
1652 0 : catch (const syntax_error& yyexc)
1653 : {
1654 0 : error (yyexc);
1655 0 : YYERROR;
1656 : }
1657 1663 : YY_SYMBOL_PRINT ("-> $$ =", yylhs);
1658 1663 : yypop_ (yylen);
1659 1663 : yylen = 0;
1660 1663 : YY_STACK_PRINT ();
1661 :
1662 : // Shift the result of the reduction.
1663 1663 : yypush_ (YY_NULLPTR, yylhs);
1664 : }
1665 1663 : goto yynewstate;
1666 :
1667 : /*--------------------------------------.
1668 : | yyerrlab -- here on detecting error. |
1669 : `--------------------------------------*/
1670 : yyerrlab:
1671 : // If not already recovering from an error, report this error.
1672 0 : if (!yyerrstatus_)
1673 : {
1674 0 : ++yynerrs_;
1675 0 : error (yyla.location, yysyntax_error_ (yystack_[0].state, yyla));
1676 : }
1677 :
1678 :
1679 0 : yyerror_range[1].location = yyla.location;
1680 0 : if (yyerrstatus_ == 3)
1681 : {
1682 : /* If just tried and failed to reuse lookahead token after an
1683 : error, discard it. */
1684 :
1685 : // Return failure if at end of input.
1686 0 : if (yyla.type_get () == yyeof_)
1687 0 : YYABORT;
1688 0 : else if (!yyla.empty ())
1689 : {
1690 0 : yy_destroy_ ("Error: discarding", yyla);
1691 0 : yyla.clear ();
1692 : }
1693 : }
1694 :
1695 : // Else will try to reuse lookahead token after shifting the error token.
1696 0 : goto yyerrlab1;
1697 :
1698 :
1699 : /*---------------------------------------------------.
1700 : | yyerrorlab -- error raised explicitly by YYERROR. |
1701 : `---------------------------------------------------*/
1702 : yyerrorlab:
1703 :
1704 : /* Pacify compilers like GCC when the user code never invokes
1705 : YYERROR and the label yyerrorlab therefore never appears in user
1706 : code. */
1707 : if (false)
1708 : goto yyerrorlab;
1709 0 : yyerror_range[1].location = yystack_[yylen - 1].location;
1710 : /* Do not reclaim the symbols of the rule whose action triggered
1711 : this YYERROR. */
1712 0 : yypop_ (yylen);
1713 0 : yylen = 0;
1714 0 : goto yyerrlab1;
1715 :
1716 : /*-------------------------------------------------------------.
1717 : | yyerrlab1 -- common code for both syntax error and YYERROR. |
1718 : `-------------------------------------------------------------*/
1719 : yyerrlab1:
1720 0 : yyerrstatus_ = 3; // Each real token shifted decrements this.
1721 : {
1722 0 : stack_symbol_type error_token;
1723 : for (;;)
1724 : {
1725 0 : yyn = yypact_[yystack_[0].state];
1726 0 : if (!yy_pact_value_is_default_ (yyn))
1727 : {
1728 0 : yyn += yyterror_;
1729 0 : if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
1730 : {
1731 0 : yyn = yytable_[yyn];
1732 0 : if (0 < yyn)
1733 0 : break;
1734 : }
1735 : }
1736 :
1737 : // Pop the current state because it cannot handle the error token.
1738 0 : if (yystack_.size () == 1)
1739 0 : YYABORT;
1740 :
1741 0 : yyerror_range[1].location = yystack_[0].location;
1742 0 : yy_destroy_ ("Error: popping", yystack_[0]);
1743 0 : yypop_ ();
1744 0 : YY_STACK_PRINT ();
1745 : }
1746 :
1747 0 : yyerror_range[2].location = yyla.location;
1748 0 : YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);
1749 :
1750 : // Shift the error token.
1751 0 : error_token.state = yyn;
1752 0 : yypush_ ("Shifting", error_token);
1753 : }
1754 0 : goto yynewstate;
1755 :
1756 : // Accept.
1757 : yyacceptlab:
1758 11 : yyresult = 0;
1759 11 : goto yyreturn;
1760 :
1761 : // Abort.
1762 : yyabortlab:
1763 0 : yyresult = 1;
1764 0 : goto yyreturn;
1765 :
1766 : yyreturn:
1767 11 : if (!yyla.empty ())
1768 0 : yy_destroy_ ("Cleanup: discarding lookahead", yyla);
1769 :
1770 : /* Do not reclaim the symbols of the rule whose action triggered
1771 : this YYABORT or YYACCEPT. */
1772 11 : yypop_ (yylen);
1773 55 : while (1 < yystack_.size ())
1774 : {
1775 22 : yy_destroy_ ("Cleanup: popping", yystack_[0]);
1776 22 : yypop_ ();
1777 : }
1778 :
1779 22 : return yyresult;
1780 : }
1781 0 : catch (...)
1782 : {
1783 0 : YYCDEBUG << "Exception caught: cleaning lookahead and stack"
1784 0 : << std::endl;
1785 : // Do not try to display the values of the reclaimed symbols,
1786 : // as their printer might throw an exception.
1787 0 : if (!yyla.empty ())
1788 0 : yy_destroy_ (YY_NULLPTR, yyla);
1789 :
1790 0 : while (1 < yystack_.size ())
1791 : {
1792 0 : yy_destroy_ (YY_NULLPTR, yystack_[0]);
1793 0 : yypop_ ();
1794 : }
1795 0 : throw;
1796 : }
1797 : }
1798 :
1799 : void
1800 0 : Gspn_parser::error (const syntax_error& yyexc)
1801 : {
1802 0 : error (yyexc.location, yyexc.what());
1803 0 : }
1804 :
1805 : // Generate an error message.
1806 : std::string
1807 0 : Gspn_parser::yysyntax_error_ (state_type yystate, const symbol_type& yyla) const
1808 : {
1809 : // Number of reported tokens (one for the "unexpected", one per
1810 : // "expected").
1811 0 : size_t yycount = 0;
1812 : // Its maximum.
1813 : enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1814 : // Arguments of yyformat.
1815 : char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1816 :
1817 : /* There are many possibilities here to consider:
1818 : - If this state is a consistent state with a default action, then
1819 : the only way this function was invoked is if the default action
1820 : is an error action. In that case, don't check for expected
1821 : tokens because there are none.
1822 : - The only way there can be no lookahead present (in yyla) is
1823 : if this state is a consistent state with a default action.
1824 : Thus, detecting the absence of a lookahead is sufficient to
1825 : determine that there is no unexpected or expected token to
1826 : report. In that case, just report a simple "syntax error".
1827 : - Don't assume there isn't a lookahead just because this state is
1828 : a consistent state with a default action. There might have
1829 : been a previous inconsistent state, consistent state with a
1830 : non-default action, or user semantic action that manipulated
1831 : yyla. (However, yyla is currently not documented for users.)
1832 : - Of course, the expected token list depends on states to have
1833 : correct lookahead information, and it depends on the parser not
1834 : to perform extra reductions after fetching a lookahead from the
1835 : scanner and before detecting a syntax error. Thus, state
1836 : merging (from LALR or IELR) and default reductions corrupt the
1837 : expected token list. However, the list is correct for
1838 : canonical LR with one exception: it will still contain any
1839 : token that will not be accepted due to an error action in a
1840 : later state.
1841 : */
1842 0 : if (!yyla.empty ())
1843 : {
1844 0 : int yytoken = yyla.type_get ();
1845 0 : yyarg[yycount++] = yytname_[yytoken];
1846 0 : int yyn = yypact_[yystate];
1847 0 : if (!yy_pact_value_is_default_ (yyn))
1848 : {
1849 : /* Start YYX at -YYN if negative to avoid negative indexes in
1850 : YYCHECK. In other words, skip the first -YYN actions for
1851 : this state because they are default actions. */
1852 0 : int yyxbegin = yyn < 0 ? -yyn : 0;
1853 : // Stay within bounds of both yycheck and yytname.
1854 0 : int yychecklim = yylast_ - yyn + 1;
1855 0 : int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1856 0 : for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
1857 0 : if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
1858 0 : && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
1859 : {
1860 0 : if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1861 : {
1862 0 : yycount = 1;
1863 0 : break;
1864 : }
1865 : else
1866 0 : yyarg[yycount++] = yytname_[yyx];
1867 : }
1868 : }
1869 : }
1870 :
1871 0 : char const* yyformat = YY_NULLPTR;
1872 0 : switch (yycount)
1873 : {
1874 : #define YYCASE_(N, S) \
1875 : case N: \
1876 : yyformat = S; \
1877 : break
1878 0 : YYCASE_(0, YY_("syntax error"));
1879 0 : YYCASE_(1, YY_("syntax error, unexpected %s"));
1880 0 : YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1881 0 : YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1882 0 : YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1883 0 : YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1884 : #undef YYCASE_
1885 : }
1886 :
1887 0 : std::string yyres;
1888 : // Argument number.
1889 0 : size_t yyi = 0;
1890 0 : for (char const* yyp = yyformat; *yyp; ++yyp)
1891 0 : if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
1892 : {
1893 0 : yyres += yytnamerr_ (yyarg[yyi++]);
1894 0 : ++yyp;
1895 : }
1896 : else
1897 0 : yyres += *yyp;
1898 0 : return yyres;
1899 : }
1900 :
1901 :
1902 : const short int Gspn_parser::yypact_ninf_ = -210;
1903 :
1904 : const signed char Gspn_parser::yytable_ninf_ = -1;
1905 :
1906 : const short int
1907 : Gspn_parser::yypact_[] =
1908 : {
1909 : -7, 44, 62, 7, 13, 35, 48, 73, 58, 69,
1910 : 85, 59, 155, 120, 127, -210, 162, 147, 147, 73,
1911 : 169, 175, -210, 158, 176, -210, -210, -210, 188, 195,
1912 : 196, 202, 199, 206, 183, 213, -210, -210, 194, -210,
1913 : 203, 204, -210, -210, -210, -210, -210, -210, 55, 51,
1914 : 222, 207, 234, 223, 245, 246, -210, -210, 55, 241,
1915 : 242, 243, 9, -210, -210, -210, 51, 244, 247, 248,
1916 : 56, 251, 0, -210, 249, 215, 250, 230, -210, -5,
1917 : -210, -2, 161, 55, 55, 55, -210, 55, 55, 55,
1918 : 55, 64, 51, 51, 51, -210, 51, 51, 51, 51,
1919 : 51, 252, 255, -210, 260, 1, -210, 256, 226, 253,
1920 : -210, 264, 261, 266, 263, -210, 101, 105, 112, 257,
1921 : 2, 2, -210, -210, 83, 92, 119, 258, 258, 217,
1922 : 217, -210, 55, -210, 267, 265, -210, 268, 5, -210,
1923 : 269, 236, -210, -210, -210, -210, 55, 55, -210, 55,
1924 : 51, 51, -210, 168, -1, -210, 271, 270, -210, 277,
1925 : 11, -210, 272, 177, 184, 191, 129, 136, 275, 274,
1926 : 276, 278, 280, 282, -210, 281, 279, -210, 287, 12,
1927 : -210, -210, -210, -210, -210, -210, -210, 51, 51, 51,
1928 : 51, -3, 288, -210, 284, 286, -210, 141, 224, -210,
1929 : 141, 289, 153, 290, 55, 292, 227, 291, -210, 51,
1930 : -210, 51, 293, 51, 198, -210, 55, 295, 228, -210,
1931 : 141, 285, 51, 231, 296, 205, -210, 55, 297, 298,
1932 : 299, 100, 301, -210, 302, 212, -210, -210, 51, -210,
1933 : -210, 300, -210, -210, 304, 305, 307, -210, 77, -210,
1934 : -210, -210, 303, 232, 182, 100, 308, 306, 309, 310,
1935 : -210, -210, -210, 311, -210
1936 : };
1937 :
1938 : const unsigned char
1939 : Gspn_parser::yydefact_[] =
1940 : {
1941 : 0, 0, 0, 0, 0, 0, 0, 0, 29, 0,
1942 : 0, 0, 0, 0, 0, 1, 0, 25, 0, 0,
1943 : 0, 0, 28, 0, 0, 30, 31, 32, 0, 0,
1944 : 0, 0, 0, 0, 0, 0, 88, 26, 0, 27,
1945 : 0, 0, 35, 36, 38, 37, 40, 39, 0, 0,
1946 : 0, 0, 0, 0, 0, 0, 3, 2, 0, 0,
1947 : 0, 0, 0, 15, 13, 14, 0, 0, 0, 0,
1948 : 0, 0, 0, 50, 0, 0, 0, 47, 42, 0,
1949 : 45, 0, 0, 0, 0, 0, 33, 0, 0, 0,
1950 : 0, 0, 0, 0, 0, 34, 0, 0, 0, 0,
1951 : 0, 0, 0, 51, 0, 0, 54, 0, 0, 0,
1952 : 48, 0, 0, 0, 0, 4, 0, 0, 0, 7,
1953 : 5, 6, 8, 16, 0, 0, 0, 17, 20, 18,
1954 : 19, 21, 0, 49, 0, 0, 55, 0, 0, 74,
1955 : 0, 0, 43, 41, 46, 44, 0, 0, 9, 0,
1956 : 0, 0, 22, 0, 0, 53, 0, 0, 75, 0,
1957 : 0, 79, 0, 0, 0, 0, 0, 0, 0, 0,
1958 : 0, 0, 0, 0, 73, 0, 0, 80, 0, 0,
1959 : 84, 11, 12, 10, 23, 24, 52, 0, 0, 0,
1960 : 0, 0, 0, 78, 0, 0, 85, 72, 0, 70,
1961 : 62, 0, 0, 0, 0, 0, 0, 0, 83, 0,
1962 : 69, 0, 0, 0, 0, 77, 0, 0, 0, 71,
1963 : 61, 0, 0, 0, 0, 0, 82, 0, 0, 0,
1964 : 0, 0, 0, 76, 0, 0, 87, 60, 0, 68,
1965 : 67, 0, 56, 81, 0, 0, 0, 86, 0, 57,
1966 : 63, 64, 0, 0, 0, 0, 0, 0, 0, 0,
1967 : 58, 66, 65, 0, 59
1968 : };
1969 :
1970 : const short int
1971 : Gspn_parser::yypgoto_[] =
1972 : {
1973 : -210, -57, -49, -210, -210, 313, 294, -210, 312, 314,
1974 : 316, 315, -210, 273, -210, -210, -210, -210, 254, 317,
1975 : -210, 201, -209, -182, -210, 67, -210, -210, 108, -210,
1976 : -210, 185, -210, -210, 167, -210, -210, 149, -210
1977 : };
1978 :
1979 : const short int
1980 : Gspn_parser::yydefgoto_[] =
1981 : {
1982 : -1, 62, 200, 4, 5, 6, 7, 8, 22, 9,
1983 : 10, 23, 79, 24, 81, 17, 18, 72, 73, 36,
1984 : 105, 106, 221, 201, 253, 241, 172, 198, 199, 53,
1985 : 138, 139, 77, 160, 161, 110, 179, 180, 37
1986 : };
1987 :
1988 : const unsigned short int
1989 : Gspn_parser::yytable_[] =
1990 : {
1991 : 70, 82, 169, 111, 223, 204, 113, 205, 203, 71,
1992 : 104, 1, 2, 15, 137, 87, 86, 91, 90, 3,
1993 : 159, 178, 87, 88, 89, 90, 116, 117, 118, 245,
1994 : 119, 120, 121, 122, 13, 14, 112, 170, 171, 114,
1995 : 230, 102, 135, 124, 125, 126, 157, 127, 128, 129,
1996 : 130, 131, 176, 195, 63, 11, 64, 65, 56, 16,
1997 : 66, 57, 28, 95, 58, 29, 1, 2, 96, 97,
1998 : 98, 99, 100, 12, 123, 153, 96, 97, 98, 99,
1999 : 100, 67, 68, 69, 3, 59, 60, 61, 2, 163,
2000 : 164, 150, 165, 20, 21, 96, 97, 98, 99, 100,
2001 : 151, 166, 167, 1, 96, 97, 98, 99, 100, 146,
2002 : 250, 251, 252, 147, 87, 88, 89, 90, 87, 88,
2003 : 89, 90, 148, 32, 149, 87, 88, 89, 90, 152,
2004 : 33, 96, 97, 98, 99, 100, 239, 240, 197, 184,
2005 : 202, 96, 97, 98, 99, 100, 185, 214, 96, 97,
2006 : 98, 99, 100, 96, 97, 98, 99, 100, 30, 225,
2007 : 197, 31, 220, 212, 220, 96, 97, 98, 99, 100,
2008 : 235, 115, 35, 34, 87, 88, 89, 90, 168, 21,
2009 : 40, 87, 88, 89, 90, 257, 41, 181, 258, 220,
2010 : 87, 88, 89, 90, 182, 44, 20, 87, 88, 89,
2011 : 90, 183, 45, 46, 87, 88, 89, 90, 224, 47,
2012 : 48, 87, 88, 89, 90, 234, 52, 49, 87, 88,
2013 : 89, 90, 244, 50, 51, 87, 88, 89, 90, 96,
2014 : 97, 71, 209, 100, 210, 216, 227, 217, 228, 231,
2015 : 255, 232, 256, 54, 55, 75, 76, 74, 78, 80,
2016 : 83, 84, 85, 92, 101, 107, 93, 94, 104, 109,
2017 : 132, 108, 133, 134, 141, 137, 140, 142, 143, 144,
2018 : 145, 156, 155, 90, 100, 154, 162, 174, 159, 173,
2019 : 175, 178, 186, 187, 188, 191, 193, 189, 190, 192,
2020 : 194, 206, 207, 208, 218, 229, 42, 211, 213, 215,
2021 : 19, 222, 226, 233, 236, 237, 136, 238, 242, 243,
2022 : 246, 247, 254, 248, 249, 260, 261, 219, 264, 262,
2023 : 263, 25, 259, 158, 27, 26, 103, 177, 196, 0,
2024 : 0, 39, 0, 0, 0, 38, 0, 0, 0, 43
2025 : };
2026 :
2027 : const short int
2028 : Gspn_parser::yycheck_[] =
2029 : {
2030 : 49, 58, 3, 8, 213, 8, 8, 10, 190, 9,
2031 : 9, 18, 19, 0, 9, 13, 7, 66, 16, 26,
2032 : 9, 9, 13, 14, 15, 16, 83, 84, 85, 238,
2033 : 87, 88, 89, 90, 27, 28, 41, 38, 39, 41,
2034 : 222, 41, 41, 92, 93, 94, 41, 96, 97, 98,
2035 : 99, 100, 41, 41, 3, 11, 5, 6, 3, 24,
2036 : 9, 6, 3, 7, 9, 6, 18, 19, 12, 13,
2037 : 14, 15, 16, 11, 10, 132, 12, 13, 14, 15,
2038 : 16, 30, 31, 32, 26, 30, 31, 32, 19, 146,
2039 : 147, 8, 149, 20, 21, 12, 13, 14, 15, 16,
2040 : 8, 150, 151, 18, 12, 13, 14, 15, 16, 8,
2041 : 33, 34, 35, 8, 13, 14, 15, 16, 13, 14,
2042 : 15, 16, 10, 3, 12, 13, 14, 15, 16, 10,
2043 : 3, 12, 13, 14, 15, 16, 36, 37, 187, 10,
2044 : 189, 12, 13, 14, 15, 16, 10, 204, 12, 13,
2045 : 14, 15, 16, 12, 13, 14, 15, 16, 3, 216,
2046 : 209, 6, 211, 10, 213, 12, 13, 14, 15, 16,
2047 : 227, 10, 25, 11, 13, 14, 15, 16, 10, 21,
2048 : 11, 13, 14, 15, 16, 3, 11, 10, 6, 238,
2049 : 13, 14, 15, 16, 10, 7, 20, 13, 14, 15,
2050 : 16, 10, 7, 7, 13, 14, 15, 16, 10, 7,
2051 : 11, 13, 14, 15, 16, 10, 22, 11, 13, 14,
2052 : 15, 16, 10, 40, 11, 13, 14, 15, 16, 12,
2053 : 13, 9, 8, 16, 10, 8, 8, 10, 10, 8,
2054 : 8, 10, 10, 40, 40, 11, 23, 40, 3, 3,
2055 : 9, 9, 9, 9, 3, 40, 9, 9, 9, 29,
2056 : 8, 11, 7, 3, 11, 9, 40, 3, 7, 3,
2057 : 7, 3, 7, 16, 16, 8, 40, 7, 9, 8,
2058 : 3, 9, 7, 9, 8, 3, 7, 9, 8, 8,
2059 : 3, 3, 8, 7, 3, 10, 23, 8, 8, 7,
2060 : 6, 8, 7, 7, 7, 7, 105, 8, 7, 7,
2061 : 10, 7, 9, 8, 7, 7, 10, 209, 7, 10,
2062 : 10, 8, 255, 138, 10, 9, 72, 160, 179, -1,
2063 : -1, 19, -1, -1, -1, 18, -1, -1, -1, 24
2064 : };
2065 :
2066 : const unsigned char
2067 : Gspn_parser::yystos_[] =
2068 : {
2069 : 0, 18, 19, 26, 45, 46, 47, 48, 49, 51,
2070 : 52, 11, 11, 27, 28, 0, 24, 57, 58, 48,
2071 : 20, 21, 50, 53, 55, 47, 52, 51, 3, 6,
2072 : 3, 6, 3, 3, 11, 25, 61, 80, 61, 50,
2073 : 11, 11, 55, 53, 7, 7, 7, 7, 11, 11,
2074 : 40, 11, 22, 71, 40, 40, 3, 6, 9, 30,
2075 : 31, 32, 43, 3, 5, 6, 9, 30, 31, 32,
2076 : 44, 9, 59, 60, 40, 11, 23, 74, 3, 54,
2077 : 3, 56, 43, 9, 9, 9, 7, 13, 14, 15,
2078 : 16, 44, 9, 9, 9, 7, 12, 13, 14, 15,
2079 : 16, 3, 41, 60, 9, 62, 63, 40, 11, 29,
2080 : 77, 8, 41, 8, 41, 10, 43, 43, 43, 43,
2081 : 43, 43, 43, 10, 44, 44, 44, 44, 44, 44,
2082 : 44, 44, 8, 7, 3, 41, 63, 9, 72, 73,
2083 : 40, 11, 3, 7, 3, 7, 8, 8, 10, 12,
2084 : 8, 8, 10, 43, 8, 7, 3, 41, 73, 9,
2085 : 75, 76, 40, 43, 43, 43, 44, 44, 10, 3,
2086 : 38, 39, 68, 8, 7, 3, 41, 76, 9, 78,
2087 : 79, 10, 10, 10, 10, 10, 7, 9, 8, 9,
2088 : 8, 3, 8, 7, 3, 41, 79, 44, 69, 70,
2089 : 44, 65, 44, 65, 8, 10, 3, 8, 7, 8,
2090 : 10, 8, 10, 8, 43, 7, 8, 10, 3, 70,
2091 : 44, 64, 8, 64, 10, 43, 7, 8, 10, 10,
2092 : 65, 8, 10, 7, 10, 43, 7, 7, 8, 36,
2093 : 37, 67, 7, 7, 10, 64, 10, 7, 8, 7,
2094 : 33, 34, 35, 66, 9, 8, 10, 3, 6, 67,
2095 : 7, 10, 10, 10, 7
2096 : };
2097 :
2098 : const unsigned char
2099 : Gspn_parser::yyr1_[] =
2100 : {
2101 : 0, 42, 43, 43, 43, 43, 43, 43, 43, 43,
2102 : 43, 43, 43, 44, 44, 44, 44, 44, 44, 44,
2103 : 44, 44, 44, 44, 44, 45, 45, 46, 46, 47,
2104 : 47, 48, 48, 49, 49, 50, 50, 51, 51, 52,
2105 : 52, 53, 54, 54, 55, 56, 56, 57, 57, 58,
2106 : 59, 59, 60, 61, 62, 62, 63, 63, 63, 63,
2107 : 63, 64, 65, 66, 66, 66, 66, 67, 67, 68,
2108 : 69, 69, 70, 71, 72, 72, 73, 73, 74, 75,
2109 : 75, 76, 76, 77, 78, 78, 79, 79, 80
2110 : };
2111 :
2112 : const unsigned char
2113 : Gspn_parser::yyr2_[] =
2114 : {
2115 : 0, 2, 1, 1, 3, 3, 3, 3, 3, 4,
2116 : 6, 6, 6, 1, 1, 1, 3, 3, 3, 3,
2117 : 3, 3, 4, 6, 6, 2, 3, 3, 2, 1,
2118 : 2, 2, 2, 6, 6, 2, 2, 4, 4, 4,
2119 : 4, 6, 1, 3, 6, 1, 3, 4, 5, 6,
2120 : 1, 2, 6, 6, 1, 2, 10, 12, 15, 17,
2121 : 10, 1, 1, 1, 1, 4, 4, 1, 1, 4,
2122 : 1, 3, 1, 6, 1, 2, 8, 6, 6, 1,
2123 : 2, 8, 6, 6, 1, 2, 8, 6, 1
2124 : };
2125 :
2126 :
2127 :
2128 : // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2129 : // First, the terminals, then, starting at \a yyntokens_, nonterminals.
2130 : const char*
2131 : const Gspn_parser::yytname_[] =
2132 : {
2133 : "\"end of file\"", "error", "$undefined", "str", "chr", "rval", "ival",
2134 : "SEMICOLON", "COMMA", "LB", "RB", "EQ", "DIV", "MUL", "PLUS", "MINUS",
2135 : "POWER", "GspnName", "NbPl", "NbTr", "PList", "TList", "in", "out",
2136 : "marking", "transitions", "Const", "INT", "DOUBLE", "inhibitor", "MIN",
2137 : "MAX", "FLOOR", "SINGLE", "INFINITE", "MULTIPLE", "ENABLINGMEMORY",
2138 : "AGEMEMORY", "IMDT", "EXPO", "'{'", "'}'", "$accept", "IntStringFormula",
2139 : "RealStringFormula", "GSPN", "declarations", "Constants", "Sizes",
2140 : "Constant", "Lists", "NbPlaces", "NbTransitions", "PlacesList",
2141 : "PLabels", "TransitionsList", "TLabels", "definitions", "PlacesDef",
2142 : "PLACES", "PLACE", "TransitionsDef", "TRANSITIONS", "TRANSITION",
2143 : "WEIGHT", "PRIORITY", "SERVICE", "MEMORY", "dist", "params", "param",
2144 : "InArcs", "incells", "incell", "OutArcs", "outcells", "outcell",
2145 : "Inhibitors", "inhibcells", "inhibcell", "redifinitions", YY_NULLPTR
2146 : };
2147 :
2148 : #if YYDEBUG
2149 : const unsigned short int
2150 : Gspn_parser::yyrline_[] =
2151 : {
2152 : 0, 130, 130, 131, 142, 143, 144, 145, 146, 147,
2153 : 148, 149, 150, 153, 154, 155, 165, 166, 167, 168,
2154 : 169, 170, 171, 172, 173, 177, 178, 180, 181, 185,
2155 : 186, 188, 189, 191, 201, 210, 211, 213, 216, 225,
2156 : 228, 237, 251, 260, 271, 279, 284, 291, 292, 294,
2157 : 296, 297, 299, 316, 318, 319, 321, 345, 370, 412,
2158 : 453, 481, 492, 504, 505, 506, 516, 530, 531, 534,
2159 : 706, 707, 711, 720, 722, 723, 725, 743, 758, 760,
2160 : 761, 763, 782, 798, 800, 801, 803, 823, 840
2161 : };
2162 :
2163 : // Print the state stack on the debug stream.
2164 : void
2165 0 : Gspn_parser::yystack_print_ ()
2166 : {
2167 0 : *yycdebug_ << "Stack now";
2168 0 : for (stack_type::const_iterator
2169 0 : i = yystack_.begin (),
2170 0 : i_end = yystack_.end ();
2171 : i != i_end; ++i)
2172 0 : *yycdebug_ << ' ' << i->state;
2173 0 : *yycdebug_ << std::endl;
2174 0 : }
2175 :
2176 : // Report on the debug stream that the rule \a yyrule is going to be reduced.
2177 : void
2178 0 : Gspn_parser::yy_reduce_print_ (int yyrule)
2179 : {
2180 0 : unsigned int yylno = yyrline_[yyrule];
2181 0 : int yynrhs = yyr2_[yyrule];
2182 : // Print the symbols being reduced, and their result.
2183 0 : *yycdebug_ << "Reducing stack by rule " << yyrule - 1
2184 0 : << " (line " << yylno << "):" << std::endl;
2185 : // The symbols being reduced.
2186 0 : for (int yyi = 0; yyi < yynrhs; yyi++)
2187 0 : YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
2188 : yystack_[(yynrhs) - (yyi + 1)]);
2189 0 : }
2190 : #endif // YYDEBUG
2191 :
2192 : // Symbol number corresponding to token number t.
2193 : inline
2194 : Gspn_parser::token_number_type
2195 3659 : Gspn_parser::yytranslate_ (int t)
2196 : {
2197 : static
2198 : const token_number_type
2199 : translate_table[] =
2200 : {
2201 : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2202 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2203 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2204 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2205 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2206 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2207 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2208 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2209 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2210 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2211 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2212 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2213 : 2, 2, 2, 40, 2, 41, 2, 2, 2, 2,
2214 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2215 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2216 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2217 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2218 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2219 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2220 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2221 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2222 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2223 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2224 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2225 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2226 : 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2227 : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2228 : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2229 : 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2230 : 35, 36, 37, 38, 39
2231 : };
2232 3659 : const unsigned int user_token_number_max_ = 294;
2233 3659 : const token_number_type undef_token_ = 2;
2234 :
2235 3659 : if (static_cast<int>(t) <= yyeof_)
2236 11 : return yyeof_;
2237 3648 : else if (static_cast<unsigned int> (t) <= user_token_number_max_)
2238 3648 : return translate_table[t];
2239 : else
2240 0 : return undef_token_;
2241 : }
2242 :
2243 :
2244 : } // gspn
2245 : #line 2246 "Gspn-parser.cc" // lalr1.cc:1167
2246 : #line 842 "../../../../src/ModelGenerator/GspnParser/Gspn-parser.yy" // lalr1.cc:1168
2247 :
2248 :
2249 : void
2250 : gspn::Gspn_parser::error (const gspn::Gspn_parser::location_type& l,
2251 : const std::string& m)
2252 : {
2253 : Reader.error (l, m);
2254 : }
|
