1 // A Bison parser, made by GNU Bison 3.3.2. 2 3 // Skeleton interface for Bison LALR(1) parsers in C++ 4 5 // Copyright (C) 2002-2015, 2018-2019 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 DynareBison.hh 36 ** Define the Dynare::parser class. 37 */ 38 39 // C++ LALR(1) parser skeleton written by Akim Demaille. 40 41 // Undocumented macros, especially those whose name start with YY_, 42 // are private implementation details. Do not rely on them. 43 44 #ifndef YY_YY_DYNAREBISON_HH_INCLUDED 45 # define YY_YY_DYNAREBISON_HH_INCLUDED 46 // // "%code requires" blocks. 47 #line 34 "DynareBison.yy" // lalr1.cc:401 48 49 #include "ExprNode.hh" 50 #include "CodeInterpreter.hh" 51 52 #line 53 "DynareBison.hh" // lalr1.cc:401 53 54 # include <cassert> 55 # include <cstdlib> // std::abort 56 # include <iostream> 57 # include <stdexcept> 58 # include <string> 59 # include <vector> 60 61 #if defined __cplusplus 62 # define YY_CPLUSPLUS __cplusplus 63 #else 64 # define YY_CPLUSPLUS 199711L 65 #endif 66 67 // Support move semantics when possible. 68 #if 201103L <= YY_CPLUSPLUS 69 # define YY_MOVE std::move 70 # define YY_MOVE_OR_COPY move 71 # define YY_MOVE_REF(Type) Type&& 72 # define YY_RVREF(Type) Type&& 73 # define YY_COPY(Type) Type 74 #else 75 # define YY_MOVE 76 # define YY_MOVE_OR_COPY copy 77 # define YY_MOVE_REF(Type) Type& 78 # define YY_RVREF(Type) const Type& 79 # define YY_COPY(Type) const Type& 80 #endif 81 82 // Support noexcept when possible. 83 #if 201103L <= YY_CPLUSPLUS 84 # define YY_NOEXCEPT noexcept 85 # define YY_NOTHROW 86 #else 87 # define YY_NOEXCEPT 88 # define YY_NOTHROW throw () 89 #endif 90 91 // Support constexpr when possible. 92 #if 201703 <= YY_CPLUSPLUS 93 # define YY_CONSTEXPR constexpr 94 #else 95 # define YY_CONSTEXPR 96 #endif 97 # include "location.hh" 98 #include <typeinfo> 99 #ifndef YYASSERT 100 # include <cassert> 101 # define YYASSERT assert 102 #endif 103 104 105 #ifndef YY_ATTRIBUTE 106 # if (defined __GNUC__ \ 107 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 108 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 109 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 110 # else 111 # define YY_ATTRIBUTE(Spec) /* empty */ 112 # endif 113 #endif 114 115 #ifndef YY_ATTRIBUTE_PURE 116 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 117 #endif 118 119 #ifndef YY_ATTRIBUTE_UNUSED 120 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 121 #endif 122 123 /* Suppress unused-variable warnings by "using" E. */ 124 #if ! defined lint || defined __GNUC__ 125 # define YYUSE(E) ((void) (E)) 126 #else 127 # define YYUSE(E) /* empty */ 128 #endif 129 130 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 131 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 132 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 133 _Pragma ("GCC diagnostic push") \ 134 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 135 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 136 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 137 _Pragma ("GCC diagnostic pop") 138 #else 139 # define YY_INITIAL_VALUE(Value) Value 140 #endif 141 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 142 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 143 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 144 #endif 145 #ifndef YY_INITIAL_VALUE 146 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 147 #endif 148 149 # ifndef YY_NULLPTR 150 # if defined __cplusplus 151 # if 201103L <= __cplusplus 152 # define YY_NULLPTR nullptr 153 # else 154 # define YY_NULLPTR 0 155 # endif 156 # else 157 # define YY_NULLPTR ((void*)0) 158 # endif 159 # endif 160 161 /* Debug traces. */ 162 #ifndef YYDEBUG 163 # define YYDEBUG 1 164 #endif 165 166 #line 25 "DynareBison.yy" // lalr1.cc:401 167 namespace Dynare { 168 #line 169 "DynareBison.hh" // lalr1.cc:401 169 170 171 172 /// A Bison parser. 173 class parser 174 { 175 public: 176 #ifndef YYSTYPE 177 /// A buffer to store and retrieve objects. 178 /// 179 /// Sort of a variant, but does not keep track of the nature 180 /// of the stored data, since that knowledge is available 181 /// via the current parser state. 182 class semantic_type 183 { 184 public: 185 /// Type of *this. 186 typedef semantic_type self_type; 187 188 /// Empty construction. semantic_type()189 semantic_type () YY_NOEXCEPT 190 : yybuffer_ () 191 , yytypeid_ (YY_NULLPTR) 192 {} 193 194 /// Construct and fill. 195 template <typename T> semantic_type(YY_RVREF (T)t)196 semantic_type (YY_RVREF (T) t) 197 : yytypeid_ (&typeid (T)) 198 { 199 YYASSERT (sizeof (T) <= size); 200 new (yyas_<T> ()) T (YY_MOVE (t)); 201 } 202 203 /// Destruction, allowed only if empty. ~semantic_type()204 ~semantic_type () YY_NOEXCEPT 205 { 206 YYASSERT (!yytypeid_); 207 } 208 209 # if 201103L <= YY_CPLUSPLUS 210 /// Instantiate a \a T in here from \a t. 211 template <typename T, typename... U> 212 T& 213 emplace (U&&... u) 214 { 215 YYASSERT (!yytypeid_); 216 YYASSERT (sizeof (T) <= size); 217 yytypeid_ = & typeid (T); 218 return *new (yyas_<T> ()) T (std::forward <U>(u)...); 219 } 220 # else 221 /// Instantiate an empty \a T in here. 222 template <typename T> 223 T& emplace()224 emplace () 225 { 226 YYASSERT (!yytypeid_); 227 YYASSERT (sizeof (T) <= size); 228 yytypeid_ = & typeid (T); 229 return *new (yyas_<T> ()) T (); 230 } 231 232 /// Instantiate a \a T in here from \a t. 233 template <typename T> 234 T& emplace(const T & t)235 emplace (const T& t) 236 { 237 YYASSERT (!yytypeid_); 238 YYASSERT (sizeof (T) <= size); 239 yytypeid_ = & typeid (T); 240 return *new (yyas_<T> ()) T (t); 241 } 242 # endif 243 244 /// Instantiate an empty \a T in here. 245 /// Obsolete, use emplace. 246 template <typename T> 247 T& build()248 build () 249 { 250 return emplace<T> (); 251 } 252 253 /// Instantiate a \a T in here from \a t. 254 /// Obsolete, use emplace. 255 template <typename T> 256 T& build(const T & t)257 build (const T& t) 258 { 259 return emplace<T> (t); 260 } 261 262 /// Accessor to a built \a T. 263 template <typename T> 264 T& as()265 as () YY_NOEXCEPT 266 { 267 YYASSERT (yytypeid_); 268 YYASSERT (*yytypeid_ == typeid (T)); 269 YYASSERT (sizeof (T) <= size); 270 return *yyas_<T> (); 271 } 272 273 /// Const accessor to a built \a T (for %printer). 274 template <typename T> 275 const T& as() const276 as () const YY_NOEXCEPT 277 { 278 YYASSERT (yytypeid_); 279 YYASSERT (*yytypeid_ == typeid (T)); 280 YYASSERT (sizeof (T) <= size); 281 return *yyas_<T> (); 282 } 283 284 /// Swap the content with \a that, of same type. 285 /// 286 /// Both variants must be built beforehand, because swapping the actual 287 /// data requires reading it (with as()), and this is not possible on 288 /// unconstructed variants: it would require some dynamic testing, which 289 /// should not be the variant's responsibility. 290 /// Swapping between built and (possibly) non-built is done with 291 /// self_type::move (). 292 template <typename T> 293 void swap(self_type & that)294 swap (self_type& that) YY_NOEXCEPT 295 { 296 YYASSERT (yytypeid_); 297 YYASSERT (*yytypeid_ == *that.yytypeid_); 298 std::swap (as<T> (), that.as<T> ()); 299 } 300 301 /// Move the content of \a that to this. 302 /// 303 /// Destroys \a that. 304 template <typename T> 305 void move(self_type & that)306 move (self_type& that) 307 { 308 # if 201103L <= YY_CPLUSPLUS 309 emplace<T> (std::move (that.as<T> ())); 310 # else 311 emplace<T> (); 312 swap<T> (that); 313 # endif 314 that.destroy<T> (); 315 } 316 317 # if 201103L <= YY_CPLUSPLUS 318 /// Move the content of \a that to this. 319 template <typename T> 320 void move(self_type && that)321 move (self_type&& that) 322 { 323 emplace<T> (std::move (that.as<T> ())); 324 that.destroy<T> (); 325 } 326 #endif 327 328 /// Copy the content of \a that to this. 329 template <typename T> 330 void copy(const self_type & that)331 copy (const self_type& that) 332 { 333 emplace<T> (that.as<T> ()); 334 } 335 336 /// Destroy the stored \a T. 337 template <typename T> 338 void destroy()339 destroy () 340 { 341 as<T> ().~T (); 342 yytypeid_ = YY_NULLPTR; 343 } 344 345 private: 346 /// Prohibit blind copies. 347 self_type& operator= (const self_type&); 348 semantic_type (const self_type&); 349 350 /// Accessor to raw memory as \a T. 351 template <typename T> 352 T* yyas_()353 yyas_ () YY_NOEXCEPT 354 { 355 void *yyp = yybuffer_.yyraw; 356 return static_cast<T*> (yyp); 357 } 358 359 /// Const accessor to raw memory as \a T. 360 template <typename T> 361 const T* yyas_() const362 yyas_ () const YY_NOEXCEPT 363 { 364 const void *yyp = yybuffer_.yyraw; 365 return static_cast<const T*> (yyp); 366 } 367 368 /// An auxiliary type to compute the largest semantic type. 369 union union_type 370 { 371 // prior_distribution 372 // prior_pdf 373 char dummy1[sizeof (PriorDistributions)]; 374 375 // change_type_arg 376 char dummy2[sizeof (SymbolType)]; 377 378 // expression 379 // expression_or_empty 380 // equation 381 // hand_side 382 char dummy3[sizeof (expr_t)]; 383 384 // calibration_range 385 char dummy4[sizeof (pair<expr_t,expr_t>)]; 386 387 // named_var_elem 388 // subsamples_eq_opt 389 // integer_range_w_inf 390 char dummy5[sizeof (pair<string,string>)]; 391 392 // FALSE 393 // FLOAT_NUMBER 394 // DATES 395 // INT_NUMBER 396 // NAME 397 // QUOTED_STRING 398 // TEX_NAME 399 // TRUE 400 // ALPHA 401 // BETA 402 // ABAND 403 // NINV 404 // CMS 405 // NCMS 406 // CNUM 407 // GAMMA 408 // INV_GAMMA 409 // INV_GAMMA1 410 // INV_GAMMA2 411 // NORMAL 412 // UNIFORM 413 // EPS 414 // PDF 415 // FIG 416 // DR 417 // NONE 418 // PRIOR 419 // PRIOR_VARIANCE 420 // HESSIAN 421 // IDENTITY_MATRIX 422 // DIRICHLET 423 // DIAGONAL 424 // OPTIMAL 425 // signed_integer 426 // non_negative_number 427 // signed_number 428 // signed_inf 429 // signed_number_w_inf 430 // boolean 431 // date_str 432 // date_expr 433 // list_sub_sampling_option 434 // sub_sampling_options 435 // filename 436 // namespace_qualified_symbol 437 // namespace_qualified_filename 438 // range 439 // integer_range 440 // signed_integer_range 441 // vec_value_1 442 // vec_value 443 // vec_value_list 444 // vec_of_vec_value 445 // vec_value_1_w_inf 446 // vec_value_w_inf 447 // symbol 448 // number 449 char dummy6[sizeof (string)]; 450 451 // prior_eq_opt 452 // options_eq_opt 453 char dummy7[sizeof (tuple<string,string,string,string>)]; 454 455 // vec_int_number 456 // vec_int_elem 457 // vec_int_1 458 // vec_int 459 char dummy8[sizeof (vector<int>)]; 460 461 // named_var_1 462 // named_var 463 char dummy9[sizeof (vector<pair<string,string>>)]; 464 465 // SYMBOL_VEC 466 // change_type_var_list 467 // vec_str_1 468 // vec_str 469 char dummy10[sizeof (vector<string>)]; 470 }; 471 472 /// The size of the largest semantic type. 473 enum { size = sizeof (union_type) }; 474 475 /// A buffer to store semantic values. 476 union 477 { 478 /// Strongest alignment constraints. 479 long double yyalign_me; 480 /// A buffer large enough to store any of the semantic values. 481 char yyraw[size]; 482 } yybuffer_; 483 484 /// Whether the content is built: if defined, the name of the stored type. 485 const std::type_info *yytypeid_; 486 }; 487 488 #else 489 typedef YYSTYPE semantic_type; 490 #endif 491 /// Symbol locations. 492 typedef location location_type; 493 494 /// Syntax errors thrown from user actions. 495 struct syntax_error : std::runtime_error 496 { syntax_errorDynare::parser::syntax_error497 syntax_error (const location_type& l, const std::string& m) 498 : std::runtime_error (m) 499 , location (l) 500 {} 501 syntax_errorDynare::parser::syntax_error502 syntax_error (const syntax_error& s) 503 : std::runtime_error (s.what ()) 504 , location (s.location) 505 {} 506 507 ~syntax_error () YY_NOEXCEPT YY_NOTHROW; 508 509 location_type location; 510 }; 511 512 /// Tokens. 513 struct token 514 { 515 enum yytokentype 516 { 517 AIM_SOLVER = 258, 518 ANALYTIC_DERIVATION = 259, 519 ANALYTIC_DERIVATION_MODE = 260, 520 AR = 261, 521 POSTERIOR_SAMPLING_METHOD = 262, 522 BALANCED_GROWTH_TEST_TOL = 263, 523 BAYESIAN_IRF = 264, 524 BETA_PDF = 265, 525 BLOCK = 266, 526 USE_CALIBRATION = 267, 527 SILENT_OPTIMIZER = 268, 528 BVAR_DENSITY = 269, 529 BVAR_FORECAST = 270, 530 NODECOMPOSITION = 271, 531 DR_DISPLAY_TOL = 272, 532 HUGE_NUMBER = 273, 533 FIG_NAME = 274, 534 WRITE_XLS = 275, 535 BVAR_PRIOR_DECAY = 276, 536 BVAR_PRIOR_FLAT = 277, 537 BVAR_PRIOR_LAMBDA = 278, 538 INTERACTIVE = 279, 539 SCREEN_SHOCKS = 280, 540 STEADYSTATE = 281, 541 BVAR_PRIOR_MU = 282, 542 BVAR_PRIOR_OMEGA = 283, 543 BVAR_PRIOR_TAU = 284, 544 BVAR_PRIOR_TRAIN = 285, 545 DETAIL_PLOT = 286, 546 TYPE = 287, 547 BVAR_REPLIC = 288, 548 BYTECODE = 289, 549 ALL_VALUES_REQUIRED = 290, 550 PROPOSAL_DISTRIBUTION = 291, 551 REALTIME = 292, 552 VINTAGE = 293, 553 CALIB_SMOOTHER = 294, 554 CHANGE_TYPE = 295, 555 CHECK = 296, 556 CONDITIONAL_FORECAST = 297, 557 CONDITIONAL_FORECAST_PATHS = 298, 558 CONF_SIG = 299, 559 CONSTANT = 300, 560 CONTROLLED_VAREXO = 301, 561 CORR = 302, 562 CUTOFF = 303, 563 CYCLE_REDUCTION = 304, 564 LOGARITHMIC_REDUCTION = 305, 565 COMMA = 306, 566 CONSIDER_ALL_ENDOGENOUS = 307, 567 CONSIDER_ONLY_OBSERVED = 308, 568 INITIAL_CONDITION_DECOMPOSITION = 309, 569 DATAFILE = 310, 570 FILE = 311, 571 SERIES = 312, 572 DOUBLING = 313, 573 DR_CYCLE_REDUCTION_TOL = 314, 574 DR_LOGARITHMIC_REDUCTION_TOL = 315, 575 DR_LOGARITHMIC_REDUCTION_MAXITER = 316, 576 DR_ALGO = 317, 577 DROP = 318, 578 DSAMPLE = 319, 579 DYNASAVE = 320, 580 DYNATYPE = 321, 581 CALIBRATION = 322, 582 DIFFERENTIATE_FORWARD_VARS = 323, 583 END = 324, 584 ENDVAL = 325, 585 EQUAL = 326, 586 ESTIMATION = 327, 587 ESTIMATED_PARAMS = 328, 588 ESTIMATED_PARAMS_BOUNDS = 329, 589 ESTIMATED_PARAMS_INIT = 330, 590 EXTENDED_PATH = 331, 591 ENDOGENOUS_PRIOR = 332, 592 EXPRESSION = 333, 593 FILENAME = 334, 594 DIRNAME = 335, 595 FILTER_STEP_AHEAD = 336, 596 FILTERED_VARS = 337, 597 FIRST_OBS = 338, 598 LAST_OBS = 339, 599 SET_TIME = 340, 600 OSR_PARAMS_BOUNDS = 341, 601 KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED = 342, 602 FALSE = 343, 603 FLOAT_NUMBER = 344, 604 DATES = 345, 605 DEFAULT = 346, 606 FIXED_POINT = 347, 607 FLIP = 348, 608 OPT_ALGO = 349, 609 COMPILATION_SETUP = 350, 610 COMPILER = 351, 611 ADD_FLAGS = 352, 612 SUBSTITUTE_FLAGS = 353, 613 ADD_LIBS = 354, 614 SUBSTITUTE_LIBS = 355, 615 FORECAST = 356, 616 K_ORDER_SOLVER = 357, 617 INSTRUMENTS = 358, 618 SHIFT = 359, 619 MEAN = 360, 620 STDEV = 361, 621 VARIANCE = 362, 622 MODE = 363, 623 INTERVAL = 364, 624 SHAPE = 365, 625 DOMAINN = 366, 626 GAMMA_PDF = 367, 627 GRAPH = 368, 628 GRAPH_FORMAT = 369, 629 CONDITIONAL_VARIANCE_DECOMPOSITION = 370, 630 NOCHECK = 371, 631 STD = 372, 632 HISTVAL = 373, 633 HISTVAL_FILE = 374, 634 HOMOTOPY_SETUP = 375, 635 HOMOTOPY_MODE = 376, 636 HOMOTOPY_STEPS = 377, 637 HOMOTOPY_FORCE_CONTINUE = 378, 638 HP_FILTER = 379, 639 HP_NGRID = 380, 640 FILTERED_THEORETICAL_MOMENTS_GRID = 381, 641 HYBRID = 382, 642 ONE_SIDED_HP_FILTER = 383, 643 IDENTIFICATION = 384, 644 INF_CONSTANT = 385, 645 INITVAL = 386, 646 INITVAL_FILE = 387, 647 BOUNDS = 388, 648 JSCALE = 389, 649 INIT = 390, 650 INFILE = 391, 651 INVARS = 392, 652 INT_NUMBER = 393, 653 INV_GAMMA_PDF = 394, 654 INV_GAMMA1_PDF = 395, 655 INV_GAMMA2_PDF = 396, 656 IRF = 397, 657 IRF_SHOCKS = 398, 658 IRF_PLOT_THRESHOLD = 399, 659 IRF_CALIBRATION = 400, 660 FAST_KALMAN_FILTER = 401, 661 KALMAN_ALGO = 402, 662 KALMAN_TOL = 403, 663 DIFFUSE_KALMAN_TOL = 404, 664 SUBSAMPLES = 405, 665 OPTIONS = 406, 666 TOLF = 407, 667 TOLX = 408, 668 PLOT_INIT_DATE = 409, 669 PLOT_END_DATE = 410, 670 LAPLACE = 411, 671 LIK_ALGO = 412, 672 LIK_INIT = 413, 673 LINEAR = 414, 674 LINEAR_DECOMPOSITION = 415, 675 LOAD_IDENT_FILES = 416, 676 LOAD_MH_FILE = 417, 677 LOAD_RESULTS_AFTER_LOAD_MH = 418, 678 LOAD_PARAMS_AND_STEADY_STATE = 419, 679 LOGLINEAR = 420, 680 LOGDATA = 421, 681 LYAPUNOV = 422, 682 LINEAR_APPROXIMATION = 423, 683 LYAPUNOV_FIXED_POINT_TOL = 424, 684 LYAPUNOV_DOUBLING_TOL = 425, 685 LOG_DEFLATOR = 426, 686 LOG_TREND_VAR = 427, 687 LOG_GROWTH_FACTOR = 428, 688 MARKOWITZ = 429, 689 MARGINAL_DENSITY = 430, 690 MAX = 431, 691 MAXIT = 432, 692 MFS = 433, 693 MH_CONF_SIG = 434, 694 MH_DROP = 435, 695 MH_INIT_SCALE = 436, 696 MH_JSCALE = 437, 697 MH_TUNE_JSCALE = 438, 698 MH_MODE = 439, 699 MH_NBLOCKS = 440, 700 MH_REPLIC = 441, 701 MH_RECOVER = 442, 702 POSTERIOR_MAX_SUBSAMPLE_DRAWS = 443, 703 MIN = 444, 704 MINIMAL_SOLVING_PERIODS = 445, 705 MODE_CHECK = 446, 706 MODE_CHECK_NEIGHBOURHOOD_SIZE = 447, 707 MODE_CHECK_SYMMETRIC_PLOTS = 448, 708 MODE_CHECK_NUMBER_OF_POINTS = 449, 709 MODE_COMPUTE = 450, 710 MODE_FILE = 451, 711 MODEL = 452, 712 MODEL_COMPARISON = 453, 713 MODEL_INFO = 454, 714 MSHOCKS = 455, 715 ABS = 456, 716 SIGN = 457, 717 MODEL_DIAGNOSTICS = 458, 718 MODIFIEDHARMONICMEAN = 459, 719 MOMENTS_VARENDO = 460, 720 CONTEMPORANEOUS_CORRELATION = 461, 721 DIFFUSE_FILTER = 462, 722 SUB_DRAWS = 463, 723 TAPER_STEPS = 464, 724 GEWEKE_INTERVAL = 465, 725 RAFTERY_LEWIS_QRS = 466, 726 RAFTERY_LEWIS_DIAGNOSTICS = 467, 727 MCMC_JUMPING_COVARIANCE = 468, 728 MOMENT_CALIBRATION = 469, 729 NUMBER_OF_PARTICLES = 470, 730 RESAMPLING = 471, 731 SYSTEMATIC = 472, 732 GENERIC = 473, 733 RESAMPLING_THRESHOLD = 474, 734 RESAMPLING_METHOD = 475, 735 KITAGAWA = 476, 736 STRATIFIED = 477, 737 SMOOTH = 478, 738 CPF_WEIGHTS = 479, 739 AMISANOTRISTANI = 480, 740 MURRAYJONESPARSLOW = 481, 741 WRITE_EQUATION_TAGS = 482, 742 NONLINEAR_FILTER_INITIALIZATION = 483, 743 FILTER_ALGORITHM = 484, 744 PROPOSAL_APPROXIMATION = 485, 745 CUBATURE = 486, 746 UNSCENTED = 487, 747 MONTECARLO = 488, 748 DISTRIBUTION_APPROXIMATION = 489, 749 NAME = 490, 750 USE_PENALIZED_OBJECTIVE_FOR_HESSIAN = 491, 751 INIT_STATE = 492, 752 FAST_REALTIME = 493, 753 RESCALE_PREDICTION_ERROR_COVARIANCE = 494, 754 GENERATE_IRFS = 495, 755 NAN_CONSTANT = 496, 756 NO_STATIC = 497, 757 NOBS = 498, 758 NOCONSTANT = 499, 759 NODISPLAY = 500, 760 NOCORR = 501, 761 NODIAGNOSTIC = 502, 762 NOFUNCTIONS = 503, 763 NO_HOMOTOPY = 504, 764 NOGRAPH = 505, 765 POSTERIOR_NOGRAPH = 506, 766 POSTERIOR_GRAPH = 507, 767 NOMOMENTS = 508, 768 NOPRINT = 509, 769 NORMAL_PDF = 510, 770 SAVE_DRAWS = 511, 771 MODEL_NAME = 512, 772 STDERR_MULTIPLES = 513, 773 DIAGONAL_ONLY = 514, 774 OBSERVATION_TRENDS = 515, 775 OPTIM = 516, 776 OPTIM_WEIGHTS = 517, 777 ORDER = 518, 778 OSR = 519, 779 OSR_PARAMS = 520, 780 MAX_DIM_COVA_GROUP = 521, 781 ADVANCED = 522, 782 OUTFILE = 523, 783 OUTVARS = 524, 784 OVERWRITE = 525, 785 DISCOUNT = 526, 786 PARALLEL_LOCAL_FILES = 527, 787 PARAMETERS = 528, 788 PARAMETER_SET = 529, 789 PARTIAL_INFORMATION = 530, 790 PERIODS = 531, 791 PERIOD = 532, 792 PLANNER_OBJECTIVE = 533, 793 PLOT_CONDITIONAL_FORECAST = 534, 794 PLOT_PRIORS = 535, 795 PREFILTER = 536, 796 PRESAMPLE = 537, 797 PERFECT_FORESIGHT_SETUP = 538, 798 PERFECT_FORESIGHT_SOLVER = 539, 799 NO_POSTERIOR_KERNEL_DENSITY = 540, 800 FUNCTION = 541, 801 PRINT = 542, 802 PRIOR_MC = 543, 803 PRIOR_TRUNC = 544, 804 PRIOR_MODE = 545, 805 PRIOR_MEAN = 546, 806 POSTERIOR_MODE = 547, 807 POSTERIOR_MEAN = 548, 808 POSTERIOR_MEDIAN = 549, 809 MLE_MODE = 550, 810 PRUNING = 551, 811 QUOTED_STRING = 552, 812 QZ_CRITERIUM = 553, 813 QZ_ZERO_THRESHOLD = 554, 814 DSGE_VAR = 555, 815 DSGE_VARLAG = 556, 816 DSGE_PRIOR_WEIGHT = 557, 817 TRUNCATE = 558, 818 PIPE_E = 559, 819 PIPE_X = 560, 820 PIPE_P = 561, 821 RELATIVE_IRF = 562, 822 REPLIC = 563, 823 SIMUL_REPLIC = 564, 824 RPLOT = 565, 825 SAVE_PARAMS_AND_STEADY_STATE = 566, 826 PARAMETER_UNCERTAINTY = 567, 827 TARGETS = 568, 828 SHOCKS = 569, 829 SHOCK_DECOMPOSITION = 570, 830 SHOCK_GROUPS = 571, 831 USE_SHOCK_GROUPS = 572, 832 SIGMA_E = 573, 833 SIMUL = 574, 834 SIMUL_ALGO = 575, 835 SIMUL_SEED = 576, 836 ENDOGENOUS_TERMINAL_PERIOD = 577, 837 SMOOTHER = 578, 838 SMOOTHER2HISTVAL = 579, 839 SQUARE_ROOT_SOLVER = 580, 840 STACK_SOLVE_ALGO = 581, 841 STEADY_STATE_MODEL = 582, 842 SOLVE_ALGO = 583, 843 SOLVER_PERIODS = 584, 844 ROBUST_LIN_SOLVE = 585, 845 STDERR = 586, 846 STEADY = 587, 847 STOCH_SIMUL = 588, 848 SYLVESTER = 589, 849 SYLVESTER_FIXED_POINT_TOL = 590, 850 REGIMES = 591, 851 REGIME = 592, 852 REALTIME_SHOCK_DECOMPOSITION = 593, 853 CONDITIONAL = 594, 854 UNCONDITIONAL = 595, 855 TEX = 596, 856 RAMSEY_MODEL = 597, 857 RAMSEY_POLICY = 598, 858 RAMSEY_CONSTRAINTS = 599, 859 PLANNER_DISCOUNT = 600, 860 PLANNER_DISCOUNT_LATEX_NAME = 601, 861 DISCRETIONARY_POLICY = 602, 862 DISCRETIONARY_TOL = 603, 863 EVALUATE_PLANNER_OBJECTIVE = 604, 864 TEX_NAME = 605, 865 TRUE = 606, 866 UNIFORM_PDF = 607, 867 UNIT_ROOT_VARS = 608, 868 USE_DLL = 609, 869 USEAUTOCORR = 610, 870 GSA_SAMPLE_FILE = 611, 871 USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED = 612, 872 VALUES = 613, 873 VAR = 614, 874 VAREXO = 615, 875 VAREXO_DET = 616, 876 VARIABLE = 617, 877 VAROBS = 618, 878 VAREXOBS = 619, 879 PREDETERMINED_VARIABLES = 620, 880 VAR_EXPECTATION = 621, 881 VAR_EXPECTATION_MODEL = 622, 882 PLOT_SHOCK_DECOMPOSITION = 623, 883 MODEL_LOCAL_VARIABLE = 624, 884 WRITE_LATEX_DYNAMIC_MODEL = 625, 885 WRITE_LATEX_STATIC_MODEL = 626, 886 WRITE_LATEX_ORIGINAL_MODEL = 627, 887 CROSSEQUATIONS = 628, 888 COVARIANCE = 629, 889 WRITE_LATEX_STEADY_STATE_MODEL = 630, 890 XLS_SHEET = 631, 891 XLS_RANGE = 632, 892 LMMCP = 633, 893 OCCBIN = 634, 894 BANDPASS_FILTER = 635, 895 COLORMAP = 636, 896 VAR_MODEL = 637, 897 PAC_MODEL = 638, 898 QOQ = 639, 899 YOY = 640, 900 AOA = 641, 901 PAC_EXPECTATION = 642, 902 TREND_COMPONENT_MODEL = 643, 903 EQUAL_EQUAL = 644, 904 EXCLAMATION_EQUAL = 645, 905 LESS = 646, 906 GREATER = 647, 907 LESS_EQUAL = 648, 908 GREATER_EQUAL = 649, 909 PLUS = 650, 910 MINUS = 651, 911 TIMES = 652, 912 DIVIDE = 653, 913 UNARY = 654, 914 POWER = 655, 915 EXP = 656, 916 LOG = 657, 917 LN = 658, 918 LOG10 = 659, 919 SIN = 660, 920 COS = 661, 921 TAN = 662, 922 ASIN = 663, 923 ACOS = 664, 924 ATAN = 665, 925 ERF = 666, 926 DIFF = 667, 927 ADL = 668, 928 AUXILIARY_MODEL_NAME = 669, 929 SQRT = 670, 930 CBRT = 671, 931 NORMCDF = 672, 932 NORMPDF = 673, 933 STEADY_STATE = 674, 934 EXPECTATION = 675, 935 VAR_ESTIMATION = 676, 936 DYNARE_SENSITIVITY = 677, 937 MORRIS = 678, 938 STAB = 679, 939 REDFORM = 680, 940 PPRIOR = 681, 941 PRIOR_RANGE = 682, 942 PPOST = 683, 943 ILPTAU = 684, 944 MORRIS_NLIV = 685, 945 MORRIS_NTRA = 686, 946 NSAM = 687, 947 LOAD_REDFORM = 688, 948 LOAD_RMSE = 689, 949 LOAD_STAB = 690, 950 ALPHA2_STAB = 691, 951 LOGTRANS_REDFORM = 692, 952 THRESHOLD_REDFORM = 693, 953 KSSTAT_REDFORM = 694, 954 ALPHA2_REDFORM = 695, 955 NAMENDO = 696, 956 NAMLAGENDO = 697, 957 NAMEXO = 698, 958 RMSE = 699, 959 LIK_ONLY = 700, 960 VAR_RMSE = 701, 961 PFILT_RMSE = 702, 962 ISTART_RMSE = 703, 963 ALPHA_RMSE = 704, 964 ALPHA2_RMSE = 705, 965 FREQ = 706, 966 INITIAL_YEAR = 707, 967 INITIAL_SUBPERIOD = 708, 968 FINAL_YEAR = 709, 969 FINAL_SUBPERIOD = 710, 970 DATA = 711, 971 VLIST = 712, 972 VLISTLOG = 713, 973 VLISTPER = 714, 974 SPECTRAL_DENSITY = 715, 975 INIT2SHOCKS = 716, 976 RESTRICTION = 717, 977 RESTRICTION_FNAME = 718, 978 CROSS_RESTRICTIONS = 719, 979 NLAGS = 720, 980 CONTEMP_REDUCED_FORM = 721, 981 REAL_PSEUDO_FORECAST = 722, 982 DUMMY_OBS = 723, 983 NSTATES = 724, 984 INDXSCALESSTATES = 725, 985 NO_BAYESIAN_PRIOR = 726, 986 SPECIFICATION = 727, 987 SIMS_ZHA = 728, 988 ALPHA = 729, 989 BETA = 730, 990 ABAND = 731, 991 NINV = 732, 992 CMS = 733, 993 NCMS = 734, 994 CNUM = 735, 995 GAMMA = 736, 996 INV_GAMMA = 737, 997 INV_GAMMA1 = 738, 998 INV_GAMMA2 = 739, 999 NORMAL = 740, 1000 UNIFORM = 741, 1001 EPS = 742, 1002 PDF = 743, 1003 FIG = 744, 1004 DR = 745, 1005 NONE = 746, 1006 PRIOR = 747, 1007 PRIOR_VARIANCE = 748, 1008 HESSIAN = 749, 1009 IDENTITY_MATRIX = 750, 1010 DIRICHLET = 751, 1011 DIAGONAL = 752, 1012 OPTIMAL = 753, 1013 GSIG2_LMDM = 754, 1014 Q_DIAG = 755, 1015 FLAT_PRIOR = 756, 1016 NCSK = 757, 1017 NSTD = 758, 1018 WEIBULL = 759, 1019 WEIBULL_PDF = 760, 1020 INDXPARR = 761, 1021 INDXOVR = 762, 1022 INDXAP = 763, 1023 APBAND = 764, 1024 INDXIMF = 765, 1025 INDXFORE = 766, 1026 FOREBAND = 767, 1027 INDXGFOREHAT = 768, 1028 INDXGIMFHAT = 769, 1029 INDXESTIMA = 770, 1030 INDXGDLS = 771, 1031 EQ_MS = 772, 1032 FILTER_COVARIANCE = 773, 1033 FILTER_DECOMPOSITION = 774, 1034 SMOOTHED_STATE_UNCERTAINTY = 775, 1035 EQ_CMS = 776, 1036 TLINDX = 777, 1037 TLNUMBER = 778, 1038 RESTRICTIONS = 779, 1039 POSTERIOR_SAMPLER_OPTIONS = 780, 1040 OUTPUT_FILE_TAG = 781, 1041 HORIZON = 782, 1042 SBVAR = 783, 1043 TREND_VAR = 784, 1044 DEFLATOR = 785, 1045 GROWTH_FACTOR = 786, 1046 MS_IRF = 787, 1047 MS_VARIANCE_DECOMPOSITION = 788, 1048 GROWTH = 789, 1049 MS_ESTIMATION = 790, 1050 MS_SIMULATION = 791, 1051 MS_COMPUTE_MDD = 792, 1052 MS_COMPUTE_PROBABILITIES = 793, 1053 MS_FORECAST = 794, 1054 SVAR_IDENTIFICATION = 795, 1055 EQUATION = 796, 1056 EXCLUSION = 797, 1057 LAG = 798, 1058 UPPER_CHOLESKY = 799, 1059 LOWER_CHOLESKY = 800, 1060 MONTHLY = 801, 1061 QUARTERLY = 802, 1062 MARKOV_SWITCHING = 803, 1063 CHAIN = 804, 1064 DURATION = 805, 1065 NUMBER_OF_REGIMES = 806, 1066 NUMBER_OF_LAGS = 807, 1067 EPILOGUE = 808, 1068 SVAR = 809, 1069 SVAR_GLOBAL_IDENTIFICATION_CHECK = 810, 1070 COEFF = 811, 1071 COEFFICIENTS = 812, 1072 VARIANCES = 813, 1073 CONSTANTS = 814, 1074 EQUATIONS = 815, 1075 EXTERNAL_FUNCTION = 816, 1076 EXT_FUNC_NAME = 817, 1077 EXT_FUNC_NARGS = 818, 1078 FIRST_DERIV_PROVIDED = 819, 1079 SECOND_DERIV_PROVIDED = 820, 1080 SELECTED_VARIABLES_ONLY = 821, 1081 COVA_COMPUTE = 822, 1082 SIMULATION_FILE_TAG = 823, 1083 FILE_TAG = 824, 1084 NO_ERROR_BANDS = 825, 1085 ERROR_BAND_PERCENTILES = 826, 1086 SHOCKS_PER_PARAMETER = 827, 1087 NO_CREATE_INIT = 828, 1088 SHOCK_DRAWS = 829, 1089 FREE_PARAMETERS = 830, 1090 MEDIAN = 831, 1091 DATA_OBS_NBR = 832, 1092 NEIGHBORHOOD_WIDTH = 833, 1093 PVALUE_KS = 834, 1094 PVALUE_CORR = 835, 1095 FILTERED_PROBABILITIES = 836, 1096 REAL_TIME_SMOOTHED = 837, 1097 PRIOR_FUNCTION = 838, 1098 POSTERIOR_FUNCTION = 839, 1099 SAMPLING_DRAWS = 840, 1100 PROPOSAL_TYPE = 841, 1101 PROPOSAL_UPPER_BOUND = 842, 1102 PROPOSAL_LOWER_BOUND = 843, 1103 PROPOSAL_DRAWS = 844, 1104 USE_MEAN_CENTER = 845, 1105 ADAPTIVE_MH_DRAWS = 846, 1106 THINNING_FACTOR = 847, 1107 COEFFICIENTS_PRIOR_HYPERPARAMETERS = 848, 1108 SMM_ESTIMATION = 849, 1109 GMM_ESTIMATION = 850, 1110 CONVERGENCE_STARTING_VALUE = 851, 1111 CONVERGENCE_ENDING_VALUE = 852, 1112 CONVERGENCE_INCREMENT_VALUE = 853, 1113 MAX_ITERATIONS_STARTING_VALUE = 854, 1114 MAX_ITERATIONS_INCREMENT_VALUE = 855, 1115 MAX_BLOCK_ITERATIONS = 856, 1116 MAX_REPEATED_OPTIMIZATION_RUNS = 857, 1117 FUNCTION_CONVERGENCE_CRITERION = 858, 1118 SAVE_REALTIME = 859, 1119 PARAMETER_CONVERGENCE_CRITERION = 860, 1120 NUMBER_OF_LARGE_PERTURBATIONS = 861, 1121 NUMBER_OF_SMALL_PERTURBATIONS = 862, 1122 NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION = 863, 1123 MAX_NUMBER_OF_STAGES = 864, 1124 RANDOM_FUNCTION_CONVERGENCE_CRITERION = 865, 1125 RANDOM_PARAMETER_CONVERGENCE_CRITERION = 866, 1126 CENTERED_MOMENTS = 867, 1127 AUTOLAG = 868, 1128 RECURSIVE_ORDER_ESTIMATION = 869, 1129 BARTLETT_KERNEL_LAG = 870, 1130 WEIGHTING_MATRIX = 871, 1131 PENALIZED_ESTIMATOR = 872, 1132 VERBOSE = 873, 1133 SIMULATION_MULTIPLE = 874, 1134 SEED = 875, 1135 BOUNDED_SHOCK_SUPPORT = 876, 1136 EQTAGS = 877, 1137 STEADY_STATE_GROWTH = 878, 1138 ANALYTICAL_GIRF = 879, 1139 IRF_IN_PERCENT = 880, 1140 EMAS_GIRF = 881, 1141 EMAS_DROP = 882, 1142 EMAS_TOLF = 883, 1143 EMAS_MAX_ITER = 884, 1144 NO_IDENTIFICATION_STRENGTH = 885, 1145 NO_IDENTIFICATION_REDUCEDFORM = 886, 1146 NO_IDENTIFICATION_MOMENTS = 887, 1147 NO_IDENTIFICATION_MINIMAL = 888, 1148 NO_IDENTIFICATION_SPECTRUM = 889, 1149 NORMALIZE_JACOBIANS = 890, 1150 GRID_NBR = 891, 1151 TOL_RANK = 892, 1152 TOL_DERIV = 893, 1153 TOL_SV = 894, 1154 CHECKS_VIA_SUBSETS = 895, 1155 MAX_DIM_SUBSETS_GROUPS = 896, 1156 MAX_NROWS = 897, 1157 SQUEEZE_SHOCK_DECOMPOSITION = 898, 1158 WITH_EPILOGUE = 899, 1159 SYMBOL_VEC = 900 1160 }; 1161 }; 1162 1163 /// (External) token type, as returned by yylex. 1164 typedef token::yytokentype token_type; 1165 1166 /// Symbol type: an internal symbol number. 1167 typedef int symbol_number_type; 1168 1169 /// The symbol type number to denote an empty symbol. 1170 enum { empty_symbol = -2 }; 1171 1172 /// Internal symbol number for tokens (subsumed by symbol_number_type). 1173 typedef unsigned short token_number_type; 1174 1175 /// A complete symbol. 1176 /// 1177 /// Expects its Base type to provide access to the symbol type 1178 /// via type_get (). 1179 /// 1180 /// Provide access to semantic value and location. 1181 template <typename Base> 1182 struct basic_symbol : Base 1183 { 1184 /// Alias to Base. 1185 typedef Base super_type; 1186 1187 /// Default constructor. basic_symbolDynare::parser::basic_symbol1188 basic_symbol () 1189 : value () 1190 , location () 1191 {} 1192 1193 #if 201103L <= YY_CPLUSPLUS 1194 /// Move constructor. 1195 basic_symbol (basic_symbol&& that); 1196 #endif 1197 1198 /// Copy constructor. 1199 basic_symbol (const basic_symbol& that); 1200 1201 /// Constructor for valueless symbols, and symbols from each type. 1202 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1203 basic_symbol (typename Base::kind_type t, location_type&& l) 1204 : Base (t) 1205 , location (std::move (l)) 1206 {} 1207 #else basic_symbolDynare::parser::basic_symbol1208 basic_symbol (typename Base::kind_type t, const location_type& l) 1209 : Base (t) 1210 , location (l) 1211 {} 1212 #endif 1213 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1214 basic_symbol (typename Base::kind_type t, PriorDistributions&& v, location_type&& l) 1215 : Base (t) 1216 , value (std::move (v)) 1217 , location (std::move (l)) 1218 {} 1219 #else basic_symbolDynare::parser::basic_symbol1220 basic_symbol (typename Base::kind_type t, const PriorDistributions& v, const location_type& l) 1221 : Base (t) 1222 , value (v) 1223 , location (l) 1224 {} 1225 #endif 1226 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1227 basic_symbol (typename Base::kind_type t, SymbolType&& v, location_type&& l) 1228 : Base (t) 1229 , value (std::move (v)) 1230 , location (std::move (l)) 1231 {} 1232 #else basic_symbolDynare::parser::basic_symbol1233 basic_symbol (typename Base::kind_type t, const SymbolType& v, const location_type& l) 1234 : Base (t) 1235 , value (v) 1236 , location (l) 1237 {} 1238 #endif 1239 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1240 basic_symbol (typename Base::kind_type t, expr_t&& v, location_type&& l) 1241 : Base (t) 1242 , value (std::move (v)) 1243 , location (std::move (l)) 1244 {} 1245 #else basic_symbolDynare::parser::basic_symbol1246 basic_symbol (typename Base::kind_type t, const expr_t& v, const location_type& l) 1247 : Base (t) 1248 , value (v) 1249 , location (l) 1250 {} 1251 #endif 1252 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1253 basic_symbol (typename Base::kind_type t, pair<expr_t,expr_t>&& v, location_type&& l) 1254 : Base (t) 1255 , value (std::move (v)) 1256 , location (std::move (l)) 1257 {} 1258 #else basic_symbolDynare::parser::basic_symbol1259 basic_symbol (typename Base::kind_type t, const pair<expr_t,expr_t>& v, const location_type& l) 1260 : Base (t) 1261 , value (v) 1262 , location (l) 1263 {} 1264 #endif 1265 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1266 basic_symbol (typename Base::kind_type t, pair<string,string>&& v, location_type&& l) 1267 : Base (t) 1268 , value (std::move (v)) 1269 , location (std::move (l)) 1270 {} 1271 #else basic_symbolDynare::parser::basic_symbol1272 basic_symbol (typename Base::kind_type t, const pair<string,string>& v, const location_type& l) 1273 : Base (t) 1274 , value (v) 1275 , location (l) 1276 {} 1277 #endif 1278 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1279 basic_symbol (typename Base::kind_type t, string&& v, location_type&& l) 1280 : Base (t) 1281 , value (std::move (v)) 1282 , location (std::move (l)) 1283 {} 1284 #else basic_symbolDynare::parser::basic_symbol1285 basic_symbol (typename Base::kind_type t, const string& v, const location_type& l) 1286 : Base (t) 1287 , value (v) 1288 , location (l) 1289 {} 1290 #endif 1291 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1292 basic_symbol (typename Base::kind_type t, tuple<string,string,string,string>&& v, location_type&& l) 1293 : Base (t) 1294 , value (std::move (v)) 1295 , location (std::move (l)) 1296 {} 1297 #else basic_symbolDynare::parser::basic_symbol1298 basic_symbol (typename Base::kind_type t, const tuple<string,string,string,string>& v, const location_type& l) 1299 : Base (t) 1300 , value (v) 1301 , location (l) 1302 {} 1303 #endif 1304 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1305 basic_symbol (typename Base::kind_type t, vector<int>&& v, location_type&& l) 1306 : Base (t) 1307 , value (std::move (v)) 1308 , location (std::move (l)) 1309 {} 1310 #else basic_symbolDynare::parser::basic_symbol1311 basic_symbol (typename Base::kind_type t, const vector<int>& v, const location_type& l) 1312 : Base (t) 1313 , value (v) 1314 , location (l) 1315 {} 1316 #endif 1317 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1318 basic_symbol (typename Base::kind_type t, vector<pair<string,string>>&& v, location_type&& l) 1319 : Base (t) 1320 , value (std::move (v)) 1321 , location (std::move (l)) 1322 {} 1323 #else basic_symbolDynare::parser::basic_symbol1324 basic_symbol (typename Base::kind_type t, const vector<pair<string,string>>& v, const location_type& l) 1325 : Base (t) 1326 , value (v) 1327 , location (l) 1328 {} 1329 #endif 1330 #if 201103L <= YY_CPLUSPLUS basic_symbolDynare::parser::basic_symbol1331 basic_symbol (typename Base::kind_type t, vector<string>&& v, location_type&& l) 1332 : Base (t) 1333 , value (std::move (v)) 1334 , location (std::move (l)) 1335 {} 1336 #else basic_symbolDynare::parser::basic_symbol1337 basic_symbol (typename Base::kind_type t, const vector<string>& v, const location_type& l) 1338 : Base (t) 1339 , value (v) 1340 , location (l) 1341 {} 1342 #endif 1343 1344 /// Destroy the symbol. ~basic_symbolDynare::parser::basic_symbol1345 ~basic_symbol () 1346 { 1347 clear (); 1348 } 1349 1350 /// Destroy contents, and record that is empty. clearDynare::parser::basic_symbol1351 void clear () 1352 { 1353 // User destructor. 1354 symbol_number_type yytype = this->type_get (); 1355 basic_symbol<Base>& yysym = *this; 1356 (void) yysym; 1357 switch (yytype) 1358 { 1359 default: 1360 break; 1361 } 1362 1363 // Type destructor. 1364 switch (yytype) 1365 { 1366 case 840: // prior_distribution 1367 case 841: // prior_pdf 1368 value.template destroy< PriorDistributions > (); 1369 break; 1370 1371 case 714: // change_type_arg 1372 value.template destroy< SymbolType > (); 1373 break; 1374 1375 case 718: // expression 1376 case 721: // expression_or_empty 1377 case 745: // equation 1378 case 748: // hand_side 1379 value.template destroy< expr_t > (); 1380 break; 1381 1382 case 1006: // calibration_range 1383 value.template destroy< pair<expr_t,expr_t> > (); 1384 break; 1385 1386 case 704: // named_var_elem 1387 case 850: // subsamples_eq_opt 1388 case 1471: // integer_range_w_inf 1389 value.template destroy< pair<string,string> > (); 1390 break; 1391 1392 case 88: // FALSE 1393 case 89: // FLOAT_NUMBER 1394 case 90: // DATES 1395 case 138: // INT_NUMBER 1396 case 235: // NAME 1397 case 297: // QUOTED_STRING 1398 case 350: // TEX_NAME 1399 case 351: // TRUE 1400 case 474: // ALPHA 1401 case 475: // BETA 1402 case 476: // ABAND 1403 case 477: // NINV 1404 case 478: // CMS 1405 case 479: // NCMS 1406 case 480: // CNUM 1407 case 481: // GAMMA 1408 case 482: // INV_GAMMA 1409 case 483: // INV_GAMMA1 1410 case 484: // INV_GAMMA2 1411 case 485: // NORMAL 1412 case 486: // UNIFORM 1413 case 487: // EPS 1414 case 488: // PDF 1415 case 489: // FIG 1416 case 490: // DR 1417 case 491: // NONE 1418 case 492: // PRIOR 1419 case 493: // PRIOR_VARIANCE 1420 case 494: // HESSIAN 1421 case 495: // IDENTITY_MATRIX 1422 case 496: // DIRICHLET 1423 case 497: // DIAGONAL 1424 case 498: // OPTIMAL 1425 case 819: // signed_integer 1426 case 820: // non_negative_number 1427 case 821: // signed_number 1428 case 822: // signed_inf 1429 case 823: // signed_number_w_inf 1430 case 824: // boolean 1431 case 842: // date_str 1432 case 843: // date_expr 1433 case 876: // list_sub_sampling_option 1434 case 877: // sub_sampling_options 1435 case 904: // filename 1436 case 905: // namespace_qualified_symbol 1437 case 906: // namespace_qualified_filename 1438 case 1469: // range 1439 case 1470: // integer_range 1440 case 1472: // signed_integer_range 1441 case 1479: // vec_value_1 1442 case 1480: // vec_value 1443 case 1481: // vec_value_list 1444 case 1482: // vec_of_vec_value 1445 case 1483: // vec_value_1_w_inf 1446 case 1484: // vec_value_w_inf 1447 case 1485: // symbol 1448 case 1486: // number 1449 value.template destroy< string > (); 1450 break; 1451 1452 case 865: // prior_eq_opt 1453 case 870: // options_eq_opt 1454 value.template destroy< tuple<string,string,string,string> > (); 1455 break; 1456 1457 case 1473: // vec_int_number 1458 case 1474: // vec_int_elem 1459 case 1475: // vec_int_1 1460 case 1476: // vec_int 1461 value.template destroy< vector<int> > (); 1462 break; 1463 1464 case 705: // named_var_1 1465 case 706: // named_var 1466 value.template destroy< vector<pair<string,string>> > (); 1467 break; 1468 1469 case 645: // SYMBOL_VEC 1470 case 715: // change_type_var_list 1471 case 1477: // vec_str_1 1472 case 1478: // vec_str 1473 value.template destroy< vector<string> > (); 1474 break; 1475 1476 default: 1477 break; 1478 } 1479 1480 Base::clear (); 1481 } 1482 1483 /// Whether empty. 1484 bool empty () const YY_NOEXCEPT; 1485 1486 /// Destructive move, \a s is emptied into this. 1487 void move (basic_symbol& s); 1488 1489 /// The semantic value. 1490 semantic_type value; 1491 1492 /// The location. 1493 location_type location; 1494 1495 private: 1496 #if YY_CPLUSPLUS < 201103L 1497 /// Assignment operator. 1498 basic_symbol& operator= (const basic_symbol& that); 1499 #endif 1500 }; 1501 1502 /// Type access provider for token (enum) based symbols. 1503 struct by_type 1504 { 1505 /// Default constructor. 1506 by_type (); 1507 1508 #if 201103L <= YY_CPLUSPLUS 1509 /// Move constructor. 1510 by_type (by_type&& that); 1511 #endif 1512 1513 /// Copy constructor. 1514 by_type (const by_type& that); 1515 1516 /// The symbol type as needed by the constructor. 1517 typedef token_type kind_type; 1518 1519 /// Constructor from (external) token numbers. 1520 by_type (kind_type t); 1521 1522 /// Record that this symbol is empty. 1523 void clear (); 1524 1525 /// Steal the symbol type from \a that. 1526 void move (by_type& that); 1527 1528 /// The (internal) type number (corresponding to \a type). 1529 /// \a empty when empty. 1530 symbol_number_type type_get () const YY_NOEXCEPT; 1531 1532 /// The token. 1533 token_type token () const YY_NOEXCEPT; 1534 1535 /// The symbol type. 1536 /// \a empty_symbol when empty. 1537 /// An int, not token_number_type, to be able to store empty_symbol. 1538 int type; 1539 }; 1540 1541 /// "External" symbols: returned by the scanner. 1542 struct symbol_type : basic_symbol<by_type> 1543 { 1544 /// Superclass. 1545 typedef basic_symbol<by_type> super_type; 1546 1547 /// Empty symbol. symbol_typeDynare::parser::symbol_type1548 symbol_type () {} 1549 1550 /// Constructor for valueless symbols, and symbols from each type. 1551 #if 201103L <= YY_CPLUSPLUS symbol_typeDynare::parser::symbol_type1552 symbol_type (int tok, location_type l) 1553 : super_type(token_type (tok), std::move (l)) 1554 { 1555 YYASSERT (tok == 0 || tok == token::AIM_SOLVER || tok == token::ANALYTIC_DERIVATION || tok == token::ANALYTIC_DERIVATION_MODE || tok == token::AR || tok == token::POSTERIOR_SAMPLING_METHOD || tok == token::BALANCED_GROWTH_TEST_TOL || tok == token::BAYESIAN_IRF || tok == token::BETA_PDF || tok == token::BLOCK || tok == token::USE_CALIBRATION || tok == token::SILENT_OPTIMIZER || tok == token::BVAR_DENSITY || tok == token::BVAR_FORECAST || tok == token::NODECOMPOSITION || tok == token::DR_DISPLAY_TOL || tok == token::HUGE_NUMBER || tok == token::FIG_NAME || tok == token::WRITE_XLS || tok == token::BVAR_PRIOR_DECAY || tok == token::BVAR_PRIOR_FLAT || tok == token::BVAR_PRIOR_LAMBDA || tok == token::INTERACTIVE || tok == token::SCREEN_SHOCKS || tok == token::STEADYSTATE || tok == token::BVAR_PRIOR_MU || tok == token::BVAR_PRIOR_OMEGA || tok == token::BVAR_PRIOR_TAU || tok == token::BVAR_PRIOR_TRAIN || tok == token::DETAIL_PLOT || tok == token::TYPE || tok == token::BVAR_REPLIC || tok == token::BYTECODE || tok == token::ALL_VALUES_REQUIRED || tok == token::PROPOSAL_DISTRIBUTION || tok == token::REALTIME || tok == token::VINTAGE || tok == token::CALIB_SMOOTHER || tok == token::CHANGE_TYPE || tok == token::CHECK || tok == token::CONDITIONAL_FORECAST || tok == token::CONDITIONAL_FORECAST_PATHS || tok == token::CONF_SIG || tok == token::CONSTANT || tok == token::CONTROLLED_VAREXO || tok == token::CORR || tok == token::CUTOFF || tok == token::CYCLE_REDUCTION || tok == token::LOGARITHMIC_REDUCTION || tok == token::COMMA || tok == token::CONSIDER_ALL_ENDOGENOUS || tok == token::CONSIDER_ONLY_OBSERVED || tok == token::INITIAL_CONDITION_DECOMPOSITION || tok == token::DATAFILE || tok == token::FILE || tok == token::SERIES || tok == token::DOUBLING || tok == token::DR_CYCLE_REDUCTION_TOL || tok == token::DR_LOGARITHMIC_REDUCTION_TOL || tok == token::DR_LOGARITHMIC_REDUCTION_MAXITER || tok == token::DR_ALGO || tok == token::DROP || tok == token::DSAMPLE || tok == token::DYNASAVE || tok == token::DYNATYPE || tok == token::CALIBRATION || tok == token::DIFFERENTIATE_FORWARD_VARS || tok == token::END || tok == token::ENDVAL || tok == token::EQUAL || tok == token::ESTIMATION || tok == token::ESTIMATED_PARAMS || tok == token::ESTIMATED_PARAMS_BOUNDS || tok == token::ESTIMATED_PARAMS_INIT || tok == token::EXTENDED_PATH || tok == token::ENDOGENOUS_PRIOR || tok == token::EXPRESSION || tok == token::FILENAME || tok == token::DIRNAME || tok == token::FILTER_STEP_AHEAD || tok == token::FILTERED_VARS || tok == token::FIRST_OBS || tok == token::LAST_OBS || tok == token::SET_TIME || tok == token::OSR_PARAMS_BOUNDS || tok == token::KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED || tok == token::DEFAULT || tok == token::FIXED_POINT || tok == token::FLIP || tok == token::OPT_ALGO || tok == token::COMPILATION_SETUP || tok == token::COMPILER || tok == token::ADD_FLAGS || tok == token::SUBSTITUTE_FLAGS || tok == token::ADD_LIBS || tok == token::SUBSTITUTE_LIBS || tok == token::FORECAST || tok == token::K_ORDER_SOLVER || tok == token::INSTRUMENTS || tok == token::SHIFT || tok == token::MEAN || tok == token::STDEV || tok == token::VARIANCE || tok == token::MODE || tok == token::INTERVAL || tok == token::SHAPE || tok == token::DOMAINN || tok == token::GAMMA_PDF || tok == token::GRAPH || tok == token::GRAPH_FORMAT || tok == token::CONDITIONAL_VARIANCE_DECOMPOSITION || tok == token::NOCHECK || tok == token::STD || tok == token::HISTVAL || tok == token::HISTVAL_FILE || tok == token::HOMOTOPY_SETUP || tok == token::HOMOTOPY_MODE || tok == token::HOMOTOPY_STEPS || tok == token::HOMOTOPY_FORCE_CONTINUE || tok == token::HP_FILTER || tok == token::HP_NGRID || tok == token::FILTERED_THEORETICAL_MOMENTS_GRID || tok == token::HYBRID || tok == token::ONE_SIDED_HP_FILTER || tok == token::IDENTIFICATION || tok == token::INF_CONSTANT || tok == token::INITVAL || tok == token::INITVAL_FILE || tok == token::BOUNDS || tok == token::JSCALE || tok == token::INIT || tok == token::INFILE || tok == token::INVARS || tok == token::INV_GAMMA_PDF || tok == token::INV_GAMMA1_PDF || tok == token::INV_GAMMA2_PDF || tok == token::IRF || tok == token::IRF_SHOCKS || tok == token::IRF_PLOT_THRESHOLD || tok == token::IRF_CALIBRATION || tok == token::FAST_KALMAN_FILTER || tok == token::KALMAN_ALGO || tok == token::KALMAN_TOL || tok == token::DIFFUSE_KALMAN_TOL || tok == token::SUBSAMPLES || tok == token::OPTIONS || tok == token::TOLF || tok == token::TOLX || tok == token::PLOT_INIT_DATE || tok == token::PLOT_END_DATE || tok == token::LAPLACE || tok == token::LIK_ALGO || tok == token::LIK_INIT || tok == token::LINEAR || tok == token::LINEAR_DECOMPOSITION || tok == token::LOAD_IDENT_FILES || tok == token::LOAD_MH_FILE || tok == token::LOAD_RESULTS_AFTER_LOAD_MH || tok == token::LOAD_PARAMS_AND_STEADY_STATE || tok == token::LOGLINEAR || tok == token::LOGDATA || tok == token::LYAPUNOV || tok == token::LINEAR_APPROXIMATION || tok == token::LYAPUNOV_FIXED_POINT_TOL || tok == token::LYAPUNOV_DOUBLING_TOL || tok == token::LOG_DEFLATOR || tok == token::LOG_TREND_VAR || tok == token::LOG_GROWTH_FACTOR || tok == token::MARKOWITZ || tok == token::MARGINAL_DENSITY || tok == token::MAX || tok == token::MAXIT || tok == token::MFS || tok == token::MH_CONF_SIG || tok == token::MH_DROP || tok == token::MH_INIT_SCALE || tok == token::MH_JSCALE || tok == token::MH_TUNE_JSCALE || tok == token::MH_MODE || tok == token::MH_NBLOCKS || tok == token::MH_REPLIC || tok == token::MH_RECOVER || tok == token::POSTERIOR_MAX_SUBSAMPLE_DRAWS || tok == token::MIN || tok == token::MINIMAL_SOLVING_PERIODS || tok == token::MODE_CHECK || tok == token::MODE_CHECK_NEIGHBOURHOOD_SIZE || tok == token::MODE_CHECK_SYMMETRIC_PLOTS || tok == token::MODE_CHECK_NUMBER_OF_POINTS || tok == token::MODE_COMPUTE || tok == token::MODE_FILE || tok == token::MODEL || tok == token::MODEL_COMPARISON || tok == token::MODEL_INFO || tok == token::MSHOCKS || tok == token::ABS || tok == token::SIGN || tok == token::MODEL_DIAGNOSTICS || tok == token::MODIFIEDHARMONICMEAN || tok == token::MOMENTS_VARENDO || tok == token::CONTEMPORANEOUS_CORRELATION || tok == token::DIFFUSE_FILTER || tok == token::SUB_DRAWS || tok == token::TAPER_STEPS || tok == token::GEWEKE_INTERVAL || tok == token::RAFTERY_LEWIS_QRS || tok == token::RAFTERY_LEWIS_DIAGNOSTICS || tok == token::MCMC_JUMPING_COVARIANCE || tok == token::MOMENT_CALIBRATION || tok == token::NUMBER_OF_PARTICLES || tok == token::RESAMPLING || tok == token::SYSTEMATIC || tok == token::GENERIC || tok == token::RESAMPLING_THRESHOLD || tok == token::RESAMPLING_METHOD || tok == token::KITAGAWA || tok == token::STRATIFIED || tok == token::SMOOTH || tok == token::CPF_WEIGHTS || tok == token::AMISANOTRISTANI || tok == token::MURRAYJONESPARSLOW || tok == token::WRITE_EQUATION_TAGS || tok == token::NONLINEAR_FILTER_INITIALIZATION || tok == token::FILTER_ALGORITHM || tok == token::PROPOSAL_APPROXIMATION || tok == token::CUBATURE || tok == token::UNSCENTED || tok == token::MONTECARLO || tok == token::DISTRIBUTION_APPROXIMATION || tok == token::USE_PENALIZED_OBJECTIVE_FOR_HESSIAN || tok == token::INIT_STATE || tok == token::FAST_REALTIME || tok == token::RESCALE_PREDICTION_ERROR_COVARIANCE || tok == token::GENERATE_IRFS || tok == token::NAN_CONSTANT || tok == token::NO_STATIC || tok == token::NOBS || tok == token::NOCONSTANT || tok == token::NODISPLAY || tok == token::NOCORR || tok == token::NODIAGNOSTIC || tok == token::NOFUNCTIONS || tok == token::NO_HOMOTOPY || tok == token::NOGRAPH || tok == token::POSTERIOR_NOGRAPH || tok == token::POSTERIOR_GRAPH || tok == token::NOMOMENTS || tok == token::NOPRINT || tok == token::NORMAL_PDF || tok == token::SAVE_DRAWS || tok == token::MODEL_NAME || tok == token::STDERR_MULTIPLES || tok == token::DIAGONAL_ONLY || tok == token::OBSERVATION_TRENDS || tok == token::OPTIM || tok == token::OPTIM_WEIGHTS || tok == token::ORDER || tok == token::OSR || tok == token::OSR_PARAMS || tok == token::MAX_DIM_COVA_GROUP || tok == token::ADVANCED || tok == token::OUTFILE || tok == token::OUTVARS || tok == token::OVERWRITE || tok == token::DISCOUNT || tok == token::PARALLEL_LOCAL_FILES || tok == token::PARAMETERS || tok == token::PARAMETER_SET || tok == token::PARTIAL_INFORMATION || tok == token::PERIODS || tok == token::PERIOD || tok == token::PLANNER_OBJECTIVE || tok == token::PLOT_CONDITIONAL_FORECAST || tok == token::PLOT_PRIORS || tok == token::PREFILTER || tok == token::PRESAMPLE || tok == token::PERFECT_FORESIGHT_SETUP || tok == token::PERFECT_FORESIGHT_SOLVER || tok == token::NO_POSTERIOR_KERNEL_DENSITY || tok == token::FUNCTION || tok == token::PRINT || tok == token::PRIOR_MC || tok == token::PRIOR_TRUNC || tok == token::PRIOR_MODE || tok == token::PRIOR_MEAN || tok == token::POSTERIOR_MODE || tok == token::POSTERIOR_MEAN || tok == token::POSTERIOR_MEDIAN || tok == token::MLE_MODE || tok == token::PRUNING || tok == token::QZ_CRITERIUM || tok == token::QZ_ZERO_THRESHOLD || tok == token::DSGE_VAR || tok == token::DSGE_VARLAG || tok == token::DSGE_PRIOR_WEIGHT || tok == token::TRUNCATE || tok == token::PIPE_E || tok == token::PIPE_X || tok == token::PIPE_P || tok == token::RELATIVE_IRF || tok == token::REPLIC || tok == token::SIMUL_REPLIC || tok == token::RPLOT || tok == token::SAVE_PARAMS_AND_STEADY_STATE || tok == token::PARAMETER_UNCERTAINTY || tok == token::TARGETS || tok == token::SHOCKS || tok == token::SHOCK_DECOMPOSITION || tok == token::SHOCK_GROUPS || tok == token::USE_SHOCK_GROUPS || tok == token::SIGMA_E || tok == token::SIMUL || tok == token::SIMUL_ALGO || tok == token::SIMUL_SEED || tok == token::ENDOGENOUS_TERMINAL_PERIOD || tok == token::SMOOTHER || tok == token::SMOOTHER2HISTVAL || tok == token::SQUARE_ROOT_SOLVER || tok == token::STACK_SOLVE_ALGO || tok == token::STEADY_STATE_MODEL || tok == token::SOLVE_ALGO || tok == token::SOLVER_PERIODS || tok == token::ROBUST_LIN_SOLVE || tok == token::STDERR || tok == token::STEADY || tok == token::STOCH_SIMUL || tok == token::SYLVESTER || tok == token::SYLVESTER_FIXED_POINT_TOL || tok == token::REGIMES || tok == token::REGIME || tok == token::REALTIME_SHOCK_DECOMPOSITION || tok == token::CONDITIONAL || tok == token::UNCONDITIONAL || tok == token::TEX || tok == token::RAMSEY_MODEL || tok == token::RAMSEY_POLICY || tok == token::RAMSEY_CONSTRAINTS || tok == token::PLANNER_DISCOUNT || tok == token::PLANNER_DISCOUNT_LATEX_NAME || tok == token::DISCRETIONARY_POLICY || tok == token::DISCRETIONARY_TOL || tok == token::EVALUATE_PLANNER_OBJECTIVE || tok == token::UNIFORM_PDF || tok == token::UNIT_ROOT_VARS || tok == token::USE_DLL || tok == token::USEAUTOCORR || tok == token::GSA_SAMPLE_FILE || tok == token::USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED || tok == token::VALUES || tok == token::VAR || tok == token::VAREXO || tok == token::VAREXO_DET || tok == token::VARIABLE || tok == token::VAROBS || tok == token::VAREXOBS || tok == token::PREDETERMINED_VARIABLES || tok == token::VAR_EXPECTATION || tok == token::VAR_EXPECTATION_MODEL || tok == token::PLOT_SHOCK_DECOMPOSITION || tok == token::MODEL_LOCAL_VARIABLE || tok == token::WRITE_LATEX_DYNAMIC_MODEL || tok == token::WRITE_LATEX_STATIC_MODEL || tok == token::WRITE_LATEX_ORIGINAL_MODEL || tok == token::CROSSEQUATIONS || tok == token::COVARIANCE || tok == token::WRITE_LATEX_STEADY_STATE_MODEL || tok == token::XLS_SHEET || tok == token::XLS_RANGE || tok == token::LMMCP || tok == token::OCCBIN || tok == token::BANDPASS_FILTER || tok == token::COLORMAP || tok == token::VAR_MODEL || tok == token::PAC_MODEL || tok == token::QOQ || tok == token::YOY || tok == token::AOA || tok == token::PAC_EXPECTATION || tok == token::TREND_COMPONENT_MODEL || tok == token::EQUAL_EQUAL || tok == token::EXCLAMATION_EQUAL || tok == token::LESS || tok == token::GREATER || tok == token::LESS_EQUAL || tok == token::GREATER_EQUAL || tok == token::PLUS || tok == token::MINUS || tok == token::TIMES || tok == token::DIVIDE || tok == token::UNARY || tok == token::POWER || tok == token::EXP || tok == token::LOG || tok == token::LN || tok == token::LOG10 || tok == token::SIN || tok == token::COS || tok == token::TAN || tok == token::ASIN || tok == token::ACOS || tok == token::ATAN || tok == token::ERF || tok == token::DIFF || tok == token::ADL || tok == token::AUXILIARY_MODEL_NAME || tok == token::SQRT || tok == token::CBRT || tok == token::NORMCDF || tok == token::NORMPDF || tok == token::STEADY_STATE || tok == token::EXPECTATION || tok == token::VAR_ESTIMATION || tok == token::DYNARE_SENSITIVITY || tok == token::MORRIS || tok == token::STAB || tok == token::REDFORM || tok == token::PPRIOR || tok == token::PRIOR_RANGE || tok == token::PPOST || tok == token::ILPTAU || tok == token::MORRIS_NLIV || tok == token::MORRIS_NTRA || tok == token::NSAM || tok == token::LOAD_REDFORM || tok == token::LOAD_RMSE || tok == token::LOAD_STAB || tok == token::ALPHA2_STAB || tok == token::LOGTRANS_REDFORM || tok == token::THRESHOLD_REDFORM || tok == token::KSSTAT_REDFORM || tok == token::ALPHA2_REDFORM || tok == token::NAMENDO || tok == token::NAMLAGENDO || tok == token::NAMEXO || tok == token::RMSE || tok == token::LIK_ONLY || tok == token::VAR_RMSE || tok == token::PFILT_RMSE || tok == token::ISTART_RMSE || tok == token::ALPHA_RMSE || tok == token::ALPHA2_RMSE || tok == token::FREQ || tok == token::INITIAL_YEAR || tok == token::INITIAL_SUBPERIOD || tok == token::FINAL_YEAR || tok == token::FINAL_SUBPERIOD || tok == token::DATA || tok == token::VLIST || tok == token::VLISTLOG || tok == token::VLISTPER || tok == token::SPECTRAL_DENSITY || tok == token::INIT2SHOCKS || tok == token::RESTRICTION || tok == token::RESTRICTION_FNAME || tok == token::CROSS_RESTRICTIONS || tok == token::NLAGS || tok == token::CONTEMP_REDUCED_FORM || tok == token::REAL_PSEUDO_FORECAST || tok == token::DUMMY_OBS || tok == token::NSTATES || tok == token::INDXSCALESSTATES || tok == token::NO_BAYESIAN_PRIOR || tok == token::SPECIFICATION || tok == token::SIMS_ZHA || tok == token::GSIG2_LMDM || tok == token::Q_DIAG || tok == token::FLAT_PRIOR || tok == token::NCSK || tok == token::NSTD || tok == token::WEIBULL || tok == token::WEIBULL_PDF || tok == token::INDXPARR || tok == token::INDXOVR || tok == token::INDXAP || tok == token::APBAND || tok == token::INDXIMF || tok == token::INDXFORE || tok == token::FOREBAND || tok == token::INDXGFOREHAT || tok == token::INDXGIMFHAT || tok == token::INDXESTIMA || tok == token::INDXGDLS || tok == token::EQ_MS || tok == token::FILTER_COVARIANCE || tok == token::FILTER_DECOMPOSITION || tok == token::SMOOTHED_STATE_UNCERTAINTY || tok == token::EQ_CMS || tok == token::TLINDX || tok == token::TLNUMBER || tok == token::RESTRICTIONS || tok == token::POSTERIOR_SAMPLER_OPTIONS || tok == token::OUTPUT_FILE_TAG || tok == token::HORIZON || tok == token::SBVAR || tok == token::TREND_VAR || tok == token::DEFLATOR || tok == token::GROWTH_FACTOR || tok == token::MS_IRF || tok == token::MS_VARIANCE_DECOMPOSITION || tok == token::GROWTH || tok == token::MS_ESTIMATION || tok == token::MS_SIMULATION || tok == token::MS_COMPUTE_MDD || tok == token::MS_COMPUTE_PROBABILITIES || tok == token::MS_FORECAST || tok == token::SVAR_IDENTIFICATION || tok == token::EQUATION || tok == token::EXCLUSION || tok == token::LAG || tok == token::UPPER_CHOLESKY || tok == token::LOWER_CHOLESKY || tok == token::MONTHLY || tok == token::QUARTERLY || tok == token::MARKOV_SWITCHING || tok == token::CHAIN || tok == token::DURATION || tok == token::NUMBER_OF_REGIMES || tok == token::NUMBER_OF_LAGS || tok == token::EPILOGUE || tok == token::SVAR || tok == token::SVAR_GLOBAL_IDENTIFICATION_CHECK || tok == token::COEFF || tok == token::COEFFICIENTS || tok == token::VARIANCES || tok == token::CONSTANTS || tok == token::EQUATIONS || tok == token::EXTERNAL_FUNCTION || tok == token::EXT_FUNC_NAME || tok == token::EXT_FUNC_NARGS || tok == token::FIRST_DERIV_PROVIDED || tok == token::SECOND_DERIV_PROVIDED || tok == token::SELECTED_VARIABLES_ONLY || tok == token::COVA_COMPUTE || tok == token::SIMULATION_FILE_TAG || tok == token::FILE_TAG || tok == token::NO_ERROR_BANDS || tok == token::ERROR_BAND_PERCENTILES || tok == token::SHOCKS_PER_PARAMETER || tok == token::NO_CREATE_INIT || tok == token::SHOCK_DRAWS || tok == token::FREE_PARAMETERS || tok == token::MEDIAN || tok == token::DATA_OBS_NBR || tok == token::NEIGHBORHOOD_WIDTH || tok == token::PVALUE_KS || tok == token::PVALUE_CORR || tok == token::FILTERED_PROBABILITIES || tok == token::REAL_TIME_SMOOTHED || tok == token::PRIOR_FUNCTION || tok == token::POSTERIOR_FUNCTION || tok == token::SAMPLING_DRAWS || tok == token::PROPOSAL_TYPE || tok == token::PROPOSAL_UPPER_BOUND || tok == token::PROPOSAL_LOWER_BOUND || tok == token::PROPOSAL_DRAWS || tok == token::USE_MEAN_CENTER || tok == token::ADAPTIVE_MH_DRAWS || tok == token::THINNING_FACTOR || tok == token::COEFFICIENTS_PRIOR_HYPERPARAMETERS || tok == token::SMM_ESTIMATION || tok == token::GMM_ESTIMATION || tok == token::CONVERGENCE_STARTING_VALUE || tok == token::CONVERGENCE_ENDING_VALUE || tok == token::CONVERGENCE_INCREMENT_VALUE || tok == token::MAX_ITERATIONS_STARTING_VALUE || tok == token::MAX_ITERATIONS_INCREMENT_VALUE || tok == token::MAX_BLOCK_ITERATIONS || tok == token::MAX_REPEATED_OPTIMIZATION_RUNS || tok == token::FUNCTION_CONVERGENCE_CRITERION || tok == token::SAVE_REALTIME || tok == token::PARAMETER_CONVERGENCE_CRITERION || tok == token::NUMBER_OF_LARGE_PERTURBATIONS || tok == token::NUMBER_OF_SMALL_PERTURBATIONS || tok == token::NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION || tok == token::MAX_NUMBER_OF_STAGES || tok == token::RANDOM_FUNCTION_CONVERGENCE_CRITERION || tok == token::RANDOM_PARAMETER_CONVERGENCE_CRITERION || tok == token::CENTERED_MOMENTS || tok == token::AUTOLAG || tok == token::RECURSIVE_ORDER_ESTIMATION || tok == token::BARTLETT_KERNEL_LAG || tok == token::WEIGHTING_MATRIX || tok == token::PENALIZED_ESTIMATOR || tok == token::VERBOSE || tok == token::SIMULATION_MULTIPLE || tok == token::SEED || tok == token::BOUNDED_SHOCK_SUPPORT || tok == token::EQTAGS || tok == token::STEADY_STATE_GROWTH || tok == token::ANALYTICAL_GIRF || tok == token::IRF_IN_PERCENT || tok == token::EMAS_GIRF || tok == token::EMAS_DROP || tok == token::EMAS_TOLF || tok == token::EMAS_MAX_ITER || tok == token::NO_IDENTIFICATION_STRENGTH || tok == token::NO_IDENTIFICATION_REDUCEDFORM || tok == token::NO_IDENTIFICATION_MOMENTS || tok == token::NO_IDENTIFICATION_MINIMAL || tok == token::NO_IDENTIFICATION_SPECTRUM || tok == token::NORMALIZE_JACOBIANS || tok == token::GRID_NBR || tok == token::TOL_RANK || tok == token::TOL_DERIV || tok == token::TOL_SV || tok == token::CHECKS_VIA_SUBSETS || tok == token::MAX_DIM_SUBSETS_GROUPS || tok == token::MAX_NROWS || tok == token::SQUEEZE_SHOCK_DECOMPOSITION || tok == token::WITH_EPILOGUE || tok == 59 || tok == 40 || tok == 41 || tok == 91 || tok == 93 || tok == 35 || tok == 58 || tok == 46); 1556 } 1557 #else symbol_typeDynare::parser::symbol_type1558 symbol_type (int tok, const location_type& l) 1559 : super_type(token_type (tok), l) 1560 { 1561 YYASSERT (tok == 0 || tok == token::AIM_SOLVER || tok == token::ANALYTIC_DERIVATION || tok == token::ANALYTIC_DERIVATION_MODE || tok == token::AR || tok == token::POSTERIOR_SAMPLING_METHOD || tok == token::BALANCED_GROWTH_TEST_TOL || tok == token::BAYESIAN_IRF || tok == token::BETA_PDF || tok == token::BLOCK || tok == token::USE_CALIBRATION || tok == token::SILENT_OPTIMIZER || tok == token::BVAR_DENSITY || tok == token::BVAR_FORECAST || tok == token::NODECOMPOSITION || tok == token::DR_DISPLAY_TOL || tok == token::HUGE_NUMBER || tok == token::FIG_NAME || tok == token::WRITE_XLS || tok == token::BVAR_PRIOR_DECAY || tok == token::BVAR_PRIOR_FLAT || tok == token::BVAR_PRIOR_LAMBDA || tok == token::INTERACTIVE || tok == token::SCREEN_SHOCKS || tok == token::STEADYSTATE || tok == token::BVAR_PRIOR_MU || tok == token::BVAR_PRIOR_OMEGA || tok == token::BVAR_PRIOR_TAU || tok == token::BVAR_PRIOR_TRAIN || tok == token::DETAIL_PLOT || tok == token::TYPE || tok == token::BVAR_REPLIC || tok == token::BYTECODE || tok == token::ALL_VALUES_REQUIRED || tok == token::PROPOSAL_DISTRIBUTION || tok == token::REALTIME || tok == token::VINTAGE || tok == token::CALIB_SMOOTHER || tok == token::CHANGE_TYPE || tok == token::CHECK || tok == token::CONDITIONAL_FORECAST || tok == token::CONDITIONAL_FORECAST_PATHS || tok == token::CONF_SIG || tok == token::CONSTANT || tok == token::CONTROLLED_VAREXO || tok == token::CORR || tok == token::CUTOFF || tok == token::CYCLE_REDUCTION || tok == token::LOGARITHMIC_REDUCTION || tok == token::COMMA || tok == token::CONSIDER_ALL_ENDOGENOUS || tok == token::CONSIDER_ONLY_OBSERVED || tok == token::INITIAL_CONDITION_DECOMPOSITION || tok == token::DATAFILE || tok == token::FILE || tok == token::SERIES || tok == token::DOUBLING || tok == token::DR_CYCLE_REDUCTION_TOL || tok == token::DR_LOGARITHMIC_REDUCTION_TOL || tok == token::DR_LOGARITHMIC_REDUCTION_MAXITER || tok == token::DR_ALGO || tok == token::DROP || tok == token::DSAMPLE || tok == token::DYNASAVE || tok == token::DYNATYPE || tok == token::CALIBRATION || tok == token::DIFFERENTIATE_FORWARD_VARS || tok == token::END || tok == token::ENDVAL || tok == token::EQUAL || tok == token::ESTIMATION || tok == token::ESTIMATED_PARAMS || tok == token::ESTIMATED_PARAMS_BOUNDS || tok == token::ESTIMATED_PARAMS_INIT || tok == token::EXTENDED_PATH || tok == token::ENDOGENOUS_PRIOR || tok == token::EXPRESSION || tok == token::FILENAME || tok == token::DIRNAME || tok == token::FILTER_STEP_AHEAD || tok == token::FILTERED_VARS || tok == token::FIRST_OBS || tok == token::LAST_OBS || tok == token::SET_TIME || tok == token::OSR_PARAMS_BOUNDS || tok == token::KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED || tok == token::DEFAULT || tok == token::FIXED_POINT || tok == token::FLIP || tok == token::OPT_ALGO || tok == token::COMPILATION_SETUP || tok == token::COMPILER || tok == token::ADD_FLAGS || tok == token::SUBSTITUTE_FLAGS || tok == token::ADD_LIBS || tok == token::SUBSTITUTE_LIBS || tok == token::FORECAST || tok == token::K_ORDER_SOLVER || tok == token::INSTRUMENTS || tok == token::SHIFT || tok == token::MEAN || tok == token::STDEV || tok == token::VARIANCE || tok == token::MODE || tok == token::INTERVAL || tok == token::SHAPE || tok == token::DOMAINN || tok == token::GAMMA_PDF || tok == token::GRAPH || tok == token::GRAPH_FORMAT || tok == token::CONDITIONAL_VARIANCE_DECOMPOSITION || tok == token::NOCHECK || tok == token::STD || tok == token::HISTVAL || tok == token::HISTVAL_FILE || tok == token::HOMOTOPY_SETUP || tok == token::HOMOTOPY_MODE || tok == token::HOMOTOPY_STEPS || tok == token::HOMOTOPY_FORCE_CONTINUE || tok == token::HP_FILTER || tok == token::HP_NGRID || tok == token::FILTERED_THEORETICAL_MOMENTS_GRID || tok == token::HYBRID || tok == token::ONE_SIDED_HP_FILTER || tok == token::IDENTIFICATION || tok == token::INF_CONSTANT || tok == token::INITVAL || tok == token::INITVAL_FILE || tok == token::BOUNDS || tok == token::JSCALE || tok == token::INIT || tok == token::INFILE || tok == token::INVARS || tok == token::INV_GAMMA_PDF || tok == token::INV_GAMMA1_PDF || tok == token::INV_GAMMA2_PDF || tok == token::IRF || tok == token::IRF_SHOCKS || tok == token::IRF_PLOT_THRESHOLD || tok == token::IRF_CALIBRATION || tok == token::FAST_KALMAN_FILTER || tok == token::KALMAN_ALGO || tok == token::KALMAN_TOL || tok == token::DIFFUSE_KALMAN_TOL || tok == token::SUBSAMPLES || tok == token::OPTIONS || tok == token::TOLF || tok == token::TOLX || tok == token::PLOT_INIT_DATE || tok == token::PLOT_END_DATE || tok == token::LAPLACE || tok == token::LIK_ALGO || tok == token::LIK_INIT || tok == token::LINEAR || tok == token::LINEAR_DECOMPOSITION || tok == token::LOAD_IDENT_FILES || tok == token::LOAD_MH_FILE || tok == token::LOAD_RESULTS_AFTER_LOAD_MH || tok == token::LOAD_PARAMS_AND_STEADY_STATE || tok == token::LOGLINEAR || tok == token::LOGDATA || tok == token::LYAPUNOV || tok == token::LINEAR_APPROXIMATION || tok == token::LYAPUNOV_FIXED_POINT_TOL || tok == token::LYAPUNOV_DOUBLING_TOL || tok == token::LOG_DEFLATOR || tok == token::LOG_TREND_VAR || tok == token::LOG_GROWTH_FACTOR || tok == token::MARKOWITZ || tok == token::MARGINAL_DENSITY || tok == token::MAX || tok == token::MAXIT || tok == token::MFS || tok == token::MH_CONF_SIG || tok == token::MH_DROP || tok == token::MH_INIT_SCALE || tok == token::MH_JSCALE || tok == token::MH_TUNE_JSCALE || tok == token::MH_MODE || tok == token::MH_NBLOCKS || tok == token::MH_REPLIC || tok == token::MH_RECOVER || tok == token::POSTERIOR_MAX_SUBSAMPLE_DRAWS || tok == token::MIN || tok == token::MINIMAL_SOLVING_PERIODS || tok == token::MODE_CHECK || tok == token::MODE_CHECK_NEIGHBOURHOOD_SIZE || tok == token::MODE_CHECK_SYMMETRIC_PLOTS || tok == token::MODE_CHECK_NUMBER_OF_POINTS || tok == token::MODE_COMPUTE || tok == token::MODE_FILE || tok == token::MODEL || tok == token::MODEL_COMPARISON || tok == token::MODEL_INFO || tok == token::MSHOCKS || tok == token::ABS || tok == token::SIGN || tok == token::MODEL_DIAGNOSTICS || tok == token::MODIFIEDHARMONICMEAN || tok == token::MOMENTS_VARENDO || tok == token::CONTEMPORANEOUS_CORRELATION || tok == token::DIFFUSE_FILTER || tok == token::SUB_DRAWS || tok == token::TAPER_STEPS || tok == token::GEWEKE_INTERVAL || tok == token::RAFTERY_LEWIS_QRS || tok == token::RAFTERY_LEWIS_DIAGNOSTICS || tok == token::MCMC_JUMPING_COVARIANCE || tok == token::MOMENT_CALIBRATION || tok == token::NUMBER_OF_PARTICLES || tok == token::RESAMPLING || tok == token::SYSTEMATIC || tok == token::GENERIC || tok == token::RESAMPLING_THRESHOLD || tok == token::RESAMPLING_METHOD || tok == token::KITAGAWA || tok == token::STRATIFIED || tok == token::SMOOTH || tok == token::CPF_WEIGHTS || tok == token::AMISANOTRISTANI || tok == token::MURRAYJONESPARSLOW || tok == token::WRITE_EQUATION_TAGS || tok == token::NONLINEAR_FILTER_INITIALIZATION || tok == token::FILTER_ALGORITHM || tok == token::PROPOSAL_APPROXIMATION || tok == token::CUBATURE || tok == token::UNSCENTED || tok == token::MONTECARLO || tok == token::DISTRIBUTION_APPROXIMATION || tok == token::USE_PENALIZED_OBJECTIVE_FOR_HESSIAN || tok == token::INIT_STATE || tok == token::FAST_REALTIME || tok == token::RESCALE_PREDICTION_ERROR_COVARIANCE || tok == token::GENERATE_IRFS || tok == token::NAN_CONSTANT || tok == token::NO_STATIC || tok == token::NOBS || tok == token::NOCONSTANT || tok == token::NODISPLAY || tok == token::NOCORR || tok == token::NODIAGNOSTIC || tok == token::NOFUNCTIONS || tok == token::NO_HOMOTOPY || tok == token::NOGRAPH || tok == token::POSTERIOR_NOGRAPH || tok == token::POSTERIOR_GRAPH || tok == token::NOMOMENTS || tok == token::NOPRINT || tok == token::NORMAL_PDF || tok == token::SAVE_DRAWS || tok == token::MODEL_NAME || tok == token::STDERR_MULTIPLES || tok == token::DIAGONAL_ONLY || tok == token::OBSERVATION_TRENDS || tok == token::OPTIM || tok == token::OPTIM_WEIGHTS || tok == token::ORDER || tok == token::OSR || tok == token::OSR_PARAMS || tok == token::MAX_DIM_COVA_GROUP || tok == token::ADVANCED || tok == token::OUTFILE || tok == token::OUTVARS || tok == token::OVERWRITE || tok == token::DISCOUNT || tok == token::PARALLEL_LOCAL_FILES || tok == token::PARAMETERS || tok == token::PARAMETER_SET || tok == token::PARTIAL_INFORMATION || tok == token::PERIODS || tok == token::PERIOD || tok == token::PLANNER_OBJECTIVE || tok == token::PLOT_CONDITIONAL_FORECAST || tok == token::PLOT_PRIORS || tok == token::PREFILTER || tok == token::PRESAMPLE || tok == token::PERFECT_FORESIGHT_SETUP || tok == token::PERFECT_FORESIGHT_SOLVER || tok == token::NO_POSTERIOR_KERNEL_DENSITY || tok == token::FUNCTION || tok == token::PRINT || tok == token::PRIOR_MC || tok == token::PRIOR_TRUNC || tok == token::PRIOR_MODE || tok == token::PRIOR_MEAN || tok == token::POSTERIOR_MODE || tok == token::POSTERIOR_MEAN || tok == token::POSTERIOR_MEDIAN || tok == token::MLE_MODE || tok == token::PRUNING || tok == token::QZ_CRITERIUM || tok == token::QZ_ZERO_THRESHOLD || tok == token::DSGE_VAR || tok == token::DSGE_VARLAG || tok == token::DSGE_PRIOR_WEIGHT || tok == token::TRUNCATE || tok == token::PIPE_E || tok == token::PIPE_X || tok == token::PIPE_P || tok == token::RELATIVE_IRF || tok == token::REPLIC || tok == token::SIMUL_REPLIC || tok == token::RPLOT || tok == token::SAVE_PARAMS_AND_STEADY_STATE || tok == token::PARAMETER_UNCERTAINTY || tok == token::TARGETS || tok == token::SHOCKS || tok == token::SHOCK_DECOMPOSITION || tok == token::SHOCK_GROUPS || tok == token::USE_SHOCK_GROUPS || tok == token::SIGMA_E || tok == token::SIMUL || tok == token::SIMUL_ALGO || tok == token::SIMUL_SEED || tok == token::ENDOGENOUS_TERMINAL_PERIOD || tok == token::SMOOTHER || tok == token::SMOOTHER2HISTVAL || tok == token::SQUARE_ROOT_SOLVER || tok == token::STACK_SOLVE_ALGO || tok == token::STEADY_STATE_MODEL || tok == token::SOLVE_ALGO || tok == token::SOLVER_PERIODS || tok == token::ROBUST_LIN_SOLVE || tok == token::STDERR || tok == token::STEADY || tok == token::STOCH_SIMUL || tok == token::SYLVESTER || tok == token::SYLVESTER_FIXED_POINT_TOL || tok == token::REGIMES || tok == token::REGIME || tok == token::REALTIME_SHOCK_DECOMPOSITION || tok == token::CONDITIONAL || tok == token::UNCONDITIONAL || tok == token::TEX || tok == token::RAMSEY_MODEL || tok == token::RAMSEY_POLICY || tok == token::RAMSEY_CONSTRAINTS || tok == token::PLANNER_DISCOUNT || tok == token::PLANNER_DISCOUNT_LATEX_NAME || tok == token::DISCRETIONARY_POLICY || tok == token::DISCRETIONARY_TOL || tok == token::EVALUATE_PLANNER_OBJECTIVE || tok == token::UNIFORM_PDF || tok == token::UNIT_ROOT_VARS || tok == token::USE_DLL || tok == token::USEAUTOCORR || tok == token::GSA_SAMPLE_FILE || tok == token::USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED || tok == token::VALUES || tok == token::VAR || tok == token::VAREXO || tok == token::VAREXO_DET || tok == token::VARIABLE || tok == token::VAROBS || tok == token::VAREXOBS || tok == token::PREDETERMINED_VARIABLES || tok == token::VAR_EXPECTATION || tok == token::VAR_EXPECTATION_MODEL || tok == token::PLOT_SHOCK_DECOMPOSITION || tok == token::MODEL_LOCAL_VARIABLE || tok == token::WRITE_LATEX_DYNAMIC_MODEL || tok == token::WRITE_LATEX_STATIC_MODEL || tok == token::WRITE_LATEX_ORIGINAL_MODEL || tok == token::CROSSEQUATIONS || tok == token::COVARIANCE || tok == token::WRITE_LATEX_STEADY_STATE_MODEL || tok == token::XLS_SHEET || tok == token::XLS_RANGE || tok == token::LMMCP || tok == token::OCCBIN || tok == token::BANDPASS_FILTER || tok == token::COLORMAP || tok == token::VAR_MODEL || tok == token::PAC_MODEL || tok == token::QOQ || tok == token::YOY || tok == token::AOA || tok == token::PAC_EXPECTATION || tok == token::TREND_COMPONENT_MODEL || tok == token::EQUAL_EQUAL || tok == token::EXCLAMATION_EQUAL || tok == token::LESS || tok == token::GREATER || tok == token::LESS_EQUAL || tok == token::GREATER_EQUAL || tok == token::PLUS || tok == token::MINUS || tok == token::TIMES || tok == token::DIVIDE || tok == token::UNARY || tok == token::POWER || tok == token::EXP || tok == token::LOG || tok == token::LN || tok == token::LOG10 || tok == token::SIN || tok == token::COS || tok == token::TAN || tok == token::ASIN || tok == token::ACOS || tok == token::ATAN || tok == token::ERF || tok == token::DIFF || tok == token::ADL || tok == token::AUXILIARY_MODEL_NAME || tok == token::SQRT || tok == token::CBRT || tok == token::NORMCDF || tok == token::NORMPDF || tok == token::STEADY_STATE || tok == token::EXPECTATION || tok == token::VAR_ESTIMATION || tok == token::DYNARE_SENSITIVITY || tok == token::MORRIS || tok == token::STAB || tok == token::REDFORM || tok == token::PPRIOR || tok == token::PRIOR_RANGE || tok == token::PPOST || tok == token::ILPTAU || tok == token::MORRIS_NLIV || tok == token::MORRIS_NTRA || tok == token::NSAM || tok == token::LOAD_REDFORM || tok == token::LOAD_RMSE || tok == token::LOAD_STAB || tok == token::ALPHA2_STAB || tok == token::LOGTRANS_REDFORM || tok == token::THRESHOLD_REDFORM || tok == token::KSSTAT_REDFORM || tok == token::ALPHA2_REDFORM || tok == token::NAMENDO || tok == token::NAMLAGENDO || tok == token::NAMEXO || tok == token::RMSE || tok == token::LIK_ONLY || tok == token::VAR_RMSE || tok == token::PFILT_RMSE || tok == token::ISTART_RMSE || tok == token::ALPHA_RMSE || tok == token::ALPHA2_RMSE || tok == token::FREQ || tok == token::INITIAL_YEAR || tok == token::INITIAL_SUBPERIOD || tok == token::FINAL_YEAR || tok == token::FINAL_SUBPERIOD || tok == token::DATA || tok == token::VLIST || tok == token::VLISTLOG || tok == token::VLISTPER || tok == token::SPECTRAL_DENSITY || tok == token::INIT2SHOCKS || tok == token::RESTRICTION || tok == token::RESTRICTION_FNAME || tok == token::CROSS_RESTRICTIONS || tok == token::NLAGS || tok == token::CONTEMP_REDUCED_FORM || tok == token::REAL_PSEUDO_FORECAST || tok == token::DUMMY_OBS || tok == token::NSTATES || tok == token::INDXSCALESSTATES || tok == token::NO_BAYESIAN_PRIOR || tok == token::SPECIFICATION || tok == token::SIMS_ZHA || tok == token::GSIG2_LMDM || tok == token::Q_DIAG || tok == token::FLAT_PRIOR || tok == token::NCSK || tok == token::NSTD || tok == token::WEIBULL || tok == token::WEIBULL_PDF || tok == token::INDXPARR || tok == token::INDXOVR || tok == token::INDXAP || tok == token::APBAND || tok == token::INDXIMF || tok == token::INDXFORE || tok == token::FOREBAND || tok == token::INDXGFOREHAT || tok == token::INDXGIMFHAT || tok == token::INDXESTIMA || tok == token::INDXGDLS || tok == token::EQ_MS || tok == token::FILTER_COVARIANCE || tok == token::FILTER_DECOMPOSITION || tok == token::SMOOTHED_STATE_UNCERTAINTY || tok == token::EQ_CMS || tok == token::TLINDX || tok == token::TLNUMBER || tok == token::RESTRICTIONS || tok == token::POSTERIOR_SAMPLER_OPTIONS || tok == token::OUTPUT_FILE_TAG || tok == token::HORIZON || tok == token::SBVAR || tok == token::TREND_VAR || tok == token::DEFLATOR || tok == token::GROWTH_FACTOR || tok == token::MS_IRF || tok == token::MS_VARIANCE_DECOMPOSITION || tok == token::GROWTH || tok == token::MS_ESTIMATION || tok == token::MS_SIMULATION || tok == token::MS_COMPUTE_MDD || tok == token::MS_COMPUTE_PROBABILITIES || tok == token::MS_FORECAST || tok == token::SVAR_IDENTIFICATION || tok == token::EQUATION || tok == token::EXCLUSION || tok == token::LAG || tok == token::UPPER_CHOLESKY || tok == token::LOWER_CHOLESKY || tok == token::MONTHLY || tok == token::QUARTERLY || tok == token::MARKOV_SWITCHING || tok == token::CHAIN || tok == token::DURATION || tok == token::NUMBER_OF_REGIMES || tok == token::NUMBER_OF_LAGS || tok == token::EPILOGUE || tok == token::SVAR || tok == token::SVAR_GLOBAL_IDENTIFICATION_CHECK || tok == token::COEFF || tok == token::COEFFICIENTS || tok == token::VARIANCES || tok == token::CONSTANTS || tok == token::EQUATIONS || tok == token::EXTERNAL_FUNCTION || tok == token::EXT_FUNC_NAME || tok == token::EXT_FUNC_NARGS || tok == token::FIRST_DERIV_PROVIDED || tok == token::SECOND_DERIV_PROVIDED || tok == token::SELECTED_VARIABLES_ONLY || tok == token::COVA_COMPUTE || tok == token::SIMULATION_FILE_TAG || tok == token::FILE_TAG || tok == token::NO_ERROR_BANDS || tok == token::ERROR_BAND_PERCENTILES || tok == token::SHOCKS_PER_PARAMETER || tok == token::NO_CREATE_INIT || tok == token::SHOCK_DRAWS || tok == token::FREE_PARAMETERS || tok == token::MEDIAN || tok == token::DATA_OBS_NBR || tok == token::NEIGHBORHOOD_WIDTH || tok == token::PVALUE_KS || tok == token::PVALUE_CORR || tok == token::FILTERED_PROBABILITIES || tok == token::REAL_TIME_SMOOTHED || tok == token::PRIOR_FUNCTION || tok == token::POSTERIOR_FUNCTION || tok == token::SAMPLING_DRAWS || tok == token::PROPOSAL_TYPE || tok == token::PROPOSAL_UPPER_BOUND || tok == token::PROPOSAL_LOWER_BOUND || tok == token::PROPOSAL_DRAWS || tok == token::USE_MEAN_CENTER || tok == token::ADAPTIVE_MH_DRAWS || tok == token::THINNING_FACTOR || tok == token::COEFFICIENTS_PRIOR_HYPERPARAMETERS || tok == token::SMM_ESTIMATION || tok == token::GMM_ESTIMATION || tok == token::CONVERGENCE_STARTING_VALUE || tok == token::CONVERGENCE_ENDING_VALUE || tok == token::CONVERGENCE_INCREMENT_VALUE || tok == token::MAX_ITERATIONS_STARTING_VALUE || tok == token::MAX_ITERATIONS_INCREMENT_VALUE || tok == token::MAX_BLOCK_ITERATIONS || tok == token::MAX_REPEATED_OPTIMIZATION_RUNS || tok == token::FUNCTION_CONVERGENCE_CRITERION || tok == token::SAVE_REALTIME || tok == token::PARAMETER_CONVERGENCE_CRITERION || tok == token::NUMBER_OF_LARGE_PERTURBATIONS || tok == token::NUMBER_OF_SMALL_PERTURBATIONS || tok == token::NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION || tok == token::MAX_NUMBER_OF_STAGES || tok == token::RANDOM_FUNCTION_CONVERGENCE_CRITERION || tok == token::RANDOM_PARAMETER_CONVERGENCE_CRITERION || tok == token::CENTERED_MOMENTS || tok == token::AUTOLAG || tok == token::RECURSIVE_ORDER_ESTIMATION || tok == token::BARTLETT_KERNEL_LAG || tok == token::WEIGHTING_MATRIX || tok == token::PENALIZED_ESTIMATOR || tok == token::VERBOSE || tok == token::SIMULATION_MULTIPLE || tok == token::SEED || tok == token::BOUNDED_SHOCK_SUPPORT || tok == token::EQTAGS || tok == token::STEADY_STATE_GROWTH || tok == token::ANALYTICAL_GIRF || tok == token::IRF_IN_PERCENT || tok == token::EMAS_GIRF || tok == token::EMAS_DROP || tok == token::EMAS_TOLF || tok == token::EMAS_MAX_ITER || tok == token::NO_IDENTIFICATION_STRENGTH || tok == token::NO_IDENTIFICATION_REDUCEDFORM || tok == token::NO_IDENTIFICATION_MOMENTS || tok == token::NO_IDENTIFICATION_MINIMAL || tok == token::NO_IDENTIFICATION_SPECTRUM || tok == token::NORMALIZE_JACOBIANS || tok == token::GRID_NBR || tok == token::TOL_RANK || tok == token::TOL_DERIV || tok == token::TOL_SV || tok == token::CHECKS_VIA_SUBSETS || tok == token::MAX_DIM_SUBSETS_GROUPS || tok == token::MAX_NROWS || tok == token::SQUEEZE_SHOCK_DECOMPOSITION || tok == token::WITH_EPILOGUE || tok == 59 || tok == 40 || tok == 41 || tok == 91 || tok == 93 || tok == 35 || tok == 58 || tok == 46); 1562 } 1563 #endif 1564 #if 201103L <= YY_CPLUSPLUS symbol_typeDynare::parser::symbol_type1565 symbol_type (int tok, string v, location_type l) 1566 : super_type(token_type (tok), std::move (v), std::move (l)) 1567 { 1568 YYASSERT (tok == token::FALSE || tok == token::FLOAT_NUMBER || tok == token::DATES || tok == token::INT_NUMBER || tok == token::NAME || tok == token::QUOTED_STRING || tok == token::TEX_NAME || tok == token::TRUE || tok == token::ALPHA || tok == token::BETA || tok == token::ABAND || tok == token::NINV || tok == token::CMS || tok == token::NCMS || tok == token::CNUM || tok == token::GAMMA || tok == token::INV_GAMMA || tok == token::INV_GAMMA1 || tok == token::INV_GAMMA2 || tok == token::NORMAL || tok == token::UNIFORM || tok == token::EPS || tok == token::PDF || tok == token::FIG || tok == token::DR || tok == token::NONE || tok == token::PRIOR || tok == token::PRIOR_VARIANCE || tok == token::HESSIAN || tok == token::IDENTITY_MATRIX || tok == token::DIRICHLET || tok == token::DIAGONAL || tok == token::OPTIMAL); 1569 } 1570 #else symbol_typeDynare::parser::symbol_type1571 symbol_type (int tok, const string& v, const location_type& l) 1572 : super_type(token_type (tok), v, l) 1573 { 1574 YYASSERT (tok == token::FALSE || tok == token::FLOAT_NUMBER || tok == token::DATES || tok == token::INT_NUMBER || tok == token::NAME || tok == token::QUOTED_STRING || tok == token::TEX_NAME || tok == token::TRUE || tok == token::ALPHA || tok == token::BETA || tok == token::ABAND || tok == token::NINV || tok == token::CMS || tok == token::NCMS || tok == token::CNUM || tok == token::GAMMA || tok == token::INV_GAMMA || tok == token::INV_GAMMA1 || tok == token::INV_GAMMA2 || tok == token::NORMAL || tok == token::UNIFORM || tok == token::EPS || tok == token::PDF || tok == token::FIG || tok == token::DR || tok == token::NONE || tok == token::PRIOR || tok == token::PRIOR_VARIANCE || tok == token::HESSIAN || tok == token::IDENTITY_MATRIX || tok == token::DIRICHLET || tok == token::DIAGONAL || tok == token::OPTIMAL); 1575 } 1576 #endif 1577 #if 201103L <= YY_CPLUSPLUS symbol_typeDynare::parser::symbol_type1578 symbol_type (int tok, vector<string> v, location_type l) 1579 : super_type(token_type (tok), std::move (v), std::move (l)) 1580 { 1581 YYASSERT (tok == token::SYMBOL_VEC); 1582 } 1583 #else symbol_typeDynare::parser::symbol_type1584 symbol_type (int tok, const vector<string>& v, const location_type& l) 1585 : super_type(token_type (tok), v, l) 1586 { 1587 YYASSERT (tok == token::SYMBOL_VEC); 1588 } 1589 #endif 1590 }; 1591 1592 /// Build a parser object. 1593 parser (ParsingDriver &driver_yyarg); 1594 virtual ~parser (); 1595 1596 /// Parse. An alias for parse (). 1597 /// \returns 0 iff parsing succeeded. 1598 int operator() (); 1599 1600 /// Parse. 1601 /// \returns 0 iff parsing succeeded. 1602 virtual int parse (); 1603 1604 #if YYDEBUG 1605 /// The current debugging stream. 1606 std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; 1607 /// Set the current debugging stream. 1608 void set_debug_stream (std::ostream &); 1609 1610 /// Type for debugging levels. 1611 typedef int debug_level_type; 1612 /// The current debugging level. 1613 debug_level_type debug_level () const YY_ATTRIBUTE_PURE; 1614 /// Set the current debugging level. 1615 void set_debug_level (debug_level_type l); 1616 #endif 1617 1618 /// Report a syntax error. 1619 /// \param loc where the syntax error is found. 1620 /// \param msg a description of the syntax error. 1621 virtual void error (const location_type& loc, const std::string& msg); 1622 1623 /// Report a syntax error. 1624 void error (const syntax_error& err); 1625 1626 // Implementation of make_symbol for each symbol type. 1627 #if 201103L <= YY_CPLUSPLUS 1628 static 1629 symbol_type make_AIM_SOLVER(location_type l)1630 make_AIM_SOLVER (location_type l) 1631 { 1632 return symbol_type (token::AIM_SOLVER, std::move (l)); 1633 } 1634 #else 1635 static 1636 symbol_type make_AIM_SOLVER(const location_type & l)1637 make_AIM_SOLVER (const location_type& l) 1638 { 1639 return symbol_type (token::AIM_SOLVER, l); 1640 } 1641 #endif 1642 #if 201103L <= YY_CPLUSPLUS 1643 static 1644 symbol_type make_ANALYTIC_DERIVATION(location_type l)1645 make_ANALYTIC_DERIVATION (location_type l) 1646 { 1647 return symbol_type (token::ANALYTIC_DERIVATION, std::move (l)); 1648 } 1649 #else 1650 static 1651 symbol_type make_ANALYTIC_DERIVATION(const location_type & l)1652 make_ANALYTIC_DERIVATION (const location_type& l) 1653 { 1654 return symbol_type (token::ANALYTIC_DERIVATION, l); 1655 } 1656 #endif 1657 #if 201103L <= YY_CPLUSPLUS 1658 static 1659 symbol_type make_ANALYTIC_DERIVATION_MODE(location_type l)1660 make_ANALYTIC_DERIVATION_MODE (location_type l) 1661 { 1662 return symbol_type (token::ANALYTIC_DERIVATION_MODE, std::move (l)); 1663 } 1664 #else 1665 static 1666 symbol_type make_ANALYTIC_DERIVATION_MODE(const location_type & l)1667 make_ANALYTIC_DERIVATION_MODE (const location_type& l) 1668 { 1669 return symbol_type (token::ANALYTIC_DERIVATION_MODE, l); 1670 } 1671 #endif 1672 #if 201103L <= YY_CPLUSPLUS 1673 static 1674 symbol_type make_AR(location_type l)1675 make_AR (location_type l) 1676 { 1677 return symbol_type (token::AR, std::move (l)); 1678 } 1679 #else 1680 static 1681 symbol_type make_AR(const location_type & l)1682 make_AR (const location_type& l) 1683 { 1684 return symbol_type (token::AR, l); 1685 } 1686 #endif 1687 #if 201103L <= YY_CPLUSPLUS 1688 static 1689 symbol_type make_POSTERIOR_SAMPLING_METHOD(location_type l)1690 make_POSTERIOR_SAMPLING_METHOD (location_type l) 1691 { 1692 return symbol_type (token::POSTERIOR_SAMPLING_METHOD, std::move (l)); 1693 } 1694 #else 1695 static 1696 symbol_type make_POSTERIOR_SAMPLING_METHOD(const location_type & l)1697 make_POSTERIOR_SAMPLING_METHOD (const location_type& l) 1698 { 1699 return symbol_type (token::POSTERIOR_SAMPLING_METHOD, l); 1700 } 1701 #endif 1702 #if 201103L <= YY_CPLUSPLUS 1703 static 1704 symbol_type make_BALANCED_GROWTH_TEST_TOL(location_type l)1705 make_BALANCED_GROWTH_TEST_TOL (location_type l) 1706 { 1707 return symbol_type (token::BALANCED_GROWTH_TEST_TOL, std::move (l)); 1708 } 1709 #else 1710 static 1711 symbol_type make_BALANCED_GROWTH_TEST_TOL(const location_type & l)1712 make_BALANCED_GROWTH_TEST_TOL (const location_type& l) 1713 { 1714 return symbol_type (token::BALANCED_GROWTH_TEST_TOL, l); 1715 } 1716 #endif 1717 #if 201103L <= YY_CPLUSPLUS 1718 static 1719 symbol_type make_BAYESIAN_IRF(location_type l)1720 make_BAYESIAN_IRF (location_type l) 1721 { 1722 return symbol_type (token::BAYESIAN_IRF, std::move (l)); 1723 } 1724 #else 1725 static 1726 symbol_type make_BAYESIAN_IRF(const location_type & l)1727 make_BAYESIAN_IRF (const location_type& l) 1728 { 1729 return symbol_type (token::BAYESIAN_IRF, l); 1730 } 1731 #endif 1732 #if 201103L <= YY_CPLUSPLUS 1733 static 1734 symbol_type make_BETA_PDF(location_type l)1735 make_BETA_PDF (location_type l) 1736 { 1737 return symbol_type (token::BETA_PDF, std::move (l)); 1738 } 1739 #else 1740 static 1741 symbol_type make_BETA_PDF(const location_type & l)1742 make_BETA_PDF (const location_type& l) 1743 { 1744 return symbol_type (token::BETA_PDF, l); 1745 } 1746 #endif 1747 #if 201103L <= YY_CPLUSPLUS 1748 static 1749 symbol_type make_BLOCK(location_type l)1750 make_BLOCK (location_type l) 1751 { 1752 return symbol_type (token::BLOCK, std::move (l)); 1753 } 1754 #else 1755 static 1756 symbol_type make_BLOCK(const location_type & l)1757 make_BLOCK (const location_type& l) 1758 { 1759 return symbol_type (token::BLOCK, l); 1760 } 1761 #endif 1762 #if 201103L <= YY_CPLUSPLUS 1763 static 1764 symbol_type make_USE_CALIBRATION(location_type l)1765 make_USE_CALIBRATION (location_type l) 1766 { 1767 return symbol_type (token::USE_CALIBRATION, std::move (l)); 1768 } 1769 #else 1770 static 1771 symbol_type make_USE_CALIBRATION(const location_type & l)1772 make_USE_CALIBRATION (const location_type& l) 1773 { 1774 return symbol_type (token::USE_CALIBRATION, l); 1775 } 1776 #endif 1777 #if 201103L <= YY_CPLUSPLUS 1778 static 1779 symbol_type make_SILENT_OPTIMIZER(location_type l)1780 make_SILENT_OPTIMIZER (location_type l) 1781 { 1782 return symbol_type (token::SILENT_OPTIMIZER, std::move (l)); 1783 } 1784 #else 1785 static 1786 symbol_type make_SILENT_OPTIMIZER(const location_type & l)1787 make_SILENT_OPTIMIZER (const location_type& l) 1788 { 1789 return symbol_type (token::SILENT_OPTIMIZER, l); 1790 } 1791 #endif 1792 #if 201103L <= YY_CPLUSPLUS 1793 static 1794 symbol_type make_BVAR_DENSITY(location_type l)1795 make_BVAR_DENSITY (location_type l) 1796 { 1797 return symbol_type (token::BVAR_DENSITY, std::move (l)); 1798 } 1799 #else 1800 static 1801 symbol_type make_BVAR_DENSITY(const location_type & l)1802 make_BVAR_DENSITY (const location_type& l) 1803 { 1804 return symbol_type (token::BVAR_DENSITY, l); 1805 } 1806 #endif 1807 #if 201103L <= YY_CPLUSPLUS 1808 static 1809 symbol_type make_BVAR_FORECAST(location_type l)1810 make_BVAR_FORECAST (location_type l) 1811 { 1812 return symbol_type (token::BVAR_FORECAST, std::move (l)); 1813 } 1814 #else 1815 static 1816 symbol_type make_BVAR_FORECAST(const location_type & l)1817 make_BVAR_FORECAST (const location_type& l) 1818 { 1819 return symbol_type (token::BVAR_FORECAST, l); 1820 } 1821 #endif 1822 #if 201103L <= YY_CPLUSPLUS 1823 static 1824 symbol_type make_NODECOMPOSITION(location_type l)1825 make_NODECOMPOSITION (location_type l) 1826 { 1827 return symbol_type (token::NODECOMPOSITION, std::move (l)); 1828 } 1829 #else 1830 static 1831 symbol_type make_NODECOMPOSITION(const location_type & l)1832 make_NODECOMPOSITION (const location_type& l) 1833 { 1834 return symbol_type (token::NODECOMPOSITION, l); 1835 } 1836 #endif 1837 #if 201103L <= YY_CPLUSPLUS 1838 static 1839 symbol_type make_DR_DISPLAY_TOL(location_type l)1840 make_DR_DISPLAY_TOL (location_type l) 1841 { 1842 return symbol_type (token::DR_DISPLAY_TOL, std::move (l)); 1843 } 1844 #else 1845 static 1846 symbol_type make_DR_DISPLAY_TOL(const location_type & l)1847 make_DR_DISPLAY_TOL (const location_type& l) 1848 { 1849 return symbol_type (token::DR_DISPLAY_TOL, l); 1850 } 1851 #endif 1852 #if 201103L <= YY_CPLUSPLUS 1853 static 1854 symbol_type make_HUGE_NUMBER(location_type l)1855 make_HUGE_NUMBER (location_type l) 1856 { 1857 return symbol_type (token::HUGE_NUMBER, std::move (l)); 1858 } 1859 #else 1860 static 1861 symbol_type make_HUGE_NUMBER(const location_type & l)1862 make_HUGE_NUMBER (const location_type& l) 1863 { 1864 return symbol_type (token::HUGE_NUMBER, l); 1865 } 1866 #endif 1867 #if 201103L <= YY_CPLUSPLUS 1868 static 1869 symbol_type make_FIG_NAME(location_type l)1870 make_FIG_NAME (location_type l) 1871 { 1872 return symbol_type (token::FIG_NAME, std::move (l)); 1873 } 1874 #else 1875 static 1876 symbol_type make_FIG_NAME(const location_type & l)1877 make_FIG_NAME (const location_type& l) 1878 { 1879 return symbol_type (token::FIG_NAME, l); 1880 } 1881 #endif 1882 #if 201103L <= YY_CPLUSPLUS 1883 static 1884 symbol_type make_WRITE_XLS(location_type l)1885 make_WRITE_XLS (location_type l) 1886 { 1887 return symbol_type (token::WRITE_XLS, std::move (l)); 1888 } 1889 #else 1890 static 1891 symbol_type make_WRITE_XLS(const location_type & l)1892 make_WRITE_XLS (const location_type& l) 1893 { 1894 return symbol_type (token::WRITE_XLS, l); 1895 } 1896 #endif 1897 #if 201103L <= YY_CPLUSPLUS 1898 static 1899 symbol_type make_BVAR_PRIOR_DECAY(location_type l)1900 make_BVAR_PRIOR_DECAY (location_type l) 1901 { 1902 return symbol_type (token::BVAR_PRIOR_DECAY, std::move (l)); 1903 } 1904 #else 1905 static 1906 symbol_type make_BVAR_PRIOR_DECAY(const location_type & l)1907 make_BVAR_PRIOR_DECAY (const location_type& l) 1908 { 1909 return symbol_type (token::BVAR_PRIOR_DECAY, l); 1910 } 1911 #endif 1912 #if 201103L <= YY_CPLUSPLUS 1913 static 1914 symbol_type make_BVAR_PRIOR_FLAT(location_type l)1915 make_BVAR_PRIOR_FLAT (location_type l) 1916 { 1917 return symbol_type (token::BVAR_PRIOR_FLAT, std::move (l)); 1918 } 1919 #else 1920 static 1921 symbol_type make_BVAR_PRIOR_FLAT(const location_type & l)1922 make_BVAR_PRIOR_FLAT (const location_type& l) 1923 { 1924 return symbol_type (token::BVAR_PRIOR_FLAT, l); 1925 } 1926 #endif 1927 #if 201103L <= YY_CPLUSPLUS 1928 static 1929 symbol_type make_BVAR_PRIOR_LAMBDA(location_type l)1930 make_BVAR_PRIOR_LAMBDA (location_type l) 1931 { 1932 return symbol_type (token::BVAR_PRIOR_LAMBDA, std::move (l)); 1933 } 1934 #else 1935 static 1936 symbol_type make_BVAR_PRIOR_LAMBDA(const location_type & l)1937 make_BVAR_PRIOR_LAMBDA (const location_type& l) 1938 { 1939 return symbol_type (token::BVAR_PRIOR_LAMBDA, l); 1940 } 1941 #endif 1942 #if 201103L <= YY_CPLUSPLUS 1943 static 1944 symbol_type make_INTERACTIVE(location_type l)1945 make_INTERACTIVE (location_type l) 1946 { 1947 return symbol_type (token::INTERACTIVE, std::move (l)); 1948 } 1949 #else 1950 static 1951 symbol_type make_INTERACTIVE(const location_type & l)1952 make_INTERACTIVE (const location_type& l) 1953 { 1954 return symbol_type (token::INTERACTIVE, l); 1955 } 1956 #endif 1957 #if 201103L <= YY_CPLUSPLUS 1958 static 1959 symbol_type make_SCREEN_SHOCKS(location_type l)1960 make_SCREEN_SHOCKS (location_type l) 1961 { 1962 return symbol_type (token::SCREEN_SHOCKS, std::move (l)); 1963 } 1964 #else 1965 static 1966 symbol_type make_SCREEN_SHOCKS(const location_type & l)1967 make_SCREEN_SHOCKS (const location_type& l) 1968 { 1969 return symbol_type (token::SCREEN_SHOCKS, l); 1970 } 1971 #endif 1972 #if 201103L <= YY_CPLUSPLUS 1973 static 1974 symbol_type make_STEADYSTATE(location_type l)1975 make_STEADYSTATE (location_type l) 1976 { 1977 return symbol_type (token::STEADYSTATE, std::move (l)); 1978 } 1979 #else 1980 static 1981 symbol_type make_STEADYSTATE(const location_type & l)1982 make_STEADYSTATE (const location_type& l) 1983 { 1984 return symbol_type (token::STEADYSTATE, l); 1985 } 1986 #endif 1987 #if 201103L <= YY_CPLUSPLUS 1988 static 1989 symbol_type make_BVAR_PRIOR_MU(location_type l)1990 make_BVAR_PRIOR_MU (location_type l) 1991 { 1992 return symbol_type (token::BVAR_PRIOR_MU, std::move (l)); 1993 } 1994 #else 1995 static 1996 symbol_type make_BVAR_PRIOR_MU(const location_type & l)1997 make_BVAR_PRIOR_MU (const location_type& l) 1998 { 1999 return symbol_type (token::BVAR_PRIOR_MU, l); 2000 } 2001 #endif 2002 #if 201103L <= YY_CPLUSPLUS 2003 static 2004 symbol_type make_BVAR_PRIOR_OMEGA(location_type l)2005 make_BVAR_PRIOR_OMEGA (location_type l) 2006 { 2007 return symbol_type (token::BVAR_PRIOR_OMEGA, std::move (l)); 2008 } 2009 #else 2010 static 2011 symbol_type make_BVAR_PRIOR_OMEGA(const location_type & l)2012 make_BVAR_PRIOR_OMEGA (const location_type& l) 2013 { 2014 return symbol_type (token::BVAR_PRIOR_OMEGA, l); 2015 } 2016 #endif 2017 #if 201103L <= YY_CPLUSPLUS 2018 static 2019 symbol_type make_BVAR_PRIOR_TAU(location_type l)2020 make_BVAR_PRIOR_TAU (location_type l) 2021 { 2022 return symbol_type (token::BVAR_PRIOR_TAU, std::move (l)); 2023 } 2024 #else 2025 static 2026 symbol_type make_BVAR_PRIOR_TAU(const location_type & l)2027 make_BVAR_PRIOR_TAU (const location_type& l) 2028 { 2029 return symbol_type (token::BVAR_PRIOR_TAU, l); 2030 } 2031 #endif 2032 #if 201103L <= YY_CPLUSPLUS 2033 static 2034 symbol_type make_BVAR_PRIOR_TRAIN(location_type l)2035 make_BVAR_PRIOR_TRAIN (location_type l) 2036 { 2037 return symbol_type (token::BVAR_PRIOR_TRAIN, std::move (l)); 2038 } 2039 #else 2040 static 2041 symbol_type make_BVAR_PRIOR_TRAIN(const location_type & l)2042 make_BVAR_PRIOR_TRAIN (const location_type& l) 2043 { 2044 return symbol_type (token::BVAR_PRIOR_TRAIN, l); 2045 } 2046 #endif 2047 #if 201103L <= YY_CPLUSPLUS 2048 static 2049 symbol_type make_DETAIL_PLOT(location_type l)2050 make_DETAIL_PLOT (location_type l) 2051 { 2052 return symbol_type (token::DETAIL_PLOT, std::move (l)); 2053 } 2054 #else 2055 static 2056 symbol_type make_DETAIL_PLOT(const location_type & l)2057 make_DETAIL_PLOT (const location_type& l) 2058 { 2059 return symbol_type (token::DETAIL_PLOT, l); 2060 } 2061 #endif 2062 #if 201103L <= YY_CPLUSPLUS 2063 static 2064 symbol_type make_TYPE(location_type l)2065 make_TYPE (location_type l) 2066 { 2067 return symbol_type (token::TYPE, std::move (l)); 2068 } 2069 #else 2070 static 2071 symbol_type make_TYPE(const location_type & l)2072 make_TYPE (const location_type& l) 2073 { 2074 return symbol_type (token::TYPE, l); 2075 } 2076 #endif 2077 #if 201103L <= YY_CPLUSPLUS 2078 static 2079 symbol_type make_BVAR_REPLIC(location_type l)2080 make_BVAR_REPLIC (location_type l) 2081 { 2082 return symbol_type (token::BVAR_REPLIC, std::move (l)); 2083 } 2084 #else 2085 static 2086 symbol_type make_BVAR_REPLIC(const location_type & l)2087 make_BVAR_REPLIC (const location_type& l) 2088 { 2089 return symbol_type (token::BVAR_REPLIC, l); 2090 } 2091 #endif 2092 #if 201103L <= YY_CPLUSPLUS 2093 static 2094 symbol_type make_BYTECODE(location_type l)2095 make_BYTECODE (location_type l) 2096 { 2097 return symbol_type (token::BYTECODE, std::move (l)); 2098 } 2099 #else 2100 static 2101 symbol_type make_BYTECODE(const location_type & l)2102 make_BYTECODE (const location_type& l) 2103 { 2104 return symbol_type (token::BYTECODE, l); 2105 } 2106 #endif 2107 #if 201103L <= YY_CPLUSPLUS 2108 static 2109 symbol_type make_ALL_VALUES_REQUIRED(location_type l)2110 make_ALL_VALUES_REQUIRED (location_type l) 2111 { 2112 return symbol_type (token::ALL_VALUES_REQUIRED, std::move (l)); 2113 } 2114 #else 2115 static 2116 symbol_type make_ALL_VALUES_REQUIRED(const location_type & l)2117 make_ALL_VALUES_REQUIRED (const location_type& l) 2118 { 2119 return symbol_type (token::ALL_VALUES_REQUIRED, l); 2120 } 2121 #endif 2122 #if 201103L <= YY_CPLUSPLUS 2123 static 2124 symbol_type make_PROPOSAL_DISTRIBUTION(location_type l)2125 make_PROPOSAL_DISTRIBUTION (location_type l) 2126 { 2127 return symbol_type (token::PROPOSAL_DISTRIBUTION, std::move (l)); 2128 } 2129 #else 2130 static 2131 symbol_type make_PROPOSAL_DISTRIBUTION(const location_type & l)2132 make_PROPOSAL_DISTRIBUTION (const location_type& l) 2133 { 2134 return symbol_type (token::PROPOSAL_DISTRIBUTION, l); 2135 } 2136 #endif 2137 #if 201103L <= YY_CPLUSPLUS 2138 static 2139 symbol_type make_REALTIME(location_type l)2140 make_REALTIME (location_type l) 2141 { 2142 return symbol_type (token::REALTIME, std::move (l)); 2143 } 2144 #else 2145 static 2146 symbol_type make_REALTIME(const location_type & l)2147 make_REALTIME (const location_type& l) 2148 { 2149 return symbol_type (token::REALTIME, l); 2150 } 2151 #endif 2152 #if 201103L <= YY_CPLUSPLUS 2153 static 2154 symbol_type make_VINTAGE(location_type l)2155 make_VINTAGE (location_type l) 2156 { 2157 return symbol_type (token::VINTAGE, std::move (l)); 2158 } 2159 #else 2160 static 2161 symbol_type make_VINTAGE(const location_type & l)2162 make_VINTAGE (const location_type& l) 2163 { 2164 return symbol_type (token::VINTAGE, l); 2165 } 2166 #endif 2167 #if 201103L <= YY_CPLUSPLUS 2168 static 2169 symbol_type make_CALIB_SMOOTHER(location_type l)2170 make_CALIB_SMOOTHER (location_type l) 2171 { 2172 return symbol_type (token::CALIB_SMOOTHER, std::move (l)); 2173 } 2174 #else 2175 static 2176 symbol_type make_CALIB_SMOOTHER(const location_type & l)2177 make_CALIB_SMOOTHER (const location_type& l) 2178 { 2179 return symbol_type (token::CALIB_SMOOTHER, l); 2180 } 2181 #endif 2182 #if 201103L <= YY_CPLUSPLUS 2183 static 2184 symbol_type make_CHANGE_TYPE(location_type l)2185 make_CHANGE_TYPE (location_type l) 2186 { 2187 return symbol_type (token::CHANGE_TYPE, std::move (l)); 2188 } 2189 #else 2190 static 2191 symbol_type make_CHANGE_TYPE(const location_type & l)2192 make_CHANGE_TYPE (const location_type& l) 2193 { 2194 return symbol_type (token::CHANGE_TYPE, l); 2195 } 2196 #endif 2197 #if 201103L <= YY_CPLUSPLUS 2198 static 2199 symbol_type make_CHECK(location_type l)2200 make_CHECK (location_type l) 2201 { 2202 return symbol_type (token::CHECK, std::move (l)); 2203 } 2204 #else 2205 static 2206 symbol_type make_CHECK(const location_type & l)2207 make_CHECK (const location_type& l) 2208 { 2209 return symbol_type (token::CHECK, l); 2210 } 2211 #endif 2212 #if 201103L <= YY_CPLUSPLUS 2213 static 2214 symbol_type make_CONDITIONAL_FORECAST(location_type l)2215 make_CONDITIONAL_FORECAST (location_type l) 2216 { 2217 return symbol_type (token::CONDITIONAL_FORECAST, std::move (l)); 2218 } 2219 #else 2220 static 2221 symbol_type make_CONDITIONAL_FORECAST(const location_type & l)2222 make_CONDITIONAL_FORECAST (const location_type& l) 2223 { 2224 return symbol_type (token::CONDITIONAL_FORECAST, l); 2225 } 2226 #endif 2227 #if 201103L <= YY_CPLUSPLUS 2228 static 2229 symbol_type make_CONDITIONAL_FORECAST_PATHS(location_type l)2230 make_CONDITIONAL_FORECAST_PATHS (location_type l) 2231 { 2232 return symbol_type (token::CONDITIONAL_FORECAST_PATHS, std::move (l)); 2233 } 2234 #else 2235 static 2236 symbol_type make_CONDITIONAL_FORECAST_PATHS(const location_type & l)2237 make_CONDITIONAL_FORECAST_PATHS (const location_type& l) 2238 { 2239 return symbol_type (token::CONDITIONAL_FORECAST_PATHS, l); 2240 } 2241 #endif 2242 #if 201103L <= YY_CPLUSPLUS 2243 static 2244 symbol_type make_CONF_SIG(location_type l)2245 make_CONF_SIG (location_type l) 2246 { 2247 return symbol_type (token::CONF_SIG, std::move (l)); 2248 } 2249 #else 2250 static 2251 symbol_type make_CONF_SIG(const location_type & l)2252 make_CONF_SIG (const location_type& l) 2253 { 2254 return symbol_type (token::CONF_SIG, l); 2255 } 2256 #endif 2257 #if 201103L <= YY_CPLUSPLUS 2258 static 2259 symbol_type make_CONSTANT(location_type l)2260 make_CONSTANT (location_type l) 2261 { 2262 return symbol_type (token::CONSTANT, std::move (l)); 2263 } 2264 #else 2265 static 2266 symbol_type make_CONSTANT(const location_type & l)2267 make_CONSTANT (const location_type& l) 2268 { 2269 return symbol_type (token::CONSTANT, l); 2270 } 2271 #endif 2272 #if 201103L <= YY_CPLUSPLUS 2273 static 2274 symbol_type make_CONTROLLED_VAREXO(location_type l)2275 make_CONTROLLED_VAREXO (location_type l) 2276 { 2277 return symbol_type (token::CONTROLLED_VAREXO, std::move (l)); 2278 } 2279 #else 2280 static 2281 symbol_type make_CONTROLLED_VAREXO(const location_type & l)2282 make_CONTROLLED_VAREXO (const location_type& l) 2283 { 2284 return symbol_type (token::CONTROLLED_VAREXO, l); 2285 } 2286 #endif 2287 #if 201103L <= YY_CPLUSPLUS 2288 static 2289 symbol_type make_CORR(location_type l)2290 make_CORR (location_type l) 2291 { 2292 return symbol_type (token::CORR, std::move (l)); 2293 } 2294 #else 2295 static 2296 symbol_type make_CORR(const location_type & l)2297 make_CORR (const location_type& l) 2298 { 2299 return symbol_type (token::CORR, l); 2300 } 2301 #endif 2302 #if 201103L <= YY_CPLUSPLUS 2303 static 2304 symbol_type make_CUTOFF(location_type l)2305 make_CUTOFF (location_type l) 2306 { 2307 return symbol_type (token::CUTOFF, std::move (l)); 2308 } 2309 #else 2310 static 2311 symbol_type make_CUTOFF(const location_type & l)2312 make_CUTOFF (const location_type& l) 2313 { 2314 return symbol_type (token::CUTOFF, l); 2315 } 2316 #endif 2317 #if 201103L <= YY_CPLUSPLUS 2318 static 2319 symbol_type make_CYCLE_REDUCTION(location_type l)2320 make_CYCLE_REDUCTION (location_type l) 2321 { 2322 return symbol_type (token::CYCLE_REDUCTION, std::move (l)); 2323 } 2324 #else 2325 static 2326 symbol_type make_CYCLE_REDUCTION(const location_type & l)2327 make_CYCLE_REDUCTION (const location_type& l) 2328 { 2329 return symbol_type (token::CYCLE_REDUCTION, l); 2330 } 2331 #endif 2332 #if 201103L <= YY_CPLUSPLUS 2333 static 2334 symbol_type make_LOGARITHMIC_REDUCTION(location_type l)2335 make_LOGARITHMIC_REDUCTION (location_type l) 2336 { 2337 return symbol_type (token::LOGARITHMIC_REDUCTION, std::move (l)); 2338 } 2339 #else 2340 static 2341 symbol_type make_LOGARITHMIC_REDUCTION(const location_type & l)2342 make_LOGARITHMIC_REDUCTION (const location_type& l) 2343 { 2344 return symbol_type (token::LOGARITHMIC_REDUCTION, l); 2345 } 2346 #endif 2347 #if 201103L <= YY_CPLUSPLUS 2348 static 2349 symbol_type make_COMMA(location_type l)2350 make_COMMA (location_type l) 2351 { 2352 return symbol_type (token::COMMA, std::move (l)); 2353 } 2354 #else 2355 static 2356 symbol_type make_COMMA(const location_type & l)2357 make_COMMA (const location_type& l) 2358 { 2359 return symbol_type (token::COMMA, l); 2360 } 2361 #endif 2362 #if 201103L <= YY_CPLUSPLUS 2363 static 2364 symbol_type make_CONSIDER_ALL_ENDOGENOUS(location_type l)2365 make_CONSIDER_ALL_ENDOGENOUS (location_type l) 2366 { 2367 return symbol_type (token::CONSIDER_ALL_ENDOGENOUS, std::move (l)); 2368 } 2369 #else 2370 static 2371 symbol_type make_CONSIDER_ALL_ENDOGENOUS(const location_type & l)2372 make_CONSIDER_ALL_ENDOGENOUS (const location_type& l) 2373 { 2374 return symbol_type (token::CONSIDER_ALL_ENDOGENOUS, l); 2375 } 2376 #endif 2377 #if 201103L <= YY_CPLUSPLUS 2378 static 2379 symbol_type make_CONSIDER_ONLY_OBSERVED(location_type l)2380 make_CONSIDER_ONLY_OBSERVED (location_type l) 2381 { 2382 return symbol_type (token::CONSIDER_ONLY_OBSERVED, std::move (l)); 2383 } 2384 #else 2385 static 2386 symbol_type make_CONSIDER_ONLY_OBSERVED(const location_type & l)2387 make_CONSIDER_ONLY_OBSERVED (const location_type& l) 2388 { 2389 return symbol_type (token::CONSIDER_ONLY_OBSERVED, l); 2390 } 2391 #endif 2392 #if 201103L <= YY_CPLUSPLUS 2393 static 2394 symbol_type make_INITIAL_CONDITION_DECOMPOSITION(location_type l)2395 make_INITIAL_CONDITION_DECOMPOSITION (location_type l) 2396 { 2397 return symbol_type (token::INITIAL_CONDITION_DECOMPOSITION, std::move (l)); 2398 } 2399 #else 2400 static 2401 symbol_type make_INITIAL_CONDITION_DECOMPOSITION(const location_type & l)2402 make_INITIAL_CONDITION_DECOMPOSITION (const location_type& l) 2403 { 2404 return symbol_type (token::INITIAL_CONDITION_DECOMPOSITION, l); 2405 } 2406 #endif 2407 #if 201103L <= YY_CPLUSPLUS 2408 static 2409 symbol_type make_DATAFILE(location_type l)2410 make_DATAFILE (location_type l) 2411 { 2412 return symbol_type (token::DATAFILE, std::move (l)); 2413 } 2414 #else 2415 static 2416 symbol_type make_DATAFILE(const location_type & l)2417 make_DATAFILE (const location_type& l) 2418 { 2419 return symbol_type (token::DATAFILE, l); 2420 } 2421 #endif 2422 #if 201103L <= YY_CPLUSPLUS 2423 static 2424 symbol_type make_FILE(location_type l)2425 make_FILE (location_type l) 2426 { 2427 return symbol_type (token::FILE, std::move (l)); 2428 } 2429 #else 2430 static 2431 symbol_type make_FILE(const location_type & l)2432 make_FILE (const location_type& l) 2433 { 2434 return symbol_type (token::FILE, l); 2435 } 2436 #endif 2437 #if 201103L <= YY_CPLUSPLUS 2438 static 2439 symbol_type make_SERIES(location_type l)2440 make_SERIES (location_type l) 2441 { 2442 return symbol_type (token::SERIES, std::move (l)); 2443 } 2444 #else 2445 static 2446 symbol_type make_SERIES(const location_type & l)2447 make_SERIES (const location_type& l) 2448 { 2449 return symbol_type (token::SERIES, l); 2450 } 2451 #endif 2452 #if 201103L <= YY_CPLUSPLUS 2453 static 2454 symbol_type make_DOUBLING(location_type l)2455 make_DOUBLING (location_type l) 2456 { 2457 return symbol_type (token::DOUBLING, std::move (l)); 2458 } 2459 #else 2460 static 2461 symbol_type make_DOUBLING(const location_type & l)2462 make_DOUBLING (const location_type& l) 2463 { 2464 return symbol_type (token::DOUBLING, l); 2465 } 2466 #endif 2467 #if 201103L <= YY_CPLUSPLUS 2468 static 2469 symbol_type make_DR_CYCLE_REDUCTION_TOL(location_type l)2470 make_DR_CYCLE_REDUCTION_TOL (location_type l) 2471 { 2472 return symbol_type (token::DR_CYCLE_REDUCTION_TOL, std::move (l)); 2473 } 2474 #else 2475 static 2476 symbol_type make_DR_CYCLE_REDUCTION_TOL(const location_type & l)2477 make_DR_CYCLE_REDUCTION_TOL (const location_type& l) 2478 { 2479 return symbol_type (token::DR_CYCLE_REDUCTION_TOL, l); 2480 } 2481 #endif 2482 #if 201103L <= YY_CPLUSPLUS 2483 static 2484 symbol_type make_DR_LOGARITHMIC_REDUCTION_TOL(location_type l)2485 make_DR_LOGARITHMIC_REDUCTION_TOL (location_type l) 2486 { 2487 return symbol_type (token::DR_LOGARITHMIC_REDUCTION_TOL, std::move (l)); 2488 } 2489 #else 2490 static 2491 symbol_type make_DR_LOGARITHMIC_REDUCTION_TOL(const location_type & l)2492 make_DR_LOGARITHMIC_REDUCTION_TOL (const location_type& l) 2493 { 2494 return symbol_type (token::DR_LOGARITHMIC_REDUCTION_TOL, l); 2495 } 2496 #endif 2497 #if 201103L <= YY_CPLUSPLUS 2498 static 2499 symbol_type make_DR_LOGARITHMIC_REDUCTION_MAXITER(location_type l)2500 make_DR_LOGARITHMIC_REDUCTION_MAXITER (location_type l) 2501 { 2502 return symbol_type (token::DR_LOGARITHMIC_REDUCTION_MAXITER, std::move (l)); 2503 } 2504 #else 2505 static 2506 symbol_type make_DR_LOGARITHMIC_REDUCTION_MAXITER(const location_type & l)2507 make_DR_LOGARITHMIC_REDUCTION_MAXITER (const location_type& l) 2508 { 2509 return symbol_type (token::DR_LOGARITHMIC_REDUCTION_MAXITER, l); 2510 } 2511 #endif 2512 #if 201103L <= YY_CPLUSPLUS 2513 static 2514 symbol_type make_DR_ALGO(location_type l)2515 make_DR_ALGO (location_type l) 2516 { 2517 return symbol_type (token::DR_ALGO, std::move (l)); 2518 } 2519 #else 2520 static 2521 symbol_type make_DR_ALGO(const location_type & l)2522 make_DR_ALGO (const location_type& l) 2523 { 2524 return symbol_type (token::DR_ALGO, l); 2525 } 2526 #endif 2527 #if 201103L <= YY_CPLUSPLUS 2528 static 2529 symbol_type make_DROP(location_type l)2530 make_DROP (location_type l) 2531 { 2532 return symbol_type (token::DROP, std::move (l)); 2533 } 2534 #else 2535 static 2536 symbol_type make_DROP(const location_type & l)2537 make_DROP (const location_type& l) 2538 { 2539 return symbol_type (token::DROP, l); 2540 } 2541 #endif 2542 #if 201103L <= YY_CPLUSPLUS 2543 static 2544 symbol_type make_DSAMPLE(location_type l)2545 make_DSAMPLE (location_type l) 2546 { 2547 return symbol_type (token::DSAMPLE, std::move (l)); 2548 } 2549 #else 2550 static 2551 symbol_type make_DSAMPLE(const location_type & l)2552 make_DSAMPLE (const location_type& l) 2553 { 2554 return symbol_type (token::DSAMPLE, l); 2555 } 2556 #endif 2557 #if 201103L <= YY_CPLUSPLUS 2558 static 2559 symbol_type make_DYNASAVE(location_type l)2560 make_DYNASAVE (location_type l) 2561 { 2562 return symbol_type (token::DYNASAVE, std::move (l)); 2563 } 2564 #else 2565 static 2566 symbol_type make_DYNASAVE(const location_type & l)2567 make_DYNASAVE (const location_type& l) 2568 { 2569 return symbol_type (token::DYNASAVE, l); 2570 } 2571 #endif 2572 #if 201103L <= YY_CPLUSPLUS 2573 static 2574 symbol_type make_DYNATYPE(location_type l)2575 make_DYNATYPE (location_type l) 2576 { 2577 return symbol_type (token::DYNATYPE, std::move (l)); 2578 } 2579 #else 2580 static 2581 symbol_type make_DYNATYPE(const location_type & l)2582 make_DYNATYPE (const location_type& l) 2583 { 2584 return symbol_type (token::DYNATYPE, l); 2585 } 2586 #endif 2587 #if 201103L <= YY_CPLUSPLUS 2588 static 2589 symbol_type make_CALIBRATION(location_type l)2590 make_CALIBRATION (location_type l) 2591 { 2592 return symbol_type (token::CALIBRATION, std::move (l)); 2593 } 2594 #else 2595 static 2596 symbol_type make_CALIBRATION(const location_type & l)2597 make_CALIBRATION (const location_type& l) 2598 { 2599 return symbol_type (token::CALIBRATION, l); 2600 } 2601 #endif 2602 #if 201103L <= YY_CPLUSPLUS 2603 static 2604 symbol_type make_DIFFERENTIATE_FORWARD_VARS(location_type l)2605 make_DIFFERENTIATE_FORWARD_VARS (location_type l) 2606 { 2607 return symbol_type (token::DIFFERENTIATE_FORWARD_VARS, std::move (l)); 2608 } 2609 #else 2610 static 2611 symbol_type make_DIFFERENTIATE_FORWARD_VARS(const location_type & l)2612 make_DIFFERENTIATE_FORWARD_VARS (const location_type& l) 2613 { 2614 return symbol_type (token::DIFFERENTIATE_FORWARD_VARS, l); 2615 } 2616 #endif 2617 #if 201103L <= YY_CPLUSPLUS 2618 static 2619 symbol_type make_END(location_type l)2620 make_END (location_type l) 2621 { 2622 return symbol_type (token::END, std::move (l)); 2623 } 2624 #else 2625 static 2626 symbol_type make_END(const location_type & l)2627 make_END (const location_type& l) 2628 { 2629 return symbol_type (token::END, l); 2630 } 2631 #endif 2632 #if 201103L <= YY_CPLUSPLUS 2633 static 2634 symbol_type make_ENDVAL(location_type l)2635 make_ENDVAL (location_type l) 2636 { 2637 return symbol_type (token::ENDVAL, std::move (l)); 2638 } 2639 #else 2640 static 2641 symbol_type make_ENDVAL(const location_type & l)2642 make_ENDVAL (const location_type& l) 2643 { 2644 return symbol_type (token::ENDVAL, l); 2645 } 2646 #endif 2647 #if 201103L <= YY_CPLUSPLUS 2648 static 2649 symbol_type make_EQUAL(location_type l)2650 make_EQUAL (location_type l) 2651 { 2652 return symbol_type (token::EQUAL, std::move (l)); 2653 } 2654 #else 2655 static 2656 symbol_type make_EQUAL(const location_type & l)2657 make_EQUAL (const location_type& l) 2658 { 2659 return symbol_type (token::EQUAL, l); 2660 } 2661 #endif 2662 #if 201103L <= YY_CPLUSPLUS 2663 static 2664 symbol_type make_ESTIMATION(location_type l)2665 make_ESTIMATION (location_type l) 2666 { 2667 return symbol_type (token::ESTIMATION, std::move (l)); 2668 } 2669 #else 2670 static 2671 symbol_type make_ESTIMATION(const location_type & l)2672 make_ESTIMATION (const location_type& l) 2673 { 2674 return symbol_type (token::ESTIMATION, l); 2675 } 2676 #endif 2677 #if 201103L <= YY_CPLUSPLUS 2678 static 2679 symbol_type make_ESTIMATED_PARAMS(location_type l)2680 make_ESTIMATED_PARAMS (location_type l) 2681 { 2682 return symbol_type (token::ESTIMATED_PARAMS, std::move (l)); 2683 } 2684 #else 2685 static 2686 symbol_type make_ESTIMATED_PARAMS(const location_type & l)2687 make_ESTIMATED_PARAMS (const location_type& l) 2688 { 2689 return symbol_type (token::ESTIMATED_PARAMS, l); 2690 } 2691 #endif 2692 #if 201103L <= YY_CPLUSPLUS 2693 static 2694 symbol_type make_ESTIMATED_PARAMS_BOUNDS(location_type l)2695 make_ESTIMATED_PARAMS_BOUNDS (location_type l) 2696 { 2697 return symbol_type (token::ESTIMATED_PARAMS_BOUNDS, std::move (l)); 2698 } 2699 #else 2700 static 2701 symbol_type make_ESTIMATED_PARAMS_BOUNDS(const location_type & l)2702 make_ESTIMATED_PARAMS_BOUNDS (const location_type& l) 2703 { 2704 return symbol_type (token::ESTIMATED_PARAMS_BOUNDS, l); 2705 } 2706 #endif 2707 #if 201103L <= YY_CPLUSPLUS 2708 static 2709 symbol_type make_ESTIMATED_PARAMS_INIT(location_type l)2710 make_ESTIMATED_PARAMS_INIT (location_type l) 2711 { 2712 return symbol_type (token::ESTIMATED_PARAMS_INIT, std::move (l)); 2713 } 2714 #else 2715 static 2716 symbol_type make_ESTIMATED_PARAMS_INIT(const location_type & l)2717 make_ESTIMATED_PARAMS_INIT (const location_type& l) 2718 { 2719 return symbol_type (token::ESTIMATED_PARAMS_INIT, l); 2720 } 2721 #endif 2722 #if 201103L <= YY_CPLUSPLUS 2723 static 2724 symbol_type make_EXTENDED_PATH(location_type l)2725 make_EXTENDED_PATH (location_type l) 2726 { 2727 return symbol_type (token::EXTENDED_PATH, std::move (l)); 2728 } 2729 #else 2730 static 2731 symbol_type make_EXTENDED_PATH(const location_type & l)2732 make_EXTENDED_PATH (const location_type& l) 2733 { 2734 return symbol_type (token::EXTENDED_PATH, l); 2735 } 2736 #endif 2737 #if 201103L <= YY_CPLUSPLUS 2738 static 2739 symbol_type make_ENDOGENOUS_PRIOR(location_type l)2740 make_ENDOGENOUS_PRIOR (location_type l) 2741 { 2742 return symbol_type (token::ENDOGENOUS_PRIOR, std::move (l)); 2743 } 2744 #else 2745 static 2746 symbol_type make_ENDOGENOUS_PRIOR(const location_type & l)2747 make_ENDOGENOUS_PRIOR (const location_type& l) 2748 { 2749 return symbol_type (token::ENDOGENOUS_PRIOR, l); 2750 } 2751 #endif 2752 #if 201103L <= YY_CPLUSPLUS 2753 static 2754 symbol_type make_EXPRESSION(location_type l)2755 make_EXPRESSION (location_type l) 2756 { 2757 return symbol_type (token::EXPRESSION, std::move (l)); 2758 } 2759 #else 2760 static 2761 symbol_type make_EXPRESSION(const location_type & l)2762 make_EXPRESSION (const location_type& l) 2763 { 2764 return symbol_type (token::EXPRESSION, l); 2765 } 2766 #endif 2767 #if 201103L <= YY_CPLUSPLUS 2768 static 2769 symbol_type make_FILENAME(location_type l)2770 make_FILENAME (location_type l) 2771 { 2772 return symbol_type (token::FILENAME, std::move (l)); 2773 } 2774 #else 2775 static 2776 symbol_type make_FILENAME(const location_type & l)2777 make_FILENAME (const location_type& l) 2778 { 2779 return symbol_type (token::FILENAME, l); 2780 } 2781 #endif 2782 #if 201103L <= YY_CPLUSPLUS 2783 static 2784 symbol_type make_DIRNAME(location_type l)2785 make_DIRNAME (location_type l) 2786 { 2787 return symbol_type (token::DIRNAME, std::move (l)); 2788 } 2789 #else 2790 static 2791 symbol_type make_DIRNAME(const location_type & l)2792 make_DIRNAME (const location_type& l) 2793 { 2794 return symbol_type (token::DIRNAME, l); 2795 } 2796 #endif 2797 #if 201103L <= YY_CPLUSPLUS 2798 static 2799 symbol_type make_FILTER_STEP_AHEAD(location_type l)2800 make_FILTER_STEP_AHEAD (location_type l) 2801 { 2802 return symbol_type (token::FILTER_STEP_AHEAD, std::move (l)); 2803 } 2804 #else 2805 static 2806 symbol_type make_FILTER_STEP_AHEAD(const location_type & l)2807 make_FILTER_STEP_AHEAD (const location_type& l) 2808 { 2809 return symbol_type (token::FILTER_STEP_AHEAD, l); 2810 } 2811 #endif 2812 #if 201103L <= YY_CPLUSPLUS 2813 static 2814 symbol_type make_FILTERED_VARS(location_type l)2815 make_FILTERED_VARS (location_type l) 2816 { 2817 return symbol_type (token::FILTERED_VARS, std::move (l)); 2818 } 2819 #else 2820 static 2821 symbol_type make_FILTERED_VARS(const location_type & l)2822 make_FILTERED_VARS (const location_type& l) 2823 { 2824 return symbol_type (token::FILTERED_VARS, l); 2825 } 2826 #endif 2827 #if 201103L <= YY_CPLUSPLUS 2828 static 2829 symbol_type make_FIRST_OBS(location_type l)2830 make_FIRST_OBS (location_type l) 2831 { 2832 return symbol_type (token::FIRST_OBS, std::move (l)); 2833 } 2834 #else 2835 static 2836 symbol_type make_FIRST_OBS(const location_type & l)2837 make_FIRST_OBS (const location_type& l) 2838 { 2839 return symbol_type (token::FIRST_OBS, l); 2840 } 2841 #endif 2842 #if 201103L <= YY_CPLUSPLUS 2843 static 2844 symbol_type make_LAST_OBS(location_type l)2845 make_LAST_OBS (location_type l) 2846 { 2847 return symbol_type (token::LAST_OBS, std::move (l)); 2848 } 2849 #else 2850 static 2851 symbol_type make_LAST_OBS(const location_type & l)2852 make_LAST_OBS (const location_type& l) 2853 { 2854 return symbol_type (token::LAST_OBS, l); 2855 } 2856 #endif 2857 #if 201103L <= YY_CPLUSPLUS 2858 static 2859 symbol_type make_SET_TIME(location_type l)2860 make_SET_TIME (location_type l) 2861 { 2862 return symbol_type (token::SET_TIME, std::move (l)); 2863 } 2864 #else 2865 static 2866 symbol_type make_SET_TIME(const location_type & l)2867 make_SET_TIME (const location_type& l) 2868 { 2869 return symbol_type (token::SET_TIME, l); 2870 } 2871 #endif 2872 #if 201103L <= YY_CPLUSPLUS 2873 static 2874 symbol_type make_OSR_PARAMS_BOUNDS(location_type l)2875 make_OSR_PARAMS_BOUNDS (location_type l) 2876 { 2877 return symbol_type (token::OSR_PARAMS_BOUNDS, std::move (l)); 2878 } 2879 #else 2880 static 2881 symbol_type make_OSR_PARAMS_BOUNDS(const location_type & l)2882 make_OSR_PARAMS_BOUNDS (const location_type& l) 2883 { 2884 return symbol_type (token::OSR_PARAMS_BOUNDS, l); 2885 } 2886 #endif 2887 #if 201103L <= YY_CPLUSPLUS 2888 static 2889 symbol_type make_KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED(location_type l)2890 make_KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED (location_type l) 2891 { 2892 return symbol_type (token::KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED, std::move (l)); 2893 } 2894 #else 2895 static 2896 symbol_type make_KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED(const location_type & l)2897 make_KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED (const location_type& l) 2898 { 2899 return symbol_type (token::KEEP_KALMAN_ALGO_IF_SINGULARITY_IS_DETECTED, l); 2900 } 2901 #endif 2902 #if 201103L <= YY_CPLUSPLUS 2903 static 2904 symbol_type make_FALSE(string v,location_type l)2905 make_FALSE (string v, location_type l) 2906 { 2907 return symbol_type (token::FALSE, std::move (v), std::move (l)); 2908 } 2909 #else 2910 static 2911 symbol_type make_FALSE(const string & v,const location_type & l)2912 make_FALSE (const string& v, const location_type& l) 2913 { 2914 return symbol_type (token::FALSE, v, l); 2915 } 2916 #endif 2917 #if 201103L <= YY_CPLUSPLUS 2918 static 2919 symbol_type make_FLOAT_NUMBER(string v,location_type l)2920 make_FLOAT_NUMBER (string v, location_type l) 2921 { 2922 return symbol_type (token::FLOAT_NUMBER, std::move (v), std::move (l)); 2923 } 2924 #else 2925 static 2926 symbol_type make_FLOAT_NUMBER(const string & v,const location_type & l)2927 make_FLOAT_NUMBER (const string& v, const location_type& l) 2928 { 2929 return symbol_type (token::FLOAT_NUMBER, v, l); 2930 } 2931 #endif 2932 #if 201103L <= YY_CPLUSPLUS 2933 static 2934 symbol_type make_DATES(string v,location_type l)2935 make_DATES (string v, location_type l) 2936 { 2937 return symbol_type (token::DATES, std::move (v), std::move (l)); 2938 } 2939 #else 2940 static 2941 symbol_type make_DATES(const string & v,const location_type & l)2942 make_DATES (const string& v, const location_type& l) 2943 { 2944 return symbol_type (token::DATES, v, l); 2945 } 2946 #endif 2947 #if 201103L <= YY_CPLUSPLUS 2948 static 2949 symbol_type make_DEFAULT(location_type l)2950 make_DEFAULT (location_type l) 2951 { 2952 return symbol_type (token::DEFAULT, std::move (l)); 2953 } 2954 #else 2955 static 2956 symbol_type make_DEFAULT(const location_type & l)2957 make_DEFAULT (const location_type& l) 2958 { 2959 return symbol_type (token::DEFAULT, l); 2960 } 2961 #endif 2962 #if 201103L <= YY_CPLUSPLUS 2963 static 2964 symbol_type make_FIXED_POINT(location_type l)2965 make_FIXED_POINT (location_type l) 2966 { 2967 return symbol_type (token::FIXED_POINT, std::move (l)); 2968 } 2969 #else 2970 static 2971 symbol_type make_FIXED_POINT(const location_type & l)2972 make_FIXED_POINT (const location_type& l) 2973 { 2974 return symbol_type (token::FIXED_POINT, l); 2975 } 2976 #endif 2977 #if 201103L <= YY_CPLUSPLUS 2978 static 2979 symbol_type make_FLIP(location_type l)2980 make_FLIP (location_type l) 2981 { 2982 return symbol_type (token::FLIP, std::move (l)); 2983 } 2984 #else 2985 static 2986 symbol_type make_FLIP(const location_type & l)2987 make_FLIP (const location_type& l) 2988 { 2989 return symbol_type (token::FLIP, l); 2990 } 2991 #endif 2992 #if 201103L <= YY_CPLUSPLUS 2993 static 2994 symbol_type make_OPT_ALGO(location_type l)2995 make_OPT_ALGO (location_type l) 2996 { 2997 return symbol_type (token::OPT_ALGO, std::move (l)); 2998 } 2999 #else 3000 static 3001 symbol_type make_OPT_ALGO(const location_type & l)3002 make_OPT_ALGO (const location_type& l) 3003 { 3004 return symbol_type (token::OPT_ALGO, l); 3005 } 3006 #endif 3007 #if 201103L <= YY_CPLUSPLUS 3008 static 3009 symbol_type make_COMPILATION_SETUP(location_type l)3010 make_COMPILATION_SETUP (location_type l) 3011 { 3012 return symbol_type (token::COMPILATION_SETUP, std::move (l)); 3013 } 3014 #else 3015 static 3016 symbol_type make_COMPILATION_SETUP(const location_type & l)3017 make_COMPILATION_SETUP (const location_type& l) 3018 { 3019 return symbol_type (token::COMPILATION_SETUP, l); 3020 } 3021 #endif 3022 #if 201103L <= YY_CPLUSPLUS 3023 static 3024 symbol_type make_COMPILER(location_type l)3025 make_COMPILER (location_type l) 3026 { 3027 return symbol_type (token::COMPILER, std::move (l)); 3028 } 3029 #else 3030 static 3031 symbol_type make_COMPILER(const location_type & l)3032 make_COMPILER (const location_type& l) 3033 { 3034 return symbol_type (token::COMPILER, l); 3035 } 3036 #endif 3037 #if 201103L <= YY_CPLUSPLUS 3038 static 3039 symbol_type make_ADD_FLAGS(location_type l)3040 make_ADD_FLAGS (location_type l) 3041 { 3042 return symbol_type (token::ADD_FLAGS, std::move (l)); 3043 } 3044 #else 3045 static 3046 symbol_type make_ADD_FLAGS(const location_type & l)3047 make_ADD_FLAGS (const location_type& l) 3048 { 3049 return symbol_type (token::ADD_FLAGS, l); 3050 } 3051 #endif 3052 #if 201103L <= YY_CPLUSPLUS 3053 static 3054 symbol_type make_SUBSTITUTE_FLAGS(location_type l)3055 make_SUBSTITUTE_FLAGS (location_type l) 3056 { 3057 return symbol_type (token::SUBSTITUTE_FLAGS, std::move (l)); 3058 } 3059 #else 3060 static 3061 symbol_type make_SUBSTITUTE_FLAGS(const location_type & l)3062 make_SUBSTITUTE_FLAGS (const location_type& l) 3063 { 3064 return symbol_type (token::SUBSTITUTE_FLAGS, l); 3065 } 3066 #endif 3067 #if 201103L <= YY_CPLUSPLUS 3068 static 3069 symbol_type make_ADD_LIBS(location_type l)3070 make_ADD_LIBS (location_type l) 3071 { 3072 return symbol_type (token::ADD_LIBS, std::move (l)); 3073 } 3074 #else 3075 static 3076 symbol_type make_ADD_LIBS(const location_type & l)3077 make_ADD_LIBS (const location_type& l) 3078 { 3079 return symbol_type (token::ADD_LIBS, l); 3080 } 3081 #endif 3082 #if 201103L <= YY_CPLUSPLUS 3083 static 3084 symbol_type make_SUBSTITUTE_LIBS(location_type l)3085 make_SUBSTITUTE_LIBS (location_type l) 3086 { 3087 return symbol_type (token::SUBSTITUTE_LIBS, std::move (l)); 3088 } 3089 #else 3090 static 3091 symbol_type make_SUBSTITUTE_LIBS(const location_type & l)3092 make_SUBSTITUTE_LIBS (const location_type& l) 3093 { 3094 return symbol_type (token::SUBSTITUTE_LIBS, l); 3095 } 3096 #endif 3097 #if 201103L <= YY_CPLUSPLUS 3098 static 3099 symbol_type make_FORECAST(location_type l)3100 make_FORECAST (location_type l) 3101 { 3102 return symbol_type (token::FORECAST, std::move (l)); 3103 } 3104 #else 3105 static 3106 symbol_type make_FORECAST(const location_type & l)3107 make_FORECAST (const location_type& l) 3108 { 3109 return symbol_type (token::FORECAST, l); 3110 } 3111 #endif 3112 #if 201103L <= YY_CPLUSPLUS 3113 static 3114 symbol_type make_K_ORDER_SOLVER(location_type l)3115 make_K_ORDER_SOLVER (location_type l) 3116 { 3117 return symbol_type (token::K_ORDER_SOLVER, std::move (l)); 3118 } 3119 #else 3120 static 3121 symbol_type make_K_ORDER_SOLVER(const location_type & l)3122 make_K_ORDER_SOLVER (const location_type& l) 3123 { 3124 return symbol_type (token::K_ORDER_SOLVER, l); 3125 } 3126 #endif 3127 #if 201103L <= YY_CPLUSPLUS 3128 static 3129 symbol_type make_INSTRUMENTS(location_type l)3130 make_INSTRUMENTS (location_type l) 3131 { 3132 return symbol_type (token::INSTRUMENTS, std::move (l)); 3133 } 3134 #else 3135 static 3136 symbol_type make_INSTRUMENTS(const location_type & l)3137 make_INSTRUMENTS (const location_type& l) 3138 { 3139 return symbol_type (token::INSTRUMENTS, l); 3140 } 3141 #endif 3142 #if 201103L <= YY_CPLUSPLUS 3143 static 3144 symbol_type make_SHIFT(location_type l)3145 make_SHIFT (location_type l) 3146 { 3147 return symbol_type (token::SHIFT, std::move (l)); 3148 } 3149 #else 3150 static 3151 symbol_type make_SHIFT(const location_type & l)3152 make_SHIFT (const location_type& l) 3153 { 3154 return symbol_type (token::SHIFT, l); 3155 } 3156 #endif 3157 #if 201103L <= YY_CPLUSPLUS 3158 static 3159 symbol_type make_MEAN(location_type l)3160 make_MEAN (location_type l) 3161 { 3162 return symbol_type (token::MEAN, std::move (l)); 3163 } 3164 #else 3165 static 3166 symbol_type make_MEAN(const location_type & l)3167 make_MEAN (const location_type& l) 3168 { 3169 return symbol_type (token::MEAN, l); 3170 } 3171 #endif 3172 #if 201103L <= YY_CPLUSPLUS 3173 static 3174 symbol_type make_STDEV(location_type l)3175 make_STDEV (location_type l) 3176 { 3177 return symbol_type (token::STDEV, std::move (l)); 3178 } 3179 #else 3180 static 3181 symbol_type make_STDEV(const location_type & l)3182 make_STDEV (const location_type& l) 3183 { 3184 return symbol_type (token::STDEV, l); 3185 } 3186 #endif 3187 #if 201103L <= YY_CPLUSPLUS 3188 static 3189 symbol_type make_VARIANCE(location_type l)3190 make_VARIANCE (location_type l) 3191 { 3192 return symbol_type (token::VARIANCE, std::move (l)); 3193 } 3194 #else 3195 static 3196 symbol_type make_VARIANCE(const location_type & l)3197 make_VARIANCE (const location_type& l) 3198 { 3199 return symbol_type (token::VARIANCE, l); 3200 } 3201 #endif 3202 #if 201103L <= YY_CPLUSPLUS 3203 static 3204 symbol_type make_MODE(location_type l)3205 make_MODE (location_type l) 3206 { 3207 return symbol_type (token::MODE, std::move (l)); 3208 } 3209 #else 3210 static 3211 symbol_type make_MODE(const location_type & l)3212 make_MODE (const location_type& l) 3213 { 3214 return symbol_type (token::MODE, l); 3215 } 3216 #endif 3217 #if 201103L <= YY_CPLUSPLUS 3218 static 3219 symbol_type make_INTERVAL(location_type l)3220 make_INTERVAL (location_type l) 3221 { 3222 return symbol_type (token::INTERVAL, std::move (l)); 3223 } 3224 #else 3225 static 3226 symbol_type make_INTERVAL(const location_type & l)3227 make_INTERVAL (const location_type& l) 3228 { 3229 return symbol_type (token::INTERVAL, l); 3230 } 3231 #endif 3232 #if 201103L <= YY_CPLUSPLUS 3233 static 3234 symbol_type make_SHAPE(location_type l)3235 make_SHAPE (location_type l) 3236 { 3237 return symbol_type (token::SHAPE, std::move (l)); 3238 } 3239 #else 3240 static 3241 symbol_type make_SHAPE(const location_type & l)3242 make_SHAPE (const location_type& l) 3243 { 3244 return symbol_type (token::SHAPE, l); 3245 } 3246 #endif 3247 #if 201103L <= YY_CPLUSPLUS 3248 static 3249 symbol_type make_DOMAINN(location_type l)3250 make_DOMAINN (location_type l) 3251 { 3252 return symbol_type (token::DOMAINN, std::move (l)); 3253 } 3254 #else 3255 static 3256 symbol_type make_DOMAINN(const location_type & l)3257 make_DOMAINN (const location_type& l) 3258 { 3259 return symbol_type (token::DOMAINN, l); 3260 } 3261 #endif 3262 #if 201103L <= YY_CPLUSPLUS 3263 static 3264 symbol_type make_GAMMA_PDF(location_type l)3265 make_GAMMA_PDF (location_type l) 3266 { 3267 return symbol_type (token::GAMMA_PDF, std::move (l)); 3268 } 3269 #else 3270 static 3271 symbol_type make_GAMMA_PDF(const location_type & l)3272 make_GAMMA_PDF (const location_type& l) 3273 { 3274 return symbol_type (token::GAMMA_PDF, l); 3275 } 3276 #endif 3277 #if 201103L <= YY_CPLUSPLUS 3278 static 3279 symbol_type make_GRAPH(location_type l)3280 make_GRAPH (location_type l) 3281 { 3282 return symbol_type (token::GRAPH, std::move (l)); 3283 } 3284 #else 3285 static 3286 symbol_type make_GRAPH(const location_type & l)3287 make_GRAPH (const location_type& l) 3288 { 3289 return symbol_type (token::GRAPH, l); 3290 } 3291 #endif 3292 #if 201103L <= YY_CPLUSPLUS 3293 static 3294 symbol_type make_GRAPH_FORMAT(location_type l)3295 make_GRAPH_FORMAT (location_type l) 3296 { 3297 return symbol_type (token::GRAPH_FORMAT, std::move (l)); 3298 } 3299 #else 3300 static 3301 symbol_type make_GRAPH_FORMAT(const location_type & l)3302 make_GRAPH_FORMAT (const location_type& l) 3303 { 3304 return symbol_type (token::GRAPH_FORMAT, l); 3305 } 3306 #endif 3307 #if 201103L <= YY_CPLUSPLUS 3308 static 3309 symbol_type make_CONDITIONAL_VARIANCE_DECOMPOSITION(location_type l)3310 make_CONDITIONAL_VARIANCE_DECOMPOSITION (location_type l) 3311 { 3312 return symbol_type (token::CONDITIONAL_VARIANCE_DECOMPOSITION, std::move (l)); 3313 } 3314 #else 3315 static 3316 symbol_type make_CONDITIONAL_VARIANCE_DECOMPOSITION(const location_type & l)3317 make_CONDITIONAL_VARIANCE_DECOMPOSITION (const location_type& l) 3318 { 3319 return symbol_type (token::CONDITIONAL_VARIANCE_DECOMPOSITION, l); 3320 } 3321 #endif 3322 #if 201103L <= YY_CPLUSPLUS 3323 static 3324 symbol_type make_NOCHECK(location_type l)3325 make_NOCHECK (location_type l) 3326 { 3327 return symbol_type (token::NOCHECK, std::move (l)); 3328 } 3329 #else 3330 static 3331 symbol_type make_NOCHECK(const location_type & l)3332 make_NOCHECK (const location_type& l) 3333 { 3334 return symbol_type (token::NOCHECK, l); 3335 } 3336 #endif 3337 #if 201103L <= YY_CPLUSPLUS 3338 static 3339 symbol_type make_STD(location_type l)3340 make_STD (location_type l) 3341 { 3342 return symbol_type (token::STD, std::move (l)); 3343 } 3344 #else 3345 static 3346 symbol_type make_STD(const location_type & l)3347 make_STD (const location_type& l) 3348 { 3349 return symbol_type (token::STD, l); 3350 } 3351 #endif 3352 #if 201103L <= YY_CPLUSPLUS 3353 static 3354 symbol_type make_HISTVAL(location_type l)3355 make_HISTVAL (location_type l) 3356 { 3357 return symbol_type (token::HISTVAL, std::move (l)); 3358 } 3359 #else 3360 static 3361 symbol_type make_HISTVAL(const location_type & l)3362 make_HISTVAL (const location_type& l) 3363 { 3364 return symbol_type (token::HISTVAL, l); 3365 } 3366 #endif 3367 #if 201103L <= YY_CPLUSPLUS 3368 static 3369 symbol_type make_HISTVAL_FILE(location_type l)3370 make_HISTVAL_FILE (location_type l) 3371 { 3372 return symbol_type (token::HISTVAL_FILE, std::move (l)); 3373 } 3374 #else 3375 static 3376 symbol_type make_HISTVAL_FILE(const location_type & l)3377 make_HISTVAL_FILE (const location_type& l) 3378 { 3379 return symbol_type (token::HISTVAL_FILE, l); 3380 } 3381 #endif 3382 #if 201103L <= YY_CPLUSPLUS 3383 static 3384 symbol_type make_HOMOTOPY_SETUP(location_type l)3385 make_HOMOTOPY_SETUP (location_type l) 3386 { 3387 return symbol_type (token::HOMOTOPY_SETUP, std::move (l)); 3388 } 3389 #else 3390 static 3391 symbol_type make_HOMOTOPY_SETUP(const location_type & l)3392 make_HOMOTOPY_SETUP (const location_type& l) 3393 { 3394 return symbol_type (token::HOMOTOPY_SETUP, l); 3395 } 3396 #endif 3397 #if 201103L <= YY_CPLUSPLUS 3398 static 3399 symbol_type make_HOMOTOPY_MODE(location_type l)3400 make_HOMOTOPY_MODE (location_type l) 3401 { 3402 return symbol_type (token::HOMOTOPY_MODE, std::move (l)); 3403 } 3404 #else 3405 static 3406 symbol_type make_HOMOTOPY_MODE(const location_type & l)3407 make_HOMOTOPY_MODE (const location_type& l) 3408 { 3409 return symbol_type (token::HOMOTOPY_MODE, l); 3410 } 3411 #endif 3412 #if 201103L <= YY_CPLUSPLUS 3413 static 3414 symbol_type make_HOMOTOPY_STEPS(location_type l)3415 make_HOMOTOPY_STEPS (location_type l) 3416 { 3417 return symbol_type (token::HOMOTOPY_STEPS, std::move (l)); 3418 } 3419 #else 3420 static 3421 symbol_type make_HOMOTOPY_STEPS(const location_type & l)3422 make_HOMOTOPY_STEPS (const location_type& l) 3423 { 3424 return symbol_type (token::HOMOTOPY_STEPS, l); 3425 } 3426 #endif 3427 #if 201103L <= YY_CPLUSPLUS 3428 static 3429 symbol_type make_HOMOTOPY_FORCE_CONTINUE(location_type l)3430 make_HOMOTOPY_FORCE_CONTINUE (location_type l) 3431 { 3432 return symbol_type (token::HOMOTOPY_FORCE_CONTINUE, std::move (l)); 3433 } 3434 #else 3435 static 3436 symbol_type make_HOMOTOPY_FORCE_CONTINUE(const location_type & l)3437 make_HOMOTOPY_FORCE_CONTINUE (const location_type& l) 3438 { 3439 return symbol_type (token::HOMOTOPY_FORCE_CONTINUE, l); 3440 } 3441 #endif 3442 #if 201103L <= YY_CPLUSPLUS 3443 static 3444 symbol_type make_HP_FILTER(location_type l)3445 make_HP_FILTER (location_type l) 3446 { 3447 return symbol_type (token::HP_FILTER, std::move (l)); 3448 } 3449 #else 3450 static 3451 symbol_type make_HP_FILTER(const location_type & l)3452 make_HP_FILTER (const location_type& l) 3453 { 3454 return symbol_type (token::HP_FILTER, l); 3455 } 3456 #endif 3457 #if 201103L <= YY_CPLUSPLUS 3458 static 3459 symbol_type make_HP_NGRID(location_type l)3460 make_HP_NGRID (location_type l) 3461 { 3462 return symbol_type (token::HP_NGRID, std::move (l)); 3463 } 3464 #else 3465 static 3466 symbol_type make_HP_NGRID(const location_type & l)3467 make_HP_NGRID (const location_type& l) 3468 { 3469 return symbol_type (token::HP_NGRID, l); 3470 } 3471 #endif 3472 #if 201103L <= YY_CPLUSPLUS 3473 static 3474 symbol_type make_FILTERED_THEORETICAL_MOMENTS_GRID(location_type l)3475 make_FILTERED_THEORETICAL_MOMENTS_GRID (location_type l) 3476 { 3477 return symbol_type (token::FILTERED_THEORETICAL_MOMENTS_GRID, std::move (l)); 3478 } 3479 #else 3480 static 3481 symbol_type make_FILTERED_THEORETICAL_MOMENTS_GRID(const location_type & l)3482 make_FILTERED_THEORETICAL_MOMENTS_GRID (const location_type& l) 3483 { 3484 return symbol_type (token::FILTERED_THEORETICAL_MOMENTS_GRID, l); 3485 } 3486 #endif 3487 #if 201103L <= YY_CPLUSPLUS 3488 static 3489 symbol_type make_HYBRID(location_type l)3490 make_HYBRID (location_type l) 3491 { 3492 return symbol_type (token::HYBRID, std::move (l)); 3493 } 3494 #else 3495 static 3496 symbol_type make_HYBRID(const location_type & l)3497 make_HYBRID (const location_type& l) 3498 { 3499 return symbol_type (token::HYBRID, l); 3500 } 3501 #endif 3502 #if 201103L <= YY_CPLUSPLUS 3503 static 3504 symbol_type make_ONE_SIDED_HP_FILTER(location_type l)3505 make_ONE_SIDED_HP_FILTER (location_type l) 3506 { 3507 return symbol_type (token::ONE_SIDED_HP_FILTER, std::move (l)); 3508 } 3509 #else 3510 static 3511 symbol_type make_ONE_SIDED_HP_FILTER(const location_type & l)3512 make_ONE_SIDED_HP_FILTER (const location_type& l) 3513 { 3514 return symbol_type (token::ONE_SIDED_HP_FILTER, l); 3515 } 3516 #endif 3517 #if 201103L <= YY_CPLUSPLUS 3518 static 3519 symbol_type make_IDENTIFICATION(location_type l)3520 make_IDENTIFICATION (location_type l) 3521 { 3522 return symbol_type (token::IDENTIFICATION, std::move (l)); 3523 } 3524 #else 3525 static 3526 symbol_type make_IDENTIFICATION(const location_type & l)3527 make_IDENTIFICATION (const location_type& l) 3528 { 3529 return symbol_type (token::IDENTIFICATION, l); 3530 } 3531 #endif 3532 #if 201103L <= YY_CPLUSPLUS 3533 static 3534 symbol_type make_INF_CONSTANT(location_type l)3535 make_INF_CONSTANT (location_type l) 3536 { 3537 return symbol_type (token::INF_CONSTANT, std::move (l)); 3538 } 3539 #else 3540 static 3541 symbol_type make_INF_CONSTANT(const location_type & l)3542 make_INF_CONSTANT (const location_type& l) 3543 { 3544 return symbol_type (token::INF_CONSTANT, l); 3545 } 3546 #endif 3547 #if 201103L <= YY_CPLUSPLUS 3548 static 3549 symbol_type make_INITVAL(location_type l)3550 make_INITVAL (location_type l) 3551 { 3552 return symbol_type (token::INITVAL, std::move (l)); 3553 } 3554 #else 3555 static 3556 symbol_type make_INITVAL(const location_type & l)3557 make_INITVAL (const location_type& l) 3558 { 3559 return symbol_type (token::INITVAL, l); 3560 } 3561 #endif 3562 #if 201103L <= YY_CPLUSPLUS 3563 static 3564 symbol_type make_INITVAL_FILE(location_type l)3565 make_INITVAL_FILE (location_type l) 3566 { 3567 return symbol_type (token::INITVAL_FILE, std::move (l)); 3568 } 3569 #else 3570 static 3571 symbol_type make_INITVAL_FILE(const location_type & l)3572 make_INITVAL_FILE (const location_type& l) 3573 { 3574 return symbol_type (token::INITVAL_FILE, l); 3575 } 3576 #endif 3577 #if 201103L <= YY_CPLUSPLUS 3578 static 3579 symbol_type make_BOUNDS(location_type l)3580 make_BOUNDS (location_type l) 3581 { 3582 return symbol_type (token::BOUNDS, std::move (l)); 3583 } 3584 #else 3585 static 3586 symbol_type make_BOUNDS(const location_type & l)3587 make_BOUNDS (const location_type& l) 3588 { 3589 return symbol_type (token::BOUNDS, l); 3590 } 3591 #endif 3592 #if 201103L <= YY_CPLUSPLUS 3593 static 3594 symbol_type make_JSCALE(location_type l)3595 make_JSCALE (location_type l) 3596 { 3597 return symbol_type (token::JSCALE, std::move (l)); 3598 } 3599 #else 3600 static 3601 symbol_type make_JSCALE(const location_type & l)3602 make_JSCALE (const location_type& l) 3603 { 3604 return symbol_type (token::JSCALE, l); 3605 } 3606 #endif 3607 #if 201103L <= YY_CPLUSPLUS 3608 static 3609 symbol_type make_INIT(location_type l)3610 make_INIT (location_type l) 3611 { 3612 return symbol_type (token::INIT, std::move (l)); 3613 } 3614 #else 3615 static 3616 symbol_type make_INIT(const location_type & l)3617 make_INIT (const location_type& l) 3618 { 3619 return symbol_type (token::INIT, l); 3620 } 3621 #endif 3622 #if 201103L <= YY_CPLUSPLUS 3623 static 3624 symbol_type make_INFILE(location_type l)3625 make_INFILE (location_type l) 3626 { 3627 return symbol_type (token::INFILE, std::move (l)); 3628 } 3629 #else 3630 static 3631 symbol_type make_INFILE(const location_type & l)3632 make_INFILE (const location_type& l) 3633 { 3634 return symbol_type (token::INFILE, l); 3635 } 3636 #endif 3637 #if 201103L <= YY_CPLUSPLUS 3638 static 3639 symbol_type make_INVARS(location_type l)3640 make_INVARS (location_type l) 3641 { 3642 return symbol_type (token::INVARS, std::move (l)); 3643 } 3644 #else 3645 static 3646 symbol_type make_INVARS(const location_type & l)3647 make_INVARS (const location_type& l) 3648 { 3649 return symbol_type (token::INVARS, l); 3650 } 3651 #endif 3652 #if 201103L <= YY_CPLUSPLUS 3653 static 3654 symbol_type make_INT_NUMBER(string v,location_type l)3655 make_INT_NUMBER (string v, location_type l) 3656 { 3657 return symbol_type (token::INT_NUMBER, std::move (v), std::move (l)); 3658 } 3659 #else 3660 static 3661 symbol_type make_INT_NUMBER(const string & v,const location_type & l)3662 make_INT_NUMBER (const string& v, const location_type& l) 3663 { 3664 return symbol_type (token::INT_NUMBER, v, l); 3665 } 3666 #endif 3667 #if 201103L <= YY_CPLUSPLUS 3668 static 3669 symbol_type make_INV_GAMMA_PDF(location_type l)3670 make_INV_GAMMA_PDF (location_type l) 3671 { 3672 return symbol_type (token::INV_GAMMA_PDF, std::move (l)); 3673 } 3674 #else 3675 static 3676 symbol_type make_INV_GAMMA_PDF(const location_type & l)3677 make_INV_GAMMA_PDF (const location_type& l) 3678 { 3679 return symbol_type (token::INV_GAMMA_PDF, l); 3680 } 3681 #endif 3682 #if 201103L <= YY_CPLUSPLUS 3683 static 3684 symbol_type make_INV_GAMMA1_PDF(location_type l)3685 make_INV_GAMMA1_PDF (location_type l) 3686 { 3687 return symbol_type (token::INV_GAMMA1_PDF, std::move (l)); 3688 } 3689 #else 3690 static 3691 symbol_type make_INV_GAMMA1_PDF(const location_type & l)3692 make_INV_GAMMA1_PDF (const location_type& l) 3693 { 3694 return symbol_type (token::INV_GAMMA1_PDF, l); 3695 } 3696 #endif 3697 #if 201103L <= YY_CPLUSPLUS 3698 static 3699 symbol_type make_INV_GAMMA2_PDF(location_type l)3700 make_INV_GAMMA2_PDF (location_type l) 3701 { 3702 return symbol_type (token::INV_GAMMA2_PDF, std::move (l)); 3703 } 3704 #else 3705 static 3706 symbol_type make_INV_GAMMA2_PDF(const location_type & l)3707 make_INV_GAMMA2_PDF (const location_type& l) 3708 { 3709 return symbol_type (token::INV_GAMMA2_PDF, l); 3710 } 3711 #endif 3712 #if 201103L <= YY_CPLUSPLUS 3713 static 3714 symbol_type make_IRF(location_type l)3715 make_IRF (location_type l) 3716 { 3717 return symbol_type (token::IRF, std::move (l)); 3718 } 3719 #else 3720 static 3721 symbol_type make_IRF(const location_type & l)3722 make_IRF (const location_type& l) 3723 { 3724 return symbol_type (token::IRF, l); 3725 } 3726 #endif 3727 #if 201103L <= YY_CPLUSPLUS 3728 static 3729 symbol_type make_IRF_SHOCKS(location_type l)3730 make_IRF_SHOCKS (location_type l) 3731 { 3732 return symbol_type (token::IRF_SHOCKS, std::move (l)); 3733 } 3734 #else 3735 static 3736 symbol_type make_IRF_SHOCKS(const location_type & l)3737 make_IRF_SHOCKS (const location_type& l) 3738 { 3739 return symbol_type (token::IRF_SHOCKS, l); 3740 } 3741 #endif 3742 #if 201103L <= YY_CPLUSPLUS 3743 static 3744 symbol_type make_IRF_PLOT_THRESHOLD(location_type l)3745 make_IRF_PLOT_THRESHOLD (location_type l) 3746 { 3747 return symbol_type (token::IRF_PLOT_THRESHOLD, std::move (l)); 3748 } 3749 #else 3750 static 3751 symbol_type make_IRF_PLOT_THRESHOLD(const location_type & l)3752 make_IRF_PLOT_THRESHOLD (const location_type& l) 3753 { 3754 return symbol_type (token::IRF_PLOT_THRESHOLD, l); 3755 } 3756 #endif 3757 #if 201103L <= YY_CPLUSPLUS 3758 static 3759 symbol_type make_IRF_CALIBRATION(location_type l)3760 make_IRF_CALIBRATION (location_type l) 3761 { 3762 return symbol_type (token::IRF_CALIBRATION, std::move (l)); 3763 } 3764 #else 3765 static 3766 symbol_type make_IRF_CALIBRATION(const location_type & l)3767 make_IRF_CALIBRATION (const location_type& l) 3768 { 3769 return symbol_type (token::IRF_CALIBRATION, l); 3770 } 3771 #endif 3772 #if 201103L <= YY_CPLUSPLUS 3773 static 3774 symbol_type make_FAST_KALMAN_FILTER(location_type l)3775 make_FAST_KALMAN_FILTER (location_type l) 3776 { 3777 return symbol_type (token::FAST_KALMAN_FILTER, std::move (l)); 3778 } 3779 #else 3780 static 3781 symbol_type make_FAST_KALMAN_FILTER(const location_type & l)3782 make_FAST_KALMAN_FILTER (const location_type& l) 3783 { 3784 return symbol_type (token::FAST_KALMAN_FILTER, l); 3785 } 3786 #endif 3787 #if 201103L <= YY_CPLUSPLUS 3788 static 3789 symbol_type make_KALMAN_ALGO(location_type l)3790 make_KALMAN_ALGO (location_type l) 3791 { 3792 return symbol_type (token::KALMAN_ALGO, std::move (l)); 3793 } 3794 #else 3795 static 3796 symbol_type make_KALMAN_ALGO(const location_type & l)3797 make_KALMAN_ALGO (const location_type& l) 3798 { 3799 return symbol_type (token::KALMAN_ALGO, l); 3800 } 3801 #endif 3802 #if 201103L <= YY_CPLUSPLUS 3803 static 3804 symbol_type make_KALMAN_TOL(location_type l)3805 make_KALMAN_TOL (location_type l) 3806 { 3807 return symbol_type (token::KALMAN_TOL, std::move (l)); 3808 } 3809 #else 3810 static 3811 symbol_type make_KALMAN_TOL(const location_type & l)3812 make_KALMAN_TOL (const location_type& l) 3813 { 3814 return symbol_type (token::KALMAN_TOL, l); 3815 } 3816 #endif 3817 #if 201103L <= YY_CPLUSPLUS 3818 static 3819 symbol_type make_DIFFUSE_KALMAN_TOL(location_type l)3820 make_DIFFUSE_KALMAN_TOL (location_type l) 3821 { 3822 return symbol_type (token::DIFFUSE_KALMAN_TOL, std::move (l)); 3823 } 3824 #else 3825 static 3826 symbol_type make_DIFFUSE_KALMAN_TOL(const location_type & l)3827 make_DIFFUSE_KALMAN_TOL (const location_type& l) 3828 { 3829 return symbol_type (token::DIFFUSE_KALMAN_TOL, l); 3830 } 3831 #endif 3832 #if 201103L <= YY_CPLUSPLUS 3833 static 3834 symbol_type make_SUBSAMPLES(location_type l)3835 make_SUBSAMPLES (location_type l) 3836 { 3837 return symbol_type (token::SUBSAMPLES, std::move (l)); 3838 } 3839 #else 3840 static 3841 symbol_type make_SUBSAMPLES(const location_type & l)3842 make_SUBSAMPLES (const location_type& l) 3843 { 3844 return symbol_type (token::SUBSAMPLES, l); 3845 } 3846 #endif 3847 #if 201103L <= YY_CPLUSPLUS 3848 static 3849 symbol_type make_OPTIONS(location_type l)3850 make_OPTIONS (location_type l) 3851 { 3852 return symbol_type (token::OPTIONS, std::move (l)); 3853 } 3854 #else 3855 static 3856 symbol_type make_OPTIONS(const location_type & l)3857 make_OPTIONS (const location_type& l) 3858 { 3859 return symbol_type (token::OPTIONS, l); 3860 } 3861 #endif 3862 #if 201103L <= YY_CPLUSPLUS 3863 static 3864 symbol_type make_TOLF(location_type l)3865 make_TOLF (location_type l) 3866 { 3867 return symbol_type (token::TOLF, std::move (l)); 3868 } 3869 #else 3870 static 3871 symbol_type make_TOLF(const location_type & l)3872 make_TOLF (const location_type& l) 3873 { 3874 return symbol_type (token::TOLF, l); 3875 } 3876 #endif 3877 #if 201103L <= YY_CPLUSPLUS 3878 static 3879 symbol_type make_TOLX(location_type l)3880 make_TOLX (location_type l) 3881 { 3882 return symbol_type (token::TOLX, std::move (l)); 3883 } 3884 #else 3885 static 3886 symbol_type make_TOLX(const location_type & l)3887 make_TOLX (const location_type& l) 3888 { 3889 return symbol_type (token::TOLX, l); 3890 } 3891 #endif 3892 #if 201103L <= YY_CPLUSPLUS 3893 static 3894 symbol_type make_PLOT_INIT_DATE(location_type l)3895 make_PLOT_INIT_DATE (location_type l) 3896 { 3897 return symbol_type (token::PLOT_INIT_DATE, std::move (l)); 3898 } 3899 #else 3900 static 3901 symbol_type make_PLOT_INIT_DATE(const location_type & l)3902 make_PLOT_INIT_DATE (const location_type& l) 3903 { 3904 return symbol_type (token::PLOT_INIT_DATE, l); 3905 } 3906 #endif 3907 #if 201103L <= YY_CPLUSPLUS 3908 static 3909 symbol_type make_PLOT_END_DATE(location_type l)3910 make_PLOT_END_DATE (location_type l) 3911 { 3912 return symbol_type (token::PLOT_END_DATE, std::move (l)); 3913 } 3914 #else 3915 static 3916 symbol_type make_PLOT_END_DATE(const location_type & l)3917 make_PLOT_END_DATE (const location_type& l) 3918 { 3919 return symbol_type (token::PLOT_END_DATE, l); 3920 } 3921 #endif 3922 #if 201103L <= YY_CPLUSPLUS 3923 static 3924 symbol_type make_LAPLACE(location_type l)3925 make_LAPLACE (location_type l) 3926 { 3927 return symbol_type (token::LAPLACE, std::move (l)); 3928 } 3929 #else 3930 static 3931 symbol_type make_LAPLACE(const location_type & l)3932 make_LAPLACE (const location_type& l) 3933 { 3934 return symbol_type (token::LAPLACE, l); 3935 } 3936 #endif 3937 #if 201103L <= YY_CPLUSPLUS 3938 static 3939 symbol_type make_LIK_ALGO(location_type l)3940 make_LIK_ALGO (location_type l) 3941 { 3942 return symbol_type (token::LIK_ALGO, std::move (l)); 3943 } 3944 #else 3945 static 3946 symbol_type make_LIK_ALGO(const location_type & l)3947 make_LIK_ALGO (const location_type& l) 3948 { 3949 return symbol_type (token::LIK_ALGO, l); 3950 } 3951 #endif 3952 #if 201103L <= YY_CPLUSPLUS 3953 static 3954 symbol_type make_LIK_INIT(location_type l)3955 make_LIK_INIT (location_type l) 3956 { 3957 return symbol_type (token::LIK_INIT, std::move (l)); 3958 } 3959 #else 3960 static 3961 symbol_type make_LIK_INIT(const location_type & l)3962 make_LIK_INIT (const location_type& l) 3963 { 3964 return symbol_type (token::LIK_INIT, l); 3965 } 3966 #endif 3967 #if 201103L <= YY_CPLUSPLUS 3968 static 3969 symbol_type make_LINEAR(location_type l)3970 make_LINEAR (location_type l) 3971 { 3972 return symbol_type (token::LINEAR, std::move (l)); 3973 } 3974 #else 3975 static 3976 symbol_type make_LINEAR(const location_type & l)3977 make_LINEAR (const location_type& l) 3978 { 3979 return symbol_type (token::LINEAR, l); 3980 } 3981 #endif 3982 #if 201103L <= YY_CPLUSPLUS 3983 static 3984 symbol_type make_LINEAR_DECOMPOSITION(location_type l)3985 make_LINEAR_DECOMPOSITION (location_type l) 3986 { 3987 return symbol_type (token::LINEAR_DECOMPOSITION, std::move (l)); 3988 } 3989 #else 3990 static 3991 symbol_type make_LINEAR_DECOMPOSITION(const location_type & l)3992 make_LINEAR_DECOMPOSITION (const location_type& l) 3993 { 3994 return symbol_type (token::LINEAR_DECOMPOSITION, l); 3995 } 3996 #endif 3997 #if 201103L <= YY_CPLUSPLUS 3998 static 3999 symbol_type make_LOAD_IDENT_FILES(location_type l)4000 make_LOAD_IDENT_FILES (location_type l) 4001 { 4002 return symbol_type (token::LOAD_IDENT_FILES, std::move (l)); 4003 } 4004 #else 4005 static 4006 symbol_type make_LOAD_IDENT_FILES(const location_type & l)4007 make_LOAD_IDENT_FILES (const location_type& l) 4008 { 4009 return symbol_type (token::LOAD_IDENT_FILES, l); 4010 } 4011 #endif 4012 #if 201103L <= YY_CPLUSPLUS 4013 static 4014 symbol_type make_LOAD_MH_FILE(location_type l)4015 make_LOAD_MH_FILE (location_type l) 4016 { 4017 return symbol_type (token::LOAD_MH_FILE, std::move (l)); 4018 } 4019 #else 4020 static 4021 symbol_type make_LOAD_MH_FILE(const location_type & l)4022 make_LOAD_MH_FILE (const location_type& l) 4023 { 4024 return symbol_type (token::LOAD_MH_FILE, l); 4025 } 4026 #endif 4027 #if 201103L <= YY_CPLUSPLUS 4028 static 4029 symbol_type make_LOAD_RESULTS_AFTER_LOAD_MH(location_type l)4030 make_LOAD_RESULTS_AFTER_LOAD_MH (location_type l) 4031 { 4032 return symbol_type (token::LOAD_RESULTS_AFTER_LOAD_MH, std::move (l)); 4033 } 4034 #else 4035 static 4036 symbol_type make_LOAD_RESULTS_AFTER_LOAD_MH(const location_type & l)4037 make_LOAD_RESULTS_AFTER_LOAD_MH (const location_type& l) 4038 { 4039 return symbol_type (token::LOAD_RESULTS_AFTER_LOAD_MH, l); 4040 } 4041 #endif 4042 #if 201103L <= YY_CPLUSPLUS 4043 static 4044 symbol_type make_LOAD_PARAMS_AND_STEADY_STATE(location_type l)4045 make_LOAD_PARAMS_AND_STEADY_STATE (location_type l) 4046 { 4047 return symbol_type (token::LOAD_PARAMS_AND_STEADY_STATE, std::move (l)); 4048 } 4049 #else 4050 static 4051 symbol_type make_LOAD_PARAMS_AND_STEADY_STATE(const location_type & l)4052 make_LOAD_PARAMS_AND_STEADY_STATE (const location_type& l) 4053 { 4054 return symbol_type (token::LOAD_PARAMS_AND_STEADY_STATE, l); 4055 } 4056 #endif 4057 #if 201103L <= YY_CPLUSPLUS 4058 static 4059 symbol_type make_LOGLINEAR(location_type l)4060 make_LOGLINEAR (location_type l) 4061 { 4062 return symbol_type (token::LOGLINEAR, std::move (l)); 4063 } 4064 #else 4065 static 4066 symbol_type make_LOGLINEAR(const location_type & l)4067 make_LOGLINEAR (const location_type& l) 4068 { 4069 return symbol_type (token::LOGLINEAR, l); 4070 } 4071 #endif 4072 #if 201103L <= YY_CPLUSPLUS 4073 static 4074 symbol_type make_LOGDATA(location_type l)4075 make_LOGDATA (location_type l) 4076 { 4077 return symbol_type (token::LOGDATA, std::move (l)); 4078 } 4079 #else 4080 static 4081 symbol_type make_LOGDATA(const location_type & l)4082 make_LOGDATA (const location_type& l) 4083 { 4084 return symbol_type (token::LOGDATA, l); 4085 } 4086 #endif 4087 #if 201103L <= YY_CPLUSPLUS 4088 static 4089 symbol_type make_LYAPUNOV(location_type l)4090 make_LYAPUNOV (location_type l) 4091 { 4092 return symbol_type (token::LYAPUNOV, std::move (l)); 4093 } 4094 #else 4095 static 4096 symbol_type make_LYAPUNOV(const location_type & l)4097 make_LYAPUNOV (const location_type& l) 4098 { 4099 return symbol_type (token::LYAPUNOV, l); 4100 } 4101 #endif 4102 #if 201103L <= YY_CPLUSPLUS 4103 static 4104 symbol_type make_LINEAR_APPROXIMATION(location_type l)4105 make_LINEAR_APPROXIMATION (location_type l) 4106 { 4107 return symbol_type (token::LINEAR_APPROXIMATION, std::move (l)); 4108 } 4109 #else 4110 static 4111 symbol_type make_LINEAR_APPROXIMATION(const location_type & l)4112 make_LINEAR_APPROXIMATION (const location_type& l) 4113 { 4114 return symbol_type (token::LINEAR_APPROXIMATION, l); 4115 } 4116 #endif 4117 #if 201103L <= YY_CPLUSPLUS 4118 static 4119 symbol_type make_LYAPUNOV_FIXED_POINT_TOL(location_type l)4120 make_LYAPUNOV_FIXED_POINT_TOL (location_type l) 4121 { 4122 return symbol_type (token::LYAPUNOV_FIXED_POINT_TOL, std::move (l)); 4123 } 4124 #else 4125 static 4126 symbol_type make_LYAPUNOV_FIXED_POINT_TOL(const location_type & l)4127 make_LYAPUNOV_FIXED_POINT_TOL (const location_type& l) 4128 { 4129 return symbol_type (token::LYAPUNOV_FIXED_POINT_TOL, l); 4130 } 4131 #endif 4132 #if 201103L <= YY_CPLUSPLUS 4133 static 4134 symbol_type make_LYAPUNOV_DOUBLING_TOL(location_type l)4135 make_LYAPUNOV_DOUBLING_TOL (location_type l) 4136 { 4137 return symbol_type (token::LYAPUNOV_DOUBLING_TOL, std::move (l)); 4138 } 4139 #else 4140 static 4141 symbol_type make_LYAPUNOV_DOUBLING_TOL(const location_type & l)4142 make_LYAPUNOV_DOUBLING_TOL (const location_type& l) 4143 { 4144 return symbol_type (token::LYAPUNOV_DOUBLING_TOL, l); 4145 } 4146 #endif 4147 #if 201103L <= YY_CPLUSPLUS 4148 static 4149 symbol_type make_LOG_DEFLATOR(location_type l)4150 make_LOG_DEFLATOR (location_type l) 4151 { 4152 return symbol_type (token::LOG_DEFLATOR, std::move (l)); 4153 } 4154 #else 4155 static 4156 symbol_type make_LOG_DEFLATOR(const location_type & l)4157 make_LOG_DEFLATOR (const location_type& l) 4158 { 4159 return symbol_type (token::LOG_DEFLATOR, l); 4160 } 4161 #endif 4162 #if 201103L <= YY_CPLUSPLUS 4163 static 4164 symbol_type make_LOG_TREND_VAR(location_type l)4165 make_LOG_TREND_VAR (location_type l) 4166 { 4167 return symbol_type (token::LOG_TREND_VAR, std::move (l)); 4168 } 4169 #else 4170 static 4171 symbol_type make_LOG_TREND_VAR(const location_type & l)4172 make_LOG_TREND_VAR (const location_type& l) 4173 { 4174 return symbol_type (token::LOG_TREND_VAR, l); 4175 } 4176 #endif 4177 #if 201103L <= YY_CPLUSPLUS 4178 static 4179 symbol_type make_LOG_GROWTH_FACTOR(location_type l)4180 make_LOG_GROWTH_FACTOR (location_type l) 4181 { 4182 return symbol_type (token::LOG_GROWTH_FACTOR, std::move (l)); 4183 } 4184 #else 4185 static 4186 symbol_type make_LOG_GROWTH_FACTOR(const location_type & l)4187 make_LOG_GROWTH_FACTOR (const location_type& l) 4188 { 4189 return symbol_type (token::LOG_GROWTH_FACTOR, l); 4190 } 4191 #endif 4192 #if 201103L <= YY_CPLUSPLUS 4193 static 4194 symbol_type make_MARKOWITZ(location_type l)4195 make_MARKOWITZ (location_type l) 4196 { 4197 return symbol_type (token::MARKOWITZ, std::move (l)); 4198 } 4199 #else 4200 static 4201 symbol_type make_MARKOWITZ(const location_type & l)4202 make_MARKOWITZ (const location_type& l) 4203 { 4204 return symbol_type (token::MARKOWITZ, l); 4205 } 4206 #endif 4207 #if 201103L <= YY_CPLUSPLUS 4208 static 4209 symbol_type make_MARGINAL_DENSITY(location_type l)4210 make_MARGINAL_DENSITY (location_type l) 4211 { 4212 return symbol_type (token::MARGINAL_DENSITY, std::move (l)); 4213 } 4214 #else 4215 static 4216 symbol_type make_MARGINAL_DENSITY(const location_type & l)4217 make_MARGINAL_DENSITY (const location_type& l) 4218 { 4219 return symbol_type (token::MARGINAL_DENSITY, l); 4220 } 4221 #endif 4222 #if 201103L <= YY_CPLUSPLUS 4223 static 4224 symbol_type make_MAX(location_type l)4225 make_MAX (location_type l) 4226 { 4227 return symbol_type (token::MAX, std::move (l)); 4228 } 4229 #else 4230 static 4231 symbol_type make_MAX(const location_type & l)4232 make_MAX (const location_type& l) 4233 { 4234 return symbol_type (token::MAX, l); 4235 } 4236 #endif 4237 #if 201103L <= YY_CPLUSPLUS 4238 static 4239 symbol_type make_MAXIT(location_type l)4240 make_MAXIT (location_type l) 4241 { 4242 return symbol_type (token::MAXIT, std::move (l)); 4243 } 4244 #else 4245 static 4246 symbol_type make_MAXIT(const location_type & l)4247 make_MAXIT (const location_type& l) 4248 { 4249 return symbol_type (token::MAXIT, l); 4250 } 4251 #endif 4252 #if 201103L <= YY_CPLUSPLUS 4253 static 4254 symbol_type make_MFS(location_type l)4255 make_MFS (location_type l) 4256 { 4257 return symbol_type (token::MFS, std::move (l)); 4258 } 4259 #else 4260 static 4261 symbol_type make_MFS(const location_type & l)4262 make_MFS (const location_type& l) 4263 { 4264 return symbol_type (token::MFS, l); 4265 } 4266 #endif 4267 #if 201103L <= YY_CPLUSPLUS 4268 static 4269 symbol_type make_MH_CONF_SIG(location_type l)4270 make_MH_CONF_SIG (location_type l) 4271 { 4272 return symbol_type (token::MH_CONF_SIG, std::move (l)); 4273 } 4274 #else 4275 static 4276 symbol_type make_MH_CONF_SIG(const location_type & l)4277 make_MH_CONF_SIG (const location_type& l) 4278 { 4279 return symbol_type (token::MH_CONF_SIG, l); 4280 } 4281 #endif 4282 #if 201103L <= YY_CPLUSPLUS 4283 static 4284 symbol_type make_MH_DROP(location_type l)4285 make_MH_DROP (location_type l) 4286 { 4287 return symbol_type (token::MH_DROP, std::move (l)); 4288 } 4289 #else 4290 static 4291 symbol_type make_MH_DROP(const location_type & l)4292 make_MH_DROP (const location_type& l) 4293 { 4294 return symbol_type (token::MH_DROP, l); 4295 } 4296 #endif 4297 #if 201103L <= YY_CPLUSPLUS 4298 static 4299 symbol_type make_MH_INIT_SCALE(location_type l)4300 make_MH_INIT_SCALE (location_type l) 4301 { 4302 return symbol_type (token::MH_INIT_SCALE, std::move (l)); 4303 } 4304 #else 4305 static 4306 symbol_type make_MH_INIT_SCALE(const location_type & l)4307 make_MH_INIT_SCALE (const location_type& l) 4308 { 4309 return symbol_type (token::MH_INIT_SCALE, l); 4310 } 4311 #endif 4312 #if 201103L <= YY_CPLUSPLUS 4313 static 4314 symbol_type make_MH_JSCALE(location_type l)4315 make_MH_JSCALE (location_type l) 4316 { 4317 return symbol_type (token::MH_JSCALE, std::move (l)); 4318 } 4319 #else 4320 static 4321 symbol_type make_MH_JSCALE(const location_type & l)4322 make_MH_JSCALE (const location_type& l) 4323 { 4324 return symbol_type (token::MH_JSCALE, l); 4325 } 4326 #endif 4327 #if 201103L <= YY_CPLUSPLUS 4328 static 4329 symbol_type make_MH_TUNE_JSCALE(location_type l)4330 make_MH_TUNE_JSCALE (location_type l) 4331 { 4332 return symbol_type (token::MH_TUNE_JSCALE, std::move (l)); 4333 } 4334 #else 4335 static 4336 symbol_type make_MH_TUNE_JSCALE(const location_type & l)4337 make_MH_TUNE_JSCALE (const location_type& l) 4338 { 4339 return symbol_type (token::MH_TUNE_JSCALE, l); 4340 } 4341 #endif 4342 #if 201103L <= YY_CPLUSPLUS 4343 static 4344 symbol_type make_MH_MODE(location_type l)4345 make_MH_MODE (location_type l) 4346 { 4347 return symbol_type (token::MH_MODE, std::move (l)); 4348 } 4349 #else 4350 static 4351 symbol_type make_MH_MODE(const location_type & l)4352 make_MH_MODE (const location_type& l) 4353 { 4354 return symbol_type (token::MH_MODE, l); 4355 } 4356 #endif 4357 #if 201103L <= YY_CPLUSPLUS 4358 static 4359 symbol_type make_MH_NBLOCKS(location_type l)4360 make_MH_NBLOCKS (location_type l) 4361 { 4362 return symbol_type (token::MH_NBLOCKS, std::move (l)); 4363 } 4364 #else 4365 static 4366 symbol_type make_MH_NBLOCKS(const location_type & l)4367 make_MH_NBLOCKS (const location_type& l) 4368 { 4369 return symbol_type (token::MH_NBLOCKS, l); 4370 } 4371 #endif 4372 #if 201103L <= YY_CPLUSPLUS 4373 static 4374 symbol_type make_MH_REPLIC(location_type l)4375 make_MH_REPLIC (location_type l) 4376 { 4377 return symbol_type (token::MH_REPLIC, std::move (l)); 4378 } 4379 #else 4380 static 4381 symbol_type make_MH_REPLIC(const location_type & l)4382 make_MH_REPLIC (const location_type& l) 4383 { 4384 return symbol_type (token::MH_REPLIC, l); 4385 } 4386 #endif 4387 #if 201103L <= YY_CPLUSPLUS 4388 static 4389 symbol_type make_MH_RECOVER(location_type l)4390 make_MH_RECOVER (location_type l) 4391 { 4392 return symbol_type (token::MH_RECOVER, std::move (l)); 4393 } 4394 #else 4395 static 4396 symbol_type make_MH_RECOVER(const location_type & l)4397 make_MH_RECOVER (const location_type& l) 4398 { 4399 return symbol_type (token::MH_RECOVER, l); 4400 } 4401 #endif 4402 #if 201103L <= YY_CPLUSPLUS 4403 static 4404 symbol_type make_POSTERIOR_MAX_SUBSAMPLE_DRAWS(location_type l)4405 make_POSTERIOR_MAX_SUBSAMPLE_DRAWS (location_type l) 4406 { 4407 return symbol_type (token::POSTERIOR_MAX_SUBSAMPLE_DRAWS, std::move (l)); 4408 } 4409 #else 4410 static 4411 symbol_type make_POSTERIOR_MAX_SUBSAMPLE_DRAWS(const location_type & l)4412 make_POSTERIOR_MAX_SUBSAMPLE_DRAWS (const location_type& l) 4413 { 4414 return symbol_type (token::POSTERIOR_MAX_SUBSAMPLE_DRAWS, l); 4415 } 4416 #endif 4417 #if 201103L <= YY_CPLUSPLUS 4418 static 4419 symbol_type make_MIN(location_type l)4420 make_MIN (location_type l) 4421 { 4422 return symbol_type (token::MIN, std::move (l)); 4423 } 4424 #else 4425 static 4426 symbol_type make_MIN(const location_type & l)4427 make_MIN (const location_type& l) 4428 { 4429 return symbol_type (token::MIN, l); 4430 } 4431 #endif 4432 #if 201103L <= YY_CPLUSPLUS 4433 static 4434 symbol_type make_MINIMAL_SOLVING_PERIODS(location_type l)4435 make_MINIMAL_SOLVING_PERIODS (location_type l) 4436 { 4437 return symbol_type (token::MINIMAL_SOLVING_PERIODS, std::move (l)); 4438 } 4439 #else 4440 static 4441 symbol_type make_MINIMAL_SOLVING_PERIODS(const location_type & l)4442 make_MINIMAL_SOLVING_PERIODS (const location_type& l) 4443 { 4444 return symbol_type (token::MINIMAL_SOLVING_PERIODS, l); 4445 } 4446 #endif 4447 #if 201103L <= YY_CPLUSPLUS 4448 static 4449 symbol_type make_MODE_CHECK(location_type l)4450 make_MODE_CHECK (location_type l) 4451 { 4452 return symbol_type (token::MODE_CHECK, std::move (l)); 4453 } 4454 #else 4455 static 4456 symbol_type make_MODE_CHECK(const location_type & l)4457 make_MODE_CHECK (const location_type& l) 4458 { 4459 return symbol_type (token::MODE_CHECK, l); 4460 } 4461 #endif 4462 #if 201103L <= YY_CPLUSPLUS 4463 static 4464 symbol_type make_MODE_CHECK_NEIGHBOURHOOD_SIZE(location_type l)4465 make_MODE_CHECK_NEIGHBOURHOOD_SIZE (location_type l) 4466 { 4467 return symbol_type (token::MODE_CHECK_NEIGHBOURHOOD_SIZE, std::move (l)); 4468 } 4469 #else 4470 static 4471 symbol_type make_MODE_CHECK_NEIGHBOURHOOD_SIZE(const location_type & l)4472 make_MODE_CHECK_NEIGHBOURHOOD_SIZE (const location_type& l) 4473 { 4474 return symbol_type (token::MODE_CHECK_NEIGHBOURHOOD_SIZE, l); 4475 } 4476 #endif 4477 #if 201103L <= YY_CPLUSPLUS 4478 static 4479 symbol_type make_MODE_CHECK_SYMMETRIC_PLOTS(location_type l)4480 make_MODE_CHECK_SYMMETRIC_PLOTS (location_type l) 4481 { 4482 return symbol_type (token::MODE_CHECK_SYMMETRIC_PLOTS, std::move (l)); 4483 } 4484 #else 4485 static 4486 symbol_type make_MODE_CHECK_SYMMETRIC_PLOTS(const location_type & l)4487 make_MODE_CHECK_SYMMETRIC_PLOTS (const location_type& l) 4488 { 4489 return symbol_type (token::MODE_CHECK_SYMMETRIC_PLOTS, l); 4490 } 4491 #endif 4492 #if 201103L <= YY_CPLUSPLUS 4493 static 4494 symbol_type make_MODE_CHECK_NUMBER_OF_POINTS(location_type l)4495 make_MODE_CHECK_NUMBER_OF_POINTS (location_type l) 4496 { 4497 return symbol_type (token::MODE_CHECK_NUMBER_OF_POINTS, std::move (l)); 4498 } 4499 #else 4500 static 4501 symbol_type make_MODE_CHECK_NUMBER_OF_POINTS(const location_type & l)4502 make_MODE_CHECK_NUMBER_OF_POINTS (const location_type& l) 4503 { 4504 return symbol_type (token::MODE_CHECK_NUMBER_OF_POINTS, l); 4505 } 4506 #endif 4507 #if 201103L <= YY_CPLUSPLUS 4508 static 4509 symbol_type make_MODE_COMPUTE(location_type l)4510 make_MODE_COMPUTE (location_type l) 4511 { 4512 return symbol_type (token::MODE_COMPUTE, std::move (l)); 4513 } 4514 #else 4515 static 4516 symbol_type make_MODE_COMPUTE(const location_type & l)4517 make_MODE_COMPUTE (const location_type& l) 4518 { 4519 return symbol_type (token::MODE_COMPUTE, l); 4520 } 4521 #endif 4522 #if 201103L <= YY_CPLUSPLUS 4523 static 4524 symbol_type make_MODE_FILE(location_type l)4525 make_MODE_FILE (location_type l) 4526 { 4527 return symbol_type (token::MODE_FILE, std::move (l)); 4528 } 4529 #else 4530 static 4531 symbol_type make_MODE_FILE(const location_type & l)4532 make_MODE_FILE (const location_type& l) 4533 { 4534 return symbol_type (token::MODE_FILE, l); 4535 } 4536 #endif 4537 #if 201103L <= YY_CPLUSPLUS 4538 static 4539 symbol_type make_MODEL(location_type l)4540 make_MODEL (location_type l) 4541 { 4542 return symbol_type (token::MODEL, std::move (l)); 4543 } 4544 #else 4545 static 4546 symbol_type make_MODEL(const location_type & l)4547 make_MODEL (const location_type& l) 4548 { 4549 return symbol_type (token::MODEL, l); 4550 } 4551 #endif 4552 #if 201103L <= YY_CPLUSPLUS 4553 static 4554 symbol_type make_MODEL_COMPARISON(location_type l)4555 make_MODEL_COMPARISON (location_type l) 4556 { 4557 return symbol_type (token::MODEL_COMPARISON, std::move (l)); 4558 } 4559 #else 4560 static 4561 symbol_type make_MODEL_COMPARISON(const location_type & l)4562 make_MODEL_COMPARISON (const location_type& l) 4563 { 4564 return symbol_type (token::MODEL_COMPARISON, l); 4565 } 4566 #endif 4567 #if 201103L <= YY_CPLUSPLUS 4568 static 4569 symbol_type make_MODEL_INFO(location_type l)4570 make_MODEL_INFO (location_type l) 4571 { 4572 return symbol_type (token::MODEL_INFO, std::move (l)); 4573 } 4574 #else 4575 static 4576 symbol_type make_MODEL_INFO(const location_type & l)4577 make_MODEL_INFO (const location_type& l) 4578 { 4579 return symbol_type (token::MODEL_INFO, l); 4580 } 4581 #endif 4582 #if 201103L <= YY_CPLUSPLUS 4583 static 4584 symbol_type make_MSHOCKS(location_type l)4585 make_MSHOCKS (location_type l) 4586 { 4587 return symbol_type (token::MSHOCKS, std::move (l)); 4588 } 4589 #else 4590 static 4591 symbol_type make_MSHOCKS(const location_type & l)4592 make_MSHOCKS (const location_type& l) 4593 { 4594 return symbol_type (token::MSHOCKS, l); 4595 } 4596 #endif 4597 #if 201103L <= YY_CPLUSPLUS 4598 static 4599 symbol_type make_ABS(location_type l)4600 make_ABS (location_type l) 4601 { 4602 return symbol_type (token::ABS, std::move (l)); 4603 } 4604 #else 4605 static 4606 symbol_type make_ABS(const location_type & l)4607 make_ABS (const location_type& l) 4608 { 4609 return symbol_type (token::ABS, l); 4610 } 4611 #endif 4612 #if 201103L <= YY_CPLUSPLUS 4613 static 4614 symbol_type make_SIGN(location_type l)4615 make_SIGN (location_type l) 4616 { 4617 return symbol_type (token::SIGN, std::move (l)); 4618 } 4619 #else 4620 static 4621 symbol_type make_SIGN(const location_type & l)4622 make_SIGN (const location_type& l) 4623 { 4624 return symbol_type (token::SIGN, l); 4625 } 4626 #endif 4627 #if 201103L <= YY_CPLUSPLUS 4628 static 4629 symbol_type make_MODEL_DIAGNOSTICS(location_type l)4630 make_MODEL_DIAGNOSTICS (location_type l) 4631 { 4632 return symbol_type (token::MODEL_DIAGNOSTICS, std::move (l)); 4633 } 4634 #else 4635 static 4636 symbol_type make_MODEL_DIAGNOSTICS(const location_type & l)4637 make_MODEL_DIAGNOSTICS (const location_type& l) 4638 { 4639 return symbol_type (token::MODEL_DIAGNOSTICS, l); 4640 } 4641 #endif 4642 #if 201103L <= YY_CPLUSPLUS 4643 static 4644 symbol_type make_MODIFIEDHARMONICMEAN(location_type l)4645 make_MODIFIEDHARMONICMEAN (location_type l) 4646 { 4647 return symbol_type (token::MODIFIEDHARMONICMEAN, std::move (l)); 4648 } 4649 #else 4650 static 4651 symbol_type make_MODIFIEDHARMONICMEAN(const location_type & l)4652 make_MODIFIEDHARMONICMEAN (const location_type& l) 4653 { 4654 return symbol_type (token::MODIFIEDHARMONICMEAN, l); 4655 } 4656 #endif 4657 #if 201103L <= YY_CPLUSPLUS 4658 static 4659 symbol_type make_MOMENTS_VARENDO(location_type l)4660 make_MOMENTS_VARENDO (location_type l) 4661 { 4662 return symbol_type (token::MOMENTS_VARENDO, std::move (l)); 4663 } 4664 #else 4665 static 4666 symbol_type make_MOMENTS_VARENDO(const location_type & l)4667 make_MOMENTS_VARENDO (const location_type& l) 4668 { 4669 return symbol_type (token::MOMENTS_VARENDO, l); 4670 } 4671 #endif 4672 #if 201103L <= YY_CPLUSPLUS 4673 static 4674 symbol_type make_CONTEMPORANEOUS_CORRELATION(location_type l)4675 make_CONTEMPORANEOUS_CORRELATION (location_type l) 4676 { 4677 return symbol_type (token::CONTEMPORANEOUS_CORRELATION, std::move (l)); 4678 } 4679 #else 4680 static 4681 symbol_type make_CONTEMPORANEOUS_CORRELATION(const location_type & l)4682 make_CONTEMPORANEOUS_CORRELATION (const location_type& l) 4683 { 4684 return symbol_type (token::CONTEMPORANEOUS_CORRELATION, l); 4685 } 4686 #endif 4687 #if 201103L <= YY_CPLUSPLUS 4688 static 4689 symbol_type make_DIFFUSE_FILTER(location_type l)4690 make_DIFFUSE_FILTER (location_type l) 4691 { 4692 return symbol_type (token::DIFFUSE_FILTER, std::move (l)); 4693 } 4694 #else 4695 static 4696 symbol_type make_DIFFUSE_FILTER(const location_type & l)4697 make_DIFFUSE_FILTER (const location_type& l) 4698 { 4699 return symbol_type (token::DIFFUSE_FILTER, l); 4700 } 4701 #endif 4702 #if 201103L <= YY_CPLUSPLUS 4703 static 4704 symbol_type make_SUB_DRAWS(location_type l)4705 make_SUB_DRAWS (location_type l) 4706 { 4707 return symbol_type (token::SUB_DRAWS, std::move (l)); 4708 } 4709 #else 4710 static 4711 symbol_type make_SUB_DRAWS(const location_type & l)4712 make_SUB_DRAWS (const location_type& l) 4713 { 4714 return symbol_type (token::SUB_DRAWS, l); 4715 } 4716 #endif 4717 #if 201103L <= YY_CPLUSPLUS 4718 static 4719 symbol_type make_TAPER_STEPS(location_type l)4720 make_TAPER_STEPS (location_type l) 4721 { 4722 return symbol_type (token::TAPER_STEPS, std::move (l)); 4723 } 4724 #else 4725 static 4726 symbol_type make_TAPER_STEPS(const location_type & l)4727 make_TAPER_STEPS (const location_type& l) 4728 { 4729 return symbol_type (token::TAPER_STEPS, l); 4730 } 4731 #endif 4732 #if 201103L <= YY_CPLUSPLUS 4733 static 4734 symbol_type make_GEWEKE_INTERVAL(location_type l)4735 make_GEWEKE_INTERVAL (location_type l) 4736 { 4737 return symbol_type (token::GEWEKE_INTERVAL, std::move (l)); 4738 } 4739 #else 4740 static 4741 symbol_type make_GEWEKE_INTERVAL(const location_type & l)4742 make_GEWEKE_INTERVAL (const location_type& l) 4743 { 4744 return symbol_type (token::GEWEKE_INTERVAL, l); 4745 } 4746 #endif 4747 #if 201103L <= YY_CPLUSPLUS 4748 static 4749 symbol_type make_RAFTERY_LEWIS_QRS(location_type l)4750 make_RAFTERY_LEWIS_QRS (location_type l) 4751 { 4752 return symbol_type (token::RAFTERY_LEWIS_QRS, std::move (l)); 4753 } 4754 #else 4755 static 4756 symbol_type make_RAFTERY_LEWIS_QRS(const location_type & l)4757 make_RAFTERY_LEWIS_QRS (const location_type& l) 4758 { 4759 return symbol_type (token::RAFTERY_LEWIS_QRS, l); 4760 } 4761 #endif 4762 #if 201103L <= YY_CPLUSPLUS 4763 static 4764 symbol_type make_RAFTERY_LEWIS_DIAGNOSTICS(location_type l)4765 make_RAFTERY_LEWIS_DIAGNOSTICS (location_type l) 4766 { 4767 return symbol_type (token::RAFTERY_LEWIS_DIAGNOSTICS, std::move (l)); 4768 } 4769 #else 4770 static 4771 symbol_type make_RAFTERY_LEWIS_DIAGNOSTICS(const location_type & l)4772 make_RAFTERY_LEWIS_DIAGNOSTICS (const location_type& l) 4773 { 4774 return symbol_type (token::RAFTERY_LEWIS_DIAGNOSTICS, l); 4775 } 4776 #endif 4777 #if 201103L <= YY_CPLUSPLUS 4778 static 4779 symbol_type make_MCMC_JUMPING_COVARIANCE(location_type l)4780 make_MCMC_JUMPING_COVARIANCE (location_type l) 4781 { 4782 return symbol_type (token::MCMC_JUMPING_COVARIANCE, std::move (l)); 4783 } 4784 #else 4785 static 4786 symbol_type make_MCMC_JUMPING_COVARIANCE(const location_type & l)4787 make_MCMC_JUMPING_COVARIANCE (const location_type& l) 4788 { 4789 return symbol_type (token::MCMC_JUMPING_COVARIANCE, l); 4790 } 4791 #endif 4792 #if 201103L <= YY_CPLUSPLUS 4793 static 4794 symbol_type make_MOMENT_CALIBRATION(location_type l)4795 make_MOMENT_CALIBRATION (location_type l) 4796 { 4797 return symbol_type (token::MOMENT_CALIBRATION, std::move (l)); 4798 } 4799 #else 4800 static 4801 symbol_type make_MOMENT_CALIBRATION(const location_type & l)4802 make_MOMENT_CALIBRATION (const location_type& l) 4803 { 4804 return symbol_type (token::MOMENT_CALIBRATION, l); 4805 } 4806 #endif 4807 #if 201103L <= YY_CPLUSPLUS 4808 static 4809 symbol_type make_NUMBER_OF_PARTICLES(location_type l)4810 make_NUMBER_OF_PARTICLES (location_type l) 4811 { 4812 return symbol_type (token::NUMBER_OF_PARTICLES, std::move (l)); 4813 } 4814 #else 4815 static 4816 symbol_type make_NUMBER_OF_PARTICLES(const location_type & l)4817 make_NUMBER_OF_PARTICLES (const location_type& l) 4818 { 4819 return symbol_type (token::NUMBER_OF_PARTICLES, l); 4820 } 4821 #endif 4822 #if 201103L <= YY_CPLUSPLUS 4823 static 4824 symbol_type make_RESAMPLING(location_type l)4825 make_RESAMPLING (location_type l) 4826 { 4827 return symbol_type (token::RESAMPLING, std::move (l)); 4828 } 4829 #else 4830 static 4831 symbol_type make_RESAMPLING(const location_type & l)4832 make_RESAMPLING (const location_type& l) 4833 { 4834 return symbol_type (token::RESAMPLING, l); 4835 } 4836 #endif 4837 #if 201103L <= YY_CPLUSPLUS 4838 static 4839 symbol_type make_SYSTEMATIC(location_type l)4840 make_SYSTEMATIC (location_type l) 4841 { 4842 return symbol_type (token::SYSTEMATIC, std::move (l)); 4843 } 4844 #else 4845 static 4846 symbol_type make_SYSTEMATIC(const location_type & l)4847 make_SYSTEMATIC (const location_type& l) 4848 { 4849 return symbol_type (token::SYSTEMATIC, l); 4850 } 4851 #endif 4852 #if 201103L <= YY_CPLUSPLUS 4853 static 4854 symbol_type make_GENERIC(location_type l)4855 make_GENERIC (location_type l) 4856 { 4857 return symbol_type (token::GENERIC, std::move (l)); 4858 } 4859 #else 4860 static 4861 symbol_type make_GENERIC(const location_type & l)4862 make_GENERIC (const location_type& l) 4863 { 4864 return symbol_type (token::GENERIC, l); 4865 } 4866 #endif 4867 #if 201103L <= YY_CPLUSPLUS 4868 static 4869 symbol_type make_RESAMPLING_THRESHOLD(location_type l)4870 make_RESAMPLING_THRESHOLD (location_type l) 4871 { 4872 return symbol_type (token::RESAMPLING_THRESHOLD, std::move (l)); 4873 } 4874 #else 4875 static 4876 symbol_type make_RESAMPLING_THRESHOLD(const location_type & l)4877 make_RESAMPLING_THRESHOLD (const location_type& l) 4878 { 4879 return symbol_type (token::RESAMPLING_THRESHOLD, l); 4880 } 4881 #endif 4882 #if 201103L <= YY_CPLUSPLUS 4883 static 4884 symbol_type make_RESAMPLING_METHOD(location_type l)4885 make_RESAMPLING_METHOD (location_type l) 4886 { 4887 return symbol_type (token::RESAMPLING_METHOD, std::move (l)); 4888 } 4889 #else 4890 static 4891 symbol_type make_RESAMPLING_METHOD(const location_type & l)4892 make_RESAMPLING_METHOD (const location_type& l) 4893 { 4894 return symbol_type (token::RESAMPLING_METHOD, l); 4895 } 4896 #endif 4897 #if 201103L <= YY_CPLUSPLUS 4898 static 4899 symbol_type make_KITAGAWA(location_type l)4900 make_KITAGAWA (location_type l) 4901 { 4902 return symbol_type (token::KITAGAWA, std::move (l)); 4903 } 4904 #else 4905 static 4906 symbol_type make_KITAGAWA(const location_type & l)4907 make_KITAGAWA (const location_type& l) 4908 { 4909 return symbol_type (token::KITAGAWA, l); 4910 } 4911 #endif 4912 #if 201103L <= YY_CPLUSPLUS 4913 static 4914 symbol_type make_STRATIFIED(location_type l)4915 make_STRATIFIED (location_type l) 4916 { 4917 return symbol_type (token::STRATIFIED, std::move (l)); 4918 } 4919 #else 4920 static 4921 symbol_type make_STRATIFIED(const location_type & l)4922 make_STRATIFIED (const location_type& l) 4923 { 4924 return symbol_type (token::STRATIFIED, l); 4925 } 4926 #endif 4927 #if 201103L <= YY_CPLUSPLUS 4928 static 4929 symbol_type make_SMOOTH(location_type l)4930 make_SMOOTH (location_type l) 4931 { 4932 return symbol_type (token::SMOOTH, std::move (l)); 4933 } 4934 #else 4935 static 4936 symbol_type make_SMOOTH(const location_type & l)4937 make_SMOOTH (const location_type& l) 4938 { 4939 return symbol_type (token::SMOOTH, l); 4940 } 4941 #endif 4942 #if 201103L <= YY_CPLUSPLUS 4943 static 4944 symbol_type make_CPF_WEIGHTS(location_type l)4945 make_CPF_WEIGHTS (location_type l) 4946 { 4947 return symbol_type (token::CPF_WEIGHTS, std::move (l)); 4948 } 4949 #else 4950 static 4951 symbol_type make_CPF_WEIGHTS(const location_type & l)4952 make_CPF_WEIGHTS (const location_type& l) 4953 { 4954 return symbol_type (token::CPF_WEIGHTS, l); 4955 } 4956 #endif 4957 #if 201103L <= YY_CPLUSPLUS 4958 static 4959 symbol_type make_AMISANOTRISTANI(location_type l)4960 make_AMISANOTRISTANI (location_type l) 4961 { 4962 return symbol_type (token::AMISANOTRISTANI, std::move (l)); 4963 } 4964 #else 4965 static 4966 symbol_type make_AMISANOTRISTANI(const location_type & l)4967 make_AMISANOTRISTANI (const location_type& l) 4968 { 4969 return symbol_type (token::AMISANOTRISTANI, l); 4970 } 4971 #endif 4972 #if 201103L <= YY_CPLUSPLUS 4973 static 4974 symbol_type make_MURRAYJONESPARSLOW(location_type l)4975 make_MURRAYJONESPARSLOW (location_type l) 4976 { 4977 return symbol_type (token::MURRAYJONESPARSLOW, std::move (l)); 4978 } 4979 #else 4980 static 4981 symbol_type make_MURRAYJONESPARSLOW(const location_type & l)4982 make_MURRAYJONESPARSLOW (const location_type& l) 4983 { 4984 return symbol_type (token::MURRAYJONESPARSLOW, l); 4985 } 4986 #endif 4987 #if 201103L <= YY_CPLUSPLUS 4988 static 4989 symbol_type make_WRITE_EQUATION_TAGS(location_type l)4990 make_WRITE_EQUATION_TAGS (location_type l) 4991 { 4992 return symbol_type (token::WRITE_EQUATION_TAGS, std::move (l)); 4993 } 4994 #else 4995 static 4996 symbol_type make_WRITE_EQUATION_TAGS(const location_type & l)4997 make_WRITE_EQUATION_TAGS (const location_type& l) 4998 { 4999 return symbol_type (token::WRITE_EQUATION_TAGS, l); 5000 } 5001 #endif 5002 #if 201103L <= YY_CPLUSPLUS 5003 static 5004 symbol_type make_NONLINEAR_FILTER_INITIALIZATION(location_type l)5005 make_NONLINEAR_FILTER_INITIALIZATION (location_type l) 5006 { 5007 return symbol_type (token::NONLINEAR_FILTER_INITIALIZATION, std::move (l)); 5008 } 5009 #else 5010 static 5011 symbol_type make_NONLINEAR_FILTER_INITIALIZATION(const location_type & l)5012 make_NONLINEAR_FILTER_INITIALIZATION (const location_type& l) 5013 { 5014 return symbol_type (token::NONLINEAR_FILTER_INITIALIZATION, l); 5015 } 5016 #endif 5017 #if 201103L <= YY_CPLUSPLUS 5018 static 5019 symbol_type make_FILTER_ALGORITHM(location_type l)5020 make_FILTER_ALGORITHM (location_type l) 5021 { 5022 return symbol_type (token::FILTER_ALGORITHM, std::move (l)); 5023 } 5024 #else 5025 static 5026 symbol_type make_FILTER_ALGORITHM(const location_type & l)5027 make_FILTER_ALGORITHM (const location_type& l) 5028 { 5029 return symbol_type (token::FILTER_ALGORITHM, l); 5030 } 5031 #endif 5032 #if 201103L <= YY_CPLUSPLUS 5033 static 5034 symbol_type make_PROPOSAL_APPROXIMATION(location_type l)5035 make_PROPOSAL_APPROXIMATION (location_type l) 5036 { 5037 return symbol_type (token::PROPOSAL_APPROXIMATION, std::move (l)); 5038 } 5039 #else 5040 static 5041 symbol_type make_PROPOSAL_APPROXIMATION(const location_type & l)5042 make_PROPOSAL_APPROXIMATION (const location_type& l) 5043 { 5044 return symbol_type (token::PROPOSAL_APPROXIMATION, l); 5045 } 5046 #endif 5047 #if 201103L <= YY_CPLUSPLUS 5048 static 5049 symbol_type make_CUBATURE(location_type l)5050 make_CUBATURE (location_type l) 5051 { 5052 return symbol_type (token::CUBATURE, std::move (l)); 5053 } 5054 #else 5055 static 5056 symbol_type make_CUBATURE(const location_type & l)5057 make_CUBATURE (const location_type& l) 5058 { 5059 return symbol_type (token::CUBATURE, l); 5060 } 5061 #endif 5062 #if 201103L <= YY_CPLUSPLUS 5063 static 5064 symbol_type make_UNSCENTED(location_type l)5065 make_UNSCENTED (location_type l) 5066 { 5067 return symbol_type (token::UNSCENTED, std::move (l)); 5068 } 5069 #else 5070 static 5071 symbol_type make_UNSCENTED(const location_type & l)5072 make_UNSCENTED (const location_type& l) 5073 { 5074 return symbol_type (token::UNSCENTED, l); 5075 } 5076 #endif 5077 #if 201103L <= YY_CPLUSPLUS 5078 static 5079 symbol_type make_MONTECARLO(location_type l)5080 make_MONTECARLO (location_type l) 5081 { 5082 return symbol_type (token::MONTECARLO, std::move (l)); 5083 } 5084 #else 5085 static 5086 symbol_type make_MONTECARLO(const location_type & l)5087 make_MONTECARLO (const location_type& l) 5088 { 5089 return symbol_type (token::MONTECARLO, l); 5090 } 5091 #endif 5092 #if 201103L <= YY_CPLUSPLUS 5093 static 5094 symbol_type make_DISTRIBUTION_APPROXIMATION(location_type l)5095 make_DISTRIBUTION_APPROXIMATION (location_type l) 5096 { 5097 return symbol_type (token::DISTRIBUTION_APPROXIMATION, std::move (l)); 5098 } 5099 #else 5100 static 5101 symbol_type make_DISTRIBUTION_APPROXIMATION(const location_type & l)5102 make_DISTRIBUTION_APPROXIMATION (const location_type& l) 5103 { 5104 return symbol_type (token::DISTRIBUTION_APPROXIMATION, l); 5105 } 5106 #endif 5107 #if 201103L <= YY_CPLUSPLUS 5108 static 5109 symbol_type make_NAME(string v,location_type l)5110 make_NAME (string v, location_type l) 5111 { 5112 return symbol_type (token::NAME, std::move (v), std::move (l)); 5113 } 5114 #else 5115 static 5116 symbol_type make_NAME(const string & v,const location_type & l)5117 make_NAME (const string& v, const location_type& l) 5118 { 5119 return symbol_type (token::NAME, v, l); 5120 } 5121 #endif 5122 #if 201103L <= YY_CPLUSPLUS 5123 static 5124 symbol_type make_USE_PENALIZED_OBJECTIVE_FOR_HESSIAN(location_type l)5125 make_USE_PENALIZED_OBJECTIVE_FOR_HESSIAN (location_type l) 5126 { 5127 return symbol_type (token::USE_PENALIZED_OBJECTIVE_FOR_HESSIAN, std::move (l)); 5128 } 5129 #else 5130 static 5131 symbol_type make_USE_PENALIZED_OBJECTIVE_FOR_HESSIAN(const location_type & l)5132 make_USE_PENALIZED_OBJECTIVE_FOR_HESSIAN (const location_type& l) 5133 { 5134 return symbol_type (token::USE_PENALIZED_OBJECTIVE_FOR_HESSIAN, l); 5135 } 5136 #endif 5137 #if 201103L <= YY_CPLUSPLUS 5138 static 5139 symbol_type make_INIT_STATE(location_type l)5140 make_INIT_STATE (location_type l) 5141 { 5142 return symbol_type (token::INIT_STATE, std::move (l)); 5143 } 5144 #else 5145 static 5146 symbol_type make_INIT_STATE(const location_type & l)5147 make_INIT_STATE (const location_type& l) 5148 { 5149 return symbol_type (token::INIT_STATE, l); 5150 } 5151 #endif 5152 #if 201103L <= YY_CPLUSPLUS 5153 static 5154 symbol_type make_FAST_REALTIME(location_type l)5155 make_FAST_REALTIME (location_type l) 5156 { 5157 return symbol_type (token::FAST_REALTIME, std::move (l)); 5158 } 5159 #else 5160 static 5161 symbol_type make_FAST_REALTIME(const location_type & l)5162 make_FAST_REALTIME (const location_type& l) 5163 { 5164 return symbol_type (token::FAST_REALTIME, l); 5165 } 5166 #endif 5167 #if 201103L <= YY_CPLUSPLUS 5168 static 5169 symbol_type make_RESCALE_PREDICTION_ERROR_COVARIANCE(location_type l)5170 make_RESCALE_PREDICTION_ERROR_COVARIANCE (location_type l) 5171 { 5172 return symbol_type (token::RESCALE_PREDICTION_ERROR_COVARIANCE, std::move (l)); 5173 } 5174 #else 5175 static 5176 symbol_type make_RESCALE_PREDICTION_ERROR_COVARIANCE(const location_type & l)5177 make_RESCALE_PREDICTION_ERROR_COVARIANCE (const location_type& l) 5178 { 5179 return symbol_type (token::RESCALE_PREDICTION_ERROR_COVARIANCE, l); 5180 } 5181 #endif 5182 #if 201103L <= YY_CPLUSPLUS 5183 static 5184 symbol_type make_GENERATE_IRFS(location_type l)5185 make_GENERATE_IRFS (location_type l) 5186 { 5187 return symbol_type (token::GENERATE_IRFS, std::move (l)); 5188 } 5189 #else 5190 static 5191 symbol_type make_GENERATE_IRFS(const location_type & l)5192 make_GENERATE_IRFS (const location_type& l) 5193 { 5194 return symbol_type (token::GENERATE_IRFS, l); 5195 } 5196 #endif 5197 #if 201103L <= YY_CPLUSPLUS 5198 static 5199 symbol_type make_NAN_CONSTANT(location_type l)5200 make_NAN_CONSTANT (location_type l) 5201 { 5202 return symbol_type (token::NAN_CONSTANT, std::move (l)); 5203 } 5204 #else 5205 static 5206 symbol_type make_NAN_CONSTANT(const location_type & l)5207 make_NAN_CONSTANT (const location_type& l) 5208 { 5209 return symbol_type (token::NAN_CONSTANT, l); 5210 } 5211 #endif 5212 #if 201103L <= YY_CPLUSPLUS 5213 static 5214 symbol_type make_NO_STATIC(location_type l)5215 make_NO_STATIC (location_type l) 5216 { 5217 return symbol_type (token::NO_STATIC, std::move (l)); 5218 } 5219 #else 5220 static 5221 symbol_type make_NO_STATIC(const location_type & l)5222 make_NO_STATIC (const location_type& l) 5223 { 5224 return symbol_type (token::NO_STATIC, l); 5225 } 5226 #endif 5227 #if 201103L <= YY_CPLUSPLUS 5228 static 5229 symbol_type make_NOBS(location_type l)5230 make_NOBS (location_type l) 5231 { 5232 return symbol_type (token::NOBS, std::move (l)); 5233 } 5234 #else 5235 static 5236 symbol_type make_NOBS(const location_type & l)5237 make_NOBS (const location_type& l) 5238 { 5239 return symbol_type (token::NOBS, l); 5240 } 5241 #endif 5242 #if 201103L <= YY_CPLUSPLUS 5243 static 5244 symbol_type make_NOCONSTANT(location_type l)5245 make_NOCONSTANT (location_type l) 5246 { 5247 return symbol_type (token::NOCONSTANT, std::move (l)); 5248 } 5249 #else 5250 static 5251 symbol_type make_NOCONSTANT(const location_type & l)5252 make_NOCONSTANT (const location_type& l) 5253 { 5254 return symbol_type (token::NOCONSTANT, l); 5255 } 5256 #endif 5257 #if 201103L <= YY_CPLUSPLUS 5258 static 5259 symbol_type make_NODISPLAY(location_type l)5260 make_NODISPLAY (location_type l) 5261 { 5262 return symbol_type (token::NODISPLAY, std::move (l)); 5263 } 5264 #else 5265 static 5266 symbol_type make_NODISPLAY(const location_type & l)5267 make_NODISPLAY (const location_type& l) 5268 { 5269 return symbol_type (token::NODISPLAY, l); 5270 } 5271 #endif 5272 #if 201103L <= YY_CPLUSPLUS 5273 static 5274 symbol_type make_NOCORR(location_type l)5275 make_NOCORR (location_type l) 5276 { 5277 return symbol_type (token::NOCORR, std::move (l)); 5278 } 5279 #else 5280 static 5281 symbol_type make_NOCORR(const location_type & l)5282 make_NOCORR (const location_type& l) 5283 { 5284 return symbol_type (token::NOCORR, l); 5285 } 5286 #endif 5287 #if 201103L <= YY_CPLUSPLUS 5288 static 5289 symbol_type make_NODIAGNOSTIC(location_type l)5290 make_NODIAGNOSTIC (location_type l) 5291 { 5292 return symbol_type (token::NODIAGNOSTIC, std::move (l)); 5293 } 5294 #else 5295 static 5296 symbol_type make_NODIAGNOSTIC(const location_type & l)5297 make_NODIAGNOSTIC (const location_type& l) 5298 { 5299 return symbol_type (token::NODIAGNOSTIC, l); 5300 } 5301 #endif 5302 #if 201103L <= YY_CPLUSPLUS 5303 static 5304 symbol_type make_NOFUNCTIONS(location_type l)5305 make_NOFUNCTIONS (location_type l) 5306 { 5307 return symbol_type (token::NOFUNCTIONS, std::move (l)); 5308 } 5309 #else 5310 static 5311 symbol_type make_NOFUNCTIONS(const location_type & l)5312 make_NOFUNCTIONS (const location_type& l) 5313 { 5314 return symbol_type (token::NOFUNCTIONS, l); 5315 } 5316 #endif 5317 #if 201103L <= YY_CPLUSPLUS 5318 static 5319 symbol_type make_NO_HOMOTOPY(location_type l)5320 make_NO_HOMOTOPY (location_type l) 5321 { 5322 return symbol_type (token::NO_HOMOTOPY, std::move (l)); 5323 } 5324 #else 5325 static 5326 symbol_type make_NO_HOMOTOPY(const location_type & l)5327 make_NO_HOMOTOPY (const location_type& l) 5328 { 5329 return symbol_type (token::NO_HOMOTOPY, l); 5330 } 5331 #endif 5332 #if 201103L <= YY_CPLUSPLUS 5333 static 5334 symbol_type make_NOGRAPH(location_type l)5335 make_NOGRAPH (location_type l) 5336 { 5337 return symbol_type (token::NOGRAPH, std::move (l)); 5338 } 5339 #else 5340 static 5341 symbol_type make_NOGRAPH(const location_type & l)5342 make_NOGRAPH (const location_type& l) 5343 { 5344 return symbol_type (token::NOGRAPH, l); 5345 } 5346 #endif 5347 #if 201103L <= YY_CPLUSPLUS 5348 static 5349 symbol_type make_POSTERIOR_NOGRAPH(location_type l)5350 make_POSTERIOR_NOGRAPH (location_type l) 5351 { 5352 return symbol_type (token::POSTERIOR_NOGRAPH, std::move (l)); 5353 } 5354 #else 5355 static 5356 symbol_type make_POSTERIOR_NOGRAPH(const location_type & l)5357 make_POSTERIOR_NOGRAPH (const location_type& l) 5358 { 5359 return symbol_type (token::POSTERIOR_NOGRAPH, l); 5360 } 5361 #endif 5362 #if 201103L <= YY_CPLUSPLUS 5363 static 5364 symbol_type make_POSTERIOR_GRAPH(location_type l)5365 make_POSTERIOR_GRAPH (location_type l) 5366 { 5367 return symbol_type (token::POSTERIOR_GRAPH, std::move (l)); 5368 } 5369 #else 5370 static 5371 symbol_type make_POSTERIOR_GRAPH(const location_type & l)5372 make_POSTERIOR_GRAPH (const location_type& l) 5373 { 5374 return symbol_type (token::POSTERIOR_GRAPH, l); 5375 } 5376 #endif 5377 #if 201103L <= YY_CPLUSPLUS 5378 static 5379 symbol_type make_NOMOMENTS(location_type l)5380 make_NOMOMENTS (location_type l) 5381 { 5382 return symbol_type (token::NOMOMENTS, std::move (l)); 5383 } 5384 #else 5385 static 5386 symbol_type make_NOMOMENTS(const location_type & l)5387 make_NOMOMENTS (const location_type& l) 5388 { 5389 return symbol_type (token::NOMOMENTS, l); 5390 } 5391 #endif 5392 #if 201103L <= YY_CPLUSPLUS 5393 static 5394 symbol_type make_NOPRINT(location_type l)5395 make_NOPRINT (location_type l) 5396 { 5397 return symbol_type (token::NOPRINT, std::move (l)); 5398 } 5399 #else 5400 static 5401 symbol_type make_NOPRINT(const location_type & l)5402 make_NOPRINT (const location_type& l) 5403 { 5404 return symbol_type (token::NOPRINT, l); 5405 } 5406 #endif 5407 #if 201103L <= YY_CPLUSPLUS 5408 static 5409 symbol_type make_NORMAL_PDF(location_type l)5410 make_NORMAL_PDF (location_type l) 5411 { 5412 return symbol_type (token::NORMAL_PDF, std::move (l)); 5413 } 5414 #else 5415 static 5416 symbol_type make_NORMAL_PDF(const location_type & l)5417 make_NORMAL_PDF (const location_type& l) 5418 { 5419 return symbol_type (token::NORMAL_PDF, l); 5420 } 5421 #endif 5422 #if 201103L <= YY_CPLUSPLUS 5423 static 5424 symbol_type make_SAVE_DRAWS(location_type l)5425 make_SAVE_DRAWS (location_type l) 5426 { 5427 return symbol_type (token::SAVE_DRAWS, std::move (l)); 5428 } 5429 #else 5430 static 5431 symbol_type make_SAVE_DRAWS(const location_type & l)5432 make_SAVE_DRAWS (const location_type& l) 5433 { 5434 return symbol_type (token::SAVE_DRAWS, l); 5435 } 5436 #endif 5437 #if 201103L <= YY_CPLUSPLUS 5438 static 5439 symbol_type make_MODEL_NAME(location_type l)5440 make_MODEL_NAME (location_type l) 5441 { 5442 return symbol_type (token::MODEL_NAME, std::move (l)); 5443 } 5444 #else 5445 static 5446 symbol_type make_MODEL_NAME(const location_type & l)5447 make_MODEL_NAME (const location_type& l) 5448 { 5449 return symbol_type (token::MODEL_NAME, l); 5450 } 5451 #endif 5452 #if 201103L <= YY_CPLUSPLUS 5453 static 5454 symbol_type make_STDERR_MULTIPLES(location_type l)5455 make_STDERR_MULTIPLES (location_type l) 5456 { 5457 return symbol_type (token::STDERR_MULTIPLES, std::move (l)); 5458 } 5459 #else 5460 static 5461 symbol_type make_STDERR_MULTIPLES(const location_type & l)5462 make_STDERR_MULTIPLES (const location_type& l) 5463 { 5464 return symbol_type (token::STDERR_MULTIPLES, l); 5465 } 5466 #endif 5467 #if 201103L <= YY_CPLUSPLUS 5468 static 5469 symbol_type make_DIAGONAL_ONLY(location_type l)5470 make_DIAGONAL_ONLY (location_type l) 5471 { 5472 return symbol_type (token::DIAGONAL_ONLY, std::move (l)); 5473 } 5474 #else 5475 static 5476 symbol_type make_DIAGONAL_ONLY(const location_type & l)5477 make_DIAGONAL_ONLY (const location_type& l) 5478 { 5479 return symbol_type (token::DIAGONAL_ONLY, l); 5480 } 5481 #endif 5482 #if 201103L <= YY_CPLUSPLUS 5483 static 5484 symbol_type make_OBSERVATION_TRENDS(location_type l)5485 make_OBSERVATION_TRENDS (location_type l) 5486 { 5487 return symbol_type (token::OBSERVATION_TRENDS, std::move (l)); 5488 } 5489 #else 5490 static 5491 symbol_type make_OBSERVATION_TRENDS(const location_type & l)5492 make_OBSERVATION_TRENDS (const location_type& l) 5493 { 5494 return symbol_type (token::OBSERVATION_TRENDS, l); 5495 } 5496 #endif 5497 #if 201103L <= YY_CPLUSPLUS 5498 static 5499 symbol_type make_OPTIM(location_type l)5500 make_OPTIM (location_type l) 5501 { 5502 return symbol_type (token::OPTIM, std::move (l)); 5503 } 5504 #else 5505 static 5506 symbol_type make_OPTIM(const location_type & l)5507 make_OPTIM (const location_type& l) 5508 { 5509 return symbol_type (token::OPTIM, l); 5510 } 5511 #endif 5512 #if 201103L <= YY_CPLUSPLUS 5513 static 5514 symbol_type make_OPTIM_WEIGHTS(location_type l)5515 make_OPTIM_WEIGHTS (location_type l) 5516 { 5517 return symbol_type (token::OPTIM_WEIGHTS, std::move (l)); 5518 } 5519 #else 5520 static 5521 symbol_type make_OPTIM_WEIGHTS(const location_type & l)5522 make_OPTIM_WEIGHTS (const location_type& l) 5523 { 5524 return symbol_type (token::OPTIM_WEIGHTS, l); 5525 } 5526 #endif 5527 #if 201103L <= YY_CPLUSPLUS 5528 static 5529 symbol_type make_ORDER(location_type l)5530 make_ORDER (location_type l) 5531 { 5532 return symbol_type (token::ORDER, std::move (l)); 5533 } 5534 #else 5535 static 5536 symbol_type make_ORDER(const location_type & l)5537 make_ORDER (const location_type& l) 5538 { 5539 return symbol_type (token::ORDER, l); 5540 } 5541 #endif 5542 #if 201103L <= YY_CPLUSPLUS 5543 static 5544 symbol_type make_OSR(location_type l)5545 make_OSR (location_type l) 5546 { 5547 return symbol_type (token::OSR, std::move (l)); 5548 } 5549 #else 5550 static 5551 symbol_type make_OSR(const location_type & l)5552 make_OSR (const location_type& l) 5553 { 5554 return symbol_type (token::OSR, l); 5555 } 5556 #endif 5557 #if 201103L <= YY_CPLUSPLUS 5558 static 5559 symbol_type make_OSR_PARAMS(location_type l)5560 make_OSR_PARAMS (location_type l) 5561 { 5562 return symbol_type (token::OSR_PARAMS, std::move (l)); 5563 } 5564 #else 5565 static 5566 symbol_type make_OSR_PARAMS(const location_type & l)5567 make_OSR_PARAMS (const location_type& l) 5568 { 5569 return symbol_type (token::OSR_PARAMS, l); 5570 } 5571 #endif 5572 #if 201103L <= YY_CPLUSPLUS 5573 static 5574 symbol_type make_MAX_DIM_COVA_GROUP(location_type l)5575 make_MAX_DIM_COVA_GROUP (location_type l) 5576 { 5577 return symbol_type (token::MAX_DIM_COVA_GROUP, std::move (l)); 5578 } 5579 #else 5580 static 5581 symbol_type make_MAX_DIM_COVA_GROUP(const location_type & l)5582 make_MAX_DIM_COVA_GROUP (const location_type& l) 5583 { 5584 return symbol_type (token::MAX_DIM_COVA_GROUP, l); 5585 } 5586 #endif 5587 #if 201103L <= YY_CPLUSPLUS 5588 static 5589 symbol_type make_ADVANCED(location_type l)5590 make_ADVANCED (location_type l) 5591 { 5592 return symbol_type (token::ADVANCED, std::move (l)); 5593 } 5594 #else 5595 static 5596 symbol_type make_ADVANCED(const location_type & l)5597 make_ADVANCED (const location_type& l) 5598 { 5599 return symbol_type (token::ADVANCED, l); 5600 } 5601 #endif 5602 #if 201103L <= YY_CPLUSPLUS 5603 static 5604 symbol_type make_OUTFILE(location_type l)5605 make_OUTFILE (location_type l) 5606 { 5607 return symbol_type (token::OUTFILE, std::move (l)); 5608 } 5609 #else 5610 static 5611 symbol_type make_OUTFILE(const location_type & l)5612 make_OUTFILE (const location_type& l) 5613 { 5614 return symbol_type (token::OUTFILE, l); 5615 } 5616 #endif 5617 #if 201103L <= YY_CPLUSPLUS 5618 static 5619 symbol_type make_OUTVARS(location_type l)5620 make_OUTVARS (location_type l) 5621 { 5622 return symbol_type (token::OUTVARS, std::move (l)); 5623 } 5624 #else 5625 static 5626 symbol_type make_OUTVARS(const location_type & l)5627 make_OUTVARS (const location_type& l) 5628 { 5629 return symbol_type (token::OUTVARS, l); 5630 } 5631 #endif 5632 #if 201103L <= YY_CPLUSPLUS 5633 static 5634 symbol_type make_OVERWRITE(location_type l)5635 make_OVERWRITE (location_type l) 5636 { 5637 return symbol_type (token::OVERWRITE, std::move (l)); 5638 } 5639 #else 5640 static 5641 symbol_type make_OVERWRITE(const location_type & l)5642 make_OVERWRITE (const location_type& l) 5643 { 5644 return symbol_type (token::OVERWRITE, l); 5645 } 5646 #endif 5647 #if 201103L <= YY_CPLUSPLUS 5648 static 5649 symbol_type make_DISCOUNT(location_type l)5650 make_DISCOUNT (location_type l) 5651 { 5652 return symbol_type (token::DISCOUNT, std::move (l)); 5653 } 5654 #else 5655 static 5656 symbol_type make_DISCOUNT(const location_type & l)5657 make_DISCOUNT (const location_type& l) 5658 { 5659 return symbol_type (token::DISCOUNT, l); 5660 } 5661 #endif 5662 #if 201103L <= YY_CPLUSPLUS 5663 static 5664 symbol_type make_PARALLEL_LOCAL_FILES(location_type l)5665 make_PARALLEL_LOCAL_FILES (location_type l) 5666 { 5667 return symbol_type (token::PARALLEL_LOCAL_FILES, std::move (l)); 5668 } 5669 #else 5670 static 5671 symbol_type make_PARALLEL_LOCAL_FILES(const location_type & l)5672 make_PARALLEL_LOCAL_FILES (const location_type& l) 5673 { 5674 return symbol_type (token::PARALLEL_LOCAL_FILES, l); 5675 } 5676 #endif 5677 #if 201103L <= YY_CPLUSPLUS 5678 static 5679 symbol_type make_PARAMETERS(location_type l)5680 make_PARAMETERS (location_type l) 5681 { 5682 return symbol_type (token::PARAMETERS, std::move (l)); 5683 } 5684 #else 5685 static 5686 symbol_type make_PARAMETERS(const location_type & l)5687 make_PARAMETERS (const location_type& l) 5688 { 5689 return symbol_type (token::PARAMETERS, l); 5690 } 5691 #endif 5692 #if 201103L <= YY_CPLUSPLUS 5693 static 5694 symbol_type make_PARAMETER_SET(location_type l)5695 make_PARAMETER_SET (location_type l) 5696 { 5697 return symbol_type (token::PARAMETER_SET, std::move (l)); 5698 } 5699 #else 5700 static 5701 symbol_type make_PARAMETER_SET(const location_type & l)5702 make_PARAMETER_SET (const location_type& l) 5703 { 5704 return symbol_type (token::PARAMETER_SET, l); 5705 } 5706 #endif 5707 #if 201103L <= YY_CPLUSPLUS 5708 static 5709 symbol_type make_PARTIAL_INFORMATION(location_type l)5710 make_PARTIAL_INFORMATION (location_type l) 5711 { 5712 return symbol_type (token::PARTIAL_INFORMATION, std::move (l)); 5713 } 5714 #else 5715 static 5716 symbol_type make_PARTIAL_INFORMATION(const location_type & l)5717 make_PARTIAL_INFORMATION (const location_type& l) 5718 { 5719 return symbol_type (token::PARTIAL_INFORMATION, l); 5720 } 5721 #endif 5722 #if 201103L <= YY_CPLUSPLUS 5723 static 5724 symbol_type make_PERIODS(location_type l)5725 make_PERIODS (location_type l) 5726 { 5727 return symbol_type (token::PERIODS, std::move (l)); 5728 } 5729 #else 5730 static 5731 symbol_type make_PERIODS(const location_type & l)5732 make_PERIODS (const location_type& l) 5733 { 5734 return symbol_type (token::PERIODS, l); 5735 } 5736 #endif 5737 #if 201103L <= YY_CPLUSPLUS 5738 static 5739 symbol_type make_PERIOD(location_type l)5740 make_PERIOD (location_type l) 5741 { 5742 return symbol_type (token::PERIOD, std::move (l)); 5743 } 5744 #else 5745 static 5746 symbol_type make_PERIOD(const location_type & l)5747 make_PERIOD (const location_type& l) 5748 { 5749 return symbol_type (token::PERIOD, l); 5750 } 5751 #endif 5752 #if 201103L <= YY_CPLUSPLUS 5753 static 5754 symbol_type make_PLANNER_OBJECTIVE(location_type l)5755 make_PLANNER_OBJECTIVE (location_type l) 5756 { 5757 return symbol_type (token::PLANNER_OBJECTIVE, std::move (l)); 5758 } 5759 #else 5760 static 5761 symbol_type make_PLANNER_OBJECTIVE(const location_type & l)5762 make_PLANNER_OBJECTIVE (const location_type& l) 5763 { 5764 return symbol_type (token::PLANNER_OBJECTIVE, l); 5765 } 5766 #endif 5767 #if 201103L <= YY_CPLUSPLUS 5768 static 5769 symbol_type make_PLOT_CONDITIONAL_FORECAST(location_type l)5770 make_PLOT_CONDITIONAL_FORECAST (location_type l) 5771 { 5772 return symbol_type (token::PLOT_CONDITIONAL_FORECAST, std::move (l)); 5773 } 5774 #else 5775 static 5776 symbol_type make_PLOT_CONDITIONAL_FORECAST(const location_type & l)5777 make_PLOT_CONDITIONAL_FORECAST (const location_type& l) 5778 { 5779 return symbol_type (token::PLOT_CONDITIONAL_FORECAST, l); 5780 } 5781 #endif 5782 #if 201103L <= YY_CPLUSPLUS 5783 static 5784 symbol_type make_PLOT_PRIORS(location_type l)5785 make_PLOT_PRIORS (location_type l) 5786 { 5787 return symbol_type (token::PLOT_PRIORS, std::move (l)); 5788 } 5789 #else 5790 static 5791 symbol_type make_PLOT_PRIORS(const location_type & l)5792 make_PLOT_PRIORS (const location_type& l) 5793 { 5794 return symbol_type (token::PLOT_PRIORS, l); 5795 } 5796 #endif 5797 #if 201103L <= YY_CPLUSPLUS 5798 static 5799 symbol_type make_PREFILTER(location_type l)5800 make_PREFILTER (location_type l) 5801 { 5802 return symbol_type (token::PREFILTER, std::move (l)); 5803 } 5804 #else 5805 static 5806 symbol_type make_PREFILTER(const location_type & l)5807 make_PREFILTER (const location_type& l) 5808 { 5809 return symbol_type (token::PREFILTER, l); 5810 } 5811 #endif 5812 #if 201103L <= YY_CPLUSPLUS 5813 static 5814 symbol_type make_PRESAMPLE(location_type l)5815 make_PRESAMPLE (location_type l) 5816 { 5817 return symbol_type (token::PRESAMPLE, std::move (l)); 5818 } 5819 #else 5820 static 5821 symbol_type make_PRESAMPLE(const location_type & l)5822 make_PRESAMPLE (const location_type& l) 5823 { 5824 return symbol_type (token::PRESAMPLE, l); 5825 } 5826 #endif 5827 #if 201103L <= YY_CPLUSPLUS 5828 static 5829 symbol_type make_PERFECT_FORESIGHT_SETUP(location_type l)5830 make_PERFECT_FORESIGHT_SETUP (location_type l) 5831 { 5832 return symbol_type (token::PERFECT_FORESIGHT_SETUP, std::move (l)); 5833 } 5834 #else 5835 static 5836 symbol_type make_PERFECT_FORESIGHT_SETUP(const location_type & l)5837 make_PERFECT_FORESIGHT_SETUP (const location_type& l) 5838 { 5839 return symbol_type (token::PERFECT_FORESIGHT_SETUP, l); 5840 } 5841 #endif 5842 #if 201103L <= YY_CPLUSPLUS 5843 static 5844 symbol_type make_PERFECT_FORESIGHT_SOLVER(location_type l)5845 make_PERFECT_FORESIGHT_SOLVER (location_type l) 5846 { 5847 return symbol_type (token::PERFECT_FORESIGHT_SOLVER, std::move (l)); 5848 } 5849 #else 5850 static 5851 symbol_type make_PERFECT_FORESIGHT_SOLVER(const location_type & l)5852 make_PERFECT_FORESIGHT_SOLVER (const location_type& l) 5853 { 5854 return symbol_type (token::PERFECT_FORESIGHT_SOLVER, l); 5855 } 5856 #endif 5857 #if 201103L <= YY_CPLUSPLUS 5858 static 5859 symbol_type make_NO_POSTERIOR_KERNEL_DENSITY(location_type l)5860 make_NO_POSTERIOR_KERNEL_DENSITY (location_type l) 5861 { 5862 return symbol_type (token::NO_POSTERIOR_KERNEL_DENSITY, std::move (l)); 5863 } 5864 #else 5865 static 5866 symbol_type make_NO_POSTERIOR_KERNEL_DENSITY(const location_type & l)5867 make_NO_POSTERIOR_KERNEL_DENSITY (const location_type& l) 5868 { 5869 return symbol_type (token::NO_POSTERIOR_KERNEL_DENSITY, l); 5870 } 5871 #endif 5872 #if 201103L <= YY_CPLUSPLUS 5873 static 5874 symbol_type make_FUNCTION(location_type l)5875 make_FUNCTION (location_type l) 5876 { 5877 return symbol_type (token::FUNCTION, std::move (l)); 5878 } 5879 #else 5880 static 5881 symbol_type make_FUNCTION(const location_type & l)5882 make_FUNCTION (const location_type& l) 5883 { 5884 return symbol_type (token::FUNCTION, l); 5885 } 5886 #endif 5887 #if 201103L <= YY_CPLUSPLUS 5888 static 5889 symbol_type make_PRINT(location_type l)5890 make_PRINT (location_type l) 5891 { 5892 return symbol_type (token::PRINT, std::move (l)); 5893 } 5894 #else 5895 static 5896 symbol_type make_PRINT(const location_type & l)5897 make_PRINT (const location_type& l) 5898 { 5899 return symbol_type (token::PRINT, l); 5900 } 5901 #endif 5902 #if 201103L <= YY_CPLUSPLUS 5903 static 5904 symbol_type make_PRIOR_MC(location_type l)5905 make_PRIOR_MC (location_type l) 5906 { 5907 return symbol_type (token::PRIOR_MC, std::move (l)); 5908 } 5909 #else 5910 static 5911 symbol_type make_PRIOR_MC(const location_type & l)5912 make_PRIOR_MC (const location_type& l) 5913 { 5914 return symbol_type (token::PRIOR_MC, l); 5915 } 5916 #endif 5917 #if 201103L <= YY_CPLUSPLUS 5918 static 5919 symbol_type make_PRIOR_TRUNC(location_type l)5920 make_PRIOR_TRUNC (location_type l) 5921 { 5922 return symbol_type (token::PRIOR_TRUNC, std::move (l)); 5923 } 5924 #else 5925 static 5926 symbol_type make_PRIOR_TRUNC(const location_type & l)5927 make_PRIOR_TRUNC (const location_type& l) 5928 { 5929 return symbol_type (token::PRIOR_TRUNC, l); 5930 } 5931 #endif 5932 #if 201103L <= YY_CPLUSPLUS 5933 static 5934 symbol_type make_PRIOR_MODE(location_type l)5935 make_PRIOR_MODE (location_type l) 5936 { 5937 return symbol_type (token::PRIOR_MODE, std::move (l)); 5938 } 5939 #else 5940 static 5941 symbol_type make_PRIOR_MODE(const location_type & l)5942 make_PRIOR_MODE (const location_type& l) 5943 { 5944 return symbol_type (token::PRIOR_MODE, l); 5945 } 5946 #endif 5947 #if 201103L <= YY_CPLUSPLUS 5948 static 5949 symbol_type make_PRIOR_MEAN(location_type l)5950 make_PRIOR_MEAN (location_type l) 5951 { 5952 return symbol_type (token::PRIOR_MEAN, std::move (l)); 5953 } 5954 #else 5955 static 5956 symbol_type make_PRIOR_MEAN(const location_type & l)5957 make_PRIOR_MEAN (const location_type& l) 5958 { 5959 return symbol_type (token::PRIOR_MEAN, l); 5960 } 5961 #endif 5962 #if 201103L <= YY_CPLUSPLUS 5963 static 5964 symbol_type make_POSTERIOR_MODE(location_type l)5965 make_POSTERIOR_MODE (location_type l) 5966 { 5967 return symbol_type (token::POSTERIOR_MODE, std::move (l)); 5968 } 5969 #else 5970 static 5971 symbol_type make_POSTERIOR_MODE(const location_type & l)5972 make_POSTERIOR_MODE (const location_type& l) 5973 { 5974 return symbol_type (token::POSTERIOR_MODE, l); 5975 } 5976 #endif 5977 #if 201103L <= YY_CPLUSPLUS 5978 static 5979 symbol_type make_POSTERIOR_MEAN(location_type l)5980 make_POSTERIOR_MEAN (location_type l) 5981 { 5982 return symbol_type (token::POSTERIOR_MEAN, std::move (l)); 5983 } 5984 #else 5985 static 5986 symbol_type make_POSTERIOR_MEAN(const location_type & l)5987 make_POSTERIOR_MEAN (const location_type& l) 5988 { 5989 return symbol_type (token::POSTERIOR_MEAN, l); 5990 } 5991 #endif 5992 #if 201103L <= YY_CPLUSPLUS 5993 static 5994 symbol_type make_POSTERIOR_MEDIAN(location_type l)5995 make_POSTERIOR_MEDIAN (location_type l) 5996 { 5997 return symbol_type (token::POSTERIOR_MEDIAN, std::move (l)); 5998 } 5999 #else 6000 static 6001 symbol_type make_POSTERIOR_MEDIAN(const location_type & l)6002 make_POSTERIOR_MEDIAN (const location_type& l) 6003 { 6004 return symbol_type (token::POSTERIOR_MEDIAN, l); 6005 } 6006 #endif 6007 #if 201103L <= YY_CPLUSPLUS 6008 static 6009 symbol_type make_MLE_MODE(location_type l)6010 make_MLE_MODE (location_type l) 6011 { 6012 return symbol_type (token::MLE_MODE, std::move (l)); 6013 } 6014 #else 6015 static 6016 symbol_type make_MLE_MODE(const location_type & l)6017 make_MLE_MODE (const location_type& l) 6018 { 6019 return symbol_type (token::MLE_MODE, l); 6020 } 6021 #endif 6022 #if 201103L <= YY_CPLUSPLUS 6023 static 6024 symbol_type make_PRUNING(location_type l)6025 make_PRUNING (location_type l) 6026 { 6027 return symbol_type (token::PRUNING, std::move (l)); 6028 } 6029 #else 6030 static 6031 symbol_type make_PRUNING(const location_type & l)6032 make_PRUNING (const location_type& l) 6033 { 6034 return symbol_type (token::PRUNING, l); 6035 } 6036 #endif 6037 #if 201103L <= YY_CPLUSPLUS 6038 static 6039 symbol_type make_QUOTED_STRING(string v,location_type l)6040 make_QUOTED_STRING (string v, location_type l) 6041 { 6042 return symbol_type (token::QUOTED_STRING, std::move (v), std::move (l)); 6043 } 6044 #else 6045 static 6046 symbol_type make_QUOTED_STRING(const string & v,const location_type & l)6047 make_QUOTED_STRING (const string& v, const location_type& l) 6048 { 6049 return symbol_type (token::QUOTED_STRING, v, l); 6050 } 6051 #endif 6052 #if 201103L <= YY_CPLUSPLUS 6053 static 6054 symbol_type make_QZ_CRITERIUM(location_type l)6055 make_QZ_CRITERIUM (location_type l) 6056 { 6057 return symbol_type (token::QZ_CRITERIUM, std::move (l)); 6058 } 6059 #else 6060 static 6061 symbol_type make_QZ_CRITERIUM(const location_type & l)6062 make_QZ_CRITERIUM (const location_type& l) 6063 { 6064 return symbol_type (token::QZ_CRITERIUM, l); 6065 } 6066 #endif 6067 #if 201103L <= YY_CPLUSPLUS 6068 static 6069 symbol_type make_QZ_ZERO_THRESHOLD(location_type l)6070 make_QZ_ZERO_THRESHOLD (location_type l) 6071 { 6072 return symbol_type (token::QZ_ZERO_THRESHOLD, std::move (l)); 6073 } 6074 #else 6075 static 6076 symbol_type make_QZ_ZERO_THRESHOLD(const location_type & l)6077 make_QZ_ZERO_THRESHOLD (const location_type& l) 6078 { 6079 return symbol_type (token::QZ_ZERO_THRESHOLD, l); 6080 } 6081 #endif 6082 #if 201103L <= YY_CPLUSPLUS 6083 static 6084 symbol_type make_DSGE_VAR(location_type l)6085 make_DSGE_VAR (location_type l) 6086 { 6087 return symbol_type (token::DSGE_VAR, std::move (l)); 6088 } 6089 #else 6090 static 6091 symbol_type make_DSGE_VAR(const location_type & l)6092 make_DSGE_VAR (const location_type& l) 6093 { 6094 return symbol_type (token::DSGE_VAR, l); 6095 } 6096 #endif 6097 #if 201103L <= YY_CPLUSPLUS 6098 static 6099 symbol_type make_DSGE_VARLAG(location_type l)6100 make_DSGE_VARLAG (location_type l) 6101 { 6102 return symbol_type (token::DSGE_VARLAG, std::move (l)); 6103 } 6104 #else 6105 static 6106 symbol_type make_DSGE_VARLAG(const location_type & l)6107 make_DSGE_VARLAG (const location_type& l) 6108 { 6109 return symbol_type (token::DSGE_VARLAG, l); 6110 } 6111 #endif 6112 #if 201103L <= YY_CPLUSPLUS 6113 static 6114 symbol_type make_DSGE_PRIOR_WEIGHT(location_type l)6115 make_DSGE_PRIOR_WEIGHT (location_type l) 6116 { 6117 return symbol_type (token::DSGE_PRIOR_WEIGHT, std::move (l)); 6118 } 6119 #else 6120 static 6121 symbol_type make_DSGE_PRIOR_WEIGHT(const location_type & l)6122 make_DSGE_PRIOR_WEIGHT (const location_type& l) 6123 { 6124 return symbol_type (token::DSGE_PRIOR_WEIGHT, l); 6125 } 6126 #endif 6127 #if 201103L <= YY_CPLUSPLUS 6128 static 6129 symbol_type make_TRUNCATE(location_type l)6130 make_TRUNCATE (location_type l) 6131 { 6132 return symbol_type (token::TRUNCATE, std::move (l)); 6133 } 6134 #else 6135 static 6136 symbol_type make_TRUNCATE(const location_type & l)6137 make_TRUNCATE (const location_type& l) 6138 { 6139 return symbol_type (token::TRUNCATE, l); 6140 } 6141 #endif 6142 #if 201103L <= YY_CPLUSPLUS 6143 static 6144 symbol_type make_PIPE_E(location_type l)6145 make_PIPE_E (location_type l) 6146 { 6147 return symbol_type (token::PIPE_E, std::move (l)); 6148 } 6149 #else 6150 static 6151 symbol_type make_PIPE_E(const location_type & l)6152 make_PIPE_E (const location_type& l) 6153 { 6154 return symbol_type (token::PIPE_E, l); 6155 } 6156 #endif 6157 #if 201103L <= YY_CPLUSPLUS 6158 static 6159 symbol_type make_PIPE_X(location_type l)6160 make_PIPE_X (location_type l) 6161 { 6162 return symbol_type (token::PIPE_X, std::move (l)); 6163 } 6164 #else 6165 static 6166 symbol_type make_PIPE_X(const location_type & l)6167 make_PIPE_X (const location_type& l) 6168 { 6169 return symbol_type (token::PIPE_X, l); 6170 } 6171 #endif 6172 #if 201103L <= YY_CPLUSPLUS 6173 static 6174 symbol_type make_PIPE_P(location_type l)6175 make_PIPE_P (location_type l) 6176 { 6177 return symbol_type (token::PIPE_P, std::move (l)); 6178 } 6179 #else 6180 static 6181 symbol_type make_PIPE_P(const location_type & l)6182 make_PIPE_P (const location_type& l) 6183 { 6184 return symbol_type (token::PIPE_P, l); 6185 } 6186 #endif 6187 #if 201103L <= YY_CPLUSPLUS 6188 static 6189 symbol_type make_RELATIVE_IRF(location_type l)6190 make_RELATIVE_IRF (location_type l) 6191 { 6192 return symbol_type (token::RELATIVE_IRF, std::move (l)); 6193 } 6194 #else 6195 static 6196 symbol_type make_RELATIVE_IRF(const location_type & l)6197 make_RELATIVE_IRF (const location_type& l) 6198 { 6199 return symbol_type (token::RELATIVE_IRF, l); 6200 } 6201 #endif 6202 #if 201103L <= YY_CPLUSPLUS 6203 static 6204 symbol_type make_REPLIC(location_type l)6205 make_REPLIC (location_type l) 6206 { 6207 return symbol_type (token::REPLIC, std::move (l)); 6208 } 6209 #else 6210 static 6211 symbol_type make_REPLIC(const location_type & l)6212 make_REPLIC (const location_type& l) 6213 { 6214 return symbol_type (token::REPLIC, l); 6215 } 6216 #endif 6217 #if 201103L <= YY_CPLUSPLUS 6218 static 6219 symbol_type make_SIMUL_REPLIC(location_type l)6220 make_SIMUL_REPLIC (location_type l) 6221 { 6222 return symbol_type (token::SIMUL_REPLIC, std::move (l)); 6223 } 6224 #else 6225 static 6226 symbol_type make_SIMUL_REPLIC(const location_type & l)6227 make_SIMUL_REPLIC (const location_type& l) 6228 { 6229 return symbol_type (token::SIMUL_REPLIC, l); 6230 } 6231 #endif 6232 #if 201103L <= YY_CPLUSPLUS 6233 static 6234 symbol_type make_RPLOT(location_type l)6235 make_RPLOT (location_type l) 6236 { 6237 return symbol_type (token::RPLOT, std::move (l)); 6238 } 6239 #else 6240 static 6241 symbol_type make_RPLOT(const location_type & l)6242 make_RPLOT (const location_type& l) 6243 { 6244 return symbol_type (token::RPLOT, l); 6245 } 6246 #endif 6247 #if 201103L <= YY_CPLUSPLUS 6248 static 6249 symbol_type make_SAVE_PARAMS_AND_STEADY_STATE(location_type l)6250 make_SAVE_PARAMS_AND_STEADY_STATE (location_type l) 6251 { 6252 return symbol_type (token::SAVE_PARAMS_AND_STEADY_STATE, std::move (l)); 6253 } 6254 #else 6255 static 6256 symbol_type make_SAVE_PARAMS_AND_STEADY_STATE(const location_type & l)6257 make_SAVE_PARAMS_AND_STEADY_STATE (const location_type& l) 6258 { 6259 return symbol_type (token::SAVE_PARAMS_AND_STEADY_STATE, l); 6260 } 6261 #endif 6262 #if 201103L <= YY_CPLUSPLUS 6263 static 6264 symbol_type make_PARAMETER_UNCERTAINTY(location_type l)6265 make_PARAMETER_UNCERTAINTY (location_type l) 6266 { 6267 return symbol_type (token::PARAMETER_UNCERTAINTY, std::move (l)); 6268 } 6269 #else 6270 static 6271 symbol_type make_PARAMETER_UNCERTAINTY(const location_type & l)6272 make_PARAMETER_UNCERTAINTY (const location_type& l) 6273 { 6274 return symbol_type (token::PARAMETER_UNCERTAINTY, l); 6275 } 6276 #endif 6277 #if 201103L <= YY_CPLUSPLUS 6278 static 6279 symbol_type make_TARGETS(location_type l)6280 make_TARGETS (location_type l) 6281 { 6282 return symbol_type (token::TARGETS, std::move (l)); 6283 } 6284 #else 6285 static 6286 symbol_type make_TARGETS(const location_type & l)6287 make_TARGETS (const location_type& l) 6288 { 6289 return symbol_type (token::TARGETS, l); 6290 } 6291 #endif 6292 #if 201103L <= YY_CPLUSPLUS 6293 static 6294 symbol_type make_SHOCKS(location_type l)6295 make_SHOCKS (location_type l) 6296 { 6297 return symbol_type (token::SHOCKS, std::move (l)); 6298 } 6299 #else 6300 static 6301 symbol_type make_SHOCKS(const location_type & l)6302 make_SHOCKS (const location_type& l) 6303 { 6304 return symbol_type (token::SHOCKS, l); 6305 } 6306 #endif 6307 #if 201103L <= YY_CPLUSPLUS 6308 static 6309 symbol_type make_SHOCK_DECOMPOSITION(location_type l)6310 make_SHOCK_DECOMPOSITION (location_type l) 6311 { 6312 return symbol_type (token::SHOCK_DECOMPOSITION, std::move (l)); 6313 } 6314 #else 6315 static 6316 symbol_type make_SHOCK_DECOMPOSITION(const location_type & l)6317 make_SHOCK_DECOMPOSITION (const location_type& l) 6318 { 6319 return symbol_type (token::SHOCK_DECOMPOSITION, l); 6320 } 6321 #endif 6322 #if 201103L <= YY_CPLUSPLUS 6323 static 6324 symbol_type make_SHOCK_GROUPS(location_type l)6325 make_SHOCK_GROUPS (location_type l) 6326 { 6327 return symbol_type (token::SHOCK_GROUPS, std::move (l)); 6328 } 6329 #else 6330 static 6331 symbol_type make_SHOCK_GROUPS(const location_type & l)6332 make_SHOCK_GROUPS (const location_type& l) 6333 { 6334 return symbol_type (token::SHOCK_GROUPS, l); 6335 } 6336 #endif 6337 #if 201103L <= YY_CPLUSPLUS 6338 static 6339 symbol_type make_USE_SHOCK_GROUPS(location_type l)6340 make_USE_SHOCK_GROUPS (location_type l) 6341 { 6342 return symbol_type (token::USE_SHOCK_GROUPS, std::move (l)); 6343 } 6344 #else 6345 static 6346 symbol_type make_USE_SHOCK_GROUPS(const location_type & l)6347 make_USE_SHOCK_GROUPS (const location_type& l) 6348 { 6349 return symbol_type (token::USE_SHOCK_GROUPS, l); 6350 } 6351 #endif 6352 #if 201103L <= YY_CPLUSPLUS 6353 static 6354 symbol_type make_SIGMA_E(location_type l)6355 make_SIGMA_E (location_type l) 6356 { 6357 return symbol_type (token::SIGMA_E, std::move (l)); 6358 } 6359 #else 6360 static 6361 symbol_type make_SIGMA_E(const location_type & l)6362 make_SIGMA_E (const location_type& l) 6363 { 6364 return symbol_type (token::SIGMA_E, l); 6365 } 6366 #endif 6367 #if 201103L <= YY_CPLUSPLUS 6368 static 6369 symbol_type make_SIMUL(location_type l)6370 make_SIMUL (location_type l) 6371 { 6372 return symbol_type (token::SIMUL, std::move (l)); 6373 } 6374 #else 6375 static 6376 symbol_type make_SIMUL(const location_type & l)6377 make_SIMUL (const location_type& l) 6378 { 6379 return symbol_type (token::SIMUL, l); 6380 } 6381 #endif 6382 #if 201103L <= YY_CPLUSPLUS 6383 static 6384 symbol_type make_SIMUL_ALGO(location_type l)6385 make_SIMUL_ALGO (location_type l) 6386 { 6387 return symbol_type (token::SIMUL_ALGO, std::move (l)); 6388 } 6389 #else 6390 static 6391 symbol_type make_SIMUL_ALGO(const location_type & l)6392 make_SIMUL_ALGO (const location_type& l) 6393 { 6394 return symbol_type (token::SIMUL_ALGO, l); 6395 } 6396 #endif 6397 #if 201103L <= YY_CPLUSPLUS 6398 static 6399 symbol_type make_SIMUL_SEED(location_type l)6400 make_SIMUL_SEED (location_type l) 6401 { 6402 return symbol_type (token::SIMUL_SEED, std::move (l)); 6403 } 6404 #else 6405 static 6406 symbol_type make_SIMUL_SEED(const location_type & l)6407 make_SIMUL_SEED (const location_type& l) 6408 { 6409 return symbol_type (token::SIMUL_SEED, l); 6410 } 6411 #endif 6412 #if 201103L <= YY_CPLUSPLUS 6413 static 6414 symbol_type make_ENDOGENOUS_TERMINAL_PERIOD(location_type l)6415 make_ENDOGENOUS_TERMINAL_PERIOD (location_type l) 6416 { 6417 return symbol_type (token::ENDOGENOUS_TERMINAL_PERIOD, std::move (l)); 6418 } 6419 #else 6420 static 6421 symbol_type make_ENDOGENOUS_TERMINAL_PERIOD(const location_type & l)6422 make_ENDOGENOUS_TERMINAL_PERIOD (const location_type& l) 6423 { 6424 return symbol_type (token::ENDOGENOUS_TERMINAL_PERIOD, l); 6425 } 6426 #endif 6427 #if 201103L <= YY_CPLUSPLUS 6428 static 6429 symbol_type make_SMOOTHER(location_type l)6430 make_SMOOTHER (location_type l) 6431 { 6432 return symbol_type (token::SMOOTHER, std::move (l)); 6433 } 6434 #else 6435 static 6436 symbol_type make_SMOOTHER(const location_type & l)6437 make_SMOOTHER (const location_type& l) 6438 { 6439 return symbol_type (token::SMOOTHER, l); 6440 } 6441 #endif 6442 #if 201103L <= YY_CPLUSPLUS 6443 static 6444 symbol_type make_SMOOTHER2HISTVAL(location_type l)6445 make_SMOOTHER2HISTVAL (location_type l) 6446 { 6447 return symbol_type (token::SMOOTHER2HISTVAL, std::move (l)); 6448 } 6449 #else 6450 static 6451 symbol_type make_SMOOTHER2HISTVAL(const location_type & l)6452 make_SMOOTHER2HISTVAL (const location_type& l) 6453 { 6454 return symbol_type (token::SMOOTHER2HISTVAL, l); 6455 } 6456 #endif 6457 #if 201103L <= YY_CPLUSPLUS 6458 static 6459 symbol_type make_SQUARE_ROOT_SOLVER(location_type l)6460 make_SQUARE_ROOT_SOLVER (location_type l) 6461 { 6462 return symbol_type (token::SQUARE_ROOT_SOLVER, std::move (l)); 6463 } 6464 #else 6465 static 6466 symbol_type make_SQUARE_ROOT_SOLVER(const location_type & l)6467 make_SQUARE_ROOT_SOLVER (const location_type& l) 6468 { 6469 return symbol_type (token::SQUARE_ROOT_SOLVER, l); 6470 } 6471 #endif 6472 #if 201103L <= YY_CPLUSPLUS 6473 static 6474 symbol_type make_STACK_SOLVE_ALGO(location_type l)6475 make_STACK_SOLVE_ALGO (location_type l) 6476 { 6477 return symbol_type (token::STACK_SOLVE_ALGO, std::move (l)); 6478 } 6479 #else 6480 static 6481 symbol_type make_STACK_SOLVE_ALGO(const location_type & l)6482 make_STACK_SOLVE_ALGO (const location_type& l) 6483 { 6484 return symbol_type (token::STACK_SOLVE_ALGO, l); 6485 } 6486 #endif 6487 #if 201103L <= YY_CPLUSPLUS 6488 static 6489 symbol_type make_STEADY_STATE_MODEL(location_type l)6490 make_STEADY_STATE_MODEL (location_type l) 6491 { 6492 return symbol_type (token::STEADY_STATE_MODEL, std::move (l)); 6493 } 6494 #else 6495 static 6496 symbol_type make_STEADY_STATE_MODEL(const location_type & l)6497 make_STEADY_STATE_MODEL (const location_type& l) 6498 { 6499 return symbol_type (token::STEADY_STATE_MODEL, l); 6500 } 6501 #endif 6502 #if 201103L <= YY_CPLUSPLUS 6503 static 6504 symbol_type make_SOLVE_ALGO(location_type l)6505 make_SOLVE_ALGO (location_type l) 6506 { 6507 return symbol_type (token::SOLVE_ALGO, std::move (l)); 6508 } 6509 #else 6510 static 6511 symbol_type make_SOLVE_ALGO(const location_type & l)6512 make_SOLVE_ALGO (const location_type& l) 6513 { 6514 return symbol_type (token::SOLVE_ALGO, l); 6515 } 6516 #endif 6517 #if 201103L <= YY_CPLUSPLUS 6518 static 6519 symbol_type make_SOLVER_PERIODS(location_type l)6520 make_SOLVER_PERIODS (location_type l) 6521 { 6522 return symbol_type (token::SOLVER_PERIODS, std::move (l)); 6523 } 6524 #else 6525 static 6526 symbol_type make_SOLVER_PERIODS(const location_type & l)6527 make_SOLVER_PERIODS (const location_type& l) 6528 { 6529 return symbol_type (token::SOLVER_PERIODS, l); 6530 } 6531 #endif 6532 #if 201103L <= YY_CPLUSPLUS 6533 static 6534 symbol_type make_ROBUST_LIN_SOLVE(location_type l)6535 make_ROBUST_LIN_SOLVE (location_type l) 6536 { 6537 return symbol_type (token::ROBUST_LIN_SOLVE, std::move (l)); 6538 } 6539 #else 6540 static 6541 symbol_type make_ROBUST_LIN_SOLVE(const location_type & l)6542 make_ROBUST_LIN_SOLVE (const location_type& l) 6543 { 6544 return symbol_type (token::ROBUST_LIN_SOLVE, l); 6545 } 6546 #endif 6547 #if 201103L <= YY_CPLUSPLUS 6548 static 6549 symbol_type make_STDERR(location_type l)6550 make_STDERR (location_type l) 6551 { 6552 return symbol_type (token::STDERR, std::move (l)); 6553 } 6554 #else 6555 static 6556 symbol_type make_STDERR(const location_type & l)6557 make_STDERR (const location_type& l) 6558 { 6559 return symbol_type (token::STDERR, l); 6560 } 6561 #endif 6562 #if 201103L <= YY_CPLUSPLUS 6563 static 6564 symbol_type make_STEADY(location_type l)6565 make_STEADY (location_type l) 6566 { 6567 return symbol_type (token::STEADY, std::move (l)); 6568 } 6569 #else 6570 static 6571 symbol_type make_STEADY(const location_type & l)6572 make_STEADY (const location_type& l) 6573 { 6574 return symbol_type (token::STEADY, l); 6575 } 6576 #endif 6577 #if 201103L <= YY_CPLUSPLUS 6578 static 6579 symbol_type make_STOCH_SIMUL(location_type l)6580 make_STOCH_SIMUL (location_type l) 6581 { 6582 return symbol_type (token::STOCH_SIMUL, std::move (l)); 6583 } 6584 #else 6585 static 6586 symbol_type make_STOCH_SIMUL(const location_type & l)6587 make_STOCH_SIMUL (const location_type& l) 6588 { 6589 return symbol_type (token::STOCH_SIMUL, l); 6590 } 6591 #endif 6592 #if 201103L <= YY_CPLUSPLUS 6593 static 6594 symbol_type make_SYLVESTER(location_type l)6595 make_SYLVESTER (location_type l) 6596 { 6597 return symbol_type (token::SYLVESTER, std::move (l)); 6598 } 6599 #else 6600 static 6601 symbol_type make_SYLVESTER(const location_type & l)6602 make_SYLVESTER (const location_type& l) 6603 { 6604 return symbol_type (token::SYLVESTER, l); 6605 } 6606 #endif 6607 #if 201103L <= YY_CPLUSPLUS 6608 static 6609 symbol_type make_SYLVESTER_FIXED_POINT_TOL(location_type l)6610 make_SYLVESTER_FIXED_POINT_TOL (location_type l) 6611 { 6612 return symbol_type (token::SYLVESTER_FIXED_POINT_TOL, std::move (l)); 6613 } 6614 #else 6615 static 6616 symbol_type make_SYLVESTER_FIXED_POINT_TOL(const location_type & l)6617 make_SYLVESTER_FIXED_POINT_TOL (const location_type& l) 6618 { 6619 return symbol_type (token::SYLVESTER_FIXED_POINT_TOL, l); 6620 } 6621 #endif 6622 #if 201103L <= YY_CPLUSPLUS 6623 static 6624 symbol_type make_REGIMES(location_type l)6625 make_REGIMES (location_type l) 6626 { 6627 return symbol_type (token::REGIMES, std::move (l)); 6628 } 6629 #else 6630 static 6631 symbol_type make_REGIMES(const location_type & l)6632 make_REGIMES (const location_type& l) 6633 { 6634 return symbol_type (token::REGIMES, l); 6635 } 6636 #endif 6637 #if 201103L <= YY_CPLUSPLUS 6638 static 6639 symbol_type make_REGIME(location_type l)6640 make_REGIME (location_type l) 6641 { 6642 return symbol_type (token::REGIME, std::move (l)); 6643 } 6644 #else 6645 static 6646 symbol_type make_REGIME(const location_type & l)6647 make_REGIME (const location_type& l) 6648 { 6649 return symbol_type (token::REGIME, l); 6650 } 6651 #endif 6652 #if 201103L <= YY_CPLUSPLUS 6653 static 6654 symbol_type make_REALTIME_SHOCK_DECOMPOSITION(location_type l)6655 make_REALTIME_SHOCK_DECOMPOSITION (location_type l) 6656 { 6657 return symbol_type (token::REALTIME_SHOCK_DECOMPOSITION, std::move (l)); 6658 } 6659 #else 6660 static 6661 symbol_type make_REALTIME_SHOCK_DECOMPOSITION(const location_type & l)6662 make_REALTIME_SHOCK_DECOMPOSITION (const location_type& l) 6663 { 6664 return symbol_type (token::REALTIME_SHOCK_DECOMPOSITION, l); 6665 } 6666 #endif 6667 #if 201103L <= YY_CPLUSPLUS 6668 static 6669 symbol_type make_CONDITIONAL(location_type l)6670 make_CONDITIONAL (location_type l) 6671 { 6672 return symbol_type (token::CONDITIONAL, std::move (l)); 6673 } 6674 #else 6675 static 6676 symbol_type make_CONDITIONAL(const location_type & l)6677 make_CONDITIONAL (const location_type& l) 6678 { 6679 return symbol_type (token::CONDITIONAL, l); 6680 } 6681 #endif 6682 #if 201103L <= YY_CPLUSPLUS 6683 static 6684 symbol_type make_UNCONDITIONAL(location_type l)6685 make_UNCONDITIONAL (location_type l) 6686 { 6687 return symbol_type (token::UNCONDITIONAL, std::move (l)); 6688 } 6689 #else 6690 static 6691 symbol_type make_UNCONDITIONAL(const location_type & l)6692 make_UNCONDITIONAL (const location_type& l) 6693 { 6694 return symbol_type (token::UNCONDITIONAL, l); 6695 } 6696 #endif 6697 #if 201103L <= YY_CPLUSPLUS 6698 static 6699 symbol_type make_TEX(location_type l)6700 make_TEX (location_type l) 6701 { 6702 return symbol_type (token::TEX, std::move (l)); 6703 } 6704 #else 6705 static 6706 symbol_type make_TEX(const location_type & l)6707 make_TEX (const location_type& l) 6708 { 6709 return symbol_type (token::TEX, l); 6710 } 6711 #endif 6712 #if 201103L <= YY_CPLUSPLUS 6713 static 6714 symbol_type make_RAMSEY_MODEL(location_type l)6715 make_RAMSEY_MODEL (location_type l) 6716 { 6717 return symbol_type (token::RAMSEY_MODEL, std::move (l)); 6718 } 6719 #else 6720 static 6721 symbol_type make_RAMSEY_MODEL(const location_type & l)6722 make_RAMSEY_MODEL (const location_type& l) 6723 { 6724 return symbol_type (token::RAMSEY_MODEL, l); 6725 } 6726 #endif 6727 #if 201103L <= YY_CPLUSPLUS 6728 static 6729 symbol_type make_RAMSEY_POLICY(location_type l)6730 make_RAMSEY_POLICY (location_type l) 6731 { 6732 return symbol_type (token::RAMSEY_POLICY, std::move (l)); 6733 } 6734 #else 6735 static 6736 symbol_type make_RAMSEY_POLICY(const location_type & l)6737 make_RAMSEY_POLICY (const location_type& l) 6738 { 6739 return symbol_type (token::RAMSEY_POLICY, l); 6740 } 6741 #endif 6742 #if 201103L <= YY_CPLUSPLUS 6743 static 6744 symbol_type make_RAMSEY_CONSTRAINTS(location_type l)6745 make_RAMSEY_CONSTRAINTS (location_type l) 6746 { 6747 return symbol_type (token::RAMSEY_CONSTRAINTS, std::move (l)); 6748 } 6749 #else 6750 static 6751 symbol_type make_RAMSEY_CONSTRAINTS(const location_type & l)6752 make_RAMSEY_CONSTRAINTS (const location_type& l) 6753 { 6754 return symbol_type (token::RAMSEY_CONSTRAINTS, l); 6755 } 6756 #endif 6757 #if 201103L <= YY_CPLUSPLUS 6758 static 6759 symbol_type make_PLANNER_DISCOUNT(location_type l)6760 make_PLANNER_DISCOUNT (location_type l) 6761 { 6762 return symbol_type (token::PLANNER_DISCOUNT, std::move (l)); 6763 } 6764 #else 6765 static 6766 symbol_type make_PLANNER_DISCOUNT(const location_type & l)6767 make_PLANNER_DISCOUNT (const location_type& l) 6768 { 6769 return symbol_type (token::PLANNER_DISCOUNT, l); 6770 } 6771 #endif 6772 #if 201103L <= YY_CPLUSPLUS 6773 static 6774 symbol_type make_PLANNER_DISCOUNT_LATEX_NAME(location_type l)6775 make_PLANNER_DISCOUNT_LATEX_NAME (location_type l) 6776 { 6777 return symbol_type (token::PLANNER_DISCOUNT_LATEX_NAME, std::move (l)); 6778 } 6779 #else 6780 static 6781 symbol_type make_PLANNER_DISCOUNT_LATEX_NAME(const location_type & l)6782 make_PLANNER_DISCOUNT_LATEX_NAME (const location_type& l) 6783 { 6784 return symbol_type (token::PLANNER_DISCOUNT_LATEX_NAME, l); 6785 } 6786 #endif 6787 #if 201103L <= YY_CPLUSPLUS 6788 static 6789 symbol_type make_DISCRETIONARY_POLICY(location_type l)6790 make_DISCRETIONARY_POLICY (location_type l) 6791 { 6792 return symbol_type (token::DISCRETIONARY_POLICY, std::move (l)); 6793 } 6794 #else 6795 static 6796 symbol_type make_DISCRETIONARY_POLICY(const location_type & l)6797 make_DISCRETIONARY_POLICY (const location_type& l) 6798 { 6799 return symbol_type (token::DISCRETIONARY_POLICY, l); 6800 } 6801 #endif 6802 #if 201103L <= YY_CPLUSPLUS 6803 static 6804 symbol_type make_DISCRETIONARY_TOL(location_type l)6805 make_DISCRETIONARY_TOL (location_type l) 6806 { 6807 return symbol_type (token::DISCRETIONARY_TOL, std::move (l)); 6808 } 6809 #else 6810 static 6811 symbol_type make_DISCRETIONARY_TOL(const location_type & l)6812 make_DISCRETIONARY_TOL (const location_type& l) 6813 { 6814 return symbol_type (token::DISCRETIONARY_TOL, l); 6815 } 6816 #endif 6817 #if 201103L <= YY_CPLUSPLUS 6818 static 6819 symbol_type make_EVALUATE_PLANNER_OBJECTIVE(location_type l)6820 make_EVALUATE_PLANNER_OBJECTIVE (location_type l) 6821 { 6822 return symbol_type (token::EVALUATE_PLANNER_OBJECTIVE, std::move (l)); 6823 } 6824 #else 6825 static 6826 symbol_type make_EVALUATE_PLANNER_OBJECTIVE(const location_type & l)6827 make_EVALUATE_PLANNER_OBJECTIVE (const location_type& l) 6828 { 6829 return symbol_type (token::EVALUATE_PLANNER_OBJECTIVE, l); 6830 } 6831 #endif 6832 #if 201103L <= YY_CPLUSPLUS 6833 static 6834 symbol_type make_TEX_NAME(string v,location_type l)6835 make_TEX_NAME (string v, location_type l) 6836 { 6837 return symbol_type (token::TEX_NAME, std::move (v), std::move (l)); 6838 } 6839 #else 6840 static 6841 symbol_type make_TEX_NAME(const string & v,const location_type & l)6842 make_TEX_NAME (const string& v, const location_type& l) 6843 { 6844 return symbol_type (token::TEX_NAME, v, l); 6845 } 6846 #endif 6847 #if 201103L <= YY_CPLUSPLUS 6848 static 6849 symbol_type make_TRUE(string v,location_type l)6850 make_TRUE (string v, location_type l) 6851 { 6852 return symbol_type (token::TRUE, std::move (v), std::move (l)); 6853 } 6854 #else 6855 static 6856 symbol_type make_TRUE(const string & v,const location_type & l)6857 make_TRUE (const string& v, const location_type& l) 6858 { 6859 return symbol_type (token::TRUE, v, l); 6860 } 6861 #endif 6862 #if 201103L <= YY_CPLUSPLUS 6863 static 6864 symbol_type make_UNIFORM_PDF(location_type l)6865 make_UNIFORM_PDF (location_type l) 6866 { 6867 return symbol_type (token::UNIFORM_PDF, std::move (l)); 6868 } 6869 #else 6870 static 6871 symbol_type make_UNIFORM_PDF(const location_type & l)6872 make_UNIFORM_PDF (const location_type& l) 6873 { 6874 return symbol_type (token::UNIFORM_PDF, l); 6875 } 6876 #endif 6877 #if 201103L <= YY_CPLUSPLUS 6878 static 6879 symbol_type make_UNIT_ROOT_VARS(location_type l)6880 make_UNIT_ROOT_VARS (location_type l) 6881 { 6882 return symbol_type (token::UNIT_ROOT_VARS, std::move (l)); 6883 } 6884 #else 6885 static 6886 symbol_type make_UNIT_ROOT_VARS(const location_type & l)6887 make_UNIT_ROOT_VARS (const location_type& l) 6888 { 6889 return symbol_type (token::UNIT_ROOT_VARS, l); 6890 } 6891 #endif 6892 #if 201103L <= YY_CPLUSPLUS 6893 static 6894 symbol_type make_USE_DLL(location_type l)6895 make_USE_DLL (location_type l) 6896 { 6897 return symbol_type (token::USE_DLL, std::move (l)); 6898 } 6899 #else 6900 static 6901 symbol_type make_USE_DLL(const location_type & l)6902 make_USE_DLL (const location_type& l) 6903 { 6904 return symbol_type (token::USE_DLL, l); 6905 } 6906 #endif 6907 #if 201103L <= YY_CPLUSPLUS 6908 static 6909 symbol_type make_USEAUTOCORR(location_type l)6910 make_USEAUTOCORR (location_type l) 6911 { 6912 return symbol_type (token::USEAUTOCORR, std::move (l)); 6913 } 6914 #else 6915 static 6916 symbol_type make_USEAUTOCORR(const location_type & l)6917 make_USEAUTOCORR (const location_type& l) 6918 { 6919 return symbol_type (token::USEAUTOCORR, l); 6920 } 6921 #endif 6922 #if 201103L <= YY_CPLUSPLUS 6923 static 6924 symbol_type make_GSA_SAMPLE_FILE(location_type l)6925 make_GSA_SAMPLE_FILE (location_type l) 6926 { 6927 return symbol_type (token::GSA_SAMPLE_FILE, std::move (l)); 6928 } 6929 #else 6930 static 6931 symbol_type make_GSA_SAMPLE_FILE(const location_type & l)6932 make_GSA_SAMPLE_FILE (const location_type& l) 6933 { 6934 return symbol_type (token::GSA_SAMPLE_FILE, l); 6935 } 6936 #endif 6937 #if 201103L <= YY_CPLUSPLUS 6938 static 6939 symbol_type make_USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED(location_type l)6940 make_USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED (location_type l) 6941 { 6942 return symbol_type (token::USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED, std::move (l)); 6943 } 6944 #else 6945 static 6946 symbol_type make_USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED(const location_type & l)6947 make_USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED (const location_type& l) 6948 { 6949 return symbol_type (token::USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED, l); 6950 } 6951 #endif 6952 #if 201103L <= YY_CPLUSPLUS 6953 static 6954 symbol_type make_VALUES(location_type l)6955 make_VALUES (location_type l) 6956 { 6957 return symbol_type (token::VALUES, std::move (l)); 6958 } 6959 #else 6960 static 6961 symbol_type make_VALUES(const location_type & l)6962 make_VALUES (const location_type& l) 6963 { 6964 return symbol_type (token::VALUES, l); 6965 } 6966 #endif 6967 #if 201103L <= YY_CPLUSPLUS 6968 static 6969 symbol_type make_VAR(location_type l)6970 make_VAR (location_type l) 6971 { 6972 return symbol_type (token::VAR, std::move (l)); 6973 } 6974 #else 6975 static 6976 symbol_type make_VAR(const location_type & l)6977 make_VAR (const location_type& l) 6978 { 6979 return symbol_type (token::VAR, l); 6980 } 6981 #endif 6982 #if 201103L <= YY_CPLUSPLUS 6983 static 6984 symbol_type make_VAREXO(location_type l)6985 make_VAREXO (location_type l) 6986 { 6987 return symbol_type (token::VAREXO, std::move (l)); 6988 } 6989 #else 6990 static 6991 symbol_type make_VAREXO(const location_type & l)6992 make_VAREXO (const location_type& l) 6993 { 6994 return symbol_type (token::VAREXO, l); 6995 } 6996 #endif 6997 #if 201103L <= YY_CPLUSPLUS 6998 static 6999 symbol_type make_VAREXO_DET(location_type l)7000 make_VAREXO_DET (location_type l) 7001 { 7002 return symbol_type (token::VAREXO_DET, std::move (l)); 7003 } 7004 #else 7005 static 7006 symbol_type make_VAREXO_DET(const location_type & l)7007 make_VAREXO_DET (const location_type& l) 7008 { 7009 return symbol_type (token::VAREXO_DET, l); 7010 } 7011 #endif 7012 #if 201103L <= YY_CPLUSPLUS 7013 static 7014 symbol_type make_VARIABLE(location_type l)7015 make_VARIABLE (location_type l) 7016 { 7017 return symbol_type (token::VARIABLE, std::move (l)); 7018 } 7019 #else 7020 static 7021 symbol_type make_VARIABLE(const location_type & l)7022 make_VARIABLE (const location_type& l) 7023 { 7024 return symbol_type (token::VARIABLE, l); 7025 } 7026 #endif 7027 #if 201103L <= YY_CPLUSPLUS 7028 static 7029 symbol_type make_VAROBS(location_type l)7030 make_VAROBS (location_type l) 7031 { 7032 return symbol_type (token::VAROBS, std::move (l)); 7033 } 7034 #else 7035 static 7036 symbol_type make_VAROBS(const location_type & l)7037 make_VAROBS (const location_type& l) 7038 { 7039 return symbol_type (token::VAROBS, l); 7040 } 7041 #endif 7042 #if 201103L <= YY_CPLUSPLUS 7043 static 7044 symbol_type make_VAREXOBS(location_type l)7045 make_VAREXOBS (location_type l) 7046 { 7047 return symbol_type (token::VAREXOBS, std::move (l)); 7048 } 7049 #else 7050 static 7051 symbol_type make_VAREXOBS(const location_type & l)7052 make_VAREXOBS (const location_type& l) 7053 { 7054 return symbol_type (token::VAREXOBS, l); 7055 } 7056 #endif 7057 #if 201103L <= YY_CPLUSPLUS 7058 static 7059 symbol_type make_PREDETERMINED_VARIABLES(location_type l)7060 make_PREDETERMINED_VARIABLES (location_type l) 7061 { 7062 return symbol_type (token::PREDETERMINED_VARIABLES, std::move (l)); 7063 } 7064 #else 7065 static 7066 symbol_type make_PREDETERMINED_VARIABLES(const location_type & l)7067 make_PREDETERMINED_VARIABLES (const location_type& l) 7068 { 7069 return symbol_type (token::PREDETERMINED_VARIABLES, l); 7070 } 7071 #endif 7072 #if 201103L <= YY_CPLUSPLUS 7073 static 7074 symbol_type make_VAR_EXPECTATION(location_type l)7075 make_VAR_EXPECTATION (location_type l) 7076 { 7077 return symbol_type (token::VAR_EXPECTATION, std::move (l)); 7078 } 7079 #else 7080 static 7081 symbol_type make_VAR_EXPECTATION(const location_type & l)7082 make_VAR_EXPECTATION (const location_type& l) 7083 { 7084 return symbol_type (token::VAR_EXPECTATION, l); 7085 } 7086 #endif 7087 #if 201103L <= YY_CPLUSPLUS 7088 static 7089 symbol_type make_VAR_EXPECTATION_MODEL(location_type l)7090 make_VAR_EXPECTATION_MODEL (location_type l) 7091 { 7092 return symbol_type (token::VAR_EXPECTATION_MODEL, std::move (l)); 7093 } 7094 #else 7095 static 7096 symbol_type make_VAR_EXPECTATION_MODEL(const location_type & l)7097 make_VAR_EXPECTATION_MODEL (const location_type& l) 7098 { 7099 return symbol_type (token::VAR_EXPECTATION_MODEL, l); 7100 } 7101 #endif 7102 #if 201103L <= YY_CPLUSPLUS 7103 static 7104 symbol_type make_PLOT_SHOCK_DECOMPOSITION(location_type l)7105 make_PLOT_SHOCK_DECOMPOSITION (location_type l) 7106 { 7107 return symbol_type (token::PLOT_SHOCK_DECOMPOSITION, std::move (l)); 7108 } 7109 #else 7110 static 7111 symbol_type make_PLOT_SHOCK_DECOMPOSITION(const location_type & l)7112 make_PLOT_SHOCK_DECOMPOSITION (const location_type& l) 7113 { 7114 return symbol_type (token::PLOT_SHOCK_DECOMPOSITION, l); 7115 } 7116 #endif 7117 #if 201103L <= YY_CPLUSPLUS 7118 static 7119 symbol_type make_MODEL_LOCAL_VARIABLE(location_type l)7120 make_MODEL_LOCAL_VARIABLE (location_type l) 7121 { 7122 return symbol_type (token::MODEL_LOCAL_VARIABLE, std::move (l)); 7123 } 7124 #else 7125 static 7126 symbol_type make_MODEL_LOCAL_VARIABLE(const location_type & l)7127 make_MODEL_LOCAL_VARIABLE (const location_type& l) 7128 { 7129 return symbol_type (token::MODEL_LOCAL_VARIABLE, l); 7130 } 7131 #endif 7132 #if 201103L <= YY_CPLUSPLUS 7133 static 7134 symbol_type make_WRITE_LATEX_DYNAMIC_MODEL(location_type l)7135 make_WRITE_LATEX_DYNAMIC_MODEL (location_type l) 7136 { 7137 return symbol_type (token::WRITE_LATEX_DYNAMIC_MODEL, std::move (l)); 7138 } 7139 #else 7140 static 7141 symbol_type make_WRITE_LATEX_DYNAMIC_MODEL(const location_type & l)7142 make_WRITE_LATEX_DYNAMIC_MODEL (const location_type& l) 7143 { 7144 return symbol_type (token::WRITE_LATEX_DYNAMIC_MODEL, l); 7145 } 7146 #endif 7147 #if 201103L <= YY_CPLUSPLUS 7148 static 7149 symbol_type make_WRITE_LATEX_STATIC_MODEL(location_type l)7150 make_WRITE_LATEX_STATIC_MODEL (location_type l) 7151 { 7152 return symbol_type (token::WRITE_LATEX_STATIC_MODEL, std::move (l)); 7153 } 7154 #else 7155 static 7156 symbol_type make_WRITE_LATEX_STATIC_MODEL(const location_type & l)7157 make_WRITE_LATEX_STATIC_MODEL (const location_type& l) 7158 { 7159 return symbol_type (token::WRITE_LATEX_STATIC_MODEL, l); 7160 } 7161 #endif 7162 #if 201103L <= YY_CPLUSPLUS 7163 static 7164 symbol_type make_WRITE_LATEX_ORIGINAL_MODEL(location_type l)7165 make_WRITE_LATEX_ORIGINAL_MODEL (location_type l) 7166 { 7167 return symbol_type (token::WRITE_LATEX_ORIGINAL_MODEL, std::move (l)); 7168 } 7169 #else 7170 static 7171 symbol_type make_WRITE_LATEX_ORIGINAL_MODEL(const location_type & l)7172 make_WRITE_LATEX_ORIGINAL_MODEL (const location_type& l) 7173 { 7174 return symbol_type (token::WRITE_LATEX_ORIGINAL_MODEL, l); 7175 } 7176 #endif 7177 #if 201103L <= YY_CPLUSPLUS 7178 static 7179 symbol_type make_CROSSEQUATIONS(location_type l)7180 make_CROSSEQUATIONS (location_type l) 7181 { 7182 return symbol_type (token::CROSSEQUATIONS, std::move (l)); 7183 } 7184 #else 7185 static 7186 symbol_type make_CROSSEQUATIONS(const location_type & l)7187 make_CROSSEQUATIONS (const location_type& l) 7188 { 7189 return symbol_type (token::CROSSEQUATIONS, l); 7190 } 7191 #endif 7192 #if 201103L <= YY_CPLUSPLUS 7193 static 7194 symbol_type make_COVARIANCE(location_type l)7195 make_COVARIANCE (location_type l) 7196 { 7197 return symbol_type (token::COVARIANCE, std::move (l)); 7198 } 7199 #else 7200 static 7201 symbol_type make_COVARIANCE(const location_type & l)7202 make_COVARIANCE (const location_type& l) 7203 { 7204 return symbol_type (token::COVARIANCE, l); 7205 } 7206 #endif 7207 #if 201103L <= YY_CPLUSPLUS 7208 static 7209 symbol_type make_WRITE_LATEX_STEADY_STATE_MODEL(location_type l)7210 make_WRITE_LATEX_STEADY_STATE_MODEL (location_type l) 7211 { 7212 return symbol_type (token::WRITE_LATEX_STEADY_STATE_MODEL, std::move (l)); 7213 } 7214 #else 7215 static 7216 symbol_type make_WRITE_LATEX_STEADY_STATE_MODEL(const location_type & l)7217 make_WRITE_LATEX_STEADY_STATE_MODEL (const location_type& l) 7218 { 7219 return symbol_type (token::WRITE_LATEX_STEADY_STATE_MODEL, l); 7220 } 7221 #endif 7222 #if 201103L <= YY_CPLUSPLUS 7223 static 7224 symbol_type make_XLS_SHEET(location_type l)7225 make_XLS_SHEET (location_type l) 7226 { 7227 return symbol_type (token::XLS_SHEET, std::move (l)); 7228 } 7229 #else 7230 static 7231 symbol_type make_XLS_SHEET(const location_type & l)7232 make_XLS_SHEET (const location_type& l) 7233 { 7234 return symbol_type (token::XLS_SHEET, l); 7235 } 7236 #endif 7237 #if 201103L <= YY_CPLUSPLUS 7238 static 7239 symbol_type make_XLS_RANGE(location_type l)7240 make_XLS_RANGE (location_type l) 7241 { 7242 return symbol_type (token::XLS_RANGE, std::move (l)); 7243 } 7244 #else 7245 static 7246 symbol_type make_XLS_RANGE(const location_type & l)7247 make_XLS_RANGE (const location_type& l) 7248 { 7249 return symbol_type (token::XLS_RANGE, l); 7250 } 7251 #endif 7252 #if 201103L <= YY_CPLUSPLUS 7253 static 7254 symbol_type make_LMMCP(location_type l)7255 make_LMMCP (location_type l) 7256 { 7257 return symbol_type (token::LMMCP, std::move (l)); 7258 } 7259 #else 7260 static 7261 symbol_type make_LMMCP(const location_type & l)7262 make_LMMCP (const location_type& l) 7263 { 7264 return symbol_type (token::LMMCP, l); 7265 } 7266 #endif 7267 #if 201103L <= YY_CPLUSPLUS 7268 static 7269 symbol_type make_OCCBIN(location_type l)7270 make_OCCBIN (location_type l) 7271 { 7272 return symbol_type (token::OCCBIN, std::move (l)); 7273 } 7274 #else 7275 static 7276 symbol_type make_OCCBIN(const location_type & l)7277 make_OCCBIN (const location_type& l) 7278 { 7279 return symbol_type (token::OCCBIN, l); 7280 } 7281 #endif 7282 #if 201103L <= YY_CPLUSPLUS 7283 static 7284 symbol_type make_BANDPASS_FILTER(location_type l)7285 make_BANDPASS_FILTER (location_type l) 7286 { 7287 return symbol_type (token::BANDPASS_FILTER, std::move (l)); 7288 } 7289 #else 7290 static 7291 symbol_type make_BANDPASS_FILTER(const location_type & l)7292 make_BANDPASS_FILTER (const location_type& l) 7293 { 7294 return symbol_type (token::BANDPASS_FILTER, l); 7295 } 7296 #endif 7297 #if 201103L <= YY_CPLUSPLUS 7298 static 7299 symbol_type make_COLORMAP(location_type l)7300 make_COLORMAP (location_type l) 7301 { 7302 return symbol_type (token::COLORMAP, std::move (l)); 7303 } 7304 #else 7305 static 7306 symbol_type make_COLORMAP(const location_type & l)7307 make_COLORMAP (const location_type& l) 7308 { 7309 return symbol_type (token::COLORMAP, l); 7310 } 7311 #endif 7312 #if 201103L <= YY_CPLUSPLUS 7313 static 7314 symbol_type make_VAR_MODEL(location_type l)7315 make_VAR_MODEL (location_type l) 7316 { 7317 return symbol_type (token::VAR_MODEL, std::move (l)); 7318 } 7319 #else 7320 static 7321 symbol_type make_VAR_MODEL(const location_type & l)7322 make_VAR_MODEL (const location_type& l) 7323 { 7324 return symbol_type (token::VAR_MODEL, l); 7325 } 7326 #endif 7327 #if 201103L <= YY_CPLUSPLUS 7328 static 7329 symbol_type make_PAC_MODEL(location_type l)7330 make_PAC_MODEL (location_type l) 7331 { 7332 return symbol_type (token::PAC_MODEL, std::move (l)); 7333 } 7334 #else 7335 static 7336 symbol_type make_PAC_MODEL(const location_type & l)7337 make_PAC_MODEL (const location_type& l) 7338 { 7339 return symbol_type (token::PAC_MODEL, l); 7340 } 7341 #endif 7342 #if 201103L <= YY_CPLUSPLUS 7343 static 7344 symbol_type make_QOQ(location_type l)7345 make_QOQ (location_type l) 7346 { 7347 return symbol_type (token::QOQ, std::move (l)); 7348 } 7349 #else 7350 static 7351 symbol_type make_QOQ(const location_type & l)7352 make_QOQ (const location_type& l) 7353 { 7354 return symbol_type (token::QOQ, l); 7355 } 7356 #endif 7357 #if 201103L <= YY_CPLUSPLUS 7358 static 7359 symbol_type make_YOY(location_type l)7360 make_YOY (location_type l) 7361 { 7362 return symbol_type (token::YOY, std::move (l)); 7363 } 7364 #else 7365 static 7366 symbol_type make_YOY(const location_type & l)7367 make_YOY (const location_type& l) 7368 { 7369 return symbol_type (token::YOY, l); 7370 } 7371 #endif 7372 #if 201103L <= YY_CPLUSPLUS 7373 static 7374 symbol_type make_AOA(location_type l)7375 make_AOA (location_type l) 7376 { 7377 return symbol_type (token::AOA, std::move (l)); 7378 } 7379 #else 7380 static 7381 symbol_type make_AOA(const location_type & l)7382 make_AOA (const location_type& l) 7383 { 7384 return symbol_type (token::AOA, l); 7385 } 7386 #endif 7387 #if 201103L <= YY_CPLUSPLUS 7388 static 7389 symbol_type make_PAC_EXPECTATION(location_type l)7390 make_PAC_EXPECTATION (location_type l) 7391 { 7392 return symbol_type (token::PAC_EXPECTATION, std::move (l)); 7393 } 7394 #else 7395 static 7396 symbol_type make_PAC_EXPECTATION(const location_type & l)7397 make_PAC_EXPECTATION (const location_type& l) 7398 { 7399 return symbol_type (token::PAC_EXPECTATION, l); 7400 } 7401 #endif 7402 #if 201103L <= YY_CPLUSPLUS 7403 static 7404 symbol_type make_TREND_COMPONENT_MODEL(location_type l)7405 make_TREND_COMPONENT_MODEL (location_type l) 7406 { 7407 return symbol_type (token::TREND_COMPONENT_MODEL, std::move (l)); 7408 } 7409 #else 7410 static 7411 symbol_type make_TREND_COMPONENT_MODEL(const location_type & l)7412 make_TREND_COMPONENT_MODEL (const location_type& l) 7413 { 7414 return symbol_type (token::TREND_COMPONENT_MODEL, l); 7415 } 7416 #endif 7417 #if 201103L <= YY_CPLUSPLUS 7418 static 7419 symbol_type make_EQUAL_EQUAL(location_type l)7420 make_EQUAL_EQUAL (location_type l) 7421 { 7422 return symbol_type (token::EQUAL_EQUAL, std::move (l)); 7423 } 7424 #else 7425 static 7426 symbol_type make_EQUAL_EQUAL(const location_type & l)7427 make_EQUAL_EQUAL (const location_type& l) 7428 { 7429 return symbol_type (token::EQUAL_EQUAL, l); 7430 } 7431 #endif 7432 #if 201103L <= YY_CPLUSPLUS 7433 static 7434 symbol_type make_EXCLAMATION_EQUAL(location_type l)7435 make_EXCLAMATION_EQUAL (location_type l) 7436 { 7437 return symbol_type (token::EXCLAMATION_EQUAL, std::move (l)); 7438 } 7439 #else 7440 static 7441 symbol_type make_EXCLAMATION_EQUAL(const location_type & l)7442 make_EXCLAMATION_EQUAL (const location_type& l) 7443 { 7444 return symbol_type (token::EXCLAMATION_EQUAL, l); 7445 } 7446 #endif 7447 #if 201103L <= YY_CPLUSPLUS 7448 static 7449 symbol_type make_LESS(location_type l)7450 make_LESS (location_type l) 7451 { 7452 return symbol_type (token::LESS, std::move (l)); 7453 } 7454 #else 7455 static 7456 symbol_type make_LESS(const location_type & l)7457 make_LESS (const location_type& l) 7458 { 7459 return symbol_type (token::LESS, l); 7460 } 7461 #endif 7462 #if 201103L <= YY_CPLUSPLUS 7463 static 7464 symbol_type make_GREATER(location_type l)7465 make_GREATER (location_type l) 7466 { 7467 return symbol_type (token::GREATER, std::move (l)); 7468 } 7469 #else 7470 static 7471 symbol_type make_GREATER(const location_type & l)7472 make_GREATER (const location_type& l) 7473 { 7474 return symbol_type (token::GREATER, l); 7475 } 7476 #endif 7477 #if 201103L <= YY_CPLUSPLUS 7478 static 7479 symbol_type make_LESS_EQUAL(location_type l)7480 make_LESS_EQUAL (location_type l) 7481 { 7482 return symbol_type (token::LESS_EQUAL, std::move (l)); 7483 } 7484 #else 7485 static 7486 symbol_type make_LESS_EQUAL(const location_type & l)7487 make_LESS_EQUAL (const location_type& l) 7488 { 7489 return symbol_type (token::LESS_EQUAL, l); 7490 } 7491 #endif 7492 #if 201103L <= YY_CPLUSPLUS 7493 static 7494 symbol_type make_GREATER_EQUAL(location_type l)7495 make_GREATER_EQUAL (location_type l) 7496 { 7497 return symbol_type (token::GREATER_EQUAL, std::move (l)); 7498 } 7499 #else 7500 static 7501 symbol_type make_GREATER_EQUAL(const location_type & l)7502 make_GREATER_EQUAL (const location_type& l) 7503 { 7504 return symbol_type (token::GREATER_EQUAL, l); 7505 } 7506 #endif 7507 #if 201103L <= YY_CPLUSPLUS 7508 static 7509 symbol_type make_PLUS(location_type l)7510 make_PLUS (location_type l) 7511 { 7512 return symbol_type (token::PLUS, std::move (l)); 7513 } 7514 #else 7515 static 7516 symbol_type make_PLUS(const location_type & l)7517 make_PLUS (const location_type& l) 7518 { 7519 return symbol_type (token::PLUS, l); 7520 } 7521 #endif 7522 #if 201103L <= YY_CPLUSPLUS 7523 static 7524 symbol_type make_MINUS(location_type l)7525 make_MINUS (location_type l) 7526 { 7527 return symbol_type (token::MINUS, std::move (l)); 7528 } 7529 #else 7530 static 7531 symbol_type make_MINUS(const location_type & l)7532 make_MINUS (const location_type& l) 7533 { 7534 return symbol_type (token::MINUS, l); 7535 } 7536 #endif 7537 #if 201103L <= YY_CPLUSPLUS 7538 static 7539 symbol_type make_TIMES(location_type l)7540 make_TIMES (location_type l) 7541 { 7542 return symbol_type (token::TIMES, std::move (l)); 7543 } 7544 #else 7545 static 7546 symbol_type make_TIMES(const location_type & l)7547 make_TIMES (const location_type& l) 7548 { 7549 return symbol_type (token::TIMES, l); 7550 } 7551 #endif 7552 #if 201103L <= YY_CPLUSPLUS 7553 static 7554 symbol_type make_DIVIDE(location_type l)7555 make_DIVIDE (location_type l) 7556 { 7557 return symbol_type (token::DIVIDE, std::move (l)); 7558 } 7559 #else 7560 static 7561 symbol_type make_DIVIDE(const location_type & l)7562 make_DIVIDE (const location_type& l) 7563 { 7564 return symbol_type (token::DIVIDE, l); 7565 } 7566 #endif 7567 #if 201103L <= YY_CPLUSPLUS 7568 static 7569 symbol_type make_UNARY(location_type l)7570 make_UNARY (location_type l) 7571 { 7572 return symbol_type (token::UNARY, std::move (l)); 7573 } 7574 #else 7575 static 7576 symbol_type make_UNARY(const location_type & l)7577 make_UNARY (const location_type& l) 7578 { 7579 return symbol_type (token::UNARY, l); 7580 } 7581 #endif 7582 #if 201103L <= YY_CPLUSPLUS 7583 static 7584 symbol_type make_POWER(location_type l)7585 make_POWER (location_type l) 7586 { 7587 return symbol_type (token::POWER, std::move (l)); 7588 } 7589 #else 7590 static 7591 symbol_type make_POWER(const location_type & l)7592 make_POWER (const location_type& l) 7593 { 7594 return symbol_type (token::POWER, l); 7595 } 7596 #endif 7597 #if 201103L <= YY_CPLUSPLUS 7598 static 7599 symbol_type make_EXP(location_type l)7600 make_EXP (location_type l) 7601 { 7602 return symbol_type (token::EXP, std::move (l)); 7603 } 7604 #else 7605 static 7606 symbol_type make_EXP(const location_type & l)7607 make_EXP (const location_type& l) 7608 { 7609 return symbol_type (token::EXP, l); 7610 } 7611 #endif 7612 #if 201103L <= YY_CPLUSPLUS 7613 static 7614 symbol_type make_LOG(location_type l)7615 make_LOG (location_type l) 7616 { 7617 return symbol_type (token::LOG, std::move (l)); 7618 } 7619 #else 7620 static 7621 symbol_type make_LOG(const location_type & l)7622 make_LOG (const location_type& l) 7623 { 7624 return symbol_type (token::LOG, l); 7625 } 7626 #endif 7627 #if 201103L <= YY_CPLUSPLUS 7628 static 7629 symbol_type make_LN(location_type l)7630 make_LN (location_type l) 7631 { 7632 return symbol_type (token::LN, std::move (l)); 7633 } 7634 #else 7635 static 7636 symbol_type make_LN(const location_type & l)7637 make_LN (const location_type& l) 7638 { 7639 return symbol_type (token::LN, l); 7640 } 7641 #endif 7642 #if 201103L <= YY_CPLUSPLUS 7643 static 7644 symbol_type make_LOG10(location_type l)7645 make_LOG10 (location_type l) 7646 { 7647 return symbol_type (token::LOG10, std::move (l)); 7648 } 7649 #else 7650 static 7651 symbol_type make_LOG10(const location_type & l)7652 make_LOG10 (const location_type& l) 7653 { 7654 return symbol_type (token::LOG10, l); 7655 } 7656 #endif 7657 #if 201103L <= YY_CPLUSPLUS 7658 static 7659 symbol_type make_SIN(location_type l)7660 make_SIN (location_type l) 7661 { 7662 return symbol_type (token::SIN, std::move (l)); 7663 } 7664 #else 7665 static 7666 symbol_type make_SIN(const location_type & l)7667 make_SIN (const location_type& l) 7668 { 7669 return symbol_type (token::SIN, l); 7670 } 7671 #endif 7672 #if 201103L <= YY_CPLUSPLUS 7673 static 7674 symbol_type make_COS(location_type l)7675 make_COS (location_type l) 7676 { 7677 return symbol_type (token::COS, std::move (l)); 7678 } 7679 #else 7680 static 7681 symbol_type make_COS(const location_type & l)7682 make_COS (const location_type& l) 7683 { 7684 return symbol_type (token::COS, l); 7685 } 7686 #endif 7687 #if 201103L <= YY_CPLUSPLUS 7688 static 7689 symbol_type make_TAN(location_type l)7690 make_TAN (location_type l) 7691 { 7692 return symbol_type (token::TAN, std::move (l)); 7693 } 7694 #else 7695 static 7696 symbol_type make_TAN(const location_type & l)7697 make_TAN (const location_type& l) 7698 { 7699 return symbol_type (token::TAN, l); 7700 } 7701 #endif 7702 #if 201103L <= YY_CPLUSPLUS 7703 static 7704 symbol_type make_ASIN(location_type l)7705 make_ASIN (location_type l) 7706 { 7707 return symbol_type (token::ASIN, std::move (l)); 7708 } 7709 #else 7710 static 7711 symbol_type make_ASIN(const location_type & l)7712 make_ASIN (const location_type& l) 7713 { 7714 return symbol_type (token::ASIN, l); 7715 } 7716 #endif 7717 #if 201103L <= YY_CPLUSPLUS 7718 static 7719 symbol_type make_ACOS(location_type l)7720 make_ACOS (location_type l) 7721 { 7722 return symbol_type (token::ACOS, std::move (l)); 7723 } 7724 #else 7725 static 7726 symbol_type make_ACOS(const location_type & l)7727 make_ACOS (const location_type& l) 7728 { 7729 return symbol_type (token::ACOS, l); 7730 } 7731 #endif 7732 #if 201103L <= YY_CPLUSPLUS 7733 static 7734 symbol_type make_ATAN(location_type l)7735 make_ATAN (location_type l) 7736 { 7737 return symbol_type (token::ATAN, std::move (l)); 7738 } 7739 #else 7740 static 7741 symbol_type make_ATAN(const location_type & l)7742 make_ATAN (const location_type& l) 7743 { 7744 return symbol_type (token::ATAN, l); 7745 } 7746 #endif 7747 #if 201103L <= YY_CPLUSPLUS 7748 static 7749 symbol_type make_ERF(location_type l)7750 make_ERF (location_type l) 7751 { 7752 return symbol_type (token::ERF, std::move (l)); 7753 } 7754 #else 7755 static 7756 symbol_type make_ERF(const location_type & l)7757 make_ERF (const location_type& l) 7758 { 7759 return symbol_type (token::ERF, l); 7760 } 7761 #endif 7762 #if 201103L <= YY_CPLUSPLUS 7763 static 7764 symbol_type make_DIFF(location_type l)7765 make_DIFF (location_type l) 7766 { 7767 return symbol_type (token::DIFF, std::move (l)); 7768 } 7769 #else 7770 static 7771 symbol_type make_DIFF(const location_type & l)7772 make_DIFF (const location_type& l) 7773 { 7774 return symbol_type (token::DIFF, l); 7775 } 7776 #endif 7777 #if 201103L <= YY_CPLUSPLUS 7778 static 7779 symbol_type make_ADL(location_type l)7780 make_ADL (location_type l) 7781 { 7782 return symbol_type (token::ADL, std::move (l)); 7783 } 7784 #else 7785 static 7786 symbol_type make_ADL(const location_type & l)7787 make_ADL (const location_type& l) 7788 { 7789 return symbol_type (token::ADL, l); 7790 } 7791 #endif 7792 #if 201103L <= YY_CPLUSPLUS 7793 static 7794 symbol_type make_AUXILIARY_MODEL_NAME(location_type l)7795 make_AUXILIARY_MODEL_NAME (location_type l) 7796 { 7797 return symbol_type (token::AUXILIARY_MODEL_NAME, std::move (l)); 7798 } 7799 #else 7800 static 7801 symbol_type make_AUXILIARY_MODEL_NAME(const location_type & l)7802 make_AUXILIARY_MODEL_NAME (const location_type& l) 7803 { 7804 return symbol_type (token::AUXILIARY_MODEL_NAME, l); 7805 } 7806 #endif 7807 #if 201103L <= YY_CPLUSPLUS 7808 static 7809 symbol_type make_SQRT(location_type l)7810 make_SQRT (location_type l) 7811 { 7812 return symbol_type (token::SQRT, std::move (l)); 7813 } 7814 #else 7815 static 7816 symbol_type make_SQRT(const location_type & l)7817 make_SQRT (const location_type& l) 7818 { 7819 return symbol_type (token::SQRT, l); 7820 } 7821 #endif 7822 #if 201103L <= YY_CPLUSPLUS 7823 static 7824 symbol_type make_CBRT(location_type l)7825 make_CBRT (location_type l) 7826 { 7827 return symbol_type (token::CBRT, std::move (l)); 7828 } 7829 #else 7830 static 7831 symbol_type make_CBRT(const location_type & l)7832 make_CBRT (const location_type& l) 7833 { 7834 return symbol_type (token::CBRT, l); 7835 } 7836 #endif 7837 #if 201103L <= YY_CPLUSPLUS 7838 static 7839 symbol_type make_NORMCDF(location_type l)7840 make_NORMCDF (location_type l) 7841 { 7842 return symbol_type (token::NORMCDF, std::move (l)); 7843 } 7844 #else 7845 static 7846 symbol_type make_NORMCDF(const location_type & l)7847 make_NORMCDF (const location_type& l) 7848 { 7849 return symbol_type (token::NORMCDF, l); 7850 } 7851 #endif 7852 #if 201103L <= YY_CPLUSPLUS 7853 static 7854 symbol_type make_NORMPDF(location_type l)7855 make_NORMPDF (location_type l) 7856 { 7857 return symbol_type (token::NORMPDF, std::move (l)); 7858 } 7859 #else 7860 static 7861 symbol_type make_NORMPDF(const location_type & l)7862 make_NORMPDF (const location_type& l) 7863 { 7864 return symbol_type (token::NORMPDF, l); 7865 } 7866 #endif 7867 #if 201103L <= YY_CPLUSPLUS 7868 static 7869 symbol_type make_STEADY_STATE(location_type l)7870 make_STEADY_STATE (location_type l) 7871 { 7872 return symbol_type (token::STEADY_STATE, std::move (l)); 7873 } 7874 #else 7875 static 7876 symbol_type make_STEADY_STATE(const location_type & l)7877 make_STEADY_STATE (const location_type& l) 7878 { 7879 return symbol_type (token::STEADY_STATE, l); 7880 } 7881 #endif 7882 #if 201103L <= YY_CPLUSPLUS 7883 static 7884 symbol_type make_EXPECTATION(location_type l)7885 make_EXPECTATION (location_type l) 7886 { 7887 return symbol_type (token::EXPECTATION, std::move (l)); 7888 } 7889 #else 7890 static 7891 symbol_type make_EXPECTATION(const location_type & l)7892 make_EXPECTATION (const location_type& l) 7893 { 7894 return symbol_type (token::EXPECTATION, l); 7895 } 7896 #endif 7897 #if 201103L <= YY_CPLUSPLUS 7898 static 7899 symbol_type make_VAR_ESTIMATION(location_type l)7900 make_VAR_ESTIMATION (location_type l) 7901 { 7902 return symbol_type (token::VAR_ESTIMATION, std::move (l)); 7903 } 7904 #else 7905 static 7906 symbol_type make_VAR_ESTIMATION(const location_type & l)7907 make_VAR_ESTIMATION (const location_type& l) 7908 { 7909 return symbol_type (token::VAR_ESTIMATION, l); 7910 } 7911 #endif 7912 #if 201103L <= YY_CPLUSPLUS 7913 static 7914 symbol_type make_DYNARE_SENSITIVITY(location_type l)7915 make_DYNARE_SENSITIVITY (location_type l) 7916 { 7917 return symbol_type (token::DYNARE_SENSITIVITY, std::move (l)); 7918 } 7919 #else 7920 static 7921 symbol_type make_DYNARE_SENSITIVITY(const location_type & l)7922 make_DYNARE_SENSITIVITY (const location_type& l) 7923 { 7924 return symbol_type (token::DYNARE_SENSITIVITY, l); 7925 } 7926 #endif 7927 #if 201103L <= YY_CPLUSPLUS 7928 static 7929 symbol_type make_MORRIS(location_type l)7930 make_MORRIS (location_type l) 7931 { 7932 return symbol_type (token::MORRIS, std::move (l)); 7933 } 7934 #else 7935 static 7936 symbol_type make_MORRIS(const location_type & l)7937 make_MORRIS (const location_type& l) 7938 { 7939 return symbol_type (token::MORRIS, l); 7940 } 7941 #endif 7942 #if 201103L <= YY_CPLUSPLUS 7943 static 7944 symbol_type make_STAB(location_type l)7945 make_STAB (location_type l) 7946 { 7947 return symbol_type (token::STAB, std::move (l)); 7948 } 7949 #else 7950 static 7951 symbol_type make_STAB(const location_type & l)7952 make_STAB (const location_type& l) 7953 { 7954 return symbol_type (token::STAB, l); 7955 } 7956 #endif 7957 #if 201103L <= YY_CPLUSPLUS 7958 static 7959 symbol_type make_REDFORM(location_type l)7960 make_REDFORM (location_type l) 7961 { 7962 return symbol_type (token::REDFORM, std::move (l)); 7963 } 7964 #else 7965 static 7966 symbol_type make_REDFORM(const location_type & l)7967 make_REDFORM (const location_type& l) 7968 { 7969 return symbol_type (token::REDFORM, l); 7970 } 7971 #endif 7972 #if 201103L <= YY_CPLUSPLUS 7973 static 7974 symbol_type make_PPRIOR(location_type l)7975 make_PPRIOR (location_type l) 7976 { 7977 return symbol_type (token::PPRIOR, std::move (l)); 7978 } 7979 #else 7980 static 7981 symbol_type make_PPRIOR(const location_type & l)7982 make_PPRIOR (const location_type& l) 7983 { 7984 return symbol_type (token::PPRIOR, l); 7985 } 7986 #endif 7987 #if 201103L <= YY_CPLUSPLUS 7988 static 7989 symbol_type make_PRIOR_RANGE(location_type l)7990 make_PRIOR_RANGE (location_type l) 7991 { 7992 return symbol_type (token::PRIOR_RANGE, std::move (l)); 7993 } 7994 #else 7995 static 7996 symbol_type make_PRIOR_RANGE(const location_type & l)7997 make_PRIOR_RANGE (const location_type& l) 7998 { 7999 return symbol_type (token::PRIOR_RANGE, l); 8000 } 8001 #endif 8002 #if 201103L <= YY_CPLUSPLUS 8003 static 8004 symbol_type make_PPOST(location_type l)8005 make_PPOST (location_type l) 8006 { 8007 return symbol_type (token::PPOST, std::move (l)); 8008 } 8009 #else 8010 static 8011 symbol_type make_PPOST(const location_type & l)8012 make_PPOST (const location_type& l) 8013 { 8014 return symbol_type (token::PPOST, l); 8015 } 8016 #endif 8017 #if 201103L <= YY_CPLUSPLUS 8018 static 8019 symbol_type make_ILPTAU(location_type l)8020 make_ILPTAU (location_type l) 8021 { 8022 return symbol_type (token::ILPTAU, std::move (l)); 8023 } 8024 #else 8025 static 8026 symbol_type make_ILPTAU(const location_type & l)8027 make_ILPTAU (const location_type& l) 8028 { 8029 return symbol_type (token::ILPTAU, l); 8030 } 8031 #endif 8032 #if 201103L <= YY_CPLUSPLUS 8033 static 8034 symbol_type make_MORRIS_NLIV(location_type l)8035 make_MORRIS_NLIV (location_type l) 8036 { 8037 return symbol_type (token::MORRIS_NLIV, std::move (l)); 8038 } 8039 #else 8040 static 8041 symbol_type make_MORRIS_NLIV(const location_type & l)8042 make_MORRIS_NLIV (const location_type& l) 8043 { 8044 return symbol_type (token::MORRIS_NLIV, l); 8045 } 8046 #endif 8047 #if 201103L <= YY_CPLUSPLUS 8048 static 8049 symbol_type make_MORRIS_NTRA(location_type l)8050 make_MORRIS_NTRA (location_type l) 8051 { 8052 return symbol_type (token::MORRIS_NTRA, std::move (l)); 8053 } 8054 #else 8055 static 8056 symbol_type make_MORRIS_NTRA(const location_type & l)8057 make_MORRIS_NTRA (const location_type& l) 8058 { 8059 return symbol_type (token::MORRIS_NTRA, l); 8060 } 8061 #endif 8062 #if 201103L <= YY_CPLUSPLUS 8063 static 8064 symbol_type make_NSAM(location_type l)8065 make_NSAM (location_type l) 8066 { 8067 return symbol_type (token::NSAM, std::move (l)); 8068 } 8069 #else 8070 static 8071 symbol_type make_NSAM(const location_type & l)8072 make_NSAM (const location_type& l) 8073 { 8074 return symbol_type (token::NSAM, l); 8075 } 8076 #endif 8077 #if 201103L <= YY_CPLUSPLUS 8078 static 8079 symbol_type make_LOAD_REDFORM(location_type l)8080 make_LOAD_REDFORM (location_type l) 8081 { 8082 return symbol_type (token::LOAD_REDFORM, std::move (l)); 8083 } 8084 #else 8085 static 8086 symbol_type make_LOAD_REDFORM(const location_type & l)8087 make_LOAD_REDFORM (const location_type& l) 8088 { 8089 return symbol_type (token::LOAD_REDFORM, l); 8090 } 8091 #endif 8092 #if 201103L <= YY_CPLUSPLUS 8093 static 8094 symbol_type make_LOAD_RMSE(location_type l)8095 make_LOAD_RMSE (location_type l) 8096 { 8097 return symbol_type (token::LOAD_RMSE, std::move (l)); 8098 } 8099 #else 8100 static 8101 symbol_type make_LOAD_RMSE(const location_type & l)8102 make_LOAD_RMSE (const location_type& l) 8103 { 8104 return symbol_type (token::LOAD_RMSE, l); 8105 } 8106 #endif 8107 #if 201103L <= YY_CPLUSPLUS 8108 static 8109 symbol_type make_LOAD_STAB(location_type l)8110 make_LOAD_STAB (location_type l) 8111 { 8112 return symbol_type (token::LOAD_STAB, std::move (l)); 8113 } 8114 #else 8115 static 8116 symbol_type make_LOAD_STAB(const location_type & l)8117 make_LOAD_STAB (const location_type& l) 8118 { 8119 return symbol_type (token::LOAD_STAB, l); 8120 } 8121 #endif 8122 #if 201103L <= YY_CPLUSPLUS 8123 static 8124 symbol_type make_ALPHA2_STAB(location_type l)8125 make_ALPHA2_STAB (location_type l) 8126 { 8127 return symbol_type (token::ALPHA2_STAB, std::move (l)); 8128 } 8129 #else 8130 static 8131 symbol_type make_ALPHA2_STAB(const location_type & l)8132 make_ALPHA2_STAB (const location_type& l) 8133 { 8134 return symbol_type (token::ALPHA2_STAB, l); 8135 } 8136 #endif 8137 #if 201103L <= YY_CPLUSPLUS 8138 static 8139 symbol_type make_LOGTRANS_REDFORM(location_type l)8140 make_LOGTRANS_REDFORM (location_type l) 8141 { 8142 return symbol_type (token::LOGTRANS_REDFORM, std::move (l)); 8143 } 8144 #else 8145 static 8146 symbol_type make_LOGTRANS_REDFORM(const location_type & l)8147 make_LOGTRANS_REDFORM (const location_type& l) 8148 { 8149 return symbol_type (token::LOGTRANS_REDFORM, l); 8150 } 8151 #endif 8152 #if 201103L <= YY_CPLUSPLUS 8153 static 8154 symbol_type make_THRESHOLD_REDFORM(location_type l)8155 make_THRESHOLD_REDFORM (location_type l) 8156 { 8157 return symbol_type (token::THRESHOLD_REDFORM, std::move (l)); 8158 } 8159 #else 8160 static 8161 symbol_type make_THRESHOLD_REDFORM(const location_type & l)8162 make_THRESHOLD_REDFORM (const location_type& l) 8163 { 8164 return symbol_type (token::THRESHOLD_REDFORM, l); 8165 } 8166 #endif 8167 #if 201103L <= YY_CPLUSPLUS 8168 static 8169 symbol_type make_KSSTAT_REDFORM(location_type l)8170 make_KSSTAT_REDFORM (location_type l) 8171 { 8172 return symbol_type (token::KSSTAT_REDFORM, std::move (l)); 8173 } 8174 #else 8175 static 8176 symbol_type make_KSSTAT_REDFORM(const location_type & l)8177 make_KSSTAT_REDFORM (const location_type& l) 8178 { 8179 return symbol_type (token::KSSTAT_REDFORM, l); 8180 } 8181 #endif 8182 #if 201103L <= YY_CPLUSPLUS 8183 static 8184 symbol_type make_ALPHA2_REDFORM(location_type l)8185 make_ALPHA2_REDFORM (location_type l) 8186 { 8187 return symbol_type (token::ALPHA2_REDFORM, std::move (l)); 8188 } 8189 #else 8190 static 8191 symbol_type make_ALPHA2_REDFORM(const location_type & l)8192 make_ALPHA2_REDFORM (const location_type& l) 8193 { 8194 return symbol_type (token::ALPHA2_REDFORM, l); 8195 } 8196 #endif 8197 #if 201103L <= YY_CPLUSPLUS 8198 static 8199 symbol_type make_NAMENDO(location_type l)8200 make_NAMENDO (location_type l) 8201 { 8202 return symbol_type (token::NAMENDO, std::move (l)); 8203 } 8204 #else 8205 static 8206 symbol_type make_NAMENDO(const location_type & l)8207 make_NAMENDO (const location_type& l) 8208 { 8209 return symbol_type (token::NAMENDO, l); 8210 } 8211 #endif 8212 #if 201103L <= YY_CPLUSPLUS 8213 static 8214 symbol_type make_NAMLAGENDO(location_type l)8215 make_NAMLAGENDO (location_type l) 8216 { 8217 return symbol_type (token::NAMLAGENDO, std::move (l)); 8218 } 8219 #else 8220 static 8221 symbol_type make_NAMLAGENDO(const location_type & l)8222 make_NAMLAGENDO (const location_type& l) 8223 { 8224 return symbol_type (token::NAMLAGENDO, l); 8225 } 8226 #endif 8227 #if 201103L <= YY_CPLUSPLUS 8228 static 8229 symbol_type make_NAMEXO(location_type l)8230 make_NAMEXO (location_type l) 8231 { 8232 return symbol_type (token::NAMEXO, std::move (l)); 8233 } 8234 #else 8235 static 8236 symbol_type make_NAMEXO(const location_type & l)8237 make_NAMEXO (const location_type& l) 8238 { 8239 return symbol_type (token::NAMEXO, l); 8240 } 8241 #endif 8242 #if 201103L <= YY_CPLUSPLUS 8243 static 8244 symbol_type make_RMSE(location_type l)8245 make_RMSE (location_type l) 8246 { 8247 return symbol_type (token::RMSE, std::move (l)); 8248 } 8249 #else 8250 static 8251 symbol_type make_RMSE(const location_type & l)8252 make_RMSE (const location_type& l) 8253 { 8254 return symbol_type (token::RMSE, l); 8255 } 8256 #endif 8257 #if 201103L <= YY_CPLUSPLUS 8258 static 8259 symbol_type make_LIK_ONLY(location_type l)8260 make_LIK_ONLY (location_type l) 8261 { 8262 return symbol_type (token::LIK_ONLY, std::move (l)); 8263 } 8264 #else 8265 static 8266 symbol_type make_LIK_ONLY(const location_type & l)8267 make_LIK_ONLY (const location_type& l) 8268 { 8269 return symbol_type (token::LIK_ONLY, l); 8270 } 8271 #endif 8272 #if 201103L <= YY_CPLUSPLUS 8273 static 8274 symbol_type make_VAR_RMSE(location_type l)8275 make_VAR_RMSE (location_type l) 8276 { 8277 return symbol_type (token::VAR_RMSE, std::move (l)); 8278 } 8279 #else 8280 static 8281 symbol_type make_VAR_RMSE(const location_type & l)8282 make_VAR_RMSE (const location_type& l) 8283 { 8284 return symbol_type (token::VAR_RMSE, l); 8285 } 8286 #endif 8287 #if 201103L <= YY_CPLUSPLUS 8288 static 8289 symbol_type make_PFILT_RMSE(location_type l)8290 make_PFILT_RMSE (location_type l) 8291 { 8292 return symbol_type (token::PFILT_RMSE, std::move (l)); 8293 } 8294 #else 8295 static 8296 symbol_type make_PFILT_RMSE(const location_type & l)8297 make_PFILT_RMSE (const location_type& l) 8298 { 8299 return symbol_type (token::PFILT_RMSE, l); 8300 } 8301 #endif 8302 #if 201103L <= YY_CPLUSPLUS 8303 static 8304 symbol_type make_ISTART_RMSE(location_type l)8305 make_ISTART_RMSE (location_type l) 8306 { 8307 return symbol_type (token::ISTART_RMSE, std::move (l)); 8308 } 8309 #else 8310 static 8311 symbol_type make_ISTART_RMSE(const location_type & l)8312 make_ISTART_RMSE (const location_type& l) 8313 { 8314 return symbol_type (token::ISTART_RMSE, l); 8315 } 8316 #endif 8317 #if 201103L <= YY_CPLUSPLUS 8318 static 8319 symbol_type make_ALPHA_RMSE(location_type l)8320 make_ALPHA_RMSE (location_type l) 8321 { 8322 return symbol_type (token::ALPHA_RMSE, std::move (l)); 8323 } 8324 #else 8325 static 8326 symbol_type make_ALPHA_RMSE(const location_type & l)8327 make_ALPHA_RMSE (const location_type& l) 8328 { 8329 return symbol_type (token::ALPHA_RMSE, l); 8330 } 8331 #endif 8332 #if 201103L <= YY_CPLUSPLUS 8333 static 8334 symbol_type make_ALPHA2_RMSE(location_type l)8335 make_ALPHA2_RMSE (location_type l) 8336 { 8337 return symbol_type (token::ALPHA2_RMSE, std::move (l)); 8338 } 8339 #else 8340 static 8341 symbol_type make_ALPHA2_RMSE(const location_type & l)8342 make_ALPHA2_RMSE (const location_type& l) 8343 { 8344 return symbol_type (token::ALPHA2_RMSE, l); 8345 } 8346 #endif 8347 #if 201103L <= YY_CPLUSPLUS 8348 static 8349 symbol_type make_FREQ(location_type l)8350 make_FREQ (location_type l) 8351 { 8352 return symbol_type (token::FREQ, std::move (l)); 8353 } 8354 #else 8355 static 8356 symbol_type make_FREQ(const location_type & l)8357 make_FREQ (const location_type& l) 8358 { 8359 return symbol_type (token::FREQ, l); 8360 } 8361 #endif 8362 #if 201103L <= YY_CPLUSPLUS 8363 static 8364 symbol_type make_INITIAL_YEAR(location_type l)8365 make_INITIAL_YEAR (location_type l) 8366 { 8367 return symbol_type (token::INITIAL_YEAR, std::move (l)); 8368 } 8369 #else 8370 static 8371 symbol_type make_INITIAL_YEAR(const location_type & l)8372 make_INITIAL_YEAR (const location_type& l) 8373 { 8374 return symbol_type (token::INITIAL_YEAR, l); 8375 } 8376 #endif 8377 #if 201103L <= YY_CPLUSPLUS 8378 static 8379 symbol_type make_INITIAL_SUBPERIOD(location_type l)8380 make_INITIAL_SUBPERIOD (location_type l) 8381 { 8382 return symbol_type (token::INITIAL_SUBPERIOD, std::move (l)); 8383 } 8384 #else 8385 static 8386 symbol_type make_INITIAL_SUBPERIOD(const location_type & l)8387 make_INITIAL_SUBPERIOD (const location_type& l) 8388 { 8389 return symbol_type (token::INITIAL_SUBPERIOD, l); 8390 } 8391 #endif 8392 #if 201103L <= YY_CPLUSPLUS 8393 static 8394 symbol_type make_FINAL_YEAR(location_type l)8395 make_FINAL_YEAR (location_type l) 8396 { 8397 return symbol_type (token::FINAL_YEAR, std::move (l)); 8398 } 8399 #else 8400 static 8401 symbol_type make_FINAL_YEAR(const location_type & l)8402 make_FINAL_YEAR (const location_type& l) 8403 { 8404 return symbol_type (token::FINAL_YEAR, l); 8405 } 8406 #endif 8407 #if 201103L <= YY_CPLUSPLUS 8408 static 8409 symbol_type make_FINAL_SUBPERIOD(location_type l)8410 make_FINAL_SUBPERIOD (location_type l) 8411 { 8412 return symbol_type (token::FINAL_SUBPERIOD, std::move (l)); 8413 } 8414 #else 8415 static 8416 symbol_type make_FINAL_SUBPERIOD(const location_type & l)8417 make_FINAL_SUBPERIOD (const location_type& l) 8418 { 8419 return symbol_type (token::FINAL_SUBPERIOD, l); 8420 } 8421 #endif 8422 #if 201103L <= YY_CPLUSPLUS 8423 static 8424 symbol_type make_DATA(location_type l)8425 make_DATA (location_type l) 8426 { 8427 return symbol_type (token::DATA, std::move (l)); 8428 } 8429 #else 8430 static 8431 symbol_type make_DATA(const location_type & l)8432 make_DATA (const location_type& l) 8433 { 8434 return symbol_type (token::DATA, l); 8435 } 8436 #endif 8437 #if 201103L <= YY_CPLUSPLUS 8438 static 8439 symbol_type make_VLIST(location_type l)8440 make_VLIST (location_type l) 8441 { 8442 return symbol_type (token::VLIST, std::move (l)); 8443 } 8444 #else 8445 static 8446 symbol_type make_VLIST(const location_type & l)8447 make_VLIST (const location_type& l) 8448 { 8449 return symbol_type (token::VLIST, l); 8450 } 8451 #endif 8452 #if 201103L <= YY_CPLUSPLUS 8453 static 8454 symbol_type make_VLISTLOG(location_type l)8455 make_VLISTLOG (location_type l) 8456 { 8457 return symbol_type (token::VLISTLOG, std::move (l)); 8458 } 8459 #else 8460 static 8461 symbol_type make_VLISTLOG(const location_type & l)8462 make_VLISTLOG (const location_type& l) 8463 { 8464 return symbol_type (token::VLISTLOG, l); 8465 } 8466 #endif 8467 #if 201103L <= YY_CPLUSPLUS 8468 static 8469 symbol_type make_VLISTPER(location_type l)8470 make_VLISTPER (location_type l) 8471 { 8472 return symbol_type (token::VLISTPER, std::move (l)); 8473 } 8474 #else 8475 static 8476 symbol_type make_VLISTPER(const location_type & l)8477 make_VLISTPER (const location_type& l) 8478 { 8479 return symbol_type (token::VLISTPER, l); 8480 } 8481 #endif 8482 #if 201103L <= YY_CPLUSPLUS 8483 static 8484 symbol_type make_SPECTRAL_DENSITY(location_type l)8485 make_SPECTRAL_DENSITY (location_type l) 8486 { 8487 return symbol_type (token::SPECTRAL_DENSITY, std::move (l)); 8488 } 8489 #else 8490 static 8491 symbol_type make_SPECTRAL_DENSITY(const location_type & l)8492 make_SPECTRAL_DENSITY (const location_type& l) 8493 { 8494 return symbol_type (token::SPECTRAL_DENSITY, l); 8495 } 8496 #endif 8497 #if 201103L <= YY_CPLUSPLUS 8498 static 8499 symbol_type make_INIT2SHOCKS(location_type l)8500 make_INIT2SHOCKS (location_type l) 8501 { 8502 return symbol_type (token::INIT2SHOCKS, std::move (l)); 8503 } 8504 #else 8505 static 8506 symbol_type make_INIT2SHOCKS(const location_type & l)8507 make_INIT2SHOCKS (const location_type& l) 8508 { 8509 return symbol_type (token::INIT2SHOCKS, l); 8510 } 8511 #endif 8512 #if 201103L <= YY_CPLUSPLUS 8513 static 8514 symbol_type make_RESTRICTION(location_type l)8515 make_RESTRICTION (location_type l) 8516 { 8517 return symbol_type (token::RESTRICTION, std::move (l)); 8518 } 8519 #else 8520 static 8521 symbol_type make_RESTRICTION(const location_type & l)8522 make_RESTRICTION (const location_type& l) 8523 { 8524 return symbol_type (token::RESTRICTION, l); 8525 } 8526 #endif 8527 #if 201103L <= YY_CPLUSPLUS 8528 static 8529 symbol_type make_RESTRICTION_FNAME(location_type l)8530 make_RESTRICTION_FNAME (location_type l) 8531 { 8532 return symbol_type (token::RESTRICTION_FNAME, std::move (l)); 8533 } 8534 #else 8535 static 8536 symbol_type make_RESTRICTION_FNAME(const location_type & l)8537 make_RESTRICTION_FNAME (const location_type& l) 8538 { 8539 return symbol_type (token::RESTRICTION_FNAME, l); 8540 } 8541 #endif 8542 #if 201103L <= YY_CPLUSPLUS 8543 static 8544 symbol_type make_CROSS_RESTRICTIONS(location_type l)8545 make_CROSS_RESTRICTIONS (location_type l) 8546 { 8547 return symbol_type (token::CROSS_RESTRICTIONS, std::move (l)); 8548 } 8549 #else 8550 static 8551 symbol_type make_CROSS_RESTRICTIONS(const location_type & l)8552 make_CROSS_RESTRICTIONS (const location_type& l) 8553 { 8554 return symbol_type (token::CROSS_RESTRICTIONS, l); 8555 } 8556 #endif 8557 #if 201103L <= YY_CPLUSPLUS 8558 static 8559 symbol_type make_NLAGS(location_type l)8560 make_NLAGS (location_type l) 8561 { 8562 return symbol_type (token::NLAGS, std::move (l)); 8563 } 8564 #else 8565 static 8566 symbol_type make_NLAGS(const location_type & l)8567 make_NLAGS (const location_type& l) 8568 { 8569 return symbol_type (token::NLAGS, l); 8570 } 8571 #endif 8572 #if 201103L <= YY_CPLUSPLUS 8573 static 8574 symbol_type make_CONTEMP_REDUCED_FORM(location_type l)8575 make_CONTEMP_REDUCED_FORM (location_type l) 8576 { 8577 return symbol_type (token::CONTEMP_REDUCED_FORM, std::move (l)); 8578 } 8579 #else 8580 static 8581 symbol_type make_CONTEMP_REDUCED_FORM(const location_type & l)8582 make_CONTEMP_REDUCED_FORM (const location_type& l) 8583 { 8584 return symbol_type (token::CONTEMP_REDUCED_FORM, l); 8585 } 8586 #endif 8587 #if 201103L <= YY_CPLUSPLUS 8588 static 8589 symbol_type make_REAL_PSEUDO_FORECAST(location_type l)8590 make_REAL_PSEUDO_FORECAST (location_type l) 8591 { 8592 return symbol_type (token::REAL_PSEUDO_FORECAST, std::move (l)); 8593 } 8594 #else 8595 static 8596 symbol_type make_REAL_PSEUDO_FORECAST(const location_type & l)8597 make_REAL_PSEUDO_FORECAST (const location_type& l) 8598 { 8599 return symbol_type (token::REAL_PSEUDO_FORECAST, l); 8600 } 8601 #endif 8602 #if 201103L <= YY_CPLUSPLUS 8603 static 8604 symbol_type make_DUMMY_OBS(location_type l)8605 make_DUMMY_OBS (location_type l) 8606 { 8607 return symbol_type (token::DUMMY_OBS, std::move (l)); 8608 } 8609 #else 8610 static 8611 symbol_type make_DUMMY_OBS(const location_type & l)8612 make_DUMMY_OBS (const location_type& l) 8613 { 8614 return symbol_type (token::DUMMY_OBS, l); 8615 } 8616 #endif 8617 #if 201103L <= YY_CPLUSPLUS 8618 static 8619 symbol_type make_NSTATES(location_type l)8620 make_NSTATES (location_type l) 8621 { 8622 return symbol_type (token::NSTATES, std::move (l)); 8623 } 8624 #else 8625 static 8626 symbol_type make_NSTATES(const location_type & l)8627 make_NSTATES (const location_type& l) 8628 { 8629 return symbol_type (token::NSTATES, l); 8630 } 8631 #endif 8632 #if 201103L <= YY_CPLUSPLUS 8633 static 8634 symbol_type make_INDXSCALESSTATES(location_type l)8635 make_INDXSCALESSTATES (location_type l) 8636 { 8637 return symbol_type (token::INDXSCALESSTATES, std::move (l)); 8638 } 8639 #else 8640 static 8641 symbol_type make_INDXSCALESSTATES(const location_type & l)8642 make_INDXSCALESSTATES (const location_type& l) 8643 { 8644 return symbol_type (token::INDXSCALESSTATES, l); 8645 } 8646 #endif 8647 #if 201103L <= YY_CPLUSPLUS 8648 static 8649 symbol_type make_NO_BAYESIAN_PRIOR(location_type l)8650 make_NO_BAYESIAN_PRIOR (location_type l) 8651 { 8652 return symbol_type (token::NO_BAYESIAN_PRIOR, std::move (l)); 8653 } 8654 #else 8655 static 8656 symbol_type make_NO_BAYESIAN_PRIOR(const location_type & l)8657 make_NO_BAYESIAN_PRIOR (const location_type& l) 8658 { 8659 return symbol_type (token::NO_BAYESIAN_PRIOR, l); 8660 } 8661 #endif 8662 #if 201103L <= YY_CPLUSPLUS 8663 static 8664 symbol_type make_SPECIFICATION(location_type l)8665 make_SPECIFICATION (location_type l) 8666 { 8667 return symbol_type (token::SPECIFICATION, std::move (l)); 8668 } 8669 #else 8670 static 8671 symbol_type make_SPECIFICATION(const location_type & l)8672 make_SPECIFICATION (const location_type& l) 8673 { 8674 return symbol_type (token::SPECIFICATION, l); 8675 } 8676 #endif 8677 #if 201103L <= YY_CPLUSPLUS 8678 static 8679 symbol_type make_SIMS_ZHA(location_type l)8680 make_SIMS_ZHA (location_type l) 8681 { 8682 return symbol_type (token::SIMS_ZHA, std::move (l)); 8683 } 8684 #else 8685 static 8686 symbol_type make_SIMS_ZHA(const location_type & l)8687 make_SIMS_ZHA (const location_type& l) 8688 { 8689 return symbol_type (token::SIMS_ZHA, l); 8690 } 8691 #endif 8692 #if 201103L <= YY_CPLUSPLUS 8693 static 8694 symbol_type make_ALPHA(string v,location_type l)8695 make_ALPHA (string v, location_type l) 8696 { 8697 return symbol_type (token::ALPHA, std::move (v), std::move (l)); 8698 } 8699 #else 8700 static 8701 symbol_type make_ALPHA(const string & v,const location_type & l)8702 make_ALPHA (const string& v, const location_type& l) 8703 { 8704 return symbol_type (token::ALPHA, v, l); 8705 } 8706 #endif 8707 #if 201103L <= YY_CPLUSPLUS 8708 static 8709 symbol_type make_BETA(string v,location_type l)8710 make_BETA (string v, location_type l) 8711 { 8712 return symbol_type (token::BETA, std::move (v), std::move (l)); 8713 } 8714 #else 8715 static 8716 symbol_type make_BETA(const string & v,const location_type & l)8717 make_BETA (const string& v, const location_type& l) 8718 { 8719 return symbol_type (token::BETA, v, l); 8720 } 8721 #endif 8722 #if 201103L <= YY_CPLUSPLUS 8723 static 8724 symbol_type make_ABAND(string v,location_type l)8725 make_ABAND (string v, location_type l) 8726 { 8727 return symbol_type (token::ABAND, std::move (v), std::move (l)); 8728 } 8729 #else 8730 static 8731 symbol_type make_ABAND(const string & v,const location_type & l)8732 make_ABAND (const string& v, const location_type& l) 8733 { 8734 return symbol_type (token::ABAND, v, l); 8735 } 8736 #endif 8737 #if 201103L <= YY_CPLUSPLUS 8738 static 8739 symbol_type make_NINV(string v,location_type l)8740 make_NINV (string v, location_type l) 8741 { 8742 return symbol_type (token::NINV, std::move (v), std::move (l)); 8743 } 8744 #else 8745 static 8746 symbol_type make_NINV(const string & v,const location_type & l)8747 make_NINV (const string& v, const location_type& l) 8748 { 8749 return symbol_type (token::NINV, v, l); 8750 } 8751 #endif 8752 #if 201103L <= YY_CPLUSPLUS 8753 static 8754 symbol_type make_CMS(string v,location_type l)8755 make_CMS (string v, location_type l) 8756 { 8757 return symbol_type (token::CMS, std::move (v), std::move (l)); 8758 } 8759 #else 8760 static 8761 symbol_type make_CMS(const string & v,const location_type & l)8762 make_CMS (const string& v, const location_type& l) 8763 { 8764 return symbol_type (token::CMS, v, l); 8765 } 8766 #endif 8767 #if 201103L <= YY_CPLUSPLUS 8768 static 8769 symbol_type make_NCMS(string v,location_type l)8770 make_NCMS (string v, location_type l) 8771 { 8772 return symbol_type (token::NCMS, std::move (v), std::move (l)); 8773 } 8774 #else 8775 static 8776 symbol_type make_NCMS(const string & v,const location_type & l)8777 make_NCMS (const string& v, const location_type& l) 8778 { 8779 return symbol_type (token::NCMS, v, l); 8780 } 8781 #endif 8782 #if 201103L <= YY_CPLUSPLUS 8783 static 8784 symbol_type make_CNUM(string v,location_type l)8785 make_CNUM (string v, location_type l) 8786 { 8787 return symbol_type (token::CNUM, std::move (v), std::move (l)); 8788 } 8789 #else 8790 static 8791 symbol_type make_CNUM(const string & v,const location_type & l)8792 make_CNUM (const string& v, const location_type& l) 8793 { 8794 return symbol_type (token::CNUM, v, l); 8795 } 8796 #endif 8797 #if 201103L <= YY_CPLUSPLUS 8798 static 8799 symbol_type make_GAMMA(string v,location_type l)8800 make_GAMMA (string v, location_type l) 8801 { 8802 return symbol_type (token::GAMMA, std::move (v), std::move (l)); 8803 } 8804 #else 8805 static 8806 symbol_type make_GAMMA(const string & v,const location_type & l)8807 make_GAMMA (const string& v, const location_type& l) 8808 { 8809 return symbol_type (token::GAMMA, v, l); 8810 } 8811 #endif 8812 #if 201103L <= YY_CPLUSPLUS 8813 static 8814 symbol_type make_INV_GAMMA(string v,location_type l)8815 make_INV_GAMMA (string v, location_type l) 8816 { 8817 return symbol_type (token::INV_GAMMA, std::move (v), std::move (l)); 8818 } 8819 #else 8820 static 8821 symbol_type make_INV_GAMMA(const string & v,const location_type & l)8822 make_INV_GAMMA (const string& v, const location_type& l) 8823 { 8824 return symbol_type (token::INV_GAMMA, v, l); 8825 } 8826 #endif 8827 #if 201103L <= YY_CPLUSPLUS 8828 static 8829 symbol_type make_INV_GAMMA1(string v,location_type l)8830 make_INV_GAMMA1 (string v, location_type l) 8831 { 8832 return symbol_type (token::INV_GAMMA1, std::move (v), std::move (l)); 8833 } 8834 #else 8835 static 8836 symbol_type make_INV_GAMMA1(const string & v,const location_type & l)8837 make_INV_GAMMA1 (const string& v, const location_type& l) 8838 { 8839 return symbol_type (token::INV_GAMMA1, v, l); 8840 } 8841 #endif 8842 #if 201103L <= YY_CPLUSPLUS 8843 static 8844 symbol_type make_INV_GAMMA2(string v,location_type l)8845 make_INV_GAMMA2 (string v, location_type l) 8846 { 8847 return symbol_type (token::INV_GAMMA2, std::move (v), std::move (l)); 8848 } 8849 #else 8850 static 8851 symbol_type make_INV_GAMMA2(const string & v,const location_type & l)8852 make_INV_GAMMA2 (const string& v, const location_type& l) 8853 { 8854 return symbol_type (token::INV_GAMMA2, v, l); 8855 } 8856 #endif 8857 #if 201103L <= YY_CPLUSPLUS 8858 static 8859 symbol_type make_NORMAL(string v,location_type l)8860 make_NORMAL (string v, location_type l) 8861 { 8862 return symbol_type (token::NORMAL, std::move (v), std::move (l)); 8863 } 8864 #else 8865 static 8866 symbol_type make_NORMAL(const string & v,const location_type & l)8867 make_NORMAL (const string& v, const location_type& l) 8868 { 8869 return symbol_type (token::NORMAL, v, l); 8870 } 8871 #endif 8872 #if 201103L <= YY_CPLUSPLUS 8873 static 8874 symbol_type make_UNIFORM(string v,location_type l)8875 make_UNIFORM (string v, location_type l) 8876 { 8877 return symbol_type (token::UNIFORM, std::move (v), std::move (l)); 8878 } 8879 #else 8880 static 8881 symbol_type make_UNIFORM(const string & v,const location_type & l)8882 make_UNIFORM (const string& v, const location_type& l) 8883 { 8884 return symbol_type (token::UNIFORM, v, l); 8885 } 8886 #endif 8887 #if 201103L <= YY_CPLUSPLUS 8888 static 8889 symbol_type make_EPS(string v,location_type l)8890 make_EPS (string v, location_type l) 8891 { 8892 return symbol_type (token::EPS, std::move (v), std::move (l)); 8893 } 8894 #else 8895 static 8896 symbol_type make_EPS(const string & v,const location_type & l)8897 make_EPS (const string& v, const location_type& l) 8898 { 8899 return symbol_type (token::EPS, v, l); 8900 } 8901 #endif 8902 #if 201103L <= YY_CPLUSPLUS 8903 static 8904 symbol_type make_PDF(string v,location_type l)8905 make_PDF (string v, location_type l) 8906 { 8907 return symbol_type (token::PDF, std::move (v), std::move (l)); 8908 } 8909 #else 8910 static 8911 symbol_type make_PDF(const string & v,const location_type & l)8912 make_PDF (const string& v, const location_type& l) 8913 { 8914 return symbol_type (token::PDF, v, l); 8915 } 8916 #endif 8917 #if 201103L <= YY_CPLUSPLUS 8918 static 8919 symbol_type make_FIG(string v,location_type l)8920 make_FIG (string v, location_type l) 8921 { 8922 return symbol_type (token::FIG, std::move (v), std::move (l)); 8923 } 8924 #else 8925 static 8926 symbol_type make_FIG(const string & v,const location_type & l)8927 make_FIG (const string& v, const location_type& l) 8928 { 8929 return symbol_type (token::FIG, v, l); 8930 } 8931 #endif 8932 #if 201103L <= YY_CPLUSPLUS 8933 static 8934 symbol_type make_DR(string v,location_type l)8935 make_DR (string v, location_type l) 8936 { 8937 return symbol_type (token::DR, std::move (v), std::move (l)); 8938 } 8939 #else 8940 static 8941 symbol_type make_DR(const string & v,const location_type & l)8942 make_DR (const string& v, const location_type& l) 8943 { 8944 return symbol_type (token::DR, v, l); 8945 } 8946 #endif 8947 #if 201103L <= YY_CPLUSPLUS 8948 static 8949 symbol_type make_NONE(string v,location_type l)8950 make_NONE (string v, location_type l) 8951 { 8952 return symbol_type (token::NONE, std::move (v), std::move (l)); 8953 } 8954 #else 8955 static 8956 symbol_type make_NONE(const string & v,const location_type & l)8957 make_NONE (const string& v, const location_type& l) 8958 { 8959 return symbol_type (token::NONE, v, l); 8960 } 8961 #endif 8962 #if 201103L <= YY_CPLUSPLUS 8963 static 8964 symbol_type make_PRIOR(string v,location_type l)8965 make_PRIOR (string v, location_type l) 8966 { 8967 return symbol_type (token::PRIOR, std::move (v), std::move (l)); 8968 } 8969 #else 8970 static 8971 symbol_type make_PRIOR(const string & v,const location_type & l)8972 make_PRIOR (const string& v, const location_type& l) 8973 { 8974 return symbol_type (token::PRIOR, v, l); 8975 } 8976 #endif 8977 #if 201103L <= YY_CPLUSPLUS 8978 static 8979 symbol_type make_PRIOR_VARIANCE(string v,location_type l)8980 make_PRIOR_VARIANCE (string v, location_type l) 8981 { 8982 return symbol_type (token::PRIOR_VARIANCE, std::move (v), std::move (l)); 8983 } 8984 #else 8985 static 8986 symbol_type make_PRIOR_VARIANCE(const string & v,const location_type & l)8987 make_PRIOR_VARIANCE (const string& v, const location_type& l) 8988 { 8989 return symbol_type (token::PRIOR_VARIANCE, v, l); 8990 } 8991 #endif 8992 #if 201103L <= YY_CPLUSPLUS 8993 static 8994 symbol_type make_HESSIAN(string v,location_type l)8995 make_HESSIAN (string v, location_type l) 8996 { 8997 return symbol_type (token::HESSIAN, std::move (v), std::move (l)); 8998 } 8999 #else 9000 static 9001 symbol_type make_HESSIAN(const string & v,const location_type & l)9002 make_HESSIAN (const string& v, const location_type& l) 9003 { 9004 return symbol_type (token::HESSIAN, v, l); 9005 } 9006 #endif 9007 #if 201103L <= YY_CPLUSPLUS 9008 static 9009 symbol_type make_IDENTITY_MATRIX(string v,location_type l)9010 make_IDENTITY_MATRIX (string v, location_type l) 9011 { 9012 return symbol_type (token::IDENTITY_MATRIX, std::move (v), std::move (l)); 9013 } 9014 #else 9015 static 9016 symbol_type make_IDENTITY_MATRIX(const string & v,const location_type & l)9017 make_IDENTITY_MATRIX (const string& v, const location_type& l) 9018 { 9019 return symbol_type (token::IDENTITY_MATRIX, v, l); 9020 } 9021 #endif 9022 #if 201103L <= YY_CPLUSPLUS 9023 static 9024 symbol_type make_DIRICHLET(string v,location_type l)9025 make_DIRICHLET (string v, location_type l) 9026 { 9027 return symbol_type (token::DIRICHLET, std::move (v), std::move (l)); 9028 } 9029 #else 9030 static 9031 symbol_type make_DIRICHLET(const string & v,const location_type & l)9032 make_DIRICHLET (const string& v, const location_type& l) 9033 { 9034 return symbol_type (token::DIRICHLET, v, l); 9035 } 9036 #endif 9037 #if 201103L <= YY_CPLUSPLUS 9038 static 9039 symbol_type make_DIAGONAL(string v,location_type l)9040 make_DIAGONAL (string v, location_type l) 9041 { 9042 return symbol_type (token::DIAGONAL, std::move (v), std::move (l)); 9043 } 9044 #else 9045 static 9046 symbol_type make_DIAGONAL(const string & v,const location_type & l)9047 make_DIAGONAL (const string& v, const location_type& l) 9048 { 9049 return symbol_type (token::DIAGONAL, v, l); 9050 } 9051 #endif 9052 #if 201103L <= YY_CPLUSPLUS 9053 static 9054 symbol_type make_OPTIMAL(string v,location_type l)9055 make_OPTIMAL (string v, location_type l) 9056 { 9057 return symbol_type (token::OPTIMAL, std::move (v), std::move (l)); 9058 } 9059 #else 9060 static 9061 symbol_type make_OPTIMAL(const string & v,const location_type & l)9062 make_OPTIMAL (const string& v, const location_type& l) 9063 { 9064 return symbol_type (token::OPTIMAL, v, l); 9065 } 9066 #endif 9067 #if 201103L <= YY_CPLUSPLUS 9068 static 9069 symbol_type make_GSIG2_LMDM(location_type l)9070 make_GSIG2_LMDM (location_type l) 9071 { 9072 return symbol_type (token::GSIG2_LMDM, std::move (l)); 9073 } 9074 #else 9075 static 9076 symbol_type make_GSIG2_LMDM(const location_type & l)9077 make_GSIG2_LMDM (const location_type& l) 9078 { 9079 return symbol_type (token::GSIG2_LMDM, l); 9080 } 9081 #endif 9082 #if 201103L <= YY_CPLUSPLUS 9083 static 9084 symbol_type make_Q_DIAG(location_type l)9085 make_Q_DIAG (location_type l) 9086 { 9087 return symbol_type (token::Q_DIAG, std::move (l)); 9088 } 9089 #else 9090 static 9091 symbol_type make_Q_DIAG(const location_type & l)9092 make_Q_DIAG (const location_type& l) 9093 { 9094 return symbol_type (token::Q_DIAG, l); 9095 } 9096 #endif 9097 #if 201103L <= YY_CPLUSPLUS 9098 static 9099 symbol_type make_FLAT_PRIOR(location_type l)9100 make_FLAT_PRIOR (location_type l) 9101 { 9102 return symbol_type (token::FLAT_PRIOR, std::move (l)); 9103 } 9104 #else 9105 static 9106 symbol_type make_FLAT_PRIOR(const location_type & l)9107 make_FLAT_PRIOR (const location_type& l) 9108 { 9109 return symbol_type (token::FLAT_PRIOR, l); 9110 } 9111 #endif 9112 #if 201103L <= YY_CPLUSPLUS 9113 static 9114 symbol_type make_NCSK(location_type l)9115 make_NCSK (location_type l) 9116 { 9117 return symbol_type (token::NCSK, std::move (l)); 9118 } 9119 #else 9120 static 9121 symbol_type make_NCSK(const location_type & l)9122 make_NCSK (const location_type& l) 9123 { 9124 return symbol_type (token::NCSK, l); 9125 } 9126 #endif 9127 #if 201103L <= YY_CPLUSPLUS 9128 static 9129 symbol_type make_NSTD(location_type l)9130 make_NSTD (location_type l) 9131 { 9132 return symbol_type (token::NSTD, std::move (l)); 9133 } 9134 #else 9135 static 9136 symbol_type make_NSTD(const location_type & l)9137 make_NSTD (const location_type& l) 9138 { 9139 return symbol_type (token::NSTD, l); 9140 } 9141 #endif 9142 #if 201103L <= YY_CPLUSPLUS 9143 static 9144 symbol_type make_WEIBULL(location_type l)9145 make_WEIBULL (location_type l) 9146 { 9147 return symbol_type (token::WEIBULL, std::move (l)); 9148 } 9149 #else 9150 static 9151 symbol_type make_WEIBULL(const location_type & l)9152 make_WEIBULL (const location_type& l) 9153 { 9154 return symbol_type (token::WEIBULL, l); 9155 } 9156 #endif 9157 #if 201103L <= YY_CPLUSPLUS 9158 static 9159 symbol_type make_WEIBULL_PDF(location_type l)9160 make_WEIBULL_PDF (location_type l) 9161 { 9162 return symbol_type (token::WEIBULL_PDF, std::move (l)); 9163 } 9164 #else 9165 static 9166 symbol_type make_WEIBULL_PDF(const location_type & l)9167 make_WEIBULL_PDF (const location_type& l) 9168 { 9169 return symbol_type (token::WEIBULL_PDF, l); 9170 } 9171 #endif 9172 #if 201103L <= YY_CPLUSPLUS 9173 static 9174 symbol_type make_INDXPARR(location_type l)9175 make_INDXPARR (location_type l) 9176 { 9177 return symbol_type (token::INDXPARR, std::move (l)); 9178 } 9179 #else 9180 static 9181 symbol_type make_INDXPARR(const location_type & l)9182 make_INDXPARR (const location_type& l) 9183 { 9184 return symbol_type (token::INDXPARR, l); 9185 } 9186 #endif 9187 #if 201103L <= YY_CPLUSPLUS 9188 static 9189 symbol_type make_INDXOVR(location_type l)9190 make_INDXOVR (location_type l) 9191 { 9192 return symbol_type (token::INDXOVR, std::move (l)); 9193 } 9194 #else 9195 static 9196 symbol_type make_INDXOVR(const location_type & l)9197 make_INDXOVR (const location_type& l) 9198 { 9199 return symbol_type (token::INDXOVR, l); 9200 } 9201 #endif 9202 #if 201103L <= YY_CPLUSPLUS 9203 static 9204 symbol_type make_INDXAP(location_type l)9205 make_INDXAP (location_type l) 9206 { 9207 return symbol_type (token::INDXAP, std::move (l)); 9208 } 9209 #else 9210 static 9211 symbol_type make_INDXAP(const location_type & l)9212 make_INDXAP (const location_type& l) 9213 { 9214 return symbol_type (token::INDXAP, l); 9215 } 9216 #endif 9217 #if 201103L <= YY_CPLUSPLUS 9218 static 9219 symbol_type make_APBAND(location_type l)9220 make_APBAND (location_type l) 9221 { 9222 return symbol_type (token::APBAND, std::move (l)); 9223 } 9224 #else 9225 static 9226 symbol_type make_APBAND(const location_type & l)9227 make_APBAND (const location_type& l) 9228 { 9229 return symbol_type (token::APBAND, l); 9230 } 9231 #endif 9232 #if 201103L <= YY_CPLUSPLUS 9233 static 9234 symbol_type make_INDXIMF(location_type l)9235 make_INDXIMF (location_type l) 9236 { 9237 return symbol_type (token::INDXIMF, std::move (l)); 9238 } 9239 #else 9240 static 9241 symbol_type make_INDXIMF(const location_type & l)9242 make_INDXIMF (const location_type& l) 9243 { 9244 return symbol_type (token::INDXIMF, l); 9245 } 9246 #endif 9247 #if 201103L <= YY_CPLUSPLUS 9248 static 9249 symbol_type make_INDXFORE(location_type l)9250 make_INDXFORE (location_type l) 9251 { 9252 return symbol_type (token::INDXFORE, std::move (l)); 9253 } 9254 #else 9255 static 9256 symbol_type make_INDXFORE(const location_type & l)9257 make_INDXFORE (const location_type& l) 9258 { 9259 return symbol_type (token::INDXFORE, l); 9260 } 9261 #endif 9262 #if 201103L <= YY_CPLUSPLUS 9263 static 9264 symbol_type make_FOREBAND(location_type l)9265 make_FOREBAND (location_type l) 9266 { 9267 return symbol_type (token::FOREBAND, std::move (l)); 9268 } 9269 #else 9270 static 9271 symbol_type make_FOREBAND(const location_type & l)9272 make_FOREBAND (const location_type& l) 9273 { 9274 return symbol_type (token::FOREBAND, l); 9275 } 9276 #endif 9277 #if 201103L <= YY_CPLUSPLUS 9278 static 9279 symbol_type make_INDXGFOREHAT(location_type l)9280 make_INDXGFOREHAT (location_type l) 9281 { 9282 return symbol_type (token::INDXGFOREHAT, std::move (l)); 9283 } 9284 #else 9285 static 9286 symbol_type make_INDXGFOREHAT(const location_type & l)9287 make_INDXGFOREHAT (const location_type& l) 9288 { 9289 return symbol_type (token::INDXGFOREHAT, l); 9290 } 9291 #endif 9292 #if 201103L <= YY_CPLUSPLUS 9293 static 9294 symbol_type make_INDXGIMFHAT(location_type l)9295 make_INDXGIMFHAT (location_type l) 9296 { 9297 return symbol_type (token::INDXGIMFHAT, std::move (l)); 9298 } 9299 #else 9300 static 9301 symbol_type make_INDXGIMFHAT(const location_type & l)9302 make_INDXGIMFHAT (const location_type& l) 9303 { 9304 return symbol_type (token::INDXGIMFHAT, l); 9305 } 9306 #endif 9307 #if 201103L <= YY_CPLUSPLUS 9308 static 9309 symbol_type make_INDXESTIMA(location_type l)9310 make_INDXESTIMA (location_type l) 9311 { 9312 return symbol_type (token::INDXESTIMA, std::move (l)); 9313 } 9314 #else 9315 static 9316 symbol_type make_INDXESTIMA(const location_type & l)9317 make_INDXESTIMA (const location_type& l) 9318 { 9319 return symbol_type (token::INDXESTIMA, l); 9320 } 9321 #endif 9322 #if 201103L <= YY_CPLUSPLUS 9323 static 9324 symbol_type make_INDXGDLS(location_type l)9325 make_INDXGDLS (location_type l) 9326 { 9327 return symbol_type (token::INDXGDLS, std::move (l)); 9328 } 9329 #else 9330 static 9331 symbol_type make_INDXGDLS(const location_type & l)9332 make_INDXGDLS (const location_type& l) 9333 { 9334 return symbol_type (token::INDXGDLS, l); 9335 } 9336 #endif 9337 #if 201103L <= YY_CPLUSPLUS 9338 static 9339 symbol_type make_EQ_MS(location_type l)9340 make_EQ_MS (location_type l) 9341 { 9342 return symbol_type (token::EQ_MS, std::move (l)); 9343 } 9344 #else 9345 static 9346 symbol_type make_EQ_MS(const location_type & l)9347 make_EQ_MS (const location_type& l) 9348 { 9349 return symbol_type (token::EQ_MS, l); 9350 } 9351 #endif 9352 #if 201103L <= YY_CPLUSPLUS 9353 static 9354 symbol_type make_FILTER_COVARIANCE(location_type l)9355 make_FILTER_COVARIANCE (location_type l) 9356 { 9357 return symbol_type (token::FILTER_COVARIANCE, std::move (l)); 9358 } 9359 #else 9360 static 9361 symbol_type make_FILTER_COVARIANCE(const location_type & l)9362 make_FILTER_COVARIANCE (const location_type& l) 9363 { 9364 return symbol_type (token::FILTER_COVARIANCE, l); 9365 } 9366 #endif 9367 #if 201103L <= YY_CPLUSPLUS 9368 static 9369 symbol_type make_FILTER_DECOMPOSITION(location_type l)9370 make_FILTER_DECOMPOSITION (location_type l) 9371 { 9372 return symbol_type (token::FILTER_DECOMPOSITION, std::move (l)); 9373 } 9374 #else 9375 static 9376 symbol_type make_FILTER_DECOMPOSITION(const location_type & l)9377 make_FILTER_DECOMPOSITION (const location_type& l) 9378 { 9379 return symbol_type (token::FILTER_DECOMPOSITION, l); 9380 } 9381 #endif 9382 #if 201103L <= YY_CPLUSPLUS 9383 static 9384 symbol_type make_SMOOTHED_STATE_UNCERTAINTY(location_type l)9385 make_SMOOTHED_STATE_UNCERTAINTY (location_type l) 9386 { 9387 return symbol_type (token::SMOOTHED_STATE_UNCERTAINTY, std::move (l)); 9388 } 9389 #else 9390 static 9391 symbol_type make_SMOOTHED_STATE_UNCERTAINTY(const location_type & l)9392 make_SMOOTHED_STATE_UNCERTAINTY (const location_type& l) 9393 { 9394 return symbol_type (token::SMOOTHED_STATE_UNCERTAINTY, l); 9395 } 9396 #endif 9397 #if 201103L <= YY_CPLUSPLUS 9398 static 9399 symbol_type make_EQ_CMS(location_type l)9400 make_EQ_CMS (location_type l) 9401 { 9402 return symbol_type (token::EQ_CMS, std::move (l)); 9403 } 9404 #else 9405 static 9406 symbol_type make_EQ_CMS(const location_type & l)9407 make_EQ_CMS (const location_type& l) 9408 { 9409 return symbol_type (token::EQ_CMS, l); 9410 } 9411 #endif 9412 #if 201103L <= YY_CPLUSPLUS 9413 static 9414 symbol_type make_TLINDX(location_type l)9415 make_TLINDX (location_type l) 9416 { 9417 return symbol_type (token::TLINDX, std::move (l)); 9418 } 9419 #else 9420 static 9421 symbol_type make_TLINDX(const location_type & l)9422 make_TLINDX (const location_type& l) 9423 { 9424 return symbol_type (token::TLINDX, l); 9425 } 9426 #endif 9427 #if 201103L <= YY_CPLUSPLUS 9428 static 9429 symbol_type make_TLNUMBER(location_type l)9430 make_TLNUMBER (location_type l) 9431 { 9432 return symbol_type (token::TLNUMBER, std::move (l)); 9433 } 9434 #else 9435 static 9436 symbol_type make_TLNUMBER(const location_type & l)9437 make_TLNUMBER (const location_type& l) 9438 { 9439 return symbol_type (token::TLNUMBER, l); 9440 } 9441 #endif 9442 #if 201103L <= YY_CPLUSPLUS 9443 static 9444 symbol_type make_RESTRICTIONS(location_type l)9445 make_RESTRICTIONS (location_type l) 9446 { 9447 return symbol_type (token::RESTRICTIONS, std::move (l)); 9448 } 9449 #else 9450 static 9451 symbol_type make_RESTRICTIONS(const location_type & l)9452 make_RESTRICTIONS (const location_type& l) 9453 { 9454 return symbol_type (token::RESTRICTIONS, l); 9455 } 9456 #endif 9457 #if 201103L <= YY_CPLUSPLUS 9458 static 9459 symbol_type make_POSTERIOR_SAMPLER_OPTIONS(location_type l)9460 make_POSTERIOR_SAMPLER_OPTIONS (location_type l) 9461 { 9462 return symbol_type (token::POSTERIOR_SAMPLER_OPTIONS, std::move (l)); 9463 } 9464 #else 9465 static 9466 symbol_type make_POSTERIOR_SAMPLER_OPTIONS(const location_type & l)9467 make_POSTERIOR_SAMPLER_OPTIONS (const location_type& l) 9468 { 9469 return symbol_type (token::POSTERIOR_SAMPLER_OPTIONS, l); 9470 } 9471 #endif 9472 #if 201103L <= YY_CPLUSPLUS 9473 static 9474 symbol_type make_OUTPUT_FILE_TAG(location_type l)9475 make_OUTPUT_FILE_TAG (location_type l) 9476 { 9477 return symbol_type (token::OUTPUT_FILE_TAG, std::move (l)); 9478 } 9479 #else 9480 static 9481 symbol_type make_OUTPUT_FILE_TAG(const location_type & l)9482 make_OUTPUT_FILE_TAG (const location_type& l) 9483 { 9484 return symbol_type (token::OUTPUT_FILE_TAG, l); 9485 } 9486 #endif 9487 #if 201103L <= YY_CPLUSPLUS 9488 static 9489 symbol_type make_HORIZON(location_type l)9490 make_HORIZON (location_type l) 9491 { 9492 return symbol_type (token::HORIZON, std::move (l)); 9493 } 9494 #else 9495 static 9496 symbol_type make_HORIZON(const location_type & l)9497 make_HORIZON (const location_type& l) 9498 { 9499 return symbol_type (token::HORIZON, l); 9500 } 9501 #endif 9502 #if 201103L <= YY_CPLUSPLUS 9503 static 9504 symbol_type make_SBVAR(location_type l)9505 make_SBVAR (location_type l) 9506 { 9507 return symbol_type (token::SBVAR, std::move (l)); 9508 } 9509 #else 9510 static 9511 symbol_type make_SBVAR(const location_type & l)9512 make_SBVAR (const location_type& l) 9513 { 9514 return symbol_type (token::SBVAR, l); 9515 } 9516 #endif 9517 #if 201103L <= YY_CPLUSPLUS 9518 static 9519 symbol_type make_TREND_VAR(location_type l)9520 make_TREND_VAR (location_type l) 9521 { 9522 return symbol_type (token::TREND_VAR, std::move (l)); 9523 } 9524 #else 9525 static 9526 symbol_type make_TREND_VAR(const location_type & l)9527 make_TREND_VAR (const location_type& l) 9528 { 9529 return symbol_type (token::TREND_VAR, l); 9530 } 9531 #endif 9532 #if 201103L <= YY_CPLUSPLUS 9533 static 9534 symbol_type make_DEFLATOR(location_type l)9535 make_DEFLATOR (location_type l) 9536 { 9537 return symbol_type (token::DEFLATOR, std::move (l)); 9538 } 9539 #else 9540 static 9541 symbol_type make_DEFLATOR(const location_type & l)9542 make_DEFLATOR (const location_type& l) 9543 { 9544 return symbol_type (token::DEFLATOR, l); 9545 } 9546 #endif 9547 #if 201103L <= YY_CPLUSPLUS 9548 static 9549 symbol_type make_GROWTH_FACTOR(location_type l)9550 make_GROWTH_FACTOR (location_type l) 9551 { 9552 return symbol_type (token::GROWTH_FACTOR, std::move (l)); 9553 } 9554 #else 9555 static 9556 symbol_type make_GROWTH_FACTOR(const location_type & l)9557 make_GROWTH_FACTOR (const location_type& l) 9558 { 9559 return symbol_type (token::GROWTH_FACTOR, l); 9560 } 9561 #endif 9562 #if 201103L <= YY_CPLUSPLUS 9563 static 9564 symbol_type make_MS_IRF(location_type l)9565 make_MS_IRF (location_type l) 9566 { 9567 return symbol_type (token::MS_IRF, std::move (l)); 9568 } 9569 #else 9570 static 9571 symbol_type make_MS_IRF(const location_type & l)9572 make_MS_IRF (const location_type& l) 9573 { 9574 return symbol_type (token::MS_IRF, l); 9575 } 9576 #endif 9577 #if 201103L <= YY_CPLUSPLUS 9578 static 9579 symbol_type make_MS_VARIANCE_DECOMPOSITION(location_type l)9580 make_MS_VARIANCE_DECOMPOSITION (location_type l) 9581 { 9582 return symbol_type (token::MS_VARIANCE_DECOMPOSITION, std::move (l)); 9583 } 9584 #else 9585 static 9586 symbol_type make_MS_VARIANCE_DECOMPOSITION(const location_type & l)9587 make_MS_VARIANCE_DECOMPOSITION (const location_type& l) 9588 { 9589 return symbol_type (token::MS_VARIANCE_DECOMPOSITION, l); 9590 } 9591 #endif 9592 #if 201103L <= YY_CPLUSPLUS 9593 static 9594 symbol_type make_GROWTH(location_type l)9595 make_GROWTH (location_type l) 9596 { 9597 return symbol_type (token::GROWTH, std::move (l)); 9598 } 9599 #else 9600 static 9601 symbol_type make_GROWTH(const location_type & l)9602 make_GROWTH (const location_type& l) 9603 { 9604 return symbol_type (token::GROWTH, l); 9605 } 9606 #endif 9607 #if 201103L <= YY_CPLUSPLUS 9608 static 9609 symbol_type make_MS_ESTIMATION(location_type l)9610 make_MS_ESTIMATION (location_type l) 9611 { 9612 return symbol_type (token::MS_ESTIMATION, std::move (l)); 9613 } 9614 #else 9615 static 9616 symbol_type make_MS_ESTIMATION(const location_type & l)9617 make_MS_ESTIMATION (const location_type& l) 9618 { 9619 return symbol_type (token::MS_ESTIMATION, l); 9620 } 9621 #endif 9622 #if 201103L <= YY_CPLUSPLUS 9623 static 9624 symbol_type make_MS_SIMULATION(location_type l)9625 make_MS_SIMULATION (location_type l) 9626 { 9627 return symbol_type (token::MS_SIMULATION, std::move (l)); 9628 } 9629 #else 9630 static 9631 symbol_type make_MS_SIMULATION(const location_type & l)9632 make_MS_SIMULATION (const location_type& l) 9633 { 9634 return symbol_type (token::MS_SIMULATION, l); 9635 } 9636 #endif 9637 #if 201103L <= YY_CPLUSPLUS 9638 static 9639 symbol_type make_MS_COMPUTE_MDD(location_type l)9640 make_MS_COMPUTE_MDD (location_type l) 9641 { 9642 return symbol_type (token::MS_COMPUTE_MDD, std::move (l)); 9643 } 9644 #else 9645 static 9646 symbol_type make_MS_COMPUTE_MDD(const location_type & l)9647 make_MS_COMPUTE_MDD (const location_type& l) 9648 { 9649 return symbol_type (token::MS_COMPUTE_MDD, l); 9650 } 9651 #endif 9652 #if 201103L <= YY_CPLUSPLUS 9653 static 9654 symbol_type make_MS_COMPUTE_PROBABILITIES(location_type l)9655 make_MS_COMPUTE_PROBABILITIES (location_type l) 9656 { 9657 return symbol_type (token::MS_COMPUTE_PROBABILITIES, std::move (l)); 9658 } 9659 #else 9660 static 9661 symbol_type make_MS_COMPUTE_PROBABILITIES(const location_type & l)9662 make_MS_COMPUTE_PROBABILITIES (const location_type& l) 9663 { 9664 return symbol_type (token::MS_COMPUTE_PROBABILITIES, l); 9665 } 9666 #endif 9667 #if 201103L <= YY_CPLUSPLUS 9668 static 9669 symbol_type make_MS_FORECAST(location_type l)9670 make_MS_FORECAST (location_type l) 9671 { 9672 return symbol_type (token::MS_FORECAST, std::move (l)); 9673 } 9674 #else 9675 static 9676 symbol_type make_MS_FORECAST(const location_type & l)9677 make_MS_FORECAST (const location_type& l) 9678 { 9679 return symbol_type (token::MS_FORECAST, l); 9680 } 9681 #endif 9682 #if 201103L <= YY_CPLUSPLUS 9683 static 9684 symbol_type make_SVAR_IDENTIFICATION(location_type l)9685 make_SVAR_IDENTIFICATION (location_type l) 9686 { 9687 return symbol_type (token::SVAR_IDENTIFICATION, std::move (l)); 9688 } 9689 #else 9690 static 9691 symbol_type make_SVAR_IDENTIFICATION(const location_type & l)9692 make_SVAR_IDENTIFICATION (const location_type& l) 9693 { 9694 return symbol_type (token::SVAR_IDENTIFICATION, l); 9695 } 9696 #endif 9697 #if 201103L <= YY_CPLUSPLUS 9698 static 9699 symbol_type make_EQUATION(location_type l)9700 make_EQUATION (location_type l) 9701 { 9702 return symbol_type (token::EQUATION, std::move (l)); 9703 } 9704 #else 9705 static 9706 symbol_type make_EQUATION(const location_type & l)9707 make_EQUATION (const location_type& l) 9708 { 9709 return symbol_type (token::EQUATION, l); 9710 } 9711 #endif 9712 #if 201103L <= YY_CPLUSPLUS 9713 static 9714 symbol_type make_EXCLUSION(location_type l)9715 make_EXCLUSION (location_type l) 9716 { 9717 return symbol_type (token::EXCLUSION, std::move (l)); 9718 } 9719 #else 9720 static 9721 symbol_type make_EXCLUSION(const location_type & l)9722 make_EXCLUSION (const location_type& l) 9723 { 9724 return symbol_type (token::EXCLUSION, l); 9725 } 9726 #endif 9727 #if 201103L <= YY_CPLUSPLUS 9728 static 9729 symbol_type make_LAG(location_type l)9730 make_LAG (location_type l) 9731 { 9732 return symbol_type (token::LAG, std::move (l)); 9733 } 9734 #else 9735 static 9736 symbol_type make_LAG(const location_type & l)9737 make_LAG (const location_type& l) 9738 { 9739 return symbol_type (token::LAG, l); 9740 } 9741 #endif 9742 #if 201103L <= YY_CPLUSPLUS 9743 static 9744 symbol_type make_UPPER_CHOLESKY(location_type l)9745 make_UPPER_CHOLESKY (location_type l) 9746 { 9747 return symbol_type (token::UPPER_CHOLESKY, std::move (l)); 9748 } 9749 #else 9750 static 9751 symbol_type make_UPPER_CHOLESKY(const location_type & l)9752 make_UPPER_CHOLESKY (const location_type& l) 9753 { 9754 return symbol_type (token::UPPER_CHOLESKY, l); 9755 } 9756 #endif 9757 #if 201103L <= YY_CPLUSPLUS 9758 static 9759 symbol_type make_LOWER_CHOLESKY(location_type l)9760 make_LOWER_CHOLESKY (location_type l) 9761 { 9762 return symbol_type (token::LOWER_CHOLESKY, std::move (l)); 9763 } 9764 #else 9765 static 9766 symbol_type make_LOWER_CHOLESKY(const location_type & l)9767 make_LOWER_CHOLESKY (const location_type& l) 9768 { 9769 return symbol_type (token::LOWER_CHOLESKY, l); 9770 } 9771 #endif 9772 #if 201103L <= YY_CPLUSPLUS 9773 static 9774 symbol_type make_MONTHLY(location_type l)9775 make_MONTHLY (location_type l) 9776 { 9777 return symbol_type (token::MONTHLY, std::move (l)); 9778 } 9779 #else 9780 static 9781 symbol_type make_MONTHLY(const location_type & l)9782 make_MONTHLY (const location_type& l) 9783 { 9784 return symbol_type (token::MONTHLY, l); 9785 } 9786 #endif 9787 #if 201103L <= YY_CPLUSPLUS 9788 static 9789 symbol_type make_QUARTERLY(location_type l)9790 make_QUARTERLY (location_type l) 9791 { 9792 return symbol_type (token::QUARTERLY, std::move (l)); 9793 } 9794 #else 9795 static 9796 symbol_type make_QUARTERLY(const location_type & l)9797 make_QUARTERLY (const location_type& l) 9798 { 9799 return symbol_type (token::QUARTERLY, l); 9800 } 9801 #endif 9802 #if 201103L <= YY_CPLUSPLUS 9803 static 9804 symbol_type make_MARKOV_SWITCHING(location_type l)9805 make_MARKOV_SWITCHING (location_type l) 9806 { 9807 return symbol_type (token::MARKOV_SWITCHING, std::move (l)); 9808 } 9809 #else 9810 static 9811 symbol_type make_MARKOV_SWITCHING(const location_type & l)9812 make_MARKOV_SWITCHING (const location_type& l) 9813 { 9814 return symbol_type (token::MARKOV_SWITCHING, l); 9815 } 9816 #endif 9817 #if 201103L <= YY_CPLUSPLUS 9818 static 9819 symbol_type make_CHAIN(location_type l)9820 make_CHAIN (location_type l) 9821 { 9822 return symbol_type (token::CHAIN, std::move (l)); 9823 } 9824 #else 9825 static 9826 symbol_type make_CHAIN(const location_type & l)9827 make_CHAIN (const location_type& l) 9828 { 9829 return symbol_type (token::CHAIN, l); 9830 } 9831 #endif 9832 #if 201103L <= YY_CPLUSPLUS 9833 static 9834 symbol_type make_DURATION(location_type l)9835 make_DURATION (location_type l) 9836 { 9837 return symbol_type (token::DURATION, std::move (l)); 9838 } 9839 #else 9840 static 9841 symbol_type make_DURATION(const location_type & l)9842 make_DURATION (const location_type& l) 9843 { 9844 return symbol_type (token::DURATION, l); 9845 } 9846 #endif 9847 #if 201103L <= YY_CPLUSPLUS 9848 static 9849 symbol_type make_NUMBER_OF_REGIMES(location_type l)9850 make_NUMBER_OF_REGIMES (location_type l) 9851 { 9852 return symbol_type (token::NUMBER_OF_REGIMES, std::move (l)); 9853 } 9854 #else 9855 static 9856 symbol_type make_NUMBER_OF_REGIMES(const location_type & l)9857 make_NUMBER_OF_REGIMES (const location_type& l) 9858 { 9859 return symbol_type (token::NUMBER_OF_REGIMES, l); 9860 } 9861 #endif 9862 #if 201103L <= YY_CPLUSPLUS 9863 static 9864 symbol_type make_NUMBER_OF_LAGS(location_type l)9865 make_NUMBER_OF_LAGS (location_type l) 9866 { 9867 return symbol_type (token::NUMBER_OF_LAGS, std::move (l)); 9868 } 9869 #else 9870 static 9871 symbol_type make_NUMBER_OF_LAGS(const location_type & l)9872 make_NUMBER_OF_LAGS (const location_type& l) 9873 { 9874 return symbol_type (token::NUMBER_OF_LAGS, l); 9875 } 9876 #endif 9877 #if 201103L <= YY_CPLUSPLUS 9878 static 9879 symbol_type make_EPILOGUE(location_type l)9880 make_EPILOGUE (location_type l) 9881 { 9882 return symbol_type (token::EPILOGUE, std::move (l)); 9883 } 9884 #else 9885 static 9886 symbol_type make_EPILOGUE(const location_type & l)9887 make_EPILOGUE (const location_type& l) 9888 { 9889 return symbol_type (token::EPILOGUE, l); 9890 } 9891 #endif 9892 #if 201103L <= YY_CPLUSPLUS 9893 static 9894 symbol_type make_SVAR(location_type l)9895 make_SVAR (location_type l) 9896 { 9897 return symbol_type (token::SVAR, std::move (l)); 9898 } 9899 #else 9900 static 9901 symbol_type make_SVAR(const location_type & l)9902 make_SVAR (const location_type& l) 9903 { 9904 return symbol_type (token::SVAR, l); 9905 } 9906 #endif 9907 #if 201103L <= YY_CPLUSPLUS 9908 static 9909 symbol_type make_SVAR_GLOBAL_IDENTIFICATION_CHECK(location_type l)9910 make_SVAR_GLOBAL_IDENTIFICATION_CHECK (location_type l) 9911 { 9912 return symbol_type (token::SVAR_GLOBAL_IDENTIFICATION_CHECK, std::move (l)); 9913 } 9914 #else 9915 static 9916 symbol_type make_SVAR_GLOBAL_IDENTIFICATION_CHECK(const location_type & l)9917 make_SVAR_GLOBAL_IDENTIFICATION_CHECK (const location_type& l) 9918 { 9919 return symbol_type (token::SVAR_GLOBAL_IDENTIFICATION_CHECK, l); 9920 } 9921 #endif 9922 #if 201103L <= YY_CPLUSPLUS 9923 static 9924 symbol_type make_COEFF(location_type l)9925 make_COEFF (location_type l) 9926 { 9927 return symbol_type (token::COEFF, std::move (l)); 9928 } 9929 #else 9930 static 9931 symbol_type make_COEFF(const location_type & l)9932 make_COEFF (const location_type& l) 9933 { 9934 return symbol_type (token::COEFF, l); 9935 } 9936 #endif 9937 #if 201103L <= YY_CPLUSPLUS 9938 static 9939 symbol_type make_COEFFICIENTS(location_type l)9940 make_COEFFICIENTS (location_type l) 9941 { 9942 return symbol_type (token::COEFFICIENTS, std::move (l)); 9943 } 9944 #else 9945 static 9946 symbol_type make_COEFFICIENTS(const location_type & l)9947 make_COEFFICIENTS (const location_type& l) 9948 { 9949 return symbol_type (token::COEFFICIENTS, l); 9950 } 9951 #endif 9952 #if 201103L <= YY_CPLUSPLUS 9953 static 9954 symbol_type make_VARIANCES(location_type l)9955 make_VARIANCES (location_type l) 9956 { 9957 return symbol_type (token::VARIANCES, std::move (l)); 9958 } 9959 #else 9960 static 9961 symbol_type make_VARIANCES(const location_type & l)9962 make_VARIANCES (const location_type& l) 9963 { 9964 return symbol_type (token::VARIANCES, l); 9965 } 9966 #endif 9967 #if 201103L <= YY_CPLUSPLUS 9968 static 9969 symbol_type make_CONSTANTS(location_type l)9970 make_CONSTANTS (location_type l) 9971 { 9972 return symbol_type (token::CONSTANTS, std::move (l)); 9973 } 9974 #else 9975 static 9976 symbol_type make_CONSTANTS(const location_type & l)9977 make_CONSTANTS (const location_type& l) 9978 { 9979 return symbol_type (token::CONSTANTS, l); 9980 } 9981 #endif 9982 #if 201103L <= YY_CPLUSPLUS 9983 static 9984 symbol_type make_EQUATIONS(location_type l)9985 make_EQUATIONS (location_type l) 9986 { 9987 return symbol_type (token::EQUATIONS, std::move (l)); 9988 } 9989 #else 9990 static 9991 symbol_type make_EQUATIONS(const location_type & l)9992 make_EQUATIONS (const location_type& l) 9993 { 9994 return symbol_type (token::EQUATIONS, l); 9995 } 9996 #endif 9997 #if 201103L <= YY_CPLUSPLUS 9998 static 9999 symbol_type make_EXTERNAL_FUNCTION(location_type l)10000 make_EXTERNAL_FUNCTION (location_type l) 10001 { 10002 return symbol_type (token::EXTERNAL_FUNCTION, std::move (l)); 10003 } 10004 #else 10005 static 10006 symbol_type make_EXTERNAL_FUNCTION(const location_type & l)10007 make_EXTERNAL_FUNCTION (const location_type& l) 10008 { 10009 return symbol_type (token::EXTERNAL_FUNCTION, l); 10010 } 10011 #endif 10012 #if 201103L <= YY_CPLUSPLUS 10013 static 10014 symbol_type make_EXT_FUNC_NAME(location_type l)10015 make_EXT_FUNC_NAME (location_type l) 10016 { 10017 return symbol_type (token::EXT_FUNC_NAME, std::move (l)); 10018 } 10019 #else 10020 static 10021 symbol_type make_EXT_FUNC_NAME(const location_type & l)10022 make_EXT_FUNC_NAME (const location_type& l) 10023 { 10024 return symbol_type (token::EXT_FUNC_NAME, l); 10025 } 10026 #endif 10027 #if 201103L <= YY_CPLUSPLUS 10028 static 10029 symbol_type make_EXT_FUNC_NARGS(location_type l)10030 make_EXT_FUNC_NARGS (location_type l) 10031 { 10032 return symbol_type (token::EXT_FUNC_NARGS, std::move (l)); 10033 } 10034 #else 10035 static 10036 symbol_type make_EXT_FUNC_NARGS(const location_type & l)10037 make_EXT_FUNC_NARGS (const location_type& l) 10038 { 10039 return symbol_type (token::EXT_FUNC_NARGS, l); 10040 } 10041 #endif 10042 #if 201103L <= YY_CPLUSPLUS 10043 static 10044 symbol_type make_FIRST_DERIV_PROVIDED(location_type l)10045 make_FIRST_DERIV_PROVIDED (location_type l) 10046 { 10047 return symbol_type (token::FIRST_DERIV_PROVIDED, std::move (l)); 10048 } 10049 #else 10050 static 10051 symbol_type make_FIRST_DERIV_PROVIDED(const location_type & l)10052 make_FIRST_DERIV_PROVIDED (const location_type& l) 10053 { 10054 return symbol_type (token::FIRST_DERIV_PROVIDED, l); 10055 } 10056 #endif 10057 #if 201103L <= YY_CPLUSPLUS 10058 static 10059 symbol_type make_SECOND_DERIV_PROVIDED(location_type l)10060 make_SECOND_DERIV_PROVIDED (location_type l) 10061 { 10062 return symbol_type (token::SECOND_DERIV_PROVIDED, std::move (l)); 10063 } 10064 #else 10065 static 10066 symbol_type make_SECOND_DERIV_PROVIDED(const location_type & l)10067 make_SECOND_DERIV_PROVIDED (const location_type& l) 10068 { 10069 return symbol_type (token::SECOND_DERIV_PROVIDED, l); 10070 } 10071 #endif 10072 #if 201103L <= YY_CPLUSPLUS 10073 static 10074 symbol_type make_SELECTED_VARIABLES_ONLY(location_type l)10075 make_SELECTED_VARIABLES_ONLY (location_type l) 10076 { 10077 return symbol_type (token::SELECTED_VARIABLES_ONLY, std::move (l)); 10078 } 10079 #else 10080 static 10081 symbol_type make_SELECTED_VARIABLES_ONLY(const location_type & l)10082 make_SELECTED_VARIABLES_ONLY (const location_type& l) 10083 { 10084 return symbol_type (token::SELECTED_VARIABLES_ONLY, l); 10085 } 10086 #endif 10087 #if 201103L <= YY_CPLUSPLUS 10088 static 10089 symbol_type make_COVA_COMPUTE(location_type l)10090 make_COVA_COMPUTE (location_type l) 10091 { 10092 return symbol_type (token::COVA_COMPUTE, std::move (l)); 10093 } 10094 #else 10095 static 10096 symbol_type make_COVA_COMPUTE(const location_type & l)10097 make_COVA_COMPUTE (const location_type& l) 10098 { 10099 return symbol_type (token::COVA_COMPUTE, l); 10100 } 10101 #endif 10102 #if 201103L <= YY_CPLUSPLUS 10103 static 10104 symbol_type make_SIMULATION_FILE_TAG(location_type l)10105 make_SIMULATION_FILE_TAG (location_type l) 10106 { 10107 return symbol_type (token::SIMULATION_FILE_TAG, std::move (l)); 10108 } 10109 #else 10110 static 10111 symbol_type make_SIMULATION_FILE_TAG(const location_type & l)10112 make_SIMULATION_FILE_TAG (const location_type& l) 10113 { 10114 return symbol_type (token::SIMULATION_FILE_TAG, l); 10115 } 10116 #endif 10117 #if 201103L <= YY_CPLUSPLUS 10118 static 10119 symbol_type make_FILE_TAG(location_type l)10120 make_FILE_TAG (location_type l) 10121 { 10122 return symbol_type (token::FILE_TAG, std::move (l)); 10123 } 10124 #else 10125 static 10126 symbol_type make_FILE_TAG(const location_type & l)10127 make_FILE_TAG (const location_type& l) 10128 { 10129 return symbol_type (token::FILE_TAG, l); 10130 } 10131 #endif 10132 #if 201103L <= YY_CPLUSPLUS 10133 static 10134 symbol_type make_NO_ERROR_BANDS(location_type l)10135 make_NO_ERROR_BANDS (location_type l) 10136 { 10137 return symbol_type (token::NO_ERROR_BANDS, std::move (l)); 10138 } 10139 #else 10140 static 10141 symbol_type make_NO_ERROR_BANDS(const location_type & l)10142 make_NO_ERROR_BANDS (const location_type& l) 10143 { 10144 return symbol_type (token::NO_ERROR_BANDS, l); 10145 } 10146 #endif 10147 #if 201103L <= YY_CPLUSPLUS 10148 static 10149 symbol_type make_ERROR_BAND_PERCENTILES(location_type l)10150 make_ERROR_BAND_PERCENTILES (location_type l) 10151 { 10152 return symbol_type (token::ERROR_BAND_PERCENTILES, std::move (l)); 10153 } 10154 #else 10155 static 10156 symbol_type make_ERROR_BAND_PERCENTILES(const location_type & l)10157 make_ERROR_BAND_PERCENTILES (const location_type& l) 10158 { 10159 return symbol_type (token::ERROR_BAND_PERCENTILES, l); 10160 } 10161 #endif 10162 #if 201103L <= YY_CPLUSPLUS 10163 static 10164 symbol_type make_SHOCKS_PER_PARAMETER(location_type l)10165 make_SHOCKS_PER_PARAMETER (location_type l) 10166 { 10167 return symbol_type (token::SHOCKS_PER_PARAMETER, std::move (l)); 10168 } 10169 #else 10170 static 10171 symbol_type make_SHOCKS_PER_PARAMETER(const location_type & l)10172 make_SHOCKS_PER_PARAMETER (const location_type& l) 10173 { 10174 return symbol_type (token::SHOCKS_PER_PARAMETER, l); 10175 } 10176 #endif 10177 #if 201103L <= YY_CPLUSPLUS 10178 static 10179 symbol_type make_NO_CREATE_INIT(location_type l)10180 make_NO_CREATE_INIT (location_type l) 10181 { 10182 return symbol_type (token::NO_CREATE_INIT, std::move (l)); 10183 } 10184 #else 10185 static 10186 symbol_type make_NO_CREATE_INIT(const location_type & l)10187 make_NO_CREATE_INIT (const location_type& l) 10188 { 10189 return symbol_type (token::NO_CREATE_INIT, l); 10190 } 10191 #endif 10192 #if 201103L <= YY_CPLUSPLUS 10193 static 10194 symbol_type make_SHOCK_DRAWS(location_type l)10195 make_SHOCK_DRAWS (location_type l) 10196 { 10197 return symbol_type (token::SHOCK_DRAWS, std::move (l)); 10198 } 10199 #else 10200 static 10201 symbol_type make_SHOCK_DRAWS(const location_type & l)10202 make_SHOCK_DRAWS (const location_type& l) 10203 { 10204 return symbol_type (token::SHOCK_DRAWS, l); 10205 } 10206 #endif 10207 #if 201103L <= YY_CPLUSPLUS 10208 static 10209 symbol_type make_FREE_PARAMETERS(location_type l)10210 make_FREE_PARAMETERS (location_type l) 10211 { 10212 return symbol_type (token::FREE_PARAMETERS, std::move (l)); 10213 } 10214 #else 10215 static 10216 symbol_type make_FREE_PARAMETERS(const location_type & l)10217 make_FREE_PARAMETERS (const location_type& l) 10218 { 10219 return symbol_type (token::FREE_PARAMETERS, l); 10220 } 10221 #endif 10222 #if 201103L <= YY_CPLUSPLUS 10223 static 10224 symbol_type make_MEDIAN(location_type l)10225 make_MEDIAN (location_type l) 10226 { 10227 return symbol_type (token::MEDIAN, std::move (l)); 10228 } 10229 #else 10230 static 10231 symbol_type make_MEDIAN(const location_type & l)10232 make_MEDIAN (const location_type& l) 10233 { 10234 return symbol_type (token::MEDIAN, l); 10235 } 10236 #endif 10237 #if 201103L <= YY_CPLUSPLUS 10238 static 10239 symbol_type make_DATA_OBS_NBR(location_type l)10240 make_DATA_OBS_NBR (location_type l) 10241 { 10242 return symbol_type (token::DATA_OBS_NBR, std::move (l)); 10243 } 10244 #else 10245 static 10246 symbol_type make_DATA_OBS_NBR(const location_type & l)10247 make_DATA_OBS_NBR (const location_type& l) 10248 { 10249 return symbol_type (token::DATA_OBS_NBR, l); 10250 } 10251 #endif 10252 #if 201103L <= YY_CPLUSPLUS 10253 static 10254 symbol_type make_NEIGHBORHOOD_WIDTH(location_type l)10255 make_NEIGHBORHOOD_WIDTH (location_type l) 10256 { 10257 return symbol_type (token::NEIGHBORHOOD_WIDTH, std::move (l)); 10258 } 10259 #else 10260 static 10261 symbol_type make_NEIGHBORHOOD_WIDTH(const location_type & l)10262 make_NEIGHBORHOOD_WIDTH (const location_type& l) 10263 { 10264 return symbol_type (token::NEIGHBORHOOD_WIDTH, l); 10265 } 10266 #endif 10267 #if 201103L <= YY_CPLUSPLUS 10268 static 10269 symbol_type make_PVALUE_KS(location_type l)10270 make_PVALUE_KS (location_type l) 10271 { 10272 return symbol_type (token::PVALUE_KS, std::move (l)); 10273 } 10274 #else 10275 static 10276 symbol_type make_PVALUE_KS(const location_type & l)10277 make_PVALUE_KS (const location_type& l) 10278 { 10279 return symbol_type (token::PVALUE_KS, l); 10280 } 10281 #endif 10282 #if 201103L <= YY_CPLUSPLUS 10283 static 10284 symbol_type make_PVALUE_CORR(location_type l)10285 make_PVALUE_CORR (location_type l) 10286 { 10287 return symbol_type (token::PVALUE_CORR, std::move (l)); 10288 } 10289 #else 10290 static 10291 symbol_type make_PVALUE_CORR(const location_type & l)10292 make_PVALUE_CORR (const location_type& l) 10293 { 10294 return symbol_type (token::PVALUE_CORR, l); 10295 } 10296 #endif 10297 #if 201103L <= YY_CPLUSPLUS 10298 static 10299 symbol_type make_FILTERED_PROBABILITIES(location_type l)10300 make_FILTERED_PROBABILITIES (location_type l) 10301 { 10302 return symbol_type (token::FILTERED_PROBABILITIES, std::move (l)); 10303 } 10304 #else 10305 static 10306 symbol_type make_FILTERED_PROBABILITIES(const location_type & l)10307 make_FILTERED_PROBABILITIES (const location_type& l) 10308 { 10309 return symbol_type (token::FILTERED_PROBABILITIES, l); 10310 } 10311 #endif 10312 #if 201103L <= YY_CPLUSPLUS 10313 static 10314 symbol_type make_REAL_TIME_SMOOTHED(location_type l)10315 make_REAL_TIME_SMOOTHED (location_type l) 10316 { 10317 return symbol_type (token::REAL_TIME_SMOOTHED, std::move (l)); 10318 } 10319 #else 10320 static 10321 symbol_type make_REAL_TIME_SMOOTHED(const location_type & l)10322 make_REAL_TIME_SMOOTHED (const location_type& l) 10323 { 10324 return symbol_type (token::REAL_TIME_SMOOTHED, l); 10325 } 10326 #endif 10327 #if 201103L <= YY_CPLUSPLUS 10328 static 10329 symbol_type make_PRIOR_FUNCTION(location_type l)10330 make_PRIOR_FUNCTION (location_type l) 10331 { 10332 return symbol_type (token::PRIOR_FUNCTION, std::move (l)); 10333 } 10334 #else 10335 static 10336 symbol_type make_PRIOR_FUNCTION(const location_type & l)10337 make_PRIOR_FUNCTION (const location_type& l) 10338 { 10339 return symbol_type (token::PRIOR_FUNCTION, l); 10340 } 10341 #endif 10342 #if 201103L <= YY_CPLUSPLUS 10343 static 10344 symbol_type make_POSTERIOR_FUNCTION(location_type l)10345 make_POSTERIOR_FUNCTION (location_type l) 10346 { 10347 return symbol_type (token::POSTERIOR_FUNCTION, std::move (l)); 10348 } 10349 #else 10350 static 10351 symbol_type make_POSTERIOR_FUNCTION(const location_type & l)10352 make_POSTERIOR_FUNCTION (const location_type& l) 10353 { 10354 return symbol_type (token::POSTERIOR_FUNCTION, l); 10355 } 10356 #endif 10357 #if 201103L <= YY_CPLUSPLUS 10358 static 10359 symbol_type make_SAMPLING_DRAWS(location_type l)10360 make_SAMPLING_DRAWS (location_type l) 10361 { 10362 return symbol_type (token::SAMPLING_DRAWS, std::move (l)); 10363 } 10364 #else 10365 static 10366 symbol_type make_SAMPLING_DRAWS(const location_type & l)10367 make_SAMPLING_DRAWS (const location_type& l) 10368 { 10369 return symbol_type (token::SAMPLING_DRAWS, l); 10370 } 10371 #endif 10372 #if 201103L <= YY_CPLUSPLUS 10373 static 10374 symbol_type make_PROPOSAL_TYPE(location_type l)10375 make_PROPOSAL_TYPE (location_type l) 10376 { 10377 return symbol_type (token::PROPOSAL_TYPE, std::move (l)); 10378 } 10379 #else 10380 static 10381 symbol_type make_PROPOSAL_TYPE(const location_type & l)10382 make_PROPOSAL_TYPE (const location_type& l) 10383 { 10384 return symbol_type (token::PROPOSAL_TYPE, l); 10385 } 10386 #endif 10387 #if 201103L <= YY_CPLUSPLUS 10388 static 10389 symbol_type make_PROPOSAL_UPPER_BOUND(location_type l)10390 make_PROPOSAL_UPPER_BOUND (location_type l) 10391 { 10392 return symbol_type (token::PROPOSAL_UPPER_BOUND, std::move (l)); 10393 } 10394 #else 10395 static 10396 symbol_type make_PROPOSAL_UPPER_BOUND(const location_type & l)10397 make_PROPOSAL_UPPER_BOUND (const location_type& l) 10398 { 10399 return symbol_type (token::PROPOSAL_UPPER_BOUND, l); 10400 } 10401 #endif 10402 #if 201103L <= YY_CPLUSPLUS 10403 static 10404 symbol_type make_PROPOSAL_LOWER_BOUND(location_type l)10405 make_PROPOSAL_LOWER_BOUND (location_type l) 10406 { 10407 return symbol_type (token::PROPOSAL_LOWER_BOUND, std::move (l)); 10408 } 10409 #else 10410 static 10411 symbol_type make_PROPOSAL_LOWER_BOUND(const location_type & l)10412 make_PROPOSAL_LOWER_BOUND (const location_type& l) 10413 { 10414 return symbol_type (token::PROPOSAL_LOWER_BOUND, l); 10415 } 10416 #endif 10417 #if 201103L <= YY_CPLUSPLUS 10418 static 10419 symbol_type make_PROPOSAL_DRAWS(location_type l)10420 make_PROPOSAL_DRAWS (location_type l) 10421 { 10422 return symbol_type (token::PROPOSAL_DRAWS, std::move (l)); 10423 } 10424 #else 10425 static 10426 symbol_type make_PROPOSAL_DRAWS(const location_type & l)10427 make_PROPOSAL_DRAWS (const location_type& l) 10428 { 10429 return symbol_type (token::PROPOSAL_DRAWS, l); 10430 } 10431 #endif 10432 #if 201103L <= YY_CPLUSPLUS 10433 static 10434 symbol_type make_USE_MEAN_CENTER(location_type l)10435 make_USE_MEAN_CENTER (location_type l) 10436 { 10437 return symbol_type (token::USE_MEAN_CENTER, std::move (l)); 10438 } 10439 #else 10440 static 10441 symbol_type make_USE_MEAN_CENTER(const location_type & l)10442 make_USE_MEAN_CENTER (const location_type& l) 10443 { 10444 return symbol_type (token::USE_MEAN_CENTER, l); 10445 } 10446 #endif 10447 #if 201103L <= YY_CPLUSPLUS 10448 static 10449 symbol_type make_ADAPTIVE_MH_DRAWS(location_type l)10450 make_ADAPTIVE_MH_DRAWS (location_type l) 10451 { 10452 return symbol_type (token::ADAPTIVE_MH_DRAWS, std::move (l)); 10453 } 10454 #else 10455 static 10456 symbol_type make_ADAPTIVE_MH_DRAWS(const location_type & l)10457 make_ADAPTIVE_MH_DRAWS (const location_type& l) 10458 { 10459 return symbol_type (token::ADAPTIVE_MH_DRAWS, l); 10460 } 10461 #endif 10462 #if 201103L <= YY_CPLUSPLUS 10463 static 10464 symbol_type make_THINNING_FACTOR(location_type l)10465 make_THINNING_FACTOR (location_type l) 10466 { 10467 return symbol_type (token::THINNING_FACTOR, std::move (l)); 10468 } 10469 #else 10470 static 10471 symbol_type make_THINNING_FACTOR(const location_type & l)10472 make_THINNING_FACTOR (const location_type& l) 10473 { 10474 return symbol_type (token::THINNING_FACTOR, l); 10475 } 10476 #endif 10477 #if 201103L <= YY_CPLUSPLUS 10478 static 10479 symbol_type make_COEFFICIENTS_PRIOR_HYPERPARAMETERS(location_type l)10480 make_COEFFICIENTS_PRIOR_HYPERPARAMETERS (location_type l) 10481 { 10482 return symbol_type (token::COEFFICIENTS_PRIOR_HYPERPARAMETERS, std::move (l)); 10483 } 10484 #else 10485 static 10486 symbol_type make_COEFFICIENTS_PRIOR_HYPERPARAMETERS(const location_type & l)10487 make_COEFFICIENTS_PRIOR_HYPERPARAMETERS (const location_type& l) 10488 { 10489 return symbol_type (token::COEFFICIENTS_PRIOR_HYPERPARAMETERS, l); 10490 } 10491 #endif 10492 #if 201103L <= YY_CPLUSPLUS 10493 static 10494 symbol_type make_SMM_ESTIMATION(location_type l)10495 make_SMM_ESTIMATION (location_type l) 10496 { 10497 return symbol_type (token::SMM_ESTIMATION, std::move (l)); 10498 } 10499 #else 10500 static 10501 symbol_type make_SMM_ESTIMATION(const location_type & l)10502 make_SMM_ESTIMATION (const location_type& l) 10503 { 10504 return symbol_type (token::SMM_ESTIMATION, l); 10505 } 10506 #endif 10507 #if 201103L <= YY_CPLUSPLUS 10508 static 10509 symbol_type make_GMM_ESTIMATION(location_type l)10510 make_GMM_ESTIMATION (location_type l) 10511 { 10512 return symbol_type (token::GMM_ESTIMATION, std::move (l)); 10513 } 10514 #else 10515 static 10516 symbol_type make_GMM_ESTIMATION(const location_type & l)10517 make_GMM_ESTIMATION (const location_type& l) 10518 { 10519 return symbol_type (token::GMM_ESTIMATION, l); 10520 } 10521 #endif 10522 #if 201103L <= YY_CPLUSPLUS 10523 static 10524 symbol_type make_CONVERGENCE_STARTING_VALUE(location_type l)10525 make_CONVERGENCE_STARTING_VALUE (location_type l) 10526 { 10527 return symbol_type (token::CONVERGENCE_STARTING_VALUE, std::move (l)); 10528 } 10529 #else 10530 static 10531 symbol_type make_CONVERGENCE_STARTING_VALUE(const location_type & l)10532 make_CONVERGENCE_STARTING_VALUE (const location_type& l) 10533 { 10534 return symbol_type (token::CONVERGENCE_STARTING_VALUE, l); 10535 } 10536 #endif 10537 #if 201103L <= YY_CPLUSPLUS 10538 static 10539 symbol_type make_CONVERGENCE_ENDING_VALUE(location_type l)10540 make_CONVERGENCE_ENDING_VALUE (location_type l) 10541 { 10542 return symbol_type (token::CONVERGENCE_ENDING_VALUE, std::move (l)); 10543 } 10544 #else 10545 static 10546 symbol_type make_CONVERGENCE_ENDING_VALUE(const location_type & l)10547 make_CONVERGENCE_ENDING_VALUE (const location_type& l) 10548 { 10549 return symbol_type (token::CONVERGENCE_ENDING_VALUE, l); 10550 } 10551 #endif 10552 #if 201103L <= YY_CPLUSPLUS 10553 static 10554 symbol_type make_CONVERGENCE_INCREMENT_VALUE(location_type l)10555 make_CONVERGENCE_INCREMENT_VALUE (location_type l) 10556 { 10557 return symbol_type (token::CONVERGENCE_INCREMENT_VALUE, std::move (l)); 10558 } 10559 #else 10560 static 10561 symbol_type make_CONVERGENCE_INCREMENT_VALUE(const location_type & l)10562 make_CONVERGENCE_INCREMENT_VALUE (const location_type& l) 10563 { 10564 return symbol_type (token::CONVERGENCE_INCREMENT_VALUE, l); 10565 } 10566 #endif 10567 #if 201103L <= YY_CPLUSPLUS 10568 static 10569 symbol_type make_MAX_ITERATIONS_STARTING_VALUE(location_type l)10570 make_MAX_ITERATIONS_STARTING_VALUE (location_type l) 10571 { 10572 return symbol_type (token::MAX_ITERATIONS_STARTING_VALUE, std::move (l)); 10573 } 10574 #else 10575 static 10576 symbol_type make_MAX_ITERATIONS_STARTING_VALUE(const location_type & l)10577 make_MAX_ITERATIONS_STARTING_VALUE (const location_type& l) 10578 { 10579 return symbol_type (token::MAX_ITERATIONS_STARTING_VALUE, l); 10580 } 10581 #endif 10582 #if 201103L <= YY_CPLUSPLUS 10583 static 10584 symbol_type make_MAX_ITERATIONS_INCREMENT_VALUE(location_type l)10585 make_MAX_ITERATIONS_INCREMENT_VALUE (location_type l) 10586 { 10587 return symbol_type (token::MAX_ITERATIONS_INCREMENT_VALUE, std::move (l)); 10588 } 10589 #else 10590 static 10591 symbol_type make_MAX_ITERATIONS_INCREMENT_VALUE(const location_type & l)10592 make_MAX_ITERATIONS_INCREMENT_VALUE (const location_type& l) 10593 { 10594 return symbol_type (token::MAX_ITERATIONS_INCREMENT_VALUE, l); 10595 } 10596 #endif 10597 #if 201103L <= YY_CPLUSPLUS 10598 static 10599 symbol_type make_MAX_BLOCK_ITERATIONS(location_type l)10600 make_MAX_BLOCK_ITERATIONS (location_type l) 10601 { 10602 return symbol_type (token::MAX_BLOCK_ITERATIONS, std::move (l)); 10603 } 10604 #else 10605 static 10606 symbol_type make_MAX_BLOCK_ITERATIONS(const location_type & l)10607 make_MAX_BLOCK_ITERATIONS (const location_type& l) 10608 { 10609 return symbol_type (token::MAX_BLOCK_ITERATIONS, l); 10610 } 10611 #endif 10612 #if 201103L <= YY_CPLUSPLUS 10613 static 10614 symbol_type make_MAX_REPEATED_OPTIMIZATION_RUNS(location_type l)10615 make_MAX_REPEATED_OPTIMIZATION_RUNS (location_type l) 10616 { 10617 return symbol_type (token::MAX_REPEATED_OPTIMIZATION_RUNS, std::move (l)); 10618 } 10619 #else 10620 static 10621 symbol_type make_MAX_REPEATED_OPTIMIZATION_RUNS(const location_type & l)10622 make_MAX_REPEATED_OPTIMIZATION_RUNS (const location_type& l) 10623 { 10624 return symbol_type (token::MAX_REPEATED_OPTIMIZATION_RUNS, l); 10625 } 10626 #endif 10627 #if 201103L <= YY_CPLUSPLUS 10628 static 10629 symbol_type make_FUNCTION_CONVERGENCE_CRITERION(location_type l)10630 make_FUNCTION_CONVERGENCE_CRITERION (location_type l) 10631 { 10632 return symbol_type (token::FUNCTION_CONVERGENCE_CRITERION, std::move (l)); 10633 } 10634 #else 10635 static 10636 symbol_type make_FUNCTION_CONVERGENCE_CRITERION(const location_type & l)10637 make_FUNCTION_CONVERGENCE_CRITERION (const location_type& l) 10638 { 10639 return symbol_type (token::FUNCTION_CONVERGENCE_CRITERION, l); 10640 } 10641 #endif 10642 #if 201103L <= YY_CPLUSPLUS 10643 static 10644 symbol_type make_SAVE_REALTIME(location_type l)10645 make_SAVE_REALTIME (location_type l) 10646 { 10647 return symbol_type (token::SAVE_REALTIME, std::move (l)); 10648 } 10649 #else 10650 static 10651 symbol_type make_SAVE_REALTIME(const location_type & l)10652 make_SAVE_REALTIME (const location_type& l) 10653 { 10654 return symbol_type (token::SAVE_REALTIME, l); 10655 } 10656 #endif 10657 #if 201103L <= YY_CPLUSPLUS 10658 static 10659 symbol_type make_PARAMETER_CONVERGENCE_CRITERION(location_type l)10660 make_PARAMETER_CONVERGENCE_CRITERION (location_type l) 10661 { 10662 return symbol_type (token::PARAMETER_CONVERGENCE_CRITERION, std::move (l)); 10663 } 10664 #else 10665 static 10666 symbol_type make_PARAMETER_CONVERGENCE_CRITERION(const location_type & l)10667 make_PARAMETER_CONVERGENCE_CRITERION (const location_type& l) 10668 { 10669 return symbol_type (token::PARAMETER_CONVERGENCE_CRITERION, l); 10670 } 10671 #endif 10672 #if 201103L <= YY_CPLUSPLUS 10673 static 10674 symbol_type make_NUMBER_OF_LARGE_PERTURBATIONS(location_type l)10675 make_NUMBER_OF_LARGE_PERTURBATIONS (location_type l) 10676 { 10677 return symbol_type (token::NUMBER_OF_LARGE_PERTURBATIONS, std::move (l)); 10678 } 10679 #else 10680 static 10681 symbol_type make_NUMBER_OF_LARGE_PERTURBATIONS(const location_type & l)10682 make_NUMBER_OF_LARGE_PERTURBATIONS (const location_type& l) 10683 { 10684 return symbol_type (token::NUMBER_OF_LARGE_PERTURBATIONS, l); 10685 } 10686 #endif 10687 #if 201103L <= YY_CPLUSPLUS 10688 static 10689 symbol_type make_NUMBER_OF_SMALL_PERTURBATIONS(location_type l)10690 make_NUMBER_OF_SMALL_PERTURBATIONS (location_type l) 10691 { 10692 return symbol_type (token::NUMBER_OF_SMALL_PERTURBATIONS, std::move (l)); 10693 } 10694 #else 10695 static 10696 symbol_type make_NUMBER_OF_SMALL_PERTURBATIONS(const location_type & l)10697 make_NUMBER_OF_SMALL_PERTURBATIONS (const location_type& l) 10698 { 10699 return symbol_type (token::NUMBER_OF_SMALL_PERTURBATIONS, l); 10700 } 10701 #endif 10702 #if 201103L <= YY_CPLUSPLUS 10703 static 10704 symbol_type make_NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION(location_type l)10705 make_NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION (location_type l) 10706 { 10707 return symbol_type (token::NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION, std::move (l)); 10708 } 10709 #else 10710 static 10711 symbol_type make_NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION(const location_type & l)10712 make_NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION (const location_type& l) 10713 { 10714 return symbol_type (token::NUMBER_OF_POSTERIOR_DRAWS_AFTER_PERTURBATION, l); 10715 } 10716 #endif 10717 #if 201103L <= YY_CPLUSPLUS 10718 static 10719 symbol_type make_MAX_NUMBER_OF_STAGES(location_type l)10720 make_MAX_NUMBER_OF_STAGES (location_type l) 10721 { 10722 return symbol_type (token::MAX_NUMBER_OF_STAGES, std::move (l)); 10723 } 10724 #else 10725 static 10726 symbol_type make_MAX_NUMBER_OF_STAGES(const location_type & l)10727 make_MAX_NUMBER_OF_STAGES (const location_type& l) 10728 { 10729 return symbol_type (token::MAX_NUMBER_OF_STAGES, l); 10730 } 10731 #endif 10732 #if 201103L <= YY_CPLUSPLUS 10733 static 10734 symbol_type make_RANDOM_FUNCTION_CONVERGENCE_CRITERION(location_type l)10735 make_RANDOM_FUNCTION_CONVERGENCE_CRITERION (location_type l) 10736 { 10737 return symbol_type (token::RANDOM_FUNCTION_CONVERGENCE_CRITERION, std::move (l)); 10738 } 10739 #else 10740 static 10741 symbol_type make_RANDOM_FUNCTION_CONVERGENCE_CRITERION(const location_type & l)10742 make_RANDOM_FUNCTION_CONVERGENCE_CRITERION (const location_type& l) 10743 { 10744 return symbol_type (token::RANDOM_FUNCTION_CONVERGENCE_CRITERION, l); 10745 } 10746 #endif 10747 #if 201103L <= YY_CPLUSPLUS 10748 static 10749 symbol_type make_RANDOM_PARAMETER_CONVERGENCE_CRITERION(location_type l)10750 make_RANDOM_PARAMETER_CONVERGENCE_CRITERION (location_type l) 10751 { 10752 return symbol_type (token::RANDOM_PARAMETER_CONVERGENCE_CRITERION, std::move (l)); 10753 } 10754 #else 10755 static 10756 symbol_type make_RANDOM_PARAMETER_CONVERGENCE_CRITERION(const location_type & l)10757 make_RANDOM_PARAMETER_CONVERGENCE_CRITERION (const location_type& l) 10758 { 10759 return symbol_type (token::RANDOM_PARAMETER_CONVERGENCE_CRITERION, l); 10760 } 10761 #endif 10762 #if 201103L <= YY_CPLUSPLUS 10763 static 10764 symbol_type make_CENTERED_MOMENTS(location_type l)10765 make_CENTERED_MOMENTS (location_type l) 10766 { 10767 return symbol_type (token::CENTERED_MOMENTS, std::move (l)); 10768 } 10769 #else 10770 static 10771 symbol_type make_CENTERED_MOMENTS(const location_type & l)10772 make_CENTERED_MOMENTS (const location_type& l) 10773 { 10774 return symbol_type (token::CENTERED_MOMENTS, l); 10775 } 10776 #endif 10777 #if 201103L <= YY_CPLUSPLUS 10778 static 10779 symbol_type make_AUTOLAG(location_type l)10780 make_AUTOLAG (location_type l) 10781 { 10782 return symbol_type (token::AUTOLAG, std::move (l)); 10783 } 10784 #else 10785 static 10786 symbol_type make_AUTOLAG(const location_type & l)10787 make_AUTOLAG (const location_type& l) 10788 { 10789 return symbol_type (token::AUTOLAG, l); 10790 } 10791 #endif 10792 #if 201103L <= YY_CPLUSPLUS 10793 static 10794 symbol_type make_RECURSIVE_ORDER_ESTIMATION(location_type l)10795 make_RECURSIVE_ORDER_ESTIMATION (location_type l) 10796 { 10797 return symbol_type (token::RECURSIVE_ORDER_ESTIMATION, std::move (l)); 10798 } 10799 #else 10800 static 10801 symbol_type make_RECURSIVE_ORDER_ESTIMATION(const location_type & l)10802 make_RECURSIVE_ORDER_ESTIMATION (const location_type& l) 10803 { 10804 return symbol_type (token::RECURSIVE_ORDER_ESTIMATION, l); 10805 } 10806 #endif 10807 #if 201103L <= YY_CPLUSPLUS 10808 static 10809 symbol_type make_BARTLETT_KERNEL_LAG(location_type l)10810 make_BARTLETT_KERNEL_LAG (location_type l) 10811 { 10812 return symbol_type (token::BARTLETT_KERNEL_LAG, std::move (l)); 10813 } 10814 #else 10815 static 10816 symbol_type make_BARTLETT_KERNEL_LAG(const location_type & l)10817 make_BARTLETT_KERNEL_LAG (const location_type& l) 10818 { 10819 return symbol_type (token::BARTLETT_KERNEL_LAG, l); 10820 } 10821 #endif 10822 #if 201103L <= YY_CPLUSPLUS 10823 static 10824 symbol_type make_WEIGHTING_MATRIX(location_type l)10825 make_WEIGHTING_MATRIX (location_type l) 10826 { 10827 return symbol_type (token::WEIGHTING_MATRIX, std::move (l)); 10828 } 10829 #else 10830 static 10831 symbol_type make_WEIGHTING_MATRIX(const location_type & l)10832 make_WEIGHTING_MATRIX (const location_type& l) 10833 { 10834 return symbol_type (token::WEIGHTING_MATRIX, l); 10835 } 10836 #endif 10837 #if 201103L <= YY_CPLUSPLUS 10838 static 10839 symbol_type make_PENALIZED_ESTIMATOR(location_type l)10840 make_PENALIZED_ESTIMATOR (location_type l) 10841 { 10842 return symbol_type (token::PENALIZED_ESTIMATOR, std::move (l)); 10843 } 10844 #else 10845 static 10846 symbol_type make_PENALIZED_ESTIMATOR(const location_type & l)10847 make_PENALIZED_ESTIMATOR (const location_type& l) 10848 { 10849 return symbol_type (token::PENALIZED_ESTIMATOR, l); 10850 } 10851 #endif 10852 #if 201103L <= YY_CPLUSPLUS 10853 static 10854 symbol_type make_VERBOSE(location_type l)10855 make_VERBOSE (location_type l) 10856 { 10857 return symbol_type (token::VERBOSE, std::move (l)); 10858 } 10859 #else 10860 static 10861 symbol_type make_VERBOSE(const location_type & l)10862 make_VERBOSE (const location_type& l) 10863 { 10864 return symbol_type (token::VERBOSE, l); 10865 } 10866 #endif 10867 #if 201103L <= YY_CPLUSPLUS 10868 static 10869 symbol_type make_SIMULATION_MULTIPLE(location_type l)10870 make_SIMULATION_MULTIPLE (location_type l) 10871 { 10872 return symbol_type (token::SIMULATION_MULTIPLE, std::move (l)); 10873 } 10874 #else 10875 static 10876 symbol_type make_SIMULATION_MULTIPLE(const location_type & l)10877 make_SIMULATION_MULTIPLE (const location_type& l) 10878 { 10879 return symbol_type (token::SIMULATION_MULTIPLE, l); 10880 } 10881 #endif 10882 #if 201103L <= YY_CPLUSPLUS 10883 static 10884 symbol_type make_SEED(location_type l)10885 make_SEED (location_type l) 10886 { 10887 return symbol_type (token::SEED, std::move (l)); 10888 } 10889 #else 10890 static 10891 symbol_type make_SEED(const location_type & l)10892 make_SEED (const location_type& l) 10893 { 10894 return symbol_type (token::SEED, l); 10895 } 10896 #endif 10897 #if 201103L <= YY_CPLUSPLUS 10898 static 10899 symbol_type make_BOUNDED_SHOCK_SUPPORT(location_type l)10900 make_BOUNDED_SHOCK_SUPPORT (location_type l) 10901 { 10902 return symbol_type (token::BOUNDED_SHOCK_SUPPORT, std::move (l)); 10903 } 10904 #else 10905 static 10906 symbol_type make_BOUNDED_SHOCK_SUPPORT(const location_type & l)10907 make_BOUNDED_SHOCK_SUPPORT (const location_type& l) 10908 { 10909 return symbol_type (token::BOUNDED_SHOCK_SUPPORT, l); 10910 } 10911 #endif 10912 #if 201103L <= YY_CPLUSPLUS 10913 static 10914 symbol_type make_EQTAGS(location_type l)10915 make_EQTAGS (location_type l) 10916 { 10917 return symbol_type (token::EQTAGS, std::move (l)); 10918 } 10919 #else 10920 static 10921 symbol_type make_EQTAGS(const location_type & l)10922 make_EQTAGS (const location_type& l) 10923 { 10924 return symbol_type (token::EQTAGS, l); 10925 } 10926 #endif 10927 #if 201103L <= YY_CPLUSPLUS 10928 static 10929 symbol_type make_STEADY_STATE_GROWTH(location_type l)10930 make_STEADY_STATE_GROWTH (location_type l) 10931 { 10932 return symbol_type (token::STEADY_STATE_GROWTH, std::move (l)); 10933 } 10934 #else 10935 static 10936 symbol_type make_STEADY_STATE_GROWTH(const location_type & l)10937 make_STEADY_STATE_GROWTH (const location_type& l) 10938 { 10939 return symbol_type (token::STEADY_STATE_GROWTH, l); 10940 } 10941 #endif 10942 #if 201103L <= YY_CPLUSPLUS 10943 static 10944 symbol_type make_ANALYTICAL_GIRF(location_type l)10945 make_ANALYTICAL_GIRF (location_type l) 10946 { 10947 return symbol_type (token::ANALYTICAL_GIRF, std::move (l)); 10948 } 10949 #else 10950 static 10951 symbol_type make_ANALYTICAL_GIRF(const location_type & l)10952 make_ANALYTICAL_GIRF (const location_type& l) 10953 { 10954 return symbol_type (token::ANALYTICAL_GIRF, l); 10955 } 10956 #endif 10957 #if 201103L <= YY_CPLUSPLUS 10958 static 10959 symbol_type make_IRF_IN_PERCENT(location_type l)10960 make_IRF_IN_PERCENT (location_type l) 10961 { 10962 return symbol_type (token::IRF_IN_PERCENT, std::move (l)); 10963 } 10964 #else 10965 static 10966 symbol_type make_IRF_IN_PERCENT(const location_type & l)10967 make_IRF_IN_PERCENT (const location_type& l) 10968 { 10969 return symbol_type (token::IRF_IN_PERCENT, l); 10970 } 10971 #endif 10972 #if 201103L <= YY_CPLUSPLUS 10973 static 10974 symbol_type make_EMAS_GIRF(location_type l)10975 make_EMAS_GIRF (location_type l) 10976 { 10977 return symbol_type (token::EMAS_GIRF, std::move (l)); 10978 } 10979 #else 10980 static 10981 symbol_type make_EMAS_GIRF(const location_type & l)10982 make_EMAS_GIRF (const location_type& l) 10983 { 10984 return symbol_type (token::EMAS_GIRF, l); 10985 } 10986 #endif 10987 #if 201103L <= YY_CPLUSPLUS 10988 static 10989 symbol_type make_EMAS_DROP(location_type l)10990 make_EMAS_DROP (location_type l) 10991 { 10992 return symbol_type (token::EMAS_DROP, std::move (l)); 10993 } 10994 #else 10995 static 10996 symbol_type make_EMAS_DROP(const location_type & l)10997 make_EMAS_DROP (const location_type& l) 10998 { 10999 return symbol_type (token::EMAS_DROP, l); 11000 } 11001 #endif 11002 #if 201103L <= YY_CPLUSPLUS 11003 static 11004 symbol_type make_EMAS_TOLF(location_type l)11005 make_EMAS_TOLF (location_type l) 11006 { 11007 return symbol_type (token::EMAS_TOLF, std::move (l)); 11008 } 11009 #else 11010 static 11011 symbol_type make_EMAS_TOLF(const location_type & l)11012 make_EMAS_TOLF (const location_type& l) 11013 { 11014 return symbol_type (token::EMAS_TOLF, l); 11015 } 11016 #endif 11017 #if 201103L <= YY_CPLUSPLUS 11018 static 11019 symbol_type make_EMAS_MAX_ITER(location_type l)11020 make_EMAS_MAX_ITER (location_type l) 11021 { 11022 return symbol_type (token::EMAS_MAX_ITER, std::move (l)); 11023 } 11024 #else 11025 static 11026 symbol_type make_EMAS_MAX_ITER(const location_type & l)11027 make_EMAS_MAX_ITER (const location_type& l) 11028 { 11029 return symbol_type (token::EMAS_MAX_ITER, l); 11030 } 11031 #endif 11032 #if 201103L <= YY_CPLUSPLUS 11033 static 11034 symbol_type make_NO_IDENTIFICATION_STRENGTH(location_type l)11035 make_NO_IDENTIFICATION_STRENGTH (location_type l) 11036 { 11037 return symbol_type (token::NO_IDENTIFICATION_STRENGTH, std::move (l)); 11038 } 11039 #else 11040 static 11041 symbol_type make_NO_IDENTIFICATION_STRENGTH(const location_type & l)11042 make_NO_IDENTIFICATION_STRENGTH (const location_type& l) 11043 { 11044 return symbol_type (token::NO_IDENTIFICATION_STRENGTH, l); 11045 } 11046 #endif 11047 #if 201103L <= YY_CPLUSPLUS 11048 static 11049 symbol_type make_NO_IDENTIFICATION_REDUCEDFORM(location_type l)11050 make_NO_IDENTIFICATION_REDUCEDFORM (location_type l) 11051 { 11052 return symbol_type (token::NO_IDENTIFICATION_REDUCEDFORM, std::move (l)); 11053 } 11054 #else 11055 static 11056 symbol_type make_NO_IDENTIFICATION_REDUCEDFORM(const location_type & l)11057 make_NO_IDENTIFICATION_REDUCEDFORM (const location_type& l) 11058 { 11059 return symbol_type (token::NO_IDENTIFICATION_REDUCEDFORM, l); 11060 } 11061 #endif 11062 #if 201103L <= YY_CPLUSPLUS 11063 static 11064 symbol_type make_NO_IDENTIFICATION_MOMENTS(location_type l)11065 make_NO_IDENTIFICATION_MOMENTS (location_type l) 11066 { 11067 return symbol_type (token::NO_IDENTIFICATION_MOMENTS, std::move (l)); 11068 } 11069 #else 11070 static 11071 symbol_type make_NO_IDENTIFICATION_MOMENTS(const location_type & l)11072 make_NO_IDENTIFICATION_MOMENTS (const location_type& l) 11073 { 11074 return symbol_type (token::NO_IDENTIFICATION_MOMENTS, l); 11075 } 11076 #endif 11077 #if 201103L <= YY_CPLUSPLUS 11078 static 11079 symbol_type make_NO_IDENTIFICATION_MINIMAL(location_type l)11080 make_NO_IDENTIFICATION_MINIMAL (location_type l) 11081 { 11082 return symbol_type (token::NO_IDENTIFICATION_MINIMAL, std::move (l)); 11083 } 11084 #else 11085 static 11086 symbol_type make_NO_IDENTIFICATION_MINIMAL(const location_type & l)11087 make_NO_IDENTIFICATION_MINIMAL (const location_type& l) 11088 { 11089 return symbol_type (token::NO_IDENTIFICATION_MINIMAL, l); 11090 } 11091 #endif 11092 #if 201103L <= YY_CPLUSPLUS 11093 static 11094 symbol_type make_NO_IDENTIFICATION_SPECTRUM(location_type l)11095 make_NO_IDENTIFICATION_SPECTRUM (location_type l) 11096 { 11097 return symbol_type (token::NO_IDENTIFICATION_SPECTRUM, std::move (l)); 11098 } 11099 #else 11100 static 11101 symbol_type make_NO_IDENTIFICATION_SPECTRUM(const location_type & l)11102 make_NO_IDENTIFICATION_SPECTRUM (const location_type& l) 11103 { 11104 return symbol_type (token::NO_IDENTIFICATION_SPECTRUM, l); 11105 } 11106 #endif 11107 #if 201103L <= YY_CPLUSPLUS 11108 static 11109 symbol_type make_NORMALIZE_JACOBIANS(location_type l)11110 make_NORMALIZE_JACOBIANS (location_type l) 11111 { 11112 return symbol_type (token::NORMALIZE_JACOBIANS, std::move (l)); 11113 } 11114 #else 11115 static 11116 symbol_type make_NORMALIZE_JACOBIANS(const location_type & l)11117 make_NORMALIZE_JACOBIANS (const location_type& l) 11118 { 11119 return symbol_type (token::NORMALIZE_JACOBIANS, l); 11120 } 11121 #endif 11122 #if 201103L <= YY_CPLUSPLUS 11123 static 11124 symbol_type make_GRID_NBR(location_type l)11125 make_GRID_NBR (location_type l) 11126 { 11127 return symbol_type (token::GRID_NBR, std::move (l)); 11128 } 11129 #else 11130 static 11131 symbol_type make_GRID_NBR(const location_type & l)11132 make_GRID_NBR (const location_type& l) 11133 { 11134 return symbol_type (token::GRID_NBR, l); 11135 } 11136 #endif 11137 #if 201103L <= YY_CPLUSPLUS 11138 static 11139 symbol_type make_TOL_RANK(location_type l)11140 make_TOL_RANK (location_type l) 11141 { 11142 return symbol_type (token::TOL_RANK, std::move (l)); 11143 } 11144 #else 11145 static 11146 symbol_type make_TOL_RANK(const location_type & l)11147 make_TOL_RANK (const location_type& l) 11148 { 11149 return symbol_type (token::TOL_RANK, l); 11150 } 11151 #endif 11152 #if 201103L <= YY_CPLUSPLUS 11153 static 11154 symbol_type make_TOL_DERIV(location_type l)11155 make_TOL_DERIV (location_type l) 11156 { 11157 return symbol_type (token::TOL_DERIV, std::move (l)); 11158 } 11159 #else 11160 static 11161 symbol_type make_TOL_DERIV(const location_type & l)11162 make_TOL_DERIV (const location_type& l) 11163 { 11164 return symbol_type (token::TOL_DERIV, l); 11165 } 11166 #endif 11167 #if 201103L <= YY_CPLUSPLUS 11168 static 11169 symbol_type make_TOL_SV(location_type l)11170 make_TOL_SV (location_type l) 11171 { 11172 return symbol_type (token::TOL_SV, std::move (l)); 11173 } 11174 #else 11175 static 11176 symbol_type make_TOL_SV(const location_type & l)11177 make_TOL_SV (const location_type& l) 11178 { 11179 return symbol_type (token::TOL_SV, l); 11180 } 11181 #endif 11182 #if 201103L <= YY_CPLUSPLUS 11183 static 11184 symbol_type make_CHECKS_VIA_SUBSETS(location_type l)11185 make_CHECKS_VIA_SUBSETS (location_type l) 11186 { 11187 return symbol_type (token::CHECKS_VIA_SUBSETS, std::move (l)); 11188 } 11189 #else 11190 static 11191 symbol_type make_CHECKS_VIA_SUBSETS(const location_type & l)11192 make_CHECKS_VIA_SUBSETS (const location_type& l) 11193 { 11194 return symbol_type (token::CHECKS_VIA_SUBSETS, l); 11195 } 11196 #endif 11197 #if 201103L <= YY_CPLUSPLUS 11198 static 11199 symbol_type make_MAX_DIM_SUBSETS_GROUPS(location_type l)11200 make_MAX_DIM_SUBSETS_GROUPS (location_type l) 11201 { 11202 return symbol_type (token::MAX_DIM_SUBSETS_GROUPS, std::move (l)); 11203 } 11204 #else 11205 static 11206 symbol_type make_MAX_DIM_SUBSETS_GROUPS(const location_type & l)11207 make_MAX_DIM_SUBSETS_GROUPS (const location_type& l) 11208 { 11209 return symbol_type (token::MAX_DIM_SUBSETS_GROUPS, l); 11210 } 11211 #endif 11212 #if 201103L <= YY_CPLUSPLUS 11213 static 11214 symbol_type make_MAX_NROWS(location_type l)11215 make_MAX_NROWS (location_type l) 11216 { 11217 return symbol_type (token::MAX_NROWS, std::move (l)); 11218 } 11219 #else 11220 static 11221 symbol_type make_MAX_NROWS(const location_type & l)11222 make_MAX_NROWS (const location_type& l) 11223 { 11224 return symbol_type (token::MAX_NROWS, l); 11225 } 11226 #endif 11227 #if 201103L <= YY_CPLUSPLUS 11228 static 11229 symbol_type make_SQUEEZE_SHOCK_DECOMPOSITION(location_type l)11230 make_SQUEEZE_SHOCK_DECOMPOSITION (location_type l) 11231 { 11232 return symbol_type (token::SQUEEZE_SHOCK_DECOMPOSITION, std::move (l)); 11233 } 11234 #else 11235 static 11236 symbol_type make_SQUEEZE_SHOCK_DECOMPOSITION(const location_type & l)11237 make_SQUEEZE_SHOCK_DECOMPOSITION (const location_type& l) 11238 { 11239 return symbol_type (token::SQUEEZE_SHOCK_DECOMPOSITION, l); 11240 } 11241 #endif 11242 #if 201103L <= YY_CPLUSPLUS 11243 static 11244 symbol_type make_WITH_EPILOGUE(location_type l)11245 make_WITH_EPILOGUE (location_type l) 11246 { 11247 return symbol_type (token::WITH_EPILOGUE, std::move (l)); 11248 } 11249 #else 11250 static 11251 symbol_type make_WITH_EPILOGUE(const location_type & l)11252 make_WITH_EPILOGUE (const location_type& l) 11253 { 11254 return symbol_type (token::WITH_EPILOGUE, l); 11255 } 11256 #endif 11257 #if 201103L <= YY_CPLUSPLUS 11258 static 11259 symbol_type make_SYMBOL_VEC(vector<string> v,location_type l)11260 make_SYMBOL_VEC (vector<string> v, location_type l) 11261 { 11262 return symbol_type (token::SYMBOL_VEC, std::move (v), std::move (l)); 11263 } 11264 #else 11265 static 11266 symbol_type make_SYMBOL_VEC(const vector<string> & v,const location_type & l)11267 make_SYMBOL_VEC (const vector<string>& v, const location_type& l) 11268 { 11269 return symbol_type (token::SYMBOL_VEC, v, l); 11270 } 11271 #endif 11272 11273 11274 private: 11275 /// This class is not copyable. 11276 parser (const parser&); 11277 parser& operator= (const parser&); 11278 11279 /// State numbers. 11280 typedef int state_type; 11281 11282 /// Generate an error message. 11283 /// \param yystate the state where the error occurred. 11284 /// \param yyla the lookahead token. 11285 virtual std::string yysyntax_error_ (state_type yystate, 11286 const symbol_type& yyla) const; 11287 11288 /// Compute post-reduction state. 11289 /// \param yystate the current state 11290 /// \param yysym the nonterminal to push on the stack 11291 state_type yy_lr_goto_state_ (state_type yystate, int yysym); 11292 11293 /// Whether the given \c yypact_ value indicates a defaulted state. 11294 /// \param yyvalue the value to check 11295 static bool yy_pact_value_is_default_ (int yyvalue); 11296 11297 /// Whether the given \c yytable_ value indicates a syntax error. 11298 /// \param yyvalue the value to check 11299 static bool yy_table_value_is_error_ (int yyvalue); 11300 11301 static const short yypact_ninf_; 11302 static const short yytable_ninf_; 11303 11304 /// Convert a scanner token number \a t to a symbol number. 11305 static token_number_type yytranslate_ (int t); 11306 11307 // Tables. 11308 // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 11309 // STATE-NUM. 11310 static const short yypact_[]; 11311 11312 // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 11313 // Performed when YYTABLE does not specify something else to do. Zero 11314 // means the default is an error. 11315 static const unsigned short yydefact_[]; 11316 11317 // YYPGOTO[NTERM-NUM]. 11318 static const short yypgoto_[]; 11319 11320 // YYDEFGOTO[NTERM-NUM]. 11321 static const short yydefgoto_[]; 11322 11323 // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 11324 // positive, shift that token. If negative, reduce the rule whose 11325 // number is the opposite. If YYTABLE_NINF, syntax error. 11326 static const short yytable_[]; 11327 11328 static const short yycheck_[]; 11329 11330 // YYSTOS[STATE-NUM] -- The (internal number of the) accessing 11331 // symbol of state STATE-NUM. 11332 static const unsigned short yystos_[]; 11333 11334 // YYR1[YYN] -- Symbol number of symbol that rule YYN derives. 11335 static const unsigned short yyr1_[]; 11336 11337 // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. 11338 static const unsigned char yyr2_[]; 11339 11340 11341 /// Convert the symbol name \a n to a form suitable for a diagnostic. 11342 static std::string yytnamerr_ (const char *n); 11343 11344 11345 /// For a symbol, its name in clear. 11346 static const char* const yytname_[]; 11347 #if YYDEBUG 11348 // YYRLINE[YYN] -- Source line where rule number YYN was defined. 11349 static const unsigned short yyrline_[]; 11350 /// Report on the debug stream that the rule \a r is going to be reduced. 11351 virtual void yy_reduce_print_ (int r); 11352 /// Print the state stack on the debug stream. 11353 virtual void yystack_print_ (); 11354 11355 /// Debugging level. 11356 int yydebug_; 11357 /// Debug stream. 11358 std::ostream* yycdebug_; 11359 11360 /// \brief Display a symbol type, value and location. 11361 /// \param yyo The output stream. 11362 /// \param yysym The symbol. 11363 template <typename Base> 11364 void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const; 11365 #endif 11366 11367 /// \brief Reclaim the memory associated to a symbol. 11368 /// \param yymsg Why this token is reclaimed. 11369 /// If null, print nothing. 11370 /// \param yysym The symbol. 11371 template <typename Base> 11372 void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const; 11373 11374 private: 11375 /// Type access provider for state based symbols. 11376 struct by_state 11377 { 11378 /// Default constructor. 11379 by_state () YY_NOEXCEPT; 11380 11381 /// The symbol type as needed by the constructor. 11382 typedef state_type kind_type; 11383 11384 /// Constructor. 11385 by_state (kind_type s) YY_NOEXCEPT; 11386 11387 /// Copy constructor. 11388 by_state (const by_state& that) YY_NOEXCEPT; 11389 11390 /// Record that this symbol is empty. 11391 void clear () YY_NOEXCEPT; 11392 11393 /// Steal the symbol type from \a that. 11394 void move (by_state& that); 11395 11396 /// The (internal) type number (corresponding to \a state). 11397 /// \a empty_symbol when empty. 11398 symbol_number_type type_get () const YY_NOEXCEPT; 11399 11400 /// The state number used to denote an empty symbol. 11401 enum { empty_state = -1 }; 11402 11403 /// The state. 11404 /// \a empty when empty. 11405 state_type state; 11406 }; 11407 11408 /// "Internal" symbol: element of the stack. 11409 struct stack_symbol_type : basic_symbol<by_state> 11410 { 11411 /// Superclass. 11412 typedef basic_symbol<by_state> super_type; 11413 /// Construct an empty symbol. 11414 stack_symbol_type (); 11415 /// Move or copy construction. 11416 stack_symbol_type (YY_RVREF (stack_symbol_type) that); 11417 /// Steal the contents from \a sym to build this. 11418 stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym); 11419 #if YY_CPLUSPLUS < 201103L 11420 /// Assignment, needed by push_back by some old implementations. 11421 /// Moves the contents of that. 11422 stack_symbol_type& operator= (stack_symbol_type& that); 11423 #endif 11424 }; 11425 11426 /// A stack with random access from its top. 11427 template <typename T, typename S = std::vector<T> > 11428 class stack 11429 { 11430 public: 11431 // Hide our reversed order. 11432 typedef typename S::reverse_iterator iterator; 11433 typedef typename S::const_reverse_iterator const_iterator; 11434 typedef typename S::size_type size_type; 11435 stack(size_type n=200)11436 stack (size_type n = 200) 11437 : seq_ (n) 11438 {} 11439 11440 /// Random access. 11441 /// 11442 /// Index 0 returns the topmost element. 11443 T& operator [](size_type i)11444 operator[] (size_type i) 11445 { 11446 return seq_[size () - 1 - i]; 11447 } 11448 11449 /// Random access. 11450 /// 11451 /// Index 0 returns the topmost element. 11452 T& operator [](int i)11453 operator[] (int i) 11454 { 11455 return operator[] (size_type (i)); 11456 } 11457 11458 /// Random access. 11459 /// 11460 /// Index 0 returns the topmost element. 11461 const T& operator [](size_type i) const11462 operator[] (size_type i) const 11463 { 11464 return seq_[size () - 1 - i]; 11465 } 11466 11467 /// Random access. 11468 /// 11469 /// Index 0 returns the topmost element. 11470 const T& operator [](int i) const11471 operator[] (int i) const 11472 { 11473 return operator[] (size_type (i)); 11474 } 11475 11476 /// Steal the contents of \a t. 11477 /// 11478 /// Close to move-semantics. 11479 void push(YY_MOVE_REF (T)t)11480 push (YY_MOVE_REF (T) t) 11481 { 11482 seq_.push_back (T ()); 11483 operator[] (0).move (t); 11484 } 11485 11486 /// Pop elements from the stack. 11487 void pop(int n=1)11488 pop (int n = 1) YY_NOEXCEPT 11489 { 11490 for (; 0 < n; --n) 11491 seq_.pop_back (); 11492 } 11493 11494 /// Pop all elements from the stack. 11495 void clear()11496 clear () YY_NOEXCEPT 11497 { 11498 seq_.clear (); 11499 } 11500 11501 /// Number of elements on the stack. 11502 size_type size() const11503 size () const YY_NOEXCEPT 11504 { 11505 return seq_.size (); 11506 } 11507 11508 /// Iterator on top of the stack (going downwards). 11509 const_iterator begin() const11510 begin () const YY_NOEXCEPT 11511 { 11512 return seq_.rbegin (); 11513 } 11514 11515 /// Bottom of the stack. 11516 const_iterator end() const11517 end () const YY_NOEXCEPT 11518 { 11519 return seq_.rend (); 11520 } 11521 11522 /// Present a slice of the top of a stack. 11523 class slice 11524 { 11525 public: slice(const stack & stack,int range)11526 slice (const stack& stack, int range) 11527 : stack_ (stack) 11528 , range_ (range) 11529 {} 11530 11531 const T& operator [](int i) const11532 operator[] (int i) const 11533 { 11534 return stack_[range_ - i]; 11535 } 11536 11537 private: 11538 const stack& stack_; 11539 int range_; 11540 }; 11541 11542 private: 11543 stack (const stack&); 11544 stack& operator= (const stack&); 11545 /// The wrapped container. 11546 S seq_; 11547 }; 11548 11549 11550 /// Stack type. 11551 typedef stack<stack_symbol_type> stack_type; 11552 11553 /// The stack. 11554 stack_type yystack_; 11555 11556 /// Push a new state on the stack. 11557 /// \param m a debug message to display 11558 /// if null, no trace is output. 11559 /// \param sym the symbol 11560 /// \warning the contents of \a s.value is stolen. 11561 void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym); 11562 11563 /// Push a new look ahead token on the state on the stack. 11564 /// \param m a debug message to display 11565 /// if null, no trace is output. 11566 /// \param s the state 11567 /// \param sym the symbol (for its value and location). 11568 /// \warning the contents of \a sym.value is stolen. 11569 void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym); 11570 11571 /// Pop \a n symbols from the stack. 11572 void yypop_ (int n = 1); 11573 11574 /// Constants. 11575 enum 11576 { 11577 yyeof_ = 0, 11578 yylast_ = 14604, ///< Last index in yytable_. 11579 yynnts_ = 833, ///< Number of nonterminal symbols. 11580 yyfinal_ = 433, ///< Termination state number. 11581 yyterror_ = 1, 11582 yyerrcode_ = 256, 11583 yyntokens_ = 654 ///< Number of tokens. 11584 }; 11585 11586 11587 // User arguments. 11588 ParsingDriver &driver; 11589 }; 11590 11591 11592 #line 25 "DynareBison.yy" // lalr1.cc:401 11593 } // Dynare 11594 #line 11595 "DynareBison.hh" // lalr1.cc:401 11595 11596 11597 11598 11599 #endif // !YY_YY_DYNAREBISON_HH_INCLUDED 11600