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 netlist_parse
64 : : #define yylex netlist_lex
65 : : #define yyerror netlist_error
66 : : #define yydebug netlist_debug
67 : : #define yynerrs netlist_nerrs
68 : :
69 : : #define yylval netlist_lval
70 : : #define yychar netlist_char
71 : :
72 : : /* Copy the first part of user declarations. */
73 : : #line 3 "parse_netlist.y" /* yacc.c:339 */
74 : :
75 : : /*
76 : : * parse_netlist.y - parser for the Qucs netlist
77 : : *
78 : : * Copyright (C) 2003, 2004, 2005, 2006, 2007 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 "check_netlist.h"
112 : : #include "logging.h"
113 : : #include "equation.h"
114 : : #include "range.h"
115 : :
116 : : using namespace qucs;
117 : :
118 : :
119 : : #line 120 "parse_netlist.cpp" /* yacc.c:339 */
120 : :
121 : : # ifndef YY_NULLPTR
122 : : # if defined __cplusplus && 201103L <= __cplusplus
123 : : # define YY_NULLPTR nullptr
124 : : # else
125 : : # define YY_NULLPTR 0
126 : : # endif
127 : : # endif
128 : :
129 : : /* Enabling verbose error messages. */
130 : : #ifdef YYERROR_VERBOSE
131 : : # undef YYERROR_VERBOSE
132 : : # define YYERROR_VERBOSE 1
133 : : #else
134 : : # define YYERROR_VERBOSE 0
135 : : #endif
136 : :
137 : : /* In a future release of Bison, this section will be replaced
138 : : by #include "tokens_netlist.h". */
139 : : #ifndef YY_NETLIST_TOKENS_NETLIST_H_INCLUDED
140 : : # define YY_NETLIST_TOKENS_NETLIST_H_INCLUDED
141 : : /* Debug traces. */
142 : : #ifndef YYDEBUG
143 : : # define YYDEBUG 0
144 : : #endif
145 : : #if YYDEBUG
146 : : extern int netlist_debug;
147 : : #endif
148 : :
149 : : /* Token type. */
150 : : #ifndef YYTOKENTYPE
151 : : # define YYTOKENTYPE
152 : : enum yytokentype
153 : : {
154 : : InvalidCharacter = 258,
155 : : Identifier = 259,
156 : : Assign = 260,
157 : : ScaleOrUnit = 261,
158 : : Eol = 262,
159 : : Eqn = 263,
160 : : DefSub = 264,
161 : : EndSub = 265,
162 : : REAL = 266,
163 : : IMAG = 267,
164 : : COMPLEX = 268,
165 : : Character = 269,
166 : : STRING = 270,
167 : : Or = 271,
168 : : And = 272,
169 : : NotEqual = 273,
170 : : Equal = 274,
171 : : Less = 275,
172 : : Greater = 276,
173 : : LessOrEqual = 277,
174 : : GreaterOrEqual = 278,
175 : : Not = 279,
176 : : NEG = 280,
177 : : POS = 281
178 : : };
179 : : #endif
180 : : /* Tokens. */
181 : : #define InvalidCharacter 258
182 : : #define Identifier 259
183 : : #define Assign 260
184 : : #define ScaleOrUnit 261
185 : : #define Eol 262
186 : : #define Eqn 263
187 : : #define DefSub 264
188 : : #define EndSub 265
189 : : #define REAL 266
190 : : #define IMAG 267
191 : : #define COMPLEX 268
192 : : #define Character 269
193 : : #define STRING 270
194 : : #define Or 271
195 : : #define And 272
196 : : #define NotEqual 273
197 : : #define Equal 274
198 : : #define Less 275
199 : : #define Greater 276
200 : : #define LessOrEqual 277
201 : : #define GreaterOrEqual 278
202 : : #define Not 279
203 : : #define NEG 280
204 : : #define POS 281
205 : :
206 : : /* Value type. */
207 : : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
208 : : typedef union YYSTYPE YYSTYPE;
209 : : union YYSTYPE
210 : : {
211 : : #line 78 "parse_netlist.y" /* yacc.c:355 */
212 : :
213 : : char * ident;
214 : : char * str;
215 : : double d;
216 : : char chr;
217 : : struct definition_t * definition;
218 : : struct definition_t * subcircuit;
219 : : struct node_t * node;
220 : : struct pair_t * pair;
221 : : struct value_t * value;
222 : : struct {
223 : : double r;
224 : : double i;
225 : : } c;
226 : : qucs::eqn::node * eqn;
227 : : qucs::eqn::constant * con;
228 : : qucs::eqn::reference * ref;
229 : : qucs::eqn::application * app;
230 : : qucs::eqn::assignment * assign;
231 : :
232 : : #line 233 "parse_netlist.cpp" /* yacc.c:355 */
233 : : };
234 : : # define YYSTYPE_IS_TRIVIAL 1
235 : : # define YYSTYPE_IS_DECLARED 1
236 : : #endif
237 : :
238 : :
239 : : extern YYSTYPE netlist_lval;
240 : :
241 : : int netlist_parse (void);
242 : :
243 : : #endif /* !YY_NETLIST_TOKENS_NETLIST_H_INCLUDED */
244 : :
245 : : /* Copy the second part of user declarations. */
246 : :
247 : : #line 248 "parse_netlist.cpp" /* yacc.c:358 */
248 : :
249 : : #ifdef short
250 : : # undef short
251 : : #endif
252 : :
253 : : #ifdef YYTYPE_UINT8
254 : : typedef YYTYPE_UINT8 yytype_uint8;
255 : : #else
256 : : typedef unsigned char yytype_uint8;
257 : : #endif
258 : :
259 : : #ifdef YYTYPE_INT8
260 : : typedef YYTYPE_INT8 yytype_int8;
261 : : #else
262 : : typedef signed char yytype_int8;
263 : : #endif
264 : :
265 : : #ifdef YYTYPE_UINT16
266 : : typedef YYTYPE_UINT16 yytype_uint16;
267 : : #else
268 : : typedef unsigned short int yytype_uint16;
269 : : #endif
270 : :
271 : : #ifdef YYTYPE_INT16
272 : : typedef YYTYPE_INT16 yytype_int16;
273 : : #else
274 : : typedef short int yytype_int16;
275 : : #endif
276 : :
277 : : #ifndef YYSIZE_T
278 : : # ifdef __SIZE_TYPE__
279 : : # define YYSIZE_T __SIZE_TYPE__
280 : : # elif defined size_t
281 : : # define YYSIZE_T size_t
282 : : # elif ! defined YYSIZE_T
283 : : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
284 : : # define YYSIZE_T size_t
285 : : # else
286 : : # define YYSIZE_T unsigned int
287 : : # endif
288 : : #endif
289 : :
290 : : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
291 : :
292 : : #ifndef YY_
293 : : # if defined YYENABLE_NLS && YYENABLE_NLS
294 : : # if ENABLE_NLS
295 : : # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
296 : : # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
297 : : # endif
298 : : # endif
299 : : # ifndef YY_
300 : : # define YY_(Msgid) Msgid
301 : : # endif
302 : : #endif
303 : :
304 : : #ifndef YY_ATTRIBUTE
305 : : # if (defined __GNUC__ \
306 : : && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
307 : : || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
308 : : # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
309 : : # else
310 : : # define YY_ATTRIBUTE(Spec) /* empty */
311 : : # endif
312 : : #endif
313 : :
314 : : #ifndef YY_ATTRIBUTE_PURE
315 : : # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
316 : : #endif
317 : :
318 : : #ifndef YY_ATTRIBUTE_UNUSED
319 : : # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
320 : : #endif
321 : :
322 : : #if !defined _Noreturn \
323 : : && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
324 : : # if defined _MSC_VER && 1200 <= _MSC_VER
325 : : # define _Noreturn __declspec (noreturn)
326 : : # else
327 : : # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
328 : : # endif
329 : : #endif
330 : :
331 : : /* Suppress unused-variable warnings by "using" E. */
332 : : #if ! defined lint || defined __GNUC__
333 : : # define YYUSE(E) ((void) (E))
334 : : #else
335 : : # define YYUSE(E) /* empty */
336 : : #endif
337 : :
338 : : #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
339 : : /* Suppress an incorrect diagnostic about yylval being uninitialized. */
340 : : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
341 : : _Pragma ("GCC diagnostic push") \
342 : : _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
343 : : _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
344 : : # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
345 : : _Pragma ("GCC diagnostic pop")
346 : : #else
347 : : # define YY_INITIAL_VALUE(Value) Value
348 : : #endif
349 : : #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
350 : : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
351 : : # define YY_IGNORE_MAYBE_UNINITIALIZED_END
352 : : #endif
353 : : #ifndef YY_INITIAL_VALUE
354 : : # define YY_INITIAL_VALUE(Value) /* Nothing. */
355 : : #endif
356 : :
357 : :
358 : : #if ! defined yyoverflow || YYERROR_VERBOSE
359 : :
360 : : /* The parser invokes alloca or malloc; define the necessary symbols. */
361 : :
362 : : # ifdef YYSTACK_USE_ALLOCA
363 : : # if YYSTACK_USE_ALLOCA
364 : : # ifdef __GNUC__
365 : : # define YYSTACK_ALLOC __builtin_alloca
366 : : # elif defined __BUILTIN_VA_ARG_INCR
367 : : # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
368 : : # elif defined _AIX
369 : : # define YYSTACK_ALLOC __alloca
370 : : # elif defined _MSC_VER
371 : : # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
372 : : # define alloca _alloca
373 : : # else
374 : : # define YYSTACK_ALLOC alloca
375 : : # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
376 : : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
377 : : /* Use EXIT_SUCCESS as a witness for stdlib.h. */
378 : : # ifndef EXIT_SUCCESS
379 : : # define EXIT_SUCCESS 0
380 : : # endif
381 : : # endif
382 : : # endif
383 : : # endif
384 : : # endif
385 : :
386 : : # ifdef YYSTACK_ALLOC
387 : : /* Pacify GCC's 'empty if-body' warning. */
388 : : # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
389 : : # ifndef YYSTACK_ALLOC_MAXIMUM
390 : : /* The OS might guarantee only one guard page at the bottom of the stack,
391 : : and a page size can be as small as 4096 bytes. So we cannot safely
392 : : invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
393 : : to allow for a few compiler-allocated temporary stack slots. */
394 : : # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
395 : : # endif
396 : : # else
397 : : # define YYSTACK_ALLOC YYMALLOC
398 : : # define YYSTACK_FREE YYFREE
399 : : # ifndef YYSTACK_ALLOC_MAXIMUM
400 : : # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
401 : : # endif
402 : : # if (defined __cplusplus && ! defined EXIT_SUCCESS \
403 : : && ! ((defined YYMALLOC || defined malloc) \
404 : : && (defined YYFREE || defined free)))
405 : : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
406 : : # ifndef EXIT_SUCCESS
407 : : # define EXIT_SUCCESS 0
408 : : # endif
409 : : # endif
410 : : # ifndef YYMALLOC
411 : : # define YYMALLOC malloc
412 : : # if ! defined malloc && ! defined EXIT_SUCCESS
413 : : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
414 : : # endif
415 : : # endif
416 : : # ifndef YYFREE
417 : : # define YYFREE free
418 : : # if ! defined free && ! defined EXIT_SUCCESS
419 : : void free (void *); /* INFRINGES ON USER NAME SPACE */
420 : : # endif
421 : : # endif
422 : : # endif
423 : : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
424 : :
425 : :
426 : : #if (! defined yyoverflow \
427 : : && (! defined __cplusplus \
428 : : || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
429 : :
430 : : /* A type that is properly aligned for any stack member. */
431 : : union yyalloc
432 : : {
433 : : yytype_int16 yyss_alloc;
434 : : YYSTYPE yyvs_alloc;
435 : : };
436 : :
437 : : /* The size of the maximum gap between one aligned stack and the next. */
438 : : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
439 : :
440 : : /* The size of an array large to enough to hold all stacks, each with
441 : : N elements. */
442 : : # define YYSTACK_BYTES(N) \
443 : : ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
444 : : + YYSTACK_GAP_MAXIMUM)
445 : :
446 : : # define YYCOPY_NEEDED 1
447 : :
448 : : /* Relocate STACK from its old location to the new one. The
449 : : local variables YYSIZE and YYSTACKSIZE give the old and new number of
450 : : elements in the stack, and YYPTR gives the new location of the
451 : : stack. Advance YYPTR to a properly aligned location for the next
452 : : stack. */
453 : : # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
454 : : do \
455 : : { \
456 : : YYSIZE_T yynewbytes; \
457 : : YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
458 : : Stack = &yyptr->Stack_alloc; \
459 : : yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
460 : : yyptr += yynewbytes / sizeof (*yyptr); \
461 : : } \
462 : : while (0)
463 : :
464 : : #endif
465 : :
466 : : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
467 : : /* Copy COUNT objects from SRC to DST. The source and destination do
468 : : not overlap. */
469 : : # ifndef YYCOPY
470 : : # if defined __GNUC__ && 1 < __GNUC__
471 : : # define YYCOPY(Dst, Src, Count) \
472 : : __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
473 : : # else
474 : : # define YYCOPY(Dst, Src, Count) \
475 : : do \
476 : : { \
477 : : YYSIZE_T yyi; \
478 : : for (yyi = 0; yyi < (Count); yyi++) \
479 : : (Dst)[yyi] = (Src)[yyi]; \
480 : : } \
481 : : while (0)
482 : : # endif
483 : : # endif
484 : : #endif /* !YYCOPY_NEEDED */
485 : :
486 : : /* YYFINAL -- State number of the termination state. */
487 : : #define YYFINAL 20
488 : : /* YYLAST -- Last index in YYTABLE. */
489 : : #define YYLAST 292
490 : :
491 : : /* YYNTOKENS -- Number of terminals. */
492 : : #define YYNTOKENS 44
493 : : /* YYNNTS -- Number of nonterminals. */
494 : : #define YYNNTS 36
495 : : /* YYNRULES -- Number of rules. */
496 : : #define YYNRULES 96
497 : : /* YYNSTATES -- Number of states. */
498 : : #define YYNSTATES 164
499 : :
500 : : /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
501 : : by yylex, with out-of-bounds checking. */
502 : : #define YYUNDEFTOK 2
503 : : #define YYMAXUTOK 281
504 : :
505 : : #define YYTRANSLATE(YYX) \
506 : : ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
507 : :
508 : : /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
509 : : as returned by yylex, without out-of-bounds checking. */
510 : : static const yytype_uint8 yytranslate[] =
511 : : {
512 : : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
513 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
514 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
515 : : 2, 2, 2, 2, 37, 2, 2, 31, 2, 2,
516 : : 41, 42, 29, 28, 43, 27, 36, 30, 2, 2,
517 : : 2, 2, 2, 2, 2, 2, 2, 2, 18, 40,
518 : : 2, 16, 2, 17, 2, 2, 2, 2, 2, 2,
519 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
520 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
521 : : 2, 38, 2, 39, 35, 2, 2, 2, 2, 2,
522 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
523 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
524 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
525 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
526 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
527 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
528 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
529 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
530 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
531 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
532 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
533 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
534 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
535 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
536 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
537 : : 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
538 : : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
539 : : 15, 19, 20, 21, 22, 23, 24, 25, 26, 32,
540 : : 33, 34
541 : : };
542 : :
543 : : #if YYDEBUG
544 : : /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
545 : : static const yytype_uint16 yyrline[] =
546 : : {
547 : : 0, 122, 122, 127, 128, 139, 142, 143, 144, 145,
548 : : 153, 167, 179, 180, 184, 185, 189, 190, 198, 199,
549 : : 205, 219, 220, 225, 228, 234, 238, 243, 252, 255,
550 : : 259, 263, 268, 269, 273, 280, 294, 295, 302, 310,
551 : : 313, 316, 319, 322, 325, 331, 337, 338, 345, 349,
552 : : 357, 358, 368, 379, 388, 392, 396, 400, 407, 414,
553 : : 423, 432, 446, 453, 459, 466, 473, 480, 487, 494,
554 : : 501, 507, 513, 520, 528, 535, 542, 549, 556, 563,
555 : : 570, 576, 583, 592, 593, 596, 599, 603, 610, 618,
556 : : 630, 631, 643, 647, 651, 655, 656
557 : : };
558 : : #endif
559 : :
560 : : #if YYDEBUG || YYERROR_VERBOSE || 0
561 : : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
562 : : First, the terminals, then, starting at YYNTOKENS, nonterminals. */
563 : : static const char *const yytname[] =
564 : : {
565 : : "$end", "error", "$undefined", "InvalidCharacter", "Identifier",
566 : : "Assign", "ScaleOrUnit", "Eol", "Eqn", "DefSub", "EndSub", "REAL",
567 : : "IMAG", "COMPLEX", "Character", "STRING", "'='", "'?'", "':'", "Or",
568 : : "And", "NotEqual", "Equal", "Less", "Greater", "LessOrEqual",
569 : : "GreaterOrEqual", "'-'", "'+'", "'*'", "'/'", "'%'", "Not", "NEG", "POS",
570 : : "'^'", "'.'", "'\"'", "'['", "']'", "';'", "'('", "')'", "','",
571 : : "$accept", "Input", "InputList", "InputLine", "ActionLine",
572 : : "DefinitionLine", "InstanceIdentifier", "NodeIdentifier", "NodeList",
573 : : "PairList", "NoneValue", "Value", "PropertyReal", "PropertyValue",
574 : : "ValueList", "EquationLine", "EquationList", "Equation", "Expression",
575 : : "ExpressionCol", "ExpressionColList", "ExpressionVector", "Vector",
576 : : "ExpressionRowList", "ExpressionMatrix", "Matrix", "Constant", "Range",
577 : : "Reference", "Application", "ExpressionList", "SubcircuitBody",
578 : : "DefBegin", "DefBody", "DefEnd", "DefBodyLine", YY_NULLPTR
579 : : };
580 : : #endif
581 : :
582 : : # ifdef YYPRINT
583 : : /* YYTOKNUM[NUM] -- (External) token number corresponding to the
584 : : (internal) symbol number NUM (which must be that of a token). */
585 : : static const yytype_uint16 yytoknum[] =
586 : : {
587 : : 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
588 : : 265, 266, 267, 268, 269, 270, 61, 63, 58, 271,
589 : : 272, 273, 274, 275, 276, 277, 278, 45, 43, 42,
590 : : 47, 37, 279, 280, 281, 94, 46, 34, 91, 93,
591 : : 59, 40, 41, 44
592 : : };
593 : : # endif
594 : :
595 : : #define YYPACT_NINF -118
596 : :
597 : : #define yypact_value_is_default(Yystate) \
598 : : (!!((Yystate) == (-118)))
599 : :
600 : : #define YYTABLE_NINF -1
601 : :
602 : : #define yytable_value_is_error(Yytable_value) \
603 : : 0
604 : :
605 : : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
606 : : STATE-NUM. */
607 : : static const yytype_int16 yypact[] =
608 : : {
609 : : 81, -4, -118, 15, 98, 39, 44, -118, 81, -118,
610 : : -118, -118, -118, 107, 98, 98, -118, -118, 99, 30,
611 : : -118, -118, -118, -118, -118, -118, 58, 107, 99, 65,
612 : : -118, -118, 99, 66, 98, 42, -118, -118, 66, 49,
613 : : 65, -118, 0, 72, 66, -118, 80, 69, 91, 65,
614 : : 131, 71, 63, -118, 66, 66, -118, -118, -118, 106,
615 : : -118, 97, -118, -118, -118, -118, 69, 69, 69, 69,
616 : : 69, 175, -118, 102, -118, -118, -118, 135, -118, 105,
617 : : 119, 120, 123, -118, -118, -118, -2, 124, 124, 124,
618 : : 126, 125, -118, 127, -118, 128, 151, 69, 69, 69,
619 : : 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
620 : : 69, 69, -118, -2, -118, -118, -118, 152, -118, 69,
621 : : 101, 121, 141, 69, -118, 69, -118, -118, -118, 196,
622 : : 229, 244, 257, 257, 64, 64, 64, 64, 104, 104,
623 : : 124, 124, 124, 124, 145, -118, 213, 69, -2, -2,
624 : : -118, 126, 147, 69, -118, 213, -118, -118, -118, 69,
625 : : -118, 213, 147, -118
626 : : };
627 : :
628 : : /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
629 : : Performed when YYTABLE does not specify something else to do. Zero
630 : : means the default is an error. */
631 : : static const yytype_uint8 yydefact[] =
632 : : {
633 : : 3, 0, 9, 0, 0, 0, 0, 2, 3, 7,
634 : : 8, 6, 5, 90, 0, 0, 12, 13, 16, 0,
635 : : 1, 4, 96, 93, 94, 95, 0, 90, 16, 0,
636 : : 14, 15, 16, 18, 0, 0, 88, 91, 18, 0,
637 : : 36, 17, 21, 0, 18, 92, 0, 0, 0, 36,
638 : : 25, 0, 32, 29, 18, 18, 28, 23, 89, 0,
639 : : 11, 62, 54, 55, 56, 57, 0, 0, 0, 0,
640 : : 0, 0, 39, 40, 41, 35, 37, 26, 22, 0,
641 : : 0, 33, 0, 20, 19, 10, 83, 71, 70, 80,
642 : : 46, 48, 49, 0, 53, 0, 0, 0, 0, 0,
643 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
644 : : 0, 0, 38, 83, 27, 24, 30, 32, 31, 61,
645 : : 84, 85, 0, 0, 45, 0, 43, 44, 42, 0,
646 : : 82, 81, 79, 78, 74, 75, 77, 76, 66, 65,
647 : : 67, 68, 69, 72, 0, 34, 59, 60, 83, 83,
648 : : 63, 46, 50, 0, 64, 58, 86, 87, 47, 0,
649 : : 52, 73, 50, 51
650 : : };
651 : :
652 : : /* YYPGOTO[NTERM-NUM]. */
653 : : static const yytype_int16 yypgoto[] =
654 : : {
655 : : -118, -118, 177, -118, -118, 2, 13, -118, -25, -20,
656 : : -118, -118, -51, 137, 73, 18, 140, 162, -47, -117,
657 : : 56, -118, -118, 46, -118, -118, -118, -118, -118, -118,
658 : : -108, 19, -118, 182, -118, -118
659 : : };
660 : :
661 : : /* YYDEFGOTO[NTERM-NUM]. */
662 : : static const yytype_int16 yydefgoto[] =
663 : : {
664 : : -1, 6, 7, 8, 9, 10, 53, 32, 33, 43,
665 : : 54, 55, 56, 57, 82, 11, 48, 49, 120, 91,
666 : : 124, 92, 93, 160, 94, 95, 72, 121, 73, 74,
667 : : 122, 12, 13, 26, 36, 27
668 : : };
669 : :
670 : : /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
671 : : positive, shift that token. If negative, reduce the rule whose
672 : : number is the opposite. If YYTABLE_NINF, syntax error. */
673 : : static const yytype_uint8 yytable[] =
674 : : {
675 : : 71, 81, 61, 38, 16, 144, 17, 41, 152, 62,
676 : : 63, 50, 64, 65, 14, 23, 119, 18, 46, 87,
677 : : 88, 89, 90, 96, 59, 66, 67, 28, 29, 23,
678 : : 68, 24, 25, 15, 83, 84, 69, 51, 52, 70,
679 : : 156, 157, 162, 19, 20, 24, 25, 44, 34, 45,
680 : : 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
681 : : 139, 140, 141, 142, 143, 80, 81, 16, 35, 17,
682 : : 39, 42, 146, 61, 50, 16, 151, 17, 90, 58,
683 : : 62, 63, 50, 64, 65, 1, 47, 60, 2, 3,
684 : : 4, 106, 107, 108, 109, 110, 66, 67, 75, 111,
685 : : 155, 68, 16, 30, 17, 31, 161, 69, 78, 52,
686 : : 70, 1, 90, 85, 22, 3, 4, 5, 97, 147,
687 : : 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
688 : : 108, 109, 110, 108, 109, 110, 111, 77, 86, 111,
689 : : 113, 114, 115, 97, 148, 98, 99, 100, 101, 102,
690 : : 103, 104, 105, 106, 107, 108, 109, 110, 116, 111,
691 : : 117, 111, 118, 50, 149, 125, 126, 127, 97, 123,
692 : : 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
693 : : 108, 109, 110, 150, 154, 21, 111, 159, 79, 76,
694 : : 145, 40, 97, 128, 98, 99, 100, 101, 102, 103,
695 : : 104, 105, 106, 107, 108, 109, 110, 158, 163, 37,
696 : : 111, 0, 112, 97, 153, 98, 99, 100, 101, 102,
697 : : 103, 104, 105, 106, 107, 108, 109, 110, 0, 0,
698 : : 97, 111, 98, 99, 100, 101, 102, 103, 104, 105,
699 : : 106, 107, 108, 109, 110, 0, 0, 0, 111, 99,
700 : : 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
701 : : 110, 0, 0, 0, 111, 100, 101, 102, 103, 104,
702 : : 105, 106, 107, 108, 109, 110, 0, 0, 0, 111,
703 : : 102, 103, 104, 105, 106, 107, 108, 109, 110, 0,
704 : : 0, 0, 111
705 : : };
706 : :
707 : : static const yytype_int16 yycheck[] =
708 : : {
709 : : 47, 52, 4, 28, 4, 113, 6, 32, 125, 11,
710 : : 12, 11, 14, 15, 18, 13, 18, 4, 38, 66,
711 : : 67, 68, 69, 70, 44, 27, 28, 14, 15, 27,
712 : : 32, 13, 13, 18, 54, 55, 38, 37, 38, 41,
713 : : 148, 149, 159, 4, 0, 27, 27, 34, 18, 7,
714 : : 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
715 : : 107, 108, 109, 110, 111, 52, 117, 4, 10, 6,
716 : : 5, 5, 119, 4, 11, 4, 123, 6, 125, 7,
717 : : 11, 12, 11, 14, 15, 4, 37, 7, 7, 8,
718 : : 9, 27, 28, 29, 30, 31, 27, 28, 7, 35,
719 : : 147, 32, 4, 4, 6, 6, 153, 38, 37, 38,
720 : : 41, 4, 159, 7, 7, 8, 9, 36, 17, 18,
721 : : 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
722 : : 29, 30, 31, 29, 30, 31, 35, 6, 41, 35,
723 : : 38, 6, 37, 17, 43, 19, 20, 21, 22, 23,
724 : : 24, 25, 26, 27, 28, 29, 30, 31, 39, 35,
725 : : 40, 35, 39, 11, 43, 40, 39, 39, 17, 43,
726 : : 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
727 : : 29, 30, 31, 42, 39, 8, 35, 40, 51, 49,
728 : : 117, 29, 17, 42, 19, 20, 21, 22, 23, 24,
729 : : 25, 26, 27, 28, 29, 30, 31, 151, 162, 27,
730 : : 35, -1, 37, 17, 18, 19, 20, 21, 22, 23,
731 : : 24, 25, 26, 27, 28, 29, 30, 31, -1, -1,
732 : : 17, 35, 19, 20, 21, 22, 23, 24, 25, 26,
733 : : 27, 28, 29, 30, 31, -1, -1, -1, 35, 20,
734 : : 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
735 : : 31, -1, -1, -1, 35, 21, 22, 23, 24, 25,
736 : : 26, 27, 28, 29, 30, 31, -1, -1, -1, 35,
737 : : 23, 24, 25, 26, 27, 28, 29, 30, 31, -1,
738 : : -1, -1, 35
739 : : };
740 : :
741 : : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
742 : : symbol of state STATE-NUM. */
743 : : static const yytype_uint8 yystos[] =
744 : : {
745 : : 0, 4, 7, 8, 9, 36, 45, 46, 47, 48,
746 : : 49, 59, 75, 76, 18, 18, 4, 6, 50, 4,
747 : : 0, 46, 7, 49, 59, 75, 77, 79, 50, 50,
748 : : 4, 6, 51, 52, 18, 10, 78, 77, 52, 5,
749 : : 61, 52, 5, 53, 50, 7, 53, 37, 60, 61,
750 : : 11, 37, 38, 50, 54, 55, 56, 57, 7, 53,
751 : : 7, 4, 11, 12, 14, 15, 27, 28, 32, 38,
752 : : 41, 62, 70, 72, 73, 7, 60, 6, 37, 57,
753 : : 50, 56, 58, 53, 53, 7, 41, 62, 62, 62,
754 : : 62, 63, 65, 66, 68, 69, 62, 17, 19, 20,
755 : : 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
756 : : 31, 35, 37, 38, 6, 37, 39, 40, 39, 18,
757 : : 62, 71, 74, 43, 64, 40, 39, 39, 42, 62,
758 : : 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
759 : : 62, 62, 62, 62, 74, 58, 62, 18, 43, 43,
760 : : 42, 62, 63, 18, 39, 62, 74, 74, 64, 40,
761 : : 67, 62, 63, 67
762 : : };
763 : :
764 : : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
765 : : static const yytype_uint8 yyr1[] =
766 : : {
767 : : 0, 44, 45, 46, 46, 47, 47, 47, 47, 47,
768 : : 48, 49, 50, 50, 51, 51, 52, 52, 53, 53,
769 : : 53, 54, 54, 55, 55, 56, 56, 56, 57, 57,
770 : : 57, 57, 58, 58, 58, 59, 60, 60, 61, 62,
771 : : 62, 62, 62, 62, 62, 63, 64, 64, 65, 66,
772 : : 67, 67, 68, 69, 70, 70, 70, 70, 71, 71,
773 : : 71, 71, 72, 73, 73, 73, 73, 73, 73, 73,
774 : : 73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
775 : : 73, 73, 73, 74, 74, 74, 74, 74, 75, 76,
776 : : 77, 77, 78, 79, 79, 79, 79
777 : : };
778 : :
779 : : /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
780 : : static const yytype_uint8 yyr2[] =
781 : : {
782 : : 0, 2, 1, 0, 2, 1, 1, 1, 1, 1,
783 : : 6, 6, 1, 1, 1, 1, 0, 2, 0, 3,
784 : : 3, 0, 2, 1, 3, 1, 2, 3, 1, 1,
785 : : 3, 3, 0, 1, 3, 6, 0, 2, 4, 1,
786 : : 1, 1, 3, 3, 3, 2, 0, 3, 1, 1,
787 : : 0, 3, 4, 1, 1, 1, 1, 1, 3, 2,
788 : : 2, 1, 1, 4, 4, 3, 3, 3, 3, 3,
789 : : 2, 2, 3, 5, 3, 3, 3, 3, 3, 3,
790 : : 2, 3, 3, 0, 1, 1, 3, 3, 3, 5,
791 : : 0, 2, 2, 1, 1, 1, 1
792 : : };
793 : :
794 : :
795 : : #define yyerrok (yyerrstatus = 0)
796 : : #define yyclearin (yychar = YYEMPTY)
797 : : #define YYEMPTY (-2)
798 : : #define YYEOF 0
799 : :
800 : : #define YYACCEPT goto yyacceptlab
801 : : #define YYABORT goto yyabortlab
802 : : #define YYERROR goto yyerrorlab
803 : :
804 : :
805 : : #define YYRECOVERING() (!!yyerrstatus)
806 : :
807 : : #define YYBACKUP(Token, Value) \
808 : : do \
809 : : if (yychar == YYEMPTY) \
810 : : { \
811 : : yychar = (Token); \
812 : : yylval = (Value); \
813 : : YYPOPSTACK (yylen); \
814 : : yystate = *yyssp; \
815 : : goto yybackup; \
816 : : } \
817 : : else \
818 : : { \
819 : : yyerror (YY_("syntax error: cannot back up")); \
820 : : YYERROR; \
821 : : } \
822 : : while (0)
823 : :
824 : : /* Error token number */
825 : : #define YYTERROR 1
826 : : #define YYERRCODE 256
827 : :
828 : :
829 : :
830 : : /* Enable debugging if requested. */
831 : : #if YYDEBUG
832 : :
833 : : # ifndef YYFPRINTF
834 : : # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
835 : : # define YYFPRINTF fprintf
836 : : # endif
837 : :
838 : : # define YYDPRINTF(Args) \
839 : : do { \
840 : : if (yydebug) \
841 : : YYFPRINTF Args; \
842 : : } while (0)
843 : :
844 : : /* This macro is provided for backward compatibility. */
845 : : #ifndef YY_LOCATION_PRINT
846 : : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
847 : : #endif
848 : :
849 : :
850 : : # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
851 : : do { \
852 : : if (yydebug) \
853 : : { \
854 : : YYFPRINTF (stderr, "%s ", Title); \
855 : : yy_symbol_print (stderr, \
856 : : Type, Value); \
857 : : YYFPRINTF (stderr, "\n"); \
858 : : } \
859 : : } while (0)
860 : :
861 : :
862 : : /*----------------------------------------.
863 : : | Print this symbol's value on YYOUTPUT. |
864 : : `----------------------------------------*/
865 : :
866 : : static void
867 : 0 : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
868 : : {
869 : 0 : FILE *yyo = yyoutput;
870 : : YYUSE (yyo);
871 [ # # ]: 0 : if (!yyvaluep)
872 : 0 : return;
873 : : # ifdef YYPRINT
874 : : if (yytype < YYNTOKENS)
875 : : YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
876 : : # endif
877 : : YYUSE (yytype);
878 : : }
879 : :
880 : :
881 : : /*--------------------------------.
882 : : | Print this symbol on YYOUTPUT. |
883 : : `--------------------------------*/
884 : :
885 : : static void
886 : 0 : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
887 : : {
888 : : YYFPRINTF (yyoutput, "%s %s (",
889 [ # # ]: 0 : yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
890 : :
891 : 0 : yy_symbol_value_print (yyoutput, yytype, yyvaluep);
892 : 0 : YYFPRINTF (yyoutput, ")");
893 : 0 : }
894 : :
895 : : /*------------------------------------------------------------------.
896 : : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
897 : : | TOP (included). |
898 : : `------------------------------------------------------------------*/
899 : :
900 : : static void
901 : 0 : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
902 : : {
903 : 0 : YYFPRINTF (stderr, "Stack now");
904 [ # # ]: 0 : for (; yybottom <= yytop; yybottom++)
905 : : {
906 : 0 : int yybot = *yybottom;
907 : 0 : YYFPRINTF (stderr, " %d", yybot);
908 : : }
909 : 0 : YYFPRINTF (stderr, "\n");
910 : 0 : }
911 : :
912 : : # define YY_STACK_PRINT(Bottom, Top) \
913 : : do { \
914 : : if (yydebug) \
915 : : yy_stack_print ((Bottom), (Top)); \
916 : : } while (0)
917 : :
918 : :
919 : : /*------------------------------------------------.
920 : : | Report that the YYRULE is going to be reduced. |
921 : : `------------------------------------------------*/
922 : :
923 : : static void
924 : 0 : yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
925 : : {
926 : 0 : unsigned long int yylno = yyrline[yyrule];
927 : 0 : int yynrhs = yyr2[yyrule];
928 : : int yyi;
929 : : YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
930 : 0 : yyrule - 1, yylno);
931 : : /* The symbols being reduced. */
932 [ # # ]: 0 : for (yyi = 0; yyi < yynrhs; yyi++)
933 : : {
934 : 0 : YYFPRINTF (stderr, " $%d = ", yyi + 1);
935 : : yy_symbol_print (stderr,
936 : 0 : yystos[yyssp[yyi + 1 - yynrhs]],
937 : : &(yyvsp[(yyi + 1) - (yynrhs)])
938 : 0 : );
939 : 0 : YYFPRINTF (stderr, "\n");
940 : : }
941 : 0 : }
942 : :
943 : : # define YY_REDUCE_PRINT(Rule) \
944 : : do { \
945 : : if (yydebug) \
946 : : yy_reduce_print (yyssp, yyvsp, Rule); \
947 : : } while (0)
948 : :
949 : : /* Nonzero means print parse trace. It is left uninitialized so that
950 : : multiple parsers can coexist. */
951 : : int yydebug;
952 : : #else /* !YYDEBUG */
953 : : # define YYDPRINTF(Args)
954 : : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
955 : : # define YY_STACK_PRINT(Bottom, Top)
956 : : # define YY_REDUCE_PRINT(Rule)
957 : : #endif /* !YYDEBUG */
958 : :
959 : :
960 : : /* YYINITDEPTH -- initial size of the parser's stacks. */
961 : : #ifndef YYINITDEPTH
962 : : # define YYINITDEPTH 200
963 : : #endif
964 : :
965 : : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
966 : : if the built-in stack extension method is used).
967 : :
968 : : Do not make this value too large; the results are undefined if
969 : : YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
970 : : evaluated with infinite-precision integer arithmetic. */
971 : :
972 : : #ifndef YYMAXDEPTH
973 : : # define YYMAXDEPTH 10000
974 : : #endif
975 : :
976 : :
977 : : #if YYERROR_VERBOSE
978 : :
979 : : # ifndef yystrlen
980 : : # if defined __GLIBC__ && defined _STRING_H
981 : : # define yystrlen strlen
982 : : # else
983 : : /* Return the length of YYSTR. */
984 : : static YYSIZE_T
985 : 0 : yystrlen (const char *yystr)
986 : : {
987 : : YYSIZE_T yylen;
988 [ # # ]: 0 : for (yylen = 0; yystr[yylen]; yylen++)
989 : 0 : continue;
990 : 0 : return yylen;
991 : : }
992 : : # endif
993 : : # endif
994 : :
995 : : # ifndef yystpcpy
996 : : # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
997 : : # define yystpcpy stpcpy
998 : : # else
999 : : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1000 : : YYDEST. */
1001 : : static char *
1002 : 0 : yystpcpy (char *yydest, const char *yysrc)
1003 : : {
1004 : 0 : char *yyd = yydest;
1005 : 0 : const char *yys = yysrc;
1006 : :
1007 [ # # ]: 0 : while ((*yyd++ = *yys++) != '\0')
1008 : 0 : continue;
1009 : :
1010 : 0 : return yyd - 1;
1011 : : }
1012 : : # endif
1013 : : # endif
1014 : :
1015 : : # ifndef yytnamerr
1016 : : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1017 : : quotes and backslashes, so that it's suitable for yyerror. The
1018 : : heuristic is that double-quoting is unnecessary unless the string
1019 : : contains an apostrophe, a comma, or backslash (other than
1020 : : backslash-backslash). YYSTR is taken from yytname. If YYRES is
1021 : : null, do not copy; instead, return the length of what the result
1022 : : would have been. */
1023 : : static YYSIZE_T
1024 : 0 : yytnamerr (char *yyres, const char *yystr)
1025 : : {
1026 [ # # ]: 0 : if (*yystr == '"')
1027 : : {
1028 : 0 : YYSIZE_T yyn = 0;
1029 : 0 : char const *yyp = yystr;
1030 : :
1031 : 0 : for (;;)
1032 [ # # # # ]: 0 : switch (*++yyp)
1033 : : {
1034 : : case '\'':
1035 : : case ',':
1036 : 0 : goto do_not_strip_quotes;
1037 : :
1038 : : case '\\':
1039 [ # # ]: 0 : if (*++yyp != '\\')
1040 : 0 : goto do_not_strip_quotes;
1041 : : /* Fall through. */
1042 : : default:
1043 [ # # ]: 0 : if (yyres)
1044 : 0 : yyres[yyn] = *yyp;
1045 : 0 : yyn++;
1046 : 0 : break;
1047 : :
1048 : : case '"':
1049 [ # # ]: 0 : if (yyres)
1050 : 0 : yyres[yyn] = '\0';
1051 : 0 : return yyn;
1052 : : }
1053 : : do_not_strip_quotes: ;
1054 : : }
1055 : :
1056 [ # # ]: 0 : if (! yyres)
1057 : 0 : return yystrlen (yystr);
1058 : :
1059 : 0 : return yystpcpy (yyres, yystr) - yyres;
1060 : : }
1061 : : # endif
1062 : :
1063 : : /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1064 : : about the unexpected token YYTOKEN for the state stack whose top is
1065 : : YYSSP.
1066 : :
1067 : : Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1068 : : not large enough to hold the message. In that case, also set
1069 : : *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1070 : : required number of bytes is too large to store. */
1071 : : static int
1072 : 0 : yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1073 : : yytype_int16 *yyssp, int yytoken)
1074 : : {
1075 : 0 : YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1076 : 0 : YYSIZE_T yysize = yysize0;
1077 : : enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1078 : : /* Internationalized format string. */
1079 : 0 : const char *yyformat = YY_NULLPTR;
1080 : : /* Arguments of yyformat. */
1081 : : char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1082 : : /* Number of reported tokens (one for the "unexpected", one per
1083 : : "expected"). */
1084 : 0 : int yycount = 0;
1085 : :
1086 : : /* There are many possibilities here to consider:
1087 : : - If this state is a consistent state with a default action, then
1088 : : the only way this function was invoked is if the default action
1089 : : is an error action. In that case, don't check for expected
1090 : : tokens because there are none.
1091 : : - The only way there can be no lookahead present (in yychar) is if
1092 : : this state is a consistent state with a default action. Thus,
1093 : : detecting the absence of a lookahead is sufficient to determine
1094 : : that there is no unexpected or expected token to report. In that
1095 : : case, just report a simple "syntax error".
1096 : : - Don't assume there isn't a lookahead just because this state is a
1097 : : consistent state with a default action. There might have been a
1098 : : previous inconsistent state, consistent state with a non-default
1099 : : action, or user semantic action that manipulated yychar.
1100 : : - Of course, the expected token list depends on states to have
1101 : : correct lookahead information, and it depends on the parser not
1102 : : to perform extra reductions after fetching a lookahead from the
1103 : : scanner and before detecting a syntax error. Thus, state merging
1104 : : (from LALR or IELR) and default reductions corrupt the expected
1105 : : token list. However, the list is correct for canonical LR with
1106 : : one exception: it will still contain any token that will not be
1107 : : accepted due to an error action in a later state.
1108 : : */
1109 [ # # ]: 0 : if (yytoken != YYEMPTY)
1110 : : {
1111 : 0 : int yyn = yypact[*yyssp];
1112 : 0 : yyarg[yycount++] = yytname[yytoken];
1113 [ # # ]: 0 : if (!yypact_value_is_default (yyn))
1114 : : {
1115 : : /* Start YYX at -YYN if negative to avoid negative indexes in
1116 : : YYCHECK. In other words, skip the first -YYN actions for
1117 : : this state because they are default actions. */
1118 [ # # ]: 0 : int yyxbegin = yyn < 0 ? -yyn : 0;
1119 : : /* Stay within bounds of both yycheck and yytname. */
1120 : 0 : int yychecklim = YYLAST - yyn + 1;
1121 : 0 : int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1122 : : int yyx;
1123 : :
1124 [ # # ]: 0 : for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1125 [ # # ][ # # ]: 0 : if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1126 : : && !yytable_value_is_error (yytable[yyx + yyn]))
1127 : : {
1128 [ # # ]: 0 : if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1129 : : {
1130 : 0 : yycount = 1;
1131 : 0 : yysize = yysize0;
1132 : 0 : break;
1133 : : }
1134 : 0 : yyarg[yycount++] = yytname[yyx];
1135 : : {
1136 : 0 : YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1137 [ # # ]: 0 : if (! (yysize <= yysize1
1138 : : && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1139 : 0 : return 2;
1140 : 0 : yysize = yysize1;
1141 : : }
1142 : : }
1143 : : }
1144 : : }
1145 : :
1146 [ # # # # : 0 : switch (yycount)
# # # ]
1147 : : {
1148 : : # define YYCASE_(N, S) \
1149 : : case N: \
1150 : : yyformat = S; \
1151 : : break
1152 : 0 : YYCASE_(0, YY_("syntax error"));
1153 : 0 : YYCASE_(1, YY_("syntax error, unexpected %s"));
1154 : 0 : YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1155 : 0 : YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1156 : 0 : YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1157 : 0 : YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1158 : : # undef YYCASE_
1159 : : }
1160 : :
1161 : : {
1162 : 0 : YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1163 [ # # ]: 0 : if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1164 : 0 : return 2;
1165 : 0 : yysize = yysize1;
1166 : : }
1167 : :
1168 [ # # ]: 0 : if (*yymsg_alloc < yysize)
1169 : : {
1170 : 0 : *yymsg_alloc = 2 * yysize;
1171 [ # # ]: 0 : if (! (yysize <= *yymsg_alloc
1172 : 0 : && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1173 : 0 : *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1174 : 0 : return 1;
1175 : : }
1176 : :
1177 : : /* Avoid sprintf, as that infringes on the user's name space.
1178 : : Don't have undefined behavior even if the translation
1179 : : produced a string with the wrong number of "%s"s. */
1180 : : {
1181 : 0 : char *yyp = *yymsg;
1182 : 0 : int yyi = 0;
1183 [ # # ]: 0 : while ((*yyp = *yyformat) != '\0')
1184 [ # # ][ # # ]: 0 : if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
[ # # ]
1185 : : {
1186 : 0 : yyp += yytnamerr (yyp, yyarg[yyi++]);
1187 : 0 : yyformat += 2;
1188 : : }
1189 : : else
1190 : : {
1191 : 0 : yyp++;
1192 : 0 : yyformat++;
1193 : : }
1194 : : }
1195 : 0 : return 0;
1196 : : }
1197 : : #endif /* YYERROR_VERBOSE */
1198 : :
1199 : : /*-----------------------------------------------.
1200 : : | Release the memory associated to this symbol. |
1201 : : `-----------------------------------------------*/
1202 : :
1203 : : static void
1204 : 206 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1205 : : {
1206 : : YYUSE (yyvaluep);
1207 [ - + ]: 206 : if (!yymsg)
1208 : 0 : yymsg = "Deleting";
1209 [ - + ]: 206 : YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1210 : :
1211 : : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1212 : : YYUSE (yytype);
1213 : : YY_IGNORE_MAYBE_UNINITIALIZED_END
1214 : 206 : }
1215 : :
1216 : :
1217 : :
1218 : :
1219 : : /* The lookahead symbol. */
1220 : : int yychar;
1221 : :
1222 : : /* The semantic value of the lookahead symbol. */
1223 : : YYSTYPE yylval;
1224 : : /* Number of syntax errors so far. */
1225 : : int yynerrs;
1226 : :
1227 : :
1228 : : /*----------.
1229 : : | yyparse. |
1230 : : `----------*/
1231 : :
1232 : : int
1233 : 103 : yyparse (void)
1234 : : {
1235 : : int yystate;
1236 : : /* Number of tokens to shift before error messages enabled. */
1237 : : int yyerrstatus;
1238 : :
1239 : : /* The stacks and their tools:
1240 : : 'yyss': related to states.
1241 : : 'yyvs': related to semantic values.
1242 : :
1243 : : Refer to the stacks through separate pointers, to allow yyoverflow
1244 : : to reallocate them elsewhere. */
1245 : :
1246 : : /* The state stack. */
1247 : : yytype_int16 yyssa[YYINITDEPTH];
1248 : : yytype_int16 *yyss;
1249 : : yytype_int16 *yyssp;
1250 : :
1251 : : /* The semantic value stack. */
1252 : : YYSTYPE yyvsa[YYINITDEPTH];
1253 : : YYSTYPE *yyvs;
1254 : : YYSTYPE *yyvsp;
1255 : :
1256 : : YYSIZE_T yystacksize;
1257 : :
1258 : : int yyn;
1259 : : int yyresult;
1260 : : /* Lookahead token as an internal (translated) token number. */
1261 : 103 : int yytoken = 0;
1262 : : /* The variables used to return semantic value and location from the
1263 : : action routines. */
1264 : : YYSTYPE yyval;
1265 : :
1266 : : #if YYERROR_VERBOSE
1267 : : /* Buffer for error messages, and its allocated size. */
1268 : : char yymsgbuf[128];
1269 : 103 : char *yymsg = yymsgbuf;
1270 : 103 : YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1271 : : #endif
1272 : :
1273 : : #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1274 : :
1275 : : /* The number of symbols on the RHS of the reduced rule.
1276 : : Keep to zero when no symbol should be popped. */
1277 : 103 : int yylen = 0;
1278 : :
1279 : 103 : yyssp = yyss = yyssa;
1280 : 103 : yyvsp = yyvs = yyvsa;
1281 : 103 : yystacksize = YYINITDEPTH;
1282 : :
1283 [ - + ][ # # ]: 103 : YYDPRINTF ((stderr, "Starting parse\n"));
1284 : :
1285 : 103 : yystate = 0;
1286 : 103 : yyerrstatus = 0;
1287 : 103 : yynerrs = 0;
1288 : 103 : yychar = YYEMPTY; /* Cause a token to be read. */
1289 : 103 : goto yysetstate;
1290 : :
1291 : : /*------------------------------------------------------------.
1292 : : | yynewstate -- Push a new state, which is found in yystate. |
1293 : : `------------------------------------------------------------*/
1294 : : yynewstate:
1295 : : /* In all cases, when you get here, the value and location stacks
1296 : : have just been pushed. So pushing a state here evens the stacks. */
1297 : 105866 : yyssp++;
1298 : :
1299 : : yysetstate:
1300 : 105969 : *yyssp = yystate;
1301 : :
1302 [ + + ]: 105969 : if (yyss + yystacksize - 1 <= yyssp)
1303 : : {
1304 : : /* Get the current used size of the three stacks, in elements. */
1305 : 17 : YYSIZE_T yysize = yyssp - yyss + 1;
1306 : :
1307 : : #ifdef yyoverflow
1308 : : {
1309 : : /* Give user a chance to reallocate the stack. Use copies of
1310 : : these so that the &'s don't force the real ones into
1311 : : memory. */
1312 : : YYSTYPE *yyvs1 = yyvs;
1313 : : yytype_int16 *yyss1 = yyss;
1314 : :
1315 : : /* Each stack pointer address is followed by the size of the
1316 : : data in use in that stack, in bytes. This used to be a
1317 : : conditional around just the two extra args, but that might
1318 : : be undefined if yyoverflow is a macro. */
1319 : : yyoverflow (YY_("memory exhausted"),
1320 : : &yyss1, yysize * sizeof (*yyssp),
1321 : : &yyvs1, yysize * sizeof (*yyvsp),
1322 : : &yystacksize);
1323 : :
1324 : : yyss = yyss1;
1325 : : yyvs = yyvs1;
1326 : : }
1327 : : #else /* no yyoverflow */
1328 : : # ifndef YYSTACK_RELOCATE
1329 : : goto yyexhaustedlab;
1330 : : # else
1331 : : /* Extend the stack our own way. */
1332 [ - + ]: 17 : if (YYMAXDEPTH <= yystacksize)
1333 : 0 : goto yyexhaustedlab;
1334 : 17 : yystacksize *= 2;
1335 [ - + ]: 17 : if (YYMAXDEPTH < yystacksize)
1336 : 0 : yystacksize = YYMAXDEPTH;
1337 : :
1338 : : {
1339 : 17 : yytype_int16 *yyss1 = yyss;
1340 : : union yyalloc *yyptr =
1341 : 17 : (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1342 [ - + ]: 17 : if (! yyptr)
1343 : 0 : goto yyexhaustedlab;
1344 : 17 : YYSTACK_RELOCATE (yyss_alloc, yyss);
1345 : 17 : YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1346 : : # undef YYSTACK_RELOCATE
1347 [ + + ]: 17 : if (yyss1 != yyssa)
1348 : 8 : YYSTACK_FREE (yyss1);
1349 : : }
1350 : : # endif
1351 : : #endif /* no yyoverflow */
1352 : :
1353 : 17 : yyssp = yyss + yysize - 1;
1354 : 17 : yyvsp = yyvs + yysize - 1;
1355 : :
1356 [ - + ][ # # ]: 17 : YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1357 : : (unsigned long int) yystacksize));
1358 : :
1359 [ - + ]: 17 : if (yyss + yystacksize - 1 <= yyssp)
1360 : 0 : YYABORT;
1361 : : }
1362 : :
1363 [ - + ][ # # ]: 105969 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1364 : :
1365 [ + + ]: 105969 : if (yystate == YYFINAL)
1366 : 103 : YYACCEPT;
1367 : :
1368 : 105866 : goto yybackup;
1369 : :
1370 : : /*-----------.
1371 : : | yybackup. |
1372 : : `-----------*/
1373 : : yybackup:
1374 : :
1375 : : /* Do appropriate processing given the current state. Read a
1376 : : lookahead token if we need one and don't already have one. */
1377 : :
1378 : : /* First try to decide what to do without reference to lookahead token. */
1379 : 105866 : yyn = yypact[yystate];
1380 [ + + ]: 105866 : if (yypact_value_is_default (yyn))
1381 : 42077 : goto yydefault;
1382 : :
1383 : : /* Not known => get a lookahead token if don't already have one. */
1384 : :
1385 : : /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1386 [ + + ]: 63789 : if (yychar == YYEMPTY)
1387 : : {
1388 [ - + ][ # # ]: 51575 : YYDPRINTF ((stderr, "Reading a token: "));
1389 [ + - ]: 51575 : yychar = yylex ();
1390 : : }
1391 : :
1392 [ + + ]: 63789 : if (yychar <= YYEOF)
1393 : : {
1394 : 206 : yychar = yytoken = YYEOF;
1395 [ - + ][ # # ]: 206 : YYDPRINTF ((stderr, "Now at end of input.\n"));
1396 : : }
1397 : : else
1398 : : {
1399 [ + - ]: 63583 : yytoken = YYTRANSLATE (yychar);
1400 [ - + ][ # # ]: 63583 : YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
[ # # ][ # # ]
1401 : : }
1402 : :
1403 : : /* If the proper action on seeing token YYTOKEN is to reduce or to
1404 : : detect an error, take that action. */
1405 : 63789 : yyn += yytoken;
1406 [ + - ][ + - ]: 63789 : if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
[ + + ]
1407 : : goto yydefault;
1408 : 51575 : yyn = yytable[yyn];
1409 [ - + ]: 51575 : if (yyn <= 0)
1410 : : {
1411 : : if (yytable_value_is_error (yyn))
1412 : : goto yyerrlab;
1413 : 0 : yyn = -yyn;
1414 : 0 : goto yyreduce;
1415 : : }
1416 : :
1417 : : /* Count tokens shifted since error; after three, turn off error
1418 : : status. */
1419 [ - + ]: 51575 : if (yyerrstatus)
1420 : 0 : yyerrstatus--;
1421 : :
1422 : : /* Shift the lookahead token. */
1423 [ - + ][ # # ]: 51575 : YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
[ # # ][ # # ]
1424 : :
1425 : : /* Discard the shifted token. */
1426 : 51575 : yychar = YYEMPTY;
1427 : :
1428 : 51575 : yystate = yyn;
1429 : : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1430 : 51575 : *++yyvsp = yylval;
1431 : : YY_IGNORE_MAYBE_UNINITIALIZED_END
1432 : :
1433 : 51575 : goto yynewstate;
1434 : :
1435 : :
1436 : : /*-----------------------------------------------------------.
1437 : : | yydefault -- do the default action for the current state. |
1438 : : `-----------------------------------------------------------*/
1439 : : yydefault:
1440 : 54291 : yyn = yydefact[yystate];
1441 [ - + ]: 54291 : if (yyn == 0)
1442 : 0 : goto yyerrlab;
1443 : 54291 : goto yyreduce;
1444 : :
1445 : :
1446 : : /*-----------------------------.
1447 : : | yyreduce -- Do a reduction. |
1448 : : `-----------------------------*/
1449 : : yyreduce:
1450 : : /* yyn is the number of a rule to reduce with. */
1451 : 54291 : yylen = yyr2[yyn];
1452 : :
1453 : : /* If YYLEN is nonzero, implement the default value of the action:
1454 : : '$$ = $1'.
1455 : :
1456 : : Otherwise, the following line sets YYVAL to garbage.
1457 : : This behavior is undocumented and Bison
1458 : : users should not rely upon it. Assigning to YYVAL
1459 : : unconditionally makes the parser a bit smaller, and it avoids a
1460 : : GCC warning that YYVAL may be used uninitialized. */
1461 : 54291 : yyval = yyvsp[1-yylen];
1462 : :
1463 : :
1464 [ - + ][ # # ]: 54291 : YY_REDUCE_PRINT (yyn);
1465 [ + + + + : 54291 : switch (yyn)
+ + + + +
+ + + + +
+ + - + -
+ + + - +
+ - + - +
+ + + + +
+ + + + -
- - - - -
- - - - +
- - - - -
- - + + +
+ + + + -
- + - - +
- - - - -
- - - - +
- + - + +
+ + + + -
- - + ]
1466 : : {
1467 : : case 2:
1468 : : #line 122 "parse_netlist.y" /* yacc.c:1661 */
1469 : : {
1470 : : definition_root = (yyvsp[0].definition);
1471 : : }
1472 : : #line 1473 "parse_netlist.cpp" /* yacc.c:1661 */
1473 : 103 : break;
1474 : :
1475 : : case 3:
1476 : : #line 127 "parse_netlist.y" /* yacc.c:1661 */
1477 : : { (yyval.definition) = NULL; }
1478 : : #line 1479 "parse_netlist.cpp" /* yacc.c:1661 */
1479 : 103 : break;
1480 : :
1481 : : case 4:
1482 : : #line 128 "parse_netlist.y" /* yacc.c:1661 */
1483 : : {
1484 : : if ((yyvsp[-1].definition)) {
1485 : : (yyvsp[-1].definition)->next = (yyvsp[0].definition);
1486 : : (yyval.definition) = (yyvsp[-1].definition);
1487 : : } else {
1488 : : (yyval.definition) = (yyvsp[0].definition);
1489 : : }
1490 : : }
1491 : : #line 1492 "parse_netlist.cpp" /* yacc.c:1661 */
1492 : 1201 : break;
1493 : :
1494 : : case 5:
1495 : : #line 139 "parse_netlist.y" /* yacc.c:1661 */
1496 : : {
1497 : : (yyval.definition) = (yyvsp[0].subcircuit);
1498 : : }
1499 : : #line 1500 "parse_netlist.cpp" /* yacc.c:1661 */
1500 : 13 : break;
1501 : :
1502 : : case 9:
1503 : : #line 145 "parse_netlist.y" /* yacc.c:1661 */
1504 : : {
1505 : : (yyval.definition) = NULL;
1506 : : }
1507 : : #line 1508 "parse_netlist.cpp" /* yacc.c:1661 */
1508 : 121 : break;
1509 : :
1510 : : case 10:
1511 : : #line 153 "parse_netlist.y" /* yacc.c:1661 */
1512 : : {
1513 : : (yyval.definition) = (struct definition_t *) calloc (sizeof (struct definition_t), 1);
1514 : : (yyval.definition)->action = PROP_ACTION;
1515 : : (yyval.definition)->type = (yyvsp[-4].ident);
1516 : : (yyval.definition)->instance = (yyvsp[-2].ident);
1517 : : (yyval.definition)->pairs = (yyvsp[-1].pair);
1518 : : (yyval.definition)->line = netlist_lineno;
1519 : : }
1520 : : #line 1521 "parse_netlist.cpp" /* yacc.c:1661 */
1521 : 181 : break;
1522 : :
1523 : : case 11:
1524 : : #line 167 "parse_netlist.y" /* yacc.c:1661 */
1525 : : {
1526 : : (yyval.definition) = (struct definition_t *) calloc (sizeof (struct definition_t), 1);
1527 : : (yyval.definition)->action = PROP_COMPONENT;
1528 : : (yyval.definition)->type = (yyvsp[-5].ident);
1529 : : (yyval.definition)->instance = (yyvsp[-3].ident);
1530 : : (yyval.definition)->nodes = (yyvsp[-2].node);
1531 : : (yyval.definition)->pairs = (yyvsp[-1].pair);
1532 : : (yyval.definition)->line = netlist_lineno;
1533 : : }
1534 : : #line 1535 "parse_netlist.cpp" /* yacc.c:1661 */
1535 : 904 : break;
1536 : :
1537 : : case 12:
1538 : : #line 179 "parse_netlist.y" /* yacc.c:1661 */
1539 : : { (yyval.ident) = (yyvsp[0].ident); }
1540 : : #line 1541 "parse_netlist.cpp" /* yacc.c:1661 */
1541 : 2103 : break;
1542 : :
1543 : : case 13:
1544 : : #line 180 "parse_netlist.y" /* yacc.c:1661 */
1545 : : { (yyval.ident) = (yyvsp[0].str); }
1546 : : #line 1547 "parse_netlist.cpp" /* yacc.c:1661 */
1547 : 3 : break;
1548 : :
1549 : : case 14:
1550 : : #line 184 "parse_netlist.y" /* yacc.c:1661 */
1551 : : { (yyval.ident) = (yyvsp[0].ident); }
1552 : : #line 1553 "parse_netlist.cpp" /* yacc.c:1661 */
1553 : 2099 : break;
1554 : :
1555 : : case 15:
1556 : : #line 185 "parse_netlist.y" /* yacc.c:1661 */
1557 : : { (yyval.ident) = (yyvsp[0].str); }
1558 : : #line 1559 "parse_netlist.cpp" /* yacc.c:1661 */
1559 : 16 : break;
1560 : :
1561 : : case 16:
1562 : : #line 189 "parse_netlist.y" /* yacc.c:1661 */
1563 : : { (yyval.node) = NULL; }
1564 : : #line 1565 "parse_netlist.cpp" /* yacc.c:1661 */
1565 : 917 : break;
1566 : :
1567 : : case 17:
1568 : : #line 190 "parse_netlist.y" /* yacc.c:1661 */
1569 : : {
1570 : : (yyval.node) = (struct node_t *) calloc (sizeof (struct node_t), 1);
1571 : : (yyval.node)->node = (yyvsp[-1].ident);
1572 : : (yyval.node)->next = (yyvsp[0].node);
1573 : : }
1574 : : #line 1575 "parse_netlist.cpp" /* yacc.c:1661 */
1575 : 2115 : break;
1576 : :
1577 : : case 18:
1578 : : #line 198 "parse_netlist.y" /* yacc.c:1661 */
1579 : : { (yyval.pair) = NULL; }
1580 : : #line 1581 "parse_netlist.cpp" /* yacc.c:1661 */
1581 : 1098 : break;
1582 : :
1583 : : case 19:
1584 : : #line 199 "parse_netlist.y" /* yacc.c:1661 */
1585 : : {
1586 : : (yyval.pair) = (struct pair_t *) calloc (sizeof (struct pair_t), 1);
1587 : : (yyval.pair)->key = (yyvsp[-2].ident);
1588 : : (yyval.pair)->value = (yyvsp[-1].value);
1589 : : (yyval.pair)->next = (yyvsp[0].pair);
1590 : : }
1591 : : #line 1592 "parse_netlist.cpp" /* yacc.c:1661 */
1592 : 10160 : break;
1593 : :
1594 : : case 20:
1595 : : #line 205 "parse_netlist.y" /* yacc.c:1661 */
1596 : : {
1597 : : if (0) {
1598 : : (yyval.pair) = (struct pair_t *) calloc (sizeof (struct pair_t), 1);
1599 : : (yyval.pair)->key = (yyvsp[-2].ident);
1600 : : (yyval.pair)->value = NULL;
1601 : : (yyval.pair)->next = (yyvsp[0].pair);
1602 : : } else {
1603 : : free ((yyvsp[-2].ident));
1604 : : (yyval.pair) = (yyvsp[0].pair);
1605 : : }
1606 : : }
1607 : : #line 1608 "parse_netlist.cpp" /* yacc.c:1661 */
1608 : 139 : break;
1609 : :
1610 : : case 21:
1611 : : #line 219 "parse_netlist.y" /* yacc.c:1661 */
1612 : : { /* nothing */ }
1613 : : #line 1614 "parse_netlist.cpp" /* yacc.c:1661 */
1614 : 0 : break;
1615 : :
1616 : : case 22:
1617 : : #line 220 "parse_netlist.y" /* yacc.c:1661 */
1618 : : { /* also nothing */ }
1619 : : #line 1620 "parse_netlist.cpp" /* yacc.c:1661 */
1620 : 139 : break;
1621 : :
1622 : : case 23:
1623 : : #line 225 "parse_netlist.y" /* yacc.c:1661 */
1624 : : {
1625 : : (yyval.value) = (yyvsp[0].value);
1626 : : }
1627 : : #line 1628 "parse_netlist.cpp" /* yacc.c:1661 */
1628 : 0 : break;
1629 : :
1630 : : case 24:
1631 : : #line 228 "parse_netlist.y" /* yacc.c:1661 */
1632 : : {
1633 : : (yyval.value) = (yyvsp[-1].value);
1634 : : }
1635 : : #line 1636 "parse_netlist.cpp" /* yacc.c:1661 */
1636 : 10160 : break;
1637 : :
1638 : : case 25:
1639 : : #line 234 "parse_netlist.y" /* yacc.c:1661 */
1640 : : {
1641 : : (yyval.value) = create_value ();
1642 : : (yyval.value)->value = (yyvsp[0].d);
1643 : : }
1644 : : #line 1645 "parse_netlist.cpp" /* yacc.c:1661 */
1645 : 7572 : break;
1646 : :
1647 : : case 26:
1648 : : #line 238 "parse_netlist.y" /* yacc.c:1661 */
1649 : : {
1650 : : (yyval.value) = create_value ();
1651 : : (yyval.value)->value = (yyvsp[-1].d);
1652 : : (yyval.value)->scale = (yyvsp[0].str);
1653 : : }
1654 : : #line 1655 "parse_netlist.cpp" /* yacc.c:1661 */
1655 : 1660 : break;
1656 : :
1657 : : case 27:
1658 : : #line 243 "parse_netlist.y" /* yacc.c:1661 */
1659 : : {
1660 : : (yyval.value) = create_value ();
1661 : : (yyval.value)->value = (yyvsp[-2].d);
1662 : : (yyval.value)->scale = (yyvsp[-1].str);
1663 : : (yyval.value)->unit = (yyvsp[0].str);
1664 : : }
1665 : : #line 1666 "parse_netlist.cpp" /* yacc.c:1661 */
1666 : 0 : break;
1667 : :
1668 : : case 28:
1669 : : #line 252 "parse_netlist.y" /* yacc.c:1661 */
1670 : : {
1671 : : (yyval.value) = (yyvsp[0].value);
1672 : : }
1673 : : #line 1674 "parse_netlist.cpp" /* yacc.c:1661 */
1674 : 9214 : break;
1675 : :
1676 : : case 29:
1677 : : #line 255 "parse_netlist.y" /* yacc.c:1661 */
1678 : : {
1679 : : (yyval.value) = create_value ();
1680 : : (yyval.value)->ident = (yyvsp[0].ident);
1681 : : }
1682 : : #line 1683 "parse_netlist.cpp" /* yacc.c:1661 */
1683 : 940 : break;
1684 : :
1685 : : case 30:
1686 : : #line 259 "parse_netlist.y" /* yacc.c:1661 */
1687 : : {
1688 : : (yyval.value) = create_value ();
1689 : : (yyval.value)->ident = (yyvsp[-1].ident);
1690 : : }
1691 : : #line 1692 "parse_netlist.cpp" /* yacc.c:1661 */
1692 : 0 : break;
1693 : :
1694 : : case 31:
1695 : : #line 263 "parse_netlist.y" /* yacc.c:1661 */
1696 : : {
1697 : : (yyval.value) = (yyvsp[-1].value);
1698 : : }
1699 : : #line 1700 "parse_netlist.cpp" /* yacc.c:1661 */
1700 : 6 : break;
1701 : :
1702 : : case 32:
1703 : : #line 268 "parse_netlist.y" /* yacc.c:1661 */
1704 : : { (yyval.value) = NULL; }
1705 : : #line 1706 "parse_netlist.cpp" /* yacc.c:1661 */
1706 : 0 : break;
1707 : :
1708 : : case 33:
1709 : : #line 269 "parse_netlist.y" /* yacc.c:1661 */
1710 : : {
1711 : : (yyvsp[0].value)->next = NULL;
1712 : : (yyval.value) = (yyvsp[0].value);
1713 : : }
1714 : : #line 1715 "parse_netlist.cpp" /* yacc.c:1661 */
1715 : 6 : break;
1716 : :
1717 : : case 34:
1718 : : #line 273 "parse_netlist.y" /* yacc.c:1661 */
1719 : : {
1720 : : (yyvsp[-2].value)->next = (yyvsp[0].value);
1721 : : (yyval.value) = (yyvsp[-2].value);
1722 : : }
1723 : : #line 1724 "parse_netlist.cpp" /* yacc.c:1661 */
1724 : 12 : break;
1725 : :
1726 : : case 35:
1727 : : #line 280 "parse_netlist.y" /* yacc.c:1661 */
1728 : : {
1729 : : /* create equation definition */
1730 : : (yyval.definition) = (struct definition_t *) calloc (sizeof (struct definition_t), 1);
1731 : : (yyval.definition)->type = strdup ("Eqn");
1732 : : (yyval.definition)->instance = (yyvsp[-3].ident);
1733 : : (yyval.definition)->action = PROP_ACTION;
1734 : : (yyval.definition)->line = netlist_lineno;
1735 : : (yyvsp[-2].assign)->setInstance ((yyvsp[-3].ident));
1736 : : (yyvsp[-2].assign)->setNext ((yyvsp[-1].eqn));
1737 : : (yyvsp[-2].assign)->applyInstance ();
1738 : : (yyval.definition)->eqns = (yyvsp[-2].assign);
1739 : : }
1740 : : #line 1741 "parse_netlist.cpp" /* yacc.c:1661 */
1741 : 68 : break;
1742 : :
1743 : : case 36:
1744 : : #line 294 "parse_netlist.y" /* yacc.c:1661 */
1745 : : { (yyval.eqn) = NULL; }
1746 : : #line 1747 "parse_netlist.cpp" /* yacc.c:1661 */
1747 : 68 : break;
1748 : :
1749 : : case 37:
1750 : : #line 295 "parse_netlist.y" /* yacc.c:1661 */
1751 : : {
1752 : : (yyvsp[-1].assign)->setNext ((yyvsp[0].eqn));
1753 : : (yyval.eqn) = (yyvsp[-1].assign);
1754 : : }
1755 : : #line 1756 "parse_netlist.cpp" /* yacc.c:1661 */
1756 : 139 : break;
1757 : :
1758 : : case 38:
1759 : : #line 302 "parse_netlist.y" /* yacc.c:1661 */
1760 : : {
1761 : : (yyval.assign) = new eqn::assignment ();
1762 : : (yyval.assign)->result = (yyvsp[-3].ident);
1763 : : (yyval.assign)->body = (yyvsp[-1].eqn);
1764 : : }
1765 : : #line 1766 "parse_netlist.cpp" /* yacc.c:1661 */
1766 : 207 : break;
1767 : :
1768 : : case 39:
1769 : : #line 310 "parse_netlist.y" /* yacc.c:1661 */
1770 : : {
1771 : : (yyval.eqn) = (yyvsp[0].con);
1772 : : }
1773 : : #line 1774 "parse_netlist.cpp" /* yacc.c:1661 */
1774 : 141 : break;
1775 : :
1776 : : case 40:
1777 : : #line 313 "parse_netlist.y" /* yacc.c:1661 */
1778 : : {
1779 : : (yyval.eqn) = (yyvsp[0].ref);
1780 : : }
1781 : : #line 1782 "parse_netlist.cpp" /* yacc.c:1661 */
1782 : 233 : break;
1783 : :
1784 : : case 41:
1785 : : #line 316 "parse_netlist.y" /* yacc.c:1661 */
1786 : : {
1787 : : (yyval.eqn) = (yyvsp[0].app);
1788 : : }
1789 : : #line 1790 "parse_netlist.cpp" /* yacc.c:1661 */
1790 : 285 : break;
1791 : :
1792 : : case 42:
1793 : : #line 319 "parse_netlist.y" /* yacc.c:1661 */
1794 : : {
1795 : : (yyval.eqn) = (yyvsp[-1].eqn);
1796 : : }
1797 : : #line 1798 "parse_netlist.cpp" /* yacc.c:1661 */
1798 : 15 : break;
1799 : :
1800 : : case 43:
1801 : : #line 322 "parse_netlist.y" /* yacc.c:1661 */
1802 : : {
1803 : : (yyval.eqn) = (yyvsp[-1].app);
1804 : : }
1805 : : #line 1806 "parse_netlist.cpp" /* yacc.c:1661 */
1806 : 0 : break;
1807 : :
1808 : : case 44:
1809 : : #line 325 "parse_netlist.y" /* yacc.c:1661 */
1810 : : {
1811 : : (yyval.eqn) = (yyvsp[-1].app);
1812 : : }
1813 : : #line 1814 "parse_netlist.cpp" /* yacc.c:1661 */
1814 : 0 : break;
1815 : :
1816 : : case 45:
1817 : : #line 331 "parse_netlist.y" /* yacc.c:1661 */
1818 : : {
1819 : : (yyvsp[-1].eqn)->appendNodes ((yyvsp[0].eqn));
1820 : : (yyval.eqn) = (yyvsp[-1].eqn);
1821 : : }
1822 : : #line 1823 "parse_netlist.cpp" /* yacc.c:1661 */
1823 : 0 : break;
1824 : :
1825 : : case 46:
1826 : : #line 337 "parse_netlist.y" /* yacc.c:1661 */
1827 : : { (yyval.eqn) = NULL; }
1828 : : #line 1829 "parse_netlist.cpp" /* yacc.c:1661 */
1829 : 0 : break;
1830 : :
1831 : : case 47:
1832 : : #line 338 "parse_netlist.y" /* yacc.c:1661 */
1833 : : {
1834 : : (yyvsp[-1].eqn)->appendNodes ((yyvsp[0].eqn));
1835 : : (yyval.eqn) = (yyvsp[-1].eqn);
1836 : : }
1837 : : #line 1838 "parse_netlist.cpp" /* yacc.c:1661 */
1838 : 0 : break;
1839 : :
1840 : : case 49:
1841 : : #line 349 "parse_netlist.y" /* yacc.c:1661 */
1842 : : {
1843 : : (yyval.app) = new eqn::application ();
1844 : : (yyval.app)->n = strdup ("vector");
1845 : : (yyval.app)->nargs = (yyvsp[0].eqn)->count ();
1846 : : (yyval.app)->args = (yyvsp[0].eqn);
1847 : : }
1848 : : #line 1849 "parse_netlist.cpp" /* yacc.c:1661 */
1849 : 0 : break;
1850 : :
1851 : : case 50:
1852 : : #line 357 "parse_netlist.y" /* yacc.c:1661 */
1853 : : { (yyval.eqn) = NULL; }
1854 : : #line 1855 "parse_netlist.cpp" /* yacc.c:1661 */
1855 : 0 : break;
1856 : :
1857 : : case 51:
1858 : : #line 358 "parse_netlist.y" /* yacc.c:1661 */
1859 : : {
1860 : : eqn::constant * c = new eqn::constant (eqn::TAG_CHAR);
1861 : : c->chr = ';';
1862 : : c->appendNodes ((yyvsp[-1].eqn));
1863 : : (yyvsp[-1].eqn)->appendNodes ((yyvsp[0].eqn));
1864 : : (yyval.eqn) = c;
1865 : : }
1866 : : #line 1867 "parse_netlist.cpp" /* yacc.c:1661 */
1867 : 0 : break;
1868 : :
1869 : : case 52:
1870 : : #line 368 "parse_netlist.y" /* yacc.c:1661 */
1871 : : {
1872 : : eqn::constant * c = new eqn::constant (eqn::TAG_CHAR);
1873 : : c->chr = ';';
1874 : : c->appendNodes ((yyvsp[-1].eqn));
1875 : : (yyvsp[-1].eqn)->appendNodes ((yyvsp[0].eqn));
1876 : : (yyvsp[-3].eqn)->appendNodes (c);
1877 : : (yyval.eqn) = (yyvsp[-3].eqn);
1878 : : }
1879 : : #line 1880 "parse_netlist.cpp" /* yacc.c:1661 */
1880 : 0 : break;
1881 : :
1882 : : case 53:
1883 : : #line 379 "parse_netlist.y" /* yacc.c:1661 */
1884 : : {
1885 : : (yyval.app) = new eqn::application ();
1886 : : (yyval.app)->n = strdup ("matrix");
1887 : : (yyval.app)->nargs = (yyvsp[0].eqn)->count ();
1888 : : (yyval.app)->args = (yyvsp[0].eqn);
1889 : : }
1890 : : #line 1891 "parse_netlist.cpp" /* yacc.c:1661 */
1891 : 0 : break;
1892 : :
1893 : : case 54:
1894 : : #line 388 "parse_netlist.y" /* yacc.c:1661 */
1895 : : {
1896 : : (yyval.con) = new eqn::constant (eqn::TAG_DOUBLE);
1897 : : (yyval.con)->d = (yyvsp[0].d);
1898 : : }
1899 : : #line 1900 "parse_netlist.cpp" /* yacc.c:1661 */
1900 : 141 : break;
1901 : :
1902 : : case 55:
1903 : : #line 392 "parse_netlist.y" /* yacc.c:1661 */
1904 : : {
1905 : : (yyval.con) = new eqn::constant (eqn::TAG_COMPLEX);
1906 : : (yyval.con)->c = new nr_complex_t (0.0, (yyvsp[0].d));
1907 : : }
1908 : : #line 1909 "parse_netlist.cpp" /* yacc.c:1661 */
1909 : 0 : break;
1910 : :
1911 : : case 56:
1912 : : #line 396 "parse_netlist.y" /* yacc.c:1661 */
1913 : : {
1914 : : (yyval.con) = new eqn::constant (eqn::TAG_CHAR);
1915 : : (yyval.con)->chr = (yyvsp[0].chr);
1916 : : }
1917 : : #line 1918 "parse_netlist.cpp" /* yacc.c:1661 */
1918 : 0 : break;
1919 : :
1920 : : case 57:
1921 : : #line 400 "parse_netlist.y" /* yacc.c:1661 */
1922 : : {
1923 : : (yyval.con) = new eqn::constant (eqn::TAG_STRING);
1924 : : (yyval.con)->s = (yyvsp[0].str);
1925 : : }
1926 : : #line 1927 "parse_netlist.cpp" /* yacc.c:1661 */
1927 : 0 : break;
1928 : :
1929 : : case 58:
1930 : : #line 407 "parse_netlist.y" /* yacc.c:1661 */
1931 : : {
1932 : : (yyval.app) = new eqn::application ();
1933 : : (yyval.app)->n = strdup ("range");
1934 : : (yyval.app)->nargs = 2;
1935 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
1936 : : (yyval.app)->args = (yyvsp[-2].eqn);
1937 : : }
1938 : : #line 1939 "parse_netlist.cpp" /* yacc.c:1661 */
1939 : 0 : break;
1940 : :
1941 : : case 59:
1942 : : #line 414 "parse_netlist.y" /* yacc.c:1661 */
1943 : : {
1944 : : (yyval.app) = new eqn::application ();
1945 : : (yyval.app)->n = strdup ("range");
1946 : : (yyval.app)->nargs = 2;
1947 : : eqn::constant * c = new eqn::constant (eqn::TAG_CHAR);
1948 : : c->chr = '?';
1949 : : c->append ((yyvsp[0].eqn));
1950 : : (yyval.app)->args = c;
1951 : : }
1952 : : #line 1953 "parse_netlist.cpp" /* yacc.c:1661 */
1953 : 0 : break;
1954 : :
1955 : : case 60:
1956 : : #line 423 "parse_netlist.y" /* yacc.c:1661 */
1957 : : {
1958 : : (yyval.app) = new eqn::application ();
1959 : : (yyval.app)->n = strdup ("range");
1960 : : (yyval.app)->nargs = 2;
1961 : : eqn::constant * c = new eqn::constant (eqn::TAG_CHAR);
1962 : : c->chr = '?';
1963 : : (yyvsp[-1].eqn)->append (c);
1964 : : (yyval.app)->args = (yyvsp[-1].eqn);
1965 : : }
1966 : : #line 1967 "parse_netlist.cpp" /* yacc.c:1661 */
1967 : 0 : break;
1968 : :
1969 : : case 61:
1970 : : #line 432 "parse_netlist.y" /* yacc.c:1661 */
1971 : : {
1972 : : (yyval.app) = new eqn::application ();
1973 : : (yyval.app)->n = strdup ("range");
1974 : : (yyval.app)->nargs = 2;
1975 : : eqn::constant * c1 = new eqn::constant (eqn::TAG_CHAR);
1976 : : eqn::constant * c2 = new eqn::constant (eqn::TAG_CHAR);
1977 : : c1->chr = '?';
1978 : : c2->chr = '?';
1979 : : c1->append (c2);
1980 : : (yyval.app)->args = c1;
1981 : : }
1982 : : #line 1983 "parse_netlist.cpp" /* yacc.c:1661 */
1983 : 0 : break;
1984 : :
1985 : : case 62:
1986 : : #line 446 "parse_netlist.y" /* yacc.c:1661 */
1987 : : {
1988 : : (yyval.ref) = new eqn::reference ();
1989 : : (yyval.ref)->n = (yyvsp[0].ident);
1990 : : }
1991 : : #line 1992 "parse_netlist.cpp" /* yacc.c:1661 */
1992 : 259 : break;
1993 : :
1994 : : case 63:
1995 : : #line 453 "parse_netlist.y" /* yacc.c:1661 */
1996 : : {
1997 : : (yyval.app) = new eqn::application ();
1998 : : (yyval.app)->n = (yyvsp[-3].ident);
1999 : : (yyval.app)->nargs = (yyvsp[-1].eqn)->count ();
2000 : : (yyval.app)->args = (yyvsp[-1].eqn);
2001 : : }
2002 : : #line 2003 "parse_netlist.cpp" /* yacc.c:1661 */
2003 : 115 : break;
2004 : :
2005 : : case 64:
2006 : : #line 459 "parse_netlist.y" /* yacc.c:1661 */
2007 : : {
2008 : : (yyval.app) = new eqn::application ();
2009 : : (yyval.app)->n = strdup ("array");
2010 : : (yyval.app)->nargs = 1 + (yyvsp[-1].eqn)->count ();
2011 : : (yyvsp[-3].ref)->setNext ((yyvsp[-1].eqn));
2012 : : (yyval.app)->args = (yyvsp[-3].ref);
2013 : : }
2014 : : #line 2015 "parse_netlist.cpp" /* yacc.c:1661 */
2015 : 26 : break;
2016 : :
2017 : : case 65:
2018 : : #line 466 "parse_netlist.y" /* yacc.c:1661 */
2019 : : {
2020 : : (yyval.app) = new eqn::application ();
2021 : : (yyval.app)->n = strdup ("+");
2022 : : (yyval.app)->nargs = 2;
2023 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2024 : : (yyval.app)->args = (yyvsp[-2].eqn);
2025 : : }
2026 : : #line 2027 "parse_netlist.cpp" /* yacc.c:1661 */
2027 : 3 : break;
2028 : :
2029 : : case 66:
2030 : : #line 473 "parse_netlist.y" /* yacc.c:1661 */
2031 : : {
2032 : : (yyval.app) = new eqn::application ();
2033 : : (yyval.app)->n = strdup ("-");
2034 : : (yyval.app)->nargs = 2;
2035 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2036 : : (yyval.app)->args = (yyvsp[-2].eqn);
2037 : : }
2038 : : #line 2039 "parse_netlist.cpp" /* yacc.c:1661 */
2039 : 35 : break;
2040 : :
2041 : : case 67:
2042 : : #line 480 "parse_netlist.y" /* yacc.c:1661 */
2043 : : {
2044 : : (yyval.app) = new eqn::application ();
2045 : : (yyval.app)->n = strdup ("*");
2046 : : (yyval.app)->nargs = 2;
2047 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2048 : : (yyval.app)->args = (yyvsp[-2].eqn);
2049 : : }
2050 : : #line 2051 "parse_netlist.cpp" /* yacc.c:1661 */
2051 : 48 : break;
2052 : :
2053 : : case 68:
2054 : : #line 487 "parse_netlist.y" /* yacc.c:1661 */
2055 : : {
2056 : : (yyval.app) = new eqn::application ();
2057 : : (yyval.app)->n = strdup ("/");
2058 : : (yyval.app)->nargs = 2;
2059 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2060 : : (yyval.app)->args = (yyvsp[-2].eqn);
2061 : : }
2062 : : #line 2063 "parse_netlist.cpp" /* yacc.c:1661 */
2063 : 27 : break;
2064 : :
2065 : : case 69:
2066 : : #line 494 "parse_netlist.y" /* yacc.c:1661 */
2067 : : {
2068 : : (yyval.app) = new eqn::application ();
2069 : : (yyval.app)->n = strdup ("%");
2070 : : (yyval.app)->nargs = 2;
2071 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2072 : : (yyval.app)->args = (yyvsp[-2].eqn);
2073 : : }
2074 : : #line 2075 "parse_netlist.cpp" /* yacc.c:1661 */
2075 : 0 : break;
2076 : :
2077 : : case 70:
2078 : : #line 501 "parse_netlist.y" /* yacc.c:1661 */
2079 : : {
2080 : : (yyval.app) = new eqn::application ();
2081 : : (yyval.app)->n = strdup ("+");
2082 : : (yyval.app)->nargs = 1;
2083 : : (yyval.app)->args = (yyvsp[0].eqn);
2084 : : }
2085 : : #line 2086 "parse_netlist.cpp" /* yacc.c:1661 */
2086 : 0 : break;
2087 : :
2088 : : case 71:
2089 : : #line 507 "parse_netlist.y" /* yacc.c:1661 */
2090 : : {
2091 : : (yyval.app) = new eqn::application ();
2092 : : (yyval.app)->n = strdup ("-");
2093 : : (yyval.app)->nargs = 1;
2094 : : (yyval.app)->args = (yyvsp[0].eqn);
2095 : : }
2096 : : #line 2097 "parse_netlist.cpp" /* yacc.c:1661 */
2097 : 10 : break;
2098 : :
2099 : : case 72:
2100 : : #line 513 "parse_netlist.y" /* yacc.c:1661 */
2101 : : {
2102 : : (yyval.app) = new eqn::application ();
2103 : : (yyval.app)->n = strdup ("^");
2104 : : (yyval.app)->nargs = 2;
2105 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2106 : : (yyval.app)->args = (yyvsp[-2].eqn);
2107 : : }
2108 : : #line 2109 "parse_netlist.cpp" /* yacc.c:1661 */
2109 : 0 : break;
2110 : :
2111 : : case 73:
2112 : : #line 520 "parse_netlist.y" /* yacc.c:1661 */
2113 : : {
2114 : : (yyval.app) = new eqn::application ();
2115 : : (yyval.app)->n = strdup ("?:");
2116 : : (yyval.app)->nargs = 3;
2117 : : (yyvsp[-4].eqn)->append ((yyvsp[-2].eqn));
2118 : : (yyvsp[-4].eqn)->append ((yyvsp[0].eqn));
2119 : : (yyval.app)->args = (yyvsp[-4].eqn);
2120 : : }
2121 : : #line 2122 "parse_netlist.cpp" /* yacc.c:1661 */
2122 : 0 : break;
2123 : :
2124 : : case 74:
2125 : : #line 528 "parse_netlist.y" /* yacc.c:1661 */
2126 : : {
2127 : : (yyval.app) = new eqn::application ();
2128 : : (yyval.app)->n = strdup ("<");
2129 : : (yyval.app)->nargs = 2;
2130 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2131 : : (yyval.app)->args = (yyvsp[-2].eqn);
2132 : : }
2133 : : #line 2134 "parse_netlist.cpp" /* yacc.c:1661 */
2134 : 21 : break;
2135 : :
2136 : : case 75:
2137 : : #line 535 "parse_netlist.y" /* yacc.c:1661 */
2138 : : {
2139 : : (yyval.app) = new eqn::application ();
2140 : : (yyval.app)->n = strdup (">");
2141 : : (yyval.app)->nargs = 2;
2142 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2143 : : (yyval.app)->args = (yyvsp[-2].eqn);
2144 : : }
2145 : : #line 2146 "parse_netlist.cpp" /* yacc.c:1661 */
2146 : 0 : break;
2147 : :
2148 : : case 76:
2149 : : #line 542 "parse_netlist.y" /* yacc.c:1661 */
2150 : : {
2151 : : (yyval.app) = new eqn::application ();
2152 : : (yyval.app)->n = strdup (">=");
2153 : : (yyval.app)->nargs = 2;
2154 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2155 : : (yyval.app)->args = (yyvsp[-2].eqn);
2156 : : }
2157 : : #line 2158 "parse_netlist.cpp" /* yacc.c:1661 */
2158 : 0 : break;
2159 : :
2160 : : case 77:
2161 : : #line 549 "parse_netlist.y" /* yacc.c:1661 */
2162 : : {
2163 : : (yyval.app) = new eqn::application ();
2164 : : (yyval.app)->n = strdup ("<=");
2165 : : (yyval.app)->nargs = 2;
2166 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2167 : : (yyval.app)->args = (yyvsp[-2].eqn);
2168 : : }
2169 : : #line 2170 "parse_netlist.cpp" /* yacc.c:1661 */
2170 : 0 : break;
2171 : :
2172 : : case 78:
2173 : : #line 556 "parse_netlist.y" /* yacc.c:1661 */
2174 : : {
2175 : : (yyval.app) = new eqn::application ();
2176 : : (yyval.app)->n = strdup ("==");
2177 : : (yyval.app)->nargs = 2;
2178 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2179 : : (yyval.app)->args = (yyvsp[-2].eqn);
2180 : : }
2181 : : #line 2182 "parse_netlist.cpp" /* yacc.c:1661 */
2182 : 0 : break;
2183 : :
2184 : : case 79:
2185 : : #line 563 "parse_netlist.y" /* yacc.c:1661 */
2186 : : {
2187 : : (yyval.app) = new eqn::application ();
2188 : : (yyval.app)->n = strdup ("!=");
2189 : : (yyval.app)->nargs = 2;
2190 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2191 : : (yyval.app)->args = (yyvsp[-2].eqn);
2192 : : }
2193 : : #line 2194 "parse_netlist.cpp" /* yacc.c:1661 */
2194 : 0 : break;
2195 : :
2196 : : case 80:
2197 : : #line 570 "parse_netlist.y" /* yacc.c:1661 */
2198 : : {
2199 : : (yyval.app) = new eqn::application ();
2200 : : (yyval.app)->n = strdup ("!");
2201 : : (yyval.app)->nargs = 1;
2202 : : (yyval.app)->args = (yyvsp[0].eqn);
2203 : : }
2204 : : #line 2205 "parse_netlist.cpp" /* yacc.c:1661 */
2205 : 0 : break;
2206 : :
2207 : : case 81:
2208 : : #line 576 "parse_netlist.y" /* yacc.c:1661 */
2209 : : {
2210 : : (yyval.app) = new eqn::application ();
2211 : : (yyval.app)->n = strdup ("&&");
2212 : : (yyval.app)->nargs = 2;
2213 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2214 : : (yyval.app)->args = (yyvsp[-2].eqn);
2215 : : }
2216 : : #line 2217 "parse_netlist.cpp" /* yacc.c:1661 */
2217 : 0 : break;
2218 : :
2219 : : case 82:
2220 : : #line 583 "parse_netlist.y" /* yacc.c:1661 */
2221 : : {
2222 : : (yyval.app) = new eqn::application ();
2223 : : (yyval.app)->n = strdup ("||");
2224 : : (yyval.app)->nargs = 2;
2225 : : (yyvsp[-2].eqn)->append ((yyvsp[0].eqn));
2226 : : (yyval.app)->args = (yyvsp[-2].eqn);
2227 : : }
2228 : : #line 2229 "parse_netlist.cpp" /* yacc.c:1661 */
2229 : 0 : break;
2230 : :
2231 : : case 83:
2232 : : #line 592 "parse_netlist.y" /* yacc.c:1661 */
2233 : : { (yyval.eqn) = NULL; }
2234 : : #line 2235 "parse_netlist.cpp" /* yacc.c:1661 */
2235 : 0 : break;
2236 : :
2237 : : case 84:
2238 : : #line 593 "parse_netlist.y" /* yacc.c:1661 */
2239 : : {
2240 : : (yyval.eqn) = (yyvsp[0].eqn);
2241 : : }
2242 : : #line 2243 "parse_netlist.cpp" /* yacc.c:1661 */
2243 : 141 : break;
2244 : :
2245 : : case 85:
2246 : : #line 596 "parse_netlist.y" /* yacc.c:1661 */
2247 : : {
2248 : : (yyval.eqn) = (yyvsp[0].app);
2249 : : }
2250 : : #line 2251 "parse_netlist.cpp" /* yacc.c:1661 */
2251 : 0 : break;
2252 : :
2253 : : case 86:
2254 : : #line 599 "parse_netlist.y" /* yacc.c:1661 */
2255 : : {
2256 : : (yyvsp[-2].eqn)->setNext ((yyvsp[0].eqn));
2257 : : (yyval.eqn) = (yyvsp[-2].eqn);
2258 : : }
2259 : : #line 2260 "parse_netlist.cpp" /* yacc.c:1661 */
2260 : 33 : break;
2261 : :
2262 : : case 87:
2263 : : #line 603 "parse_netlist.y" /* yacc.c:1661 */
2264 : : {
2265 : : (yyvsp[-2].app)->setNext ((yyvsp[0].eqn));
2266 : : (yyval.eqn) = (yyvsp[-2].app);
2267 : : }
2268 : : #line 2269 "parse_netlist.cpp" /* yacc.c:1661 */
2269 : 0 : break;
2270 : :
2271 : : case 88:
2272 : : #line 610 "parse_netlist.y" /* yacc.c:1661 */
2273 : : { /* a full subcircuit definition found */
2274 : : (yyvsp[-2].subcircuit)->sub = (yyvsp[-1].definition);
2275 : : (yyval.subcircuit) = (yyvsp[-2].subcircuit);
2276 : : (yyvsp[-1].definition) = NULL;
2277 : : }
2278 : : #line 2279 "parse_netlist.cpp" /* yacc.c:1661 */
2279 : 13 : break;
2280 : :
2281 : : case 89:
2282 : : #line 618 "parse_netlist.y" /* yacc.c:1661 */
2283 : : {
2284 : : /* create subcircuit definition right here */
2285 : : (yyval.subcircuit) = (struct definition_t *) calloc (sizeof (struct definition_t), 1);
2286 : : (yyval.subcircuit)->type = strdup ("Def");
2287 : : (yyval.subcircuit)->instance = (yyvsp[-3].ident);
2288 : : (yyval.subcircuit)->nodes = (yyvsp[-2].node);
2289 : : (yyval.subcircuit)->pairs = (yyvsp[-1].pair);
2290 : : (yyval.subcircuit)->action = PROP_ACTION;
2291 : : (yyval.subcircuit)->line = netlist_lineno;
2292 : : }
2293 : : #line 2294 "parse_netlist.cpp" /* yacc.c:1661 */
2294 : 13 : break;
2295 : :
2296 : : case 90:
2297 : : #line 630 "parse_netlist.y" /* yacc.c:1661 */
2298 : : { (yyval.definition) = NULL; }
2299 : : #line 2300 "parse_netlist.cpp" /* yacc.c:1661 */
2300 : 13 : break;
2301 : :
2302 : : case 91:
2303 : : #line 631 "parse_netlist.y" /* yacc.c:1661 */
2304 : : { /* chain definitions here */
2305 : : if ((yyvsp[-1].definition)) {
2306 : : (yyvsp[-1].definition)->next = (yyvsp[0].definition);
2307 : : (yyval.definition) = (yyvsp[-1].definition);
2308 : : }
2309 : : else {
2310 : : (yyval.definition) = (yyvsp[0].definition);
2311 : : }
2312 : : }
2313 : : #line 2314 "parse_netlist.cpp" /* yacc.c:1661 */
2314 : 86 : break;
2315 : :
2316 : : case 92:
2317 : : #line 643 "parse_netlist.y" /* yacc.c:1661 */
2318 : : { /* nothing to do */ }
2319 : : #line 2320 "parse_netlist.cpp" /* yacc.c:1661 */
2320 : 13 : break;
2321 : :
2322 : : case 93:
2323 : : #line 647 "parse_netlist.y" /* yacc.c:1661 */
2324 : : { /* chain definitions here */
2325 : : (yyvsp[0].definition)->next = (yyval.definition);
2326 : : (yyval.definition) = (yyvsp[0].definition);
2327 : : }
2328 : : #line 2329 "parse_netlist.cpp" /* yacc.c:1661 */
2329 : 86 : break;
2330 : :
2331 : : case 94:
2332 : : #line 651 "parse_netlist.y" /* yacc.c:1661 */
2333 : : { /* chain definitions here */
2334 : : (yyvsp[0].definition)->next = (yyval.definition);
2335 : : (yyval.definition) = (yyvsp[0].definition);
2336 : : }
2337 : : #line 2338 "parse_netlist.cpp" /* yacc.c:1661 */
2338 : 0 : break;
2339 : :
2340 : : case 95:
2341 : : #line 655 "parse_netlist.y" /* yacc.c:1661 */
2342 : : { /* do nothing here, see subcircuit rule */ }
2343 : : #line 2344 "parse_netlist.cpp" /* yacc.c:1661 */
2344 : 0 : break;
2345 : :
2346 : : case 96:
2347 : : #line 656 "parse_netlist.y" /* yacc.c:1661 */
2348 : : {
2349 : : (yyval.definition) = NULL;
2350 : : }
2351 : : #line 2352 "parse_netlist.cpp" /* yacc.c:1661 */
2352 : 0 : break;
2353 : :
2354 : :
2355 : : #line 2356 "parse_netlist.cpp" /* yacc.c:1661 */
2356 : 1067 : default: break;
2357 : : }
2358 : : /* User semantic actions sometimes alter yychar, and that requires
2359 : : that yytoken be updated with the new translation. We take the
2360 : : approach of translating immediately before every use of yytoken.
2361 : : One alternative is translating here after every semantic action,
2362 : : but that translation would be missed if the semantic action invokes
2363 : : YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2364 : : if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2365 : : incorrect destructor might then be invoked immediately. In the
2366 : : case of YYERROR or YYBACKUP, subsequent parser actions might lead
2367 : : to an incorrect destructor call or verbose syntax error message
2368 : : before the lookahead is translated. */
2369 [ - + ][ # # ]: 54291 : YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
[ # # ][ # # ]
2370 : :
2371 : 54291 : YYPOPSTACK (yylen);
2372 : 54291 : yylen = 0;
2373 [ - + ][ # # ]: 54291 : YY_STACK_PRINT (yyss, yyssp);
2374 : :
2375 : 54291 : *++yyvsp = yyval;
2376 : :
2377 : : /* Now 'shift' the result of the reduction. Determine what state
2378 : : that goes to, based on the state we popped back to and the rule
2379 : : number reduced by. */
2380 : :
2381 : 54291 : yyn = yyr1[yyn];
2382 : :
2383 : 54291 : yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2384 [ + + ][ + - ]: 54291 : if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
[ + + ]
2385 : 27825 : yystate = yytable[yystate];
2386 : : else
2387 : 26466 : yystate = yydefgoto[yyn - YYNTOKENS];
2388 : :
2389 : 54291 : goto yynewstate;
2390 : :
2391 : :
2392 : : /*--------------------------------------.
2393 : : | yyerrlab -- here on detecting error. |
2394 : : `--------------------------------------*/
2395 : : yyerrlab:
2396 : : /* Make sure we have latest lookahead translation. See comments at
2397 : : user semantic actions for why this is necessary. */
2398 [ # # ][ # # ]: 0 : yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2399 : :
2400 : : /* If not already recovering from an error, report this error. */
2401 [ # # ]: 0 : if (!yyerrstatus)
2402 : : {
2403 : 0 : ++yynerrs;
2404 : : #if ! YYERROR_VERBOSE
2405 : : yyerror (YY_("syntax error"));
2406 : : #else
2407 : : # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2408 : : yyssp, yytoken)
2409 : : {
2410 : 0 : char const *yymsgp = YY_("syntax error");
2411 : : int yysyntax_error_status;
2412 : 0 : yysyntax_error_status = YYSYNTAX_ERROR;
2413 [ # # ]: 0 : if (yysyntax_error_status == 0)
2414 : 0 : yymsgp = yymsg;
2415 [ # # ]: 0 : else if (yysyntax_error_status == 1)
2416 : : {
2417 [ # # ]: 0 : if (yymsg != yymsgbuf)
2418 : 0 : YYSTACK_FREE (yymsg);
2419 : 0 : yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2420 [ # # ]: 0 : if (!yymsg)
2421 : : {
2422 : 0 : yymsg = yymsgbuf;
2423 : 0 : yymsg_alloc = sizeof yymsgbuf;
2424 : 0 : yysyntax_error_status = 2;
2425 : : }
2426 : : else
2427 : : {
2428 : 0 : yysyntax_error_status = YYSYNTAX_ERROR;
2429 : 0 : yymsgp = yymsg;
2430 : : }
2431 : : }
2432 [ # # ]: 0 : yyerror (yymsgp);
2433 [ # # ]: 0 : if (yysyntax_error_status == 2)
2434 : 0 : goto yyexhaustedlab;
2435 : : }
2436 : : # undef YYSYNTAX_ERROR
2437 : : #endif
2438 : : }
2439 : :
2440 : :
2441 : :
2442 [ # # ]: 0 : if (yyerrstatus == 3)
2443 : : {
2444 : : /* If just tried and failed to reuse lookahead token after an
2445 : : error, discard it. */
2446 : :
2447 [ # # ]: 0 : if (yychar <= YYEOF)
2448 : : {
2449 : : /* Return failure if at end of input. */
2450 [ # # ]: 0 : if (yychar == YYEOF)
2451 : 0 : YYABORT;
2452 : : }
2453 : : else
2454 : : {
2455 : : yydestruct ("Error: discarding",
2456 [ # # ]: 0 : yytoken, &yylval);
2457 : 0 : yychar = YYEMPTY;
2458 : : }
2459 : : }
2460 : :
2461 : : /* Else will try to reuse lookahead token after shifting the error
2462 : : token. */
2463 : 0 : goto yyerrlab1;
2464 : :
2465 : :
2466 : : /*---------------------------------------------------.
2467 : : | yyerrorlab -- error raised explicitly by YYERROR. |
2468 : : `---------------------------------------------------*/
2469 : : yyerrorlab:
2470 : :
2471 : : /* Pacify compilers like GCC when the user code never invokes
2472 : : YYERROR and the label yyerrorlab therefore never appears in user
2473 : : code. */
2474 : : if (/*CONSTCOND*/ 0)
2475 : : goto yyerrorlab;
2476 : :
2477 : : /* Do not reclaim the symbols of the rule whose action triggered
2478 : : this YYERROR. */
2479 : : YYPOPSTACK (yylen);
2480 : : yylen = 0;
2481 : : YY_STACK_PRINT (yyss, yyssp);
2482 : : yystate = *yyssp;
2483 : : goto yyerrlab1;
2484 : :
2485 : :
2486 : : /*-------------------------------------------------------------.
2487 : : | yyerrlab1 -- common code for both syntax error and YYERROR. |
2488 : : `-------------------------------------------------------------*/
2489 : : yyerrlab1:
2490 : 0 : yyerrstatus = 3; /* Each real token shifted decrements this. */
2491 : :
2492 : 0 : for (;;)
2493 : : {
2494 : 0 : yyn = yypact[yystate];
2495 [ # # ]: 0 : if (!yypact_value_is_default (yyn))
2496 : : {
2497 : 0 : yyn += YYTERROR;
2498 [ # # ][ # # ]: 0 : if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
[ # # ]
2499 : : {
2500 : 0 : yyn = yytable[yyn];
2501 [ # # ]: 0 : if (0 < yyn)
2502 : 0 : break;
2503 : : }
2504 : : }
2505 : :
2506 : : /* Pop the current state because it cannot handle the error token. */
2507 [ # # ]: 0 : if (yyssp == yyss)
2508 : 0 : YYABORT;
2509 : :
2510 : :
2511 : : yydestruct ("Error: popping",
2512 [ # # ]: 0 : yystos[yystate], yyvsp);
2513 : 0 : YYPOPSTACK (1);
2514 : 0 : yystate = *yyssp;
2515 [ # # ][ # # ]: 0 : YY_STACK_PRINT (yyss, yyssp);
2516 : : }
2517 : :
2518 : : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2519 : 0 : *++yyvsp = yylval;
2520 : : YY_IGNORE_MAYBE_UNINITIALIZED_END
2521 : :
2522 : :
2523 : : /* Shift the error token. */
2524 [ # # ][ # # ]: 0 : YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
[ # # ][ # # ]
2525 : :
2526 : 0 : yystate = yyn;
2527 : 0 : goto yynewstate;
2528 : :
2529 : :
2530 : : /*-------------------------------------.
2531 : : | yyacceptlab -- YYACCEPT comes here. |
2532 : : `-------------------------------------*/
2533 : : yyacceptlab:
2534 : 103 : yyresult = 0;
2535 : 103 : goto yyreturn;
2536 : :
2537 : : /*-----------------------------------.
2538 : : | yyabortlab -- YYABORT comes here. |
2539 : : `-----------------------------------*/
2540 : : yyabortlab:
2541 : 0 : yyresult = 1;
2542 : 0 : goto yyreturn;
2543 : :
2544 : : #if !defined yyoverflow || YYERROR_VERBOSE
2545 : : /*-------------------------------------------------.
2546 : : | yyexhaustedlab -- memory exhaustion comes here. |
2547 : : `-------------------------------------------------*/
2548 : : yyexhaustedlab:
2549 [ # # ]: 0 : yyerror (YY_("memory exhausted"));
2550 : 0 : yyresult = 2;
2551 : : /* Fall through. */
2552 : : #endif
2553 : :
2554 : : yyreturn:
2555 [ - + ]: 103 : if (yychar != YYEMPTY)
2556 : : {
2557 : : /* Make sure we have latest lookahead translation. See comments at
2558 : : user semantic actions for why this is necessary. */
2559 [ # # ]: 0 : yytoken = YYTRANSLATE (yychar);
2560 : : yydestruct ("Cleanup: discarding lookahead",
2561 [ # # ]: 0 : yytoken, &yylval);
2562 : : }
2563 : : /* Do not reclaim the symbols of the rule whose action triggered
2564 : : this YYABORT or YYACCEPT. */
2565 : 103 : YYPOPSTACK (yylen);
2566 [ - + ][ # # ]: 103 : YY_STACK_PRINT (yyss, yyssp);
2567 [ + + ]: 309 : while (yyssp != yyss)
2568 : : {
2569 : : yydestruct ("Cleanup: popping",
2570 [ + - ]: 206 : yystos[*yyssp], yyvsp);
2571 : 206 : YYPOPSTACK (1);
2572 : : }
2573 : : #ifndef yyoverflow
2574 [ + + ]: 103 : if (yyss != yyssa)
2575 : 9 : YYSTACK_FREE (yyss);
2576 : : #endif
2577 : : #if YYERROR_VERBOSE
2578 [ - + ]: 103 : if (yymsg != yymsgbuf)
2579 : 0 : YYSTACK_FREE (yymsg);
2580 : : #endif
2581 : 103 : return yyresult;
2582 : : }
2583 : : #line 662 "parse_netlist.y" /* yacc.c:1906 */
2584 : :
2585 : :
2586 : : int netlist_error (const char * error) {
2587 : : logprint (LOG_ERROR, "line %d: %s\n", netlist_lineno, error);
2588 : : return 0;
2589 : : }
|
