?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge similar probes within a module.
[iverilog.git] / netlist.cc
blob8b1edfe90af6b1ea870ba021ddd9a5a00c07b77c
1 /*
2 * Copyright (c) 1998-2000 Stephen Williams (steve@icarus.com)
3 *
4 * This source code is free software; you can redistribute it
5 * and/or modify it in source code form under the terms of the GNU
6 * General Public License as published by the Free Software
7 * Foundation; either version 2 of the License, or (at your option)
8 * any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
18 */
19 #if !defined(WINNT) && !defined(macintosh)
20 #ident "$Id: netlist.cc,v 1.127 2000/05/27 19:33:23 steve Exp $"
21 #endif
22
23 # include <cassert>
24 # include <typeinfo>
25 # include "netlist.h"
26 # include "netmisc.h"
27
28 ostream& operator<< (ostream&o, NetNet::Type t)
29 {
30 switch (t) {
31 case NetNet::IMPLICIT:
32 o << "wire /*implicit*/";
33 break;
34 case NetNet::IMPLICIT_REG:
35 o << "reg /*implicit*/";
36 break;
37 case NetNet::INTEGER:
38 o << "integer";
39 break;
40 case NetNet::REG:
41 o << "reg";
42 break;
43 case NetNet::SUPPLY0:
44 o << "supply0";
45 break;
46 case NetNet::SUPPLY1:
47 o << "supply1";
48 break;
49 case NetNet::TRI:
50 o << "tri";
51 break;
52 case NetNet::TRI0:
53 o << "tri0";
54 break;
55 case NetNet::TRI1:
56 o << "tri1";
57 break;
58 case NetNet::TRIAND:
59 o << "triand";
60 break;
61 case NetNet::TRIOR:
62 o << "trior";
63 break;
64 case NetNet::WAND:
65 o << "wand";
66 break;
67 case NetNet::WOR:
68 o << "wor";
69 break;
70 case NetNet::WIRE:
71 o << "wire";
72 break;
73 }
74 return o;
75 }
76
77
78 void connect(Link&l, Link&r)
79 {
80 assert(&l != &r);
81 assert(l.next_->prev_ == &l);
82 assert(l.prev_->next_ == &l);
83 assert(r.next_->prev_ == &r);
84 assert(r.prev_->next_ == &r);
85
86 Link* cur = &l;
87 do {
88 Link*tmp = cur->next_;
89
90 // If I stumble on r in the nexus, then stop now because
91 // we are already connected.
92 if (tmp == &r) break;
93
94 // Pull cur out of left list...
95 cur->prev_->next_ = cur->next_;
96 cur->next_->prev_ = cur->prev_;
97
98 // Put cur in right list
99 cur->next_ = r.next_;
100 cur->prev_ = &r;
101 cur->next_->prev_ = cur;
102 cur->prev_->next_ = cur;
103
104 // Go to the next item in the left list.
105 cur = tmp;
106 } while (cur != &l);
107
108 assert(l.next_->prev_ == &l);
109 assert(l.prev_->next_ == &l);
110 assert(r.next_->prev_ == &r);
111 assert(r.prev_->next_ == &r);
112 }
113
114 Link::Link()
115 : dir_(PASSIVE), drive0_(STRONG), drive1_(STRONG),
116 inst_(0), next_(this), prev_(this)
117 {
118 }
119
120 Link::~Link()
121 {
122 unlink();
123 }
124
125 void Link::set_dir(DIR d)
126 {
127 dir_ = d;
128 }
129
130 Link::DIR Link::get_dir() const
131 {
132 return dir_;
133 }
134
135 void Link::drive0(Link::strength_t str)
136 {
137 drive0_ = str;
138 }
139
140 void Link::drive1(Link::strength_t str)
141 {
142 drive1_ = str;
143 }
144
145 Link::strength_t Link::drive0() const
146 {
147 return drive0_;
148 }
149
150 Link::strength_t Link::drive1() const
151 {
152 return drive1_;
153 }
154
155 void Link::cur_link(NetObj*&net, unsigned &pin)
156 {
157 net = node_;
158 pin = pin_;
159 }
160
161 void Link::unlink()
162 {
163 next_->prev_ = prev_;
164 prev_->next_ = next_;
165 next_ = prev_ = this;
166 }
167
168 bool Link::is_equal(const Link&that) const
169 {
170 return (node_ == that.node_) && (pin_ == that.pin_);
171 }
172
173 bool Link::is_linked() const
174 {
175 return next_ != this;
176 }
177
178 bool Link::is_linked(const NetObj&that) const
179 {
180 for (const Link*idx = next_ ; this != idx ; idx = idx->next_)
181 if (idx->node_ == &that)
182 return true;
183
184 return false;
185 }
186
187 bool Link::is_linked(const Link&that) const
188 {
189 for (const Link*idx = next_ ; this != idx ; idx = idx->next_)
190 if (idx->is_equal(that))
191 return true;
192
193 return false;
194 }
195
196 void Link::next_link(NetObj*&net, unsigned&pin)
197 {
198 assert(next_->prev_ == this);
199 assert(prev_->next_ == this);
200 net = next_->node_;
201 pin = next_->pin_;
202 }
203
204 void Link::next_link(const NetObj*&net, unsigned&pin) const
205 {
206 assert(next_->prev_ == this);
207 assert(prev_->next_ == this);
208 net = next_->node_;
209 pin = next_->pin_;
210 }
211
212 Link* Link::next_link()
213 {
214 assert(next_->prev_ == this);
215 assert(prev_->next_ == this);
216 return next_;
217 }
218
219 const Link* Link::next_link() const
220 {
221 assert(next_->prev_ == this);
222 assert(prev_->next_ == this);
223 return next_;
224 }
225
226 const NetObj*Link::get_obj() const
227 {
228 return node_;
229 }
230
231 NetObj*Link::get_obj()
232 {
233 return node_;
234 }
235
236 unsigned Link::get_pin() const
237 {
238 return pin_;
239 }
240
241 void Link::set_name(const string&n, unsigned i)
242 {
243 name_ = n;
244 inst_ = i;
245 }
246
247 const string& Link::get_name() const
248 {
249 return name_;
250 }
251
252 unsigned Link::get_inst() const
253 {
254 return inst_;
255 }
256
257 bool connected(const NetObj&l, const NetObj&r)
258 {
259 for (unsigned idx = 0 ; idx < l.pin_count() ; idx += 1)
260 if (! l.pin(idx).is_linked(r))
261 return false;
262
263 return true;
264 }
265
266 unsigned count_inputs(const Link&pin)
267 {
268 unsigned count = (pin.get_dir() == Link::INPUT)? 1 : 0;
269 const NetObj*cur;
270 unsigned cpin;
271 pin.next_link(cur, cpin);
272 while (cur->pin(cpin) != pin) {
273 if (cur->pin(cpin).get_dir() == Link::INPUT)
274 count += 1;
275 cur->pin(cpin).next_link(cur, cpin);
276 }
277
278 return count;
279 }
280
281 unsigned count_outputs(const Link&pin)
282 {
283 unsigned count = (pin.get_dir() == Link::OUTPUT)? 1 : 0;
284 const NetObj*cur;
285 unsigned cpin;
286 pin.next_link(cur, cpin);
287 while (cur->pin(cpin) != pin) {
288 if (cur->pin(cpin).get_dir() == Link::OUTPUT)
289 count += 1;
290 cur->pin(cpin).next_link(cur, cpin);
291 }
292
293 return count;
294 }
295
296 unsigned count_signals(const Link&pin)
297 {
298 unsigned count = 0;
299 if (dynamic_cast<const NetNet*>(pin.get_obj()))
300 count += 1;
301
302 const NetObj*cur;
303 unsigned cpin;
304 pin.next_link(cur, cpin);
305 while (cur->pin(cpin) != pin) {
306 if (dynamic_cast<const NetNet*>(cur))
307 count += 1;
308
309 cur->pin(cpin).next_link(cur, cpin);
310 }
311
312 return count;
313 }
314
315 const NetNet* find_link_signal(const NetObj*net, unsigned pin, unsigned&bidx)
316 {
317 const NetObj*cur;
318 unsigned cpin;
319 net->pin(pin).next_link(cur, cpin);
320
321 while (cur != net) {
322 const NetNet*sig = dynamic_cast<const NetNet*>(cur);
323 if (sig) {
324 bidx = cpin;
325 return sig;
326 }
327 cur->pin(cpin).next_link(cur, cpin);
328 }
329
330 return 0;
331 }
332
333 Link* find_next_output(Link*lnk)
334 {
335 for (Link*cur = lnk->next_link()
336 ; cur != lnk ; cur = cur->next_link())
337 if (cur->get_dir() == Link::OUTPUT)
338 return cur;
339
340 return 0;
341 }
342
343 NetObj::NetObj(const string&n, unsigned np)
344 : name_(n), npins_(np), delay1_(0), delay2_(0), delay3_(0), mark_(false)
345 {
346 pins_ = new Link[npins_];
347 for (unsigned idx = 0 ; idx < npins_ ; idx += 1) {
348 pins_[idx].node_ = this;
349 pins_[idx].pin_ = idx;
350 }
351 }
352
353 NetObj::~NetObj()
354 {
355 delete[]pins_;
356 }
357
358 void NetObj::set_attributes(const map<string,string>&attr)
359 {
360 assert(attributes_.size() == 0);
361 attributes_ = attr;
362 }
363
364 string NetObj::attribute(const string&key) const
365 {
366 map<string,string>::const_iterator idx = attributes_.find(key);
367 if (idx == attributes_.end())
368 return "";
369
370 return (*idx).second;
371 }
372
373 void NetObj::attribute(const string&key, const string&value)
374 {
375 attributes_[key] = value;
376 }
377
378 bool NetObj::has_compat_attributes(const NetObj&that) const
379 {
380 map<string,string>::const_iterator idx;
381 for (idx = that.attributes_.begin()
382 ; idx != that.attributes_.end() ; idx ++) {
383 map<string,string>::const_iterator cur;
384 cur = attributes_.find((*idx).first);
385
386 if (cur == attributes_.end())
387 return false;
388 if ((*cur).second != (*idx).second)
389 return false;
390 }
391
392 return true;
393 }
394
395 Link& NetObj::pin(unsigned idx)
396 {
397 assert(idx < npins_);
398 return pins_[idx];
399 }
400
401 const Link& NetObj::pin(unsigned idx) const
402 {
403 assert(idx < npins_);
404 return pins_[idx];
405 }
406
407 NetNode::NetNode(const string&n, unsigned npins)
408 : NetObj(n, npins), node_next_(0), node_prev_(0), design_(0)
409 {
410 }
411
412 NetNode::~NetNode()
413 {
414 if (design_)
415 design_->del_node(this);
416 }
417
418 NetNode* NetNode::next_node()
419 {
420 for (Link*pin0 = pin(0).next_link()
421 ; *pin0 != pin(0) ; pin0 = pin0->next_link()) {
422 NetNode*cur = dynamic_cast<NetNode*>(pin0->get_obj());
423 if (cur == 0)
424 continue;
425 if (cur->pin_count() != pin_count())
426 continue;
427
428
429 bool flag = true;
430 for (unsigned idx = 0 ; idx < pin_count() ; idx += 1)
431 flag = flag && pin(idx).is_linked(cur->pin(idx));
432
433 if (flag == true)
434 return cur;
435 }
436
437 return 0;
438 }
439
440 NetNet::NetNet(NetScope*s, const string&n, Type t, unsigned npins)
441 : NetObj(n, npins), sig_next_(0), sig_prev_(0), scope_(s),
442 type_(t), port_type_(NOT_A_PORT), msb_(npins-1), lsb_(0),
443 local_flag_(false), eref_count_(0)
444 {
445 assert(scope_);
446
447 ivalue_ = new verinum::V[npins];
448 for (unsigned idx = 0 ; idx < npins ; idx += 1) {
449 pin(idx).set_name("P", idx);
450 ivalue_[idx] = verinum::Vz;
451 }
452
453 scope_->add_signal(this);
454 }
455
456 NetNet::NetNet(NetScope*s, const string&n, Type t, long ms, long ls)
457 : NetObj(n, ((ms>ls)?ms-ls:ls-ms) + 1), sig_next_(0),
458 sig_prev_(0), scope_(s), type_(t),
459 port_type_(NOT_A_PORT), msb_(ms), lsb_(ls), local_flag_(false),
460 eref_count_(0)
461 {
462 assert(scope_);
463
464 ivalue_ = new verinum::V[pin_count()];
465 for (unsigned idx = 0 ; idx < pin_count() ; idx += 1) {
466 pin(idx).set_name("P", idx);
467 ivalue_[idx] = verinum::Vz;
468 }
469
470 scope_->add_signal(this);
471 }
472
473 NetNet::~NetNet()
474 {
475 assert(eref_count_ == 0);
476 if (scope_)
477 scope_->rem_signal(this);
478 }
479
480 NetScope* NetNet::scope()
481 {
482 return scope_;
483 }
484
485 const NetScope* NetNet::scope() const
486 {
487 return scope_;
488 }
489
490 unsigned NetNet::sb_to_idx(long sb) const
491 {
492 if (msb_ >= lsb_)
493 return sb - lsb_;
494 else
495 return lsb_ - sb;
496 }
497
498 void NetNet::incr_eref()
499 {
500 eref_count_ += 1;
501 }
502
503 void NetNet::decr_eref()
504 {
505 assert(eref_count_ > 0);
506 eref_count_ -= 1;
507 }
508
509 unsigned NetNet::get_eref() const
510 {
511 return eref_count_;
512 }
513
514 NetTmp::NetTmp(NetScope*s, const string&name, unsigned npins)
515 : NetNet(s, name, IMPLICIT, npins)
516 {
517 local_flag(true);
518 }
519
520 NetProc::NetProc()
521 : next_(0)
522 {
523 }
524
525 NetProc::~NetProc()
526 {
527 }
528
529 NetProcTop::NetProcTop(Type t, NetProc*st)
530 : type_(t), statement_(st)
531 {
532 }
533
534 NetProcTop::~NetProcTop()
535 {
536 delete statement_;
537 }
538
539 NetProc* NetProcTop::statement()
540 {
541 return statement_;
542 }
543
544 const NetProc* NetProcTop::statement() const
545 {
546 return statement_;
547 }
548
549 /*
550 * The NetFF class represents an LPM_FF device. The pinout is assigned
551 * like so:
552 * 0 -- Clock
553 * 1 -- Enable
554 * 2 -- Aload
555 * 3 -- Aset
556 * 4 -- Aclr
557 * 5 -- Sload
558 * 6 -- Sset
559 * 7 -- Sclr
560 *
561 * 8 -- Data[0]
562 * 9 -- Q[0]
563 * ...
564 */
565
566 NetFF::NetFF(const string&n, unsigned wid)
567 : NetNode(n, 8 + 2*wid)
568 {
569 pin_Clock().set_dir(Link::INPUT);
570 pin_Clock().set_name("Clock", 0);
571 pin_Enable().set_dir(Link::INPUT);
572 pin_Enable().set_name("Enable", 0);
573 pin_Aload().set_dir(Link::INPUT);
574 pin_Aload().set_name("Aload", 0);
575 pin_Aset().set_dir(Link::INPUT);
576 pin_Aset().set_name("Aset", 0);
577 pin_Aclr().set_dir(Link::INPUT);
578 pin_Aclr().set_name("Aclr", 0);
579 pin_Sload().set_dir(Link::INPUT);
580 pin_Sload().set_name("Sload", 0);
581 pin_Sset().set_dir(Link::INPUT);
582 pin_Sset().set_name("Sset", 0);
583 pin_Sclr().set_dir(Link::INPUT);
584 pin_Sclr().set_name("Sclr", 0);
585 for (unsigned idx = 0 ; idx < wid ; idx += 1) {
586 pin_Data(idx).set_dir(Link::INPUT);
587 pin_Data(idx).set_name("Data", idx);
588 pin_Q(idx).set_dir(Link::OUTPUT);
589 pin_Q(idx).set_name("Q", idx);
590 }
591 }
592
593 NetFF::~NetFF()
594 {
595 }
596
597 unsigned NetFF::width() const
598 {
599 return (pin_count() - 8) / 2;
600 }
601
602 Link& NetFF::pin_Clock()
603 {
604 return pin(0);
605 }
606
607 const Link& NetFF::pin_Clock() const
608 {
609 return pin(0);
610 }
611
612 Link& NetFF::pin_Enable()
613 {
614 return pin(1);
615 }
616
617 const Link& NetFF::pin_Enable() const
618 {
619 return pin(1);
620 }
621
622 Link& NetFF::pin_Aload()
623 {
624 return pin(2);
625 }
626
627 Link& NetFF::pin_Aset()
628 {
629 return pin(3);
630 }
631
632 Link& NetFF::pin_Aclr()
633 {
634 return pin(4);
635 }
636
637 Link& NetFF::pin_Sload()
638 {
639 return pin(5);
640 }
641
642 Link& NetFF::pin_Sset()
643 {
644 return pin(6);
645 }
646
647 Link& NetFF::pin_Sclr()
648 {
649 return pin(7);
650 }
651
652 Link& NetFF::pin_Data(unsigned w)
653 {
654 unsigned pn = 8 + 2*w;
655 assert(pn < pin_count());
656 return pin(pn);
657 }
658
659 const Link& NetFF::pin_Data(unsigned w) const
660 {
661 unsigned pn = 8 + 2*w;
662 assert(pn < pin_count());
663 return pin(pn);
664 }
665
666 Link& NetFF::pin_Q(unsigned w)
667 {
668 unsigned pn = 9 + w*2;
669 assert(pn < pin_count());
670 return pin(pn);
671 }
672
673 const Link& NetFF::pin_Q(unsigned w) const
674 {
675 unsigned pn = 9 + w*2;
676 assert(pn < pin_count());
677 return pin(pn);
678 }
679
680
681 /*
682 * The NetAddSub class represents an LPM_ADD_SUB device. The pinout is
683 * assigned like so:
684 * 0 -- Add_Sub
685 * 1 -- Aclr
686 * 2 -- Clock
687 * 3 -- Cin
688 * 4 -- Cout
689 * 5 -- Overflow
690 * 6 -- DataA[0]
691 * 7 -- DataB[0]
692 * 8 -- Result[0]
693 */
694 NetAddSub::NetAddSub(const string&n, unsigned w)
695 : NetNode(n, w*3+6)
696 {
697 pin(0).set_dir(Link::INPUT); pin(0).set_name("Add_Sub", 0);
698 pin(1).set_dir(Link::INPUT); pin(1).set_name("Aclr", 0);
699 pin(2).set_dir(Link::INPUT); pin(2).set_name("Clock", 0);
700 pin(3).set_dir(Link::INPUT); pin(3).set_name("Cin", 0);
701 pin(4).set_dir(Link::OUTPUT); pin(4).set_name("Cout", 0);
702 pin(5).set_dir(Link::OUTPUT); pin(5).set_name("Overflow", 0);
703 for (unsigned idx = 0 ; idx < w ; idx += 1) {
704 pin_DataA(idx).set_dir(Link::INPUT);
705 pin_DataB(idx).set_dir(Link::INPUT);
706 pin_Result(idx).set_dir(Link::OUTPUT);
707 pin_DataA(idx).set_name("DataA", idx);
708 pin_DataB(idx).set_name("DataB", idx);
709 pin_Result(idx).set_name("Result", idx);
710 }
711 }
712
713 NetAddSub::~NetAddSub()
714 {
715 }
716
717 unsigned NetAddSub::width()const
718 {
719 return (pin_count() - 6) / 3;
720 }
721
722 Link& NetAddSub::pin_Cout()
723 {
724 return pin(4);
725 }
726
727 const Link& NetAddSub::pin_Cout() const
728 {
729 return pin(4);
730 }
731
732 Link& NetAddSub::pin_DataA(unsigned idx)
733 {
734 idx = 6 + idx*3;
735 assert(idx < pin_count());
736 return pin(idx);
737 }
738
739 const Link& NetAddSub::pin_DataA(unsigned idx) const
740 {
741 idx = 6 + idx*3;
742 assert(idx < pin_count());
743 return pin(idx);
744 }
745
746 Link& NetAddSub::pin_DataB(unsigned idx)
747 {
748 idx = 7 + idx*3;
749 assert(idx < pin_count());
750 return pin(idx);
751 }
752
753 const Link& NetAddSub::pin_DataB(unsigned idx) const
754 {
755 idx = 7 + idx*3;
756 assert(idx < pin_count());
757 return pin(idx);
758 }
759
760 Link& NetAddSub::pin_Result(unsigned idx)
761 {
762 idx = 8 + idx*3;
763 assert(idx < pin_count());
764 return pin(idx);
765 }
766
767 const Link& NetAddSub::pin_Result(unsigned idx) const
768 {
769 idx = 8 + idx*3;
770 assert(idx < pin_count());
771 return pin(idx);
772 }
773
774 /*
775 * The pinout for the NetCLShift is:
776 * 0 -- Direction
777 * 1 -- Underflow
778 * 2 -- Overflow
779 * 3 -- Data(0)
780 * 3+W -- Result(0)
781 * 3+2W -- Distance(0)
782 */
783 NetCLShift::NetCLShift(const string&n, unsigned width, unsigned width_dist)
784 : NetNode(n, 3+2*width+width_dist), width_(width), width_dist_(width_dist)
785 {
786 pin(0).set_dir(Link::INPUT); pin(0).set_name("Direction", 0);
787 pin(1).set_dir(Link::OUTPUT); pin(1).set_name("Underflow", 0);
788 pin(2).set_dir(Link::OUTPUT); pin(2).set_name("Overflow", 0);
789
790 for (unsigned idx = 0 ; idx < width_ ; idx += 1) {
791 pin(3+idx).set_dir(Link::INPUT);
792 pin(3+idx).set_name("Data", idx);
793
794 pin(3+width_+idx).set_dir(Link::OUTPUT);
795 pin(3+width_+idx).set_name("Result", idx);
796 }
797
798 for (unsigned idx = 0 ; idx < width_dist_ ; idx += 1) {
799 pin(3+2*width_+idx).set_dir(Link::INPUT);
800 pin(3+2*width_+idx).set_name("Distance", idx);
801 }
802 }
803
804 NetCLShift::~NetCLShift()
805 {
806 }
807
808 unsigned NetCLShift::width() const
809 {
810 return width_;
811 }
812
813 unsigned NetCLShift::width_dist() const
814 {
815 return width_dist_;
816 }
817
818 Link& NetCLShift::pin_Direction()
819 {
820 return pin(0);
821 }
822
823 const Link& NetCLShift::pin_Direction() const
824 {
825 return pin(0);
826 }
827
828 Link& NetCLShift::pin_Underflow()
829 {
830 return pin(1);
831 }
832
833 const Link& NetCLShift::pin_Underflow() const
834 {
835 return pin(1);
836 }
837
838 Link& NetCLShift::pin_Overflow()
839 {
840 return pin(2);
841 }
842
843 const Link& NetCLShift::pin_Overflow() const
844 {
845 return pin(2);
846 }
847
848 Link& NetCLShift::pin_Data(unsigned idx)
849 {
850 assert(idx < width_);
851 return pin(3+idx);
852 }
853
854 const Link& NetCLShift::pin_Data(unsigned idx) const
855 {
856 assert(idx < width_);
857 return pin(3+idx);
858 }
859
860 Link& NetCLShift::pin_Result(unsigned idx)
861 {
862 assert(idx < width_);
863 return pin(3+width_+idx);
864 }
865
866 const Link& NetCLShift::pin_Result(unsigned idx) const
867 {
868 assert(idx < width_);
869 return pin(3+width_+idx);
870 }
871
872 Link& NetCLShift::pin_Distance(unsigned idx)
873 {
874 assert(idx < width_dist_);
875 return pin(3+2*width_+idx);
876 }
877
878 const Link& NetCLShift::pin_Distance(unsigned idx) const
879 {
880 assert(idx < width_dist_);
881 return pin(3+2*width_+idx);
882 }
883
884 NetCompare::NetCompare(const string&n, unsigned wi)
885 : NetNode(n, 8+2*wi), width_(wi)
886 {
887 pin(0).set_dir(Link::INPUT); pin(0).set_name("Aclr");
888 pin(1).set_dir(Link::INPUT); pin(1).set_name("Clock");
889 pin(2).set_dir(Link::OUTPUT); pin(2).set_name("AGB");
890 pin(3).set_dir(Link::OUTPUT); pin(3).set_name("AGEB");
891 pin(4).set_dir(Link::OUTPUT); pin(4).set_name("AEB");
892 pin(5).set_dir(Link::OUTPUT); pin(5).set_name("ANEB");
893 pin(6).set_dir(Link::OUTPUT); pin(6).set_name("ALB");
894 pin(7).set_dir(Link::OUTPUT); pin(7).set_name("ALEB");
895 for (unsigned idx = 0 ; idx < width_ ; idx += 1) {
896 pin(8+idx).set_dir(Link::INPUT);
897 pin(8+idx).set_name("DataA", idx);
898 pin(8+width_+idx).set_dir(Link::INPUT);
899 pin(8+width_+idx).set_name("DataB", idx);
900 }
901 }
902
903 NetCompare::~NetCompare()
904 {
905 }
906
907 unsigned NetCompare::width() const
908 {
909 return width_;
910 }
911
912 Link& NetCompare::pin_Aclr()
913 {
914 return pin(0);
915 }
916
917 const Link& NetCompare::pin_Aclr() const
918 {
919 return pin(0);
920 }
921
922 Link& NetCompare::pin_Clock()
923 {
924 return pin(1);
925 }
926
927 const Link& NetCompare::pin_Clock() const
928 {
929 return pin(1);
930 }
931
932 Link& NetCompare::pin_AGB()
933 {
934 return pin(2);
935 }
936
937 const Link& NetCompare::pin_AGB() const
938 {
939 return pin(2);
940 }
941
942 Link& NetCompare::pin_AGEB()
943 {
944 return pin(3);
945 }
946
947 const Link& NetCompare::pin_AGEB() const
948 {
949 return pin(3);
950 }
951
952 Link& NetCompare::pin_AEB()
953 {
954 return pin(4);
955 }
956
957 const Link& NetCompare::pin_AEB() const
958 {
959 return pin(4);
960 }
961
962 Link& NetCompare::pin_ANEB()
963 {
964 return pin(5);
965 }
966
967 const Link& NetCompare::pin_ANEB() const
968 {
969 return pin(5);
970 }
971
972 Link& NetCompare::pin_ALB()
973 {
974 return pin(6);
975 }
976
977 const Link& NetCompare::pin_ALB() const
978 {
979 return pin(6);
980 }
981
982 Link& NetCompare::pin_ALEB()
983 {
984 return pin(7);
985 }
986
987 const Link& NetCompare::pin_ALEB() const
988 {
989 return pin(7);
990 }
991
992 Link& NetCompare::pin_DataA(unsigned idx)
993 {
994 return pin(8+idx);
995 }
996
997 const Link& NetCompare::pin_DataA(unsigned idx) const
998 {
999 return pin(8+idx);
1000 }
1001
1002 Link& NetCompare::pin_DataB(unsigned idx)
1003 {
1004 return pin(8+width_+idx);
1005 }
1006
1007 const Link& NetCompare::pin_DataB(unsigned idx) const
1008 {
1009 return pin(8+width_+idx);
1010 }
1011
1012 NetDivide::NetDivide(const string&n, unsigned wr,
1013 unsigned wa, unsigned wb)
1014 : NetNode(n, wr+wa+wb), width_r_(wr), width_a_(wa), width_b_(wb)
1015 {
1016 unsigned p = 0;
1017 for (unsigned idx = 0 ; idx < width_r_ ; idx += 1, p += 1) {
1018 pin(p).set_dir(Link::OUTPUT);
1019 pin(p).set_name("Result", idx);
1020 }
1021 for (unsigned idx = 0 ; idx < width_a_ ; idx += 1, p += 1) {
1022 pin(p).set_dir(Link::INPUT);
1023 pin(p).set_name("DataA", idx);
1024 }
1025 for (unsigned idx = 0 ; idx < width_b_ ; idx += 1, p += 1) {
1026 pin(p).set_dir(Link::INPUT);
1027 pin(p).set_name("DataB", idx);
1028 }
1029 }
1030
1031 NetDivide::~NetDivide()
1032 {
1033 }
1034
1035 unsigned NetDivide::width_r() const
1036 {
1037 return width_r_;
1038 }
1039
1040 unsigned NetDivide::width_a() const
1041 {
1042 return width_a_;
1043 }
1044
1045 unsigned NetDivide::width_b() const
1046 {
1047 return width_b_;
1048 }
1049
1050 Link& NetDivide::pin_Result(unsigned idx)
1051 {
1052 assert(idx < width_r_);
1053 return pin(idx);
1054 }
1055
1056 const Link& NetDivide::pin_Result(unsigned idx) const
1057 {
1058 assert(idx < width_r_);
1059 return pin(idx);
1060 }
1061
1062 Link& NetDivide::pin_DataA(unsigned idx)
1063 {
1064 assert(idx < width_a_);
1065 return pin(idx+width_r_);
1066 }
1067
1068 const Link& NetDivide::pin_DataA(unsigned idx) const
1069 {
1070 assert(idx < width_a_);
1071 return pin(idx+width_r_);
1072 }
1073
1074 Link& NetDivide::pin_DataB(unsigned idx)
1075 {
1076 assert(idx < width_b_);
1077 return pin(idx+width_r_+width_a_);
1078 }
1079
1080 const Link& NetDivide::pin_DataB(unsigned idx) const
1081 {
1082 assert(idx < width_b_);
1083 return pin(idx+width_r_+width_a_);
1084 }
1085
1086 NetMult::NetMult(const string&n, unsigned wr, unsigned wa, unsigned wb,
1087 unsigned ws)
1088 : NetNode(n, 2+wr+wa+wb+ws), width_r_(wr), width_a_(wa), width_b_(wb),
1089 width_s_(ws)
1090 {
1091 pin(0).set_dir(Link::INPUT); pin(0).set_name("Aclr", 0);
1092 pin(1).set_dir(Link::INPUT); pin(1).set_name("Clock", 0);
1093
1094
1095 unsigned p = 2;
1096 for (unsigned idx = 0 ; idx < width_r_ ; idx += 1, p += 1) {
1097 pin(p).set_dir(Link::OUTPUT);
1098 pin(p).set_name("Result", idx);
1099 }
1100 for (unsigned idx = 0 ; idx < width_a_ ; idx += 1, p += 1) {
1101 pin(p).set_dir(Link::INPUT);
1102 pin(p).set_name("DataA", idx);
1103 }
1104 for (unsigned idx = 0 ; idx < width_b_ ; idx += 1, p += 1) {
1105 pin(p).set_dir(Link::INPUT);
1106 pin(p).set_name("DataB", idx);
1107 }
1108 for (unsigned idx = 0 ; idx < width_s_ ; idx += 1, p += 1) {
1109 pin(p).set_dir(Link::INPUT);
1110 pin(p).set_name("Sum", idx);
1111 }
1112 }
1113
1114 NetMult::~NetMult()
1115 {
1116 }
1117
1118 unsigned NetMult::width_r() const
1119 {
1120 return width_r_;
1121 }
1122
1123 unsigned NetMult::width_a() const
1124 {
1125 return width_a_;
1126 }
1127
1128 unsigned NetMult::width_b() const
1129 {
1130 return width_b_;
1131 }
1132
1133 unsigned NetMult::width_s() const
1134 {
1135 return width_s_;
1136 }
1137
1138 Link& NetMult::pin_Aclr()
1139 {
1140 return pin(0);
1141 }
1142
1143 const Link& NetMult::pin_Aclr() const
1144 {
1145 return pin(0);
1146 }
1147
1148 Link& NetMult::pin_Clock()
1149 {
1150 return pin(1);
1151 }
1152
1153 const Link& NetMult::pin_Clock() const
1154 {
1155 return pin(1);
1156 }
1157
1158 Link& NetMult::pin_Result(unsigned idx)
1159 {
1160 assert(idx < width_r_);
1161 return pin(idx+2);
1162 }
1163
1164 const Link& NetMult::pin_Result(unsigned idx) const
1165 {
1166 assert(idx < width_r_);
1167 return pin(idx+2);
1168 }
1169
1170 Link& NetMult::pin_DataA(unsigned idx)
1171 {
1172 assert(idx < width_a_);
1173 return pin(idx+2+width_r_);
1174 }
1175
1176 const Link& NetMult::pin_DataA(unsigned idx) const
1177 {
1178 assert(idx < width_a_);
1179 return pin(idx+2+width_r_);
1180 }
1181
1182 Link& NetMult::pin_DataB(unsigned idx)
1183 {
1184 assert(idx < width_b_);
1185 return pin(idx+2+width_r_+width_a_);
1186 }
1187
1188 const Link& NetMult::pin_DataB(unsigned idx) const
1189 {
1190 assert(idx < width_b_);
1191 return pin(idx+2+width_r_+width_a_);
1192 }
1193
1194 Link& NetMult::pin_Sum(unsigned idx)
1195 {
1196 assert(idx < width_s_);
1197 return pin(idx+2+width_r_+width_a_+width_b_);
1198 }
1199
1200 const Link& NetMult::pin_Sum(unsigned idx) const
1201 {
1202 assert(idx < width_s_);
1203 return pin(idx+2+width_r_+width_a_+width_b_);
1204 }
1205
1206 /*
1207 * The NetMux class represents an LPM_MUX device. The pinout is assigned
1208 * like so:
1209 * 0 -- Aclr (optional)
1210 * 1 -- Clock (optional)
1211 * 2 -- Result[0]
1212 * 2+N -- Result[N]
1213 */
1214
1215 NetMux::NetMux(const string&n, unsigned wi, unsigned si, unsigned sw)
1216 : NetNode(n, 2+wi+sw+wi*si), width_(wi), size_(si), swidth_(sw)
1217 {
1218 pin(0).set_dir(Link::INPUT); pin(0).set_name("Aclr", 0);
1219 pin(1).set_dir(Link::INPUT); pin(1).set_name("Clock", 0);
1220
1221 for (unsigned idx = 0 ; idx < width_ ; idx += 1) {
1222 pin_Result(idx).set_dir(Link::OUTPUT);
1223 pin_Result(idx).set_name("Result", idx);
1224
1225 for (unsigned jdx = 0 ; jdx < size_ ; jdx += 1) {
1226 pin_Data(idx,jdx).set_dir(Link::INPUT);
1227 pin_Data(idx,jdx).set_name("Data", jdx*width_+idx);
1228 }
1229 }
1230
1231 for (unsigned idx = 0 ; idx < swidth_ ; idx += 1) {
1232 pin_Sel(idx).set_dir(Link::INPUT);
1233 pin_Sel(idx).set_name("Sel", idx);
1234 }
1235 }
1236
1237 NetMux::~NetMux()
1238 {
1239 }
1240
1241 unsigned NetMux::width()const
1242 {
1243 return width_;
1244 }
1245
1246 unsigned NetMux::size() const
1247 {
1248 return size_;
1249 }
1250
1251 unsigned NetMux::sel_width() const
1252 {
1253 return swidth_;
1254 }
1255
1256 Link& NetMux::pin_Aclr()
1257 {
1258 return pin(0);
1259 }
1260
1261 const Link& NetMux::pin_Aclr() const
1262 {
1263 return pin(0);
1264 }
1265
1266 Link& NetMux::pin_Clock()
1267 {
1268 return pin(1);
1269 }
1270
1271 const Link& NetMux::pin_Clock() const
1272 {
1273 return pin(1);
1274 }
1275
1276 Link& NetMux::pin_Result(unsigned w)
1277 {
1278 assert(w < width_);
1279 return pin(2+w);
1280 }
1281
1282 const Link& NetMux::pin_Result(unsigned w) const
1283 {
1284 assert(w < width_);
1285 return pin(2+w);
1286 }
1287
1288 Link& NetMux::pin_Sel(unsigned w)
1289 {
1290 assert(w < swidth_);
1291 return pin(2+width_+w);
1292 }
1293
1294 const Link& NetMux::pin_Sel(unsigned w) const
1295 {
1296 assert(w < swidth_);
1297 return pin(2+width_+w);
1298 }
1299
1300 Link& NetMux::pin_Data(unsigned w, unsigned s)
1301 {
1302 assert(w < width_);
1303 assert(s < size_);
1304 return pin(2+width_+swidth_+s*width_+w);
1305 }
1306
1307 const Link& NetMux::pin_Data(unsigned w, unsigned s) const
1308 {
1309 assert(w < width_);
1310 assert(s < size_);
1311 return pin(2+width_+swidth_+s*width_+w);
1312 }
1313
1314
1315 NetRamDq::NetRamDq(const string&n, NetMemory*mem, unsigned awid)
1316 : NetNode(n, 3+2*mem->width()+awid), mem_(mem), awidth_(awid)
1317 {
1318 pin(0).set_dir(Link::INPUT); pin(0).set_name("InClock", 0);
1319 pin(1).set_dir(Link::INPUT); pin(1).set_name("OutClock", 0);
1320 pin(2).set_dir(Link::INPUT); pin(2).set_name("WE", 0);
1321
1322 for (unsigned idx = 0 ; idx < awidth_ ; idx += 1) {
1323 pin(3+idx).set_dir(Link::INPUT);
1324 pin(3+idx).set_name("Address", idx);
1325 }
1326
1327 for (unsigned idx = 0 ; idx < width() ; idx += 1) {
1328 pin(3+awidth_+idx).set_dir(Link::INPUT);
1329 pin(3+awidth_+idx).set_name("Data", idx);
1330 }
1331
1332 for (unsigned idx = 0 ; idx < width() ; idx += 1) {
1333 pin(3+awidth_+width()+idx).set_dir(Link::OUTPUT);
1334 pin(3+awidth_+width()+idx).set_name("Q", idx);
1335 }
1336
1337 next_ = mem_->ram_list_;
1338 mem_->ram_list_ = this;
1339 }
1340
1341 NetRamDq::~NetRamDq()
1342 {
1343 if (mem_->ram_list_ == this) {
1344 mem_->ram_list_ = next_;
1345
1346 } else {
1347 NetRamDq*cur = mem_->ram_list_;
1348 while (cur->next_ != this) {
1349 assert(cur->next_);
1350 cur = cur->next_;
1351 }
1352 assert(cur->next_ == this);
1353 cur->next_ = next_;
1354 }
1355 }
1356
1357 unsigned NetRamDq::width() const
1358 {
1359 return mem_->width();
1360 }
1361
1362 unsigned NetRamDq::awidth() const
1363 {
1364 return awidth_;
1365 }
1366
1367 unsigned NetRamDq::size() const
1368 {
1369 return mem_->count();
1370 }
1371
1372 const NetMemory* NetRamDq::mem() const
1373 {
1374 return mem_;
1375 }
1376
1377 unsigned NetRamDq::count_partners() const
1378 {
1379 unsigned count = 0;
1380 for (NetRamDq*cur = mem_->ram_list_ ; cur ; cur = cur->next_)
1381 count += 1;
1382
1383 return count;
1384 }
1385
1386 void NetRamDq::absorb_partners()
1387 {
1388 NetRamDq*cur, *tmp;
1389 for (cur = mem_->ram_list_, tmp = 0
1390 ; cur||tmp ; cur = cur? cur->next_ : tmp) {
1391 tmp = 0;
1392 if (cur == this) continue;
1393
1394 bool ok_flag = true;
1395 for (unsigned idx = 0 ; idx < awidth() ; idx += 1)
1396 ok_flag &= pin_Address(idx).is_linked(cur->pin_Address(idx));
1397
1398 if (!ok_flag) continue;
1399
1400 if (pin_InClock().is_linked()
1401 && cur->pin_InClock().is_linked()
1402 && ! pin_InClock().is_linked(cur->pin_InClock()))
1403 continue;
1404
1405 if (pin_OutClock().is_linked()
1406 && cur->pin_OutClock().is_linked()
1407 && ! pin_OutClock().is_linked(cur->pin_OutClock()))
1408 continue;
1409
1410 if (pin_WE().is_linked()
1411 && cur->pin_WE().is_linked()
1412 && ! pin_WE().is_linked(cur->pin_WE()))
1413 continue;
1414
1415 for (unsigned idx = 0 ; idx < width() ; idx += 1) {
1416 if (!pin_Data(idx).is_linked()) continue;
1417 if (! cur->pin_Data(idx).is_linked()) continue;
1418
1419 ok_flag &= pin_Data(idx).is_linked(cur->pin_Data(idx));
1420 }
1421
1422 if (! ok_flag) continue;
1423
1424 for (unsigned idx = 0 ; idx < width() ; idx += 1) {
1425 if (!pin_Q(idx).is_linked()) continue;
1426 if (! cur->pin_Q(idx).is_linked()) continue;
1427
1428 ok_flag &= pin_Q(idx).is_linked(cur->pin_Q(idx));
1429 }
1430
1431 if (! ok_flag) continue;
1432
1433 // I see no other reason to reject cur, so link up all
1434 // my pins and delete it.
1435 connect(pin_InClock(), cur->pin_InClock());
1436 connect(pin_OutClock(), cur->pin_OutClock());
1437 connect(pin_WE(), cur->pin_WE());
1438
1439 for (unsigned idx = 0 ; idx < awidth() ; idx += 1)
1440 connect(pin_Address(idx), cur->pin_Address(idx));
1441
1442 for (unsigned idx = 0 ; idx < width() ; idx += 1) {
1443 connect(pin_Data(idx), cur->pin_Data(idx));
1444 connect(pin_Q(idx), cur->pin_Q(idx));
1445 }
1446
1447 tmp = cur->next_;
1448 delete cur;
1449 cur = 0;
1450 }
1451 }
1452
1453 Link& NetRamDq::pin_InClock()
1454 {
1455 return pin(0);
1456 }
1457
1458 const Link& NetRamDq::pin_InClock() const
1459 {
1460 return pin(0);
1461 }
1462
1463 Link& NetRamDq::pin_OutClock()
1464 {
1465 return pin(1);
1466 }
1467
1468 const Link& NetRamDq::pin_OutClock() const
1469 {
1470 return pin(1);
1471 }
1472
1473 Link& NetRamDq::pin_WE()
1474 {
1475 return pin(2);
1476 }
1477
1478 const Link& NetRamDq::pin_WE() const
1479 {
1480 return pin(2);
1481 }
1482
1483 Link& NetRamDq::pin_Address(unsigned idx)
1484 {
1485 assert(idx < awidth_);
1486 return pin(3+idx);
1487 }
1488
1489 const Link& NetRamDq::pin_Address(unsigned idx) const
1490 {
1491 assert(idx < awidth_);
1492 return pin(3+idx);
1493 }
1494
1495 Link& NetRamDq::pin_Data(unsigned idx)
1496 {
1497 assert(idx < width());
1498 return pin(3+awidth_+idx);
1499 }
1500
1501 const Link& NetRamDq::pin_Data(unsigned idx) const
1502 {
1503 assert(idx < width());
1504 return pin(3+awidth_+idx);
1505 }
1506
1507 Link& NetRamDq::pin_Q(unsigned idx)
1508 {
1509 assert(idx < width());
1510 return pin(3+awidth_+width()+idx);
1511 }
1512
1513 const Link& NetRamDq::pin_Q(unsigned idx) const
1514 {
1515 assert(idx < width());
1516 return pin(3+awidth_+width()+idx);
1517 }
1518
1519 /*
1520 * NetAssign
1521 */
1522
1523 NetAssign_::NetAssign_(const string&n, unsigned w)
1524 : NetNode(n, w), rval_(0), bmux_(0)
1525 {
1526 for (unsigned idx = 0 ; idx < pin_count() ; idx += 1) {
1527 pin(idx).set_dir(Link::OUTPUT);
1528 pin(idx).set_name("P", idx);
1529 }
1530
1531 }
1532
1533 NetAssign_::~NetAssign_()
1534 {
1535 if (rval_) delete rval_;
1536 if (bmux_) delete bmux_;
1537 }
1538
1539 void NetAssign_::set_rval(NetExpr*r)
1540 {
1541 if (rval_) delete rval_;
1542 rval_ = r;
1543 }
1544
1545 void NetAssign_::set_bmux(NetExpr*r)
1546 {
1547 assert(bmux_ == 0);
1548 bmux_ = r;
1549 }
1550
1551 NetExpr* NetAssign_::rval()
1552 {
1553 return rval_;
1554 }
1555
1556 const NetExpr* NetAssign_::rval() const
1557 {
1558 return rval_;
1559 }
1560
1561 const NetExpr* NetAssign_::bmux() const
1562 {
1563 return bmux_;
1564 }
1565
1566 NetAssign::NetAssign(const string&n, Design*des, unsigned w, NetExpr*rv)
1567 : NetAssign_(n, w)
1568 {
1569 set_rval(rv);
1570 }
1571
1572 NetAssign::NetAssign(const string&n, Design*des, unsigned w,
1573 NetExpr*mu, NetExpr*rv)
1574 : NetAssign_(n, w)
1575 {
1576 bool flag = rv->set_width(1);
1577 if (flag == false) {
1578 cerr << rv->get_line() << ": Expression bit width" <<
1579 " conflicts with l-value bit width." << endl;
1580 des->errors += 1;
1581 }
1582
1583 set_rval(rv);
1584 set_bmux(mu);
1585 }
1586
1587 NetAssign::~NetAssign()
1588 {
1589 }
1590
1591 NetAssignNB::NetAssignNB(const string&n, Design*des, unsigned w, NetExpr*rv)
1592 : NetAssign_(n, w)
1593 {
1594 if (rv->expr_width() < w) {
1595 cerr << rv->get_line() << ": Expression bit width (" <<
1596 rv->expr_width() << ") conflicts with l-value "
1597 "bit width (" << w << ")." << endl;
1598 des->errors += 1;
1599 }
1600
1601 set_rval(rv);
1602 }
1603
1604 NetAssignNB::NetAssignNB(const string&n, Design*des, unsigned w,
1605 NetExpr*mu, NetExpr*rv)
1606 : NetAssign_(n, w)
1607 {
1608 bool flag = rv->set_width(1);
1609 if (flag == false) {
1610 cerr << rv->get_line() << ": Expression bit width" <<
1611 " conflicts with l-value bit width." << endl;
1612 des->errors += 1;
1613 }
1614
1615 set_rval(rv);
1616 set_bmux(mu);
1617 }
1618
1619 NetAssignNB::~NetAssignNB()
1620 {
1621 }
1622
1623
1624 NetAssignMem_::NetAssignMem_(NetMemory*m, NetNet*i, NetExpr*r)
1625 : mem_(m), index_(i), rval_(r)
1626 {
1627 index_->incr_eref();
1628 }
1629
1630 NetAssignMem_::~NetAssignMem_()
1631 {
1632 index_->decr_eref();
1633 }
1634
1635 NetAssignMem::NetAssignMem(NetMemory*m, NetNet*i, NetExpr*r)
1636 : NetAssignMem_(m, i, r)
1637 {
1638 }
1639
1640 NetAssignMem::~NetAssignMem()
1641 {
1642 }
1643
1644 NetAssignMemNB::NetAssignMemNB(NetMemory*m, NetNet*i, NetExpr*r)
1645 : NetAssignMem_(m, i, r)
1646 {
1647 }
1648
1649 NetAssignMemNB::~NetAssignMemNB()
1650 {
1651 }
1652
1653
1654 NetBlock::~NetBlock()
1655 {
1656 }
1657
1658 void NetBlock::append(NetProc*cur)
1659 {
1660 if (last_ == 0) {
1661 last_ = cur;
1662 cur->next_ = cur;
1663 } else {
1664 cur->next_ = last_->next_;
1665 last_->next_ = cur;
1666 last_ = cur;
1667 }
1668 }
1669
1670 const NetProc* NetBlock::proc_first() const
1671 {
1672 if (last_ == 0)
1673 return 0;
1674
1675 return last_->next_;
1676 }
1677
1678 const NetProc* NetBlock::proc_next(const NetProc*cur) const
1679 {
1680 if (cur == last_)
1681 return 0;
1682
1683 return cur->next_;
1684 }
1685
1686 NetBUFZ::NetBUFZ(const string&n)
1687 : NetNode(n, 2)
1688 {
1689 pin(0).set_dir(Link::OUTPUT);
1690 pin(1).set_dir(Link::INPUT);
1691 pin(0).set_name("O", 0);
1692 pin(1).set_name("I", 0);
1693 }
1694
1695 NetBUFZ::~NetBUFZ()
1696 {
1697 }
1698
1699
1700 NetCase::NetCase(NetCase::TYPE c, NetExpr*ex, unsigned cnt)
1701 : type_(c), expr_(ex), nitems_(cnt)
1702 {
1703 assert(expr_);
1704 items_ = new Item[nitems_];
1705 for (unsigned idx = 0 ; idx < nitems_ ; idx += 1) {
1706 items_[idx].statement = 0;
1707 }
1708 }
1709
1710 NetCase::~NetCase()
1711 {
1712 delete expr_;
1713 for (unsigned idx = 0 ; idx < nitems_ ; idx += 1) {
1714 delete items_[idx].guard;
1715 if (items_[idx].statement) delete items_[idx].statement;
1716 }
1717 delete[]items_;
1718 }
1719
1720 NetCase::TYPE NetCase::type() const
1721 {
1722 return type_;
1723 }
1724
1725 void NetCase::set_case(unsigned idx, NetExpr*e, NetProc*p)
1726 {
1727 assert(idx < nitems_);
1728 items_[idx].guard = e;
1729 items_[idx].statement = p;
1730 if (items_[idx].guard)
1731 items_[idx].guard->set_width(expr_->expr_width());
1732 }
1733
1734 NetCaseCmp::NetCaseCmp(const string&n)
1735 : NetNode(n, 3)
1736 {
1737 pin(0).set_dir(Link::OUTPUT); pin(0).set_name("O",0);
1738 pin(1).set_dir(Link::INPUT); pin(1).set_name("I",0);
1739 pin(2).set_dir(Link::INPUT); pin(2).set_name("I",1);
1740 }
1741
1742 NetCaseCmp::~NetCaseCmp()
1743 {
1744 }
1745
1746 NetCondit::NetCondit(NetExpr*ex, NetProc*i, NetProc*e)
1747 : expr_(ex), if_(i), else_(e)
1748 {
1749 }
1750
1751 NetCondit::~NetCondit()
1752 {
1753 delete expr_;
1754 if (if_) delete if_;
1755 if (else_) delete else_;
1756 }
1757
1758 const NetExpr* NetCondit::expr() const
1759 {
1760 return expr_;
1761 }
1762
1763 NetExpr* NetCondit::expr()
1764 {
1765 return expr_;
1766 }
1767
1768 void NetCondit::set_expr(NetExpr*ex)
1769 {
1770 delete expr_;
1771 expr_ = ex;
1772 }
1773
1774 NetProc* NetCondit::if_clause()
1775 {
1776 return if_;
1777 }
1778
1779 NetProc* NetCondit::else_clause()
1780 {
1781 return else_;
1782 }
1783
1784 NetConst::NetConst(const string&n, verinum::V v)
1785 : NetNode(n, 1)
1786 {
1787 pin(0).set_dir(Link::OUTPUT);
1788 pin(0).set_name("O", 0);
1789 value_ = new verinum::V[1];
1790 value_[0] = v;
1791 }
1792
1793 NetConst::NetConst(const string&n, const verinum&val)
1794 : NetNode(n, val.len())
1795 {
1796 value_ = new verinum::V[pin_count()];
1797 for (unsigned idx = 0 ; idx < pin_count() ; idx += 1) {
1798 pin(idx).set_dir(Link::OUTPUT);
1799 pin(idx).set_name("O", idx);
1800 value_[idx] = val.get(idx);
1801 }
1802 }
1803
1804 NetConst::~NetConst()
1805 {
1806 delete[]value_;
1807 }
1808
1809 verinum::V NetConst::value(unsigned idx) const
1810 {
1811 assert(idx < pin_count());
1812 return value_[idx];
1813 }
1814
1815 NetFuncDef::NetFuncDef(NetScope*s, const svector<NetNet*>&po)
1816 : scope_(s), statement_(0), ports_(po)
1817 {
1818 }
1819
1820 NetFuncDef::~NetFuncDef()
1821 {
1822 }
1823
1824 const string NetFuncDef::name() const
1825 {
1826 return scope_->name();
1827 }
1828
1829 void NetFuncDef::set_proc(NetProc*st)
1830 {
1831 assert(statement_ == 0);
1832 assert(st != 0);
1833 statement_ = st;
1834 }
1835
1836 const NetProc* NetFuncDef::proc() const
1837 {
1838 return statement_;
1839 }
1840
1841 NetScope*NetFuncDef::scope()
1842 {
1843 return scope_;
1844 }
1845
1846 unsigned NetFuncDef::port_count() const
1847 {
1848 return ports_.count();
1849 }
1850
1851 const NetNet* NetFuncDef::port(unsigned idx) const
1852 {
1853 assert(idx < ports_.count());
1854 return ports_[idx];
1855 }
1856
1857 NetSTask::NetSTask(const string&na, const svector<NetExpr*>&pa)
1858 : name_(na), parms_(pa)
1859 {
1860 assert(name_[0] == '$');
1861 }
1862
1863 NetSTask::~NetSTask()
1864 {
1865 for (unsigned idx = 0 ; idx < parms_.count() ; idx += 1)
1866 delete parms_[idx];
1867
1868 }
1869
1870 const NetExpr* NetSTask::parm(unsigned idx) const
1871 {
1872 return parms_[idx];
1873 }
1874
1875 NetEUFunc::NetEUFunc(NetFuncDef*def, NetESignal*res, svector<NetExpr*>&p)
1876 : func_(def), result_(res), parms_(p)
1877 {
1878 expr_width(result_->expr_width());
1879 }
1880
1881 NetEUFunc::~NetEUFunc()
1882 {
1883 for (unsigned idx = 0 ; idx < parms_.count() ; idx += 1)
1884 delete parms_[idx];
1885 }
1886
1887 const string NetEUFunc::name() const
1888 {
1889 return func_->name();
1890 }
1891
1892 const NetESignal*NetEUFunc::result() const
1893 {
1894 return result_;
1895 }
1896
1897 unsigned NetEUFunc::parm_count() const
1898 {
1899 return parms_.count();
1900 }
1901
1902 const NetExpr* NetEUFunc::parm(unsigned idx) const
1903 {
1904 assert(idx < parms_.count());
1905 return parms_[idx];
1906 }
1907
1908 const NetFuncDef* NetEUFunc::definition() const
1909 {
1910 return func_;
1911 }
1912
1913 NetEUFunc* NetEUFunc::dup_expr() const
1914 {
1915 assert(0);
1916 return 0;
1917 }
1918
1919 NetUTask::NetUTask(NetTaskDef*def)
1920 : task_(def)
1921 {
1922 }
1923
1924 NetUTask::~NetUTask()
1925 {
1926 }
1927
1928 NetExpr::NetExpr(unsigned w)
1929 : width_(w)
1930 {
1931 }
1932
1933 NetExpr::~NetExpr()
1934 {
1935 }
1936
1937 NetEBAdd::NetEBAdd(char op, NetExpr*l, NetExpr*r)
1938 : NetEBinary(op, l, r)
1939 {
1940 if (l->expr_width() > r->expr_width())
1941 r->set_width(l->expr_width());
1942
1943 if (r->expr_width() > l->expr_width())
1944 l->set_width(r->expr_width());
1945
1946 if (l->expr_width() < r->expr_width())
1947 r->set_width(l->expr_width());
1948
1949 if (r->expr_width() < l->expr_width())
1950 l->set_width(r->expr_width());
1951
1952 if (r->expr_width() > l->expr_width())
1953 expr_width(r->expr_width());
1954 else
1955 expr_width(l->expr_width());
1956 }
1957
1958 NetEBAdd::~NetEBAdd()
1959 {
1960 }
1961
1962 NetEBAdd* NetEBAdd::dup_expr() const
1963 {
1964 NetEBAdd*result = new NetEBAdd(op_, left_->dup_expr(),
1965 right_->dup_expr());
1966 return result;
1967 }
1968
1969 NetEBBits::NetEBBits(char op, NetExpr*l, NetExpr*r)
1970 : NetEBinary(op, l, r)
1971 {
1972 /* First try to naturally adjust the size of the
1973 expressions to match. */
1974 if (l->expr_width() > r->expr_width())
1975 r->set_width(l->expr_width());
1976
1977 if (r->expr_width() > l->expr_width())
1978 l->set_width(r->expr_width());
1979
1980 if (l->expr_width() < r->expr_width())
1981 r->set_width(l->expr_width());
1982
1983 if (r->expr_width() < l->expr_width())
1984 l->set_width(r->expr_width());
1985
1986 /* If the expressions cannot be matched, pad them to fit. */
1987 if (l->expr_width() > r->expr_width())
1988 right_ = pad_to_width(r, l->expr_width());
1989
1990 if (r->expr_width() > l->expr_width())
1991 left_ = pad_to_width(l, r->expr_width());
1992
1993 assert(left_->expr_width() == right_->expr_width());
1994 expr_width(left_->expr_width());
1995 }
1996
1997 NetEBBits::~NetEBBits()
1998 {
1999 }
2000
2001 NetEBBits* NetEBBits::dup_expr() const
2002 {
2003 NetEBBits*result = new NetEBBits(op_, left_->dup_expr(),
2004 right_->dup_expr());
2005 return result;
2006 }
2007
2008 NetEBComp::NetEBComp(char op, NetExpr*l, NetExpr*r)
2009 : NetEBinary(op, l, r)
2010 {
2011 expr_width(1);
2012 }
2013
2014 NetEBComp::~NetEBComp()
2015 {
2016 }
2017
2018 NetEBComp* NetEBComp::dup_expr() const
2019 {
2020 NetEBComp*result = new NetEBComp(op_, left_->dup_expr(),
2021 right_->dup_expr());
2022 return result;
2023 }
2024
2025 NetEBDiv::NetEBDiv(char op, NetExpr*l, NetExpr*r)
2026 : NetEBinary(op, l, r)
2027 {
2028 unsigned w = l->expr_width();
2029 if (r->expr_width() > w)
2030 w = r->expr_width();
2031
2032 expr_width(w);
2033 }
2034
2035 NetEBDiv::~NetEBDiv()
2036 {
2037 }
2038
2039 NetEBDiv* NetEBDiv::dup_expr() const
2040 {
2041 NetEBDiv*result = new NetEBDiv(op_, left_->dup_expr(),
2042 right_->dup_expr());
2043 return result;
2044 }
2045
2046 NetEBinary::NetEBinary(char op, NetExpr*l, NetExpr*r)
2047 : op_(op), left_(l), right_(r)
2048 {
2049 }
2050
2051 NetEBinary::~NetEBinary()
2052 {
2053 delete left_;
2054 delete right_;
2055 }
2056
2057 NetEBinary* NetEBinary::dup_expr() const
2058 {
2059 assert(0);
2060 }
2061
2062 NetEBLogic::NetEBLogic(char op, NetExpr*l, NetExpr*r)
2063 : NetEBinary(op, l, r)
2064 {
2065 expr_width(1);
2066 }
2067
2068 NetEBLogic::~NetEBLogic()
2069 {
2070 }
2071
2072 NetEBLogic* NetEBLogic::dup_expr() const
2073 {
2074 NetEBLogic*result = new NetEBLogic(op_, left_->dup_expr(),
2075 right_->dup_expr());
2076 return result;
2077 }
2078
2079 NetEBMult::NetEBMult(char op, NetExpr*l, NetExpr*r)
2080 : NetEBinary(op, l, r)
2081 {
2082 expr_width(l->expr_width() + r->expr_width());
2083 }
2084
2085 NetEBMult::~NetEBMult()
2086 {
2087 }
2088
2089 NetEBMult* NetEBMult::dup_expr() const
2090 {
2091 NetEBMult*result = new NetEBMult(op_, left_->dup_expr(),
2092 right_->dup_expr());
2093 return result;
2094 }
2095
2096 NetEBShift::NetEBShift(char op, NetExpr*l, NetExpr*r)
2097 : NetEBinary(op, l, r)
2098 {
2099 expr_width(l->expr_width());
2100 }
2101
2102 NetEBShift::~NetEBShift()
2103 {
2104 }
2105
2106 NetEBShift* NetEBShift::dup_expr() const
2107 {
2108 NetEBShift*result = new NetEBShift(op_, left_->dup_expr(),
2109 right_->dup_expr());
2110 return result;
2111 }
2112
2113 NetEConcat::NetEConcat(unsigned cnt, unsigned r)
2114 : parms_(cnt), repeat_(r)
2115 {
2116 expr_width(0);
2117 }
2118
2119 NetEConcat::~NetEConcat()
2120 {
2121 for (unsigned idx = 0 ; idx < parms_.count() ; idx += 1)
2122 delete parms_[idx];
2123 }
2124
2125 void NetEConcat::set(unsigned idx, NetExpr*e)
2126 {
2127 assert(idx < parms_.count());
2128 assert(parms_[idx] == 0);
2129 parms_[idx] = e;
2130 expr_width( expr_width() + repeat_*e->expr_width() );
2131 }
2132
2133 NetEConcat* NetEConcat::dup_expr() const
2134 {
2135 NetEConcat*dup = new NetEConcat(parms_.count(), repeat_);
2136 for (unsigned idx = 0 ; idx < parms_.count() ; idx += 1)
2137 if (parms_[idx]) {
2138 assert(parms_[idx]->dup_expr());
2139 dup->parms_[idx] = parms_[idx]->dup_expr();
2140 }
2141
2142
2143 dup->expr_width(expr_width());
2144 return dup;
2145 }
2146
2147 NetEConst::NetEConst(const verinum&val)
2148 : NetExpr(val.len()), value_(val)
2149 {
2150 }
2151
2152 NetEConst::~NetEConst()
2153 {
2154 }
2155
2156 NetEConst* NetEConst::dup_expr() const
2157 {
2158 NetEConst*tmp = new NetEConst(value_);
2159 tmp->set_line(*this);
2160 return tmp;
2161 }
2162
2163 NetEIdent* NetEIdent::dup_expr() const
2164 {
2165 assert(0);
2166 }
2167
2168 NetEMemory::NetEMemory(NetMemory*m, NetExpr*i)
2169 : NetExpr(m->width()), mem_(m), idx_(i)
2170 {
2171 }
2172
2173 NetEMemory::~NetEMemory()
2174 {
2175 }
2176
2177 NetMemory::NetMemory(NetScope*sc, const string&n, long w, long s, long e)
2178 : name_(n), width_(w), idxh_(s), idxl_(e), ram_list_(0), scope_(sc)
2179 {
2180 scope_->add_memory(this);
2181 }
2182
2183 NetMemory::~NetMemory()
2184 {
2185 assert(scope_);
2186 scope_->rem_memory(this);
2187 }
2188
2189 unsigned NetMemory::count() const
2190 {
2191 if (idxh_ < idxl_)
2192 return idxl_ - idxh_ + 1;
2193 else
2194 return idxh_ - idxl_ + 1;
2195 }
2196
2197 unsigned NetMemory::index_to_address(long idx) const
2198 {
2199 if (idxh_ < idxl_)
2200 return idx - idxh_;
2201 else
2202 return idx - idxl_;
2203 }
2204
2205
2206 void NetMemory::set_attributes(const map<string,string>&attr)
2207 {
2208 assert(attributes_.size() == 0);
2209 attributes_ = attr;
2210 }
2211
2212 NetEMemory* NetEMemory::dup_expr() const
2213 {
2214 assert(0);
2215 }
2216
2217 NetEParam::NetEParam()
2218 : des_(0)
2219 {
2220 }
2221
2222 NetEParam::NetEParam(Design*d, NetScope*s, const string&n)
2223 : des_(d), scope_(s), name_(n)
2224 {
2225 }
2226
2227 NetEParam::~NetEParam()
2228 {
2229 }
2230
2231 NetEParam* NetEParam::dup_expr() const
2232 {
2233 return 0;
2234 }
2235
2236 NetEScope::NetEScope(NetScope*s)
2237 : scope_(s)
2238 {
2239 }
2240
2241 NetEScope::~NetEScope()
2242 {
2243 }
2244
2245 const NetScope* NetEScope::scope() const
2246 {
2247 return scope_;
2248 }
2249
2250 NetESFunc::NetESFunc(const string&n, unsigned width, unsigned np)
2251 : name_(n)
2252 {
2253 expr_width(width);
2254 nparms_ = np;
2255 parms_ = new NetExpr*[np];
2256 for (unsigned idx = 0 ; idx < nparms_ ; idx += 1)
2257 parms_[idx] = 0;
2258 }
2259
2260 NetESFunc::~NetESFunc()
2261 {
2262 for (unsigned idx = 0 ; idx < nparms_ ; idx += 1)
2263 if (parms_[idx]) delete parms_[idx];
2264
2265 delete[]parms_;
2266 }
2267
2268 const string& NetESFunc::name() const
2269 {
2270 return name_;
2271 }
2272
2273 unsigned NetESFunc::nparms() const
2274 {
2275 return nparms_;
2276 }
2277
2278 void NetESFunc::parm(unsigned idx, NetExpr*v)
2279 {
2280 assert(idx < nparms_);
2281 if (parms_[idx])
2282 delete parms_[idx];
2283 parms_[idx] = v;
2284 }
2285
2286 const NetExpr* NetESFunc::parm(unsigned idx) const
2287 {
2288 assert(idx < nparms_);
2289 return parms_[idx];
2290 }
2291
2292 NetExpr* NetESFunc::parm(unsigned idx)
2293 {
2294 assert(idx < nparms_);
2295 return parms_[idx];
2296 }
2297
2298 NetESignal::NetESignal(NetNet*n)
2299 : NetExpr(n->pin_count()), net_(n)
2300 {
2301 net_->incr_eref();
2302 set_line(*n);
2303 }
2304
2305 NetESignal::~NetESignal()
2306 {
2307 net_->decr_eref();
2308 }
2309
2310 const string& NetESignal::name() const
2311 {
2312 return net_->name();
2313 }
2314
2315 unsigned NetESignal::pin_count() const
2316 {
2317 return net_->pin_count();
2318 }
2319
2320 Link& NetESignal::pin(unsigned idx)
2321 {
2322 return net_->pin(idx);
2323 }
2324
2325 NetESignal* NetESignal::dup_expr() const
2326 {
2327 assert(0);
2328 }
2329
2330 NetESubSignal::NetESubSignal(NetESignal*sig, NetExpr*ex)
2331 : sig_(sig), idx_(ex)
2332 {
2333 // This supports mux type indexing of an expression, so the
2334 // with is by definition 1 bit.
2335 expr_width(1);
2336 }
2337
2338 NetESubSignal::~NetESubSignal()
2339 {
2340 delete idx_;
2341 }
2342
2343 NetESubSignal* NetESubSignal::dup_expr() const
2344 {
2345 assert(0);
2346 }
2347
2348 NetETernary::NetETernary(NetExpr*c, NetExpr*t, NetExpr*f)
2349 : cond_(c), true_val_(t), false_val_(f)
2350 {
2351 expr_width(true_val_->expr_width());
2352 }
2353
2354 NetETernary::~NetETernary()
2355 {
2356 delete cond_;
2357 delete true_val_;
2358 delete false_val_;
2359 }
2360
2361 const NetExpr* NetETernary::cond_expr() const
2362 {
2363 return cond_;
2364 }
2365
2366 const NetExpr* NetETernary::true_expr() const
2367 {
2368 return true_val_;
2369 }
2370
2371 const NetExpr* NetETernary::false_expr() const
2372 {
2373 return false_val_;
2374 }
2375
2376 NetETernary* NetETernary::dup_expr() const
2377 {
2378 assert(0);
2379 }
2380
2381 NetEUnary::NetEUnary(char op, NetExpr*ex)
2382 : NetExpr(ex->expr_width()), op_(op), expr_(ex)
2383 {
2384 switch (op_) {
2385 case '!': // Logical not
2386 case '&': // Reduction and
2387 case '|': // Reduction or
2388 case '^': // Reduction XOR
2389 case 'A': // Reduction NAND (~&)
2390 case 'N': // Reduction NOR (~|)
2391 case 'X': // Reduction NXOR (~^)
2392 expr_width(1);
2393 break;
2394 }
2395 }
2396
2397 NetEUnary::~NetEUnary()
2398 {
2399 delete expr_;
2400 }
2401
2402 NetEUnary* NetEUnary::dup_expr() const
2403 {
2404 assert(0);
2405 }
2406
2407 NetEUBits::NetEUBits(char op, NetExpr*ex)
2408 : NetEUnary(op, ex)
2409 {
2410 }
2411
2412 NetEUBits::~NetEUBits()
2413 {
2414 }
2415
2416 NetForever::NetForever(NetProc*p)
2417 : statement_(p)
2418 {
2419 }
2420
2421 NetForever::~NetForever()
2422 {
2423 delete statement_;
2424 }
2425
2426 NetLogic::NetLogic(const string&n, unsigned pins, TYPE t)
2427 : NetNode(n, pins), type_(t)
2428 {
2429 pin(0).set_dir(Link::OUTPUT);
2430 pin(0).set_name("O", 0);
2431 for (unsigned idx = 1 ; idx < pins ; idx += 1) {
2432 pin(idx).set_dir(Link::INPUT);
2433 pin(idx).set_name("I", idx-1);
2434 }
2435 }
2436
2437 NetRepeat::NetRepeat(NetExpr*e, NetProc*p)
2438 : expr_(e), statement_(p)
2439 {
2440 }
2441
2442 NetRepeat::~NetRepeat()
2443 {
2444 delete expr_;
2445 delete statement_;
2446 }
2447
2448 const NetExpr* NetRepeat::expr() const
2449 {
2450 return expr_;
2451 }
2452
2453 NetTaskDef::NetTaskDef(const string&n, const svector<NetNet*>&po)
2454 : name_(n), proc_(0), ports_(po)
2455 {
2456 }
2457
2458 NetTaskDef::~NetTaskDef()
2459 {
2460 delete proc_;
2461 }
2462
2463 void NetTaskDef::set_proc(NetProc*p)
2464 {
2465 assert(proc_ == 0);
2466 proc_ = p;
2467 }
2468
2469 unsigned NetTaskDef::port_count() const
2470 {
2471 return ports_.count();
2472 }
2473
2474 NetNet* NetTaskDef::port(unsigned idx)
2475 {
2476 assert(idx < ports_.count());
2477 return ports_[idx];
2478 }
2479
2480 const string& NetTaskDef::name() const
2481 {
2482 return name_;
2483 }
2484
2485 const NetProc*NetTaskDef::proc() const
2486 {
2487 return proc_;
2488 }
2489
2490 /*
2491 * This method takes the input string, which contains exactly one
2492 * edge, and connects it to the correct output state. The output state
2493 * will be generated if needed, and the value compared.
2494 */
2495 bool NetUDP::set_sequ_(const string&input, char output)
2496 {
2497 if (output == '-')
2498 output = input[0];
2499
2500 string frm = input;
2501 string to = input;
2502 to[0] = output;
2503
2504 unsigned edge = frm.find_first_not_of("01x");
2505 assert(frm.find_last_not_of("01x") == edge);
2506
2507 switch (input[edge]) {
2508 case 'r':
2509 frm[edge] = '0';
2510 to[edge] = '1';
2511 break;
2512 case 'R':
2513 frm[edge] = 'x';
2514 to[edge] = '1';
2515 break;
2516 case 'f':
2517 frm[edge] = '1';
2518 to[edge] = '0';
2519 break;
2520 case 'F':
2521 frm[edge] = 'x';
2522 to[edge] = '0';
2523 break;
2524 case 'P':
2525 frm[edge] = '0';
2526 to[edge] = 'x';
2527 break;
2528 case 'N':
2529 frm[edge] = '1';
2530 to[edge] = 'x';
2531 break;
2532 default:
2533 assert(0);
2534 }
2535
2536 state_t_*sfrm = find_state_(frm);
2537 state_t_*sto = find_state_(to);
2538
2539 switch (to[edge]) {
2540 case '0':
2541 // Notice that I might have caught this edge already
2542 if (sfrm->pins[edge].zer != sto) {
2543 assert(sfrm->pins[edge].zer == 0);
2544 sfrm->pins[edge].zer = sto;
2545 }
2546 break;
2547 case '1':
2548 // Notice that I might have caught this edge already
2549 if (sfrm->pins[edge].one != sto) {
2550 assert(sfrm->pins[edge].one == 0);
2551 sfrm->pins[edge].one = sto;
2552 }
2553 break;
2554 case 'x':
2555 // Notice that I might have caught this edge already
2556 if (sfrm->pins[edge].xxx != sto) {
2557 assert(sfrm->pins[edge].xxx == 0);
2558 sfrm->pins[edge].xxx = sto;
2559 }
2560 break;
2561 }
2562
2563 return true;
2564 }
2565
2566 bool NetUDP::sequ_glob_(string input, char output)
2567 {
2568 for (unsigned idx = 0 ; idx < input.length() ; idx += 1)
2569 switch (input[idx]) {
2570 case '0':
2571 case '1':
2572 case 'x':
2573 case 'r':
2574 case 'R':
2575 case 'f':
2576 case 'F':
2577 case 'P':
2578 case 'N':
2579 break;
2580
2581 case '?': // Iterate over all the levels
2582 input[idx] = '0';
2583 sequ_glob_(input, output);
2584 input[idx] = '1';
2585 sequ_glob_(input, output);
2586 input[idx] = 'x';
2587 sequ_glob_(input, output);
2588 return true;
2589
2590 case 'n': // Iterate over (n) edges
2591 input[idx] = 'f';
2592 sequ_glob_(input, output);
2593 input[idx] = 'F';
2594 sequ_glob_(input, output);
2595 input[idx] = 'N';
2596 sequ_glob_(input, output);
2597 return true;
2598
2599 case 'p': // Iterate over (p) edges
2600 input[idx] = 'r';
2601 sequ_glob_(input, output);
2602 input[idx] = 'R';
2603 sequ_glob_(input, output);
2604 input[idx] = 'P';
2605 sequ_glob_(input, output);
2606 return true;
2607
2608 case '_': // Iterate over (?0) edges
2609 input[idx] = 'f';
2610 sequ_glob_(input, output);
2611 input[idx] = 'F';
2612 sequ_glob_(input, output);
2613 return true;
2614
2615 case '*': // Iterate over all the edges
2616 input[idx] = 'r';
2617 sequ_glob_(input, output);
2618 input[idx] = 'R';
2619 sequ_glob_(input, output);
2620 input[idx] = 'f';
2621 sequ_glob_(input, output);
2622 input[idx] = 'F';
2623 sequ_glob_(input, output);
2624 input[idx] = 'P';
2625 sequ_glob_(input, output);
2626 input[idx] = 'N';
2627 sequ_glob_(input, output);
2628 return true;
2629
2630 default:
2631 assert(0);
2632 }
2633
2634 return set_sequ_(input, output);
2635 }
2636
2637 /*
2638 * $Log: netlist.cc,v $
2639 * Revision 1.127 2000/05/27 19:33:23 steve
2640 * Merge similar probes within a module.
2641 *
2642 * Revision 1.126 2000/05/19 01:43:16 steve
2643 * Accept different widths for add operands.
2644 *
2645 * Revision 1.125 2000/05/11 23:37:27 steve
2646 * Add support for procedural continuous assignment.
2647 *
2648 * Revision 1.124 2000/05/07 18:20:07 steve
2649 * Import MCD support from Stephen Tell, and add
2650 * system function parameter support to the IVL core.
2651 *
2652 * Revision 1.123 2000/05/07 04:37:56 steve
2653 * Carry strength values from Verilog source to the
2654 * pform and netlist for gates.
2655 *
2656 * Change vvm constants to use the driver_t to drive
2657 * a constant value. This works better if there are
2658 * multiple drivers on a signal.
2659 *
2660 * Revision 1.122 2000/05/04 03:37:58 steve
2661 * Add infrastructure for system functions, move
2662 * $time to that structure and add $random.
2663 *
2664 * Revision 1.121 2000/05/02 03:13:31 steve
2665 * Move memories to the NetScope object.
2666 *
2667 * Revision 1.120 2000/05/02 00:58:12 steve
2668 * Move signal tables to the NetScope class.
2669 *
2670 * Revision 1.119 2000/04/28 18:43:23 steve
2671 * integer division in expressions properly get width.
2672 *
2673 * Revision 1.118 2000/04/23 03:45:24 steve
2674 * Add support for the procedural release statement.
2675 *
2676 * Revision 1.117 2000/04/22 04:20:19 steve
2677 * Add support for force assignment.
2678 *
2679 * Revision 1.116 2000/04/18 01:02:54 steve
2680 * Minor cleanup of NetTaskDef.
2681 *
2682 * Revision 1.115 2000/04/16 23:32:19 steve
2683 * Synthesis of comparator in expressions.
2684 *
2685 * Connect the NetEvent and related classes
2686 * together better.
2687 *
2688 * Revision 1.114 2000/04/15 19:51:30 steve
2689 * fork-join support in vvm.
2690 *
2691 * Revision 1.113 2000/04/12 20:02:53 steve
2692 * Finally remove the NetNEvent and NetPEvent classes,
2693 * Get synthesis working with the NetEvWait class,
2694 * and get started supporting multiple events in a
2695 * wait in vvm.
2696 *
2697 * Revision 1.112 2000/04/04 03:20:15 steve
2698 * Simulate named event trigger and waits.
2699 *
2700 * Revision 1.111 2000/04/02 04:26:06 steve
2701 * Remove the useless sref template.
2702 *
2703 * Revision 1.110 2000/04/01 21:40:22 steve
2704 * Add support for integer division.
2705 *
2706 * Revision 1.109 2000/03/29 04:37:11 steve
2707 * New and improved combinational primitives.
2708 *
2709 * Revision 1.108 2000/03/12 17:09:41 steve
2710 * Support localparam.
2711 *
2712 * Revision 1.107 2000/03/10 06:20:48 steve
2713 * Handle defparam to partial hierarchical names.
2714 *
2715 * Revision 1.106 2000/03/08 04:36:53 steve
2716 * Redesign the implementation of scopes and parameters.
2717 * I now generate the scopes and notice the parameters
2718 * in a separate pass over the pform. Once the scopes
2719 * are generated, I can process overrides and evalutate
2720 * paremeters before elaboration begins.
2721 *
2722 * Revision 1.105 2000/02/23 02:56:54 steve
2723 * Macintosh compilers do not support ident.
2724 *
2725 * Revision 1.104 2000/01/13 03:35:35 steve
2726 * Multiplication all the way to simulation.
2727 *
2728 * Revision 1.103 2000/01/10 01:35:24 steve
2729 * Elaborate parameters afer binding of overrides.
2730 *
2731 * Revision 1.102 1999/12/30 04:19:12 steve
2732 * Propogate constant 0 in low bits of adders.
2733 */
2734
Icarus Verilog