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

Cleanup cppcheck warnings in vvp

This commit is contained in:
Cary R 2021-01-01 00:19:27 -08:00
parent 053777f16d
commit 66c5d8cc20
10 changed files with 61 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
vvp/delay.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2005-2016 Stephen Williams <steve@icarus.com> * Copyright (c) 2005-2020 Stephen Williams <steve@icarus.com>
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -166,13 +166,13 @@ vvp_fun_delay::vvp_fun_delay(vvp_net_t*n, unsigned width, const vvp_delay_t&d)
// to simulation time units. // to simulation time units.
__vpiScope*scope = vpip_peek_current_scope(); __vpiScope*scope = vpip_peek_current_scope();
int pow = scope->time_units - scope->time_precision; int powr = scope->time_units - scope->time_precision;
round_ = 1; round_ = 1;
for (int lp = 0; lp < pow; lp += 1) round_ *= 10; for (int lp = 0; lp < powr; lp += 1) round_ *= 10;
pow = scope->time_precision - vpip_get_time_precision(); powr = scope->time_precision - vpip_get_time_precision();
scale_ = 1; scale_ = 1;
for (int lp = 0; lp < pow; lp += 1) scale_ *= 10; for (int lp = 0; lp < powr; lp += 1) scale_ *= 10;
} }
vvp_fun_delay::~vvp_fun_delay() vvp_fun_delay::~vvp_fun_delay()

10
vvp/event.cc
View File

@ -987,20 +987,20 @@ void compile_event(char*label, char*type, unsigned argc, struct symb_s*argv)
} else { } else {
vvp_fun_edge::edge_t edge = vvp_edge_none; vvp_fun_edge::edge_t edge_type = vvp_edge_none;
if (strcmp(type,"posedge") == 0) if (strcmp(type,"posedge") == 0)
edge = vvp_edge_posedge; edge_type = vvp_edge_posedge;
else if (strcmp(type,"negedge") == 0) else if (strcmp(type,"negedge") == 0)
edge = vvp_edge_negedge; edge_type = vvp_edge_negedge;
assert(argc <= 4); assert(argc <= 4);
free(type); free(type);
if (vpip_peek_current_scope()->is_automatic()) { if (vpip_peek_current_scope()->is_automatic()) {
fun = new vvp_fun_edge_aa(edge); fun = new vvp_fun_edge_aa(edge_type);
} else { } else {
fun = new vvp_fun_edge_sa(edge); fun = new vvp_fun_edge_sa(edge_type);
} }
} }

2
vvp/logic.cc
View File

@ -461,7 +461,7 @@ void vvp_fun_muxz::run_run()
default: default:
{ {
unsigned min_size = a_.size(); unsigned min_size = a_.size();
unsigned max_size = a_.size(); unsigned max_size = min_size;
if (b_.size() < min_size) if (b_.size() < min_size)
min_size = b_.size(); min_size = b_.size();
if (b_.size() > max_size) if (b_.size() > max_size)

8
vvp/schedule.cc
View File

@ -894,7 +894,7 @@ void schedule_propagate_vector(vvp_net_t*net,
void schedule_assign_array_word(vvp_array_t mem, void schedule_assign_array_word(vvp_array_t mem,
unsigned word_addr, unsigned word_addr,
unsigned off, unsigned off,
vvp_vector4_t val, const vvp_vector4_t&val,
vvp_time64_t delay) vvp_time64_t delay)
{ {
struct assign_array_word_s*cur = new struct assign_array_word_s; struct assign_array_word_s*cur = new struct assign_array_word_s;
@ -926,7 +926,7 @@ void schedule_set_vector(vvp_net_ptr_t ptr, const vvp_vector4_t&bit)
schedule_event_(cur, 0, SEQ_ACTIVE); schedule_event_(cur, 0, SEQ_ACTIVE);
} }
void schedule_set_vector(vvp_net_ptr_t ptr, vvp_vector8_t bit) void schedule_set_vector(vvp_net_ptr_t ptr, const vvp_vector8_t&bit)
{ {
struct assign_vector8_event_s*cur = new struct assign_vector8_event_s; struct assign_vector8_event_s*cur = new struct assign_vector8_event_s;
cur->ptr = ptr; cur->ptr = ptr;
@ -942,7 +942,7 @@ void schedule_set_vector(vvp_net_ptr_t ptr, double bit)
schedule_event_(cur, 0, SEQ_ACTIVE); schedule_event_(cur, 0, SEQ_ACTIVE);
} }
void schedule_init_vector(vvp_net_ptr_t ptr, vvp_vector4_t bit) void schedule_init_vector(vvp_net_ptr_t ptr, const vvp_vector4_t&bit)
{ {
struct assign_vector4_event_s*cur = new struct assign_vector4_event_s(bit); struct assign_vector4_event_s*cur = new struct assign_vector4_event_s(bit);
cur->ptr = ptr; cur->ptr = ptr;
@ -951,7 +951,7 @@ void schedule_init_vector(vvp_net_ptr_t ptr, vvp_vector4_t bit)
schedule_init_event(cur); schedule_init_event(cur);
} }
void schedule_init_vector(vvp_net_ptr_t ptr, vvp_vector8_t bit) void schedule_init_vector(vvp_net_ptr_t ptr, const vvp_vector8_t&bit)
{ {
struct assign_vector8_event_s*cur = new struct assign_vector8_event_s; struct assign_vector8_event_s*cur = new struct assign_vector8_event_s;
cur->ptr = ptr; cur->ptr = ptr;

10
vvp/schedule.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_schedule_H #ifndef IVL_schedule_H
#define IVL_schedule_H #define IVL_schedule_H
/* /*
* Copyright (c) 2001-2017 Stephen Williams (steve@icarus.com) * Copyright (c) 2001-2020 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -55,7 +55,7 @@ extern void schedule_assign_vector(vvp_net_ptr_t ptr,
extern void schedule_assign_array_word(vvp_array_t mem, extern void schedule_assign_array_word(vvp_array_t mem,
unsigned word_address, unsigned word_address,
unsigned off, unsigned off,
vvp_vector4_t val, const vvp_vector4_t&val,
vvp_time64_t delay); vvp_time64_t delay);
extern void schedule_assign_array_word(vvp_array_t mem, extern void schedule_assign_array_word(vvp_array_t mem,
@ -85,7 +85,7 @@ extern void schedule_propagate_vector(vvp_net_t*ptr,
* creates an event in the active queue. * creates an event in the active queue.
*/ */
extern void schedule_set_vector(vvp_net_ptr_t ptr, const vvp_vector4_t&val); extern void schedule_set_vector(vvp_net_ptr_t ptr, const vvp_vector4_t&val);
extern void schedule_set_vector(vvp_net_ptr_t ptr, vvp_vector8_t val); extern void schedule_set_vector(vvp_net_ptr_t ptr, const vvp_vector8_t&val);
extern void schedule_set_vector(vvp_net_ptr_t ptr, double val); extern void schedule_set_vector(vvp_net_ptr_t ptr, double val);
/* /*
@ -104,8 +104,8 @@ extern void schedule_t0_trigger(vvp_net_ptr_t ptr);
* variable, but still allows the initial value to be driven * variable, but still allows the initial value to be driven
* (propagated as events) through the rest of the net. * (propagated as events) through the rest of the net.
*/ */
extern void schedule_init_vector(vvp_net_ptr_t ptr, vvp_vector4_t val); extern void schedule_init_vector(vvp_net_ptr_t ptr, const vvp_vector4_t&val);
extern void schedule_init_vector(vvp_net_ptr_t ptr, vvp_vector8_t val); extern void schedule_init_vector(vvp_net_ptr_t ptr, const vvp_vector8_t&val);
extern void schedule_init_vector(vvp_net_ptr_t ptr, double val); extern void schedule_init_vector(vvp_net_ptr_t ptr, double val);
/* /*
* The schedule_init_propagate function is similar to the above but * The schedule_init_propagate function is similar to the above but

34
vvp/vthread.cc
View File

@ -483,7 +483,7 @@ inline static string get_queue_type(string&)
return "queue<string>"; return "queue<string>";
} }
inline static string get_queue_type(vvp_vector4_t value) inline static string get_queue_type(const vvp_vector4_t&value)
{ {
ostringstream buf; ostringstream buf;
buf << "queue<vector[" << value.size() << "]>"; buf << "queue<vector[" << value.size() << "]>";
@ -496,12 +496,12 @@ inline static void print_queue_value(double value)
cerr << value; cerr << value;
} }
inline static void print_queue_value(string value) inline static void print_queue_value(const string&value)
{ {
cerr << "\"" << value << "\""; cerr << "\"" << value << "\"";
} }
inline static void print_queue_value(vvp_vector4_t value) inline static void print_queue_value(const vvp_vector4_t&value)
{ {
cerr << value; cerr << value;
} }
@ -1077,7 +1077,7 @@ bool of_ASSIGN_VEC4(vthread_t thr, vvp_code_t cp)
{ {
vvp_net_ptr_t ptr (cp->net, 0); vvp_net_ptr_t ptr (cp->net, 0);
unsigned delay = cp->bit_idx[0]; unsigned delay = cp->bit_idx[0];
vvp_vector4_t&val = thr->peek_vec4(); const vvp_vector4_t&val = thr->peek_vec4();
schedule_assign_vector(ptr, 0, 0, val, delay); schedule_assign_vector(ptr, 0, 0, val, delay);
thr->pop_vec4(1); thr->pop_vec4(1);
@ -1121,7 +1121,6 @@ bool of_ASSIGN_VEC4_A_D(vthread_t thr, vvp_code_t cp)
} }
if (off+wid > array_wid) { if (off+wid > array_wid) {
val = val.subvalue(0, array_wid-off); val = val.subvalue(0, array_wid-off);
wid = val.size();
} }
schedule_assign_array_word(cp->array, adr, off, val, del); schedule_assign_array_word(cp->array, adr, off, val, del);
@ -1164,7 +1163,6 @@ bool of_ASSIGN_VEC4_A_E(vthread_t thr, vvp_code_t cp)
} }
if (off+wid > array_wid) { if (off+wid > array_wid) {
val = val.subvalue(0, array_wid-off); val = val.subvalue(0, array_wid-off);
wid = val.size();
} }
if (thr->ecount == 0) { if (thr->ecount == 0) {
@ -1213,7 +1211,6 @@ bool of_ASSIGN_VEC4_OFF_D(vthread_t thr, vvp_code_t cp)
} }
if (off+wid > sig->value_size()) { if (off+wid > sig->value_size()) {
val = val.subvalue(0, sig->value_size()-off); val = val.subvalue(0, sig->value_size()-off);
wid = val.size();
} }
schedule_assign_vector(ptr, off, sig->value_size(), val, del); schedule_assign_vector(ptr, off, sig->value_size(), val, del);
@ -1255,7 +1252,6 @@ bool of_ASSIGN_VEC4_OFF_E(vthread_t thr, vvp_code_t cp)
} }
if (off+wid > sig->value_size()) { if (off+wid > sig->value_size()) {
val = val.subvalue(0, sig->value_size()-off); val = val.subvalue(0, sig->value_size()-off);
wid = val.size();
} }
if (thr->ecount == 0) { if (thr->ecount == 0) {
@ -1809,7 +1805,7 @@ bool of_CMPIE(vthread_t thr, vvp_code_t cp)
{ {
unsigned wid = cp->number; unsigned wid = cp->number;
vvp_vector4_t&lval = thr->peek_vec4(); const vvp_vector4_t&lval = thr->peek_vec4();
// I expect that most of the bits of an immediate value are // I expect that most of the bits of an immediate value are
// going to be zero, so start the result vector with all zero // going to be zero, so start the result vector with all zero
@ -1827,7 +1823,7 @@ bool of_CMPINE(vthread_t thr, vvp_code_t cp)
{ {
unsigned wid = cp->number; unsigned wid = cp->number;
vvp_vector4_t&lval = thr->peek_vec4(); const vvp_vector4_t&lval = thr->peek_vec4();
// I expect that most of the bits of an immediate value are // I expect that most of the bits of an immediate value are
// going to be zero, so start the result vector with all zero // going to be zero, so start the result vector with all zero
@ -1944,7 +1940,7 @@ bool of_CMPIS(vthread_t thr, vvp_code_t cp)
{ {
unsigned wid = cp->number; unsigned wid = cp->number;
vvp_vector4_t&lval = thr->peek_vec4(); const vvp_vector4_t&lval = thr->peek_vec4();
// I expect that most of the bits of an immediate value are // I expect that most of the bits of an immediate value are
// going to be zero, so start the result vector with all zero // going to be zero, so start the result vector with all zero
@ -2080,7 +2076,7 @@ bool of_CMPIU(vthread_t thr, vvp_code_t cp)
{ {
unsigned wid = cp->number; unsigned wid = cp->number;
vvp_vector4_t&lval = thr->peek_vec4(); const vvp_vector4_t&lval = thr->peek_vec4();
// I expect that most of the bits of an immediate value are // I expect that most of the bits of an immediate value are
// going to be zero, so start the result vector with all zero // going to be zero, so start the result vector with all zero
@ -5813,7 +5809,7 @@ inline static string get_darray_type(string&)
return "darray<string>"; return "darray<string>";
} }
inline static string get_darray_type(vvp_vector4_t value) inline static string get_darray_type(const vvp_vector4_t&value)
{ {
ostringstream buf; ostringstream buf;
buf << "darray<vector[" << value.size() << "]>"; buf << "darray<vector[" << value.size() << "]>";
@ -5975,17 +5971,17 @@ static void pop_prop_val(vthread_t thr, vvp_vector4_t&val, unsigned wid)
val.resize(wid); val.resize(wid);
} }
static void set_val(vvp_cobject*cobj, size_t pid, double&val) static void set_val(vvp_cobject*cobj, size_t pid, const double&val)
{ {
cobj->set_real(pid, val); cobj->set_real(pid, val);
} }
static void set_val(vvp_cobject*cobj, size_t pid, string&val) static void set_val(vvp_cobject*cobj, size_t pid, const string&val)
{ {
cobj->set_string(pid, val); cobj->set_string(pid, val);
} }
static void set_val(vvp_cobject*cobj, size_t pid, vvp_vector4_t&val) static void set_val(vvp_cobject*cobj, size_t pid, const vvp_vector4_t&val)
{ {
cobj->set_vec4(pid, val); cobj->set_vec4(pid, val);
} }
@ -6202,12 +6198,12 @@ bool of_STORE_QOBJ_V(vthread_t thr, vvp_code_t cp)
return store_qobj<vvp_vector4_t, vvp_queue_vec4>(thr, cp, cp->bit_idx[1]); return store_qobj<vvp_vector4_t, vvp_queue_vec4>(thr, cp, cp->bit_idx[1]);
} }
static void vvp_send(vthread_t thr, vvp_net_ptr_t ptr, double&val) static void vvp_send(vthread_t thr, vvp_net_ptr_t ptr, const double&val)
{ {
vvp_send_real(ptr, val, thr->wt_context); vvp_send_real(ptr, val, thr->wt_context);
} }
static void vvp_send(vthread_t thr, vvp_net_ptr_t ptr, string&val) static void vvp_send(vthread_t thr, vvp_net_ptr_t ptr, const string&val)
{ {
vvp_send_string(ptr, val, thr->wt_context); vvp_send_string(ptr, val, thr->wt_context);
} }
@ -6358,7 +6354,7 @@ bool of_STORE_VEC4A(vthread_t thr, vvp_code_t cp)
unsigned adr_index = cp->bit_idx[0]; unsigned adr_index = cp->bit_idx[0];
unsigned off_index = cp->bit_idx[1]; unsigned off_index = cp->bit_idx[1];
vvp_vector4_t&value = thr->peek_vec4(); const vvp_vector4_t&value = thr->peek_vec4();
long adr = adr_index? thr->words[adr_index].w_int : 0; long adr = adr_index? thr->words[adr_index].w_int : 0;
long off = off_index? thr->words[off_index].w_int : 0; long off = off_index? thr->words[off_index].w_int : 0;

2
vvp/vvp_darray.cc
View File

@ -516,7 +516,7 @@ vvp_queue_real::~vvp_queue_real()
/* /*
* Helper functions used while copying multiple elements into a queue. * Helper functions used while copying multiple elements into a queue.
*/ */
static void print_copy_is_too_big(size_t src_size, unsigned max_size, string qtype) static void print_copy_is_too_big(size_t src_size, unsigned max_size, const string&qtype)
{ {
cerr << get_fileline() cerr << get_fileline()
<< "Warning: queue<" << qtype << "> is bounded to have at most " << "Warning: queue<" << qtype << "> is bounded to have at most "

6
vvp/vvp_island.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2008-2015 Stephen Williams (steve@icarus.com) * Copyright (c) 2008-2020 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -62,9 +62,9 @@ vvp_island::~vvp_island()
if (!at_EOS) assert(0); if (!at_EOS) assert(0);
while (branches_) { while (branches_) {
vvp_island_branch *next = branches_->next_branch; vvp_island_branch *next_br = branches_->next_branch;
delete branches_; delete branches_;
branches_ = next; branches_ = next_br;
} }
} }

20
vvp/vvp_net.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2004-2018 Stephen Williams (steve@icarus.com) * Copyright (c) 2004-2020 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -561,36 +561,36 @@ unsigned long multiply_with_carry(unsigned long a, unsigned long b,
void vvp_send_vec8(vvp_net_ptr_t ptr, const vvp_vector8_t&val) void vvp_send_vec8(vvp_net_ptr_t ptr, const vvp_vector8_t&val)
{ {
while (vvp_net_t*cur = ptr.ptr()) { while (vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_vec8(ptr, val); cur->fun->recv_vec8(ptr, val);
ptr = next; ptr = next_val;
} }
} }
void vvp_send_real(vvp_net_ptr_t ptr, double val, vvp_context_t context) void vvp_send_real(vvp_net_ptr_t ptr, double val, vvp_context_t context)
{ {
while (vvp_net_t*cur = ptr.ptr()) { while (vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_real(ptr, val, context); cur->fun->recv_real(ptr, val, context);
ptr = next; ptr = next_val;
} }
} }
void vvp_send_long(vvp_net_ptr_t ptr, long val) void vvp_send_long(vvp_net_ptr_t ptr, long val)
{ {
while (vvp_net_t*cur = ptr.ptr()) { while (vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_long(ptr, val); cur->fun->recv_long(ptr, val);
ptr = next; ptr = next_val;
} }
} }
@ -598,12 +598,12 @@ void vvp_send_long_pv(vvp_net_ptr_t ptr, long val,
unsigned base, unsigned wid) unsigned base, unsigned wid)
{ {
while (vvp_net_t*cur = ptr.ptr()) { while (vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_long_pv(ptr, val, base, wid); cur->fun->recv_long_pv(ptr, val, base, wid);
ptr = next; ptr = next_val;
} }
} }
@ -3441,7 +3441,7 @@ void vvp_wide_fun_core::recv_real_from_inputs(unsigned)
} }
void vvp_wide_fun_core::dispatch_vec4_from_input_(unsigned port, void vvp_wide_fun_core::dispatch_vec4_from_input_(unsigned port,
vvp_vector4_t bit) const vvp_vector4_t&bit)
{ {
assert(port < nports_); assert(port < nports_);
if (port_values_ == 0) port_values_ = new vvp_vector4_t [nports_]; if (port_values_ == 0) port_values_ = new vvp_vector4_t [nports_];

24
vvp/vvp_net.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_vvp_net_H #ifndef IVL_vvp_net_H
#define IVL_vvp_net_H #define IVL_vvp_net_H
/* /*
* Copyright (c) 2004-2018 Stephen Williams (steve@icarus.com) * Copyright (c) 2004-2020 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -1564,7 +1564,7 @@ class vvp_wide_fun_core : public vvp_net_fun_t {
virtual void recv_real_from_inputs(unsigned port); virtual void recv_real_from_inputs(unsigned port);
friend class vvp_wide_fun_t; friend class vvp_wide_fun_t;
void dispatch_vec4_from_input_(unsigned port, vvp_vector4_t bit); void dispatch_vec4_from_input_(unsigned port, const vvp_vector4_t&bit);
void dispatch_real_from_input_(unsigned port, double bit); void dispatch_real_from_input_(unsigned port, double bit);
private: private:
@ -1606,12 +1606,12 @@ class vvp_wide_fun_t : public vvp_net_fun_t {
inline void vvp_send_vec4(vvp_net_ptr_t ptr, const vvp_vector4_t&val, vvp_context_t context) inline void vvp_send_vec4(vvp_net_ptr_t ptr, const vvp_vector4_t&val, vvp_context_t context)
{ {
while (class vvp_net_t*cur = ptr.ptr()) { while (class vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_vec4(ptr, val, context); cur->fun->recv_vec4(ptr, val, context);
ptr = next; ptr = next_val;
} }
} }
@ -1625,24 +1625,24 @@ extern void vvp_send_long_pv(vvp_net_ptr_t ptr, long val,
inline void vvp_send_string(vvp_net_ptr_t ptr, const std::string&val, vvp_context_t context) inline void vvp_send_string(vvp_net_ptr_t ptr, const std::string&val, vvp_context_t context)
{ {
while (vvp_net_t*cur = ptr.ptr()) { while (vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_string(ptr, val, context); cur->fun->recv_string(ptr, val, context);
ptr = next; ptr = next_val;
} }
} }
inline void vvp_send_object(vvp_net_ptr_t ptr, vvp_object_t val, vvp_context_t context) inline void vvp_send_object(vvp_net_ptr_t ptr, vvp_object_t val, vvp_context_t context)
{ {
while (vvp_net_t*cur = ptr.ptr()) { while (vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_object(ptr, val, context); cur->fun->recv_object(ptr, val, context);
ptr = next; ptr = next_val;
} }
} }
@ -1670,12 +1670,12 @@ inline void vvp_send_vec4_pv(vvp_net_ptr_t ptr, const vvp_vector4_t&val,
vvp_context_t context) vvp_context_t context)
{ {
while (class vvp_net_t*cur = ptr.ptr()) { while (class vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_vec4_pv(ptr, val, base, wid, vwid, context); cur->fun->recv_vec4_pv(ptr, val, base, wid, vwid, context);
ptr = next; ptr = next_val;
} }
} }
@ -1683,12 +1683,12 @@ inline void vvp_send_vec8_pv(vvp_net_ptr_t ptr, const vvp_vector8_t&val,
unsigned base, unsigned wid, unsigned vwid) unsigned base, unsigned wid, unsigned vwid)
{ {
while (class vvp_net_t*cur = ptr.ptr()) { while (class vvp_net_t*cur = ptr.ptr()) {
vvp_net_ptr_t next = cur->port[ptr.port()]; vvp_net_ptr_t next_val = cur->port[ptr.port()];
if (cur->fun) if (cur->fun)
cur->fun->recv_vec8_pv(ptr, val, base, wid, vwid); cur->fun->recv_vec8_pv(ptr, val, base, wid, vwid);
ptr = next; ptr = next_val;
} }
} }