Branch data Line data Source code
1 : : /* -*-c++-*- */
2 : :
3 : : %{
4 : : /*
5 : : * parse_netlist.y - parser for the Qucs netlist
6 : : *
7 : : * Copyright (C) 2003, 2004, 2005, 2006, 2007 Stefan Jahn <stefan@lkcc.org>
8 : : *
9 : : * This is free software; you can redistribute it and/or modify
10 : : * it under the terms of the GNU General Public License as published by
11 : : * the Free Software Foundation; either version 2, or (at your option)
12 : : * any later version.
13 : : *
14 : : * This software is distributed in the hope that it will be useful,
15 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : : * GNU General Public License for more details.
18 : : *
19 : : * You should have received a copy of the GNU General Public License
20 : : * along with this package; see the file COPYING. If not, write to
21 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
22 : : * Boston, MA 02110-1301, USA.
23 : : *
24 : : * $Id$
25 : : *
26 : : */
27 : :
28 : : #if HAVE_CONFIG_H
29 : : # include <config.h>
30 : : #endif
31 : :
32 : : #include <stdio.h>
33 : : #include <stdlib.h>
34 : : #include <string.h>
35 : :
36 : : #define YYERROR_VERBOSE 42
37 : : #define YYDEBUG 1
38 : : #define YYMAXDEPTH 1000000
39 : :
40 : : #include "check_netlist.h"
41 : : #include "logging.h"
42 : : #include "equation.h"
43 : : #include "range.h"
44 : :
45 : : using namespace qucs;
46 : :
47 : : %}
48 : :
49 : : %name-prefix="netlist_"
50 : :
51 : : %token InvalidCharacter
52 : : %token Identifier
53 : : %token Assign
54 : : %token ScaleOrUnit
55 : : %token Eol
56 : : %token Eqn
57 : : %token DefSub
58 : : %token EndSub
59 : : %token REAL
60 : : %token IMAG
61 : : %token COMPLEX
62 : : %token Character
63 : : %token STRING
64 : :
65 : : %right '='
66 : : %right '?' ':'
67 : : %left Or
68 : : %left And
69 : : %left NotEqual Equal
70 : : %left Less Greater LessOrEqual GreaterOrEqual
71 : : %left '-' '+'
72 : : %left '*' '/' '%'
73 : : %right Not
74 : : %left NEG /* unary negation */
75 : : %left POS /* unary non-negation */
76 : : %right '^'
77 : :
78 : : %union {
79 : : char * ident;
80 : : char * str;
81 : : double d;
82 : : char chr;
83 : : struct definition_t * definition;
84 : : struct definition_t * subcircuit;
85 : : struct node_t * node;
86 : : struct pair_t * pair;
87 : : struct value_t * value;
88 : : struct {
89 : : double r;
90 : : double i;
91 : : } c;
92 : : qucs::eqn::node * eqn;
93 : : qucs::eqn::constant * con;
94 : : qucs::eqn::reference * ref;
95 : : qucs::eqn::application * app;
96 : : qucs::eqn::assignment * assign;
97 : : }
98 : :
99 : : %type <ident> Identifier Assign NodeIdentifier InstanceIdentifier
100 : : %type <str> ScaleOrUnit
101 : : %type <d> REAL IMAG
102 : : %type <c> COMPLEX
103 : : %type <chr> Character
104 : : %type <str> STRING
105 : : %type <definition> DefinitionLine ActionLine DefBody DefBodyLine EquationLine
106 : : %type <definition> InputList InputLine
107 : : %type <subcircuit> DefBegin SubcircuitBody
108 : : %type <node> NodeList
109 : : %type <pair> PairList
110 : : %type <value> PropertyValue ValueList Value PropertyReal
111 : : %type <eqn> EquationList Expression ExpressionList
112 : : %type <assign> Equation
113 : : %type <con> Constant
114 : : %type <ref> Reference
115 : : %type <app> Application Range Matrix Vector
116 : : %type <eqn> ExpressionMatrix ExpressionVector
117 : : %type <eqn> ExpressionRowList ExpressionCol ExpressionColList
118 : :
119 : : %%
120 : :
121 : : Input:
122 : : InputList {
123 : 103 : definition_root = $1;
124 : : }
125 : : ;
126 : :
127 : 103 : InputList: /* nothing */ { $$ = NULL; }
128 : : | InputLine InputList {
129 [ + + ]: 1201 : if ($1) {
130 : 1080 : $1->next = $2;
131 : 1080 : $$ = $1;
132 : : } else {
133 : 121 : $$ = $2;
134 : : }
135 : : }
136 : : ;
137 : :
138 : : InputLine:
139 : : SubcircuitBody {
140 : 13 : $$ = $1;
141 : : }
142 : : | EquationLine
143 : : | ActionLine
144 : : | DefinitionLine
145 : : | Eol {
146 : 121 : $$ = NULL;
147 : : }
148 : : ;
149 : :
150 : : /* An action line in the netlist, i.e. the specification of the type
151 : : of simulation to be performed */
152 : : ActionLine:
153 : : '.' Identifier ':' InstanceIdentifier PairList Eol {
154 : 181 : $$ = (struct definition_t *) calloc (sizeof (struct definition_t), 1);
155 : 181 : $$->action = PROP_ACTION;
156 : 181 : $$->type = $2;
157 : 181 : $$->instance = $4;
158 : 181 : $$->pairs = $5;
159 : 181 : $$->line = netlist_lineno;
160 : : }
161 : : ;
162 : :
163 : : /* A definition line in the netlist, i.e. a component specification
164 : : such as R:R1 _net0 gnd R="50 Ohm" Temp="26.85" Tc1="0.0" Tc2="0.0" Tnom="26.85"
165 : : */
166 : : DefinitionLine:
167 : : Identifier ':' InstanceIdentifier NodeList PairList Eol {
168 : 904 : $$ = (struct definition_t *) calloc (sizeof (struct definition_t), 1);
169 : 904 : $$->action = PROP_COMPONENT;
170 : 904 : $$->type = $1;
171 : 904 : $$->instance = $3;
172 : 904 : $$->nodes = $4;
173 : 904 : $$->pairs = $5;
174 : 904 : $$->line = netlist_lineno;
175 : : }
176 : : ;
177 : :
178 : : InstanceIdentifier:
179 : 2103 : Identifier { $$ = $1; }
180 : 3 : | ScaleOrUnit { $$ = $1; }
181 : : ;
182 : :
183 : : NodeIdentifier:
184 : 2099 : Identifier { $$ = $1; }
185 : 16 : | ScaleOrUnit { $$ = $1; }
186 : : ;
187 : :
188 : : /* List of nodes for a component */
189 : 917 : NodeList: /* nothing */ { $$ = NULL; }
190 : : | NodeIdentifier NodeList {
191 : 2115 : $$ = (struct node_t *) calloc (sizeof (struct node_t), 1);
192 : 2115 : $$->node = $1;
193 : 2115 : $$->next = $2;
194 : : }
195 : : ;
196 : :
197 : : /* Assigns the list of key-value pairs x="y" */
198 : 1098 : PairList: /* nothing */ { $$ = NULL; }
199 : : | Assign Value PairList {
200 : 10160 : $$ = (struct pair_t *) calloc (sizeof (struct pair_t), 1);
201 : 10160 : $$->key = $1;
202 : 10160 : $$->value = $2;
203 : 10160 : $$->next = $3;
204 : : }
205 : : | Assign NoneValue PairList {
206 : : if (0) {
207 : : $$ = (struct pair_t *) calloc (sizeof (struct pair_t), 1);
208 : : $$->key = $1;
209 : : $$->value = NULL;
210 : : $$->next = $3;
211 : : } else {
212 : 139 : free ($1);
213 : 139 : $$ = $3;
214 : : }
215 : : }
216 : : ;
217 : :
218 : : /* A empty value in a pair list */
219 : : NoneValue: { /* nothing */ }
220 : : | '"' '"' { /* also nothing */ }
221 : : ;
222 : :
223 : : /* A property value, can either be on its own or enclosed in quotes */
224 : : Value:
225 : : PropertyValue {
226 : 0 : $$ = $1;
227 : : }
228 : : | '"' PropertyValue '"' {
229 : 10160 : $$ = $2;
230 : : }
231 : : ;
232 : :
233 : : PropertyReal:
234 : : REAL {
235 : 7572 : $$ = create_value ();
236 : 7572 : $$->value = $1;
237 : : }
238 : : | REAL ScaleOrUnit {
239 : 1660 : $$ = create_value ();
240 : 1660 : $$->value = $1;
241 : 1660 : $$->scale = $2;
242 : : }
243 : : | REAL ScaleOrUnit ScaleOrUnit {
244 : 0 : $$ = create_value ();
245 : 0 : $$->value = $1;
246 : 0 : $$->scale = $2;
247 : 0 : $$->unit = $3;
248 : : }
249 : : ;
250 : :
251 : : PropertyValue:
252 : : PropertyReal {
253 : 9214 : $$ = $1;
254 : : }
255 : : | InstanceIdentifier {
256 : 940 : $$ = create_value ();
257 : 940 : $$->ident = $1;
258 : : }
259 : : | '[' InstanceIdentifier ']' {
260 : 0 : $$ = create_value ();
261 : 0 : $$->ident = $2;
262 : : }
263 : : | '[' ValueList ']' {
264 : 6 : $$ = $2;
265 : : }
266 : : ;
267 : :
268 : 0 : ValueList: /* nothing */ { $$ = NULL; }
269 : : | PropertyReal {
270 : 6 : $1->next = NULL;
271 : 6 : $$ = $1;
272 : : }
273 : : | PropertyReal ';' ValueList {
274 : 12 : $1->next = $3;
275 : 12 : $$ = $1;
276 : : }
277 : : ;
278 : :
279 : : EquationLine:
280 : : Eqn ':' InstanceIdentifier Equation EquationList Eol {
281 : : /* create equation definition */
282 : 68 : $$ = (struct definition_t *) calloc (sizeof (struct definition_t), 1);
283 [ + - ]: 68 : $$->type = strdup ("Eqn");
284 : 68 : $$->instance = $3;
285 : 68 : $$->action = PROP_ACTION;
286 : 68 : $$->line = netlist_lineno;
287 [ + - ]: 68 : $4->setInstance ($3);
288 : 68 : $4->setNext ($5);
289 [ + - ]: 68 : $4->applyInstance ();
290 : 68 : $$->eqns = $4;
291 : : }
292 : : ;
293 : :
294 : 68 : EquationList: /* nothing */ { $$ = NULL; }
295 : : | Equation EquationList {
296 : 139 : $1->setNext ($2);
297 : 139 : $$ = $1;
298 : : }
299 : : ;
300 : :
301 : : Equation:
302 : : Assign '"' Expression '"' {
303 [ + - ][ + - ]: 207 : $$ = new eqn::assignment ();
304 : 207 : $$->result = $1;
305 : 207 : $$->body = $3;
306 : : }
307 : : ;
308 : :
309 : : Expression:
310 : : Constant {
311 : 141 : $$ = $1;
312 : : }
313 : : | Reference {
314 : 233 : $$ = $1;
315 : : }
316 : : | Application {
317 : 285 : $$ = $1;
318 : : }
319 : : | '(' Expression ')' {
320 : 15 : $$ = $2;
321 : : }
322 : : | '[' Vector ']' {
323 : 0 : $$ = $2;
324 : : }
325 : : | '[' Matrix ']' {
326 : 0 : $$ = $2;
327 : : }
328 : : ;
329 : :
330 : : ExpressionCol:
331 : : Expression ExpressionColList {
332 [ # # ]: 0 : $1->appendNodes ($2);
333 : 0 : $$ = $1;
334 : : }
335 : : ;
336 : :
337 : 0 : ExpressionColList: /* nothing */ { $$ = NULL; }
338 : : | ',' Expression ExpressionColList {
339 [ # # ]: 0 : $2->appendNodes ($3);
340 : 0 : $$ = $2;
341 : : }
342 : : ;
343 : :
344 : : ExpressionVector:
345 : : ExpressionCol
346 : : ;
347 : :
348 : : Vector:
349 : : ExpressionVector {
350 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
351 [ # # ]: 0 : $$->n = strdup ("vector");
352 [ # # ]: 0 : $$->nargs = $1->count ();
353 : 0 : $$->args = $1;
354 : : }
355 : : ;
356 : :
357 : 0 : ExpressionRowList: /* nothing */ { $$ = NULL; }
358 : : | ';' ExpressionCol ExpressionRowList {
359 [ # # ][ # # ]: 0 : eqn::constant * c = new eqn::constant (eqn::TAG_CHAR);
360 : 0 : c->chr = ';';
361 [ # # ]: 0 : c->appendNodes ($2);
362 [ # # ]: 0 : $2->appendNodes ($3);
363 : 0 : $$ = c;
364 : : }
365 : : ;
366 : :
367 : : ExpressionMatrix:
368 : : ExpressionCol ';' ExpressionCol ExpressionRowList {
369 [ # # ][ # # ]: 0 : eqn::constant * c = new eqn::constant (eqn::TAG_CHAR);
370 : 0 : c->chr = ';';
371 [ # # ]: 0 : c->appendNodes ($3);
372 [ # # ]: 0 : $3->appendNodes ($4);
373 [ # # ]: 0 : $1->appendNodes (c);
374 : 0 : $$ = $1;
375 : : }
376 : : ;
377 : :
378 : : Matrix:
379 : : ExpressionMatrix {
380 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
381 [ # # ]: 0 : $$->n = strdup ("matrix");
382 [ # # ]: 0 : $$->nargs = $1->count ();
383 : 0 : $$->args = $1;
384 : : }
385 : : ;
386 : :
387 : : Constant:
388 : : REAL {
389 [ + - ][ + - ]: 141 : $$ = new eqn::constant (eqn::TAG_DOUBLE);
390 : 141 : $$->d = $1;
391 : : }
392 : : | IMAG {
393 [ # # ][ # # ]: 0 : $$ = new eqn::constant (eqn::TAG_COMPLEX);
394 [ # # ]: 0 : $$->c = new nr_complex_t (0.0, $1);
395 : : }
396 : : | Character {
397 [ # # ][ # # ]: 0 : $$ = new eqn::constant (eqn::TAG_CHAR);
398 : 0 : $$->chr = $1;
399 : : }
400 : : | STRING {
401 [ # # ][ # # ]: 0 : $$ = new eqn::constant (eqn::TAG_STRING);
402 : 0 : $$->s = $1;
403 : : }
404 : : ;
405 : :
406 : : Range:
407 : : Expression ':' Expression {
408 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
409 [ # # ]: 0 : $$->n = strdup ("range");
410 : 0 : $$->nargs = 2;
411 [ # # ]: 0 : $1->append ($3);
412 : 0 : $$->args = $1;
413 : : }
414 : : | ':' Expression {
415 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
416 [ # # ]: 0 : $$->n = strdup ("range");
417 : 0 : $$->nargs = 2;
418 [ # # ][ # # ]: 0 : eqn::constant * c = new eqn::constant (eqn::TAG_CHAR);
419 : 0 : c->chr = '?';
420 [ # # ]: 0 : c->append ($2);
421 : 0 : $$->args = c;
422 : : }
423 : : | Expression ':' {
424 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
425 [ # # ]: 0 : $$->n = strdup ("range");
426 : 0 : $$->nargs = 2;
427 [ # # ][ # # ]: 0 : eqn::constant * c = new eqn::constant (eqn::TAG_CHAR);
428 : 0 : c->chr = '?';
429 [ # # ]: 0 : $1->append (c);
430 : 0 : $$->args = $1;
431 : : }
432 : : | ':' {
433 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
434 [ # # ]: 0 : $$->n = strdup ("range");
435 : 0 : $$->nargs = 2;
436 [ # # ][ # # ]: 0 : eqn::constant * c1 = new eqn::constant (eqn::TAG_CHAR);
437 [ # # ][ # # ]: 0 : eqn::constant * c2 = new eqn::constant (eqn::TAG_CHAR);
438 : 0 : c1->chr = '?';
439 : 0 : c2->chr = '?';
440 [ # # ]: 0 : c1->append (c2);
441 : 0 : $$->args = c1;
442 : : }
443 : : ;
444 : :
445 : : Reference:
446 : : Identifier {
447 [ + - ][ + - ]: 259 : $$ = new eqn::reference ();
448 : 259 : $$->n = $1;
449 : : }
450 : : ;
451 : :
452 : : Application:
453 : : Identifier '(' ExpressionList ')' {
454 [ + - ][ + - ]: 115 : $$ = new eqn::application ();
455 : 115 : $$->n = $1;
456 [ + - ]: 115 : $$->nargs = $3->count ();
457 : 115 : $$->args = $3;
458 : : }
459 : : | Reference '[' ExpressionList ']' {
460 [ + - ][ + - ]: 26 : $$ = new eqn::application ();
461 [ + - ]: 26 : $$->n = strdup ("array");
462 [ + - ]: 26 : $$->nargs = 1 + $3->count ();
463 : 26 : $1->setNext ($3);
464 : 26 : $$->args = $1;
465 : : }
466 : : | Expression '+' Expression {
467 [ + - ][ + - ]: 3 : $$ = new eqn::application ();
468 [ + - ]: 3 : $$->n = strdup ("+");
469 : 3 : $$->nargs = 2;
470 [ + - ]: 3 : $1->append ($3);
471 : 3 : $$->args = $1;
472 : : }
473 : : | Expression '-' Expression {
474 [ + - ][ + - ]: 35 : $$ = new eqn::application ();
475 [ + - ]: 35 : $$->n = strdup ("-");
476 : 35 : $$->nargs = 2;
477 [ + - ]: 35 : $1->append ($3);
478 : 35 : $$->args = $1;
479 : : }
480 : : | Expression '*' Expression {
481 [ + - ][ + - ]: 48 : $$ = new eqn::application ();
482 [ + - ]: 48 : $$->n = strdup ("*");
483 : 48 : $$->nargs = 2;
484 [ + - ]: 48 : $1->append ($3);
485 : 48 : $$->args = $1;
486 : : }
487 : : | Expression '/' Expression {
488 [ + - ][ + - ]: 27 : $$ = new eqn::application ();
489 [ + - ]: 27 : $$->n = strdup ("/");
490 : 27 : $$->nargs = 2;
491 [ + - ]: 27 : $1->append ($3);
492 : 27 : $$->args = $1;
493 : : }
494 : : | Expression '%' Expression {
495 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
496 [ # # ]: 0 : $$->n = strdup ("%");
497 : 0 : $$->nargs = 2;
498 [ # # ]: 0 : $1->append ($3);
499 : 0 : $$->args = $1;
500 : : }
501 : : | '+' Expression %prec POS {
502 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
503 [ # # ]: 0 : $$->n = strdup ("+");
504 : 0 : $$->nargs = 1;
505 : 0 : $$->args = $2;
506 : : }
507 : : | '-' Expression %prec NEG {
508 [ + - ][ + - ]: 10 : $$ = new eqn::application ();
509 [ + - ]: 10 : $$->n = strdup ("-");
510 : 10 : $$->nargs = 1;
511 : 10 : $$->args = $2;
512 : : }
513 : : | Expression '^' Expression {
514 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
515 [ # # ]: 0 : $$->n = strdup ("^");
516 : 0 : $$->nargs = 2;
517 [ # # ]: 0 : $1->append ($3);
518 : 0 : $$->args = $1;
519 : : }
520 : : | Expression '?' Expression ':' Expression {
521 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
522 [ # # ]: 0 : $$->n = strdup ("?:");
523 : 0 : $$->nargs = 3;
524 [ # # ]: 0 : $1->append ($3);
525 [ # # ]: 0 : $1->append ($5);
526 : 0 : $$->args = $1;
527 : : }
528 : : | Expression Less Expression {
529 [ + - ][ + - ]: 21 : $$ = new eqn::application ();
530 [ + - ]: 21 : $$->n = strdup ("<");
531 : 21 : $$->nargs = 2;
532 [ + - ]: 21 : $1->append ($3);
533 : 21 : $$->args = $1;
534 : : }
535 : : | Expression Greater Expression {
536 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
537 [ # # ]: 0 : $$->n = strdup (">");
538 : 0 : $$->nargs = 2;
539 [ # # ]: 0 : $1->append ($3);
540 : 0 : $$->args = $1;
541 : : }
542 : : | Expression GreaterOrEqual Expression {
543 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
544 [ # # ]: 0 : $$->n = strdup (">=");
545 : 0 : $$->nargs = 2;
546 [ # # ]: 0 : $1->append ($3);
547 : 0 : $$->args = $1;
548 : : }
549 : : | Expression LessOrEqual Expression {
550 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
551 [ # # ]: 0 : $$->n = strdup ("<=");
552 : 0 : $$->nargs = 2;
553 [ # # ]: 0 : $1->append ($3);
554 : 0 : $$->args = $1;
555 : : }
556 : : | Expression Equal Expression {
557 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
558 [ # # ]: 0 : $$->n = strdup ("==");
559 : 0 : $$->nargs = 2;
560 [ # # ]: 0 : $1->append ($3);
561 : 0 : $$->args = $1;
562 : : }
563 : : | Expression NotEqual Expression {
564 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
565 [ # # ]: 0 : $$->n = strdup ("!=");
566 : 0 : $$->nargs = 2;
567 [ # # ]: 0 : $1->append ($3);
568 : 0 : $$->args = $1;
569 : : }
570 : : | Not Expression {
571 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
572 [ # # ]: 0 : $$->n = strdup ("!");
573 : 0 : $$->nargs = 1;
574 : 0 : $$->args = $2;
575 : : }
576 : : | Expression And Expression {
577 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
578 [ # # ]: 0 : $$->n = strdup ("&&");
579 : 0 : $$->nargs = 2;
580 [ # # ]: 0 : $1->append ($3);
581 : 0 : $$->args = $1;
582 : : }
583 : : | Expression Or Expression {
584 [ # # ][ # # ]: 0 : $$ = new eqn::application ();
585 [ # # ]: 0 : $$->n = strdup ("||");
586 : 0 : $$->nargs = 2;
587 [ # # ]: 0 : $1->append ($3);
588 : 0 : $$->args = $1;
589 : : }
590 : : ;
591 : :
592 : 0 : ExpressionList: /* nothing */ { $$ = NULL; }
593 : : | Expression {
594 : 141 : $$ = $1;
595 : : }
596 : : | Range {
597 : 0 : $$ = $1;
598 : : }
599 : : | Expression ',' ExpressionList {
600 : 33 : $1->setNext ($3);
601 : 33 : $$ = $1;
602 : : }
603 : : | Range ',' ExpressionList {
604 : 0 : $1->setNext ($3);
605 : 0 : $$ = $1;
606 : : }
607 : : ;
608 : :
609 : : SubcircuitBody:
610 : : DefBegin DefBody DefEnd { /* a full subcircuit definition found */
611 : 13 : $1->sub = $2;
612 : 13 : $$ = $1;
613 : 13 : $2 = NULL;
614 : : }
615 : : ;
616 : :
617 : : DefBegin:
618 : : DefSub InstanceIdentifier NodeList PairList Eol {
619 : : /* create subcircuit definition right here */
620 : 13 : $$ = (struct definition_t *) calloc (sizeof (struct definition_t), 1);
621 [ + - ]: 13 : $$->type = strdup ("Def");
622 : 13 : $$->instance = $2;
623 : 13 : $$->nodes = $3;
624 : 13 : $$->pairs = $4;
625 : 13 : $$->action = PROP_ACTION;
626 : 13 : $$->line = netlist_lineno;
627 : : }
628 : : ;
629 : :
630 : 13 : DefBody: /* nothing */ { $$ = NULL; }
631 : : | DefBodyLine DefBody { /* chain definitions here */
632 [ + - ]: 86 : if ($1) {
633 : 86 : $1->next = $2;
634 : 86 : $$ = $1;
635 : : }
636 : : else {
637 : 0 : $$ = $2;
638 : : }
639 : : }
640 : : ;
641 : :
642 : : DefEnd:
643 : : EndSub Eol { /* nothing to do */ }
644 : : ;
645 : :
646 : : DefBodyLine:
647 : : DefinitionLine { /* chain definitions here */
648 : 86 : $1->next = $$;
649 : 86 : $$ = $1;
650 : : }
651 : : | EquationLine { /* chain definitions here */
652 : 0 : $1->next = $$;
653 : 0 : $$ = $1;
654 : : }
655 : : | SubcircuitBody { /* do nothing here, see subcircuit rule */ }
656 : : | Eol {
657 : 0 : $$ = NULL;
658 : : }
659 : : ;
660 : :
661 : :
662 : : %%
663 : :
664 : 0 : int netlist_error (const char * error) {
665 : 0 : logprint (LOG_ERROR, "line %d: %s\n", netlist_lineno, error);
666 : 0 : return 0;
667 : : }
|
