0c38be8f |
1 | // A Bison parser, made by GNU Bison 3.7.4. |
68922bcc |
2 | |
3 | // Skeleton interface for Bison LALR(1) parsers in C++ |
4 | |
5 | // Copyright (C) 2002-2015, 2018-2020 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 | |
34 | /** |
35 | ** \file StepFile/step.tab.hxx |
36 | ** Define the step::parser class. |
37 | */ |
38 | |
39 | // C++ LALR(1) parser skeleton written by Akim Demaille. |
40 | |
41 | // DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, |
42 | // especially those whose name start with YY_ or yy_. They are |
43 | // private implementation details that can be changed or removed. |
44 | |
45 | #ifndef YY_STEP_STEPFILE_STEP_TAB_HXX_INCLUDED |
46 | # define YY_STEP_STEPFILE_STEP_TAB_HXX_INCLUDED |
47 | // "%code requires" blocks. |
48 | |
49 | // This file is part of Open CASCADE Technology software library. |
50 | // This file is generated, do not modify it directly; edit source file step.yacc instead. |
51 | |
2057c37b |
52 | #include <StepFile_ReadData.hxx> |
68922bcc |
53 | namespace step { |
54 | class scanner; |
55 | }; |
56 | |
57 | #ifdef _MSC_VER |
58 | // disable MSVC warning C4522: 'step::parser::stack_symbol_type': multiple assignment operators |
59 | #pragma warning(disable: 4522) |
60 | // disable MSVC warning C4512: 'step::parser::stack::slice' : assignment operator could not be generated |
61 | #pragma warning(disable: 4512) |
62 | #endif |
63 | |
64 | |
65 | |
66 | |
67 | # include <cstdlib> // std::abort |
68 | # include <iostream> |
69 | # include <stdexcept> |
70 | # include <string> |
71 | # include <vector> |
72 | |
73 | #if defined __cplusplus |
74 | # define YY_CPLUSPLUS __cplusplus |
75 | #else |
76 | # define YY_CPLUSPLUS 199711L |
77 | #endif |
78 | |
79 | // Support move semantics when possible. |
80 | #if 201103L <= YY_CPLUSPLUS |
81 | # define YY_MOVE std::move |
82 | # define YY_MOVE_OR_COPY move |
83 | # define YY_MOVE_REF(Type) Type&& |
84 | # define YY_RVREF(Type) Type&& |
85 | # define YY_COPY(Type) Type |
86 | #else |
87 | # define YY_MOVE |
88 | # define YY_MOVE_OR_COPY copy |
89 | # define YY_MOVE_REF(Type) Type& |
90 | # define YY_RVREF(Type) const Type& |
91 | # define YY_COPY(Type) const Type& |
92 | #endif |
93 | |
94 | // Support noexcept when possible. |
95 | #if 201103L <= YY_CPLUSPLUS |
96 | # define YY_NOEXCEPT noexcept |
97 | # define YY_NOTHROW |
98 | #else |
99 | # define YY_NOEXCEPT |
100 | # define YY_NOTHROW throw () |
101 | #endif |
102 | |
103 | // Support constexpr when possible. |
104 | #if 201703 <= YY_CPLUSPLUS |
105 | # define YY_CONSTEXPR constexpr |
106 | #else |
107 | # define YY_CONSTEXPR |
108 | #endif |
0c38be8f |
109 | |
68922bcc |
110 | |
111 | |
112 | #ifndef YY_ATTRIBUTE_PURE |
113 | # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) |
114 | # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) |
115 | # else |
116 | # define YY_ATTRIBUTE_PURE |
117 | # endif |
118 | #endif |
119 | |
120 | #ifndef YY_ATTRIBUTE_UNUSED |
121 | # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) |
122 | # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) |
123 | # else |
124 | # define YY_ATTRIBUTE_UNUSED |
125 | # endif |
126 | #endif |
127 | |
128 | /* Suppress unused-variable warnings by "using" E. */ |
129 | #if ! defined lint || defined __GNUC__ |
130 | # define YYUSE(E) ((void) (E)) |
131 | #else |
132 | # define YYUSE(E) /* empty */ |
133 | #endif |
134 | |
135 | #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ |
136 | /* Suppress an incorrect diagnostic about yylval being uninitialized. */ |
137 | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ |
138 | _Pragma ("GCC diagnostic push") \ |
139 | _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ |
140 | _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") |
141 | # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ |
142 | _Pragma ("GCC diagnostic pop") |
143 | #else |
144 | # define YY_INITIAL_VALUE(Value) Value |
145 | #endif |
146 | #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN |
147 | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN |
148 | # define YY_IGNORE_MAYBE_UNINITIALIZED_END |
149 | #endif |
150 | #ifndef YY_INITIAL_VALUE |
151 | # define YY_INITIAL_VALUE(Value) /* Nothing. */ |
152 | #endif |
153 | |
154 | #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ |
155 | # define YY_IGNORE_USELESS_CAST_BEGIN \ |
156 | _Pragma ("GCC diagnostic push") \ |
157 | _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") |
158 | # define YY_IGNORE_USELESS_CAST_END \ |
159 | _Pragma ("GCC diagnostic pop") |
160 | #endif |
161 | #ifndef YY_IGNORE_USELESS_CAST_BEGIN |
162 | # define YY_IGNORE_USELESS_CAST_BEGIN |
163 | # define YY_IGNORE_USELESS_CAST_END |
164 | #endif |
165 | |
166 | # ifndef YY_CAST |
167 | # ifdef __cplusplus |
168 | # define YY_CAST(Type, Val) static_cast<Type> (Val) |
169 | # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) |
170 | # else |
171 | # define YY_CAST(Type, Val) ((Type) (Val)) |
172 | # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) |
173 | # endif |
174 | # endif |
175 | # ifndef YY_NULLPTR |
176 | # if defined __cplusplus |
177 | # if 201103L <= __cplusplus |
178 | # define YY_NULLPTR nullptr |
179 | # else |
180 | # define YY_NULLPTR 0 |
181 | # endif |
182 | # else |
183 | # define YY_NULLPTR ((void*)0) |
184 | # endif |
185 | # endif |
186 | |
187 | /* Debug traces. */ |
188 | #ifndef YYDEBUG |
189 | # define YYDEBUG 0 |
190 | #endif |
191 | |
192 | namespace step { |
193 | |
194 | |
195 | |
196 | |
197 | /// A Bison parser. |
198 | class parser |
199 | { |
200 | public: |
201 | #ifndef YYSTYPE |
202 | /// Symbol semantic values. |
203 | typedef int semantic_type; |
204 | #else |
205 | typedef YYSTYPE semantic_type; |
206 | #endif |
68922bcc |
207 | |
208 | /// Syntax errors thrown from user actions. |
209 | struct syntax_error : std::runtime_error |
210 | { |
0c38be8f |
211 | syntax_error (const std::string& m) |
68922bcc |
212 | : std::runtime_error (m) |
68922bcc |
213 | {} |
214 | |
215 | syntax_error (const syntax_error& s) |
216 | : std::runtime_error (s.what ()) |
68922bcc |
217 | {} |
218 | |
219 | ~syntax_error () YY_NOEXCEPT YY_NOTHROW; |
68922bcc |
220 | }; |
221 | |
222 | /// Token kinds. |
223 | struct token |
224 | { |
225 | enum token_kind_type |
226 | { |
227 | YYEMPTY = -2, |
228 | YYEOF = 0, // "end of file" |
229 | YYerror = 256, // error |
230 | YYUNDEF = 257, // "invalid token" |
231 | STEP = 258, // STEP |
232 | HEADER = 259, // HEADER |
233 | ENDSEC = 260, // ENDSEC |
234 | DATA = 261, // DATA |
235 | ENDSTEP = 262, // ENDSTEP |
236 | SCOPE = 263, // SCOPE |
237 | ENDSCOPE = 264, // ENDSCOPE |
238 | ENTITY = 265, // ENTITY |
239 | TYPE = 266, // TYPE |
240 | INTEGER = 267, // INTEGER |
241 | FLOAT = 268, // FLOAT |
242 | IDENT = 269, // IDENT |
243 | TEXT = 270, // TEXT |
244 | NONDEF = 271, // NONDEF |
245 | ENUM = 272, // ENUM |
246 | HEXA = 273, // HEXA |
247 | QUID = 274 // QUID |
248 | }; |
249 | /// Backward compatibility alias (Bison 3.6). |
250 | typedef token_kind_type yytokentype; |
251 | }; |
252 | |
253 | /// Token kind, as returned by yylex. |
254 | typedef token::yytokentype token_kind_type; |
255 | |
256 | /// Backward compatibility alias (Bison 3.6). |
257 | typedef token_kind_type token_type; |
258 | |
259 | /// Symbol kinds. |
260 | struct symbol_kind |
261 | { |
262 | enum symbol_kind_type |
263 | { |
264 | YYNTOKENS = 27, ///< Number of tokens. |
265 | S_YYEMPTY = -2, |
266 | S_YYEOF = 0, // "end of file" |
267 | S_YYerror = 1, // error |
268 | S_YYUNDEF = 2, // "invalid token" |
269 | S_STEP = 3, // STEP |
270 | S_HEADER = 4, // HEADER |
271 | S_ENDSEC = 5, // ENDSEC |
272 | S_DATA = 6, // DATA |
273 | S_ENDSTEP = 7, // ENDSTEP |
274 | S_SCOPE = 8, // SCOPE |
275 | S_ENDSCOPE = 9, // ENDSCOPE |
276 | S_ENTITY = 10, // ENTITY |
277 | S_TYPE = 11, // TYPE |
278 | S_INTEGER = 12, // INTEGER |
279 | S_FLOAT = 13, // FLOAT |
280 | S_IDENT = 14, // IDENT |
281 | S_TEXT = 15, // TEXT |
282 | S_NONDEF = 16, // NONDEF |
283 | S_ENUM = 17, // ENUM |
284 | S_HEXA = 18, // HEXA |
285 | S_QUID = 19, // QUID |
286 | S_20_ = 20, // ' ' |
287 | S_21_ = 21, // ';' |
288 | S_22_ = 22, // '(' |
289 | S_23_ = 23, // ')' |
290 | S_24_ = 24, // ',' |
291 | S_25_ = 25, // '=' |
292 | S_26_ = 26, // '/' |
293 | S_YYACCEPT = 27, // $accept |
294 | S_finvide = 28, // finvide |
295 | S_finstep = 29, // finstep |
296 | S_stepf1 = 30, // stepf1 |
297 | S_stepf2 = 31, // stepf2 |
298 | S_stepf3 = 32, // stepf3 |
299 | S_stepf = 33, // stepf |
300 | S_headl = 34, // headl |
301 | S_headent = 35, // headent |
302 | S_endhead = 36, // endhead |
303 | S_unarg = 37, // unarg |
304 | S_listype = 38, // listype |
305 | S_deblist = 39, // deblist |
306 | S_finlist = 40, // finlist |
307 | S_listarg = 41, // listarg |
308 | S_arglist = 42, // arglist |
309 | S_model = 43, // model |
310 | S_bloc = 44, // bloc |
311 | S_plex = 45, // plex |
312 | S_unent = 46, // unent |
313 | S_debscop = 47, // debscop |
314 | S_unid = 48, // unid |
315 | S_export = 49, // export |
316 | S_debexp = 50, // debexp |
317 | S_finscop = 51, // finscop |
318 | S_entlab = 52, // entlab |
319 | S_enttype = 53 // enttype |
320 | }; |
321 | }; |
322 | |
323 | /// (Internal) symbol kind. |
324 | typedef symbol_kind::symbol_kind_type symbol_kind_type; |
325 | |
326 | /// The number of tokens. |
327 | static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS; |
328 | |
329 | /// A complete symbol. |
330 | /// |
331 | /// Expects its Base type to provide access to the symbol kind |
332 | /// via kind (). |
333 | /// |
0c38be8f |
334 | /// Provide access to semantic value. |
68922bcc |
335 | template <typename Base> |
336 | struct basic_symbol : Base |
337 | { |
338 | /// Alias to Base. |
339 | typedef Base super_type; |
340 | |
341 | /// Default constructor. |
342 | basic_symbol () |
343 | : value () |
68922bcc |
344 | {} |
345 | |
346 | #if 201103L <= YY_CPLUSPLUS |
347 | /// Move constructor. |
348 | basic_symbol (basic_symbol&& that) |
349 | : Base (std::move (that)) |
350 | , value (std::move (that.value)) |
68922bcc |
351 | {} |
352 | #endif |
353 | |
354 | /// Copy constructor. |
355 | basic_symbol (const basic_symbol& that); |
356 | /// Constructor for valueless symbols. |
0c38be8f |
357 | basic_symbol (typename Base::kind_type t); |
68922bcc |
358 | |
359 | /// Constructor for symbols with semantic value. |
360 | basic_symbol (typename Base::kind_type t, |
0c38be8f |
361 | YY_RVREF (semantic_type) v); |
68922bcc |
362 | |
363 | /// Destroy the symbol. |
364 | ~basic_symbol () |
365 | { |
366 | clear (); |
367 | } |
368 | |
369 | /// Destroy contents, and record that is empty. |
370 | void clear () |
371 | { |
372 | Base::clear (); |
373 | } |
374 | |
68922bcc |
375 | /// The user-facing name of this symbol. |
0c38be8f |
376 | std::string name () const YY_NOEXCEPT |
68922bcc |
377 | { |
378 | return parser::symbol_name (this->kind ()); |
379 | } |
68922bcc |
380 | |
381 | /// Backward compatibility (Bison 3.6). |
382 | symbol_kind_type type_get () const YY_NOEXCEPT; |
383 | |
384 | /// Whether empty. |
385 | bool empty () const YY_NOEXCEPT; |
386 | |
387 | /// Destructive move, \a s is emptied into this. |
388 | void move (basic_symbol& s); |
389 | |
390 | /// The semantic value. |
391 | semantic_type value; |
392 | |
68922bcc |
393 | private: |
394 | #if YY_CPLUSPLUS < 201103L |
395 | /// Assignment operator. |
396 | basic_symbol& operator= (const basic_symbol& that); |
397 | #endif |
398 | }; |
399 | |
400 | /// Type access provider for token (enum) based symbols. |
401 | struct by_kind |
402 | { |
403 | /// Default constructor. |
404 | by_kind (); |
405 | |
406 | #if 201103L <= YY_CPLUSPLUS |
407 | /// Move constructor. |
408 | by_kind (by_kind&& that); |
409 | #endif |
410 | |
411 | /// Copy constructor. |
412 | by_kind (const by_kind& that); |
413 | |
414 | /// The symbol kind as needed by the constructor. |
415 | typedef token_kind_type kind_type; |
416 | |
417 | /// Constructor from (external) token numbers. |
418 | by_kind (kind_type t); |
419 | |
420 | /// Record that this symbol is empty. |
421 | void clear (); |
422 | |
423 | /// Steal the symbol kind from \a that. |
424 | void move (by_kind& that); |
425 | |
426 | /// The (internal) type number (corresponding to \a type). |
427 | /// \a empty when empty. |
428 | symbol_kind_type kind () const YY_NOEXCEPT; |
429 | |
430 | /// Backward compatibility (Bison 3.6). |
431 | symbol_kind_type type_get () const YY_NOEXCEPT; |
432 | |
433 | /// The symbol kind. |
434 | /// \a S_YYEMPTY when empty. |
435 | symbol_kind_type kind_; |
436 | }; |
437 | |
438 | /// Backward compatibility for a private implementation detail (Bison 3.6). |
439 | typedef by_kind by_type; |
440 | |
441 | /// "External" symbols: returned by the scanner. |
442 | struct symbol_type : basic_symbol<by_kind> |
443 | {}; |
444 | |
445 | /// Build a parser object. |
446 | parser (step::scanner* scanner_yyarg); |
447 | virtual ~parser (); |
448 | |
449 | #if 201103L <= YY_CPLUSPLUS |
450 | /// Non copyable. |
451 | parser (const parser&) = delete; |
452 | /// Non copyable. |
453 | parser& operator= (const parser&) = delete; |
454 | #endif |
455 | |
456 | /// Parse. An alias for parse (). |
457 | /// \returns 0 iff parsing succeeded. |
458 | int operator() (); |
459 | |
460 | /// Parse. |
461 | /// \returns 0 iff parsing succeeded. |
462 | virtual int parse (); |
463 | |
464 | #if YYDEBUG |
465 | /// The current debugging stream. |
466 | std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; |
467 | /// Set the current debugging stream. |
468 | void set_debug_stream (std::ostream &); |
469 | |
470 | /// Type for debugging levels. |
471 | typedef int debug_level_type; |
472 | /// The current debugging level. |
473 | debug_level_type debug_level () const YY_ATTRIBUTE_PURE; |
474 | /// Set the current debugging level. |
475 | void set_debug_level (debug_level_type l); |
476 | #endif |
477 | |
478 | /// Report a syntax error. |
68922bcc |
479 | /// \param msg a description of the syntax error. |
0c38be8f |
480 | virtual void error (const std::string& msg); |
68922bcc |
481 | |
482 | /// Report a syntax error. |
483 | void error (const syntax_error& err); |
484 | |
68922bcc |
485 | /// The user-facing name of the symbol whose (internal) number is |
486 | /// YYSYMBOL. No bounds checking. |
0c38be8f |
487 | static std::string symbol_name (symbol_kind_type yysymbol); |
488 | |
68922bcc |
489 | |
490 | |
0c38be8f |
491 | class context |
492 | { |
493 | public: |
494 | context (const parser& yyparser, const symbol_type& yyla); |
495 | const symbol_type& lookahead () const { return yyla_; } |
496 | symbol_kind_type token () const { return yyla_.kind (); } |
497 | /// Put in YYARG at most YYARGN of the expected tokens, and return the |
498 | /// number of tokens stored in YYARG. If YYARG is null, return the |
499 | /// number of expected tokens (guaranteed to be less than YYNTOKENS). |
500 | int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; |
68922bcc |
501 | |
0c38be8f |
502 | private: |
503 | const parser& yyparser_; |
504 | const symbol_type& yyla_; |
505 | }; |
68922bcc |
506 | |
507 | private: |
508 | #if YY_CPLUSPLUS < 201103L |
509 | /// Non copyable. |
510 | parser (const parser&); |
511 | /// Non copyable. |
512 | parser& operator= (const parser&); |
513 | #endif |
514 | |
515 | |
516 | /// Stored state numbers (used for stacks). |
517 | typedef signed char state_type; |
518 | |
0c38be8f |
519 | /// The arguments of the error message. |
520 | int yy_syntax_error_arguments_ (const context& yyctx, |
521 | symbol_kind_type yyarg[], int yyargn) const; |
522 | |
523 | /// Generate an error message. |
524 | /// \param yyctx the context in which the error occurred. |
525 | virtual std::string yysyntax_error_ (const context& yyctx) const; |
68922bcc |
526 | /// Compute post-reduction state. |
527 | /// \param yystate the current state |
528 | /// \param yysym the nonterminal to push on the stack |
529 | static state_type yy_lr_goto_state_ (state_type yystate, int yysym); |
530 | |
531 | /// Whether the given \c yypact_ value indicates a defaulted state. |
532 | /// \param yyvalue the value to check |
533 | static bool yy_pact_value_is_default_ (int yyvalue); |
534 | |
535 | /// Whether the given \c yytable_ value indicates a syntax error. |
536 | /// \param yyvalue the value to check |
537 | static bool yy_table_value_is_error_ (int yyvalue); |
538 | |
539 | static const signed char yypact_ninf_; |
540 | static const signed char yytable_ninf_; |
541 | |
542 | /// Convert a scanner token kind \a t to a symbol kind. |
543 | /// In theory \a t should be a token_kind_type, but character literals |
544 | /// are valid, yet not members of the token_type enum. |
545 | static symbol_kind_type yytranslate_ (int t); |
546 | |
0c38be8f |
547 | /// Convert the symbol name \a n to a form suitable for a diagnostic. |
548 | static std::string yytnamerr_ (const char *yystr); |
549 | |
68922bcc |
550 | /// For a symbol, its name in clear. |
551 | static const char* const yytname_[]; |
68922bcc |
552 | |
553 | |
554 | // Tables. |
555 | // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
556 | // STATE-NUM. |
557 | static const signed char yypact_[]; |
558 | |
559 | // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. |
560 | // Performed when YYTABLE does not specify something else to do. Zero |
561 | // means the default is an error. |
562 | static const signed char yydefact_[]; |
563 | |
564 | // YYPGOTO[NTERM-NUM]. |
565 | static const signed char yypgoto_[]; |
566 | |
567 | // YYDEFGOTO[NTERM-NUM]. |
568 | static const signed char yydefgoto_[]; |
569 | |
570 | // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If |
571 | // positive, shift that token. If negative, reduce the rule whose |
572 | // number is the opposite. If YYTABLE_NINF, syntax error. |
573 | static const signed char yytable_[]; |
574 | |
575 | static const signed char yycheck_[]; |
576 | |
577 | // YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
578 | // symbol of state STATE-NUM. |
579 | static const signed char yystos_[]; |
580 | |
581 | // YYR1[YYN] -- Symbol number of symbol that rule YYN derives. |
582 | static const signed char yyr1_[]; |
583 | |
584 | // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. |
585 | static const signed char yyr2_[]; |
586 | |
587 | |
588 | #if YYDEBUG |
589 | // YYRLINE[YYN] -- Source line where rule number YYN was defined. |
590 | static const unsigned char yyrline_[]; |
591 | /// Report on the debug stream that the rule \a r is going to be reduced. |
592 | virtual void yy_reduce_print_ (int r) const; |
593 | /// Print the state stack on the debug stream. |
594 | virtual void yy_stack_print_ () const; |
595 | |
596 | /// Debugging level. |
597 | int yydebug_; |
598 | /// Debug stream. |
599 | std::ostream* yycdebug_; |
600 | |
601 | /// \brief Display a symbol kind, value and location. |
602 | /// \param yyo The output stream. |
603 | /// \param yysym The symbol. |
604 | template <typename Base> |
605 | void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const; |
606 | #endif |
607 | |
608 | /// \brief Reclaim the memory associated to a symbol. |
609 | /// \param yymsg Why this token is reclaimed. |
610 | /// If null, print nothing. |
611 | /// \param yysym The symbol. |
612 | template <typename Base> |
613 | void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const; |
614 | |
615 | private: |
616 | /// Type access provider for state based symbols. |
617 | struct by_state |
618 | { |
619 | /// Default constructor. |
620 | by_state () YY_NOEXCEPT; |
621 | |
622 | /// The symbol kind as needed by the constructor. |
623 | typedef state_type kind_type; |
624 | |
625 | /// Constructor. |
626 | by_state (kind_type s) YY_NOEXCEPT; |
627 | |
628 | /// Copy constructor. |
629 | by_state (const by_state& that) YY_NOEXCEPT; |
630 | |
631 | /// Record that this symbol is empty. |
632 | void clear () YY_NOEXCEPT; |
633 | |
634 | /// Steal the symbol kind from \a that. |
635 | void move (by_state& that); |
636 | |
637 | /// The symbol kind (corresponding to \a state). |
638 | /// \a symbol_kind::S_YYEMPTY when empty. |
639 | symbol_kind_type kind () const YY_NOEXCEPT; |
640 | |
641 | /// The state number used to denote an empty symbol. |
642 | /// We use the initial state, as it does not have a value. |
643 | enum { empty_state = 0 }; |
644 | |
645 | /// The state. |
646 | /// \a empty when empty. |
647 | state_type state; |
648 | }; |
649 | |
650 | /// "Internal" symbol: element of the stack. |
651 | struct stack_symbol_type : basic_symbol<by_state> |
652 | { |
653 | /// Superclass. |
654 | typedef basic_symbol<by_state> super_type; |
655 | /// Construct an empty symbol. |
656 | stack_symbol_type (); |
657 | /// Move or copy construction. |
658 | stack_symbol_type (YY_RVREF (stack_symbol_type) that); |
659 | /// Steal the contents from \a sym to build this. |
660 | stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym); |
661 | #if YY_CPLUSPLUS < 201103L |
662 | /// Assignment, needed by push_back by some old implementations. |
663 | /// Moves the contents of that. |
664 | stack_symbol_type& operator= (stack_symbol_type& that); |
665 | |
666 | /// Assignment, needed by push_back by other implementations. |
667 | /// Needed by some other old implementations. |
668 | stack_symbol_type& operator= (const stack_symbol_type& that); |
669 | #endif |
670 | }; |
671 | |
672 | /// A stack with random access from its top. |
673 | template <typename T, typename S = std::vector<T> > |
674 | class stack |
675 | { |
676 | public: |
677 | // Hide our reversed order. |
678 | typedef typename S::iterator iterator; |
679 | typedef typename S::const_iterator const_iterator; |
680 | typedef typename S::size_type size_type; |
681 | typedef typename std::ptrdiff_t index_type; |
682 | |
683 | stack (size_type n = 200) |
684 | : seq_ (n) |
685 | {} |
686 | |
687 | #if 201103L <= YY_CPLUSPLUS |
688 | /// Non copyable. |
689 | stack (const stack&) = delete; |
690 | /// Non copyable. |
691 | stack& operator= (const stack&) = delete; |
692 | #endif |
693 | |
694 | /// Random access. |
695 | /// |
696 | /// Index 0 returns the topmost element. |
697 | const T& |
698 | operator[] (index_type i) const |
699 | { |
700 | return seq_[size_type (size () - 1 - i)]; |
701 | } |
702 | |
703 | /// Random access. |
704 | /// |
705 | /// Index 0 returns the topmost element. |
706 | T& |
707 | operator[] (index_type i) |
708 | { |
709 | return seq_[size_type (size () - 1 - i)]; |
710 | } |
711 | |
712 | /// Steal the contents of \a t. |
713 | /// |
714 | /// Close to move-semantics. |
715 | void |
716 | push (YY_MOVE_REF (T) t) |
717 | { |
718 | seq_.push_back (T ()); |
719 | operator[] (0).move (t); |
720 | } |
721 | |
722 | /// Pop elements from the stack. |
723 | void |
724 | pop (std::ptrdiff_t n = 1) YY_NOEXCEPT |
725 | { |
726 | for (; 0 < n; --n) |
727 | seq_.pop_back (); |
728 | } |
729 | |
730 | /// Pop all elements from the stack. |
731 | void |
732 | clear () YY_NOEXCEPT |
733 | { |
734 | seq_.clear (); |
735 | } |
736 | |
737 | /// Number of elements on the stack. |
738 | index_type |
739 | size () const YY_NOEXCEPT |
740 | { |
741 | return index_type (seq_.size ()); |
742 | } |
743 | |
744 | /// Iterator on top of the stack (going downwards). |
745 | const_iterator |
746 | begin () const YY_NOEXCEPT |
747 | { |
748 | return seq_.begin (); |
749 | } |
750 | |
751 | /// Bottom of the stack. |
752 | const_iterator |
753 | end () const YY_NOEXCEPT |
754 | { |
755 | return seq_.end (); |
756 | } |
757 | |
758 | /// Present a slice of the top of a stack. |
759 | class slice |
760 | { |
761 | public: |
762 | slice (const stack& stack, index_type range) |
763 | : stack_ (stack) |
764 | , range_ (range) |
765 | {} |
766 | |
767 | const T& |
768 | operator[] (index_type i) const |
769 | { |
770 | return stack_[range_ - i]; |
771 | } |
772 | |
773 | private: |
774 | const stack& stack_; |
775 | index_type range_; |
776 | }; |
777 | |
778 | private: |
779 | #if YY_CPLUSPLUS < 201103L |
780 | /// Non copyable. |
781 | stack (const stack&); |
782 | /// Non copyable. |
783 | stack& operator= (const stack&); |
784 | #endif |
785 | /// The wrapped container. |
786 | S seq_; |
787 | }; |
788 | |
789 | |
790 | /// Stack type. |
791 | typedef stack<stack_symbol_type> stack_type; |
792 | |
793 | /// The stack. |
794 | stack_type yystack_; |
795 | |
796 | /// Push a new state on the stack. |
797 | /// \param m a debug message to display |
798 | /// if null, no trace is output. |
799 | /// \param sym the symbol |
800 | /// \warning the contents of \a s.value is stolen. |
801 | void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym); |
802 | |
803 | /// Push a new look ahead token on the state on the stack. |
804 | /// \param m a debug message to display |
805 | /// if null, no trace is output. |
806 | /// \param s the state |
807 | /// \param sym the symbol (for its value and location). |
808 | /// \warning the contents of \a sym.value is stolen. |
809 | void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym); |
810 | |
811 | /// Pop \a n symbols from the stack. |
812 | void yypop_ (int n = 1); |
813 | |
814 | /// Constants. |
815 | enum |
816 | { |
2057c37b |
817 | yylast_ = 82, ///< Last index in yytable_. |
68922bcc |
818 | yynnts_ = 27, ///< Number of nonterminal symbols. |
819 | yyfinal_ = 7 ///< Termination state number. |
820 | }; |
821 | |
822 | |
823 | // User arguments. |
824 | step::scanner* scanner; |
825 | |
826 | }; |
827 | |
828 | |
829 | } // step |
830 | |
831 | |
2057c37b |
832 | // "%code provides" blocks. |
833 | |
834 | // Define stepFlexLexer class by inclusion of FlexLexer.h, |
835 | // but only if this has not been done yet, to avoid redefinition |
836 | #if !defined(yyFlexLexer) && !defined(FlexLexerOnce) |
837 | #define yyFlexLexer stepFlexLexer |
838 | #include "FlexLexer.h" |
839 | #endif |
840 | |
841 | namespace step { |
842 | |
843 | // To feed data back to bison, the yylex method needs yylval and |
844 | // yylloc parameters. Since the stepFlexLexer class is defined in the |
845 | // system header <FlexLexer.h> the signature of its yylex() method |
846 | // can not be changed anymore. This makes it necessary to derive a |
847 | // scanner class that provides a method with the desired signature: |
848 | |
849 | class scanner : public stepFlexLexer |
850 | { |
851 | public: |
852 | explicit scanner(StepFile_ReadData* theDataModel, std::istream* in = 0, std::ostream* out = 0); |
853 | |
0c38be8f |
854 | int lex(step::parser::semantic_type* yylval); |
2057c37b |
855 | |
856 | StepFile_ReadData* myDataModel; |
857 | }; |
858 | |
859 | }; |
860 | |
68922bcc |
861 | |
862 | |
863 | #endif // !YY_STEP_STEPFILE_STEP_TAB_HXX_INCLUDED |