net_assign.cc

   1 /*
   2  * Copyright (c) 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 #ifdef HAVE_CVS_IDENT
  20 #ident "$Id: net_assign.cc,v 1.22 2007/01/16 05:44:15 steve Exp $"
  21 #endif
  22
  23 # include "config.h"
  24
  25 # include  "netlist.h"
  26
  27 /*
  28  * NetAssign
  29  */
  30
  31 unsigned count_lval_width(const NetAssign_*idx)
  32 {
  33       unsigned wid = 0;
  34       while (idx) {
  35             wid += idx->lwidth();
  36             idx = idx->more;
  37       }
  38       return wid;
  39 }
  40
  41 NetAssign_::NetAssign_(NetNet*s)
  42 : sig_(s), word_(0), base_(0)
  43 {
  44       lwid_ = sig_->vector_width();
  45       sig_->incr_lref();
  46       more = 0;
  47 }
  48
  49 NetAssign_::~NetAssign_()
  50 {
  51       if (sig_) {
  52             sig_->decr_lref();
  53             if (turn_sig_to_wire_on_release_ && sig_->peek_lref() == 0)
  54                   sig_->type(NetNet::WIRE);
  55       }
  56
  57       assert( more == 0 );
  58       if (word_) delete word_;
  59 }
  60
  61 void NetAssign_::set_word(NetExpr*r)
  62 {
  63       assert(word_ == 0);
  64       word_ = r;
  65 }
  66
  67 NetExpr* NetAssign_::word()
  68 {
  69       return word_;
  70 }
  71
  72 const NetExpr* NetAssign_::word() const
  73 {
  74       return word_;
  75 }
  76
  77 const NetExpr* NetAssign_::get_base() const
  78 {
  79       return base_;
  80 }
  81
  82 unsigned NetAssign_::lwidth() const
  83 {
  84       return lwid_;
  85 }
  86
  87 perm_string NetAssign_::name() const
  88 {
  89       if (sig_) {
  90             return sig_->name();
  91       } else {
  92             return perm_string::literal("");
  93       }
  94 }
  95
  96 NetNet* NetAssign_::sig() const
  97 {
  98       return sig_;
  99 }
 100
 101 void NetAssign_::set_part(NetExpr*base, unsigned wid)
 102 {
 103       base_ = base;
 104       lwid_ = wid;
 105 }
 106
 107 /*
 108  */
 109 void NetAssign_::turn_sig_to_wire_on_release()
 110 {
 111       turn_sig_to_wire_on_release_ = true;
 112 }
 113
 114 NetAssignBase::NetAssignBase(NetAssign_*lv, NetExpr*rv)
 115 : lval_(lv), rval_(rv), delay_(0)
 116 {
 117 }
 118
 119 NetAssignBase::~NetAssignBase()
 120 {
 121       if (rval_) delete rval_;
 122       while (lval_) {
 123             NetAssign_*tmp = lval_;
 124             lval_ = tmp->more;
 125             tmp->more = 0;
 126             delete tmp;
 127       }
 128 }
 129
 130 NetExpr* NetAssignBase::rval()
 131 {
 132       return rval_;
 133 }
 134
 135 const NetExpr* NetAssignBase::rval() const
 136 {
 137       return rval_;
 138 }
 139
 140 void NetAssignBase::set_rval(NetExpr*r)
 141 {
 142       if (rval_) delete rval_;
 143       rval_ = r;
 144 }
 145
 146 NetAssign_* NetAssignBase::l_val(unsigned idx)
 147 {
 148       NetAssign_*cur = lval_;
 149       while (idx > 0) {
 150             if (cur == 0)
 151                   return cur;
 152
 153             cur = cur->more;
 154             idx -= 1;
 155       }
 156
 157       assert(idx == 0);
 158       return cur;
 159 }
 160
 161 const NetAssign_* NetAssignBase::l_val(unsigned idx) const
 162 {
 163       const NetAssign_*cur = lval_;
 164       while (idx > 0) {
 165             if (cur == 0)
 166                   return cur;
 167
 168             cur = cur->more;
 169             idx -= 1;
 170       }
 171
 172       assert(idx == 0);
 173       return cur;
 174 }
 175
 176 unsigned NetAssignBase::l_val_count() const
 177 {
 178       const NetAssign_*cur = lval_;
 179       unsigned cnt = 0;
 180       while (cur) {
 181             cnt += 1;
 182             cur = cur->more;
 183       }
 184
 185       return cnt;
 186 }
 187
 188 unsigned NetAssignBase::lwidth() const
 189 {
 190       unsigned sum = 0;
 191       for (NetAssign_*cur = lval_ ;  cur ;  cur = cur->more)
 192             sum += cur->lwidth();
 193       return sum;
 194 }
 195
 196 void NetAssignBase::set_delay(NetExpr*expr)
 197 {
 198       delay_ = expr;
 199 }
 200
 201 const NetExpr* NetAssignBase::get_delay() const
 202 {
 203       return delay_;
 204 }
 205
 206 NetAssign::NetAssign(NetAssign_*lv, NetExpr*rv)
 207 : NetAssignBase(lv, rv)
 208 {
 209 }
 210
 211 NetAssign::~NetAssign()
 212 {
 213 }
 214
 215 NetAssignNB::NetAssignNB(NetAssign_*lv, NetExpr*rv)
 216 : NetAssignBase(lv, rv)
 217 {
 218 }
 219
 220 NetAssignNB::~NetAssignNB()
 221 {
 222 }
 223
 224 NetCAssign::NetCAssign(NetAssign_*lv, NetExpr*rv)
 225 : NetAssignBase(lv, rv)
 226 {
 227 }
 228
 229 NetCAssign::~NetCAssign()
 230 {
 231 }
 232
 233 NetDeassign::NetDeassign(NetAssign_*l)
 234 : NetAssignBase(l, 0)
 235 {
 236 }
 237
 238 NetDeassign::~NetDeassign()
 239 {
 240 }
 241
 242 NetForce::NetForce(NetAssign_*lv, NetExpr*rv)
 243 : NetAssignBase(lv, rv)
 244 {
 245 }
 246
 247 NetForce::~NetForce()
 248 {
 249 }
 250
 251 NetRelease::NetRelease(NetAssign_*l)
 252 : NetAssignBase(l, 0)
 253 {
 254 }
 255
 256 NetRelease::~NetRelease()
 257 {
 258 }
 259
 260 /*
 261  * $Log: net_assign.cc,v $
 262  * Revision 1.22  2007/01/16 05:44:15  steve
 263  *  Major rework of array handling. Memories are replaced with the
 264  *  more general concept of arrays. The NetMemory and NetEMemory
 265  *  classes are removed from the ivl core program, and the IVL_LPM_RAM
 266  *  lpm type is removed from the ivl_target API.
 267  *
 268  * Revision 1.21  2006/02/02 02:43:58  steve
 269  *  Allow part selects of memory words in l-values.
 270  *
 271  * Revision 1.20  2005/07/11 16:56:50  steve
 272  *  Remove NetVariable and ivl_variable_t structures.
 273  *
 274  * Revision 1.19  2004/12/11 02:31:26  steve
 275  *  Rework of internals to carry vectors through nexus instead
 276  *  of single bits. Make the ivl, tgt-vvp and vvp initial changes
 277  *  down this path.
 278  *
 279  * Revision 1.18  2004/08/28 15:08:31  steve
 280  *  Do not change reg to wire in NetAssign_ unless synthesizing.
 281  *
 282  * Revision 1.17  2004/02/18 17:11:56  steve
 283  *  Use perm_strings for named langiage items.
 284  *
 285  * Revision 1.16  2003/01/26 21:15:58  steve
 286  *  Rework expression parsing and elaboration to
 287  *  accommodate real/realtime values and expressions.
 288  */
 289