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 18889-ac2cbba) Lines: 175 252 69.4 %
Date: 2016-05-01 Functions: 5 5 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 188 269 69.9 %

           Branch data     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         [ +  + ]:        791 :   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                 :        756 :   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         [ +  + ]:       4830 :     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                 :     269762 : 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         [ -  + ]:     269762 :   if (!yymsg)
    1414                 :          0 :     yymsg = "Deleting";
    1415                 :            :   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
    1416                 :            : 
    1417   [ -  -  -  -  :     269762 :   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                 :     269762 :         break;
    1584                 :            :     }
    1585                 :     269762 : }
    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                 :     134881 : 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                 :     134881 :   char *yymsg = yymsgbuf;
    1687                 :     134881 :   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                 :     134881 :   int yylen = 0;
    1695                 :            : 
    1696                 :     134881 :   yytoken = 0;
    1697                 :     134881 :   yyss = yyssa;
    1698                 :     134881 :   yyvs = yyvsa;
    1699                 :     134881 :   yyls = yylsa;
    1700                 :     134881 :   yystacksize = YYINITDEPTH;
    1701                 :            : 
    1702                 :            :   YYDPRINTF ((stderr, "Starting parse\n"));
    1703                 :            : 
    1704                 :     134881 :   yystate = 0;
    1705                 :     134881 :   yyerrstatus = 0;
    1706                 :     134881 :   yynerrs = 0;
    1707                 :     134881 :   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                 :     134881 :   yyssp = yyss;
    1714                 :     134881 :   yyvsp = yyvs;
    1715                 :     134881 :   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                 :     134881 :   yylsp[0] = yylloc;
    1732                 :            : 
    1733                 :     134881 :   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                 :   72126795 :   yyssp++;
    1742                 :            : 
    1743                 :            :  yysetstate:
    1744                 :   72261676 :   *yyssp = yystate;
    1745                 :            : 
    1746         [ -  + ]:   72261676 :   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         [ +  + ]:   72261676 :   if (yystate == YYFINAL)
    1815                 :     134874 :     YYACCEPT;
    1816                 :            : 
    1817                 :   72126802 :   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                 :   72126802 :   yyn = yypact[yystate];
    1829         [ +  + ]:   72126802 :   if (yypact_value_is_default (yyn))
    1830                 :    6118697 :     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         [ +  + ]:   66008105 :   if (yychar == YYEMPTY)
    1836                 :            :     {
    1837                 :            :       YYDPRINTF ((stderr, "Reading a token: "));
    1838                 :   33537416 :       yychar = YYLEX;
    1839                 :            :     }
    1840                 :            : 
    1841         [ +  + ]:   66008105 :   if (yychar <= YYEOF)
    1842                 :            :     {
    1843                 :     497748 :       yychar = yytoken = YYEOF;
    1844                 :            :       YYDPRINTF ((stderr, "Now at end of input.\n"));
    1845                 :            :     }
    1846                 :            :   else
    1847                 :            :     {
    1848         [ +  - ]:   65510357 :       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                 :   66008105 :   yyn += yytoken;
    1855 [ +  + ][ +  + ]:   66008105 :   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
                 [ +  + ]
    1856                 :            :     goto yydefault;
    1857                 :   33949171 :   yyn = yytable[yyn];
    1858         [ +  + ]:   33949171 :   if (yyn <= 0)
    1859                 :            :     {
    1860                 :            :       if (yytable_value_is_error (yyn))
    1861                 :            :         goto yyerrlab;
    1862                 :     411762 :       yyn = -yyn;
    1863                 :     411762 :       goto yyreduce;
    1864                 :            :     }
    1865                 :            : 
    1866                 :            :   /* Count tokens shifted since error; after three, turn off error
    1867                 :            :      status.  */
    1868         [ +  + ]:   33537409 :   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                 :   33537409 :   yychar = YYEMPTY;
    1876                 :            : 
    1877                 :   33537409 :   yystate = yyn;
    1878                 :   33537409 :   *++yyvsp = yylval;
    1879                 :   33537409 :   *++yylsp = yylloc;
    1880                 :   33537409 :   goto yynewstate;
    1881                 :            : 
    1882                 :            : 
    1883                 :            : /*-----------------------------------------------------------.
    1884                 :            : | yydefault -- do the default action for the current state.  |
    1885                 :            : `-----------------------------------------------------------*/
    1886                 :            : yydefault:
    1887                 :   38177631 :   yyn = yydefact[yystate];
    1888         [ +  + ]:   38177631 :   if (yyn == 0)
    1889                 :        133 :     goto yyerrlab;
    1890                 :   38177498 :   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                 :   38589260 :   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                 :   38589260 :   yyval = yyvsp[1-yylen];
    1909                 :            : 
    1910                 :            :   /* Default location.  */
    1911         [ +  + ]:   38589260 :   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
    1912                 :            :   YY_REDUCE_PRINT (yyn);
    1913   [ +  +  +  +  :   38589260 :   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                 :   38589260 :   YYPOPSTACK (yylen);
    2692                 :   38589260 :   yylen = 0;
    2693                 :            :   YY_STACK_PRINT (yyss, yyssp);
    2694                 :            : 
    2695                 :   38589260 :   *++yyvsp = yyval;
    2696                 :   38589260 :   *++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                 :   38589260 :   yyn = yyr1[yyn];
    2703                 :            : 
    2704                 :   38589260 :   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
    2705 [ +  + ][ +  - ]:   38589260 :   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
                 [ +  + ]
    2706                 :   18368207 :     yystate = yytable[yystate];
    2707                 :            :   else
    2708                 :   20221053 :     yystate = yydefgoto[yyn - YYNTOKENS];
    2709                 :            : 
    2710                 :   38589260 :   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                 :     134874 :   yyresult = 0;
    2860                 :     134874 :   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         [ +  + ]:     134881 :   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                 :     134881 :   YYPOPSTACK (yylen);
    2891                 :            :   YY_STACK_PRINT (yyss, yyssp);
    2892         [ +  + ]:     404629 :   while (yyssp != yyss)
    2893                 :            :     {
    2894                 :     269748 :       yydestruct ("Cleanup: popping",
    2895                 :     269748 :                   yystos[*yyssp], yyvsp, yylsp, lex);
    2896                 :     269748 :       YYPOPSTACK (1);
    2897                 :            :     }
    2898                 :            : #ifndef yyoverflow
    2899         [ -  + ]:     134881 :   if (yyss != yyssa)
    2900                 :          0 :     YYSTACK_FREE (yyss);
    2901                 :            : #endif
    2902                 :            : #if YYERROR_VERBOSE
    2903         [ -  + ]:     134881 :   if (yymsg != yymsgbuf)
    2904                 :          0 :     YYSTACK_FREE (yymsg);
    2905                 :            : #endif
    2906                 :            :   /* Make sure YYID is used.  */
    2907                 :     134881 :   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.9