ghw/ghwdump.c

   1 /* Display a GHDL Wavefile for debugging.
   2   Copyright (C) 2005 Tristan Gingold
   3
   4   This program is free software: you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation, either version 2 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program.  If not, see <gnu.org/licenses>.
  16 */
  17
  18 #include <assert.h>
  19 #include <stdint.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24
  25 #include "libghw.h"
  26
  27 static const char *progname;
  28 void
  29 usage (void)
  30 {
  31   printf ("usage: %s [OPTIONS] FILEs...\n", progname);
  32   printf ("Options are:\n"
  33           " -t  display types\n"
  34           " -h  display hierarchy\n"
  35           " -H  display hierarchy with full pathnames\n"
  36           " -T  display time\n"
  37           " -s  display signals (and time)\n"
  38           " -S  display strings\n"
  39           " -f  <lst> list of signals to display (default: all, example: -f "
  40           "1,3,5-7,21-33)\n"
  41           " -l  display list of sections\n" " -v  verbose\n");
  42 }
  43
  44 static void
  45 add_single_signal (int **signalSet, int *nbSignals, int signal)
  46 {
  47   assert (NULL != signalSet);
  48   assert (NULL != nbSignals);
  49   assert (0 <= nbSignals[0]);
  50   assert (0 <= signal);
  51
  52   int newSize = (1 + nbSignals[0]);
  53   /*printf("adding signal %6d set of signals to display\n", signal); */
  54   signalSet[0] = (int *) realloc (signalSet[0], newSize * sizeof (int));
  55   signalSet[0][nbSignals[0]] = signal;
  56   nbSignals[0] = newSize;
  57 }
  58
  59 static void
  60 add_signal_range (int **signalSet, int *nbSignals, const char *s,
  61                   const char *e)
  62 {
  63
  64   int i;
  65   int rangeSize;
  66   int rangeEnd = -1;
  67   int rangeStart = -1;
  68   int bytesMatched = -1;
  69   int expected = ((e - s) - 1);
  70   int itemsMatched =
  71     sscanf (s, "%d-%d%n", &rangeStart, &rangeEnd, &bytesMatched);
  72   if (2 == itemsMatched && expected == bytesMatched)
  73     {
  74       if (rangeEnd < rangeStart)
  75         {
  76           int t = rangeEnd;
  77           rangeEnd = rangeStart;
  78           rangeStart = t;
  79         }
  80     }
  81   else
  82     {
  83       itemsMatched = sscanf (s, "%d%n", &rangeStart, &bytesMatched);
  84       if (1 == itemsMatched && expected == bytesMatched)
  85         {
  86           if (0 <= rangeStart)
  87             {
  88               rangeEnd = rangeStart;
  89             }
  90         }
  91     }
  92
  93   rangeSize = (rangeEnd - rangeStart);
  94   if (rangeEnd < 0 || rangeStart < 0 || rangeSize < 0)
  95     {
  96       fprintf (stderr,
  97                "incorrect signal range specification\"%s\" found in "
  98                "command line, aborting\n", s);
  99       exit (1);
 100     }
 101
 102   for (i = rangeStart; i <= rangeEnd; ++i)
 103     {
 104       add_single_signal (signalSet, nbSignals, i);
 105     }
 106 }
 107
 108 static void
 109 add_signals (int **signalSet, int *nbSignals, const char *arg)
 110 {
 111   int c = -1;
 112   const char *e;
 113   const char *s = e = arg;
 114   while (0 != c)
 115     {
 116       c = *(e++);
 117       if (',' == c || 0 == c)
 118         {
 119           add_signal_range (signalSet, nbSignals, s, e);
 120           s = e;
 121         }
 122     }
 123 }
 124
 125 static void
 126 disp_string_table (struct ghw_handler *hp)
 127 {
 128   int i;
 129   printf ("String table:\n");
 130
 131   for (i = 1; i < hp->nbr_str; i++)
 132     printf (" %s\n", hp->str_table[i]);
 133 }
 134
 135 int
 136 main (int argc, char **argv)
 137 {
 138   int i;
 139   int flag_disp_types;
 140   int flag_disp_hierarchy;
 141   int flag_disp_time;
 142   int flag_disp_signals;
 143   int flag_disp_strings;
 144   int flag_full_names;
 145   int flag_list;
 146   int flag_verbose;
 147   int nb_signals;
 148   int *signal_set;
 149   int filter_done;
 150   int eof;
 151   enum ghw_sm_type sm;
 152
 153   progname = argv[0];
 154   flag_disp_types = 0;
 155   flag_disp_hierarchy = 0;
 156   flag_full_names = 0;
 157   flag_disp_time = 0;
 158   flag_disp_signals = 0;
 159   flag_disp_strings = 0;
 160   flag_list = 0;
 161   flag_verbose = 0;
 162   nb_signals = 0;
 163   signal_set = NULL;
 164   filter_done = 0;
 165
 166   /* Disp help if there is only an help option.  */
 167   if (argc == 2
 168       && (strcmp (argv[1], "--help") == 0 || strcmp (argv[1], "-h") == 0))
 169     {
 170       usage ();
 171       exit (0);
 172     }
 173
 174   while (1)
 175     {
 176       int c;
 177
 178       c = getopt (argc, argv, "thHTsSlvf:");
 179       if (c == -1)
 180         break;
 181       switch (c)
 182         {
 183         case 't':
 184           flag_disp_types = 1;
 185           break;
 186         case 'h':
 187           flag_disp_hierarchy = 1;
 188           break;
 189         case 'H':
 190           flag_disp_hierarchy = 1;
 191           flag_full_names = 1;
 192           break;
 193         case 'T':
 194           flag_disp_time = 1;
 195           break;
 196         case 's':
 197           flag_disp_signals = 1;
 198           flag_disp_time = 1;
 199           break;
 200         case 'S':
 201           flag_disp_strings = 1;
 202           break;
 203         case 'f':
 204           add_signals (&signal_set, &nb_signals, optarg);
 205           break;
 206         case 'l':
 207           flag_list = 1;
 208           break;
 209         case 'v':
 210           flag_verbose++;
 211           break;
 212         default:
 213           usage ();
 214           exit (2);
 215         }
 216     }
 217
 218   if (optind >= argc)
 219     {
 220       usage ();
 221       return 1;
 222     }
 223
 224   for (i = optind; i < argc; i++)
 225     {
 226       struct ghw_handler h;
 227       struct ghw_handler *hp = &h;
 228
 229       hp->flag_verbose = flag_verbose;
 230
 231       if (ghw_open (hp, argv[i]) != 0)
 232         {
 233           fprintf (stderr, "cannot open ghw file %s\n", argv[i]);
 234           return 1;
 235         }
 236       if (flag_list)
 237         {
 238           while (1)
 239             {
 240               const char *section_name;
 241               int section;
 242
 243               section = ghw_read_section (hp);
 244               if (section == -2)
 245                 {
 246                   printf ("eof of file\n");
 247                   break;
 248                 }
 249               else if (section < 0)
 250                 {
 251                   printf ("Error in file\n");
 252                   break;
 253                 }
 254               else if (section == 0)
 255                 {
 256                   printf ("Unknown section\n");
 257                   break;
 258                 }
 259               section_name = ghw_sections[section].name;
 260               printf ("Section %s\n", section_name);
 261               if ((*ghw_sections[section].handler) (hp) < 0)
 262                 break;
 263
 264               if (flag_disp_strings && strcmp (section_name, "STR") == 0)
 265                 disp_string_table (hp);
 266               else if (flag_disp_types && strcmp (section_name, "TYP") == 0)
 267                 ghw_disp_types (hp);
 268             }
 269         }
 270       else
 271         {
 272           if (ghw_read_base (hp) < 0)
 273             {
 274               fprintf (stderr, "cannot read ghw file\n");
 275               return 2;
 276             }
 277           if (flag_disp_types)
 278             ghw_disp_types (hp);
 279           if (flag_disp_hierarchy)
 280             {
 281               hp->flag_full_names = flag_full_names;
 282               ghw_disp_hie (hp, hp->hie);
 283             }
 284
 285 #if 1
 286           sm = ghw_sm_init;
 287           eof = 0;
 288           while (!eof)
 289             {
 290               switch (ghw_read_sm (hp, &sm))
 291                 {
 292                 case ghw_res_snapshot:
 293                 case ghw_res_cycle:
 294                   if (flag_disp_time)
 295                     printf ("Time is " GHWPRI64 " fs\n", hp->snap_time);
 296                   if (flag_disp_signals)
 297                     {
 298                       if (!filter_done)
 299                         {
 300                           ghw_filter_signals (hp, signal_set, nb_signals);
 301                           filter_done = 1;
 302                         }
 303                       ghw_disp_values (hp);
 304                     }
 305                   break;
 306                 case ghw_res_eof:
 307                   eof = 1;
 308                   break;
 309                 default:
 310                   abort ();
 311                 }
 312             }
 313
 314 #else
 315           if (ghw_read_dump (hp) < 0)
 316             {
 317               fprintf (stderr, "error in ghw dump\n");
 318               return 3;
 319             }
 320 #endif
 321         }
 322       ghw_close (&h);
 323     }
 324   return 0;
 325 }