defines.h

Go to the documentation of this file.

#ifndef __DEFINES_H__
#define __DEFINES_H__

/*
 Copyright (c) 2006-2010 Trevor Williams

 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 2 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "../config.h"

#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include <float.h>

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "cexcept.h"

#define COVERED_VERSION    VERSION

#define CDD_VERSION        24

#define COVERED_HEADER     "\nCovered %s -- Verilog Code Coverage Utility\nWritten by Trevor Williams  (phase1geo@gmail.com)\nFreely distributable under the GPL license\n", COVERED_VERSION

#define DFLT_OUTPUT_CDD    "cov.cdd"

#define PROFILING_OUTPUT_NAME "covered.prof"

#define DFLT_VPI_NAME      "covered_vpi.v"

#define DFLT_DUMPVARS_NAME "covered_dump.v"

#define INTEGER_WIDTH      (SIZEOF_INT * 8)

#define MAX_BIT_WIDTH      65536

#define MAX_MALLOC_SIZE    (MAX_BIT_WIDTH * 2)

#define USER_MSG_LENGTH    (MAX_BIT_WIDTH * 2)

#define DEFAULT_LINE_WIDTH 105

#define GENERATION_1995         0

#define GENERATION_2001         1

#define GENERATION_SV           2

#define DUMP_FMT_NONE      0

#define DUMP_FMT_VCD       1

#define DUMP_FMT_LXT       2

#define DUMP_FMT_FST       3

#define FATAL        1

#define FATAL_WRAP   2

#define WARNING      3

#define WARNING_WRAP 4

#define NORMAL       5

#define DEBUG        6

#define HEADER       7

#define DB_TYPE_SIGNAL        1

#define DB_TYPE_EXPRESSION    2

#define DB_TYPE_FUNIT         3

#define DB_TYPE_STATEMENT     4

#define DB_TYPE_INFO          5

#define DB_TYPE_FSM           6

#define DB_TYPE_RACE          7

#define DB_TYPE_SCORE_ARGS    8

#define DB_TYPE_SU_START      9

#define DB_TYPE_SU_END        10

#define DB_TYPE_MESSAGE       11

#define DB_TYPE_MERGED_CDD    12

#define DB_TYPE_EXCLUDE       13

#define DB_TYPE_FUNIT_VERSION 14

#define DB_TYPE_INST_ONLY     15

#define FUNIT_MODULE         0

#define FUNIT_NAMED_BLOCK    1

#define FUNIT_FUNCTION       2

#define FUNIT_TASK           3

#define FUNIT_NO_SCORE       4

#define FUNIT_AFUNCTION      5

#define FUNIT_ATASK          6

#define FUNIT_ANAMED_BLOCK   7

#define FUNIT_TYPES          8

#define MERGE_ER_NONE    0

#define MERGE_ER_FIRST   1

#define MERGE_ER_LAST    2

#define MERGE_ER_ALL     3

#define MERGE_ER_NEW     4

#define MERGE_ER_OLD     5

#define REPORT_SUMMARY       0x0

#define REPORT_DETAILED      0x2

#define REPORT_VERBOSE       0xffffffff

#define VECTOR_MERGE_MASK    0x6c

#define ESUPPL_MERGE_MASK            0x3fffff

#define ESUPPL_BITS_TO_STORE         5

#define ESUPPL_WAS_SWAPPED(x)        x.part.swapped

#define ESUPPL_IS_ROOT(x)            x.part.root

#define ESUPPL_IS_TRUE(x)            x.part.eval_t

#define ESUPPL_IS_FALSE(x)           x.part.eval_f

#define ESUPPL_WAS_TRUE(x)           x.part.true

#define ESUPPL_WAS_FALSE(x)          x.part.false

#define ESUPPL_IS_LEFT_CHANGED(x)    x.part.left_changed

#define ESUPPL_IS_RIGHT_CHANGED(x)   x.part.right_changed

#define ESUPPL_WAS_COMB_COUNTED(x)   x.part.comb_cntd

#define ESUPPL_IS_LHS(x)             x.part.lhs

#define ESUPPL_IS_IN_FUNC(x)         x.part.in_func

#define ESUPPL_OWNS_VEC(x)           x.part.owns_vec

#define ESUPPL_EXCLUDED(x)           x.part.excluded

#define ESUPPL_TYPE(x)               x.part.type

#define ESUPPL_STATIC_BASE(x)        x.part.base

#define SSUPPL_TYPE_INPUT_NET      0

#define SSUPPL_TYPE_INPUT_REG      1

#define SSUPPL_TYPE_OUTPUT_NET     2

#define SSUPPL_TYPE_OUTPUT_REG     3

#define SSUPPL_TYPE_INOUT_NET      4

#define SSUPPL_TYPE_INOUT_REG      5

#define SSUPPL_TYPE_DECL_NET       6

#define SSUPPL_TYPE_DECL_REG       7

#define SSUPPL_TYPE_EVENT          8

#define SSUPPL_TYPE_IMPLICIT       9

#define SSUPPL_TYPE_IMPLICIT_POS   10

#define SSUPPL_TYPE_IMPLICIT_NEG   11

#define SSUPPL_TYPE_PARAM          12

#define SSUPPL_TYPE_GENVAR         13

#define SSUPPL_TYPE_ENUM           14

#define SSUPPL_TYPE_MEM            15

#define SSUPPL_TYPE_DECL_SREAL     16

#define SSUPPL_TYPE_DECL_REAL      17

#define SSUPPL_TYPE_PARAM_REAL     18

#define SSUPPL_TYPE_IMPLICIT_REAL  19

#define SSUPPL_TYPE_IMPLICIT_SREAL 20 

#define SIGNAL_IS_NET(x)          ((x->suppl.part.type == SSUPPL_TYPE_INPUT_NET)    || \
                                   (x->suppl.part.type == SSUPPL_TYPE_OUTPUT_NET)   || \
                                   (x->suppl.part.type == SSUPPL_TYPE_INOUT_NET)    || \
                                   (x->suppl.part.type == SSUPPL_TYPE_EVENT)        || \
                                   (x->suppl.part.type == SSUPPL_TYPE_DECL_NET)     || \
                                   (x->suppl.part.type == SSUPPL_TYPE_IMPLICIT)     || \
                                   (x->suppl.part.type == SSUPPL_TYPE_IMPLICIT_POS) || \
                                   (x->suppl.part.type == SSUPPL_TYPE_IMPLICIT_NEG))

#define SIGNAL_ASSIGN_FROM_DUMPFILE(x)  ((x->suppl.part.assigned == 0)                  && \
                                         (x->suppl.part.type != SSUPPL_TYPE_PARAM)      && \
                                         (x->suppl.part.type != SSUPPL_TYPE_PARAM_REAL) && \
                                         (x->suppl.part.type != SSUPPL_TYPE_ENUM)       && \
                                         (x->suppl.part.type != SSUPPL_TYPE_MEM)        && \
                                         (x->suppl.part.type != SSUPPL_TYPE_GENVAR)     && \
                                         (x->suppl.part.type != SSUPPL_TYPE_EVENT))
     
#define READ_MODE_NO_MERGE                0

#define READ_MODE_MERGE_NO_MERGE          1

#define READ_MODE_REPORT_NO_MERGE         2

#define READ_MODE_MERGE_INST_MERGE        3

#define READ_MODE_REPORT_MOD_MERGE        4

#define PARAM_TYPE_DECLARED             0

#define PARAM_TYPE_OVERRIDE             1

#define PARAM_TYPE_SIG_LSB              2

#define PARAM_TYPE_SIG_MSB              3

#define PARAM_TYPE_INST_LSB             4

#define PARAM_TYPE_INST_MSB             5

#define PARAM_TYPE_DECLARED_LOCAL       6

#define GI_TYPE_EXPR            0

#define GI_TYPE_SIG             1

#define GI_TYPE_STMT            2

#define GI_TYPE_INST            3

#define GI_TYPE_TFN             4

#define GI_TYPE_BIND            5

#define DELAY_EXPR_DEFAULT      0

#define DELAY_EXPR_MIN          1

#define DELAY_EXPR_TYP          2

#define DELAY_EXPR_MAX          3

typedef enum logic_rm_type_e {
  LOGIC_RM_REAL = 0,     
  LOGIC_RM_SYSFUNC,      
  LOGIC_RM_SYSTASK,      
  LOGIC_RM_NUM           
} logic_rm_type;

typedef enum exp_op_type_e {
  EXP_OP_STATIC = 0,      
  EXP_OP_SIG,             
  EXP_OP_XOR,             
  EXP_OP_MULTIPLY,        
  EXP_OP_DIVIDE,          
  EXP_OP_MOD,             
  EXP_OP_ADD,             
  EXP_OP_SUBTRACT,        
  EXP_OP_AND,             
  EXP_OP_OR,              
  EXP_OP_NAND,            
  EXP_OP_NOR,             
  EXP_OP_NXOR,            
  EXP_OP_LT,              
  EXP_OP_GT,              
  EXP_OP_LSHIFT,          
  EXP_OP_RSHIFT,          
  EXP_OP_EQ,              
  EXP_OP_CEQ,             
  EXP_OP_LE,              
  EXP_OP_GE,              
  EXP_OP_NE,              
  EXP_OP_CNE,             
  EXP_OP_LOR,             
  EXP_OP_LAND,            
  EXP_OP_COND,            
  EXP_OP_COND_SEL,        
  EXP_OP_UINV,            
  EXP_OP_UAND,            
  EXP_OP_UNOT,            
  EXP_OP_UOR,             
  EXP_OP_UXOR,            
  EXP_OP_UNAND,           
  EXP_OP_UNOR,            
  EXP_OP_UNXOR,           
  EXP_OP_SBIT_SEL,        
  EXP_OP_MBIT_SEL,        
  EXP_OP_EXPAND,          
  EXP_OP_CONCAT,          
  EXP_OP_PEDGE,           
  EXP_OP_NEDGE,           
  EXP_OP_AEDGE,           
  EXP_OP_LAST,            
  EXP_OP_EOR,             
  EXP_OP_DELAY,           
  EXP_OP_CASE,            
  EXP_OP_CASEX,           
  EXP_OP_CASEZ,           
  EXP_OP_DEFAULT,         
  EXP_OP_LIST,            
  EXP_OP_PARAM,           
  EXP_OP_PARAM_SBIT,      
  EXP_OP_PARAM_MBIT,      
  EXP_OP_ASSIGN,          
  EXP_OP_DASSIGN,         
  EXP_OP_BASSIGN,         
  EXP_OP_NASSIGN,         
  EXP_OP_IF,              
  EXP_OP_FUNC_CALL,       
  EXP_OP_TASK_CALL,       
  EXP_OP_TRIGGER,         
  EXP_OP_NB_CALL,         
  EXP_OP_FORK,            
  EXP_OP_JOIN,            
  EXP_OP_DISABLE,         
  EXP_OP_REPEAT,          
  EXP_OP_WHILE,           
  EXP_OP_ALSHIFT,         
  EXP_OP_ARSHIFT,         
  EXP_OP_SLIST,           
  EXP_OP_EXPONENT,        
  EXP_OP_PASSIGN,         
  EXP_OP_RASSIGN,         
  EXP_OP_MBIT_POS,        
  EXP_OP_MBIT_NEG,        
  EXP_OP_PARAM_MBIT_POS,  
  EXP_OP_PARAM_MBIT_NEG,  
  EXP_OP_NEGATE,          
  EXP_OP_NOOP,            
  EXP_OP_ALWAYS_COMB,     
  EXP_OP_ALWAYS_LATCH,    
  EXP_OP_IINC,            
  EXP_OP_PINC,            
  EXP_OP_IDEC,            
  EXP_OP_PDEC,            
  EXP_OP_DLY_ASSIGN,      
  EXP_OP_DLY_OP,          
  EXP_OP_RPT_DLY,         
  EXP_OP_DIM,             
  EXP_OP_WAIT,            
  EXP_OP_SFINISH,         
  EXP_OP_SSTOP,           
  EXP_OP_ADD_A,           
  EXP_OP_SUB_A,           
  EXP_OP_MLT_A,           
  EXP_OP_DIV_A,           
  EXP_OP_MOD_A,           
  EXP_OP_AND_A,           
  EXP_OP_OR_A,            
  EXP_OP_XOR_A,           
  EXP_OP_LS_A,            
  EXP_OP_RS_A,            
  EXP_OP_ALS_A,           
  EXP_OP_ARS_A,           
  EXP_OP_FOREVER,         
  EXP_OP_STIME,           
  EXP_OP_SRANDOM,         
  EXP_OP_PLIST,           
  EXP_OP_SASSIGN,         
  EXP_OP_SSRANDOM,        
  EXP_OP_SURANDOM,        
  EXP_OP_SURAND_RANGE,    
  EXP_OP_SR2B,            
  EXP_OP_SB2R,            
  EXP_OP_SSR2B,           
  EXP_OP_SB2SR,           
  EXP_OP_SI2R,            
  EXP_OP_SR2I,            
  EXP_OP_STESTARGS,       
  EXP_OP_SVALARGS,        
  EXP_OP_SSIGNED,         
  EXP_OP_SUNSIGNED,       
  EXP_OP_SCLOG2,          
  EXP_OP_SREALTIME,       
  EXP_OP_NUM              
} exp_op_type;

#define EXPR_IS_MEASURABLE(x)      (((exp_op_info[x->op].suppl.measurable == 1) && \
                                     (ESUPPL_IS_LHS( x->suppl ) == 0) && \
                                     (x->value->suppl.part.data_type != VDATA_R64) && \
                                     (x->value->suppl.part.data_type != VDATA_R32) && \
                                     !((ESUPPL_IS_ROOT( x->suppl ) == 0) && \
                                       ((x->op == EXP_OP_SIG) || \
                                        (x->op == EXP_OP_SBIT_SEL) || \
                                        (x->op == EXP_OP_MBIT_SEL) || \
                                        (x->op == EXP_OP_MBIT_POS) || \
                                        (x->op == EXP_OP_MBIT_NEG)) && \
                                       (x->parent->expr->op != EXP_OP_ASSIGN) && \
                                       (x->parent->expr->op != EXP_OP_DASSIGN) && \
                                       (x->parent->expr->op != EXP_OP_BASSIGN) && \
                                       (x->parent->expr->op != EXP_OP_NASSIGN) && \
                                       (x->parent->expr->op != EXP_OP_RASSIGN) && \
                                       (x->parent->expr->op != EXP_OP_DLY_OP) && \
                                       (x->parent->expr->op != EXP_OP_IF) && \
                                       (x->parent->expr->op != EXP_OP_WHILE) && \
                                       (x->parent->expr->op != EXP_OP_COND)) && \
                                     (x->line != 0)) ? 1 : 0)

#define EXPR_IS_STATIC(x)        exp_op_info[x->op].suppl.is_static

#define EXPR_IS_COMB(x)          ((exp_op_info[x->op].suppl.is_comb > 0) && \
                                  (EXPR_IS_OP_AND_ASSIGN(x) || \
                                  (!expression_is_static_only( x->left ) && \
                                   !expression_is_static_only( x->right))))

#define EXPR_IS_EVENT(x)         exp_op_info[x->op].suppl.is_event

#define EXPR_IS_CONTEXT_SWITCH(x)       ((exp_op_info[x->op].suppl.is_context_switch == 1) || \
                                         ((x->op == EXP_OP_NB_CALL) && !ESUPPL_IS_IN_FUNC(x->suppl)))

#define EXPR_OWNS_VEC(o)                ((o != EXP_OP_SIG)            && \
                                         (o != EXP_OP_SBIT_SEL)       && \
                                         (o != EXP_OP_MBIT_SEL)       && \
                                         (o != EXP_OP_MBIT_POS)       && \
                                         (o != EXP_OP_MBIT_NEG)       && \
                                         (o != EXP_OP_TRIGGER)        && \
                                         (o != EXP_OP_PARAM)          && \
                                         (o != EXP_OP_PARAM_SBIT)     && \
                                         (o != EXP_OP_PARAM_MBIT)     && \
                                         (o != EXP_OP_PARAM_MBIT_POS) && \
                                         (o != EXP_OP_PARAM_MBIT_NEG) && \
                                         (o != EXP_OP_ASSIGN)         && \
                                         (o != EXP_OP_DASSIGN)        && \
                                         (o != EXP_OP_BASSIGN)        && \
                                         (o != EXP_OP_NASSIGN)        && \
                                         (o != EXP_OP_RASSIGN)        && \
                                         (o != EXP_OP_IF)             && \
                                         (o != EXP_OP_WHILE)          && \
                                         (o != EXP_OP_PASSIGN)        && \
                                         (o != EXP_OP_DLY_ASSIGN)     && \
                                         (o != EXP_OP_DIM))

#define EXPR_IS_UNARY(x)        exp_op_info[x->op].suppl.is_unary

#define EXPR_COMB_MISSED(x)     (EXPR_IS_MEASURABLE( x ) && (x->ulid != -1))

#define EXPR_LEFT_DEALLOCABLE(x)     (((x->op != EXP_OP_CASE)  && \
                                       (x->op != EXP_OP_CASEX) && \
                                       (x->op != EXP_OP_CASEZ)) || \
                                      (x->suppl.part.owned == 1))

#define EXPR_RIGHT_DEALLOCABLE(x)    (TRUE)

#define EXPR_IS_OP_AND_ASSIGN(x)     ((x->op == EXP_OP_ADD_A) || \
                                      (x->op == EXP_OP_SUB_A) || \
                                      (x->op == EXP_OP_MLT_A) || \
                                      (x->op == EXP_OP_DIV_A) || \
                                      (x->op == EXP_OP_MOD_A) || \
                                      (x->op == EXP_OP_AND_A) || \
                                      (x->op == EXP_OP_OR_A)  || \
                                      (x->op == EXP_OP_XOR_A) || \
                                      (x->op == EXP_OP_LS_A)  || \
                                      (x->op == EXP_OP_RS_A)  || \
                                      (x->op == EXP_OP_ALS_A) || \
                                      (x->op == EXP_OP_ARS_A))

#define EXPR_TMP_VECS(x)             exp_op_info[x].suppl.tmp_vecs

#define EXPR_OP_HAS_DIM(x)          ((x == EXP_OP_DIM)            || \
                                     (x == EXP_OP_SBIT_SEL)       || \
                                     (x == EXP_OP_PARAM_SBIT)     || \
                                     (x == EXP_OP_MBIT_SEL)       || \
                                     (x == EXP_OP_PARAM_MBIT)     || \
                                     (x == EXP_OP_MBIT_POS)       || \
                                     (x == EXP_OP_MBIT_NEG)       || \
                                     (x == EXP_OP_PARAM_MBIT_POS) || \
                                     (x == EXP_OP_PARAM_MBIT_NEG))

#define DECIMAL                 0       
#define BINARY                  1       
#define OCTAL                   2       
#define HEXIDECIMAL             3       
#define QSTRING                 4       
#define ATTRIBUTE_UNKNOWN       0       
#define ATTRIBUTE_FSM           1       
#define RACE_TYPE_SEQ_USES_NON_BLOCK         0

#define RACE_TYPE_CMB_USES_BLOCK             1

#define RACE_TYPE_MIX_USES_NON_BLOCK         2

#define RACE_TYPE_HOMOGENOUS                 3

#define RACE_TYPE_ASSIGN_IN_ONE_BLOCK1       4

#define RACE_TYPE_ASSIGN_IN_ONE_BLOCK2       5

#define RACE_TYPE_STROBE_DISPLAY_NON_BLOCK   6

#define RACE_TYPE_NO_POUND_0_PROC_ASSIGNS    7

#define RACE_TYPE_NUM                        8

#define NOT_COMB        0

#define AND_COMB        1

#define OR_COMB         2

#define OTHER_COMB      3

#define VTYPE_VAL   0

#define VTYPE_SIG   1

#define VTYPE_EXP   2

#define VTYPE_MEM   3

#define VDATA_UL      0

#define VDATA_R64     1

#define VDATA_R32     2

typedef enum vtype_val_indices_e {
  VTYPE_INDEX_VAL_VALL,
  VTYPE_INDEX_VAL_VALH,
  VTYPE_INDEX_VAL_NUM
} vtype_val_indices;

typedef enum vtype_sig_indices_e {
  VTYPE_INDEX_SIG_VALL,
  VTYPE_INDEX_SIG_VALH,
  VTYPE_INDEX_SIG_XHOLD,
  VTYPE_INDEX_SIG_TOG01,
  VTYPE_INDEX_SIG_TOG10,
  VTYPE_INDEX_SIG_MISC,
  VTYPE_INDEX_SIG_NUM
} vtype_sig_indices;

typedef enum vtype_mem_indices_e {
  VTYPE_INDEX_MEM_VALL,
  VTYPE_INDEX_MEM_VALH,
  VTYPE_INDEX_MEM_XHOLD,
  VTYPE_INDEX_MEM_TOG01,
  VTYPE_INDEX_MEM_TOG10,
  VTYPE_INDEX_MEM_WR,
  VTYPE_INDEX_MEM_RD,
  VTYPE_INDEX_MEM_MISC,
  VTYPE_INDEX_MEM_NUM
} vtype_mem_indices;

typedef enum vtype_exp_indices_e {
  VTYPE_INDEX_EXP_VALL,
  VTYPE_INDEX_EXP_VALH,
  VTYPE_INDEX_EXP_EVAL_A,
  VTYPE_INDEX_EXP_EVAL_B,
  VTYPE_INDEX_EXP_EVAL_C,
  VTYPE_INDEX_EXP_EVAL_D,
  VTYPE_INDEX_EXP_NUM
} vtype_exp_indices;

typedef enum cp_indices_e {
  CP_TYPE_LINE,
  CP_TYPE_TOGGLE,
  CP_TYPE_MEM,
  CP_TYPE_LOGIC,
  CP_TYPE_FSM,
  CP_TYPE_ASSERT,
  CP_TYPE_NUM
} cp_indices;

typedef enum rpt_type_e {
  RPT_TYPE_HIT,
  RPT_TYPE_MISS,
  RPT_TYPE_EXCL
} rpt_type;

#define VSUPPL_MASK               (unsigned char)0x7f

#define ETYPE_NONE      0

#define ETYPE_FUNIT     1

#define ETYPE_DELAY     2

#define ETYPE_THREAD    3

#define ETYPE_VEC1      4

#define ETYPE_VEC2      5

#define THR_ST_NONE     0

#define THR_ST_ACTIVE   1

#define THR_ST_DELAYED  2

#define THR_ST_WAITING  3

#define SU_TYPE_STRUCT        0

#define SU_TYPE_UNION         1

#define SU_TYPE_TAGGED_UNION  2

#define SU_MEMTYPE_VOID      0

#define SU_MEMTYPE_SIG       1

#define SU_MEMTYPE_TYPEDEF   2

#define SU_MEMTYPE_ENUM      3

#define SU_MEMTYPE_SU        4

//#define snprintf(x,y,...)     assert( snprintf( x, y, __VA_ARGS__ ) < (y) );

#define TIME_CMP_LE(x,y)         ((((x).lo <= (y).lo) && ((x).hi <= (y).hi)) || ((x).hi < (y).hi))
#define TIME_CMP_GT(x,y)         (((x).lo > (y).lo) || ((x).hi > (y).hi))
#define TIME_CMP_GE(x,y)         ((((x).lo >= (y).lo) && ((x).hi >= (y).hi)) || ((x).hi > (y).hi))
#define TIME_CMP_NE(x,y)         (((x).lo ^ (y).lo) || ((x).hi ^ (y).hi))

#define TIME_INC(x,y)           (x).hi+=((0xffffffff-(x).lo)<(y).lo)?((y).hi+1):(y).hi; (x).lo+=(y).lo; (x).full+=(y).full;

#define FEQ(x,y)           (fabs(x-y) < FLT_EPSILON)
      
#define DEQ(x,y)           (fabs(x-y) < DBL_EPSILON)

typedef enum {
  FALSE,   
  TRUE     
} bool;

#if SIZEOF_CHAR == 1
typedef unsigned char uint8;
#define UINT8(x) x
#define ato8(x)  atoi(x)
#define FMT8     "hh"
#elif SIZEOF_SHORT == 1
typedef unsigned short uint8;
#define UINT8(x) x
#define ato8(x)  atoi(x)
#define FMT8     "h"
#elif SIZEOF_INT == 1
typedef unsigned int uint8;
#define UINT8(x) x
#define ato8(x)  atoi(x)
#define FMT8     ""
#elif SIZEOF_LONG == 1
typedef unsigned long uint8;
#define UINT8(x) x
#define ato8(x)  atol(x)
#define FMT8     "l"
#elif SIZEOF_LONG_LONG == 1
typedef unsigned long long uint8;
#define UINT8(x) x ## LL
#define ato8(x)  atoll(x)
#define FMT8     "ll"
#else
#error "Unable to find an 8-bit data type"
#endif

#if SIZEOF_CHAR == 2
typedef unsigned char uint16;
#define UINT16(x) x
#define ato16(x)  atoi(x)
#define FMT16     "hh"
#elif SIZEOF_SHORT == 2
typedef unsigned short uint16;
#define UINT16(x) x
#define ato16(x)  atoi(x)
#define FMT16     "h"
#elif SIZEOF_INT == 2
typedef unsigned int uint16;
#define UINT16(x) x
#define ato16(x)  atoi(x)
#define FMT16     ""
#elif SIZEOF_LONG == 2
typedef unsigned long uint16;
#define UINT16(x) x
#define ato16(x)  atol(x)
#define FMT16     "l"
#elif SIZEOF_LONG_LONG == 2
typedef unsigned long long uint16;
#define UINT16(x) x ## LL
#define ato16(x)  atoll(x)
#define FMT16     "ll"
#else
#error "Unable to find a 16-bit data type"
#endif

#if SIZEOF_CHAR == 4
typedef unsigned char uint32;
#define UINT32(x) x
#define ato32(x)  atoi(x)
#define FMT32     "hh"
#elif SIZEOF_SHORT == 4
typedef unsigned short uint32;
#define UINT32(x) x
#define ato32(x)  atoi(x)
#define FMT32     "h"
#elif SIZEOF_INT == 4
typedef unsigned int uint32;
#define UINT32(x) x
#define ato32(x)  atoi(x)
#define FMT32     ""
#elif SIZEOF_LONG == 4
typedef unsigned long uint32;
#define UINT32(x) x
#define ato32(x)  atol(x)
#define FMT32     "l"
#elif SIZEOF_LONG_LONG == 4
typedef unsigned long long uint32;
#define UINT32(x) x ## LL
#define ato32(x)  atoll(x)
#define FMT32     "ll"
#else
#error "Unable to find a 32-bit data type"
#endif

#if SIZEOF_FLOAT == 4
typedef float real32;
#elif SIZEOF_DOUBLE == 4
typedef double real32;
#else
#error "Unable to find a 32-bit real data type"
#endif

#if SIZEOF_CHAR == 8
typedef char int64;
typedef unsigned char uint64;
#define UINT64(x) x
#define ato64(x)  atoi(x)
#define FMT64     "hh"
#elif SIZEOF_SHORT == 8
typedef short int64;
typedef unsigned short uint64;
#define UINT64(x) x
#define ato64(x)  atoi(x)
#define FMT64     "h"
#elif SIZEOF_INT == 8
typedef int int64;
typedef unsigned int uint64;
#define UINT64(x) x
#define ato64(x)  atoi(x)
#define FMT64     ""
#elif SIZEOF_LONG == 8
typedef long int64;
typedef unsigned long uint64;
#define UINT64(x) x
#define ato64(x)  atol(x)
#define FMT64     "l"
#elif SIZEOF_LONG_LONG == 8
typedef long long int64;
typedef unsigned long long uint64;
#define UINT64(x) x ## LL
#define ato64(x)  atoll(x)
#define FMT64     "ll"
#else
#error "Unable to find a 64-bit data type"
#endif

#if SIZEOF_FLOAT == 8
typedef float real64;
#elif SIZEOF_DOUBLE == 8
typedef double real64;
#else
#error "Unable to find a 64-bit real data type"
#endif

typedef unsigned long ulong;

#if SIZEOF_LONG == 1
#define UL_SET     (unsigned long)0xff
#define UL_DIV_VAL 3
#define UL_MOD_VAL 0x7
#define UL_BITS    8
#elif SIZEOF_LONG == 2
#define UL_SET     (unsigned long)0xffff
#define UL_DIV_VAL 4
#define UL_MOD_VAL 0xf
#define UL_BITS    16
#elif SIZEOF_LONG == 4
#define UL_SET     (unsigned long)0xffffffff
#define UL_DIV_VAL 5
#define UL_MOD_VAL 0x1f
#define UL_BITS    32
#elif SIZEOF_LONG == 8
#define UL_SET     (unsigned long)0xffffffffffffffffLL
#define UL_DIV_VAL 6
#define UL_MOD_VAL 0x3f
#define UL_BITS    64
#else
#error "Unsigned long is of an unsupported size"
#endif

#define UL_DIV(x)  (((unsigned int)x) >> UL_DIV_VAL)

#define UL_MOD(x)  (((unsigned int)x) &  UL_MOD_VAL)

/*------------------------------------------------------------------------------*/

union esuppl_u;

typedef union esuppl_u esuppl;

union esuppl_u {
  uint32   all;               
  struct {
 
    /* MASKED BITS */
    uint32 swapped        :1;  
    uint32 root           :1;  
    uint32 false          :1;  
    uint32 true           :1;  
    uint32 left_changed   :1;  
    uint32 right_changed  :1;  
    uint32 eval_00        :1;  
    uint32 eval_01        :1;  
    uint32 eval_10        :1;  
    uint32 eval_11        :1;  
    uint32 lhs            :1;  
    uint32 in_func        :1;  
    uint32 owns_vec       :1;  
    uint32 excluded       :1;  
    uint32 type           :3;  
    uint32 base           :3;  
    uint32 clear_changed  :1;  
    uint32 parenthesis    :1;  
    /* UNMASKED BITS */
    uint32 eval_t         :1;  
    uint32 eval_f         :1;  
    uint32 comb_cntd      :1;  
    uint32 exp_added      :1;  
    uint32 owned          :1;  
    uint32 gen_expr       :1;  
    uint32 prev_called    :1;  
    uint32 for_cntrl      :1;  
    uint32 nba            :1;  
  } part;
};

/*------------------------------------------------------------------------------*/

union ssuppl_u;

typedef union ssuppl_u ssuppl;

union ssuppl_u {
  uint32 all;
  struct {
    uint32 col            :16; 
    uint32 type           :5;  
    uint32 big_endian     :1;  
    uint32 excluded       :1;  
    uint32 not_handled    :1;  
    uint32 assigned       :1;  
    uint32 mba            :1;  
    uint32 implicit_size  :1;  
  } part;
};

/*------------------------------------------------------------------------------*/

union psuppl_u;

typedef union psuppl_u psuppl;

union psuppl_u {
  uint32 all;
  struct {
    uint32 order    : 16;      
    uint32 type     : 3;       
    uint32 owns_expr: 1;       
    uint32 dimension: 10;      
  } part;
};

/*------------------------------------------------------------------------------*/

union isuppl_u;

typedef union isuppl_u isuppl;

union isuppl_u {
  uint32 all;
  struct {
    uint32 scored      : 1;    
    uint32 excl_assign : 1;    
    uint32 excl_always : 1;    
    uint32 excl_init   : 1;    
    uint32 excl_final  : 1;    
    uint32 excl_pragma : 1;    
    uint32 assert_ovl  : 1;    
    uint32 vec_ul_size : 2;    
  } part;
};

/*------------------------------------------------------------------------------*/

union vsuppl_u;

typedef union vsuppl_u vsuppl;

union vsuppl_u {
  uint8   all;                    
  struct {
    uint8 type      :2;           
    uint8 data_type :2;           
    uint8 owns_data :1;           
    uint8 is_signed :1;           
    uint8 is_2state :1;           
    uint8 set       :1;           
  } part;
};

/*------------------------------------------------------------------------------*/

union fsuppl_u;

typedef union fsuppl_u fsuppl;

union fsuppl_u {
  uint8 all;                      
  struct {
    uint8 known : 1;              
  } part;
};

/*------------------------------------------------------------------------------*/

union asuppl_u;

typedef union asuppl_u asuppl;

union asuppl_u {
  uint8 all;                      
  struct {
    uint8 hit      : 1;           
    uint8 excluded : 1;           
  } part;
};

/*------------------------------------------------------------------------------*/
/*  STRUCTURE/UNION DECLARATIONS  */

union  expr_stmt_u;
struct exp_info_s;
struct str_link_s;
struct rv64_s;
struct rv32_s;
struct vector_s;
struct const_value_s;
struct vecblk_s;
struct exp_dim_s;
struct expression_s;
struct vsignal_s;
struct fsm_s;
struct fsm_table_arc_s;
struct fsm_table_s;
struct statement_s;
struct sig_link_s;
struct exp_link_s;
struct stmt_link_s;
struct stmt_loop_link_s;
struct statistic_s;
struct mod_parm_s;
struct inst_parm_s;
struct fsm_arc_s;
struct fsm_link_s;
struct race_blk_s;
struct func_unit_s;
struct funit_link_s;
struct inst_link_s;
struct sym_sig_s;
struct symtable_s;
struct static_expr_s;
struct vector_width_s;
struct exp_bind_s;
struct case_stmt_s;
struct case_gitem_s;
struct funit_inst_s;
struct tnode_s;

#ifdef HAVE_SYS_TIME_H
struct timer_s;
#endif

struct fsm_var_s;
struct fv_bind_s;
struct attr_param_s;
struct stmt_blk_s;
struct thread_s;
struct thr_link_s;
struct thr_list_s;
struct perf_stat_s;
struct port_info_s;
struct param_oride_s;
struct gen_item_s;
struct gitem_link_s;
struct typedef_item_s;
struct enum_item_s;
struct sig_range_s;
struct dim_range_s;
struct reentrant_s;
struct rstack_entry_s;
struct struct_union_s;
struct su_member_s;
struct profiler_s;
struct db_s;
struct sim_time_s;
struct comp_cdd_cov_s;
struct exclude_reason_s;
struct dim_and_nba_s;
struct nonblock_assign_s;

/*------------------------------------------------------------------------------*/
/*  STRUCTURE/UNION TYPEDEFS  */

typedef struct exp_info_s exp_info;

typedef struct str_link_s str_link;

typedef struct rv64_s rv64;

typedef struct rv32_s rv32;

typedef struct vector_s vector;

typedef struct const_value_s const_value;

typedef struct vecblk_s vecblk;

typedef struct exp_dim_s exp_dim;

typedef union expr_stmt_u expr_stmt;

typedef struct expression_s expression;

typedef struct vsignal_s     vsignal;

typedef struct fsm_s fsm;

typedef struct fsm_table_arc_s fsm_table_arc;

typedef struct fsm_table_s fsm_table;

typedef struct statement_s statement;

typedef struct sig_link_s sig_link;

typedef struct exp_link_s exp_link;

typedef struct stmt_link_s stmt_link;

typedef struct stmt_loop_link_s stmt_loop_link;

typedef struct statistic_s statistic;

typedef struct mod_parm_s mod_parm;

typedef struct inst_parm_s inst_parm;

typedef struct fsm_arc_s fsm_arc;

typedef struct fsm_link_s fsm_link;

typedef struct race_blk_s race_blk;

typedef struct func_unit_s func_unit;

typedef struct funit_link_s funit_link;

typedef struct inst_link_s inst_link;

typedef struct sym_sig_s sym_sig;

typedef struct symtable_s symtable;

typedef struct static_expr_s static_expr;

typedef struct vector_width_s vector_width;

typedef struct exp_bind_s exp_bind;

typedef struct case_stmt_s case_statement;

typedef struct case_gitem_s case_gitem;

typedef struct funit_inst_s funit_inst;

typedef struct tnode_s tnode;

#ifdef HAVE_SYS_TIME_H

typedef struct timer_s timer;
#endif

typedef struct fsm_var_s fsm_var;

typedef struct fv_bind_s fv_bind;

typedef struct attr_param_s attr_param;

typedef struct stmt_blk_s stmt_blk;

typedef struct thread_s thread;

typedef struct thr_link_s thr_link;

typedef struct thr_list_s thr_list;

typedef struct perf_stat_s perf_stat;

typedef struct port_info_s port_info;

typedef struct param_oride_s param_oride;

typedef struct gen_item_s gen_item;

typedef struct gitem_link_s gitem_link;

typedef struct typedef_item_s typedef_item;

typedef struct enum_item_s enum_item;

typedef struct sig_range_s sig_range;

typedef struct dim_range_s dim_range;

typedef struct reentrant_s reentrant;

typedef struct rstack_entry_s rstack_entry;

typedef struct struct_union_s struct_union;

typedef struct su_member_s su_member;

typedef struct profiler_s profiler;

typedef struct db_s db;

typedef struct sim_time_s sim_time;

typedef struct comp_cdd_cov_s comp_cdd_cov;

typedef struct exclude_reason_s exclude_reason;

typedef struct dim_and_nba_s dim_and_nba;

typedef struct nonblock_assign_s nonblock_assign;

/*------------------------------------------------------------------------------*/
/*  STRUCTURE/UNION DEFINITIONS  */

struct sim_time_s {
  unsigned int lo;                   
  unsigned int hi;                   
  uint64       full;                 
  bool         final;                
};

struct exp_info_s {
  char* name;                             
  char* op_str;                           
  bool  (*func)( expression*, thread*, const sim_time* );  
  struct {
    uint32 is_event:1;                    
    uint32 is_static:1;                   
    uint32 is_comb:2;                     
    uint32 is_unary:1;                    
    uint32 measurable:1;                  
    uint32 is_context_switch:1;           
    uint32 assignable:1;                  
    uint32 tmp_vecs:3;                    
    uint32 real_op:2;                     
  } suppl;                                
};

struct str_link_s {
  char*         str;                 
  char*         str2;                
  uint32        suppl;               
  uint32        suppl2;              
  uint8         suppl3;              
  vector_width* range;               
  str_link*     next;                
};

struct rv64_s {
  char*  str;                        
  real64 val;                        
};

struct rv32_s {
  char*  str;                        
  real32 val;                        
};

struct vector_s {
  unsigned int width;                
  vsuppl       suppl;                
  union {
    ulong** ul;                      
    rv64*   r64;                     
    rv32*   r32;                     
  } value;
};

struct const_value_s {
  vector* vec;                       
  int     base;                      
};

struct vecblk_s {
  vector vec[5];                     
  int    index;                      
}; 

struct exp_dim_s {
  int  curr_lsb;                     
  int  dim_lsb;                      
  bool dim_be;                       
  int  dim_width;                    
  bool last;                         
};

union expr_stmt_u {
  expression* expr;                  
  statement*  stmt;                  
};

struct expression_s {
  vector*      value;              
  exp_op_type  op;                 
  esuppl       suppl;              
  int          id;                 
  int          ulid;               
  int          line;               
  uint32       exec_num;           
  union {
    uint32 all;
    struct {
      uint32 last  : 16;           
      uint32 first : 16;           
    } part;
  } col;
  vsignal*     sig;                
  char*        name;               
  expr_stmt*   parent;             
  expression*  right;              
  expression*  left;               
  fsm*         table;              
  union {
    func_unit*   funit;            
    thread*      thr;              
    uint64*      scale;            
    vecblk*      tvecs;            
    exp_dim*     dim;              
    dim_and_nba* dim_nba;          
  } elem;
};

struct vsignal_s {
  int          id;                   
  char*        name;                 
  int          line;                 
  ssuppl       suppl;                
  vector*      value;                
  unsigned int pdim_num;             
  unsigned int udim_num;             
  dim_range*   dim;                  
  exp_link*    exp_head;             
  exp_link*    exp_tail;             
};

struct fsm_s {
  char*       name;                  
  int         line;                  
  expression* from_state;            
  expression* to_state;              
  fsm_arc*    arc_head;              
  fsm_arc*    arc_tail;              
  fsm_table*  table;                 
  bool        exclude;               
};

struct fsm_table_arc_s {
  asuppl       suppl;                
  unsigned int from;                 
  unsigned int to;                   
};

struct fsm_table_s {
  fsuppl          suppl;             
  unsigned int    id;                
  vector**        fr_states;         
  unsigned int    num_fr_states;     
  vector**        to_states;         
  unsigned int    num_to_states;     
  fsm_table_arc** arcs;              
  unsigned int    num_arcs;          
};

struct statement_s {
  expression* exp;                   
  statement*  next_true;             
  statement*  next_false;            
  statement*  head;                  
  int         conn_id;               
  func_unit*  funit;                 
  union {
    uint32  all;
    struct {
      /* Masked bits */
      uint32  head      :1;          
      uint32  stop_true :1;          
      uint32  stop_false:1;          
      uint32  cont      :1;          
      uint32  is_called :1;          
      uint32  excluded  :1;          
      uint32  final     :1;          
      uint32  ignore_rc :1;          
      /* Unmasked bits */
      uint32  added     :1;          
    } part;
  } suppl;                           
  unsigned int ppline;               
};

struct sig_link_s {
  vsignal*  sig;                     
  sig_link* next;                    
};

struct exp_link_s {
  expression* exp;                   
  exp_link*   next;                  
};

struct stmt_link_s {
  statement* stmt;                   
  stmt_link* next;                   
  bool       rm_stmt;                
};

struct stmt_loop_link_s {
  statement*      stmt;              
  int             id;                
  int             type;              
  stmt_loop_link* next;              
};

struct statistic_s {
  unsigned int line_hit;                    
  unsigned int line_excluded;               
  unsigned int line_total;                  
  unsigned int tog01_hit;                   
  unsigned int tog10_hit;                   
  unsigned int tog_excluded;                
  unsigned int tog_total;                   
  bool         tog_cov_found;               
  unsigned int comb_hit;                    
  unsigned int comb_excluded;               
  unsigned int comb_total;                  
  int          state_total;                 
  int          state_hit;                   
  int          arc_total;                   
  int          arc_hit;                     
  int          arc_excluded;                
  unsigned int race_total;                  
  unsigned int rtype_total[RACE_TYPE_NUM];  
  unsigned int assert_hit;                  
  unsigned int assert_excluded;             
  unsigned int assert_total;                
  unsigned int mem_wr_hit;                  
  unsigned int mem_rd_hit;                  
  unsigned int mem_ae_total;                
  unsigned int mem_tog01_hit;               
  unsigned int mem_tog10_hit;               
  unsigned int mem_tog_total;               
  bool         mem_cov_found;               
  unsigned int mem_excluded;                
  bool         show;                        
};

struct mod_parm_s {
  char*        name;                 
  static_expr* msb;                  
  static_expr* lsb;                  
  bool         is_signed;            
  expression*  expr;                 
  psuppl       suppl;                
  exp_link*    exp_head;             
  exp_link*    exp_tail;             
  vsignal*     sig;                  
  char*        inst_name;            
  mod_parm*    next;                 
};

struct inst_parm_s {
  vsignal*     sig;                  
  char*        inst_name;            
  mod_parm*    mparm;                
  inst_parm*   next;                 
};

struct fsm_arc_s {
  expression* from_state;            
  expression* to_state;              
  fsm_arc*    next;                  
};

struct fsm_link_s {
  fsm*      table;                   
  fsm_link* next;                    
};

struct race_blk_s {
  int       start_line;              
  int       end_line;                
  int       reason;                  
  race_blk* next;                    
};

struct func_unit_s {
  int             type;              
  char*           name;              
  char*           filename;          
  char*           version;           
  int             start_line;        
  int             end_line;          
  int             ts_unit;           
  uint64          timescale;         
  statistic*      stat;              
  sig_link*       sig_head;          
  sig_link*       sig_tail;          
  exp_link*       exp_head;          
  exp_link*       exp_tail;          
  statement*      first_stmt;        
  stmt_link*      stmt_head;         
  stmt_link*      stmt_tail;         
  fsm_link*       fsm_head;          
  fsm_link*       fsm_tail;          
  race_blk*       race_head;         
  race_blk*       race_tail;         
  mod_parm*       param_head;        
  mod_parm*       param_tail;        
  gitem_link*     gitem_head;        
  gitem_link*     gitem_tail;        
  func_unit*      parent;            
  funit_link*     tf_head;           
  funit_link*     tf_tail;           
  typedef_item*   tdi_head;          
  typedef_item*   tdi_tail;          
  enum_item*      ei_head;           
  enum_item*      ei_tail;           
  struct_union*   su_head;           
  struct_union*   su_tail;           
  exclude_reason* er_head;           
  exclude_reason* er_tail;           
  int             elem_type;         
  union {
    thread*   thr;                   
    thr_list* tlist;                 
  } elem;                            
};

struct funit_link_s {
  func_unit*  funit;                 
  funit_link* next;                  
};

struct inst_link_s {
  funit_inst* inst;                  
  bool        ignore;                
  bool        base;                  
  inst_link*  next;                  
};

struct sym_sig_s {
  vsignal* sig;                      
  int      msb;                      
  int      lsb;                      
  sym_sig* next;                     
};

struct symtable_s {
  sym_sig*     sig_head;             
  sym_sig*     sig_tail;             
  char*        value;                
  unsigned int size;                 
  symtable*    table[256];           
};

struct static_expr_s {
  expression* exp;                   
  int         num;                   
};

struct vector_width_s {
  static_expr*  left;                
  static_expr*  right;               
  bool          implicit;            
};

struct exp_bind_s {
  int              type;             
  char*            name;             
  int              clear_assigned;   
  int              line;             
  expression*      exp;              
  expression*      fsm;              
  func_unit*       funit;            
  exp_bind*        next;             
};

struct case_stmt_s {
  expression*     expr;              
  statement*      stmt;              
  unsigned int    line;              
  unsigned int    ppline;            
  case_statement* prev;              
};

struct case_gitem_s {
  expression*     expr;              
  gen_item*       gi;                
  int             line;              
  case_gitem*     prev;              
};

struct funit_inst_s {
  char*         name;                
  struct {
    uint8 name_diff : 1;             
    uint8 ignore    : 1;             
    uint8 gend_scope: 1;             
  } suppl;                           
  func_unit*    funit;               
  statistic*    stat;                
  vector_width* range;               
  inst_parm*    param_head;          
  inst_parm*    param_tail;          
  gitem_link*   gitem_head;          
  gitem_link*   gitem_tail;          
  funit_inst*   parent;              
  funit_inst*   child_head;          
  funit_inst*   child_tail;          
  funit_inst*   next;                
};

struct tnode_s {
  char*  name;                       
  char*  value;                      
  tnode* left;                       
  tnode* right;                      
  tnode* up;                         
};

#ifdef HAVE_SYS_TIME_H

struct timer_s {
  struct timeval start;              
  uint64         total;              
};
#endif

struct fsm_var_s {
  char*       funit;                 
  char*       name;                  
  expression* ivar;                  
  expression* ovar;                  
  vsignal*    iexp;                  
  fsm*        table;                 
  bool        exclude;               
  int         line;                  
  fsm_var*    next;                  
};

struct fv_bind_s {
  char*       sig_name;              
  expression* expr;                  
  char*       funit_name;            
  statement*  stmt;                  
  fv_bind*    next;                  
};

struct attr_param_s {
  char*       name;                  
  expression* expr;                  
  int         index;                 
  attr_param* next;                  
  attr_param* prev;                  
};

struct stmt_blk_s {
  statement* stmt;                   
  bool       remove;                 
  bool       seq;                    
  bool       cmb;                    
  bool       bassign;                
  bool       nassign;                
};

struct thread_s {
  func_unit* funit;                  
  thread*    parent;                 
  statement* curr;                   
  reentrant* ren;                    
  union {
    uint8 all;
    struct {
      uint8 state      : 2;          
      uint8 kill       : 1;          
      uint8 exec_first : 1;          
    } part;
  } suppl;
  unsigned   active_children;        
  thread*    queue_prev;             
  thread*    queue_next;             
  thread*    all_prev;               
  thread*    all_next;               
  sim_time   curr_time;              
};

struct thr_link_s {
  thread*   thr;                     
  thr_link* next;                    
};

struct thr_list_s {
  thr_link* head;                    
  thr_link* tail;                    
  thr_link* next;                    
};

struct perf_stat_s {
  uint32  op_exec_cnt[EXP_OP_NUM];   
  float   op_cnt[EXP_OP_NUM];        
};

struct port_info_s {
  int           type;                
  bool          is_signed;           
  sig_range*    prange;              
  sig_range*    urange;              
};

struct param_oride_s {
  char*        name;                 
  expression*  expr;                 
  param_oride* next;                 
};

struct gen_item_s {
  union {
    expression* expr;                
    vsignal*    sig;                 
    statement*  stmt;                
    funit_inst* inst;                
  } elem;                            
  union {
    uint32      all;                 
    struct {
      uint32    type       : 3;      
      uint32    conn_id    : 16;     
      uint32    stop_true  : 1;      
      uint32    stop_false : 1;      
      uint32    resolved   : 1;      
      uint32    removed    : 1;      
    } part;
  } suppl;
  char*         varname;             
  gen_item*     next_true;           
  gen_item*     next_false;          
};

struct gitem_link_s {
  gen_item*   gi;                    
  gitem_link* next;                  
};

struct typedef_item_s {
  char*         name;                
  bool          is_signed;           
  bool          is_handled;          
  bool          is_sizeable;         
  sig_range*    prange;              
  sig_range*    urange;              
  typedef_item* next;                
};

struct enum_item_s {
  vsignal*      sig;                 
  static_expr*  value;               
  bool          last;                
  enum_item*    next;                
};

struct sig_range_s {
  int           dim_num;             
  vector_width* dim;                 
  bool          clear;               
  bool          exp_dealloc;         
};

struct dim_range_s {
  int        msb;                    
  int        lsb;                    
};

struct reentrant_s {
  uint8*        data;                
  int           data_size;           
};

struct struct_union_s {
  char*         name;                
  int           type;                
  bool          packed;              
  bool          is_signed;           
  bool          owns_data;           
  int           tag_pos;             
  vector*       data;                
  su_member*    mem_head;            
  su_member*    mem_tail;            
  struct_union* next;                
};

struct su_member_s {
  int             type;              
  int             pos;               
  union {
    vsignal*      sig;               
    struct_union* su;                
    enum_item*    ei;                
    typedef_item* tdi;               
  } elem;                            
  su_member*      parent;            
  su_member*      next;              
};

struct profiler_s {
  char*  func_name;                  
#ifdef HAVE_SYS_TIME_H
  /*@null@*/ timer* time_in;         
#endif
  int    calls;                      
  int    mallocs;                    
  int    frees;                      
  bool   timed;                      
};

struct db_s {
  char*       top_module;            
  char**      leading_hierarchies;   
  int         leading_hier_num;      
  bool        leading_hiers_differ;  
  inst_link*  inst_head;             
  inst_link*  inst_tail;             
  funit_link* funit_head;            
  funit_link* funit_tail;            
  str_link*   fver_head;             
  str_link*   fver_tail;             
};

struct comp_cdd_cov_s {
  char*        cdd_name;                
  uint64       timesteps;               
  uint64       total_cps;               
  uint64       unique_cps;              
  uint64       score;                   
  bool         required;                
  ulong*       cps[CP_TYPE_NUM];        
  unsigned int cps_index[CP_TYPE_NUM];  
};

struct exclude_reason_s {
  char            type;                 
  int             id;                   
  time_t          timestamp;            
  char*           reason;               
  exclude_reason* next;                 
};

struct dim_and_nba_s {
  exp_dim*         dim;                 
  nonblock_assign* nba;                 
};

struct nonblock_assign_s {
  vsignal*        lhs_sig;              
  int             lhs_lsb;              
  int             lhs_msb;              
  vector*         rhs_vec;              
  int             rhs_lsb;              
  int             rhs_msb;              
  struct {
    uint8         is_signed : 1;        
    uint8         added     : 1;        
  } suppl;                              
};

define_exception_type(int);

extern struct exception_context the_exception_context[1];

#endif