C:/Simulate/Napados/Source/napa.h

Go to the documentation of this file.

 
#ifndef  NAPA_H
#define  NAPA_H
 
/* ****************************************************************************************************************************** */
 
/* This file is included in all source files of the NAPA compiler.                                                                */
 
 
/* ************************ VERSION ID ****************************************************************************************** */
 
/* The version ID has a prefix followed by a number:                                                                              */
 
/*        Prefix X means a BETA RELEASE.                                                                                          */
/*        Prefix V means a REGULAR VERSION.                                                                                       */
 
/* The number indicates the release number:                                                                                       */
 
/* M.NP   M indicates major release ID.                                                                                           */
/*        N indicates major change needing a correction of existing netlists.                                                     */
/*        P indicates minor change not impacting existing netlists.                                                               */
 
/* A lowercase letter suffix could be added (bug correction, cosmetic fix).                                                       */
 
/* V1 was supporting           Integer for digital and             Float for analog                                               */
/* V2 was supporting      Long Integer for digital and      Double Float for analog                                               */
/* V3 supports       Long Long Integer for digital and      Double Float for analog   and is  ANSI-c2x compliant                  */
 
 
#define NAPA_COMPILER_VERSION  "V4.50"                                        /* See date of release in file 'main.c'             */
 
 
/* ******************************************************************** AUTHOR: Yves Leduc (Email: yves.leduc.be@gmail.com) ***** */
 
/* Source could be compiled with any ANSI-C compiler c2x standard revision (ISO/IEC 9899:2018), 64 bits.                          */
/* MINGW GNU-C compiler (Windows 64 bits version) is the compiler used by the author to test the software.                        */
 
/* It is expected that an ANSI-C compliant compiler does not issue any warning.                                                   */
/* Exception: Warnings may be issued by some compiler as norm ISO does not allow arrays containing more than 65535 bytes.         */
 
/* NB: NAPA, in its current version, requests to run on a LITTLE-ENDIAN platform  (e.g Intel CPU)                                 */
 
 
/* ************************ COMPILATION OPTIONS ********************************************************************************* */
 
/* It is IMPORTANT to distinguish DOS based platform as the file pathname is not case sensitive.                                  */
/* This is the only conditional compilation in the code with 2 other exceptions:                                                  */
 
/* 1. It is possible to trigger some debugging information                      (to help code maintenance, see 'main.c')          */
/* 2. It is possible to compile some code allowing further user's extensions    (to extend NAPA to the extreme, see below)        */
 
 
/* ************************ PLATFORM IDENTIFICATION ***************************************************************************** */
 
/* Other platforms may be considered. A minimum requirement is an ANSI-C compiler, no memory limitation like the infamous 640K of */
/* DOS, and a file system like the UNIX system. Expect to have to rework a few items if the file system is different.             */
 
/* For example, these sources are compatible with DOS, only because the GNU compiler hides some of the differences between DOS    */
/* and UNIX file and directory naming. Using another compiler for DOS operations could cause incompatibilities. In any case,      */
/* scripts to run NAPA have to be rewritten.                                                                                      */
 
/* It is sometimes possible to detect the platform automatically. It is nevertheless requested here to use dedicated compiler     */
/* options to indicate the platform:                                                                                              */
 
/* For WINDOWS platform,        define   '__WIN64__'                                                                              */
/* For LINUX platform,          define   '__LINUX__'                                                                              */
/* For UNIX platform,           define   '__UNIX__'                                                                               */
 
 
#define IS_LINUX    1
#define IS_UNIX     2
#define IS_WIN64    4
 
#if defined(__LINUX__)
  #define PLATFORM  IS_LINUX
  #define MACHINE   "Linux"
#endif
 
#if defined(__UNIX__)
  #define PLATFORM  IS_UNIX
  #define MACHINE   " Unix"
#endif
 
#if defined(__WIN64__)
  #define PLATFORM  IS_WIN64
  #define MACHINE   "Win64"
#endif
 
#if !defined(PLATFORM)                                                        /* Unidentified Platform                            */
  #define PLATFORM  0
  #define MACHINE   " ??? "
#endif
 
 
/* ****************************************************************************************************************************** */
 
#define BIG_ENDIAN         0
#define LITTLE_ENDIAN      1
 
 
/* ** STANDARD I/O's ************************************************************************************************************ */
 
#define STDIN              stdin                                              /* Currently not used                               */
#define STDOUT             stdout                                             /* Output C file of the NAPA compiler               */
#define STDERR             stderr                                             /* Error and warning messages                       */
 
 
/* ** USER'S EXTENSION TO ADD NAPA_LOOP_OPTION to the simulator built by NAPA to respond to complex user's demand.                */
 
#define NAPA_LOOP_OPTION   NO                                                 /* Recommended:  NO                                 */
 
 
/* ** INCLUDE FILES ************************************************************************************************************* */
 
#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdbool.h>
 
 
/* ** NODES AND VARIABLES CODING ************************************************************************************************ */
 
#define NAPA_DIGITAL_TYPE     long long                                       /* DIGITAL node or variable                         */
#define NAPA_ANALOG_TYPE      double                                          /* ANALOG  node or variable                         */
#define NAPA_ITERATOR_TYPE    long                                            /* iterator                                         */
 
 
/* ** A FEW MATHEMATICAL CONSTANTS ********************************************************************************************** */
 
#define _PI_                  3.14159265358979323846264338327950288L          /*   pi                                             */
#define _PI2_                 1.57079632679489661923132169163975144L          /*   pi / 2                                         */
#define _PI4_                 0.78539816339744830961566084581987572L          /*   pi / 4                                         */
#define _PI8_                 0.39269908169872415480783042290993786L          /*   pi / 8                                         */
#define _2PI_                 6.28318530717958647692528676655900576L          /*   2 * pi                                         */
#define _E_                   2.71828182845904523536028747135266250L          /*   e                                              */
 
#define _D2R_                 (_PI_/180.0L)                                   /*   from degree to radian                          */
#define _R2D_                 (180.0L/_PI_)                                   /*   from radian to degree                          */
 
#define _SMALL_               (10.0*pow(10.0, - (double) DBL_DIG))            /* 'Small value', used e.g. to compare to 0.0       */
 
 
 
/* *** DEFAULT VALUES FOR NAPA SIMULATOR OUTPUT FORMAT ************************************************************************** */
 
#define I_FORMAT_S             " % 6lld"                                      /* Size corresponding to signed integer up to 16b   */
#define I_FORMAT_M             " % 11lld"                                     /* Size corresponding to signed integer up to 32b   */
#define I_FORMAT_L             " % 21lld"                                     /* Size corresponding to signed integer up to 64b   */
#define I_FORMAT_V             " % 17lld"                                     /* Export format must be coherent with S_FORMAT_V   */
 
#define X_FORMAT_S             " %#06llX"                                     /* Size corresponding to signed hex up to 16b       */
#define X_FORMAT_M             " %#010llX"                                    /* Size corresponding to signed hex up to 32b       */
#define X_FORMAT_L             " %#018llX"                                    /* Size corresponding to signed hex up to 64b       */
#define X_FORMAT_V             " %#017llX"                                    /* Export format must be coherent with S_FORMAT_V   */
 
#define R_FORMAT_S             " % .9e"
#define R_FORMAT_M             " % .12e"
#define R_FORMAT_L             " % .15e"
#define R_FORMAT_V             " % .9e"                                       /* Export format must be coherent with S_FORMAT_V   */
 
#define S_FORMAT_S             " %6s"
#define S_FORMAT_M             " %12s"
#define S_FORMAT_L             " %24s"
#define S_FORMAT_V             "%18s"
 
 
#define DEFAULT_I_FORMAT       I_FORMAT_M                                     /* Default of output integer format, medium size    */
#define DEFAULT_X_FORMAT       X_FORMAT_L                                     /* Default of output integer format, LARGE size     */
#define DEFAULT_R_FORMAT       R_FORMAT_M                                     /* Default of output real format,    medium size    */
#define DEFAULT_S_FORMAT       S_FORMAT_M                                     /* Default of output string format,  medium size    */
 
 
/* ** MACROS DEFINING INTERNAL ARRAY SIZES ************************************************************************************** */
 
/* This is important to use a line size -at least- equal to 10000 as NAPA is handling long                                        */
/* strings after expansion of signal names. More hierarchy, longer are the resulting names.                                       */
 
/* Smaller machine with limited memory could be impacted by large numbers here.                                                   */
 
#define MAXNODES              4095L                                           /*  max number of nodes                             */
#define MAXVARS               2047L                                           /*  max number of variables                         */
#define MAXUPDATES            2047L                                           /*  max number of updates                           */
#define MAXDECLARES           1023L                                           /*  max number of declarations                      */
#define MAXINSTANCES           511L                                           /*  max number of instantiation of cells            */
#define MAXFILECELLS           511L                                           /*  max number of cell file names recorded          */
#define MAXUSERTOOLS           511L                                           /*  max number of user's defined functions          */
#define MAXDECLARECOMMONS      255L                                           /*  max number of common declarations               */
#define MAXDIRS                255L                                           /*  max number of directives                        */
#define MAXFUNCTIONS           255L                                           /*  max number of functions to be recorded          */
#define MAXOPTIONS             127L                                           /*  max number of options to be recorded            */
#define MAXALIASES             127L                                           /*  max number of aliases                           */
#define MAXRECORDS             127L                                           /*  max number of array of pointers                 */
#define MAXOPCODES             127L                                           /*  max number of opcodes                           */
#define MAXPARMS               127L                                           /*  max number of cell parameters                   */
#define MAXSEGMENTS            127L                                           /*  max number of simulation segments               */
#define MAXARRAYS               63L                                           /*  max number of arrays                            */
#define MAXCOMMENTS             63L                                           /*  max number of comment lines                     */
#define MAXFILES                63L                                           /*  max number of files open (simulation)           */
#define MAXIOS                  63L                                           /*  max number of IO streams                        */
#define MAXPOSTS                63L                                           /*  max number of post-processing functions         */
#define MAXCMDLINES             63L                                           /*  max number of command line parameters           */
#define MAXDEBUGS               63L                                           /*  max number of debugs                            */
#define MAXHEADERS              63L                                           /*  max number of different headers                 */
#define MAXINJECTS              63L                                           /*  max number of inject to node                    */
#define MAXSTUCKS               63L                                           /*  max number of nodes stuck to a value            */
#define MAXDEPTH                31L                                           /*  max depth for hierarchy                         */
#define MAXEXPORTS              31L                                           /*  max number of exported variables                */
#define MAXGROUPS               31L                                           /*  max number of post-processing groups            */
 
#define LINLENGTH            16383L                                           /*  max length of a line                            */
#define STRLENGTH             2047L                                           /*  max length of a string                          */
 
 
/* ****************************************************************************************************************************** */
 
/* ** MACROS DEFINING NAPA NODE KINDS ******************************************************************************************* */
 
#define UNKNOWN_KIND           (-1)
 
#define ADC_KIND                 1
#define ALGEBRA_KIND             2
#define ALU_KIND                 3
#define AND_KIND                 4
#define AVERAGE_KIND             5
#define BSHIFT_KIND              6
#define BTOI_KIND                7
#define BUF_KIND                 8
#define BWAND_KIND               9
#define BWINV_KIND              10
#define BWNAND_KIND             11
#define BWNOR_KIND              12
#define BWOR_KIND               13
#define BWXNOR_KIND             14
#define BWXOR_KIND              15
#define CELL_KIND               16
#define CHG_KIND                17
#define CLIP_KIND               18
#define CLOCK_KIND              19
#define COMP_KIND               20
#define CONST_KIND              21
#define COPY_KIND               22
#define COS_KIND                23
#define COS2_KIND              924                                            /* Internal use, issued during process              */
#define DAC_KIND                25
#define DALGEBRA_KIND           26
#define DC_KIND                 27
#define DELAY_KIND              28
#define DELAY1_KIND            929                                            /* Internal use, issued during process              */
#define DELAY2_KIND            930                                            /* Internal use, issued during process              */
#define DELAY3_KIND            931                                            /* Internal use, issued during process              */
#define DIFFERENTIATOR_KIND     32
#define DIV_KIND                33
#define DTOI_KIND               34
#define DTOOL_KIND              35
#define DUSER_KIND              36
#define EQUAL_KIND              37
#define FZAND_KIND              38
#define FZBUF_KIND              39
#define FZINV_KIND              40
#define FZNAND_KIND             41
#define FZNOR_KIND              42
#define FZOR_KIND               43
#define FZXNOR_KIND             44
#define FZXOR_KIND              45
#define GAIN_KIND               46
#define GEN_KIND                47
#define HOLD_KIND               48
#define IALGEBRA_KIND           49
#define INTEGRATOR_KIND         50
#define INV_KIND                51
#define ITOB_KIND               52
#define ITOD_KIND               53
#define ITOOL_KIND              54
#define IUSER_KIND              55
#define LATCH_KIND              56
#define LSHIFT_KIND             57
#define MAX_KIND                58
#define MERGE_KIND              59
#define MIN_KIND                60
#define MOD_KIND                61
#define MULLER_KIND             63
#define MUX_KIND                64
#define NAND_KIND               65
#define NOISE_KIND              66
#define NOR_KIND                67
#define OFFSET_KIND             68
#define OR_KIND                 69
#define OSC_KIND                70
#define POLY_KIND               71
#define PROD_KIND               72
#define QUANT_KIND              73
#define RAM_KIND                74
#define RAM2_KIND               75
#define RECT_KIND               76
#define RELAY_KIND              77
#define RIP_KIND                78
#define ROM_KIND                79
#define ROM2_KIND               80
#define RSHIFT_KIND             81
#define RSHIFT1_KIND            82
#define RSHIFT2_KIND            83
#define SET_KIND               984                                            /*  Internal use, issued during process             */
#define SIGN_KIND               85
#define SIN_KIND                86
#define SIN2_KIND              987                                            /*  Internal use, issued during process             */
#define SQUARE_KIND             88
#define STEP_KIND               89
#define SUB_KIND                90
#define SUM_KIND                91
#define TEST_KIND               92
#define TOGGLE_KIND             93
#define TRACK_KIND              94
#define TRIANGLE_KIND           95
#define TRIG_KIND               96
#define UADC_KIND               97
#define UDAC_KIND               98
#define WSUM_KIND               99
#define XNOR_KIND              100
#define XOR_KIND               101
#define ZERO_KIND              102
 
 
/* ****************************************************************************************************************************** */
 
#define UNDEFINED              (-1)
#define UNKNOWN_TYPE             0
 
 
/* ** MACROS DEFINING DATA TYPES ************************ It is important that the definitions are power of 2 ******************* */
 
#define DIGITAL_DATA_TYPE        1                                            /*  2^0                                             */
#define ANALOG_DATA_TYPE         2                                            /*  2^1                                             */
#define STRING_DATA_TYPE         4                                            /*  2^2                                             */
#define HEX_DATA_TYPE            8                                            /*  2^3                                             */
#define BOOLEAN_DATA_TYPE       16                                            /*  2^4                                             */
#define NO_DATA_TYPE            32                                            /*  2^5                                             */
 
#define CONSTANT_TYPE           64                                            /*  2^6                                             */
 
 
/* ** MACROS DEFINING SAMPLING TYPES ******************************************************************************************** */
 
#define MAIN_SEGMENT_TYPE        1
#define NOMINAL_SEGMENT_TYPE     2
#define DECIMATE_SEGMENT_TYPE    3
#define INTERPOLATE_SEGMENT_TYPE 4
#define DROP_SEGMENT_TYPE        5
 
 
/* ** MACROS DEFINING I/O TYPES ************************************************************************************************* */
 
#define INPUT_TYPE               1
#define OUTPUT_TYPE              2
 
 
/* ** MACROS USED DURING SYNTAX VERIFICATION ************ It is important that the definitions are power of 2 ******************* */
 
#define DONTCARE                 0
#define NODE                     1                                            /*  2^0                                             */
#define VARIABLE                 2                                            /*  2^1                                             */
#define NUMBER                   4                                            /*  2^2                                             */
#define STRING                   8                                            /*  2^3                                             */
#define NOSIGN                  16                                            /*  2^4                                             */
 
 
/* ** MACRO FUNCTIONS *********************************************************************************************************** */
 
#define ABS(x)                   ((0.0<(x))?(x):-(x))
 
#define MIN(x,y)                 (((x)<(y))?(x):(y))
#define MAX(x,y)                 (((x)>(y))?(x):(y))
 
#define ISEQUAL(x,y)             (fabs(((x)-(y)))<=(_SMALL_*(fabs(x)+fabs(y))))
#define ISNOTEQUAL(x,y)          (fabs(((x)-(y)))> (_SMALL_*(fabs(x)+fabs(y))))
 
#define D2I(x)                   ((0.0<(x))?(long)((x)+0.5):(long)((x)-0.5))
#define I2D(n)                   ((double)(n))
 
#define ISNOTSMALL(x)            (fabs(x)> _SMALL_)
#define ISSMALL(x)               (fabs(x)<=_SMALL_)
 
#define ISINTEGER(x)             ISEQUAL(I2D(D2I(x)),(x))                     /* check the value, regardless of the type          */
#define ISNOTINTEGER(x)          ISNOTEQUAL(I2D(D2I(x)),(x))                  /* check the value, regardless of the type          */
 
#define _STR_(x)                 #x
#define STRINGIFY(x)             _STR_(x)                                     /* stringification                                  */
 
#define ISEMPTY(s)               (0==strlen(s))                               /* test on string                                   */
#define ISNOTEMPTY(s)            (0!=strlen(s))
 
#define LENGTH(s)                ((long)strlen(s))                            /* length of a string                               */
 
 
/* ** OTHER MACROS ************************************************************************************************************** */
 
#define FALSE                    0                                            /*  boolean                                         */
#define TRUE                     1
 
#define MAYBE                  (-1)                                           /* 3 levels                                         */
#define NO                       0
#define YES                      1
 
#define WARNING                  1                                            /*  Error level                                     */
#define ERROR                    2
 
#define NO_EXPAND                0                                            /*  File expansion flag                             */
#define EXPAND                   1
 
#define LEFT_VALUE             (-1)                                           /*  Left or right value identifier                  */
#define RIGHT_VALUE              1
 
 
/* *** DATA STRUCTURES ********************************************************************************************************** */
 
/* These data types are used to define intermediate lists built on the fly by the compiler.                                       */
 
/*     Data Type               List                                   Iterator                                                    */
 
/*     ALIAS_TYPE              Alias_List[MAXARRAYS]                  Num_Aliases                                                 */
/*     ARRAY_TYPE              Array_List[MAXARRAYS]                  Num_Arrays                                                  */
/*     CMDLINE_TYPE            Cmdline_List[MAXCMDLINES]              Num_Cmdlines                                                */
/*     DEBUG_TYPE              Debug_List[MAXDEBUGS]                  Num_Debugs                                                  */
/*     DECLARE_TYPE            Declare_List[MAXDECLARES]              Num_Declares                                                */
/*     DECLARE_COMMON_TYPE     Declare_Common_List[MAXDECLARECOMMONS] Num_Declare_Commons                                         */
/*     DIRECTIVE_TYPE          Directive_List[MAXDIRS]                Num_Directives                                              */
/*     DUMP_TYPE               Dump_List                              .                                                           */
/*     EXPORT_TYPE             Export_List[MAXEXPORTS]                Num_Exports                                                 */
/*     FUNCTION_TYPE           Function_List[MAXFUNCTIONS]            Num_Functions                                               */
/*     GATEWAY_TYPE            Gateway_List                           .                                                           */
/*     GROUP_TYPE              Group_List[MAXGROUPS]                  Num_Groups                                                  */
/*     HEADER_TYPE             Header_List[MAXHEADERS]                Num_Headers                                                 */
/*     INJECT_TYPE             Inject_List[MAXINJECTS]                Num_Injects                                                 */
/*     INTERLUDE_TYPE          Interlude_List                         .                                                           */
/*     IO_TYPE                 IO_List[MAXIOS]                        Num_IOs                                                     */
/*     LOAD_TYPE               Load_List                              .                                                           */
/*     NODE_TYPE               Node_List[MAXNODES]                    Num_Nodes                                                   */
/*     OPCODE_TYPE             Opcode_List[MAXOPCODES]                Num_Opcodes                                                 */
/*     PING_TYPE               Ping_List                              .                                                           */
/*     POST_TYPE               Post_List[MAXPOSTS]                    Num_Posts                                                   */
/*     RECORD_TYPE             Record_List[MAXRECORDS]                Num_Records                                                 */
/*     SAMPLING_TYPE           Sampling_List                          .                                                           */
/*     RANDOMSEED_TYPE         Seed_List                              .                                                           */
/*     SEGMENT_TYPE            Segment_List[MAXSEGMENTS]              Num_Segments                                                */
/*     STUCK_TYPE              Stuck_List[MAXSTUCKS]                  Num_Stucks                                                  */
/*     TERMINATE_TYPE          Terminate_List                         .                                                           */
/*     UPDATE_TYPE             Update_List[MAXUPDATES]                Num_Updates                                                 */
/*     USERTOOL_TYPE           UserTool_List[MAXUSERTOOLS]            Num_UserTools                                               */
/*     VAR_TYPE                Var_List[MAXVARS]                      Num_Vars                                                    */
 

typedef struct {
  char  *name;                             
  char  *aliasof;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} ALIAS_TYPE;

typedef struct {
  char  *variant;                          
  char  *name;                             
  char  *size;                             
  long   type;                             
  long   kind;                             
  long   port;                             
  char  *fname;                            
  int    used;                             
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} ARRAY_TYPE;

typedef struct {
  char  *parms;                            
  char  *comment;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} CMDLINE_TYPE;

typedef struct {
  char  *name;                             
  long   usage;                            
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} DEBUG_TYPE;

typedef struct {
  char  *name;                             
  long   number;                           
  long   type;                             
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} DECLARE_TYPE;

typedef struct {
  char  *value;                            
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} DECLARE_COMMON_TYPE;

typedef struct {
  char  *name;                             
  char  *parms;                            
  char  *value;                            
  int    used;                             
  int    function;                         
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} DIRECTIVE_TYPE;

typedef struct {
  char  *fname;                            
  char  *condition;                        
  int    event;                            
  long   segment;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} DUMP_TYPE;

typedef struct {
  char  *name;                             
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} EXPORT_TYPE;
 
typedef struct {
  char  *table;                            
  long   number;                           
} FUNCTION_TYPE;

typedef struct {
  long   counter;                          
  long   segment;                          
} GATEWAY_TYPE;

typedef struct {
  char  *ifname;                           
  char  *ofname;                           
  long   ID;                               
} GROUP_TYPE;

typedef struct {
  char  *fname;                            
  char  *option;                           
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} HEADER_TYPE;

typedef struct {
  char  *name;                             
  char  *value;                            
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} INJECT_TYPE;

typedef struct {
  char  *fname;                            
  char  *element;                          
  char  *condition;                        
  long   type;                             
  int    event;                            
  long   segment;                          
  double rate;                             
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} IO_TYPE;

typedef struct {
  char   *fname;                           
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} LOAD_TYPE;

typedef struct {
  char  *name1;                            
  char  *name2;                            
  char  *tag;                              
  char  *value;                            
  char  *option;                           
  long  *depend;                           
  long   ID;                               
  long   ID2;                              
  long   type;                             
  long   declare;                          
  int    inject;                           
  long   kind;                             
  long   width;                            
  int    delayed;                          
  int    aliased;                          
  int    determined;                       
  int    used;                             
  int    init;                             
  int    errflag;                          
  int    flag;                             
  long   segment;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} NODE_TYPE;

typedef struct {
  long   number1;                          
  long   number2;                          
  long   number3;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} INTERLUDE_TYPE;

typedef struct {
  char  *name;                             
  long   code;                             
  char  *function;                         
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} OPCODE_TYPE;
 
typedef struct {
  char   funstr[LINLENGTH];                
  char   funset[MAXFUNCTIONS][STRLENGTH];  
  char   optstr[LINLENGTH];                
  char   optset[MAXFUNCTIONS][STRLENGTH];  
  char   valstr[LINLENGTH];                
  char   valset[MAXFUNCTIONS][STRLENGTH];  
  long   nfun;                             
  long   nopt;                             
  long   nval;                             
  long   maxid;                            
} OPTION_TYPE;

typedef struct {
  char  *fname;                            
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} PING_TYPE;

typedef struct {
  char  *origin;                           
  char  *function;                         
  char  *option;                           
  char  *ofname;                           
  long   number;                           
  char  *parms;                            
  long   segment;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
  long   ID;                               
} POST_TYPE;

typedef struct {
  long   rndseed;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} RANDOMSEED_TYPE;

typedef struct {
  char  *name;                             
  long   size;                             
  long   nrow;                             
  long   ncol;                             
  long   ID;                               
  long  *depend;                           
  int    determined;                       
  int    used;                             
  int    nflag;                            
  int    pflag;                            
  char  *list1;                            
  char  *list2;                            
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} RECORD_TYPE;
 
typedef struct {
  double frequency;                        
  double period;                           
  char  *formula;                          
  long   segment;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} SAMPLING_TYPE;

typedef struct {
  char  *value;                            
  long   type;                             
  long   ref;                              
  int    used1;                            
  int    used2;                            
  int    used3;                            
  int    periodic;                         
  double offset;                           
  double rate;                             
  double frequency;                        
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} SEGMENT_TYPE;

typedef struct {
  char  *name;                             
  char  *value;                            
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} STUCK_TYPE;

typedef struct {
  char  *condition;                        
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} TERMINATE_TYPE;

typedef struct {
  char  *name;                             
  char  *value;                            
  char  *condition;                        
  long   ID;                               
  long  *depend;                           
  int    determined;                       
  int    constant;                         
  int    event;                            
  long   segment;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} UPDATE_TYPE;

typedef struct {
  char  *name;                             
  char  *function;                         
  char  *parms;                            
  char  *option;                           
  long   kind;                             
  long   number;                           
  long   mailbox;                          
  long   ID;                               
  long   node;                             
  long   segment;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} USERTOOL_TYPE;

typedef struct {
  char  *name1;                            
  char  *name2;                            
  char  *comment;                          
  char  *value;                            
  long  *depend;                           
  long   external;                         
  long   ID;                               
  long   type;                             
  long   declare;                          
  long   width;                            
  int    aliased;                          
  int    determined;                       
  int    used;                             
  int    constant;                         
  int    event;                            
  long   segment;                          
  unsigned long mline[MAXDEPTH];           
  unsigned long mfile[MAXDEPTH];           
} VAR_TYPE;
 
 
/* *** GLOBAL VARIABLES ********************************************************************************************************* */
 
/* This file 'napa.h' is included in all source files of the NAPA compiler. To avoid multiple declarations of variables, macro    */
/* EXTERN is defined at the beginning of each C file: in file 'main.c', its definition corresponds to a blank definition, in all  */
/* other files, its definition corresponds to 'extern' C identifier.                                                              */
 
EXTERN long    Max_Depth;
 
EXTERN long    Num_Aliases;
EXTERN long    Num_Arrays;
EXTERN long    Num_Asserts;
EXTERN long    Num_Calls;
EXTERN long    Num_Cells;
EXTERN long    Num_Cmdlines;
EXTERN long    Num_Comments;
EXTERN long    Num_Declare_Commons;
EXTERN long    Num_Consts;
EXTERN long    Num_Creates;
EXTERN long    Num_Debugs;
EXTERN long    Num_Declares;
EXTERN long    Num_Delays;
EXTERN long    Num_Directives;
EXTERN long    Num_Exports;
EXTERN long    Num_FileCells;
EXTERN long    Num_Functions;
EXTERN long    Num_Generators;
EXTERN long    Num_Groups;
EXTERN long    Num_Headers;
EXTERN long    Num_Inits;
EXTERN long    Num_Injects;
EXTERN long    Num_Instances;
EXTERN long    Num_IOs;
EXTERN long    Num_Macros;
EXTERN long    Num_Nodes;
EXTERN long    Num_Nulls;
EXTERN long    Num_Opcodes;
EXTERN long    Num_Posts;
EXTERN long    Num_Records;
EXTERN long    Num_Redefs;
EXTERN long    Num_Restarts;
EXTERN long    Num_Segments;
EXTERN long    Num_Stucks;
EXTERN long    Num_Tools;
EXTERN long    Num_Updates;
EXTERN long    Num_UserTools;
EXTERN long    Num_Vars;
EXTERN long    Num_Voids;
 
 
/* These flags are set on the fly to record information used to build the NAPA compiler                                           */
 
EXTERN int     Antithetic_Flag;                                               /* random stream                                    */
EXTERN int     Array_Flag;                                                    /* ram/rom usage                                    */
EXTERN int     Assert_Flag;                                                   /* assert usage                                     */
EXTERN int     Call_Flag;                                                     /* call usage                                       */
EXTERN int     Cmdline_Flag;                                                  /* command line usage                               */
EXTERN int     Comment_Flag;                                                  /* comment                                          */
EXTERN int     Debug_Flag;                                                    /* use of debug                                     */
EXTERN int     Delayed_Flag;                                                  /* use of &delayed                                  */
EXTERN int     Directive_Flag;                                                /* use of directive                                 */
EXTERN int     Drop_Flag;                                                     /* drop instruction                                 */
EXTERN int     Dump_Flag;                                                     /* dump instruction                                 */
EXTERN int     Error_Flag;                                                    /* error detection                                  */
EXTERN int     Expand_Flag;                                                   /* input expansion                                  */
EXTERN int     Export_Flag;                                                   /* export variable                                  */
EXTERN int     Fs_Flag;                                                       /* sampling frequency                               */
EXTERN int     Fs_Ext_Flag;                                                   /* sampling frequency command line                  */
EXTERN int     Function_Flag;                                                 /* function usage                                   */
EXTERN int     Gateway_Flag;                                                  /* gateway after assert                             */
EXTERN int     Hierarchy_Flag;                                                /* hierarchical netlist                             */
EXTERN int     Inject_Flag;                                                   /* inject instruction                               */
EXTERN int     Input_Flag;                                                    /* input instruction                                */
EXTERN int     Interpolate_Flag;                                              /* interpolation                                    */
EXTERN int     List_Flag;                                                     /* list node and var                                */
EXTERN int     Load_Flag;                                                     /* load instruction                                 */
EXTERN int     Loop_Flag;                                                     /* build main loop                                  */
EXTERN int     Multdelay_Flag;                                                /* multiple delay usage                             */
EXTERN int     Interlude_Flag1;                                               /* interlude usage                                  */
EXTERN int     Interlude_Flag2;                                               /* interlude usage                                  */
EXTERN int     Interlude_Flag3;                                               /* interlude usage                                  */
EXTERN int     Option_Flag;                                                   /* option                                           */
EXTERN int     Output_Flag;                                                   /* output instruction                               */
EXTERN int     Periodic_Flag;                                                 /* periodic sampling                                */
EXTERN int     Ping_Flag;                                                     /* ping instruction                                 */
EXTERN int     Pointer_Flag;                                                  /* array of pointers                                */
EXTERN int     Post_Flag;                                                     /* postprocessor instruction                        */
EXTERN int     Seed_Flag;                                                     /* seed flag for random number                      */
EXTERN int     Stuck_Flag;                                                    /* node stuck use                                   */
EXTERN int     Synchro_Flag;                                                  /* tool synchronisation                             */
EXTERN int     Terminate_Flag;                                                /* terminate instruction                            */
EXTERN int     Title_Flag;                                                    /* title instruction                                */
EXTERN int     Tool_Index_Flag;                                               /* TOOL_INDEX flag                                  */
EXTERN int     Tool_Flag;                                                     /* tool flag                                        */
EXTERN int     Ts_Flag;                                                       /* sampling period                                  */
EXTERN int     Ts_Ext_Flag;                                                   /* sampling period command line                     */
EXTERN int     Update_Flag;                                                   /* update flag                                      */
EXTERN int     User_Flag;                                                     /* user flag                                        */
EXTERN int     UserTool_Flag;                                                 /* tool/user flag                                   */
EXTERN int     Verbose_Flag;                                                  /* verbose mode flag                                */
EXTERN int     Warning_Flag;                                                  /* warning                                          */
 
EXTERN char    Last_Instruction[STRLENGTH];                                   /* trace previous instruction                       */
EXTERN char    Last_Postprocess[STRLENGTH];                                   /* trace previous postprocessor                     */
 
EXTERN char    E_Format[STRLENGTH];
EXTERN char    I_Format[STRLENGTH];
EXTERN char    R_Format[STRLENGTH];
EXTERN char    S_Format[STRLENGTH];
EXTERN char    V_Format[STRLENGTH];
EXTERN char    X_Format[STRLENGTH];
 
EXTERN char    I_String_Format[STRLENGTH];
EXTERN char    R_String_Format[STRLENGTH];
EXTERN char    S_String_Format[STRLENGTH];
EXTERN char    X_String_Format[STRLENGTH];
 
EXTERN char    NAPA_Command_Line[STRLENGTH];
 
EXTERN char   *User_Name;
 
EXTERN char   *Main_File_Name;
 
EXTERN char   *Generator_Lib_Name;
EXTERN char   *Header_Lib_Name;
EXTERN char   *Net_Lib_Name;
 
EXTERN char    Void_List_Name[STRLENGTH];
 
EXTERN char    Export0_Head_String[LINLENGTH];
EXTERN char    Export1_Head_String[LINLENGTH];
EXTERN char    Export0_List_String[LINLENGTH];
EXTERN char    Export1_List_String[LINLENGTH];
 
EXTERN char    Cmdline_String[STRLENGTH];
EXTERN char    Comment_String[MAXCOMMENTS][LINLENGTH];                        /* MAXCOMMENTS strings of LINLENGTH characters      */
EXTERN char    Short_Title_String[2*STRLENGTH];
EXTERN char    Title_String[2*STRLENGTH];
 
EXTERN char    Root_String[STRLENGTH];
 
EXTERN char    Cur_Fil_Name[MAXDEPTH][STRLENGTH];                             /* MAXDEPTH strings of STRLENGTH characters         */
EXTERN char    Cur_Lib_Name[MAXDEPTH][STRLENGTH];                             /* MAXDEPTH strings of STRLENGTH characters         */
 
EXTERN long    Cell_Num_Parms[MAXDEPTH];                                      /* number of parameters                             */
 
EXTERN char    Cell_Plist[MAXDEPTH][MAXPARMS][LINLENGTH];                     /* parms list (cell)                                */
EXTERN char    Inst_Plist[MAXDEPTH][MAXPARMS][LINLENGTH];                     /* parms list (instance)                            */
 
EXTERN char   *Record_Instantiation_Name[MAXINSTANCES];                       /* record instance names                            */
EXTERN char   *Record_Cell_File_Table[MAXFILECELLS];                          /* record cell files                                */
EXTERN long    Record_Cell_File_Usage[MAXFILECELLS];                          /* number of use                                    */
 
EXTERN char    Segment_Condition[MAXSEGMENTS][STRLENGTH];                     /* MAXSEGMENTS strings of STRLENGTH characters      */
 
EXTERN char    Cell_Name_Prefix[MAXDEPTH][STRLENGTH];                         /* MAXDEPTH strings of STRLENGTH characters         */
 
EXTERN char    Condition_Assign[LINLENGTH];                                   /* temporary storage for condition assignation      */
 
EXTERN ALIAS_TYPE          Alias_List[MAXALIASES];                            /* index: Num_Aliases                               */
EXTERN ARRAY_TYPE          Array_List[MAXARRAYS];                             /* index: Num_Arrays                                */
EXTERN CMDLINE_TYPE        Cmdline_List[MAXCMDLINES];                         /* index: Num_Cmdlines                              */
EXTERN DEBUG_TYPE          Debug_List[MAXDEBUGS];                             /* index: Num_Debugs                                */
EXTERN DECLARE_TYPE        Declare_List[MAXDECLARES];                         /* index: Num_Declares                              */
EXTERN DECLARE_COMMON_TYPE Declare_Common_List[MAXDECLARECOMMONS];            /* index: Num_Declare_Commons                       */
EXTERN DIRECTIVE_TYPE      Directive_List[MAXDIRS];                           /* index: Num_Directives                            */
EXTERN EXPORT_TYPE         Export_List[MAXEXPORTS];                           /* index: Num_Exports                               */
EXTERN FUNCTION_TYPE       Function_List[MAXFUNCTIONS];                       /* index: Num_Functions                             */
EXTERN GROUP_TYPE          Group_List[MAXGROUPS];                             /* index: Num_Groups                                */
EXTERN HEADER_TYPE         Header_List[MAXHEADERS];                           /* index: Num_Headers                               */
EXTERN INJECT_TYPE         Inject_List[MAXINJECTS];                           /* index: Num_Injects                               */
EXTERN IO_TYPE             IO_List[MAXIOS];                                   /* index: Num_IOs                                   */
EXTERN NODE_TYPE           Node_List[MAXNODES];                               /* index: Num_Nodes                                 */
EXTERN OPCODE_TYPE         Opcode_List[MAXOPCODES];                           /* index: Num_Opcodes                               */
EXTERN POST_TYPE           Post_List[MAXPOSTS];                               /* index: Num_Posts                                 */
EXTERN RECORD_TYPE         Record_List[MAXRECORDS];                           /* index: Num_Records                               */
EXTERN SEGMENT_TYPE        Segment_List[MAXSEGMENTS];                         /* index: Num_Segments                              */
EXTERN STUCK_TYPE          Stuck_List[MAXSTUCKS];                             /* index: Num_Stucks                                */
EXTERN UPDATE_TYPE         Update_List[MAXUPDATES];                           /* index: Num_Updates                               */
EXTERN USERTOOL_TYPE       UserTool_List[MAXUSERTOOLS];                       /* index: Num_UserTools                             */
EXTERN VAR_TYPE            Var_List[MAXVARS];                                 /* index: Num_Vars                                  */
 
EXTERN DUMP_TYPE           Dump_List;
EXTERN GATEWAY_TYPE        Gateway_List;
EXTERN INTERLUDE_TYPE      Interlude_List;
EXTERN LOAD_TYPE           Load_List;
EXTERN OPTION_TYPE         Option_List;
EXTERN PING_TYPE           Ping_List;
EXTERN SAMPLING_TYPE       Sampling_List;
EXTERN RANDOMSEED_TYPE     Seed_List;
EXTERN TERMINATE_TYPE      Terminate_List;
 
EXTERN double              Simulation_Rate;
 
EXTERN long                Delay_Input[MAXNODES];                             /* pointer: delay_num                               */
 
EXTERN time_t              NAPA_Time;                                         /* compilation time                                 */
 
EXTERN double              NAPA_Compile_Start;                                /* compilation time                                 */
EXTERN double              NAPA_Compile_Stop;                                 /* compilation time                                 */
EXTERN char                NAPA_Compile_Time[33];                             /* compilation time                                 */
 
EXTERN char                NAPA_Identification_String[35];                    /* compiler time stamp                              */
EXTERN char                NAPA_Job_ID[19];                                   /* job ID                                           */
 
 
/* ****************************************************************************************************************************** */
#endif                                                                                                                  /* NAPA_H */
/* end of file                                                                                                                    */