GSaha567/seq_level_training_data
052
1text,length,is_long_context,metric_val,label_metric2"/* A Bison parser, made by GNU Bison 3.0.4. */3 4/* Bison implementation for Yacc-like parsers in C5 6 Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.7 8 This program is free software: you can redistribute it and/or modify9 it under the terms of the GNU General Public License as published by10 the Free Software Foundation, either version 3 of the License, or11 (at your option) any later version.12 13 This program is distributed in the hope that it will be useful,14 but WITHOUT ANY WARRANTY; without even the implied warranty of15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the16 GNU General Public License for more details.17 18 You should have received a copy of the GNU General Public License19 along with this program. If not, see <http://www.gnu.org/licenses/>. */20 21/* As a special exception, you may create a larger work that contains22 part or all of the Bison parser skeleton and distribute that work23 under terms of your choice, so long as that work isn't itself a24 parser generator using the skeleton or a modified version thereof25 as a parser skeleton. Alternatively, if you modify or redistribute26 the parser skeleton itself, you may (at your option) remove this27 special exception, which will cause the skeleton and the resulting28 Bison output files to be licensed under the GNU General Public29 License without this special exception.30 31 This special exception was added by the Free Software Foundation in32 version 2.2 of Bison. */33 34/* C LALR(1) parser skeleton written by Richard Stallman, by35 simplifying the original so-called ""semantic"" parser. */36 37/* All symbols defined below should begin with yy or YY, to avoid38 infringing on user name space. This should be done even for local39 variables, as they might otherwise be expanded by user macros.40 There are some unavoidable exceptions within include files to41 define necessary library symbols; they are noted ""INFRINGES ON42 USER NAME SPACE"" below. */43 44/* Identify Bison output. */45#define YYBISON 146 47/* Bison version. */48#define YYBISON_VERSION ""3.0.4""49 50/* Skeleton name. */51#define YYSKELETON_NAME ""yacc.c""52 53/* Pure parsers. */54#define YYPURE 155 56/* Push parsers. */57#define YYPUSH 058 59/* Pull parsers. */60#define YYPULL 161 62 63/* Substitute the variable and function names. */64#define yyparse vm_var__parse65#define yylex vm_var__lex66#define yyerror vm_var__error67#define yydebug vm_var__debug68#define yynerrs vm_var__nerrs69 70 71/* Copy the first part of user declarations. */72#line 17 ""vm_var_syntax.y"" /* yacc.c:339 */73 74#include <iostream>75#include <sstream>76#include <string>77#include <map>78#include <algorithm>79 80#include <ctype.h>81#include <string.h>82 83#include ""vm_var_syntax.h""84#include ""VirtualMachinePool.h""85#include ""VirtualMachine.h""86#include ""Nebula.h""87 88#define vm_var__lex vm_var_lex89 90#define YYERROR_VERBOSE91#define VM_VAR_TO_UPPER(S) transform (S.begin(),S.end(),S.begin(), \\92(int(*)(int))toupper)93 94extern ""C""95{96 #include ""mem_collector.h""97 98 void vm_var__error(99 YYLTYPE * llocp,100 mem_collector * mc,101 VirtualMachine * vm,102 ostringstream * parsed,103 char ** errmsg,104 const char * str);105 106 int vm_var__lex (YYSTYPE *lvalp, YYLTYPE *llocp, mem_collector * mc);107 108 int vm_var__parse (mem_collector * mc,109 VirtualMachine * vm,110 ostringstream * parsed,111 char ** errmsg);112 113 int vm_var_parse (VirtualMachine * vm,114 ostringstream * parsed,115 char ** errmsg)116 {117 mem_collector mc;118 int rc;119 120 mem_collector_init(&mc);121 122 rc = vm_var__parse(&mc, vm, parsed, errmsg);123 124 mem_collector_cleanup(&mc);125 126 return rc;127 }128}129 130/* -------------------------------------------------------------------------- */131/* -------------------------------------------------------------------------- */132 133void get_image_attribute(VirtualMachine * vm,134 const string& attr_name,135 const string& img_name,136 const string& img_value,137 string& attr_value)138{139 Nebula& nd = Nebula::instance();140 141 ImagePool * ipool = nd.get_ipool();142 Image * img;143 int iid = -1;144 145 int num;146 vector<const VectorAttribute *> disks;147 148 attr_value.clear();149 150 if ( img_name.empty() || (img_name!=""IMAGE"" && img_name!=""IMAGE_ID"") )151 {152 return;153 }154 155 // ----------------------------------------------156 // Check that the image is in the template, so157 // are sure that we can access the image template158 // ----------------------------------------------159 num = vm->get_template_attribute(""DISK"", disks);160 161 for (int i=0; i < num ;i++)162 {163 if ( disks[i]->vector_value(img_name.c_str()) == img_value )164 {165 string iid_str = disks[i]->vector_value(""IMAGE_ID"");166 istringstream iss(iid_str);167 168 iss >> iid;169 170 if (iss.fail())171 {172 iid = -1;173 }174 175 break;176 }177 }178 179 if (iid == -1)180 {181 return;182 }183 184 // ----------------------------------------------185 // Get the attribute template from the image186 // ----------------------------------------------187 img = ipool->get(iid, true);188 189 if ( img == 0 )190 {191 return;192 }193 194 if (attr_name == ""TEMPLATE"")195 {196 attr_value = img->to_xml64(attr_value);197 }198 else199 {200 img->get_template_attribute(attr_name.c_str(), attr_value);201 }202 203 img->unlock();204}205 206/* -------------------------------------------------------------------------- */207/* -------------------------------------------------------------------------- */208 209void get_network_attribute(VirtualMachine * vm,210 const string& attr_name,211 const string& net_name,212 const string& net_value,213 string& attr_value)214{215 Nebula& nd = Nebula::instance();216 217 VirtualNetworkPool * vnpool = nd.get_vnpool();218 VirtualNetwork * vn;219 int ar_id, vnet_id = -1;220 221 int num;222 vector<const VectorAttribute *> nets;223 224 attr_value.clear();225 226 if ( net_name.empty() ||227 (net_name!=""NETWORK"" && net_name!=""NETWORK_ID"" && net_name!=""NIC_ID""))228 {229 return;230 }231 232 // ----------------------------------------------233 // Check that the network is in the template, so234 // are sure that we can access its template235 // ----------------------------------------------236 num = vm->get_template_attribute(""NIC"", nets);237 238 for (int i=0; i < num ;i++)239 {240 if ( nets[i]->vector_value(net_name.c_str()) == net_value )241 {242 if (nets[i]->vector_value(""NETWORK_ID"", vnet_id) != 0)243 {244 vnet_id = -1;245 }246 247 if (nets[i]->vector_value(""AR_ID"", ar_id) != 0)248 {249 vnet_id = -1;250 }251 252 break;253 }254 }255 256 if (vnet_id == -1)257 {258 return;259 }260 261 // ----------------------------------------------262 // Get the attribute template from the image263 // ----------------------------------------------264 vn = vnpool->get(vnet_id, true);265 266 if ( vn == 0 )267 {268 return;269 }270 271 if (attr_name == ""TEMPLATE"")272 {273 attr_value = vn->to_xml64(attr_value);274 }275 else276 {277 vn->get_template_attribute(attr_name.c_str(), attr_value, ar_id);278 }279 280 vn->unlock();281}282 283/* -------------------------------------------------------------------------- */284/* -------------------------------------------------------------------------- */285 286void get_user_attribute(VirtualMachine * vm,287 const string& attr_name,288 string& attr_value)289{290 Nebula& nd = Nebula::instance();291 292 UserPool * upool = nd.get_upool();293 User * user;294 295 attr_value.clear();296 297 user = upool->get(vm->get_uid(), true);298 299 if ( user == 0 )300 {301 return;302 }303 304 if (attr_name == ""TEMPLATE"")305 {306 attr_value = user->to_xml64(attr_value);307 }308 else309 {310 user->get_template_attribute(attr_name.c_str(),attr_value);311 }312 313 user->unlock();314}315 316/* -------------------------------------------------------------------------- */317/* -------------------------------------------------------------------------- */318 319void insert_single(VirtualMachine * vm,320 ostringstream& parsed,321 const string& name)322{323 string value = """";324 325 if (name == ""TEMPLATE"")326 {327 vm->to_xml64(value);328 }329 else if (name == ""UID"")330 {331 parsed << vm->get_uid();332 }333 else if (name == ""UNAME"")334 {335 parsed << vm->get_uname();336 }337 else if (name == ""GID"")338 {339 parsed << vm->get_gid();340 }341 else if (name == ""GNAME"")342 {343 parsed << vm->get_gname();344 }345 else if (name == ""NAME"")346 {347 348 parsed << vm->get_name();349 }350 else351 {352 353 vm->get_template_attribute(name.c_str(),value);354 355 if (value.empty())356 {357 vm->get_user_template_attribute(name.c_str(),value);358 }359 }360 361 if (!value.empty())362 {363 parsed << value;364 }365}366 367/* -------------------------------------------------------------------------- */368/* -------------------------------------------------------------------------- */369 370void insert_vector(VirtualMachine * vm,371 ostringstream& parsed,372 const string& name,373 const string& vname,374 const string& vvar,375 const string& vval)376 377{378 vector<const VectorAttribute*> values;379 const VectorAttribute * vattr = 0;380 381 int num;382 383 if (name == ""NETWORK"")384 {385 string value;386 387 get_network_attribute(vm,vname,vvar,vval,value);388 389 if (!value.empty())390 {391 parsed << value;392 }393 394 return;395 }396 else if (name == ""IMAGE"")397 {398 string value;399 400 get_image_attribute(vm,vname,vvar,vval,value);401 402 if (!value.empty())403 {404 parsed << value;405 }406 407 return;408 }409 else if (name == ""USER"")410 {411 string value;412 413 get_user_attribute(vm, vname, value);414 415 if (!value.empty())416 {417 parsed << value;418 }419 420 return;421 }422 else423 {424 if ( ( num = vm->get_template_attribute(name.c_str(), values) ) <= 0 )425 {426 return;427 }428 429 if ( vvar.empty() )430 {431 vattr = values[0];432 }433 else434 {435 const VectorAttribute * tmp = 0;436 437 for (int i=0 ; i < num ; i++)438 {439 if (tmp->vector_value(vvar.c_str()) == vval)440 {441 vattr = tmp;442 break;443 }444 }445 }446 447 if ( vattr != 0 )448 {449 parsed << vattr->vector_value(vname.c_str());450 }451 }452}453 454/* -------------------------------------------------------------------------- */455/* -------------------------------------------------------------------------- */456 457 458#line 458 ""vm_var_syntax.cc"" /* yacc.c:339 */459 460# ifndef YY_NULLPTR461# if defined __cplusplus && 201103L <= __cplusplus462# define YY_NULLPTR nullptr463# else464# define YY_NULLPTR 0465# endif466# endif467 468/* Enabling verbose error messages. */469#ifdef YYERROR_VERBOSE470# undef YYERROR_VERBOSE471# define YYERROR_VERBOSE 1472#else473# define YYERROR_VERBOSE 0474#endif475 476/* In a future release of Bison, this section will be replaced477 by #include ""vm_var_syntax.hh"". */478#ifndef YY_VM_VAR_VM_VAR_SYNTAX_HH_INCLUDED479# define YY_VM_VAR_VM_VAR_SYNTAX_HH_INCLUDED480/* Debug traces. */481#ifndef YYDEBUG482# define YYDEBUG 0483#endif484#if YYDEBUG485extern int vm_var__debug;486#endif487 488/* Token type. */489#ifndef YYTOKENTYPE490# define YYTOKENTYPE491 enum yytokentype492 {493 EQUAL = 258,494 COMMA = 259,495 OBRACKET = 260,496 CBRACKET = 261,497 EOA = 262,498 STRING = 263,499 VARIABLE = 264,500 RSTRING = 265,501 INTEGER = 266502 };503#endif504 505/* Value type. */506#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED507 508union YYSTYPE509{510#line 410 ""vm_var_syntax.y"" /* yacc.c:355 */511 512 char * val_str;513 int val_int;514 char val_char;515 516#line 516 ""vm_var_syntax.cc"" /* yacc.c:355 */517};518 519typedef union YYSTYPE YYSTYPE;520# define YYSTYPE_IS_TRIVIAL 1521# define YYSTYPE_IS_DECLARED 1522#endif523 524/* Location type. */525#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED526typedef struct YYLTYPE YYLTYPE;527struct YYLTYPE528{529 int first_line;530 int first_column;531 int last_line;532 int last_column;533};534# define YYLTYPE_IS_DECLARED 1535# define YYLTYPE_IS_TRIVIAL 1536#endif537 538 539 540int vm_var__parse (mem_collector * mc, VirtualMachine * vm, ostringstream * parsed, char ** errmsg);541 542#endif /* !YY_VM_VAR_VM_VAR_SYNTAX_HH_INCLUDED */543 544/* Copy the second part of user declarations. */545 546#line 546 ""vm_var_syntax.cc"" /* yacc.c:358 */547 548#ifdef short549# undef short550#endif551 552#ifdef YYTYPE_UINT8553typedef YYTYPE_UINT8 yytype_uint8;554#else555typedef unsigned char yytype_uint8;556#endif557 558#ifdef YYTYPE_INT8559typedef YYTYPE_INT8 yytype_int8;560#else561typedef signed char yytype_int8;562#endif563 564#ifdef YYTYPE_UINT16565typedef YYTYPE_UINT16 yytype_uint16;566#else567typedef unsigned short int yytype_uint16;568#endif569 570#ifdef YYTYPE_INT16571typedef YYTYPE_INT16 yytype_int16;572#else573typedef short int yytype_int16;574#endif575 576#ifndef YYSIZE_T577# ifdef __SIZE_TYPE__578# define YYSIZE_T __SIZE_TYPE__579# elif defined size_t580# define YYSIZE_T size_t581# elif ! defined YYSIZE_T582# include <stddef.h> /* INFRINGES ON USER NAME SPACE */583# define YYSIZE_T size_t584# else585# define YYSIZE_T unsigned int586# endif587#endif588 589#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)590 591#ifndef YY_592# if defined YYENABLE_NLS && YYENABLE_NLS593# if ENABLE_NLS594# include <libintl.h> /* INFRINGES ON USER NAME SPACE */595# define YY_(Msgid) dgettext (""bison-runtime"", Msgid)596# endif597# endif598# ifndef YY_599# define YY_(Msgid) Msgid600# endif601#endif602 603#ifndef YY_ATTRIBUTE604# if (defined __GNUC__ \\605 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \\606 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C607# define YY_ATTRIBUTE(Spec) __attribute__(Spec)608# else609# define YY_ATTRIBUTE(Spec) /* empty */610# endif611#endif612 613#ifndef YY_ATTRIBUTE_PURE614# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))615#endif616 617#ifndef YY_ATTRIBUTE_UNUSED618# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))619#endif620 621#if !defined _Noreturn \\622 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)623# if defined _MSC_VER && 1200 <= _MSC_VER624# define _Noreturn __declspec (noreturn)625# else626# define _Noreturn YY_ATTRIBUTE ((__noreturn__))627# endif628#endif629 630/* Suppress unused-variable warnings by ""using"" E. */631#if ! defined lint || defined __GNUC__632# define YYUSE(E) ((void) (E))633#else634# define YYUSE(E) /* empty */635#endif636 637#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__638/* Suppress an incorrect diagnostic about yylval being uninitialized. */639# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \\640 _Pragma (""GCC diagnostic push"") \\641 _Pragma (""GCC diagnostic ignored \\""-Wuninitialized\\"""")\\642 _Pragma (""GCC diagnostic ignored \\""-Wmaybe-uninitialized\\"""")643# define YY_IGNORE_MAYBE_UNINITIALIZED_END \\644 _Pragma (""GCC diagnostic pop"")645#else646# define YY_INITIAL_VALUE(Value) Value647#endif648#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN649# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN650# define YY_IGNORE_MAYBE_UNINITIALIZED_END651#endif652#ifndef YY_INITIAL_VALUE653# define YY_INITIAL_VALUE(Value) /* Nothing. */654#endif655 656 657#if ! defined yyoverflow || YYERROR_VERBOSE658 659/* The parser invokes alloca or malloc; define the necessary symbols. */660 661# ifdef YYSTACK_USE_ALLOCA662# if YYSTACK_USE_ALLOCA663# ifdef __GNUC__664# define YYSTACK_ALLOC __builtin_alloca665# elif defined __BUILTIN_VA_ARG_INCR666# include <alloca.h> /* INFRINGES ON USER NAME SPACE */667# elif defined _AIX668# define YYSTACK_ALLOC __alloca669# elif defined _MSC_VER670# include <malloc.h> /* INFRINGES ON USER NAME SPACE */671# define alloca _alloca672# else673# define YYSTACK_ALLOC alloca674# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS675# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */676 /* Use EXIT_SUCCESS as a witness for stdlib.h. */677# ifndef EXIT_SUCCESS678# define EXIT_SUCCESS 0679# endif680# endif681# endif682# endif683# endif684 685# ifdef YYSTACK_ALLOC686 /* Pacify GCC's 'empty if-body' warning. */687# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)688# ifndef YYSTACK_ALLOC_MAXIMUM689 /* The OS might guarantee only one guard page at the bottom of the stack,690 and a page size can be as small as 4096 bytes. So we cannot safely691 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number692 to allow for a few compiler-allocated temporary stack slots. */693# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */694# endif695# else696# define YYSTACK_ALLOC YYMALLOC697# define YYSTACK_FREE YYFREE698# ifndef YYSTACK_ALLOC_MAXIMUM699# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM700# endif701# if (defined __cplusplus && ! defined EXIT_SUCCESS \\702 && ! ((defined YYMALLOC || defined malloc) \\703 && (defined YYFREE || defined free)))704# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */705# ifndef EXIT_SUCCESS706# define EXIT_SUCCESS 0707# endif708# endif709# ifndef YYMALLOC710# define YYMALLOC malloc711# if ! defined malloc && ! defined EXIT_SUCCESS712void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */713# endif714# endif715# ifndef YYFREE716# define YYFREE free717# if ! defined free && ! defined EXIT_SUCCESS718void free (void *); /* INFRINGES ON USER NAME SPACE */719# endif720# endif721# endif722#endif /* ! defined yyoverflow || YYERROR_VERBOSE */723 724 725#if (! defined yyoverflow \\726 && (! defined __cplusplus \\727 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \\728 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))729 730/* A type that is properly aligned for any stack member. */731union yyalloc732{733 yytype_int16 yyss_alloc;734 YYSTYPE yyvs_alloc;735 YYLTYPE yyls_alloc;736};737 738/* The size of the maximum gap between one aligned stack and the next. */739# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)740 741/* The size of an array large to enough to hold all stacks, each with742 N elements. */743# define YYSTACK_BYTES(N) \\744 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \\745 + 2 * YYSTACK_GAP_MAXIMUM)746 747# define YYCOPY_NEEDED 1748 749/* Relocate STACK from its old location to the new one. The750 local variables YYSIZE and YYSTACKSIZE give the old and new number of751 elements in the stack, and YYPTR gives the new location of the752 stack. Advance YYPTR to a properly aligned location for the next753 stack. */754# define YYSTACK_RELOCATE(Stack_alloc, Stack) \\755 do \\756 { \\757 YYSIZE_T yynewbytes; \\758 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \\759 Stack = &yyptr->Stack_alloc; \\760 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \\761 yyptr += yynewbytes / sizeof (*yyptr); \\762 } \\763 while (0)764 765#endif766 767#if defined YYCOPY_NEEDED && YYCOPY_NEEDED768/* Copy COUNT objects from SRC to DST. The source and destination do769 not overlap. */770# ifndef YYCOPY771# if defined __GNUC__ && 1 < __GNUC__772# define YYCOPY(Dst, Src, Count) \\773 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))774# else775# define YYCOPY(Dst, Src, Count) \\776 do \\777 { \\778 YYSIZE_T yyi; \\779 for (yyi = 0; yyi < (Count); yyi++) \\780 (Dst)[yyi] = (Src)[yyi]; \\781 } \\782 while (0)783# endif784# endif785#endif /* !YYCOPY_NEEDED */786 787/* YYFINAL -- State number of the termination state. */788#define YYFINAL 7789/* YYLAST -- Last index in YYTABLE. */790#define YYLAST 18791 792/* YYNTOKENS -- Number of terminals. */793#define YYNTOKENS 12794/* YYNNTS -- Number of nonterminals. */795#define YYNNTS 3796/* YYNRULES -- Number of rules. */797#define YYNRULES 7798/* YYNSTATES -- Number of states. */799#define YYNSTATES 18800 801/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned802 by yylex, with out-of-bounds checking. */803#define YYUNDEFTOK 2804#define YYMAXUTOK 266805 806#define YYTRANSLATE(YYX) \\807 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)808 809/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM810 as returned by yylex, without out-of-bounds checking. */811static const yytype_uint8 yytranslate[] =812{813 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,814 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,815 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,816 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,817 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,818 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,819 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,820 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,821 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,822 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,823 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,824 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,825 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,826 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,827 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,828 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,829 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,830 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,831 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,832 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,833 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,834 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,835 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,836 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,837 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,838 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,839 5, 6, 7, 8, 9, 10, 11840};841 842#if YYDEBUG843 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */844static const yytype_uint16 yyrline[] =845{846 0, 434, 434, 435, 438, 442, 455, 470847};848#endif849 850#if YYDEBUG || YYERROR_VERBOSE || 0851/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.852 First, the terminals, then, starting at YYNTOKENS, nonterminals. */853static const char *const yytname[] =854{855 ""$end"", ""error"", ""$undefined"", ""EQUAL"", ""COMMA"", ""OBRACKET"", ""CBRACKET"",856 ""EOA"", ""STRING"", ""VARIABLE"", ""RSTRING"", ""INTEGER"", ""$accept"",857 ""vm_string"", ""vm_variable"", YY_NULLPTR858};859#endif860 861# ifdef YYPRINT862/* YYTOKNUM[NUM] -- (External) token number corresponding to the863 (internal) symbol number NUM (which must be that of a token). */864static const yytype_uint16 yytoknum[] =865{866 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,867 265, 266868};869# endif870 871#define YYPACT_NINF -5872 873#define yypact_value_is_default(Yystate) \\874 (!!((Yystate) == (-5)))875 876#define YYTABLE_NINF -1877 878#define yytable_value_is_error(Yytable_value) \\879 0880 881 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing882 STATE-NUM. */883static const yytype_int8 yypact[] =884{885 -3, -4, -5, 0, -5, -1, -5, -5, -5, -2,886 2, 5, 10, -5, 6, 9, 11, -5887};888 889 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.890 Performed when YYTABLE does not specify something else to do. Zero891 means the default is an error. */892static const yytype_uint8 yydefact[] =893{894 0, 0, 4, 0, 2, 0, 5, 1, 3, 0,895 0, 0, 0, 6, 0, 0, 0, 7896};897 898 /* YYPGOTO[NTERM-NUM]. */899static const yytype_int8 yypgoto[] =900{901 -5, -5, 13902};903 904 /* YYDEFGOTO[NTERM-NUM]. */905static const yytype_int8 yydefgoto[] =906{907 -1, 3, 4908};909 910 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If911 positive, shift that token. If negative, reduce the rule whose912 number is the opposite. If YYTABLE_NINF, syntax error. */913static const yytype_uint8 yytable[] =914{915 7, 5, 10, 6, 11, 0, 1, 2, 9, 1,916 2, 12, 13, 14, 15, 16, 8, 0, 17917};918 919static const yytype_int8 yycheck[] =920{921 0, 5, 4, 7, 6, -1, 9, 10, 9, 9,922 10, 9, 7, 3, 8, 6, 3, -1, 7923};924 925 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing926 symbol of state STATE-NUM. */927static const yytype_uint8 yystos[] =928{929 0, 9, 10, 13, 14, 5, 7, 0, 14, 9,930 4, 6, 9, 7, 3, 8, 6, 7931};932 933 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */934static const yytype_uint8 yyr1[] =935{936 0, 12, 13, 13, 14, 14, 14, 14937};938 939 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */940static const yytype_uint8 yyr2[] =941{942 0, 2, 1, 2, 1, 2, 5, 9943};944 945 946#define yyerrok (yyerrstatus = 0)947#define yyclearin (yychar = YYEMPTY)948#define YYEMPTY (-2)949#define YYEOF 0950 951#define YYACCEPT goto yyacceptlab952#define YYABORT goto yyabortlab953#define YYERROR goto yyerrorlab954 955 956#define YYRECOVERING() (!!yyerrstatus)957 958#define YYBACKUP(Token, Value) \\959do \\960 if (yychar == YYEMPTY) \\961 { \\962 yychar = (Token); \\963 yylval = (Value); \\964 YYPOPSTACK (yylen); \\965 yystate = *yyssp; \\966 goto yybackup; \\967 } \\968 else \\969 { \\970 yyerror (&yylloc, mc, vm, parsed, errmsg, YY_(""syntax error: cannot back up"")); \\971 YYERROR; \\972 } \\973while (0)974 975/* Error token number */976#define YYTERROR 1977#define YYERRCODE 256978 979 980/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].981 If N is 0, then set CURRENT to the empty location which ends982 the previous symbol: RHS[0] (always defined). */983 984#ifndef YYLLOC_DEFAULT985# define YYLLOC_DEFAULT(Current, Rhs, N) \\986 do \\987 if (N) \\988 { \\989 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \\990 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \\991 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \\992 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \\993 } \\994 else \\995 { \\996 (Current).first_line = (Current).last_line = \\997 YYRHSLOC (Rhs, 0).last_line; \\998 (Current).first_column = (Current).last_column = \\999 YYRHSLOC (Rhs, 0).last_column; \\1000 } \\1001 while (0)1002#endif1003 1004#define YYRHSLOC(Rhs, K) ((Rhs)[K])1005 1006 1007/* Enable debugging if requested. */1008#if YYDEBUG1009 1010# ifndef YYFPRINTF1011# include <stdio.h> /* INFRINGES ON USER NAME SPACE */1012# define YYFPRINTF fprintf1013# endif1014 1015# define YYDPRINTF(Args) \\1016do { \\1017 if (yydebug) \\1018 YYFPRINTF Args; \\1019} while (0)1020 1021 1022/* YY_LOCATION_PRINT -- Print the location on the stream.1023 This macro was not mandated originally: define only if we know1024 we won't break user code: when these are the locations we know. */1025 1026#ifndef YY_LOCATION_PRINT1027# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL1028 1029/* Print *YYLOCP on YYO. Private, do not rely on its existence. */1030 1031YY_ATTRIBUTE_UNUSED1032static unsigned1033yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)1034{1035 unsigned res = 0;1036 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;1037 if (0 <= yylocp->first_line)1038 {1039 res += YYFPRINTF (yyo, ""%d"", yylocp->first_line);1040 if (0 <= yylocp->first_column)1041 res += YYFPRINTF (yyo, "".%d"", yylocp->first_column);1042 }1043 if (0 <= yylocp->last_line)1044 {1045 if (yylocp->first_line < yylocp->last_line)1046 {1047 res += YYFPRINTF (yyo, ""-%d"", yylocp->last_line);1048 if (0 <= end_col)1049 res += YYFPRINTF (yyo, "".%d"", end_col);1050 }1051 else if (0 <= end_col && yylocp->first_column < end_col)1052 res += YYFPRINTF (yyo, ""-%d"", end_col);1053 }1054 return res;1055 }1056 1057# define YY_LOCATION_PRINT(File, Loc) \\1058 yy_location_print_ (File, &(Loc))1059 1060# else1061# define YY_LOCATION_PRINT(File, Loc) ((void) 0)1062# endif1063#endif1064 1065 1066# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \\1067do { \\1068 if (yydebug) \\1069 { \\1070 YYFPRINTF (stderr, ""%s "", Title); \\1071 yy_symbol_print (stderr, \\1072 Type, Value, Location, mc, vm, parsed, errmsg); \\1073 YYFPRINTF (stderr, ""\\n""); \\1074 } \\1075} while (0)1076 1077 1078/*----------------------------------------.1079| Print this symbol's value on YYOUTPUT. |1080`----------------------------------------*/1081 1082static void1083yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, mem_collector * mc, VirtualMachine * vm, ostringstream * parsed, char ** errmsg)1084{1085 FILE *yyo = yyoutput;1086 YYUSE (yyo);1087 YYUSE (yylocationp);1088 YYUSE (mc);1089 YYUSE (vm);1090 YYUSE (parsed);1091 YYUSE (errmsg);1092 if (!yyvaluep)1093 return;1094# ifdef YYPRINT1095 if (yytype < YYNTOKENS)1096 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);1097# endif1098 YYUSE (yytype);1099}1100 1101 1102/*--------------------------------.1103| Print this symbol on YYOUTPUT. |1104`--------------------------------*/1105 1106static void1107yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, mem_collector * mc, VirtualMachine * vm, ostringstream * parsed, char ** errmsg)1108{1109 YYFPRINTF (yyoutput, ""%s %s ("",1110 yytype < YYNTOKENS ? ""token"" : ""nterm"", yytname[yytype]);1111 1112 YY_LOCATION_PRINT (yyoutput, *yylocationp);1113 YYFPRINTF (yyoutput, "": "");1114 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, mc, vm, parsed, errmsg);1115 YYFPRINTF (yyoutput, "")"");1116}1117 1118/*------------------------------------------------------------------.1119| yy_stack_print -- Print the state stack from its BOTTOM up to its |1120| TOP (included). |1121`------------------------------------------------------------------*/1122 1123static void1124yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)1125{1126 YYFPRINTF (stderr, ""Stack now"");1127 for (; yybottom <= yytop; yybottom++)1128 {1129 int yybot = *yybottom;1130 YYFPRINTF (stderr, "" %d"", yybot);1131 }1132 YYFPRINTF (stderr, ""\\n"");1133}1134 1135# define YY_STACK_PRINT(Bottom, Top) \\1136do { \\1137 if (yydebug) \\1138 yy_stack_print ((Bottom), (Top)); \\1139} while (0)1140 1141 1142/*------------------------------------------------.1143| Report that the YYRULE is going to be reduced. |1144`------------------------------------------------*/1145 1146static void1147yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, mem_collector * mc, VirtualMachine * vm, ostringstream * parsed, char ** errmsg)1148{1149 unsigned long int yylno = yyrline[yyrule];1150 int yynrhs = yyr2[yyrule];1151 int yyi;1152 YYFPRINTF (stderr, ""Reducing stack by rule %d (line %lu):\\n"",1153 yyrule - 1, yylno);1154 /* The symbols being reduced. */1155 for (yyi = 0; yyi < yynrhs; yyi++)1156 {1157 YYFPRINTF (stderr, "" $%d = "", yyi + 1);1158 yy_symbol_print (stderr,1159 yystos[yyssp[yyi + 1 - yynrhs]],1160 &(yyvsp[(yyi + 1) - (yynrhs)])1161 , &(yylsp[(yyi + 1) - (yynrhs)]) , mc, vm, parsed, errmsg);1162 YYFPRINTF (stderr, ""\\n"");1163 }1164}1165 1166# define YY_REDUCE_PRINT(Rule) \\1167do { \\1168 if (yydebug) \\1169 yy_reduce_print (yyssp, yyvsp, yylsp, Rule, mc, vm, parsed, errmsg); \\1170} while (0)1171 1172/* Nonzero means print parse trace. It is left uninitialized so that1173 multiple parsers can coexist. */1174int yydebug;1175#else /* !YYDEBUG */1176# define YYDPRINTF(Args)1177# define YY_SYMBOL_PRINT(Title, Type, Value, Location)1178# define YY_STACK_PRINT(Bottom, Top)1179# define YY_REDUCE_PRINT(Rule)1180#endif /* !YYDEBUG */1181 1182 1183/* YYINITDEPTH -- initial size of the parser's stacks. */1184#ifndef YYINITDEPTH1185# define YYINITDEPTH 2001186#endif1187 1188/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only1189 if the built-in stack extension method is used).1190 1191 Do not make this value too large; the results are undefined if1192 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)1193 evaluated with infinite-precision integer arithmetic. */1194 1195#ifndef YYMAXDEPTH1196# define YYMAXDEPTH 100001197#endif1198 1199 1200#if YYERROR_VERBOSE