1 /*
2 * Copyright (c) 2019 Martin Whitaker (icarus@martin-whitaker.me.uk)
3 *
4 * This source code is free software; you can redistribute it
5 * and/or modify it in source code form under the terms of the GNU
6 * General Public License as published by the Free Software
7 * Foundation; either version 2 of the License, or (at your option)
8 * any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 */
19
20 #if defined(__MINGW32__) || defined (__CYGWIN__)
21
22 #include "vpi_user.h"
23 #include <assert.h>
24
25 static vpip_routines_s*vpip_routines = 0;
26
27 // callback related
28
vpi_register_cb(p_cb_data data)29 vpiHandle vpi_register_cb(p_cb_data data)
30 {
31 assert(vpip_routines);
32 return vpip_routines->register_cb(data);
33 }
vpi_remove_cb(vpiHandle ref)34 PLI_INT32 vpi_remove_cb(vpiHandle ref)
35 {
36 assert(vpip_routines);
37 return vpip_routines->remove_cb(ref);
38 }
39
vpi_register_systf(const struct t_vpi_systf_data * ss)40 vpiHandle vpi_register_systf(const struct t_vpi_systf_data*ss)
41 {
42 assert(vpip_routines);
43 return vpip_routines->register_systf(ss);
44 }
vpi_get_systf_info(vpiHandle obj,p_vpi_systf_data data)45 void vpi_get_systf_info(vpiHandle obj, p_vpi_systf_data data)
46 {
47 assert(vpip_routines);
48 vpip_routines->get_systf_info(obj, data);
49 }
50
51 // for obtaining handles
52
vpi_handle_by_name(const char * name,vpiHandle scope)53 vpiHandle vpi_handle_by_name(const char*name, vpiHandle scope)
54 {
55 assert(vpip_routines);
56 return vpip_routines->handle_by_name(name, scope);
57 }
vpi_handle_by_index(vpiHandle ref,PLI_INT32 idx)58 vpiHandle vpi_handle_by_index(vpiHandle ref, PLI_INT32 idx)
59 {
60 assert(vpip_routines);
61 return vpip_routines->handle_by_index(ref, idx);
62 }
63
64 // for traversing relationships
65
vpi_handle(PLI_INT32 type,vpiHandle ref)66 vpiHandle vpi_handle(PLI_INT32 type, vpiHandle ref)
67 {
68 assert(vpip_routines);
69 return vpip_routines->handle(type, ref);
70 }
vpi_iterate(PLI_INT32 type,vpiHandle ref)71 vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle ref)
72 {
73 assert(vpip_routines);
74 return vpip_routines->iterate(type, ref);
75 }
vpi_scan(vpiHandle iter)76 vpiHandle vpi_scan(vpiHandle iter)
77 {
78 assert(vpip_routines);
79 return vpip_routines->scan(iter);
80 }
81
82 // for processing properties
83
vpi_get(int property,vpiHandle ref)84 PLI_INT32 vpi_get(int property, vpiHandle ref)
85 {
86 assert(vpip_routines);
87 return vpip_routines->get(property, ref);
88 }
vpi_get_str(PLI_INT32 property,vpiHandle ref)89 char*vpi_get_str(PLI_INT32 property, vpiHandle ref)
90 {
91 assert(vpip_routines);
92 return vpip_routines->get_str(property, ref);
93 }
94
95 // delay processing
96
vpi_get_delays(vpiHandle expr,p_vpi_delay delays)97 void vpi_get_delays(vpiHandle expr, p_vpi_delay delays)
98 {
99 assert(vpip_routines);
100 vpip_routines->get_delays(expr, delays);
101 }
vpi_put_delays(vpiHandle expr,p_vpi_delay delays)102 void vpi_put_delays(vpiHandle expr, p_vpi_delay delays)
103 {
104 assert(vpip_routines);
105 vpip_routines->put_delays(expr, delays);
106 }
107
108 // value processing
109
vpi_get_value(vpiHandle expr,p_vpi_value value)110 void vpi_get_value(vpiHandle expr, p_vpi_value value)
111 {
112 assert(vpip_routines);
113 vpip_routines->get_value(expr, value);
114 }
vpi_put_value(vpiHandle obj,p_vpi_value value,p_vpi_time when,PLI_INT32 flags)115 vpiHandle vpi_put_value(vpiHandle obj, p_vpi_value value, p_vpi_time when, PLI_INT32 flags)
116 {
117 assert(vpip_routines);
118 return vpip_routines->put_value(obj, value, when, flags);
119 }
120
121 // time processing
122
vpi_get_time(vpiHandle obj,s_vpi_time * t)123 void vpi_get_time(vpiHandle obj, s_vpi_time*t)
124 {
125 assert(vpip_routines);
126 vpip_routines->get_time(obj, t);
127 }
128
129 // data processing
130
vpi_get_userdata(vpiHandle obj)131 void*vpi_get_userdata(vpiHandle obj)
132 {
133 assert(vpip_routines);
134 return vpip_routines->get_userdata(obj);
135 }
vpi_put_userdata(vpiHandle obj,void * data)136 PLI_INT32 vpi_put_userdata(vpiHandle obj, void*data)
137 {
138 assert(vpip_routines);
139 return vpip_routines->put_userdata(obj, data);
140 }
141
142 // I/O routines
143
vpi_mcd_open(char * name)144 PLI_UINT32 vpi_mcd_open(char*name)
145 {
146 assert(vpip_routines);
147 return vpip_routines->mcd_open(name);
148 }
vpi_mcd_close(PLI_UINT32 mcd)149 PLI_UINT32 vpi_mcd_close(PLI_UINT32 mcd)
150 {
151 assert(vpip_routines);
152 return vpip_routines->mcd_close(mcd);
153 }
vpi_mcd_flush(PLI_UINT32 mcd)154 PLI_INT32 vpi_mcd_flush(PLI_UINT32 mcd)
155 {
156 assert(vpip_routines);
157 return vpip_routines->mcd_flush(mcd);
158 }
vpi_mcd_name(PLI_UINT32 mcd)159 char*vpi_mcd_name(PLI_UINT32 mcd)
160 {
161 assert(vpip_routines);
162 return vpip_routines->mcd_name(mcd);
163 }
vpi_mcd_printf(PLI_UINT32 mcd,const char * fmt,...)164 PLI_INT32 vpi_mcd_printf(PLI_UINT32 mcd, const char*fmt, ...)
165 {
166 va_list ap;
167 va_start(ap, fmt);
168 assert(vpip_routines);
169 PLI_INT32 rv = vpip_routines->mcd_vprintf(mcd, fmt, ap);
170 va_end(ap);
171 return rv;
172 }
vpi_mcd_vprintf(PLI_UINT32 mcd,const char * fmt,va_list ap)173 PLI_INT32 vpi_mcd_vprintf(PLI_UINT32 mcd, const char*fmt, va_list ap)
174 {
175 assert(vpip_routines);
176 return vpip_routines->mcd_vprintf(mcd, fmt, ap);
177 }
178
vpi_flush(void)179 PLI_INT32 vpi_flush(void)
180 {
181 assert(vpip_routines);
182 return vpip_routines->flush();
183 }
vpi_printf(const char * fmt,...)184 PLI_INT32 vpi_printf(const char*fmt, ...)
185 {
186 va_list ap;
187 va_start(ap, fmt);
188 assert(vpip_routines);
189 PLI_INT32 rv = vpip_routines->vprintf(fmt, ap);
190 va_end(ap);
191 return rv;
192 }
vpi_vprintf(const char * fmt,va_list ap)193 PLI_INT32 vpi_vprintf(const char*fmt, va_list ap)
194 {
195 assert(vpip_routines);
196 return vpip_routines->vprintf(fmt, ap);
197 }
198
199 // utility routines
200
vpi_chk_error(p_vpi_error_info info)201 PLI_INT32 vpi_chk_error(p_vpi_error_info info)
202 {
203 assert(vpip_routines);
204 return vpip_routines->chk_error(info);
205 }
vpi_compare_objects(vpiHandle obj1,vpiHandle obj2)206 PLI_INT32 vpi_compare_objects(vpiHandle obj1, vpiHandle obj2)
207 {
208 assert(vpip_routines);
209 return vpip_routines->compare_objects(obj1, obj2);
210 }
vpi_free_object(vpiHandle ref)211 PLI_INT32 vpi_free_object(vpiHandle ref)
212 {
213 assert(vpip_routines);
214 return vpip_routines->free_object(ref);
215 }
vpi_get_vlog_info(p_vpi_vlog_info info)216 PLI_INT32 vpi_get_vlog_info(p_vpi_vlog_info info)
217 {
218 assert(vpip_routines);
219 return vpip_routines->get_vlog_info(info);
220
221 }
222
223 // control routines
224
vpi_control(PLI_INT32 operation,...)225 void vpi_control(PLI_INT32 operation, ...)
226 {
227 va_list ap;
228 va_start(ap, operation);
229 assert(vpip_routines);
230 vpip_routines->vcontrol(operation, ap);
231 va_end(ap);
232 }
vpi_sim_control(PLI_INT32 operation,...)233 void vpi_sim_control(PLI_INT32 operation, ...)
234 {
235 va_list ap;
236 va_start(ap, operation);
237 assert(vpip_routines);
238 vpip_routines->vcontrol(operation, ap);
239 va_end(ap);
240 }
241
242 // proposed standard extensions
243
vpi_fopen(const char * name,const char * mode)244 PLI_INT32 vpi_fopen(const char*name, const char*mode)
245 {
246 assert(vpip_routines);
247 return vpip_routines->fopen(name, mode);
248 }
vpi_get_file(PLI_INT32 fd)249 FILE*vpi_get_file(PLI_INT32 fd)
250 {
251 assert(vpip_routines);
252 return vpip_routines->get_file(fd);
253 }
254
255 // Icarus extensions
256
vpip_calc_clog2(vpiHandle arg)257 s_vpi_vecval vpip_calc_clog2(vpiHandle arg)
258 {
259 assert(vpip_routines);
260 return vpip_routines->calc_clog2(arg);
261 }
vpip_count_drivers(vpiHandle ref,unsigned idx,unsigned counts[4])262 void vpip_count_drivers(vpiHandle ref, unsigned idx, unsigned counts[4])
263 {
264 assert(vpip_routines);
265 vpip_routines->count_drivers(ref, idx, counts);
266 }
vpip_format_strength(char * str,s_vpi_value * value,unsigned bit)267 void vpip_format_strength(char*str, s_vpi_value*value, unsigned bit)
268 {
269 assert(vpip_routines);
270 vpip_routines->format_strength(str, value, bit);
271 }
vpip_make_systf_system_defined(vpiHandle ref)272 void vpip_make_systf_system_defined(vpiHandle ref)
273 {
274 assert(vpip_routines);
275 vpip_routines->make_systf_system_defined(ref);
276 }
vpip_mcd_rawwrite(PLI_UINT32 mcd,const char * buf,size_t count)277 void vpip_mcd_rawwrite(PLI_UINT32 mcd, const char*buf, size_t count)
278 {
279 assert(vpip_routines);
280 vpip_routines->mcd_rawwrite(mcd, buf, count);
281 }
vpip_set_return_value(int value)282 void vpip_set_return_value(int value)
283 {
284 assert(vpip_routines);
285 vpip_routines->set_return_value(value);
286 }
287
vpip_set_callback(vpip_routines_s * routines,PLI_UINT32 version)288 DLLEXPORT PLI_UINT32 vpip_set_callback(vpip_routines_s*routines, PLI_UINT32 version)
289 {
290 if (version != vpip_routines_version)
291 return 0;
292
293 vpip_routines = routines;
294 return 1;
295 }
296
297 #else
298
__libvpi_c_dummy_function(void)299 void __libvpi_c_dummy_function(void)
300 {
301 }
302
303 #endif
304