pform_dump.cc

   1 /*
   2  * Copyright (c) 1998-2008 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
  20 # include "config.h"
  21
  22 /*
  23  * This file provides the pform_dump function, that dumps the module
  24  * passed as a parameter. The dump is as much as possible in Verilog
  25  * syntax, so that a human can tell that it really does describe the
  26  * module in question.
  27  */
  28 # include  "pform.h"
  29 # include  "PEvent.h"
  30 # include  "PGenerate.h"
  31 # include  "PSpec.h"
  32 # include  "discipline.h"
  33 # include  <iostream>
  34 # include  <iomanip>
  35 # include  <typeinfo>
  36
  37 ostream& operator << (ostream&out, const PExpr&obj)
  38 {
  39       obj.dump(out);
  40       return out;
  41 }
  42
  43 ostream& operator << (ostream&o, const PDelays&d)
  44 {
  45       d.dump_delays(o);
  46       return o;
  47 }
  48
  49 ostream& operator<< (ostream&o, PGate::strength_t str)
  50 {
  51       switch (str) {
  52           case PGate::HIGHZ:
  53             o << "highz";
  54             break;
  55           case PGate::WEAK:
  56             o << "weak";
  57             break;
  58           case PGate::PULL:
  59             o << "pull";
  60             break;
  61           case PGate::STRONG:
  62             o << "strong";
  63             break;
  64           case PGate::SUPPLY:
  65             o << "supply";
  66             break;
  67           default:
  68             assert(0);
  69       }
  70       return o;
  71 }
  72
  73 ostream& operator<< (ostream&out, perm_string that)
  74 {
  75       out << that.str();
  76       return out;
  77 }
  78
  79 ostream& operator<< (ostream&out, const index_component_t&that)
  80 {
  81       out << "[";
  82       switch (that.sel) {
  83           case index_component_t::SEL_BIT:
  84             out << *that.msb;
  85             break;
  86           case index_component_t::SEL_PART:
  87             out << *that.msb << ":" << *that.lsb;
  88             break;
  89           case index_component_t::SEL_IDX_UP:
  90             out << *that.msb << "+:" << *that.lsb;
  91             break;
  92           case index_component_t::SEL_IDX_DO:
  93             out << *that.msb << "-:" << *that.lsb;
  94             break;
  95           default:
  96             out << "???";
  97             break;
  98       }
  99       out << "]";
 100       return out;
 101 }
 102
 103 ostream& operator<< (ostream&out, const name_component_t&that)
 104 {
 105       out << that.name.str();
 106
 107       typedef std::list<index_component_t>::const_iterator index_it_t;
 108       for (index_it_t idx = that.index.begin()
 109                  ; idx != that.index.end() ;  idx++) {
 110
 111             out << *idx;
 112       }
 113       return out;
 114 }
 115
 116 ostream& operator<< (ostream&o, const pform_name_t&that)
 117 {
 118       pform_name_t::const_iterator cur;
 119
 120       cur = that.begin();
 121       o << *cur;
 122
 123       cur++;
 124       while (cur != that.end()) {
 125             o << "." << *cur;
 126             cur++;
 127       }
 128
 129       return o;
 130 }
 131
 132
 133 std::ostream& operator << (std::ostream&out, ddomain_t dom)
 134 {
 135       switch (dom) {
 136           case DD_NONE:
 137             out << "no-domain";
 138             break;
 139           case DD_DISCRETE:
 140             out << "discrete";
 141             break;
 142           case DD_CONTINUOUS:
 143             out << "continuous";
 144             break;
 145           default:
 146             assert(0);
 147             break;
 148       }
 149       return out;
 150 }
 151
 152 void PExpr::dump(ostream&out) const
 153 {
 154       out << typeid(*this).name();
 155 }
 156
 157 void PEConcat::dump(ostream&out) const
 158 {
 159       if (repeat_)
 160             out << "{" << *repeat_;
 161
 162       if (parms_.count() == 0) {
 163             out << "{}";
 164             return;
 165       }
 166
 167       out << "{";
 168       if (parms_[0]) out << *parms_[0];
 169       for (unsigned idx = 1 ;  idx < parms_.count() ;  idx += 1) {
 170             out << ", ";
 171             if (parms_[idx]) out << *parms_[idx];
 172       }
 173
 174       out << "}";
 175
 176       if (repeat_) out << "}";
 177 }
 178
 179 void PECallFunction::dump(ostream &out) const
 180 {
 181       out << path_ << "(";
 182
 183       if (parms_.count() > 0) {
 184             if (parms_[0]) parms_[0]->dump(out);
 185             for (unsigned idx = 1; idx < parms_.count(); ++idx) {
 186                   out << ", ";
 187                   if (parms_[idx]) parms_[idx]->dump(out);
 188             }
 189       }
 190       out << ")";
 191 }
 192
 193 void PEEvent::dump(ostream&out) const
 194 {
 195       switch (type_) {
 196           case PEEvent::ANYEDGE:
 197             break;
 198           case PEEvent::POSEDGE:
 199             out << "posedge ";
 200             break;
 201           case PEEvent::NEGEDGE:
 202             out << "negedge ";
 203             break;
 204           case PEEvent::POSITIVE:
 205             out << "positive ";
 206             break;
 207       }
 208       out << *expr_;
 209
 210 }
 211
 212 void PEFNumber::dump(ostream &out) const
 213 {
 214       out << value();
 215 }
 216
 217 void PENumber::dump(ostream&out) const
 218 {
 219       out << value();
 220 }
 221
 222 void PEIdent::dump(ostream&out) const
 223 {
 224       out << path_;
 225 }
 226
 227 void PEString::dump(ostream&out) const
 228 {
 229       out << "\"" << text_ << "\"";
 230 }
 231
 232 void PETernary::dump(ostream&out) const
 233 {
 234       out << "(" << *expr_ << ")?(" << *tru_ << "):(" << *fal_ << ")";
 235 }
 236
 237 void PEUnary::dump(ostream&out) const
 238 {
 239       switch (op_) {
 240           case 'm':
 241             out << "abs";
 242             break;
 243           default:
 244             out << op_;
 245             break;
 246       }
 247       out << "(" << *expr_ << ")";
 248 }
 249
 250 void PEBinary::dump(ostream&out) const
 251 {
 252         /* Handle some special cases, where the operators are written
 253            in function notation. */
 254       if (op_ == 'm') {
 255             out << "min(" << *left_ << "," << *right_ << ")";
 256             return;
 257       }
 258       if (op_ == 'M') {
 259             out << "min(" << *left_ << "," << *right_ << ")";
 260             return;
 261       }
 262
 263       out << "(" << *left_ << ")";
 264       switch (op_) {
 265           case 'a':
 266             out << "&&";
 267             break;
 268           case 'e':
 269             out << "==";
 270             break;
 271           case 'E':
 272             out << "===";
 273             break;
 274           case 'l':
 275             out << "<<";
 276             break;
 277           case 'n':
 278             out << "!=";
 279             break;
 280           case 'N':
 281             out << "!==";
 282             break;
 283           case 'R':
 284             out << ">>>";
 285             break;
 286           case 'r':
 287             out << ">>";
 288             break;
 289           default:
 290             out << op_;
 291             break;
 292       }
 293       out << "(" << *right_ << ")";
 294 }
 295
 296
 297 void PWire::dump(ostream&out, unsigned ind) const
 298 {
 299       out << setw(ind) << "" << type_;
 300
 301       switch (port_type_) {
 302           case NetNet::PIMPLICIT:
 303             out << " implicit input";
 304             break;
 305           case NetNet::PINPUT:
 306             out << " input";
 307             break;
 308           case NetNet::POUTPUT:
 309             out << " output";
 310             break;
 311           case NetNet::PINOUT:
 312             out << " inout";
 313             break;
 314           case NetNet::NOT_A_PORT:
 315             break;
 316       }
 317
 318       out << " " << data_type_;
 319
 320       if (signed_) {
 321             out << " signed";
 322       }
 323
 324       if (discipline_) {
 325             out << " discipline<" << discipline_->name() << ">";
 326       }
 327
 328       if (port_set_) {
 329             if (port_msb_ == 0) {
 330                   out << " port<scalar>";
 331             } else {
 332                   out << " port[" << *port_msb_ << ":" << *port_lsb_ << "]";
 333             }
 334       }
 335       if (net_set_) {
 336             if (net_msb_ == 0) {
 337                   out << " net<scalar>";
 338             } else {
 339                   out << " net[" << *net_msb_ << ":" << *net_lsb_ << "]";
 340             }
 341       }
 342
 343       out << " " << name_;
 344
 345         // If the wire has indices, dump them.
 346       if (lidx_ || ridx_) {
 347             out << "[";
 348             if (lidx_) out << *lidx_;
 349             if (ridx_) out << ":" << *ridx_;
 350             out << "]";
 351       }
 352
 353       out << ";" << endl;
 354       for (map<perm_string,PExpr*>::const_iterator idx = attributes.begin()
 355                  ; idx != attributes.end()
 356                  ; idx ++) {
 357             out << "        " << (*idx).first;
 358             if ((*idx).second)
 359                   out << " = " << *(*idx).second;
 360             out << endl;
 361       }
 362 }
 363
 364 void PGate::dump_pins(ostream&out) const
 365 {
 366       if (pin_count()) {
 367             if (pin(0)) out << *pin(0);
 368
 369             for (unsigned idx = 1 ;  idx < pin_count() ;  idx += 1) {
 370                   out << ", ";
 371                   if (pin(idx)) out << *pin(idx);
 372             }
 373       }
 374 }
 375
 376 void PDelays::dump_delays(ostream&out) const
 377 {
 378       if (delay_[0] && delay_[1] && delay_[2])
 379             out << "#(" << *delay_[0] << "," << *delay_[1] << "," <<
 380                   *delay_[2] << ")";
 381       else if (delay_[0])
 382             out << "#" << *delay_[0];
 383       else
 384             out << "#0";
 385
 386 }
 387
 388 void PGate::dump_delays(ostream&out) const
 389 {
 390       delay_.dump_delays(out);
 391 }
 392
 393 void PGate::dump(ostream&out, unsigned ind) const
 394 {
 395       out << setw(ind) << "" << typeid(*this).name() << " ";
 396       delay_.dump_delays(out);
 397       out << " " << get_name() << "(";
 398       dump_pins(out);
 399       out << ");" << endl;
 400
 401 }
 402
 403 void PGAssign::dump(ostream&out, unsigned ind) const
 404 {
 405       out << setw(ind) << "";
 406       out << "assign (" << strength0() << "0 " << strength1() << "1) ";
 407       dump_delays(out);
 408       out << " " << *pin(0) << " = " << *pin(1) << ";" << endl;
 409 }
 410
 411 void PGBuiltin::dump(ostream&out, unsigned ind) const
 412 {
 413       out << setw(ind) << "";
 414       switch (type()) {
 415           case PGBuiltin::BUFIF0:
 416             out << "bufif0 ";
 417             break;
 418           case PGBuiltin::BUFIF1:
 419             out << "bufif1 ";
 420             break;
 421           case PGBuiltin::NOTIF0:
 422             out << "bufif0 ";
 423             break;
 424           case PGBuiltin::NOTIF1:
 425             out << "bufif1 ";
 426             break;
 427           case PGBuiltin::NAND:
 428             out << "nand ";
 429             break;
 430           case PGBuiltin::NMOS:
 431             out << "nmos ";
 432             break;
 433           case PGBuiltin::RNMOS:
 434             out << "rnmos ";
 435             break;
 436           case PGBuiltin::RPMOS:
 437             out << "rpmos ";
 438             break;
 439           case PGBuiltin::PMOS:
 440             out << "pmos ";
 441             break;
 442           case PGBuiltin::RCMOS:
 443             out << "rcmos ";
 444             break;
 445           case PGBuiltin::CMOS:
 446             out << "cmos ";
 447             break;
 448           default:
 449             out << "builtin gate ";
 450       }
 451
 452       out << "(" << strength0() << "0 " << strength1() << "1) ";
 453       dump_delays(out);
 454       out << " " << get_name();
 455
 456       if (msb_) {
 457             out << " [" << *msb_ << ":" << *lsb_ << "]";
 458       }
 459
 460       out << "(";
 461       dump_pins(out);
 462       out << ");" << endl;
 463 }
 464
 465 void PGModule::dump(ostream&out, unsigned ind) const
 466 {
 467       out << setw(ind) << "" << type_ << " ";
 468
 469         // If parameters are overridden by order, dump them.
 470       if (overrides_ && overrides_->count() > 0) {
 471             assert(parms_ == 0);
 472             out << "#(";
 473
 474             if ((*overrides_)[0] == 0)
 475                   out << "<nil>";
 476             else
 477                   out << *((*overrides_)[0]);
 478             for (unsigned idx = 1 ;  idx < overrides_->count() ;  idx += 1) {
 479                   out << "," << *((*overrides_)[idx]);
 480             }
 481             out << ") ";
 482       }
 483
 484         // If parameters are overridden by name, dump them.
 485       if (parms_) {
 486             assert(overrides_ == 0);
 487             out << "#(";
 488             out << "." << parms_[0].name << "(" << *parms_[0].parm << ")";
 489             for (unsigned idx = 1 ;  idx < nparms_ ;  idx += 1) {
 490                   out << ", ." << parms_[idx].name << "(" <<
 491                         *parms_[idx].parm << ")";
 492             }
 493             out << ") ";
 494       }
 495
 496       out << get_name();
 497
 498         // If the module is arrayed, print the index expressions.
 499       if (msb_ || lsb_) {
 500             out << "[";
 501             if (msb_) out << *msb_;
 502             out << ":";
 503             if (lsb_) out << *lsb_;
 504             out << "]";
 505       }
 506
 507       out << "(";
 508       if (pins_) {
 509             out << "." << pins_[0].name << "(";
 510             if (pins_[0].parm) out << *pins_[0].parm;
 511             out << ")";
 512             for (unsigned idx = 1 ;  idx < npins_ ;  idx += 1) {
 513                   out << ", ." << pins_[idx].name << "(";
 514                   if (pins_[idx].parm)
 515                         out << *pins_[idx].parm;
 516                   out << ")";
 517             }
 518       } else {
 519             dump_pins(out);
 520       }
 521       out << ");" << endl;
 522 }
 523
 524 void Statement::dump(ostream&out, unsigned ind) const
 525 {
 526         /* I give up. I don't know what type this statement is,
 527            so just print the C++ typeid and let the user figure
 528            it out. */
 529       out << setw(ind) << "";
 530       out << "/* " << get_fileline() << ": " << typeid(*this).name()
 531           << " */ ;" << endl;
 532 }
 533
 534 void PAssign::dump(ostream&out, unsigned ind) const
 535 {
 536       out << setw(ind) << "";
 537       out << *lval() << " = " << delay_ << " " << *rval() << ";";
 538       out << "  /* " << get_fileline() << " */" << endl;
 539 }
 540
 541 void PAssignNB::dump(ostream&out, unsigned ind) const
 542 {
 543       out << setw(ind) << "";
 544       out << *lval() << " <= " << delay_ << " " << *rval() << ";";
 545       out << "  /* " << get_fileline() << " */" << endl;
 546 }
 547
 548 void PBlock::dump(ostream&out, unsigned ind) const
 549 {
 550       out << setw(ind) << "" << "begin";
 551       if (pscope_name() != 0)
 552             out << " : " << pscope_name();
 553       out << endl;
 554
 555       if (pscope_name() != 0)
 556             dump_wires_(out, ind+2);
 557
 558       for (unsigned idx = 0 ;  idx < list_.count() ;  idx += 1) {
 559             if (list_[idx])
 560                   list_[idx]->dump(out, ind+2);
 561             else
 562                   out << setw(ind+2) << "" << "/* NOOP */ ;" << endl;
 563       }
 564
 565       out << setw(ind) << "" << "end" << endl;
 566 }
 567
 568 void PCallTask::dump(ostream&out, unsigned ind) const
 569 {
 570       out << setw(ind) << "" << path_;
 571
 572       if (parms_.count() > 0) {
 573             out << "(";
 574             if (parms_[0])
 575                   out << *parms_[0];
 576
 577             for (unsigned idx = 1 ;  idx < parms_.count() ;  idx += 1) {
 578                   out << ", ";
 579                   if (parms_[idx])
 580                         out << *parms_[idx];
 581             }
 582             out << ")";
 583       }
 584
 585       out << "; /* " << get_fileline() << " */" << endl;
 586 }
 587
 588 void PCase::dump(ostream&out, unsigned ind) const
 589 {
 590       out << setw(ind) << "";
 591       switch (type_) {
 592           case NetCase::EQ:
 593             out << "case";
 594             break;
 595           case NetCase::EQX:
 596             out << "casex";
 597             break;
 598           case NetCase::EQZ:
 599             out << "casez";
 600             break;
 601       }
 602       out << " (" << *expr_ << ") /* " << get_fileline() << " */" << endl;
 603
 604       for (unsigned idx = 0 ;  idx < items_->count() ;  idx += 1) {
 605             PCase::Item*cur = (*items_)[idx];
 606
 607             if (cur->expr.count() == 0) {
 608                   out << setw(ind+2) << "" << "default:";
 609
 610             } else {
 611                   out << setw(ind+2) << "" << *cur->expr[0];
 612
 613                   for(unsigned e = 1 ; e < cur->expr.count() ; e += 1)
 614                         out << ", " << *cur->expr[e];
 615
 616                   out << ":";
 617             }
 618
 619             if (cur->stat) {
 620                   out << endl;
 621                   cur->stat->dump(out, ind+6);
 622             } else {
 623                   out << " ;" << endl;
 624             }
 625       }
 626
 627       out << setw(ind) << "" << "endcase" << endl;
 628 }
 629
 630 void PCondit::dump(ostream&out, unsigned ind) const
 631 {
 632       out << setw(ind) << "" << "if (" << *expr_ << ")" << endl;
 633       if (if_)
 634             if_->dump(out, ind+3);
 635       else
 636             out << setw(ind) << ";" << endl;
 637       if (else_) {
 638             out << setw(ind) << "" << "else" << endl;
 639             else_->dump(out, ind+3);
 640       }
 641 }
 642
 643 void PCAssign::dump(ostream&out, unsigned ind) const
 644 {
 645       out << setw(ind) << "" << "assign " << *lval_ << " = " << *expr_
 646           << "; /* " << get_fileline() << " */" << endl;
 647 }
 648
 649 void PDeassign::dump(ostream&out, unsigned ind) const
 650 {
 651       out << setw(ind) << "" << "deassign " << *lval_ << "; /* "
 652           << get_fileline() << " */" << endl;
 653 }
 654
 655 void PDelayStatement::dump(ostream&out, unsigned ind) const
 656 {
 657       out << setw(ind) << "" << "#" << *delay_ << " /* " <<
 658             get_fileline() << " */";
 659       if (statement_) {
 660             out << endl;
 661             statement_->dump(out, ind+2);
 662       } else {
 663             out << " /* noop */;" << endl;
 664       }
 665 }
 666
 667 void PDisable::dump(ostream&out, unsigned ind) const
 668 {
 669       out << setw(ind) << "" << "disable " << scope_ << "; /* "
 670           << get_fileline() << " */" << endl;
 671 }
 672
 673 void PEventStatement::dump(ostream&out, unsigned ind) const
 674 {
 675       if (expr_.count() == 0) {
 676             out << setw(ind) << "" << "@* ";
 677
 678       } else {
 679             out << setw(ind) << "" << "@(" << *(expr_[0]);
 680             if (expr_.count() > 1)
 681                   for (unsigned idx = 1 ;  idx < expr_.count() ;  idx += 1)
 682                         out << " or " << *(expr_[idx]);
 683
 684             out << ")";
 685       }
 686
 687       if (statement_) {
 688             out << endl;
 689             statement_->dump(out, ind+2);
 690       } else {
 691             out << " ;" << endl;
 692       }
 693 }
 694
 695 void PForce::dump(ostream&out, unsigned ind) const
 696 {
 697       out << setw(ind) << "" << "force " << *lval_ << " = " << *expr_
 698           << "; /* " << get_fileline() << " */" << endl;
 699 }
 700
 701 void PForever::dump(ostream&out, unsigned ind) const
 702 {
 703       out << setw(ind) << "" << "forever /* " << get_fileline() << " */" << endl;
 704       statement_->dump(out, ind+3);
 705 }
 706
 707 void PForStatement::dump(ostream&out, unsigned ind) const
 708 {
 709       out << setw(ind) << "" << "for (" << *name1_ << " = " << *expr1_
 710           << "; " << *cond_ << "; " << *name2_ << " = " << *expr2_ <<
 711             ")" << endl;
 712       statement_->dump(out, ind+3);
 713 }
 714
 715 void PFunction::dump(ostream&out, unsigned ind) const
 716 {
 717       out << setw(ind) << "" << "function ";
 718       switch (return_type_.type) {
 719           case PTF_NONE:
 720             out << "?none? ";
 721             break;
 722           case PTF_REG:
 723             out << "reg ";
 724             break;
 725           case PTF_REG_S:
 726             out << "reg_s ";
 727             break;
 728           case PTF_INTEGER:
 729             out << "integer ";
 730             break;
 731           case PTF_REAL:
 732             out << "real ";
 733             break;
 734           case PTF_REALTIME:
 735             out << "realtime ";
 736             break;
 737           case PTF_TIME:
 738             out << "time ";
 739             break;
 740       }
 741
 742       if (return_type_.range) {
 743             out << "[";
 744             out << "] ";
 745       }
 746
 747       out << pscope_name() << ";" << endl;
 748
 749       if (ports_)
 750             for (unsigned idx = 0 ;  idx < ports_->count() ;  idx += 1) {
 751                   out << setw(ind) << "";
 752                   out << "input ";
 753                   out << (*ports_)[idx]->basename() << ";" << endl;
 754             }
 755
 756       dump_wires_(out, ind);
 757
 758       if (statement_)
 759             statement_->dump(out, ind);
 760       else
 761             out << setw(ind) << "" << "/* NOOP */" << endl;
 762 }
 763
 764 void PRelease::dump(ostream&out, unsigned ind) const
 765 {
 766       out << setw(ind) << "" << "release " << *lval_ << "; /* "
 767           << get_fileline() << " */" << endl;
 768 }
 769
 770 void PRepeat::dump(ostream&out, unsigned ind) const
 771 {
 772       out << setw(ind) << "" << "repeat (" << *expr_ << ")" << endl;
 773       statement_->dump(out, ind+3);
 774 }
 775
 776 void PTask::dump(ostream&out, unsigned ind) const
 777 {
 778       if (ports_)
 779             for (unsigned idx = 0 ;  idx < ports_->count() ;  idx += 1) {
 780                   out << setw(ind) << "";
 781                   switch ((*ports_)[idx]->get_port_type()) {
 782                       case NetNet::PINPUT:
 783                         out << "input ";
 784                         break;
 785                       case NetNet::POUTPUT:
 786                         out << "output ";
 787                         break;
 788                       case NetNet::PINOUT:
 789                         out << "inout ";
 790                         break;
 791                       default:
 792                         assert(0);
 793                         break;
 794                   }
 795                   out << (*ports_)[idx]->basename() << ";" << endl;
 796             }
 797
 798       dump_wires_(out, ind);
 799
 800       if (statement_)
 801             statement_->dump(out, ind);
 802       else
 803             out << setw(ind) << "" << "/* NOOP */" << endl;
 804 }
 805
 806 void PTrigger::dump(ostream&out, unsigned ind) const
 807 {
 808       out << setw(ind) << "" << "-> " << event_ << ";" << endl;
 809 }
 810
 811 void PWhile::dump(ostream&out, unsigned ind) const
 812 {
 813       out << setw(ind) << "" << "while (" << *cond_ << ")" << endl;
 814       statement_->dump(out, ind+3);
 815 }
 816
 817 void PProcess::dump(ostream&out, unsigned ind) const
 818 {
 819       switch (type_) {
 820           case PProcess::PR_INITIAL:
 821             out << setw(ind) << "" << "initial";
 822             break;
 823           case PProcess::PR_ALWAYS:
 824             out << setw(ind) << "" << "always";
 825             break;
 826       }
 827
 828       out << " /* " << get_fileline() << " */" << endl;
 829
 830       for (map<perm_string,PExpr*>::const_iterator idx = attributes.begin()
 831                  ; idx != attributes.end() ; idx++ ) {
 832
 833             out << setw(ind+2) << "" << "(* " << (*idx).first;
 834             if ((*idx).second) {
 835                   out << " = " << *(*idx).second;
 836             }
 837             out << " *)" << endl;
 838       }
 839
 840       statement_->dump(out, ind+2);
 841 }
 842
 843 void PSpecPath::dump(std::ostream&out, unsigned ind) const
 844 {
 845       out << setw(ind) << "" << "specify path ";
 846
 847       if (condition)
 848             out << "if (" << *condition << ") ";
 849
 850       out << "(";
 851       if (edge) {
 852             if (edge > 0)
 853                   out << "posedge ";
 854             else
 855                   out << "negedge ";
 856       }
 857
 858       for (unsigned idx = 0 ;  idx < src.size() ;  idx += 1) {
 859             if (idx > 0) out << ", ";
 860             assert(src[idx]);
 861             out << src[idx];
 862       }
 863
 864       out << " => ";
 865
 866       if (data_source_expression)
 867             out << "(";
 868
 869       for (unsigned idx = 0 ; idx < dst.size() ;  idx += 1) {
 870             if (idx > 0) out << ", ";
 871             assert(dst[idx]);
 872             out << dst[idx];
 873       }
 874
 875       if (data_source_expression)
 876             out << " : " << *data_source_expression << ")";
 877
 878       out << ") = (";
 879       for (unsigned idx = 0 ;  idx < delays.size() ;  idx += 1) {
 880             if (idx > 0) out << ", ";
 881             assert(delays[idx]);
 882             out << *delays[idx];
 883       }
 884       out << ");" << endl;
 885 }
 886
 887 void PGenerate::dump(ostream&out, unsigned indent) const
 888 {
 889       out << setw(indent) << "" << "generate(" << id_number << ")";
 890
 891       switch (scheme_type) {
 892           case GS_NONE:
 893             break;
 894           case GS_LOOP:
 895             out << " for ("
 896                 << loop_index
 897                 << "=" << *loop_init
 898                 << "; " << *loop_test
 899                 << "; " << loop_index
 900                 << "=" << *loop_step << ")";
 901             break;
 902           case GS_CONDIT:
 903             out << " if (" << *loop_test << ")";
 904             break;
 905           case GS_ELSE:
 906             out << " else !(" << *loop_test << ")";
 907             break;
 908           case GS_CASE:
 909             out << " case (" << *loop_test << ")";
 910             break;
 911           case GS_CASE_ITEM:
 912             if (loop_test)
 913                   out << " (" << *loop_test << ") == (" << *parent->loop_test << ")";
 914             else
 915                   out << " default:";
 916             break;
 917       }
 918
 919       if (scope_name)
 920             out << " : " << scope_name;
 921
 922       out << endl;
 923
 924       for (map<perm_string,PWire*>::const_iterator idx = wires.begin()
 925                  ; idx != wires.end() ;  idx++) {
 926
 927             (*idx).second->dump(out, indent+2);
 928       }
 929
 930       for (list<PGate*>::const_iterator idx = gates.begin()
 931                  ; idx != gates.end() ;  idx++) {
 932             (*idx)->dump(out, indent+2);
 933       }
 934
 935       for (list<PProcess*>::const_iterator idx = behaviors.begin()
 936                  ; idx != behaviors.end() ;  idx++) {
 937             (*idx)->dump(out, indent+2);
 938       }
 939
 940       for (list<PGenerate*>::const_iterator idx = generates.begin()
 941                  ; idx != generates.end() ;  idx++) {
 942             (*idx)->dump(out, indent+2);
 943       }
 944
 945       out << setw(indent) << "" << "endgenerate" << endl;
 946 }
 947
 948 void PScope::dump_wires_(ostream&out, unsigned indent) const
 949 {
 950         // Iterate through and display all the wires.
 951       for (map<perm_string,PWire*>::const_iterator wire = wires.begin()
 952                  ; wire != wires.end() ; wire ++ ) {
 953
 954             (*wire).second->dump(out, indent);
 955       }
 956 }
 957
 958 void Module::dump(ostream&out) const
 959 {
 960       if (attributes.begin() != attributes.end()) {
 961             out << "(* ";
 962             for (map<perm_string,PExpr*>::const_iterator idx = attributes.begin()
 963                  ; idx != attributes.end() ; idx++ ) {
 964                     if (idx != attributes.begin()) {
 965                         out << " , ";
 966                     }
 967                     out << (*idx).first;
 968                     if ((*idx).second) {
 969                         out << " = " << *(*idx).second;
 970                     }
 971             }
 972             out << " *)  ";
 973       }
 974
 975       out << "module " << mod_name() << ";" << endl;
 976
 977       for (unsigned idx = 0 ;  idx < ports.count() ;  idx += 1) {
 978             port_t*cur = ports[idx];
 979
 980             if (cur == 0) {
 981                   out << "    unconnected" << endl;
 982                   continue;
 983             }
 984
 985             out << "    ." << cur->name << "(" << *cur->expr[0];
 986             for (unsigned wdx = 1 ;  wdx < cur->expr.count() ;  wdx += 1) {
 987                   out << ", " << *cur->expr[wdx];
 988             }
 989
 990             out << ")" << endl;
 991       }
 992
 993       typedef map<perm_string,param_expr_t>::const_iterator parm_iter_t;
 994       typedef map<pform_name_t,PExpr*>::const_iterator parm_hiter_t;
 995       for (parm_iter_t cur = parameters.begin()
 996                  ; cur != parameters.end() ; cur ++) {
 997             out << "    parameter " << (*cur).second.type << " ";
 998             if ((*cur).second.signed_flag)
 999                   out << "signed ";
1000             if ((*cur).second.msb)
1001                   out << "[" << *(*cur).second.msb << ":"
1002                       << *(*cur).second.lsb << "] ";
1003             out << (*cur).first << " = ";
1004             if ((*cur).second.expr)
1005                   out << *(*cur).second.expr;
1006             else
1007                   out << "/* ERROR */";
1008             for (Module::range_t*tmp = (*cur).second.range
1009                        ; tmp ; tmp = tmp->next) {
1010                   if (tmp->exclude_flag)
1011                         out << " exclude ";
1012                   else
1013                         out << " from ";
1014                   if (tmp->low_open_flag)
1015                         out << "(";
1016                   else
1017                         out << "[";
1018                   if (tmp->low_expr)
1019                         out << *(tmp->low_expr);
1020                   else if (tmp->low_open_flag==false)
1021                         out << "-inf";
1022                   else
1023                         out << "<nil>";
1024                   out << ":";
1025                   if (tmp->high_expr)
1026                         out << *(tmp->high_expr);
1027                   else if (tmp->high_open_flag==false)
1028                         out << "inf";
1029                   else
1030                         out << "<nil>";
1031                   if (tmp->high_open_flag)
1032                         out << ")";
1033                   else
1034                         out << "]";
1035             }
1036             out << ";" << endl;
1037       }
1038
1039       for (parm_iter_t cur = localparams.begin()
1040                  ; cur != localparams.end() ; cur ++) {
1041             out << "    localparam ";
1042             if ((*cur).second.msb)
1043                   out << "[" << *(*cur).second.msb << ":"
1044                       << *(*cur).second.lsb << "] ";
1045             out << (*cur).first << " = ";
1046             if ((*cur).second.expr)
1047                   out << *(*cur).second.expr << ";" << endl;
1048             else
1049                   out << "/* ERROR */;" << endl;
1050       }
1051
1052       typedef map<perm_string,LineInfo*>::const_iterator genvar_iter_t;
1053       for (genvar_iter_t cur = genvars.begin()
1054                  ; cur != genvars.end() ; cur++) {
1055             out << "    genvar " << ((*cur).first) << ";" << endl;
1056       }
1057
1058       typedef list<PGenerate*>::const_iterator genscheme_iter_t;
1059       for (genscheme_iter_t cur = generate_schemes.begin()
1060                  ; cur != generate_schemes.end() ; cur++) {
1061             (*cur)->dump(out, 4);
1062       }
1063
1064       typedef map<perm_string,PExpr*>::const_iterator specparm_iter_t;
1065       for (specparm_iter_t cur = specparams.begin()
1066                  ; cur != specparams.end() ; cur ++) {
1067             out << "    specparam " << (*cur).first << " = "
1068                 << *(*cur).second << ";" << endl;
1069       }
1070
1071       for (parm_hiter_t cur = defparms.begin()
1072                  ; cur != defparms.end() ;  cur ++) {
1073             out << "    defparam " << (*cur).first << " = ";
1074             if ((*cur).second)
1075                   out << *(*cur).second << ";" << endl;
1076             else
1077                   out << "/* ERROR */;" << endl;
1078       }
1079
1080       for (map<perm_string,PEvent*>::const_iterator cur = events.begin()
1081                  ; cur != events.end() ;  cur ++ ) {
1082             PEvent*ev = (*cur).second;
1083             out << "    event " << ev->name() << "; // "
1084                 << ev->get_fileline() << endl;
1085       }
1086
1087         // Iterate through and display all the wires.
1088       dump_wires_(out, 4);
1089
1090         // Dump the task definitions.
1091       typedef map<perm_string,PTask*>::const_iterator task_iter_t;
1092       for (task_iter_t cur = tasks_.begin()
1093                  ; cur != tasks_.end() ; cur ++) {
1094             out << "    task " << (*cur).first << ";" << endl;
1095             (*cur).second->dump(out, 6);
1096             out << "    endtask;" << endl;
1097       }
1098
1099         // Dump the function definitions.
1100       typedef map<perm_string,PFunction*>::const_iterator func_iter_t;
1101       for (func_iter_t cur = funcs_.begin()
1102                  ; cur != funcs_.end() ; cur ++) {
1103             out << "    function " << (*cur).first << ";" << endl;
1104             (*cur).second->dump(out, 6);
1105             out << "    endfunction;" << endl;
1106       }
1107
1108
1109         // Iterate through and display all the gates
1110       for (list<PGate*>::const_iterator gate = gates_.begin()
1111                  ; gate != gates_.end()
1112                  ; gate ++ ) {
1113
1114             (*gate)->dump(out);
1115       }
1116
1117
1118       for (list<PProcess*>::const_iterator behav = behaviors.begin()
1119                  ; behav != behaviors.end()
1120                  ; behav ++ ) {
1121
1122             (*behav)->dump(out, 4);
1123       }
1124
1125       for (list<PSpecPath*>::const_iterator spec = specify_paths.begin()
1126                  ; spec != specify_paths.end()
1127                  ; spec ++ ) {
1128
1129             (*spec)->dump(out, 4);
1130       }
1131
1132       out << "endmodule" << endl;
1133 }
1134
1135 void pform_dump(ostream&out, Module*mod)
1136 {
1137       mod->dump(out);
1138 }
1139
1140 void PUdp::dump(ostream&out) const
1141 {
1142       out << "primitive " << name_ << "(" << ports[0];
1143       for (unsigned idx = 1 ;  idx < ports.count() ;  idx += 1)
1144             out << ", " << ports[idx];
1145       out << ");" << endl;
1146
1147       if (sequential)
1148             out << "    reg " << ports[0] << ";" << endl;
1149
1150       out << "    table" << endl;
1151       for (unsigned idx = 0 ;  idx < tinput.count() ;  idx += 1) {
1152             out << "     ";
1153             for (unsigned chr = 0 ;  chr < tinput[idx].length() ;  chr += 1)
1154                   out << " " << tinput[idx][chr];
1155
1156             if (sequential)
1157                   out << " : " << tcurrent[idx];
1158
1159             out << " : " << toutput[idx] << " ;" << endl;
1160       }
1161       out << "    endtable" << endl;
1162
1163       if (sequential)
1164             out << "    initial " << ports[0] << " = 1'b" << initial
1165                 << ";" << endl;
1166
1167         // Dump the attributes for the primitive as attribute
1168         // statements.
1169       for (map<string,PExpr*>::const_iterator idx = attributes.begin()
1170                  ; idx != attributes.end()
1171                  ; idx ++) {
1172             out << "    attribute " << (*idx).first;
1173             if ((*idx).second)
1174                   out << " = " << *(*idx).second;
1175             out << endl;
1176       }
1177
1178       out << "endprimitive" << endl;
1179 }
1180
1181 void pform_dump(std::ostream&out, const nature_t*nat)
1182 {
1183       out << "nature " << nat->name() << endl;
1184       out << "    access " << nat->access() << ";" << endl;
1185       out << "endnature" << endl;
1186 }
1187
1188 void pform_dump(std::ostream&out, const discipline_t*dis)
1189 {
1190       out << "discipline " << dis->name() << endl;
1191       out << "    domain " << dis->domain() << ";" << endl;
1192       if (const nature_t*tmp = dis->potential())
1193             out << "    potential " << tmp->name() << ";" << endl;
1194       if (const nature_t*tmp = dis->flow())
1195             out << "    flow " << tmp->name() << ";" << endl;
1196       out << "enddiscipline" << endl;
1197 }