vcddiff.cpp

// SPDX-FileCopyrightText: 1991-2004 Pragmatic C Software Corp.
// SPDX-FileCopyrightText: 2015-2026 Wilson Snyder
// SPDX-License-Identifier: GPL-3.0
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3 of the License, or (at your
// option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA, 02111-1307.

#define VERSION "2026-02-23-veripool"

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <ctype.h>
#include <time.h>
#include <string.h>
#include <assert.h>
#include "vcddiff.h"

static int get_token(FILE*, char*);
static void read_to_end(FILE*);
static char timescale(FILE*, int*);
static void add_signal(char*, char*, unsigned int, int, int);
static int get_var_type(char*);
static void variable(FILE*, char*);
static void alloc_sig_mem();
static int get_vkeywrd(char*);
static long get_lines(FILE*, int*, int*, char*);
static void print_signal_info(signal_t*, signal_t*, vtime_t, vtime_t, bool);
static void print_scalar_state(signal_t*, signal_t*, vtime_t, vtime_t, char, char, bool);
static void print_vector_state(signal_t*, signal_t*, vtime_t, vtime_t, char*, char*, bool);
static void print_scalar_edge(signal_t*, signal_t*, vtime_t, vtime_t, char, char, bool);
static void print_edges(signal_t*, char*, int, int, char);
static void print_vector_edge(signal_t*, signal_t*, vtime_t, vtime_t, char*, char*, bool);
static int get_nxt_chg(FILE*, char*, int*, int*, char*, vtime_t*, bool);
static vtime_t get_time_diffs(FILE*, FILE*, char*, char*, long, long, vtime_t, vtime_t, bool);
static void print_map();
static void compare_types(char*, char*, signal_t*, signal_t*);
static bool map_var_names(char*, char*);
static void run_diffs(FILE*, FILE*, char*, char*, long, long);
static void print_header();
static void print_help();
static void edge_space(int, int, bool);

// globals
static int line_num1G;  // cur position of file1
static int line_num2G;  // cur position of file2
static char curmodG[1000];  // cur mod hier name
static FILE* file1G;  // to check if it is the first file
static bool state_flagG;  // print edges or states
static bool wrap_flagG;  // print edges or states
static bool extended_flagG;  // parse extended VCD format
static signal_t** sig_int1G;  // int codes for file 1
static signal_t** sig_int2G;  // int codes for file 2
static int* fd1_to_fd2_mapG;  // mappings from one file to the other
static int* fd2_to_fd1_mapG;
static int max_codeG;  // max code so sig_int? is large enough
static char scopesG[MAXSCOPES][MAXSIG];  // scope of mods
static int quit_flagG;  // flag to quit
static bool next_listG;  // to signal the next list of signals
signal_t* sig1_hdG;  // the head of the first file of signals
signal_t* sig2_hdG;  // the head of the second file of signals
signal_t* lastsigG;  // mark the last signal of the file

// signal to code from dinotrace wave viewer www.veripool.org/dinotrace
// extended vcd converted, removes '<'
#define VERILOG_ID_TO_POS(_code_) \
   strpbrk(_code_, "<") && extended_flagG \
      ? atoi(_code_ + 1) \
      : (_code_[0] \
            ? ((_code_[0] - 32) \
               + 94 \
                    * (_code_[1] \
                          ? ((_code_[1] - 32) \
                             + 94 \
                                  * (_code_[2] ? ((_code_[2] - 32) \
                                                  + 94 * (_code_[3] ? ((_code_[3] - 32)) : 0)) \
                                               : 0)) \
                          : 0)) \
            : 0)

#define VERILOG_POS_TO_SIG1(_pos_) \
   (((unsigned)(_pos_) < (unsigned)max_codeG) ? sig_int1G[(_pos_)] : 0)

#define VERILOG_POS_TO_SIG2(_pos_) \
   (((unsigned)(_pos_) < (unsigned)max_codeG) ? sig_int2G[(_pos_)] : 0)

// **********************************************************************

// get a new token from the file fp, and place in token, return the length
static int get_token(FILE* fp, char* token) {
   int i = 0;
   int c;
   while ((c = fgetc(fp)) != EOF) {
      if (isspace(c)) {
         if (c == '\n') {
            if (fp == file1G)
               line_num1G++;
            else
               line_num2G++;
         }
         continue;
      }
      break;
   }

   if (c == EOF) return EOF;
   token[i++] = c;

   while (!isspace(c = fgetc(fp)) && i < MAXTOKSIZE) {
      if (c == EOF)
         return EOF;
      else
         token[i++] = c;
   }

   if (i >= MAXTOKSIZE - 1) {
      printf("Token too long.\n");
      exit(1);
   }

   if (c == '\n') {
      if (fp == file1G)
         line_num1G++;
      else
         line_num2G++;
   }

   token[i] = '\0';
   return i;
}

// read the file until an $end is reached
static void read_to_end(FILE* fp) {
   static char token[MAXTOKSIZE];

   while (get_token(fp, token) != EOF) {
      if (!strncmp(token, "$end", 4)) return;
   }
}

// get the timescale information for comparison return char of units, and
// the number 1, 10, 100 in tnum
static char timescale(FILE* fp, int* tnum) {
   static char token[MAXTOKSIZE * 2];  // Needs to hold 2 tokens because of the concatenation.
   static char tmp[MAXTOKSIZE];
   char* tok;

   int toklen = get_token(fp, token);
   if (toklen == EOF) {
      printf("*** ERROR Invalid timescale specification.\n");
      exit(1);
   }
   assert(toklen < MAXTOKSIZE);

   tok = token;
   // AIV 02/04/03 there can be a space between 1 ns, not always 1ns
   int i;
   for (i = 0; i < toklen; i++) {
      if (!isdigit(token[i])) break;
   }
   if (i == toklen) {
      get_token(fp, tmp);
      strcat(token, tmp);
   }

   *tnum = atoi(tok);

   if (*tnum != 1 && *tnum != 10 && *tnum != 100) {
      printf("*** ERROR-time number(%d) in timescale on line %d is illegal - assuming 1\n", *tnum,
             (fp == file1G) ? line_num1G : line_num2G);
      *tnum = 1;
   }

   while (isdigit(*tok)) tok++;
   if (!*tok) get_token(fp, token);

   switch (*tok) {
   case 's':
   case 'm':
   case 'u':
   case 'n':
   case 'p':
   case 'f': return *tok;
   default:
      printf("*** ERROR-illegal character(%c) in timescale on line %d\n", *tok,
             (fp == file1G) ? line_num1G : line_num2G);
      return 0;
   }
}

// add a new signal to the list, init values signal name, identifies
// the code to index the array of signals, and the number of bits, if
// bits is 1 it is scalar
static void add_signal(char* signame, char* ident, unsigned int code, int bits, int type) {
   char* cp;
   // get rid of scapes before and after
   while (isspace(*signame)) signame++;
   for (cp = signame + strlen(signame) - 1; cp >= signame && isspace(*cp); cp--) *cp = '\0';

   signal_t* newsig = (signal_t*)malloc(sizeof(signal_t));
   newsig->sig_code = code;
   newsig->ident = (char*)malloc(strlen(ident) + 1);
   // init values to x's
   newsig->state = '?';
   newsig->type = type;
   newsig->in_both = true;
   newsig->size = bits;
   newsig->next = nullptr;

   if (type == REAL) {
      // TODO what about large reals ???
      newsig->vector = (char*)malloc(REALSIZE);
      newsig->vector[0] = '0';
      newsig->vector[1] = '\0';
   } else if (bits > 1) {
      newsig->vector = (char*)malloc(bits + 2);
      newsig->vector[bits] = '\0';
      bits--;
      for (; bits >= 0; bits--) newsig->vector[bits] = '?';
   } else {
      newsig->vector = nullptr;
   }

   // signal not found so print first diff
   newsig->found = false;
   strcpy(newsig->ident, ident);
   // link signals for hash setup and mapping
   if (lastsigG) lastsigG->next = newsig;

   if (!sig1_hdG) sig1_hdG = newsig;

   if (next_listG && !sig2_hdG) sig2_hdG = newsig;

   lastsigG = newsig;
   newsig->signame = (char*)malloc(strlen(signame) + 1);
   strcpy(newsig->signame, signame);
   max_codeG = MAX((unsigned)max_codeG, code + 1);
}

// dump variable types must be kept in alphabetical order
// Values must match the var type #defines in vcddiff.h
static variable_types_t var_types[]
   = {{"bit", BIT},  // GTKWave's fst2vcd
      {"byte", BYTE},  // GTKWave's fst2vcd
      {"event", EVENT},
      {"int", INT},  // GTKWave's fst2vcd
      {"integer", INTEGER},
      {"logic", LOGIC},  // GTKWave's fst2vcd
      {"longint", LONGINT},  // GTKWave's fst2vcd
      {"parameter", PARAMETER},
      {"port", PORT},  // GTKWave's fst2vcd
      {"real", REAL},
      {"real_parameter", REAL},  // GTKWave's fst2vcd, handle as if real
      {"realtime", REALTIME},  // GTKWave's fst2vcd
      {"reg", REG},
      {"shortint", SHORTINT},  // GTKWave's fst2vcd
      {"supply0", SUPPLY0},
      {"supply1", SUPPLY1},
      {"time", TIME},
      {"tri", TRI},
      {"tri0", TRI0},
      {"tri1", TRI1},
      {"triand", TRIAND},
      {"trior", TRIOR},
      {"trireg", TRIREG},
      {"wand", WAND},
      {"wire", WIRE},
      {"wor", WOR}};

#define VARTYPE (sizeof(var_types) / sizeof(variable_types_t))

static int get_var_type(char* tstr) {
   int l = 0;
   int h = VARTYPE - 1;
   for (;;) {
      int m = (l + h) / 2;
      int cv;
      if ((cv = strcmp(var_types[m].vnam, tstr)) == 0) return var_types[m].vnum;
      if (cv < 0)
         l = m + 1;
      else
         h = m - 1;
      if (h < l) break;
   }
   return -1;
}

// var line so add a new signal with its identifier
static void variable(FILE* fp, char* file_name) {
   char signame[MAXSIG];
   char ident[MAXIDLENGTH];
   static char token[MAXTOKSIZE];

   // type, size
   {
      int len = get_token(fp, token);
      if (len == EOF) {
         printf("ERROR - EOF during declaration of variable.  Aborting.\n");
         exit(1);
      }
   }
   // most ofter a reg otherwise do a search
   char type;
   if (strncmp(token, "reg", 3) == 0)
      type = REG;
   else
      type = get_var_type(token);

   if (type < 0 || type > UNDEFINED) {
      type = UNDEFINED;
      printf("Error- Unknown variable type %s\n", token);
   }
   // according to the std ieee verilog
   // if it is port is an evcd (port not allowed in vcd for signal declaration)
   if (extended_flagG == false && strncmp(token, "port", 4) == 0) {
      extended_flagG = true;

   } else if (extended_flagG && strncmp(token, "port", 4) != 0) {
      // parsing an evcd file but encountered in a non standard definition
      printf("Error - Unknown variable type for EVCD standard %s\n", token);
   }
   // get number of bits
   // AIV TODO error recovery should be used here for invalid tokens
   // if a $var line is short vars (starts with a '$') rewind, print
   // message and return
   {
      int len = get_token(fp, token);
      if (len == EOF) {
         printf("ERROR - EOF during declaration of variable.  Aborting.\n");
         exit(1);
      }
   }
   int bits = atoi(token);

   if (bits < 0) {
      printf("Negative size illegal on line %d of %s\n", (fp == file1G) ? line_num1G : line_num2G,
             file_name);
      return;
   }

   // identifier
   get_token(fp, token);

   memset(
      ident, 0,
      sizeof(ident));  // ensure that ident is null-terminated, even it is too long to fit in ident
   strncpy(ident, token, sizeof(ident) - 1);

   for (char* s = token; *s; s++) {
      if (!isprint(*s)) {
         printf("*** ERROR-illegal character(%c) in signal name on line %d\n", *s,
                (fp == file1G) ? line_num1G : line_num2G);
         exit(1);
      }
   }

   // variable name
   get_token(fp, token);
   memset(signame, 0, MAXSIG);
   strncpy(signame, curmodG, MAXSIG - 1);
   {
      int available = MAXSIG - 1 - strlen(signame);
      if (available > 0) { strncat(signame, token, available); }
   }

   get_token(fp, token);
   // if there is a space between the var name and the range concat it
   // to the name
   if (token[0] != '$') {
      int available = MAXSIG - 1 - strlen(signame);
      if (available > 0) { strncat(signame, token, available); }
      get_token(fp, token);
      if (token[0] != '$') {
         printf("ERROR - missing $end for %s\n", signame);
         exit(1);
      }
   }

   add_signal(signame, ident, VERILOG_ID_TO_POS(ident), bits, type);
}

// setup memory for the hash of signals, which is the max of all signals,
// then setup up arrays according to the signal's code index
static void alloc_sig_mem() {
   sig_int1G = (signal_t**)calloc(sizeof(signal_t*), (max_codeG + 1));
   for (signal_t* sig = sig1_hdG; sig; sig = sig->next) sig_int1G[sig->sig_code] = sig;

   sig_int2G = (signal_t**)calloc(sizeof(signal_t*), (max_codeG + 1));
   for (signal_t* sig = sig2_hdG; sig; sig = sig->next) sig_int2G[sig->sig_code] = sig;
}

// dump file keywords must be kept in alphabetical order
static variable_types_t vkeywds[]
   = {{"attrbegin", V_ATTRBEGIN},  // GTKWave
      {"comment", V_COMMENT},       {"date", V_DATE},   {"end", V_END},
      {"enddefinitions", V_ENDDEF}, {"scope", V_SCOPE}, {"timescale", V_TIMESCALE},
      {"upscope", V_UPSCOPE},       {"var", V_VAR},     {"version", V_VERSION}};

#define VKEYWDS (sizeof(vkeywds) / sizeof(variable_types_t))

// search for verilog keywords
static int get_vkeywrd(char* tstr) {
   // start at $end
   int l = -2;
   int h = VKEYWDS - 1;
   for (;;) {
      int m = (l + h) / 2;
      int cv;
      if (m < 0) return EOF;
      if ((cv = strcmp(vkeywds[m].vnam, tstr)) == 0) return vkeywds[m].vnum;
      if (cv < 0)
         l = m + 1;
      else
         h = m - 1;
      if (h < l) break;
   }
   return EOF;
}

static void make_curmod(int level) {
   char sep[2];
   sep[0] = '.';
   sep[1] = '\0';

   strcpy(curmodG, scopesG[0]);
   strcat(curmodG, sep);

   for (int i = 1; i < level; i++) {
      strcat(curmodG, scopesG[i]);
      strcat(curmodG, sep);
   }
}

// process all the lines until $enddef is reached, determines all variable
// names, seperated by a '.' between scopes, place the timescale number
// and units, and return the file location to start processing diffs
static long get_lines(FILE* fp, int* units, int* tnum, char* file_name) {
   // 1+because of the line with "tok++", which would otherwise make the buffer
   // smaller than expected by get_token
   static char token[MAXTOKSIZE + 1];

   int level = 0;
   *units = 1;
   *tnum = 1;

   char* tok;
   while (get_token(fp, token) != EOF) {
      tok = token;
      if (tok[0] != '$') {
         printf("***ERROR Unknown token '%s' on line %d of %s\n", tok,
                (fp == file1G) ? line_num1G : line_num2G, file_name);
         continue;
      }
      tok++;

      switch (get_vkeywrd(tok)) {
      case V_END: break;

      case V_VAR: variable(fp, file_name); break;

      case V_UPSCOPE:
         if (level > 0) level--;
         make_curmod(level);
         break;

      case V_SCOPE:
         get_token(fp, tok);
         get_token(fp, tok);

         if (level < MAXSCOPES) {
            strcpy(scopesG[level], tok);
            level++;
            make_curmod(level);
         } else {
            printf("*** ERROR-exceeded max scope levels %d\n", level);
            exit(0);
         }
         break;
      case V_ATTRBEGIN:
      case V_COMMENT:
      case V_DATE:
      case V_VERSION: read_to_end(fp); break;

      case V_TIMESCALE: *units = timescale(fp, tnum); break;

      case V_ENDDEF:
         next_listG = true;
         lastsigG = nullptr;
         return ftell(fp);

      default:
         printf("Unknown command '%s' on line %d of %s\n", tok,
                (fp == file1G) ? line_num1G : line_num2G, file_name);
         break;
      }
   }
   return -1;
}

// print the diff signal information
static void print_signal_info(signal_t* sig1, signal_t* sig2, vtime_t time1, vtime_t time2,
                              bool isone) {
   if (time1 == time2) {
      if (sig1->sig_code == sig2->sig_code)
         printf("%s (%s) differs at time %lld\n", sig1->signame, sig1->ident, time1);
      else
         printf("%s (%s , %s) differs at time %lld\n", sig1->signame, sig1->ident, sig2->ident,
                time1);
      return;
   } else {
      if (sig1->sig_code == sig2->sig_code)
         printf("%c %s (%s) at time %lld next occurence at time %lld\n", isone ? '>' : '<',
                sig1->signame, sig1->ident, time1, time2);
      else
         printf("%c %s (%s, %s) at time %lld next occurence at time %lld\n", isone ? '>' : '<',
                sig1->signame, sig1->ident, sig2->ident, time1, time2);
      return;
   }
}

// print the scalar value
static void print_scalar_state(signal_t* sig1, signal_t* sig2, vtime_t time1, vtime_t time2,
                               char state1, char state2, bool isone) {
   if (time1 == time2) {
      sig1->found = true;
      sig2->found = true;
      if (state1 != state2) {
         print_signal_info(sig1, sig2, time1, time2, isone);
         printf("\t%c\n\t%c\n", state1, state2);
         return;
      }
   } else {
      print_signal_info(sig1, sig2, time1, time2, isone);
      printf("%c #%lld \t%c\n", isone ? '>' : '<', time1, state1);
      printf("%c #%lld \t%c\n", isone ? '>' : '<', time2, state2);
      return;
   }
}

// print the vector value
static void print_vector_state(signal_t* sig1, signal_t* sig2, vtime_t time1, vtime_t time2,
                               char* sval1, char* sval2, bool isone) {
   const int size1 = strlen(sval1);
   const int size2 = strlen(sval2);
   if (time1 == time2) {
      sig1->found = true;
      sig2->found = true;
      if (strcmp(sval1, sval2) != 0) {
         print_signal_info(sig1, sig2, time1, time2, isone);
         if (size1 == size2)
            printf("\t%s\n\t%s\n", sval1, sval2);
         else {
            if (size1 > size2) {
               printf("\t%s\n\t", sval1);
               for (int i = 0; i < size1 - size2; i++) putc(' ', stdout);
               printf("%s\n", sval2);
            } else {
               printf("\t");
               for (int i = 0; i < size2 - size1; i++) putc(' ', stdout);
               printf("%s\n\t%s\n", sval1, sval2);
            }
         }
         return;
      }
   } else {
      print_signal_info(sig1, sig2, time1, time2, isone);
      if (size1 == size2) {
         printf("%c #%lld \t%s\n", isone ? '>' : '<', time1, sval1);
         printf("%c #%lld \t%s\n", isone ? '>' : '<', time2, sval2);
      } else {
         if (size1 > size2) {
            printf("%c #%lld \t%s\n", isone ? '>' : '<', time1, sval1);
            printf("%c #%lld \t", isone ? '>' : '<', time2);
            for (int i = 0; i < size1 - size2; i++) putc(' ', stdout);
            printf("%s\n", sval2);
         } else {
            printf("%c #%lld \t", isone ? '>' : '<', time1);
            for (int i = 0; i < size2 - size1; i++) putc(' ', stdout);
            printf("%s\n", sval1);
            printf("%c #%lld \t%s\n", isone ? '>' : '<', time2, sval2);
         }
      }
   }
}

// print scalar edge value
static void print_scalar_edge(signal_t* sig1, signal_t* sig2, vtime_t time1, vtime_t time2,
                              char state1, char state2, bool isone) {
   if (time1 == time2) {
      sig1->found = true;
      sig2->found = true;
      if (state1 != state2) {
         print_signal_info(sig1, sig2, time1, time2, isone);

         if (sig1->state == state1)
            printf("\t(%c-)\n", state1);
         else
            printf("\t(%c%c)\n", sig1->state, state1);
         if (sig2->state == state2)
            printf("\t(%c-)\n", state2);
         else
            printf("\t(%c%c)\n", sig2->state, state2);
         return;
      }
   } else {
      print_signal_info(sig1, sig2, time1, time2, isone);

      if (sig1->state == state1)
         printf("%c #%lld \t(%c-)\n", isone ? '>' : '<', time1, state1);
      else
         printf("%c #%lld \t(%c%c)\n", isone ? '>' : '<', time1, sig1->state, state1);
      if (sig2->state == state2)
         printf("%c #%lld \t(%c-)\n", isone ? '>' : '<', time2, state2);
      else
         printf("%c #%lld \t(%c%c)\n", isone ? '>' : '<', time2, sig2->state, state2);
      return;
   }
}

// print the edge values
// sig - signal pointer
// sval - sval string value
// str_size - size of sval
// search - '<' or '>' if a search was performed otherwise 'n' for none
// this is needed for wrapping of the line
static void print_edges(signal_t* sig, char* sval, int str_size, int vec_size, char searchc) {
   // AIV 02/06/03 the print edges were wrong for different sizes
   // for example, b10 is now b101 at the next time
   // vector is the old value and sval is the new
   int min;
   if (str_size > vec_size)
      min = vec_size;
   else
      min = str_size;

   int tprint = 0;
   for (int i = 0; i < min; i++, tprint++) {
      if (sig->vector[i] == sval[i])
         printf(" (%c-)", sig->vector[i]);
      else
         printf(" (%c%c)", sig->vector[i], sval[i]);

      // only want to print 11 edges per line
      if (wrap_flagG && tprint != 0 && !(tprint % EDGE_PER_LINE)) {
         if (searchc != 'n')
            printf(" \\\n%c\t", searchc);
         else
            printf(" \\\n\t");
      }
   }
   if (str_size == vec_size) return;

   if (min == vec_size) {
      for (int i = min; i < str_size; i++, tprint++) {
         printf(" (?%c)", sval[i]);
         if (wrap_flagG && tprint != 0 && !(tprint % EDGE_PER_LINE)) {
            if (searchc != 'n')
               printf(" \\\n%c\t", searchc);
            else
               printf(" \\\n\t");
         }
      }
   } else {
      // if the first value is a '?', no need to print the rest
      // since it can only be '?' on the first value change
      if (sig->vector[0] != '?') {
         for (int i = min; i < vec_size; i++, tprint++) {
            printf(" (%c?)", sig->vector[i]);
            if (wrap_flagG && tprint != 0 && !(tprint % EDGE_PER_LINE)) {
               if (searchc != 'n')
                  printf(" \\\n%c\t", searchc);
               else
                  printf(" \\\n\t");
            }
         }
      }
   }
}

// add space so the vector edge valued line up correctly
static void edge_space(int size1, int size2, bool is_sigone) {
   int r;
   if (size1 == size2) return;
   if (is_sigone && size2 > size1) {
      int diff = (size2 - size1) * CHAR_PER_EDGE;
      if (wrap_flagG) {
         r = diff / EDGE_PER_LINE;
         if (r > 0) {
            r = (r * EDGE_PER_LINE);
            diff -= r;
            if (diff <= CHAR_PER_EDGE) diff = 0;
         }
      }
      for (int i = 0; i < diff; i++) putc(' ', stdout);
   }
   if (!is_sigone && size1 > size2) {
      int diff = (size1 - size2) * CHAR_PER_EDGE;
      if (wrap_flagG) {
         r = diff / EDGE_PER_LINE;
         if (r > 0) {
            r = (r * EDGE_PER_LINE);
            diff -= r;
            if (diff <= CHAR_PER_EDGE) diff = 0;
         }
      }
      for (int i = 0; i < diff; i++) putc(' ', stdout);
   }
}

// print vector edge
static void print_vector_edge(signal_t* sig1, signal_t* sig2, vtime_t time1, vtime_t time2,
                              char* sval1, char* sval2, bool isone) {
   int size1;
   int size2;
   int vsize1;
   int vsize2;
   int max1;
   int max2;

   if (time1 == time2) {
      sig1->found = true;
      sig2->found = true;

      if (strcmp(sval1, sval2) != 0) {

         if (sig1->type == REAL) {
            print_vector_state(sig1, sig2, time1, time2, sval1, sval2, isone);
            return;
         }

         print_signal_info(sig1, sig2, time1, time2, isone);
         printf("\t");

         size1 = strlen(sval1);
         vsize1 = sig1->vector ? strlen(sig1->vector) : 0;
         max1 = MAX(size1, vsize1);

         size2 = strlen(sval2);
         vsize2 = sig2->vector ? strlen(sig2->vector) : 0;
         max2 = MAX(size2, vsize2);

         edge_space(max1, max2, true);
         print_edges(sig1, sval1, size1, vsize1, 'n');
         if (wrap_flagG && sig1->size > EDGE_PER_LINE)
            printf("\n\n\t");
         else
            printf("\n\t");
         edge_space(max1, max2, false);
         print_edges(sig2, sval2, size2, vsize2, 'n');
         printf("\n");
         return;
      }
   } else {
      if (sig1->type == REAL) {
         print_vector_state(sig1, sig2, time1, time2, sval1, sval2, isone);
         return;
      }
      print_signal_info(sig1, sig2, time1, time2, isone);
      char dirc = isone ? '>' : '<';
      printf("%c #%lld \t", dirc, time1);

      size1 = strlen(sval1);
      vsize1 = sig1->vector ? strlen(sig1->vector) : 0;
      max1 = MAX(size1, vsize1);

      size2 = strlen(sval2);
      vsize2 = sig2->vector ? strlen(sig2->vector) : 0;
      max2 = MAX(size2, vsize2);

      edge_space(max1, max2, true);
      print_edges(sig1, sval1, size1, vsize1, dirc);
      printf("\n%c #%lld \t", dirc, time2);
      edge_space(max1, max2, false);
      print_edges(sig2, sval2, size2, vsize2, dirc);
      printf("\n");
      return;
   }
}

// get the next time change in the other file if there is one
static int get_nxt_chg(FILE* fp, char* fname, int* sigcode, int* bit, char* value, vtime_t* time,
                       bool isone) {
   char* line;
   char* separator;
   int token_length;
   static char token[MAXTOKSIZE];

   while (get_token(fp, token) != EOF) {
      line = token;

      switch (*line++) {
         // scalar cases
      case '0':
      case '1':
      case 'z':
      case 'Z':
      case 'x':
      case 'X':

         if (extended_flagG) {
            // check if it contains '<', if true parsing the eVCD
            separator = strpbrk(token, "<");  // get the separator
            if (!separator) {
               printf("Unknown Identifier not found '%s' in file %d '%s' on line %d\n", line,
                      isone ? 1 : 2, fname, isone ? line_num1G : line_num2G);
               continue;
            } else if (separator - line > 1) {
               // it is a vector
               line--;
               get_token(fp, token);
               strncpy(value, line, separator - line);
               *sigcode = VERILOG_ID_TO_POS(separator);
               if (isone) {
                  if (!VERILOG_POS_TO_SIG1(*sigcode)) {
                     printf("Unknown Identifier '%s' in file %d '%s' on line %d\n", line,
                            isone ? 1 : 2, fname, isone ? line_num1G : line_num2G);
                     continue;
                  }
               } else if (!VERILOG_POS_TO_SIG2(*sigcode)) {
                  printf("Unknown Identifier '%s' in file %d '%s' on line %d\n", line,
                         isone ? 1 : 2, fname, isone ? line_num1G : line_num2G);
                  continue;
               }
               return VECTOR;
            }
         }
         // otherwise vcd
         *bit = *(line - 1);
         *sigcode = VERILOG_ID_TO_POS(line);
         if (isone) {
            if (!VERILOG_POS_TO_SIG1(*sigcode)) {
               printf("Unknown Identifier '%s' in file %d '%s' on line %d\n", line, isone ? 1 : 2,
                      fname, isone ? line_num1G : line_num2G);
               continue;
            }
         } else if (!VERILOG_POS_TO_SIG2(*sigcode)) {
            printf("Unknown Identifier '%s' in file %d '%s' on line %d\n", line, isone ? 1 : 2,
                   fname, isone ? line_num1G : line_num2G);
            continue;
         }
         return SCALAR;
         break;
         // vector or real cases
      case 'b':
      case 'r':
         strncpy(value, line, MAXTOKSIZE);
         get_token(fp, token);
         *sigcode = VERILOG_ID_TO_POS(token);
         if (isone) {
            if (!VERILOG_POS_TO_SIG1(*sigcode)) {
               printf("Unknown Identifier '%s' in file %d '%s' on line %d\n", line, isone ? 1 : 2,
                      fname, isone ? line_num1G : line_num2G);
               continue;
            }
         } else if (!VERILOG_POS_TO_SIG2(*sigcode)) {
            printf("Unknown Identifier '%s' in file %d '%s' on line %d\n", line, isone ? 1 : 2,
                   fname, isone ? line_num1G : line_num2G);
            continue;
         }
         return VECTOR;
      case 'p':
         // pport_value 0_strength_component 1_strength_component identifier_code
         // parsing "port_value"
         strncpy(value, line, MAXTOKSIZE);
         // parsing "0_strength_component"
         token_length = get_token(fp, token);
         strncat(value, " ", 2);  // separate port value from strength
         strncat(value, token, token_length);
         // parsing "1_strength_component"
         token_length = get_token(fp, token);
         strncat(value, " ", 2);  // separate port value from strength
         strncat(value, token, token_length);
         get_token(fp, token);
         // parsing "identifier_code"
         *sigcode = VERILOG_ID_TO_POS(token);
         if (isone) {
            if (!VERILOG_POS_TO_SIG1(*sigcode)) {
               printf("Unknown Identifier '%s' in file %d '%s' on line %d\n", line, isone ? 1 : 2,
                      fname, isone ? line_num1G : line_num2G);
               continue;
            }
         } else if (!VERILOG_POS_TO_SIG2(*sigcode)) {
            printf("Unknown Identifier '%s' in file %d '%s' on line %d\n", line, isone ? 1 : 2,
                   fname, isone ? line_num1G : line_num2G);
            continue;
         }
         return VECTOR;  // fake vector if single bit
         // time change value
      case '#': *time = (vtime_t)atoll(line); return TIME;
      case '$':
         // AIV 02/03/03 need to read until $end for $comment
         if (!strcmp(line, "comment") || !strcmp(line, "dumpall")) read_to_end(fp);
         if (!strcmp(line, "dumpports") && extended_flagG)
            get_token(fp, token);  // skip dumpports keyword
         break;
      default:
         line--;
         printf("***ERROR Unknown token '%s' in file %d '%s' on line %d\n", line, isone ? 1 : 2,
                fname, isone ? line_num1G : line_num2G);
         // TODO shouldn't die here if possible
         exit(0);
         continue;
         break;
      }
   }
   return EOF;
}

// used to place the string back on the fp to be used later
static void restore(FILE* fp, char* str, int size) {
   {
      int r = ungetc(' ', fp);
      assert(r != EOF);
   }
   char* cp = &str[size - 1];

   for (int i = 0; i < size; i++, cp--) {
      int r = ungetc(*cp, fp);
      if (r == EOF) {
         // because ungetc implementations are not required to support
         // more than one call of it in a row, this sort of usage is
         // fundamentally flawed.
         printf("*** ERROR Failed using ungetc.  Aborting.\n");
         exit(1);
      }
   }
}

// return true if the next signal isn't the same, otherwise false
static bool peek_nxt_sig(FILE* fp, int sigcode1, bool isone) {
   static char tmp[MAXTOKSIZE], sig[MAXTOKSIZE];

   const int size1 = get_token(fp, tmp);
   if (size1 == EOF) return true;
   char* cp = tmp;

   if (tmp[0] == 'b') {
      int size2;
      size2 = get_token(fp, sig);
      restore(fp, sig, size2);
      restore(fp, tmp, size1);
      cp = sig;
   } else if (tmp[0] == '0' || tmp[0] == '1' || tmp[0] == 'x' || tmp[0] == 'z') {
      restore(fp, tmp, size1);
      cp++;
   } else {
      restore(fp, tmp, size1);
      return true;
   }

   // map signal to the right sigcode
   int sigcode2 = VERILOG_ID_TO_POS(cp);

   // LOOKATME can this ever happen ??
   if (sigcode2 < 0 || sigcode2 > max_codeG) return true;
   if (isone) {
      if (fd2_to_fd1_mapG[sigcode2] == -1) return true;
      sigcode2 = fd2_to_fd1_mapG[sigcode2];
   } else {
      if (fd1_to_fd2_mapG[sigcode2] == -1) return true;
      sigcode2 = fd1_to_fd2_mapG[sigcode2];
   }

   return sigcode1 != sigcode2;
}

// rewind to file and reset line count to the start of a #time
static void rewind_time(FILE* fp, long seek, vtime_t* time, vtime_t treset, int* linenum,
                        int lreset) {
   *time = treset;
   fseek(fp, seek, SEEK_SET);
   // reset the line counts
   *linenum = lreset;
}

// get the differences of a time block from #time to the next #time2 or EOF

static vtime_t get_time_diffs(FILE* mainfp, FILE* otherfp, char* mname, char* oname, long seek1,
                              long seek2, vtime_t ltime1, vtime_t ltime2, bool isone) {
   static char svalue1[MAXTOKSIZE], svalue2[MAXTOKSIZE];
   int retval = 0;
   int state1 = '?';
   int state2 = '?';
   signal_t* sig1;
   signal_t* sig2;

   int sigcode1 = 0;
   int sigcode2 = 0;
   bool first = true;
   vtime_t time = ltime1;
   vtime_t nxt_time = ltime2;

   // AIV 02/04/03 added temps to reset line count for unkown tokens, etc
   int tmpline1 = line_num1G;
   int tmpline2 = line_num2G;

   // LOOKATME rewind needed here because of reset ungets, and seek from
   // the start of the file, should write own buffer
   rewind(isone ? mainfp : otherfp);
   if (isone)
      fseek(mainfp, seek1, SEEK_CUR);
   else
      fseek(otherfp, seek2, SEEK_CUR);

   while (retval != EOF) {
      retval = get_nxt_chg(mainfp, mname, &sigcode1, &state1, svalue1, &time, isone);
      switch (retval) {
      case SCALAR:
      case VECTOR:
         // rewind if the next sig isn't the same
         // LOOKATME could change so that if the first sig isn't
         // get_nxt would rewind, to speed up ??
         if (!first && peek_nxt_sig(otherfp, sigcode1, isone)) {
            rewind_time(otherfp, seek2, &nxt_time, ltime2, isone ? &line_num2G : &line_num1G,
                        isone ? tmpline2 : tmpline1);
         }

         first = false;
         if (isone) {
            sig1 = VERILOG_POS_TO_SIG1(sigcode1);
            sigcode1 = fd1_to_fd2_mapG[sigcode1];
            sig2 = VERILOG_POS_TO_SIG2(sigcode1);
         } else {
            sig1 = VERILOG_POS_TO_SIG2(sigcode1);
            sigcode1 = fd2_to_fd1_mapG[sigcode1];
            sig2 = VERILOG_POS_TO_SIG1(sigcode1);
         }

         if (!sig1->in_both) break;
         if (sig1->found) {
            sig1->found = false;
            sig2->found = false;
            if (retval == SCALAR)
               sig1->state = state1;
            else {
               if (sig1->vector) { strcpy(sig1->vector, svalue1); }
            }
            break;
         }
         // should check to see if sig1 and sig 2 are the same type??
         for (;;) {
            if (get_nxt_chg(otherfp, oname, &sigcode2, &state2, svalue2, &nxt_time, !isone)
                == EOF) {
               printf("%s (%s) Never found in file %d at time %lld\n", sig1->signame, sig1->ident,
                      isone ? 1 : 2, time);
               break;
            } else if (sigcode1 == sigcode2)
               break;
         }

         if (retval == SCALAR) {
            if (state_flagG)
               print_scalar_state(sig1, sig2, time, nxt_time, state1, state2, isone);
            else
               print_scalar_edge(sig1, sig2, time, nxt_time, state1, state2, isone);
            sig1->state = state1;
         } else if (retval == VECTOR) {
            if (state_flagG)
               print_vector_state(sig1, sig2, time, nxt_time, svalue1, svalue2, isone);
            else
               print_vector_edge(sig1, sig2, time, nxt_time, svalue1, svalue2, isone);
            if (sig1->vector) { strcpy(sig1->vector, svalue1); }
         }
         // if isn't the same time must of scanned foward so rewind
         if (nxt_time != time) {
            rewind_time(otherfp, seek2, &nxt_time, ltime2, isone ? &line_num2G : &line_num1G,
                        isone ? tmpline2 : tmpline1);
         }

         break;
      case TIME:
         // rewind to the start time, to process other file
         if (isone) {
            rewind_time(otherfp, seek2, &nxt_time, ltime2, isone ? &line_num2G : &line_num1G,
                        isone ? tmpline2 : tmpline1);
         }
         if (time != 0) return time;
         break;
      case EOF: quit_flagG = EOF; return time;
      default: continue;
      }
   }
   // TODO should never get here emit error
   return time;
}

// print the map of identifiers to signal name between files
static void print_map() {
   for (int i = 0; i < max_codeG; i++) {
      if (fd1_to_fd2_mapG[i] != -1) {
         signal_t* sig = VERILOG_POS_TO_SIG2(fd1_to_fd2_mapG[i]);
         if (!sig || !sig->in_both) continue;
         printf("%d %d %s\n", i, fd1_to_fd2_mapG[i], sig->signame);
      }
   }
   printf("*********Second*********\n");
   for (int i = 0; i < max_codeG; i++) {
      if (fd2_to_fd1_mapG[i] != -1) {
         signal_t* sig = VERILOG_POS_TO_SIG1(fd2_to_fd1_mapG[i]);
         if (!sig || !sig->in_both) continue;
         printf("%d %d %s\n", i, fd2_to_fd1_mapG[i], sig->signame);
      }
   }
}

static void print_var_type_name(int vnum) {
   if (vnum < 0 || vnum >= UNDEFINED) {
      printf("UNDEFINED");
   } else {
      printf("'%s'", var_types[vnum].vnam);
   }
}

// check to make sure the files are the same in type/size in both files
static void compare_types(char* file_nam1, char* file_nam2, signal_t* sig1, signal_t* sig2) {
   if (sig1->in_both) {
      if (sig1->type != sig2->type) {
         if (sig1->sig_code == sig2->sig_code)
            printf("WARNING - Ignoring signal %s (%s) - types don't match\n", sig1->signame,
                   sig1->ident);
         else
            printf("WARNING - Ignoring signal %s (%s %s) - types don't match\n", sig1->signame,
                   sig1->ident, sig2->ident);

         printf("\t file '%s' type ", file_nam1);
         print_var_type_name(sig1->type);
         printf("\n");

         printf("\t file '%s' type ", file_nam2);
         print_var_type_name(sig2->type);
         printf("\n\n");

         sig1->in_both = false;
         sig2->in_both = false;
         return;
      }
      if (sig1->size != sig2->size) {
         if (sig1->sig_code == sig2->sig_code)
            printf("WARNING - Ignoring signal %s (%s) - sizes don't match\n", sig1->signame,
                   sig1->ident);
         else
            printf("WARNING - Ignoring signal %s (%s %s) - sizes don't match\n", sig1->signame,
                   sig1->ident, sig2->ident);

         printf("\t file '%s' size '%d'\n", file_nam1, sig1->size);
         printf("\t file '%s' size '%d'\n\n", file_nam2, sig2->size);
         sig1->in_both = false;
         sig2->in_both = false;
         return;
      }
   }
}

// map the signal names to identifiers from one file to the other
static bool map(char* file_nam1, char* file_nam2, int* file_map, signal_t* startsig,
                signal_t* otherstart, bool isone) {
   bool one_found = false;
   for (signal_t* sig1 = startsig; sig1; sig1 = sig1->next) {
      signal_t* sig2;
      if (isone)
         sig2 = VERILOG_POS_TO_SIG2(sig1->sig_code);
      else
         sig2 = VERILOG_POS_TO_SIG1(sig1->sig_code);

      if (!sig2) {
         for (sig2 = otherstart; sig2; sig2 = sig2->next) {
            if (!sig2->in_both) continue;
            if (strcmp(sig1->signame, sig2->signame) == 0) {
               file_map[sig1->sig_code] = sig2->sig_code;
               compare_types(file_nam1, file_nam2, sig1, sig2);
               one_found = true;
               break;
            }
         }
      } else if (strcmp(sig1->signame, sig2->signame) == 0) {
         file_map[sig1->sig_code] = sig1->sig_code;
         compare_types(file_nam1, file_nam2, sig1, sig2);
         one_found = true;
      } else {
         for (sig2 = otherstart; sig2; sig2 = sig2->next) {
            if (!sig2->in_both) continue;
            if (strcmp(sig1->signame, sig2->signame) == 0) {
               file_map[sig1->sig_code] = sig2->sig_code;
               compare_types(file_nam1, file_nam2, sig1, sig2);
               one_found = true;
               break;
            }
         }
      }
      if (!sig2) {
         printf("WARNING - Ignoring signal %s (%s) - not defined in both files\n", sig1->signame,
                sig1->ident);
         printf("\t  Defined in file '%s' and not file '%s'\n\n", file_nam1, file_nam2);
         file_map[sig1->sig_code] = sig1->sig_code;
         sig1->in_both = false;
      }
   }

   return one_found;
}

// map both files
static bool map_var_names(char* file_nam1, char* file_nam2) {
   fd1_to_fd2_mapG = (int*)malloc(sizeof(int) * max_codeG);
   for (int i = 0; i < max_codeG; i++) fd1_to_fd2_mapG[i] = -1;

   fd2_to_fd1_mapG = (int*)malloc(sizeof(int) * max_codeG);
   for (int i = 0; i < max_codeG; i++) fd2_to_fd1_mapG[i] = -1;

   const bool one_found1 = map(file_nam1, file_nam2, fd1_to_fd2_mapG, sig1_hdG, sig2_hdG, true);
   const bool one_found2 = map(file_nam2, file_nam1, fd2_to_fd1_mapG, sig2_hdG, sig1_hdG, false);
   if (0) print_map();
   return one_found1 && one_found2;
}

// actually run the files to diff the two
static void run_diffs(FILE* fp1, FILE* fp2, char* fnam1, char* fnam2, long start1, long start2) {
   static char token[MAXTOKSIZE];
   vtime_t time1 = 0;
   vtime_t time2 = 0;
   vtime_t temp_time1 = 0;

   while (quit_flagG != EOF) {
      // while the times are the same
      while (time1 == time2) {
         temp_time1 = time1;
         time1 = get_time_diffs(fp1, fp2, fnam1, fnam2, start1, start2, time1, time2, true);
         long temp1_chars = ftell(fp1);

         time2 = get_time_diffs(fp2, fp1, fnam2, fnam1, start2, start1, time2, temp_time1, false);
         start2 = ftell(fp2);
         start1 = temp1_chars;
         if (quit_flagG) break;
      }

      // time one is ahead
      while (time2 < time1) {
         time2 = get_time_diffs(fp2, fp1, fnam2, fnam1, start2, start1, time2, temp_time1, false);
         start2 = ftell(fp2);
         if (quit_flagG) {
            if (get_token(fp1, token) != EOF) {
               printf("*****End of file hit at file 2 ('%s') time %lld quiting\n", fnam2, time2);
               printf("WARNING - Files have different end times\n");
            }
            break;
         }
      }

      // while time two is ahead
      while (time1 < time2) {
         time1 = get_time_diffs(fp1, fp2, fnam1, fnam2, start1, start2, time1, time2, true);
         start1 = ftell(fp1);
         if (quit_flagG) {
            if (get_token(fp2, token) != EOF) {
               printf("*****End of file hit at file 1 ('%s') time %lld quiting\n", fnam1, time1);
               printf("WARNING - Files have different end times\n");
            }
            break;
         }
      }
   }
}

static void print_version() { printf("%s_%s (%s).\n", "vcddiff", VERSION, "Linux-ELF"); }

// print help information
static void print_help() {
   print_version();

   printf(" --state \n -s \n");
   printf("\tPrints the current state of variables, instead of\n \tthe default edge value. \n");
   printf(" --wrap  \n -w \n");
   printf("\tWraps the line, only used for default edge print values\n\tnot --state print "
          "messages. \n");

   printf("\n");
   print_header();
   exit(0);
}

// print program header info
static void print_header() {
   print_version();
   printf("Copyright (c) 2002-2004 Pragmatic C Software Corp.\n");
   printf("All Rights reserved.  Licensed under the GNU General Public License (GPL).\n");
   printf("See the 'COPYING' file for details.  NO WARRANTY provided.\n");
   time_t now;
   time(&now);
   char s1[30];
   strcpy(s1, ctime(&now));
   s1[24] = '\0';
   printf("Today is %s.\n\n", s1);
}

static void set_options(int argc, char** argv) {
   for (int i = 1; i < argc - 2; i++) {
      if (!strcmp(argv[i], "--state") || !strcmp(argv[i], "-s")) {
         if (wrap_flagG)
            printf("WARNING - wrap cannot be used with --state option, wrap disabled\n\n");
         else
            state_flagG = true;
      } else if (!strcmp(argv[i], "--wrap") || !strcmp(argv[i], "-w")) {
         if (state_flagG)
            printf("WARNING - wrap cannot be used with --state option, wrap disabled\n\n");
         else
            wrap_flagG = true;
      } else {
         printf("ERROR - Unknown option %s\n", argv[i]);
         printf("\t Try 'vcddiff --help' for more infomation\n");
         exit(0);
      }
   }
}

// handle non-seekable files (e.g. FIFOs)
static FILE* open_seekable(const char* filename, char** buffered_data) {
   struct stat st;
   int fd = -1;
   size_t buffer_size = 4096;
   size_t total_read = 0;
   char* buffer = nullptr;

   FILE* fp;
   if (!(fp = fopen(filename, "r"))) {
      printf("*** ERROR-opening file %s\n", filename);
      exit(1);
   }

   *buffered_data = nullptr;

#ifdef _WIN32
   return fp;
#else
   fd = fileno(fp);
   if (fstat(fd, &st) != 0) {
      printf("*** ERROR-cannot stat file %s\n", filename);
      exit(1);
   }

   if (S_ISREG(st.st_mode)) { return fp; }

   buffer = static_cast<char*>(malloc(buffer_size));

   if (!buffer) {
      printf("*** ERROR-cannot allocate memory for buffering %s\n", filename);
      exit(1);
   }

   // read entire file into memory
   while (1) {
      size_t bytes_read;

      bytes_read = fread(buffer + total_read, 1, buffer_size - total_read, fp);
      total_read += bytes_read;

      if (bytes_read == 0) {
         if (feof(fp)) { break; }
         if (ferror(fp)) {
            printf("*** ERROR-reading from %s\n", filename);
            free(buffer);
            exit(1);
         }
      }

      if (total_read >= buffer_size - 1) {
         char* new_buffer;

         buffer_size *= 2;
         new_buffer = static_cast<char*>(realloc(buffer, buffer_size));
         if (!new_buffer) {
            printf("*** ERROR-cannot allocate memory for buffering %s\n", filename);
            free(buffer);
            exit(1);
         }
         buffer = new_buffer;
      }
   }

   fclose(fp);

   fp = fmemopen(buffer, total_read, "r");
   if (!fp) {
      printf("*** ERROR-cannot create memory stream for %s\n", filename);
      free(buffer);
      exit(1);
   }

   *buffered_data = buffer;
   return fp;
#endif
}

int main(int argc, char** argv) {
   int unit1;
   int unit2;
   int tnum1;
   int tnum2;
   char* buffer1 = nullptr;
   char* buffer2 = nullptr;

   extended_flagG = false;
   quit_flagG = false;
   sig1_hdG = nullptr;
   sig2_hdG = nullptr;

   // print_header();
   if (argc < 2) {
      printf("ERROR - Usage: [options] 'file1' 'file2'\n");
      printf("\t Try 'vcddiff --help' for more infomation\n");
      exit(1);
   }
   if (!strcmp(argv[1], "--help") || !strcmp(argv[1], "-h")) print_help();
   if (!strcmp(argv[1], "--version") || !strcmp(argv[1], "-v") || !strcmp(argv[1], "-V")) {
      print_version();
      exit(0);
   }

   if (argc < 3) {
      printf("ERROR - Usage: [options] 'file1' 'file2'\n");
      printf("\t Try 'vcddiff --help' for more infomation\n");
      exit(1);
   }

   wrap_flagG = state_flagG = false;

   FILE* fp1 = open_seekable(argv[argc - 2], &buffer1);

   // set first file to the global pointer to check the line count
   file1G = fp1;

   FILE* fp2 = open_seekable(argv[argc - 1], &buffer2);

   set_options(argc, argv);

   sig_int1G = nullptr;
   sig_int2G = nullptr;

   // could skip copying the filename, just pass argv
   char* file_nam1 = (char*)malloc(strlen(argv[argc - 2]) + 1);
   strcpy(file_nam1, argv[argc - 2]);
   long start1 = get_lines(fp1, &unit1, &tnum1, file_nam1);

   char* file_nam2 = (char*)malloc(strlen(argv[argc - 1]) + 1);
   strcpy(file_nam2, argv[argc - 1]);
   long start2 = get_lines(fp2, &unit2, &tnum2, file_nam2);
   alloc_sig_mem();
   const bool map_found = map_var_names(file_nam1, file_nam2);

   if (map_found) {
      if (tnum1 != tnum2) {
         printf("*** ERROR-dump files have different timescale time numbers '%d' in file 1, and "
                "'%d' in file 2\n",
                tnum1, tnum2);
         exit(1);
      }

      if (unit1 != unit2) {
         printf("*** ERROR-dump files have different time scale units '%cs' in file 1, and '%cs' "
                "in file 2\n",
                unit1, unit2);
         exit(1);
      }

      run_diffs(fp1, fp2, file_nam1, file_nam2, start1, start2);
   } else
      printf("*** ERROR-dump files have no matching variables to diff\n");

   // free and close
   free(sig_int1G);
   free(sig_int2G);
   free(fd1_to_fd2_mapG);
   free(fd2_to_fd1_mapG);
   fclose(fp1);
   fclose(fp2);
   if (buffer1) free(buffer1);
   if (buffer2) free(buffer2);
   return 0;
}