Code coverage tests

This page documents the degree to which the PARI/GP source code is tested by our public test suite, distributed with the source distribution in directory src/test/. This is measured by the gcov utility; we then process gcov output using the lcov frond-end.

We test a few variants depending on Configure flags on the pari.math.u-bordeaux.fr machine (x86_64 architecture), and agregate them in the final report:

The target is 90% coverage for all mathematical modules (given that branches depending on DEBUGLEVEL or DEBUGMEM are not covered). This script is run to produce the results below.

LCOV - code coverage report
Current view: top level - language - parse.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 19350-bd5f220) Lines: 175 252 69.4 %
Date: 2016-08-24 06:11:24 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* A Bison parser, made by GNU Bison 2.5.  */
       2             : 
       3             : /* Bison implementation for Yacc-like parsers in C
       4             :    
       5             :       Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
       6             :    
       7             :    This program is free software: you can redistribute it and/or modify
       8             :    it under the terms of the GNU General Public License as published by
       9             :    the Free Software Foundation, either version 3 of the License, or
      10             :    (at your option) any later version.
      11             :    
      12             :    This program is distributed in the hope that it will be useful,
      13             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :    GNU General Public License for more details.
      16             :    
      17             :    You should have received a copy of the GNU General Public License
      18             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
      19             : 
      20             : /* As a special exception, you may create a larger work that contains
      21             :    part or all of the Bison parser skeleton and distribute that work
      22             :    under terms of your choice, so long as that work isn't itself a
      23             :    parser generator using the skeleton or a modified version thereof
      24             :    as a parser skeleton.  Alternatively, if you modify or redistribute
      25             :    the parser skeleton itself, you may (at your option) remove this
      26             :    special exception, which will cause the skeleton and the resulting
      27             :    Bison output files to be licensed under the GNU General Public
      28             :    License without this special exception.
      29             :    
      30             :    This special exception was added by the Free Software Foundation in
      31             :    version 2.2 of Bison.  */
      32             : 
      33             : /* C LALR(1) parser skeleton written by Richard Stallman, by
      34             :    simplifying the original so-called "semantic" parser.  */
      35             : 
      36             : /* All symbols defined below should begin with yy or YY, to avoid
      37             :    infringing on user name space.  This should be done even for local
      38             :    variables, as they might otherwise be expanded by user macros.
      39             :    There are some unavoidable exceptions within include files to
      40             :    define necessary library symbols; they are noted "INFRINGES ON
      41             :    USER NAME SPACE" below.  */
      42             : 
      43             : /* Identify Bison output.  */
      44             : #define YYBISON 1
      45             : 
      46             : /* Bison version.  */
      47             : #define YYBISON_VERSION "2.5"
      48             : 
      49             : /* Skeleton name.  */
      50             : #define YYSKELETON_NAME "yacc.c"
      51             : 
      52             : /* Pure parsers.  */
      53             : #define YYPURE 1
      54             : 
      55             : /* Push parsers.  */
      56             : #define YYPUSH 0
      57             : 
      58             : /* Pull parsers.  */
      59             : #define YYPULL 1
      60             : 
      61             : /* Using locations.  */
      62             : #define YYLSP_NEEDED 1
      63             : 
      64             : /* Substitute the variable and function names.  */
      65             : #define yyparse         pari_parse
      66             : #define yylex           pari_lex
      67             : #define yyerror         pari_error
      68             : #define yylval          pari_lval
      69             : #define yychar          pari_char
      70             : #define yydebug         pari_debug
      71             : #define yynerrs         pari_nerrs
      72             : #define yylloc          pari_lloc
      73             : 
      74             : /* Copy the first part of user declarations.  */
      75             : 
      76             : /* Line 268 of yacc.c  */
      77             : #line 1 "../src/language/parse.y"
      78             : 
      79             : /* Copyright (C) 2006  The PARI group.
      80             : 
      81             : This file is part of the PARI package.
      82             : 
      83             : PARI/GP is free software; you can redistribute it and/or modify it under the
      84             : terms of the GNU General Public License as published by the Free Software
      85             : Foundation. It is distributed in the hope that it will be useful, but WITHOUT
      86             : ANY WARRANTY WHATSOEVER.
      87             : 
      88             : Check the License for details. You should have received a copy of it, along
      89             : with the package; see the file 'COPYING'. If not, write to the Free Software
      90             : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      91             : 
      92             : #define YYSIZE_T size_t
      93             : #define YYSTYPE union token_value
      94             : #define YYLTYPE struct node_loc
      95             : #define YYLLOC_DEFAULT(Current, Rhs, N)     \
      96             :         ((Current).start  = ((N)?(Rhs)[1].start:(Rhs)[0].end),  \
      97             :          (Current).end    = (Rhs)[N].end)
      98             : #include "parsec.h"
      99             : #define NOARG(x) newnode(Fnoarg,-1,-1,&(x))
     100             : #define NORANGE(x) newnode(Fnorange,-1,-1,&(x))
     101             : 
     102             : 
     103             : /* Line 268 of yacc.c  */
     104             : #line 105 "../src/language/parse.c"
     105             : 
     106             : /* Enabling traces.  */
     107             : #ifndef YYDEBUG
     108             : # define YYDEBUG 0
     109             : #endif
     110             : 
     111             : /* Enabling verbose error messages.  */
     112             : #ifdef YYERROR_VERBOSE
     113             : # undef YYERROR_VERBOSE
     114             : # define YYERROR_VERBOSE 1
     115             : #else
     116             : # define YYERROR_VERBOSE 1
     117             : #endif
     118             : 
     119             : /* Enabling the token table.  */
     120             : #ifndef YYTOKEN_TABLE
     121             : # define YYTOKEN_TABLE 0
     122             : #endif
     123             : 
     124             : 
     125             : /* Tokens.  */
     126             : #ifndef YYTOKENTYPE
     127             : # define YYTOKENTYPE
     128             :    /* Put the tokens into the symbol table, so that GDB and other debuggers
     129             :       know about them.  */
     130             :    enum yytokentype {
     131             :      KPARROW = 258,
     132             :      KARROW = 259,
     133             :      KDOTDOT = 260,
     134             :      KPE = 261,
     135             :      KSE = 262,
     136             :      KME = 263,
     137             :      KDE = 264,
     138             :      KDRE = 265,
     139             :      KEUCE = 266,
     140             :      KMODE = 267,
     141             :      KAND = 268,
     142             :      KOR = 269,
     143             :      KID = 270,
     144             :      KEQ = 271,
     145             :      KNE = 272,
     146             :      KGE = 273,
     147             :      KLE = 274,
     148             :      KSRE = 275,
     149             :      KSLE = 276,
     150             :      KSR = 277,
     151             :      KSL = 278,
     152             :      KDR = 279,
     153             :      KPP = 280,
     154             :      KSS = 281,
     155             :      KINTEGER = 282,
     156             :      KREAL = 283,
     157             :      KENTRY = 284,
     158             :      KSTRING = 285,
     159             :      DEFFUNC = 286,
     160             :      SEQ = 287,
     161             :      LVAL = 288,
     162             :      INT = 289,
     163             :      SIGN = 290
     164             :    };
     165             : #endif
     166             : 
     167             : 
     168             : 
     169             : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
     170             : 
     171             : # define yystype YYSTYPE /* obsolescent; will be withdrawn */
     172             : # define YYSTYPE_IS_DECLARED 1
     173             : #endif
     174             : 
     175             : #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
     176             : typedef struct YYLTYPE
     177             : {
     178             :   int first_line;
     179             :   int first_column;
     180             :   int last_line;
     181             :   int last_column;
     182             : } YYLTYPE;
     183             : # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
     184             : # define YYLTYPE_IS_DECLARED 1
     185             : # define YYLTYPE_IS_TRIVIAL 1
     186             : #endif
     187             : 
     188             : 
     189             : /* Copy the second part of user declarations.  */
     190             : 
     191             : 
     192             : /* Line 343 of yacc.c  */
     193             : #line 194 "../src/language/parse.c"
     194             : 
     195             : #ifdef short
     196             : # undef short
     197             : #endif
     198             : 
     199             : #ifdef YYTYPE_UINT8
     200             : typedef YYTYPE_UINT8 yytype_uint8;
     201             : #else
     202             : typedef unsigned char yytype_uint8;
     203             : #endif
     204             : 
     205             : #ifdef YYTYPE_INT8
     206             : typedef YYTYPE_INT8 yytype_int8;
     207             : #elif (defined __STDC__ || defined __C99__FUNC__ \
     208             :      || defined __cplusplus || defined _MSC_VER)
     209             : typedef signed char yytype_int8;
     210             : #else
     211             : typedef short int yytype_int8;
     212             : #endif
     213             : 
     214             : #ifdef YYTYPE_UINT16
     215             : typedef YYTYPE_UINT16 yytype_uint16;
     216             : #else
     217             : typedef unsigned short int yytype_uint16;
     218             : #endif
     219             : 
     220             : #ifdef YYTYPE_INT16
     221             : typedef YYTYPE_INT16 yytype_int16;
     222             : #else
     223             : typedef short int yytype_int16;
     224             : #endif
     225             : 
     226             : #ifndef YYSIZE_T
     227             : # ifdef __SIZE_TYPE__
     228             : #  define YYSIZE_T __SIZE_TYPE__
     229             : # elif defined size_t
     230             : #  define YYSIZE_T size_t
     231             : # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
     232             :      || defined __cplusplus || defined _MSC_VER)
     233             : #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
     234             : #  define YYSIZE_T size_t
     235             : # else
     236             : #  define YYSIZE_T unsigned int
     237             : # endif
     238             : #endif
     239             : 
     240             : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
     241             : 
     242             : #ifndef YY_
     243             : # if defined YYENABLE_NLS && YYENABLE_NLS
     244             : #  if ENABLE_NLS
     245             : #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
     246             : #   define YY_(msgid) dgettext ("bison-runtime", msgid)
     247             : #  endif
     248             : # endif
     249             : # ifndef YY_
     250             : #  define YY_(msgid) msgid
     251             : # endif
     252             : #endif
     253             : 
     254             : /* Suppress unused-variable warnings by "using" E.  */
     255             : #if ! defined lint || defined __GNUC__
     256             : # define YYUSE(e) ((void) (e))
     257             : #else
     258             : # define YYUSE(e) /* empty */
     259             : #endif
     260             : 
     261             : /* Identity function, used to suppress warnings about constant conditions.  */
     262             : #ifndef lint
     263             : # define YYID(n) (n)
     264             : #else
     265             : #if (defined __STDC__ || defined __C99__FUNC__ \
     266             :      || defined __cplusplus || defined _MSC_VER)
     267             : static int
     268             : YYID (int yyi)
     269             : #else
     270             : static int
     271             : YYID (yyi)
     272             :     int yyi;
     273             : #endif
     274             : {
     275             :   return yyi;
     276             : }
     277             : #endif
     278             : 
     279             : #if ! defined yyoverflow || YYERROR_VERBOSE
     280             : 
     281             : /* The parser invokes alloca or malloc; define the necessary symbols.  */
     282             : 
     283             : # ifdef YYSTACK_USE_ALLOCA
     284             : #  if YYSTACK_USE_ALLOCA
     285             : #   ifdef __GNUC__
     286             : #    define YYSTACK_ALLOC __builtin_alloca
     287             : #   elif defined __BUILTIN_VA_ARG_INCR
     288             : #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
     289             : #   elif defined _AIX
     290             : #    define YYSTACK_ALLOC __alloca
     291             : #   elif defined _MSC_VER
     292             : #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
     293             : #    define alloca _alloca
     294             : #   else
     295             : #    define YYSTACK_ALLOC alloca
     296             : #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
     297             :      || defined __cplusplus || defined _MSC_VER)
     298             : #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
     299             : #     ifndef EXIT_SUCCESS
     300             : #      define EXIT_SUCCESS 0
     301             : #     endif
     302             : #    endif
     303             : #   endif
     304             : #  endif
     305             : # endif
     306             : 
     307             : # ifdef YYSTACK_ALLOC
     308             :    /* Pacify GCC's `empty if-body' warning.  */
     309             : #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
     310             : #  ifndef YYSTACK_ALLOC_MAXIMUM
     311             :     /* The OS might guarantee only one guard page at the bottom of the stack,
     312             :        and a page size can be as small as 4096 bytes.  So we cannot safely
     313             :        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
     314             :        to allow for a few compiler-allocated temporary stack slots.  */
     315             : #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
     316             : #  endif
     317             : # else
     318             : #  define YYSTACK_ALLOC YYMALLOC
     319             : #  define YYSTACK_FREE YYFREE
     320             : #  ifndef YYSTACK_ALLOC_MAXIMUM
     321             : #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
     322             : #  endif
     323             : #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
     324             :        && ! ((defined YYMALLOC || defined malloc) \
     325             :              && (defined YYFREE || defined free)))
     326             : #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
     327             : #   ifndef EXIT_SUCCESS
     328             : #    define EXIT_SUCCESS 0
     329             : #   endif
     330             : #  endif
     331             : #  ifndef YYMALLOC
     332             : #   define YYMALLOC malloc
     333             : #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
     334             :      || defined __cplusplus || defined _MSC_VER)
     335             : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
     336             : #   endif
     337             : #  endif
     338             : #  ifndef YYFREE
     339             : #   define YYFREE free
     340             : #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
     341             :      || defined __cplusplus || defined _MSC_VER)
     342             : void free (void *); /* INFRINGES ON USER NAME SPACE */
     343             : #   endif
     344             : #  endif
     345             : # endif
     346             : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
     347             : 
     348             : 
     349             : #if (! defined yyoverflow \
     350             :      && (! defined __cplusplus \
     351             :          || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
     352             :              && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
     353             : 
     354             : /* A type that is properly aligned for any stack member.  */
     355             : union yyalloc
     356             : {
     357             :   yytype_int16 yyss_alloc;
     358             :   YYSTYPE yyvs_alloc;
     359             :   YYLTYPE yyls_alloc;
     360             : };
     361             : 
     362             : /* The size of the maximum gap between one aligned stack and the next.  */
     363             : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
     364             : 
     365             : /* The size of an array large to enough to hold all stacks, each with
     366             :    N elements.  */
     367             : # define YYSTACK_BYTES(N) \
     368             :      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
     369             :       + 2 * YYSTACK_GAP_MAXIMUM)
     370             : 
     371             : # define YYCOPY_NEEDED 1
     372             : 
     373             : /* Relocate STACK from its old location to the new one.  The
     374             :    local variables YYSIZE and YYSTACKSIZE give the old and new number of
     375             :    elements in the stack, and YYPTR gives the new location of the
     376             :    stack.  Advance YYPTR to a properly aligned location for the next
     377             :    stack.  */
     378             : # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
     379             :     do                                                                  \
     380             :       {                                                                 \
     381             :         YYSIZE_T yynewbytes;                                            \
     382             :         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                     \
     383             :         Stack = &yyptr->Stack_alloc;                                     \
     384             :         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
     385             :         yyptr += yynewbytes / sizeof (*yyptr);                          \
     386             :       }                                                                 \
     387             :     while (YYID (0))
     388             : 
     389             : #endif
     390             : 
     391             : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
     392             : /* Copy COUNT objects from FROM to TO.  The source and destination do
     393             :    not overlap.  */
     394             : # ifndef YYCOPY
     395             : #  if defined __GNUC__ && 1 < __GNUC__
     396             : #   define YYCOPY(To, From, Count) \
     397             :       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
     398             : #  else
     399             : #   define YYCOPY(To, From, Count)              \
     400             :       do                                        \
     401             :         {                                       \
     402             :           YYSIZE_T yyi;                         \
     403             :           for (yyi = 0; yyi < (Count); yyi++)        \
     404             :             (To)[yyi] = (From)[yyi];            \
     405             :         }                                       \
     406             :       while (YYID (0))
     407             : #  endif
     408             : # endif
     409             : #endif /* !YYCOPY_NEEDED */
     410             : 
     411             : /* YYFINAL -- State number of the termination state.  */
     412             : #define YYFINAL  47
     413             : /* YYLAST -- Last index in YYTABLE.  */
     414             : #define YYLAST   671
     415             : 
     416             : /* YYNTOKENS -- Number of terminals.  */
     417             : #define YYNTOKENS  61
     418             : /* YYNNTS -- Number of nonterminals.  */
     419             : #define YYNNTS  21
     420             : /* YYNRULES -- Number of rules.  */
     421             : #define YYNRULES  109
     422             : /* YYNRULES -- Number of states.  */
     423             : #define YYNSTATES  192
     424             : 
     425             : /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
     426             : #define YYUNDEFTOK  2
     427             : #define YYMAXUTOK   290
     428             : 
     429             : #define YYTRANSLATE(YYX)                                                \
     430             :   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
     431             : 
     432             : /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
     433             : static const yytype_uint8 yytranslate[] =
     434             : {
     435             :        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     436             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     437             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     438             :        2,     2,     2,    50,     2,    49,     2,    43,    38,    53,
     439             :       55,    59,    46,    41,    36,    42,    54,    45,     2,     2,
     440             :        2,     2,     2,     2,     2,     2,     2,     2,    56,    35,
     441             :       40,    37,    39,     2,     2,     2,     2,     2,     2,     2,
     442             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     443             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     444             :        2,    52,    44,    57,    48,     2,    58,     2,     2,     2,
     445             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     446             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     447             :        2,     2,     2,     2,    60,     2,    51,     2,     2,     2,
     448             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     449             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     450             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     451             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     452             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     453             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     454             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     455             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     456             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     457             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     458             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     459             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     460             :        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
     461             :        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
     462             :       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     463             :       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
     464             :       47
     465             : };
     466             : 
     467             : #if YYDEBUG
     468             : /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
     469             :    YYRHS.  */
     470             : static const yytype_uint16 yyprhs[] =
     471             : {
     472             :        0,     0,     3,     5,     6,     8,    11,    15,    16,    18,
     473             :       22,    25,    31,    35,    37,    40,    42,    45,    48,    51,
     474             :       55,    59,    61,    63,    65,    69,    71,    74,    76,    81,
     475             :       83,    85,    87,    89,    91,    95,    99,   102,   105,   109,
     476             :      113,   117,   121,   125,   129,   133,   137,   141,   144,   147,
     477             :      151,   155,   159,   163,   167,   171,   175,   179,   183,   187,
     478             :      191,   195,   199,   203,   207,   211,   215,   219,   223,   226,
     479             :      229,   233,   236,   239,   242,   245,   247,   251,   255,   257,
     480             :      260,   264,   266,   270,   274,   278,   281,   287,   291,   295,
     481             :      299,   303,   308,   310,   314,   318,   324,   330,   332,   337,
     482             :      340,   341,   346,   348,   352,   357,   361,   368,   374,   378
     483             : };
     484             : 
     485             : /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
     486             : static const yytype_int8 yyrhs[] =
     487             : {
     488             :       62,     0,    -1,    63,    -1,    -1,    68,    -1,    63,    35,
     489             :       -1,    63,    35,    68,    -1,    -1,    68,    -1,    68,     5,
     490             :       68,    -1,    48,    68,    -1,    52,    64,    36,    64,    57,
     491             :       -1,    52,    64,    57,    -1,    58,    -1,    66,    58,    -1,
     492             :       43,    -1,    43,    27,    -1,    43,    66,    -1,    43,    49,
     493             :       -1,    43,    49,    27,    -1,    43,    49,    66,    -1,    27,
     494             :       -1,    28,    -1,    54,    -1,    27,    54,    29,    -1,    30,
     495             :       -1,    53,    29,    -1,    67,    -1,    68,    55,    78,    59,
     496             :       -1,    79,    -1,    69,    -1,    72,    -1,    75,    -1,    81,
     497             :       -1,    72,    37,    68,    -1,    69,    37,    68,    -1,    69,
     498             :       25,    -1,    69,    26,    -1,    69,     8,    68,    -1,    69,
     499             :        9,    68,    -1,    69,    10,    68,    -1,    69,    11,    68,
     500             :       -1,    69,    12,    68,    -1,    69,    21,    68,    -1,    69,
     501             :       20,    68,    -1,    69,     6,    68,    -1,    69,     7,    68,
     502             :       -1,    50,    68,    -1,    49,    68,    -1,    68,    14,    68,
     503             :       -1,    68,    13,    68,    -1,    68,    38,    68,    -1,    68,
     504             :       15,    68,    -1,    68,    16,    68,    -1,    68,    17,    68,
     505             :       -1,    68,    18,    68,    -1,    68,    39,    68,    -1,    68,
     506             :       19,    68,    -1,    68,    40,    68,    -1,    68,    42,    68,
     507             :       -1,    68,    41,    68,    -1,    68,    23,    68,    -1,    68,
     508             :       22,    68,    -1,    68,    43,    68,    -1,    68,    24,    68,
     509             :       -1,    68,    44,    68,    -1,    68,    45,    68,    -1,    68,
     510             :       46,    68,    -1,    41,    68,    -1,    42,    68,    -1,    68,
     511             :       48,    68,    -1,    68,    51,    -1,    68,    53,    -1,    68,
     512             :       50,    -1,    68,    65,    -1,    80,    -1,    68,    56,    29,
     513             :       -1,    55,    68,    59,    -1,    29,    -1,    69,    65,    -1,
     514             :       69,    56,    29,    -1,    68,    -1,    70,    36,    68,    -1,
     515             :       70,    35,    70,    -1,    71,    35,    70,    -1,    52,    57,
     516             :       -1,    52,    68,     5,    68,    57,    -1,    52,    35,    57,
     517             :       -1,    52,    70,    57,    -1,    52,    71,    57,    -1,    52,
     518             :        1,    57,    -1,    69,    40,    42,    68,    -1,    73,    -1,
     519             :       73,    36,    68,    -1,    73,    35,    74,    -1,    73,    36,
     520             :       68,    35,    74,    -1,    52,    68,    60,    74,    57,    -1,
     521             :       63,    -1,    69,    52,     5,    57,    -1,    38,    69,    -1,
     522             :       -1,    76,     1,    77,    68,    -1,    76,    -1,    78,    36,
     523             :       76,    -1,    29,    55,    78,    59,    -1,    68,    54,    29,
     524             :       -1,    29,    55,    78,    59,    37,    63,    -1,    68,    54,
     525             :       29,    37,    63,    -1,    69,     4,    63,    -1,    55,    78,
     526             :        3,    63,    -1
     527             : };
     528             : 
     529             : /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
     530             : static const yytype_uint8 yyrline[] =
     531             : {
     532             :        0,    86,    86,    89,    90,    91,    92,    95,    96,    97,
     533             :       98,   101,   102,   105,   106,   109,   110,   111,   112,   113,
     534             :      114,   117,   118,   119,   120,   122,   123,   124,   125,   126,
     535             :      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
     536             :      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
     537             :      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
     538             :      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
     539             :      167,   168,   169,   170,   171,   172,   173,   174,   177,   178,
     540             :      179,   182,   183,   186,   187,   190,   191,   192,   193,   194,
     541             :      195,   198,   201,   202,   203,   204,   207,   210,   211,   212,
     542             :      213,   213,   217,   218,   221,   224,   227,   229,   231,   232
     543             : };
     544             : #endif
     545             : 
     546             : #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
     547             : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     548             :    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
     549             : static const char *const yytname[] =
     550             : {
     551             :   "$end", "error", "$undefined", "\")->\"", "\"->\"", "\"..\"", "\"+=\"",
     552             :   "\"-=\"", "\"*=\"", "\"/=\"", "\"\\\\/=\"", "\"\\\\=\"", "\"%=\"",
     553             :   "\"&&\"", "\"||\"", "\"===\"", "\"==\"", "\"!=\"", "\">=\"", "\"<=\"",
     554             :   "\">>=\"", "\"<<=\"", "\">>\"", "\"<<\"", "\"\\\\/\"", "\"++\"",
     555             :   "\"--\"", "\"integer\"", "\"real number\"", "\"variable name\"",
     556             :   "\"character string\"", "DEFFUNC", "SEQ", "LVAL", "INT", "';'", "','",
     557             :   "'='", "'&'", "'>'", "'<'", "'+'", "'-'", "'%'", "'\\\\'", "'/'", "'*'",
     558             :   "SIGN", "'^'", "'#'", "'!'", "'~'", "'['", "'\\''", "'.'", "'('", "':'",
     559             :   "']'", "'`'", "')'", "'|'", "$accept", "sequence", "seq", "range",
     560             :   "matrix_index", "backticks", "history", "expr", "lvalue", "matrixelts",
     561             :   "matrixlines", "matrix", "in", "inseq", "compr", "arg", "$@1", "listarg",
     562             :   "funcid", "memberid", "definition", 0
     563             : };
     564             : #endif
     565             : 
     566             : # ifdef YYPRINT
     567             : /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
     568             :    token YYLEX-NUM.  */
     569             : static const yytype_uint16 yytoknum[] =
     570             : {
     571             :        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     572             :      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     573             :      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
     574             :      285,   286,   287,   288,   289,    59,    44,    61,    38,    62,
     575             :       60,    43,    45,    37,    92,    47,    42,   290,    94,    35,
     576             :       33,   126,    91,    39,    46,    40,    58,    93,    96,    41,
     577             :      124
     578             : };
     579             : # endif
     580             : 
     581             : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
     582             : static const yytype_uint8 yyr1[] =
     583             : {
     584             :        0,    61,    62,    63,    63,    63,    63,    64,    64,    64,
     585             :       64,    65,    65,    66,    66,    67,    67,    67,    67,    67,
     586             :       67,    68,    68,    68,    68,    68,    68,    68,    68,    68,
     587             :       68,    68,    68,    68,    68,    68,    68,    68,    68,    68,
     588             :       68,    68,    68,    68,    68,    68,    68,    68,    68,    68,
     589             :       68,    68,    68,    68,    68,    68,    68,    68,    68,    68,
     590             :       68,    68,    68,    68,    68,    68,    68,    68,    68,    68,
     591             :       68,    68,    68,    68,    68,    68,    68,    68,    69,    69,
     592             :       69,    70,    70,    71,    71,    72,    72,    72,    72,    72,
     593             :       72,    73,    74,    74,    74,    74,    75,    76,    76,    76,
     594             :       77,    76,    78,    78,    79,    80,    81,    81,    81,    81
     595             : };
     596             : 
     597             : /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
     598             : static const yytype_uint8 yyr2[] =
     599             : {
     600             :        0,     2,     1,     0,     1,     2,     3,     0,     1,     3,
     601             :        2,     5,     3,     1,     2,     1,     2,     2,     2,     3,
     602             :        3,     1,     1,     1,     3,     1,     2,     1,     4,     1,
     603             :        1,     1,     1,     1,     3,     3,     2,     2,     3,     3,
     604             :        3,     3,     3,     3,     3,     3,     3,     2,     2,     3,
     605             :        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
     606             :        3,     3,     3,     3,     3,     3,     3,     3,     2,     2,
     607             :        3,     2,     2,     2,     2,     1,     3,     3,     1,     2,
     608             :        3,     1,     3,     3,     3,     2,     5,     3,     3,     3,
     609             :        3,     4,     1,     3,     3,     5,     5,     1,     4,     2,
     610             :        0,     4,     1,     3,     4,     3,     6,     5,     3,     4
     611             : };
     612             : 
     613             : /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
     614             :    Performed when YYTABLE doesn't specify something else to do.  Zero
     615             :    means the default is an error.  */
     616             : static const yytype_uint8 yydefact[] =
     617             : {
     618             :        3,    21,    22,    78,    25,     0,     0,    15,     0,     0,
     619             :        0,     0,    23,     3,     0,     2,    27,     4,    30,    31,
     620             :       32,    29,    75,    33,     0,     3,    68,    69,    16,    18,
     621             :       13,    17,    48,    47,     0,     0,    85,    81,     0,     0,
     622             :       26,     0,    97,     4,    30,     0,     0,     1,     5,     0,
     623             :        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     624             :        0,     0,     0,     0,     0,     0,     0,     0,     0,    73,
     625             :       71,     7,    72,     0,     3,     0,    74,     3,     0,     0,
     626             :        0,     0,     0,     0,     0,     0,     0,    36,    37,     0,
     627             :        0,    79,     0,    24,     0,    19,    20,    14,    90,    87,
     628             :        0,     0,     0,     0,    88,     0,    89,    78,    99,    77,
     629             :        7,   100,     3,     3,     6,    50,    49,    52,    53,    54,
     630             :       55,    57,    62,    61,    64,    51,    56,    58,    60,    59,
     631             :       63,    65,    66,    67,    70,     0,     0,     8,   105,     0,
     632             :       76,   108,    45,    46,    38,    39,    40,    41,    42,    44,
     633             :       43,    35,    80,    34,   104,     0,     0,    92,     0,    81,
     634             :       83,    82,    84,     0,     0,   109,     0,    10,     7,    12,
     635             :        0,     3,    28,     3,    86,     0,     0,     0,    96,    98,
     636             :      101,     0,     9,   107,   106,     0,    94,    93,    11,    91,
     637             :        0,    95
     638             : };
     639             : 
     640             : /* YYDEFGOTO[NTERM-NUM].  */
     641             : static const yytype_int16 yydefgoto[] =
     642             : {
     643             :       -1,    14,    42,   136,    76,    31,    16,    17,    18,    38,
     644             :       39,    19,   157,   158,    20,    45,   164,    46,    21,    22,
     645             :       23
     646             : };
     647             : 
     648             : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     649             :    STATE-NUM.  */
     650             : #define YYPACT_NINF -165
     651             : static const yytype_int16 yypact[] =
     652             : {
     653             :      616,   -33,  -165,   -28,  -165,   616,   616,   -17,   616,   616,
     654             :       84,     1,  -165,   582,    31,     3,  -165,   461,   141,    46,
     655             :     -165,  -165,  -165,  -165,    60,   582,   150,   150,  -165,    12,
     656             :     -165,    38,   190,    54,    42,    44,  -165,   172,    36,    47,
     657             :     -165,    61,     3,   325,   227,     6,    33,  -165,   616,   616,
     658             :      616,   616,   616,   616,   616,   616,   616,   616,   616,   616,
     659             :      616,   616,   616,   616,   616,   616,   616,   616,   616,  -165,
     660             :     -165,   599,  -165,    73,   582,    74,  -165,   616,   616,   616,
     661             :      616,   616,   616,   616,   616,   616,   616,  -165,  -165,   616,
     662             :       86,  -165,   616,  -165,   -22,  -165,    38,  -165,  -165,  -165,
     663             :      616,    61,   616,   616,  -165,   616,  -165,  -165,   -36,  -165,
     664             :      282,  -165,   616,   582,   461,   503,   503,   538,   538,   538,
     665             :      538,   538,   150,   150,   150,   503,   538,   538,   552,   552,
     666             :      150,   150,   150,   150,   150,   616,    50,   252,    79,   -19,
     667             :     -165,     3,   461,   461,   461,   461,   461,   461,   461,   461,
     668             :      461,   461,  -165,   461,    80,   372,   -27,   -12,    63,   461,
     669             :       82,   461,    82,    64,   616,     3,    32,   461,   599,  -165,
     670             :      616,   616,  -165,   616,  -165,    87,    61,   616,  -165,  -165,
     671             :      461,    65,   461,     3,     3,   616,  -165,   417,  -165,   461,
     672             :       61,  -165
     673             : };
     674             : 
     675             : /* YYPGOTO[NTERM-NUM].  */
     676             : static const yytype_int16 yypgoto[] =
     677             : {
     678             :     -165,  -165,    11,   -44,   -16,    99,  -165,    -5,    -7,   -83,
     679             :     -165,  -165,  -165,  -164,  -165,    18,  -165,   -10,  -165,  -165,
     680             :     -165
     681             : };
     682             : 
     683             : /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
     684             :    positive, shift that token.  If negative, reduce the rule which
     685             :    number is the opposite.  If YYTABLE_NINF, syntax error.  */
     686             : #define YYTABLE_NINF -104
     687             : static const yytype_int16 yytable[] =
     688             : {
     689             :       26,    27,    91,    32,    33,    37,    44,   111,    43,  -102,
     690             :       28,    15,   186,   175,   113,    94,    71,   113,    44,   160,
     691             :       90,    24,   162,   176,   177,    71,   191,    25,    91,    90,
     692             :       40,    47,    29,   111,   108,  -103,   112,   154,    48,    95,
     693             :      172,    30,  -102,   114,   115,   116,   117,   118,   119,   120,
     694             :      121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
     695             :      131,   132,   133,   134,   139,  -102,   137,    44,  -103,   113,
     696             :       30,   102,   103,   142,   143,   144,   145,   146,   147,   148,
     697             :      149,   150,   105,    92,   151,    34,   168,   153,   141,    93,
     698             :      107,  -103,    91,   104,   156,   155,    97,   159,   161,    98,
     699             :      159,    99,   138,   140,   106,   137,    44,   169,    73,    74,
     700             :       75,     1,     2,     3,     4,   152,   171,   173,   103,    35,
     701             :      178,   179,   188,   165,   181,     5,     6,     7,    96,   185,
     702             :      167,   166,     0,     8,     9,     0,    10,    11,    12,    13,
     703             :       91,    36,     0,     0,     0,    77,     0,    78,    79,    80,
     704             :       81,    82,    83,    84,     0,     0,     0,     0,     0,   180,
     705             :        0,    85,    86,   137,     0,   182,    87,    88,     0,   156,
     706             :        0,     0,   187,     0,     0,     0,     0,   100,    89,     0,
     707             :      189,     0,   183,   156,   184,    49,    50,    51,    52,    53,
     708             :       54,    55,     0,    71,    56,    57,    58,    90,    68,     0,
     709             :       69,    70,    71,    72,    73,    74,    75,     0,     0,     0,
     710             :       59,    60,    61,    62,    63,    64,    65,    66,    67,     0,
     711             :       68,     0,    69,    70,    71,    72,    73,    74,    75,     0,
     712             :        0,    77,   101,    78,    79,    80,    81,    82,    83,    84,
     713             :       69,    70,    71,    72,    73,    74,    75,    85,    86,     0,
     714             :        0,     0,    87,    88,     0,     0,     0,   170,     0,     0,
     715             :        0,     0,     0,     0,    89,    49,    50,    51,    52,    53,
     716             :       54,    55,     0,     0,    56,    57,    58,     0,     0,   110,
     717             :        0,     0,     0,    90,     0,     0,     0,   163,     0,     0,
     718             :       59,    60,    61,    62,    63,    64,    65,    66,    67,     0,
     719             :       68,     0,    69,    70,    71,    72,    73,    74,    75,     1,
     720             :        2,     3,     4,     0,     0,     0,     0,     0,     0,     0,
     721             :        0,     0,     0,     5,     6,     7,     0,     0,     0,     0,
     722             :      135,     8,     9,     0,    10,    11,    12,    13,    49,    50,
     723             :       51,    52,    53,    54,    55,     0,     0,    56,    57,    58,
     724             :        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     725             :        0,     0,     0,    59,    60,    61,    62,    63,    64,    65,
     726             :       66,    67,     0,    68,     0,    69,    70,    71,    72,    73,
     727             :       74,    75,     0,     0,   109,    49,    50,    51,    52,    53,
     728             :       54,    55,     0,     0,    56,    57,    58,     0,     0,     0,
     729             :        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     730             :       59,    60,    61,    62,    63,    64,    65,    66,    67,     0,
     731             :       68,     0,    69,    70,    71,    72,    73,    74,    75,   174,
     732             :       49,    50,    51,    52,    53,    54,    55,     0,     0,    56,
     733             :       57,    58,     0,     0,     0,     0,     0,     0,     0,     0,
     734             :        0,     0,   190,     0,     0,    59,    60,    61,    62,    63,
     735             :       64,    65,    66,    67,     0,    68,     0,    69,    70,    71,
     736             :       72,    73,    74,    75,    49,    50,    51,    52,    53,    54,
     737             :       55,     0,     0,    56,    57,    58,     0,     0,     0,     0,
     738             :        0,     0,     0,     0,     0,     0,     0,     0,     0,    59,
     739             :       60,    61,    62,    63,    64,    65,    66,    67,     0,    68,
     740             :        0,    69,    70,    71,    72,    73,    74,    75,    51,    52,
     741             :       53,    54,    55,     0,     0,    56,    57,    58,     0,     0,
     742             :        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     743             :        0,     0,    60,    61,    62,    63,    64,    65,    66,    67,
     744             :        0,    68,     0,    69,    70,    71,    72,    73,    74,    75,
     745             :       56,    57,    58,     0,     0,     0,     0,     0,     0,     0,
     746             :        0,     0,     0,     0,    56,    57,    58,     0,     0,    62,
     747             :       63,    64,    65,    66,    67,     0,    68,     0,    69,    70,
     748             :       71,    72,    73,    74,    75,    64,    65,    66,    67,     0,
     749             :       68,     0,    69,    70,    71,    72,    73,    74,    75,     1,
     750             :        2,     3,     4,     0,     0,     0,     0,     0,     0,     0,
     751             :       41,     0,     0,     5,     6,     7,     1,     2,     3,     4,
     752             :        0,     8,     9,     0,    10,    11,    12,    13,     0,     0,
     753             :        5,     6,     7,     1,     2,     3,     4,   135,     8,     9,
     754             :        0,    10,    11,    12,    13,     0,     0,     5,     6,     7,
     755             :        0,     0,     0,     0,     0,     8,     9,     0,    10,    11,
     756             :       12,    13
     757             : };
     758             : 
     759             : #define yypact_value_is_default(yystate) \
     760             :   ((yystate) == (-165))
     761             : 
     762             : #define yytable_value_is_error(yytable_value) \
     763             :   YYID (0)
     764             : 
     765             : static const yytype_int16 yycheck[] =
     766             : {
     767             :        5,     6,    18,     8,     9,    10,    13,     1,    13,     3,
     768             :       27,     0,   176,    40,    36,    25,    52,    36,    25,   102,
     769             :       56,    54,   105,    35,    36,    52,   190,    55,    44,    56,
     770             :       29,     0,    49,     1,    41,     3,     3,    59,    35,    27,
     771             :       59,    58,    36,    48,    49,    50,    51,    52,    53,    54,
     772             :       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
     773             :       65,    66,    67,    68,    74,    59,    71,    74,    36,    36,
     774             :       58,    35,    36,    78,    79,    80,    81,    82,    83,    84,
     775             :       85,    86,    35,    37,    89,     1,    36,    92,    77,    29,
     776             :       29,    59,   108,    57,   101,   100,    58,   102,   103,    57,
     777             :      105,    57,    29,    29,    57,   110,   113,    57,    54,    55,
     778             :       56,    27,    28,    29,    30,    29,    37,    37,    36,    35,
     779             :       57,    57,    57,   112,   168,    41,    42,    43,    29,    42,
     780             :      135,   113,    -1,    49,    50,    -1,    52,    53,    54,    55,
     781             :      156,    57,    -1,    -1,    -1,     4,    -1,     6,     7,     8,
     782             :        9,    10,    11,    12,    -1,    -1,    -1,    -1,    -1,   164,
     783             :       -1,    20,    21,   168,    -1,   170,    25,    26,    -1,   176,
     784             :       -1,    -1,   177,    -1,    -1,    -1,    -1,     5,    37,    -1,
     785             :      185,    -1,   171,   190,   173,    13,    14,    15,    16,    17,
     786             :       18,    19,    -1,    52,    22,    23,    24,    56,    48,    -1,
     787             :       50,    51,    52,    53,    54,    55,    56,    -1,    -1,    -1,
     788             :       38,    39,    40,    41,    42,    43,    44,    45,    46,    -1,
     789             :       48,    -1,    50,    51,    52,    53,    54,    55,    56,    -1,
     790             :       -1,     4,    60,     6,     7,     8,     9,    10,    11,    12,
     791             :       50,    51,    52,    53,    54,    55,    56,    20,    21,    -1,
     792             :       -1,    -1,    25,    26,    -1,    -1,    -1,     5,    -1,    -1,
     793             :       -1,    -1,    -1,    -1,    37,    13,    14,    15,    16,    17,
     794             :       18,    19,    -1,    -1,    22,    23,    24,    -1,    -1,    52,
     795             :       -1,    -1,    -1,    56,    -1,    -1,    -1,     5,    -1,    -1,
     796             :       38,    39,    40,    41,    42,    43,    44,    45,    46,    -1,
     797             :       48,    -1,    50,    51,    52,    53,    54,    55,    56,    27,
     798             :       28,    29,    30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     799             :       -1,    -1,    -1,    41,    42,    43,    -1,    -1,    -1,    -1,
     800             :       48,    49,    50,    -1,    52,    53,    54,    55,    13,    14,
     801             :       15,    16,    17,    18,    19,    -1,    -1,    22,    23,    24,
     802             :       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     803             :       -1,    -1,    -1,    38,    39,    40,    41,    42,    43,    44,
     804             :       45,    46,    -1,    48,    -1,    50,    51,    52,    53,    54,
     805             :       55,    56,    -1,    -1,    59,    13,    14,    15,    16,    17,
     806             :       18,    19,    -1,    -1,    22,    23,    24,    -1,    -1,    -1,
     807             :       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     808             :       38,    39,    40,    41,    42,    43,    44,    45,    46,    -1,
     809             :       48,    -1,    50,    51,    52,    53,    54,    55,    56,    57,
     810             :       13,    14,    15,    16,    17,    18,    19,    -1,    -1,    22,
     811             :       23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     812             :       -1,    -1,    35,    -1,    -1,    38,    39,    40,    41,    42,
     813             :       43,    44,    45,    46,    -1,    48,    -1,    50,    51,    52,
     814             :       53,    54,    55,    56,    13,    14,    15,    16,    17,    18,
     815             :       19,    -1,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,
     816             :       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    38,
     817             :       39,    40,    41,    42,    43,    44,    45,    46,    -1,    48,
     818             :       -1,    50,    51,    52,    53,    54,    55,    56,    15,    16,
     819             :       17,    18,    19,    -1,    -1,    22,    23,    24,    -1,    -1,
     820             :       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     821             :       -1,    -1,    39,    40,    41,    42,    43,    44,    45,    46,
     822             :       -1,    48,    -1,    50,    51,    52,    53,    54,    55,    56,
     823             :       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     824             :       -1,    -1,    -1,    -1,    22,    23,    24,    -1,    -1,    41,
     825             :       42,    43,    44,    45,    46,    -1,    48,    -1,    50,    51,
     826             :       52,    53,    54,    55,    56,    43,    44,    45,    46,    -1,
     827             :       48,    -1,    50,    51,    52,    53,    54,    55,    56,    27,
     828             :       28,    29,    30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     829             :       38,    -1,    -1,    41,    42,    43,    27,    28,    29,    30,
     830             :       -1,    49,    50,    -1,    52,    53,    54,    55,    -1,    -1,
     831             :       41,    42,    43,    27,    28,    29,    30,    48,    49,    50,
     832             :       -1,    52,    53,    54,    55,    -1,    -1,    41,    42,    43,
     833             :       -1,    -1,    -1,    -1,    -1,    49,    50,    -1,    52,    53,
     834             :       54,    55
     835             : };
     836             : 
     837             : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     838             :    symbol of state STATE-NUM.  */
     839             : static const yytype_uint8 yystos[] =
     840             : {
     841             :        0,    27,    28,    29,    30,    41,    42,    43,    49,    50,
     842             :       52,    53,    54,    55,    62,    63,    67,    68,    69,    72,
     843             :       75,    79,    80,    81,    54,    55,    68,    68,    27,    49,
     844             :       58,    66,    68,    68,     1,    35,    57,    68,    70,    71,
     845             :       29,    38,    63,    68,    69,    76,    78,     0,    35,    13,
     846             :       14,    15,    16,    17,    18,    19,    22,    23,    24,    38,
     847             :       39,    40,    41,    42,    43,    44,    45,    46,    48,    50,
     848             :       51,    52,    53,    54,    55,    56,    65,     4,     6,     7,
     849             :        8,     9,    10,    11,    12,    20,    21,    25,    26,    37,
     850             :       56,    65,    37,    29,    78,    27,    66,    58,    57,    57,
     851             :        5,    60,    35,    36,    57,    35,    57,    29,    69,    59,
     852             :       52,     1,     3,    36,    68,    68,    68,    68,    68,    68,
     853             :       68,    68,    68,    68,    68,    68,    68,    68,    68,    68,
     854             :       68,    68,    68,    68,    68,    48,    64,    68,    29,    78,
     855             :       29,    63,    68,    68,    68,    68,    68,    68,    68,    68,
     856             :       68,    68,    29,    68,    59,    68,    69,    73,    74,    68,
     857             :       70,    68,    70,     5,    77,    63,    76,    68,    36,    57,
     858             :        5,    37,    59,    37,    57,    40,    35,    36,    57,    57,
     859             :       68,    64,    68,    63,    63,    42,    74,    68,    57,    68,
     860             :       35,    74
     861             : };
     862             : 
     863             : #define yyerrok         (yyerrstatus = 0)
     864             : #define yyclearin       (yychar = YYEMPTY)
     865             : #define YYEMPTY         (-2)
     866             : #define YYEOF           0
     867             : 
     868             : #define YYACCEPT        goto yyacceptlab
     869             : #define YYABORT         goto yyabortlab
     870             : #define YYERROR         goto yyerrorlab
     871             : 
     872             : 
     873             : /* Like YYERROR except do call yyerror.  This remains here temporarily
     874             :    to ease the transition to the new meaning of YYERROR, for GCC.
     875             :    Once GCC version 2 has supplanted version 1, this can go.  However,
     876             :    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
     877             :    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
     878             :    discussed.  */
     879             : 
     880             : #define YYFAIL          goto yyerrlab
     881             : #if defined YYFAIL
     882             :   /* This is here to suppress warnings from the GCC cpp's
     883             :      -Wunused-macros.  Normally we don't worry about that warning, but
     884             :      some users do, and we want to make it easy for users to remove
     885             :      YYFAIL uses, which will produce warnings from Bison 2.5.  */
     886             : #endif
     887             : 
     888             : #define YYRECOVERING()  (!!yyerrstatus)
     889             : 
     890             : #define YYBACKUP(Token, Value)                                  \
     891             : do                                                              \
     892             :   if (yychar == YYEMPTY && yylen == 1)                          \
     893             :     {                                                           \
     894             :       yychar = (Token);                                         \
     895             :       yylval = (Value);                                         \
     896             :       YYPOPSTACK (1);                                           \
     897             :       goto yybackup;                                            \
     898             :     }                                                           \
     899             :   else                                                          \
     900             :     {                                                           \
     901             :       yyerror (&yylloc, lex, YY_("syntax error: cannot back up")); \
     902             :       YYERROR;                                                  \
     903             :     }                                                           \
     904             : while (YYID (0))
     905             : 
     906             : 
     907             : #define YYTERROR        1
     908             : #define YYERRCODE       256
     909             : 
     910             : 
     911             : /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
     912             :    If N is 0, then set CURRENT to the empty location which ends
     913             :    the previous symbol: RHS[0] (always defined).  */
     914             : 
     915             : #define YYRHSLOC(Rhs, K) ((Rhs)[K])
     916             : #ifndef YYLLOC_DEFAULT
     917             : # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
     918             :     do                                                                  \
     919             :       if (YYID (N))                                                    \
     920             :         {                                                               \
     921             :           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
     922             :           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
     923             :           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
     924             :           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
     925             :         }                                                               \
     926             :       else                                                              \
     927             :         {                                                               \
     928             :           (Current).first_line   = (Current).last_line   =              \
     929             :             YYRHSLOC (Rhs, 0).last_line;                                \
     930             :           (Current).first_column = (Current).last_column =              \
     931             :             YYRHSLOC (Rhs, 0).last_column;                              \
     932             :         }                                                               \
     933             :     while (YYID (0))
     934             : #endif
     935             : 
     936             : 
     937             : /* YY_LOCATION_PRINT -- Print the location on the stream.
     938             :    This macro was not mandated originally: define only if we know
     939             :    we won't break user code: when these are the locations we know.  */
     940             : 
     941             : #ifndef YY_LOCATION_PRINT
     942             : # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
     943             : #  define YY_LOCATION_PRINT(File, Loc)                  \
     944             :      fprintf (File, "%d.%d-%d.%d",                    \
     945             :               (Loc).first_line, (Loc).first_column,     \
     946             :               (Loc).last_line,  (Loc).last_column)
     947             : # else
     948             : #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
     949             : # endif
     950             : #endif
     951             : 
     952             : 
     953             : /* YYLEX -- calling `yylex' with the right arguments.  */
     954             : 
     955             : #ifdef YYLEX_PARAM
     956             : # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
     957             : #else
     958             : # define YYLEX yylex (&yylval, &yylloc, lex)
     959             : #endif
     960             : 
     961             : /* Enable debugging if requested.  */
     962             : #if YYDEBUG
     963             : 
     964             : # ifndef YYFPRINTF
     965             : #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
     966             : #  define YYFPRINTF fprintf
     967             : # endif
     968             : 
     969             : # define YYDPRINTF(Args)                        \
     970             : do {                                            \
     971             :   if (yydebug)                                  \
     972             :     YYFPRINTF Args;                             \
     973             : } while (YYID (0))
     974             : 
     975             : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
     976             : do {                                                                      \
     977             :   if (yydebug)                                                            \
     978             :     {                                                                     \
     979             :       YYFPRINTF (stderr, "%s ", Title);                                         \
     980             :       yy_symbol_print (stderr,                                            \
     981             :                   Type, Value, Location, lex); \
     982             :       YYFPRINTF (stderr, "\n");                                                 \
     983             :     }                                                                     \
     984             : } while (YYID (0))
     985             : 
     986             : 
     987             : /*--------------------------------.
     988             : | Print this symbol on YYOUTPUT.  |
     989             : `--------------------------------*/
     990             : 
     991             : /*ARGSUSED*/
     992             : #if (defined __STDC__ || defined __C99__FUNC__ \
     993             :      || defined __cplusplus || defined _MSC_VER)
     994             : static void
     995             : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, char **lex)
     996             : #else
     997             : static void
     998             : yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, lex)
     999             :     FILE *yyoutput;
    1000             :     int yytype;
    1001             :     YYSTYPE const * const yyvaluep;
    1002             :     YYLTYPE const * const yylocationp;
    1003             :     char **lex;
    1004             : #endif
    1005             : {
    1006             :   if (!yyvaluep)
    1007             :     return;
    1008             :   YYUSE (yylocationp);
    1009             :   YYUSE (lex);
    1010             : # ifdef YYPRINT
    1011             :   if (yytype < YYNTOKENS)
    1012             :     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
    1013             : # else
    1014             :   YYUSE (yyoutput);
    1015             : # endif
    1016             :   switch (yytype)
    1017             :     {
    1018             :       default:
    1019             :         break;
    1020             :     }
    1021             : }
    1022             : 
    1023             : 
    1024             : /*--------------------------------.
    1025             : | Print this symbol on YYOUTPUT.  |
    1026             : `--------------------------------*/
    1027             : 
    1028             : #if (defined __STDC__ || defined __C99__FUNC__ \
    1029             :      || defined __cplusplus || defined _MSC_VER)
    1030             : static void
    1031             : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, char **lex)
    1032             : #else
    1033             : static void
    1034             : yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, lex)
    1035             :     FILE *yyoutput;
    1036             :     int yytype;
    1037             :     YYSTYPE const * const yyvaluep;
    1038             :     YYLTYPE const * const yylocationp;
    1039             :     char **lex;
    1040             : #endif
    1041             : {
    1042             :   if (yytype < YYNTOKENS)
    1043             :     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
    1044             :   else
    1045             :     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
    1046             : 
    1047             :   YY_LOCATION_PRINT (yyoutput, *yylocationp);
    1048             :   YYFPRINTF (yyoutput, ": ");
    1049             :   yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, lex);
    1050             :   YYFPRINTF (yyoutput, ")");
    1051             : }
    1052             : 
    1053             : /*------------------------------------------------------------------.
    1054             : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
    1055             : | TOP (included).                                                   |
    1056             : `------------------------------------------------------------------*/
    1057             : 
    1058             : #if (defined __STDC__ || defined __C99__FUNC__ \
    1059             :      || defined __cplusplus || defined _MSC_VER)
    1060             : static void
    1061             : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
    1062             : #else
    1063             : static void
    1064             : yy_stack_print (yybottom, yytop)
    1065             :     yytype_int16 *yybottom;
    1066             :     yytype_int16 *yytop;
    1067             : #endif
    1068             : {
    1069             :   YYFPRINTF (stderr, "Stack now");
    1070             :   for (; yybottom <= yytop; yybottom++)
    1071             :     {
    1072             :       int yybot = *yybottom;
    1073             :       YYFPRINTF (stderr, " %d", yybot);
    1074             :     }
    1075             :   YYFPRINTF (stderr, "\n");
    1076             : }
    1077             : 
    1078             : # define YY_STACK_PRINT(Bottom, Top)                            \
    1079             : do {                                                            \
    1080             :   if (yydebug)                                                  \
    1081             :     yy_stack_print ((Bottom), (Top));                           \
    1082             : } while (YYID (0))
    1083             : 
    1084             : 
    1085             : /*------------------------------------------------.
    1086             : | Report that the YYRULE is going to be reduced.  |
    1087             : `------------------------------------------------*/
    1088             : 
    1089             : #if (defined __STDC__ || defined __C99__FUNC__ \
    1090             :      || defined __cplusplus || defined _MSC_VER)
    1091             : static void
    1092             : yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, char **lex)
    1093             : #else
    1094             : static void
    1095             : yy_reduce_print (yyvsp, yylsp, yyrule, lex)
    1096             :     YYSTYPE *yyvsp;
    1097             :     YYLTYPE *yylsp;
    1098             :     int yyrule;
    1099             :     char **lex;
    1100             : #endif
    1101             : {
    1102             :   int yynrhs = yyr2[yyrule];
    1103             :   int yyi;
    1104             :   unsigned long int yylno = yyrline[yyrule];
    1105             :   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
    1106             :              yyrule - 1, yylno);
    1107             :   /* The symbols being reduced.  */
    1108             :   for (yyi = 0; yyi < yynrhs; yyi++)
    1109             :     {
    1110             :       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
    1111             :       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
    1112             :                        &(yyvsp[(yyi + 1) - (yynrhs)])
    1113             :                        , &(yylsp[(yyi + 1) - (yynrhs)])                    , lex);
    1114             :       YYFPRINTF (stderr, "\n");
    1115             :     }
    1116             : }
    1117             : 
    1118             : # define YY_REDUCE_PRINT(Rule)          \
    1119             : do {                                    \
    1120             :   if (yydebug)                          \
    1121             :     yy_reduce_print (yyvsp, yylsp, Rule, lex); \
    1122             : } while (YYID (0))
    1123             : 
    1124             : /* Nonzero means print parse trace.  It is left uninitialized so that
    1125             :    multiple parsers can coexist.  */
    1126             : int yydebug;
    1127             : #else /* !YYDEBUG */
    1128             : # define YYDPRINTF(Args)
    1129             : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
    1130             : # define YY_STACK_PRINT(Bottom, Top)
    1131             : # define YY_REDUCE_PRINT(Rule)
    1132             : #endif /* !YYDEBUG */
    1133             : 
    1134             : 
    1135             : /* YYINITDEPTH -- initial size of the parser's stacks.  */
    1136             : #ifndef YYINITDEPTH
    1137             : # define YYINITDEPTH 200
    1138             : #endif
    1139             : 
    1140             : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
    1141             :    if the built-in stack extension method is used).
    1142             : 
    1143             :    Do not make this value too large; the results are undefined if
    1144             :    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
    1145             :    evaluated with infinite-precision integer arithmetic.  */
    1146             : 
    1147             : #ifndef YYMAXDEPTH
    1148             : # define YYMAXDEPTH 10000
    1149             : #endif
    1150             : 
    1151             : 
    1152             : #if YYERROR_VERBOSE
    1153             : 
    1154             : # ifndef yystrlen
    1155             : #  if defined __GLIBC__ && defined _STRING_H
    1156             : #   define yystrlen strlen
    1157             : #  else
    1158             : /* Return the length of YYSTR.  */
    1159             : #if (defined __STDC__ || defined __C99__FUNC__ \
    1160             :      || defined __cplusplus || defined _MSC_VER)
    1161             : static YYSIZE_T
    1162             : yystrlen (const char *yystr)
    1163             : #else
    1164             : static YYSIZE_T
    1165             : yystrlen (yystr)
    1166             :     const char *yystr;
    1167             : #endif
    1168             : {
    1169             :   YYSIZE_T yylen;
    1170             :   for (yylen = 0; yystr[yylen]; yylen++)
    1171             :     continue;
    1172             :   return yylen;
    1173             : }
    1174             : #  endif
    1175             : # endif
    1176             : 
    1177             : # ifndef yystpcpy
    1178             : #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
    1179             : #   define yystpcpy stpcpy
    1180             : #  else
    1181             : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
    1182             :    YYDEST.  */
    1183             : #if (defined __STDC__ || defined __C99__FUNC__ \
    1184             :      || defined __cplusplus || defined _MSC_VER)
    1185             : static char *
    1186         196 : yystpcpy (char *yydest, const char *yysrc)
    1187             : #else
    1188             : static char *
    1189             : yystpcpy (yydest, yysrc)
    1190             :     char *yydest;
    1191             :     const char *yysrc;
    1192             : #endif
    1193             : {
    1194         196 :   char *yyd = yydest;
    1195         196 :   const char *yys = yysrc;
    1196             : 
    1197         987 :   while ((*yyd++ = *yys++) != '\0')
    1198         595 :     continue;
    1199             : 
    1200         196 :   return yyd - 1;
    1201             : }
    1202             : #  endif
    1203             : # endif
    1204             : 
    1205             : # ifndef yytnamerr
    1206             : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
    1207             :    quotes and backslashes, so that it's suitable for yyerror.  The
    1208             :    heuristic is that double-quoting is unnecessary unless the string
    1209             :    contains an apostrophe, a comma, or backslash (other than
    1210             :    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
    1211             :    null, do not copy; instead, return the length of what the result
    1212             :    would have been.  */
    1213             : static YYSIZE_T
    1214         756 : yytnamerr (char *yyres, const char *yystr)
    1215             : {
    1216         756 :   if (*yystr == '"')
    1217             :     {
    1218         364 :       YYSIZE_T yyn = 0;
    1219         364 :       char const *yyp = yystr;
    1220             : 
    1221             :       for (;;)
    1222        3570 :         switch (*++yyp)
    1223             :           {
    1224             :           case '\'':
    1225             :           case ',':
    1226           0 :             goto do_not_strip_quotes;
    1227             : 
    1228             :           case '\\':
    1229           0 :             if (*++yyp != '\\')
    1230           0 :               goto do_not_strip_quotes;
    1231             :             /* Fall through.  */
    1232             :           default:
    1233        3206 :             if (yyres)
    1234        1603 :               yyres[yyn] = *yyp;
    1235        3206 :             yyn++;
    1236        3206 :             break;
    1237             : 
    1238             :           case '"':
    1239         364 :             if (yyres)
    1240         182 :               yyres[yyn] = '\0';
    1241         364 :             return yyn;
    1242             :           }
    1243        3206 :     do_not_strip_quotes: ;
    1244             :     }
    1245             : 
    1246         392 :   if (! yyres)
    1247         196 :     return yystrlen (yystr);
    1248             : 
    1249         196 :   return yystpcpy (yyres, yystr) - yyres;
    1250             : }
    1251             : # endif
    1252             : 
    1253             : /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
    1254             :    about the unexpected token YYTOKEN for the state stack whose top is
    1255             :    YYSSP.
    1256             : 
    1257             :    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
    1258             :    not large enough to hold the message.  In that case, also set
    1259             :    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
    1260             :    required number of bytes is too large to store.  */
    1261             : static int
    1262          98 : yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
    1263             :                 yytype_int16 *yyssp, int yytoken)
    1264             : {
    1265          98 :   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
    1266          98 :   YYSIZE_T yysize = yysize0;
    1267             :   YYSIZE_T yysize1;
    1268             :   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
    1269             :   /* Internationalized format string. */
    1270          98 :   const char *yyformat = 0;
    1271             :   /* Arguments of yyformat. */
    1272             :   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
    1273             :   /* Number of reported tokens (one for the "unexpected", one per
    1274             :      "expected"). */
    1275          98 :   int yycount = 0;
    1276             : 
    1277             :   /* There are many possibilities here to consider:
    1278             :      - Assume YYFAIL is not used.  It's too flawed to consider.  See
    1279             :        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
    1280             :        for details.  YYERROR is fine as it does not invoke this
    1281             :        function.
    1282             :      - If this state is a consistent state with a default action, then
    1283             :        the only way this function was invoked is if the default action
    1284             :        is an error action.  In that case, don't check for expected
    1285             :        tokens because there are none.
    1286             :      - The only way there can be no lookahead present (in yychar) is if
    1287             :        this state is a consistent state with a default action.  Thus,
    1288             :        detecting the absence of a lookahead is sufficient to determine
    1289             :        that there is no unexpected or expected token to report.  In that
    1290             :        case, just report a simple "syntax error".
    1291             :      - Don't assume there isn't a lookahead just because this state is a
    1292             :        consistent state with a default action.  There might have been a
    1293             :        previous inconsistent state, consistent state with a non-default
    1294             :        action, or user semantic action that manipulated yychar.
    1295             :      - Of course, the expected token list depends on states to have
    1296             :        correct lookahead information, and it depends on the parser not
    1297             :        to perform extra reductions after fetching a lookahead from the
    1298             :        scanner and before detecting a syntax error.  Thus, state merging
    1299             :        (from LALR or IELR) and default reductions corrupt the expected
    1300             :        token list.  However, the list is correct for canonical LR with
    1301             :        one exception: it will still contain any token that will not be
    1302             :        accepted due to an error action in a later state.
    1303             :   */
    1304          98 :   if (yytoken != YYEMPTY)
    1305             :     {
    1306          98 :       int yyn = yypact[*yyssp];
    1307          98 :       yyarg[yycount++] = yytname[yytoken];
    1308          98 :       if (!yypact_value_is_default (yyn))
    1309             :         {
    1310             :           /* Start YYX at -YYN if negative to avoid negative indexes in
    1311             :              YYCHECK.  In other words, skip the first -YYN actions for
    1312             :              this state because they are default actions.  */
    1313          98 :           int yyxbegin = yyn < 0 ? -yyn : 0;
    1314             :           /* Stay within bounds of both yycheck and yytname.  */
    1315          98 :           int yychecklim = YYLAST - yyn + 1;
    1316          98 :           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
    1317             :           int yyx;
    1318             : 
    1319        6076 :           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
    1320        5978 :             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
    1321         371 :                 && !yytable_value_is_error (yytable[yyx + yyn]))
    1322             :               {
    1323         280 :                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
    1324             :                   {
    1325           0 :                     yycount = 1;
    1326           0 :                     yysize = yysize0;
    1327           0 :                     break;
    1328             :                   }
    1329         280 :                 yyarg[yycount++] = yytname[yyx];
    1330         280 :                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
    1331         280 :                 if (! (yysize <= yysize1
    1332             :                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
    1333           0 :                   return 2;
    1334         280 :                 yysize = yysize1;
    1335             :               }
    1336             :         }
    1337             :     }
    1338             : 
    1339          98 :   switch (yycount)
    1340             :     {
    1341             : # define YYCASE_(N, S)                      \
    1342             :       case N:                               \
    1343             :         yyformat = S;                       \
    1344             :       break
    1345           0 :       YYCASE_(0, YY_("syntax error"));
    1346           0 :       YYCASE_(1, YY_("syntax error, unexpected %s"));
    1347           7 :       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
    1348           0 :       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
    1349          91 :       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
    1350           0 :       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
    1351             : # undef YYCASE_
    1352             :     }
    1353             : 
    1354          98 :   yysize1 = yysize + yystrlen (yyformat);
    1355          98 :   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
    1356           0 :     return 2;
    1357          98 :   yysize = yysize1;
    1358             : 
    1359          98 :   if (*yymsg_alloc < yysize)
    1360             :     {
    1361           0 :       *yymsg_alloc = 2 * yysize;
    1362           0 :       if (! (yysize <= *yymsg_alloc
    1363             :              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
    1364           0 :         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
    1365           0 :       return 1;
    1366             :     }
    1367             : 
    1368             :   /* Avoid sprintf, as that infringes on the user's name space.
    1369             :      Don't have undefined behavior even if the translation
    1370             :      produced a string with the wrong number of "%s"s.  */
    1371             :   {
    1372          98 :     char *yyp = *yymsg;
    1373          98 :     int yyi = 0;
    1374        4928 :     while ((*yyp = *yyformat) != '\0')
    1375        4732 :       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
    1376             :         {
    1377         378 :           yyp += yytnamerr (yyp, yyarg[yyi++]);
    1378         378 :           yyformat += 2;
    1379             :         }
    1380             :       else
    1381             :         {
    1382        4354 :           yyp++;
    1383        4354 :           yyformat++;
    1384             :         }
    1385             :   }
    1386          98 :   return 0;
    1387             : }
    1388             : #endif /* YYERROR_VERBOSE */
    1389             : 
    1390             : /*-----------------------------------------------.
    1391             : | Release the memory associated to this symbol.  |
    1392             : `-----------------------------------------------*/
    1393             : 
    1394             : /*ARGSUSED*/
    1395             : #if (defined __STDC__ || defined __C99__FUNC__ \
    1396             :      || defined __cplusplus || defined _MSC_VER)
    1397             : static void
    1398      159490 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, char **lex)
    1399             : #else
    1400             : static void
    1401             : yydestruct (yymsg, yytype, yyvaluep, yylocationp, lex)
    1402             :     const char *yymsg;
    1403             :     int yytype;
    1404             :     YYSTYPE *yyvaluep;
    1405             :     YYLTYPE *yylocationp;
    1406             :     char **lex;
    1407             : #endif
    1408             : {
    1409             :   YYUSE (yyvaluep);
    1410             :   YYUSE (yylocationp);
    1411             :   YYUSE (lex);
    1412             : 
    1413      159490 :   if (!yymsg)
    1414           0 :     yymsg = "Deleting";
    1415             :   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
    1416             : 
    1417      159490 :   switch (yytype)
    1418             :     {
    1419             :       case 63: /* "seq" */
    1420             : 
    1421             : /* Line 1391 of yacc.c  */
    1422             : #line 83 "../src/language/parse.y"
    1423             :         { pari_discarded++; };
    1424             : 
    1425             : /* Line 1391 of yacc.c  */
    1426             : #line 1427 "../src/language/parse.c"
    1427           0 :         break;
    1428             :       case 64: /* "range" */
    1429             : 
    1430             : /* Line 1391 of yacc.c  */
    1431             : #line 83 "../src/language/parse.y"
    1432             :         { pari_discarded++; };
    1433             : 
    1434             : /* Line 1391 of yacc.c  */
    1435             : #line 1436 "../src/language/parse.c"
    1436           0 :         break;
    1437             :       case 65: /* "matrix_index" */
    1438             : 
    1439             : /* Line 1391 of yacc.c  */
    1440             : #line 83 "../src/language/parse.y"
    1441             :         { pari_discarded++; };
    1442             : 
    1443             : /* Line 1391 of yacc.c  */
    1444             : #line 1445 "../src/language/parse.c"
    1445           0 :         break;
    1446             :       case 66: /* "backticks" */
    1447             : 
    1448             : /* Line 1391 of yacc.c  */
    1449             : #line 83 "../src/language/parse.y"
    1450             :         { pari_discarded++; };
    1451             : 
    1452             : /* Line 1391 of yacc.c  */
    1453             : #line 1454 "../src/language/parse.c"
    1454           0 :         break;
    1455             :       case 67: /* "history" */
    1456             : 
    1457             : /* Line 1391 of yacc.c  */
    1458             : #line 83 "../src/language/parse.y"
    1459             :         { pari_discarded++; };
    1460             : 
    1461             : /* Line 1391 of yacc.c  */
    1462             : #line 1463 "../src/language/parse.c"
    1463           0 :         break;
    1464             :       case 68: /* "expr" */
    1465             : 
    1466             : /* Line 1391 of yacc.c  */
    1467             : #line 83 "../src/language/parse.y"
    1468             :         { pari_discarded++; };
    1469             : 
    1470             : /* Line 1391 of yacc.c  */
    1471             : #line 1472 "../src/language/parse.c"
    1472           0 :         break;
    1473             :       case 69: /* "lvalue" */
    1474             : 
    1475             : /* Line 1391 of yacc.c  */
    1476             : #line 83 "../src/language/parse.y"
    1477             :         { pari_discarded++; };
    1478             : 
    1479             : /* Line 1391 of yacc.c  */
    1480             : #line 1481 "../src/language/parse.c"
    1481           0 :         break;
    1482             :       case 70: /* "matrixelts" */
    1483             : 
    1484             : /* Line 1391 of yacc.c  */
    1485             : #line 83 "../src/language/parse.y"
    1486             :         { pari_discarded++; };
    1487             : 
    1488             : /* Line 1391 of yacc.c  */
    1489             : #line 1490 "../src/language/parse.c"
    1490           0 :         break;
    1491             :       case 71: /* "matrixlines" */
    1492             : 
    1493             : /* Line 1391 of yacc.c  */
    1494             : #line 83 "../src/language/parse.y"
    1495             :         { pari_discarded++; };
    1496             : 
    1497             : /* Line 1391 of yacc.c  */
    1498             : #line 1499 "../src/language/parse.c"
    1499           0 :         break;
    1500             :       case 72: /* "matrix" */
    1501             : 
    1502             : /* Line 1391 of yacc.c  */
    1503             : #line 83 "../src/language/parse.y"
    1504             :         { pari_discarded++; };
    1505             : 
    1506             : /* Line 1391 of yacc.c  */
    1507             : #line 1508 "../src/language/parse.c"
    1508           0 :         break;
    1509             :       case 73: /* "in" */
    1510             : 
    1511             : /* Line 1391 of yacc.c  */
    1512             : #line 83 "../src/language/parse.y"
    1513             :         { pari_discarded++; };
    1514             : 
    1515             : /* Line 1391 of yacc.c  */
    1516             : #line 1517 "../src/language/parse.c"
    1517           0 :         break;
    1518             :       case 74: /* "inseq" */
    1519             : 
    1520             : /* Line 1391 of yacc.c  */
    1521             : #line 83 "../src/language/parse.y"
    1522             :         { pari_discarded++; };
    1523             : 
    1524             : /* Line 1391 of yacc.c  */
    1525             : #line 1526 "../src/language/parse.c"
    1526           0 :         break;
    1527             :       case 75: /* "compr" */
    1528             : 
    1529             : /* Line 1391 of yacc.c  */
    1530             : #line 83 "../src/language/parse.y"
    1531             :         { pari_discarded++; };
    1532             : 
    1533             : /* Line 1391 of yacc.c  */
    1534             : #line 1535 "../src/language/parse.c"
    1535           0 :         break;
    1536             :       case 76: /* "arg" */
    1537             : 
    1538             : /* Line 1391 of yacc.c  */
    1539             : #line 83 "../src/language/parse.y"
    1540             :         { pari_discarded++; };
    1541             : 
    1542             : /* Line 1391 of yacc.c  */
    1543             : #line 1544 "../src/language/parse.c"
    1544           0 :         break;
    1545             :       case 78: /* "listarg" */
    1546             : 
    1547             : /* Line 1391 of yacc.c  */
    1548             : #line 83 "../src/language/parse.y"
    1549             :         { pari_discarded++; };
    1550             : 
    1551             : /* Line 1391 of yacc.c  */
    1552             : #line 1553 "../src/language/parse.c"
    1553           0 :         break;
    1554             :       case 79: /* "funcid" */
    1555             : 
    1556             : /* Line 1391 of yacc.c  */
    1557             : #line 83 "../src/language/parse.y"
    1558             :         { pari_discarded++; };
    1559             : 
    1560             : /* Line 1391 of yacc.c  */
    1561             : #line 1562 "../src/language/parse.c"
    1562           0 :         break;
    1563             :       case 80: /* "memberid" */
    1564             : 
    1565             : /* Line 1391 of yacc.c  */
    1566             : #line 83 "../src/language/parse.y"
    1567             :         { pari_discarded++; };
    1568             : 
    1569             : /* Line 1391 of yacc.c  */
    1570             : #line 1571 "../src/language/parse.c"
    1571           0 :         break;
    1572             :       case 81: /* "definition" */
    1573             : 
    1574             : /* Line 1391 of yacc.c  */
    1575             : #line 83 "../src/language/parse.y"
    1576             :         { pari_discarded++; };
    1577             : 
    1578             : /* Line 1391 of yacc.c  */
    1579             : #line 1580 "../src/language/parse.c"
    1580           0 :         break;
    1581             : 
    1582             :       default:
    1583      159490 :         break;
    1584             :     }
    1585      159490 : }
    1586             : 
    1587             : 
    1588             : /* Prevent warnings from -Wmissing-prototypes.  */
    1589             : #ifdef YYPARSE_PARAM
    1590             : #if defined __STDC__ || defined __cplusplus
    1591             : int yyparse (void *YYPARSE_PARAM);
    1592             : #else
    1593             : int yyparse ();
    1594             : #endif
    1595             : #else /* ! YYPARSE_PARAM */
    1596             : #if defined __STDC__ || defined __cplusplus
    1597             : int yyparse (char **lex);
    1598             : #else
    1599             : int yyparse ();
    1600             : #endif
    1601             : #endif /* ! YYPARSE_PARAM */
    1602             : 
    1603             : 
    1604             : /*----------.
    1605             : | yyparse.  |
    1606             : `----------*/
    1607             : 
    1608             : #ifdef YYPARSE_PARAM
    1609             : #if (defined __STDC__ || defined __C99__FUNC__ \
    1610             :      || defined __cplusplus || defined _MSC_VER)
    1611             : int
    1612             : yyparse (void *YYPARSE_PARAM)
    1613             : #else
    1614             : int
    1615             : yyparse (YYPARSE_PARAM)
    1616             :     void *YYPARSE_PARAM;
    1617             : #endif
    1618             : #else /* ! YYPARSE_PARAM */
    1619             : #if (defined __STDC__ || defined __C99__FUNC__ \
    1620             :      || defined __cplusplus || defined _MSC_VER)
    1621             : int
    1622       79745 : yyparse (char **lex)
    1623             : #else
    1624             : int
    1625             : yyparse (lex)
    1626             :     char **lex;
    1627             : #endif
    1628             : #endif
    1629             : {
    1630             : /* The lookahead symbol.  */
    1631             : int yychar;
    1632             : 
    1633             : /* The semantic value of the lookahead symbol.  */
    1634             : YYSTYPE yylval;
    1635             : 
    1636             : /* Location data for the lookahead symbol.  */
    1637             : YYLTYPE yylloc;
    1638             : 
    1639             :     /* Number of syntax errors so far.  */
    1640             :     int yynerrs;
    1641             : 
    1642             :     int yystate;
    1643             :     /* Number of tokens to shift before error messages enabled.  */
    1644             :     int yyerrstatus;
    1645             : 
    1646             :     /* The stacks and their tools:
    1647             :        `yyss': related to states.
    1648             :        `yyvs': related to semantic values.
    1649             :        `yyls': related to locations.
    1650             : 
    1651             :        Refer to the stacks thru separate pointers, to allow yyoverflow
    1652             :        to reallocate them elsewhere.  */
    1653             : 
    1654             :     /* The state stack.  */
    1655             :     yytype_int16 yyssa[YYINITDEPTH];
    1656             :     yytype_int16 *yyss;
    1657             :     yytype_int16 *yyssp;
    1658             : 
    1659             :     /* The semantic value stack.  */
    1660             :     YYSTYPE yyvsa[YYINITDEPTH];
    1661             :     YYSTYPE *yyvs;
    1662             :     YYSTYPE *yyvsp;
    1663             : 
    1664             :     /* The location stack.  */
    1665             :     YYLTYPE yylsa[YYINITDEPTH];
    1666             :     YYLTYPE *yyls;
    1667             :     YYLTYPE *yylsp;
    1668             : 
    1669             :     /* The locations where the error started and ended.  */
    1670             :     YYLTYPE yyerror_range[3];
    1671             : 
    1672             :     YYSIZE_T yystacksize;
    1673             : 
    1674             :   int yyn;
    1675             :   int yyresult;
    1676             :   /* Lookahead token as an internal (translated) token number.  */
    1677             :   int yytoken;
    1678             :   /* The variables used to return semantic value and location from the
    1679             :      action routines.  */
    1680             :   YYSTYPE yyval;
    1681             :   YYLTYPE yyloc;
    1682             : 
    1683             : #if YYERROR_VERBOSE
    1684             :   /* Buffer for error messages, and its allocated size.  */
    1685             :   char yymsgbuf[128];
    1686       79745 :   char *yymsg = yymsgbuf;
    1687       79745 :   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
    1688             : #endif
    1689             : 
    1690             : #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
    1691             : 
    1692             :   /* The number of symbols on the RHS of the reduced rule.
    1693             :      Keep to zero when no symbol should be popped.  */
    1694       79745 :   int yylen = 0;
    1695             : 
    1696       79745 :   yytoken = 0;
    1697       79745 :   yyss = yyssa;
    1698       79745 :   yyvs = yyvsa;
    1699       79745 :   yyls = yylsa;
    1700       79745 :   yystacksize = YYINITDEPTH;
    1701             : 
    1702             :   YYDPRINTF ((stderr, "Starting parse\n"));
    1703             : 
    1704       79745 :   yystate = 0;
    1705       79745 :   yyerrstatus = 0;
    1706       79745 :   yynerrs = 0;
    1707       79745 :   yychar = YYEMPTY; /* Cause a token to be read.  */
    1708             : 
    1709             :   /* Initialize stack pointers.
    1710             :      Waste one element of value and location stack
    1711             :      so that they stay on the same level as the state stack.
    1712             :      The wasted elements are never initialized.  */
    1713       79745 :   yyssp = yyss;
    1714       79745 :   yyvsp = yyvs;
    1715       79745 :   yylsp = yyls;
    1716             : 
    1717             : #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
    1718             :   /* Initialize the default location before parsing starts.  */
    1719             :   yylloc.first_line   = yylloc.last_line   = 1;
    1720             :   yylloc.first_column = yylloc.last_column = 1;
    1721             : #endif
    1722             : 
    1723             : /* User initialization code.  */
    1724             : 
    1725             : /* Line 1590 of yacc.c  */
    1726             : #line 30 "../src/language/parse.y"
    1727             : { yylloc.start=yylloc.end=*lex; }
    1728             : 
    1729             : /* Line 1590 of yacc.c  */
    1730             : #line 1731 "../src/language/parse.c"
    1731       79745 :   yylsp[0] = yylloc;
    1732             : 
    1733       79745 :   goto yysetstate;
    1734             : 
    1735             : /*------------------------------------------------------------.
    1736             : | yynewstate -- Push a new state, which is found in yystate.  |
    1737             : `------------------------------------------------------------*/
    1738             :  yynewstate:
    1739             :   /* In all cases, when you get here, the value and location stacks
    1740             :      have just been pushed.  So pushing a state here evens the stacks.  */
    1741    60426799 :   yyssp++;
    1742             : 
    1743             :  yysetstate:
    1744    60506544 :   *yyssp = yystate;
    1745             : 
    1746    60506544 :   if (yyss + yystacksize - 1 <= yyssp)
    1747             :     {
    1748             :       /* Get the current used size of the three stacks, in elements.  */
    1749           0 :       YYSIZE_T yysize = yyssp - yyss + 1;
    1750             : 
    1751             : #ifdef yyoverflow
    1752             :       {
    1753             :         /* Give user a chance to reallocate the stack.  Use copies of
    1754             :            these so that the &'s don't force the real ones into
    1755             :            memory.  */
    1756             :         YYSTYPE *yyvs1 = yyvs;
    1757             :         yytype_int16 *yyss1 = yyss;
    1758             :         YYLTYPE *yyls1 = yyls;
    1759             : 
    1760             :         /* Each stack pointer address is followed by the size of the
    1761             :            data in use in that stack, in bytes.  This used to be a
    1762             :            conditional around just the two extra args, but that might
    1763             :            be undefined if yyoverflow is a macro.  */
    1764             :         yyoverflow (YY_("memory exhausted"),
    1765             :                     &yyss1, yysize * sizeof (*yyssp),
    1766             :                     &yyvs1, yysize * sizeof (*yyvsp),
    1767             :                     &yyls1, yysize * sizeof (*yylsp),
    1768             :                     &yystacksize);
    1769             : 
    1770             :         yyls = yyls1;
    1771             :         yyss = yyss1;
    1772             :         yyvs = yyvs1;
    1773             :       }
    1774             : #else /* no yyoverflow */
    1775             : # ifndef YYSTACK_RELOCATE
    1776             :       goto yyexhaustedlab;
    1777             : # else
    1778             :       /* Extend the stack our own way.  */
    1779           0 :       if (YYMAXDEPTH <= yystacksize)
    1780           0 :         goto yyexhaustedlab;
    1781           0 :       yystacksize *= 2;
    1782           0 :       if (YYMAXDEPTH < yystacksize)
    1783           0 :         yystacksize = YYMAXDEPTH;
    1784             : 
    1785             :       {
    1786           0 :         yytype_int16 *yyss1 = yyss;
    1787           0 :         union yyalloc *yyptr =
    1788           0 :           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
    1789           0 :         if (! yyptr)
    1790           0 :           goto yyexhaustedlab;
    1791           0 :         YYSTACK_RELOCATE (yyss_alloc, yyss);
    1792           0 :         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
    1793           0 :         YYSTACK_RELOCATE (yyls_alloc, yyls);
    1794             : #  undef YYSTACK_RELOCATE
    1795           0 :         if (yyss1 != yyssa)
    1796           0 :           YYSTACK_FREE (yyss1);
    1797             :       }
    1798             : # endif
    1799             : #endif /* no yyoverflow */
    1800             : 
    1801           0 :       yyssp = yyss + yysize - 1;
    1802           0 :       yyvsp = yyvs + yysize - 1;
    1803           0 :       yylsp = yyls + yysize - 1;
    1804             : 
    1805             :       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
    1806             :                   (unsigned long int) yystacksize));
    1807             : 
    1808           0 :       if (yyss + yystacksize - 1 <= yyssp)
    1809           0 :         YYABORT;
    1810             :     }
    1811             : 
    1812             :   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
    1813             : 
    1814    60506544 :   if (yystate == YYFINAL)
    1815       79738 :     YYACCEPT;
    1816             : 
    1817    60426806 :   goto yybackup;
    1818             : 
    1819             : /*-----------.
    1820             : | yybackup.  |
    1821             : `-----------*/
    1822             : yybackup:
    1823             : 
    1824             :   /* Do appropriate processing given the current state.  Read a
    1825             :      lookahead token if we need one and don't already have one.  */
    1826             : 
    1827             :   /* First try to decide what to do without reference to lookahead token.  */
    1828    60426806 :   yyn = yypact[yystate];
    1829    60426806 :   if (yypact_value_is_default (yyn))
    1830     5066208 :     goto yydefault;
    1831             : 
    1832             :   /* Not known => get a lookahead token if don't already have one.  */
    1833             : 
    1834             :   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
    1835    55360598 :   if (yychar == YYEMPTY)
    1836             :     {
    1837             :       YYDPRINTF ((stderr, "Reading a token: "));
    1838    28226211 :       yychar = YYLEX;
    1839             :     }
    1840             : 
    1841    55360598 :   if (yychar <= YYEOF)
    1842             :     {
    1843      305598 :       yychar = yytoken = YYEOF;
    1844             :       YYDPRINTF ((stderr, "Now at end of input.\n"));
    1845             :     }
    1846             :   else
    1847             :     {
    1848    55055000 :       yytoken = YYTRANSLATE (yychar);
    1849             :       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    1850             :     }
    1851             : 
    1852             :   /* If the proper action on seeing token YYTOKEN is to reduce or to
    1853             :      detect an error, take that action.  */
    1854    55360598 :   yyn += yytoken;
    1855    55360598 :   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    1856             :     goto yydefault;
    1857    28451491 :   yyn = yytable[yyn];
    1858    28451491 :   if (yyn <= 0)
    1859             :     {
    1860             :       if (yytable_value_is_error (yyn))
    1861             :         goto yyerrlab;
    1862      225287 :       yyn = -yyn;
    1863      225287 :       goto yyreduce;
    1864             :     }
    1865             : 
    1866             :   /* Count tokens shifted since error; after three, turn off error
    1867             :      status.  */
    1868    28226204 :   if (yyerrstatus)
    1869          77 :     yyerrstatus--;
    1870             : 
    1871             :   /* Shift the lookahead token.  */
    1872             :   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
    1873             : 
    1874             :   /* Discard the shifted token.  */
    1875    28226204 :   yychar = YYEMPTY;
    1876             : 
    1877    28226204 :   yystate = yyn;
    1878    28226204 :   *++yyvsp = yylval;
    1879    28226204 :   *++yylsp = yylloc;
    1880    28226204 :   goto yynewstate;
    1881             : 
    1882             : 
    1883             : /*-----------------------------------------------------------.
    1884             : | yydefault -- do the default action for the current state.  |
    1885             : `-----------------------------------------------------------*/
    1886             : yydefault:
    1887    31975315 :   yyn = yydefact[yystate];
    1888    31975315 :   if (yyn == 0)
    1889         133 :     goto yyerrlab;
    1890    31975182 :   goto yyreduce;
    1891             : 
    1892             : 
    1893             : /*-----------------------------.
    1894             : | yyreduce -- Do a reduction.  |
    1895             : `-----------------------------*/
    1896             : yyreduce:
    1897             :   /* yyn is the number of a rule to reduce with.  */
    1898    32200469 :   yylen = yyr2[yyn];
    1899             : 
    1900             :   /* If YYLEN is nonzero, implement the default value of the action:
    1901             :      `$$ = $1'.
    1902             : 
    1903             :      Otherwise, the following line sets YYVAL to garbage.
    1904             :      This behavior is undocumented and Bison
    1905             :      users should not rely upon it.  Assigning to YYVAL
    1906             :      unconditionally makes the parser a bit smaller, and it avoids a
    1907             :      GCC warning that YYVAL may be used uninitialized.  */
    1908    32200469 :   yyval = yyvsp[1-yylen];
    1909             : 
    1910             :   /* Default location.  */
    1911    32200469 :   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
    1912             :   YY_REDUCE_PRINT (yyn);
    1913    32200469 :   switch (yyn)
    1914             :     {
    1915             :         case 2:
    1916             : 
    1917             : /* Line 1806 of yacc.c  */
    1918             : #line 86 "../src/language/parse.y"
    1919             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    1920             :     break;
    1921             : 
    1922             :   case 3:
    1923             : 
    1924             : /* Line 1806 of yacc.c  */
    1925             : #line 89 "../src/language/parse.y"
    1926             :     {(yyval.val)=NOARG((yyloc));}
    1927             :     break;
    1928             : 
    1929             :   case 4:
    1930             : 
    1931             : /* Line 1806 of yacc.c  */
    1932             : #line 90 "../src/language/parse.y"
    1933             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    1934             :     break;
    1935             : 
    1936             :   case 5:
    1937             : 
    1938             : /* Line 1806 of yacc.c  */
    1939             : #line 91 "../src/language/parse.y"
    1940             :     {(yyval.val)=(yyvsp[(1) - (2)].val); (yyloc)=(yylsp[(1) - (2)]);}
    1941             :     break;
    1942             : 
    1943             :   case 6:
    1944             : 
    1945             : /* Line 1806 of yacc.c  */
    1946             : #line 92 "../src/language/parse.y"
    1947             :     {(yyval.val)=newnode(Fseq,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    1948             :     break;
    1949             : 
    1950             :   case 7:
    1951             : 
    1952             : /* Line 1806 of yacc.c  */
    1953             : #line 95 "../src/language/parse.y"
    1954             :     { (yyval.val)=newnode(Frange,NORANGE((yyloc)),NORANGE((yyloc)),&(yyloc)); }
    1955             :     break;
    1956             : 
    1957             :   case 8:
    1958             : 
    1959             : /* Line 1806 of yacc.c  */
    1960             : #line 96 "../src/language/parse.y"
    1961             :     { (yyval.val)=newnode(Frange,(yyvsp[(1) - (1)].val),NORANGE((yyloc)),&(yyloc)); }
    1962             :     break;
    1963             : 
    1964             :   case 9:
    1965             : 
    1966             : /* Line 1806 of yacc.c  */
    1967             : #line 97 "../src/language/parse.y"
    1968             :     { (yyval.val)=newnode(Frange,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc)); }
    1969             :     break;
    1970             : 
    1971             :   case 10:
    1972             : 
    1973             : /* Line 1806 of yacc.c  */
    1974             : #line 98 "../src/language/parse.y"
    1975             :     { (yyval.val)=newnode(Frange,NORANGE((yyloc)),(yyvsp[(2) - (2)].val),&(yyloc)); }
    1976             :     break;
    1977             : 
    1978             :   case 11:
    1979             : 
    1980             : /* Line 1806 of yacc.c  */
    1981             : #line 101 "../src/language/parse.y"
    1982             :     {(yyval.val)=newnode(Fmatrix,(yyvsp[(2) - (5)].val),(yyvsp[(4) - (5)].val),&(yyloc));}
    1983             :     break;
    1984             : 
    1985             :   case 12:
    1986             : 
    1987             : /* Line 1806 of yacc.c  */
    1988             : #line 102 "../src/language/parse.y"
    1989             :     {(yyval.val)=newnode(Fmatrix,(yyvsp[(2) - (3)].val),-1,&(yyloc));}
    1990             :     break;
    1991             : 
    1992             :   case 13:
    1993             : 
    1994             : /* Line 1806 of yacc.c  */
    1995             : #line 105 "../src/language/parse.y"
    1996             :     {(yyval.val)=1;}
    1997             :     break;
    1998             : 
    1999             :   case 14:
    2000             : 
    2001             : /* Line 1806 of yacc.c  */
    2002             : #line 106 "../src/language/parse.y"
    2003             :     {(yyval.val)=(yyvsp[(1) - (2)].val)+1;}
    2004             :     break;
    2005             : 
    2006             :   case 15:
    2007             : 
    2008             : /* Line 1806 of yacc.c  */
    2009             : #line 109 "../src/language/parse.y"
    2010             :     {(yyval.val)=newopcall(OPhist,-1,-1,&(yyloc));}
    2011             :     break;
    2012             : 
    2013             :   case 16:
    2014             : 
    2015             : /* Line 1806 of yacc.c  */
    2016             : #line 110 "../src/language/parse.y"
    2017             :     {(yyval.val)=newopcall(OPhist,newintnode(&(yylsp[(2) - (2)])),-1,&(yyloc));}
    2018             :     break;
    2019             : 
    2020             :   case 17:
    2021             : 
    2022             : /* Line 1806 of yacc.c  */
    2023             : #line 111 "../src/language/parse.y"
    2024             :     {(yyval.val)=newopcall(OPhist,newnode(Fsmall,-(yyvsp[(2) - (2)].val),-1,&(yyloc)),-1,&(yyloc));}
    2025             :     break;
    2026             : 
    2027             :   case 18:
    2028             : 
    2029             : /* Line 1806 of yacc.c  */
    2030             : #line 112 "../src/language/parse.y"
    2031             :     {(yyval.val)=newopcall(OPhisttime,-1,-1,&(yyloc));}
    2032             :     break;
    2033             : 
    2034             :   case 19:
    2035             : 
    2036             : /* Line 1806 of yacc.c  */
    2037             : #line 113 "../src/language/parse.y"
    2038             :     {(yyval.val)=newopcall(OPhisttime,newintnode(&(yylsp[(3) - (3)])),-1,&(yyloc));}
    2039             :     break;
    2040             : 
    2041             :   case 20:
    2042             : 
    2043             : /* Line 1806 of yacc.c  */
    2044             : #line 114 "../src/language/parse.y"
    2045             :     {(yyval.val)=newopcall(OPhisttime,newnode(Fsmall,-(yyvsp[(3) - (3)].val),-1,&(yyloc)),-1,&(yyloc));}
    2046             :     break;
    2047             : 
    2048             :   case 21:
    2049             : 
    2050             : /* Line 1806 of yacc.c  */
    2051             : #line 117 "../src/language/parse.y"
    2052             :     {(yyval.val)=newintnode(&(yylsp[(1) - (1)]));}
    2053             :     break;
    2054             : 
    2055             :   case 22:
    2056             : 
    2057             : /* Line 1806 of yacc.c  */
    2058             : #line 118 "../src/language/parse.y"
    2059             :     {(yyval.val)=newconst(CSTreal,&(yyloc));}
    2060             :     break;
    2061             : 
    2062             :   case 23:
    2063             : 
    2064             : /* Line 1806 of yacc.c  */
    2065             : #line 119 "../src/language/parse.y"
    2066             :     {(yyval.val)=newconst(CSTreal,&(yyloc));}
    2067             :     break;
    2068             : 
    2069             :   case 24:
    2070             : 
    2071             : /* Line 1806 of yacc.c  */
    2072             : #line 120 "../src/language/parse.y"
    2073             :     {(yyval.val)=newnode(Ffunction,newconst(CSTmember,&(yylsp[(3) - (3)])),
    2074             :                                                 newintnode(&(yylsp[(1) - (3)])),&(yyloc));}
    2075             :     break;
    2076             : 
    2077             :   case 25:
    2078             : 
    2079             : /* Line 1806 of yacc.c  */
    2080             : #line 122 "../src/language/parse.y"
    2081             :     {(yyval.val)=newconst(CSTstr,&(yyloc));}
    2082             :     break;
    2083             : 
    2084             :   case 26:
    2085             : 
    2086             : /* Line 1806 of yacc.c  */
    2087             : #line 123 "../src/language/parse.y"
    2088             :     {(yyval.val)=newconst(CSTquote,&(yyloc));}
    2089             :     break;
    2090             : 
    2091             :   case 27:
    2092             : 
    2093             : /* Line 1806 of yacc.c  */
    2094             : #line 124 "../src/language/parse.y"
    2095             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2096             :     break;
    2097             : 
    2098             :   case 28:
    2099             : 
    2100             : /* Line 1806 of yacc.c  */
    2101             : #line 125 "../src/language/parse.y"
    2102             :     {(yyval.val)=newnode(Fcall,(yyvsp[(1) - (4)].val),(yyvsp[(3) - (4)].val),&(yyloc));}
    2103             :     break;
    2104             : 
    2105             :   case 29:
    2106             : 
    2107             : /* Line 1806 of yacc.c  */
    2108             : #line 126 "../src/language/parse.y"
    2109             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2110             :     break;
    2111             : 
    2112             :   case 30:
    2113             : 
    2114             : /* Line 1806 of yacc.c  */
    2115             : #line 127 "../src/language/parse.y"
    2116             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2117             :     break;
    2118             : 
    2119             :   case 31:
    2120             : 
    2121             : /* Line 1806 of yacc.c  */
    2122             : #line 128 "../src/language/parse.y"
    2123             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2124             :     break;
    2125             : 
    2126             :   case 32:
    2127             : 
    2128             : /* Line 1806 of yacc.c  */
    2129             : #line 129 "../src/language/parse.y"
    2130             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2131             :     break;
    2132             : 
    2133             :   case 33:
    2134             : 
    2135             : /* Line 1806 of yacc.c  */
    2136             : #line 130 "../src/language/parse.y"
    2137             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2138             :     break;
    2139             : 
    2140             :   case 34:
    2141             : 
    2142             : /* Line 1806 of yacc.c  */
    2143             : #line 131 "../src/language/parse.y"
    2144             :     {(yyval.val)=newnode(Fassign,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2145             :     break;
    2146             : 
    2147             :   case 35:
    2148             : 
    2149             : /* Line 1806 of yacc.c  */
    2150             : #line 132 "../src/language/parse.y"
    2151             :     {(yyval.val)=newnode(Fassign,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2152             :     break;
    2153             : 
    2154             :   case 36:
    2155             : 
    2156             : /* Line 1806 of yacc.c  */
    2157             : #line 133 "../src/language/parse.y"
    2158             :     {(yyval.val)=newopcall(OPpp,(yyvsp[(1) - (2)].val),-1,&(yyloc));}
    2159             :     break;
    2160             : 
    2161             :   case 37:
    2162             : 
    2163             : /* Line 1806 of yacc.c  */
    2164             : #line 134 "../src/language/parse.y"
    2165             :     {(yyval.val)=newopcall(OPss,(yyvsp[(1) - (2)].val),-1,&(yyloc));}
    2166             :     break;
    2167             : 
    2168             :   case 38:
    2169             : 
    2170             : /* Line 1806 of yacc.c  */
    2171             : #line 135 "../src/language/parse.y"
    2172             :     {(yyval.val)=newopcall(OPme,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2173             :     break;
    2174             : 
    2175             :   case 39:
    2176             : 
    2177             : /* Line 1806 of yacc.c  */
    2178             : #line 136 "../src/language/parse.y"
    2179             :     {(yyval.val)=newopcall(OPde,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2180             :     break;
    2181             : 
    2182             :   case 40:
    2183             : 
    2184             : /* Line 1806 of yacc.c  */
    2185             : #line 137 "../src/language/parse.y"
    2186             :     {(yyval.val)=newopcall(OPdre,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2187             :     break;
    2188             : 
    2189             :   case 41:
    2190             : 
    2191             : /* Line 1806 of yacc.c  */
    2192             : #line 138 "../src/language/parse.y"
    2193             :     {(yyval.val)=newopcall(OPeuce,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2194             :     break;
    2195             : 
    2196             :   case 42:
    2197             : 
    2198             : /* Line 1806 of yacc.c  */
    2199             : #line 139 "../src/language/parse.y"
    2200             :     {(yyval.val)=newopcall(OPmode,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2201             :     break;
    2202             : 
    2203             :   case 43:
    2204             : 
    2205             : /* Line 1806 of yacc.c  */
    2206             : #line 140 "../src/language/parse.y"
    2207             :     {(yyval.val)=newopcall(OPsle,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2208             :     break;
    2209             : 
    2210             :   case 44:
    2211             : 
    2212             : /* Line 1806 of yacc.c  */
    2213             : #line 141 "../src/language/parse.y"
    2214             :     {(yyval.val)=newopcall(OPsre,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2215             :     break;
    2216             : 
    2217             :   case 45:
    2218             : 
    2219             : /* Line 1806 of yacc.c  */
    2220             : #line 142 "../src/language/parse.y"
    2221             :     {(yyval.val)=newopcall(OPpe,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2222             :     break;
    2223             : 
    2224             :   case 46:
    2225             : 
    2226             : /* Line 1806 of yacc.c  */
    2227             : #line 143 "../src/language/parse.y"
    2228             :     {(yyval.val)=newopcall(OPse,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2229             :     break;
    2230             : 
    2231             :   case 47:
    2232             : 
    2233             : /* Line 1806 of yacc.c  */
    2234             : #line 144 "../src/language/parse.y"
    2235             :     {(yyval.val)=newopcall(OPnb,(yyvsp[(2) - (2)].val),-1,&(yyloc));}
    2236             :     break;
    2237             : 
    2238             :   case 48:
    2239             : 
    2240             : /* Line 1806 of yacc.c  */
    2241             : #line 145 "../src/language/parse.y"
    2242             :     {(yyval.val)=newopcall(OPlength,(yyvsp[(2) - (2)].val),-1,&(yyloc));}
    2243             :     break;
    2244             : 
    2245             :   case 49:
    2246             : 
    2247             : /* Line 1806 of yacc.c  */
    2248             : #line 146 "../src/language/parse.y"
    2249             :     {(yyval.val)=newopcall(OPor,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2250             :     break;
    2251             : 
    2252             :   case 50:
    2253             : 
    2254             : /* Line 1806 of yacc.c  */
    2255             : #line 147 "../src/language/parse.y"
    2256             :     {(yyval.val)=newopcall(OPand,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2257             :     break;
    2258             : 
    2259             :   case 51:
    2260             : 
    2261             : /* Line 1806 of yacc.c  */
    2262             : #line 148 "../src/language/parse.y"
    2263             :     {(yyval.val)=newopcall(OPand,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2264             :     break;
    2265             : 
    2266             :   case 52:
    2267             : 
    2268             : /* Line 1806 of yacc.c  */
    2269             : #line 149 "../src/language/parse.y"
    2270             :     {(yyval.val)=newopcall(OPid,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2271             :     break;
    2272             : 
    2273             :   case 53:
    2274             : 
    2275             : /* Line 1806 of yacc.c  */
    2276             : #line 150 "../src/language/parse.y"
    2277             :     {(yyval.val)=newopcall(OPeq,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2278             :     break;
    2279             : 
    2280             :   case 54:
    2281             : 
    2282             : /* Line 1806 of yacc.c  */
    2283             : #line 151 "../src/language/parse.y"
    2284             :     {(yyval.val)=newopcall(OPne,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2285             :     break;
    2286             : 
    2287             :   case 55:
    2288             : 
    2289             : /* Line 1806 of yacc.c  */
    2290             : #line 152 "../src/language/parse.y"
    2291             :     {(yyval.val)=newopcall(OPge,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2292             :     break;
    2293             : 
    2294             :   case 56:
    2295             : 
    2296             : /* Line 1806 of yacc.c  */
    2297             : #line 153 "../src/language/parse.y"
    2298             :     {(yyval.val)=newopcall(OPg,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2299             :     break;
    2300             : 
    2301             :   case 57:
    2302             : 
    2303             : /* Line 1806 of yacc.c  */
    2304             : #line 154 "../src/language/parse.y"
    2305             :     {(yyval.val)=newopcall(OPle,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2306             :     break;
    2307             : 
    2308             :   case 58:
    2309             : 
    2310             : /* Line 1806 of yacc.c  */
    2311             : #line 155 "../src/language/parse.y"
    2312             :     {(yyval.val)=newopcall(OPl,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2313             :     break;
    2314             : 
    2315             :   case 59:
    2316             : 
    2317             : /* Line 1806 of yacc.c  */
    2318             : #line 156 "../src/language/parse.y"
    2319             :     {(yyval.val)=newopcall(OPs,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2320             :     break;
    2321             : 
    2322             :   case 60:
    2323             : 
    2324             : /* Line 1806 of yacc.c  */
    2325             : #line 157 "../src/language/parse.y"
    2326             :     {(yyval.val)=newopcall(OPp,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2327             :     break;
    2328             : 
    2329             :   case 61:
    2330             : 
    2331             : /* Line 1806 of yacc.c  */
    2332             : #line 158 "../src/language/parse.y"
    2333             :     {(yyval.val)=newopcall(OPsl,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2334             :     break;
    2335             : 
    2336             :   case 62:
    2337             : 
    2338             : /* Line 1806 of yacc.c  */
    2339             : #line 159 "../src/language/parse.y"
    2340             :     {(yyval.val)=newopcall(OPsr,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2341             :     break;
    2342             : 
    2343             :   case 63:
    2344             : 
    2345             : /* Line 1806 of yacc.c  */
    2346             : #line 160 "../src/language/parse.y"
    2347             :     {(yyval.val)=newopcall(OPmod,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2348             :     break;
    2349             : 
    2350             :   case 64:
    2351             : 
    2352             : /* Line 1806 of yacc.c  */
    2353             : #line 161 "../src/language/parse.y"
    2354             :     {(yyval.val)=newopcall(OPdr,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2355             :     break;
    2356             : 
    2357             :   case 65:
    2358             : 
    2359             : /* Line 1806 of yacc.c  */
    2360             : #line 162 "../src/language/parse.y"
    2361             :     {(yyval.val)=newopcall(OPeuc,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2362             :     break;
    2363             : 
    2364             :   case 66:
    2365             : 
    2366             : /* Line 1806 of yacc.c  */
    2367             : #line 163 "../src/language/parse.y"
    2368             :     {(yyval.val)=newopcall(OPd,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2369             :     break;
    2370             : 
    2371             :   case 67:
    2372             : 
    2373             : /* Line 1806 of yacc.c  */
    2374             : #line 164 "../src/language/parse.y"
    2375             :     {(yyval.val)=newopcall(OPm,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2376             :     break;
    2377             : 
    2378             :   case 68:
    2379             : 
    2380             : /* Line 1806 of yacc.c  */
    2381             : #line 165 "../src/language/parse.y"
    2382             :     {(yyval.val)=(yyvsp[(2) - (2)].val);}
    2383             :     break;
    2384             : 
    2385             :   case 69:
    2386             : 
    2387             : /* Line 1806 of yacc.c  */
    2388             : #line 166 "../src/language/parse.y"
    2389             :     {(yyval.val)=newopcall(OPn,(yyvsp[(2) - (2)].val),-1,&(yyloc));}
    2390             :     break;
    2391             : 
    2392             :   case 70:
    2393             : 
    2394             : /* Line 1806 of yacc.c  */
    2395             : #line 167 "../src/language/parse.y"
    2396             :     {(yyval.val)=newopcall(OPpow,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2397             :     break;
    2398             : 
    2399             :   case 71:
    2400             : 
    2401             : /* Line 1806 of yacc.c  */
    2402             : #line 168 "../src/language/parse.y"
    2403             :     {(yyval.val)=newopcall(OPtrans,(yyvsp[(1) - (2)].val),-1,&(yyloc));}
    2404             :     break;
    2405             : 
    2406             :   case 72:
    2407             : 
    2408             : /* Line 1806 of yacc.c  */
    2409             : #line 169 "../src/language/parse.y"
    2410             :     {(yyval.val)=newopcall(OPderiv,(yyvsp[(1) - (2)].val),-1,&(yyloc));}
    2411             :     break;
    2412             : 
    2413             :   case 73:
    2414             : 
    2415             : /* Line 1806 of yacc.c  */
    2416             : #line 170 "../src/language/parse.y"
    2417             :     {(yyval.val)=newopcall(OPfact,(yyvsp[(1) - (2)].val),-1,&(yyloc));}
    2418             :     break;
    2419             : 
    2420             :   case 74:
    2421             : 
    2422             : /* Line 1806 of yacc.c  */
    2423             : #line 171 "../src/language/parse.y"
    2424             :     {(yyval.val)=newnode(Fmatcoeff,(yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val),&(yyloc));}
    2425             :     break;
    2426             : 
    2427             :   case 75:
    2428             : 
    2429             : /* Line 1806 of yacc.c  */
    2430             : #line 172 "../src/language/parse.y"
    2431             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2432             :     break;
    2433             : 
    2434             :   case 76:
    2435             : 
    2436             : /* Line 1806 of yacc.c  */
    2437             : #line 173 "../src/language/parse.y"
    2438             :     {(yyval.val)=newnode(Ftag,(yyvsp[(1) - (3)].val),0,&(yyloc));}
    2439             :     break;
    2440             : 
    2441             :   case 77:
    2442             : 
    2443             : /* Line 1806 of yacc.c  */
    2444             : #line 174 "../src/language/parse.y"
    2445             :     {(yyval.val)=(yyvsp[(2) - (3)].val);}
    2446             :     break;
    2447             : 
    2448             :   case 78:
    2449             : 
    2450             : /* Line 1806 of yacc.c  */
    2451             : #line 177 "../src/language/parse.y"
    2452             :     {(yyval.val)=newnode(Fentry,newconst(CSTentry,&(yylsp[(1) - (1)])),-1,&(yyloc));}
    2453             :     break;
    2454             : 
    2455             :   case 79:
    2456             : 
    2457             : /* Line 1806 of yacc.c  */
    2458             : #line 178 "../src/language/parse.y"
    2459             :     {(yyval.val)=newnode(Fmatcoeff,(yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val),&(yyloc));}
    2460             :     break;
    2461             : 
    2462             :   case 80:
    2463             : 
    2464             : /* Line 1806 of yacc.c  */
    2465             : #line 179 "../src/language/parse.y"
    2466             :     {(yyval.val)=newnode(Ftag,(yyvsp[(1) - (3)].val),newconst(CSTentry,&(yylsp[(2) - (3)])),&(yyloc));}
    2467             :     break;
    2468             : 
    2469             :   case 81:
    2470             : 
    2471             : /* Line 1806 of yacc.c  */
    2472             : #line 182 "../src/language/parse.y"
    2473             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2474             :     break;
    2475             : 
    2476             :   case 82:
    2477             : 
    2478             : /* Line 1806 of yacc.c  */
    2479             : #line 183 "../src/language/parse.y"
    2480             :     {(yyval.val)=newnode(Fmatrixelts,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2481             :     break;
    2482             : 
    2483             :   case 83:
    2484             : 
    2485             : /* Line 1806 of yacc.c  */
    2486             : #line 186 "../src/language/parse.y"
    2487             :     {(yyval.val)=newnode(Fmatrixlines,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2488             :     break;
    2489             : 
    2490             :   case 84:
    2491             : 
    2492             : /* Line 1806 of yacc.c  */
    2493             : #line 187 "../src/language/parse.y"
    2494             :     {(yyval.val)=newnode(Fmatrixlines,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2495             :     break;
    2496             : 
    2497             :   case 85:
    2498             : 
    2499             : /* Line 1806 of yacc.c  */
    2500             : #line 190 "../src/language/parse.y"
    2501             :     {(yyval.val)=newnode(Fvec,-1,-1,&(yyloc));}
    2502             :     break;
    2503             : 
    2504             :   case 86:
    2505             : 
    2506             : /* Line 1806 of yacc.c  */
    2507             : #line 191 "../src/language/parse.y"
    2508             :     {(yyval.val)=newopcall(OPrange,(yyvsp[(2) - (5)].val),(yyvsp[(4) - (5)].val),&(yyloc));}
    2509             :     break;
    2510             : 
    2511             :   case 87:
    2512             : 
    2513             : /* Line 1806 of yacc.c  */
    2514             : #line 192 "../src/language/parse.y"
    2515             :     {(yyval.val)=newnode(Fmat,-1,-1,&(yyloc));}
    2516             :     break;
    2517             : 
    2518             :   case 88:
    2519             : 
    2520             : /* Line 1806 of yacc.c  */
    2521             : #line 193 "../src/language/parse.y"
    2522             :     {(yyval.val)=newnode(Fvec,(yyvsp[(2) - (3)].val),-1,&(yyloc));}
    2523             :     break;
    2524             : 
    2525             :   case 89:
    2526             : 
    2527             : /* Line 1806 of yacc.c  */
    2528             : #line 194 "../src/language/parse.y"
    2529             :     {(yyval.val)=newnode(Fmat,(yyvsp[(2) - (3)].val),-1,&(yyloc));}
    2530             :     break;
    2531             : 
    2532             :   case 90:
    2533             : 
    2534             : /* Line 1806 of yacc.c  */
    2535             : #line 195 "../src/language/parse.y"
    2536             :     {(yyval.val)=-1; YYABORT;}
    2537             :     break;
    2538             : 
    2539             :   case 91:
    2540             : 
    2541             : /* Line 1806 of yacc.c  */
    2542             : #line 198 "../src/language/parse.y"
    2543             :     {(yyval.val)=newnode(Flistarg,(yyvsp[(4) - (4)].val),(yyvsp[(1) - (4)].val),&(yyloc));}
    2544             :     break;
    2545             : 
    2546             :   case 92:
    2547             : 
    2548             : /* Line 1806 of yacc.c  */
    2549             : #line 201 "../src/language/parse.y"
    2550             :     {(yyval.val)=newopcall(OPcompr,(yyvsp[(1) - (1)].val),-2,&(yyloc));}
    2551             :     break;
    2552             : 
    2553             :   case 93:
    2554             : 
    2555             : /* Line 1806 of yacc.c  */
    2556             : #line 202 "../src/language/parse.y"
    2557             :     {(yyval.val)=newopcall3(OPcompr,(yyvsp[(1) - (3)].val),-2,(yyvsp[(3) - (3)].val),&(yyloc));}
    2558             :     break;
    2559             : 
    2560             :   case 94:
    2561             : 
    2562             : /* Line 1806 of yacc.c  */
    2563             : #line 203 "../src/language/parse.y"
    2564             :     {(yyval.val)=newopcall(OPcomprc,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2565             :     break;
    2566             : 
    2567             :   case 95:
    2568             : 
    2569             : /* Line 1806 of yacc.c  */
    2570             : #line 204 "../src/language/parse.y"
    2571             :     {(yyval.val)=newopcall3(OPcomprc,(yyvsp[(1) - (5)].val),(yyvsp[(5) - (5)].val),(yyvsp[(3) - (5)].val),&(yyloc));}
    2572             :     break;
    2573             : 
    2574             :   case 96:
    2575             : 
    2576             : /* Line 1806 of yacc.c  */
    2577             : #line 207 "../src/language/parse.y"
    2578             :     {(yyval.val)=addcurrexpr((yyvsp[(4) - (5)].val),(yyvsp[(2) - (5)].val),&(yyloc));}
    2579             :     break;
    2580             : 
    2581             :   case 97:
    2582             : 
    2583             : /* Line 1806 of yacc.c  */
    2584             : #line 210 "../src/language/parse.y"
    2585             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2586             :     break;
    2587             : 
    2588             :   case 98:
    2589             : 
    2590             : /* Line 1806 of yacc.c  */
    2591             : #line 211 "../src/language/parse.y"
    2592             :     {(yyval.val)=newnode(Fvararg,(yyvsp[(1) - (4)].val),-1,&(yyloc));}
    2593             :     break;
    2594             : 
    2595             :   case 99:
    2596             : 
    2597             : /* Line 1806 of yacc.c  */
    2598             : #line 212 "../src/language/parse.y"
    2599             :     {(yyval.val)=newnode(Frefarg,(yyvsp[(2) - (2)].val),-1,&(yyloc));}
    2600             :     break;
    2601             : 
    2602             :   case 100:
    2603             : 
    2604             : /* Line 1806 of yacc.c  */
    2605             : #line 213 "../src/language/parse.y"
    2606             :     {if (!pari_once) { yyerrok; } pari_once=1;}
    2607             :     break;
    2608             : 
    2609             :   case 101:
    2610             : 
    2611             : /* Line 1806 of yacc.c  */
    2612             : #line 214 "../src/language/parse.y"
    2613             :     {pari_once=0; (yyval.val)=newopcall(OPcat,(yyvsp[(1) - (4)].val),(yyvsp[(4) - (4)].val),&(yyloc));}
    2614             :     break;
    2615             : 
    2616             :   case 102:
    2617             : 
    2618             : /* Line 1806 of yacc.c  */
    2619             : #line 217 "../src/language/parse.y"
    2620             :     {(yyval.val)=(yyvsp[(1) - (1)].val);}
    2621             :     break;
    2622             : 
    2623             :   case 103:
    2624             : 
    2625             : /* Line 1806 of yacc.c  */
    2626             : #line 218 "../src/language/parse.y"
    2627             :     {(yyval.val)=newnode(Flistarg,(yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2628             :     break;
    2629             : 
    2630             :   case 104:
    2631             : 
    2632             : /* Line 1806 of yacc.c  */
    2633             : #line 221 "../src/language/parse.y"
    2634             :     {(yyval.val)=newnode(Ffunction,newconst(CSTentry,&(yylsp[(1) - (4)])),(yyvsp[(3) - (4)].val),&(yyloc));}
    2635             :     break;
    2636             : 
    2637             :   case 105:
    2638             : 
    2639             : /* Line 1806 of yacc.c  */
    2640             : #line 224 "../src/language/parse.y"
    2641             :     {(yyval.val)=newnode(Ffunction,newconst(CSTmember,&(yylsp[(3) - (3)])),(yyvsp[(1) - (3)].val),&(yyloc));}
    2642             :     break;
    2643             : 
    2644             :   case 106:
    2645             : 
    2646             : /* Line 1806 of yacc.c  */
    2647             : #line 228 "../src/language/parse.y"
    2648             :     {(yyval.val)=newfunc(CSTentry,&(yylsp[(1) - (6)]),(yyvsp[(3) - (6)].val),(yyvsp[(6) - (6)].val),&(yyloc));}
    2649             :     break;
    2650             : 
    2651             :   case 107:
    2652             : 
    2653             : /* Line 1806 of yacc.c  */
    2654             : #line 230 "../src/language/parse.y"
    2655             :     {(yyval.val)=newfunc(CSTmember,&(yylsp[(3) - (5)]),(yyvsp[(1) - (5)].val),(yyvsp[(5) - (5)].val),&(yyloc));}
    2656             :     break;
    2657             : 
    2658             :   case 108:
    2659             : 
    2660             : /* Line 1806 of yacc.c  */
    2661             : #line 231 "../src/language/parse.y"
    2662             :     {(yyval.val)=newnode(Flambda, (yyvsp[(1) - (3)].val),(yyvsp[(3) - (3)].val),&(yyloc));}
    2663             :     break;
    2664             : 
    2665             :   case 109:
    2666             : 
    2667             : /* Line 1806 of yacc.c  */
    2668             : #line 232 "../src/language/parse.y"
    2669             :     {(yyval.val)=newnode(Flambda, (yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val),&(yyloc));}
    2670             :     break;
    2671             : 
    2672             : 
    2673             : 
    2674             : /* Line 1806 of yacc.c  */
    2675             : #line 2676 "../src/language/parse.c"
    2676           0 :       default: break;
    2677             :     }
    2678             :   /* User semantic actions sometimes alter yychar, and that requires
    2679             :      that yytoken be updated with the new translation.  We take the
    2680             :      approach of translating immediately before every use of yytoken.
    2681             :      One alternative is translating here after every semantic action,
    2682             :      but that translation would be missed if the semantic action invokes
    2683             :      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
    2684             :      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
    2685             :      incorrect destructor might then be invoked immediately.  In the
    2686             :      case of YYERROR or YYBACKUP, subsequent parser actions might lead
    2687             :      to an incorrect destructor call or verbose syntax error message
    2688             :      before the lookahead is translated.  */
    2689             :   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
    2690             : 
    2691    32200469 :   YYPOPSTACK (yylen);
    2692    32200469 :   yylen = 0;
    2693             :   YY_STACK_PRINT (yyss, yyssp);
    2694             : 
    2695    32200469 :   *++yyvsp = yyval;
    2696    32200469 :   *++yylsp = yyloc;
    2697             : 
    2698             :   /* Now `shift' the result of the reduction.  Determine what state
    2699             :      that goes to, based on the state we popped back to and the rule
    2700             :      number reduced by.  */
    2701             : 
    2702    32200469 :   yyn = yyr1[yyn];
    2703             : 
    2704    32200469 :   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
    2705    32200469 :   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    2706    15485549 :     yystate = yytable[yystate];
    2707             :   else
    2708    16714920 :     yystate = yydefgoto[yyn - YYNTOKENS];
    2709             : 
    2710    32200469 :   goto yynewstate;
    2711             : 
    2712             : 
    2713             : /*------------------------------------.
    2714             : | yyerrlab -- here on detecting error |
    2715             : `------------------------------------*/
    2716             : yyerrlab:
    2717             :   /* Make sure we have latest lookahead translation.  See comments at
    2718             :      user semantic actions for why this is necessary.  */
    2719         133 :   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
    2720             : 
    2721             :   /* If not already recovering from an error, report this error.  */
    2722         133 :   if (!yyerrstatus)
    2723             :     {
    2724          98 :       ++yynerrs;
    2725             : #if ! YYERROR_VERBOSE
    2726             :       yyerror (&yylloc, lex, YY_("syntax error"));
    2727             : #else
    2728             : # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
    2729             :                                         yyssp, yytoken)
    2730             :       {
    2731          98 :         char const *yymsgp = YY_("syntax error");
    2732             :         int yysyntax_error_status;
    2733          98 :         yysyntax_error_status = YYSYNTAX_ERROR;
    2734          98 :         if (yysyntax_error_status == 0)
    2735          98 :           yymsgp = yymsg;
    2736           0 :         else if (yysyntax_error_status == 1)
    2737             :           {
    2738           0 :             if (yymsg != yymsgbuf)
    2739           0 :               YYSTACK_FREE (yymsg);
    2740           0 :             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
    2741           0 :             if (!yymsg)
    2742             :               {
    2743           0 :                 yymsg = yymsgbuf;
    2744           0 :                 yymsg_alloc = sizeof yymsgbuf;
    2745           0 :                 yysyntax_error_status = 2;
    2746             :               }
    2747             :             else
    2748             :               {
    2749           0 :                 yysyntax_error_status = YYSYNTAX_ERROR;
    2750           0 :                 yymsgp = yymsg;
    2751             :               }
    2752             :           }
    2753          98 :         yyerror (&yylloc, lex, yymsgp);
    2754          98 :         if (yysyntax_error_status == 2)
    2755           0 :           goto yyexhaustedlab;
    2756             :       }
    2757             : # undef YYSYNTAX_ERROR
    2758             : #endif
    2759             :     }
    2760             : 
    2761         133 :   yyerror_range[1] = yylloc;
    2762             : 
    2763         133 :   if (yyerrstatus == 3)
    2764             :     {
    2765             :       /* If just tried and failed to reuse lookahead token after an
    2766             :          error, discard it.  */
    2767             : 
    2768           0 :       if (yychar <= YYEOF)
    2769             :         {
    2770             :           /* Return failure if at end of input.  */
    2771           0 :           if (yychar == YYEOF)
    2772           0 :             YYABORT;
    2773             :         }
    2774             :       else
    2775             :         {
    2776           0 :           yydestruct ("Error: discarding",
    2777             :                       yytoken, &yylval, &yylloc, lex);
    2778           0 :           yychar = YYEMPTY;
    2779             :         }
    2780             :     }
    2781             : 
    2782             :   /* Else will try to reuse lookahead token after shifting the error
    2783             :      token.  */
    2784         133 :   goto yyerrlab1;
    2785             : 
    2786             : 
    2787             : /*---------------------------------------------------.
    2788             : | yyerrorlab -- error raised explicitly by YYERROR.  |
    2789             : `---------------------------------------------------*/
    2790             : yyerrorlab:
    2791             : 
    2792             :   /* Pacify compilers like GCC when the user code never invokes
    2793             :      YYERROR and the label yyerrorlab therefore never appears in user
    2794             :      code.  */
    2795             :   if (/*CONSTCOND*/ 0)
    2796             :      goto yyerrorlab;
    2797             : 
    2798             :   yyerror_range[1] = yylsp[1-yylen];
    2799             :   /* Do not reclaim the symbols of the rule which action triggered
    2800             :      this YYERROR.  */
    2801             :   YYPOPSTACK (yylen);
    2802             :   yylen = 0;
    2803             :   YY_STACK_PRINT (yyss, yyssp);
    2804             :   yystate = *yyssp;
    2805             :   goto yyerrlab1;
    2806             : 
    2807             : 
    2808             : /*-------------------------------------------------------------.
    2809             : | yyerrlab1 -- common code for both syntax error and YYERROR.  |
    2810             : `-------------------------------------------------------------*/
    2811             : yyerrlab1:
    2812         133 :   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
    2813             : 
    2814             :   for (;;)
    2815             :     {
    2816         140 :       yyn = yypact[yystate];
    2817         140 :       if (!yypact_value_is_default (yyn))
    2818             :         {
    2819         140 :           yyn += YYTERROR;
    2820         140 :           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
    2821             :             {
    2822         126 :               yyn = yytable[yyn];
    2823         126 :               if (0 < yyn)
    2824         126 :                 break;
    2825             :             }
    2826             :         }
    2827             : 
    2828             :       /* Pop the current state because it cannot handle the error token.  */
    2829          14 :       if (yyssp == yyss)
    2830           7 :         YYABORT;
    2831             : 
    2832           7 :       yyerror_range[1] = *yylsp;
    2833           7 :       yydestruct ("Error: popping",
    2834           7 :                   yystos[yystate], yyvsp, yylsp, lex);
    2835           7 :       YYPOPSTACK (1);
    2836           7 :       yystate = *yyssp;
    2837             :       YY_STACK_PRINT (yyss, yyssp);
    2838           7 :     }
    2839             : 
    2840         126 :   *++yyvsp = yylval;
    2841             : 
    2842         126 :   yyerror_range[2] = yylloc;
    2843             :   /* Using YYLLOC is tempting, but would change the location of
    2844             :      the lookahead.  YYLOC is available though.  */
    2845         126 :   YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
    2846         126 :   *++yylsp = yyloc;
    2847             : 
    2848             :   /* Shift the error token.  */
    2849             :   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
    2850             : 
    2851         126 :   yystate = yyn;
    2852         126 :   goto yynewstate;
    2853             : 
    2854             : 
    2855             : /*-------------------------------------.
    2856             : | yyacceptlab -- YYACCEPT comes here.  |
    2857             : `-------------------------------------*/
    2858             : yyacceptlab:
    2859       79738 :   yyresult = 0;
    2860       79738 :   goto yyreturn;
    2861             : 
    2862             : /*-----------------------------------.
    2863             : | yyabortlab -- YYABORT comes here.  |
    2864             : `-----------------------------------*/
    2865             : yyabortlab:
    2866           7 :   yyresult = 1;
    2867           7 :   goto yyreturn;
    2868             : 
    2869             : #if !defined(yyoverflow) || YYERROR_VERBOSE
    2870             : /*-------------------------------------------------.
    2871             : | yyexhaustedlab -- memory exhaustion comes here.  |
    2872             : `-------------------------------------------------*/
    2873             : yyexhaustedlab:
    2874           0 :   yyerror (&yylloc, lex, YY_("memory exhausted"));
    2875           0 :   yyresult = 2;
    2876             :   /* Fall through.  */
    2877             : #endif
    2878             : 
    2879             : yyreturn:
    2880       79745 :   if (yychar != YYEMPTY)
    2881             :     {
    2882             :       /* Make sure we have latest lookahead translation.  See comments at
    2883             :          user semantic actions for why this is necessary.  */
    2884           7 :       yytoken = YYTRANSLATE (yychar);
    2885           7 :       yydestruct ("Cleanup: discarding lookahead",
    2886             :                   yytoken, &yylval, &yylloc, lex);
    2887             :     }
    2888             :   /* Do not reclaim the symbols of the rule which action triggered
    2889             :      this YYABORT or YYACCEPT.  */
    2890       79745 :   YYPOPSTACK (yylen);
    2891             :   YY_STACK_PRINT (yyss, yyssp);
    2892      318966 :   while (yyssp != yyss)
    2893             :     {
    2894      159476 :       yydestruct ("Cleanup: popping",
    2895      159476 :                   yystos[*yyssp], yyvsp, yylsp, lex);
    2896      159476 :       YYPOPSTACK (1);
    2897             :     }
    2898             : #ifndef yyoverflow
    2899       79745 :   if (yyss != yyssa)
    2900           0 :     YYSTACK_FREE (yyss);
    2901             : #endif
    2902             : #if YYERROR_VERBOSE
    2903       79745 :   if (yymsg != yymsgbuf)
    2904           0 :     YYSTACK_FREE (yymsg);
    2905             : #endif
    2906             :   /* Make sure YYID is used.  */
    2907       79745 :   return YYID (yyresult);
    2908             : }
    2909             : 
    2910             : 
    2911             : 
    2912             : /* Line 2067 of yacc.c  */
    2913             : #line 235 "../src/language/parse.y"
    2914             : 
    2915             : 

Generated by: LCOV version 1.11