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

Properly handle base-type logic enumerations. 

The next()/prev() methods need to know of the base type
so that the comparisons can go right.
This commit is contained in:
Stephen Williams 2010-11-21 17:24:46 -08:00
parent de215f1f8d
commit 8a91931d49
15 changed files with 327 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
ivl_target.h
View File

@ -625,10 +625,34 @@ extern const char* ivl_nature_name(ivl_nature_t net);
* Enumerations are a collections of symbolic names and vector
* values. The enumeration has a base type, and a list of names and
* values.
*
* FUNCTION SUMMARY
*
* ivl_enum_names
* This is the number of enumeration names in the enum type.
*
* ivl_enum_name
* Get the string name for an item in the enumeration
*
* ivl_enum_bits
* Get the bits (lsb first) of the enumeration value. The width
* of the enumeration should match the length of this string. Every
* name also has bits that make up the value.
*
* ivl_enum_type
* Get the data-type for the base type that the enum uses. This
* will be either IVL_VT_BOOL or IVL_VT_LOGIC
*
* ivl_enum_width
* Return the bit width of the base type for this enum type.
*
* SEMANTIC NOTES
*/
extern unsigned ivl_enum_names(ivl_enumtype_t net);
extern const char*ivl_enum_name(ivl_enumtype_t net, unsigned idx);
extern const char*ivl_enum_bits(ivl_enumtype_t net, unsigned idx);
extern ivl_variable_type_t ivl_enum_type(ivl_enumtype_t net);
extern unsigned ivl_enum_width(ivl_enumtype_t net);
/* EVENTS
*

12
t-dll-api.cc
View File

@ -231,6 +231,18 @@ extern "C" const char* ivl_enum_bits(ivl_enumtype_t net, unsigned idx)
return net->bits_at(idx);
}
extern "C" ivl_variable_type_t ivl_enum_type(ivl_enumtype_t net)
{
assert(net);
return net->base_type();
}
extern "C" unsigned ivl_enum_width(ivl_enumtype_t net)
{
assert(net);
return net->base_width();
}
extern "C" const char* ivl_event_name(ivl_event_t net)
{
static char*name_buffer = 0;

58
tgt-vvp/draw_enum.c
View File

@ -20,29 +20,61 @@
# include "vvp_priv.h"
# include "ivl_alloc.h"
# include <stdlib.h>
# include <string.h>
# include <assert.h>
static void draw_enum2_value(ivl_enumtype_t enumtype, unsigned idx)
{
long val = 0;
long mask = 1;
const char*bits = ivl_enum_bits(enumtype, idx);
const char*bit;
for (bit = bits, mask = 1 ; bit[0] != 0 ; bit += 1, mask <<= 1) {
if (*bit == '1')
val |= mask;
}
fprintf(vvp_out, "%ld", val);
}
static void draw_enum4_value(ivl_enumtype_t enumtype, unsigned idx)
{
const char*bits = ivl_enum_bits(enumtype, idx);
const char*bit;
fprintf(vvp_out, "%u'b", ivl_enum_width(enumtype));
for (bit = bits+strlen(bits) ; bit > bits ; bit -= 1)
fputc(bit[-1], vvp_out);
}
void draw_enumeration_in_scope(ivl_enumtype_t enumtype)
{
unsigned idx;
unsigned name_count = ivl_enum_names(enumtype);
const char*dtype = ivl_enum_type(enumtype)==IVL_VT_BOOL? "2" : "4";
fprintf(vvp_out, "enum%p .enum\n", enumtype);
fprintf(vvp_out, "enum%p .enum%s (%u)\n", enumtype,
dtype, ivl_enum_width(enumtype));
for (idx = 0 ; idx < ivl_enum_names(enumtype) ; idx += 1) {
const char*comma = idx+1 < ivl_enum_names(enumtype)? "," : "";
for (idx = 0 ; idx < name_count ; idx += 1) {
fprintf(vvp_out, " \"%s\" ", ivl_enum_name(enumtype, idx));
fprintf(vvp_out, " \"%s\"", ivl_enum_name(enumtype, idx));
long val = 0;
long mask = 1;
const char*bits = ivl_enum_bits(enumtype, idx);
const char*bit;
for (bit = bits, mask = 1 ; bit[0] != 0 ; bit += 1, mask <<= 1) {
if (*bit == '1')
val |= mask;
switch (ivl_enum_type(enumtype)) {
case IVL_VT_BOOL:
draw_enum2_value(enumtype, idx);
break;
case IVL_VT_LOGIC:
draw_enum4_value(enumtype, idx);
break;
default:
assert(0);
}
fprintf(vvp_out, " %ld%s\n", val, comma);
if ((idx+1) < name_count)
fputc(',', vvp_out);
fputc('\n', vvp_out);
}
fprintf(vvp_out, " ;\n");

2
vpi/Makefile.in
View File

@ -165,7 +165,7 @@ $(vpidir)/v2005_math.vpi: ./v2005_math.vpi
$(vpidir)/v2005_math.sft: v2005_math.sft
$(INSTALL_DATA) $< "$(DESTDIR)$@"
$(vpidir)/v2009_math.vpi: ./v2009.vpi
$(vpidir)/v2009.vpi: ./v2009.vpi
$(INSTALL_PROGRAM) ./v2009.vpi "$(DESTDIR)$(vpidir)/v2009.vpi"
$(vpidir)/v2009.sft: v2009.sft

93
vpi/v2009_enum.c
View File

@ -19,6 +19,7 @@
# include "vpi_config.h"
# include "sv_vpi_user.h"
# include <stdlib.h>
# include <assert.h>
static void missing_arguments(vpiHandle sys)
@ -73,7 +74,52 @@ static PLI_INT32 ivl_method_next_prev_compiletf(ICARUS_VPI_CONST PLI_BYTE8*data)
return 0;
}
static PLI_INT32 ivl_method_next2_calltf(PLI_BYTE8*data)
static int compare_value_eequal(s_vpi_value*ref1, s_vpi_value*ref2, long wid)
{
if (ref1->format == vpiIntVal && ref2->format == vpiIntVal)
return ref1->value.integer == ref2->value.integer;
if (ref1->format == vpiVectorVal && ref2->format == vpiVectorVal) {
int words = (wid-1)/32 + 1;
int idx;
for (idx = 0 ; idx < words ; idx += 1) {
if (ref1->value.vector[idx].aval != ref2->value.vector[idx].aval)
return 0;
if (ref1->value.vector[idx].bval != ref2->value.vector[idx].bval)
return 0;
}
return 1;
}
if (ref1->format == vpiVectorVal && ref2->format == vpiIntVal) {
s_vpi_value*tmp = ref1;
ref1 = ref2;
ref2 = tmp;
}
if (ref1->format == vpiIntVal && ref2->format == vpiVectorVal) {
int use_aval = ref1->value.integer;
int words = (wid-1)/32 + 1;
int idx;
for (idx = 0 ; idx < words ; idx += 1) {
if (use_aval != ref2->value.vector[idx].aval)
return 0;
if (0 != ref2->value.vector[idx].bval)
return 0;
use_aval = 0;
}
return 1;
}
vpi_printf("XXXX formats are: %d vs %d\n", ref1->format, ref2->format);
assert(0);
return 0;
}
static PLI_INT32 ivl_method_next_calltf(PLI_BYTE8*data)
{
vpiHandle sys = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, sys);
@ -83,25 +129,46 @@ static PLI_INT32 ivl_method_next2_calltf(PLI_BYTE8*data)
vpiHandle enum_list = 0;
vpiHandle memb = 0, first_memb = 0;
long use_width = 0;
long item_width = vpi_get(vpiSize, arg_item);
s_vpi_value memb_value, item_value;
assert(arg_extra == 0);
item_value.format = vpiIntVal;
item_value.format = vpiObjTypeVal;
vpi_get_value(arg_item, &item_value);
/* If this value is a vector value, then make a safe copy of
the vector so that other vpi functions don't trash it. */
if (item_value.format == vpiVectorVal) {
unsigned idx;
unsigned hwid = (item_width - 1)/32 + 1;
s_vpi_vecval*op = calloc(hwid, sizeof(s_vpi_vecval));
for (idx = 0 ; idx < hwid ; idx += 1) {
op[idx].aval = item_value.value.vector[idx].aval;
op[idx].bval = item_value.value.vector[idx].bval;
}
item_value.value.vector = op;
}
enum_list = vpi_iterate(vpiMember, arg_enum);
assert(enum_list);
/* Search for the current value in the member list. */
do {
memb = vpi_scan(enum_list);
if (first_memb == 0) first_memb = memb;
if (first_memb == 0) {
first_memb = memb;
use_width = vpi_get(vpiSize, first_memb);
assert(use_width == vpi_get(vpiSize, arg_item));
}
if (memb == 0) break;
memb_value.format = vpiIntVal;
memb_value.format = vpiObjTypeVal;
vpi_get_value(memb, &memb_value);
} while (memb_value.value.integer != item_value.value.integer);
} while (! compare_value_eequal(&item_value, &memb_value, use_width));
if (memb != 0);
memb = vpi_scan(enum_list);
@ -114,13 +181,17 @@ static PLI_INT32 ivl_method_next2_calltf(PLI_BYTE8*data)
memb_value.format = vpiIntVal;
}
/* Free any stached copy of the vector. */
if (item_value.format == vpiVectorVal)
free(item_value.value.vector);
vpi_get_value(memb, &memb_value);
vpi_put_value(sys, &memb_value, 0, vpiNoDelay);
return 0;
}
static PLI_INT32 ivl_method_prev2_calltf(PLI_BYTE8*data)
static PLI_INT32 ivl_method_prev_calltf(PLI_BYTE8*data)
{
vpiHandle sys = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, sys);
@ -130,6 +201,7 @@ static PLI_INT32 ivl_method_prev2_calltf(PLI_BYTE8*data)
vpiHandle enum_list = 0;
vpiHandle memb = 0, prev = 0, last_memb = 0;
int use_wid = 0;
s_vpi_value memb_value, item_value;
@ -146,10 +218,13 @@ static PLI_INT32 ivl_method_prev2_calltf(PLI_BYTE8*data)
prev = memb;
memb = vpi_scan(enum_list);
if (memb == 0) break;
if (use_wid == 0)
use_wid = vpi_get(vpiSize, memb);
last_memb = memb;
memb_value.format = vpiIntVal;
vpi_get_value(memb, &memb_value);
} while (memb_value.value.integer != item_value.value.integer);
} while (! compare_value_eequal(&memb_value, &item_value, use_wid));
while (memb) {
last_memb = memb;
@ -170,7 +245,7 @@ void v2009_enum_register(void)
s_vpi_systf_data tf_data;
tf_data.type = vpiSysFunc;
tf_data.calltf = ivl_method_next2_calltf;
tf_data.calltf = ivl_method_next_calltf;
tf_data.compiletf = ivl_method_next_prev_compiletf;
tf_data.sizetf = 0;
tf_data.tfname = "$ivl_method$next";
@ -178,7 +253,7 @@ void v2009_enum_register(void)
vpi_register_systf(&tf_data);
tf_data.type = vpiSysFunc;
tf_data.calltf = ivl_method_prev2_calltf;
tf_data.calltf = ivl_method_prev_calltf;
tf_data.compiletf = 0;
tf_data.sizetf = 0;
tf_data.tfname = "$ivl_method$prev";

5
vvp/compile.h
View File

@ -202,7 +202,10 @@ extern void compile_dff(char*label,
struct symb_s arg_e,
struct symb_s arg_a);
extern void compile_enum_type(char*label, std::list<struct enum_name_s>*names);
extern void compile_enum2_type(char*label, long width,
std::list<struct enum_name_s>*names);
extern void compile_enum4_type(char*label, long width,
std::list<struct enum_name_s>*names);
class __vpiModPath;
extern __vpiModPath* compile_modpath(char*label,

78
vvp/enum_type.cc
View File

@ -26,6 +26,7 @@ struct enumconst_s {
struct __vpiHandle base;
const char*name;
vvp_vector2_t val2;
vvp_vector4_t val4;
};
static struct enumconst_s* enumconst_from_handle(vpiHandle obj)
@ -49,6 +50,22 @@ static struct __vpiEnumTypespec* vpip_enum_typespec_from_handle(vpiHandle obj)
return 0;
}
static int enum_type_get(int code, vpiHandle obj)
{
struct __vpiEnumTypespec*ref = vpip_enum_typespec_from_handle(obj);
assert(ref);
switch (code) {
case vpiSize:
return ref->names.size();
default:
fprintf(stderr, "vvp error: get %d not supported "
"by __vpiEnumTypespec\n", code);
assert(0);
return 0;
}
}
static vpiHandle enum_type_iterate(int code, vpiHandle obj)
{
struct __vpiEnumTypespec*ref = vpip_enum_typespec_from_handle(obj);
@ -57,7 +74,7 @@ static vpiHandle enum_type_iterate(int code, vpiHandle obj)
if (code == vpiMember) {
vpiHandle*args = (vpiHandle*)
calloc(ref->names.size(), sizeof(vpiHandle*));
for (int idx = 0 ; idx < ref->names.size() ; idx += 1)
for (size_t idx = 0 ; idx < ref->names.size() ; idx += 1)
args[idx] = vpi_handle(&ref->names[idx]);
return vpip_make_iterator(ref->names.size(), args, true);
@ -68,7 +85,7 @@ static vpiHandle enum_type_iterate(int code, vpiHandle obj)
static const struct __vpirt enum_type_rt = {
vpiEnumTypespec,
0, //enum_type_get,
enum_type_get,
0, //enum_type_get_str,
0, //enum_type_get_value,
0, //enum_type_put_value,
@ -80,6 +97,19 @@ static const struct __vpirt enum_type_rt = {
0, //enum_type_put_delays
};
static int enum_name_get(int code, vpiHandle obj)
{
struct enumconst_s*ref = enumconst_from_handle(obj);
assert(ref);
switch (code) {
case vpiSize:
return ref->val4.size()? ref->val4.size() : ref->val2.size();
default:
return 0;
}
}
static char* enum_name_get_str(int code, vpiHandle obj)
{
struct enumconst_s*ref = enumconst_from_handle(obj);
@ -98,20 +128,15 @@ static void enum_name_get_value(vpiHandle obj, p_vpi_value value)
struct enumconst_s*ref = enumconst_from_handle(obj);
assert(ref);
switch (value->format) {
case vpiObjTypeVal:
value->format = vpiIntVal;
case vpiIntVal:
vector2_to_value(ref->val2, value->value.integer, true);
break;
default:
break;
}
if (ref->val4.size() > 0)
vpip_vec4_get_value(ref->val4, ref->val4.size(), false, value);
else
vpip_vec2_get_value(ref->val2, ref->val2.size(), true, value);
}
static const struct __vpirt enum_name_rt = {
vpiEnumConst,
0, //enum_name_get,
enum_name_get,
enum_name_get_str,
enum_name_get_value,
0, //enum_name_put_value,
@ -123,7 +148,29 @@ static const struct __vpirt enum_name_rt = {
0, //enum_name_put_delays
};
void compile_enum_type(char*label, std::list<struct enum_name_s>*names)
void compile_enum2_type(char*label, long width, std::list<struct enum_name_s>*names)
{
struct __vpiEnumTypespec*spec = new struct __vpiEnumTypespec;
spec->base.vpi_type = &enum_type_rt;
spec->names = std::vector<enumconst_s> (names->size());
size_t idx = 0;
for (list<struct enum_name_s>::iterator cur = names->begin()
; cur != names->end() ; ++cur, ++idx) {
assert(cur->val4 == 0);
spec->names[idx].base.vpi_type = &enum_name_rt;
spec->names[idx].name = cur->text;
spec->names[idx].val2 = vvp_vector2_t(cur->val2, width);
}
assert(idx == spec->names.size());
compile_vpi_symbol(label, vpi_handle(spec));
free(label);
delete names;
}
void compile_enum4_type(char*label, long width, std::list<struct enum_name_s>*names)
{
struct __vpiEnumTypespec*spec = new struct __vpiEnumTypespec;
spec->base.vpi_type = &enum_type_rt;
@ -134,7 +181,10 @@ void compile_enum_type(char*label, std::list<struct enum_name_s>*names)
; cur != names->end() ; ++cur, ++idx) {
spec->names[idx].base.vpi_type = &enum_name_rt;
spec->names[idx].name = cur->text;
spec->names[idx].val2 = vvp_vector2_t(cur->val2, 32);
assert(cur->val4);
spec->names[idx].val4 = vector4_from_text(cur->val4, width);
free(cur->val4);
cur->val4 = 0;
}
assert(idx == spec->names.size());

3
vvp/lexor.lex
View File

@ -142,7 +142,8 @@ static char* strdupnew(char const *str)
".concat" { return K_CONCAT; }
".delay" { return K_DELAY; }
".dff" { return K_DFF; }
".enum" { return K_ENUM; }
".enum2" { return K_ENUM2; }
".enum4" { return K_ENUM4; }
".event" { return K_EVENT; }
".event/or" { return K_EVENT_OR; }
".export" { return K_EXPORT; }

13
vvp/parse.y
View File

@ -80,7 +80,8 @@ static struct __vpiModPath*modpath_dst = 0;
%token K_CMP_EEQ K_CMP_EQ K_CMP_EQ_R K_CMP_NEE K_CMP_NE K_CMP_NE_R
%token K_CMP_GE K_CMP_GE_R K_CMP_GE_S K_CMP_GT K_CMP_GT_R K_CMP_GT_S
%token K_CONCAT K_DEBUG K_DELAY K_DFF
%token K_ENUM K_EVENT K_EVENT_OR K_EXPORT K_EXTEND_S K_FUNCTOR K_IMPORT K_ISLAND
%token K_ENUM2 K_ENUM4 K_EVENT K_EVENT_OR K_EXPORT K_EXTEND_S K_FUNCTOR
%token K_IMPORT K_ISLAND
%token K_MODPATH
%token K_NET K_NET_S K_NET_R K_NET_2S K_NET_2U K_NET8 K_NET8_S
%token K_PARAM_STR K_PARAM_L K_PARAM_REAL K_PART K_PART_PV
@ -799,8 +800,10 @@ statement
/* Enumeration types */
enum_type
: T_LABEL K_ENUM enum_type_names ';'
{ compile_enum_type($1, $3); }
: T_LABEL K_ENUM2 '(' T_NUMBER ')' enum_type_names ';'
{ compile_enum2_type($1, $4, $6); }
| T_LABEL K_ENUM4 '(' T_NUMBER ')' enum_type_names ';'
{ compile_enum4_type($1, $4, $6); }
;
enum_type_names
@ -818,7 +821,9 @@ enum_type_names
enum_type_name
: T_STRING T_NUMBER
{ $$.text = $1; $$.val2 = $2; }
{ $$.text = $1; $$.val2 = $2; $$.val4 = 0; }
| T_STRING T_VECTOR
{ $$.text = $1; $$.val2 = 0; $$.val4 = $2.text; }
;
local_flag

1
vvp/parse_misc.h
View File

@ -73,6 +73,7 @@ struct numbv_s {
struct enum_name_s {
char*text;
uint64_t val2;
char*val4;
};
extern void numbv_init(struct numbv_s*obj);

16
vvp/vpi_const.cc
View File

@ -442,7 +442,6 @@ vpiHandle vpip_make_binary_const(unsigned wid, const char*bits)
obj->signed_flag = 0;
obj->sized_flag = 0;
obj->bits = vvp_vector4_t(wid);
const char*bp = bits;
if (*bp == 's') {
@ -450,9 +449,18 @@ vpiHandle vpip_make_binary_const(unsigned wid, const char*bits)
obj->signed_flag = 1;
}
obj->bits = vector4_from_text(bp, wid);
return &(obj->base);
}
vvp_vector4_t vector4_from_text(const char*bits, unsigned wid)
{
vvp_vector4_t res (wid);
for (unsigned idx = 0 ; idx < wid ; idx += 1) {
vvp_bit4_t val = BIT4_0;
switch (bp[wid-idx-1]) {
switch (bits[wid-idx-1]) {
case '0':
val = BIT4_0;
break;
@ -467,10 +475,10 @@ vpiHandle vpip_make_binary_const(unsigned wid, const char*bits)
break;
}
obj->bits.set_bit(idx, val);
res.set_bit(idx, val);
}
return &(obj->base);
return res;
}
struct __vpiBinaryParam : public __vpiBinaryConst {

47
vvp/vpi_priv.cc
View File

@ -711,6 +711,53 @@ void vpip_vec4_get_value(const vvp_vector4_t&word_val, unsigned width,
}
}
void vpip_vec2_get_value(const vvp_vector2_t&word_val, unsigned width,
bool signed_flag, s_vpi_value*vp)
{
char *rbuf = 0;
switch (vp->format) {
default:
fprintf(stderr, "sorry: Format %d not implemented for "
"getting vector2 values.\n", (int)vp->format);
assert(0);
case vpiSuppressVal:
break;
case vpiObjTypeVal:
vp->format = vpiIntVal;
case vpiIntVal:
vector2_to_value(word_val, vp->value.integer, true);
break;
case vpiVectorVal: {
unsigned hwid = (width - 1)/32 + 1;
rbuf = need_result_buf(hwid * sizeof(s_vpi_vecval), RBUF_VAL);
s_vpi_vecval *op = (p_vpi_vecval)rbuf;
vp->value.vector = op;
op->aval = op->bval = 0;
for (unsigned idx = 0 ; idx < width ; idx += 1) {
if (word_val.value(idx)) {
op->aval |= (1 << idx % 32);
op->bval &= ~(1 << idx % 32);
} else {
op->aval &= ~(1 << idx % 32);
op->bval &= ~(1 << idx % 32);
}
if (!((idx+1) % 32) && (idx+1 < width)) {
op++;
op->aval = op->bval = 0;
}
}
break;
}
}
}
/*
* Convert a real value to the appropriate integer.
*/

2
vvp/vpi_priv.h
View File

@ -611,6 +611,8 @@ extern double real_from_vpi_value(s_vpi_value*vp);
extern void vpip_vec4_get_value(const vvp_vector4_t&word_val, unsigned width,
bool signed_flag, s_vpi_value*vp);
extern void vpip_vec2_get_value(const vvp_vector2_t&word_val, unsigned width,
bool signed_flag, s_vpi_value*vp);
extern void vpip_real_get_value(double real, s_vpi_value*vp);
/*

51
vvp/vvp_net.cc
View File

@ -1527,11 +1527,11 @@ ostream& operator<< (ostream&out, const vvp_vector4_t&that)
return out;
}
bool vector4_to_value(const vvp_vector4_t&vec, long&val,
bool is_signed, bool is_arithmetic)
template <class INT>bool do_vector4_to_value(const vvp_vector4_t&vec, INT&val,
bool is_signed, bool is_arithmetic)
{
long res = 0;
long msk = 1;
INT msk = 1;
bool rc_flag = true;
unsigned size = vec.size();
@ -1555,13 +1555,25 @@ bool vector4_to_value(const vvp_vector4_t&vec, long&val,
if (is_signed && vec.value(vec.size()-1) == BIT4_1) {
if (vec.size() < 8*sizeof(val))
res |= (-1L) << vec.size();
res |= (INT)(-1L) << vec.size();
}
val = res;
return rc_flag;
}
bool vector4_to_value(const vvp_vector4_t&vec, long&val,
bool is_signed, bool is_arithmetic)
{
return do_vector4_to_value(vec, val, is_signed, is_arithmetic);
}
bool vector4_to_value(const vvp_vector4_t&vec, int32_t&val,
bool is_signed, bool is_arithmetic)
{
return do_vector4_to_value(vec, val, is_signed, is_arithmetic);
}
bool vector4_to_value(const vvp_vector4_t&vec, unsigned long&val)
{
unsigned long res = 0;
@ -1591,36 +1603,7 @@ bool vector4_to_value(const vvp_vector4_t&vec, unsigned long&val)
bool vector4_to_value(const vvp_vector4_t&vec, int64_t&val,
bool is_signed, bool is_arithmetic)
{
long res = 0;
long msk = 1;
bool rc_flag = true;
unsigned size = vec.size();
if (size > 8*sizeof(val)) size = 8*sizeof(val);
for (unsigned idx = 0 ; idx < size ; idx += 1) {
switch (vec.value(idx)) {
case BIT4_0:
break;
case BIT4_1:
res |= msk;
break;
default:
if (is_arithmetic)
return false;
else
rc_flag = false;
}
msk <<= 1L;
}
if (is_signed && vec.value(vec.size()-1) == BIT4_1) {
if (vec.size() < 8*sizeof(val))
res |= (-1L) << vec.size();
}
val = res;
return rc_flag;
return do_vector4_to_value(vec, val, is_signed, is_arithmetic);
}
bool vector4_to_value(const vvp_vector4_t&vec, vvp_time64_t&val)

3
vvp/vvp_net.h
View File

@ -490,6 +490,7 @@ template <class T> extern T coerce_to_width(const T&that, unsigned width);
*/
extern bool vector4_to_value(const vvp_vector4_t&a, long&val, bool is_signed, bool is_arithmetic =true);
extern bool vector4_to_value(const vvp_vector4_t&a, unsigned long&val);
extern bool vector4_to_value(const vvp_vector4_t&a, int32_t&val, bool is_signed, bool is_arithmetic =true);
#ifndef UL_AND_TIME64_SAME
extern bool vector4_to_value(const vvp_vector4_t&a, int64_t&val, bool is_signed, bool is_arithmetic =true);
extern bool vector4_to_value(const vvp_vector4_t&a, vvp_time64_t&val);
@ -498,6 +499,8 @@ extern bool vector4_to_value(const vvp_vector4_t&a, double&val, bool is_signed);
extern bool vector2_to_value(const vvp_vector2_t&a, int32_t&val, bool is_signed);
extern vvp_vector4_t vector4_from_text(const char*bits, unsigned wid);
/*
* The __vpiArray handle uses instances of this to keep an array of
* real valued variables.