Branch data Line data Source code
1 : : /*
2 : : * net.cpp - net class implementation
3 : : *
4 : : * Copyright (C) 2003, 2004, 2005, 2006, 2007 Stefan Jahn <stefan@lkcc.org>
5 : : *
6 : : * This is free software; you can redistribute it and/or modify
7 : : * it under the terms of the GNU General Public License as published by
8 : : * the Free Software Foundation; either version 2, or (at your option)
9 : : * any later version.
10 : : *
11 : : * This software is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with this package; see the file COPYING. If not, write to
18 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19 : : * Boston, MA 02110-1301, USA.
20 : : *
21 : : * $Id$
22 : : *
23 : : */
24 : :
25 : : #if HAVE_CONFIG_H
26 : : # include <config.h>
27 : : #endif
28 : :
29 : : #include <stdio.h>
30 : : #include <stdlib.h>
31 : : #include <string.h>
32 : : #include <assert.h>
33 : :
34 : : #include "logging.h"
35 : : #include "complex.h"
36 : : #include "object.h"
37 : : #include "node.h"
38 : : #include "circuit.h"
39 : : #include "strlist.h"
40 : : #include "vector.h"
41 : : #include "dataset.h"
42 : : #include "net.h"
43 : : #include "tee.h"
44 : : #include "open.h"
45 : : #include "itrafo.h"
46 : : #include "ptrlist.h"
47 : : #include "analysis.h"
48 : : #include "nodelist.h"
49 : : #include "nodeset.h"
50 : : #include "equation.h"
51 : : #include "environment.h"
52 : : #include "component_id.h"
53 : :
54 : : namespace qucs {
55 : :
56 : : // Constructor creates an unnamed instance of the net class.
57 : 0 : net::net () : object () {
58 : 0 : root = drop = NULL;
59 : 0 : nPorts = nCircuits = nSources = 0;
60 : 0 : insertedNodes = inserted = reduced = 0;
61 [ # # ]: 0 : actions = new ptrlist<analysis> ();
[ # # # # ]
[ # # ]
62 [ # # ][ # # ]: 0 : orgacts = new ptrlist<analysis> ();
[ # # ][ # # ]
63 : 0 : env = NULL;
64 : 0 : nset = NULL;
65 : 0 : srcFactor = 1;
66 : 0 : }
67 : :
68 : : // Constructor creates a named instance of the net class.
69 : 103 : net::net (const char * n) : object (n) {
70 : 103 : root = drop = NULL;
71 : 103 : nPorts = nCircuits = nSources = 0;
72 : 103 : insertedNodes = inserted = reduced = 0;
73 [ + - ]: 103 : actions = new ptrlist<analysis> ();
[ + - # # ]
[ # # ]
74 [ + - ][ + - ]: 103 : orgacts = new ptrlist<analysis> ();
[ # # ][ # # ]
75 : 103 : env = NULL;
76 : 103 : nset = NULL;
77 : 103 : srcFactor = 1;
78 : 103 : }
79 : :
80 : : // Destructor deletes the net class object.
81 : 103 : net::~net () {
82 : : circuit * n;
83 : : // delete each and every circuit
84 [ + + ][ # # ]: 1212 : for (circuit * c = root; c != NULL; c = n) {
85 : 1109 : n = (circuit *) c->getNext ();
86 [ + - ]: 1109 : delete c;
[ + - # # ]
[ # # ]
87 : : }
88 : : // delete original actions
89 [ + + ][ # # ]: 284 : for(auto * element : *orgacts) {
90 [ + - ]: 181 : delete element;
[ + - # # ]
[ # # ]
91 : 181 : element = nullptr;
92 : : }
93 : :
94 [ + - ][ # # ]: 103 : delete orgacts;
95 : : // delete nodeset
96 [ + - ][ # # ]: 103 : delNodeset ();
97 [ + - ][ # # ]: 103 : delete actions;
98 [ - + ][ # # ]: 206 : }
99 : :
100 : : /* The copy constructor creates a new instance of the net class based
101 : : on the given net object. */
102 : 0 : net::net (net & n) : object (n) {
103 : 0 : root = drop = NULL;
104 : 0 : nPorts = nCircuits = nSources = 0;
105 : 0 : insertedNodes = inserted = reduced = 0;
106 [ # # ][ # # ]: 0 : actions = n.actions ? new ptrlist<analysis> (*n.actions) : NULL;
[ # # ][ # # ]
[ # # ][ # # ]
107 [ # # ][ # # ]: 0 : orgacts = new ptrlist<analysis> ();
[ # # ][ # # ]
108 : 0 : env = n.env;
109 : 0 : nset = NULL;
110 : 0 : srcFactor = 1;
111 : 0 : }
112 : :
113 : : /* This function prepends the given circuit to the list of registered
114 : : circuits. */
115 : 243460 : void net::insertCircuit (circuit * c) {
116 : : #if 0
117 : : assert (!containsCircuit (c));
118 : : #endif
119 : :
120 : : // chain circuit appropriately
121 [ + + ]: 243460 : if (root) root->setPrev (c);
122 : 243460 : c->setNext (root);
123 : 243460 : c->setPrev (NULL);
124 : 243460 : root = c;
125 : 243460 : nCircuits++;
126 : 243460 : c->setEnabled (1);
127 : 243460 : c->setNet (this);
128 : :
129 : : /* handle AC power sources as s-parameter ports if it is not part of
130 : : a subcircuit */
131 [ + + ][ + - ]: 243460 : if (c->getType () == CIR_PAC && c->getSubcircuit () == NULL) {
[ + + ]
132 : 40 : nPorts++;
133 [ + - ]: 40 : if (!c->getPort ()) c->setPort (c->getPropertyInteger ("Num"));
134 : : }
135 : : // handle DC voltage sources
136 [ + + ]: 243460 : if (c->getVoltageSources () > 0) {
137 [ + + ]: 23034 : if (c->getVoltageSource () < 0) c->setVoltageSource (nSources);
138 : 23034 : nSources += c->getVoltageSources ();
139 : : }
140 : 243460 : }
141 : :
142 : : /* The function removes the given circuit from the list of registered
143 : : circuits. */
144 : 242351 : void net::removeCircuit (circuit * c, int dropping) {
145 : : #if 0
146 : : assert (containsCircuit (c));
147 : : #endif
148 : :
149 : : // adjust the circuit chain appropriately
150 [ + + ]: 242351 : if (c == root) {
151 : 76491 : root = (circuit *) c->getNext ();
152 [ + - ]: 76491 : if (root) root->setPrev (NULL);
153 : : }
154 : : else {
155 [ + + ]: 165860 : if (c->getNext ()) c->getNext()->setPrev (c->getPrev ());
156 : 165860 : c->getPrev()->setNext (c->getNext ());
157 : : }
158 : 242351 : nCircuits--;
159 : 242351 : c->setEnabled (0);
160 : 242351 : c->setNet (NULL);
161 [ - + ]: 242351 : if (c->getPort ()) nPorts--;
162 [ + + ]: 242351 : if (c->getVoltageSource () >= 0) nSources -= c->getVoltageSources ();
163 : :
164 : : // shift the circuit object to the drop list
165 [ + + ]: 242351 : if (c->isOriginal ()) {
166 [ + + ]: 117472 : if (dropping) {
167 [ + + ]: 117454 : if (drop) drop->setPrev (c);
168 : 117454 : c->setNext (drop);
169 : 117454 : c->setPrev (NULL);
170 : 117454 : drop = c;
171 : : }
172 : : }
173 : : // really destroy the circuit object
174 [ + - ]: 124879 : else delete c;
175 : 242351 : }
176 : :
177 : : /* The function returns non-zero if the given circuit is already part
178 : : of the netlist. It returns zero if not. */
179 : 0 : int net::containsCircuit (circuit * cand) {
180 [ # # ]: 0 : for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ())
181 [ # # ]: 0 : if (c == cand) return 1;
182 : 0 : return 0;
183 : : }
184 : :
185 : : /* This function prepends the given analysis to the list of registered
186 : : analyses. */
187 : 181 : void net::insertAnalysis (analysis * a) {
188 : 181 : orgacts->push_front (a);
189 : 181 : actions->push_front (a);
190 : 181 : }
191 : :
192 : : /* The function removes the given analysis from the list of registered
193 : : analyses. */
194 : 59 : void net::removeAnalysis (analysis * a) {
195 : 59 : actions->remove(a);
196 : 59 : }
197 : :
198 : : /* The function returns the analysis associated with the netlist
199 : : object specified by the given instance name and returns NULL if
200 : : there is no such analysis. */
201 : 201 : analysis * net::findAnalysis (const char * const n) const {
202 [ - + ]: 201 : if (n == NULL) return NULL;
203 [ + + ]: 416 : for (auto *a : *actions) {
204 [ + + ]: 341 : if (!strcmp (a->getName (), n))
205 : 126 : return a;
206 : : }
207 : 201 : return NULL;
208 : : }
209 : :
210 : : /* The function returns the analysis associated with the netlist
211 : : object specified by the given type of analysis and returns NULL if
212 : : there is no such analysis. */
213 : 103 : analysis * net::findAnalysis (int type) {
214 [ + + ]: 211 : for (auto *a: *actions) {
215 [ + + ]: 155 : if (a->getType () == type)
216 : 47 : return a;
217 : : }
218 : 103 : return NULL;
219 : : }
220 : :
221 : : /* Looks recursively for a type of analysis. */
222 : 165 : int net::containsAnalysis (analysis * child, int type) {
223 : 165 : ptrlist<analysis> * alist = child->getAnalysis ();
224 [ + + ]: 165 : if(alist != nullptr) {
225 [ + + ]: 158 : for (auto *a : *alist) {
226 [ + + ]: 79 : if (a->getType () == type)
227 : 51 : return 1;
228 [ + + ]: 28 : else if (a->getType () == ANALYSIS_SWEEP)
229 [ + - ]: 20 : return containsAnalysis (a, type);
230 : : }
231 : : }
232 : 165 : return 0;
233 : : }
234 : :
235 : : /* This function runs all registered analyses applied to the current
236 : : netlist, except for external analysis types. */
237 : 103 : dataset * net::runAnalysis (int &err) {
238 [ + - ]: 103 : dataset * out = new dataset ();
239 : :
240 : : // apply some data to all analyses
241 [ + + ]: 284 : for (auto *a : *actions) {
242 [ + - ][ + - ]: 181 : if (!a->isExternal ())
243 : : {
244 : 181 : a->setNet (this);
245 : 181 : a->setData (out);
246 : : }
247 : : }
248 : :
249 : : // re-order analyses
250 : 103 : orderAnalysis ();
251 : :
252 : : // initialize analyses
253 [ + + ]: 225 : for (auto *a: * actions) {
254 [ + - ][ + - ]: 122 : if (!a->isExternal ())
255 : : {
256 [ + - ]: 122 : err |= a->initialize ();
257 : : }
258 : : }
259 : :
260 : : // solve the analyses
261 [ + + ]: 225 : for (auto *a: * actions) {
262 [ + - ][ + - ]: 122 : if (!a->isExternal ())
263 : : {
264 [ + - ]: 122 : a->getEnv()->runSolver ();
265 [ + - ]: 122 : err |= a->solve ();
266 : : }
267 : : }
268 : :
269 : : // cleanup analyses
270 [ + + ]: 225 : for (auto *a: *actions) {
271 [ + - ][ + - ]: 122 : if (!a->isExternal ())
272 : : {
273 [ + - ]: 122 : err |= a->cleanup ();
274 : : }
275 : : }
276 : :
277 : 103 : return out;
278 : : }
279 : :
280 : : /* The function returns the analysis with the second lowest order. If
281 : : there is no recursive sweep it returns NULL. */
282 : 162 : analysis * net::findSecondOrder (void) {
283 : 162 : analysis * parent = NULL;
284 [ + + ]: 323 : for (auto *a : *actions) {
285 : : // parameter sweeps are potential parent sweeps
286 [ + + ]: 220 : if (a->getType () == ANALYSIS_SWEEP) {
287 : : // find the appropriate sub analysis
288 [ + - ]: 118 : analysis * child = getChildAnalysis (a);
289 [ + + ]: 118 : if (child != NULL) {
290 : : // check if child is not another variable sweep
291 [ + + ]: 63 : if (child->getType () != ANALYSIS_SWEEP) {
292 : 39 : parent = a;
293 : 39 : break;
294 : : }
295 : : // check if the child's child is still in the analysis list
296 [ + - ][ + + ]: 24 : else if (getChildAnalysis (child) == NULL) {
297 : 20 : parent = a;
298 : 20 : break;
299 : : }
300 : : }
301 : : }
302 : : }
303 : 162 : return parent;
304 : : }
305 : :
306 : : /* The function reorders (prioritizes) the registered analysis to the
307 : : netlist object. In fact it chains the analyses to be executed in
308 : : a certain order. */
309 : 103 : void net::orderAnalysis (void) {
310 : : analysis * parent, * child;
311 : 103 : analysis * dc = findAnalysis (ANALYSIS_DC);
312 : 103 : int dcApplied = 0;
313 [ + + ]: 162 : do {
314 : : // get second order sweep
315 [ + + ]: 162 : if ((parent = findSecondOrder ()) != NULL) {
316 : 59 : child = getChildAnalysis (parent);
317 : 59 : removeAnalysis (child);
318 : : // apply sub-analysis to each parent analysis if any
319 [ + - ]: 59 : if (actions != nullptr) {
320 [ + + ]: 142 : for (auto *a: *actions) {
321 [ + - ]: 83 : const char * cn = getChild (a);
322 [ + + ][ + + ]: 83 : if (cn != NULL && !strcmp (cn, child->getName ())) {
[ + + ]
323 [ + - ]: 59 : a->addAnalysis (child);
324 : : // apply DC analysis if necessary
325 [ + + + + ]: 87 : if (child->getType () != ANALYSIS_DC &&
[ - + ][ - + ]
326 : 28 : child->getType () != ANALYSIS_SWEEP && dc != NULL) {
327 [ # # ]: 0 : if (!dcApplied)
328 [ # # ]: 0 : removeAnalysis (dc);
329 [ # # ]: 0 : a->addAnalysis (dc);
330 : 0 : dcApplied++;
331 : : }
332 : : }
333 : : }
334 : : }
335 : : // sort the sub-analysis of each parent
336 [ + + ]: 142 : for (auto *a: *actions) {
337 [ + - ]: 83 : sortChildAnalyses (a);
338 : : }
339 : : }
340 : : } while (parent != NULL);
341 : :
342 : : // sort the parent analyses
343 [ + - ]: 103 : parent = new analysis ();
344 : 103 : parent->setAnalysis (actions);
345 : 103 : sortChildAnalyses (parent);
346 [ + - ]: 103 : actions = new ptrlist<analysis> (*(parent->getAnalysis ()));
347 [ + - ]: 103 : delete parent;
348 : 103 : }
349 : :
350 : : // This function sorts the analyses of the given parent analysis.
351 : 186 : void net::sortChildAnalyses (analysis * parent) {
352 : 186 : ptrlist<analysis> * alist = parent->getAnalysis ();
353 [ + + ]: 186 : if (alist != nullptr) {
354 [ + + ]: 354 : for (auto *a: *alist) {
355 [ + + ][ + + ]: 337 : if (a->getType () == ANALYSIS_DC
[ + + ]
356 [ + - ]: 145 : || containsAnalysis (a, ANALYSIS_DC)) {
357 [ + - ]: 98 : parent->delAnalysis (a);
358 [ + - ]: 98 : parent->addAnalysis (a);
359 : : }
360 : : }
361 : : }
362 : 186 : }
363 : :
364 : : // Returns the instance name of the given parents child analysis.
365 : 284 : const char * net::getChild (analysis * parent) const {
366 : 284 : const char * child = NULL;
367 [ + - ][ + + ]: 284 : if (parent != NULL && parent->getType () == ANALYSIS_SWEEP)
[ + + ]
368 : 280 : child = parent->getPropertyString ("Sim");
369 : 284 : return child;
370 : : }
371 : :
372 : : // Returns the child analysis of the given parent if possible.
373 : 201 : analysis * net::getChildAnalysis (analysis * parent) {
374 : 201 : return findAnalysis (getChild (parent));
375 : : }
376 : :
377 : : // Returns the last order sweep being not an parameter sweep.
378 : 0 : analysis * net::findLastOrder (analysis * a) {
379 : 0 : ptrlist<analysis> * alist = a->getAnalysis ();
380 [ # # ]: 0 : analysis * child = alist ? alist->front() : NULL;
381 [ # # ][ # # ]: 0 : if (child != NULL && child->getType () == ANALYSIS_SWEEP) {
[ # # ]
382 : 0 : return findLastOrder (child);
383 : : }
384 [ # # ]: 0 : return child ? child : a;
385 : : }
386 : :
387 : : // Returns the last order sweep being not an parameter sweep.
388 : 22824 : ptrlist<analysis> * net::findLastOrderChildren (analysis * a) {
389 : 22824 : ptrlist<analysis> * alist = a->getAnalysis ();
390 [ + - ]: 22824 : analysis * child = alist ? alist->front() : NULL;
391 [ + - ][ + + ]: 22824 : if (child != NULL && child->getType () == ANALYSIS_SWEEP) {
[ + + ]
392 : 144 : return findLastOrderChildren (child);
393 : : }
394 : 22824 : return alist;
395 : : }
396 : :
397 : : /* The function re-shifts all circuits in the drop list to the actual
398 : : list of circuit objects. */
399 : 5783 : void net::getDroppedCircuits (nodelist * nodes) {
400 : : circuit * n;
401 [ + + ]: 123237 : for (circuit * c = drop; c != NULL; c = n) {
402 : 117454 : n = (circuit *) c->getNext ();
403 [ + - ]: 117454 : if (nodes) nodes->insert (c);
404 : 117454 : insertCircuit (c);
405 : : }
406 : 5783 : drop = NULL;
407 : 5783 : }
408 : :
409 : : /* This function deletes all unnecessary circuits in the list of
410 : : registered circuit objects. */
411 : 5783 : void net::deleteUnusedCircuits (nodelist * nodes) {
412 : : circuit * n;
413 [ + + ]: 141028 : for (circuit * c = root; c != NULL; c = n) {
414 : 135245 : n = (circuit *) c->getNext ();
415 [ + + ]: 135245 : if (!c->isOriginal ()) {
416 [ + - ]: 5884 : if (nodes) nodes->remove (c);
417 : 5884 : removeCircuit (c);
418 : : }
419 : : }
420 : 5783 : }
421 : :
422 : : /* Returns the first node in the list of real circuit objects
423 : : connected to the given node. If there is no such node (unconnected
424 : : node) the function returns NULL. */
425 : 0 : node * net::findConnectedCircuitNode (node * n) {
426 : :
427 : 0 : char * _name = n->getName ();
428 : : node * _node;
429 : :
430 : : // through the list of circuit objects
431 [ # # ]: 0 : for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ()) {
432 : : // skip signal circuits
433 [ # # ]: 0 : if (c->getPort ()) continue;
434 : : // through the list of nodes in a circuit
435 [ # # ]: 0 : for (int i = 0; i < c->getSize (); i++) {
436 : 0 : _node = c->getNode (i);
437 [ # # ]: 0 : if (!strcmp (_node->getName (), _name)) {
438 [ # # ]: 0 : if (_node != n) {
439 : 0 : return _node;
440 : : }
441 : : }
442 : : }
443 : : }
444 : 0 : return NULL;
445 : : }
446 : :
447 : : /* Returns the first node in the list of circuit objects (including
448 : : signals) connected to the given node. If there is no such node
449 : : (unconnected node) the function returns NULL. */
450 : 50308 : node * net::findConnectedNode (node * n) {
451 : :
452 : 50308 : char * _name = n->getName ();
453 : : node * _node;
454 : :
455 [ + + ]: 133648 : for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ()) {
456 [ + + ]: 310410 : for (int i = 0; i < c->getSize (); i++) {
457 : 227070 : _node = c->getNode (i);
458 [ + + ]: 227070 : if (!strcmp (_node->getName (), _name)) {
459 [ + + ]: 100204 : if (_node != n) {
460 : 50302 : return _node;
461 : : }
462 : : }
463 : : }
464 : : }
465 : 50308 : return NULL;
466 : : }
467 : :
468 : : // Rename the given circuit and mark it as being a reduced one.
469 : 124675 : void net::reducedCircuit (circuit * c) {
470 : : char n[32];
471 : 124675 : sprintf (n, "reduced%d", reduced++);
472 [ + - ]: 124675 : c->setName (n);
473 : 124675 : }
474 : :
475 : : /* Rename the given circuit and mark it as being a inserted one and
476 : : remember when it was inserted. */
477 : 204 : void net::insertedCircuit (circuit * c) {
478 : : char n[32];
479 : 204 : sprintf (n, "inserted%d", inserted);
480 [ + - ]: 204 : c->setName (n);
481 : 204 : c->setInserted (inserted);
482 : 204 : inserted++;
483 : 204 : }
484 : :
485 : : // Rename the given node and mark it as being a inserted one.
486 : 284 : void net::insertedNode (node * c) {
487 : : char n[32];
488 : 284 : sprintf (n, "inode%d", insertedNodes++);
489 [ + - ]: 284 : c->setName (n);
490 : 284 : }
491 : :
492 : : /* This helper function checks whether the circuit chain of the
493 : : netlist is properly working. It returns the number of errors or
494 : : zero if there are no errors. */
495 : 0 : int net::checkCircuitChain (void) {
496 : 0 : int error = 0;
497 [ # # ]: 0 : for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ()) {
498 [ # # ]: 0 : if (c->getPrev ())
499 [ # # ]: 0 : if (c->getPrev()->getNext () != c) {
500 : 0 : error++;
501 : : logprint (LOG_ERROR, "ERROR: prev->next != circuit '%s'\n",
502 : 0 : c->getName ());
503 : : }
504 [ # # ]: 0 : if (c->getNext ())
505 [ # # ]: 0 : if (c->getNext()->getPrev () != c) {
506 : 0 : error++;
507 : : logprint (LOG_ERROR, "ERROR: next->prev != circuit '%s'\n",
508 : 0 : c->getName ());
509 : : }
510 : : }
511 : 0 : return error;
512 : : }
513 : :
514 : : /* This function counts the number of signals (ports) within the list
515 : : of registerd circuits. */
516 : 0 : int net::countPorts (void) {
517 : 0 : int count = 0;
518 [ # # ]: 0 : for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ()) {
519 [ # # ]: 0 : if (c->getPort ()) count++;
520 : : }
521 : 0 : return count;
522 : : }
523 : :
524 : : /* This function counts the number of circuits within the list of
525 : : registered circuits. */
526 : 5783 : int net::countNodes (void) {
527 : 5783 : int count = 0;
528 [ + + ]: 135144 : for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ()) {
529 [ + + ]: 129361 : if (!c->getPort ()) count += c->getSize ();
530 : : }
531 : 5783 : return count;
532 : : }
533 : :
534 : : /* The function returns the number of non-linear circuits within the
535 : : list of registered circuits. */
536 : 22386 : int net::isNonLinear (void) {
537 : 22386 : int count = 0;
538 [ + + ]: 138294 : for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ()) {
539 [ + + ]: 115908 : if (c->isNonLinear ()) count++;
540 : : }
541 : 22386 : return count;
542 : : }
543 : :
544 : : /* The function adds the given nodeset object to the netlist's nodeset
545 : : list. */
546 : 2 : void net::addNodeset (nodeset * n) {
547 : 2 : n->setNext (nset);
548 : 2 : nset = n;
549 : 2 : }
550 : :
551 : : /* The following function deletes all the nodeset list of the netlist
552 : : object. Called from the destructor. */
553 : 103 : void net::delNodeset (void) {
554 : : nodeset * next;
555 [ + + ]: 105 : for (nodeset * n = nset; n != NULL; n = next) {
556 : 2 : next = n->getNext ();
557 [ + - ]: 2 : delete n;
558 : : }
559 : 103 : nset = NULL;
560 : 103 : }
561 : :
562 : :
563 : 0 : void net::setActionNetAll(net * subnet)
564 : : {
565 [ # # ]: 0 : for (auto *a : *(this->actions))
566 : 0 : a->setNet(subnet);
567 : 0 : }
568 : :
569 : :
570 : : #if DEBUG
571 : : // DEBUG function: Lists the netlist.
572 : 0 : void net::list (void) {
573 : : logprint (LOG_STATUS, "DEBUG: netlist `%s' (%d circuits, "
574 : : "%d ports, %d nodes)\n", getName (), countPorts (),
575 : 0 : countPorts (), countNodes ());
576 : : // go through circuit list
577 [ # # ]: 0 : for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ()) {
578 : : // list each circuit
579 : 0 : logprint (LOG_STATUS, " %s[", c->getName ());
580 [ # # ]: 0 : for (int i = 0; i < c->getSize (); i++) {
581 : : logprint (LOG_STATUS, "%s-%d",
582 : 0 : c->getNode(i)->getName (), c->getNode(i)->getNode ());
583 [ # # ]: 0 : if (i < c->getSize () - 1)
584 : 0 : logprint (LOG_STATUS, ",");
585 : : }
586 : 0 : logprint (LOG_STATUS, "] { %s }\n", c->propertyList ());
587 : : }
588 : 0 : }
589 : : #endif /* DEBUG */
590 : :
591 : : } // namespace qucs
|
