/builds/wireshark/wireshark/build/plugins/epan/mate/mate_grammar.c (2024)

1/* This file is automatically generated by Lemon from input grammar2** source file "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon". */3/* mate_grammar.lemon4 * MATE's configuration language grammar5 *6 * Copyright 2005, Luis E. Garcia Ontanon <[emailprotected]>7 *8 * Wireshark - Network traffic analyzer9 * By Gerald Combs <[emailprotected]>10 * Copyright 1998 Gerald Combs11 *12 * SPDX-License-Identifier: GPL-2.0-or-later13 */14 15/*16 * XXX - there's a Lemon bug where this grammar produces a parser that17 * fails assertions; to work around it, we disable assert() failures.18 */19#ifndef NDEBUG20#define NDEBUG21#endif22#include "config.h"23 24#include <errno(*__errno_location ()).h>25 26#include "mate.h"27#include "mate_grammar.h"28#include <wsutil/file_util.h>29#include <wsutil/str_util.h>30 31#define DUMMYvoid* void*32 33typedef struct _extraction {34char* as;35header_field_info* hfi;36struct _extraction* next;37struct _extraction* last;38} extraction_t;39 40typedef struct _pdu_criteria_t {41AVPL* criterium_avpl;42avpl_match_mode criterium_match_mode;43accept_mode_t criterium_accept_mode;44} pdu_criteria_t;45 46typedef struct _gop_options {47gop_tree_mode_t pdu_tree_mode;48bool_Bool drop_unassigned;49bool_Bool show_times;50double expiration;51double idle_timeout;52double lifetime;53AVPL* start;54AVPL* stop;55AVPL* extras;56} gop_options_t;57 58typedef struct _gog_statements {59double expiration;60gop_tree_mode_t gop_tree_mode;61GPtrArray* transform_list;62AVPL* extras;63LoAL* current_gogkeys;64} gog_statement_t;65 66typedef struct _transf_match_t {67avpl_match_mode match_mode;68AVPL* avpl;69} transf_match_t;70 71typedef struct _transf_action_t {72avpl_replace_mode replace_mode;73AVPL* avpl;74} transf_action_t;75 76static void configuration_error(mate_config* mc, const char* fmt, ...) {77static char error_buffer[256];78const char* incl;79int i;80mate_config_frame* current_frame;81va_list list;82 83va_start( list, fmt )__builtin_va_start(list, fmt);84vsnprintf(error_buffer,sizeof(error_buffer),fmt,list);85va_end( list )__builtin_va_end(list);86 87i = (int) mc->config_stack->len;88 89while (i--) {90 91if (i>0) {92incl = "\n included from: ";93} else {94incl = " ";95}96 97current_frame = (mate_config_frame *)g_ptr_array_index(mc->config_stack,(unsigned)i)((mc->config_stack)->pdata)[(unsigned)i];98 99g_string_append_printf(mc->config_error,"%s%s at line %u",incl, current_frame->filename, current_frame->linenum);100}101 102g_string_append_printf(mc->config_error,": %s\n",error_buffer);103 104THROW(MateConfigError)except_throw(1, (65535), ((void*)0));105 106}107 108static AVPL_Transf* new_transform_elem(AVPL* match, AVPL* replace, avpl_match_mode match_mode, avpl_replace_mode replace_mode) {109 AVPL_Transf* t = (AVPL_Transf *)g_malloc(sizeof(AVPL_Transf));110 111 t->name = NULL((void*)0);112 t->match = match;113 t->replace = replace;114 t->match_mode = match_mode;115 t->replace_mode = replace_mode;116 117 t->map = NULL((void*)0);118 t->next = NULL((void*)0);119 120 return t;121}122 123static char* recolonize(mate_config* mc, char* s) {124GString* str = g_string_new("");125char** vec;126char* r;127unsigned i,v;128char c;129 130vec = g_strsplit(s,":",0);131 132for (i = 0; vec[i]; i++) {133ascii_strdown_inplace(vec[i]);134 135v = 0;136switch ( strlen(vec[i]) ) {137 case 2:138c = vec[i][1];139vec[i][1] = vec[i][0];140vec[i][0] = c;141if (vec[i][0] >= '0' && vec[i][0] <= '9') {142v += (vec[i][1] - '0' )*16;143} else {144v += (vec[i][1] - 'a' + 10)*16;145}146/* FALL THROUGH */147 case 1:148if (vec[i][0] >= '0' && vec[i][0] <= '9') {149v += (vec[i][0] - '0' );150} else {151v += (vec[i][0] - 'a' + 10);152}153 case 0:154break;155 default:156configuration_error(mc,"bad token %s",s);157}158 159g_string_append_printf(str,":%.2X",v);160}161 162g_strfreev(vec);163 164g_string_erase(str,0,1);165 166r = str->str;167 168g_string_free(str,false0);169 170return r;171}172 173DIAG_OFF_LEMON()clang diagnostic push clang diagnostic ignored "-Wunreachable-code"
174#line 200 "./mate_grammar.c"175/**************** End of %include directives **********************************/176/* These constants specify the various numeric values for terminal symbols.177***************** Begin token definitions *************************************/178#ifndef TOKEN_DONE_KW1179#define TOKEN_DONE_KW1 1180#define TOKEN_SEMICOLON2 2181#define TOKEN_DEBUG_KW3 3182#define TOKEN_OPEN_BRACE4 4183#define TOKEN_CLOSE_BRACE5 5184#define TOKEN_FILENAME_KW6 6185#define TOKEN_QUOTED7 7186#define TOKEN_NAME8 8187#define TOKEN_LEVEL_KW9 9188#define TOKEN_INTEGER10 10189#define TOKEN_PDU_KW11 11190#define TOKEN_GOP_KW12 12191#define TOKEN_GOG_KW13 13192#define TOKEN_DEFAULT_KW14 14193#define TOKEN_LAST_EXTRACTED_KW15 15194#define TOKEN_DROP_UNASSIGNED_KW16 16195#define TOKEN_DISCARD_PDU_DATA_KW17 17196#define TOKEN_EXPIRATION_KW18 18197#define TOKEN_IDLE_TIMEOUT_KW19 19198#define TOKEN_LIFETIME_KW20 20199#define TOKEN_SHOW_TREE_KW21 21200#define TOKEN_SHOW_TIMES_KW22 22201#define TOKEN_GOP_TREE_KW23 23202#define TOKEN_TRANSFORM_KW24 24203#define TOKEN_MATCH_KW25 25204#define TOKEN_STRICT_KW26 26205#define TOKEN_EVERY_KW27 27206#define TOKEN_LOOSE_KW28 28207#define TOKEN_REPLACE_KW29 29208#define TOKEN_INSERT_KW30 30209#define TOKEN_PROTO_KW31 31210#define TOKEN_TRANSPORT_KW32 32211#define TOKEN_PAYLOAD_KW33 33212#define TOKEN_CRITERIA_KW34 34213#define TOKEN_ACCEPT_KW35 35214#define TOKEN_REJECT_KW36 36215#define TOKEN_EXTRACT_KW37 37216#define TOKEN_FROM_KW38 38217#define TOKEN_LAST_PDU_KW39 39218#define TOKEN_SLASH40 40219#define TOKEN_ON_KW41 41220#define TOKEN_START_KW42 42221#define TOKEN_STOP_KW43 43222#define TOKEN_NO_TREE_KW44 44223#define TOKEN_PDU_TREE_KW45 45224#define TOKEN_FRAME_TREE_KW46 46225#define TOKEN_BASIC_TREE_KW47 47226#define TOKEN_TRUE_KW48 48227#define TOKEN_FALSE_KW49 49228#define TOKEN_FLOATING50 50229#define TOKEN_NULL_TREE_KW51 51230#define TOKEN_FULL_TREE_KW52 52231#define TOKEN_MEMBER_KW53 53232#define TOKEN_EXTRA_KW54 54233#define TOKEN_COMMA55 55234#define TOKEN_OPEN_PARENS56 56235#define TOKEN_CLOSE_PARENS57 57236#define TOKEN_AVP_OPERATOR58 58237#define TOKEN_PIPE59 59238#define TOKEN_DOTED_IP60 60239#define TOKEN_COLONIZED61 61240#endif241/**************** End token definitions ***************************************/242 243/* The next sections is a series of control #defines.244** various aspects of the generated parser.245** YYCODETYPE is the data type used to store the integer codes246** that represent terminal and non-terminal symbols.247** "unsigned char" is used if there are fewer than248** 256 symbols. Larger types otherwise.249** YYNOCODE is a number of type YYCODETYPE that is not used for250** any terminal or nonterminal symbol.251** YYFALLBACK If defined, this indicates that one or more tokens252** (also known as: "terminal symbols") have fall-back253** values which should be used if the original symbol254** would not parse. This permits keywords to sometimes255** be used as identifiers, for example.256** YYACTIONTYPE is the data type used for "action codes" - numbers257** that indicate what to do in response to the next258** token.259** MateParserTOKENTYPE is the data type used for minor type for terminal260** symbols. Background: A "minor type" is a semantic261** value associated with a terminal or non-terminal262** symbols. For example, for an "ID" terminal symbol,263** the minor type might be the name of the identifier.264** Each non-terminal can have a different minor type.265** Terminal symbols all have the same minor type, though.266** This macros defines the minor type for terminal267** symbols.268** YYMINORTYPE is the data type used for all minor types.269** This is typically a union of many types, one of270** which is MateParserTOKENTYPE. The entry in the union271** for terminal symbols is called "yy0".272** YYSTACKDEPTH is the maximum depth of the parser's stack. If273** zero the stack is dynamically sized using realloc()274** MateParserARG_SDECL A static variable declaration for the %extra_argument275** MateParserARG_PDECL A parameter declaration for the %extra_argument276** MateParserARG_PARAM Code to pass %extra_argument as a subroutine parameter277** MateParserARG_STORE Code to store %extra_argument into yypParser278** MateParserARG_FETCH Code to extract %extra_argument from yypParser279** MateParserCTX_* As MateParserARG_ except for %extra_context280** YYERRORSYMBOL is the code number of the error symbol. If not281** defined, then do no error processing.282** YYNSTATE the combined number of states.283** YYNRULE the number of rules in the grammar284** YYNTOKEN Number of terminal symbols285** YY_MAX_SHIFT Maximum value for shift actions286** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions287** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions288** YY_ERROR_ACTION The yy_action[] code for syntax error289** YY_ACCEPT_ACTION The yy_action[] code for accept290** YY_NO_ACTION The yy_action[] code for no-op291** YY_MIN_REDUCE Minimum value for reduce actions292** YY_MAX_REDUCE Maximum value for reduce actions293*/294#ifndef INTERFACE1295# define INTERFACE1 1296#endif297/************* Begin control #defines *****************************************/298#define YYCODETYPEunsigned char unsigned char299#define YYNOCODE137 137300#define YYACTIONTYPEunsigned short int unsigned short int301#define MateParserTOKENTYPEchar* char* 302typedef union {303 int yyinit;304 MateParserTOKENTYPEchar* yy0;305 AVPL_Transf* yy11;306 AVPL* yy70;307 LoAL* yy77;308 transf_action_t* yy85;309 avpl_replace_mode yy143;310 transf_match_t* yy146;311 GPtrArray* yy147;312 accept_mode_t yy148;313 gop_options_t* yy155;314 extraction_t* yy179;315 header_field_info* yy210;316 bool_Bool yy219;317 AVP* yy226;318 gog_statement_t* yy229;319 pdu_criteria_t* yy231;320 double yy244;321 char* yy249;322 gop_tree_mode_t yy255;323 avpl_match_mode yy274;324} YYMINORTYPE;325#ifndef YYSTACKDEPTH100326#define YYSTACKDEPTH100 100327#endif328#define MateParserARG_SDECLmate_config* mc ; mate_config* mc ;329#define MateParserARG_PDECL, mate_config* mc , mate_config* mc 330#define MateParserARG_PARAM,mc ,mc 331#define MateParserARG_FETCHmate_config* mc =yypParser->mc ; mate_config* mc =yypParser->mc ;332#define MateParserARG_STOREyypParser->mc =mc ; yypParser->mc =mc ;333#define MateParserCTX_SDECL334#define MateParserCTX_PDECL335#define MateParserCTX_PARAM336#define MateParserCTX_FETCH337#define MateParserCTX_STORE338#define YYNSTATE183 183339#define YYNRULE149 149340#define YYNRULE_WITH_ACTION114 114341#define YYNTOKEN62 62342#define YY_MAX_SHIFT182 182343#define YY_MIN_SHIFTREDUCE287 287344#define YY_MAX_SHIFTREDUCE435 435345#define YY_ERROR_ACTION436 436346#define YY_ACCEPT_ACTION437 437347#define YY_NO_ACTION438 438348#define YY_MIN_REDUCE439 439349#define YY_MAX_REDUCE587 587350/************* End control #defines *******************************************/351#define YY_NLOOKAHEAD((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))352 353/* Define the yytestcase() macro to be a no-op if is not already defined354** otherwise.355**356** Applications can choose to define yytestcase() in the %include section357** to a macro that can assist in verifying code coverage. For production358** code the yytestcase() macro should be turned off. But it is useful359** for testing.360*/361#ifndef yytestcase362# define yytestcase(X)363#endif364 365 366/* Next are the tables used to determine what action to take based on the367** current state and lookahead token. These tables are used to implement368** functions that take a state number and lookahead value and return an369** action integer.370**371** Suppose the action integer is N. Then the action is determined as372** follows373**374** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead375** token onto the stack and goto state N.376**377** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then378** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE.379**380** N == YY_ERROR_ACTION A syntax error has occurred.381**382** N == YY_ACCEPT_ACTION The parser accepts its input.383**384** N == YY_NO_ACTION No such action. Denotes unused385** slots in the yy_action[] table.386**387** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE388** and YY_MAX_REDUCE389**390** The action table is constructed as a single large table named yy_action[].391** Given state S and lookahead X, the action is computed as either:392**393** (A) N = yy_action[ yy_shift_ofst[S] + X ]394** (B) N = yy_default[S]395**396** The (A) formula is preferred. The B formula is used instead if397** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X.398**399** The formulas above are for computing the action when the lookahead is400** a terminal symbol. If the lookahead is a non-terminal (as occurs after401** a reduce action) then the yy_reduce_ofst[] array is used in place of402** the yy_shift_ofst[] array.403**404** The following are the tables generated in this section:405**406** yy_action[] A single table containing all actions.407** yy_lookahead[] A table containing the lookahead for each entry in408** yy_action. Used to detect hash collisions.409** yy_shift_ofst[] For each state, the offset into yy_action for410** shifting terminals.411** yy_reduce_ofst[] For each state, the offset into yy_action for412** shifting non-terminals after a reduce.413** yy_default[] Default action for each state.414**415*********** Begin parsing tables **********************************************/416#define YY_ACTTAB_COUNT(309) (309)417static const YYACTIONTYPEunsigned short int yy_action[] = {418 /* 0 */ 553, 182, 554, 181, 545, 8, 460, 4, 437, 1,419 /* 10 */ 542, 138, 126, 111, 165, 546, 101, 47, 381, 395,420 /* 20 */ 396, 139, 398, 75, 141, 481, 102, 11, 527, 103,421 /* 30 */ 541, 318, 319, 315, 316, 317, 536, 306, 459, 4,422 /* 40 */ 129, 99, 70, 5, 528, 358, 359, 360, 361, 482,423 /* 50 */ 6, 554, 554, 554, 554, 554, 554, 20, 472, 366,424 /* 60 */ 374, 71, 397, 323, 372, 373, 3, 43, 50, 98,425 /* 70 */ 491, 64, 399, 400, 392, 387, 100, 491, 362, 363,426 /* 80 */ 327, 328, 74, 20, 386, 167, 166, 43, 340, 385,427 /* 90 */ 129, 107, 119, 161, 66, 157, 73, 63, 118, 365,428 /* 100 */ 106, 63, 115, 7, 116, 378, 117, 27, 105, 42,429 /* 110 */ 120, 109, 131, 19, 132, 133, 142, 143, 144, 148,430 /* 120 */ 15, 149, 150, 18, 22, 156, 151, 11, 14, 152,431 /* 130 */ 158, 16, 26, 25, 24, 23, 50, 49, 48, 364,432 /* 140 */ 44, 31, 30, 29, 102, 28, 2, 10, 146, 124,433 /* 150 */ 34, 33, 45, 52, 122, 51, 32, 46, 59, 57,434 /* 160 */ 55, 53, 54, 58, 69, 39, 67, 112, 113, 114,435 /* 170 */ 56, 135, 68, 17, 38, 140, 37, 41, 36, 35,436 /* 180 */ 123, 40, 535, 21, 162, 490, 155, 147, 127, 175,437 /* 190 */ 12, 130, 178, 136, 172, 169, 104, 462, 377, 370,438 /* 200 */ 368, 367, 110, 465, 540, 108, 9, 344, 346, 379,439 /* 210 */ 352, 354, 356, 342, 348, 350, 341, 61, 65, 62,440 /* 220 */ 121, 60, 331, 325, 125, 332, 128, 77, 334, 78,441 /* 230 */ 336, 321, 134, 13, 72, 145, 309, 83, 154, 80,442 /* 240 */ 81, 137, 305, 76, 293, 294, 90, 84, 82, 180,443 /* 250 */ 164, 91, 93, 87, 295, 95, 160, 86, 88, 94,444 /* 260 */ 418, 96, 296, 79, 297, 298, 299, 301, 423, 438,445 /* 270 */ 302, 168, 153, 85, 290, 303, 304, 291, 431, 438,446 /* 280 */ 171, 300, 159, 438, 438, 417, 89, 438, 173, 288,447 /* 290 */ 174, 163, 287, 292, 438, 289, 92, 438, 438, 176,448 /* 300 */ 438, 97, 411, 177, 410, 438, 170, 438, 179,449};450static const YYCODETYPEunsigned char yy_lookahead[] = {451 /* 0 */ 0, 1, 62, 3, 107, 64, 65, 66, 109, 110,452 /* 10 */ 107, 11, 12, 13, 14, 107, 108, 85, 2, 7,453 /* 20 */ 8, 67, 10, 69, 24, 80, 8, 24, 96, 105,454 /* 30 */ 106, 29, 30, 26, 27, 28, 98, 5, 65, 66,455 /* 40 */ 37, 103, 97, 95, 96, 44, 45, 46, 47, 80,456 /* 50 */ 81, 111, 112, 113, 114, 115, 116, 25, 56, 10,457 /* 60 */ 47, 4, 50, 2, 51, 52, 4, 53, 54, 101,458 /* 70 */ 102, 55, 60, 61, 5, 57, 101, 102, 48, 49,459 /* 80 */ 35, 36, 55, 25, 57, 7, 8, 53, 8, 8,460 /* 90 */ 37, 99, 73, 73, 68, 99, 68, 40, 74, 50,461 /* 100 */ 71, 40, 71, 56, 71, 8, 71, 22, 104, 70,462 /* 110 */ 74, 88, 74, 76, 74, 74, 74, 74, 74, 71,463 /* 120 */ 58, 71, 71, 23, 18, 71, 74, 24, 59, 74,464 /* 130 */ 74, 21, 16, 20, 19, 18, 54, 43, 42, 8,465 /* 140 */ 94, 39, 17, 16, 8, 34, 4, 33, 127, 72,466 /* 150 */ 17, 16, 93, 86, 88, 87, 15, 97, 83, 85,467 /* 160 */ 89, 91, 90, 84, 75, 22, 78, 104, 104, 104,468 /* 170 */ 97, 79, 77, 21, 16, 63, 20, 22, 19, 18,469 /* 180 */ 104, 18, 98, 23, 13, 102, 12, 11, 102, 12,470 /* 190 */ 100, 104, 13, 102, 11, 9, 6, 104, 2, 2,471 /* 200 */ 2, 2, 8, 104, 106, 5, 4, 2, 2, 2,472 /* 210 */ 2, 2, 2, 2, 2, 2, 2, 25, 38, 41,473 /* 220 */ 5, 4, 2, 2, 8, 2, 8, 126, 2, 125,474 /* 230 */ 2, 2, 5, 32, 31, 5, 2, 129, 133, 132,475 /* 240 */ 131, 8, 2, 8, 2, 2, 123, 128, 130, 121,476 /* 250 */ 124, 122, 120, 132, 2, 118, 136, 135, 134, 119,477 /* 260 */ 2, 117, 2, 4, 2, 2, 2, 2, 2, 137,478 /* 270 */ 2, 10, 5, 4, 2, 2, 2, 2, 2, 137,479 /* 280 */ 9, 2, 5, 137, 137, 2, 4, 137, 10, 2,480 /* 290 */ 9, 5, 2, 2, 137, 2, 4, 137, 137, 10,481 /* 300 */ 137, 4, 2, 9, 2, 137, 10, 137, 5, 137,482 /* 310 */ 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,483 /* 320 */ 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,484 /* 330 */ 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,485 /* 340 */ 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,486 /* 350 */ 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,487 /* 360 */ 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,488 /* 370 */ 137,489};490#define YY_SHIFT_COUNT(182) (182)491#define YY_SHIFT_MIN(0) (0)492#define YY_SHIFT_MAX(303) (303)493static const unsigned short int yy_shift_ofst[] = {494 /* 0 */ 309, 0, 58, 12, 2, 14, 3, 18, 32, 34,495 /* 10 */ 80, 81, 53, 80, 12, 12, 1, 1, 13, 7,496 /* 20 */ 7, 13, 49, 49, 49, 49, 30, 30, 45, 30,497 /* 30 */ 30, 30, 30, 30, 30, 49, 49, 49, 30, 30,498 /* 40 */ 49, 30, 47, 97, 85, 100, 106, 103, 47, 47,499 /* 50 */ 47, 85, 110, 116, 113, 115, 117, 103, 82, 94,500 /* 60 */ 96, 47, 131, 80, 81, 80, 47, 102, 125, 127,501 /* 70 */ 111, 114, 80, 47, 136, 47, 142, 133, 135, 141,502 /* 80 */ 143, 152, 158, 156, 159, 161, 155, 160, 152, 163,503 /* 90 */ 171, 174, 176, 179, 177, 183, 186, 190, 61, 16,504 /* 100 */ 57, 69, 62, 27, 78, 196, 197, 198, 199, 200,505 /* 110 */ 202, 194, 205, 206, 207, 208, 209, 210, 211, 212,506 /* 120 */ 213, 214, 215, 217, 192, 178, 216, 220, 180, 218,507 /* 130 */ 221, 223, 226, 228, 229, 227, 201, 203, 233, 234,508 /* 140 */ 240, 235, 242, 243, 252, 258, 230, 259, 260, 262,509 /* 150 */ 263, 264, 265, 266, 267, 269, 268, 273, 274, 276,510 /* 160 */ 277, 279, 282, 283, 286, 292, 287, 290, 293, 261,511 /* 170 */ 272, 296, 271, 275, 278, 281, 291, 289, 294, 300,512 /* 180 */ 303, 297, 302,513};514#define YY_REDUCE_COUNT(97) (97)515#define YY_REDUCE_MIN(-103) (-103)516#define YY_REDUCE_MAX(144) (144)517static const short yy_reduce_ofst[] = {518 /* 0 */ -101, -60, -59, -92, -46, -68, -55, -76, -27, -52,519 /* 10 */ -32, -62, -31, -25, -103, -97, 19, 20, -8, 26,520 /* 20 */ 28, -4, 29, 31, 33, 35, 24, 36, 37, 38,521 /* 30 */ 40, 41, 42, 43, 44, 48, 50, 51, 52, 55,522 /* 40 */ 54, 56, 4, 39, 23, 46, 59, 60, 63, 64,523 /* 50 */ 65, 66, 68, 67, 70, 72, 71, 73, 74, 79,524 /* 60 */ 75, 76, 77, 83, 84, 86, 87, 92, 88, 95,525 /* 70 */ 89, 90, 91, 93, 98, 99, 112, 21, 101, 104,526 /* 80 */ 105, 107, 109, 118, 108, 119, 120, 122, 121, 124,527 /* 90 */ 126, 123, 129, 128, 132, 140, 137, 144,528};529static const YYACTIONTYPEunsigned short int yy_default[] = {530 /* 0 */ 555, 436, 463, 436, 464, 532, 534, 436, 463, 436,531 /* 10 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 466,532 /* 20 */ 466, 436, 436, 436, 436, 436, 436, 436, 478, 436,533 /* 30 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,534 /* 40 */ 436, 436, 436, 436, 503, 521, 523, 534, 436, 436,535 /* 50 */ 436, 503, 501, 495, 509, 507, 505, 534, 532, 499,536 /* 60 */ 497, 436, 436, 436, 436, 436, 436, 489, 487, 485,537 /* 70 */ 476, 474, 436, 436, 436, 436, 436, 574, 573, 572,538 /* 80 */ 582, 581, 580, 579, 578, 577, 587, 586, 581, 585,539 /* 90 */ 584, 576, 571, 568, 567, 566, 565, 564, 436, 436,540 /* 100 */ 436, 436, 543, 436, 436, 436, 436, 436, 436, 436,541 /* 110 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,542 /* 120 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,543 /* 130 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,544 /* 140 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,545 /* 150 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,546 /* 160 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,547 /* 170 */ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,548 /* 180 */ 436, 436, 436,549};550/********** End of lemon-generated parsing tables *****************************/551 552/* The next table maps tokens (terminal symbols) into fallback tokens.553** If a construct like the following:554**555** %fallback ID X Y Z.556**557** appears in the grammar, then ID becomes a fallback token for X, Y,558** and Z. Whenever one of the tokens X, Y, or Z is input to the parser559** but it does not parse, the type of the token is changed to ID and560** the parse is retried before an error is thrown.561**562** This feature can be used, for example, to cause some keywords in a language563** to revert to identifiers if they keyword does not apply in the context where564** it appears.565*/566#ifdef YYFALLBACK567static const YYCODETYPEunsigned char yyFallback[] = {568};569#endif /* YYFALLBACK */570 571/* The following structure represents a single element of the572** parser's stack. Information stored includes:573**574** + The state number for the parser at this level of the stack.575**576** + The value of the token stored at this level of the stack.577** (In other words, the "major" token.)578**579** + The semantic value stored at this level of the stack. This is580** the information used by the action routines in the grammar.581** It is sometimes called the "minor" token.582**583** After the "shift" half of a SHIFTREDUCE action, the stateno field584** actually contains the reduce action for the second half of the585** SHIFTREDUCE.586*/587struct yyStackEntry {588 YYACTIONTYPEunsigned short int stateno; /* The state-number, or reduce action in SHIFTREDUCE */589 YYCODETYPEunsigned char major; /* The major token value. This is the code590 ** number for the token at this stack level */591 YYMINORTYPE minor; /* The user-supplied minor token value. This592 ** is the value of the token */593};594typedef struct yyStackEntry yyStackEntry;595 596/* The state of the parser is completely contained in an instance of597** the following structure */598struct yyParser {599 yyStackEntry *yytos; /* Pointer to top element of the stack */600#ifdef YYTRACKMAXSTACKDEPTH601 int yyhwm; /* High-water mark of the stack */602#endif603#ifndef YYNOERRORRECOVERY604 int yyerrcnt; /* Shifts left before out of the error */605#endif606 MateParserARG_SDECLmate_config* mc ; /* A place to hold %extra_argument */607 MateParserCTX_SDECL /* A place to hold %extra_context */608#if YYSTACKDEPTH100<=0609 int yystksz; /* Current side of the stack */610 yyStackEntry *yystack; /* The parser's stack */611 yyStackEntry yystk0; /* First stack entry */612#else613 yyStackEntry yystack[YYSTACKDEPTH100]; /* The parser's stack */614 yyStackEntry *yystackEnd; /* Last entry in the stack */615#endif616};617typedef struct yyParser yyParser;618 619#include <assert.h>620#ifndef NDEBUG621#include <stdio.h>622static FILE *yyTraceFILE = 0;623static char *yyTracePrompt = 0;624#endif /* NDEBUG */625 626#ifndef NDEBUG627/*628** Turn parser tracing on by giving a stream to which to write the trace629** and a prompt to preface each trace message. Tracing is turned off630** by making either argument NULL631**632** Inputs:633** <ul>634** <li> A FILE* to which trace output should be written.635** If NULL, then tracing is turned off.636** <li> A prefix string written at the beginning of every637** line of trace output. If NULL, then tracing is638** turned off.639** </ul>640**641** Outputs:642** None.643*/644void MateParserTrace(FILE *TraceFILE, char *zTracePrompt){645 yyTraceFILE = TraceFILE;646 yyTracePrompt = zTracePrompt;647 if( yyTraceFILE==0 ) yyTracePrompt = 0;648 else if( yyTracePrompt==0 ) yyTraceFILE = 0;649}650#endif /* NDEBUG */651 652#if defined(YYCOVERAGE) || !defined(NDEBUG)653/* For tracing shifts, the names of all terminals and nonterminals654** are required. The following table supplies these names */655static const char *const yyTokenName[] = {656 /* 0 */ "$",657 /* 1 */ "DONE_KW",658 /* 2 */ "SEMICOLON",659 /* 3 */ "DEBUG_KW",660 /* 4 */ "OPEN_BRACE",661 /* 5 */ "CLOSE_BRACE",662 /* 6 */ "FILENAME_KW",663 /* 7 */ "QUOTED",664 /* 8 */ "NAME",665 /* 9 */ "LEVEL_KW",666 /* 10 */ "INTEGER",667 /* 11 */ "PDU_KW",668 /* 12 */ "GOP_KW",669 /* 13 */ "GOG_KW",670 /* 14 */ "DEFAULT_KW",671 /* 15 */ "LAST_EXTRACTED_KW",672 /* 16 */ "DROP_UNASSIGNED_KW",673 /* 17 */ "DISCARD_PDU_DATA_KW",674 /* 18 */ "EXPIRATION_KW",675 /* 19 */ "IDLE_TIMEOUT_KW",676 /* 20 */ "LIFETIME_KW",677 /* 21 */ "SHOW_TREE_KW",678 /* 22 */ "SHOW_TIMES_KW",679 /* 23 */ "GOP_TREE_KW",680 /* 24 */ "TRANSFORM_KW",681 /* 25 */ "MATCH_KW",682 /* 26 */ "STRICT_KW",683 /* 27 */ "EVERY_KW",684 /* 28 */ "LOOSE_KW",685 /* 29 */ "REPLACE_KW",686 /* 30 */ "INSERT_KW",687 /* 31 */ "PROTO_KW",688 /* 32 */ "TRANSPORT_KW",689 /* 33 */ "PAYLOAD_KW",690 /* 34 */ "CRITERIA_KW",691 /* 35 */ "ACCEPT_KW",692 /* 36 */ "REJECT_KW",693 /* 37 */ "EXTRACT_KW",694 /* 38 */ "FROM_KW",695 /* 39 */ "LAST_PDU_KW",696 /* 40 */ "SLASH",697 /* 41 */ "ON_KW",698 /* 42 */ "START_KW",699 /* 43 */ "STOP_KW",700 /* 44 */ "NO_TREE_KW",701 /* 45 */ "PDU_TREE_KW",702 /* 46 */ "FRAME_TREE_KW",703 /* 47 */ "BASIC_TREE_KW",704 /* 48 */ "TRUE_KW",705 /* 49 */ "FALSE_KW",706 /* 50 */ "FLOATING",707 /* 51 */ "NULL_TREE_KW",708 /* 52 */ "FULL_TREE_KW",709 /* 53 */ "MEMBER_KW",710 /* 54 */ "EXTRA_KW",711 /* 55 */ "COMMA",712 /* 56 */ "OPEN_PARENS",713 /* 57 */ "CLOSE_PARENS",714 /* 58 */ "AVP_OPERATOR",715 /* 59 */ "PIPE",716 /* 60 */ "DOTED_IP",717 /* 61 */ "COLONIZED",718 /* 62 */ "transform_decl",719 /* 63 */ "transform_body",720 /* 64 */ "transform_statements",721 /* 65 */ "transform_statement",722 /* 66 */ "transform_match",723 /* 67 */ "transform_action",724 /* 68 */ "match_mode",725 /* 69 */ "action_mode",726 /* 70 */ "gop_name",727 /* 71 */ "time_value",728 /* 72 */ "pdu_name",729 /* 73 */ "gop_tree_mode",730 /* 74 */ "true_false",731 /* 75 */ "criteria_statement",732 /* 76 */ "accept_mode",733 /* 77 */ "pdu_drop_unassigned_statement",734 /* 78 */ "discard_pdu_data_statement",735 /* 79 */ "last_extracted_statement",736 /* 80 */ "extraction_statement",737 /* 81 */ "extraction_statements",738 /* 82 */ "gop_options",739 /* 83 */ "gop_start_statement",740 /* 84 */ "gop_stop_statement",741 /* 85 */ "extra_statement",742 /* 86 */ "gop_drop_unassigned_statement",743 /* 87 */ "show_goptree_statement",744 /* 88 */ "show_times_statement",745 /* 89 */ "gop_expiration_statement",746 /* 90 */ "idle_timeout_statement",747 /* 91 */ "lifetime_statement",748 /* 92 */ "gog_statements",749 /* 93 */ "gog_expiration_statement",750 /* 94 */ "gog_goptree_statement",751 /* 95 */ "gog_key_statements",752 /* 96 */ "gog_key_statement",753 /* 97 */ "transform_list_statement",754 /* 98 */ "transform",755 /* 99 */ "gop_tree_type",756 /* 100 */ "payload_statement",757 /* 101 */ "proto_stack",758 /* 102 */ "field",759 /* 103 */ "transform_list",760 /* 104 */ "avpl",761 /* 105 */ "avps",762 /* 106 */ "avp",763 /* 107 */ "value",764 /* 108 */ "avp_oneoff",765 /* 109 */ "mate_config",766 /* 110 */ "decls",767 /* 111 */ "decl",768 /* 112 */ "pdu_decl",769 /* 113 */ "gop_decl",770 /* 114 */ "gog_decl",771 /* 115 */ "defaults_decl",772 /* 116 */ "debug_decl",773 /* 117 */ "dbgfile_default",774 /* 118 */ "dbglevel_default",775 /* 119 */ "pdu_dbglevel_default",776 /* 120 */ "gop_dbglevel_default",777 /* 121 */ "gog_dbglevel_default",778 /* 122 */ "pdu_defaults",779 /* 123 */ "gop_defaults",780 /* 124 */ "gog_defaults",781 /* 125 */ "pdu_last_extracted_default",782 /* 126 */ "pdu_drop_unassigned_default",783 /* 127 */ "pdu_discard_default",784 /* 128 */ "gop_expiration_default",785 /* 129 */ "gop_idle_timeout_default",786 /* 130 */ "gop_lifetime_default",787 /* 131 */ "gop_drop_unassigned_default",788 /* 132 */ "gop_tree_mode_default",789 /* 133 */ "gop_show_times_default",790 /* 134 */ "gog_expiration_default",791 /* 135 */ "gog_goptree_default",792 /* 136 */ "gog_show_times_default",793};794#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */795 796#ifndef NDEBUG797/* For tracing reduce actions, the names of all rules are required.798*/799static const char *const yyRuleName[] = {800 /* 0 */ "dbgfile_default ::= FILENAME_KW QUOTED SEMICOLON",801 /* 1 */ "dbgfile_default ::= FILENAME_KW NAME SEMICOLON",802 /* 2 */ "dbglevel_default ::= LEVEL_KW INTEGER SEMICOLON",803 /* 3 */ "pdu_dbglevel_default ::= PDU_KW LEVEL_KW INTEGER SEMICOLON",804 /* 4 */ "gop_dbglevel_default ::= GOP_KW LEVEL_KW INTEGER SEMICOLON",805 /* 5 */ "gog_dbglevel_default ::= GOG_KW LEVEL_KW INTEGER SEMICOLON",806 /* 6 */ "pdu_last_extracted_default ::= LAST_EXTRACTED_KW true_false SEMICOLON",807 /* 7 */ "pdu_drop_unassigned_default ::= DROP_UNASSIGNED_KW true_false SEMICOLON",808 /* 8 */ "pdu_discard_default ::= DISCARD_PDU_DATA_KW true_false SEMICOLON",809 /* 9 */ "gop_expiration_default ::= EXPIRATION_KW time_value SEMICOLON",810 /* 10 */ "gop_idle_timeout_default ::= IDLE_TIMEOUT_KW time_value SEMICOLON",811 /* 11 */ "gop_lifetime_default ::= LIFETIME_KW time_value SEMICOLON",812 /* 12 */ "gop_drop_unassigned_default ::= DROP_UNASSIGNED_KW true_false SEMICOLON",813 /* 13 */ "gop_tree_mode_default ::= SHOW_TREE_KW gop_tree_mode SEMICOLON",814 /* 14 */ "gop_show_times_default ::= SHOW_TIMES_KW true_false SEMICOLON",815 /* 15 */ "gog_expiration_default ::= EXPIRATION_KW time_value SEMICOLON",816 /* 16 */ "gog_goptree_default ::= GOP_TREE_KW gop_tree_type SEMICOLON",817 /* 17 */ "gog_show_times_default ::= SHOW_TIMES_KW true_false SEMICOLON",818 /* 18 */ "transform_decl ::= TRANSFORM_KW NAME transform_body SEMICOLON",819 /* 19 */ "transform_body ::= OPEN_BRACE transform_statements CLOSE_BRACE",820 /* 20 */ "transform_statements ::= transform_statements transform_statement",821 /* 21 */ "transform_statements ::= transform_statement",822 /* 22 */ "transform_statement ::= transform_match transform_action SEMICOLON",823 /* 23 */ "transform_match ::= MATCH_KW match_mode avpl",824 /* 24 */ "transform_match ::=",825 /* 25 */ "transform_action ::=",826 /* 26 */ "transform_action ::= action_mode avpl",827 /* 27 */ "match_mode ::=",828 /* 28 */ "match_mode ::= STRICT_KW",829 /* 29 */ "match_mode ::= EVERY_KW",830 /* 30 */ "match_mode ::= LOOSE_KW",831 /* 31 */ "action_mode ::= REPLACE_KW",832 /* 32 */ "action_mode ::= INSERT_KW",833 /* 33 */ "action_mode ::=",834 /* 34 */ "pdu_decl ::= PDU_KW NAME PROTO_KW field TRANSPORT_KW proto_stack OPEN_BRACE payload_statement extraction_statements transform_list_statement criteria_statement pdu_drop_unassigned_statement discard_pdu_data_statement last_extracted_statement CLOSE_BRACE SEMICOLON",835 /* 35 */ "payload_statement ::=",836 /* 36 */ "payload_statement ::= PAYLOAD_KW proto_stack SEMICOLON",837 /* 37 */ "criteria_statement ::=",838 /* 38 */ "criteria_statement ::= CRITERIA_KW accept_mode match_mode avpl SEMICOLON",839 /* 39 */ "accept_mode ::=",840 /* 40 */ "accept_mode ::= ACCEPT_KW",841 /* 41 */ "accept_mode ::= REJECT_KW",842 /* 42 */ "extraction_statements ::= extraction_statements extraction_statement",843 /* 43 */ "extraction_statements ::= extraction_statement",844 /* 44 */ "extraction_statement ::= EXTRACT_KW NAME FROM_KW field SEMICOLON",845 /* 45 */ "pdu_drop_unassigned_statement ::= DROP_UNASSIGNED_KW true_false SEMICOLON",846 /* 46 */ "pdu_drop_unassigned_statement ::=",847 /* 47 */ "discard_pdu_data_statement ::= DISCARD_PDU_DATA_KW true_false SEMICOLON",848 /* 48 */ "discard_pdu_data_statement ::=",849 /* 49 */ "last_extracted_statement ::= LAST_PDU_KW true_false SEMICOLON",850 /* 50 */ "last_extracted_statement ::=",851 /* 51 */ "proto_stack ::= proto_stack SLASH field",852 /* 52 */ "proto_stack ::= field",853 /* 53 */ "field ::= NAME",854 /* 54 */ "gop_decl ::= GOP_KW NAME ON_KW pdu_name MATCH_KW avpl OPEN_BRACE gop_start_statement gop_stop_statement extra_statement transform_list_statement gop_expiration_statement idle_timeout_statement lifetime_statement gop_drop_unassigned_statement show_goptree_statement show_times_statement CLOSE_BRACE SEMICOLON",855 /* 55 */ "gop_drop_unassigned_statement ::= DROP_UNASSIGNED_KW true_false SEMICOLON",856 /* 56 */ "gop_drop_unassigned_statement ::=",857 /* 57 */ "gop_start_statement ::= START_KW avpl SEMICOLON",858 /* 58 */ "gop_start_statement ::=",859 /* 59 */ "gop_stop_statement ::= STOP_KW avpl SEMICOLON",860 /* 60 */ "gop_stop_statement ::=",861 /* 61 */ "show_goptree_statement ::= SHOW_TREE_KW gop_tree_mode SEMICOLON",862 /* 62 */ "show_goptree_statement ::=",863 /* 63 */ "show_times_statement ::= SHOW_TIMES_KW true_false SEMICOLON",864 /* 64 */ "show_times_statement ::=",865 /* 65 */ "gop_expiration_statement ::= EXPIRATION_KW time_value SEMICOLON",866 /* 66 */ "gop_expiration_statement ::=",867 /* 67 */ "idle_timeout_statement ::= IDLE_TIMEOUT_KW time_value SEMICOLON",868 /* 68 */ "idle_timeout_statement ::=",869 /* 69 */ "lifetime_statement ::= LIFETIME_KW time_value SEMICOLON",870 /* 70 */ "lifetime_statement ::=",871 /* 71 */ "gop_tree_mode ::= NO_TREE_KW",872 /* 72 */ "gop_tree_mode ::= PDU_TREE_KW",873 /* 73 */ "gop_tree_mode ::= FRAME_TREE_KW",874 /* 74 */ "gop_tree_mode ::= BASIC_TREE_KW",875 /* 75 */ "true_false ::= TRUE_KW",876 /* 76 */ "true_false ::= FALSE_KW",877 /* 77 */ "pdu_name ::= NAME",878 /* 78 */ "time_value ::= FLOATING",879 /* 79 */ "time_value ::= INTEGER",880 /* 80 */ "gog_decl ::= GOG_KW NAME OPEN_BRACE gog_key_statements extra_statement transform_list_statement gog_expiration_statement gog_goptree_statement show_times_statement CLOSE_BRACE SEMICOLON",881 /* 81 */ "gog_goptree_statement ::= GOP_TREE_KW gop_tree_type SEMICOLON",882 /* 82 */ "gog_goptree_statement ::=",883 /* 83 */ "gog_expiration_statement ::= EXPIRATION_KW time_value SEMICOLON",884 /* 84 */ "gog_expiration_statement ::=",885 /* 85 */ "gop_tree_type ::= NULL_TREE_KW",886 /* 86 */ "gop_tree_type ::= FULL_TREE_KW",887 /* 87 */ "gop_tree_type ::= BASIC_TREE_KW",888 /* 88 */ "gog_key_statements ::= gog_key_statements gog_key_statement",889 /* 89 */ "gog_key_statements ::= gog_key_statement",890 /* 90 */ "gog_key_statement ::= MEMBER_KW gop_name avpl SEMICOLON",891 /* 91 */ "gop_name ::= NAME",892 /* 92 */ "extra_statement ::= EXTRA_KW avpl SEMICOLON",893 /* 93 */ "extra_statement ::=",894 /* 94 */ "transform_list_statement ::= TRANSFORM_KW transform_list SEMICOLON",895 /* 95 */ "transform_list_statement ::=",896 /* 96 */ "transform_list ::= transform_list COMMA transform",897 /* 97 */ "transform_list ::= transform",898 /* 98 */ "transform ::= NAME",899 /* 99 */ "avpl ::= OPEN_PARENS avps CLOSE_PARENS",900 /* 100 */ "avpl ::= OPEN_PARENS CLOSE_PARENS",901 /* 101 */ "avps ::= avps COMMA avp",902 /* 102 */ "avps ::= avp",903 /* 103 */ "avp ::= NAME AVP_OPERATOR value",904 /* 104 */ "avp ::= NAME",905 /* 105 */ "avp ::= NAME OPEN_BRACE avp_oneoff CLOSE_BRACE",906 /* 106 */ "avp_oneoff ::= avp_oneoff PIPE value",907 /* 107 */ "avp_oneoff ::= value",908 /* 108 */ "value ::= QUOTED",909 /* 109 */ "value ::= NAME",910 /* 110 */ "value ::= FLOATING",911 /* 111 */ "value ::= INTEGER",912 /* 112 */ "value ::= DOTED_IP",913 /* 113 */ "value ::= COLONIZED",914 /* 114 */ "mate_config ::= decls",915 /* 115 */ "decls ::= decls decl",916 /* 116 */ "decls ::=",917 /* 117 */ "decl ::= pdu_decl",918 /* 118 */ "decl ::= gop_decl",919 /* 119 */ "decl ::= gog_decl",920 /* 120 */ "decl ::= transform_decl",921 /* 121 */ "decl ::= defaults_decl",922 /* 122 */ "decl ::= debug_decl",923 /* 123 */ "decl ::= DONE_KW SEMICOLON",924 /* 124 */ "debug_decl ::= DEBUG_KW OPEN_BRACE dbgfile_default dbglevel_default pdu_dbglevel_default gop_dbglevel_default gog_dbglevel_default CLOSE_BRACE SEMICOLON",925 /* 125 */ "dbgfile_default ::=",926 /* 126 */ "dbglevel_default ::=",927 /* 127 */ "pdu_dbglevel_default ::=",928 /* 128 */ "gop_dbglevel_default ::=",929 /* 129 */ "gog_dbglevel_default ::=",930 /* 130 */ "defaults_decl ::= DEFAULT_KW OPEN_BRACE pdu_defaults gop_defaults gog_defaults CLOSE_BRACE SEMICOLON",931 /* 131 */ "pdu_defaults ::= PDU_KW OPEN_BRACE pdu_last_extracted_default pdu_drop_unassigned_default pdu_discard_default CLOSE_BRACE SEMICOLON",932 /* 132 */ "pdu_defaults ::=",933 /* 133 */ "pdu_last_extracted_default ::=",934 /* 134 */ "pdu_drop_unassigned_default ::=",935 /* 135 */ "pdu_discard_default ::=",936 /* 136 */ "gop_defaults ::= GOP_KW OPEN_BRACE gop_expiration_default gop_idle_timeout_default gop_lifetime_default gop_drop_unassigned_default gop_tree_mode_default gop_show_times_default CLOSE_BRACE SEMICOLON",937 /* 137 */ "gop_defaults ::=",938 /* 138 */ "gop_expiration_default ::=",939 /* 139 */ "gop_idle_timeout_default ::=",940 /* 140 */ "gop_lifetime_default ::=",941 /* 141 */ "gop_drop_unassigned_default ::=",942 /* 142 */ "gop_tree_mode_default ::=",943 /* 143 */ "gop_show_times_default ::=",944 /* 144 */ "gog_defaults ::= GOG_KW OPEN_BRACE gog_expiration_default gop_tree_mode_default gog_goptree_default gog_show_times_default CLOSE_BRACE SEMICOLON",945 /* 145 */ "gog_defaults ::=",946 /* 146 */ "gog_expiration_default ::=",947 /* 147 */ "gog_goptree_default ::=",948 /* 148 */ "gog_show_times_default ::=",949};950#endif /* NDEBUG */951 952 953#if YYSTACKDEPTH100<=0954/*955** Try to increase the size of the parser stack. Return the number956** of errors. Return 0 on success.957*/958static int yyGrowStack(yyParser *p){959 int newSize;960 int idx;961 yyStackEntry *pNew;962 963 newSize = p->yystksz*2 + 100;964 idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;965 if( p->yystack==&p->yystk0 ){966 pNew = malloc(newSize*sizeof(pNew[0]));967 if( pNew ) pNew[0] = p->yystk0;968 }else{969 pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));970 }971 if( pNew ){972 p->yystack = pNew;973 p->yytos = &p->yystack[idx];974#ifndef NDEBUG975 if( yyTraceFILE ){976 fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",977 yyTracePrompt, p->yystksz, newSize);978 }979#endif980 p->yystksz = newSize;981 }982 return pNew==0;983}984#endif985 986/* Datatype of the argument to the memory allocated passed as the987** second argument to MateParserAlloc() below. This can be changed by988** putting an appropriate #define in the %include section of the input989** grammar.990*/991#ifndef YYMALLOCARGTYPEsize_t992# define YYMALLOCARGTYPEsize_t size_t993#endif994 995/* Initialize a new parser that has already been allocated.996*/997void MateParserInit(void *yypRawParser MateParserCTX_PDECL){998 yyParser *yypParser = (yyParser*)yypRawParser;999 MateParserCTX_STORE1000#ifdef YYTRACKMAXSTACKDEPTH1001 yypParser->yyhwm = 0;1002#endif1003#if YYSTACKDEPTH100<=01004 yypParser->yytos = NULL((void*)0);1005 yypParser->yystack = NULL((void*)0);1006 yypParser->yystksz = 0;1007 if( yyGrowStack(yypParser) ){1008 yypParser->yystack = &yypParser->yystk0;1009 yypParser->yystksz = 1;1010 }1011#endif1012#ifndef YYNOERRORRECOVERY1013 yypParser->yyerrcnt = -1;1014#endif1015 yypParser->yytos = yypParser->yystack;1016 yypParser->yystack[0].stateno = 0;1017 yypParser->yystack[0].major = 0;1018#if YYSTACKDEPTH100>01019 yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH100-1];1020#endif1021}1022 1023#ifndef MateParser_ENGINEALWAYSONSTACK1024/*1025** This function allocates a new parser.1026** The only argument is a pointer to a function which works like1027** malloc.1028**1029** Inputs:1030** A pointer to the function used to allocate memory.1031**1032** Outputs:1033** A pointer to a parser. This pointer is used in subsequent calls1034** to MateParser and MateParserFree.1035*/1036void *MateParserAlloc(void *(*mallocProc)(YYMALLOCARGTYPEsize_t) MateParserCTX_PDECL){1037 yyParser *yypParser;1038 yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPEsize_t)sizeof(yyParser) );1039 if( yypParser ){1040 MateParserCTX_STORE1041 MateParserInit(yypParser MateParserCTX_PARAM);1042 }1043 return (void*)yypParser;1044}1045#endif /* MateParser_ENGINEALWAYSONSTACK */1046 1047 1048/* The following function deletes the "minor type" or semantic value1049** associated with a symbol. The symbol can be either a terminal1050** or nonterminal. "yymajor" is the symbol code, and "yypminor" is1051** a pointer to the value to be deleted. The code used to do the1052** deletions is derived from the %destructor and/or %token_destructor1053** directives of the input grammar.1054*/1055static void yy_destructor(1056 yyParser *yypParser, /* The parser */1057 YYCODETYPEunsigned char yymajor, /* Type code for object to destroy */1058 YYMINORTYPE *yypminor /* The object to be destroyed */1059){1060 MateParserARG_FETCHmate_config* mc =yypParser->mc ;1061 MateParserCTX_FETCH1062 switch( yymajor ){1063 /* Here is inserted the actions which take place when a1064 ** terminal or non-terminal is destroyed. This can happen1065 ** when the symbol is popped from the stack during a1066 ** reduce or during error processing or when a parser is1067 ** being destroyed before it is finished parsing.1068 **1069 ** Note: during a reduce, the only symbols destroyed are those1070 ** which appear on the RHS of the rule, but which are *not* used1071 ** inside the C code.1072 */1073/********* Begin destructor definitions ***************************************/1074 /* TERMINAL Destructor */1075 case 1: /* DONE_KW */1076 case 2: /* SEMICOLON */1077 case 3: /* DEBUG_KW */1078 case 4: /* OPEN_BRACE */1079 case 5: /* CLOSE_BRACE */1080 case 6: /* FILENAME_KW */1081 case 7: /* QUOTED */1082 case 8: /* NAME */1083 case 9: /* LEVEL_KW */1084 case 10: /* INTEGER */1085 case 11: /* PDU_KW */1086 case 12: /* GOP_KW */1087 case 13: /* GOG_KW */1088 case 14: /* DEFAULT_KW */1089 case 15: /* LAST_EXTRACTED_KW */1090 case 16: /* DROP_UNASSIGNED_KW */1091 case 17: /* DISCARD_PDU_DATA_KW */1092 case 18: /* EXPIRATION_KW */1093 case 19: /* IDLE_TIMEOUT_KW */1094 case 20: /* LIFETIME_KW */1095 case 21: /* SHOW_TREE_KW */1096 case 22: /* SHOW_TIMES_KW */1097 case 23: /* GOP_TREE_KW */1098 case 24: /* TRANSFORM_KW */1099 case 25: /* MATCH_KW */1100 case 26: /* STRICT_KW */1101 case 27: /* EVERY_KW */1102 case 28: /* LOOSE_KW */1103 case 29: /* REPLACE_KW */1104 case 30: /* INSERT_KW */1105 case 31: /* PROTO_KW */1106 case 32: /* TRANSPORT_KW */1107 case 33: /* PAYLOAD_KW */1108 case 34: /* CRITERIA_KW */1109 case 35: /* ACCEPT_KW */1110 case 36: /* REJECT_KW */1111 case 37: /* EXTRACT_KW */1112 case 38: /* FROM_KW */1113 case 39: /* LAST_PDU_KW */1114 case 40: /* SLASH */1115 case 41: /* ON_KW */1116 case 42: /* START_KW */1117 case 43: /* STOP_KW */1118 case 44: /* NO_TREE_KW */1119 case 45: /* PDU_TREE_KW */1120 case 46: /* FRAME_TREE_KW */1121 case 47: /* BASIC_TREE_KW */1122 case 48: /* TRUE_KW */1123 case 49: /* FALSE_KW */1124 case 50: /* FLOATING */1125 case 51: /* NULL_TREE_KW */1126 case 52: /* FULL_TREE_KW */1127 case 53: /* MEMBER_KW */1128 case 54: /* EXTRA_KW */1129 case 55: /* COMMA */1130 case 56: /* OPEN_PARENS */1131 case 57: /* CLOSE_PARENS */1132 case 58: /* AVP_OPERATOR */1133 case 59: /* PIPE */1134 case 60: /* DOTED_IP */1135 case 61: /* COLONIZED */1136{1137#line 185 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1138 1139(void) mc; /* Mark unused, similar to Q_UNUSED */1140g_free((yypminor->yy0));1141 1142#line 1167 "./mate_grammar.c"1143}1144 break;1145/********* End destructor definitions *****************************************/1146 default: break; /* If no destructor action specified: do nothing */1147 }1148}1149 1150/*1151** Pop the parser's stack once.1152**1153** If there is a destructor routine associated with the token which1154** is popped from the stack, then call it.1155*/1156static void yy_pop_parser_stack(yyParser *pParser){1157 yyStackEntry *yytos;1158 assert( pParser->yytos!=0 )((void) (0));1159 assert( pParser->yytos > pParser->yystack )((void) (0));1160 yytos = pParser->yytos--;1161#ifndef NDEBUG1162 if( yyTraceFILE ){1163 fprintf(yyTraceFILE,"%sPopping %s\n",1164 yyTracePrompt,1165 yyTokenName[yytos->major]);1166 }1167#endif1168 yy_destructor(pParser, yytos->major, &yytos->minor);1169}1170 1171/*1172** Clear all secondary memory allocations from the parser1173*/1174void MateParserFinalize(void *p){1175 yyParser *pParser = (yyParser*)p;1176 while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser);1177#if YYSTACKDEPTH100<=01178 if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack);1179#endif1180}1181 1182#ifndef MateParser_ENGINEALWAYSONSTACK1183/*1184** Deallocate and destroy a parser. Destructors are called for1185** all stack elements before shutting the parser down.1186**1187** If the YYPARSEFREENEVERNULL macro exists (for example because it1188** is defined in a %include section of the input grammar) then it is1189** assumed that the input pointer is never NULL.1190*/1191void MateParserFree(1192 void *p, /* The parser to be deleted */1193 void (*freeProc)(void*) /* Function used to reclaim memory */1194){1195#ifndef YYPARSEFREENEVERNULL1196 if( p==0 ) return;1197#endif1198 MateParserFinalize(p);1199 (*freeProc)(p);1200}1201#endif /* MateParser_ENGINEALWAYSONSTACK */1202 1203/*1204** Return the peak depth of the stack for a parser.1205*/1206#ifdef YYTRACKMAXSTACKDEPTH1207int MateParserStackPeak(void *p){1208 yyParser *pParser = (yyParser*)p;1209 return pParser->yyhwm;1210}1211#endif1212 1213/* This array of booleans keeps track of the parser statement1214** coverage. The element yycoverage[X][Y] is set when the parser1215** is in state X and has a lookahead token Y. In a well-tested1216** systems, every element of this matrix should end up being set.1217*/1218#if defined(YYCOVERAGE)1219static unsigned char yycoverage[YYNSTATE183][YYNTOKEN62];1220#endif1221 1222/*1223** Write into out a description of every state/lookahead combination that1224**1225** (1) has not been used by the parser, and1226** (2) is not a syntax error.1227**1228** Return the number of missed state/lookahead combinations.1229*/1230#if defined(YYCOVERAGE)1231int MateParserCoverage(FILE *out){1232 int stateno, iLookAhead, i;1233 int nMissed = 0;1234 for(stateno=0; stateno<YYNSTATE183; stateno++){1235 i = yy_shift_ofst[stateno];1236 for(iLookAhead=0; iLookAhead<YYNTOKEN62; iLookAhead++){1237 if( yy_lookahead[i+iLookAhead]!=iLookAhead ) continue;1238 if( yycoverage[stateno][iLookAhead]==0 ) nMissed++;1239 if( out ){1240 fprintf(out,"State %d lookahead %s %s\n", stateno,1241 yyTokenName[iLookAhead],1242 yycoverage[stateno][iLookAhead] ? "ok" : "missed");1243 }1244 }1245 }1246 return nMissed;1247}1248#endif1249 1250/*1251** Find the appropriate action for a parser given the terminal1252** look-ahead token iLookAhead.1253*/1254static YYACTIONTYPEunsigned short int yy_find_shift_action(1255 YYCODETYPEunsigned char iLookAhead, /* The look-ahead token */1256 YYACTIONTYPEunsigned short int stateno /* Current state number */1257){1258 int i;1259 1260 if( stateno>YY_MAX_SHIFT182 ) return stateno;1261 assert( stateno <= YY_SHIFT_COUNT )((void) (0));1262#if defined(YYCOVERAGE)1263 yycoverage[stateno][iLookAhead] = 1;1264#endif1265 do{1266 i = yy_shift_ofst[stateno];1267 assert( i>=0 )((void) (0));1268 assert( i<=YY_ACTTAB_COUNT )((void) (0));1269 assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD )((void) (0));1270 assert( iLookAhead!=YYNOCODE )((void) (0));1271 assert( iLookAhead < YYNTOKEN )((void) (0));1272 i += iLookAhead;1273 assert( i<(int)YY_NLOOKAHEAD )((void) (0));1274 if( yy_lookahead[i]!=iLookAhead ){1275#ifdef YYFALLBACK1276 YYCODETYPEunsigned char iFallback; /* Fallback token */1277 assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) )((void) (0));1278 iFallback = yyFallback[iLookAhead];1279 if( iFallback!=0 ){1280#ifndef NDEBUG1281 if( yyTraceFILE ){1282 fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",1283 yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);1284 }1285#endif1286 assert( yyFallback[iFallback]==0 )((void) (0)); /* Fallback loop must terminate */1287 iLookAhead = iFallback;1288 continue;1289 }1290#endif1291#ifdef YYWILDCARD1292 {1293 int j = i - iLookAhead + YYWILDCARD;1294 assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) )((void) (0));1295 if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){1296#ifndef NDEBUG1297 if( yyTraceFILE ){1298 fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",1299 yyTracePrompt, yyTokenName[iLookAhead],1300 yyTokenName[YYWILDCARD]);1301 }1302#endif /* NDEBUG */1303 return yy_action[j];1304 }1305 }1306#endif /* YYWILDCARD */1307 return yy_default[stateno];1308 }else{1309 assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) )((void) (0));1310 return yy_action[i];1311 }1312 }while(1);1313}1314 1315/*1316** Find the appropriate action for a parser given the non-terminal1317** look-ahead token iLookAhead.1318*/1319static YYACTIONTYPEunsigned short int yy_find_reduce_action(1320 YYACTIONTYPEunsigned short int stateno, /* Current state number */1321 YYCODETYPEunsigned char iLookAhead /* The look-ahead token */1322){1323 int i;1324#ifdef YYERRORSYMBOL1325 if( stateno>YY_REDUCE_COUNT(97) ){1326 return yy_default[stateno];1327 }1328#else1329 assert( stateno<=YY_REDUCE_COUNT )((void) (0));1330#endif1331 i = yy_reduce_ofst[stateno];1332 assert( iLookAhead!=YYNOCODE )((void) (0));1333 i += iLookAhead;1334#ifdef YYERRORSYMBOL1335 if( i<0 || i>=YY_ACTTAB_COUNT(309) || yy_lookahead[i]!=iLookAhead ){1336 return yy_default[stateno];1337 }1338#else1339 assert( i>=0 && i<YY_ACTTAB_COUNT )((void) (0));1340 assert( yy_lookahead[i]==iLookAhead )((void) (0));1341#endif1342 return yy_action[i];1343}1344 1345/*1346** The following routine is called if the stack overflows.1347*/1348static void yyStackOverflow(yyParser *yypParser){1349 MateParserARG_FETCHmate_config* mc =yypParser->mc ;1350 MateParserCTX_FETCH1351#ifndef NDEBUG1352 if( yyTraceFILE ){1353 fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);1354 }1355#endif1356 while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);1357 /* Here code is inserted which will execute if the parser1358 ** stack every overflows */1359/******** Begin %stack_overflow code ******************************************/1360/******** End %stack_overflow code ********************************************/1361 MateParserARG_STOREyypParser->mc =mc ; /* Suppress warning about unused %extra_argument var */1362 MateParserCTX_STORE1363}1364 1365/*1366** Print tracing information for a SHIFT action1367*/1368#ifndef NDEBUG1369static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){1370 if( yyTraceFILE ){1371 if( yyNewState<YYNSTATE183 ){1372 fprintf(yyTraceFILE,"%s%s '%s', go to state %d\n",1373 yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],1374 yyNewState);1375 }else{1376 fprintf(yyTraceFILE,"%s%s '%s', pending reduce %d\n",1377 yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],1378 yyNewState - YY_MIN_REDUCE439);1379 }1380 }1381}1382#else1383# define yyTraceShift(X,Y,Z)1384#endif1385 1386/*1387** Perform a shift action.1388*/1389static void yy_shift(1390 yyParser *yypParser, /* The parser to be shifted */1391 YYACTIONTYPEunsigned short int yyNewState, /* The new state to shift in */1392 YYCODETYPEunsigned char yyMajor, /* The major token to shift in */1393 MateParserTOKENTYPEchar* yyMinor /* The minor token to shift in */1394){1395 yyStackEntry *yytos;1396 yypParser->yytos++;1397#ifdef YYTRACKMAXSTACKDEPTH1398 if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){1399 yypParser->yyhwm++;1400 assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) )((void) (0));1401 }1402#endif1403#if YYSTACKDEPTH100>01404 if( yypParser->yytos>yypParser->yystackEnd ){1405 yypParser->yytos--;1406 yyStackOverflow(yypParser);1407 return;1408 }1409#else1410 if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){1411 if( yyGrowStack(yypParser) ){1412 yypParser->yytos--;1413 yyStackOverflow(yypParser);1414 return;1415 }1416 }1417#endif1418 if( yyNewState > YY_MAX_SHIFT182 ){1419 yyNewState += YY_MIN_REDUCE439 - YY_MIN_SHIFTREDUCE287;1420 }1421 yytos = yypParser->yytos;1422 yytos->stateno = yyNewState;1423 yytos->major = yyMajor;1424 yytos->minor.yy0 = yyMinor;1425 yyTraceShift(yypParser, yyNewState, "Shift");1426}1427 1428/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side1429** of that rule */1430static const YYCODETYPEunsigned char yyRuleInfoLhs[] = {1431 117, /* (0) dbgfile_default ::= FILENAME_KW QUOTED SEMICOLON */1432 117, /* (1) dbgfile_default ::= FILENAME_KW NAME SEMICOLON */1433 118, /* (2) dbglevel_default ::= LEVEL_KW INTEGER SEMICOLON */1434 119, /* (3) pdu_dbglevel_default ::= PDU_KW LEVEL_KW INTEGER SEMICOLON */1435 120, /* (4) gop_dbglevel_default ::= GOP_KW LEVEL_KW INTEGER SEMICOLON */1436 121, /* (5) gog_dbglevel_default ::= GOG_KW LEVEL_KW INTEGER SEMICOLON */1437 125, /* (6) pdu_last_extracted_default ::= LAST_EXTRACTED_KW true_false SEMICOLON */1438 126, /* (7) pdu_drop_unassigned_default ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1439 127, /* (8) pdu_discard_default ::= DISCARD_PDU_DATA_KW true_false SEMICOLON */1440 128, /* (9) gop_expiration_default ::= EXPIRATION_KW time_value SEMICOLON */1441 129, /* (10) gop_idle_timeout_default ::= IDLE_TIMEOUT_KW time_value SEMICOLON */1442 130, /* (11) gop_lifetime_default ::= LIFETIME_KW time_value SEMICOLON */1443 131, /* (12) gop_drop_unassigned_default ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1444 132, /* (13) gop_tree_mode_default ::= SHOW_TREE_KW gop_tree_mode SEMICOLON */1445 133, /* (14) gop_show_times_default ::= SHOW_TIMES_KW true_false SEMICOLON */1446 134, /* (15) gog_expiration_default ::= EXPIRATION_KW time_value SEMICOLON */1447 135, /* (16) gog_goptree_default ::= GOP_TREE_KW gop_tree_type SEMICOLON */1448 136, /* (17) gog_show_times_default ::= SHOW_TIMES_KW true_false SEMICOLON */1449 62, /* (18) transform_decl ::= TRANSFORM_KW NAME transform_body SEMICOLON */1450 63, /* (19) transform_body ::= OPEN_BRACE transform_statements CLOSE_BRACE */1451 64, /* (20) transform_statements ::= transform_statements transform_statement */1452 64, /* (21) transform_statements ::= transform_statement */1453 65, /* (22) transform_statement ::= transform_match transform_action SEMICOLON */1454 66, /* (23) transform_match ::= MATCH_KW match_mode avpl */1455 66, /* (24) transform_match ::= */1456 67, /* (25) transform_action ::= */1457 67, /* (26) transform_action ::= action_mode avpl */1458 68, /* (27) match_mode ::= */1459 68, /* (28) match_mode ::= STRICT_KW */1460 68, /* (29) match_mode ::= EVERY_KW */1461 68, /* (30) match_mode ::= LOOSE_KW */1462 69, /* (31) action_mode ::= REPLACE_KW */1463 69, /* (32) action_mode ::= INSERT_KW */1464 69, /* (33) action_mode ::= */1465 112, /* (34) pdu_decl ::= PDU_KW NAME PROTO_KW field TRANSPORT_KW proto_stack OPEN_BRACE payload_statement extraction_statements transform_list_statement criteria_statement pdu_drop_unassigned_statement discard_pdu_data_statement last_extracted_statement CLOSE_BRACE SEMICOLON */1466 100, /* (35) payload_statement ::= */1467 100, /* (36) payload_statement ::= PAYLOAD_KW proto_stack SEMICOLON */1468 75, /* (37) criteria_statement ::= */1469 75, /* (38) criteria_statement ::= CRITERIA_KW accept_mode match_mode avpl SEMICOLON */1470 76, /* (39) accept_mode ::= */1471 76, /* (40) accept_mode ::= ACCEPT_KW */1472 76, /* (41) accept_mode ::= REJECT_KW */1473 81, /* (42) extraction_statements ::= extraction_statements extraction_statement */1474 81, /* (43) extraction_statements ::= extraction_statement */1475 80, /* (44) extraction_statement ::= EXTRACT_KW NAME FROM_KW field SEMICOLON */1476 77, /* (45) pdu_drop_unassigned_statement ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1477 77, /* (46) pdu_drop_unassigned_statement ::= */1478 78, /* (47) discard_pdu_data_statement ::= DISCARD_PDU_DATA_KW true_false SEMICOLON */1479 78, /* (48) discard_pdu_data_statement ::= */1480 79, /* (49) last_extracted_statement ::= LAST_PDU_KW true_false SEMICOLON */1481 79, /* (50) last_extracted_statement ::= */1482 101, /* (51) proto_stack ::= proto_stack SLASH field */1483 101, /* (52) proto_stack ::= field */1484 102, /* (53) field ::= NAME */1485 113, /* (54) gop_decl ::= GOP_KW NAME ON_KW pdu_name MATCH_KW avpl OPEN_BRACE gop_start_statement gop_stop_statement extra_statement transform_list_statement gop_expiration_statement idle_timeout_statement lifetime_statement gop_drop_unassigned_statement show_goptree_statement show_times_statement CLOSE_BRACE SEMICOLON */1486 86, /* (55) gop_drop_unassigned_statement ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1487 86, /* (56) gop_drop_unassigned_statement ::= */1488 83, /* (57) gop_start_statement ::= START_KW avpl SEMICOLON */1489 83, /* (58) gop_start_statement ::= */1490 84, /* (59) gop_stop_statement ::= STOP_KW avpl SEMICOLON */1491 84, /* (60) gop_stop_statement ::= */1492 87, /* (61) show_goptree_statement ::= SHOW_TREE_KW gop_tree_mode SEMICOLON */1493 87, /* (62) show_goptree_statement ::= */1494 88, /* (63) show_times_statement ::= SHOW_TIMES_KW true_false SEMICOLON */1495 88, /* (64) show_times_statement ::= */1496 89, /* (65) gop_expiration_statement ::= EXPIRATION_KW time_value SEMICOLON */1497 89, /* (66) gop_expiration_statement ::= */1498 90, /* (67) idle_timeout_statement ::= IDLE_TIMEOUT_KW time_value SEMICOLON */1499 90, /* (68) idle_timeout_statement ::= */1500 91, /* (69) lifetime_statement ::= LIFETIME_KW time_value SEMICOLON */1501 91, /* (70) lifetime_statement ::= */1502 73, /* (71) gop_tree_mode ::= NO_TREE_KW */1503 73, /* (72) gop_tree_mode ::= PDU_TREE_KW */1504 73, /* (73) gop_tree_mode ::= FRAME_TREE_KW */1505 73, /* (74) gop_tree_mode ::= BASIC_TREE_KW */1506 74, /* (75) true_false ::= TRUE_KW */1507 74, /* (76) true_false ::= FALSE_KW */1508 72, /* (77) pdu_name ::= NAME */1509 71, /* (78) time_value ::= FLOATING */1510 71, /* (79) time_value ::= INTEGER */1511 114, /* (80) gog_decl ::= GOG_KW NAME OPEN_BRACE gog_key_statements extra_statement transform_list_statement gog_expiration_statement gog_goptree_statement show_times_statement CLOSE_BRACE SEMICOLON */1512 94, /* (81) gog_goptree_statement ::= GOP_TREE_KW gop_tree_type SEMICOLON */1513 94, /* (82) gog_goptree_statement ::= */1514 93, /* (83) gog_expiration_statement ::= EXPIRATION_KW time_value SEMICOLON */1515 93, /* (84) gog_expiration_statement ::= */1516 99, /* (85) gop_tree_type ::= NULL_TREE_KW */1517 99, /* (86) gop_tree_type ::= FULL_TREE_KW */1518 99, /* (87) gop_tree_type ::= BASIC_TREE_KW */1519 95, /* (88) gog_key_statements ::= gog_key_statements gog_key_statement */1520 95, /* (89) gog_key_statements ::= gog_key_statement */1521 96, /* (90) gog_key_statement ::= MEMBER_KW gop_name avpl SEMICOLON */1522 70, /* (91) gop_name ::= NAME */1523 85, /* (92) extra_statement ::= EXTRA_KW avpl SEMICOLON */1524 85, /* (93) extra_statement ::= */1525 97, /* (94) transform_list_statement ::= TRANSFORM_KW transform_list SEMICOLON */1526 97, /* (95) transform_list_statement ::= */1527 103, /* (96) transform_list ::= transform_list COMMA transform */1528 103, /* (97) transform_list ::= transform */1529 98, /* (98) transform ::= NAME */1530 104, /* (99) avpl ::= OPEN_PARENS avps CLOSE_PARENS */1531 104, /* (100) avpl ::= OPEN_PARENS CLOSE_PARENS */1532 105, /* (101) avps ::= avps COMMA avp */1533 105, /* (102) avps ::= avp */1534 106, /* (103) avp ::= NAME AVP_OPERATOR value */1535 106, /* (104) avp ::= NAME */1536 106, /* (105) avp ::= NAME OPEN_BRACE avp_oneoff CLOSE_BRACE */1537 108, /* (106) avp_oneoff ::= avp_oneoff PIPE value */1538 108, /* (107) avp_oneoff ::= value */1539 107, /* (108) value ::= QUOTED */1540 107, /* (109) value ::= NAME */1541 107, /* (110) value ::= FLOATING */1542 107, /* (111) value ::= INTEGER */1543 107, /* (112) value ::= DOTED_IP */1544 107, /* (113) value ::= COLONIZED */1545 109, /* (114) mate_config ::= decls */1546 110, /* (115) decls ::= decls decl */1547 110, /* (116) decls ::= */1548 111, /* (117) decl ::= pdu_decl */1549 111, /* (118) decl ::= gop_decl */1550 111, /* (119) decl ::= gog_decl */1551 111, /* (120) decl ::= transform_decl */1552 111, /* (121) decl ::= defaults_decl */1553 111, /* (122) decl ::= debug_decl */1554 111, /* (123) decl ::= DONE_KW SEMICOLON */1555 116, /* (124) debug_decl ::= DEBUG_KW OPEN_BRACE dbgfile_default dbglevel_default pdu_dbglevel_default gop_dbglevel_default gog_dbglevel_default CLOSE_BRACE SEMICOLON */1556 117, /* (125) dbgfile_default ::= */1557 118, /* (126) dbglevel_default ::= */1558 119, /* (127) pdu_dbglevel_default ::= */1559 120, /* (128) gop_dbglevel_default ::= */1560 121, /* (129) gog_dbglevel_default ::= */1561 115, /* (130) defaults_decl ::= DEFAULT_KW OPEN_BRACE pdu_defaults gop_defaults gog_defaults CLOSE_BRACE SEMICOLON */1562 122, /* (131) pdu_defaults ::= PDU_KW OPEN_BRACE pdu_last_extracted_default pdu_drop_unassigned_default pdu_discard_default CLOSE_BRACE SEMICOLON */1563 122, /* (132) pdu_defaults ::= */1564 125, /* (133) pdu_last_extracted_default ::= */1565 126, /* (134) pdu_drop_unassigned_default ::= */1566 127, /* (135) pdu_discard_default ::= */1567 123, /* (136) gop_defaults ::= GOP_KW OPEN_BRACE gop_expiration_default gop_idle_timeout_default gop_lifetime_default gop_drop_unassigned_default gop_tree_mode_default gop_show_times_default CLOSE_BRACE SEMICOLON */1568 123, /* (137) gop_defaults ::= */1569 128, /* (138) gop_expiration_default ::= */1570 129, /* (139) gop_idle_timeout_default ::= */1571 130, /* (140) gop_lifetime_default ::= */1572 131, /* (141) gop_drop_unassigned_default ::= */1573 132, /* (142) gop_tree_mode_default ::= */1574 133, /* (143) gop_show_times_default ::= */1575 124, /* (144) gog_defaults ::= GOG_KW OPEN_BRACE gog_expiration_default gop_tree_mode_default gog_goptree_default gog_show_times_default CLOSE_BRACE SEMICOLON */1576 124, /* (145) gog_defaults ::= */1577 134, /* (146) gog_expiration_default ::= */1578 135, /* (147) gog_goptree_default ::= */1579 136, /* (148) gog_show_times_default ::= */1580};1581 1582/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number1583** of symbols on the right-hand side of that rule. */1584static const signed char yyRuleInfoNRhs[] = {1585 -3, /* (0) dbgfile_default ::= FILENAME_KW QUOTED SEMICOLON */1586 -3, /* (1) dbgfile_default ::= FILENAME_KW NAME SEMICOLON */1587 -3, /* (2) dbglevel_default ::= LEVEL_KW INTEGER SEMICOLON */1588 -4, /* (3) pdu_dbglevel_default ::= PDU_KW LEVEL_KW INTEGER SEMICOLON */1589 -4, /* (4) gop_dbglevel_default ::= GOP_KW LEVEL_KW INTEGER SEMICOLON */1590 -4, /* (5) gog_dbglevel_default ::= GOG_KW LEVEL_KW INTEGER SEMICOLON */1591 -3, /* (6) pdu_last_extracted_default ::= LAST_EXTRACTED_KW true_false SEMICOLON */1592 -3, /* (7) pdu_drop_unassigned_default ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1593 -3, /* (8) pdu_discard_default ::= DISCARD_PDU_DATA_KW true_false SEMICOLON */1594 -3, /* (9) gop_expiration_default ::= EXPIRATION_KW time_value SEMICOLON */1595 -3, /* (10) gop_idle_timeout_default ::= IDLE_TIMEOUT_KW time_value SEMICOLON */1596 -3, /* (11) gop_lifetime_default ::= LIFETIME_KW time_value SEMICOLON */1597 -3, /* (12) gop_drop_unassigned_default ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1598 -3, /* (13) gop_tree_mode_default ::= SHOW_TREE_KW gop_tree_mode SEMICOLON */1599 -3, /* (14) gop_show_times_default ::= SHOW_TIMES_KW true_false SEMICOLON */1600 -3, /* (15) gog_expiration_default ::= EXPIRATION_KW time_value SEMICOLON */1601 -3, /* (16) gog_goptree_default ::= GOP_TREE_KW gop_tree_type SEMICOLON */1602 -3, /* (17) gog_show_times_default ::= SHOW_TIMES_KW true_false SEMICOLON */1603 -4, /* (18) transform_decl ::= TRANSFORM_KW NAME transform_body SEMICOLON */1604 -3, /* (19) transform_body ::= OPEN_BRACE transform_statements CLOSE_BRACE */1605 -2, /* (20) transform_statements ::= transform_statements transform_statement */1606 -1, /* (21) transform_statements ::= transform_statement */1607 -3, /* (22) transform_statement ::= transform_match transform_action SEMICOLON */1608 -3, /* (23) transform_match ::= MATCH_KW match_mode avpl */1609 0, /* (24) transform_match ::= */1610 0, /* (25) transform_action ::= */1611 -2, /* (26) transform_action ::= action_mode avpl */1612 0, /* (27) match_mode ::= */1613 -1, /* (28) match_mode ::= STRICT_KW */1614 -1, /* (29) match_mode ::= EVERY_KW */1615 -1, /* (30) match_mode ::= LOOSE_KW */1616 -1, /* (31) action_mode ::= REPLACE_KW */1617 -1, /* (32) action_mode ::= INSERT_KW */1618 0, /* (33) action_mode ::= */1619 -16, /* (34) pdu_decl ::= PDU_KW NAME PROTO_KW field TRANSPORT_KW proto_stack OPEN_BRACE payload_statement extraction_statements transform_list_statement criteria_statement pdu_drop_unassigned_statement discard_pdu_data_statement last_extracted_statement CLOSE_BRACE SEMICOLON */1620 0, /* (35) payload_statement ::= */1621 -3, /* (36) payload_statement ::= PAYLOAD_KW proto_stack SEMICOLON */1622 0, /* (37) criteria_statement ::= */1623 -5, /* (38) criteria_statement ::= CRITERIA_KW accept_mode match_mode avpl SEMICOLON */1624 0, /* (39) accept_mode ::= */1625 -1, /* (40) accept_mode ::= ACCEPT_KW */1626 -1, /* (41) accept_mode ::= REJECT_KW */1627 -2, /* (42) extraction_statements ::= extraction_statements extraction_statement */1628 -1, /* (43) extraction_statements ::= extraction_statement */1629 -5, /* (44) extraction_statement ::= EXTRACT_KW NAME FROM_KW field SEMICOLON */1630 -3, /* (45) pdu_drop_unassigned_statement ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1631 0, /* (46) pdu_drop_unassigned_statement ::= */1632 -3, /* (47) discard_pdu_data_statement ::= DISCARD_PDU_DATA_KW true_false SEMICOLON */1633 0, /* (48) discard_pdu_data_statement ::= */1634 -3, /* (49) last_extracted_statement ::= LAST_PDU_KW true_false SEMICOLON */1635 0, /* (50) last_extracted_statement ::= */1636 -3, /* (51) proto_stack ::= proto_stack SLASH field */1637 -1, /* (52) proto_stack ::= field */1638 -1, /* (53) field ::= NAME */1639 -19, /* (54) gop_decl ::= GOP_KW NAME ON_KW pdu_name MATCH_KW avpl OPEN_BRACE gop_start_statement gop_stop_statement extra_statement transform_list_statement gop_expiration_statement idle_timeout_statement lifetime_statement gop_drop_unassigned_statement show_goptree_statement show_times_statement CLOSE_BRACE SEMICOLON */1640 -3, /* (55) gop_drop_unassigned_statement ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1641 0, /* (56) gop_drop_unassigned_statement ::= */1642 -3, /* (57) gop_start_statement ::= START_KW avpl SEMICOLON */1643 0, /* (58) gop_start_statement ::= */1644 -3, /* (59) gop_stop_statement ::= STOP_KW avpl SEMICOLON */1645 0, /* (60) gop_stop_statement ::= */1646 -3, /* (61) show_goptree_statement ::= SHOW_TREE_KW gop_tree_mode SEMICOLON */1647 0, /* (62) show_goptree_statement ::= */1648 -3, /* (63) show_times_statement ::= SHOW_TIMES_KW true_false SEMICOLON */1649 0, /* (64) show_times_statement ::= */1650 -3, /* (65) gop_expiration_statement ::= EXPIRATION_KW time_value SEMICOLON */1651 0, /* (66) gop_expiration_statement ::= */1652 -3, /* (67) idle_timeout_statement ::= IDLE_TIMEOUT_KW time_value SEMICOLON */1653 0, /* (68) idle_timeout_statement ::= */1654 -3, /* (69) lifetime_statement ::= LIFETIME_KW time_value SEMICOLON */1655 0, /* (70) lifetime_statement ::= */1656 -1, /* (71) gop_tree_mode ::= NO_TREE_KW */1657 -1, /* (72) gop_tree_mode ::= PDU_TREE_KW */1658 -1, /* (73) gop_tree_mode ::= FRAME_TREE_KW */1659 -1, /* (74) gop_tree_mode ::= BASIC_TREE_KW */1660 -1, /* (75) true_false ::= TRUE_KW */1661 -1, /* (76) true_false ::= FALSE_KW */1662 -1, /* (77) pdu_name ::= NAME */1663 -1, /* (78) time_value ::= FLOATING */1664 -1, /* (79) time_value ::= INTEGER */1665 -11, /* (80) gog_decl ::= GOG_KW NAME OPEN_BRACE gog_key_statements extra_statement transform_list_statement gog_expiration_statement gog_goptree_statement show_times_statement CLOSE_BRACE SEMICOLON */1666 -3, /* (81) gog_goptree_statement ::= GOP_TREE_KW gop_tree_type SEMICOLON */1667 0, /* (82) gog_goptree_statement ::= */1668 -3, /* (83) gog_expiration_statement ::= EXPIRATION_KW time_value SEMICOLON */1669 0, /* (84) gog_expiration_statement ::= */1670 -1, /* (85) gop_tree_type ::= NULL_TREE_KW */1671 -1, /* (86) gop_tree_type ::= FULL_TREE_KW */1672 -1, /* (87) gop_tree_type ::= BASIC_TREE_KW */1673 -2, /* (88) gog_key_statements ::= gog_key_statements gog_key_statement */1674 -1, /* (89) gog_key_statements ::= gog_key_statement */1675 -4, /* (90) gog_key_statement ::= MEMBER_KW gop_name avpl SEMICOLON */1676 -1, /* (91) gop_name ::= NAME */1677 -3, /* (92) extra_statement ::= EXTRA_KW avpl SEMICOLON */1678 0, /* (93) extra_statement ::= */1679 -3, /* (94) transform_list_statement ::= TRANSFORM_KW transform_list SEMICOLON */1680 0, /* (95) transform_list_statement ::= */1681 -3, /* (96) transform_list ::= transform_list COMMA transform */1682 -1, /* (97) transform_list ::= transform */1683 -1, /* (98) transform ::= NAME */1684 -3, /* (99) avpl ::= OPEN_PARENS avps CLOSE_PARENS */1685 -2, /* (100) avpl ::= OPEN_PARENS CLOSE_PARENS */1686 -3, /* (101) avps ::= avps COMMA avp */1687 -1, /* (102) avps ::= avp */1688 -3, /* (103) avp ::= NAME AVP_OPERATOR value */1689 -1, /* (104) avp ::= NAME */1690 -4, /* (105) avp ::= NAME OPEN_BRACE avp_oneoff CLOSE_BRACE */1691 -3, /* (106) avp_oneoff ::= avp_oneoff PIPE value */1692 -1, /* (107) avp_oneoff ::= value */1693 -1, /* (108) value ::= QUOTED */1694 -1, /* (109) value ::= NAME */1695 -1, /* (110) value ::= FLOATING */1696 -1, /* (111) value ::= INTEGER */1697 -1, /* (112) value ::= DOTED_IP */1698 -1, /* (113) value ::= COLONIZED */1699 -1, /* (114) mate_config ::= decls */1700 -2, /* (115) decls ::= decls decl */1701 0, /* (116) decls ::= */1702 -1, /* (117) decl ::= pdu_decl */1703 -1, /* (118) decl ::= gop_decl */1704 -1, /* (119) decl ::= gog_decl */1705 -1, /* (120) decl ::= transform_decl */1706 -1, /* (121) decl ::= defaults_decl */1707 -1, /* (122) decl ::= debug_decl */1708 -2, /* (123) decl ::= DONE_KW SEMICOLON */1709 -9, /* (124) debug_decl ::= DEBUG_KW OPEN_BRACE dbgfile_default dbglevel_default pdu_dbglevel_default gop_dbglevel_default gog_dbglevel_default CLOSE_BRACE SEMICOLON */1710 0, /* (125) dbgfile_default ::= */1711 0, /* (126) dbglevel_default ::= */1712 0, /* (127) pdu_dbglevel_default ::= */1713 0, /* (128) gop_dbglevel_default ::= */1714 0, /* (129) gog_dbglevel_default ::= */1715 -7, /* (130) defaults_decl ::= DEFAULT_KW OPEN_BRACE pdu_defaults gop_defaults gog_defaults CLOSE_BRACE SEMICOLON */1716 -7, /* (131) pdu_defaults ::= PDU_KW OPEN_BRACE pdu_last_extracted_default pdu_drop_unassigned_default pdu_discard_default CLOSE_BRACE SEMICOLON */1717 0, /* (132) pdu_defaults ::= */1718 0, /* (133) pdu_last_extracted_default ::= */1719 0, /* (134) pdu_drop_unassigned_default ::= */1720 0, /* (135) pdu_discard_default ::= */1721 -10, /* (136) gop_defaults ::= GOP_KW OPEN_BRACE gop_expiration_default gop_idle_timeout_default gop_lifetime_default gop_drop_unassigned_default gop_tree_mode_default gop_show_times_default CLOSE_BRACE SEMICOLON */1722 0, /* (137) gop_defaults ::= */1723 0, /* (138) gop_expiration_default ::= */1724 0, /* (139) gop_idle_timeout_default ::= */1725 0, /* (140) gop_lifetime_default ::= */1726 0, /* (141) gop_drop_unassigned_default ::= */1727 0, /* (142) gop_tree_mode_default ::= */1728 0, /* (143) gop_show_times_default ::= */1729 -8, /* (144) gog_defaults ::= GOG_KW OPEN_BRACE gog_expiration_default gop_tree_mode_default gog_goptree_default gog_show_times_default CLOSE_BRACE SEMICOLON */1730 0, /* (145) gog_defaults ::= */1731 0, /* (146) gog_expiration_default ::= */1732 0, /* (147) gog_goptree_default ::= */1733 0, /* (148) gog_show_times_default ::= */1734};1735 1736static void yy_accept(yyParser*); /* Forward Declaration */1737 1738/*1739** Perform a reduce action and the shift that must immediately1740** follow the reduce.1741**1742** The yyLookahead and yyLookaheadToken parameters provide reduce actions1743** access to the lookahead token (if any). The yyLookahead will be YYNOCODE1744** if the lookahead token has already been consumed. As this procedure is1745** only called from one place, optimizing compilers will in-line it, which1746** means that the extra parameters have no performance impact.1747*/1748static YYACTIONTYPEunsigned short int yy_reduce(1749 yyParser *yypParser, /* The parser */1750 unsigned int yyruleno, /* Number of the rule by which to reduce */1751 int yyLookahead, /* Lookahead token, or YYNOCODE if none */1752 MateParserTOKENTYPEchar* yyLookaheadToken /* Value of the lookahead token */1753 MateParserCTX_PDECL /* %extra_context */1754){1755 int yygoto; /* The next state */1756 YYACTIONTYPEunsigned short int yyact; /* The next action */1757 yyStackEntry *yymsp; /* The top of the parser's stack */1758 int yysize; /* Amount to pop the stack */1759 MateParserARG_FETCHmate_config* mc =yypParser->mc ;1760 (void)yyLookahead;1761 (void)yyLookaheadToken;1762 yymsp = yypParser->yytos;1763 1764 switch( yyruleno ){1765 /* Beginning here are the reduction cases. A typical example1766 ** follows:1767 ** case 0:1768 ** #line <lineno> <grammarfile>1769 ** { ... } // User supplied code1770 ** #line <lineno> <thisfile>1771 ** break;1772 */1773/********** Begin reduce actions **********************************************/1774 YYMINORTYPE yylhsminor;1775 case 0: /* dbgfile_default ::= FILENAME_KW QUOTED SEMICOLON */1776{ yy_destructor(yypParser,6,&yymsp[-2].minor);1777#line 274 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1778{ mc->dbg_facility = ws_fopenfopen(yymsp[-1].minor.yy0,"w"); if (mc->dbg_facility == NULL((void*)0)) report_open_failure(yymsp[-1].minor.yy0,errno(*__errno_location ()),true1); }1779#line 1804 "./mate_grammar.c"1780 yy_destructor(yypParser,2,&yymsp[0].minor);1781}1782 break;1783 case 1: /* dbgfile_default ::= FILENAME_KW NAME SEMICOLON */1784{ yy_destructor(yypParser,6,&yymsp[-2].minor);1785#line 275 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1786{ mc->dbg_facility = ws_fopenfopen(yymsp[-1].minor.yy0,"w"); if (mc->dbg_facility == NULL((void*)0)) report_open_failure(yymsp[-1].minor.yy0,errno(*__errno_location ()),true1); }1787#line 1812 "./mate_grammar.c"1788 yy_destructor(yypParser,2,&yymsp[0].minor);1789}1790 break;1791 case 2: /* dbglevel_default ::= LEVEL_KW INTEGER SEMICOLON */1792{ yy_destructor(yypParser,9,&yymsp[-2].minor);1793#line 278 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1794{ mc->dbg_lvl = (int) strtol(yymsp[-1].minor.yy0,NULL((void*)0),10); }1795#line 1820 "./mate_grammar.c"1796 yy_destructor(yypParser,2,&yymsp[0].minor);1797}1798 break;1799 case 3: /* pdu_dbglevel_default ::= PDU_KW LEVEL_KW INTEGER SEMICOLON */1800{ yy_destructor(yypParser,11,&yymsp[-3].minor);1801#line 281 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1802{ mc->dbg_pdu_lvl = (int) strtol(yymsp[-1].minor.yy0,NULL((void*)0),10); }1803#line 1828 "./mate_grammar.c"1804 yy_destructor(yypParser,9,&yymsp[-2].minor);1805 yy_destructor(yypParser,2,&yymsp[0].minor);1806}1807 break;1808 case 4: /* gop_dbglevel_default ::= GOP_KW LEVEL_KW INTEGER SEMICOLON */1809{ yy_destructor(yypParser,12,&yymsp[-3].minor);1810#line 284 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1811{ mc->dbg_gop_lvl = (int) strtol(yymsp[-1].minor.yy0,NULL((void*)0),10); }1812#line 1837 "./mate_grammar.c"1813 yy_destructor(yypParser,9,&yymsp[-2].minor);1814 yy_destructor(yypParser,2,&yymsp[0].minor);1815}1816 break;1817 case 5: /* gog_dbglevel_default ::= GOG_KW LEVEL_KW INTEGER SEMICOLON */1818{ yy_destructor(yypParser,13,&yymsp[-3].minor);1819#line 287 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1820{ mc->dbg_gog_lvl = (int) strtol(yymsp[-1].minor.yy0,NULL((void*)0),10); }1821#line 1846 "./mate_grammar.c"1822 yy_destructor(yypParser,9,&yymsp[-2].minor);1823 yy_destructor(yypParser,2,&yymsp[0].minor);1824}1825 break;1826 case 6: /* pdu_last_extracted_default ::= LAST_EXTRACTED_KW true_false SEMICOLON */1827{ yy_destructor(yypParser,15,&yymsp[-2].minor);1828#line 299 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1829{ mc->defaults.pdu.last_extracted = yymsp[-1].minor.yy219; }1830#line 1855 "./mate_grammar.c"1831 yy_destructor(yypParser,2,&yymsp[0].minor);1832}1833 break;1834 case 7: /* pdu_drop_unassigned_default ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1835{ yy_destructor(yypParser,16,&yymsp[-2].minor);1836#line 302 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1837{ mc->defaults.pdu.drop_unassigned = yymsp[-1].minor.yy219; }1838#line 1863 "./mate_grammar.c"1839 yy_destructor(yypParser,2,&yymsp[0].minor);1840}1841 break;1842 case 8: /* pdu_discard_default ::= DISCARD_PDU_DATA_KW true_false SEMICOLON */1843{ yy_destructor(yypParser,17,&yymsp[-2].minor);1844#line 305 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1845{ mc->defaults.pdu.discard = yymsp[-1].minor.yy219; }1846#line 1871 "./mate_grammar.c"1847 yy_destructor(yypParser,2,&yymsp[0].minor);1848}1849 break;1850 case 9: /* gop_expiration_default ::= EXPIRATION_KW time_value SEMICOLON */1851 case 15: /* gog_expiration_default ::= EXPIRATION_KW time_value SEMICOLON */ yytestcase(yyruleno==15);1852{ yy_destructor(yypParser,18,&yymsp[-2].minor);1853#line 311 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1854{ mc->defaults.gop.expiration = yymsp[-1].minor.yy244; }1855#line 1880 "./mate_grammar.c"1856 yy_destructor(yypParser,2,&yymsp[0].minor);1857}1858 break;1859 case 10: /* gop_idle_timeout_default ::= IDLE_TIMEOUT_KW time_value SEMICOLON */1860{ yy_destructor(yypParser,19,&yymsp[-2].minor);1861#line 314 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1862{ mc->defaults.gop.idle_timeout = yymsp[-1].minor.yy244; }1863#line 1888 "./mate_grammar.c"1864 yy_destructor(yypParser,2,&yymsp[0].minor);1865}1866 break;1867 case 11: /* gop_lifetime_default ::= LIFETIME_KW time_value SEMICOLON */1868{ yy_destructor(yypParser,20,&yymsp[-2].minor);1869#line 317 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1870{ mc->defaults.gop.lifetime = yymsp[-1].minor.yy244; }1871#line 1896 "./mate_grammar.c"1872 yy_destructor(yypParser,2,&yymsp[0].minor);1873}1874 break;1875 case 12: /* gop_drop_unassigned_default ::= DROP_UNASSIGNED_KW true_false SEMICOLON */1876{ yy_destructor(yypParser,16,&yymsp[-2].minor);1877#line 320 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1878{ mc->defaults.gop.drop_unassigned = yymsp[-1].minor.yy219; }1879#line 1904 "./mate_grammar.c"1880 yy_destructor(yypParser,2,&yymsp[0].minor);1881}1882 break;1883 case 13: /* gop_tree_mode_default ::= SHOW_TREE_KW gop_tree_mode SEMICOLON */1884{ yy_destructor(yypParser,21,&yymsp[-2].minor);1885#line 323 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1886{ mc->defaults.gop.pdu_tree_mode = (gop_pdu_tree_t)yymsp[-1].minor.yy255; }1887#line 1912 "./mate_grammar.c"1888 yy_destructor(yypParser,2,&yymsp[0].minor);1889}1890 break;1891 case 14: /* gop_show_times_default ::= SHOW_TIMES_KW true_false SEMICOLON */1892{ yy_destructor(yypParser,22,&yymsp[-2].minor);1893#line 326 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1894{ mc->defaults.gop.show_times = yymsp[-1].minor.yy219; }1895#line 1920 "./mate_grammar.c"1896 yy_destructor(yypParser,2,&yymsp[0].minor);1897}1898 break;1899 case 16: /* gog_goptree_default ::= GOP_TREE_KW gop_tree_type SEMICOLON */1900{ yy_destructor(yypParser,23,&yymsp[-2].minor);1901#line 335 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1902{ mc->defaults.gog.gop_tree_mode = yymsp[-1].minor.yy255; }1903#line 1928 "./mate_grammar.c"1904 yy_destructor(yypParser,2,&yymsp[0].minor);1905}1906 break;1907 case 17: /* gog_show_times_default ::= SHOW_TIMES_KW true_false SEMICOLON */1908{ yy_destructor(yypParser,22,&yymsp[-2].minor);1909#line 338 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1910{ mc->defaults.gog.show_times = yymsp[-1].minor.yy219; }1911#line 1936 "./mate_grammar.c"1912 yy_destructor(yypParser,2,&yymsp[0].minor);1913}1914 break;1915 case 18: /* transform_decl ::= TRANSFORM_KW NAME transform_body SEMICOLON */1916{ yy_destructor(yypParser,24,&yymsp[-3].minor);1917#line 345 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1918{1919AVPL_Transf* c;1920 1921if ( g_hash_table_lookup(mc->transfs,yymsp[-2].minor.yy0) ) {1922configuration_error(mc,"yymsp[-3].minor.yy11 transformation called '%s' exists already",yymsp[-2].minor.yy0);1923}1924 1925for ( c = yymsp[-1].minor.yy11; c; c = c->next )1926c->name = g_strdup(yymsp[-2].minor.yy0);1927 1928g_hash_table_insert(mc->transfs,yymsp[-1].minor.yy11->name,yymsp[-1].minor.yy11);1929 1930yymsp[-3].minor.yy11 = NULL((void*)0);1931}1932#line 1957 "./mate_grammar.c"1933 yy_destructor(yypParser,2,&yymsp[0].minor);1934}1935 break;1936 case 19: /* transform_body ::= OPEN_BRACE transform_statements CLOSE_BRACE */1937{ yy_destructor(yypParser,4,&yymsp[-2].minor);1938#line 360 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1939{ yymsp[-2].minor.yy11 = yymsp[-1].minor.yy11; }1940#line 1965 "./mate_grammar.c"1941 yy_destructor(yypParser,5,&yymsp[0].minor);1942}1943 break;1944 case 20: /* transform_statements ::= transform_statements transform_statement */1945#line 362 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1946{1947AVPL_Transf* c;1948 1949for ( c = yymsp[-1].minor.yy11; c->next; c = c->next ) ;1950c->next = yymsp[0].minor.yy11;1951yylhsminor.yy11 = yymsp[-1].minor.yy11;1952}1953#line 1978 "./mate_grammar.c"1954 yymsp[-1].minor.yy11 = yylhsminor.yy11;1955 break;1956 case 21: /* transform_statements ::= transform_statement */1957#line 370 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1958{ yylhsminor.yy11 = yymsp[0].minor.yy11; }1959#line 1984 "./mate_grammar.c"1960 yymsp[0].minor.yy11 = yylhsminor.yy11;1961 break;1962 case 22: /* transform_statement ::= transform_match transform_action SEMICOLON */1963#line 372 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1964{1965yylhsminor.yy11 = new_transform_elem(yymsp[-2].minor.yy146->avpl,yymsp[-1].minor.yy85->avpl,yymsp[-2].minor.yy146->match_mode,yymsp[-1].minor.yy85->replace_mode);1966}1967#line 1992 "./mate_grammar.c"1968 yy_destructor(yypParser,2,&yymsp[0].minor);1969 yymsp[-2].minor.yy11 = yylhsminor.yy11;1970 break;1971 case 23: /* transform_match ::= MATCH_KW match_mode avpl */1972{ yy_destructor(yypParser,25,&yymsp[-2].minor);1973#line 376 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1974{1975yymsp[-2].minor.yy146 = (transf_match_t *)g_malloc(sizeof(transf_match_t));1976yymsp[-2].minor.yy146->match_mode = yymsp[-1].minor.yy274;1977yymsp[-2].minor.yy146->avpl = yymsp[0].minor.yy70;1978}1979#line 2004 "./mate_grammar.c"1980}1981 break;1982 case 24: /* transform_match ::= */1983#line 382 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1984{1985yymsp[1].minor.yy146 = (transf_match_t *)g_malloc(sizeof(transf_match_t));1986yymsp[1].minor.yy146->match_mode = AVPL_STRICT;1987yymsp[1].minor.yy146->avpl = new_avpl("");1988 1989}1990#line 2015 "./mate_grammar.c"1991 break;1992 case 25: /* transform_action ::= */1993#line 389 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"1994{1995yymsp[1].minor.yy85 = (transf_action_t *)g_malloc(sizeof(transf_action_t));1996yymsp[1].minor.yy85->replace_mode = AVPL_INSERT;1997yymsp[1].minor.yy85->avpl = new_avpl("");1998}1999#line 2024 "./mate_grammar.c"2000 break;2001 case 26: /* transform_action ::= action_mode avpl */2002#line 394 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2003{2004yylhsminor.yy85 = (transf_action_t *)g_malloc(sizeof(transf_action_t));2005yylhsminor.yy85->replace_mode = yymsp[-1].minor.yy143;2006yylhsminor.yy85->avpl = yymsp[0].minor.yy70;2007}2008#line 2033 "./mate_grammar.c"2009 yymsp[-1].minor.yy85 = yylhsminor.yy85;2010 break;2011 case 27: /* match_mode ::= */2012#line 400 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2013{ yymsp[1].minor.yy274 = AVPL_STRICT; }2014#line 2039 "./mate_grammar.c"2015 break;2016 case 28: /* match_mode ::= STRICT_KW */2017{ yy_destructor(yypParser,26,&yymsp[0].minor);2018#line 401 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2019{ yymsp[0].minor.yy274 = AVPL_STRICT; }2020#line 2045 "./mate_grammar.c"2021}2022 break;2023 case 29: /* match_mode ::= EVERY_KW */2024{ yy_destructor(yypParser,27,&yymsp[0].minor);2025#line 402 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2026{ yymsp[0].minor.yy274 = AVPL_EVERY; }2027#line 2052 "./mate_grammar.c"2028}2029 break;2030 case 30: /* match_mode ::= LOOSE_KW */2031{ yy_destructor(yypParser,28,&yymsp[0].minor);2032#line 403 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2033{ yymsp[0].minor.yy274 = AVPL_LOOSE; }2034#line 2059 "./mate_grammar.c"2035}2036 break;2037 case 31: /* action_mode ::= REPLACE_KW */2038{ yy_destructor(yypParser,29,&yymsp[0].minor);2039#line 405 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2040{ yymsp[0].minor.yy143 = AVPL_REPLACE; }2041#line 2066 "./mate_grammar.c"2042}2043 break;2044 case 32: /* action_mode ::= INSERT_KW */2045{ yy_destructor(yypParser,30,&yymsp[0].minor);2046#line 406 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2047{ yymsp[0].minor.yy143 = AVPL_INSERT; }2048#line 2073 "./mate_grammar.c"2049}2050 break;2051 case 33: /* action_mode ::= */2052#line 407 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2053{ yymsp[1].minor.yy143 = AVPL_INSERT; }2054#line 2079 "./mate_grammar.c"2055 break;2056 case 34: /* pdu_decl ::= PDU_KW NAME PROTO_KW field TRANSPORT_KW proto_stack OPEN_BRACE payload_statement extraction_statements transform_list_statement criteria_statement pdu_drop_unassigned_statement discard_pdu_data_statement last_extracted_statement CLOSE_BRACE SEMICOLON */2057{ yy_destructor(yypParser,11,&yymsp[-15].minor);2058#line 423 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2059{2060 2061mate_cfg_pdu* cfg = new_pducfg(mc, yymsp[-14].minor.yy0);2062extraction_t *extraction, *next_extraction;2063GPtrArray* transport_stack = g_ptr_array_new();2064int i;2065 2066if (! cfg ) configuration_error(mc,"could not create Pdu %s.",yymsp[-14].minor.yy0);2067 2068cfg->hfid_proto = yymsp[-12].minor.yy210->id;2069 2070cfg->last_extracted = yymsp[-2].minor.yy219;2071cfg->discard = yymsp[-3].minor.yy219;2072cfg->drop_unassigned = yymsp[-4].minor.yy219;2073 2074/*2075 * Add this protocol to our table of wanted hfids.2076 */2077mc->wanted_hfids = g_array_append_val(mc->wanted_hfids, yymsp[-12].minor.yy210->id)g_array_append_vals (mc->wanted_hfids, &(yymsp[-12].minor
.yy210->id), 1);2078 2079/* flip the transport_stack */2080for (i = yymsp[-10].minor.yy147->len - 1; yymsp[-10].minor.yy147->len; i--) {2081g_ptr_array_add(transport_stack,g_ptr_array_remove_index(yymsp[-10].minor.yy147,i));2082}2083 2084g_ptr_array_free(yymsp[-10].minor.yy147, true1);2085 2086cfg->transport_ranges = transport_stack;2087cfg->payload_ranges = yymsp[-8].minor.yy147;2088 2089if (yymsp[-5].minor.yy231) {2090cfg->criterium = yymsp[-5].minor.yy231->criterium_avpl;2091cfg->criterium_match_mode = yymsp[-5].minor.yy231->criterium_match_mode;2092cfg->criterium_accept_mode = yymsp[-5].minor.yy231->criterium_accept_mode;2093}2094 2095cfg->transforms = yymsp[-6].minor.yy147;2096 2097for (extraction = yymsp[-7].minor.yy179; extraction; extraction = next_extraction) {2098next_extraction = extraction->next;2099 2100if ( ! add_hfid(mc, extraction->hfi, extraction->as, cfg->hfids_attr) ) {2101configuration_error(mc,"MATE: failed to create extraction rule '%s'",extraction->as);2102}2103 2104g_free(extraction);2105}2106}2107#line 2132 "./mate_grammar.c"2108 yy_destructor(yypParser,31,&yymsp[-13].minor);2109 yy_destructor(yypParser,32,&yymsp[-11].minor);2110 yy_destructor(yypParser,4,&yymsp[-9].minor);2111 yy_destructor(yypParser,5,&yymsp[-1].minor);2112 yy_destructor(yypParser,2,&yymsp[0].minor);2113}2114 break;2115 case 35: /* payload_statement ::= */2116#line 472 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2117{ yymsp[1].minor.yy147 = NULL((void*)0); }2118#line 2143 "./mate_grammar.c"2119 break;2120 case 36: /* payload_statement ::= PAYLOAD_KW proto_stack SEMICOLON */2121{ yy_destructor(yypParser,33,&yymsp[-2].minor);2122#line 473 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2123{ yymsp[-2].minor.yy147 = yymsp[-1].minor.yy147; }2124#line 2149 "./mate_grammar.c"2125 yy_destructor(yypParser,2,&yymsp[0].minor);2126}2127 break;2128 case 37: /* criteria_statement ::= */2129#line 475 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2130{ yymsp[1].minor.yy231 = NULL((void*)0); }2131#line 2156 "./mate_grammar.c"2132 break;2133 case 38: /* criteria_statement ::= CRITERIA_KW accept_mode match_mode avpl SEMICOLON */2134{ yy_destructor(yypParser,34,&yymsp[-4].minor);2135#line 476 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2136{2137yymsp[-4].minor.yy231 = g_new(pdu_criteria_t, 1)((pdu_criteria_t *) g_malloc_n ((1), sizeof (pdu_criteria_t))
);2138yymsp[-4].minor.yy231->criterium_avpl = yymsp[-1].minor.yy70;2139yymsp[-4].minor.yy231->criterium_match_mode = yymsp[-2].minor.yy274;2140yymsp[-4].minor.yy231->criterium_accept_mode = yymsp[-3].minor.yy148;2141}2142#line 2167 "./mate_grammar.c"2143 yy_destructor(yypParser,2,&yymsp[0].minor);2144}2145 break;2146 case 39: /* accept_mode ::= */2147#line 483 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2148{ yymsp[1].minor.yy148 = ACCEPT_MODE; }2149#line 2174 "./mate_grammar.c"2150 break;2151 case 40: /* accept_mode ::= ACCEPT_KW */2152{ yy_destructor(yypParser,35,&yymsp[0].minor);2153#line 484 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2154{ yymsp[0].minor.yy148 = ACCEPT_MODE; }2155#line 2180 "./mate_grammar.c"2156}2157 break;2158 case 41: /* accept_mode ::= REJECT_KW */2159{ yy_destructor(yypParser,36,&yymsp[0].minor);2160#line 485 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2161{ yymsp[0].minor.yy148 = REJECT_MODE; }2162#line 2187 "./mate_grammar.c"2163}2164 break;2165 case 42: /* extraction_statements ::= extraction_statements extraction_statement */2166#line 487 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2167{ yylhsminor.yy179 = yymsp[-1].minor.yy179; yylhsminor.yy179->last = yylhsminor.yy179->last->next = yymsp[0].minor.yy179; }2168#line 2193 "./mate_grammar.c"2169 yymsp[-1].minor.yy179 = yylhsminor.yy179;2170 break;2171 case 43: /* extraction_statements ::= extraction_statement */2172#line 488 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2173{ yylhsminor.yy179 = yymsp[0].minor.yy179; yylhsminor.yy179->last = yylhsminor.yy179; }2174#line 2199 "./mate_grammar.c"2175 yymsp[0].minor.yy179 = yylhsminor.yy179;2176 break;2177 case 44: /* extraction_statement ::= EXTRACT_KW NAME FROM_KW field SEMICOLON */2178{ yy_destructor(yypParser,37,&yymsp[-4].minor);2179#line 490 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2180{2181yymsp[-4].minor.yy179 = g_new(extraction_t, 1)((extraction_t *) g_malloc_n ((1), sizeof (extraction_t)));2182yymsp[-4].minor.yy179->as = yymsp[-3].minor.yy0;2183yymsp[-4].minor.yy179->hfi = yymsp[-1].minor.yy210;2184yymsp[-4].minor.yy179->next = yymsp[-4].minor.yy179->last = NULL((void*)0);2185}2186#line 2211 "./mate_grammar.c"2187 yy_destructor(yypParser,38,&yymsp[-2].minor);2188 yy_destructor(yypParser,2,&yymsp[0].minor);2189}2190 break;2191 case 45: /* pdu_drop_unassigned_statement ::= DROP_UNASSIGNED_KW true_false SEMICOLON */2192 case 55: /* gop_drop_unassigned_statement ::= DROP_UNASSIGNED_KW true_false SEMICOLON */ yytestcase(yyruleno==55);2193{ yy_destructor(yypParser,16,&yymsp[-2].minor);2194#line 498 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2195{ yymsp[-2].minor.yy219 = yymsp[-1].minor.yy219; }2196#line 2221 "./mate_grammar.c"2197 yy_destructor(yypParser,2,&yymsp[0].minor);2198}2199 break;2200 case 46: /* pdu_drop_unassigned_statement ::= */2201#line 499 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2202{ yymsp[1].minor.yy219 = mc->defaults.pdu.drop_unassigned; }2203#line 2228 "./mate_grammar.c"2204 break;2205 case 47: /* discard_pdu_data_statement ::= DISCARD_PDU_DATA_KW true_false SEMICOLON */2206{ yy_destructor(yypParser,17,&yymsp[-2].minor);2207#line 501 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2208{ yymsp[-2].minor.yy219 = yymsp[-1].minor.yy219; }2209#line 2234 "./mate_grammar.c"2210 yy_destructor(yypParser,2,&yymsp[0].minor);2211}2212 break;2213 case 48: /* discard_pdu_data_statement ::= */2214#line 502 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2215{ yymsp[1].minor.yy219 = mc->defaults.pdu.discard; }2216#line 2241 "./mate_grammar.c"2217 break;2218 case 49: /* last_extracted_statement ::= LAST_PDU_KW true_false SEMICOLON */2219{ yy_destructor(yypParser,39,&yymsp[-2].minor);2220#line 504 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2221{ yymsp[-2].minor.yy219 = yymsp[-1].minor.yy219; }2222#line 2247 "./mate_grammar.c"2223 yy_destructor(yypParser,2,&yymsp[0].minor);2224}2225 break;2226 case 50: /* last_extracted_statement ::= */2227#line 505 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2228{ yymsp[1].minor.yy219 = mc->defaults.pdu.last_extracted; }2229#line 2254 "./mate_grammar.c"2230 break;2231 case 51: /* proto_stack ::= proto_stack SLASH field */2232#line 507 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2233{2234int* hfidp = g_new(int, 1)((int *) g_malloc_n ((1), sizeof (int)));2235 2236*hfidp = yymsp[0].minor.yy210->id;2237g_ptr_array_add(yymsp[-2].minor.yy147,hfidp);2238yylhsminor.yy147 = yymsp[-2].minor.yy147;2239}2240#line 2265 "./mate_grammar.c"2241 yy_destructor(yypParser,40,&yymsp[-1].minor);2242 yymsp[-2].minor.yy147 = yylhsminor.yy147;2243 break;2244 case 52: /* proto_stack ::= field */2245#line 515 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2246{2247int* hfidp = g_new(int, 1)((int *) g_malloc_n ((1), sizeof (int)));2248*hfidp = yymsp[0].minor.yy210->id;2249 2250yylhsminor.yy147 = g_ptr_array_new();2251g_ptr_array_add(yylhsminor.yy147,hfidp);2252}2253#line 2278 "./mate_grammar.c"2254 yymsp[0].minor.yy147 = yylhsminor.yy147;2255 break;2256 case 53: /* field ::= NAME */2257#line 523 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2258{2259yylhsminor.yy210 = proto_registrar_get_byname(yymsp[0].minor.yy0);2260if (yylhsminor.yy210 == NULL((void*)0)) {2261configuration_error(mc,"\nUnknown Proto/Transport/field: %s\n",yymsp[0].minor.yy0);2262};2263}2264#line 2289 "./mate_grammar.c"2265 yymsp[0].minor.yy210 = yylhsminor.yy210;2266 break;2267 case 54: /* gop_decl ::= GOP_KW NAME ON_KW pdu_name MATCH_KW avpl OPEN_BRACE gop_start_statement gop_stop_statement extra_statement transform_list_statement gop_expiration_statement idle_timeout_statement lifetime_statement gop_drop_unassigned_statement show_goptree_statement show_times_statement CLOSE_BRACE SEMICOLON */2268{ yy_destructor(yypParser,12,&yymsp[-18].minor);2269#line 544 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2270{2271mate_cfg_gop* cfg;2272 2273if (g_hash_table_lookup(mc->gopcfgs,yymsp[-17].minor.yy0)) configuration_error(mc,"yymsp[-18].minor.yy0 Gop Named '%s' exists already.",yymsp[-17].minor.yy0);2274if (g_hash_table_lookup(mc->gops_by_pduname,yymsp[-15].minor.yy249) ) configuration_error(mc,"Gop for Pdu '%s' exists already",yymsp[-15].minor.yy249);2275 2276cfg = new_gopcfg(mc, yymsp[-17].minor.yy0);2277g_hash_table_insert(mc->gops_by_pduname,yymsp[-15].minor.yy249,cfg);2278g_hash_table_insert(mc->gopcfgs,cfg->name,cfg);2279 2280cfg->on_pdu = yymsp[-15].minor.yy249;2281cfg->key = yymsp[-13].minor.yy70;2282cfg->drop_unassigned = yymsp[-4].minor.yy219;2283cfg->show_times = yymsp[-2].minor.yy219;2284cfg->pdu_tree_mode = (gop_pdu_tree_t)yymsp[-3].minor.yy255;2285cfg->expiration = yymsp[-7].minor.yy244;2286cfg->idle_timeout = yymsp[-6].minor.yy244;2287cfg->lifetime = yymsp[-5].minor.yy244;2288cfg->start = yymsp[-11].minor.yy70;2289cfg->stop = yymsp[-10].minor.yy70;2290cfg->transforms = yymsp[-8].minor.yy147;2291 2292merge_avpl(cfg->extra,yymsp[-9].minor.yy70,true1);2293delete_avpl(yymsp[-9].minor.yy70,true1);2294}2295#line 2320 "./mate_grammar.c"2296 yy_destructor(yypParser,41,&yymsp[-16].minor);2297 yy_destructor(yypParser,25,&yymsp[-14].minor);2298 yy_destructor(yypParser,4,&yymsp[-12].minor);2299 yy_destructor(yypParser,5,&yymsp[-1].minor);2300 yy_destructor(yypParser,2,&yymsp[0].minor);2301}2302 break;2303 case 56: /* gop_drop_unassigned_statement ::= */2304#line 571 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2305{ yymsp[1].minor.yy219 = mc->defaults.gop.drop_unassigned; }2306#line 2331 "./mate_grammar.c"2307 break;2308 case 57: /* gop_start_statement ::= START_KW avpl SEMICOLON */2309{ yy_destructor(yypParser,42,&yymsp[-2].minor);2310#line 573 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2311{ yymsp[-2].minor.yy70 = yymsp[-1].minor.yy70; }2312#line 2337 "./mate_grammar.c"2313 yy_destructor(yypParser,2,&yymsp[0].minor);2314}2315 break;2316 case 58: /* gop_start_statement ::= */2317 case 60: /* gop_stop_statement ::= */ yytestcase(yyruleno==60);2318#line 574 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2319{ yymsp[1].minor.yy70 = NULL((void*)0); }2320#line 2345 "./mate_grammar.c"2321 break;2322 case 59: /* gop_stop_statement ::= STOP_KW avpl SEMICOLON */2323{ yy_destructor(yypParser,43,&yymsp[-2].minor);2324#line 576 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2325{ yymsp[-2].minor.yy70 = yymsp[-1].minor.yy70; }2326#line 2351 "./mate_grammar.c"2327 yy_destructor(yypParser,2,&yymsp[0].minor);2328}2329 break;2330 case 61: /* show_goptree_statement ::= SHOW_TREE_KW gop_tree_mode SEMICOLON */2331{ yy_destructor(yypParser,21,&yymsp[-2].minor);2332#line 579 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2333{ yymsp[-2].minor.yy255 = yymsp[-1].minor.yy255; }2334#line 2359 "./mate_grammar.c"2335 yy_destructor(yypParser,2,&yymsp[0].minor);2336}2337 break;2338 case 62: /* show_goptree_statement ::= */2339#line 580 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2340{ yymsp[1].minor.yy255 = (gop_tree_mode_t)mc->defaults.gop.pdu_tree_mode; }2341#line 2366 "./mate_grammar.c"2342 break;2343 case 63: /* show_times_statement ::= SHOW_TIMES_KW true_false SEMICOLON */2344{ yy_destructor(yypParser,22,&yymsp[-2].minor);2345#line 582 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2346{ yymsp[-2].minor.yy219 = yymsp[-1].minor.yy219; }2347#line 2372 "./mate_grammar.c"2348 yy_destructor(yypParser,2,&yymsp[0].minor);2349}2350 break;2351 case 64: /* show_times_statement ::= */2352#line 583 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2353{ yymsp[1].minor.yy219 = mc->defaults.gop.show_times; }2354#line 2379 "./mate_grammar.c"2355 break;2356 case 65: /* gop_expiration_statement ::= EXPIRATION_KW time_value SEMICOLON */2357 case 83: /* gog_expiration_statement ::= EXPIRATION_KW time_value SEMICOLON */ yytestcase(yyruleno==83);2358{ yy_destructor(yypParser,18,&yymsp[-2].minor);2359#line 585 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2360{ yymsp[-2].minor.yy244 = yymsp[-1].minor.yy244; }2361#line 2386 "./mate_grammar.c"2362 yy_destructor(yypParser,2,&yymsp[0].minor);2363}2364 break;2365 case 66: /* gop_expiration_statement ::= */2366 case 68: /* idle_timeout_statement ::= */ yytestcase(yyruleno==68);2367 case 70: /* lifetime_statement ::= */ yytestcase(yyruleno==70);2368#line 586 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2369{ yymsp[1].minor.yy244 = mc->defaults.gop.lifetime; }2370#line 2395 "./mate_grammar.c"2371 break;2372 case 67: /* idle_timeout_statement ::= IDLE_TIMEOUT_KW time_value SEMICOLON */2373{ yy_destructor(yypParser,19,&yymsp[-2].minor);2374#line 588 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2375{ yymsp[-2].minor.yy244 = yymsp[-1].minor.yy244; }2376#line 2401 "./mate_grammar.c"2377 yy_destructor(yypParser,2,&yymsp[0].minor);2378}2379 break;2380 case 69: /* lifetime_statement ::= LIFETIME_KW time_value SEMICOLON */2381{ yy_destructor(yypParser,20,&yymsp[-2].minor);2382#line 591 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2383{ yymsp[-2].minor.yy244 = yymsp[-1].minor.yy244; }2384#line 2409 "./mate_grammar.c"2385 yy_destructor(yypParser,2,&yymsp[0].minor);2386}2387 break;2388 case 71: /* gop_tree_mode ::= NO_TREE_KW */2389{ yy_destructor(yypParser,44,&yymsp[0].minor);2390#line 594 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2391{ yymsp[0].minor.yy255 = (gop_tree_mode_t)GOP_NO_TREE; }2392#line 2417 "./mate_grammar.c"2393}2394 break;2395 case 72: /* gop_tree_mode ::= PDU_TREE_KW */2396{ yy_destructor(yypParser,45,&yymsp[0].minor);2397#line 595 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2398{ yymsp[0].minor.yy255 = (gop_tree_mode_t)GOP_PDU_TREE; }2399#line 2424 "./mate_grammar.c"2400}2401 break;2402 case 73: /* gop_tree_mode ::= FRAME_TREE_KW */2403{ yy_destructor(yypParser,46,&yymsp[0].minor);2404#line 596 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2405{ yymsp[0].minor.yy255 = (gop_tree_mode_t)GOP_FRAME_TREE; }2406#line 2431 "./mate_grammar.c"2407}2408 break;2409 case 74: /* gop_tree_mode ::= BASIC_TREE_KW */2410{ yy_destructor(yypParser,47,&yymsp[0].minor);2411#line 597 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2412{ yymsp[0].minor.yy255 = (gop_tree_mode_t)GOP_BASIC_PDU_TREE; }2413#line 2438 "./mate_grammar.c"2414}2415 break;2416 case 75: /* true_false ::= TRUE_KW */2417{ yy_destructor(yypParser,48,&yymsp[0].minor);2418#line 599 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2419{ yymsp[0].minor.yy219 = true1; }2420#line 2445 "./mate_grammar.c"2421}2422 break;2423 case 76: /* true_false ::= FALSE_KW */2424{ yy_destructor(yypParser,49,&yymsp[0].minor);2425#line 600 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2426{ yymsp[0].minor.yy219 = false0; }2427#line 2452 "./mate_grammar.c"2428}2429 break;2430 case 77: /* pdu_name ::= NAME */2431#line 602 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2432{2433mate_cfg_pdu* c;2434if (( c = (mate_cfg_pdu *)g_hash_table_lookup(mc->pducfgs,yymsp[0].minor.yy0) )) {2435yylhsminor.yy249 = c->name;2436} else {2437configuration_error(mc,"No such Pdu: '%s'",yymsp[0].minor.yy0);2438}2439}2440#line 2465 "./mate_grammar.c"2441 yymsp[0].minor.yy249 = yylhsminor.yy249;2442 break;2443 case 78: /* time_value ::= FLOATING */2444 case 79: /* time_value ::= INTEGER */ yytestcase(yyruleno==79);2445#line 612 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2446{2447yylhsminor.yy244 = g_ascii_strtod(yymsp[0].minor.yy0,NULL((void*)0));2448}2449#line 2474 "./mate_grammar.c"2450 yymsp[0].minor.yy244 = yylhsminor.yy244;2451 break;2452 case 80: /* gog_decl ::= GOG_KW NAME OPEN_BRACE gog_key_statements extra_statement transform_list_statement gog_expiration_statement gog_goptree_statement show_times_statement CLOSE_BRACE SEMICOLON */2453{ yy_destructor(yypParser,13,&yymsp[-10].minor);2454#line 630 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2455{2456mate_cfg_gog* cfg = NULL((void*)0);2457 2458if ( g_hash_table_lookup(mc->gogcfgs,yymsp[-9].minor.yy0) ) {2459configuration_error(mc,"Gog '%s' exists already ",yymsp[-9].minor.yy0);2460}2461 2462cfg = new_gogcfg(mc, yymsp[-9].minor.yy0);2463 2464cfg->expiration = yymsp[-4].minor.yy244;2465cfg->gop_tree_mode = yymsp[-3].minor.yy255;2466cfg->transforms = yymsp[-5].minor.yy147;2467cfg->keys = yymsp[-7].minor.yy77;2468cfg->show_times = yymsp[-2].minor.yy219;2469 2470merge_avpl(cfg->extra,yymsp[-6].minor.yy70,true1);2471delete_avpl(yymsp[-6].minor.yy70,true1);2472}2473#line 2498 "./mate_grammar.c"2474 yy_destructor(yypParser,4,&yymsp[-8].minor);2475 yy_destructor(yypParser,5,&yymsp[-1].minor);2476 yy_destructor(yypParser,2,&yymsp[0].minor);2477}2478 break;2479 case 81: /* gog_goptree_statement ::= GOP_TREE_KW gop_tree_type SEMICOLON */2480{ yy_destructor(yypParser,23,&yymsp[-2].minor);2481#line 649 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2482{ yymsp[-2].minor.yy255 = yymsp[-1].minor.yy255; }2483#line 2508 "./mate_grammar.c"2484 yy_destructor(yypParser,2,&yymsp[0].minor);2485}2486 break;2487 case 82: /* gog_goptree_statement ::= */2488#line 650 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2489{ yymsp[1].minor.yy255 = mc->defaults.gog.gop_tree_mode; }2490#line 2515 "./mate_grammar.c"2491 break;2492 case 84: /* gog_expiration_statement ::= */2493#line 653 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2494{ yymsp[1].minor.yy244 = mc->defaults.gog.expiration; }2495#line 2520 "./mate_grammar.c"2496 break;2497 case 85: /* gop_tree_type ::= NULL_TREE_KW */2498{ yy_destructor(yypParser,51,&yymsp[0].minor);2499#line 655 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2500{ yymsp[0].minor.yy255 = GOP_NULL_TREE; }2501#line 2526 "./mate_grammar.c"2502}2503 break;2504 case 86: /* gop_tree_type ::= FULL_TREE_KW */2505{ yy_destructor(yypParser,52,&yymsp[0].minor);2506#line 656 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2507{ yymsp[0].minor.yy255 = GOP_FULL_TREE; }2508#line 2533 "./mate_grammar.c"2509}2510 break;2511 case 87: /* gop_tree_type ::= BASIC_TREE_KW */2512{ yy_destructor(yypParser,47,&yymsp[0].minor);2513#line 657 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2514{ yymsp[0].minor.yy255 = GOP_BASIC_TREE; }2515#line 2540 "./mate_grammar.c"2516}2517 break;2518 case 88: /* gog_key_statements ::= gog_key_statements gog_key_statement */2519#line 659 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2520{2521loal_append(yymsp[-1].minor.yy77,yymsp[0].minor.yy70);2522yylhsminor.yy77 = yymsp[-1].minor.yy77;2523}2524#line 2549 "./mate_grammar.c"2525 yymsp[-1].minor.yy77 = yylhsminor.yy77;2526 break;2527 case 89: /* gog_key_statements ::= gog_key_statement */2528#line 664 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2529{2530yylhsminor.yy77 = new_loal("");2531loal_append(yylhsminor.yy77,yymsp[0].minor.yy70);2532}2533#line 2558 "./mate_grammar.c"2534 yymsp[0].minor.yy77 = yylhsminor.yy77;2535 break;2536 case 90: /* gog_key_statement ::= MEMBER_KW gop_name avpl SEMICOLON */2537{ yy_destructor(yypParser,53,&yymsp[-3].minor);2538#line 670 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2539{2540rename_avpl(yymsp[-1].minor.yy70,yymsp[-2].minor.yy249);2541yymsp[-3].minor.yy70 = yymsp[-1].minor.yy70;2542}2543#line 2568 "./mate_grammar.c"2544 yy_destructor(yypParser,2,&yymsp[0].minor);2545}2546 break;2547 case 91: /* gop_name ::= NAME */2548#line 675 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2549{2550mate_cfg_gop* c;2551if (( c = (mate_cfg_gop *)g_hash_table_lookup(mc->gopcfgs,yymsp[0].minor.yy0) )) {2552yylhsminor.yy249 = c->name;2553} else {2554configuration_error(mc,"No Gop called '%s' has been already declared",yymsp[0].minor.yy0);2555}2556}2557#line 2582 "./mate_grammar.c"2558 yymsp[0].minor.yy249 = yylhsminor.yy249;2559 break;2560 case 92: /* extra_statement ::= EXTRA_KW avpl SEMICOLON */2561{ yy_destructor(yypParser,54,&yymsp[-2].minor);2562#line 687 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2563{ yymsp[-2].minor.yy70 = yymsp[-1].minor.yy70; }2564#line 2589 "./mate_grammar.c"2565 yy_destructor(yypParser,2,&yymsp[0].minor);2566}2567 break;2568 case 93: /* extra_statement ::= */2569#line 688 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2570{ yymsp[1].minor.yy70 = new_avpl(""); }2571#line 2596 "./mate_grammar.c"2572 break;2573 case 94: /* transform_list_statement ::= TRANSFORM_KW transform_list SEMICOLON */2574{ yy_destructor(yypParser,24,&yymsp[-2].minor);2575#line 690 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2576{ yymsp[-2].minor.yy147 = yymsp[-1].minor.yy147; }2577#line 2602 "./mate_grammar.c"2578 yy_destructor(yypParser,2,&yymsp[0].minor);2579}2580 break;2581 case 95: /* transform_list_statement ::= */2582#line 691 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2583{ yymsp[1].minor.yy147 = g_ptr_array_new(); }2584#line 2609 "./mate_grammar.c"2585 break;2586 case 96: /* transform_list ::= transform_list COMMA transform */2587#line 693 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2588{2589yylhsminor.yy147 = yymsp[-2].minor.yy147;2590g_ptr_array_add(yymsp[-2].minor.yy147,yymsp[0].minor.yy11);2591}2592#line 2617 "./mate_grammar.c"2593 yy_destructor(yypParser,55,&yymsp[-1].minor);2594 yymsp[-2].minor.yy147 = yylhsminor.yy147;2595 break;2596 case 97: /* transform_list ::= transform */2597#line 698 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2598{2599yylhsminor.yy147 = g_ptr_array_new();2600g_ptr_array_add(yylhsminor.yy147,yymsp[0].minor.yy11);2601}2602#line 2627 "./mate_grammar.c"2603 yymsp[0].minor.yy147 = yylhsminor.yy147;2604 break;2605 case 98: /* transform ::= NAME */2606#line 703 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2607{2608AVPL_Transf* t;2609 2610if (( t = (AVPL_Transf *)g_hash_table_lookup(mc->transfs,yymsp[0].minor.yy0) )) {2611yylhsminor.yy11 = t;2612} else {2613configuration_error(mc,"There's no such Transformation: %s",yymsp[0].minor.yy0);2614}2615}2616#line 2641 "./mate_grammar.c"2617 yymsp[0].minor.yy11 = yylhsminor.yy11;2618 break;2619 case 99: /* avpl ::= OPEN_PARENS avps CLOSE_PARENS */2620{ yy_destructor(yypParser,56,&yymsp[-2].minor);2621#line 713 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2622{ yymsp[-2].minor.yy70 = yymsp[-1].minor.yy70; }2623#line 2648 "./mate_grammar.c"2624 yy_destructor(yypParser,57,&yymsp[0].minor);2625}2626 break;2627 case 100: /* avpl ::= OPEN_PARENS CLOSE_PARENS */2628{ yy_destructor(yypParser,56,&yymsp[-1].minor);2629#line 714 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2630{ yymsp[-1].minor.yy70 = new_avpl(""); }2631#line 2656 "./mate_grammar.c"2632 yy_destructor(yypParser,57,&yymsp[0].minor);2633}2634 break;2635 case 101: /* avps ::= avps COMMA avp */2636#line 716 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2637{ yylhsminor.yy70 = yymsp[-2].minor.yy70; if ( ! insert_avp(yymsp[-2].minor.yy70,yymsp[0].minor.yy226) ) delete_avp(yymsp[0].minor.yy226); }2638#line 2663 "./mate_grammar.c"2639 yy_destructor(yypParser,55,&yymsp[-1].minor);2640 yymsp[-2].minor.yy70 = yylhsminor.yy70;2641 break;2642 case 102: /* avps ::= avp */2643#line 717 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2644{ yylhsminor.yy70 = new_avpl(""); if ( ! insert_avp(yylhsminor.yy70,yymsp[0].minor.yy226) ) delete_avp(yymsp[0].minor.yy226); }2645#line 2670 "./mate_grammar.c"2646 yymsp[0].minor.yy70 = yylhsminor.yy70;2647 break;2648 case 103: /* avp ::= NAME AVP_OPERATOR value */2649#line 719 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2650{ yylhsminor.yy226 = new_avp(yymsp[-2].minor.yy0,yymsp[0].minor.yy249,*yymsp[-1].minor.yy0); }2651#line 2676 "./mate_grammar.c"2652 yymsp[-2].minor.yy226 = yylhsminor.yy226;2653 break;2654 case 104: /* avp ::= NAME */2655#line 720 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2656{ yylhsminor.yy226 = new_avp(yymsp[0].minor.yy0,"",'?'); }2657#line 2682 "./mate_grammar.c"2658 yymsp[0].minor.yy226 = yylhsminor.yy226;2659 break;2660 case 105: /* avp ::= NAME OPEN_BRACE avp_oneoff CLOSE_BRACE */2661#line 721 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2662{ yylhsminor.yy226 = new_avp(yymsp[-3].minor.yy0,yymsp[-1].minor.yy249,'|'); }2663#line 2688 "./mate_grammar.c"2664 yy_destructor(yypParser,4,&yymsp[-2].minor);2665 yy_destructor(yypParser,5,&yymsp[0].minor);2666 yymsp[-3].minor.yy226 = yylhsminor.yy226;2667 break;2668 case 106: /* avp_oneoff ::= avp_oneoff PIPE value */2669#line 723 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2670{ yylhsminor.yy249 = ws_strdup_printf("%s|%s",yymsp[-2].minor.yy249,yymsp[0].minor.yy249)wmem_strdup_printf(((void*)0), "%s|%s",yymsp[-2].minor.yy249,
yymsp[0].minor.yy249); }2671#line 2696 "./mate_grammar.c"2672 yy_destructor(yypParser,59,&yymsp[-1].minor);2673 yymsp[-2].minor.yy249 = yylhsminor.yy249;2674 break;2675 case 107: /* avp_oneoff ::= value */2676#line 724 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2677{ yylhsminor.yy249 = g_strdup(yymsp[0].minor.yy249); }2678#line 2703 "./mate_grammar.c"2679 yymsp[0].minor.yy249 = yylhsminor.yy249;2680 break;2681 case 108: /* value ::= QUOTED */2682 case 109: /* value ::= NAME */ yytestcase(yyruleno==109);2683 case 110: /* value ::= FLOATING */ yytestcase(yyruleno==110);2684 case 111: /* value ::= INTEGER */ yytestcase(yyruleno==111);2685 case 112: /* value ::= DOTED_IP */ yytestcase(yyruleno==112);2686#line 726 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2687{ yylhsminor.yy249 = g_strdup(yymsp[0].minor.yy0); }2688#line 2713 "./mate_grammar.c"2689 yymsp[0].minor.yy249 = yylhsminor.yy249;2690 break;2691 case 113: /* value ::= COLONIZED */2692#line 731 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2693{ yylhsminor.yy249 = recolonize(mc,yymsp[0].minor.yy0); }2694#line 2719 "./mate_grammar.c"2695 yymsp[0].minor.yy249 = yylhsminor.yy249;2696 break;2697 case 123: /* decl ::= DONE_KW SEMICOLON */2698{ yy_destructor(yypParser,1,&yymsp[-1].minor);2699#line 267 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2700{2701}2702#line 2727 "./mate_grammar.c"2703 yy_destructor(yypParser,2,&yymsp[0].minor);2704}2705 break;2706 case 124: /* debug_decl ::= DEBUG_KW OPEN_BRACE dbgfile_default dbglevel_default pdu_dbglevel_default gop_dbglevel_default gog_dbglevel_default CLOSE_BRACE SEMICOLON */2707{ yy_destructor(yypParser,3,&yymsp[-8].minor);2708#line 272 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2709{2710}2711#line 2736 "./mate_grammar.c"2712 yy_destructor(yypParser,4,&yymsp[-7].minor);2713 yy_destructor(yypParser,5,&yymsp[-1].minor);2714 yy_destructor(yypParser,2,&yymsp[0].minor);2715}2716 break;2717 case 130: /* defaults_decl ::= DEFAULT_KW OPEN_BRACE pdu_defaults gop_defaults gog_defaults CLOSE_BRACE SEMICOLON */2718{ yy_destructor(yypParser,14,&yymsp[-6].minor);2719#line 294 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2720{2721}2722#line 2747 "./mate_grammar.c"2723 yy_destructor(yypParser,4,&yymsp[-5].minor);2724 yy_destructor(yypParser,5,&yymsp[-1].minor);2725 yy_destructor(yypParser,2,&yymsp[0].minor);2726}2727 break;2728 case 131: /* pdu_defaults ::= PDU_KW OPEN_BRACE pdu_last_extracted_default pdu_drop_unassigned_default pdu_discard_default CLOSE_BRACE SEMICOLON */2729{ yy_destructor(yypParser,11,&yymsp[-6].minor);2730#line 296 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2731{2732}2733#line 2758 "./mate_grammar.c"2734 yy_destructor(yypParser,4,&yymsp[-5].minor);2735 yy_destructor(yypParser,5,&yymsp[-1].minor);2736 yy_destructor(yypParser,2,&yymsp[0].minor);2737}2738 break;2739 case 136: /* gop_defaults ::= GOP_KW OPEN_BRACE gop_expiration_default gop_idle_timeout_default gop_lifetime_default gop_drop_unassigned_default gop_tree_mode_default gop_show_times_default CLOSE_BRACE SEMICOLON */2740{ yy_destructor(yypParser,12,&yymsp[-9].minor);2741#line 308 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2742{2743}2744#line 2769 "./mate_grammar.c"2745 yy_destructor(yypParser,4,&yymsp[-8].minor);2746 yy_destructor(yypParser,5,&yymsp[-1].minor);2747 yy_destructor(yypParser,2,&yymsp[0].minor);2748}2749 break;2750 case 144: /* gog_defaults ::= GOG_KW OPEN_BRACE gog_expiration_default gop_tree_mode_default gog_goptree_default gog_show_times_default CLOSE_BRACE SEMICOLON */2751{ yy_destructor(yypParser,13,&yymsp[-7].minor);2752#line 329 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2753{2754}2755#line 2780 "./mate_grammar.c"2756 yy_destructor(yypParser,4,&yymsp[-6].minor);2757 yy_destructor(yypParser,5,&yymsp[-1].minor);2758 yy_destructor(yypParser,2,&yymsp[0].minor);2759}2760 break;2761 default:2762 /* (114) mate_config ::= decls */ yytestcase(yyruleno==114);2763 /* (115) decls ::= decls decl */ yytestcase(yyruleno==115);2764 /* (116) decls ::= */ yytestcase(yyruleno==116);2765 /* (117) decl ::= pdu_decl (OPTIMIZED OUT) */ assert(yyruleno!=117)((void) (0));2766 /* (118) decl ::= gop_decl (OPTIMIZED OUT) */ assert(yyruleno!=118)((void) (0));2767 /* (119) decl ::= gog_decl (OPTIMIZED OUT) */ assert(yyruleno!=119)((void) (0));2768 /* (120) decl ::= transform_decl (OPTIMIZED OUT) */ assert(yyruleno!=120)((void) (0));2769 /* (121) decl ::= defaults_decl (OPTIMIZED OUT) */ assert(yyruleno!=121)((void) (0));2770 /* (122) decl ::= debug_decl (OPTIMIZED OUT) */ assert(yyruleno!=122)((void) (0));2771 /* (125) dbgfile_default ::= */ yytestcase(yyruleno==125);2772 /* (126) dbglevel_default ::= */ yytestcase(yyruleno==126);2773 /* (127) pdu_dbglevel_default ::= */ yytestcase(yyruleno==127);2774 /* (128) gop_dbglevel_default ::= */ yytestcase(yyruleno==128);2775 /* (129) gog_dbglevel_default ::= */ yytestcase(yyruleno==129);2776 /* (132) pdu_defaults ::= */ yytestcase(yyruleno==132);2777 /* (133) pdu_last_extracted_default ::= */ yytestcase(yyruleno==133);2778 /* (134) pdu_drop_unassigned_default ::= */ yytestcase(yyruleno==134);2779 /* (135) pdu_discard_default ::= */ yytestcase(yyruleno==135);2780 /* (137) gop_defaults ::= */ yytestcase(yyruleno==137);2781 /* (138) gop_expiration_default ::= */ yytestcase(yyruleno==138);2782 /* (139) gop_idle_timeout_default ::= */ yytestcase(yyruleno==139);2783 /* (140) gop_lifetime_default ::= */ yytestcase(yyruleno==140);2784 /* (141) gop_drop_unassigned_default ::= */ yytestcase(yyruleno==141);2785 /* (142) gop_tree_mode_default ::= */ yytestcase(yyruleno==142);2786 /* (143) gop_show_times_default ::= */ yytestcase(yyruleno==143);2787 /* (145) gog_defaults ::= */ yytestcase(yyruleno==145);2788 /* (146) gog_expiration_default ::= */ yytestcase(yyruleno==146);2789 /* (147) gog_goptree_default ::= */ yytestcase(yyruleno==147);2790 /* (148) gog_show_times_default ::= */ yytestcase(yyruleno==148);2791 break;2792/********** End reduce actions ************************************************/2793 };2794 assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) )((void) (0));2795 yygoto = yyRuleInfoLhs[yyruleno];2796 yysize = yyRuleInfoNRhs[yyruleno];2797 yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPEunsigned char)yygoto);2798 2799 /* There are no SHIFTREDUCE actions on nonterminals because the table2800 ** generator has simplified them to pure REDUCE actions. */2801 assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) )((void) (0));2802 2803 /* It is not possible for a REDUCE to be followed by an error */2804 assert( yyact!=YY_ERROR_ACTION )((void) (0));2805 2806 yymsp += yysize+1;2807 yypParser->yytos = yymsp;2808 yymsp->stateno = (YYACTIONTYPEunsigned short int)yyact;2809 yymsp->major = (YYCODETYPEunsigned char)yygoto;2810 yyTraceShift(yypParser, yyact, "... then shift");2811 return yyact;2812}2813 2814/*2815** The following code executes when the parse fails2816*/2817#ifndef YYNOERRORRECOVERY2818static void yy_parse_failed(2819 yyParser *yypParser /* The parser */2820){2821 MateParserARG_FETCHmate_config* mc =yypParser->mc ;2822 MateParserCTX_FETCH2823#ifndef NDEBUG2824 if( yyTraceFILE ){2825 fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);2826 }2827#endif2828 while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);2829 /* Here code is inserted which will be executed whenever the2830 ** parser fails */2831/************ Begin %parse_failure code ***************************************/2832#line 196 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2833 2834configuration_error(mc,"Parse Error");2835#line 2860 "./mate_grammar.c"2836/************ End %parse_failure code *****************************************/2837 MateParserARG_STOREyypParser->mc =mc ; /* Suppress warning about unused %extra_argument variable */2838 MateParserCTX_STORE2839}2840#endif /* YYNOERRORRECOVERY */2841 2842/*2843** The following code executes when a syntax error first occurs.2844*/2845static void yy_syntax_error(2846 yyParser *yypParser, /* The parser */2847 int yymajor, /* The major type of the error token */2848 MateParserTOKENTYPEchar* yyminor /* The minor type of the error token */2849){2850 MateParserARG_FETCHmate_config* mc =yypParser->mc ;2851 MateParserCTX_FETCH2852#define TOKENyyminor yyminor2853/************ Begin %syntax_error code ****************************************/2854#line 192 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"2855 2856configuration_error(mc,"Syntax Error before %s",yyminor);2857#line 2882 "./mate_grammar.c"2858/************ End %syntax_error code ******************************************/2859 MateParserARG_STOREyypParser->mc =mc ; /* Suppress warning about unused %extra_argument variable */2860 MateParserCTX_STORE2861}2862 2863/*2864** The following is executed when the parser accepts2865*/2866static void yy_accept(2867 yyParser *yypParser /* The parser */2868){2869 MateParserARG_FETCHmate_config* mc =yypParser->mc ;2870 MateParserCTX_FETCH2871#ifndef NDEBUG2872 if( yyTraceFILE ){2873 fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);2874 }2875#endif2876#ifndef YYNOERRORRECOVERY2877 yypParser->yyerrcnt = -1;2878#endif2879 assert( yypParser->yytos==yypParser->yystack )((void) (0));2880 /* Here code is inserted which will be executed whenever the2881 ** parser accepts */2882/*********** Begin %parse_accept code *****************************************/2883/*********** End %parse_accept code *******************************************/2884 MateParserARG_STOREyypParser->mc =mc ; /* Suppress warning about unused %extra_argument variable */2885 MateParserCTX_STORE2886}2887 2888/* The main parser program.2889** The first argument is a pointer to a structure obtained from2890** "MateParserAlloc" which describes the current state of the parser.2891** The second argument is the major token number. The third is2892** the minor token. The fourth optional argument is whatever the2893** user wants (and specified in the grammar) and is available for2894** use by the action routines.2895**2896** Inputs:2897** <ul>2898** <li> A pointer to the parser (an opaque structure.)2899** <li> The major token number.2900** <li> The minor token number.2901** <li> An option argument of a grammar-specified type.2902** </ul>2903**2904** Outputs:2905** None.2906*/2907void MateParser(2908 void *yyp, /* The parser */2909 int yymajor, /* The major token code number */2910 MateParserTOKENTYPEchar* yyminor /* The value for the token */2911 MateParserARG_PDECL, mate_config* mc /* Optional %extra_argument parameter */2912){2913 YYMINORTYPE yyminorunion;2914 YYACTIONTYPEunsigned short int yyact; /* The parser action. */2915#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)2916 int yyendofinput; /* True if we are at the end of input */2917#endif2918#ifdef YYERRORSYMBOL2919 int yyerrorhit = 0; /* True if yymajor has invoked an error */2920#endif2921 yyParser *yypParser = (yyParser*)yyp; /* The parser */2922 MateParserCTX_FETCH2923 MateParserARG_STOREyypParser->mc =mc ;2924 2925 assert( yypParser->yytos!=0 )((void) (0));2926#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)2927 yyendofinput = (yymajor==0);2928#endif2929 2930 yyact = yypParser->yytos->stateno;2931#ifndef NDEBUG2932 if( yyTraceFILE ){2933 if( yyact < YY_MIN_REDUCE439 ){2934 fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",2935 yyTracePrompt,yyTokenName[yymajor],yyact);2936 }else{2937 fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",2938 yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE439);2939 }2940 }2941#endif2942 2943 while(1){ /* Exit by "break" */2944 assert( yypParser->yytos>=yypParser->yystack )((void) (0));2945 assert( yyact==yypParser->yytos->stateno )((void) (0));2946 yyact = yy_find_shift_action((YYCODETYPEunsigned char)yymajor,yyact);2947 if( yyact >= YY_MIN_REDUCE439 ){2948 unsigned int yyruleno = yyact - YY_MIN_REDUCE439; /* Reduce by this rule */2949#ifndef NDEBUG2950 assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) )((void) (0));2951 if( yyTraceFILE ){2952 int yysize = yyRuleInfoNRhs[yyruleno];2953 if( yysize ){2954 fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",2955 yyTracePrompt,2956 yyruleno, yyRuleName[yyruleno],2957 yyruleno<YYNRULE_WITH_ACTION114 ? "" : " without external action",2958 yypParser->yytos[yysize].stateno);2959 }else{2960 fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",2961 yyTracePrompt, yyruleno, yyRuleName[yyruleno],2962 yyruleno<YYNRULE_WITH_ACTION114 ? "" : " without external action");2963 }2964 }2965#endif /* NDEBUG */2966 2967 /* Check that the stack is large enough to grow by a single entry2968 ** if the RHS of the rule is empty. This ensures that there is room2969 ** enough on the stack to push the LHS value */2970 if( yyRuleInfoNRhs[yyruleno]==0 ){2971#ifdef YYTRACKMAXSTACKDEPTH2972 if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){2973 yypParser->yyhwm++;2974 assert( yypParser->yyhwm ==((void) (0))2975 (int)(yypParser->yytos - yypParser->yystack))((void) (0));2976 }2977#endif2978#if YYSTACKDEPTH100>02979 if( yypParser->yytos>=yypParser->yystackEnd ){2980 yyStackOverflow(yypParser);2981 break;2982 }2983#else2984 if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){2985 if( yyGrowStack(yypParser) ){2986 yyStackOverflow(yypParser);2987 break;2988 }2989 }2990#endif2991 }2992 yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor MateParserCTX_PARAM);2993 }else if( yyact <= YY_MAX_SHIFTREDUCE435 ){2994 yy_shift(yypParser,yyact,(YYCODETYPEunsigned char)yymajor,yyminor);2995#ifndef YYNOERRORRECOVERY2996 yypParser->yyerrcnt--;2997#endif2998 break;2999 }else if( yyact==YY_ACCEPT_ACTION437 ){3000 yypParser->yytos--;3001 yy_accept(yypParser);3002 return;3003 }else{3004 assert( yyact == YY_ERROR_ACTION )((void) (0));3005 yyminorunion.yy0 = yyminor;3006#ifdef YYERRORSYMBOL3007 int yymx;3008#endif3009#ifndef NDEBUG3010 if( yyTraceFILE ){3011 fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);3012 }3013#endif3014#ifdef YYERRORSYMBOL3015 /* A syntax error has occurred.3016 ** The response to an error depends upon whether or not the3017 ** grammar defines an error token "ERROR".3018 **3019 ** This is what we do if the grammar does define ERROR:3020 **3021 ** * Call the %syntax_error function.3022 **3023 ** * Begin popping the stack until we enter a state where3024 ** it is legal to shift the error symbol, then shift3025 ** the error symbol.3026 **3027 ** * Set the error count to three.3028 **3029 ** * Begin accepting and shifting new tokens. No new error3030 ** processing will occur until three tokens have been3031 ** shifted successfully.3032 **3033 */3034 if( yypParser->yyerrcnt<0 ){3035 yy_syntax_error(yypParser,yymajor,yyminor);3036 }3037 yymx = yypParser->yytos->major;3038 if( yymx==YYERRORSYMBOL || yyerrorhit ){3039#ifndef NDEBUG3040 if( yyTraceFILE ){3041 fprintf(yyTraceFILE,"%sDiscard input token %s\n",3042 yyTracePrompt,yyTokenName[yymajor]);3043 }3044#endif3045 yy_destructor(yypParser, (YYCODETYPEunsigned char)yymajor, &yyminorunion);3046 yymajor = YYNOCODE137;3047 }else{3048 while( yypParser->yytos > yypParser->yystack ){3049 yyact = yy_find_reduce_action(yypParser->yytos->stateno,3050 YYERRORSYMBOL);3051 if( yyact<=YY_MAX_SHIFTREDUCE435 ) break;3052 yy_pop_parser_stack(yypParser);3053 }3054 if( yypParser->yytos <= yypParser->yystack || yymajor==0 ){3055 yy_destructor(yypParser,(YYCODETYPEunsigned char)yymajor,&yyminorunion);3056 yy_parse_failed(yypParser);3057#ifndef YYNOERRORRECOVERY3058 yypParser->yyerrcnt = -1;3059#endif3060 yymajor = YYNOCODE137;3061 }else if( yymx!=YYERRORSYMBOL ){3062 yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor);3063 }3064 }3065 yypParser->yyerrcnt = 3;3066 yyerrorhit = 1;3067 if( yymajor==YYNOCODE137 ) break;3068 yyact = yypParser->yytos->stateno;3069#elif defined(YYNOERRORRECOVERY)3070 /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to3071 ** do any kind of error recovery. Instead, simply invoke the syntax3072 ** error routine and continue going as if nothing had happened.3073 **3074 ** Applications can set this macro (for example inside %include) if3075 ** they intend to abandon the parse upon the first syntax error seen.3076 */3077 yy_syntax_error(yypParser,yymajor, yyminor);3078 yy_destructor(yypParser,(YYCODETYPEunsigned char)yymajor,&yyminorunion);3079 break;3080#else /* YYERRORSYMBOL is not defined */3081 /* This is what we do if the grammar does not define ERROR:3082 **3083 ** * Report an error message, and throw away the input token.3084 **3085 ** * If the input token is $, then fail the parse.3086 **3087 ** As before, subsequent error messages are suppressed until3088 ** three input tokens have been successfully shifted.3089 */3090 if( yypParser->yyerrcnt<=0 ){3091 yy_syntax_error(yypParser,yymajor, yyminor);3092 }3093 yypParser->yyerrcnt = 3;3094 yy_destructor(yypParser,(YYCODETYPEunsigned char)yymajor,&yyminorunion);3095 if( yyendofinput ){3096 yy_parse_failed(yypParser);3097#ifndef YYNOERRORRECOVERY3098 yypParser->yyerrcnt = -1;3099#endif3100 }3101 break;3102#endif3103 }3104 }3105#ifndef NDEBUG3106 if( yyTraceFILE ){3107 yyStackEntry *i;3108 char cDiv = '[';3109 fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);3110 for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){3111 fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]);3112 cDiv = ' ';3113 }3114 fprintf(yyTraceFILE,"]\n");3115 }3116#endif3117 return;3118}3119 3120/*3121** Return the fallback token corresponding to canonical token iToken, or3122** 0 if iToken has no fallback.3123*/3124int MateParserFallback(int iToken){3125#ifdef YYFALLBACK3126 assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) )((void) (0));3127 return yyFallback[iToken];3128#else3129 (void)iToken;3130 return 0;3131#endif3132}3133#line 176 "/builds/wireshark/wireshark/plugins/epan/mate/mate_grammar.lemon"3134 3135DIAG_ON_LEMON()clang diagnostic pop3136#line 3161 "./mate_grammar.c"