sl_gram.c

Go to the documentation of this file.

/* A Bison parser, made by GNU Bison 2.3.  */

/* Skeleton implementation for Bison's Yacc-like parsers in C

   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

/* As a special exception, you may create a larger work that contains
   part or all of the Bison parser skeleton and distribute that work
   under terms of your choice, so long as that work isn't itself a
   parser generator using the skeleton or a modified version thereof
   as a parser skeleton.  Alternatively, if you modify or redistribute
   the parser skeleton itself, you may (at your option) remove this
   special exception, which will cause the skeleton and the resulting
   Bison output files to be licensed under the GNU General Public
   License without this special exception.

   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by
   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with slx_ or SL_, to avoid
   infringing on user name space.  This should be done even for local
   variables, as they might otherwise be expanded by user macros.
   There are some unavoidable exceptions within include files to
   define necessary library symbols; they are noted "INFRINGES ON
   USER NAME SPACE" below.  */

/* Identify Bison output.  */
#define SL_BISON 1

/* Bison version.  */
#define SL_BISON_VERSION "2.3"

/* Skeleton name.  */
#define SL_SKELETON_NAME "yacc.c"

/* Pure parsers.  */
#define SL_PURE 0

/* Using locations.  */
#define SL_LSP_NEEDED 0



/* Tokens.  */
#ifndef SL_TOKENTYPE
# define SL_TOKENTYPE
   /* Put the tokens into the symbol table, so that GDB and other debuggers
      know about them.  */
   enum slx_tokentype {
     ACCFERM = 1,
     ACCOUVR = 2,
     CONSTANTE = 3,
     EGAL = 4,
     IDENT = 5,
     INF = 6,
     INFEGAL = 7,
     MOINS = 8,
     PLUS = 9,
     SUP = 10,
     SUPEGAL = 11,
     VAR = 12,
     VIRG = 13
   };
#endif
/* Tokens.  */
#define ACCFERM 1
#define ACCOUVR 2
#define CONSTANTE 3
#define EGAL 4
#define IDENT 5
#define INF 6
#define INFEGAL 7
#define MOINS 8
#define PLUS 9
#define SUP 10
#define SUPEGAL 11
#define VAR 12
#define VIRG 13




/* Copy the first part of user declarations.  */
#line 7 "sl_gram.y"


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "sc.h"
#include "malloc.h"
#include "union.h"


extern char slx_text[]; /* dialogue avec l'analyseur lexical */
Psysteme ps_yacc;
boolean syntax_error;
Value valcst;
Value fac;        /* facteur multiplicatif suivant qu'on analyse un terme*/
                      /* introduit par un moins (-1) ou par un plus (1) */
int sens;             /* indique le sens de l'inegalite
                         sens = -1  ==> l'operateur est soit > ,soit >=,
                         sens = 1   ==> l'operateur est soit <, soit <=   */
short int cote;       /* booleen indiquant quel membre est en cours d'analyse*/
Value b1, b2;      /* element du vecteur colonne du systeme donne 
          par l'analyse d'une contrainte */
Pcontrainte eq;       /* pointeur sur l'egalite ou l'inegalite courante */
Pvecteur cp ;         /* pointeur sur le membre courant */ 
short int operat;     /* dernier operateur rencontre */

extern   Pcontrainte p_eg_fin;
extern   Pcontrainte p_ineg_fin;
extern   Pvecteur p_pred;
extern   Pvecteur p_membre_courant;
extern   Pvecteur cp;
Psyslist sl_yacc; Pbase ba_yacc; Variable va_yacc; 

/*code des operateurs de comparaison */
#define OPINF 1
#define OPINFEGAL 2
#define OPEGAL 3
#define OPSUPEGAL 4
#define OPSUP 5
#define DROIT 1
#define GAUCHE 2
/* #define NULL 0 */



/* Enabling traces.  */
#ifndef SL_DEBUG
# define SL_DEBUG 0
#endif

/* Enabling verbose error messages.  */
#ifdef SL_ERROR_VERBOSE
# undef SL_ERROR_VERBOSE
# define SL_ERROR_VERBOSE 1
#else
# define SL_ERROR_VERBOSE 0
#endif

/* Enabling the token table.  */
#ifndef SL_TOKEN_TABLE
# define SL_TOKEN_TABLE 0
#endif

#if ! defined SL_STYPE && ! defined SL_STYPE_IS_DECLARED
typedef union SL_STYPE
#line 74 "sl_gram.y"
{
    Value Value;
    Variable Variable;
}
/* Line 187 of yacc.c.  */
#line 181 "y.tab.c"
        SL_STYPE;
# define slx_stype SL_STYPE /* obsolescent; will be withdrawn */
# define SL_STYPE_IS_DECLARED 1
# define SL_STYPE_IS_TRIVIAL 1
#endif



/* Copy the second part of user declarations.  */


/* Line 216 of yacc.c.  */
#line 194 "y.tab.c"

#ifdef short
# undef short
#endif

#ifdef SL_TYPE_UINT8
typedef SL_TYPE_UINT8 slx_type_uint8;
#else
typedef unsigned char slx_type_uint8;
#endif

#ifdef SL_TYPE_INT8
typedef SL_TYPE_INT8 slx_type_int8;
#elif (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
typedef signed char slx_type_int8;
#else
typedef short int slx_type_int8;
#endif

#ifdef SL_TYPE_UINT16
typedef SL_TYPE_UINT16 slx_type_uint16;
#else
typedef unsigned short int slx_type_uint16;
#endif

#ifdef SL_TYPE_INT16
typedef SL_TYPE_INT16 slx_type_int16;
#else
typedef short int slx_type_int16;
#endif

#ifndef SL_SIZE_T
# ifdef __SIZE_TYPE__
#  define SL_SIZE_T __SIZE_TYPE__
# elif defined size_t
#  define SL_SIZE_T size_t
# elif ! defined SL_SIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
#  define SL_SIZE_T size_t
# else
#  define SL_SIZE_T unsigned int
# endif
#endif

#define SL_SIZE_MAXIMUM ((SL_SIZE_T) -1)

#ifndef SL__
# if SL_ENABLE_NLS
#  if ENABLE_NLS
#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
#   define SL__(msgid) dgettext ("bison-runtime", msgid)
#  endif
# endif
# ifndef SL__
#  define SL__(msgid) msgid
# endif
#endif

/* Suppress unused-variable warnings by "using" E.  */
#if ! defined lint || defined __GNUC__
# define SL_USE(e) ((void) (e))
#else
# define SL_USE(e) /* empty */
#endif

/* Identity function, used to suppress warnings about constant conditions.  */
#ifndef lint
# define SL_ID(n) (n)
#else
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static int
SL_ID (int i)
#else
static int
SL_ID (i)
    int i;
#endif
{
  return i;
}
#endif

#if ! defined slx_overflow || SL_ERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# ifdef SL_STACK_USE_ALLOCA
#  if SL_STACK_USE_ALLOCA
#   ifdef __GNUC__
#    define SL_STACK_ALLOC __builtin_alloca
#   elif defined __BUILTIN_VA_ARG_INCR
#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
#   elif defined _AIX
#    define SL_STACK_ALLOC __alloca
#   elif defined _MSC_VER
#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
#    define alloca _alloca
#   else
#    define SL_STACK_ALLOC alloca
#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
#     ifndef _STDLIB_H
#      define _STDLIB_H 1
#     endif
#    endif
#   endif
#  endif
# endif

# ifdef SL_STACK_ALLOC
   /* Pacify GCC's `empty if-body' warning.  */
#  define SL_STACK_FREE(Ptr) do { /* empty */; } while (SL_ID (0))
#  ifndef SL_STACK_ALLOC_MAXIMUM
    /* The OS might guarantee only one guard page at the bottom of the stack,
       and a page size can be as small as 4096 bytes.  So we cannot safely
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
       to allow for a few compiler-allocated temporary stack slots.  */
#   define SL_STACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
#  endif
# else
#  define SL_STACK_ALLOC SL_MALLOC
#  define SL_STACK_FREE SL_FREE
#  ifndef SL_STACK_ALLOC_MAXIMUM
#   define SL_STACK_ALLOC_MAXIMUM SL_SIZE_MAXIMUM
#  endif
#  if (defined __cplusplus && ! defined _STDLIB_H \
       && ! ((defined SL_MALLOC || defined malloc) \
             && (defined SL_FREE || defined free)))
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
#   ifndef _STDLIB_H
#    define _STDLIB_H 1
#   endif
#  endif
#  ifndef SL_MALLOC
#   define SL_MALLOC malloc
#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
void *malloc (SL_SIZE_T); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
#  ifndef SL_FREE
#   define SL_FREE free
#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
void free (void *); /* INFRINGES ON USER NAME SPACE */
#   endif
#  endif
# endif
#endif /* ! defined slx_overflow || SL_ERROR_VERBOSE */


#if (! defined slx_overflow \
     && (! defined __cplusplus \
         || (defined SL_STYPE_IS_TRIVIAL && SL_STYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */
union slx_alloc
{
  slx_type_int16 slx_ss;
  SL_STYPE slx_vs;
  };

/* The size of the maximum gap between one aligned stack and the next.  */
# define SL_STACK_GAP_MAXIMUM (sizeof (union slx_alloc) - 1)

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# define SL_STACK_BYTES(N) \
     ((N) * (sizeof (slx_type_int16) + sizeof (SL_STYPE)) \
      + SL_STACK_GAP_MAXIMUM)

/* Copy COUNT objects from FROM to TO.  The source and destination do
   not overlap.  */
# ifndef SL_COPY
#  if defined __GNUC__ && 1 < __GNUC__
#   define SL_COPY(To, From, Count) \
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
#  else
#   define SL_COPY(To, From, Count)             \
      do                                        \
        {                                       \
          SL_SIZE_T slx_i;                              \
          for (slx_i = 0; slx_i < (Count); slx_i++)     \
            (To)[slx_i] = (From)[slx_i];                \
        }                                       \
      while (SL_ID (0))
#  endif
# endif

/* Relocate STACK from its old location to the new one.  The
   local variables SL_SIZE and SL_STACKSIZE give the old and new number of
   elements in the stack, and SL_PTR gives the new location of the
   stack.  Advance SL_PTR to a properly aligned location for the next
   stack.  */
# define SL_STACK_RELOCATE(Stack)                                       \
    do                                                                  \
      {                                                                 \
        SL_SIZE_T slx_newbytes;                                         \
        SL_COPY (&slx_ptr->Stack, Stack, slx_size);                             \
        Stack = &slx_ptr->Stack;                                                \
        slx_newbytes = slx_stacksize * sizeof (*Stack) + SL_STACK_GAP_MAXIMUM; \
        slx_ptr += slx_newbytes / sizeof (*slx_ptr);                            \
      }                                                                 \
    while (SL_ID (0))

#endif

/* SL_FINAL -- State number of the termination state.  */
#define SL_FINAL  3
/* SL_LAST -- Last index in SL_TABLE.  */
#define SL_LAST   31

/* SL_NTOKENS -- Number of terminals.  */
#define SL_NTOKENS  16
/* SL_NNTS -- Number of nonterminals.  */
#define SL_NNTS  25
/* SL_NRULES -- Number of rules.  */
#define SL_NRULES  40
/* SL_NRULES -- Number of states.  */
#define SL_NSTATES  49

/* SL_TRANSLATE(SL_LEX) -- Bison symbol number corresponding to SL_LEX.  */
#define SL_UNDEFTOK  2
#define SL_MAXUTOK   257

#define SL_TRANSLATE(SL_X)                                              \
  ((unsigned int) (SL_X) <= SL_MAXUTOK ? slx_translate[SL_X] : SL_UNDEFTOK)

/* SL_TRANSLATE[SL_LEX] -- Bison symbol number corresponding to SL_LEX.  */
static const slx_type_uint8 slx_translate[] =
{
       0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
      12,    13,    14,    15,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2
};

#if SL_DEBUG
/* SL_PRHS[SL_N] -- Index of the first RHS symbol of rule number SL_N in
   SL_RHS.  */
static const slx_type_uint8 slx_prhs[] =
{
       0,     0,     3,     8,     9,    10,    13,    15,    19,    21,
      23,    26,    33,    34,    35,    37,    41,    42,    49,    50,
      51,    54,    55,    58,    62,    65,    67,    69,    71,    73,
      75,    77,    79,    81,    83,    85,    87,    89,    94,    95,
      97
};

/* SL_RHS -- A `-1'-separated list of the rules' RHS.  */
static const slx_type_int8 slx_rhs[] =
{
      17,     0,    -1,    18,    20,    23,    19,    -1,    -1,    -1,
      14,    21,    -1,    22,    -1,    21,    15,    22,    -1,     7,
      -1,    24,    -1,    24,    23,    -1,    25,     4,    27,    40,
       3,    26,    -1,    -1,    -1,    28,    -1,    27,    15,    28,
      -1,    -1,    29,    38,    36,    31,    39,    30,    -1,    -1,
      -1,    37,    33,    -1,    -1,    32,    33,    -1,    31,    37,
      33,    -1,    35,    34,    -1,    35,    -1,    34,    -1,     7,
      -1,     5,    -1,     8,    -1,     9,    -1,     6,    -1,    12,
      -1,    13,    -1,    11,    -1,    10,    -1,    31,    -1,    38,
      36,    31,    39,    -1,    -1,    15,    -1,    -1
};

/* SL_RLINE[SL_N] -- source line where rule number SL_N was defined.  */
static const slx_type_uint16 slx_rline[] =
{
       0,    82,    82,    86,    93,    98,   101,   102,   105,   112,
     113,   116,   120,   128,   139,   140,   141,   144,   148,   161,
     166,   167,   167,   168,   171,   183,   195,   206,   221,   227,
     235,   243,   251,   259,   268,   270,   274,   275,   279,   307,
     308
};
#endif

#if SL_DEBUG || SL_ERROR_VERBOSE || SL_TOKEN_TABLE
/* SL_TNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at SL_NTOKENS, nonterminals.  */
static const char *const slx_tname[] =
{
  "$end", "error", "$undefined", "ACCFERM", "ACCOUVR", "CONSTANTE",
  "EGAL", "IDENT", "INF", "INFEGAL", "MOINS", "PLUS", "SUP", "SUPEGAL",
  "VAR", "VIRG", "$accept", "s_list", "inisl", "endsl", "defvar", "l_var",
  "newid", "l_sys", "system", "inisys", "endsys", "l_eq", "eq", "debeq",
  "feq", "membre", "@1", "terme", "ident", "const", "op", "addop",
  "multi_membre", "fin_mult_membre", "virg_opt", 0
};
#endif

# ifdef SL_PRINT
/* SL_TOKNUM[SL_LEX-NUM] -- Internal token number corresponding to
   token SL_LEX-NUM.  */
static const slx_type_uint16 slx_toknum[] =
{
       0,   256,   257,     1,     2,     3,     4,     5,     6,     7,
       8,     9,    10,    11,    12,    13
};
# endif

/* SL_R1[SL_N] -- Symbol number of symbol that rule SL_N derives.  */
static const slx_type_uint8 slx_r1[] =
{
       0,    16,    17,    18,    19,    20,    21,    21,    22,    23,
      23,    24,    25,    26,    27,    27,    27,    28,    29,    30,
      31,    32,    31,    31,    33,    33,    33,    34,    35,    36,
      36,    36,    36,    36,    37,    37,    38,    38,    39,    40,
      40
};

/* SL_R2[SL_N] -- Number of symbols composing right hand side of rule SL_N.  */
static const slx_type_uint8 slx_r2[] =
{
       0,     2,     4,     0,     0,     2,     1,     3,     1,     1,
       2,     6,     0,     0,     1,     3,     0,     6,     0,     0,
       2,     0,     2,     3,     2,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     4,     0,     1,
       0
};

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

/* SL_DEFGOTO[NTERM-NUM].  */
static const slx_type_int8 slx_defgoto[] =
{
      -1,     1,     2,    13,     5,     7,     8,     9,    10,    11,
      43,    17,    18,    19,    48,    24,    25,    33,    34,    35,
      42,    26,    27,    47,    21
};

/* SL_PACT[STATE-NUM] -- Index in SL_TABLE of the portion describing
   STATE-NUM.  */
#define SL_PACT_NINF -25
static const slx_type_int8 slx_pact[] =
{
     -25,     7,     2,   -25,    11,   -25,   -25,     4,   -25,   -25,
      16,    17,    11,   -25,   -25,    -2,   -25,     8,   -25,     1,
      21,    22,   -25,   -25,     1,    10,    10,    -3,   -25,   -25,
      10,   -25,   -25,   -25,   -25,    19,   -25,   -25,   -25,   -25,
     -25,   -25,     1,   -25,   -25,   -25,     1,    -1,   -25
};

/* SL_PGOTO[NTERM-NUM].  */
static const slx_type_int8 slx_pgoto[] =
{
     -25,   -25,   -25,   -25,   -25,   -25,    15,    18,   -25,   -25,
     -25,   -25,     9,   -25,   -25,   -12,   -25,   -22,    -4,   -25,
     -25,   -24,   -25,   -25,   -25
};

/* SL_TABLE[SL_PACT[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 SL_DEFACT says.
   If SL_TABLE_NINF, syntax error.  */
#define SL_TABLE_NINF -40
static const slx_type_int8 slx_table[] =
{
      30,   -16,   -19,    37,    36,    38,    39,     3,    44,    40,
      41,    22,    23,   -16,   -19,    31,     4,    32,     6,    12,
     -12,    15,    30,    20,   -39,    29,    32,    16,    14,    28,
      46,    45
};

static const slx_type_uint8 slx_check[] =
{
      24,     3,     3,     6,    26,     8,     9,     0,    30,    12,
      13,    10,    11,    15,    15,     5,    14,     7,     7,    15,
       4,     4,    46,    15,     3,     3,     7,    12,    10,    20,
      42,    35
};

/* SL_STOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const slx_type_uint8 slx_stos[] =
{
       0,    17,    18,     0,    14,    20,     7,    21,    22,    23,
      24,    25,    15,    19,    23,     4,    22,    27,    28,    29,
      15,    40,    10,    11,    31,    32,    37,    38,    28,     3,
      37,     5,     7,    33,    34,    35,    33,     6,     8,     9,
      12,    13,    36,    26,    33,    34,    31,    39,    30
};

#define slx_errok               (slx_errstatus = 0)
#define slx_clearin     (slx_char = SL_EMPTY)
#define SL_EMPTY                (-2)
#define SL_EOF          0

#define SL_ACCEPT       goto slx_acceptlab
#define SL_ABORT                goto slx_abortlab
#define SL_ERROR                goto slx_errorlab


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

#define SL_FAIL         goto slx_errlab

#define SL_RECOVERING()  (!!slx_errstatus)

#define SL_BACKUP(Token, Value)                                 \
do                                                              \
  if (slx_char == SL_EMPTY && slx_len == 1)                             \
    {                                                           \
      slx_char = (Token);                                               \
      slx_lval = (Value);                                               \
      slx_token = SL_TRANSLATE (slx_char);                              \
      SL_POPSTACK (1);                                          \
      goto slx_backup;                                          \
    }                                                           \
  else                                                          \
    {                                                           \
      slx_error (SL__("syntax error: cannot back up")); \
      SL_ERROR;                                                 \
    }                                                           \
while (SL_ID (0))


#define SL_TERROR       1
#define SL_ERRCODE      256


/* SL_LLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

#define SL_RHSLOC(Rhs, K) ((Rhs)[K])
#ifndef SL_LLOC_DEFAULT
# define SL_LLOC_DEFAULT(Current, Rhs, N)                               \
    do                                                                  \
      if (SL_ID (N))                                                    \
        {                                                               \
          (Current).first_line   = SL_RHSLOC (Rhs, 1).first_line;       \
          (Current).first_column = SL_RHSLOC (Rhs, 1).first_column;     \
          (Current).last_line    = SL_RHSLOC (Rhs, N).last_line;                \
          (Current).last_column  = SL_RHSLOC (Rhs, N).last_column;      \
        }                                                               \
      else                                                              \
        {                                                               \
          (Current).first_line   = (Current).last_line   =              \
            SL_RHSLOC (Rhs, 0).last_line;                               \
          (Current).first_column = (Current).last_column =              \
            SL_RHSLOC (Rhs, 0).last_column;                             \
        }                                                               \
    while (SL_ID (0))
#endif


/* SL__LOCATION_PRINT -- Print the location on the stream.
   This macro was not mandated originally: define only if we know
   we won't break user code: when these are the locations we know.  */

#ifndef SL__LOCATION_PRINT
# if SL_LTYPE_IS_TRIVIAL
#  define SL__LOCATION_PRINT(File, Loc)                 \
     fprintf (File, "%d.%d-%d.%d",                      \
              (Loc).first_line, (Loc).first_column,     \
              (Loc).last_line,  (Loc).last_column)
# else
#  define SL__LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif


/* SL_LEX -- calling `slx_lex' with the right arguments.  */

#ifdef SL_LEX_PARAM
# define SL_LEX slx_lex (SL_LEX_PARAM)
#else
# define SL_LEX slx_lex ()
#endif

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

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

# define SL_DPRINTF(Args)                       \
do {                                            \
  if (slx_debug)                                        \
    SL_FPRINTF Args;                            \
} while (SL_ID (0))

# define SL__SYMBOL_PRINT(Title, Type, Value, Location)                   \
do {                                                                      \
  if (slx_debug)                                                                  \
    {                                                                     \
      SL_FPRINTF (stderr, "%s ", Title);                                          \
      slx__symbol_print (stderr,                                                  \
                  Type, Value); \
      SL_FPRINTF (stderr, "\n");                                                  \
    }                                                                     \
} while (SL_ID (0))


/*--------------------------------.
| Print this symbol on SL_OUTPUT.  |
`--------------------------------*/

/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
slx__symbol_value_print (FILE *slx_output, int slx_type, SL_STYPE const * const slx_valuep)
#else
static void
slx__symbol_value_print (slx_output, slx_type, slx_valuep)
    FILE *slx_output;
    int slx_type;
    SL_STYPE const * const slx_valuep;
#endif
{
  if (!slx_valuep)
    return;
# ifdef SL_PRINT
  if (slx_type < SL_NTOKENS)
    SL_PRINT (slx_output, slx_toknum[slx_type], *slx_valuep);
# else
  SL_USE (slx_output);
# endif
  switch (slx_type)
    {
      default:
        break;
    }
}


/*--------------------------------.
| Print this symbol on SL_OUTPUT.  |
`--------------------------------*/

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
slx__symbol_print (FILE *slx_output, int slx_type, SL_STYPE const * const slx_valuep)
#else
static void
slx__symbol_print (slx_output, slx_type, slx_valuep)
    FILE *slx_output;
    int slx_type;
    SL_STYPE const * const slx_valuep;
#endif
{
  if (slx_type < SL_NTOKENS)
    SL_FPRINTF (slx_output, "token %s (", slx_tname[slx_type]);
  else
    SL_FPRINTF (slx_output, "nterm %s (", slx_tname[slx_type]);

  slx__symbol_value_print (slx_output, slx_type, slx_valuep);
  SL_FPRINTF (slx_output, ")");
}

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

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
slx__stack_print (slx_type_int16 *bottom, slx_type_int16 *top)
#else
static void
slx__stack_print (bottom, top)
    slx_type_int16 *bottom;
    slx_type_int16 *top;
#endif
{
  SL_FPRINTF (stderr, "Stack now");
  for (; bottom <= top; ++bottom)
    SL_FPRINTF (stderr, " %d", *bottom);
  SL_FPRINTF (stderr, "\n");
}

# define SL__STACK_PRINT(Bottom, Top)                           \
do {                                                            \
  if (slx_debug)                                                        \
    slx__stack_print ((Bottom), (Top));                         \
} while (SL_ID (0))


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

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
slx__reduce_print (SL_STYPE *slx_vsp, int slx_rule)
#else
static void
slx__reduce_print (slx_vsp, slx_rule)
    SL_STYPE *slx_vsp;
    int slx_rule;
#endif
{
  int slx_nrhs = slx_r2[slx_rule];
  int slx_i;
  unsigned long int slx_lno = slx_rline[slx_rule];
  SL_FPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
             slx_rule - 1, slx_lno);
  /* The symbols being reduced.  */
  for (slx_i = 0; slx_i < slx_nrhs; slx_i++)
    {
      fprintf (stderr, "   $%d = ", slx_i + 1);
      slx__symbol_print (stderr, slx_rhs[slx_prhs[slx_rule] + slx_i],
                       &(slx_vsp[(slx_i + 1) - (slx_nrhs)])
                                       );
      fprintf (stderr, "\n");
    }
}

# define SL__REDUCE_PRINT(Rule)         \
do {                                    \
  if (slx_debug)                                \
    slx__reduce_print (slx_vsp, Rule); \
} while (SL_ID (0))

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int slx_debug;
#else /* !SL_DEBUG */
# define SL_DPRINTF(Args)
# define SL__SYMBOL_PRINT(Title, Type, Value, Location)
# define SL__STACK_PRINT(Bottom, Top)
# define SL__REDUCE_PRINT(Rule)
#endif /* !SL_DEBUG */


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

/* SL_MAXDEPTH -- 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
   SL_STACK_ALLOC_MAXIMUM < SL_STACK_BYTES (SL_MAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef SL_MAXDEPTH
# define SL_MAXDEPTH 10000
#endif



#if SL_ERROR_VERBOSE

# ifndef slx_strlen
#  if defined __GLIBC__ && defined _STRING_H
#   define slx_strlen strlen
#  else
/* Return the length of SL_STR.  */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static SL_SIZE_T
slx_strlen (const char *slx_str)
#else
static SL_SIZE_T
slx_strlen (slx_str)
    const char *slx_str;
#endif
{
  SL_SIZE_T slx_len;
  for (slx_len = 0; slx_str[slx_len]; slx_len++)
    continue;
  return slx_len;
}
#  endif
# endif

# ifndef slx_stpcpy
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
#   define slx_stpcpy stpcpy
#  else
/* Copy SL_SRC to SL_DEST, returning the address of the terminating '\0' in
   SL_DEST.  */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static char *
slx_stpcpy (char *slx_dest, const char *slx_src)
#else
static char *
slx_stpcpy (slx_dest, slx_src)
    char *slx_dest;
    const char *slx_src;
#endif
{
  char *slx_d = slx_dest;
  const char *slx_s = slx_src;

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

  return slx_d - 1;
}
#  endif
# endif

# ifndef slx_tnamerr
/* Copy to SL_RES the contents of SL_STR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for slx_error.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  SL_STR is taken from slx_tname.  If SL_RES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static SL_SIZE_T
slx_tnamerr (char *slx_res, const char *slx_str)
{
  if (*slx_str == '"')
    {
      SL_SIZE_T slx_n = 0;
      char const *slx_p = slx_str;

      for (;;)
        switch (*++slx_p)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++slx_p != '\\')
              goto do_not_strip_quotes;
            /* Fall through.  */
          default:
            if (slx_res)
              slx_res[slx_n] = *slx_p;
            slx_n++;
            break;

          case '"':
            if (slx_res)
              slx_res[slx_n] = '\0';
            return slx_n;
          }
    do_not_strip_quotes: ;
    }

  if (! slx_res)
    return slx_strlen (slx_str);

  return slx_stpcpy (slx_res, slx_str) - slx_res;
}
# endif

/* Copy into SL_RESULT an error message about the unexpected token
   SL_CHAR while in state SL_STATE.  Return the number of bytes copied,
   including the terminating null byte.  If SL_RESULT is null, do not
   copy anything; just return the number of bytes that would be
   copied.  As a special case, return 0 if an ordinary "syntax error"
   message will do.  Return SL_SIZE_MAXIMUM if overflow occurs during
   size calculation.  */
static SL_SIZE_T
slx_syntax_error (char *slx_result, int slx_state, int slx_char)
{
  int slx_n = slx_pact[slx_state];

  if (! (SL_PACT_NINF < slx_n && slx_n <= SL_LAST))
    return 0;
  else
    {
      int slx_type = SL_TRANSLATE (slx_char);
      SL_SIZE_T slx_size0 = slx_tnamerr (0, slx_tname[slx_type]);
      SL_SIZE_T slx_size = slx_size0;
      SL_SIZE_T slx_size1;
      int slx_size_overflow = 0;
      enum { SL_ERROR_VERBOSE_ARGS_MAXIMUM = 5 };
      char const *slx_arg[SL_ERROR_VERBOSE_ARGS_MAXIMUM];
      int slx_x;

# if 0
      /* This is so xgettext sees the translatable formats that are
         constructed on the fly.  */
      SL__("syntax error, unexpected %s");
      SL__("syntax error, unexpected %s, expecting %s");
      SL__("syntax error, unexpected %s, expecting %s or %s");
      SL__("syntax error, unexpected %s, expecting %s or %s or %s");
      SL__("syntax error, unexpected %s, expecting %s or %s or %s or %s");
# endif
      char *slx_fmt;
      char const *slx_f;
      static char const slx_unexpected[] = "syntax error, unexpected %s";
      static char const slx_expecting[] = ", expecting %s";
      static char const slx_or[] = " or %s";
      char slx_format[sizeof slx_unexpected
                    + sizeof slx_expecting - 1
                    + ((SL_ERROR_VERBOSE_ARGS_MAXIMUM - 2)
                       * (sizeof slx_or - 1))];
      char const *slx_prefix = slx_expecting;

      /* Start SL_X at -SL_N if negative to avoid negative indexes in
         SL_CHECK.  */
      int slx_xbegin = slx_n < 0 ? -slx_n : 0;

      /* Stay within bounds of both slx_check and slx_tname.  */
      int slx_checklim = SL_LAST - slx_n + 1;
      int slx_xend = slx_checklim < SL_NTOKENS ? slx_checklim : SL_NTOKENS;
      int slx_count = 1;

      slx_arg[0] = slx_tname[slx_type];
      slx_fmt = slx_stpcpy (slx_format, slx_unexpected);

      for (slx_x = slx_xbegin; slx_x < slx_xend; ++slx_x)
        if (slx_check[slx_x + slx_n] == slx_x && slx_x != SL_TERROR)
          {
            if (slx_count == SL_ERROR_VERBOSE_ARGS_MAXIMUM)
              {
                slx_count = 1;
                slx_size = slx_size0;
                slx_format[sizeof slx_unexpected - 1] = '\0';
                break;
              }
            slx_arg[slx_count++] = slx_tname[slx_x];
            slx_size1 = slx_size + slx_tnamerr (0, slx_tname[slx_x]);
            slx_size_overflow |= (slx_size1 < slx_size);
            slx_size = slx_size1;
            slx_fmt = slx_stpcpy (slx_fmt, slx_prefix);
            slx_prefix = slx_or;
          }

      slx_f = SL__(slx_format);
      slx_size1 = slx_size + slx_strlen (slx_f);
      slx_size_overflow |= (slx_size1 < slx_size);
      slx_size = slx_size1;

      if (slx_size_overflow)
        return SL_SIZE_MAXIMUM;

      if (slx_result)
        {
          /* Avoid sprintf, as that infringes on the user's name space.
             Don't have undefined behavior even if the translation
             produced a string with the wrong number of "%s"s.  */
          char *slx_p = slx_result;