luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Shadow reduction part 2 

Continue cleaning up shadowed variables, flagged by turning on -Wshadow.
No intended change in functionality.  Patch looks right, and is tested
to compile and run on my machine.  No regressions in test suite.
This commit is contained in:
Larry Doolittle 2008-10-13 09:51:05 -07:00 committed by Stephen Williams
parent 647b3e5bda
commit 3adcbb5611
19 changed files with 127 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
PFunction.cc
View File

@ -21,10 +21,10 @@
#include "PTask.h"
PFunction::PFunction(perm_string name, PScope*parent, bool is_auto)
PFunction::PFunction(perm_string name, PScope*parent, bool is_auto__)
: PScope(name, parent), ports_(0), statement_(0)
{
is_auto_ = is_auto;
is_auto_ = is_auto__;
return_type_.type = PTF_NONE;
}

4
PTask.cc
View File

@ -21,10 +21,10 @@
# include "PTask.h"
PTask::PTask(perm_string name, PScope*parent, bool is_auto)
PTask::PTask(perm_string name, PScope*parent, bool is_auto__)
: PScope(name, parent), ports_(0), statement_(0)
{
is_auto_ = is_auto;
is_auto_ = is_auto__;
}
PTask::~PTask()

40
Statement.cc
View File

@ -26,20 +26,20 @@ Statement::~Statement()
{
}
PAssign_::PAssign_(PExpr*lval, PExpr*ex, bool is_constant)
: event_(0), count_(0), lval_(lval), rval_(ex), is_constant_(is_constant)
PAssign_::PAssign_(PExpr*lval__, PExpr*ex, bool is_constant)
: event_(0), count_(0), lval_(lval__), rval_(ex), is_constant_(is_constant)
{
delay_ = 0;
}
PAssign_::PAssign_(PExpr*lval, PExpr*de, PExpr*ex)
: event_(0), count_(0), lval_(lval), rval_(ex), is_constant_(false)
PAssign_::PAssign_(PExpr*lval__, PExpr*de, PExpr*ex)
: event_(0), count_(0), lval_(lval__), rval_(ex), is_constant_(false)
{
delay_ = de;
}
PAssign_::PAssign_(PExpr*lval, PExpr*cnt, PEventStatement*ev, PExpr*ex)
: event_(ev), count_(cnt), lval_(lval), rval_(ex), is_constant_(false)
PAssign_::PAssign_(PExpr*lval__, PExpr*cnt, PEventStatement*ev, PExpr*ex)
: event_(ev), count_(cnt), lval_(lval__), rval_(ex), is_constant_(false)
{
delay_ = 0;
}
@ -50,23 +50,23 @@ PAssign_::~PAssign_()
delete rval_;
}
PAssign::PAssign(PExpr*lval, PExpr*ex)
: PAssign_(lval, ex, false)
PAssign::PAssign(PExpr*lval__, PExpr*ex)
: PAssign_(lval__, ex, false)
{
}
PAssign::PAssign(PExpr*lval, PExpr*d, PExpr*ex)
: PAssign_(lval, d, ex)
PAssign::PAssign(PExpr*lval__, PExpr*d, PExpr*ex)
: PAssign_(lval__, d, ex)
{
}
PAssign::PAssign(PExpr*lval, PExpr*cnt, PEventStatement*d, PExpr*ex)
: PAssign_(lval, cnt, d, ex)
PAssign::PAssign(PExpr*lval__, PExpr*cnt, PEventStatement*d, PExpr*ex)
: PAssign_(lval__, cnt, d, ex)
{
}
PAssign::PAssign(PExpr*lval, PExpr*ex, bool is_constant)
: PAssign_(lval, ex, is_constant)
PAssign::PAssign(PExpr*lval__, PExpr*ex, bool is_constant)
: PAssign_(lval__, ex, is_constant)
{
}
@ -74,18 +74,18 @@ PAssign::~PAssign()
{
}
PAssignNB::PAssignNB(PExpr*lval, PExpr*ex)
: PAssign_(lval, ex, false)
PAssignNB::PAssignNB(PExpr*lval__, PExpr*ex)
: PAssign_(lval__, ex, false)
{
}
PAssignNB::PAssignNB(PExpr*lval, PExpr*d, PExpr*ex)
: PAssign_(lval, d, ex)
PAssignNB::PAssignNB(PExpr*lval__, PExpr*d, PExpr*ex)
: PAssign_(lval__, d, ex)
{
}
PAssignNB::PAssignNB(PExpr*lval, PExpr*cnt, PEventStatement*d, PExpr*ex)
: PAssign_(lval, cnt, d, ex)
PAssignNB::PAssignNB(PExpr*lval__, PExpr*cnt, PEventStatement*d, PExpr*ex)
: PAssign_(lval__, cnt, d, ex)
{
}

10
discipline.cc
View File

@ -19,8 +19,8 @@
# include "discipline.h"
nature_t::nature_t(perm_string name, perm_string access)
: name_(name), access_(access)
nature_t::nature_t(perm_string name__, perm_string access__)
: name_(name__), access_(access__)
{
}
@ -28,9 +28,9 @@ nature_t::~nature_t()
{
}
discipline_t::discipline_t(perm_string name, ddomain_t domain,
nature_t*pot, nature_t*flow)
: name_(name), domain_(domain), potential_(pot), flow_(flow)
discipline_t::discipline_t(perm_string name__, ddomain_t domain__,
nature_t*pot, nature_t*flow__)
: name_(name__), domain_(domain__), potential_(pot), flow_(flow__)
{
}

4
elab_net.cc
View File

@ -246,9 +246,9 @@ bool PEIdent::eval_part_select_(Design*des, NetScope*scope, NetNet*sig,
lidx = sig->sb_to_idx(midx_val-wid+1);
if (midx < lidx) {
long tmp = midx;
long tmpx = midx;
midx = lidx;
lidx = tmp;
lidx = tmpx;
}
break;

6
elab_pexpr.cc
View File

@ -132,13 +132,13 @@ NetExpr*PEFNumber::elaborate_pexpr(Design*des, NetScope*scope) const
*/
NetExpr*PEIdent::elaborate_pexpr(Design*des, NetScope*scope) const
{
pform_name_t path = path_;
pform_name_t oldpath = path_;
name_component_t name_tail = path_.back();
path.pop_back();
oldpath.pop_back();
NetScope*pscope = scope;
if (path_.size() > 0) {
list<hname_t> tmp = eval_scope_path(des, scope, path);
list<hname_t> tmp = eval_scope_path(des, scope, oldpath);
pscope = des->find_scope(scope, tmp);
}

20
elab_scope.cc
View File

@ -287,8 +287,8 @@ static void elaborate_scope_funcs(Design*des, NetScope*scope,
class generate_schemes_work_item_t : public elaborator_work_item_t {
public:
generate_schemes_work_item_t(Design*des, NetScope*scope, Module*mod)
: elaborator_work_item_t(des), scope_(scope), mod_(mod)
generate_schemes_work_item_t(Design*des__, NetScope*scope, Module*mod)
: elaborator_work_item_t(des__), scope_(scope), mod_(mod)
{ }
void elaborate_runrun()
@ -766,11 +766,11 @@ void PGenerate::elaborate_subscope_(Design*des, NetScope*scope)
class delayed_elaborate_scope_mod_instances : public elaborator_work_item_t {
public:
delayed_elaborate_scope_mod_instances(Design*des,
delayed_elaborate_scope_mod_instances(Design*des__,
const PGModule*obj,
Module*mod,
NetScope*sc)
: elaborator_work_item_t(des), obj_(obj), mod_(mod), sc_(sc)
: elaborator_work_item_t(des__), obj_(obj), mod_(mod), sc_(sc)
{ }
~delayed_elaborate_scope_mod_instances() { }
@ -961,16 +961,16 @@ void PGModule::elaborate_scope_mod_instances_(Design*des, Module*mod, NetScope*s
assert(parms_ == 0);
list<perm_string>::const_iterator cur
= mod->param_names.begin();
unsigned idx = 0;
unsigned jdx = 0;
for (;;) {
if (idx >= overrides_->count())
if (jdx >= overrides_->count())
break;
if (cur == mod->param_names.end())
break;
replace[*cur] = (*overrides_)[idx];
replace[*cur] = (*overrides_)[jdx];
idx += 1;
jdx += 1;
cur ++;
}
}
@ -979,8 +979,8 @@ void PGModule::elaborate_scope_mod_instances_(Design*des, Module*mod, NetScope*s
// so the mapping into the replace list is much easier.
if (parms_) {
assert(overrides_ == 0);
for (unsigned idx = 0 ; idx < nparms_ ; idx += 1)
replace[parms_[idx].name] = parms_[idx].parm;
for (unsigned jdx = 0 ; jdx < nparms_ ; jdx += 1)
replace[parms_[jdx].name] = parms_[jdx].parm;
}

16
elaborate.cc
View File

@ -3741,10 +3741,10 @@ bool Module::elaborate(Design*des, NetScope*scope) const
NetExpr*val = elab_and_eval(des, scope, (*cur).second, -1);
NetScope::spec_val_t value;
if (NetECReal*val_c = dynamic_cast<NetECReal*> (val)) {
if (NetECReal*val_cr = dynamic_cast<NetECReal*> (val)) {
value.type = IVL_VT_REAL;
value.real_val = val_c->value().as_double();
value.real_val = val_cr->value().as_double();
if (debug_elaborate)
cerr << get_fileline() << ": debug: Elaborate "
@ -3922,8 +3922,8 @@ struct root_elem {
class elaborate_root_scope_t : public elaborator_work_item_t {
public:
elaborate_root_scope_t(Design*des, NetScope*scope, Module*rmod)
: elaborator_work_item_t(des), scope_(scope), rmod_(rmod)
elaborate_root_scope_t(Design*des__, NetScope*scope, Module*rmod)
: elaborator_work_item_t(des__), scope_(scope), rmod_(rmod)
{ }
~elaborate_root_scope_t() { }
@ -3942,8 +3942,8 @@ class elaborate_root_scope_t : public elaborator_work_item_t {
class top_defparams : public elaborator_work_item_t {
public:
top_defparams(Design*des)
: elaborator_work_item_t(des)
top_defparams(Design*des__)
: elaborator_work_item_t(des__)
{ }
~top_defparams() { }
@ -3966,8 +3966,8 @@ class top_defparams : public elaborator_work_item_t {
class later_defparams : public elaborator_work_item_t {
public:
later_defparams(Design*des)
: elaborator_work_item_t(des)
later_defparams(Design*des__)
: elaborator_work_item_t(des__)
{ }
~later_defparams() { }

56
eval_tree.cc
View File

@ -813,9 +813,9 @@ NetExpr* NetEBDiv::eval_tree(int prune_to_width)
verireal lval = lc->value();
if (NetECReal*rc = dynamic_cast<NetECReal*>(right_)) {
if (NetECReal*rcr = dynamic_cast<NetECReal*>(right_)) {
NetECReal*tmp = 0;
verireal rval = rc->value();
verireal rval = rcr->value();
switch (op_) {
case '/':
@ -1655,11 +1655,11 @@ NetEConst* NetEUReduce::eval_tree(int prune_to_width)
return new NetEConst(verinum(res, 1));
}
NetExpr* evaluate_clog2(NetExpr*&arg)
NetExpr* evaluate_clog2(NetExpr*&arg_)
{
eval_expr(arg);
NetEConst*tmpi = dynamic_cast<NetEConst *>(arg);
NetECReal*tmpr = dynamic_cast<NetECReal *>(arg);
eval_expr(arg_);
NetEConst*tmpi = dynamic_cast<NetEConst *>(arg_);
NetECReal*tmpr = dynamic_cast<NetECReal *>(arg_);
if (tmpi || tmpr) {
verinum arg;
if (tmpi) {
@ -1706,11 +1706,11 @@ NetExpr* evaluate_clog2(NetExpr*&arg)
return 0;
}
NetExpr* evaluate_math_one_arg(NetExpr*&arg, const char*name)
NetExpr* evaluate_math_one_arg(NetExpr*&arg_, const char*name)
{
eval_expr(arg);
NetEConst*tmpi = dynamic_cast<NetEConst *>(arg);
NetECReal*tmpr = dynamic_cast<NetECReal *>(arg);
eval_expr(arg_);
NetEConst*tmpi = dynamic_cast<NetEConst *>(arg_);
NetECReal*tmpr = dynamic_cast<NetECReal *>(arg_);
if (tmpi || tmpr) {
double arg;
if (tmpi) {
@ -1763,14 +1763,14 @@ NetExpr* evaluate_math_one_arg(NetExpr*&arg, const char*name)
return 0;
}
NetExpr* evaluate_math_two_args(NetExpr*&arg0, NetExpr*&arg1, const char*name)
NetExpr* evaluate_math_two_args(NetExpr*&arg0_, NetExpr*&arg1_, const char*name)
{
eval_expr(arg0);
eval_expr(arg1);
NetEConst*tmpi0 = dynamic_cast<NetEConst *>(arg0);
NetECReal*tmpr0 = dynamic_cast<NetECReal *>(arg0);
NetEConst*tmpi1 = dynamic_cast<NetEConst *>(arg1);
NetECReal*tmpr1 = dynamic_cast<NetECReal *>(arg1);
eval_expr(arg0_);
eval_expr(arg1_);
NetEConst*tmpi0 = dynamic_cast<NetEConst *>(arg0_);
NetECReal*tmpr0 = dynamic_cast<NetECReal *>(arg0_);
NetEConst*tmpi1 = dynamic_cast<NetEConst *>(arg1_);
NetECReal*tmpr1 = dynamic_cast<NetECReal *>(arg1_);
if ((tmpi0 || tmpr0) && (tmpi1 || tmpr1)) {
double arg0, arg1;
if (tmpi0) {
@ -1796,10 +1796,10 @@ NetExpr* evaluate_math_two_args(NetExpr*&arg0, NetExpr*&arg1, const char*name)
return 0;
}
NetExpr* evaluate_abs(NetExpr*&arg)
NetExpr* evaluate_abs(NetExpr*&arg_)
{
eval_expr(arg);
NetEConst*tmpi = dynamic_cast<NetEConst *>(arg);
eval_expr(arg_);
NetEConst*tmpi = dynamic_cast<NetEConst *>(arg_);
if (tmpi) {
verinum arg = tmpi->value();
if (arg.is_negative()) {
@ -1808,7 +1808,7 @@ NetExpr* evaluate_abs(NetExpr*&arg)
return new NetEConst(arg);
}
NetECReal*tmpr = dynamic_cast<NetECReal *>(arg);
NetECReal*tmpr = dynamic_cast<NetECReal *>(arg_);
if (tmpr) {
double arg = tmpr->value().as_double();
return new NetECReal(verireal(fabs(arg)));
@ -1817,14 +1817,14 @@ NetExpr* evaluate_abs(NetExpr*&arg)
return 0;
}
NetExpr* evaluate_min_max(NetExpr*&arg0, NetExpr*&arg1, const char*name)
NetExpr* evaluate_min_max(NetExpr*&arg0_, NetExpr*&arg1_, const char*name)
{
eval_expr(arg0);
eval_expr(arg1);
NetEConst*tmpi0 = dynamic_cast<NetEConst *>(arg0);
NetECReal*tmpr0 = dynamic_cast<NetECReal *>(arg0);
NetEConst*tmpi1 = dynamic_cast<NetEConst *>(arg1);
NetECReal*tmpr1 = dynamic_cast<NetECReal *>(arg1);
eval_expr(arg0_);
eval_expr(arg1_);
NetEConst*tmpi0 = dynamic_cast<NetEConst *>(arg0_);
NetECReal*tmpr0 = dynamic_cast<NetECReal *>(arg0_);
NetEConst*tmpi1 = dynamic_cast<NetEConst *>(arg1_);
NetECReal*tmpr1 = dynamic_cast<NetECReal *>(arg1_);
if (tmpi0 && tmpi1) {
verinum arg0 = tmpi0->value();
verinum arg1 = tmpi1->value();

8
expr_synth.cc
View File

@ -50,8 +50,8 @@ static bool process_binary_args(Design*des, NetScope*scope,
cases of constants, which can be converted more directly. */
if (left->expr_type() == IVL_VT_REAL) {
lsig = left->synthesize(des, scope);
} else if (NetEConst*tmp = dynamic_cast<NetEConst*> (left)) {
lsig = convert_to_real_const(des, scope, tmp);
} else if (NetEConst*tmpc = dynamic_cast<NetEConst*> (left)) {
lsig = convert_to_real_const(des, scope, tmpc);
} else {
NetNet*tmp = left->synthesize(des, scope);
lsig = cast_to_real(des, scope, tmp);
@ -59,8 +59,8 @@ static bool process_binary_args(Design*des, NetScope*scope,
if (right->expr_type() == IVL_VT_REAL) {
rsig = right->synthesize(des, scope);
} else if (NetEConst*tmp = dynamic_cast<NetEConst*> (right)) {
rsig = convert_to_real_const(des, scope, tmp);
} else if (NetEConst*tmpc = dynamic_cast<NetEConst*> (right)) {
rsig = convert_to_real_const(des, scope, tmpc);
} else {
NetNet*tmp = right->synthesize(des, scope);
rsig = cast_to_real(des, scope, tmp);

4
link_const.cc
View File

@ -81,8 +81,8 @@ bool Nexus::drivers_constant() const
/* If there is a supply net, then this nexus will have a
constant value independent of any drivers. */
if (const NetNet*sig = dynamic_cast<const NetNet*>(cur->get_obj()))
switch (sig->type()) {
if (const NetNet*s = dynamic_cast<const NetNet*>(cur->get_obj()))
switch (s->type()) {
case NetNet::SUPPLY0:
driven_ = V0;
return true;

8
net_design.cc
View File

@ -580,10 +580,10 @@ void NetScope::evaluate_parameter_real_(Design*des, param_ref_t cur)
void NetScope::evaluate_parameters(Design*des)
{
NetScope*cur = sub_;
while (cur) {
cur->evaluate_parameters(des);
cur = cur->sib_;
NetScope*curs = sub_;
while (curs) {
curs->evaluate_parameters(des);
curs = curs->sib_;
}
if (debug_scopes)

32
net_expr.cc
View File

@ -35,8 +35,8 @@ ivl_variable_type_t NetExpr::expr_type() const
* Create an add/sub node from the two operands. Make a best guess of
* the
*/
NetEBAdd::NetEBAdd(char op, NetExpr*l, NetExpr*r, bool lossless_flag)
: NetEBinary(op, l, r)
NetEBAdd::NetEBAdd(char op__, NetExpr*l, NetExpr*r, bool lossless_flag)
: NetEBinary(op__, l, r)
{
NetEConst* tmp;
@ -124,8 +124,8 @@ ivl_variable_type_t NetEBAdd::expr_type() const
* expression. Otherwise, the netlist will have to allow the
* expressions to have different widths.
*/
NetEBComp::NetEBComp(char op, NetExpr*l, NetExpr*r)
: NetEBinary(op, l, r)
NetEBComp::NetEBComp(char op__, NetExpr*l, NetExpr*r)
: NetEBinary(op__, l, r)
{
// The output of compare is always unsigned.
cast_signed_base_(false);
@ -188,8 +188,8 @@ ivl_variable_type_t NetEBComp::expr_type() const
return IVL_VT_BOOL;
}
NetEBDiv::NetEBDiv(char op, NetExpr*l, NetExpr*r)
: NetEBinary(op, l, r)
NetEBDiv::NetEBDiv(char op__, NetExpr*l, NetExpr*r)
: NetEBinary(op__, l, r)
{
unsigned w = l->expr_width();
if (r->expr_width() > w)
@ -221,8 +221,8 @@ ivl_variable_type_t NetEBDiv::expr_type() const
return IVL_VT_LOGIC;
}
NetEBMinMax::NetEBMinMax(char op, NetExpr*l, NetExpr*r)
: NetEBinary(op, l, r)
NetEBMinMax::NetEBMinMax(char op__, NetExpr*l, NetExpr*r)
: NetEBinary(op__, l, r)
{
expr_width( max(l->expr_width(), r->expr_width()) );
cast_signed(l->has_sign() || r->has_sign());
@ -242,8 +242,8 @@ ivl_variable_type_t NetEBMinMax::expr_type() const
return IVL_VT_LOGIC;
}
NetEBMult::NetEBMult(char op, NetExpr*l, NetExpr*r)
: NetEBinary(op, l, r)
NetEBMult::NetEBMult(char op__, NetExpr*l, NetExpr*r)
: NetEBinary(op__, l, r)
{
if (expr_type() == IVL_VT_REAL)
expr_width(1);
@ -282,10 +282,10 @@ ivl_variable_type_t NetEBMult::expr_type() const
return IVL_VT_LOGIC;
}
NetEBPow::NetEBPow(char op, NetExpr*l, NetExpr*r)
: NetEBinary(op, l, r)
NetEBPow::NetEBPow(char op__, NetExpr*l, NetExpr*r)
: NetEBinary(op__, l, r)
{
assert(op == 'p');
assert(op__ == 'p');
/* This is incorrect! a * (2^b - 1) is close. */
expr_width(l->expr_width()+r->expr_width());
cast_signed(l->has_sign() || r->has_sign());
@ -313,13 +313,13 @@ ivl_variable_type_t NetEBPow::expr_type() const
return IVL_VT_LOGIC;
}
NetEBShift::NetEBShift(char op, NetExpr*l, NetExpr*r)
: NetEBinary(op, l, r)
NetEBShift::NetEBShift(char op__, NetExpr*l, NetExpr*r)
: NetEBinary(op__, l, r)
{
expr_width(l->expr_width());
// The >>> is signed if the left operand is signed.
if (op == 'R') cast_signed(l->has_sign());
if (op__ == 'R') cast_signed(l->has_sign());
}
NetEBShift::~NetEBShift()

16
net_func.cc
View File

@ -49,36 +49,36 @@ NetUserFunc::~NetUserFunc()
ivl_variable_type_t NetUserFunc::data_type(unsigned port) const
{
NetFuncDef*def = def_->func_def();
NetFuncDef*fdef = def_->func_def();
/* Port 0 is the return port. */
if (port == 0) {
const NetNet*sig = def->return_sig();
const NetNet*sig = fdef->return_sig();
assert(sig);
return sig->data_type();
}
port -= 1;
assert(port < def->port_count());
const NetNet*port_sig = def->port(port);
assert(port < fdef->port_count());
const NetNet*port_sig = fdef->port(port);
return port_sig->data_type();
}
unsigned NetUserFunc::port_width(unsigned port) const
{
NetFuncDef*def = def_->func_def();
NetFuncDef*fdef = def_->func_def();
/* Port 0 is the return port. */
if (port == 0) {
const NetNet*sig = def->return_sig();
const NetNet*sig = fdef->return_sig();
assert(sig);
return sig->vector_width();
}
port -= 1;
assert(port < def->port_count());
const NetNet*port_sig = def->port(port);
assert(port < fdef->port_count());
const NetNet*port_sig = fdef->port(port);
return port_sig->vector_width();
}

4
net_link.cc
View File

@ -103,9 +103,9 @@ void Link::drivers_delays(NetExpr*rise, NetExpr*fall, NetExpr*decay)
nexus_->drivers_delays(rise, fall, decay);
}
void Link::drivers_drive(strength_t drive0, strength_t drive1)
void Link::drivers_drive(strength_t drive0__, strength_t drive1__)
{
nexus_->drivers_drive(drive0, drive1);
nexus_->drivers_drive(drive0__, drive1__);
}
void Link::drive0(Link::strength_t str)

6
net_scope.cc
View File

@ -107,7 +107,7 @@ void NetScope::set_line(perm_string file, perm_string def_file,
}
NetExpr* NetScope::set_parameter(perm_string key, NetExpr*expr,
ivl_variable_type_t type,
ivl_variable_type_t type__,
NetExpr*msb, NetExpr*lsb, bool signed_flag,
NetScope::range_t*range_list,
const LineInfo&file_line)
@ -115,7 +115,7 @@ NetExpr* NetScope::set_parameter(perm_string key, NetExpr*expr,
param_expr_t&ref = parameters[key];
NetExpr* res = ref.expr;
ref.expr = expr;
ref.type = type;
ref.type = type__;
ref.msb = msb;
ref.lsb = lsb;
ref.signed_flag = signed_flag;
@ -123,7 +123,7 @@ NetExpr* NetScope::set_parameter(perm_string key, NetExpr*expr,
ref.range = range_list;
ref.set_line(file_line);
ivl_assert(file_line, type != IVL_VT_NO_TYPE);
ivl_assert(file_line, type__ != IVL_VT_NO_TYPE);
return res;
}

8
net_tran.cc
View File

@ -42,8 +42,8 @@ static bool has_enable(ivl_switch_type_t tt)
}
}
NetTran::NetTran(NetScope*scope, perm_string n, ivl_switch_type_t tt)
: NetNode(scope, n, has_enable(tt)? 3 : 2), type_(tt)
NetTran::NetTran(NetScope*scope__, perm_string n, ivl_switch_type_t tt)
: NetNode(scope__, n, has_enable(tt)? 3 : 2), type_(tt)
{
pin(0).set_dir(Link::PASSIVE);
pin(1).set_dir(Link::PASSIVE);
@ -52,8 +52,8 @@ NetTran::NetTran(NetScope*scope, perm_string n, ivl_switch_type_t tt)
}
}
NetTran::NetTran(NetScope*scope, perm_string n, unsigned wid, unsigned part, unsigned off)
: NetNode(scope, n, 2), type_(IVL_SW_TRAN_VP), wid_(wid), part_(part), off_(off)
NetTran::NetTran(NetScope*scope__, perm_string n, unsigned wid, unsigned part, unsigned off)
: NetNode(scope__, n, 2), type_(IVL_SW_TRAN_VP), wid_(wid), part_(part), off_(off)
{
pin(0).set_dir(Link::PASSIVE);
pin(1).set_dir(Link::PASSIVE);

4
pform.cc
View File

@ -1640,8 +1640,8 @@ void pform_set_attrib(perm_string name, perm_string key, char*value)
if (PWire*cur = lexical_scope->wires_find(name)) {
cur->attributes[key] = new PEString(value);
} else if (PGate*cur = pform_cur_module->get_gate(name)) {
cur->attributes[key] = new PEString(value);
} else if (PGate*curg = pform_cur_module->get_gate(name)) {
curg->attributes[key] = new PEString(value);
} else {
free(value);

4
verinum.cc
View File

@ -47,8 +47,8 @@ verinum::verinum()
{
}
verinum::verinum(const V*bits, unsigned nbits, bool has_len)
: has_len_(has_len), has_sign_(false), string_flag_(false)
verinum::verinum(const V*bits, unsigned nbits, bool has_len__)
: has_len_(has_len__), has_sign_(false), string_flag_(false)
{
nbits_ = nbits;
bits_ = new V [nbits];