vpi: Added $ivl_string_method$to_vec for strings to vectors conversion.

vpi/system.sft

@@ -22,4 +22,5 @@ $simparam      vpiSysFuncReal
 $simparam$str  vpiSysFuncSized 1024 unsigned
 $table_model   vpiSysFuncReal
 
-$ivl_string_method$len	vpiSysFuncInt
+$ivl_string_method$len      vpiSysFuncInt
+$ivl_string_method$to_vec   vpiSysFuncVoid

vpi/v2009_string.c

@@ -19,6 +19,9 @@
 
 # include  "sys_priv.h"
 # include  <assert.h>
+# include  <math.h>
+# include  <stdlib.h>
+# include  <string.h>
 
 static PLI_INT32 one_string_arg_compiletf(ICARUS_VPI_CONST PLI_BYTE8*name)
 {
@@ -75,6 +78,118 @@ static PLI_INT32 len_calltf(ICARUS_VPI_CONST PLI_BYTE8*name)
       return 0;
 }
 
+
+static PLI_INT32 to_vec_compiletf(ICARUS_VPI_CONST PLI_BYTE8*user_data)
+{
+    (void) user_data; /* Parameter is not used. */
+
+    vpiHandle systf_handle, arg_iterator, arg_handle;
+    PLI_INT32 arg_type[2];
+
+    /* obtain a handle to the system task instance */
+    systf_handle = vpi_handle(vpiSysTfCall, NULL);
+    if (systf_handle == NULL) {
+        vpi_printf("ERROR: $ivl_string_method$to_vec failed to obtain systf handle\n");
+        vpi_control(vpiFinish,0); /* abort simulation */
+        return 0;
+    }
+
+    /* obtain handles to system task arguments */
+    arg_iterator = vpi_iterate(vpiArgument, systf_handle);
+    if (arg_iterator == NULL) {
+        vpi_printf("ERROR: $ivl_string_method$to_vec requires 2 arguments\n");
+        vpi_control(vpiFinish, 0);
+        return 0;
+    }
+
+    /* check the type of object in system task arguments */
+    arg_handle = vpi_scan(arg_iterator);
+    for(int i = 0; i < 2; ++i) {
+        arg_type[i] = vpi_get(vpiType, arg_handle);
+        arg_handle = vpi_scan(arg_iterator);
+    }
+
+    if (arg_handle != NULL) {       /* are there more arguments? */
+        vpi_printf("ERROR: $ivl_string_method$to_vec can only have 2 arguments\n");
+        vpi_free_object(arg_iterator);
+        vpi_control(vpiFinish, 0);
+        return 0;
+    }
+
+    if ((arg_type[0] != vpiStringVar) ||
+        (arg_type[1] != vpiNet && arg_type[1] != vpiReg)) {
+        vpi_printf("ERROR: $ivl_string_method$to_vec value arguments must be a string and a net or reg\n");
+        vpi_free_object(arg_iterator);
+        vpi_control(vpiFinish, 0);
+        return 0;
+    }
+
+    return 0;
+}
+
+static PLI_INT32 to_vec_calltf(ICARUS_VPI_CONST PLI_BYTE8*name)
+{
+      (void)name; /* Parameter is not used. */
+
+      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
+      vpiHandle argv, str, vec;
+      s_vpi_value str_val;
+      s_vpi_vecval*vec_val;
+
+      /* Fetch arguments */
+      argv = vpi_iterate(vpiArgument, callh);
+      assert(argv);
+      str = vpi_scan(argv);
+      assert(str);
+      vec = vpi_scan(argv);
+      assert(vec);
+      vpi_free_object(argv);
+
+      int str_size = vpi_get(vpiSize, str);
+      int vec_size = vpi_get(vpiSize, vec);
+      if(str_size <= 0) {
+	    vpi_printf("ERROR: Cannot cast empty string");
+            assert(0);
+      }
+
+      if(vec_size != str_size * 8) {
+	    vpi_printf("ERROR: String and vector size do not match");
+            assert(0);
+      }
+
+      str_val.format = vpiStringVal;
+      vpi_get_value(str, &str_val);
+      assert(str_val.value.str);
+
+      /* Conversion part */
+      int vec_number = ceil((double)str_size / sizeof(PLI_INT32));
+      vec_val = calloc(vec_number, sizeof(s_vpi_vecval));
+      PLI_BYTE8*str_ptr = &str_val.value.str[str_size - 1];
+
+      /* We have to reverse the order of string, no memcpy here */
+      for(int i = 0; i < vec_number; ++i) {
+	    int copy_size = str_size > (int)sizeof(PLI_INT32) ?
+                                    (int)sizeof(PLI_INT32) : str_size;
+
+            /* Clear the part responsible for X & Z values */
+	    memset(&vec_val[i].bval, 0x00, sizeof(PLI_INT32));
+	    PLI_BYTE8*dest = (PLI_BYTE8*)&vec_val[i].aval;
+
+	    for(int j = 0; j < copy_size; ++j)
+		*dest++ = *str_ptr--;
+
+	    str_size -= copy_size;
+      }
+
+      str_val.format = vpiVectorVal;
+      str_val.value.vector = vec_val;
+      vpi_put_value(vec, &str_val, 0, vpiNoDelay);
+
+      free(vec_val);
+
+      return 0;
+}
+
 void v2009_string_register(void)
 {
       s_vpi_systf_data tf_data;
@@ -89,4 +204,14 @@ void v2009_string_register(void)
       tf_data.user_data = "$ivl_string_method$len";
       res = vpi_register_systf(&tf_data);
       vpip_make_systf_system_defined(res);
+
+      tf_data.type      = vpiSysTask;
+      tf_data.sysfunctype = 0;
+      tf_data.tfname    = "$ivl_string_method$to_vec";
+      tf_data.calltf    = to_vec_calltf;
+      tf_data.compiletf = to_vec_compiletf;
+      tf_data.sizetf    = 0;
+      tf_data.user_data = "$ivl_string_method$to_vec";
+      res = vpi_register_systf(&tf_data);
+      vpip_make_systf_system_defined(res);
 }