diff --git a/vpi_user.h b/vpi_user.h index 3bc520b4f..d255f56d4 100644 --- a/vpi_user.h +++ b/vpi_user.h @@ -79,6 +79,15 @@ typedef struct t_vpi_vlog_info typedef struct t_vpi_time { + + /* + Type can be : + + vpiScaledRealTime == 1 + vpiSimTime == 2 + vpiSuppressTime == 3 + */ + PLI_INT32 type; PLI_UINT32 high; PLI_UINT32 low; @@ -116,6 +125,114 @@ typedef struct t_vpi_value { } value; } s_vpi_value, *p_vpi_value; + +/* + + Conform the IEEE 1364, We add the + Standard vpi_delay structure to + enable the modpath delay values + + + Conform IEEE 1364, Pg 670 : + + The "da" field of the s_vpi_delay + structure shall be a user allocated + array of "s_vpi_time" struture + + The arrary shall store delay values returned + by vpi_get_delay(). The number of elements in + the array shall be determined by + + (1) The number of delays to be retrived + ( normally this is used in vpi_get_delays (..) ) + { + (1.1) Setted by "no_of_delays" field + + (1.2) For the primitive_object, the no_of_delays + shall be 2 or 3 + + (1.3) For path_delay object the no_of_delays shall + be 1,2,3,6, 12 + + (1.4) For timing_check_object, the no_of_delays shall + be match the number of limits existing in the + Time Check + + (1.5) For intermodule_path object, the no_of_delays shall + be 2 or 3 + } + + + + + (2) The "mtm_flag" && "pulsere_flag" + + + Normally, if you set mtm = X, pulsere = Y + then, you will need allocate (num * no_of_delay) + s_vpi_time elements for 'da' array before calling + the vpi_get/put_delays (..) + + --------------------------------------------------------------------------- + | | | | + | mtm_flag | No of s_vpi_time array | order in which delay | + | pulsere_flag | element required by the | elements shall be filed | + | | s_vpi_delay->da | | + | | | | + |----------------|-------------------------|------------------------------| + | | | 1o delay da[0]--> 1o delay | + | mtm = false | no_of_delay | 2o delay da[1]--> 2o delay | + | pulere = false | | | + | | | | + |----------------|-------------------------|------------------------------| + | | | 1o delay da[0]--> min delay | + | mtm = true | | da[1]--> typ delay | + | pulere = false | 3*no_of_delay | da[2]--> max delay | + | | | 2o delay da[3]--> min delay | + | | | da[4]--> typ delay | + | | | .... | + |----------------|-------------------------|------------------------------| + | | | 1o delay da[0]--> delay | + | mtm = false | | da[1]--> rej limit | + | pulere = true | 3*no_of_delay | da[2]--> err limit | + | | | 2o delay da[3]--> delay | + | | | da[4]--> rej limit | + | | | .... | + |----------------|-------------------------|------------------------------| + | | | 1o delay da[0]--> min delay | + | mtm = true | | da[1]--> typ delay | + | pulere = true | 9*no_of_delay | da[2]--> max delay | + | | | da[3]--> min delay | + | | | da[4]--> typ delay | + | | | da[5]--> max delay | + | | | da[6]--> min delay | + | | | da[7]--> typ delay | + | | | da[8]--> max delay | + | | | 2o delay da[9]--> min delay | + | | | .... | + ------------------------------------------------------------------------- + + IMPORTANT : + + The delay Structure has to be allocated before passing a pointer to + "vpi_get_delays ( )". + +*/ + + +typedef struct t_vpi_delay { + struct t_vpi_time *da; /* Array of delay datas */ + PLI_INT32 no_of_delays ; + PLI_INT32 time_type; /* vpiScaledRealTime, vpiSimTime */ + PLI_INT32 mtm_flag; + PLI_INT32 append_flag; + PLI_INT32 plusere_flag; +} s_vpi_delay, *p_vpi_delay; + + + + + /* These are valid codes for the format of the t_vpi_value structure. */ #define vpiBinStrVal 1 #define vpiOctStrVal 2 @@ -158,6 +275,7 @@ typedef struct t_vpi_value { #define vpiIterator 27 #define vpiMemory 29 #define vpiMemoryWord 30 +#define vpiModPath 31 #define vpiModule 32 #define vpiNamedBegin 33 #define vpiNamedEvent 34 @@ -177,6 +295,8 @@ typedef struct t_vpi_value { #define vpiSysTfCall 85 #define vpiArgument 89 #define vpiInternalScope 92 +#define vpiModPathIn 95 +#define vpiModPathOut 96 #define vpiVariables 100 #define vpiCallback 1000 @@ -361,6 +481,18 @@ extern vpiHandle vpi_put_value(vpiHandle obj, p_vpi_value value, extern PLI_INT32 vpi_free_object(vpiHandle ref); extern PLI_INT32 vpi_get_vlog_info(p_vpi_vlog_info vlog_info_p); +/* + These Routines will enable the modpath vpiHandle + to read/write delay values +*/ +extern void vpi_get_delays(vpiHandle expr, p_vpi_delay delays); + +extern void vpi_put_delays(vpiHandle expr, p_vpi_delay delays); + + + + + /* * These functions support attaching user data to an instance of a * system task or function. These functions only apply to diff --git a/vvp/compile.cc b/vvp/compile.cc index 1517cea46..9a4dcb9fa 100644 --- a/vvp/compile.cc +++ b/vvp/compile.cc @@ -47,6 +47,21 @@ unsigned compile_errors = 0; + +/* Auxiliary variable used to guard actual modpath input */ +char *actual_modpath_input ; + + +/* Auxiliary variable used to guard actual scope label */ +char *actual_modpath_label ; + + +/* Flag used to identify if actual modpath have been created */ +int modpath_flag = 0 ; +vpiHandle vpiobj, srcobj ; +vvp_net_t *actual_modpath_input_net ; + + /* * The opcode table lists all the code mnemonics, along with their * opcode and operand types. The table is written sorted by mnemonic @@ -1127,8 +1142,27 @@ vvp_fun_modpath* compile_modpath(char*label, struct symb_s src) input_connect(net, 0, src.text); define_functor_symbol(label, net); + + actual_modpath_input_net = net ; + // Make the vpiHandle for the vpiModPath + + actual_modpath_input=(char *)calloc(strlen(src.text)+1,sizeof(char)) ; + + strcpy ( actual_modpath_input, src.text ) ; + + actual_modpath_label =(char *)calloc(strlen(label)+1, sizeof (char )) ; + strcpy ( actual_modpath_label, label ) ; + + + vpiobj = 0 ; + modpath_flag = 0 ; /* + If we are compiling a new + modpath vpiobj, we have to set + the flag = 0, indicating a + new modpath vpiHandle have to + be created + */ free(label); - return obj; } @@ -1145,6 +1179,31 @@ static vvp_net_t*make_modpath_src(vvp_fun_modpath*dst, char edge, numbv_clear(&vals); vvp_fun_modpath_src*obj = 0; + /* + Added By Yang + + if the modpath_flag is NULL, then, + we have to call the modpath maker + to create a new modpath vpiHandle, + and insert all modpath_src into the vpi + + else + + just call the vpip_modpath_add_src to + insert new modpath source datas + */ + + if ( modpath_flag == 0 ) + { + vpiobj = vpip_make_modpath ( actual_modpath_label, actual_modpath_input , actual_modpath_input_net ) ; + modpath_flag = 1 ; + free ( actual_modpath_label ) ; + free ( actual_modpath_input ) ; + } + + + + if (edge == 0) { obj = new vvp_fun_modpath_src(use_delay); @@ -1173,11 +1232,20 @@ static vvp_net_t*make_modpath_src(vvp_fun_modpath*dst, char edge, } vvp_net_t*net = new vvp_net_t; + /* + Added by Yang + + Compiling the delays values into actual modpath vpiHandle + */ + //vpip_add_mopdath_delay ( vpiobj, src.text, use_delay ) ; + srcobj = vpip_make_modpath_src ( src.text, use_delay, net ) ; + vpip_add_modpath_src ( vpiobj, srcobj ) ; + + net->fun = obj; - input_connect(net, 0, src.text); - dst->add_modpath_src(obj); + return net; } diff --git a/vvp/delay.cc b/vvp/delay.cc index 30d12b4bf..da8a7b564 100644 --- a/vvp/delay.cc +++ b/vvp/delay.cc @@ -427,7 +427,17 @@ void vvp_fun_modpath::run_run() vvp_fun_modpath_src::vvp_fun_modpath_src(vvp_time64_t del[12]) { for (unsigned idx = 0 ; idx < 12 ; idx += 1) - delay_[idx] = del[idx]; + { + delay_[idx] = del[idx]; + /* + Added By Yang. + + Make the delay[12] value to be Public + make the get_delays(), put_delays() to + be possible + */ + delay [idx] = del[idx]; + } next_ = 0; wake_time_ = 0; diff --git a/vvp/delay.h b/vvp/delay.h index 7aea03e3c..d599160f9 100644 --- a/vvp/delay.h +++ b/vvp/delay.h @@ -185,8 +185,16 @@ class vvp_fun_modpath_src : public vvp_net_fun_t { public: void recv_vec4(vvp_net_ptr_t port, const vvp_vector4_t&bit); - virtual bool test_vec4(const vvp_vector4_t&bit); + + /* + Added By Yang. + + Make the Delay Value be Public too + make the get_delays(), put_delays() be possible + */ + vvp_time64_t delay[12]; + private: // FIXME: Needs to be a 12-value array diff --git a/vvp/vpi_priv.cc b/vvp/vpi_priv.cc index 1ac1ae172..7e33a7084 100644 --- a/vvp/vpi_priv.cc +++ b/vvp/vpi_priv.cc @@ -841,6 +841,70 @@ vpiHandle vpi_handle_by_name(const char *name, vpiHandle scope) return 0; } + +/* + We Increment the tow vpi methods to enable the + read/write SDF delay values from/into + the modpath vpiHandle + + + baiscally, they will redirect the generic vpi_interface + + vpi_get_delay ( .. ) + vpi_put_delay ( .. ) + + + to the + + modpath_get_delay ( .. ) ; + modpath_put_delay ( .. ) ; + +*/ + + + +void vpi_get_delays(vpiHandle expr, p_vpi_delay delays) +{ + assert(expr); + assert(delays); + + if (expr->vpi_type->vpi_get_delays_) + { + (expr->vpi_type->vpi_get_delays_)(expr, delays); + + if (vpi_trace) + { + fprintf(vpi_trace, + "vpi_get_delays(%s, %p) -->\n", expr, delays); + } + } +} + + +void vpi_put_delays(vpiHandle expr, p_vpi_delay delays) +{ + assert(expr ); + assert(delays ); + + if (expr->vpi_type->vpi_put_delays_) + { + (expr->vpi_type->vpi_put_delays_)(expr, delays); + + if (vpi_trace) + { + fprintf(vpi_trace, + "vpi_put_delays(%s, %p) -->\n", expr, delays); + } + } +} + + + + + + + + extern "C" PLI_INT32 vpi_vprintf(const char*fmt, va_list ap) { return vpi_mcd_vprintf(1, fmt, ap); diff --git a/vvp/vpi_priv.h b/vvp/vpi_priv.h index 83b1ce5e3..a4eaefb5c 100644 --- a/vvp/vpi_priv.h +++ b/vvp/vpi_priv.h @@ -27,6 +27,14 @@ # include "vvp_net.h" # include "memory.h" + +/* + * Added to use some "vvp_fun_modpath_src" + * and "vvp_fun_modpath" classes definitions + */ +#include "delay.h" + + /* * This header file contains the internal definitions that the vvp * program uses to implement the public interface in the vpi_user.h @@ -84,6 +92,13 @@ struct __vpirt { /* This implements the vpi_free_object method. */ int (*vpi_free_object_)(vpiHandle); + + /* + This tow method are used to read/write delay + value from/into modpath record + */ + void (*vpi_get_delays_)(vpiHandle, p_vpi_delay); + void (*vpi_put_delays_)(vpiHandle, p_vpi_delay); }; /* @@ -194,6 +209,109 @@ extern vpiHandle vpip_make_net(const char*name, int msb, int lsb, extern __vpiSignal* vpip_signal_from_handle(vpiHandle obj); +struct __vpiModPathSrc { + struct __vpiHandle base ; + struct __vpiScope *scope ; + int type ; + char *label ; /* + Must Be removed in Future + because the ModPathSrc have + no label + */ + char *name ; + struct __vpiModPathSrc *next ; + + /* Just Temporary */ + vvp_time64_t use_delay [12] ; + /* + Conform the IEEE1364, we use the + standard delay value structure + (p_vpi_time) to represent delay values + of each modpath_src delay + + the "p_vpi_time" is defined in the + "vpi_user.h" + */ + p_vpi_delay delays ; + + /* + The Posedge, Negedge are already defined + in the "delays->p_vpi_time(da)->high/low" + + bool posedge, negedge ; + */ + vvp_net_t *node; +} ; + + +/* + * + * The vpiMoaPath vpiHandle will define + * a vpiModPath of record .modpath as defined + * in the IEEE 1364 + * + */ + +struct __vpiModPath { + struct __vpiHandle base ; + struct __vpiScope *scope ; + + /* + * The name, input must be removed + * in future um ModPathSrc have no + * name. + */ + char *name ; + char *input ; + 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 ; +}; + + + +/* + * The Function is used to create the vpiHandle + * for vpiModPath && vpiModPathIn objects + */ + +extern vpiHandle vpip_make_modpath_src ( char *name, + vvp_time64_t use_delay[12] , + vvp_net_t *net ) ; + +extern vpiHandle vpip_make_modpath ( char *name, + char *input, + vvp_net_t *net ) ; + +extern void vpip_add_mopdath_delay ( vpiHandle vpiobj, + char *label, + vvp_time64_t use_delay[12] ) ; + +extern void vpip_add_mopdath_edge ( vpiHandle vpiobj, + char *label, + vvp_time64_t use_delay[12], + bool posedge , + 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 * passed in will be saved, so the caller must allocate it (or not diff --git a/vvp/vpi_signal.cc b/vvp/vpi_signal.cc index 4e2dd454f..a8a75fdb8 100644 --- a/vvp/vpi_signal.cc +++ b/vvp/vpi_signal.cc @@ -655,6 +655,377 @@ static const struct __vpirt vpip_net_rt = { 0 }; + + + + +/* + 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) +{ + assert( (ref->vpi_type->type_code==vpiModPath) ); + struct __vpiModPath *rfp = (struct __vpiModPath *)ref ; + + switch (code) + { + case vpiScope: + return &rfp->scope->base ; + + case vpiModule: + { + struct __vpiScope*scope = rfp->scope; + while (scope && scope->base.vpi_type->type_code != vpiModule) + scope = scope->scope; + + assert(scope); + return &scope->base; + } + } + 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 ; +} + + + + + + + +/* + This Struct will be used by the make_vpi_modpath ( ) + to initializa the vpiModPath vpiHandle type, and assign + method routines +*/ + +static const struct __vpirt vpip_modpath_rt = { + vpiModPath, + modpath_get, + modpath_get_str, + modpath_get_value, + modpath_put_value, + modpath_get_handle, + modpath_iterate, + modpath_index, + modpath_free_object, + 0, // modpath_get_delays, + 0 // modpath_put_delays +}; + + + + + + + + +/* + * All the below routines that begin with + * modpath_src_* belong the internal function + * of an vpiModPathIn object. This is used to + * make some specific delays path operations + * + */ + + +static int modpath_src_get(int code, vpiHandle ref) +{ + assert((ref->vpi_type->type_code == vpiModPath)); + return 0 ; +} + + + +/* + * 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; +} + + + + +static void modpath_src_get_value(vpiHandle ref, p_vpi_value vp) +{ + assert((ref->vpi_type->type_code == vpiModPathIn)); + struct __vpiModPathSrc* modpathsrc = vpip_modpath_src_from_handle( ref) ; + assert ( modpathsrc ) ; + return ; +} + + +static vpiHandle modpath_src_put_value(vpiHandle ref, s_vpi_value *vp ) +{ + assert((ref->vpi_type->type_code == vpiModPathIn)); + struct __vpiModPathSrc* modpathsrc = vpip_modpath_src_from_handle( ref) ; + assert ( modpathsrc ) ; + return 0 ; +} + + + + + +static vpiHandle modpath_src_get_handle(int code, vpiHandle ref) +{ + assert( (ref->vpi_type->type_code==vpiModPathIn ) ); + struct __vpiModPathSrc *rfp = (struct __vpiModPathSrc *)ref ; + + switch (code) + { + case vpiScope: + return &rfp->scope->base ; + + case vpiModule: + { + struct __vpiScope*scope = rfp->scope; + while (scope && scope->base.vpi_type->type_code != vpiModule) + scope = scope->scope; + + assert(scope); + return &scope->base; + } + } + return 0; +} + + + + +static vpiHandle modpath_src_index ( vpiHandle ref, int code ) +{ + assert( (ref->vpi_type->type_code == vpiModPathIn ) ); + return 0 ; +} + + +static int modpath_src_free_object( vpiHandle ref ) +{ + assert( (ref->vpi_type->type_code == vpiModPathIn ) ); + free ( ref ) ; + return 1 ; +} + + + +/* + * This Routine will put specific demension of delay[] values + * into a vpiHandle. In this case, he will put an + * specific delays values in a vpiModPathIn object + * + */ +static void modpath_src_put_delays ( vpiHandle ref, p_vpi_delay delays ) +{ + int i ; + assert((ref->vpi_type->type_code == vpiModPathIn)); + + struct __vpiModPathSrc * src = vpip_modpath_src_from_handle( ref) ; + assert ( src ) ; + vvp_fun_modpath_src *fun = dynamic_cast(src->node->fun); + assert( fun ); + + for ( i = 0 ; i < delays->no_of_delays ; i++) + { + fun->delay[i] = delays->da[ i ].real ; + } +} + + + + + + +/* + * This Routine will retrive the delay[12] values + * of an vpiHandle. In this case, he will get an + * specific delays values from an vpiModPathIn + * object + * + */ + +static void modpath_src_get_delays ( vpiHandle ref, p_vpi_delay delays ) +{ + int i ; + assert(( ref->vpi_type->type_code == vpiModPathIn )); + + struct __vpiModPathSrc * src = vpip_modpath_src_from_handle( ref) ; + assert ( src ) ; + vvp_fun_modpath_src *fun = dynamic_cast(src->node->fun); + assert( fun ); + for ( i = 0 ; i < delays->no_of_delays ; 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 +}; + + + + + /* * Construct a vpiIntegerVar object. Indicate the type using a flag * to minimize the code modifications. Icarus implements integers @@ -722,3 +1093,105 @@ vpiHandle vpip_make_net(const char*name, int msb, int lsb, return &obj->base; } + + + +/* + this Routine will safetly convert a modpath vpiHandle + 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; +} + +/* + this Routine will safetly convert a modpathsrc vpiHandle + to a struct __vpiModPathSrc { }, This is equivalent ao + vpiModPathIn handle +*/ + +struct __vpiModPathSrc* vpip_modpath_src_from_handle(vpiHandle ref) +{ + if (ref->vpi_type->type_code != vpiModPathIn) + return 0; + + return (struct __vpiModPathSrc *) ref; +} + + + +void vpip_add_mopdath_edge ( vpiHandle vpiobj, char *label, + vvp_time64_t use_delay[12] , + bool posedge , bool negedge ) +{ + // printf(" In the vpip_add_mopdath_edge( ) \n") ; + + +} + + + +void vpip_add_modpath_src ( vpiHandle modpath, vpiHandle src ) +{ + assert( (src->vpi_type->type_code == vpiModPathIn )); + assert( (modpath->vpi_type->type_code == vpiModPath )); + + return ; +} + + + + + + + +/* + * This function will Construct a vpiModPath Object. + * give a respective "net", and will point to his + * respective functor + */ + +vpiHandle vpip_make_modpath ( char *name, char *input, vvp_net_t *net ) +{ + + struct __vpiModPath *obj = (struct __vpiModPath *) calloc (1, sizeof ( struct __vpiModPath ) ) ; + obj->base.vpi_type = &vpip_modpath_rt ; + obj->scope = vpip_peek_current_scope ( ); + + 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 ) ; + + obj->input_net = net ; + vpip_attach_to_current_scope (&obj->base) ; + return &obj->base ; +} + + + +/* + * 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 ; +} +