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

Make the modpath source define the VPI modpath object. 

The modpath source node defines the modpath object, and carries the
nodes for the source expression. The modpath outputs are references
by pointers to the vpiModPath that is not in itself a vpi object
any more. This makes the VPI view of a module path look like the
source-destinaiton pair that is the IEEE1364 description of the
modpath.
This commit is contained in:
Stephen Williams 2007-11-05 19:58:20 -08:00
parent 68cf5baba5
commit 5bcbd09ed9
5 changed files with 136 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
vvp/compile.cc
View File

@ -1131,17 +1131,20 @@ struct __vpiModPath* compile_modpath(char*label, struct symb_s drv,
define_functor_symbol(label, net); define_functor_symbol(label, net);
vpiHandle tmp = vpip_make_modpath(label, drv.text, net); __vpiModPath*modpath = vpip_make_modpath(net);
__vpiModPath*modpath = vpip_modpath_from_handle(tmp);
compile_vpi_lookup(&modpath->path_term_out.expr, dest.text); compile_vpi_lookup(&modpath->path_term_out.expr, dest.text);
free(label);
modpath->modpath = obj; modpath->modpath = obj;
return modpath; return modpath;
} }
static vvp_net_t*make_modpath_src(struct __vpiModPath*path, char edge, static struct __vpiModPathSrc*make_modpath_src(struct __vpiModPath*path,
struct symb_s src, struct numbv_s vals) char edge,
struct symb_s src,
struct numbv_s vals)
{ {
vvp_fun_modpath*dst = path->modpath; vvp_fun_modpath*dst = path->modpath;
@ -1188,29 +1191,36 @@ static vvp_net_t*make_modpath_src(struct __vpiModPath*path, char edge,
Compiling the delays values into actual modpath vpiHandle Compiling the delays values into actual modpath vpiHandle
*/ */
//vpip_add_mopdath_delay ( vpiobj, src.text, use_delay ) ; //vpip_add_mopdath_delay ( vpiobj, src.text, use_delay ) ;
vpiHandle srcobj = vpip_make_modpath_src ( src.text, use_delay, net ) ; struct __vpiModPathSrc* srcobj = vpip_make_modpath_src (path, use_delay, net) ;
vpip_add_modpath_src (vpi_handle(path), srcobj); vpip_attach_to_current_scope(vpi_handle(srcobj));
net->fun = obj; net->fun = obj;
input_connect(net, 0, src.text); input_connect(net, 0, src.text);
dst->add_modpath_src(obj); dst->add_modpath_src(obj);
return net; return srcobj;
}
void compile_modpath_src(struct __vpiModPath*dst, char edge,
struct symb_s src, struct numbv_s vals)
{
make_modpath_src(dst, edge, src, vals);
} }
void compile_modpath_src(struct __vpiModPath*dst, char edge, void compile_modpath_src(struct __vpiModPath*dst, char edge,
struct symb_s src, struct symb_s src,
struct numbv_s vals, struct numbv_s vals,
struct symb_s condit_src) struct symb_s condit_src,
struct symb_s path_term_in)
{ {
vvp_net_t*net = make_modpath_src(dst, edge, src, vals); struct __vpiModPathSrc*obj = make_modpath_src(dst, edge, src, vals);
input_connect(net, 1, condit_src.text); input_connect(obj->net, 1, condit_src.text);
compile_vpi_lookup(&obj->path_term_in.expr, path_term_in.text);
}
void compile_modpath_src(struct __vpiModPath*dst, char edge,
struct symb_s src,
struct numbv_s vals,
int condit_src,
struct symb_s path_term_in)
{
assert(condit_src == 0);
struct __vpiModPathSrc*obj = make_modpath_src(dst, edge, src, vals);
compile_vpi_lookup(&obj->path_term_in.expr, path_term_in.text);
} }
/* /*

7
vvp/compile.h
View File

@ -181,12 +181,15 @@ extern __vpiModPath* compile_modpath(char*label,
extern void compile_modpath_src(__vpiModPath*dst, extern void compile_modpath_src(__vpiModPath*dst,
char edge, char edge,
struct symb_s input, struct symb_s input,
struct numbv_s d); struct numbv_s d,
int condit_input, /* match with '0' */
struct symb_s path_term_input);
extern void compile_modpath_src(__vpiModPath*dst, extern void compile_modpath_src(__vpiModPath*dst,
char edge, char edge,
struct symb_s input, struct symb_s input,
struct numbv_s d, struct numbv_s d,
struct symb_s condit_input); struct symb_s condit_input,
struct symb_s path_term_input);
extern void compile_reduce_and(char*label, struct symb_s arg); extern void compile_reduce_and(char*label, struct symb_s arg);
extern void compile_reduce_or(char*label, struct symb_s arg); extern void compile_reduce_or(char*label, struct symb_s arg);

323
vvp/delay.cc
View File

@ -497,39 +497,8 @@ bool vvp_fun_modpath_edge::test_vec4(const vvp_vector4_t&bit)
*/ */
static int modpath_src_get(int code, vpiHandle ref) static int modpath_src_get(int code, vpiHandle ref)
{ {
assert((ref->vpi_type->type_code == vpiModPath)); struct __vpiModPathSrc*obj = vpip_modpath_src_from_handle(ref);
return 0 ; assert(obj);
}
/*
* This routine will return an modpathIn input port
* name for an modpath vpiHandle object
*
*/
static char* modpath_src_get_str(int code, vpiHandle ref)
{
assert((ref->vpi_type->type_code == vpiModPathIn));
struct __vpiModPathSrc *refp = (struct __vpiModPathSrc *)ref;
char *bn = strdup(vpi_get_str(vpiFullName, &refp->scope->base));
char *nm = (char *)refp->name ;
char *rbuf = need_result_buf(strlen(bn) + strlen(nm) + 2, RBUF_STR);
switch (code)
{
case vpiFullName:
sprintf(rbuf, "%s.%s", bn, nm);
free(bn);
return rbuf;
case vpiName:
strcpy(rbuf, nm);
free(bn);
return rbuf;
}
free(bn);
return 0 ; return 0 ;
} }
@ -551,23 +520,27 @@ static vpiHandle modpath_src_put_value(vpiHandle ref, s_vpi_value *vp )
static vpiHandle modpath_src_get_handle(int code, vpiHandle ref) static vpiHandle modpath_src_get_handle(int code, vpiHandle ref)
{ {
assert( (ref->vpi_type->type_code==vpiModPathIn ) ); struct __vpiModPathSrc*rfp = vpip_modpath_src_from_handle(ref);
struct __vpiModPathSrc *rfp = (struct __vpiModPathSrc *)ref ; assert(rfp);
switch (code) {
switch (code)
{
case vpiScope: case vpiScope:
return &rfp->scope->base ; return vpi_handle(rfp->dest->scope);
case vpiModule: case vpiModule:
{ { struct __vpiScope*scope = rfp->dest->scope;
struct __vpiScope*scope = rfp->scope;
while (scope && scope->base.vpi_type->type_code != vpiModule) while (scope && scope->base.vpi_type->type_code != vpiModule)
scope = scope->scope; scope = scope->scope;
assert(scope); assert(scope);
return &scope->base; return vpi_handle(scope);
} }
case vpiModPathIn:
return vpi_handle(&rfp->path_term_in);
case vpiModPathOut:
return vpi_handle(&rfp->dest->path_term_out);
} }
return 0; return 0;
} }
@ -586,7 +559,6 @@ static int modpath_src_free_object( vpiHandle ref )
return 1 ; return 1 ;
} }
/* /*
* This Routine will put specific demension of delay[] values * This Routine will put specific demension of delay[] values
* into a vpiHandle. In this case, he will put an * into a vpiHandle. In this case, he will put an
@ -596,15 +568,13 @@ static int modpath_src_free_object( vpiHandle ref )
static void modpath_src_put_delays ( vpiHandle ref, p_vpi_delay delays ) static void modpath_src_put_delays ( vpiHandle ref, p_vpi_delay delays )
{ {
int i ; int i ;
assert((ref->vpi_type->type_code == vpiModPathIn));
struct __vpiModPathSrc * src = vpip_modpath_src_from_handle( ref) ; struct __vpiModPathSrc * src = vpip_modpath_src_from_handle( ref) ;
assert(src) ; assert(src) ;
vvp_fun_modpath_src *fun = dynamic_cast<vvp_fun_modpath_src*>(src->node->fun);
vvp_fun_modpath_src *fun = dynamic_cast<vvp_fun_modpath_src*>(src->net->fun);
assert( fun ); assert( fun );
for ( i = 0 ; i < delays->no_of_delays ; i++) for ( i = 0 ; i < delays->no_of_delays ; i++) {
{
fun->delay[i] = delays->da[ i ].real ; fun->delay[i] = delays->da[ i ].real ;
} }
} }
@ -620,183 +590,15 @@ static void modpath_src_put_delays ( vpiHandle ref, p_vpi_delay delays )
static void modpath_src_get_delays ( vpiHandle ref, p_vpi_delay delays ) static void modpath_src_get_delays ( vpiHandle ref, p_vpi_delay delays )
{ {
int i ; int i ;
assert(( ref->vpi_type->type_code == vpiModPathIn ));
struct __vpiModPathSrc * src = vpip_modpath_src_from_handle( ref) ; struct __vpiModPathSrc * src = vpip_modpath_src_from_handle( ref) ;
assert(src); assert(src);
vvp_fun_modpath_src *fun = dynamic_cast<vvp_fun_modpath_src*>(src->node->fun);
vvp_fun_modpath_src *fun = dynamic_cast<vvp_fun_modpath_src*>(src->net->fun);
assert( fun ); assert( fun );
for ( i = 0 ; i < delays->no_of_delays ; i++) for ( i = 0 ; i < delays->no_of_delays ; i++)
delays->da[ i ].real = fun->delay[i]; delays->da[ i ].real = fun->delay[i];
} }
/*
This Struct will be used by the make_vpi_modpath_src ( )
to initializa the vpiModPathIn vpiHandle type, and assign
method routines
vpiModPathIn vpiHandle interanl operations :
we have
vpi_get == modpath_src_get (..) ;
vpi_get_str == modpath_src_get_str (..) ;
vpi_get_value == modpath_src_get_value (..) ;
vpi_put_value == modpath_src_put_value (..) ;
vpi_get_handle == modpath_src_get_handle (..) ;
vpi_iterate == modpath_src_iterate (..) ;
vpi_index == modpath_src_index ( .. ) ;
vpi_free_object == modpath_src_free_object ( .. ) ;
vpi_get_delay == modpath_src_get_delay (..) ;
vpi_put_delay == modpath_src_put_delay (..) ;
*/
static const struct __vpirt vpip_modpath_src = {
vpiModPathIn,
modpath_src_get,
modpath_src_get_str,
modpath_src_get_value,
modpath_src_put_value,
modpath_src_get_handle,
0, /* modpath_src_iterate,*/
modpath_src_index,
modpath_src_free_object,
modpath_src_get_delays,
modpath_src_put_delays
};
/*
* This function will Constructs a vpiModPathIn
* ( struct __vpiModPathSrc ) Object. will give
* a delays[12] values, and point to the specified functor
*
*/
vpiHandle vpip_make_modpath_src ( char *name, vvp_time64_t use_delay[12] , vvp_net_t *net )
{
struct __vpiModPathSrc *obj = (struct __vpiModPathSrc *) calloc (1, sizeof ( struct __vpiModPathSrc ) ) ;
obj->base.vpi_type = &vpip_modpath_src;
obj->scope = vpip_peek_current_scope ( );
obj->name = (char *)calloc(strlen(name) + 1 , sizeof ( char )) ;
strcpy ( obj->name, name ) ;
obj->node = net ;
vpip_attach_to_current_scope (&obj->base) ;
return &obj->base ;
}
/*
vpiModPath vpiHandle interanl operations :
we have
vpi_get == modpath_get (..) ;
vpi_get_str == modpath_get_str (..) ;
vpi_get_value == modpath_get_value (..) ;
vpi_put_value == modpath_put_value (..) ;
vpi_get_handle == modpath_get_handle (..) ;
vpi_iterate == modpath_iterate (..) ;
vpi_index == modpath_index ( .. ) ;
vpi_free_object == modpath_free_object ( .. ) ;
vpi_get_delay == modpath_get_delay (..) ;
vpi_put_delay == modpath_put_delay (..) ;
*/
static int modpath_get(int code, vpiHandle ref)
{
assert((ref->vpi_type->type_code == vpiModPath));
return 0 ;
}
static char* modpath_get_str(int code, vpiHandle ref)
{
assert((ref->vpi_type->type_code == vpiModPath));
struct __vpiModPath *refp = (struct __vpiModPath *)ref;
char *bn = strdup(vpi_get_str(vpiFullName, &refp->scope->base));
char *nm = (char *)refp->name ;
char *rbuf = need_result_buf(strlen(bn) + strlen(nm) + 2, RBUF_STR);
switch (code)
{
case vpiFullName:
sprintf(rbuf, "%s.%s", bn, nm);
free(bn);
return rbuf;
case vpiName:
strcpy(rbuf, nm);
free(bn);
return rbuf;
}
free(bn);
return 0;
}
static void modpath_get_value(vpiHandle ref, p_vpi_value vp)
{
assert((ref->vpi_type->type_code == vpiModPath));
// struct __vpiModPath* modpath = vpip_modpath_from_handle( ref) ;
// assert ( modpath ) ;
return ;
}
static vpiHandle modpath_put_value(vpiHandle ref, s_vpi_value *vp )
{
assert((ref->vpi_type->type_code == vpiModPath));
// struct __vpiModPath* modpath = vpip_modpath_from_handle( ref) ;
// assert ( modpath ) ;
return 0 ;
}
static vpiHandle modpath_get_handle(int code, vpiHandle ref)
{
struct __vpiModPath *rfp = vpip_modpath_from_handle(ref);
assert(rfp);
switch (code) {
case vpiScope:
return vpi_handle(rfp->scope);
case vpiModule:
{ struct __vpiScope*scope = rfp->scope;
while (scope && scope->base.vpi_type->type_code != vpiModule)
scope = scope->scope;
assert(scope);
return vpi_handle(scope);
}
case vpiModPathOut:
return vpi_handle(&rfp->path_term_out);
}
return 0;
}
static vpiHandle modpath_iterate (int code , vpiHandle ref )
{
assert( (ref->vpi_type->type_code == vpiModPath) );
return 0 ;
}
static vpiHandle modpath_index ( vpiHandle ref, int code )
{
assert( (ref->vpi_type->type_code == vpiModPath) );
return 0 ;
}
static int modpath_free_object( vpiHandle ref )
{
assert( (ref->vpi_type->type_code == vpiModPath) );
free ( ref ) ;
return 1 ;
}
static vpiHandle pathterm_get_handle(int code, vpiHandle ref) static vpiHandle pathterm_get_handle(int code, vpiHandle ref)
{ {
@ -811,24 +613,23 @@ static vpiHandle pathterm_get_handle(int code, vpiHandle ref)
} }
} }
/* /*
This Struct will be used by the make_vpi_modpath ( ) * The __vpiModPathSrc class is what the VPI client sees as a
to initializa the vpiModPath vpiHandle type, and assign * vpiModPath object. The __vpiModPath structure contains items that
method routines * are common to a bunch of modpaths, including the destination term.
*/ */
static const struct __vpirt vpip_modpath_rt = { static const struct __vpirt vpip_modpath_src_rt = {
vpiModPath, vpiModPath,
modpath_get, modpath_src_get,
modpath_get_str, 0, /* vpi_get_str */
modpath_get_value, modpath_src_get_value,
modpath_put_value, modpath_src_put_value,
modpath_get_handle, modpath_src_get_handle,
modpath_iterate, 0, /* modpath_src_iterate,*/
modpath_index, modpath_src_index,
modpath_free_object, modpath_src_free_object,
0, // modpath_get_delays, modpath_src_get_delays,
0 // modpath_put_delays modpath_src_put_delays
}; };
static const struct __vpirt vpip_modpath_term_rt = { static const struct __vpirt vpip_modpath_term_rt = {
@ -857,25 +658,35 @@ static void initialize_path_term(struct __vpiModPathTerm&obj)
* respective functor * respective functor
*/ */
vpiHandle vpip_make_modpath ( char *name, char *input, vvp_net_t *net ) struct __vpiModPath* vpip_make_modpath(vvp_net_t *net)
{ {
struct __vpiModPath*obj = (struct __vpiModPath *)calloc(1, sizeof ( struct __vpiModPath ) ); struct __vpiModPath*obj = (struct __vpiModPath *)calloc(1, sizeof ( struct __vpiModPath ) );
obj->base.vpi_type = &vpip_modpath_rt ;
obj->scope = vpip_peek_current_scope ( ); obj->scope = vpip_peek_current_scope ( );
initialize_path_term(obj->path_term_out); initialize_path_term(obj->path_term_out);
obj->name = (char *)calloc(strlen(name) + 1 , sizeof ( char )) ;
strcpy ( obj->name, name ) ;
obj->input = (char *)calloc(strlen(input) + 1 , sizeof ( char )) ;
strcpy ( obj->input,input ) ;
fprintf(stderr, "XXXX: Add vpiModpath...\n");
obj->input_net = net ; obj->input_net = net ;
vpip_attach_to_current_scope (&obj->base) ;
return &obj->base ; return obj;
}
/*
* This function will Constructs a vpiModPathIn
* ( struct __vpiModPathSrc ) Object. will give
* a delays[12] values, and point to the specified functor
*
*/
struct __vpiModPathSrc* vpip_make_modpath_src (struct __vpiModPath*path, vvp_time64_t use_delay[12] , vvp_net_t *net )
{
struct __vpiModPathSrc *obj = (struct __vpiModPathSrc *) calloc (1, sizeof ( struct __vpiModPathSrc ) ) ;
obj->base.vpi_type = &vpip_modpath_src_rt;
obj->dest = path;
obj->net = net;
initialize_path_term(obj->path_term_in);
return obj;
} }
@ -884,14 +695,6 @@ vpiHandle vpip_make_modpath ( char *name, char *input, vvp_net_t *net )
to a struct __vpiModPath { } to a struct __vpiModPath { }
*/ */
struct __vpiModPath* vpip_modpath_from_handle(vpiHandle ref)
{
if (ref->vpi_type->type_code != vpiModPath)
return 0;
return (struct __vpiModPath *) ref;
}
struct __vpiModPathTerm* vpip_modpath_term_from_handle(vpiHandle ref) struct __vpiModPathTerm* vpip_modpath_term_from_handle(vpiHandle ref)
{ {
if (ref->vpi_type->type_code != vpiPathTerm) if (ref->vpi_type->type_code != vpiPathTerm)
@ -908,7 +711,7 @@ struct __vpiModPathTerm* vpip_modpath_term_from_handle(vpiHandle ref)
struct __vpiModPathSrc* vpip_modpath_src_from_handle(vpiHandle ref) struct __vpiModPathSrc* vpip_modpath_src_from_handle(vpiHandle ref)
{ {
if (ref->vpi_type->type_code != vpiModPathIn) if (ref->vpi_type->type_code != vpiModPath)
return 0; return 0;
return (struct __vpiModPathSrc *) ref; return (struct __vpiModPathSrc *) ref;
@ -925,13 +728,3 @@ void vpip_add_mopdath_edge ( vpiHandle vpiobj, char *label,
} }
void vpip_add_modpath_src ( vpiHandle modpath, vpiHandle src )
{
assert( (src->vpi_type->type_code == vpiModPathIn ));
assert( (modpath->vpi_type->type_code == vpiModPath ));
return ;
}

24
vvp/parse.y
View File

@ -775,18 +775,18 @@ modpath_src_list
; ;
modpath_src modpath_src
: symbol '(' numbers ')' : symbol '(' numbers ')' symbol
{ compile_modpath_src(modpath_dst, 0, $1, $3); } { compile_modpath_src(modpath_dst, 0, $1, $3, 0, $5); }
| symbol '(' numbers '?' symbol ')' | symbol '(' numbers '?' symbol ')' symbol
{ compile_modpath_src(modpath_dst, 0, $1, $3, $5); } { compile_modpath_src(modpath_dst, 0, $1, $3, $5, $7); }
| symbol '+' '(' numbers ')' | symbol '+' '(' numbers ')' symbol
{ compile_modpath_src(modpath_dst, '+', $1, $4); } { compile_modpath_src(modpath_dst, '+', $1, $4, 0, $6); }
| symbol '+' '(' numbers '?' symbol ')' | symbol '+' '(' numbers '?' symbol ')' symbol
{ compile_modpath_src(modpath_dst, '+', $1, $4, $6); } { compile_modpath_src(modpath_dst, '+', $1, $4, $6, $8); }
| symbol '-' '(' numbers ')' | symbol '-' '(' numbers ')' symbol
{ compile_modpath_src(modpath_dst, '-', $1, $4); } { compile_modpath_src(modpath_dst, '-', $1, $4, 0, $6); }
| symbol '-' '(' numbers '?' symbol ')' | symbol '-' '(' numbers '?' symbol ')' symbol
{ compile_modpath_src(modpath_dst, '-', $1, $4, $6); } { compile_modpath_src(modpath_dst, '-', $1, $4, $6, $8); }
; ;
udp_table udp_table

69
vvp/vpi_priv.h
View File

@ -218,17 +218,18 @@ extern vpiHandle vpip_make_net(const char*name, int msb, int lsb,
extern __vpiSignal* vpip_signal_from_handle(vpiHandle obj); extern __vpiSignal* vpip_signal_from_handle(vpiHandle obj);
struct __vpiModPathTerm {
struct __vpiHandle base;
vpiHandle expr;
};
struct __vpiModPathSrc { struct __vpiModPathSrc {
struct __vpiHandle base; struct __vpiHandle base;
struct __vpiScope *scope ; struct __vpiModPath *dest;
int type; int type;
char *label ; /*
Must Be removed in Future /* This is the input expression for this modpath. */
because the ModPathSrc have struct __vpiModPathTerm path_term_in;
no label
*/
char *name ;
struct __vpiModPathSrc *next ;
/* Just Temporary */ /* Just Temporary */
vvp_time64_t use_delay [12] ; vvp_time64_t use_delay [12] ;
@ -243,21 +244,13 @@ struct __vpiModPathSrc {
*/ */
p_vpi_delay delays ; p_vpi_delay delays ;
/* /* This is the input net for the modpath. signals on this net
The Posedge, Negedge are already defined are used to determine the modpath. They are *not* propagated
in the "delays->p_vpi_time(da)->high/low" anywhere. */
vvp_net_t *net;
bool posedge, negedge ;
*/
vvp_net_t *node;
} ; } ;
struct __vpiModPathTerm {
struct __vpiHandle base;
vpiHandle expr;
};
/* /*
* *
* The vpiMoaPath vpiHandle will define * The vpiMoaPath vpiHandle will define
@ -267,35 +260,14 @@ struct __vpiModPathTerm {
*/ */
struct __vpiModPath { struct __vpiModPath {
struct __vpiHandle base ;
struct __vpiScope *scope ; struct __vpiScope *scope ;
class vvp_fun_modpath*modpath; class vvp_fun_modpath*modpath;
struct __vpiModPathTerm path_term_out; struct __vpiModPathTerm path_term_out;
/*
* The name, input must be removed
* in future um ModPathSrc have no
* name.
*/
char *name ;
char *input ;
vvp_net_t *input_net ; vvp_net_t *input_net ;
struct __vpiModPathSrc *src_list ;
/*
* Keep an array of internal modpath_src
* vpiHandle
*/
struct __vpiHandle **src ;
/*
* Registering the number of modpath_src
* number
*/
unsigned int src_no ;
}; };
extern struct __vpiModPath* vpip_modpath_from_handle(vpiHandle ref);
extern struct __vpiModPathTerm* vpip_modpath_term_from_handle(vpiHandle ref); extern struct __vpiModPathTerm* vpip_modpath_term_from_handle(vpiHandle ref);
extern struct __vpiModPathSrc* vpip_modpath_src_from_handle(vpiHandle ref); extern struct __vpiModPathSrc* vpip_modpath_src_from_handle(vpiHandle ref);
@ -305,13 +277,11 @@ extern struct __vpiModPathSrc* vpip_modpath_src_from_handle(vpiHandle ref);
* for vpiModPath && vpiModPathIn objects * for vpiModPath && vpiModPathIn objects
*/ */
extern vpiHandle vpip_make_modpath_src ( char *name, extern struct __vpiModPathSrc* vpip_make_modpath_src (struct __vpiModPath*path_dest,
vvp_time64_t use_delay[12] , vvp_time64_t use_delay[12] ,
vvp_net_t *net ) ; vvp_net_t *net ) ;
extern vpiHandle vpip_make_modpath ( char *name, extern struct __vpiModPath* vpip_make_modpath(vvp_net_t *net) ;
char *input,
vvp_net_t *net ) ;
extern void vpip_add_mopdath_delay ( vpiHandle vpiobj, extern void vpip_add_mopdath_delay ( vpiHandle vpiobj,
char *label, char *label,
@ -323,15 +293,6 @@ extern void vpip_add_mopdath_edge ( vpiHandle vpiobj,
bool posedge , bool posedge ,
bool negedge ) ; bool negedge ) ;
extern void vpip_add_modpath_src ( vpiHandle modpath,
vpiHandle src ) ;
extern __vpiModPath* vpip_modpath_from_handle ( vpiHandle obj);
extern __vpiModPathSrc* vpip_modpath_src_from_handle( vpiHandle obj);
/* /*
* These methods support the vpi creation of events. The name string * These methods support the vpi creation of events. The name string