sl_gram.c

Go to the documentation of this file.

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

/* 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 3 of the License, 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, see <http://www.gnu.org/licenses/>.  */

/* 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.4.1"

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

/* Pure parsers.  */
#define SL_PURE 0

/* Push parsers.  */
#define SL_PUSH 0

/* Pull parsers.  */
#define SL_PULL 1

/* Using locations.  */
#define SL_LSP_NEEDED 0



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

/* Line 189 of yacc.c  */
#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 */



/* Line 189 of yacc.c  */
#line 124 "y.tab.c"

/* 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


/* 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




#if ! defined SL_STYPE && ! defined SL_STYPE_IS_DECLARED
typedef union SL_STYPE
{

/* Line 214 of yacc.c  */
#line 74 "sl_gram.y"

    Value Value;
    Variable Variable;



/* Line 214 of yacc.c  */
#line 197 "y.tab.c"
} SL_STYPE;
# define SL_STYPE_IS_TRIVIAL 1
# define slx_stype SL_STYPE /* obsolescent; will be withdrawn */
# define SL_STYPE_IS_DECLARED 1
#endif


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


/* Line 264 of yacc.c  */
#line 209 "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 slx_i)
#else
static int
SL_ID (slx_i)
    int slx_i;
#endif
{
  return slx_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_alloc;
  SL_STYPE slx_vs_alloc;
};

/* 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_alloc, Stack)                          \
    do                                                                  \
      {                                                                 \
        SL_SIZE_T slx_newbytes;                                         \
        SL_COPY (&slx_ptr->Stack_alloc, Stack, slx_size);                       \
        Stack = &slx_ptr->Stack_alloc;                                  \
        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 *slx_bottom, slx_type_int16 *slx_top)
#else
static void
slx__stack_print (slx_bottom, slx_top)
    slx_type_int16 *slx_bottom;
    slx_type_int16 *slx_top;
#endif
{
  SL_FPRINTF (stderr, "Stack now");
  for (; slx_bottom <= slx_top; slx_bottom++)
    {
      int slx_bot = *slx_bottom;
      SL_FPRINTF (stderr, " %d", slx_bot);
    }
  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++)
    {
      SL_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)])
                                       );
      SL_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;
          int slx_i = 0;
          while ((*slx_p = *slx_f) != '\0')
            {
              if (*slx_p == '%' && slx_f[1] == 's' && slx_i < slx_count)
                {
                  slx_p += slx_tnamerr (slx_p, slx_arg[slx_i++]);
                  slx_f += 2;
                }
              else
                {
                  slx_p++;
                  slx_f++;
                }
            }
        }
      return slx_size;
    }
}
#endif /* SL_ERROR_VERBOSE */


/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
slx_destruct (const char *slx_msg, int slx_type, SL_STYPE *slx_valuep)
#else
static void
slx_destruct (slx_msg, slx_type, slx_valuep)
    const char *slx_msg;
    int slx_type;
    SL_STYPE *slx_valuep;
#endif
{
  SL_USE (slx_valuep);

  if (!slx_msg)
    slx_msg = "Deleting";
  SL__SYMBOL_PRINT (slx_msg, slx_type, slx_valuep, slx_locationp);

  switch (slx_type)
    {

      default:
        break;
    }
}

/* Prevent warnings from -Wmissing-prototypes.  */
#ifdef SL_PARSE_PARAM
#if defined __STDC__ || defined __cplusplus
int slx_parse (void *SL_PARSE_PARAM);
#else
int slx_parse ();
#endif
#else /* ! SL_PARSE_PARAM */
#if defined __STDC__ || defined __cplusplus
int slx_parse (void);
#else
int slx_parse ();
#endif
#endif /* ! SL_PARSE_PARAM */


/* The lookahead symbol.  */
int slx_char;

/* The semantic value of the lookahead symbol.  */
SL_STYPE slx_lval;

/* Number of syntax errors so far.  */
int slx_nerrs;



/*-------------------------.
| slx_parse or slx_push_parse.  |
`-------------------------*/

#ifdef SL_PARSE_PARAM
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
int
slx_parse (void *SL_PARSE_PARAM)
#else
int
slx_parse (SL_PARSE_PARAM)
    void *SL_PARSE_PARAM;
#endif
#else /* ! SL_PARSE_PARAM */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
int
slx_parse (void)
#else
int
slx_parse ()

#endif
#endif
{


    int slx_state;
    /* Number of tokens to shift before error messages enabled.  */
    int slx_errstatus;

    /* The stacks and their tools:
       `slx_ss': related to states.
       `slx_vs': related to semantic values.

       Refer to the stacks thru separate pointers, to allow slx_overflow
       to reallocate them elsewhere.  */

    /* The state stack.  */
    slx_type_int16 slx_ssa[SL_INITDEPTH];
    slx_type_int16 *slx_ss;
    slx_type_int16 *slx_ssp;

    /* The semantic value stack.  */
    SL_STYPE slx_vsa[SL_INITDEPTH];
    SL_STYPE *slx_vs;
    SL_STYPE *slx_vsp;

    SL_SIZE_T slx_stacksize;

  int slx_n;
  int slx_result;
  /* Lookahead token as an internal (translated) token number.  */
  int slx_token;
  /* The variables used to return semantic value and location from the
     action routines.  */
  SL_STYPE slx_val;

#if SL_ERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char slx_msgbuf[128];
  char *slx_msg = slx_msgbuf;
  SL_SIZE_T slx_msg_alloc = sizeof slx_msgbuf;
#endif

#define SL_POPSTACK(N)   (slx_vsp -= (N), slx_ssp -= (N))

  /* The number of symbols on the RHS of the reduced rule.
     Keep to zero when no symbol should be popped.  */
  int slx_len = 0;

  slx_token = 0;
  slx_ss = slx_ssa;
  slx_vs = slx_vsa;
  slx_stacksize = SL_INITDEPTH;

  SL_DPRINTF ((stderr, "Starting parse\n"));

  slx_state = 0;
  slx_errstatus = 0;
  slx_nerrs = 0;
  slx_char = SL_EMPTY; /* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */
  slx_ssp = slx_ss;
  slx_vsp = slx_vs;

  goto slx_setstate;

/*------------------------------------------------------------.
| slx_newstate -- Push a new state, which is found in slx_state.  |
`------------------------------------------------------------*/
 slx_newstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  slx_ssp++;

 slx_setstate:
  *slx_ssp = slx_state;

  if (slx_ss + slx_stacksize - 1 <= slx_ssp)
    {
      /* Get the current used size of the three stacks, in elements.  */
      SL_SIZE_T slx_size = slx_ssp - slx_ss + 1;

#ifdef slx_overflow
      {
        /* Give user a chance to reallocate the stack.  Use copies of
           these so that the &'s don't force the real ones into
           memory.  */
        SL_STYPE *slx_vs1 = slx_vs;
        slx_type_int16 *slx_ss1 = slx_ss;

        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if slx_overflow is a macro.  */
        slx_overflow (SL__("memory exhausted"),
                    &slx_ss1, slx_size * sizeof (*slx_ssp),
                    &slx_vs1, slx_size * sizeof (*slx_vsp),
                    &slx_stacksize);

        slx_ss = slx_ss1;
        slx_vs = slx_vs1;
      }
#else /* no slx_overflow */
# ifndef SL_STACK_RELOCATE
      goto slx_exhaustedlab;
# else
      /* Extend the stack our own way.  */
      if (SL_MAXDEPTH <= slx_stacksize)
        goto slx_exhaustedlab;
      slx_stacksize *= 2;
      if (SL_MAXDEPTH < slx_stacksize)
        slx_stacksize = SL_MAXDEPTH;

      {
        slx_type_int16 *slx_ss1 = slx_ss;
        union slx_alloc *slx_ptr =
          (union slx_alloc *) SL_STACK_ALLOC (SL_STACK_BYTES (slx_stacksize));
        if (! slx_ptr)
          goto slx_exhaustedlab;
        SL_STACK_RELOCATE (slx_ss_alloc, slx_ss);
        SL_STACK_RELOCATE (slx_vs_alloc, slx_vs);
#  undef SL_STACK_RELOCATE
        if (slx_ss1 != slx_ssa)
          SL_STACK_FREE (slx_ss1);
      }
# endif
#endif /* no slx_overflow */

      slx_ssp = slx_ss + slx_size - 1;
      slx_vsp = slx_vs + slx_size - 1;

      SL_DPRINTF ((stderr, "Stack size increased to %lu\n",
                  (unsigned long int) slx_stacksize));

      if (slx_ss + slx_stacksize - 1 <= slx_ssp)
        SL_ABORT;
    }

  SL_DPRINTF ((stderr, "Entering state %d\n", slx_state));

  if (slx_state == SL_FINAL)
    SL_ACCEPT;

  goto slx_backup;

/*-----------.
| slx_backup.  |
`-----------*/
slx_backup:

  /* Do appropriate processing given the current state.  Read a
     lookahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to lookahead token.  */
  slx_n = slx_pact[slx_state];
  if (slx_n == SL_PACT_NINF)
    goto slx_default;

  /* Not known => get a lookahead token if don't already have one.  */

  /* SL_CHAR is either SL_EMPTY or SL_EOF or a valid lookahead symbol.  */
  if (slx_char == SL_EMPTY)
    {
      SL_DPRINTF ((stderr, "Reading a token: "));
      slx_char = SL_LEX;
    }

  if (slx_char <= SL_EOF)
    {
      slx_char = slx_token = SL_EOF;
      SL_DPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      slx_token = SL_TRANSLATE (slx_char);
      SL__SYMBOL_PRINT ("Next token is", slx_token, &slx_lval, &slx_lloc);
    }

  /* If the proper action on seeing token SL_TOKEN is to reduce or to
     detect an error, take that action.  */
  slx_n += slx_token;
  if (slx_n < 0 || SL_LAST < slx_n || slx_check[slx_n] != slx_token)
    goto slx_default;
  slx_n = slx_table[slx_n];
  if (slx_n <= 0)
    {
      if (slx_n == 0 || slx_n == SL_TABLE_NINF)
        goto slx_errlab;
      slx_n = -slx_n;
      goto slx_reduce;
    }

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (slx_errstatus)
    slx_errstatus--;

  /* Shift the lookahead token.  */
  SL__SYMBOL_PRINT ("Shifting", slx_token, &slx_lval, &slx_lloc);

  /* Discard the shifted token.  */
  slx_char = SL_EMPTY;

  slx_state = slx_n;
  *++slx_vsp = slx_lval;

  goto slx_newstate;


/*-----------------------------------------------------------.
| slx_default -- do the default action for the current state.  |
`-----------------------------------------------------------*/
slx_default:
  slx_n = slx_defact[slx_state];
  if (slx_n == 0)
    goto slx_errlab;
  goto slx_reduce;


/*-----------------------------.
| slx_reduce -- Do a reduction.  |
`-----------------------------*/
slx_reduce:
  /* slx_n is the number of a rule to reduce with.  */
  slx_len = slx_r2[slx_n];

  /* If SL_LEN is nonzero, implement the default value of the action:
     `$$ = $1'.

     Otherwise, the following line sets SL_VAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to SL_VAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that SL_VAL may be used uninitialized.  */
  slx_val = slx_vsp[1-slx_len];


  SL__REDUCE_PRINT (slx_n);
  switch (slx_n)
    {
        case 3:

/* Line 1455 of yacc.c  */
#line 86 "sl_gram.y"
    { /* Initialisation de la liste des systemes */
     sl_yacc      = NULL; 
     syntax_error = FALSE;
   }
    break;

  case 4:

/* Line 1455 of yacc.c  */
#line 93 "sl_gram.y"
    { /* Fin de la list des systemes */
     vect_rm( (Pvecteur) ba_yacc ); ba_yacc = NULL;
   }
    break;

  case 8:

/* Line 1455 of yacc.c  */
#line 106 "sl_gram.y"
    {
        if(!base_contains_variable_p(ba_yacc, (Variable) slx_text))
            ba_yacc = vect_add_variable(ba_yacc, (Variable) strdup(slx_text));
   }
    break;

  case 12:

/* Line 1455 of yacc.c  */
#line 120 "sl_gram.y"
    { /* initialisation des parametres de la liste de systemes */
          /* et initialisation des variables */
     ps_yacc = sc_new();
     init_globals();
   }
    break;

  case 13:

/* Line 1455 of yacc.c  */
#line 128 "sl_gram.y"
    {   
          /* on rajoute le systeme trouve a la liste */
     if (ps_yacc != NULL) {
       ps_yacc->base = NULL;
       sc_creer_base( ps_yacc );
     }
     sl_yacc = sl_append_system_first( sl_yacc, ps_yacc );
   }
    break;

  case 18:

/* Line 1455 of yacc.c  */
#line 148 "sl_gram.y"
    {   
     fac    = VALUE_ONE;
     sens   = 1;
     cote   = GAUCHE;
     b1     = 0;
     b2     = 0;
     operat = 0;
     cp     = NULL;
     eq     = contrainte_new();
   }
    break;

  case 19:

/* Line 1455 of yacc.c  */
#line 161 "sl_gram.y"
    { 
     contrainte_free(eq); 
   }
    break;

  case 21:

/* Line 1455 of yacc.c  */
#line 167 "sl_gram.y"
    { fac = VALUE_ONE;}
    break;

  case 24:

/* Line 1455 of yacc.c  */
#line 172 "sl_gram.y"
    {
     if (cote==DROIT)
       value_oppose(fac);

     /* ajout du couple (ident,const) a la contrainte courante */
     vect_add_elem(&(eq->vecteur), (Variable) (slx_vsp[(2) - (2)].Variable),value_mult(fac,(slx_vsp[(1) - (2)].Value)));
     /* duplication du couple (ident,const) de la combinaison lineaire
        traitee*/ 
     if (operat) vect_add_elem(&cp,(Variable) (slx_vsp[(2) - (2)].Variable),
                                    value_uminus(value_mult(fac,(slx_vsp[(1) - (2)].Value))));
   }
    break;

  case 25:

/* Line 1455 of yacc.c  */
#line 184 "sl_gram.y"
    {
       Value v = value_mult(fac,(slx_vsp[(1) - (1)].Value));
            if (cote==DROIT)
            {
                value_addto(b1,v); value_substract(b2,v);
            }
            else
            {
                value_addto(b2,v); value_substract(b1,v);
            }
   }
    break;

  case 26:

/* Line 1455 of yacc.c  */
#line 196 "sl_gram.y"
    {
       if (cote==DROIT) value_oppose(fac);

     /* ajout du couple (ident,1) a la contrainte courante */
     vect_add_elem (&(eq->vecteur),(Variable) (slx_vsp[(1) - (1)].Variable),fac);
     /* duplication du couple (ident,1) de la combinaison lineaire traitee */
     if (operat) vect_add_elem(&cp,(Variable) (slx_vsp[(1) - (1)].Variable),value_uminus(fac));
   }
    break;

  case 27:

/* Line 1455 of yacc.c  */
#line 207 "sl_gram.y"
    {
     va_yacc = base_find_variable_name(ba_yacc, 
                   (Variable) slx_text, 
                   variable_default_name);
     if(VARIABLE_UNDEFINED_P(va_yacc)) {
       (void) fprintf(stderr, 
            "Variable %s not declared. Add it to the VAR list!\n",
            variable_default_name((Variable) slx_text));
       exit(1);
     }
     (slx_val.Variable) = va_yacc;
   }
    break;

  case 28:

/* Line 1455 of yacc.c  */
#line 222 "sl_gram.y"
    { sscan_Value(slx_text, &valcst);
     (slx_val.Value) = (Value) valcst;
   }
    break;

  case 29:

/* Line 1455 of yacc.c  */
#line 228 "sl_gram.y"
    { 
     cote   = DROIT; 
     sens   = 1;
     operat = OPINF;
     cp     = NULL;
     b2     = 0; 
   }
    break;

  case 30:

/* Line 1455 of yacc.c  */
#line 236 "sl_gram.y"
    { 
     cote   = DROIT; 
     sens   = 1;
     operat = OPINFEGAL;
     cp     = NULL;
     b2     = 0;
   }
    break;

  case 31:

/* Line 1455 of yacc.c  */
#line 244 "sl_gram.y"
    { 
     cote   = DROIT; 
     sens   = 1;
     operat = OPEGAL; 
     cp     = NULL;
     b2     = 0;
   }
    break;

  case 32:

/* Line 1455 of yacc.c  */
#line 252 "sl_gram.y"
    {  
     cote   = DROIT; 
     sens   = -1;
     operat = OPSUP; 
     cp     = NULL;
     b2     = 0;
   }
    break;

  case 33:

/* Line 1455 of yacc.c  */
#line 260 "sl_gram.y"
    { 
     cote   = DROIT; 
     sens   = -1;
     operat = OPSUPEGAL;
     cp     = NULL;
     b2     = 0;
   }
    break;

  case 34:

/* Line 1455 of yacc.c  */
#line 269 "sl_gram.y"
    { fac = VALUE_ONE; }
    break;

  case 35:

/* Line 1455 of yacc.c  */
#line 271 "sl_gram.y"
    { fac = VALUE_MONE; }
    break;

  case 38:

/* Line 1455 of yacc.c  */
#line 279 "sl_gram.y"
    {
     vect_add_elem(&(eq->vecteur),TCST,value_uminus(b1));
     switch (operat) {
     case OPINF:
       creer_ineg(ps_yacc,eq,sens);
       vect_add_elem(&(eq->vecteur),TCST,VALUE_ONE);
       break;
     case OPINFEGAL:
       creer_ineg(ps_yacc,eq,sens);
       break;
     case OPSUPEGAL:
       creer_ineg(ps_yacc,eq,sens);
       break;
     case OPSUP:
       creer_ineg(ps_yacc,eq,sens);
       vect_add_elem (&(eq->vecteur),TCST,VALUE_ONE);
       break;
     case OPEGAL:
       creer_eg(ps_yacc,eq);
       break;
     }

     eq = contrainte_new();
     eq->vecteur = cp;
     b1 = b2;
   }
    break;



/* Line 1455 of yacc.c  */
#line 1710 "y.tab.c"
      default: break;
    }
  SL__SYMBOL_PRINT ("-> $$ =", slx_r1[slx_n], &slx_val, &slx_loc);

  SL_POPSTACK (slx_len);
  slx_len = 0;
  SL__STACK_PRINT (slx_ss, slx_ssp);

  *++slx_vsp = slx_val;

  /* Now `shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */

  slx_n = slx_r1[slx_n];

  slx_state = slx_pgoto[slx_n - SL_NTOKENS] + *slx_ssp;
  if (0 <= slx_state && slx_state <= SL_LAST && slx_check[slx_state] == *slx_ssp)
    slx_state = slx_table[slx_state];
  else
    slx_state = slx_defgoto[slx_n - SL_NTOKENS];

  goto slx_newstate;


/*------------------------------------.
| slx_errlab -- here on detecting error |
`------------------------------------*/
slx_errlab:
  /* If not already recovering from an error, report this error.  */
  if (!slx_errstatus)
    {
      ++slx_nerrs;
#if ! SL_ERROR_VERBOSE
      slx_error (SL__("syntax error"));
#else
      {
        SL_SIZE_T slx_size = slx_syntax_error (0, slx_state, slx_char);
        if (slx_msg_alloc < slx_size && slx_msg_alloc < SL_STACK_ALLOC_MAXIMUM)
          {
            SL_SIZE_T slx_alloc = 2 * slx_size;
            if (! (slx_size <= slx_alloc && slx_alloc <= SL_STACK_ALLOC_MAXIMUM))
              slx_alloc = SL_STACK_ALLOC_MAXIMUM;
            if (slx_msg != slx_msgbuf)
              SL_STACK_FREE (slx_msg);
            slx_msg = (char *) SL_STACK_ALLOC (slx_alloc);
            if (slx_msg)
              slx_msg_alloc = slx_alloc;
            else
              {
                slx_msg = slx_msgbuf;
                slx_msg_alloc = sizeof slx_msgbuf;
              }
          }

        if (0 < slx_size && slx_size <= slx_msg_alloc)
          {
            (void) slx_syntax_error (slx_msg, slx_state, slx_char);
            slx_error (slx_msg);
          }
        else
          {
            slx_error (SL__("syntax error"));
            if (slx_size != 0)
              goto slx_exhaustedlab;
          }
      }
#endif
    }



  if (slx_errstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */

      if (slx_char <= SL_EOF)
        {
          /* Return failure if at end of input.  */
          if (slx_char == SL_EOF)
            SL_ABORT;
        }
      else
        {
          slx_destruct ("Error: discarding",
                      slx_token, &slx_lval);
          slx_char = SL_EMPTY;
        }
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto slx_errlab1;


/*---------------------------------------------------.
| slx_errorlab -- error raised explicitly by SL_ERROR.  |
`---------------------------------------------------*/
slx_errorlab:

  /* Pacify compilers like GCC when the user code never invokes
     SL_ERROR and the label slx_errorlab therefore never appears in user
     code.  */
  if (/*CONSTCOND*/ 0)
     goto slx_errorlab;

  /* Do not reclaim the symbols of the rule which action triggered
     this SL_ERROR.  */
  SL_POPSTACK (slx_len);
  slx_len = 0;
  SL__STACK_PRINT (slx_ss, slx_ssp);
  slx_state = *slx_ssp;
  goto slx_errlab1;


/*-------------------------------------------------------------.
| slx_errlab1 -- common code for both syntax error and SL_ERROR.  |
`-------------------------------------------------------------*/
slx_errlab1:
  slx_errstatus = 3;    /* Each real token shifted decrements this.  */

  for (;;)
    {
      slx_n = slx_pact[slx_state];
      if (slx_n != SL_PACT_NINF)
        {
          slx_n += SL_TERROR;
          if (0 <= slx_n && slx_n <= SL_LAST && slx_check[slx_n] == SL_TERROR)
            {
              slx_n = slx_table[slx_n];
              if (0 < slx_n)
                break;
            }
        }

      /* Pop the current state because it cannot handle the error token.  */
      if (slx_ssp == slx_ss)
        SL_ABORT;


      slx_destruct ("Error: popping",
                  slx_stos[slx_state], slx_vsp);
      SL_POPSTACK (1);
      slx_state = *slx_ssp;
      SL__STACK_PRINT (slx_ss, slx_ssp);
    }

  *++slx_vsp = slx_lval;


  /* Shift the error token.  */
  SL__SYMBOL_PRINT ("Shifting", slx_stos[slx_n], slx_vsp, slx_lsp);

  slx_state = slx_n;
  goto slx_newstate;


/*-------------------------------------.
| slx_acceptlab -- SL_ACCEPT comes here.  |
`-------------------------------------*/
slx_acceptlab:
  slx_result = 0;
  goto slx_return;

/*-----------------------------------.
| slx_abortlab -- SL_ABORT comes here.  |
`-----------------------------------*/
slx_abortlab:
  slx_result = 1;
  goto slx_return;

#if !defined(slx_overflow) || SL_ERROR_VERBOSE
/*-------------------------------------------------.
| slx_exhaustedlab -- memory exhaustion comes here.  |
`-------------------------------------------------*/
slx_exhaustedlab:
  slx_error (SL__("memory exhausted"));
  slx_result = 2;
  /* Fall through.  */
#endif

slx_return:
  if (slx_char != SL_EMPTY)
     slx_destruct ("Cleanup: discarding lookahead",
                 slx_token, &slx_lval);
  /* Do not reclaim the symbols of the rule which action triggered
     this SL_ABORT or SL_ACCEPT.  */
  SL_POPSTACK (slx_len);
  SL__STACK_PRINT (slx_ss, slx_ssp);
  while (slx_ssp != slx_ss)
    {
      slx_destruct ("Cleanup: popping",
                  slx_stos[*slx_ssp], slx_vsp);
      SL_POPSTACK (1);
    }
#ifndef slx_overflow
  if (slx_ss != slx_ssa)
    SL_STACK_FREE (slx_ss);
#endif
#if SL_ERROR_VERBOSE
  if (slx_msg != slx_msgbuf)
    SL_STACK_FREE (slx_msg);
#endif
  /* Make sure SL_ID is used.  */
  return SL_ID (slx_result);
}



/* Line 1675 of yacc.c  */
#line 311 "sl_gram.y"


int slx_error(s)
char *s;
{
  /* procedure minimum de recouvrement d'erreurs */
  int c;
  (void) fprintf(stderr,"%s near %s\n",s,slx_text);
  while ((c = getchar()) != EOF) putchar(c);
  syntax_error = TRUE;
  return 0;
}

---