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-bordeaux1.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 16912-212c0f0) Lines: 167 252 66.3 %
Date: 2014-10-20 Functions: 5 5 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 185 270 68.5 %

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

Generated by: LCOV version 1.9