projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0031970: Data Exchange, STEP reader - parser syntax error messages are inaccessible
[occt.git] / src / StepFile / step.tab.hxx
CommitLineData
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 53namespace 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
192namespace 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
841namespace 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
Open CASCADE Technology repository