Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

307 lines (252 sloc) 5.338 kb
/*
* Copyright (c) 2000-2010 Stephen Williams (steve@icarus.com)
*
* This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU
* General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
# include "config.h"
# include "netlist.h"
/*
* NetAssign
*/
unsigned count_lval_width(const NetAssign_*idx)
{
unsigned wid = 0;
while (idx) {
wid += idx->lwidth();
idx = idx->more;
}
return wid;
}
NetAssign_::NetAssign_(NetNet*s)
: sig_(s), word_(0), base_(0)
{
lwid_ = sig_->vector_width();
sig_->incr_lref();
more = 0;
turn_sig_to_wire_on_release_ = false;
}
NetAssign_::~NetAssign_()
{
if (sig_) {
sig_->decr_lref();
if (turn_sig_to_wire_on_release_ && sig_->peek_lref() == 0)
sig_->type(NetNet::WIRE);
}
assert( more == 0 );
delete word_;
}
void NetAssign_::set_word(NetExpr*r)
{
assert(word_ == 0);
word_ = r;
}
NetExpr* NetAssign_::word()
{
return word_;
}
const NetExpr* NetAssign_::word() const
{
return word_;
}
const NetExpr* NetAssign_::get_base() const
{
return base_;
}
ivl_select_type_t NetAssign_::select_type() const
{
return sel_type_;
}
unsigned NetAssign_::lwidth() const
{
return lwid_;
}
ivl_variable_type_t NetAssign_::expr_type() const
{
return sig_->data_type();
}
netenum_t*NetAssign_::enumeration() const
{
netenum_t*tmp = 0;
// If the base signal is not an enumeration, return nil.
if ( (tmp = sig_->enumeration()) == 0 )
return 0;
// Part select of an enumeration is not an enumeration.
if (base_ != 0)
return 0;
// Concatenation of enumerations is not an enumeration.
if (more != 0)
return 0;
return tmp;
}
perm_string NetAssign_::name() const
{
if (sig_) {
return sig_->name();
} else {
return perm_string::literal("");
}
}
NetNet* NetAssign_::sig() const
{
return sig_;
}
void NetAssign_::set_part(NetExpr*base, unsigned wid,
ivl_select_type_t sel_type)
{
base_ = base;
lwid_ = wid;
sel_type_ = sel_type;
}
/*
*/
void NetAssign_::turn_sig_to_wire_on_release()
{
turn_sig_to_wire_on_release_ = true;
}
NetAssignBase::NetAssignBase(NetAssign_*lv, NetExpr*rv)
: lval_(lv), rval_(rv), delay_(0)
{
}
NetAssignBase::~NetAssignBase()
{
delete rval_;
while (lval_) {
NetAssign_*tmp = lval_;
lval_ = tmp->more;
tmp->more = 0;
delete tmp;
}
}
NetExpr* NetAssignBase::rval()
{
return rval_;
}
const NetExpr* NetAssignBase::rval() const
{
return rval_;
}
void NetAssignBase::set_rval(NetExpr*r)
{
delete rval_;
rval_ = r;
}
NetAssign_* NetAssignBase::l_val(unsigned idx)
{
NetAssign_*cur = lval_;
while (idx > 0) {
if (cur == 0)
return cur;
cur = cur->more;
idx -= 1;
}
assert(idx == 0);
return cur;
}
const NetAssign_* NetAssignBase::l_val(unsigned idx) const
{
const NetAssign_*cur = lval_;
while (idx > 0) {
if (cur == 0)
return cur;
cur = cur->more;
idx -= 1;
}
assert(idx == 0);
return cur;
}
unsigned NetAssignBase::l_val_count() const
{
const NetAssign_*cur = lval_;
unsigned cnt = 0;
while (cur) {
cnt += 1;
cur = cur->more;
}
return cnt;
}
unsigned NetAssignBase::lwidth() const
{
unsigned sum = 0;
for (NetAssign_*cur = lval_ ; cur ; cur = cur->more)
sum += cur->lwidth();
return sum;
}
void NetAssignBase::set_delay(NetExpr*expr)
{
delay_ = expr;
}
const NetExpr* NetAssignBase::get_delay() const
{
return delay_;
}
NetAssign::NetAssign(NetAssign_*lv, NetExpr*rv)
: NetAssignBase(lv, rv)
{
}
NetAssign::~NetAssign()
{
}
NetAssignNB::NetAssignNB(NetAssign_*lv, NetExpr*rv, NetEvWait*ev, NetExpr*cnt)
: NetAssignBase(lv, rv)
{
event_ = ev;
count_ = cnt;
}
NetAssignNB::~NetAssignNB()
{
}
unsigned NetAssignNB::nevents() const
{
if (event_) return event_->nevents();
return 0;
}
const NetEvent*NetAssignNB::event(unsigned idx) const
{
if (event_) return event_->event(idx);
return 0;
}
const NetExpr*NetAssignNB::get_count() const
{
return count_;
}
NetCAssign::NetCAssign(NetAssign_*lv, NetExpr*rv)
: NetAssignBase(lv, rv)
{
}
NetCAssign::~NetCAssign()
{
}
NetDeassign::NetDeassign(NetAssign_*l)
: NetAssignBase(l, 0)
{
}
NetDeassign::~NetDeassign()
{
}
NetForce::NetForce(NetAssign_*lv, NetExpr*rv)
: NetAssignBase(lv, rv)
{
}
NetForce::~NetForce()
{
}
NetRelease::NetRelease(NetAssign_*l)
: NetAssignBase(l, 0)
{
}
NetRelease::~NetRelease()
{
}
Jump to Line
Something went wrong with that request. Please try again.