Statement.h

   1 #ifndef __Statement_H
   2 #define __Statement_H
   3 /*
   4  * Copyright (c) 1998-2000 Stephen Williams (steve@icarus.com)
   5  *
   6  *    This source code is free software; you can redistribute it
   7  *    and/or modify it in source code form under the terms of the GNU
   8  *    General Public License as published by the Free Software
   9  *    Foundation; either version 2 of the License, or (at your option)
  10  *    any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License
  18  *    along with this program; if not, write to the Free Software
  19  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  20  */
  21 #ifdef HAVE_CVS_IDENT
  22 #ident "$Id: Statement.h,v 1.44 2007/05/24 04:07:11 steve Exp $"
  23 #endif
  24
  25 # include  <string>
  26 # include  "svector.h"
  27 # include  "StringHeap.h"
  28 # include  "PDelays.h"
  29 # include  "PExpr.h"
  30 # include  "HName.h"
  31 # include  "LineInfo.h"
  32 class PExpr;
  33 class Statement;
  34 class PEventStatement;
  35 class Design;
  36 class NetAssign_;
  37 class NetCAssign;
  38 class NetDeassign;
  39 class NetForce;
  40 class NetScope;
  41
  42 /*
  43  * The PProcess is the root of a behavioral process. Each process gets
  44  * one of these, which contains its type (initial or always) and a
  45  * pointer to the single statement that is the process. A module may
  46  * have several concurrent processes.
  47  */
  48 class PProcess : public LineInfo {
  49
  50     public:
  51       enum Type { PR_INITIAL, PR_ALWAYS };
  52
  53       PProcess(Type t, Statement*st)
  54       : type_(t), statement_(st) { }
  55
  56       virtual ~PProcess();
  57
  58       bool elaborate(Design*des, NetScope*scope) const;
  59
  60       Type type() const { return type_; }
  61       Statement*statement() { return statement_; }
  62
  63       map<perm_string,PExpr*> attributes;
  64
  65       virtual void dump(ostream&out, unsigned ind) const;
  66
  67     private:
  68       Type type_;
  69       Statement*statement_;
  70 };
  71
  72 /*
  73  * The PProcess is a process, the Statement is the actual action. In
  74  * fact, the Statement class is abstract and represents all the
  75  * possible kinds of statements that exist in Verilog.
  76  */
  77 class Statement : public LineInfo {
  78
  79     public:
  80       Statement() { }
  81       virtual ~Statement() =0;
  82
  83       virtual void dump(ostream&out, unsigned ind) const;
  84       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
  85       virtual void elaborate_scope(Design*des, NetScope*scope) const;
  86 };
  87
  88 /*
  89  * Assignment statements of the various forms are handled by this
  90  * type. The rvalue is an expression. The lvalue needs to be figured
  91  * out by the parser as much as possible.
  92  */
  93 class PAssign_  : public Statement {
  94     public:
  95       explicit PAssign_(PExpr*lval, PExpr*ex);
  96       explicit PAssign_(PExpr*lval, PExpr*de, PExpr*ex);
  97       explicit PAssign_(PExpr*lval, PEventStatement*de, PExpr*ex);
  98       virtual ~PAssign_() =0;
  99
 100       const PExpr* lval() const  { return lval_; }
 101       const PExpr* rval() const  { return rval_; }
 102
 103     protected:
 104       NetAssign_* elaborate_lval(Design*, NetScope*scope) const;
 105
 106       PExpr* delay_;
 107       PEventStatement*event_;
 108
 109     private:
 110       PExpr* lval_;
 111       PExpr* rval_;
 112 };
 113
 114 class PAssign  : public PAssign_ {
 115
 116     public:
 117       explicit PAssign(PExpr*lval, PExpr*ex);
 118       explicit PAssign(PExpr*lval, PExpr*de, PExpr*ex);
 119       explicit PAssign(PExpr*lval, PEventStatement*de, PExpr*ex);
 120       ~PAssign();
 121
 122       virtual void dump(ostream&out, unsigned ind) const;
 123       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 124
 125     private:
 126 };
 127
 128 class PAssignNB  : public PAssign_ {
 129
 130     public:
 131       explicit PAssignNB(PExpr*lval, PExpr*ex);
 132       explicit PAssignNB(PExpr*lval, PExpr*de, PExpr*ex);
 133       ~PAssignNB();
 134
 135       virtual void dump(ostream&out, unsigned ind) const;
 136       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 137
 138     private:
 139       NetProc*assign_to_memory_(class NetMemory*, PExpr*,
 140                                 Design*des, NetScope*scope) const;
 141 };
 142
 143 /*
 144  * A block statement is an ordered list of statements that make up the
 145  * block. The block can be sequential or parallel, which only affects
 146  * how the block is interpreted. The parser collects the list of
 147  * statements before constructing this object, so it knows a priori
 148  * what is contained.
 149  */
 150 class PBlock  : public Statement {
 151
 152     public:
 153       enum BL_TYPE { BL_SEQ, BL_PAR };
 154
 155       explicit PBlock(perm_string n, BL_TYPE t, const svector<Statement*>&st);
 156       explicit PBlock(BL_TYPE t, const svector<Statement*>&st);
 157       explicit PBlock(BL_TYPE t);
 158       ~PBlock();
 159
 160       BL_TYPE bl_type() const { return bl_type_; }
 161
 162
 163       virtual void dump(ostream&out, unsigned ind) const;
 164       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 165       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 166
 167     private:
 168       perm_string name_;
 169       const BL_TYPE bl_type_;
 170       svector<Statement*>list_;
 171 };
 172
 173 class PCallTask  : public Statement {
 174
 175     public:
 176       explicit PCallTask(const pform_name_t&n, const svector<PExpr*>&parms);
 177       explicit PCallTask(perm_string n, const svector<PExpr*>&parms);
 178       ~PCallTask();
 179
 180       const pform_name_t& path() const;
 181
 182       unsigned nparms() const { return parms_.count(); }
 183
 184       PExpr*&parm(unsigned idx)
 185             { assert(idx < parms_.count());
 186               return parms_[idx];
 187             }
 188
 189       PExpr* parm(unsigned idx) const
 190             { assert(idx < parms_.count());
 191               return parms_[idx];
 192             }
 193
 194       virtual void dump(ostream&out, unsigned ind) const;
 195       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 196
 197     private:
 198       NetProc* elaborate_sys(Design*des, NetScope*scope) const;
 199       NetProc* elaborate_usr(Design*des, NetScope*scope) const;
 200
 201       pform_name_t path_;
 202       svector<PExpr*> parms_;
 203 };
 204
 205 class PCase  : public Statement {
 206
 207     public:
 208       struct Item {
 209             svector<PExpr*>expr;
 210             Statement*stat;
 211       };
 212
 213       PCase(NetCase::TYPE, PExpr*ex, svector<Item*>*);
 214       ~PCase();
 215
 216       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 217       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 218       virtual void dump(ostream&out, unsigned ind) const;
 219
 220     private:
 221       NetCase::TYPE type_;
 222       PExpr*expr_;
 223
 224       svector<Item*>*items_;
 225
 226     private: // not implemented
 227       PCase(const PCase&);
 228       PCase& operator= (const PCase&);
 229 };
 230
 231 class PCAssign  : public Statement {
 232
 233     public:
 234       explicit PCAssign(PExpr*l, PExpr*r);
 235       ~PCAssign();
 236
 237       virtual NetCAssign* elaborate(Design*des, NetScope*scope) const;
 238       virtual void dump(ostream&out, unsigned ind) const;
 239
 240     private:
 241       PExpr*lval_;
 242       PExpr*expr_;
 243 };
 244
 245 class PCondit  : public Statement {
 246
 247     public:
 248       PCondit(PExpr*ex, Statement*i, Statement*e);
 249       ~PCondit();
 250
 251       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 252       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 253       virtual void dump(ostream&out, unsigned ind) const;
 254
 255     private:
 256       PExpr*expr_;
 257       Statement*if_;
 258       Statement*else_;
 259
 260     private: // not implemented
 261       PCondit(const PCondit&);
 262       PCondit& operator= (const PCondit&);
 263 };
 264
 265 class PDeassign  : public Statement {
 266
 267     public:
 268       explicit PDeassign(PExpr*l);
 269       ~PDeassign();
 270
 271       virtual NetDeassign* elaborate(Design*des, NetScope*scope) const;
 272       virtual void dump(ostream&out, unsigned ind) const;
 273
 274     private:
 275       PExpr*lval_;
 276 };
 277
 278 class PDelayStatement  : public Statement {
 279
 280     public:
 281       PDelayStatement(PExpr*d, Statement*st);
 282       ~PDelayStatement();
 283
 284       virtual void dump(ostream&out, unsigned ind) const;
 285       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 286       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 287
 288     private:
 289       PExpr*delay_;
 290       Statement*statement_;
 291 };
 292
 293
 294 /*
 295  * This represents the parsing of a disable <scope> statement.
 296  */
 297 class PDisable  : public Statement {
 298
 299     public:
 300       explicit PDisable(const pform_name_t&sc);
 301       ~PDisable();
 302
 303       virtual void dump(ostream&out, unsigned ind) const;
 304       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 305
 306     private:
 307       pform_name_t scope_;
 308 };
 309
 310 /*
 311  * The event statement represents the event delay in behavioral
 312  * code. It comes from such things as:
 313  *
 314  *      @name <statement>;
 315  *      @(expr) <statement>;
 316  *      @* <statement>;
 317  */
 318 class PEventStatement  : public Statement {
 319
 320     public:
 321
 322       explicit PEventStatement(const svector<PEEvent*>&ee);
 323       explicit PEventStatement(PEEvent*ee);
 324         // Make an @* statement.
 325       explicit PEventStatement(void);
 326
 327       ~PEventStatement();
 328
 329       void set_statement(Statement*st);
 330
 331       virtual void dump(ostream&out, unsigned ind) const;
 332       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 333       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 334
 335         // This method is used to elaborate, but attach a previously
 336         // elaborated statement to the event.
 337       NetProc* elaborate_st(Design*des, NetScope*scope, NetProc*st) const;
 338
 339       NetProc* elaborate_wait(Design*des, NetScope*scope, NetProc*st) const;
 340
 341     private:
 342       svector<PEEvent*>expr_;
 343       Statement*statement_;
 344 };
 345
 346 class PForce  : public Statement {
 347
 348     public:
 349       explicit PForce(PExpr*l, PExpr*r);
 350       ~PForce();
 351
 352       virtual NetForce* elaborate(Design*des, NetScope*scope) const;
 353       virtual void dump(ostream&out, unsigned ind) const;
 354
 355     private:
 356       PExpr*lval_;
 357       PExpr*expr_;
 358 };
 359
 360 class PForever : public Statement {
 361     public:
 362       explicit PForever(Statement*s);
 363       ~PForever();
 364
 365       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 366       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 367       virtual void dump(ostream&out, unsigned ind) const;
 368
 369     private:
 370       Statement*statement_;
 371 };
 372
 373 class PForStatement  : public Statement {
 374
 375     public:
 376       PForStatement(PExpr*n1, PExpr*e1, PExpr*cond,
 377                     PExpr*n2, PExpr*e2, Statement*st);
 378       ~PForStatement();
 379
 380       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 381       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 382       virtual void dump(ostream&out, unsigned ind) const;
 383
 384     private:
 385       PExpr* name1_;
 386       PExpr* expr1_;
 387
 388       PExpr*cond_;
 389
 390       PExpr* name2_;
 391       PExpr* expr2_;
 392
 393       Statement*statement_;
 394 };
 395
 396 class PNoop  : public Statement {
 397
 398     public:
 399       PNoop() { }
 400       ~PNoop() { }
 401 };
 402
 403 class PRepeat : public Statement {
 404     public:
 405       explicit PRepeat(PExpr*expr, Statement*s);
 406       ~PRepeat();
 407
 408       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 409       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 410       virtual void dump(ostream&out, unsigned ind) const;
 411
 412     private:
 413       PExpr*expr_;
 414       Statement*statement_;
 415 };
 416
 417 class PRelease  : public Statement {
 418
 419     public:
 420       explicit PRelease(PExpr*l);
 421       ~PRelease();
 422
 423       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 424       virtual void dump(ostream&out, unsigned ind) const;
 425
 426     private:
 427       PExpr*lval_;
 428 };
 429
 430 /*
 431  * The PTrigger statement sends a trigger to a named event. Take the
 432  * name here.
 433  */
 434 class PTrigger  : public Statement {
 435
 436     public:
 437       explicit PTrigger(const pform_name_t&ev);
 438       ~PTrigger();
 439
 440       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 441       virtual void dump(ostream&out, unsigned ind) const;
 442
 443     private:
 444       pform_name_t event_;
 445 };
 446
 447 class PWhile  : public Statement {
 448
 449     public:
 450       PWhile(PExpr*e1, Statement*st);
 451       ~PWhile();
 452
 453       virtual NetProc* elaborate(Design*des, NetScope*scope) const;
 454       virtual void elaborate_scope(Design*des, NetScope*scope) const;
 455       virtual void dump(ostream&out, unsigned ind) const;
 456
 457     private:
 458       PExpr*cond_;
 459       Statement*statement_;
 460 };
 461
 462 /*
 463  * $Log: Statement.h,v $
 464  * Revision 1.44  2007/05/24 04:07:11  steve
 465  *  Rework the heirarchical identifier parse syntax and pform
 466  *  to handle more general combinations of heirarch and bit selects.
 467  *
 468  * Revision 1.43  2007/03/05 05:59:10  steve
 469  *  Handle processes within generate loops.
 470  *
 471  * Revision 1.42  2005/12/05 21:21:18  steve
 472  *  Fixes for stubborn compilers.
 473  *
 474  * Revision 1.41  2004/12/11 02:31:25  steve
 475  *  Rework of internals to carry vectors through nexus instead
 476  *  of single bits. Make the ivl, tgt-vvp and vvp initial changes
 477  *  down this path.
 478  *
 479  * Revision 1.40  2004/02/20 18:53:33  steve
 480  *  Addtrbute keys are perm_strings.
 481  *
 482  * Revision 1.39  2004/02/18 17:11:54  steve
 483  *  Use perm_strings for named langiage items.
 484  *
 485  * Revision 1.38  2003/05/19 02:50:58  steve
 486  *  Implement the wait statement behaviorally instead of as nets.
 487  *
 488  * Revision 1.37  2003/01/30 16:23:07  steve
 489  *  Spelling fixes.
 490  *
 491  * Revision 1.36  2002/08/12 01:34:58  steve
 492  *  conditional ident string using autoconfig.
 493  *
 494  * Revision 1.35  2002/06/04 05:38:44  steve
 495  *  Add support for memory words in l-value of
 496  *  blocking assignments, and remove the special
 497  *  NetAssignMem class.
 498  *
 499  * Revision 1.34  2002/05/26 01:39:02  steve
 500  *  Carry Verilog 2001 attributes with processes,
 501  *  all the way through to the ivl_target API.
 502  *
 503  *  Divide signal reference counts between rval
 504  *  and lval references.
 505  *
 506  * Revision 1.33  2002/04/21 22:31:02  steve
 507  *  Redo handling of assignment internal delays.
 508  *  Leave it possible for them to be calculated
 509  *  at run time.
 510  *
 511  * Revision 1.32  2002/04/21 04:59:07  steve
 512  *  Add support for conbinational events by finding
 513  *  the inputs to expressions and some statements.
 514  *  Get case and assignment statements working.
 515  *
 516  * Revision 1.31  2001/12/03 04:47:14  steve
 517  *  Parser and pform use hierarchical names as hname_t
 518  *  objects instead of encoded strings.
 519  *
 520  * Revision 1.30  2001/11/22 06:20:59  steve
 521  *  Use NetScope instead of string for scope path.
 522  *
 523  * Revision 1.29  2000/09/09 15:21:26  steve
 524  *  move lval elaboration to PExpr virtual methods.
 525  *
 526  * Revision 1.28  2000/09/03 17:58:35  steve
 527  *  Change elaborate_lval to return NetAssign_ objects.
 528  *
 529  * Revision 1.27  2000/07/26 05:08:07  steve
 530  *  Parse disable statements to pform.
 531  *
 532  * Revision 1.26  2000/05/11 23:37:26  steve
 533  *  Add support for procedural continuous assignment.
 534  *
 535  * Revision 1.25  2000/04/22 04:20:19  steve
 536  *  Add support for force assignment.
 537  *
 538  * Revision 1.24  2000/04/12 04:23:57  steve
 539  *  Named events really should be expressed with PEIdent
 540  *  objects in the pform,
 541  *
 542  *  Handle named events within the mix of net events
 543  *  and edges. As a unified lot they get caught together.
 544  *  wait statements are broken into more complex statements
 545  *  that include a conditional.
 546  *
 547  *  Do not generate NetPEvent or NetNEvent objects in
 548  *  elaboration. NetEvent, NetEvWait and NetEvProbe
 549  *  take over those functions in the netlist.
 550  */
 551 #endif