bootparse.c

PostgreSQL 8.1.4的源码 适用于Linux下的开源数据库系统

     311,   315,   316,   320,   321,   325,   334,   338,   339,   343,
     344,   345,   349,   351,   353,   358,   362
};
#endif

#if YYDEBUG || YYERROR_VERBOSE
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const Int_yytname[] =
{
  "$end", "error", "$undefined", "CONST_P", "ID", "OPEN", "XCLOSE", 
  "XCREATE", "INSERT_TUPLE", "XDECLARE", "INDEX", "ON", "USING", "XBUILD", 
  "INDICES", "UNIQUE", "COMMA", "EQUALS", "LPAREN", "RPAREN", "OBJ_ID", 
  "XBOOTSTRAP", "XSHARED_RELATION", "XWITHOUT_OIDS", "NULLVAL", "low", 
  "high", "$accept", "TopLevel", "Boot_Queries", "Boot_Query", 
  "Boot_OpenStmt", "Boot_CloseStmt", "Boot_CreateStmt", "@1", "@2", 
  "Boot_InsertStmt", "@3", "Boot_DeclareIndexStmt", 
  "Boot_DeclareUniqueIndexStmt", "Boot_BuildIndsStmt", 
  "boot_index_params", "boot_index_param", "optbootstrap", 
  "optsharedrelation", "optwithoutoids", "boot_typelist", 
  "boot_type_thing", "oidspec", "optoideq", "boot_tuplelist", 
  "boot_tuple", "boot_const", "boot_ident", 0
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
   token YYLEX-NUM.  */
static const unsigned short Int_yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279,   280,   281
};
# endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const unsigned char Int_yyr1[] =
{
       0,    27,    28,    28,    29,    29,    30,    30,    30,    30,
      30,    30,    30,    31,    32,    32,    34,    35,    33,    37,
      36,    38,    39,    40,    41,    41,    42,    43,    43,    44,
      44,    45,    45,    46,    46,    47,    48,    49,    49,    50,
      50,    50,    51,    51,    51,    52,    53
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
static const unsigned char Int_yyr2[] =
{
       0,     2,     1,     0,     1,     2,     1,     1,     1,     1,
       1,     1,     1,     2,     2,     1,     0,     0,    11,     0,
       6,    11,    12,     2,     3,     1,     2,     1,     0,     1,
       0,     1,     0,     1,     3,     3,     1,     3,     0,     1,
       2,     3,     1,     1,     1,     1,     1
};

/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
   means the default is an error.  */
static const unsigned char Int_yydefact[] =
{
       3,     0,    15,    28,    38,     0,     0,     0,     2,     4,
       6,     7,     8,     9,    10,    11,    12,    46,    13,    14,
      27,    30,     0,    19,     0,     0,    23,     1,     5,    29,
      32,     0,     0,     0,     0,    31,     0,    37,    36,     0,
       0,     0,     0,    45,    44,     0,    39,    43,    42,     0,
       0,     0,     0,    20,    40,     0,     0,    16,    41,     0,
       0,     0,     0,     0,    17,    33,     0,     0,     0,     0,
       0,     0,     0,    25,     0,     0,    34,    18,    35,     0,
      21,    26,     0,    24,    22
};

/* YYDEFGOTO[NTERM-NUM]. */
static const Int_yysigned_char Int_yydefgoto[] =
{
      -1,     7,     8,     9,    10,    11,    12,    61,    70,    13,
      32,    14,    15,    16,    72,    73,    21,    30,    36,    64,
      65,    37,    23,    45,    46,    47,    38
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -39
static const Int_yysigned_char Int_yypact[] =
{
      23,    11,    11,    -3,     5,    -2,     7,    22,    23,   -39,
     -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,
     -39,    12,    10,   -39,    11,    27,   -39,   -39,   -39,   -39,
      16,    11,    24,    11,    11,   -39,    11,   -39,   -39,     2,
      29,    11,    11,   -39,   -39,     0,   -39,   -39,   -39,    11,
      30,    25,     2,   -39,   -39,    33,    11,   -39,   -39,    11,
      34,    11,    31,    11,    36,   -39,    37,    11,    32,    11,
      28,    11,    -7,   -39,    11,    11,   -39,   -39,   -39,    11,
     -39,   -39,     1,   -39,   -39
};

/* YYPGOTO[NTERM-NUM].  */
static const Int_yysigned_char Int_yypgoto[] =
{
     -39,   -39,   -39,    45,   -39,   -39,   -39,   -39,   -39,   -39,
     -39,   -39,   -39,   -39,   -19,   -22,   -39,   -39,   -39,   -39,
     -10,   -31,   -39,   -39,   -38,   -39,    -1
};

/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
   positive, shift that token.  If negative, reduce the rule which
   number is the opposite.  If zero, do what YYDEFACT says.
   If YYTABLE_NINF, syntax error.  */
#define YYTABLE_NINF -1
static const unsigned char Int_yytable[] =
{
      18,    19,    40,    43,    17,    43,    17,    54,    24,    79,
      50,    51,    80,    25,    58,    17,    52,    79,    20,    53,
      84,    26,    27,    33,    44,    22,    44,    31,     1,     2,
       3,     4,     5,    41,    29,    42,     6,    34,    48,    35,
      49,    56,    39,    57,    48,    59,    63,    77,    55,    67,
      75,    48,    69,    28,    71,    60,    82,    83,    62,    76,
      66,     0,    68,     0,     0,     0,    74,     0,    66,     0,
      78,     0,     0,    81,    74,     0,     0,     0,    74
};

static const Int_yysigned_char Int_yycheck[] =
{
       1,     2,    33,     3,     4,     3,     4,    45,    10,    16,
      41,    42,    19,    15,    52,     4,    16,    16,    21,    19,
      19,    14,     0,    24,    24,    20,    24,    17,     5,     6,
       7,     8,     9,    34,    22,    36,    13,    10,    39,    23,
      11,    11,    18,    18,    45,    12,    12,    19,    49,    18,
      18,    52,    16,     8,    17,    56,    75,    79,    59,    69,
      61,    -1,    63,    -1,    -1,    -1,    67,    -1,    69,    -1,
      71,    -1,    -1,    74,    75,    -1,    -1,    -1,    79
};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const unsigned char Int_yystos[] =
{
       0,     5,     6,     7,     8,     9,    13,    28,    29,    30,
      31,    32,    33,    36,    38,    39,    40,     4,    53,    53,
      21,    43,    20,    49,    10,    15,    14,     0,    30,    22,
      44,    17,    37,    53,    10,    23,    45,    48,    53,    18,
      48,    53,    53,     3,    24,    50,    51,    52,    53,    11,
      48,    48,    16,    19,    51,    53,    11,    18,    51,    12,
      53,    34,    53,    12,    46,    47,    53,    18,    53,    16,
      35,    17,    41,    42,    53,    18,    47,    19,    53,    16,
      19,    53,    41,    42,    19
};

#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#endif
#if ! defined (YYSIZE_T) && defined (size_t)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
# if defined (__STDC__) || defined (__cplusplus)
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
# define YYSIZE_T unsigned int
#endif

#define Int_yyerrok		(Int_yyerrstatus = 0)
#define Int_yyclearin	(Int_yychar = YYEMPTY)
#define YYEMPTY		(-2)
#define YYEOF		0

#define YYACCEPT	goto Int_yyacceptlab
#define YYABORT		goto Int_yyabortlab
#define YYERROR		goto Int_yyerrlab1

/* Like YYERROR except do call Int_yyerror.  This remains here temporarily
   to ease the transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */

#define YYFAIL		goto Int_yyerrlab

#define YYRECOVERING()  (!!Int_yyerrstatus)

#define YYBACKUP(Token, Value)					\
do								\
  if (Int_yychar == YYEMPTY && Int_yylen == 1)				\
    {								\
      Int_yychar = (Token);						\
      Int_yylval = (Value);						\
      Int_yytoken = YYTRANSLATE (Int_yychar);				\
      YYPOPSTACK;						\
      goto Int_yybackup;						\
    }								\
  else								\
    { 								\
      Int_yyerror ("syntax error: cannot back up");\
      YYERROR;							\
    }								\
while (0)

#define YYTERROR	1
#define YYERRCODE	256

/* YYLLOC_DEFAULT -- Compute the default location (before the actions
   are run).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)         \
  Current.first_line   = Rhs[1].first_line;      \
  Current.first_column = Rhs[1].first_column;    \
  Current.last_line    = Rhs[N].last_line;       \
  Current.last_column  = Rhs[N].last_column;
#endif

/* YYLEX -- calling `Int_yylex' with the right arguments.  */

#ifdef YYLEX_PARAM
# define YYLEX Int_yylex (YYLEX_PARAM)
#else
# define YYLEX Int_yylex ()
#endif

/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)			\
do {						\
  if (Int_yydebug)					\
    YYFPRINTF Args;				\
} while (0)

# define YYDSYMPRINT(Args)			\
do {						\
  if (Int_yydebug)					\
    Int_yysymprint Args;				\
} while (0)

# define YYDSYMPRINTF(Title, Token, Value, Location)		\
do {								\
  if (Int_yydebug)							\
    {								\
      YYFPRINTF (stderr, "%s ", Title);				\
      Int_yysymprint (stderr, 					\
                  Token, Value);	\
      YYFPRINTF (stderr, "\n");					\
    }								\
} while (0)

/*------------------------------------------------------------------.
| Int_yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (cinluded).                                                   |
`------------------------------------------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
Int_yy_stack_print (short *bottom, short *top)
#else
static void
Int_yy_stack_print (bottom, top)
    short *bottom;
    short *top;
#endif
{
  YYFPRINTF (stderr, "Stack now");
  for (/* Nothing. */; bottom <= top; ++bottom)
    YYFPRINTF (stderr, " %d", *bottom);
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)				\
do {								\
  if (Int_yydebug)							\
    Int_yy_stack_print ((Bottom), (Top));				\
} while (0)


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
Int_yy_reduce_print (int Int_yyrule)
#else
static void
Int_yy_reduce_print (Int_yyrule)
    int Int_yyrule;
#endif
{
  int Int_yyi;
  unsigned int Int_yylineno = Int_yyrline[Int_yyrule];
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
             Int_yyrule - 1, Int_yylineno);
  /* Print the symbols being reduced, and their result.  */
  for (Int_yyi = Int_yyprhs[Int_yyrule]; 0 <= Int_yyrhs[Int_yyi]; Int_yyi++)
    YYFPRINTF (stderr, "%s ", Int_yytname [Int_yyrhs[Int_yyi]]);
  YYFPRINTF (stderr, "-> %s\n", Int_yytname [Int_yyr1[Int_yyrule]]);
}

# define YY_REDUCE_PRINT(Rule)		\
do {					\
  if (Int_yydebug)				\
    Int_yy_reduce_print (Rule);		\
} while (0)

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int Int_yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YYDSYMPRINT(Args)
# define YYDSYMPRINTF(Title, Token, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef	YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#if YYMAXDEPTH == 0
# undef YYMAXDEPTH
#endif

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif



#if YYERROR_VERBOSE

# ifndef Int_yystrlen
#  if defined (__GLIBC__) && defined (_STRING_H)
#   define Int_yystrlen strlen
#  else
/* Return the length of YYSTR.  */
static YYSIZE_T
#   if defined (__STDC__) || defined (__cplusplus)
Int_yystrlen (const char *Int_yystr)
#   else
Int_yystrlen (Int_yystr)
     const char *Int_yystr;
#   endif
{
  register const char *Int_yys = Int_yystr;

  while (*Int_yys++ != '\0')
    continue;

  return Int_yys - Int_yystr - 1;
}
#  endif
# endif

# ifndef Int_yystpcpy
#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
#   define Int_yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
static char *
#   if defined (__STDC__) || defined (__cplusplus)
Int_yystpcpy (char *Int_yydest, const char *Int_yysrc)
#   else
Int_yystpcpy (Int_yydest, Int_yysrc)
     char *Int_yydest;
     const char *Int_yysrc;
#   endif
{
  register char *Int_yyd = Int_yydest;
  register const char *Int_yys = Int_yysrc;

  while ((*Int_yyd++ = *Int_yys++) != '\0')
    continue;

  return Int_yyd - 1;
}
#  endif
# endif

#endif /* !YYERROR_VERBOSE */



#if YYDEBUG
/*--------------------------------.
| Print this symbol on YYOUTPUT.  |
`--------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
Int_yysymprint (FILE *Int_yyoutput, int Int_yytype, YYSTYPE *Int_yyvaluep)
#else
static void
Int_yysymprint (Int_yyoutput, Int_yytype, Int_yyvaluep)
    FILE *Int_yyoutput;
    int Int_yytype;
    YYSTYPE *Int_yyvaluep;
#endif
{
  /* Pacify ``unused variable'' warnings.  */
  (void) Int_yyvaluep;