/* This file is automatically generated by Lemon from input grammar

** source file "/src/wireshark/epan/protobuf_lang_parser.lemon". */

/* protobuf_lang_parser.lemon

 *

 * C Protocol Buffers Language (PBL) Parser (for *.proto files)

 * Copyright 2020, Huang Qiangxiong <qiangxiong.huang@qq.com>

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

/* This parser is mainly to get MESSAGE, ENUM, and FIELD information from *.proto files.

 * There are three formats of *.proto files:

 * 1) Protocol Buffers Edition 2023 Language Specification

 *      https://protobuf.dev/reference/protobuf/edition-2023-spec

 * 2) Protocol Buffers Version 3 Language Specification:

 *      https://developers.google.com/protocol-buffers/docs/reference/proto3-spec

 * 3) Protocol Buffers Version 2 Language Specification:

 *      https://developers.google.com/protocol-buffers/docs/reference/proto2-spec

 * There are some errors about 'proto', 'option' (value), 'extensions',  and 'reserved' (fieldName) definitions on that sites.

 * This parser is created because Wireshark is mainly implemented in plain ANSI C but the official

 * Protocol Buffers Language parser is implemented in C++.

 */

#include "config.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <glib.h>

#include <assert.h>

#include <ws_diag_control.h>

#include <wsutil/file_util.h>

#include "protobuf_lang_tree.h"

#include "protobuf_lang_parser.h"

#include "protobuf_lang_scanner_lex.h"

#define NAME_TO_BE_SET "<NAME_TO_BE_SET>"

#define NEED_NOT_NAME "<NEED_NOT_NAME>"

static void *ProtobufLangParserAlloc(void *(*mallocProc)(size_t));

static void ProtobufLangParser(void *yyp, int yymajor, protobuf_lang_token_t *yyminor, protobuf_lang_state_t *state);

static void ProtobufLangParserFree(void *p, void (*freeProc)(void*));

/* Error handling function for parser */

void protobuf_lang_error(void* yyscanner, protobuf_lang_state_t *state, const char *msg);

/* Extended error handling function */

void pbl_parser_error(protobuf_lang_state_t *state, const char *fmt, ...);

/* It's just the approximate line number which is gotten when a grammar rule is reduced

   by the parser (lemon). That might be overridden by the lineno argument of

   pbl_set_node_name() later. */

#define CUR_LINENO (protobuf_lang_get_lineno(state->scanner))

DIAG_OFF_LEMON()

#line 81 "./protobuf_lang_parser.c"

/**************** End of %include directives **********************************/

/* These constants specify the various numeric values for terminal symbols.

***************** Begin token definitions *************************************/

#ifndef PT_IDENT

#define PT_IDENT                        1

#define PT_SYNTAX                       2

#define PT_EDITION                      3

#define PT_IMPORT                       4

#define PT_WEAK                         5

#define PT_PUBLIC                       6

#define PT_PACKAGE                      7

#define PT_OPTION                       8

#define PT_REQUIRED                     9

#define PT_OPTIONAL                    10

#define PT_REPEATED                    11

#define PT_ONEOF                       12

#define PT_MAP                         13

#define PT_RESERVED                    14

#define PT_ENUM                        15

#define PT_GROUP                       16

#define PT_EXTEND                      17

#define PT_EXTENSIONS                  18

#define PT_MESSAGE                     19

#define PT_SERVICE                     20

#define PT_RPC                         21

#define PT_STREAM                      22

#define PT_RETURNS                     23

#define PT_TO                          24

#define PT_ASSIGN                      25

#define PT_SEMICOLON                   26

#define PT_LPAREN                      27

#define PT_RPAREN                      28

#define PT_DOT                         29

#define PT_LCURLY                      30

#define PT_RCURLY                      31

#define PT_STRLIT                      32

#define PT_LBRACKET                    33

#define PT_RBRACKET                    34

#define PT_EQUAL                       35

#define PT_NOTEQUAL                    36

#define PT_NOTEQUAL2                   37

#define PT_GEQUAL                      38

#define PT_LEQUAL                      39

#define PT_ASSIGN_PLUS                 40

#define PT_PLUS                        41

#define PT_MINUS                       42

#define PT_MULTIPLY                    43

#define PT_DIV                         44

#define PT_LOGIC_OR                    45

#define PT_OR                          46

#define PT_LOGIC_AND                   47

#define PT_AND                         48

#define PT_NOT                         49

#define PT_NEG                         50

#define PT_XOR                         51

#define PT_SHL                         52

#define PT_SHR                         53

#define PT_PERCENT                     54

#define PT_DOLLAR                      55

#define PT_COND                        56

#define PT_COMMA                       57

#define PT_COLON                       58

#define PT_LESS                        59

#define PT_GREATER                     60

#define PT_DECIMALLIT                  61

#define PT_OCTALLIT                    62

#define PT_HEXLIT                      63

#endif

/**************** End token definitions ***************************************/

/* The next sections is a series of control #defines.

** various aspects of the generated parser.

**    YYCODETYPE         is the data type used to store the integer codes

**                       that represent terminal and non-terminal symbols.

**                       "unsigned char" is used if there are fewer than

**                       256 symbols.  Larger types otherwise.

**    YYNOCODE           is a number of type YYCODETYPE that is not used for

**                       any terminal or nonterminal symbol.

**    YYFALLBACK         If defined, this indicates that one or more tokens

**                       (also known as: "terminal symbols") have fall-back

**                       values which should be used if the original symbol

**                       would not parse.  This permits keywords to sometimes

**                       be used as identifiers, for example.

**    YYACTIONTYPE       is the data type used for "action codes" - numbers

**                       that indicate what to do in response to the next

**                       token.

**    ProtobufLangParserTOKENTYPE     is the data type used for minor type for terminal

**                       symbols.  Background: A "minor type" is a semantic

**                       value associated with a terminal or non-terminal

**                       symbols.  For example, for an "ID" terminal symbol,

**                       the minor type might be the name of the identifier.

**                       Each non-terminal can have a different minor type.

**                       Terminal symbols all have the same minor type, though.

**                       This macros defines the minor type for terminal

**                       symbols.

**    YYMINORTYPE        is the data type used for all minor types.

**                       This is typically a union of many types, one of

**                       which is ProtobufLangParserTOKENTYPE.  The entry in the union

**                       for terminal symbols is called "yy0".

**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If

**                       zero the stack is dynamically sized using realloc()

**    ProtobufLangParserARG_SDECL     A static variable declaration for the %extra_argument

**    ProtobufLangParserARG_PDECL     A parameter declaration for the %extra_argument

**    ProtobufLangParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter

**    ProtobufLangParserARG_STORE     Code to store %extra_argument into yypParser

**    ProtobufLangParserARG_FETCH     Code to extract %extra_argument from yypParser

**    ProtobufLangParserCTX_*         As ProtobufLangParserARG_ except for %extra_context

**    YYERRORSYMBOL      is the code number of the error symbol.  If not

**                       defined, then do no error processing.

**    YYNSTATE           the combined number of states.

**    YYNRULE            the number of rules in the grammar

**    YYNTOKEN           Number of terminal symbols

**    YY_MAX_SHIFT       Maximum value for shift actions

**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions

**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions

**    YY_ERROR_ACTION    The yy_action[] code for syntax error

**    YY_ACCEPT_ACTION   The yy_action[] code for accept

**    YY_NO_ACTION       The yy_action[] code for no-op

**    YY_MIN_REDUCE      Minimum value for reduce actions

**    YY_MAX_REDUCE      Maximum value for reduce actions

*/

#ifndef INTERFACE

# define INTERFACE 1

#endif

/************* Begin control #defines *****************************************/

#define YYCODETYPE unsigned char

#define YYNOCODE 131

#define YYACTIONTYPE unsigned short int

#define ProtobufLangParserTOKENTYPE  protobuf_lang_token_t* 

typedef union {

  int yyinit;

  ProtobufLangParserTOKENTYPE yy0;

  pbl_node_t* yy93;

  int yy116;

  protobuf_lang_token_t* yy118;

  uint64_t yy180;

  gchar* yy254;

} YYMINORTYPE;

#ifndef YYSTACKDEPTH

#define YYSTACKDEPTH 100

#endif

#define ProtobufLangParserARG_SDECL  protobuf_lang_state_t *state ;

#define ProtobufLangParserARG_PDECL , protobuf_lang_state_t *state 

#define ProtobufLangParserARG_PARAM ,state 

#define ProtobufLangParserARG_FETCH  protobuf_lang_state_t *state =yypParser->state ;

#define ProtobufLangParserARG_STORE yypParser->state =state ;

#define ProtobufLangParserCTX_SDECL

#define ProtobufLangParserCTX_PDECL

#define ProtobufLangParserCTX_PARAM

#define ProtobufLangParserCTX_FETCH

#define ProtobufLangParserCTX_STORE

#define YYFALLBACK 1

#define YYNSTATE             166

#define YYNRULE              191

#define YYNRULE_WITH_ACTION  78

#define YYNTOKEN             64

#define YY_MAX_SHIFT         165

#define YY_MIN_SHIFTREDUCE   338

#define YY_MAX_SHIFTREDUCE   528

#define YY_ERROR_ACTION      529

#define YY_ACCEPT_ACTION     530

#define YY_NO_ACTION         531

#define YY_MIN_REDUCE        532

#define YY_MAX_REDUCE        722

/************* End control #defines *******************************************/

#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

/* Define the yytestcase() macro to be a no-op if is not already defined

** otherwise.

**

** Applications can choose to define yytestcase() in the %include section

** to a macro that can assist in verifying code coverage.  For production

** code the yytestcase() macro should be turned off.  But it is useful

** for testing.

*/

#ifndef yytestcase

# define yytestcase(X)

#endif

/* Next are the tables used to determine what action to take based on the

** current state and lookahead token.  These tables are used to implement

** functions that take a state number and lookahead value and return an

** action integer.

**

** Suppose the action integer is N.  Then the action is determined as

** follows

**

**   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead

**                                      token onto the stack and goto state N.

**

**   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then

**     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.

**

**   N == YY_ERROR_ACTION               A syntax error has occurred.

**

**   N == YY_ACCEPT_ACTION              The parser accepts its input.

**

**   N == YY_NO_ACTION                  No such action.  Denotes unused

**                                      slots in the yy_action[] table.

**

**   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE

**     and YY_MAX_REDUCE

**

** The action table is constructed as a single large table named yy_action[].

** Given state S and lookahead X, the action is computed as either:

**

**    (A)   N = yy_action[ yy_shift_ofst[S] + X ]

**    (B)   N = yy_default[S]

**

** The (A) formula is preferred.  The B formula is used instead if

** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X.

**

** The formulas above are for computing the action when the lookahead is

** a terminal symbol.  If the lookahead is a non-terminal (as occurs after

** a reduce action) then the yy_reduce_ofst[] array is used in place of

** the yy_shift_ofst[] array.

**

** The following are the tables generated in this section:

**

**  yy_action[]        A single table containing all actions.

**  yy_lookahead[]     A table containing the lookahead for each entry in

**                     yy_action.  Used to detect hash collisions.

**  yy_shift_ofst[]    For each state, the offset into yy_action for

**                     shifting terminals.

**  yy_reduce_ofst[]   For each state, the offset into yy_action for

**                     shifting non-terminals after a reduce.

**  yy_default[]       Default action for each state.

**

*********** Begin parsing tables **********************************************/

#define YY_ACTTAB_COUNT (518)

static const YYACTIONTYPE yy_action[] = {

 /*     0 */   558,  528,  155,  579,  113,  112,  578,   99,  578,  101,

 /*    10 */   578,  141,  578,  143,  578,  103,  578,  105,  135,   39,

 /*    20 */    39,  593,  687,  688,  528,  444,  461,  434,  435,  462,

 /*    30 */    91,  427,  430,  436,  437,  438,  439,  440,  441,  442,

 /*    40 */   443,  445,  446,  447,  448,  449,  450,  451,  452,  453,

 /*    50 */   454,  455,  456,  457,  458,  459,  460,  463,  464,  465,

 /*    60 */   466,  405,  406,  407,  528,   39,  528,   27,   27,   33,

 /*    70 */    33,   25,  380,  381,  382,   60,  136,    5,   66,   61,

 /*    80 */    55,   24,   67,  563,   96,  682,  683,   50,  119,  526,

 /*    90 */   598,  528,  564,   95,  390,   98,  580,  560,   25,  380,

 /*   100 */   381,  382,   60,  136,    5,   66,   61,   55,   24,   67,

 /*   110 */   133,  677,  678,   27,  160,   33,  526,  133,  528,  697,

 /*   120 */   602,  391,  528,    4,  696,   25,  380,  381,  382,   60,

 /*   130 */   136,    5,   66,   61,   55,   24,   67,   46,   64,  405,

 /*   140 */   406,  407,  577,  526,   25,   25,  536,  536,  351,  530,

 /*   150 */   165,   69,   68,  536,  603,  549,  536,   53,   49,  547,

 /*   160 */   528,  548,  526,  526,  499,  698,  536,  367,  491,  111,

 /*   170 */   551,   14,  552,  550,  665,  613,  614,  615,  616,  542,

 /*   180 */   528,   52,  405,  406,  407,  667,  669,  124,  559,  598,

 /*   190 */    73,  666,  668,   79,   25,   42,  150,   27,   27,  139,

 /*   200 */    59,   66,  149,   55,  577,   67,   54,  149,  528,   91,

 /*   210 */   414,  414,  526,  528,  528,   25,  380,  381,  382,  528,

 /*   220 */    38,   37,  588,   61,   93,  544,  160,  380,  381,  382,

 /*   230 */   153,  582,  602,  526,   61,  691,  153,  623,  392,   78,

 /*   240 */   405,  406,  407,   27,  526,  414,  153,  690,  692,  400,

 /*   250 */   706,   92,   94,   97,   97,  142,   92,  107,   46,   64,

 /*   260 */   106,  151,  107,  577,  160,  142,  603,  156,   25,  675,

 /*   270 */   602,  626,  703,  160,  405,  406,  407,  583,  162,  602,

 /*   280 */   596,  528,  627,   63,  705,  625,  526,  577,  555,   36,

 /*   290 */    36,  486,   33,   33,  597,  127,  528,  598,   80,   81,

 /*   300 */    33,   33,   51,   25,  603,   33,   33,  711,  117,    5,

 /*   310 */   671,  672,  117,  603,  607,  676,  606,  670,  100,  580,

 /*   320 */   144,  526,   72,   71,  161,  414,  359,  581,   33,   33,

 /*   330 */   144,  102,  580,   36,   36,   36,  528,  528,   33,  152,

 /*   340 */   108,  108,  405,  406,  407,   70,   33,  528,  605,  128,

 /*   350 */   604,   33,   62,  129,  104,  580,  528,  115,  128,  598,

 /*   360 */     9,  129,   78,    4,   77,  405,  406,  407,  528,   78,

 /*   370 */   116,   10,  598,   78,   33,   77,  118,  543,  598,   36,

 /*   380 */    11,  122,   78,  598,   77,  674,  123,  130,  598,  598,

 /*   390 */   114,  134,   12,  138,   78,  577,   77,  140,  138,  146,

 /*   400 */   148,  710,    4,  140,  146,  148,  710,  157,  340,  158,

 /*   410 */   157,  158,  339,  490,  415,  485,  109,   82,  415,   83,

 /*   420 */   398,  396,  131,  378,  132,  137,  145,   15,   16,  164,

 /*   430 */    17,  376,  147,  506,  505,  154,  345,  344,   18,  159,

 /*   440 */   343,  163,  415,  415,  110,   21,  415,   22,   22,   22,

 /*   450 */    40,   41,    8,    7,    1,   22,    6,    2,   23,    3,

 /*   460 */    20,   74,   13,   75,   76,   42,  612,  375,   48,   47,

 /*   470 */   374,  372,   43,  120,  121,  373,  371,  125,   44,   84,

 /*   480 */   126,   28,   45,   85,  500,  397,   56,   57,   58,  395,

 /*   490 */    29,   62,   86,   30,   87,   31,   32,   88,  379,  377,

 /*   500 */   611,   34,   35,  507,  610,  362,  415,   26,  531,  424,

 /*   510 */   531,   89,  347,   19,   65,   90,  423,  346,

};

static const YYCODETYPE yy_lookahead[] = {

 /*     0 */   104,    1,  106,  104,    2,    3,  104,  105,  104,  105,

 /*    10 */   104,  105,  104,  105,  104,  105,  104,  105,   67,   70,

 /*    20 */    71,   70,  113,  114,    1,   25,   26,   27,   28,   29,

 /*    30 */    30,   31,   32,   33,   34,   35,   36,   37,   38,   39,

 /*    40 */    40,   41,   42,   43,   44,   45,   46,   47,   48,   49,

 /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,   58,   59,

 /*    60 */    60,   61,   62,   63,    1,  116,    1,   70,   71,   70,

 /*    70 */    71,    8,    9,   10,   11,   12,   13,   14,   15,   16,

 /*    80 */    17,   18,   19,   85,   86,  113,  114,   22,   68,   26,

 /*    90 */    70,    1,   94,   95,   31,   96,   97,  104,    8,    9,

 /*   100 */    10,   11,   12,   13,   14,   15,   16,   17,   18,   19,

 /*   110 */    70,  113,  114,  116,   64,  116,   26,   77,    1,   69,

 /*   120 */    70,   31,    1,   81,  127,    8,    9,   10,   11,   12,

 /*   130 */    13,   14,   15,   16,   17,   18,   19,   65,   66,   61,

 /*   140 */    62,   63,   70,   26,    8,    8,   82,   83,   31,  107,

 /*   150 */   108,  109,  110,   89,  104,   83,   92,   21,   22,   87,

 /*   160 */     1,   89,   26,   26,   26,  115,  102,   31,   31,   64,

 /*   170 */    98,   33,  100,  101,  102,  111,  112,  113,  114,   70,

 /*   180 */     1,   22,   61,   62,   63,  113,  114,   68,  104,   70,

 /*   190 */     4,  119,  120,    7,    8,   57,   64,   70,   71,   65,

 /*   200 */    66,   15,   70,   17,   70,   19,   20,   75,    1,   30,

 /*   210 */    32,   32,   26,    1,    1,    8,    9,   10,   11,    1,

 /*   220 */    41,   42,   88,   16,   64,  116,   64,    9,   10,   11,

 /*   230 */   104,   69,   70,   26,   16,  101,  104,   70,   31,   27,

 /*   240 */    61,   62,   63,  116,   26,   32,  104,  113,  114,   31,

 /*   250 */    70,  125,   64,  126,  127,   70,  130,  125,   65,   66,

 /*   260 */   128,  129,  130,   70,   64,   80,  104,   70,    8,   69,

 /*   270 */    70,  104,  130,   64,   61,   62,   63,  115,   69,   70,

 /*   280 */    87,    1,  115,   66,  104,  118,   26,   70,   91,   70,

 /*   290 */    71,   31,   70,   71,  101,   68,    1,   70,    5,    6,

 /*   300 */    70,   71,   22,    8,  104,   70,   71,  114,   70,   14,

 /*   310 */   113,  114,   74,  104,   70,  115,   70,  120,   96,   97,

 /*   320 */    70,   26,   41,   42,  115,   32,   31,   97,   70,   71,

 /*   330 */    80,   96,   97,   70,   71,  116,    1,    1,  116,   64,

 /*   340 */   121,  122,   61,   62,   63,   41,  116,    1,  104,   70,

 /*   350 */   104,  116,   16,   70,   96,   97,    1,   68,   79,   70,

 /*   360 */    25,   78,   27,   81,   29,   61,   62,   63,    1,   27,

 /*   370 */    68,   25,   70,   27,  116,   29,   68,  116,   70,  116,

 /*   380 */    25,   68,   27,   70,   29,  122,   68,   68,   70,   70,

 /*   390 */   108,   66,   25,   70,   27,   70,   29,   70,   75,   70,

 /*   400 */    70,   70,   81,   76,   75,   75,   75,   70,   26,   70,

 /*   410 */    73,   72,   26,   26,   32,   26,   64,   30,   32,   30,

 /*   420 */    26,   26,   34,   26,   34,   34,   34,   33,   33,  108,

 /*   430 */    33,   26,   34,   26,   26,   34,   26,   26,   33,   70,

 /*   440 */    26,   70,   32,   32,   64,   57,   32,   57,   57,   57,

 /*   450 */   124,  123,   93,  103,   84,   57,   99,   84,   57,   84,

 /*   460 */   117,   25,   90,   25,   57,   57,    0,   28,   27,   57,

 /*   470 */    28,   28,   27,   23,   28,   28,   28,   23,   27,   30,

 /*   480 */    28,   25,   27,   30,   26,   26,   60,   57,   59,   26,

 /*   490 */    25,   16,   30,   25,   30,   25,   25,   30,   26,   26,

 /*   500 */     0,   25,   24,   26,    0,   26,   32,   25,  131,   26,

 /*   510 */   131,   30,   28,   33,   57,   30,   26,   26,  131,  131,

 /*   520 */   131,  131,  131,  131,  131,  131,  131,  131,  131,  131,

 /*   530 */   131,  131,  131,  131,  131,  131,  131,  131,  131,  131,

 /*   540 */   131,  131,  131,  131,  131,  131,  131,  131,  131,  131,

 /*   550 */   131,  131,  131,  131,  131,  131,  131,  131,  131,  131,

 /*   560 */   131,  131,  131,  131,  131,  131,  131,  131,  131,  131,

 /*   570 */   131,  131,  131,  131,  131,  131,  131,  131,  131,  131,

 /*   580 */   131,  131,

};

#define YY_SHIFT_COUNT    (165)

#define YY_SHIFT_MIN      (0)

#define YY_SHIFT_MAX      (504)

static const unsigned short int yy_shift_ofst[] = {

 /*     0 */     2,   63,   90,  117,  186,  213,  207,  218,  136,  179,

 /*    10 */   179,  179,  179,  295,  212,  212,  212,  212,  212,  212,

 /*    20 */     0,  212,  212,  212,   78,  212,  281,  335,  304,  304,

 /*    30 */   304,  304,  304,  346,  304,  121,  355,  121,  121,  367,

 /*    40 */   137,  260,   78,   65,  159,  280,  336,   23,   23,   23,

 /*    50 */    23,   23,   23,   23,   23,   23,   23,   23,   23,   23,

 /*    60 */    23,   23,   23,   23,   23,   23,   23,   23,  518,  518,

 /*    70 */    78,   78,   78,  293,  178,  178,  178,  342,   23,   23,

 /*    80 */   178,  178,  518,  518,  518,  518,  518,  518,  518,  518,

 /*    90 */   518,  518,  138,  382,  386,  387,  389,  388,  390,  394,

 /*   100 */   391,  395,  392,  397,  398,  405,  407,  408,  401,  410,

 /*   110 */   411,  414,  436,  438,  466,  439,  412,  441,  442,  443,

 /*   120 */   445,  450,  446,  447,  448,  451,  454,  452,  455,  449,

 /*   130 */   453,  458,  459,  456,  426,  430,  429,  463,  465,  475,

 /*   140 */   462,  464,  468,  467,  470,  472,  471,  473,  476,  457,

 /*   150 */   474,  477,  474,  478,  479,  480,  482,  481,  485,  484,

 /*   160 */   474,  483,  490,  491,  500,  504,

};

#define YY_REDUCE_COUNT (91)

#define YY_REDUCE_MIN   (-104)

#define YY_REDUCE_MAX   (380)

static const short yy_reduce_ofst[] = {

 /*     0 */    42,   72,   72,   72,   64,  132,  134,  193,   -2,   50,

 /*    10 */   162,  200,  209,  197,  127,   -1,  222,  235,  258,  219,

 /*    20 */   167,   -3,  230,  263,  126,  -51, -104,  109,  -98,  -96,

 /*    30 */   -94,  -92,  -90,  109,  -88,  180,  109,  244,  246,  109,

 /*    40 */   -91,  -28,  142,   20,  119,  227,  217,  289,  302,  238,

 /*    50 */   308,  313,  318,  279,  283,  319,   40,  325,  -49,  323,

 /*    60 */   327,  185,  250,  329,  330,  331,  337,  339,  282,  321,

 /*    70 */  -101,   -7,   84,  105,  160,  188,  275,  261,  369,  371,

 /*    80 */   352,  380,  326,  328,  359,  350,  357,  370,  373,  372,

 /*    90 */   375,  343,

};

static const YYACTIONTYPE yy_default[] = {

 /*     0 */   535,  529,  529,  529,  532,  529,  529,  529,  529,  529,

 /*    10 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*    20 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*    30 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*    40 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*    50 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*    60 */   529,  529,  529,  529,  529,  529,  529,  529,  535,  535,

 /*    70 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*    80 */   529,  529,  686,  681,  562,  595,  587,  546,  546,  554,

 /*    90 */   546,  622,  529,  529,  529,  529,  529,  529,  529,  529,

 /*   100 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*   110 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*   120 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*   130 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  529,

 /*   140 */   529,  529,  529,  529,  529,  529,  529,  529,  529,  709,

 /*   150 */   707,  529,  708,  704,  529,  557,  529,  529,  529,  529,

 /*   160 */   721,  529,  529,  529,  529,  529,

};

/********** End of lemon-generated parsing tables *****************************/

/* The next table maps tokens (terminal symbols) into fallback tokens.

** If a construct like the following:

**

**      %fallback ID X Y Z.

**

** appears in the grammar, then ID becomes a fallback token for X, Y,

** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser

** but it does not parse, the type of the token is changed to ID and

** the parse is retried before an error is thrown.

**

** This feature can be used, for example, to cause some keywords in a language

** to revert to identifiers if they keyword does not apply in the context where

** it appears.

*/

#ifdef YYFALLBACK

static const YYCODETYPE yyFallback[] = {

    0,  /*          $ => nothing */

    0,  /*   PT_IDENT => nothing */

    1,  /*  PT_SYNTAX => PT_IDENT */

    1,  /* PT_EDITION => PT_IDENT */

    1,  /*  PT_IMPORT => PT_IDENT */

    1,  /*    PT_WEAK => PT_IDENT */

    1,  /*  PT_PUBLIC => PT_IDENT */

    1,  /* PT_PACKAGE => PT_IDENT */

    1,  /*  PT_OPTION => PT_IDENT */

    1,  /* PT_REQUIRED => PT_IDENT */

    1,  /* PT_OPTIONAL => PT_IDENT */

    1,  /* PT_REPEATED => PT_IDENT */

    1,  /*   PT_ONEOF => PT_IDENT */

    1,  /*     PT_MAP => PT_IDENT */

    1,  /* PT_RESERVED => PT_IDENT */

    1,  /*    PT_ENUM => PT_IDENT */

    1,  /*   PT_GROUP => PT_IDENT */

    1,  /*  PT_EXTEND => PT_IDENT */

    1,  /* PT_EXTENSIONS => PT_IDENT */

    1,  /* PT_MESSAGE => PT_IDENT */

    1,  /* PT_SERVICE => PT_IDENT */

    1,  /*     PT_RPC => PT_IDENT */

    1,  /*  PT_STREAM => PT_IDENT */

    1,  /* PT_RETURNS => PT_IDENT */

    1,  /*      PT_TO => PT_IDENT */

    0,  /*  PT_ASSIGN => nothing */

    0,  /* PT_SEMICOLON => nothing */

    0,  /*  PT_LPAREN => nothing */

    0,  /*  PT_RPAREN => nothing */

    0,  /*     PT_DOT => nothing */

    0,  /*  PT_LCURLY => nothing */

    0,  /*  PT_RCURLY => nothing */

    0,  /*  PT_STRLIT => nothing */

    0,  /* PT_LBRACKET => nothing */

    0,  /* PT_RBRACKET => nothing */

    0,  /*   PT_EQUAL => nothing */

    0,  /* PT_NOTEQUAL => nothing */

    0,  /* PT_NOTEQUAL2 => nothing */

    0,  /*  PT_GEQUAL => nothing */

    0,  /*  PT_LEQUAL => nothing */

    0,  /* PT_ASSIGN_PLUS => nothing */

    0,  /*    PT_PLUS => nothing */

    0,  /*   PT_MINUS => nothing */

    0,  /* PT_MULTIPLY => nothing */

    0,  /*     PT_DIV => nothing */

    0,  /* PT_LOGIC_OR => nothing */

    0,  /*      PT_OR => nothing */

    0,  /* PT_LOGIC_AND => nothing */

    0,  /*     PT_AND => nothing */

    0,  /*     PT_NOT => nothing */

    0,  /*     PT_NEG => nothing */

    0,  /*     PT_XOR => nothing */

    0,  /*     PT_SHL => nothing */

    0,  /*     PT_SHR => nothing */

    0,  /* PT_PERCENT => nothing */

    0,  /*  PT_DOLLAR => nothing */

    0,  /*    PT_COND => nothing */

    0,  /*   PT_COMMA => nothing */

    0,  /*   PT_COLON => nothing */

    0,  /*    PT_LESS => nothing */

    0,  /* PT_GREATER => nothing */

    0,  /* PT_DECIMALLIT => nothing */

    0,  /* PT_OCTALLIT => nothing */

    0,  /*  PT_HEXLIT => nothing */

};

#endif /* YYFALLBACK */

/* The following structure represents a single element of the

** parser's stack.  Information stored includes:

**

**   +  The state number for the parser at this level of the stack.

**

**   +  The value of the token stored at this level of the stack.

**      (In other words, the "major" token.)

**

**   +  The semantic value stored at this level of the stack.  This is

**      the information used by the action routines in the grammar.

**      It is sometimes called the "minor" token.

**

** After the "shift" half of a SHIFTREDUCE action, the stateno field

** actually contains the reduce action for the second half of the

** SHIFTREDUCE.

*/

struct yyStackEntry {

  YYACTIONTYPE stateno;  /* The state-number, or reduce action in SHIFTREDUCE */

  YYCODETYPE major;      /* The major token value.  This is the code

                         ** number for the token at this stack level */

  YYMINORTYPE minor;     /* The user-supplied minor token value.  This

                         ** is the value of the token  */

};

typedef struct yyStackEntry yyStackEntry;

/* The state of the parser is completely contained in an instance of

** the following structure */

struct yyParser {

  yyStackEntry *yytos;          /* Pointer to top element of the stack */

#ifdef YYTRACKMAXSTACKDEPTH

  int yyhwm;                    /* High-water mark of the stack */

#endif

#ifndef YYNOERRORRECOVERY

  int yyerrcnt;                 /* Shifts left before out of the error */

#endif

  ProtobufLangParserARG_SDECL                /* A place to hold %extra_argument */

  ProtobufLangParserCTX_SDECL                /* A place to hold %extra_context */

#if YYSTACKDEPTH<=0

  int yystksz;                  /* Current side of the stack */

  yyStackEntry *yystack;        /* The parser's stack */

  yyStackEntry yystk0;          /* First stack entry */

#else

  yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */

  yyStackEntry *yystackEnd;            /* Last entry in the stack */

#endif

};

typedef struct yyParser yyParser;

#include <assert.h>

#ifndef NDEBUG

#include <stdio.h>

static FILE *yyTraceFILE = 0;

static char *yyTracePrompt = 0;

#endif /* NDEBUG */

#ifndef NDEBUG

/*

** Turn parser tracing on by giving a stream to which to write the trace

** and a prompt to preface each trace message.  Tracing is turned off

** by making either argument NULL

**

** Inputs:

** <ul>

** <li> A FILE* to which trace output should be written.

**      If NULL, then tracing is turned off.

** <li> A prefix string written at the beginning of every

**      line of trace output.  If NULL, then tracing is

**      turned off.

** </ul>

**

** Outputs:

** None.

*/

void ProtobufLangParserTrace(FILE *TraceFILE, char *zTracePrompt){

  yyTraceFILE = TraceFILE;

  yyTracePrompt = zTracePrompt;

  if( yyTraceFILE==0 ) yyTracePrompt = 0;

  else if( yyTracePrompt==0 ) yyTraceFILE = 0;

}

#endif /* NDEBUG */

#if defined(YYCOVERAGE) || !defined(NDEBUG)

/* For tracing shifts, the names of all terminals and nonterminals

** are required.  The following table supplies these names */

static const char *const yyTokenName[] = {

  /*    0 */ "$",

  /*    1 */ "PT_IDENT",

  /*    2 */ "PT_SYNTAX",

  /*    3 */ "PT_EDITION",

  /*    4 */ "PT_IMPORT",

  /*    5 */ "PT_WEAK",

  /*    6 */ "PT_PUBLIC",

  /*    7 */ "PT_PACKAGE",

  /*    8 */ "PT_OPTION",

  /*    9 */ "PT_REQUIRED",

  /*   10 */ "PT_OPTIONAL",

  /*   11 */ "PT_REPEATED",

  /*   12 */ "PT_ONEOF",

  /*   13 */ "PT_MAP",

  /*   14 */ "PT_RESERVED",

  /*   15 */ "PT_ENUM",

  /*   16 */ "PT_GROUP",

  /*   17 */ "PT_EXTEND",

  /*   18 */ "PT_EXTENSIONS",

  /*   19 */ "PT_MESSAGE",

  /*   20 */ "PT_SERVICE",

  /*   21 */ "PT_RPC",

  /*   22 */ "PT_STREAM",

  /*   23 */ "PT_RETURNS",

  /*   24 */ "PT_TO",

  /*   25 */ "PT_ASSIGN",

  /*   26 */ "PT_SEMICOLON",

  /*   27 */ "PT_LPAREN",

  /*   28 */ "PT_RPAREN",

  /*   29 */ "PT_DOT",

  /*   30 */ "PT_LCURLY",

  /*   31 */ "PT_RCURLY",

  /*   32 */ "PT_STRLIT",

  /*   33 */ "PT_LBRACKET",

  /*   34 */ "PT_RBRACKET",

  /*   35 */ "PT_EQUAL",

  /*   36 */ "PT_NOTEQUAL",

  /*   37 */ "PT_NOTEQUAL2",

  /*   38 */ "PT_GEQUAL",

  /*   39 */ "PT_LEQUAL",

  /*   40 */ "PT_ASSIGN_PLUS",

  /*   41 */ "PT_PLUS",

  /*   42 */ "PT_MINUS",

  /*   43 */ "PT_MULTIPLY",

  /*   44 */ "PT_DIV",

  /*   45 */ "PT_LOGIC_OR",

  /*   46 */ "PT_OR",

  /*   47 */ "PT_LOGIC_AND",

  /*   48 */ "PT_AND",

  /*   49 */ "PT_NOT",

  /*   50 */ "PT_NEG",

  /*   51 */ "PT_XOR",

  /*   52 */ "PT_SHL",

  /*   53 */ "PT_SHR",

  /*   54 */ "PT_PERCENT",

  /*   55 */ "PT_DOLLAR",

  /*   56 */ "PT_COND",

  /*   57 */ "PT_COMMA",

  /*   58 */ "PT_COLON",

  /*   59 */ "PT_LESS",

  /*   60 */ "PT_GREATER",

  /*   61 */ "PT_DECIMALLIT",

  /*   62 */ "PT_OCTALLIT",

  /*   63 */ "PT_HEXLIT",

  /*   64 */ "strLit",

  /*   65 */ "label",

  /*   66 */ "type",

  /*   67 */ "keyType",

  /*   68 */ "messageType",

  /*   69 */ "constant",

  /*   70 */ "exIdent",

  /*   71 */ "optionName",

  /*   72 */ "messageName",

  /*   73 */ "enumName",

  /*   74 */ "streamName",

  /*   75 */ "fieldName",

  /*   76 */ "oneofName",

  /*   77 */ "mapName",

  /*   78 */ "serviceName",

  /*   79 */ "rpcName",

  /*   80 */ "groupName",

  /*   81 */ "protoBody",

  /*   82 */ "topLevelDef",

  /*   83 */ "message",

  /*   84 */ "messageBody",

  /*   85 */ "rpc",

  /*   86 */ "rpcDecl",

  /*   87 */ "field",

  /*   88 */ "oneofField",

  /*   89 */ "enum",

  /*   90 */ "enumBody",

  /*   91 */ "enumField",

  /*   92 */ "service",

  /*   93 */ "serviceBody",

  /*   94 */ "stream",

  /*   95 */ "streamDecl",

  /*   96 */ "fieldOptions",

  /*   97 */ "fieldOption",

  /*   98 */ "oneof",

  /*   99 */ "oneofBody",

  /*  100 */ "mapField",

  /*  101 */ "group",

  /*  102 */ "extend",

  /*  103 */ "extendBody",

  /*  104 */ "intLit",

  /*  105 */ "fieldNumber",

  /*  106 */ "enumNumber",

  /*  107 */ "proto",

  /*  108 */ "wholeProtoBody",

  /*  109 */ "syntax",

  /*  110 */ "edition",

  /*  111 */ "import",

  /*  112 */ "package",

  /*  113 */ "option",

  /*  114 */ "emptyStatement",

  /*  115 */ "customOptionValue",

  /*  116 */ "extIdentInParentheses",

  /*  117 */ "customOptionBody",

  /*  118 */ "symbolsWithoutCurly",

  /*  119 */ "extensions",

  /*  120 */ "reserved",

  /*  121 */ "enumValueOptions",

  /*  122 */ "enumValueOption",

  /*  123 */ "rpcBody",

  /*  124 */ "streamBody",

  /*  125 */ "ranges",

  /*  126 */ "declarations",

  /*  127 */ "declaration",

  /*  128 */ "quoteFieldNames",

  /*  129 */ "reservedIdent",

  /*  130 */ "range",

};

#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */

#ifndef NDEBUG

/* For tracing reduce actions, the names of all rules are required.

*/

static const char *const yyRuleName[] = {

 /*   0 */ "wholeProtoBody ::= protoBody",

 /*   1 */ "syntax ::= PT_SYNTAX PT_ASSIGN strLit PT_SEMICOLON",

 /*   2 */ "edition ::= PT_EDITION PT_ASSIGN strLit PT_SEMICOLON",

 /*   3 */ "protoBody ::=",

 /*   4 */ "protoBody ::= protoBody topLevelDef",

 /*   5 */ "import ::= PT_IMPORT strLit PT_SEMICOLON",

 /*   6 */ "import ::= PT_IMPORT PT_PUBLIC strLit PT_SEMICOLON",

 /*   7 */ "import ::= PT_IMPORT PT_WEAK strLit PT_SEMICOLON",

 /*   8 */ "package ::= PT_PACKAGE exIdent PT_SEMICOLON",

 /*   9 */ "extIdentInParentheses ::= PT_LPAREN exIdent PT_RPAREN",

 /*  10 */ "optionName ::= optionName exIdent",

 /*  11 */ "optionName ::= optionName PT_DOT extIdentInParentheses",

 /*  12 */ "optionName ::= optionName extIdentInParentheses",

 /*  13 */ "message ::= PT_MESSAGE messageName PT_LCURLY messageBody PT_RCURLY",

 /*  14 */ "messageBody ::=",

 /*  15 */ "messageBody ::= messageBody field",

 /*  16 */ "messageBody ::= messageBody enum",

 /*  17 */ "messageBody ::= messageBody message",

 /*  18 */ "messageBody ::= messageBody group",

 /*  19 */ "messageBody ::= messageBody oneof",

 /*  20 */ "messageBody ::= messageBody mapField",

 /*  21 */ "enum ::= PT_ENUM enumName PT_LCURLY enumBody PT_RCURLY",

 /*  22 */ "enumBody ::=",

 /*  23 */ "enumBody ::= enumBody enumField",

 /*  24 */ "enumField ::= exIdent PT_ASSIGN enumNumber PT_LBRACKET enumValueOptions PT_RBRACKET PT_SEMICOLON",

 /*  25 */ "enumField ::= exIdent PT_ASSIGN enumNumber",

 /*  26 */ "enumNumber ::= intLit",

 /*  27 */ "enumNumber ::= PT_PLUS intLit",

 /*  28 */ "enumNumber ::= PT_MINUS intLit",

 /*  29 */ "service ::= PT_SERVICE serviceName PT_LCURLY serviceBody PT_RCURLY",

 /*  30 */ "serviceBody ::=",

 /*  31 */ "serviceBody ::= serviceBody rpc",

 /*  32 */ "serviceBody ::= serviceBody stream",

 /*  33 */ "rpcDecl ::= PT_RPC rpcName PT_LPAREN messageType PT_RPAREN PT_RETURNS PT_LPAREN messageType PT_RPAREN",

 /*  34 */ "rpcDecl ::= PT_RPC rpcName PT_LPAREN PT_STREAM messageType PT_RPAREN PT_RETURNS PT_LPAREN messageType PT_RPAREN",

 /*  35 */ "rpcDecl ::= PT_RPC rpcName PT_LPAREN messageType PT_RPAREN PT_RETURNS PT_LPAREN PT_STREAM messageType PT_RPAREN",

 /*  36 */ "rpcDecl ::= PT_RPC rpcName PT_LPAREN PT_STREAM messageType PT_RPAREN PT_RETURNS PT_LPAREN PT_STREAM messageType PT_RPAREN",

 /*  37 */ "streamDecl ::= PT_STREAM streamName PT_LPAREN messageType PT_COMMA messageType PT_RPAREN",

 /*  38 */ "field ::= type fieldName PT_ASSIGN fieldNumber PT_SEMICOLON",

 /*  39 */ "field ::= type fieldName PT_ASSIGN fieldNumber PT_LBRACKET fieldOptions PT_RBRACKET PT_SEMICOLON",

 /*  40 */ "field ::= label type fieldName PT_ASSIGN fieldNumber PT_SEMICOLON",

 /*  41 */ "field ::= label type fieldName PT_ASSIGN fieldNumber PT_LBRACKET fieldOptions PT_RBRACKET PT_SEMICOLON",

 /*  42 */ "label ::= PT_REQUIRED",

 /*  43 */ "label ::= PT_OPTIONAL",

 /*  44 */ "label ::= PT_REPEATED",

 /*  45 */ "type ::= exIdent",

 /*  46 */ "fieldNumber ::= intLit",

 /*  47 */ "fieldNumber ::= PT_PLUS intLit",

 /*  48 */ "fieldOptions ::= fieldOption",

 /*  49 */ "fieldOptions ::= fieldOptions PT_COMMA fieldOption",

 /*  50 */ "fieldOption ::= optionName PT_ASSIGN constant",

 /*  51 */ "fieldOption ::= optionName PT_ASSIGN customOptionValue",

 /*  52 */ "group ::= PT_GROUP groupName PT_ASSIGN fieldNumber PT_LCURLY messageBody PT_RCURLY",

 /*  53 */ "group ::= label PT_GROUP groupName PT_ASSIGN fieldNumber PT_LCURLY messageBody PT_RCURLY",

 /*  54 */ "oneof ::= PT_ONEOF oneofName PT_LCURLY oneofBody PT_RCURLY",

 /*  55 */ "oneofBody ::=",

 /*  56 */ "oneofBody ::= oneofBody oneofField",

 /*  57 */ "oneofField ::= type fieldName PT_ASSIGN fieldNumber PT_LBRACKET fieldOptions PT_RBRACKET PT_SEMICOLON",

 /*  58 */ "oneofField ::= type fieldName PT_ASSIGN fieldNumber PT_SEMICOLON",

 /*  59 */ "mapField ::= PT_MAP PT_LESS keyType PT_COMMA type PT_GREATER mapName PT_ASSIGN fieldNumber PT_LBRACKET fieldOptions PT_RBRACKET PT_SEMICOLON",

 /*  60 */ "mapField ::= PT_MAP PT_LESS keyType PT_COMMA type PT_GREATER mapName PT_ASSIGN fieldNumber PT_SEMICOLON",

 /*  61 */ "keyType ::= exIdent",

 /*  62 */ "extend ::= PT_EXTEND messageType PT_LCURLY extendBody PT_RCURLY",

 /*  63 */ "extendBody ::=",

 /*  64 */ "extendBody ::= extendBody field",

 /*  65 */ "extendBody ::= extendBody group",

 /*  66 */ "messageType ::= exIdent",

 /*  67 */ "intLit ::= PT_DECIMALLIT",

 /*  68 */ "intLit ::= PT_OCTALLIT",

 /*  69 */ "intLit ::= PT_HEXLIT",

 /*  70 */ "constant ::= exIdent",

 /*  71 */ "constant ::= intLit",

 /*  72 */ "constant ::= PT_PLUS intLit",

 /*  73 */ "constant ::= PT_MINUS intLit",

 /*  74 */ "constant ::= PT_PLUS exIdent",

 /*  75 */ "constant ::= PT_MINUS exIdent",

 /*  76 */ "strLit ::= PT_STRLIT",

 /*  77 */ "strLit ::= strLit PT_STRLIT",

 /*  78 */ "proto ::= wholeProtoBody",

 /*  79 */ "proto ::= syntax wholeProtoBody",

 /*  80 */ "proto ::= edition wholeProtoBody",

 /*  81 */ "protoBody ::= protoBody import",

 /*  82 */ "protoBody ::= protoBody package",

 /*  83 */ "protoBody ::= protoBody option",

 /*  84 */ "protoBody ::= protoBody emptyStatement",

 /*  85 */ "option ::= PT_OPTION optionName PT_ASSIGN constant PT_SEMICOLON",

 /*  86 */ "option ::= PT_OPTION optionName PT_ASSIGN customOptionValue PT_SEMICOLON",

 /*  87 */ "optionName ::= exIdent",

 /*  88 */ "optionName ::= extIdentInParentheses",

 /*  89 */ "customOptionValue ::= PT_LCURLY customOptionBody PT_RCURLY",

 /*  90 */ "customOptionBody ::=",

 /*  91 */ "customOptionBody ::= customOptionBody exIdent",

 /*  92 */ "customOptionBody ::= customOptionBody PT_STRLIT",

 /*  93 */ "customOptionBody ::= customOptionBody symbolsWithoutCurly",

 /*  94 */ "customOptionBody ::= customOptionBody intLit",

 /*  95 */ "customOptionBody ::= customOptionBody customOptionValue",

 /*  96 */ "symbolsWithoutCurly ::= PT_LPAREN",

 /*  97 */ "symbolsWithoutCurly ::= PT_RPAREN",

 /*  98 */ "symbolsWithoutCurly ::= PT_LBRACKET",

 /*  99 */ "symbolsWithoutCurly ::= PT_RBRACKET",

 /* 100 */ "symbolsWithoutCurly ::= PT_EQUAL",

 /* 101 */ "symbolsWithoutCurly ::= PT_NOTEQUAL",

 /* 102 */ "symbolsWithoutCurly ::= PT_NOTEQUAL2",

 /* 103 */ "symbolsWithoutCurly ::= PT_GEQUAL",

 /* 104 */ "symbolsWithoutCurly ::= PT_LEQUAL",

 /* 105 */ "symbolsWithoutCurly ::= PT_ASSIGN_PLUS",

 /* 106 */ "symbolsWithoutCurly ::= PT_ASSIGN",

 /* 107 */ "symbolsWithoutCurly ::= PT_PLUS",

 /* 108 */ "symbolsWithoutCurly ::= PT_MINUS",

 /* 109 */ "symbolsWithoutCurly ::= PT_MULTIPLY",

 /* 110 */ "symbolsWithoutCurly ::= PT_DIV",

 /* 111 */ "symbolsWithoutCurly ::= PT_LOGIC_OR",

 /* 112 */ "symbolsWithoutCurly ::= PT_OR",

 /* 113 */ "symbolsWithoutCurly ::= PT_LOGIC_AND",

 /* 114 */ "symbolsWithoutCurly ::= PT_AND",

 /* 115 */ "symbolsWithoutCurly ::= PT_NOT",

 /* 116 */ "symbolsWithoutCurly ::= PT_NEG",

 /* 117 */ "symbolsWithoutCurly ::= PT_XOR",

 /* 118 */ "symbolsWithoutCurly ::= PT_SHL",

 /* 119 */ "symbolsWithoutCurly ::= PT_SHR",

 /* 120 */ "symbolsWithoutCurly ::= PT_PERCENT",

 /* 121 */ "symbolsWithoutCurly ::= PT_DOLLAR",

 /* 122 */ "symbolsWithoutCurly ::= PT_COND",

 /* 123 */ "symbolsWithoutCurly ::= PT_SEMICOLON",

 /* 124 */ "symbolsWithoutCurly ::= PT_DOT",

 /* 125 */ "symbolsWithoutCurly ::= PT_COMMA",

 /* 126 */ "symbolsWithoutCurly ::= PT_COLON",

 /* 127 */ "symbolsWithoutCurly ::= PT_LESS",

 /* 128 */ "symbolsWithoutCurly ::= PT_GREATER",

 /* 129 */ "topLevelDef ::= message",

 /* 130 */ "topLevelDef ::= enum",

 /* 131 */ "topLevelDef ::= extend",

 /* 132 */ "topLevelDef ::= service",

 /* 133 */ "messageBody ::= messageBody extend",

 /* 134 */ "messageBody ::= messageBody extensions",

 /* 135 */ "messageBody ::= messageBody option",

 /* 136 */ "messageBody ::= messageBody reserved",

 /* 137 */ "messageBody ::= messageBody emptyStatement",

 /* 138 */ "enumBody ::= enumBody reserved",

 /* 139 */ "enumBody ::= enumBody option",

 /* 140 */ "enumBody ::= enumBody emptyStatement",

 /* 141 */ "enumValueOptions ::= enumValueOption",

 /* 142 */ "enumValueOptions ::= enumValueOptions PT_COMMA enumValueOption",

 /* 143 */ "enumValueOption ::= optionName PT_ASSIGN constant",

 /* 144 */ "enumValueOption ::= optionName PT_ASSIGN customOptionValue",

 /* 145 */ "serviceBody ::= serviceBody option",

 /* 146 */ "serviceBody ::= serviceBody emptyStatement",

 /* 147 */ "rpc ::= rpcDecl PT_SEMICOLON",

 /* 148 */ "rpc ::= rpcDecl PT_LCURLY rpcBody PT_RCURLY",

 /* 149 */ "rpcBody ::=",

 /* 150 */ "rpcBody ::= rpcBody option",

 /* 151 */ "rpcBody ::= rpcBody emptyStatement",

 /* 152 */ "stream ::= streamDecl PT_SEMICOLON",

 /* 153 */ "stream ::= streamDecl PT_LCURLY streamBody PT_RCURLY",

 /* 154 */ "streamBody ::=",

 /* 155 */ "streamBody ::= streamBody option",

 /* 156 */ "streamBody ::= streamBody emptyStatement",

 /* 157 */ "groupName ::= exIdent",

 /* 158 */ "oneofBody ::= oneofBody option",

 /* 159 */ "oneofBody ::= oneofBody group",

 /* 160 */ "oneofBody ::= oneofBody emptyStatement",

 /* 161 */ "extensions ::= PT_EXTENSIONS ranges PT_SEMICOLON",

 /* 162 */ "extensions ::= PT_EXTENSIONS ranges PT_LBRACKET declarations PT_RBRACKET PT_SEMICOLON",

 /* 163 */ "declarations ::= declaration",

 /* 164 */ "declarations ::= declarations PT_COMMA declaration",

 /* 165 */ "declaration ::= optionName PT_ASSIGN constant",

 /* 166 */ "declaration ::= optionName PT_ASSIGN customOptionValue",

 /* 167 */ "reserved ::= PT_RESERVED ranges PT_SEMICOLON",

 /* 168 */ "reserved ::= PT_RESERVED quoteFieldNames PT_SEMICOLON",

 /* 169 */ "reserved ::= PT_RESERVED reservedIdent PT_SEMICOLON",

 /* 170 */ "ranges ::= range",

 /* 171 */ "ranges ::= ranges PT_COMMA range",

 /* 172 */ "range ::= intLit",

 /* 173 */ "range ::= intLit PT_TO intLit",

 /* 174 */ "range ::= intLit PT_TO exIdent",

 /* 175 */ "quoteFieldNames ::= strLit",

 /* 176 */ "quoteFieldNames ::= quoteFieldNames PT_COMMA strLit",

 /* 177 */ "reservedIdent ::= fieldName",

 /* 178 */ "reservedIdent ::= fieldName PT_COMMA fieldName",

 /* 179 */ "extendBody ::= extendBody emptyStatement",

 /* 180 */ "messageName ::= exIdent",

 /* 181 */ "enumName ::= exIdent",

 /* 182 */ "streamName ::= exIdent",

 /* 183 */ "fieldName ::= exIdent",

 /* 184 */ "oneofName ::= exIdent",

 /* 185 */ "mapName ::= exIdent",

 /* 186 */ "serviceName ::= exIdent",

 /* 187 */ "rpcName ::= exIdent",

 /* 188 */ "emptyStatement ::= PT_SEMICOLON",

 /* 189 */ "constant ::= strLit",

 /* 190 */ "exIdent ::= PT_IDENT",

};

#endif /* NDEBUG */

#if YYSTACKDEPTH<=0

/*

** Try to increase the size of the parser stack.  Return the number

** of errors.  Return 0 on success.

*/

static int yyGrowStack(yyParser *p){

  int newSize;

  int idx;

  yyStackEntry *pNew;

  newSize = p->yystksz*2 + 100;

  idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;

  if( p->yystack==&p->yystk0 ){

    pNew = malloc(newSize*sizeof(pNew[0]));

    if( pNew ) pNew[0] = p->yystk0;

  }else{

    pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));

  }

  if( pNew ){

    p->yystack = pNew;

    p->yytos = &p->yystack[idx];

#ifndef NDEBUG

    if( yyTraceFILE ){

      fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",

              yyTracePrompt, p->yystksz, newSize);

    }

#endif

    p->yystksz = newSize;

  }

  return pNew==0;

}

#endif

/* Datatype of the argument to the memory allocated passed as the

** second argument to ProtobufLangParserAlloc() below.  This can be changed by

** putting an appropriate #define in the %include section of the input

** grammar.

*/

#ifndef YYMALLOCARGTYPE

# define YYMALLOCARGTYPE size_t

#endif

/* Initialize a new parser that has already been allocated.

*/

void ProtobufLangParserInit(void *yypRawParser ProtobufLangParserCTX_PDECL){

  yyParser *yypParser = (yyParser*)yypRawParser;

  ProtobufLangParserCTX_STORE

#ifdef YYTRACKMAXSTACKDEPTH

  yypParser->yyhwm = 0;

#endif

#if YYSTACKDEPTH<=0

  yypParser->yytos = NULL;

  yypParser->yystack = NULL;

  yypParser->yystksz = 0;

  if( yyGrowStack(yypParser) ){

    yypParser->yystack = &yypParser->yystk0;

    yypParser->yystksz = 1;

  }

#endif

#ifndef YYNOERRORRECOVERY

  yypParser->yyerrcnt = -1;

#endif

  yypParser->yytos = yypParser->yystack;

  yypParser->yystack[0].stateno = 0;

  yypParser->yystack[0].major = 0;

#if YYSTACKDEPTH>0

  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];

#endif

}

#ifndef ProtobufLangParser_ENGINEALWAYSONSTACK

/*

** This function allocates a new parser.

** The only argument is a pointer to a function which works like

** malloc.

**

** Inputs:

** A pointer to the function used to allocate memory.

**

** Outputs:

** A pointer to a parser.  This pointer is used in subsequent calls

** to ProtobufLangParser and ProtobufLangParserFree.

*/

void *ProtobufLangParserAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) ProtobufLangParserCTX_PDECL){

  yyParser *yypParser;

  yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );

  if( yypParser ){

    ProtobufLangParserCTX_STORE

    ProtobufLangParserInit(yypParser ProtobufLangParserCTX_PARAM);

  }

  return (void*)yypParser;

}

#endif /* ProtobufLangParser_ENGINEALWAYSONSTACK */

/* The following function deletes the "minor type" or semantic value

** associated with a symbol.  The symbol can be either a terminal

** or nonterminal. "yymajor" is the symbol code, and "yypminor" is

** a pointer to the value to be deleted.  The code used to do the

** deletions is derived from the %destructor and/or %token_destructor

** directives of the input grammar.

*/

static void yy_destructor(

  yyParser *yypParser,    /* The parser */

  YYCODETYPE yymajor,     /* Type code for object to destroy */

  YYMINORTYPE *yypminor   /* The object to be destroyed */

){

  ProtobufLangParserARG_FETCH

  ProtobufLangParserCTX_FETCH

  switch( yymajor ){

    /* Here is inserted the actions which take place when a

    ** terminal or non-terminal is destroyed.  This can happen

    ** when the symbol is popped from the stack during a

    ** reduce or during error processing or when a parser is

    ** being destroyed before it is finished parsing.

    **

    ** Note: during a reduce, the only symbols destroyed are those

    ** which appear on the RHS of the rule, but which are *not* used

    ** inside the C code.

    */

/********* Begin destructor definitions ***************************************/

      /* TERMINAL Destructor */

    case 1: /* PT_IDENT */

    case 2: /* PT_SYNTAX */

    case 3: /* PT_EDITION */

    case 4: /* PT_IMPORT */

    case 5: /* PT_WEAK */

    case 6: /* PT_PUBLIC */

    case 7: /* PT_PACKAGE */

    case 8: /* PT_OPTION */

    case 9: /* PT_REQUIRED */

    case 10: /* PT_OPTIONAL */

    case 11: /* PT_REPEATED */

    case 12: /* PT_ONEOF */

    case 13: /* PT_MAP */

    case 14: /* PT_RESERVED */

    case 15: /* PT_ENUM */

    case 16: /* PT_GROUP */

    case 17: /* PT_EXTEND */

    case 18: /* PT_EXTENSIONS */

    case 19: /* PT_MESSAGE */

    case 20: /* PT_SERVICE */

    case 21: /* PT_RPC */

    case 22: /* PT_STREAM */

    case 23: /* PT_RETURNS */

    case 24: /* PT_TO */

    case 25: /* PT_ASSIGN */

    case 26: /* PT_SEMICOLON */

    case 27: /* PT_LPAREN */

    case 28: /* PT_RPAREN */

    case 29: /* PT_DOT */

    case 30: /* PT_LCURLY */

    case 31: /* PT_RCURLY */

    case 32: /* PT_STRLIT */