vpi/vcd_priv.c

   1 /*
   2  * Copyright (c) 2003 Stephen Williams (steve@icarus.com)
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  18  */
  19 #ifdef HAVE_CVS_IDENT
  20 #ident "$Id: vcd_priv.c,v 1.6 2004/10/04 01:10:58 steve Exp $"
  21 #endif
  22
  23 # include  "vpi_config.h"
  24 # include  "vcd_priv.h"
  25 # include  <stdio.h>
  26 # include  <stdlib.h>
  27 # include  <string.h>
  28 # include  <assert.h>
  29 #ifdef HAVE_MALLOC_H
  30 # include  <malloc.h>
  31 #endif
  32 # include  <ctype.h>
  33 # include  "stringheap.h"
  34
  35 int is_escaped_id(const char *name)
  36 {
  37       int lp;
  38
  39       assert(name);
  40         /* The first digit must be alpha or '_' to be a normal id. */
  41       if (isalpha(name[0]) || name[0] == '_') {
  42             for (lp=1; name[lp] != '\0'; lp++) {
  43                     /* If this digit is not alpha-numeric or '_' we have
  44                      * an escaped identifier. */
  45                   if (!(isalnum(name[lp]) || name[lp] == '_')) {
  46                         return 1;
  47                   }
  48             }
  49               /* We looked at all the digits, so this is a normal id. */
  50             return 0;
  51       }
  52       return 1;
  53 }
  54
  55 struct stringheap_s name_heap = {0, 0};
  56
  57 struct vcd_names_s {
  58       const char *name;
  59       struct vcd_names_s *next;
  60 };
  61
  62 void vcd_names_add(struct vcd_names_list_s*tab, const char *name)
  63 {
  64       struct vcd_names_s *nl = (struct vcd_names_s *)
  65             malloc(sizeof(struct vcd_names_s));
  66       assert(nl);
  67       nl->name = strdup_sh(&name_heap, name);
  68       nl->next = tab->vcd_names_list;
  69       tab->vcd_names_list = nl;
  70       tab->listed_names ++;
  71 }
  72
  73 static int vcd_names_compare(const void *s1, const void *s2)
  74 {
  75       const char *v1 = *(const char **) s1;
  76       const char *v2 = *(const char **) s2;
  77
  78       return strcmp(v1, v2);
  79 }
  80
  81 const char *vcd_names_search(struct vcd_names_list_s*tab, const char *key)
  82 {
  83       const char **v;
  84
  85       if (tab->vcd_names_sorted == 0)
  86             return 0;
  87
  88       v = (const char **) bsearch(&key,
  89                                   tab->vcd_names_sorted, tab->sorted_names,
  90                                   sizeof(const char *), vcd_names_compare );
  91
  92       return(v ? *v : NULL);
  93 }
  94
  95 void vcd_names_sort(struct vcd_names_list_s*tab)
  96 {
  97       if (tab->listed_names) {
  98             struct vcd_names_s *r;
  99             const char **l;
 100
 101             tab->sorted_names += tab->listed_names;
 102             tab->vcd_names_sorted = (const char **)
 103                   realloc(tab->vcd_names_sorted,
 104                           tab->sorted_names*(sizeof(const char *)));
 105             assert(tab->vcd_names_sorted);
 106
 107             l = tab->vcd_names_sorted + tab->sorted_names - tab->listed_names;
 108             tab->listed_names = 0;
 109
 110             r = tab->vcd_names_list;
 111             tab->vcd_names_list = 0x0;
 112
 113             while (r) {
 114                   struct vcd_names_s *rr = r;
 115                   r = rr->next;
 116                   *(l++) = rr->name;
 117                   free(rr);
 118             }
 119
 120             qsort(tab->vcd_names_sorted, tab->sorted_names,
 121                   sizeof(const char **), vcd_names_compare);
 122       }
 123 }
 124
 125
 126 /*
 127    Nexus Id cache
 128
 129    In structural models, many signals refer to the same nexus.
 130    Some structural models also have very many signals.  This cache
 131    saves nexus_id - vcd_id pairs, and reuses the vcd_id when a signal
 132    refers to a nexus that is already dumped.
 133
 134    The new signal will be listed as a $var, but no callback
 135    will be installed.  This saves considerable CPU time and leads
 136    to smalle VCD files.
 137
 138    The _vpiNexusId is a private (int) property of IVL simulators.
 139 */
 140
 141 struct vcd_id_s
 142 {
 143       const char *id;
 144       struct vcd_id_s *next;
 145       int nex;
 146 };
 147
 148 static inline unsigned ihash(int nex)
 149 {
 150       unsigned a = nex;
 151       a ^= a>>16;
 152       a ^= a>>8;
 153       return a & 0xff;
 154 }
 155
 156 static struct vcd_id_s **vcd_ids = 0;
 157
 158 const char *find_nexus_ident(int nex)
 159 {
 160       struct vcd_id_s *bucket;
 161
 162       if (!vcd_ids) {
 163             vcd_ids = (struct vcd_id_s **)
 164                   calloc(256, sizeof(struct vcd_id_s*));
 165             assert(vcd_ids);
 166       }
 167
 168       bucket = vcd_ids[ihash(nex)];
 169       while (bucket) {
 170             if (nex == bucket->nex)
 171                   return bucket->id;
 172             bucket = bucket->next;
 173       }
 174
 175       return 0;
 176 }
 177
 178 void set_nexus_ident(int nex, const char *id)
 179 {
 180       struct vcd_id_s *bucket;
 181
 182       assert(vcd_ids);
 183
 184       bucket = (struct vcd_id_s *) malloc(sizeof(struct vcd_id_s));
 185       bucket->next = vcd_ids[ihash(nex)];
 186       bucket->id = id;
 187       bucket->nex = nex;
 188       vcd_ids[ihash(nex)] = bucket;
 189 }
 190
 191 /* This is used by the compiletf routines to check if an argument
 192  * is numeric. */
 193 static void check_numeric_arg(vpiHandle arg, char *msg, PLI_BYTE8 *name)
 194 {
 195       assert(arg);
 196
 197       switch (vpi_get(vpiType, arg)) {
 198          case vpiConstant:
 199          case vpiParameter:
 200              /* String constants are invalid numeric values. */
 201            if (vpi_get(vpiConstType, arg) == vpiStringConst) {
 202                  vpi_mcd_printf(1, msg, name);
 203                  vpi_control(vpiFinish, 1);
 204            }
 205            break;
 206
 207            /* These have valid numeric values. */
 208          case vpiIntegerVar:
 209          case vpiMemoryWord:
 210          case vpiNet:
 211          case vpiRealVar:
 212          case vpiReg:
 213          case vpiTimeVar:
 214            break;
 215
 216          default:
 217              /* Anything else is not a numeric value. */
 218            vpi_mcd_printf(1, msg, name);
 219            vpi_control(vpiFinish, 1);
 220            break;
 221       }
 222 }
 223
 224 /* This is used by the compiletf routines to check if an argument
 225  * is a string value. */
 226 static void check_string_arg(vpiHandle arg, char *msg, PLI_BYTE8 *name)
 227 {
 228       assert(arg);
 229       PLI_INT32 ctype = 0;
 230
 231       switch (vpi_get(vpiType, arg)) {
 232          case vpiConstant:
 233          case vpiParameter:
 234              /* These must be a string or binary constant. */
 235            ctype = vpi_get(vpiConstType, arg);
 236            if (ctype != vpiStringConst && ctype != vpiBinaryConst) {
 237                  vpi_mcd_printf(1, msg, name);
 238                  vpi_control(vpiFinish, 1);
 239            }
 240            break;
 241
 242            /* These have valid string values. */
 243          case vpiIntegerVar:
 244          case vpiMemoryWord:
 245          case vpiNet:
 246          case vpiReg:
 247          case vpiTimeVar:
 248            break;
 249
 250          default:
 251              /* Anything else is not a string. */
 252            vpi_mcd_printf(1, msg, name);
 253            vpi_control(vpiFinish, 1);
 254            break;
 255       }
 256 }
 257
 258 /*
 259  * Since the compiletf routines are all the same they are located here,
 260  * so we only need a single copy.
 261  */
 262
 263 /* $dumpall does not take an argument. */
 264 PLI_INT32 sys_dumpall_compiletf(PLI_BYTE8 *name)
 265 {
 266       vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
 267       vpiHandle argv = vpi_iterate(vpiArgument, callh);
 268
 269       if (argv != 0) {
 270             vpi_mcd_printf(1, "ERROR: %s does not take an argument.\n", name);
 271             vpi_control(vpiFinish, 1);
 272       }
 273
 274       return 0;
 275 }
 276
 277 /* $dumpfile takes a single string argument. */
 278 PLI_INT32 sys_dumpfile_compiletf(PLI_BYTE8 *name)
 279 {
 280       vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
 281       vpiHandle argv = vpi_iterate(vpiArgument, callh);
 282
 283       /* Check that there is an argument and that it is a string. */
 284       if (argv == 0) {
 285             vpi_mcd_printf(1, "ERROR: %s requires an argument.\n", name);
 286             vpi_control(vpiFinish, 1);
 287             return 0;
 288       }
 289       check_string_arg(vpi_scan(argv), "ERROR: %s's argument must be a"
 290                                        " string.\n", name);
 291
 292       /* Check that there is only a single argument. */
 293       if (vpi_scan(argv) != 0) {
 294             vpi_mcd_printf(1, "ERROR: %s takes a single argument.\n", name);
 295             vpi_control(vpiFinish, 1);
 296             return 0;
 297       }
 298
 299       return 0;
 300 }
 301
 302 /* $dumpflush does not take an argument. */
 303 PLI_INT32 sys_dumpflush_compiletf(PLI_BYTE8 *name)
 304 {
 305       vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
 306       vpiHandle argv = vpi_iterate(vpiArgument, callh);
 307
 308       if (argv != 0) {
 309             vpi_mcd_printf(1, "ERROR: %s does not take an argument.\n", name);
 310             vpi_control(vpiFinish, 1);
 311       }
 312
 313       return 0;
 314 }
 315
 316 /* $dumplimit takes a single numeric argument. */
 317 PLI_INT32 sys_dumplimit_compiletf(PLI_BYTE8 *name)
 318 {
 319       vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
 320       vpiHandle argv = vpi_iterate(vpiArgument, callh);
 321
 322       /* Check that there is an argument and that it is numeric. */
 323       if (argv == 0) {
 324             vpi_mcd_printf(1, "ERROR: %s requires an argument.\n", name);
 325             vpi_control(vpiFinish, 1);
 326             return 0;
 327       }
 328       check_numeric_arg(vpi_scan(argv), "ERROR: %s's argument must be"
 329                                         " numeric.\n", name);
 330
 331       /* Check that there is only a single argument. */
 332       if (vpi_scan(argv) != 0) {
 333             vpi_mcd_printf(1, "ERROR: %s takes a single argument.\n", name);
 334             vpi_control(vpiFinish, 1);
 335             return 0;
 336       }
 337
 338       return 0;
 339 }
 340
 341 /* $dumpoff does not take an argument. */
 342 PLI_INT32 sys_dumpoff_compiletf(PLI_BYTE8 *name)
 343 {
 344       vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
 345       vpiHandle argv = vpi_iterate(vpiArgument, callh);
 346
 347       if (argv != 0) {
 348             vpi_mcd_printf(1, "ERROR: %s does not take an argument.\n", name);
 349             vpi_control(vpiFinish, 1);
 350       }
 351
 352       return 0;
 353 }
 354
 355 /* $dumpon does not take an argument. */
 356 PLI_INT32 sys_dumpon_compiletf(PLI_BYTE8 *name)
 357 {
 358       vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
 359       vpiHandle argv = vpi_iterate(vpiArgument, callh);
 360
 361       if (argv != 0) {
 362             vpi_mcd_printf(1, "ERROR: %s does not take an argument.\n", name);
 363             vpi_control(vpiFinish, 1);
 364       }
 365
 366       return 0;
 367 }
 368
 369 /* $dumpvars takes a variety of arguments. */
 370 PLI_INT32 sys_dumpvars_compiletf(PLI_BYTE8 *name)
 371 {
 372       vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
 373       vpiHandle argv = vpi_iterate(vpiArgument, callh);
 374       vpiHandle arg;
 375
 376       /* No arguments is OK, dump everything. */
 377       if (argv == 0)
 378             return 0;
 379
 380       /* The first argument is the numeric level. */
 381       check_numeric_arg(vpi_scan(argv), "ERROR: %s's first argument must be"
 382                                         " numeric.\n", name);
 383
 384       /* The rest of the arguments are either a module or a variable. */
 385       while ((arg=vpi_scan(argv)) != NULL) {
 386         switch(vpi_get(vpiType, arg)) {
 387           /* The module types. */
 388           case vpiModule:
 389           case vpiTask:
 390           case vpiFunction:
 391           case vpiNamedBegin:
 392           case vpiNamedFork:
 393           /* The variable types. */
 394           case vpiNet:
 395           case vpiReg:
 396           case vpiMemoryWord:
 397           case vpiIntegerVar:
 398           case vpiTimeVar:
 399           case vpiRealVar:
 400             break;
 401           default:
 402             vpi_mcd_printf(1, "ERROR: %s cannot dump a %s.\n",
 403                            name, vpi_get_str(vpiType, arg));
 404             vpi_control(vpiFinish, 1);
 405         }
 406       }
 407
 408       return 0;
 409 }
 410