LCOV - code coverage report
Current view: top level - src - parse_touchstone.cpp (source / functions) Hit Total Coverage
Test: qucs-core-0.0.19 Code Coverage Lines: 0 276 0.0 %
Date: 2015-01-05 16:01:02 Functions: 0 10 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 252 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* A Bison parser, made by GNU Bison 3.0.2.  */
       2                 :            : 
       3                 :            : /* Bison implementation for Yacc-like parsers in C
       4                 :            : 
       5                 :            :    Copyright (C) 1984, 1989-1990, 2000-2013 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 "3.0.2"
      48                 :            : 
      49                 :            : /* Skeleton name.  */
      50                 :            : #define YYSKELETON_NAME "yacc.c"
      51                 :            : 
      52                 :            : /* Pure parsers.  */
      53                 :            : #define YYPURE 0
      54                 :            : 
      55                 :            : /* Push parsers.  */
      56                 :            : #define YYPUSH 0
      57                 :            : 
      58                 :            : /* Pull parsers.  */
      59                 :            : #define YYPULL 1
      60                 :            : 
      61                 :            : 
      62                 :            : /* Substitute the variable and function names.  */
      63                 :            : #define yyparse         touchstone_parse
      64                 :            : #define yylex           touchstone_lex
      65                 :            : #define yyerror         touchstone_error
      66                 :            : #define yydebug         touchstone_debug
      67                 :            : #define yynerrs         touchstone_nerrs
      68                 :            : 
      69                 :            : #define yylval          touchstone_lval
      70                 :            : #define yychar          touchstone_char
      71                 :            : 
      72                 :            : /* Copy the first part of user declarations.  */
      73                 :            : #line 3 "parse_touchstone.y" /* yacc.c:339  */
      74                 :            : 
      75                 :            : /*
      76                 :            :  * parse_touchstone.y - parser for Touchstone files
      77                 :            :  *
      78                 :            :  * Copyright (C) 2003, 2005, 2006 Stefan Jahn <stefan@lkcc.org>
      79                 :            :  *
      80                 :            :  * This is free software; you can redistribute it and/or modify
      81                 :            :  * it under the terms of the GNU General Public License as published by
      82                 :            :  * the Free Software Foundation; either version 2, or (at your option)
      83                 :            :  * any later version.
      84                 :            :  *
      85                 :            :  * This software is distributed in the hope that it will be useful,
      86                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      87                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      88                 :            :  * GNU General Public License for more details.
      89                 :            :  *
      90                 :            :  * You should have received a copy of the GNU General Public License
      91                 :            :  * along with this package; see the file COPYING.  If not, write to
      92                 :            :  * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
      93                 :            :  * Boston, MA 02110-1301, USA.
      94                 :            :  *
      95                 :            :  * $Id$
      96                 :            :  *
      97                 :            :  */
      98                 :            : 
      99                 :            : #if HAVE_CONFIG_H
     100                 :            : # include <config.h>
     101                 :            : #endif
     102                 :            : 
     103                 :            : #include <stdio.h>
     104                 :            : #include <stdlib.h>
     105                 :            : #include <string.h>
     106                 :            : 
     107                 :            : #define YYERROR_VERBOSE 42
     108                 :            : #define YYDEBUG 1
     109                 :            : #define YYMAXDEPTH 1000000
     110                 :            : 
     111                 :            : #include "logging.h"
     112                 :            : #include "complex.h"
     113                 :            : #include "object.h"
     114                 :            : #include "vector.h"
     115                 :            : #include "dataset.h"
     116                 :            : #include "strlist.h"
     117                 :            : #include "check_touchstone.h"
     118                 :            : 
     119                 :            : using namespace qucs;
     120                 :            : 
     121                 :            : 
     122                 :            : #line 123 "parse_touchstone.cpp" /* yacc.c:339  */
     123                 :            : 
     124                 :            : # ifndef YY_NULLPTR
     125                 :            : #  if defined __cplusplus && 201103L <= __cplusplus
     126                 :            : #   define YY_NULLPTR nullptr
     127                 :            : #  else
     128                 :            : #   define YY_NULLPTR 0
     129                 :            : #  endif
     130                 :            : # endif
     131                 :            : 
     132                 :            : /* Enabling verbose error messages.  */
     133                 :            : #ifdef YYERROR_VERBOSE
     134                 :            : # undef YYERROR_VERBOSE
     135                 :            : # define YYERROR_VERBOSE 1
     136                 :            : #else
     137                 :            : # define YYERROR_VERBOSE 0
     138                 :            : #endif
     139                 :            : 
     140                 :            : /* In a future release of Bison, this section will be replaced
     141                 :            :    by #include "tokens_touchstone.h".  */
     142                 :            : #ifndef YY_TOUCHSTONE_TOKENS_TOUCHSTONE_H_INCLUDED
     143                 :            : # define YY_TOUCHSTONE_TOKENS_TOUCHSTONE_H_INCLUDED
     144                 :            : /* Debug traces.  */
     145                 :            : #ifndef YYDEBUG
     146                 :            : # define YYDEBUG 0
     147                 :            : #endif
     148                 :            : #if YYDEBUG
     149                 :            : extern int touchstone_debug;
     150                 :            : #endif
     151                 :            : 
     152                 :            : /* Token type.  */
     153                 :            : #ifndef YYTOKENTYPE
     154                 :            : # define YYTOKENTYPE
     155                 :            :   enum yytokentype
     156                 :            :   {
     157                 :            :     InvalidCharacter = 258,
     158                 :            :     Float = 259,
     159                 :            :     Option = 260,
     160                 :            :     Eol = 261
     161                 :            :   };
     162                 :            : #endif
     163                 :            : /* Tokens.  */
     164                 :            : #define InvalidCharacter 258
     165                 :            : #define Float 259
     166                 :            : #define Option 260
     167                 :            : #define Eol 261
     168                 :            : 
     169                 :            : /* Value type.  */
     170                 :            : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
     171                 :            : typedef union YYSTYPE YYSTYPE;
     172                 :            : union YYSTYPE
     173                 :            : {
     174                 :            : #line 59 "parse_touchstone.y" /* yacc.c:355  */
     175                 :            : 
     176                 :            :   char * ident;
     177                 :            :   double f;
     178                 :            :   qucs::vector * v;
     179                 :            :   qucs::strlist * list;
     180                 :            : 
     181                 :            : #line 182 "parse_touchstone.cpp" /* yacc.c:355  */
     182                 :            : };
     183                 :            : # define YYSTYPE_IS_TRIVIAL 1
     184                 :            : # define YYSTYPE_IS_DECLARED 1
     185                 :            : #endif
     186                 :            : 
     187                 :            : 
     188                 :            : extern YYSTYPE touchstone_lval;
     189                 :            : 
     190                 :            : int touchstone_parse (void);
     191                 :            : 
     192                 :            : #endif /* !YY_TOUCHSTONE_TOKENS_TOUCHSTONE_H_INCLUDED  */
     193                 :            : 
     194                 :            : /* Copy the second part of user declarations.  */
     195                 :            : 
     196                 :            : #line 197 "parse_touchstone.cpp" /* yacc.c:358  */
     197                 :            : 
     198                 :            : #ifdef short
     199                 :            : # undef short
     200                 :            : #endif
     201                 :            : 
     202                 :            : #ifdef YYTYPE_UINT8
     203                 :            : typedef YYTYPE_UINT8 yytype_uint8;
     204                 :            : #else
     205                 :            : typedef unsigned char yytype_uint8;
     206                 :            : #endif
     207                 :            : 
     208                 :            : #ifdef YYTYPE_INT8
     209                 :            : typedef YYTYPE_INT8 yytype_int8;
     210                 :            : #else
     211                 :            : typedef signed char yytype_int8;
     212                 :            : #endif
     213                 :            : 
     214                 :            : #ifdef YYTYPE_UINT16
     215                 :            : typedef YYTYPE_UINT16 yytype_uint16;
     216                 :            : #else
     217                 :            : typedef unsigned short int yytype_uint16;
     218                 :            : #endif
     219                 :            : 
     220                 :            : #ifdef YYTYPE_INT16
     221                 :            : typedef YYTYPE_INT16 yytype_int16;
     222                 :            : #else
     223                 :            : typedef short int yytype_int16;
     224                 :            : #endif
     225                 :            : 
     226                 :            : #ifndef YYSIZE_T
     227                 :            : # ifdef __SIZE_TYPE__
     228                 :            : #  define YYSIZE_T __SIZE_TYPE__
     229                 :            : # elif defined size_t
     230                 :            : #  define YYSIZE_T size_t
     231                 :            : # elif ! defined YYSIZE_T
     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                 :            : #ifndef YY_ATTRIBUTE
     254                 :            : # if (defined __GNUC__                                               \
     255                 :            :       && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
     256                 :            :      || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
     257                 :            : #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
     258                 :            : # else
     259                 :            : #  define YY_ATTRIBUTE(Spec) /* empty */
     260                 :            : # endif
     261                 :            : #endif
     262                 :            : 
     263                 :            : #ifndef YY_ATTRIBUTE_PURE
     264                 :            : # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
     265                 :            : #endif
     266                 :            : 
     267                 :            : #ifndef YY_ATTRIBUTE_UNUSED
     268                 :            : # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
     269                 :            : #endif
     270                 :            : 
     271                 :            : #if !defined _Noreturn \
     272                 :            :      && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
     273                 :            : # if defined _MSC_VER && 1200 <= _MSC_VER
     274                 :            : #  define _Noreturn __declspec (noreturn)
     275                 :            : # else
     276                 :            : #  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
     277                 :            : # endif
     278                 :            : #endif
     279                 :            : 
     280                 :            : /* Suppress unused-variable warnings by "using" E.  */
     281                 :            : #if ! defined lint || defined __GNUC__
     282                 :            : # define YYUSE(E) ((void) (E))
     283                 :            : #else
     284                 :            : # define YYUSE(E) /* empty */
     285                 :            : #endif
     286                 :            : 
     287                 :            : #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
     288                 :            : /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
     289                 :            : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     290                 :            :     _Pragma ("GCC diagnostic push") \
     291                 :            :     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
     292                 :            :     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
     293                 :            : # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
     294                 :            :     _Pragma ("GCC diagnostic pop")
     295                 :            : #else
     296                 :            : # define YY_INITIAL_VALUE(Value) Value
     297                 :            : #endif
     298                 :            : #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
     299                 :            : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
     300                 :            : # define YY_IGNORE_MAYBE_UNINITIALIZED_END
     301                 :            : #endif
     302                 :            : #ifndef YY_INITIAL_VALUE
     303                 :            : # define YY_INITIAL_VALUE(Value) /* Nothing. */
     304                 :            : #endif
     305                 :            : 
     306                 :            : 
     307                 :            : #if ! defined yyoverflow || YYERROR_VERBOSE
     308                 :            : 
     309                 :            : /* The parser invokes alloca or malloc; define the necessary symbols.  */
     310                 :            : 
     311                 :            : # ifdef YYSTACK_USE_ALLOCA
     312                 :            : #  if YYSTACK_USE_ALLOCA
     313                 :            : #   ifdef __GNUC__
     314                 :            : #    define YYSTACK_ALLOC __builtin_alloca
     315                 :            : #   elif defined __BUILTIN_VA_ARG_INCR
     316                 :            : #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
     317                 :            : #   elif defined _AIX
     318                 :            : #    define YYSTACK_ALLOC __alloca
     319                 :            : #   elif defined _MSC_VER
     320                 :            : #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
     321                 :            : #    define alloca _alloca
     322                 :            : #   else
     323                 :            : #    define YYSTACK_ALLOC alloca
     324                 :            : #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
     325                 :            : #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
     326                 :            :       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
     327                 :            : #     ifndef EXIT_SUCCESS
     328                 :            : #      define EXIT_SUCCESS 0
     329                 :            : #     endif
     330                 :            : #    endif
     331                 :            : #   endif
     332                 :            : #  endif
     333                 :            : # endif
     334                 :            : 
     335                 :            : # ifdef YYSTACK_ALLOC
     336                 :            :    /* Pacify GCC's 'empty if-body' warning.  */
     337                 :            : #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
     338                 :            : #  ifndef YYSTACK_ALLOC_MAXIMUM
     339                 :            :     /* The OS might guarantee only one guard page at the bottom of the stack,
     340                 :            :        and a page size can be as small as 4096 bytes.  So we cannot safely
     341                 :            :        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
     342                 :            :        to allow for a few compiler-allocated temporary stack slots.  */
     343                 :            : #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
     344                 :            : #  endif
     345                 :            : # else
     346                 :            : #  define YYSTACK_ALLOC YYMALLOC
     347                 :            : #  define YYSTACK_FREE YYFREE
     348                 :            : #  ifndef YYSTACK_ALLOC_MAXIMUM
     349                 :            : #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
     350                 :            : #  endif
     351                 :            : #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
     352                 :            :        && ! ((defined YYMALLOC || defined malloc) \
     353                 :            :              && (defined YYFREE || defined free)))
     354                 :            : #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
     355                 :            : #   ifndef EXIT_SUCCESS
     356                 :            : #    define EXIT_SUCCESS 0
     357                 :            : #   endif
     358                 :            : #  endif
     359                 :            : #  ifndef YYMALLOC
     360                 :            : #   define YYMALLOC malloc
     361                 :            : #   if ! defined malloc && ! defined EXIT_SUCCESS
     362                 :            : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
     363                 :            : #   endif
     364                 :            : #  endif
     365                 :            : #  ifndef YYFREE
     366                 :            : #   define YYFREE free
     367                 :            : #   if ! defined free && ! defined EXIT_SUCCESS
     368                 :            : void free (void *); /* INFRINGES ON USER NAME SPACE */
     369                 :            : #   endif
     370                 :            : #  endif
     371                 :            : # endif
     372                 :            : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
     373                 :            : 
     374                 :            : 
     375                 :            : #if (! defined yyoverflow \
     376                 :            :      && (! defined __cplusplus \
     377                 :            :          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
     378                 :            : 
     379                 :            : /* A type that is properly aligned for any stack member.  */
     380                 :            : union yyalloc
     381                 :            : {
     382                 :            :   yytype_int16 yyss_alloc;
     383                 :            :   YYSTYPE yyvs_alloc;
     384                 :            : };
     385                 :            : 
     386                 :            : /* The size of the maximum gap between one aligned stack and the next.  */
     387                 :            : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
     388                 :            : 
     389                 :            : /* The size of an array large to enough to hold all stacks, each with
     390                 :            :    N elements.  */
     391                 :            : # define YYSTACK_BYTES(N) \
     392                 :            :      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
     393                 :            :       + YYSTACK_GAP_MAXIMUM)
     394                 :            : 
     395                 :            : # define YYCOPY_NEEDED 1
     396                 :            : 
     397                 :            : /* Relocate STACK from its old location to the new one.  The
     398                 :            :    local variables YYSIZE and YYSTACKSIZE give the old and new number of
     399                 :            :    elements in the stack, and YYPTR gives the new location of the
     400                 :            :    stack.  Advance YYPTR to a properly aligned location for the next
     401                 :            :    stack.  */
     402                 :            : # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
     403                 :            :     do                                                                  \
     404                 :            :       {                                                                 \
     405                 :            :         YYSIZE_T yynewbytes;                                            \
     406                 :            :         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
     407                 :            :         Stack = &yyptr->Stack_alloc;                                    \
     408                 :            :         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
     409                 :            :         yyptr += yynewbytes / sizeof (*yyptr);                          \
     410                 :            :       }                                                                 \
     411                 :            :     while (0)
     412                 :            : 
     413                 :            : #endif
     414                 :            : 
     415                 :            : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
     416                 :            : /* Copy COUNT objects from SRC to DST.  The source and destination do
     417                 :            :    not overlap.  */
     418                 :            : # ifndef YYCOPY
     419                 :            : #  if defined __GNUC__ && 1 < __GNUC__
     420                 :            : #   define YYCOPY(Dst, Src, Count) \
     421                 :            :       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
     422                 :            : #  else
     423                 :            : #   define YYCOPY(Dst, Src, Count)              \
     424                 :            :       do                                        \
     425                 :            :         {                                       \
     426                 :            :           YYSIZE_T yyi;                         \
     427                 :            :           for (yyi = 0; yyi < (Count); yyi++)   \
     428                 :            :             (Dst)[yyi] = (Src)[yyi];            \
     429                 :            :         }                                       \
     430                 :            :       while (0)
     431                 :            : #  endif
     432                 :            : # endif
     433                 :            : #endif /* !YYCOPY_NEEDED */
     434                 :            : 
     435                 :            : /* YYFINAL -- State number of the termination state.  */
     436                 :            : #define YYFINAL  8
     437                 :            : /* YYLAST -- Last index in YYTABLE.  */
     438                 :            : #define YYLAST   23
     439                 :            : 
     440                 :            : /* YYNTOKENS -- Number of terminals.  */
     441                 :            : #define YYNTOKENS  9
     442                 :            : /* YYNNTS -- Number of nonterminals.  */
     443                 :            : #define YYNNTS  6
     444                 :            : /* YYNRULES -- Number of rules.  */
     445                 :            : #define YYNRULES  19
     446                 :            : /* YYNSTATES -- Number of states.  */
     447                 :            : #define YYNSTATES  30
     448                 :            : 
     449                 :            : /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
     450                 :            :    by yylex, with out-of-bounds checking.  */
     451                 :            : #define YYUNDEFTOK  2
     452                 :            : #define YYMAXUTOK   261
     453                 :            : 
     454                 :            : #define YYTRANSLATE(YYX)                                                \
     455                 :            :   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
     456                 :            : 
     457                 :            : /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
     458                 :            :    as returned by yylex, without out-of-bounds checking.  */
     459                 :            : static const yytype_uint8 yytranslate[] =
     460                 :            : {
     461                 :            :        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     462                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     463                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     464                 :            :        2,     2,     2,     2,     2,     7,     2,     2,     2,     2,
     465                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     466                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     467                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     468                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     469                 :            :        2,     2,     8,     2,     2,     2,     2,     2,     2,     2,
     470                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     471                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     472                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     473                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     474                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     475                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     476                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     477                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     478                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     479                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     480                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     481                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     482                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     483                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     484                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     485                 :            :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     486                 :            :        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
     487                 :            :        5,     6
     488                 :            : };
     489                 :            : 
     490                 :            : #if YYDEBUG
     491                 :            :   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
     492                 :            : static const yytype_uint8 yyrline[] =
     493                 :            : {
     494                 :            :        0,    74,    74,    78,    82,    86,    89,    90,    97,    98,
     495                 :            :      102,   108,   112,   119,   128,   141,   152,   164,   174,   182
     496                 :            : };
     497                 :            : #endif
     498                 :            : 
     499                 :            : #if YYDEBUG || YYERROR_VERBOSE || 0
     500                 :            : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     501                 :            :    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
     502                 :            : static const char *const yytname[] =
     503                 :            : {
     504                 :            :   "$end", "error", "$undefined", "InvalidCharacter", "Float", "Option",
     505                 :            :   "Eol", "'#'", "'R'", "$accept", "Input", "OptionLine", "OptionList",
     506                 :            :   "Dataset", "DataLine", YY_NULLPTR
     507                 :            : };
     508                 :            : #endif
     509                 :            : 
     510                 :            : # ifdef YYPRINT
     511                 :            : /* YYTOKNUM[NUM] -- (External) token number corresponding to the
     512                 :            :    (internal) symbol number NUM (which must be that of a token).  */
     513                 :            : static const yytype_uint16 yytoknum[] =
     514                 :            : {
     515                 :            :        0,   256,   257,   258,   259,   260,   261,    35,    82
     516                 :            : };
     517                 :            : # endif
     518                 :            : 
     519                 :            : #define YYPACT_NINF -10
     520                 :            : 
     521                 :            : #define yypact_value_is_default(Yystate) \
     522                 :            :   (!!((Yystate) == (-10)))
     523                 :            : 
     524                 :            : #define YYTABLE_NINF -1
     525                 :            : 
     526                 :            : #define yytable_value_is_error(Yytable_value) \
     527                 :            :   0
     528                 :            : 
     529                 :            :   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     530                 :            :      STATE-NUM.  */
     531                 :            : static const yytype_int8 yypact[] =
     532                 :            : {
     533                 :            :        0,     0,     3,    10,    -2,   -10,     3,    -3,   -10,     7,
     534                 :            :       -2,   -10,     6,   -10,   -10,    11,    12,   -10,    -2,     3,
     535                 :            :       13,   -10,     8,    14,   -10,    15,    16,    17,    18,   -10
     536                 :            : };
     537                 :            : 
     538                 :            :   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
     539                 :            :      Performed when YYTABLE does not specify something else to do.  Zero
     540                 :            :      means the default is an error.  */
     541                 :            : static const yytype_uint8 yydefact[] =
     542                 :            : {
     543                 :            :        0,     0,     6,     0,     8,     5,     6,     0,     1,     0,
     544                 :            :        8,     2,    10,     7,     4,     0,    19,    11,     8,     6,
     545                 :            :       12,     9,     0,    18,     3,    13,    17,    15,    16,    14
     546                 :            : };
     547                 :            : 
     548                 :            :   /* YYPGOTO[NTERM-NUM].  */
     549                 :            : static const yytype_int8 yypgoto[] =
     550                 :            : {
     551                 :            :      -10,   -10,    22,    -6,    -9,   -10
     552                 :            : };
     553                 :            : 
     554                 :            :   /* YYDEFGOTO[NTERM-NUM].  */
     555                 :            : static const yytype_int8 yydefgoto[] =
     556                 :            : {
     557                 :            :       -1,     3,     4,     7,    11,    12
     558                 :            : };
     559                 :            : 
     560                 :            :   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
     561                 :            :      positive, shift that token.  If negative, reduce the rule whose
     562                 :            :      number is the opposite.  If YYTABLE_NINF, syntax error.  */
     563                 :            : static const yytype_uint8 yytable[] =
     564                 :            : {
     565                 :            :       13,    17,     9,    14,    10,    15,     1,     2,     6,    21,
     566                 :            :        8,    16,    18,    22,    24,    19,    20,    23,    25,    26,
     567                 :            :       27,    28,    29,     5
     568                 :            : };
     569                 :            : 
     570                 :            : static const yytype_uint8 yycheck[] =
     571                 :            : {
     572                 :            :        6,    10,     4,     6,     6,     8,     6,     7,     5,    18,
     573                 :            :        0,     4,     6,    19,     6,     4,     4,     4,     4,     4,
     574                 :            :        4,     4,     4,     1
     575                 :            : };
     576                 :            : 
     577                 :            :   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     578                 :            :      symbol of state STATE-NUM.  */
     579                 :            : static const yytype_uint8 yystos[] =
     580                 :            : {
     581                 :            :        0,     6,     7,    10,    11,    11,     5,    12,     0,     4,
     582                 :            :        6,    13,    14,    12,     6,     8,     4,    13,     6,     4,
     583                 :            :        4,    13,    12,     4,     6,     4,     4,     4,     4,     4
     584                 :            : };
     585                 :            : 
     586                 :            :   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
     587                 :            : static const yytype_uint8 yyr1[] =
     588                 :            : {
     589                 :            :        0,     9,    10,    11,    11,    11,    12,    12,    13,    13,
     590                 :            :       13,    13,    14,    14,    14,    14,    14,    14,    14,    14
     591                 :            : };
     592                 :            : 
     593                 :            :   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
     594                 :            : static const yytype_uint8 yyr2[] =
     595                 :            : {
     596                 :            :        0,     2,     2,     6,     3,     2,     0,     2,     0,     3,
     597                 :            :        1,     2,     3,     5,     9,     7,     8,     6,     4,     2
     598                 :            : };
     599                 :            : 
     600                 :            : 
     601                 :            : #define yyerrok         (yyerrstatus = 0)
     602                 :            : #define yyclearin       (yychar = YYEMPTY)
     603                 :            : #define YYEMPTY         (-2)
     604                 :            : #define YYEOF           0
     605                 :            : 
     606                 :            : #define YYACCEPT        goto yyacceptlab
     607                 :            : #define YYABORT         goto yyabortlab
     608                 :            : #define YYERROR         goto yyerrorlab
     609                 :            : 
     610                 :            : 
     611                 :            : #define YYRECOVERING()  (!!yyerrstatus)
     612                 :            : 
     613                 :            : #define YYBACKUP(Token, Value)                                  \
     614                 :            : do                                                              \
     615                 :            :   if (yychar == YYEMPTY)                                        \
     616                 :            :     {                                                           \
     617                 :            :       yychar = (Token);                                         \
     618                 :            :       yylval = (Value);                                         \
     619                 :            :       YYPOPSTACK (yylen);                                       \
     620                 :            :       yystate = *yyssp;                                         \
     621                 :            :       goto yybackup;                                            \
     622                 :            :     }                                                           \
     623                 :            :   else                                                          \
     624                 :            :     {                                                           \
     625                 :            :       yyerror (YY_("syntax error: cannot back up")); \
     626                 :            :       YYERROR;                                                  \
     627                 :            :     }                                                           \
     628                 :            : while (0)
     629                 :            : 
     630                 :            : /* Error token number */
     631                 :            : #define YYTERROR        1
     632                 :            : #define YYERRCODE       256
     633                 :            : 
     634                 :            : 
     635                 :            : 
     636                 :            : /* Enable debugging if requested.  */
     637                 :            : #if YYDEBUG
     638                 :            : 
     639                 :            : # ifndef YYFPRINTF
     640                 :            : #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
     641                 :            : #  define YYFPRINTF fprintf
     642                 :            : # endif
     643                 :            : 
     644                 :            : # define YYDPRINTF(Args)                        \
     645                 :            : do {                                            \
     646                 :            :   if (yydebug)                                  \
     647                 :            :     YYFPRINTF Args;                             \
     648                 :            : } while (0)
     649                 :            : 
     650                 :            : /* This macro is provided for backward compatibility. */
     651                 :            : #ifndef YY_LOCATION_PRINT
     652                 :            : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
     653                 :            : #endif
     654                 :            : 
     655                 :            : 
     656                 :            : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
     657                 :            : do {                                                                      \
     658                 :            :   if (yydebug)                                                            \
     659                 :            :     {                                                                     \
     660                 :            :       YYFPRINTF (stderr, "%s ", Title);                                   \
     661                 :            :       yy_symbol_print (stderr,                                            \
     662                 :            :                   Type, Value); \
     663                 :            :       YYFPRINTF (stderr, "\n");                                           \
     664                 :            :     }                                                                     \
     665                 :            : } while (0)
     666                 :            : 
     667                 :            : 
     668                 :            : /*----------------------------------------.
     669                 :            : | Print this symbol's value on YYOUTPUT.  |
     670                 :            : `----------------------------------------*/
     671                 :            : 
     672                 :            : static void
     673                 :          0 : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
     674                 :            : {
     675                 :          0 :   FILE *yyo = yyoutput;
     676                 :            :   YYUSE (yyo);
     677         [ #  # ]:          0 :   if (!yyvaluep)
     678                 :          0 :     return;
     679                 :            : # ifdef YYPRINT
     680                 :            :   if (yytype < YYNTOKENS)
     681                 :            :     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
     682                 :            : # endif
     683                 :            :   YYUSE (yytype);
     684                 :            : }
     685                 :            : 
     686                 :            : 
     687                 :            : /*--------------------------------.
     688                 :            : | Print this symbol on YYOUTPUT.  |
     689                 :            : `--------------------------------*/
     690                 :            : 
     691                 :            : static void
     692                 :          0 : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
     693                 :            : {
     694                 :            :   YYFPRINTF (yyoutput, "%s %s (",
     695         [ #  # ]:          0 :              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
     696                 :            : 
     697                 :          0 :   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
     698                 :          0 :   YYFPRINTF (yyoutput, ")");
     699                 :          0 : }
     700                 :            : 
     701                 :            : /*------------------------------------------------------------------.
     702                 :            : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
     703                 :            : | TOP (included).                                                   |
     704                 :            : `------------------------------------------------------------------*/
     705                 :            : 
     706                 :            : static void
     707                 :          0 : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
     708                 :            : {
     709                 :          0 :   YYFPRINTF (stderr, "Stack now");
     710         [ #  # ]:          0 :   for (; yybottom <= yytop; yybottom++)
     711                 :            :     {
     712                 :          0 :       int yybot = *yybottom;
     713                 :          0 :       YYFPRINTF (stderr, " %d", yybot);
     714                 :            :     }
     715                 :          0 :   YYFPRINTF (stderr, "\n");
     716                 :          0 : }
     717                 :            : 
     718                 :            : # define YY_STACK_PRINT(Bottom, Top)                            \
     719                 :            : do {                                                            \
     720                 :            :   if (yydebug)                                                  \
     721                 :            :     yy_stack_print ((Bottom), (Top));                           \
     722                 :            : } while (0)
     723                 :            : 
     724                 :            : 
     725                 :            : /*------------------------------------------------.
     726                 :            : | Report that the YYRULE is going to be reduced.  |
     727                 :            : `------------------------------------------------*/
     728                 :            : 
     729                 :            : static void
     730                 :          0 : yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
     731                 :            : {
     732                 :          0 :   unsigned long int yylno = yyrline[yyrule];
     733                 :          0 :   int yynrhs = yyr2[yyrule];
     734                 :            :   int yyi;
     735                 :            :   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
     736                 :          0 :              yyrule - 1, yylno);
     737                 :            :   /* The symbols being reduced.  */
     738         [ #  # ]:          0 :   for (yyi = 0; yyi < yynrhs; yyi++)
     739                 :            :     {
     740                 :          0 :       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
     741                 :            :       yy_symbol_print (stderr,
     742                 :          0 :                        yystos[yyssp[yyi + 1 - yynrhs]],
     743                 :            :                        &(yyvsp[(yyi + 1) - (yynrhs)])
     744                 :          0 :                                               );
     745                 :          0 :       YYFPRINTF (stderr, "\n");
     746                 :            :     }
     747                 :          0 : }
     748                 :            : 
     749                 :            : # define YY_REDUCE_PRINT(Rule)          \
     750                 :            : do {                                    \
     751                 :            :   if (yydebug)                          \
     752                 :            :     yy_reduce_print (yyssp, yyvsp, Rule); \
     753                 :            : } while (0)
     754                 :            : 
     755                 :            : /* Nonzero means print parse trace.  It is left uninitialized so that
     756                 :            :    multiple parsers can coexist.  */
     757                 :            : int yydebug;
     758                 :            : #else /* !YYDEBUG */
     759                 :            : # define YYDPRINTF(Args)
     760                 :            : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
     761                 :            : # define YY_STACK_PRINT(Bottom, Top)
     762                 :            : # define YY_REDUCE_PRINT(Rule)
     763                 :            : #endif /* !YYDEBUG */
     764                 :            : 
     765                 :            : 
     766                 :            : /* YYINITDEPTH -- initial size of the parser's stacks.  */
     767                 :            : #ifndef YYINITDEPTH
     768                 :            : # define YYINITDEPTH 200
     769                 :            : #endif
     770                 :            : 
     771                 :            : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
     772                 :            :    if the built-in stack extension method is used).
     773                 :            : 
     774                 :            :    Do not make this value too large; the results are undefined if
     775                 :            :    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
     776                 :            :    evaluated with infinite-precision integer arithmetic.  */
     777                 :            : 
     778                 :            : #ifndef YYMAXDEPTH
     779                 :            : # define YYMAXDEPTH 10000
     780                 :            : #endif
     781                 :            : 
     782                 :            : 
     783                 :            : #if YYERROR_VERBOSE
     784                 :            : 
     785                 :            : # ifndef yystrlen
     786                 :            : #  if defined __GLIBC__ && defined _STRING_H
     787                 :            : #   define yystrlen strlen
     788                 :            : #  else
     789                 :            : /* Return the length of YYSTR.  */
     790                 :            : static YYSIZE_T
     791                 :          0 : yystrlen (const char *yystr)
     792                 :            : {
     793                 :            :   YYSIZE_T yylen;
     794         [ #  # ]:          0 :   for (yylen = 0; yystr[yylen]; yylen++)
     795                 :          0 :     continue;
     796                 :          0 :   return yylen;
     797                 :            : }
     798                 :            : #  endif
     799                 :            : # endif
     800                 :            : 
     801                 :            : # ifndef yystpcpy
     802                 :            : #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
     803                 :            : #   define yystpcpy stpcpy
     804                 :            : #  else
     805                 :            : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
     806                 :            :    YYDEST.  */
     807                 :            : static char *
     808                 :          0 : yystpcpy (char *yydest, const char *yysrc)
     809                 :            : {
     810                 :          0 :   char *yyd = yydest;
     811                 :          0 :   const char *yys = yysrc;
     812                 :            : 
     813         [ #  # ]:          0 :   while ((*yyd++ = *yys++) != '\0')
     814                 :          0 :     continue;
     815                 :            : 
     816                 :          0 :   return yyd - 1;
     817                 :            : }
     818                 :            : #  endif
     819                 :            : # endif
     820                 :            : 
     821                 :            : # ifndef yytnamerr
     822                 :            : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
     823                 :            :    quotes and backslashes, so that it's suitable for yyerror.  The
     824                 :            :    heuristic is that double-quoting is unnecessary unless the string
     825                 :            :    contains an apostrophe, a comma, or backslash (other than
     826                 :            :    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
     827                 :            :    null, do not copy; instead, return the length of what the result
     828                 :            :    would have been.  */
     829                 :            : static YYSIZE_T
     830                 :          0 : yytnamerr (char *yyres, const char *yystr)
     831                 :            : {
     832         [ #  # ]:          0 :   if (*yystr == '"')
     833                 :            :     {
     834                 :          0 :       YYSIZE_T yyn = 0;
     835                 :          0 :       char const *yyp = yystr;
     836                 :            : 
     837                 :          0 :       for (;;)
     838   [ #  #  #  # ]:          0 :         switch (*++yyp)
     839                 :            :           {
     840                 :            :           case '\'':
     841                 :            :           case ',':
     842                 :          0 :             goto do_not_strip_quotes;
     843                 :            : 
     844                 :            :           case '\\':
     845         [ #  # ]:          0 :             if (*++yyp != '\\')
     846                 :          0 :               goto do_not_strip_quotes;
     847                 :            :             /* Fall through.  */
     848                 :            :           default:
     849         [ #  # ]:          0 :             if (yyres)
     850                 :          0 :               yyres[yyn] = *yyp;
     851                 :          0 :             yyn++;
     852                 :          0 :             break;
     853                 :            : 
     854                 :            :           case '"':
     855         [ #  # ]:          0 :             if (yyres)
     856                 :          0 :               yyres[yyn] = '\0';
     857                 :          0 :             return yyn;
     858                 :            :           }
     859                 :            :     do_not_strip_quotes: ;
     860                 :            :     }
     861                 :            : 
     862         [ #  # ]:          0 :   if (! yyres)
     863                 :          0 :     return yystrlen (yystr);
     864                 :            : 
     865                 :          0 :   return yystpcpy (yyres, yystr) - yyres;
     866                 :            : }
     867                 :            : # endif
     868                 :            : 
     869                 :            : /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
     870                 :            :    about the unexpected token YYTOKEN for the state stack whose top is
     871                 :            :    YYSSP.
     872                 :            : 
     873                 :            :    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
     874                 :            :    not large enough to hold the message.  In that case, also set
     875                 :            :    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
     876                 :            :    required number of bytes is too large to store.  */
     877                 :            : static int
     878                 :          0 : yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
     879                 :            :                 yytype_int16 *yyssp, int yytoken)
     880                 :            : {
     881                 :          0 :   YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
     882                 :          0 :   YYSIZE_T yysize = yysize0;
     883                 :            :   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
     884                 :            :   /* Internationalized format string. */
     885                 :          0 :   const char *yyformat = YY_NULLPTR;
     886                 :            :   /* Arguments of yyformat. */
     887                 :            :   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
     888                 :            :   /* Number of reported tokens (one for the "unexpected", one per
     889                 :            :      "expected"). */
     890                 :          0 :   int yycount = 0;
     891                 :            : 
     892                 :            :   /* There are many possibilities here to consider:
     893                 :            :      - If this state is a consistent state with a default action, then
     894                 :            :        the only way this function was invoked is if the default action
     895                 :            :        is an error action.  In that case, don't check for expected
     896                 :            :        tokens because there are none.
     897                 :            :      - The only way there can be no lookahead present (in yychar) is if
     898                 :            :        this state is a consistent state with a default action.  Thus,
     899                 :            :        detecting the absence of a lookahead is sufficient to determine
     900                 :            :        that there is no unexpected or expected token to report.  In that
     901                 :            :        case, just report a simple "syntax error".
     902                 :            :      - Don't assume there isn't a lookahead just because this state is a
     903                 :            :        consistent state with a default action.  There might have been a
     904                 :            :        previous inconsistent state, consistent state with a non-default
     905                 :            :        action, or user semantic action that manipulated yychar.
     906                 :            :      - Of course, the expected token list depends on states to have
     907                 :            :        correct lookahead information, and it depends on the parser not
     908                 :            :        to perform extra reductions after fetching a lookahead from the
     909                 :            :        scanner and before detecting a syntax error.  Thus, state merging
     910                 :            :        (from LALR or IELR) and default reductions corrupt the expected
     911                 :            :        token list.  However, the list is correct for canonical LR with
     912                 :            :        one exception: it will still contain any token that will not be
     913                 :            :        accepted due to an error action in a later state.
     914                 :            :   */
     915         [ #  # ]:          0 :   if (yytoken != YYEMPTY)
     916                 :            :     {
     917                 :          0 :       int yyn = yypact[*yyssp];
     918                 :          0 :       yyarg[yycount++] = yytname[yytoken];
     919         [ #  # ]:          0 :       if (!yypact_value_is_default (yyn))
     920                 :            :         {
     921                 :            :           /* Start YYX at -YYN if negative to avoid negative indexes in
     922                 :            :              YYCHECK.  In other words, skip the first -YYN actions for
     923                 :            :              this state because they are default actions.  */
     924         [ #  # ]:          0 :           int yyxbegin = yyn < 0 ? -yyn : 0;
     925                 :            :           /* Stay within bounds of both yycheck and yytname.  */
     926                 :          0 :           int yychecklim = YYLAST - yyn + 1;
     927                 :          0 :           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
     928                 :            :           int yyx;
     929                 :            : 
     930         [ #  # ]:          0 :           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
     931 [ #  # ][ #  # ]:          0 :             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
     932                 :            :                 && !yytable_value_is_error (yytable[yyx + yyn]))
     933                 :            :               {
     934         [ #  # ]:          0 :                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
     935                 :            :                   {
     936                 :          0 :                     yycount = 1;
     937                 :          0 :                     yysize = yysize0;
     938                 :          0 :                     break;
     939                 :            :                   }
     940                 :          0 :                 yyarg[yycount++] = yytname[yyx];
     941                 :            :                 {
     942                 :          0 :                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
     943         [ #  # ]:          0 :                   if (! (yysize <= yysize1
     944                 :            :                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
     945                 :          0 :                     return 2;
     946                 :          0 :                   yysize = yysize1;
     947                 :            :                 }
     948                 :            :               }
     949                 :            :         }
     950                 :            :     }
     951                 :            : 
     952   [ #  #  #  #  :          0 :   switch (yycount)
                #  #  # ]
     953                 :            :     {
     954                 :            : # define YYCASE_(N, S)                      \
     955                 :            :       case N:                               \
     956                 :            :         yyformat = S;                       \
     957                 :            :       break
     958                 :          0 :       YYCASE_(0, YY_("syntax error"));
     959                 :          0 :       YYCASE_(1, YY_("syntax error, unexpected %s"));
     960                 :          0 :       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
     961                 :          0 :       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
     962                 :          0 :       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
     963                 :          0 :       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
     964                 :            : # undef YYCASE_
     965                 :            :     }
     966                 :            : 
     967                 :            :   {
     968                 :          0 :     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
     969         [ #  # ]:          0 :     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
     970                 :          0 :       return 2;
     971                 :          0 :     yysize = yysize1;
     972                 :            :   }
     973                 :            : 
     974         [ #  # ]:          0 :   if (*yymsg_alloc < yysize)
     975                 :            :     {
     976                 :          0 :       *yymsg_alloc = 2 * yysize;
     977         [ #  # ]:          0 :       if (! (yysize <= *yymsg_alloc
     978                 :          0 :              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
     979                 :          0 :         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
     980                 :          0 :       return 1;
     981                 :            :     }
     982                 :            : 
     983                 :            :   /* Avoid sprintf, as that infringes on the user's name space.
     984                 :            :      Don't have undefined behavior even if the translation
     985                 :            :      produced a string with the wrong number of "%s"s.  */
     986                 :            :   {
     987                 :          0 :     char *yyp = *yymsg;
     988                 :          0 :     int yyi = 0;
     989         [ #  # ]:          0 :     while ((*yyp = *yyformat) != '\0')
     990 [ #  # ][ #  # ]:          0 :       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
                 [ #  # ]
     991                 :            :         {
     992                 :          0 :           yyp += yytnamerr (yyp, yyarg[yyi++]);
     993                 :          0 :           yyformat += 2;
     994                 :            :         }
     995                 :            :       else
     996                 :            :         {
     997                 :          0 :           yyp++;
     998                 :          0 :           yyformat++;
     999                 :            :         }
    1000                 :            :   }
    1001                 :          0 :   return 0;
    1002                 :            : }
    1003                 :            : #endif /* YYERROR_VERBOSE */
    1004                 :            : 
    1005                 :            : /*-----------------------------------------------.
    1006                 :            : | Release the memory associated to this symbol.  |
    1007                 :            : `-----------------------------------------------*/
    1008                 :            : 
    1009                 :            : static void
    1010                 :          0 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
    1011                 :            : {
    1012                 :            :   YYUSE (yyvaluep);
    1013         [ #  # ]:          0 :   if (!yymsg)
    1014                 :          0 :     yymsg = "Deleting";
    1015         [ #  # ]:          0 :   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
    1016                 :            : 
    1017                 :            :   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    1018                 :            :   YYUSE (yytype);
    1019                 :            :   YY_IGNORE_MAYBE_UNINITIALIZED_END
    1020                 :          0 : }
    1021                 :            : 
    1022                 :            : 
    1023                 :            : 
    1024                 :            : 
    1025                 :            : /* The lookahead symbol.  */
    1026                 :            : int yychar;
    1027                 :            : 
    1028                 :            : /* The semantic value of the lookahead symbol.  */
    1029                 :            : YYSTYPE yylval;
    1030                 :            : /* Number of syntax errors so far.  */
    1031                 :            : int yynerrs;
    1032                 :            : 
    1033                 :            : 
    1034                 :            : /*----------.
    1035                 :            : | yyparse.  |
    1036                 :            : `----------*/
    1037                 :            : 
    1038                 :            : int
    1039                 :          0 : yyparse (void)
    1040                 :            : {
    1041                 :            :     int yystate;
    1042                 :            :     /* Number of tokens to shift before error messages enabled.  */
    1043                 :            :     int yyerrstatus;
    1044                 :            : 
    1045                 :            :     /* The stacks and their tools:
    1046                 :            :        'yyss': related to states.
    1047                 :            :        'yyvs': related to semantic values.
    1048                 :            : 
    1049                 :            :        Refer to the stacks through separate pointers, to allow yyoverflow
    1050                 :            :        to reallocate them elsewhere.  */
    1051                 :            : 
    1052                 :            :     /* The state stack.  */
    1053                 :            :     yytype_int16 yyssa[YYINITDEPTH];
    1054                 :            :     yytype_int16 *yyss;
    1055                 :            :     yytype_int16 *yyssp;
    1056                 :            : 
    1057                 :            :     /* The semantic value stack.  */
    1058                 :            :     YYSTYPE yyvsa[YYINITDEPTH];
    1059                 :            :     YYSTYPE *yyvs;
    1060                 :            :     YYSTYPE *yyvsp;
    1061                 :            : 
    1062                 :            :     YYSIZE_T yystacksize;
    1063                 :            : 
    1064                 :            :   int yyn;
    1065                 :            :   int yyresult;
    1066                 :            :   /* Lookahead token as an internal (translated) token number.  */
    1067                 :          0 :   int yytoken = 0;
    1068                 :            :   /* The variables used to return semantic value and location from the
    1069                 :            :      action routines.  */
    1070                 :            :   YYSTYPE yyval;
    1071                 :            : 
    1072                 :            : #if YYERROR_VERBOSE
    1073                 :            :   /* Buffer for error messages, and its allocated size.  */
    1074                 :            :   char yymsgbuf[128];
    1075                 :          0 :   char *yymsg = yymsgbuf;
    1076                 :          0 :   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
    1077                 :            : #endif
    1078                 :            : 
    1079                 :            : #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
    1080                 :            : 
    1081                 :            :   /* The number of symbols on the RHS of the reduced rule.
    1082                 :            :      Keep to zero when no symbol should be popped.  */
    1083                 :          0 :   int yylen = 0;
    1084                 :            : 
    1085                 :          0 :   yyssp = yyss = yyssa;
    1086                 :          0 :   yyvsp = yyvs = yyvsa;
    1087                 :          0 :   yystacksize = YYINITDEPTH;
    1088                 :            : 
    1089 [ #  # ][ #  # ]:          0 :   YYDPRINTF ((stderr, "Starting parse\n"));
    1090                 :            : 
    1091                 :          0 :   yystate = 0;
    1092                 :          0 :   yyerrstatus = 0;
    1093                 :          0 :   yynerrs = 0;
    1094                 :          0 :   yychar = YYEMPTY; /* Cause a token to be read.  */
    1095                 :          0 :   goto yysetstate;
    1096                 :            : 
    1097                 :            : /*------------------------------------------------------------.
    1098                 :            : | yynewstate -- Push a new state, which is found in yystate.  |
    1099                 :            : `------------------------------------------------------------*/
    1100                 :            :  yynewstate:
    1101                 :            :   /* In all cases, when you get here, the value and location stacks
    1102                 :            :      have just been pushed.  So pushing a state here evens the stacks.  */
    1103                 :          0 :   yyssp++;
    1104                 :            : 
    1105                 :            :  yysetstate:
    1106                 :          0 :   *yyssp = yystate;
    1107                 :            : 
    1108         [ #  # ]:          0 :   if (yyss + yystacksize - 1 <= yyssp)
    1109                 :            :     {
    1110                 :            :       /* Get the current used size of the three stacks, in elements.  */
    1111                 :          0 :       YYSIZE_T yysize = yyssp - yyss + 1;
    1112                 :            : 
    1113                 :            : #ifdef yyoverflow
    1114                 :            :       {
    1115                 :            :         /* Give user a chance to reallocate the stack.  Use copies of
    1116                 :            :            these so that the &'s don't force the real ones into
    1117                 :            :            memory.  */
    1118                 :            :         YYSTYPE *yyvs1 = yyvs;
    1119                 :            :         yytype_int16 *yyss1 = yyss;
    1120                 :            : 
    1121                 :            :         /* Each stack pointer address is followed by the size of the
    1122                 :            :            data in use in that stack, in bytes.  This used to be a
    1123                 :            :            conditional around just the two extra args, but that might
    1124                 :            :            be undefined if yyoverflow is a macro.  */
    1125                 :            :         yyoverflow (YY_("memory exhausted"),
    1126                 :            :                     &yyss1, yysize * sizeof (*yyssp),
    1127                 :            :                     &yyvs1, yysize * sizeof (*yyvsp),
    1128                 :            :                     &yystacksize);
    1129                 :            : 
    1130                 :            :         yyss = yyss1;
    1131                 :            :         yyvs = yyvs1;
    1132                 :            :       }
    1133                 :            : #else /* no yyoverflow */
    1134                 :            : # ifndef YYSTACK_RELOCATE
    1135                 :            :       goto yyexhaustedlab;
    1136                 :            : # else
    1137                 :            :       /* Extend the stack our own way.  */
    1138         [ #  # ]:          0 :       if (YYMAXDEPTH <= yystacksize)
    1139                 :          0 :         goto yyexhaustedlab;
    1140                 :          0 :       yystacksize *= 2;
    1141         [ #  # ]:          0 :       if (YYMAXDEPTH < yystacksize)
    1142                 :          0 :         yystacksize = YYMAXDEPTH;
    1143                 :            : 
    1144                 :            :       {
    1145                 :          0 :         yytype_int16 *yyss1 = yyss;
    1146                 :            :         union yyalloc *yyptr =
    1147                 :          0 :           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
    1148         [ #  # ]:          0 :         if (! yyptr)
    1149                 :          0 :           goto yyexhaustedlab;
    1150                 :          0 :         YYSTACK_RELOCATE (yyss_alloc, yyss);
    1151                 :          0 :         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
    1152                 :            : #  undef YYSTACK_RELOCATE
    1153         [ #  # ]:          0 :         if (yyss1 != yyssa)
    1154                 :          0 :           YYSTACK_FREE (yyss1);
    1155                 :            :       }
    1156                 :            : # endif
    1157                 :            : #endif /* no yyoverflow */
    1158                 :            : 
    1159                 :          0 :       yyssp = yyss + yysize - 1;
    1160                 :          0 :       yyvsp = yyvs + yysize - 1;
    1161                 :            : 
    1162 [ #  # ][ #  # ]:          0 :       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
    1163                 :            :                   (unsigned long int) yystacksize));
    1164                 :            : 
    1165         [ #  # ]:          0 :       if (yyss + yystacksize - 1 <= yyssp)
    1166                 :          0 :         YYABORT;
    1167                 :            :     }
    1168                 :            : 
    1169 [ #  # ][ #  # ]:          0 :   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
    1170                 :            : 
    1171         [ #  # ]:          0 :   if (yystate == YYFINAL)
    1172                 :          0 :     YYACCEPT;
    1173                 :            : 
    1174                 :          0 :   goto yybackup;
    1175                 :            : 
    1176                 :            : /*-----------.
    1177                 :            : | yybackup.  |
    1178                 :            : `-----------*/
    1179                 :            : yybackup:
    1180                 :            : 
    1181                 :            :   /* Do appropriate processing given the current state.  Read a
    1182                 :            :      lookahead token if we need one and don't already have one.  */
    1183                 :            : 
    1184                 :            :   /* First try to decide what to do without reference to lookahead token.  */
    1185                 :          0 :   yyn = yypact[yystate];
    1186         [ #  # ]:          0 :   if (yypact_value_is_default (yyn))
    1187                 :          0 :     goto yydefault;
    1188                 :            : 
    1189                 :            :   /* Not known => get a lookahead token if don't already have one.  */
    1190                 :            : 
    1191                 :            :   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
    1192         [ #  # ]:          0 :   if (yychar == YYEMPTY)
    1193                 :            :     {
    1194 [ #  # ][ #  # ]:          0 :       YYDPRINTF ((stderr, "Reading a token: "));
    1195         [ #  # ]:          0 :       yychar = yylex ();
    1196                 :            :     }
    1197                 :            : 
    1198         [ #  # ]:          0 :   if (yychar <= YYEOF)
    1199                 :            :     {
    1200                 :          0 :       yychar = yytoken = YYEOF;
    1201 [ #  # ][ #  # ]:          0 :       YYDPRINTF ((stderr, "Now at end of input.\n"));
    1202                 :            :     }
    1203                 :            :   else
    1204                 :            :     {
    1205         [ #  # ]:          0 :       yytoken = YYTRANSLATE (yychar);
    1206 [ #  # ][ #  # ]:          0 :       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
         [ #  # ][ #  # ]
    1207                 :            :     }
    1208                 :            : 
    1209                 :            :   /* If the proper action on seeing token YYTOKEN is to reduce or to
    1210                 :            :      detect an error, take that action.  */
    1211                 :          0 :   yyn += yytoken;
    1212 [ #  # ][ #  # ]:          0 :   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
                 [ #  # ]
    1213                 :            :     goto yydefault;
    1214                 :          0 :   yyn = yytable[yyn];
    1215         [ #  # ]:          0 :   if (yyn <= 0)
    1216                 :            :     {
    1217                 :            :       if (yytable_value_is_error (yyn))
    1218                 :            :         goto yyerrlab;
    1219                 :          0 :       yyn = -yyn;
    1220                 :          0 :       goto yyreduce;
    1221                 :            :     }
    1222                 :            : 
    1223                 :            :   /* Count tokens shifted since error; after three, turn off error
    1224                 :            :      status.  */
    1225         [ #  # ]:          0 :   if (yyerrstatus)
    1226                 :          0 :     yyerrstatus--;
    1227                 :            : 
    1228                 :            :   /* Shift the lookahead token.  */
    1229 [ #  # ][ #  # ]:          0 :   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
         [ #  # ][ #  # ]
    1230                 :            : 
    1231                 :            :   /* Discard the shifted token.  */
    1232                 :          0 :   yychar = YYEMPTY;
    1233                 :            : 
    1234                 :          0 :   yystate = yyn;
    1235                 :            :   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    1236                 :          0 :   *++yyvsp = yylval;
    1237                 :            :   YY_IGNORE_MAYBE_UNINITIALIZED_END
    1238                 :            : 
    1239                 :          0 :   goto yynewstate;
    1240                 :            : 
    1241                 :            : 
    1242                 :            : /*-----------------------------------------------------------.
    1243                 :            : | yydefault -- do the default action for the current state.  |
    1244                 :            : `-----------------------------------------------------------*/
    1245                 :            : yydefault:
    1246                 :          0 :   yyn = yydefact[yystate];
    1247         [ #  # ]:          0 :   if (yyn == 0)
    1248                 :          0 :     goto yyerrlab;
    1249                 :          0 :   goto yyreduce;
    1250                 :            : 
    1251                 :            : 
    1252                 :            : /*-----------------------------.
    1253                 :            : | yyreduce -- Do a reduction.  |
    1254                 :            : `-----------------------------*/
    1255                 :            : yyreduce:
    1256                 :            :   /* yyn is the number of a rule to reduce with.  */
    1257                 :          0 :   yylen = yyr2[yyn];
    1258                 :            : 
    1259                 :            :   /* If YYLEN is nonzero, implement the default value of the action:
    1260                 :            :      '$$ = $1'.
    1261                 :            : 
    1262                 :            :      Otherwise, the following line sets YYVAL to garbage.
    1263                 :            :      This behavior is undocumented and Bison
    1264                 :            :      users should not rely upon it.  Assigning to YYVAL
    1265                 :            :      unconditionally makes the parser a bit smaller, and it avoids a
    1266                 :            :      GCC warning that YYVAL may be used uninitialized.  */
    1267                 :          0 :   yyval = yyvsp[1-yylen];
    1268                 :            : 
    1269                 :            : 
    1270 [ #  # ][ #  # ]:          0 :   YY_REDUCE_PRINT (yyn);
    1271   [ #  #  #  #  :          0 :   switch (yyn)
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1272                 :            :     {
    1273                 :            :         case 2:
    1274                 :            : #line 74 "parse_touchstone.y" /* yacc.c:1661  */
    1275                 :            :     { /* describes a valid touchstone */ }
    1276                 :            : #line 1277 "parse_touchstone.cpp" /* yacc.c:1661  */
    1277                 :          0 :     break;
    1278                 :            : 
    1279                 :            :   case 3:
    1280                 :            : #line 78 "parse_touchstone.y" /* yacc.c:1661  */
    1281                 :            :     {
    1282                 :            :     touchstone_vector = NULL;
    1283                 :            :     touchstone_options.resistance = (yyvsp[-2].f);
    1284                 :            :   }
    1285                 :            : #line 1286 "parse_touchstone.cpp" /* yacc.c:1661  */
    1286                 :          0 :     break;
    1287                 :            : 
    1288                 :            :   case 4:
    1289                 :            : #line 82 "parse_touchstone.y" /* yacc.c:1661  */
    1290                 :            :     {
    1291                 :            :     touchstone_vector = NULL;
    1292                 :            :     touchstone_options.resistance = 50.0;
    1293                 :            :   }
    1294                 :            : #line 1295 "parse_touchstone.cpp" /* yacc.c:1661  */
    1295                 :          0 :     break;
    1296                 :            : 
    1297                 :            :   case 5:
    1298                 :            : #line 86 "parse_touchstone.y" /* yacc.c:1661  */
    1299                 :            :     { /* skip this line */ }
    1300                 :            : #line 1301 "parse_touchstone.cpp" /* yacc.c:1661  */
    1301                 :          0 :     break;
    1302                 :            : 
    1303                 :            :   case 6:
    1304                 :            : #line 89 "parse_touchstone.y" /* yacc.c:1661  */
    1305                 :            :     { }
    1306                 :            : #line 1307 "parse_touchstone.cpp" /* yacc.c:1661  */
    1307                 :          0 :     break;
    1308                 :            : 
    1309                 :            :   case 7:
    1310                 :            : #line 90 "parse_touchstone.y" /* yacc.c:1661  */
    1311                 :            :     {
    1312                 :            :     if (touchstone_idents == NULL) touchstone_idents = new strlist ();
    1313                 :            :     touchstone_idents->add ((yyvsp[-1].ident));
    1314                 :            :     free ((yyvsp[-1].ident));
    1315                 :            :   }
    1316                 :            : #line 1317 "parse_touchstone.cpp" /* yacc.c:1661  */
    1317                 :          0 :     break;
    1318                 :            : 
    1319                 :            :   case 8:
    1320                 :            : #line 97 "parse_touchstone.y" /* yacc.c:1661  */
    1321                 :            :     { }
    1322                 :            : #line 1323 "parse_touchstone.cpp" /* yacc.c:1661  */
    1323                 :          0 :     break;
    1324                 :            : 
    1325                 :            :   case 9:
    1326                 :            : #line 98 "parse_touchstone.y" /* yacc.c:1661  */
    1327                 :            :     { /* append vector lines */
    1328                 :            :     (yyvsp[-2].v)->setNext (touchstone_vector);
    1329                 :            :     touchstone_vector = (yyvsp[-2].v);
    1330                 :            :   }
    1331                 :            : #line 1332 "parse_touchstone.cpp" /* yacc.c:1661  */
    1332                 :          0 :     break;
    1333                 :            : 
    1334                 :            :   case 10:
    1335                 :            : #line 102 "parse_touchstone.y" /* yacc.c:1661  */
    1336                 :            :     { /* last line, no trailing end-of-line */
    1337                 :            :     (yyvsp[0].v)->setNext (touchstone_vector);
    1338                 :            :     touchstone_vector = (yyvsp[0].v);
    1339                 :            :     logprint (LOG_ERROR, "line %d: no trailing end-of-line found, "
    1340                 :            :               "continuing...\n", touchstone_lineno);
    1341                 :            :   }
    1342                 :            : #line 1343 "parse_touchstone.cpp" /* yacc.c:1661  */
    1343                 :          0 :     break;
    1344                 :            : 
    1345                 :            :   case 11:
    1346                 :            : #line 108 "parse_touchstone.y" /* yacc.c:1661  */
    1347                 :            :     { /* skip this line */ }
    1348                 :            : #line 1349 "parse_touchstone.cpp" /* yacc.c:1661  */
    1349                 :          0 :     break;
    1350                 :            : 
    1351                 :            :   case 12:
    1352                 :            : #line 112 "parse_touchstone.y" /* yacc.c:1661  */
    1353                 :            :     {
    1354                 :            :     /* 1-port start */
    1355                 :            :     (yyval.v) = new vector ();
    1356                 :            :     (yyval.v)->add ((yyvsp[-2].f));
    1357                 :            :     (yyval.v)->add ((yyvsp[-1].f));
    1358                 :            :     (yyval.v)->add ((yyvsp[0].f));
    1359                 :            :   }
    1360                 :            : #line 1361 "parse_touchstone.cpp" /* yacc.c:1661  */
    1361                 :          0 :     break;
    1362                 :            : 
    1363                 :            :   case 13:
    1364                 :            : #line 119 "parse_touchstone.y" /* yacc.c:1661  */
    1365                 :            :     {
    1366                 :            :     /* noise parameters */
    1367                 :            :     (yyval.v) = new vector ();
    1368                 :            :     (yyval.v)->add ((yyvsp[-4].f));
    1369                 :            :     (yyval.v)->add ((yyvsp[-3].f));
    1370                 :            :     (yyval.v)->add ((yyvsp[-2].f));
    1371                 :            :     (yyval.v)->add ((yyvsp[-1].f));
    1372                 :            :     (yyval.v)->add ((yyvsp[0].f));
    1373                 :            :   }
    1374                 :            : #line 1375 "parse_touchstone.cpp" /* yacc.c:1661  */
    1375                 :          0 :     break;
    1376                 :            : 
    1377                 :            :   case 14:
    1378                 :            : #line 128 "parse_touchstone.y" /* yacc.c:1661  */
    1379                 :            :     {
    1380                 :            :     /* 2-port and 4- to n-port start */
    1381                 :            :     (yyval.v) = new vector ();
    1382                 :            :     (yyval.v)->add ((yyvsp[-8].f));
    1383                 :            :     (yyval.v)->add ((yyvsp[-7].f));
    1384                 :            :     (yyval.v)->add ((yyvsp[-6].f));
    1385                 :            :     (yyval.v)->add ((yyvsp[-5].f));
    1386                 :            :     (yyval.v)->add ((yyvsp[-4].f));
    1387                 :            :     (yyval.v)->add ((yyvsp[-3].f));
    1388                 :            :     (yyval.v)->add ((yyvsp[-2].f));
    1389                 :            :     (yyval.v)->add ((yyvsp[-1].f));
    1390                 :            :     (yyval.v)->add ((yyvsp[0].f));
    1391                 :            :   }
    1392                 :            : #line 1393 "parse_touchstone.cpp" /* yacc.c:1661  */
    1393                 :          0 :     break;
    1394                 :            : 
    1395                 :            :   case 15:
    1396                 :            : #line 141 "parse_touchstone.y" /* yacc.c:1661  */
    1397                 :            :     {
    1398                 :            :     /* 3-port start */
    1399                 :            :     (yyval.v) = new vector ();
    1400                 :            :     (yyval.v)->add ((yyvsp[-6].f));
    1401                 :            :     (yyval.v)->add ((yyvsp[-5].f));
    1402                 :            :     (yyval.v)->add ((yyvsp[-4].f));
    1403                 :            :     (yyval.v)->add ((yyvsp[-3].f));
    1404                 :            :     (yyval.v)->add ((yyvsp[-2].f));
    1405                 :            :     (yyval.v)->add ((yyvsp[-1].f));
    1406                 :            :     (yyval.v)->add ((yyvsp[0].f));
    1407                 :            :   }
    1408                 :            : #line 1409 "parse_touchstone.cpp" /* yacc.c:1661  */
    1409                 :          0 :     break;
    1410                 :            : 
    1411                 :            :   case 16:
    1412                 :            : #line 152 "parse_touchstone.y" /* yacc.c:1661  */
    1413                 :            :     {
    1414                 :            :     /* 4- and n-port continued */
    1415                 :            :     (yyval.v) = new vector ();
    1416                 :            :     (yyval.v)->add ((yyvsp[-7].f));
    1417                 :            :     (yyval.v)->add ((yyvsp[-6].f));
    1418                 :            :     (yyval.v)->add ((yyvsp[-5].f));
    1419                 :            :     (yyval.v)->add ((yyvsp[-4].f));
    1420                 :            :     (yyval.v)->add ((yyvsp[-3].f));
    1421                 :            :     (yyval.v)->add ((yyvsp[-2].f));
    1422                 :            :     (yyval.v)->add ((yyvsp[-1].f));
    1423                 :            :     (yyval.v)->add ((yyvsp[0].f));
    1424                 :            :   }
    1425                 :            : #line 1426 "parse_touchstone.cpp" /* yacc.c:1661  */
    1426                 :          0 :     break;
    1427                 :            : 
    1428                 :            :   case 17:
    1429                 :            : #line 164 "parse_touchstone.y" /* yacc.c:1661  */
    1430                 :            :     {
    1431                 :            :     /* 3- and n-port continued */
    1432                 :            :     (yyval.v) = new vector ();
    1433                 :            :     (yyval.v)->add ((yyvsp[-5].f));
    1434                 :            :     (yyval.v)->add ((yyvsp[-4].f));
    1435                 :            :     (yyval.v)->add ((yyvsp[-3].f));
    1436                 :            :     (yyval.v)->add ((yyvsp[-2].f));
    1437                 :            :     (yyval.v)->add ((yyvsp[-1].f));
    1438                 :            :     (yyval.v)->add ((yyvsp[0].f));
    1439                 :            :   }
    1440                 :            : #line 1441 "parse_touchstone.cpp" /* yacc.c:1661  */
    1441                 :          0 :     break;
    1442                 :            : 
    1443                 :            :   case 18:
    1444                 :            : #line 174 "parse_touchstone.y" /* yacc.c:1661  */
    1445                 :            :     {
    1446                 :            :     /* n-port continued */
    1447                 :            :     (yyval.v) = new vector ();
    1448                 :            :     (yyval.v)->add ((yyvsp[-3].f));
    1449                 :            :     (yyval.v)->add ((yyvsp[-2].f));
    1450                 :            :     (yyval.v)->add ((yyvsp[-1].f));
    1451                 :            :     (yyval.v)->add ((yyvsp[0].f));
    1452                 :            :   }
    1453                 :            : #line 1454 "parse_touchstone.cpp" /* yacc.c:1661  */
    1454                 :          0 :     break;
    1455                 :            : 
    1456                 :            :   case 19:
    1457                 :            : #line 182 "parse_touchstone.y" /* yacc.c:1661  */
    1458                 :            :     {
    1459                 :            :     /* n-port continued */
    1460                 :            :     (yyval.v) = new vector ();
    1461                 :            :     (yyval.v)->add ((yyvsp[-1].f));
    1462                 :            :     (yyval.v)->add ((yyvsp[0].f));
    1463                 :            :   }
    1464                 :            : #line 1465 "parse_touchstone.cpp" /* yacc.c:1661  */
    1465                 :          0 :     break;
    1466                 :            : 
    1467                 :            : 
    1468                 :            : #line 1469 "parse_touchstone.cpp" /* yacc.c:1661  */
    1469                 :          0 :       default: break;
    1470                 :            :     }
    1471                 :            :   /* User semantic actions sometimes alter yychar, and that requires
    1472                 :            :      that yytoken be updated with the new translation.  We take the
    1473                 :            :      approach of translating immediately before every use of yytoken.
    1474                 :            :      One alternative is translating here after every semantic action,
    1475                 :            :      but that translation would be missed if the semantic action invokes
    1476                 :            :      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
    1477                 :            :      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
    1478                 :            :      incorrect destructor might then be invoked immediately.  In the
    1479                 :            :      case of YYERROR or YYBACKUP, subsequent parser actions might lead
    1480                 :            :      to an incorrect destructor call or verbose syntax error message
    1481                 :            :      before the lookahead is translated.  */
    1482 [ #  # ][ #  # ]:          0 :   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
         [ #  # ][ #  # ]
    1483                 :            : 
    1484                 :          0 :   YYPOPSTACK (yylen);
    1485                 :          0 :   yylen = 0;
    1486 [ #  # ][ #  # ]:          0 :   YY_STACK_PRINT (yyss, yyssp);
    1487                 :            : 
    1488                 :          0 :   *++yyvsp = yyval;
    1489                 :            : 
    1490                 :            :   /* Now 'shift' the result of the reduction.  Determine what state
    1491                 :            :      that goes to, based on the state we popped back to and the rule
    1492                 :            :      number reduced by.  */
    1493                 :            : 
    1494                 :          0 :   yyn = yyr1[yyn];
    1495                 :            : 
    1496                 :          0 :   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
    1497 [ #  # ][ #  # ]:          0 :   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
                 [ #  # ]
    1498                 :          0 :     yystate = yytable[yystate];
    1499                 :            :   else
    1500                 :          0 :     yystate = yydefgoto[yyn - YYNTOKENS];
    1501                 :            : 
    1502                 :          0 :   goto yynewstate;
    1503                 :            : 
    1504                 :            : 
    1505                 :            : /*--------------------------------------.
    1506                 :            : | yyerrlab -- here on detecting error.  |
    1507                 :            : `--------------------------------------*/
    1508                 :            : yyerrlab:
    1509                 :            :   /* Make sure we have latest lookahead translation.  See comments at
    1510                 :            :      user semantic actions for why this is necessary.  */
    1511 [ #  # ][ #  # ]:          0 :   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
    1512                 :            : 
    1513                 :            :   /* If not already recovering from an error, report this error.  */
    1514         [ #  # ]:          0 :   if (!yyerrstatus)
    1515                 :            :     {
    1516                 :          0 :       ++yynerrs;
    1517                 :            : #if ! YYERROR_VERBOSE
    1518                 :            :       yyerror (YY_("syntax error"));
    1519                 :            : #else
    1520                 :            : # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
    1521                 :            :                                         yyssp, yytoken)
    1522                 :            :       {
    1523                 :          0 :         char const *yymsgp = YY_("syntax error");
    1524                 :            :         int yysyntax_error_status;
    1525                 :          0 :         yysyntax_error_status = YYSYNTAX_ERROR;
    1526         [ #  # ]:          0 :         if (yysyntax_error_status == 0)
    1527                 :          0 :           yymsgp = yymsg;
    1528         [ #  # ]:          0 :         else if (yysyntax_error_status == 1)
    1529                 :            :           {
    1530         [ #  # ]:          0 :             if (yymsg != yymsgbuf)
    1531                 :          0 :               YYSTACK_FREE (yymsg);
    1532                 :          0 :             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
    1533         [ #  # ]:          0 :             if (!yymsg)
    1534                 :            :               {
    1535                 :          0 :                 yymsg = yymsgbuf;
    1536                 :          0 :                 yymsg_alloc = sizeof yymsgbuf;
    1537                 :          0 :                 yysyntax_error_status = 2;
    1538                 :            :               }
    1539                 :            :             else
    1540                 :            :               {
    1541                 :          0 :                 yysyntax_error_status = YYSYNTAX_ERROR;
    1542                 :          0 :                 yymsgp = yymsg;
    1543                 :            :               }
    1544                 :            :           }
    1545         [ #  # ]:          0 :         yyerror (yymsgp);
    1546         [ #  # ]:          0 :         if (yysyntax_error_status == 2)
    1547                 :          0 :           goto yyexhaustedlab;
    1548                 :            :       }
    1549                 :            : # undef YYSYNTAX_ERROR
    1550                 :            : #endif
    1551                 :            :     }
    1552                 :            : 
    1553                 :            : 
    1554                 :            : 
    1555         [ #  # ]:          0 :   if (yyerrstatus == 3)
    1556                 :            :     {
    1557                 :            :       /* If just tried and failed to reuse lookahead token after an
    1558                 :            :          error, discard it.  */
    1559                 :            : 
    1560         [ #  # ]:          0 :       if (yychar <= YYEOF)
    1561                 :            :         {
    1562                 :            :           /* Return failure if at end of input.  */
    1563         [ #  # ]:          0 :           if (yychar == YYEOF)
    1564                 :          0 :             YYABORT;
    1565                 :            :         }
    1566                 :            :       else
    1567                 :            :         {
    1568                 :            :           yydestruct ("Error: discarding",
    1569         [ #  # ]:          0 :                       yytoken, &yylval);
    1570                 :          0 :           yychar = YYEMPTY;
    1571                 :            :         }
    1572                 :            :     }
    1573                 :            : 
    1574                 :            :   /* Else will try to reuse lookahead token after shifting the error
    1575                 :            :      token.  */
    1576                 :          0 :   goto yyerrlab1;
    1577                 :            : 
    1578                 :            : 
    1579                 :            : /*---------------------------------------------------.
    1580                 :            : | yyerrorlab -- error raised explicitly by YYERROR.  |
    1581                 :            : `---------------------------------------------------*/
    1582                 :            : yyerrorlab:
    1583                 :            : 
    1584                 :            :   /* Pacify compilers like GCC when the user code never invokes
    1585                 :            :      YYERROR and the label yyerrorlab therefore never appears in user
    1586                 :            :      code.  */
    1587                 :            :   if (/*CONSTCOND*/ 0)
    1588                 :            :      goto yyerrorlab;
    1589                 :            : 
    1590                 :            :   /* Do not reclaim the symbols of the rule whose action triggered
    1591                 :            :      this YYERROR.  */
    1592                 :            :   YYPOPSTACK (yylen);
    1593                 :            :   yylen = 0;
    1594                 :            :   YY_STACK_PRINT (yyss, yyssp);
    1595                 :            :   yystate = *yyssp;
    1596                 :            :   goto yyerrlab1;
    1597                 :            : 
    1598                 :            : 
    1599                 :            : /*-------------------------------------------------------------.
    1600                 :            : | yyerrlab1 -- common code for both syntax error and YYERROR.  |
    1601                 :            : `-------------------------------------------------------------*/
    1602                 :            : yyerrlab1:
    1603                 :          0 :   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
    1604                 :            : 
    1605                 :          0 :   for (;;)
    1606                 :            :     {
    1607                 :          0 :       yyn = yypact[yystate];
    1608         [ #  # ]:          0 :       if (!yypact_value_is_default (yyn))
    1609                 :            :         {
    1610                 :          0 :           yyn += YYTERROR;
    1611 [ #  # ][ #  # ]:          0 :           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
                 [ #  # ]
    1612                 :            :             {
    1613                 :          0 :               yyn = yytable[yyn];
    1614         [ #  # ]:          0 :               if (0 < yyn)
    1615                 :          0 :                 break;
    1616                 :            :             }
    1617                 :            :         }
    1618                 :            : 
    1619                 :            :       /* Pop the current state because it cannot handle the error token.  */
    1620         [ #  # ]:          0 :       if (yyssp == yyss)
    1621                 :          0 :         YYABORT;
    1622                 :            : 
    1623                 :            : 
    1624                 :            :       yydestruct ("Error: popping",
    1625         [ #  # ]:          0 :                   yystos[yystate], yyvsp);
    1626                 :          0 :       YYPOPSTACK (1);
    1627                 :          0 :       yystate = *yyssp;
    1628 [ #  # ][ #  # ]:          0 :       YY_STACK_PRINT (yyss, yyssp);
    1629                 :            :     }
    1630                 :            : 
    1631                 :            :   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    1632                 :          0 :   *++yyvsp = yylval;
    1633                 :            :   YY_IGNORE_MAYBE_UNINITIALIZED_END
    1634                 :            : 
    1635                 :            : 
    1636                 :            :   /* Shift the error token.  */
    1637 [ #  # ][ #  # ]:          0 :   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
         [ #  # ][ #  # ]
    1638                 :            : 
    1639                 :          0 :   yystate = yyn;
    1640                 :          0 :   goto yynewstate;
    1641                 :            : 
    1642                 :            : 
    1643                 :            : /*-------------------------------------.
    1644                 :            : | yyacceptlab -- YYACCEPT comes here.  |
    1645                 :            : `-------------------------------------*/
    1646                 :            : yyacceptlab:
    1647                 :          0 :   yyresult = 0;
    1648                 :          0 :   goto yyreturn;
    1649                 :            : 
    1650                 :            : /*-----------------------------------.
    1651                 :            : | yyabortlab -- YYABORT comes here.  |
    1652                 :            : `-----------------------------------*/
    1653                 :            : yyabortlab:
    1654                 :          0 :   yyresult = 1;
    1655                 :          0 :   goto yyreturn;
    1656                 :            : 
    1657                 :            : #if !defined yyoverflow || YYERROR_VERBOSE
    1658                 :            : /*-------------------------------------------------.
    1659                 :            : | yyexhaustedlab -- memory exhaustion comes here.  |
    1660                 :            : `-------------------------------------------------*/
    1661                 :            : yyexhaustedlab:
    1662         [ #  # ]:          0 :   yyerror (YY_("memory exhausted"));
    1663                 :          0 :   yyresult = 2;
    1664                 :            :   /* Fall through.  */
    1665                 :            : #endif
    1666                 :            : 
    1667                 :            : yyreturn:
    1668         [ #  # ]:          0 :   if (yychar != YYEMPTY)
    1669                 :            :     {
    1670                 :            :       /* Make sure we have latest lookahead translation.  See comments at
    1671                 :            :          user semantic actions for why this is necessary.  */
    1672         [ #  # ]:          0 :       yytoken = YYTRANSLATE (yychar);
    1673                 :            :       yydestruct ("Cleanup: discarding lookahead",
    1674         [ #  # ]:          0 :                   yytoken, &yylval);
    1675                 :            :     }
    1676                 :            :   /* Do not reclaim the symbols of the rule whose action triggered
    1677                 :            :      this YYABORT or YYACCEPT.  */
    1678                 :          0 :   YYPOPSTACK (yylen);
    1679 [ #  # ][ #  # ]:          0 :   YY_STACK_PRINT (yyss, yyssp);
    1680         [ #  # ]:          0 :   while (yyssp != yyss)
    1681                 :            :     {
    1682                 :            :       yydestruct ("Cleanup: popping",
    1683         [ #  # ]:          0 :                   yystos[*yyssp], yyvsp);
    1684                 :          0 :       YYPOPSTACK (1);
    1685                 :            :     }
    1686                 :            : #ifndef yyoverflow
    1687         [ #  # ]:          0 :   if (yyss != yyssa)
    1688                 :          0 :     YYSTACK_FREE (yyss);
    1689                 :            : #endif
    1690                 :            : #if YYERROR_VERBOSE
    1691         [ #  # ]:          0 :   if (yymsg != yymsgbuf)
    1692                 :          0 :     YYSTACK_FREE (yymsg);
    1693                 :            : #endif
    1694                 :          0 :   return yyresult;
    1695                 :            : }
    1696                 :            : #line 190 "parse_touchstone.y" /* yacc.c:1906  */
    1697                 :            : 
    1698                 :            : 
    1699                 :            : int touchstone_error (const char * error) {
    1700                 :            :   logprint (LOG_ERROR, "line %d: %s\n", touchstone_lineno, error);
    1701                 :            :   return 0;
    1702                 :            : }

Generated by: LCOV version 1.11