C:/Simulate/Napados/Source/fc.c

Go to the documentation of this file.

/* ** MISCELLANEOUS FUNCTIONS DEFINITIONS *************************************************************************************** */
 
#undef  EXTERN
#define EXTERN extern
 
#include "./napa.h"
#include "./proto.h"
 
 
/* *** In this file: ************************************************************************************************************ */
 
/* char *get_a_line(char *buf, unsigned long *nl,FILE *fp, unsigned long *mlin, const unsigned long *mfil)                        */
 
/* double GCD(double n1, double n2)                                                                                               */
/* double LCM(double n1, double n2)                                                                                               */
 
/* int  test_endianness(void)                                                                                                     */
/* int  verify_rshift(void)                                                                                                       */
 
/* long f2printf(FILE *fp1, FILE *fp2, char *fmt, ...)                                                                            */
/* long process_condition(char *str, const unsigned long *mlin, const unsigned long *mfil)                                        */
 
/* void build_condition(char *cond, const unsigned long *ml, const unsigned long *mf)                                             */
/* void cat_file(const char *fnam, const char *type, long command, const unsigned long *mlin, const unsigned long *mfil)          */
/* void check_array_usage(void)                                                                                                   */
/* void check_directive_usage(void)                                                                                               */
/* void check_record_usage(void)                                                                                                  */
/* void collect_export_definitions(void)                                                                                          */
/* void compact_segment(void)                                                                                                     */
/* void complete_directives(void)                                                                                                 */
/* void default_control_variables(void)                                                                                           */
/* void determine_output_segment_rate(void)                                                                                       */
/* void determine_segment_processing_rate(void)                                                                                   */
/* void determine_simulation_rate(void)                                                                                           */
/* void expand_dump_definitions(void)                                                                                             */
/* void expand_IO_definitions(void)                                                                                               */
/* void expand_records(void)                                                                                                      */
/* void expand_string_variables(void)                                                                                             */
/* void expand_update_definitions(void)                                                                                           */
/* void last_message(void)                                                                                                        */
/* void print_error_location(const char *type, const unsigned long *mlin, const unsigned long *mfil)                              */
/* void print_info_location(const char *type, const unsigned long *mlin, const unsigned long *mfil)                               */
/* void print_limits(void)                                                                                                        */
/* void print_location(const unsigned long *mlin, const unsigned long *mfil)                                                      */
/* void print_problem_location(const char *type, const unsigned long *mlin, const unsigned long *mfil, const char *kind)          */
/* void print_warning_location(const char *type, const unsigned long *mlin, const unsigned long *mfil)                            */
/* void process_aliases(void)                                                                                                     */
/* void process_error_if_any(void)                                                                                                */
/* void wall_clock(void)                                                                                                          */
 
 
/* ****************************************************************************************************************************** */
 
/* output the current limits of the compiler set in file "napa.h"                                                                 */
 
void print_limits(void) {
  (void) fprintf(STDERR,     "\n\nCURRENT LIMITATION OF THE NAPA COMPILER:\n\n"                          );
  (void) fprintf(STDERR,         "  max number of nodes                    = %6ld\n",   MAXNODES         );
  (void) fprintf(STDERR,         "  max number of variables                = %6ld\n",   MAXVARS          );
  (void) fprintf(STDERR,         "  max number of updates                  = %6ld\n",   MAXUPDATES       );
  (void) fprintf(STDERR,         "  max number of arrays of pointers       = %6ld\n",   MAXRECORDS       );
  (void) fprintf(STDERR,         "  max number of instantiation of cells   = %6ld\n",   MAXINSTANCES     );
  (void) fprintf(STDERR,         "  max number of declarations             = %6ld\n",   MAXDECLARES      );
  (void) fprintf(STDERR,         "  max number of common declarations      = %6ld\n",   MAXDECLARECOMMONS);
  (void) fprintf(STDERR,         "  max number of opcodes                  = %6ld\n",   MAXOPCODES       );
  (void) fprintf(STDERR,         "  max number of cell file names recorded = %6ld\n",   MAXFILECELLS     );
  (void) fprintf(STDERR,         "  max number of functions to be recorded = %6ld\n",   MAXFUNCTIONS     );
  (void) fprintf(STDERR,         "  max number of options to be recorded   = %6ld\n",   MAXOPTIONS       );
  (void) fprintf(STDERR,         "  max number of user's defined functions = %6ld\n",   MAXUSERTOOLS     );
  (void) fprintf(STDERR,         "  max number of postprocessing functions = %6ld\n",   MAXPOSTS         );
  (void) fprintf(STDERR,         "  max number of inject to nodes          = %6ld\n",   MAXINJECTS       );
  (void) fprintf(STDERR,         "  max number of IO streams               = %6ld\n",   MAXIOS           );
  (void) fprintf(STDERR,         "  max number of open files (simulation)  = %6ld\n",   MAXFILES         );
  (void) fprintf(STDERR,         "  max number of headers                  = %6ld\n",   MAXHEADERS       );
  (void) fprintf(STDERR,         "  max number of directives               = %6ld\n",   MAXDIRS          );
  (void) fprintf(STDERR,         "  max number of cell parameters          = %6ld\n",   MAXPARMS         );
  (void) fprintf(STDERR,         "  max number of nodes stuck to a value   = %6ld\n",   MAXSTUCKS        );
  (void) fprintf(STDERR,         "  max number of command line parameters  = %6ld\n",   MAXCMDLINES      );
  (void) fprintf(STDERR,         "  max number of aliases                  = %6ld\n",   MAXALIASES       );
  (void) fprintf(STDERR,         "  max number of arrays                   = %6ld\n",   MAXARRAYS        );
  (void) fprintf(STDERR,         "  max number of simulation segments      = %6ld\n",   MAXSEGMENTS      );
  (void) fprintf(STDERR,         "  max number of exported variables       = %6ld\n\n", MAXEXPORTS       );
  (void) fprintf(STDERR,         "  max depth for cell hierarchy           = %6ld\n\n", MAXDEPTH         );
  (void) fprintf(STDERR,         "  max length of strings and tokens       = %6ld\n",   STRLENGTH        );
  (void) fprintf(STDERR,         "  max length of instructions             = %6ld\n\n", LINLENGTH        );
  (void) fprintf(STDERR,         "These limitations can be changed by a new compilation of the\n"        );
  (void) fprintf(STDERR,         "sources after reworking the limits in source file 'napa.h'. \n"        );
  (void) fprintf(STDERR,         "Please contact the author,   yves.leduc.be@gmail.com        \n\n"      );
 
  return;
}
 
 
/* Read a line from file pointed by 'fp', fill the string buffer 'buf' and return the number of lines read by this reading        */
/* process through pointer 'nl'.                                                                                                  */
 
/* This function performs all important line preprocessing: it cleans end of line, process continuation line, tracks line         */
/* numbering, expand iterative identifiers and update the 'mlin', 'mfil' documentation counters.                                  */
 
char *get_a_line(char *buf, unsigned long *nl, FILE *fp, unsigned long *mlin, const unsigned long *mfil) {
  static char  tok[LINLENGTH + 1L] = {'\0'};
  static char *p = (char*) NULL;
  long   len;
  int    continue_on_next_line;
  (void) strcpy(buf, "");
  *nl = 0UL;
  do {
    p = fgets(tok, LINLENGTH, fp);                                            /* read a line from the input file                  */
    if ((char*) NULL == p) {
      if (0UL < *nl) {
        *mlin = *mlin + *nl;
        print_error_location("continuation line", mlin, mfil);
        (void) fprintf(STDERR,   " end of file is detected although a new line was expected\n");
        print_error_banner_and_exit();
      }
      break;
    }
    clean_line(tok);                                                          /* clear comments, process tabs, end of line spaces */
    len = LENGTH(tok);
    (*nl)++;
    if ((1UL < *nl) && (0L == len)) {                                         /* many subtle errors undetected if authorized!!!   */
      *mlin = *mlin + *nl;
      print_error_location("continuation line", mlin, mfil);
      (void) fprintf(STDERR,     " 'all blank' or 'all comment' lines are not allowed inside an instruction\n");
      print_error_banner_and_exit();
    }
    if (3L <= len) {
      continue_on_next_line = (int) (('.' == tok[len-3L]) && ('.' == tok[len-2L]) && ('.' == tok[len-1L]));
      /* could be true or false!*/
    } else {
      continue_on_next_line = false;
    }
    if (continue_on_next_line) {
      tok[len-3L] = ' ';
      tok[len-2L] = '\0';
      clean_line(tok);
    }
    if ((LENGTH(buf) + LENGTH(tok)) > LINLENGTH) {
      *mlin = *mlin + *nl;
      print_error_location("instruction", mlin, mfil);
      (void) fprintf(STDERR,     " the length of instruction exceeds maximum length (%ld)\n", LINLENGTH);
      print_limits();
      print_error_banner_and_exit();
    }
    if (1L < *nl) {                                                           /* insert blank before concatenating instr. lines   */
      (void) strcat(buf, " ");
    }
    (void) strcat(buf, tok);
  } while (continue_on_next_line);
  expand_iterative_identifiers(buf, mlin, mfil);                              /* iterative identifiers by extension               */
  return p;
}
 
 
/* Print in two output streams if stream is not 'NULL'                                                                            */
 
long f2printf(FILE *fp1, FILE *fp2, char *fmt, ...) {
  va_list argp;
  long n1 = 0L;
  long n2 = 0L;
  if ((FILE*) NULL != fp1) {
    va_start(argp, fmt);
    n1 = vfprintf(fp1, fmt, argp);
    va_end(argp);
  }
  if (fp1 == fp2) {
    return n1;
  }
  if ((FILE*) NULL != fp2) {
    va_start(argp, fmt);
    n2 = vfprintf(fp2, fmt, argp);
    va_end(argp);
  }
  return MAX(n1, n2);
}
 
 
/* "default_control_variables" sets the default value of the variable controlling the NAPA simulation.                            */
 
/* Several flags have been initialized during the process of the command line process (Verbose_Flag, Expand_Flag, List_Flag)      */
/* There is a tricky process to determine the length corresponding to default formats                                             */
/* for 'doub_format', 'int_format' and 'string_format'                                                                            */
 
void default_control_variables(void) {
  long i;
  char tok[STRLENGTH] = {'\0'};
  NAPA_Compile_Start = ((double) clock()) / ((double) CLOCKS_PER_SEC);
  if (0 != atexit(last_message)) {                                            /* register exit function                           */
    print_error_location("control variables", NULL, NULL);
    (void) fprintf(STDERR,       " Registering 'last_message()' did not succeed\n");
  }
  (void) strcpy(Title_String,    "");                                         /* default of title: empty string                   */
  for (i = 0L; i < MAXCOMMENTS; i++) {
    (void) strcpy(Comment_String[i], "");                                     /* default of comment: empty string                 */
  }
  (void) strcpy(Cmdline_String, "");                                          /* default of command_line parms                    */
  (void) strcpy(I_Format, DEFAULT_I_FORMAT);                                  /* default of output digital format                 */
  (void) strcpy(X_Format, DEFAULT_X_FORMAT);                                  /* default of output digital format (hexa)          */
  (void) strcpy(R_Format, DEFAULT_R_FORMAT);                                  /* default of output analog format                  */
  (void) strcpy(S_Format, DEFAULT_S_FORMAT);                                  /* default of output string format                  */
  (void) strcpy(Last_Instruction, "");                                        /* to trace instruction flow                        */
  (void) strcpy(Last_Postprocess, "");                                        /* to trace postprocess flow                        */
  Sampling_List.frequency = 1.0;                                              /* default of operating frequency                   */
  Seed_List.rndseed       = 0L;                                               /* default of seed for random number                */
  Interlude_List.number1  = 0L;                                               /* default of interlude number                      */
  Interlude_List.number2  = 0L;                                               /* default of interlude number                      */
  Loop_Flag           = true;
  Periodic_Flag       = true;
  Synchro_Flag        = true;
  Antithetic_Flag     = false;
  Array_Flag          = false;
  Assert_Flag         = false;
  Call_Flag           = false;
  Cmdline_Flag        = false;
  Comment_Flag        = false;
  Debug_Flag          = false;
  Delayed_Flag        = false;
  Directive_Flag      = false;
  Drop_Flag           = false;
  Dump_Flag           = false;
  Error_Flag          = false;
  Export_Flag         = false;
  Fs_Ext_Flag         = false;
  Fs_Flag             = false;
  Function_Flag       = false;
  Gateway_Flag        = false;
  Hierarchy_Flag      = false;
  Inject_Flag         = false;
  Input_Flag          = false;
  Interlude_Flag1     = false;
  Interlude_Flag2     = false;
  Interlude_Flag3     = false;
  Interpolate_Flag    = false;
  Load_Flag           = false;
  Multdelay_Flag      = false;
  Option_Flag         = false;
  Output_Flag         = false;
  Ping_Flag           = false;
  Pointer_Flag        = false;
  Post_Flag           = false;
  Seed_Flag           = false;
  Stuck_Flag          = false;
  Terminate_Flag      = false;
  Title_Flag          = false;
  Tool_Flag           = false;
  Tool_Index_Flag     = false;
  Ts_Flag             = false;
  Ts_Ext_Flag         = false;
  Update_Flag         = false;
  User_Flag           = false;
  UserTool_Flag       = false;
  Warning_Flag        = false;
  Num_Aliases         = 0L;
  Num_Arrays          = 0L;
  Num_Asserts         = 0L;
  Num_Calls           = 0L;
  Num_Cells           = 0L;
  Num_Cmdlines        = 0L;
  Num_Comments        = 0L;
  Num_Declare_Commons = 0L;
  Num_Consts          = 0L;
  Num_Creates         = 0L;
  Num_Debugs          = 0L;
  Num_Declares        = 0L;
  Num_Delays          = 0L;
  Max_Depth           = 0L;
  Num_Directives      = 0L;
  Num_Exports         = 0L;
  Num_FileCells       = 0L;
  Num_Functions       = 0L;
  Num_Generators      = 0L;
  Num_Groups          = 0L;
  Num_Headers         = 0L;
  Num_Inits           = 0L;
  Num_Injects         = 0L;
  Num_Instances       = 0L;
  Num_IOs             = 0L;
  Num_Macros          = 0L;
  Num_Nodes           = 0L;
  Num_Nulls           = 0L;
  Num_Opcodes         = 0L;
  Num_Posts           = 0L;
  Num_Records         = 0L;
  Num_Redefs          = 0L;
  Num_Restarts        = 0L;
  Num_Segments        = 0L;
  Num_Stucks          = 0L;
  Num_Tools           = 0L;
  Num_Updates         = 0L;
  Num_UserTools       = 0L;
  Num_Vars            = 0L;
  Num_Voids           = 0L;
  (void) snprintf(Condition_Assign,    (size_t) (LINLENGTH-1L), "%s", "");
  (void) snprintf(Export0_List_String, (size_t) (LINLENGTH-1L), "%s", "");
  (void) snprintf(Export0_Head_String, (size_t) (LINLENGTH-1L), "%s", "");
  (void) snprintf(tok, (size_t)  (STRLENGTH-1L), I_Format, (NAPA_DIGITAL_TYPE) 1LL);  /* eff. string len resulting of this format */
  (void) snprintf(I_String_Format,     (size_t) (STRLENGTH-1L), "%%%lds", LENGTH(tok)-1L);
  (void) snprintf(tok, (size_t)  (STRLENGTH-1L), X_Format, (NAPA_DIGITAL_TYPE) 1LL);  /* eff. string len resulting of this format */
  (void) snprintf(X_String_Format,     (size_t) (STRLENGTH-1L), "%%%lds", LENGTH(tok)-1L);
  (void) snprintf(tok, (size_t)  (STRLENGTH-1L), R_Format, (NAPA_ANALOG_TYPE)  1.0);  /* eff. string len resulting of this format */
  (void) snprintf(R_String_Format,     (size_t) (STRLENGTH-1L), "%%%lds", LENGTH(tok)-1L);
  (void) strcpy(S_String_Format, S_Format);                                           /* eff. string len resulting of this format */
  return;
}
 
 
/* This function adds directive 'NO_BANNER' if 'STRICTLY_NO_BANNER' has been defined,                                             */
/* as 'STRICTLY_NO_BANNER' should imply 'NO_BANNER'                                                                               */
 
void complete_directives(void) {
  if ((UNDEFINED == directive_id("NO_BANNER")) && (UNDEFINED != directive_id("STRICTLY_NO_BANNER"))) {
    strcpy_alloc(&(Directive_List[Num_Directives].name ), "NO_BANNER", NULL, NULL);
    strcpy_alloc(&(Directive_List[Num_Directives].parms), "",          NULL, NULL);
    strcpy_alloc(&(Directive_List[Num_Directives].value), "",          NULL, NULL);
    increment_directive_number("directive");
  }
  return;
}
 
 
/* This function allows indirection inside string variables to update title.                                                      */
 
void expand_string_variables(void) {
  long  i, len;
  char *str = (char*) NULL;
  char  tok[LINLENGTH] = {'\0'};
  if (0L < Num_Vars) {
    for (i = 0L; i < Num_Vars; i++) {
      if (STRING_DATA_TYPE == Var_List[i].type) {
        (void) strcpy(tok, Var_List[i].value);
        expand_indirections(tok);
        if (0 != strcmp(tok, Var_List[i].value)) {
          strcpy_realloc(&(Var_List[i].value), tok, Var_List[i].mline, Var_List[i].mfile);
        }
      }
      str = Var_List[i].value;
      do {
        str = get_token(str, tok, true);
        if (0 == strcmp(tok, "when")) {
          print_error_location("var", Var_List[i].mline, Var_List[i].mfile);
          (void) fprintf(STDERR, " the definition of a variable cannot be conditioned by an event\n");
          break;
        }
      } while (ISNOTEMPTY(tok));
    }
  }
  expand_indirections(Title_String);                                          /* title is always expanded after variables         */
  (void) strcpy(Short_Title_String, Title_String);
  i = 0L;
  while ('\0' != Title_String[i]) {                                           /* extract first line of title                      */
    if (('/' == Title_String[i]) && ('n' == Title_String[i+1L])) {            /* the '\' was converted in '/'                     */
      Short_Title_String[i] = '\0';
      Title_String[i] = '\\';                                                 /* restore the '\'                                  */
    } else {
      Short_Title_String[i] = Title_String[i];
    }
    i++;
  }
  if (Comment_Flag) {
    len = 0L;
    for (i = 0L; i < Num_Comments; i++) {
      expand_indirections(Comment_String[i]);                                 /* comment is always expanded after variables       */
      len = MAX(LENGTH(Comment_String[i]), len);
    }
    len += 1L;
    for (i = 0L; i < Num_Comments; i++) {
      (void) strcpy(tok, Comment_String[i]);
      (void) snprintf(Comment_String[i], (size_t) (LINLENGTH-1L), "%s%*s", tok, (int) (len-LENGTH(tok))," ");
    }
  }
  return;
}
 
 
/* Expand array of pointers definition, record must be sorted before this processing!                                             */
 
void expand_records(void) {
  int   n;
  int   nflag, pflag;
  long  i, a, sz, nr, nc;
  long  first;
  char *s  = (char*) NULL;
  char *t1 = (char*) NULL;
  char *t2 = (char*) NULL;
  char  sgn[2] = {'\0'};
  char  tok[STRLENGTH]  = {'\0'};
  char  tok1[STRLENGTH] = {'\0'};
  char  tok2[STRLENGTH] = {'\0'};
  char  buf[LINLENGTH]  = {'\0'};
  char  buf1[LINLENGTH] = {'\0'};
  char  buf2[LINLENGTH] = {'\0'};
  if (0L == Num_Records) {
    return;
  }
  for (i = 0L; i < Num_Records; i++) {
    (void) strcpy(buf, "");
    s  = Record_List[i].list1;                                                /* list of parameters                               */
    sz = Record_List[i].size;
    nr = Record_List[i].nrow;
    nc = Record_List[i].ncol;
    first = true;
    for (;;) {
      s = get_sign_and_token(s, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      a = record_id(tok);
      if (UNDEFINED == a) {                                                   /* atom of the array                                */
        (void) strcat(buf, sgn);
        (void) strcat(buf, tok);
        (void) strcat(buf, " ");
        continue;
      }
      (void) strcat(buf, Record_List[a].list1);                               /* expand array                                     */
      (void) strcat(buf, " ");
      if (0L == Record_List[a].size) {
        sz = 0L;                                                              /* array with undefined size                        */
        nr = 0L;
        nc = 0L;
      } else {
        sz += Record_List[a].size - 1L;
        if ((!first) && (nc != Record_List[a].ncol)) {                        /* not rectangular                                  */
          nr = 1L;
          nc = sz;
        } else {
          if (!first) {
            nr++;
          }
          nc = Record_List[a].ncol;
        }
        first = false;
      }
    }
    clean_line(buf);
    strcpy_realloc(&(Record_List[i].list1), buf, Record_List[i].mline, Record_List[i].mfile);
    strcpy_realloc(&(Record_List[i].list2), buf, Record_List[i].mline, Record_List[i].mfile);
    Record_List[i].size = sz;                                                 /* new size                                         */
    Record_List[i].nrow = nr;
    if (0L != nr) {
      Record_List[i].ncol = sz / nr;                                          /* keep dimensions to 2 by flattening subarrays     */
    } else {
      Record_List[i].ncol = sz;
    }
  }
  for (i = 0L; i < Num_Records; i++) {
    s = Record_List[i].list1;                                                 /* list of parameters                               */
    n = 0;
    (void) strcpy(buf1, "");
    (void) strcpy(buf2, "");
    nflag = true;
    pflag = true;
    for (;;) {
 
      s = get_sign_and_token(s, sgn, tok1);
      (void) strcpy(tok,  sgn);
      (void) strcat(tok, tok1);
 
      if (ISEMPTY(tok)) {
        break;
      }
      (void) strcpy(tok1, tok);
      (void) strcpy(tok2, tok);
      t1 = strstr(tok1, "::");
      t2 = strstr(tok2, "::");
      if ((char*) NULL != t1) {
        pflag = false;
        nflag = nflag && true;
        (void) strcpy(tok1, t1+2);                                            /* passing by name, extract var for verification     */
        clean_line(tok1);
        (void) strcat(buf1, tok1);
        (void) strcat(buf1, " " );
        *t2 = '\0';
        (void) strcat(buf2, tok2);
        (void) strcat(buf2, " " );
      } else {                                                                /* passing by position                              */
        nflag = false;
        pflag = pflag && true;
        clean_line(tok1);
        (void) strcat(buf1, tok1);
        (void) strcat(buf1, " " );
        (void) snprintf(tok2, (size_t) (STRLENGTH-1L), "%d ", n);
        (void) strcat(buf2, tok2);
        n++;
      }
    }
    if (!(pflag || nflag)) {
      print_error_location("record", Record_List[i].mline, Record_List[i].mfile);
      (void) fprintf(STDERR,     " inconsistant parameters passing: by position or by name?\n");
    }
    Record_List[i].nflag = nflag;
    Record_List[i].pflag = pflag;
    clean_line(buf1);
    clean_line(buf2);
    strcpy_realloc(&(Record_List[i].list1), buf1, Record_List[i].mline, Record_List[i].mfile);
    strcpy_realloc(&(Record_List[i].list2), buf2, Record_List[i].mline, Record_List[i].mfile);
  }
  return;
}
 
 
/* Scan nodes and arrays to tag array usage                                                                                       */
 
void check_array_usage(void) {
  long  out;
  long  kd, m;
  char *s = (char*) NULL;
  char  sgn[2]          = {'\0'};
  char  tok1[STRLENGTH] = {'\0'};
  for (out = 0L; out < Num_Nodes; out++) {
    s  = Node_List[out].value;
    kd = Node_List[out].kind;
    switch (kd) {
    case ITOOL_KIND :
    case DTOOL_KIND :
    case IUSER_KIND :
    case DUSER_KIND :
    case DALGEBRA_KIND :
    case IALGEBRA_KIND :
    case ALGEBRA_KIND :
    case TEST_KIND :
    case CONST_KIND :
    case DC_KIND :
      for (;;) {
        s = get_token(s, tok1, true);
        if (ISEMPTY(tok1)) {
          break;
        }
        m = array_name_id(tok1);
        if (UNDEFINED != m) {                                                 /* detect use of array by file                      */
          Array_List[m].used = true;
        }
      }
      break;
    case RAM_KIND :
    case RAM2_KIND :
    case ROM_KIND :
    case ROM2_KIND :
      s = get_sign_and_token(s, sgn, tok1);
      m = array_id(tok1);
      if (UNDEFINED != m) {                                                   /* detect use of array by name                      */
        Array_List[m].used = true;
      }
      break;
    default:
      break;
    }
  }
  for (m = 0L; m < Num_Arrays; m++) {
    if ((Array_List[m].used) && (UNKNOWN_KIND != Array_List[m].kind)) {
      Array_Flag = true;
      continue;
    }
  }
  return;
}
 
 
/* Scan nodes and records to tag record usage                                                                                     */
 
void check_record_usage(void) {
  long  out;
  long  kd, m;
  char *s  = (char*) NULL;
  char *s1 = (char*) NULL;
  char  sgn[2] = {'\0'};
  char  tok1[STRLENGTH] = {'\0'};
  for (out = 0L; out < Num_Nodes; out++) {
    s  = Node_List[out].value;
    kd = Node_List[out].kind;
    switch (kd) {
    case ITOOL_KIND :
    case DTOOL_KIND :
    case IUSER_KIND :
    case DUSER_KIND :
      for (;;) {
        s = get_token(s, tok1, false);
        if (ISEMPTY(tok1)) {
          break;
        }
        m = record_id(tok1);
        if (UNDEFINED != m) {                                                 /* detect use of array by name                      */
          Record_List[m].used = true;
        }
      }
      break;
    case DALGEBRA_KIND :
    case IALGEBRA_KIND :
    case ALGEBRA_KIND :
    case CONST_KIND :
    case DC_KIND :
    case TEST_KIND :
      for (;;) {
        s = get_token(s, tok1, true);
        if (ISEMPTY(tok1)) {
          break;
        }
        m = record_id(tok1);
        if (UNDEFINED != m) {                                                 /* detect use of array by name                      */
          Record_List[m].used = true;
        }
      }
      break;
    default:
      break;
    }
  }
  for (out = 0L; out < Num_Records; out++) {
    s1 = Record_List[out].list1;
    for (;;) {
      s1 = get_sign_and_token(s1, sgn, tok1);
      if (ISEMPTY(tok1)) {
        break;
      }
      m = var_id(tok1);
      if (UNDEFINED != m) {
        Var_List[m].used = true;
      }
    }
  }
  Pointer_Flag = false;
  for (out = 0L; out < Num_Records; out++) {
    if (Record_List[out].used) {
      Pointer_Flag = true;
      break;
    }
  }
  return;
}
 
 
void check_directive_usage(void) {
  long d;
  if ((0 >= Num_Directives) || (Cmdline_Flag)) {                              /* no directive in netlist, or standalone simulator */
    return;
  }
  mark_directives();                                                          /* inspect napa netlist for macro usage             */
  for (d = 0L; d < Num_Directives; d++) {                                     /* directives used in the C file produced by NAPA   */
    if ((0 == strcmp(Directive_List[d].name, "TIME_OFFSET"       )) || (0 == strcmp(Directive_List[d].name, "JITTER"   ))
     || (0 == strcmp(Directive_List[d].name, "STRICTLY_NO_BANNER")) || (0 == strcmp(Directive_List[d].name, "NO_BANNER"))
     || (0 == strcmp(Directive_List[d].name, "NO_TIME_OUTPUT"    )) || (0 == strcmp(Directive_List[d].name, "VERBOSE"  ))
     || (0 == strcmp(Directive_List[d].name, "NAPA_EXIT_STATUS"  )) ) {
      Directive_List[d].used = true;
      continue;
    }
    if (Assert_Flag) {
      if (0 == strcmp(Directive_List[d].name, "NO_ASSERT"  )) {
        Directive_List[d].used = true;
        continue;
      }
    }
    if (Dump_Flag) {
      if ((0 == strcmp(Directive_List[d].name, "DUMP"      )) || (0 == strcmp(Directive_List[d].name, "NO_GLOBAL"      ))
       || (0 == strcmp(Directive_List[d].name, "NO_ARRAY"  )) || (0 == strcmp(Directive_List[d].name, "NO_VAR"         ))
       || (0 == strcmp(Directive_List[d].name, "NO_NODE"   ))) {
        Directive_List[d].used = true;
        continue;
      }
    }
    if (Directive_List[d].function) {                                         /* this is a macro function, not a true directive   */
      Directive_List[d].used = true;
      continue;
    }
    Directive_Flag = true;
  }
  return;
}
 
 
/* Scan and collect the definition of export variables                                                                            */
 
void collect_export_definitions(void) {
  long  e, n, m;
  long  first;
  char *str = (char*) NULL;
  char  tok1[STRLENGTH] = {'\0'};
  char  tok2[STRLENGTH] = {'\0'};
  char  sgn[2]          = {'\0'};
  if (!Export_Flag) {
    return;
  }
  first = true;
  (void) strcpy(E_Format, "");                                                /* set E_Format with empty string                   */
  (void) strcpy(V_Format, "");                                                /* set V_Format with empty string                   */
  for (e = 0L; e < Num_Exports; e++) {                                        /* scan each export instruction to collect names    */
    str = Export_List[e].name;
    for (;;) {                                                                /* scan export list, identifier after identifier    */
      str = get_sign_and_token(str, sgn, tok1);
      if (ISEMPTY(tok1)) {
        break;                                                                /* end of list                                      */
      }
      if (!is_an_identifier(tok1)) {
        print_error_location("export", Export_List[e].mline, Export_List[e].mfile              );
        (void) fprintf(STDERR,   " export node or variable <%s> is not a NAPA identifier\n", tok1);
        process_node_error(tok1);
        process_variable_error(tok1);
        return;
      }
      if (ISNOTEMPTY(sgn)) {
        print_error_location("export", Export_List[e].mline, Export_List[e].mfile      );
        (void) fprintf(STDERR,   " export node or variable <%s> cannot be signed\n", tok1);
        return;
      }
      n = node_id(tok1);
      if (UNDEFINED != n) {                                                   /* is it a node ?                                   */
        Node_List[n].used = true;
        if (ANALOG_DATA_TYPE == Node_List[n].type) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   R_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, R_FORMAT_V);
          }
        } else {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   I_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, I_FORMAT_V);
          }
        }
      }
      m   = var_id(tok1);                                                     /* is it a variable ?                               */
      if (UNDEFINED != m) {
        Var_List[m].used = true;
        if (ANALOG_DATA_TYPE == Var_List[m].type) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   R_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, R_FORMAT_V);
          }
        } else if (DIGITAL_DATA_TYPE == Var_List[m].type) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   I_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, I_FORMAT_V);
          }
        } else {
          print_error_location("export", Export_List[e].mline, Export_List[e].mfile);
          (void) fprintf(STDERR, " a string variable cannot be exported <%s>", tok1);
        }
      }
      if ((UNDEFINED == n) && (UNDEFINED == m)) {                             /* an identifier known by NAPA                      */
        if (DIGITAL_DATA_TYPE == get_type(tok1)) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   I_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, I_FORMAT_V);
          }
        }
        if (ANALOG_DATA_TYPE == get_type(tok1)) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   R_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, R_FORMAT_V);
          }
        }
      }
      (void) snprintf(tok2, (size_t) (STRLENGTH-1L), S_FORMAT_V, tok1);
      (void) strcat(Export0_Head_String, tok2);
      (void) build_name("", tok1, RIGHT_VALUE);
      (void) strcat(Export0_List_String, tok1);
      (void) strcat(Export0_List_String, ", ");
      if (first) {
        (void) strcpy(Export1_Head_String, Export0_Head_String);
        (void) strcpy(Export1_List_String, Export0_List_String);
      }
      first = false;
    }
  }
  Export0_List_String[LENGTH(Export0_List_String) - 2L] = '\0';               /* suppress last ", "                               */
  Export1_List_String[LENGTH(Export1_List_String) - 2L] = '\0';               /* suppress last ", "                               */
  return;
}
 
 
/* Fill empty definition with the corresponding variable definition                                                               */
/* during the process, extract event condition                                                                                    */
 
void expand_update_definitions(void) {
  long  out;
  long  v;
  char *str = (char*) NULL;
  char *nam = (char*) NULL;
  char *s   = (char*) NULL;
  char  tok[STRLENGTH] = {'\0'};
  int   flag;
  for (out = 0L; out < Num_Updates; out++) {
    nam = Update_List[out].name;                                              /* search also for alias                            */
    if ((0 == strncmp(nam, "$call$",    (size_t) 6))
     || (0 == strncmp(nam, "$null$",    (size_t) 6))
     || (0 == strncmp(nam, "$restart$", (size_t) 9))) {
      strcpy_alloc(&(Update_List[out].condition), "", Update_List[out].mline, Update_List[out].mfile);
      continue;
    }
    if ((UNDEFINED == var_id(nam)) && (0 != strncmp(nam, "$assert$", (size_t) 8))) {
      print_error_location("update", Update_List[out].mline, Update_List[out].mfile);
      (void) fprintf(STDERR,     " variable to be updated <%s> does not exist!\n", nam );
      process_variable_error(nam);
      continue;
    }
    if (STRING_DATA_TYPE == Var_List[var_id(nam)].type) {
      print_error_location("update", Update_List[out].mline, Update_List[out].mfile);
      (void) fprintf(STDERR,     " string <%s>: a string cannot be updated!", nam      );
      continue;
    }
    str = Update_List[out].value;
    do {
      s = str;                                                                /* remember location of 'when' token                */
      str = get_token(str, tok, true);
      if (0 == strcmp(tok, "when")) {
        if (Update_List[out].event) {
          print_error_location("event", Update_List[out].mline, Update_List[out].mfile);
          (void) fprintf(STDERR, " an event cannot be conditioned\n");
          continue;
        }
        break;
      }
    } while (ISNOTEMPTY(tok));
    flag = process_condition(str, Update_List[out].mline, Update_List[out].mfile);
    *(s) = '\0';                                                              /* split in value and condition                     */
 
    if (flag) {
      strcpy_alloc(&(Update_List[out].condition), str, Update_List[out].mline, Update_List[out].mfile);
    } else {
      strcpy_alloc(&(Update_List[out].condition),  "", Update_List[out].mline, Update_List[out].mfile);
    }
    clean_line(Update_List[out].value);
    /* if update value is empty, use the definition of the corresponding variable                                                 */
    if (ISEMPTY(Update_List[out].value)) {
      v = var_id(Update_List[out].name);
      if (UNDEFINED != v) {
        strcpy_realloc(&(Update_List[out].value), Var_List[v].value, Update_List[out].mline, Update_List[out].mfile);
      } else {                                                                /* should never occur                               */
        print_error_location("update", Update_List[out].mline, Update_List[out].mfile);
        (void) fprintf(STDERR,   " no update expansion, as variable to be updated does not exist\n");
      }
    }
  }
  return;
}
 
 
/* IO definitions may be completed by a "when" keyword followed by a combination of events                                        */
/* This function expands this definition                                                                                          */
 
void expand_IO_definitions(void) {
  long  out;
  char *str = (char*) NULL;
  char *s   = (char*) NULL;
  char  tok[STRLENGTH] = {'\0'};
  int   flag;
  for (out = 0L; out < Num_IOs; out++) {
    if (INPUT_TYPE == IO_List[out].type) {
      str = IO_List[out].element;
      do {
        str = get_token(str, tok, true);
        if (0 == strcmp(tok, "when")) {
          print_error_location("input", IO_List[out].mline, IO_List[out].mfile);
          (void) fprintf(STDERR, " this instruction cannot be conditioned by an event\n");
          break;
        }
      } while (ISNOTEMPTY(tok));
      continue;
    }
    if (OUTPUT_TYPE == IO_List[out].type) {
      str = IO_List[out].element;
      do {
        s = str;                                                              /* remember location of 'when' token                */
        str = get_token(str, tok, true);
        if (0 == strcmp(tok, "when")) {
          break;
        }
      } while (ISNOTEMPTY(tok));
      flag = process_condition(str, IO_List[out].mline, IO_List[out].mfile);
      *(s) = '\0';                                                            /* split in value and condition                     */
      if (flag) {
        strcpy_alloc(&(IO_List[out].condition), str, IO_List[out].mline, IO_List[out].mfile);
      } else {
        strcpy_alloc(&(IO_List[out].condition), "",  IO_List[out].mline, IO_List[out].mfile);
      }
    }
  }
  return;
}
 
 
/* "dump" may be completed by a "when" keyword followed by a combination of events. This function expands this definition.        */
 
void expand_dump_definitions(void) {
  char *str = (char*) NULL;
  char  tok[STRLENGTH] = {'\0'};
  if (!Dump_Flag) {
    return;
  }
  str = Dump_List.condition;
  if (0 == strcmp(str, "false")) {
    strcpy_alloc(&(Dump_List.condition), "false", Dump_List.mline, Dump_List.mfile);
    return;
  }
  if ((0 == strcmp(str, "true")) || ISEMPTY(str)) {
    strcpy_alloc(&(Dump_List.condition), "true",  Dump_List.mline, Dump_List.mfile);
    return;
  }
  str = get_token(str, tok, true);
  if (ISEMPTY(tok) || (0 != strcmp(tok, "when"))) {
    print_error_location("dump", Dump_List.mline, Dump_List.mfile);
    (void) fprintf(STDERR,       " this instruction must be conditioned by an event\n");
    return;
  }
  (void) process_condition(str, Dump_List.mline, Dump_List.mfile);
  strcpy_alloc(&(Dump_List.condition), str, Dump_List.mline, Dump_List.mfile);
  return;
}
 
 
/* This function analyses and processes condition following a "when" keyword. It is called by the two functions above.            */
 
long process_condition(char *str, const unsigned long *mlin, const unsigned long *mfil) {
  long  in;
  char *s = (char*) NULL;
  char  sgn[2]         = {'\0'};
  char  brc[3]         = {'\0'};
  char  tok[LINLENGTH] = {'\0'};
  int   cond;
  cond = false;
  if (ISEMPTY(str)) {
    return false;
  }
  C_syntax_checker(str, mlin, mfil);
  while (ISNOTEMPTY(str)) {
    s = str;
    str = get_token_between_braces(str, brc, tok);
    if ((0 == strcmp(brc, "()")) && (0 == strcmp(tok, "new"))) {
      str = s;
    }
    str = get_sign_and_token(str, sgn, tok);
    in = node_id(tok);
    if (UNDEFINED != in) {
      print_error_location("condition", mlin, mfil);
      (void) fprintf(STDERR,     "<%s> cannot be a node but an event\n", tok);
      break;
    }
    in = var_id(tok);
    if ((UNDEFINED == in) && (isalpha((int) *tok))) {
      print_error_location("condition", mlin, mfil);
      (void) fprintf(STDERR,     "<%s>? Only events and operators on boolean are allowed in a condition\n", tok);
      break;
    }
    if ((UNDEFINED != in) && (!Var_List[in].event)) {
      print_error_location("condition", mlin, mfil);
      (void) fprintf(STDERR,     " <%s> cannot be a variable but an event\n", tok);
      break;
    }
    cond = true;
  }
  return cond;
}
 
 
void build_condition(char *cond, const unsigned long *mlin, const unsigned long *mfil) {
  long  in;
  char  sgn[2]          = {'\0'};
  char  tok[STRLENGTH]  = {'\0'};
  char  buf1[LINLENGTH] = {'\0'};
  char  buf2[LINLENGTH] = {'\0'};
  char *str = (char*) NULL;
  str  = cond;
  if (ISEMPTY(str)) {
    print_error_location("condition", mlin, mfil);
    (void) fprintf(STDERR,       " syntax error in condition <%s>, event is missing\n", str);
    return;
  }
  (void) fprintf(STDOUT,         "  if ( ");
  while (ISNOTEMPTY(str)) {
    str = get_sign_and_token(str, sgn, tok);
    in  = var_id(tok);
    if (UNDEFINED == in) {
      (void) strcpy(buf1, buf2);
      if ((0 == strcmp("&&", tok)) || (0 == strcmp("||", tok))) {
        (void) snprintf(buf2, (size_t) (LINLENGTH-1L), "%s %s ", buf1, tok);
      } else {
        (void) snprintf(buf2, (size_t) (LINLENGTH-1L), "%s%s",   buf1, tok);
      }
      continue;
    }
    (void) strcpy(buf1, buf2);
    (void) build_name(sgn, tok, RIGHT_VALUE);
    (void) snprintf(buf2, (size_t) (LINLENGTH-1L), "%s%s",       buf1, tok);
  }
  clean_parentheses(buf2);
  (void) fprintf(STDOUT,         "%s", buf2);
  (void) fprintf(STDOUT,         " ) {\n");
  return;
}
 
 
/* "build_to_be_delayed_node_list" makes node list including a delay for special processing                                       */
/* this procedure makes a list of node ID's which are inputs for delayed nodes.                                                   */
 
void build_to_be_delayed_node_list(void) {
  long  in;
  long  out;
  long  k;
  char  sgn[2]         = {'\0'};
  char  tok[STRLENGTH] = {'\0'};
  char *str = (char*) NULL;
  for (out = 0L; out < Num_Nodes; out++) {
    k = Node_List[out].kind;
    if ((DELAY1_KIND == k) || (DELAY2_KIND == k) || (DELAY3_KIND == k) || (DELAY_KIND == k)) {
      str = Node_List[out].value;                                             /* get the unprocessed node_value                   */
      str = get_sign_and_token(str, sgn, tok);                                /* skip delay number                                */
      str = get_sign_and_token(str, sgn, tok);                                /* input_node name                                  */
      in  = node_id(tok);
      Delay_Input[Num_Delays] = Node_List[in].ID;
      Num_Delays++;
    }
  }
  return;
}
 
 
/* Simulation loop is running at a multiple of the user defined sampling frequency as interpolation and decimation have to be     */
/* handled properly. This function returns the minimum factor by which we have to multiply the nominal sampling frequency to      */
/* obtain the frequency to run the simulation. During parsing, the data are stored as they are obtained, i.e as relative numbers, */
/* the function here establishes absolute quantities. All data are double float to avoid overflow.                                */
 
void determine_simulation_rate(void) {
  double numerator[MAXSEGMENTS];
  double denominator[MAXSEGMENTS];
  double gcd, lcm;
  long   nseg;
  /* First segment (could be empty) is always running as specified by the instruction NAPA 'fs' sampling frequency                */
  numerator[0L]   = 1.0;
  denominator[0L] = 1.0;
  /* Determination of the rate of each segment                                                                                    */
  for (nseg = 1L; nseg < Num_Segments; nseg++) {
    if (INTERPOLATE_SEGMENT_TYPE == Segment_List[nseg].type) {
      if (0L == Segment_List[nseg].ref) {                                     /* increase referred to previous segment rate       */
        numerator[nseg]   =   numerator[nseg-1L] * Segment_List[nseg].rate;
        denominator[nseg] = denominator[nseg-1L];
      } else {                                                                /* increase referred to global sampling rate        */
        numerator[nseg]   = Segment_List[nseg].rate;
        denominator[nseg] = 1.0;
      }
    }
    if (DECIMATE_SEGMENT_TYPE == Segment_List[nseg].type)    {
      if (0L == Segment_List[nseg].ref) {                                     /* decrease referred to previous segment rate       */
        numerator[nseg]   =   numerator[nseg-1L];
        denominator[nseg] = denominator[nseg-1L] * Segment_List[nseg].rate;
      } else {                                                                /* decrease referred to global sampling rate        */
        numerator[nseg]   = 1.0;
        denominator[nseg] = Segment_List[nseg].rate;
      }
    }
    if (NOMINAL_SEGMENT_TYPE == Segment_List[nseg].type)     {
      numerator[nseg]   = 1.0;
      denominator[nseg] = 1.0;
    }
    if (DROP_SEGMENT_TYPE == Segment_List[nseg].type)        {                /* no change but a conditional execution            */
      numerator[nseg]   =   numerator[nseg-1L];
      denominator[nseg] = denominator[nseg-1L];
    }
    gcd = GCD(numerator[nseg], denominator[nseg]);
    numerator[nseg]   /= gcd;
    denominator[nseg] /= gcd;
  }
  /* search for the lowest frequency for the simulation loop                                                                      */
  lcm   = 1.0;
  for (nseg = 0L; nseg < Num_Segments; nseg++) {
    if (!((Segment_List[nseg].used1) || (Segment_List[nseg].used2))) {
      continue;
    }
    lcm = LCM(lcm, numerator[nseg]);
  }
  Simulation_Rate = lcm;
  return;
}
 
 
/* Each segment should run at its own pace relative to main loop simulation rate 'Simulation_Rate'                                */
 
void determine_segment_processing_rate(void) {
  double rn, sn;
  long   nseg;
  Segment_List[0].frequency = Sampling_List.frequency;                        /* the 'fs' frequency                               */
  Segment_List[0].offset    = 0.0;
  Segment_List[0].rate      = Simulation_Rate;
  for (nseg = 1L; nseg < Num_Segments; nseg++) {
    rn = Segment_List[nseg].rate;
    sn = Segment_List[nseg].offset;
    if (NOMINAL_SEGMENT_TYPE == Segment_List[nseg].type) {                    /* referred to global sampling rate                 */
      Segment_List[nseg].frequency   = Segment_List[0].frequency;
      Segment_List[nseg].rate        = Segment_List[0].rate;
      Segment_List[nseg].offset      = Segment_List[0].offset;
    }
    if (DECIMATE_SEGMENT_TYPE == Segment_List[nseg].type) {                   /* 'decimate': decrease rate                        */
      if (0L == Segment_List[nseg].ref) {                                     /* decreasing referred to previous segment rate     */
        Segment_List[nseg].frequency = Segment_List[nseg-1L].frequency / rn;
        Segment_List[nseg].rate      = Segment_List[nseg-1L].rate * rn;
        Segment_List[nseg].offset    = Segment_List[nseg-1L].offset + (Segment_List[nseg-1L].rate * sn);
      } else {                                                                /* decreasing referred to main loop sampling rate   */
        Segment_List[nseg].frequency = Segment_List[0].frequency / rn;
        Segment_List[nseg].rate      = Segment_List[0].rate * rn;
        Segment_List[nseg].offset    = Segment_List[0].offset + (Segment_List[0].rate * sn);
      }
    }
    if (INTERPOLATE_SEGMENT_TYPE == Segment_List[nseg].type) {                /* 'interpolate': increase rate                     */
      if (0L == Segment_List[nseg].ref) {                                     /* increasing referred to previous segment rate     */
        Segment_List[nseg].frequency = Segment_List[nseg-1L].frequency * rn;
        Segment_List[nseg].rate      = Segment_List[nseg-1L].rate / rn;
        Segment_List[nseg].offset    = Segment_List[nseg-1L].offset;
      } else {                                                                /* increasing referred to main loop sampling rate   */
        Segment_List[nseg].frequency = Segment_List[0].frequency * rn;
        Segment_List[nseg].rate      = Segment_List[0].rate / rn;
        Segment_List[nseg].offset    = Segment_List[0].offset;
      }
    }
    if (DROP_SEGMENT_TYPE == Segment_List[nseg].type) {
      if (0L == Segment_List[nseg].ref) {                                     /* ignore condition, using previous segment rate    */
        Segment_List[nseg].frequency = Segment_List[nseg-1L].frequency;
        Segment_List[nseg].rate      = Segment_List[nseg-1L].rate;
        Segment_List[nseg].offset    = Segment_List[nseg-1L].offset;
      } else {                                                                /* ignore condition, using main loop sampling rate  */
        Segment_List[nseg].frequency = Segment_List[0].frequency;
        Segment_List[nseg].rate      = Segment_List[0].rate;
        Segment_List[nseg].offset    = Segment_List[0].offset;
      }
    }
  }
  for (nseg = 1L; nseg < Num_Segments; nseg++) {
    Segment_List[nseg].offset = fmod(Segment_List[nseg].offset, Segment_List[nseg].rate);
  }
  return;
}
 
 
void determine_output_segment_rate(void) {  /* determine the processing rate in function of the nodes and variables to be output  */
  int   ok, always, first, atleastone;
  long  out, seg;
  long  d, m, n, u;
  long  s;
  long  seglist[MAXSEGMENTS];
  char  sgn[2]          = {'\0'};
  char  lst[LINLENGTH]  = {'\0'};
  char  cnd1[LINLENGTH] = {'\0'};
  char  cnd2[LINLENGTH] = {'\0'};
  char  tok[STRLENGTH]  = {'\0'};
  char *str = (char*) NULL;
  for (out = 0L; out < Num_IOs; out++) {                                      /* process output after output                      */
    if (OUTPUT_TYPE != IO_List[out].type) {
      continue;
    }
    for (s = 0L; s < MAXSEGMENTS; s++) {
      seglist[s] = -1L;
    }
    atleastone = false;                                                       /* to detect at least one non constant parameter    */
    always     = false;
    first      = true;
    ok         = false;
    (void) strcpy(lst, IO_List[out].element);
    str    = lst;
    for (;;) {                                                                /* scan token after token in the output list        */
      seg = 0L;
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      m = 0L;
      for (;;) {                                                              /* consider only each updated variables             */
        m++;
        u = update_id(tok, m);                                                /* consider all the updates of a variable           */
        if (UNDEFINED != u)  {
          seg = Update_List[u].segment;
          ok  = true;
        } else {
          break;
        }
        if (!ok) {
          continue;
        }
        atleastone = true;
        if (ISEQUAL(1.0, Segment_List[seg].rate)) {
          always = true;                                                      /* one of the output is full rate                   */
          break;                                                              /* therefore the output rate is at max frequency    */
        }
        if (seglist[seg] != seg) {                                            /* avoid repetition                                 */
          if (first) {
            (void) snprintf(cnd2, (size_t) (LINLENGTH-1L),       "%s_%ld",       "napa_segment_run", seg);
            first = false;
          } else {
            (void) strcpy(cnd1, cnd2);
            (void) snprintf(cnd2, (size_t) (LINLENGTH-1L), "%s || %s_%ld", cnd1, "napa_segment_run", seg);
          }
          seglist[seg] = seg;                                                 /* record identified segment                        */
        }
      }
    }
 
    ok    = false;
    (void) strcpy(lst, IO_List[out].element);
    str   = lst;
    for (;;) {                                                                /* scan token after token in the output list        */
      seg = 0L;
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      n = node_id(tok);
      if (UNDEFINED != n) {
        if ((DC_KIND != Node_List[n].kind) && (CONST_KIND != Node_List[n].kind)) {                         /* ignore constants    */
          seg = Node_List[n].segment;
          ok  = true;
        }
      }
      if (!ok) {
        continue;
      }
      atleastone = true;
      if (ISEQUAL(1.0, Segment_List[seg].rate)) {
        always = true;                                                        /* one of the output is full rate                   */
        break;
      }
      if (seglist[seg] != seg) {                                              /* avoid repetition                                 */
        if (first) {
          (void) snprintf(cnd2, (size_t) (LINLENGTH-1L),       "%s_%ld",       "napa_segment_run", seg);
          first = false;
        } else {
          (void) strcpy(cnd1, cnd2);
          (void) snprintf(cnd2, (size_t) (LINLENGTH-1L), "%s || %s_%ld", cnd1, "napa_segment_run", seg);
        }
      }
      seglist[seg] = seg;                                                     /* record identified segment                        */
    }
    if (!atleastone) {
      (void) strcpy(cnd2, " 0LL == ABS_LOOP_INDEX ");                         /* only constants are output                        */
    }
    if (ISEMPTY(IO_List[out].condition)) {
      if (always) {                                                           /* at least one output is evaluated 'full rate'     */
        (void) strcpy(cnd1, "true");
      } else {
        (void) strcpy(cnd1, cnd2);
      }
    } else {
      if (always) {                                                           /* at least one output is evaluated 'full rate'     */
        (void) snprintf(cnd1, (size_t) (LINLENGTH-1L), "%s",               IO_List[out].condition);
      } else {
        (void) snprintf(cnd1, (size_t) (LINLENGTH-1L), "(%s) && %s", cnd2, IO_List[out].condition);
      }
    }
    strcpy_realloc(&(IO_List[out].condition), cnd1, IO_List[out].mline, IO_List[out].mfile);
    IO_List[out].segment = 0L;                                                /* assign segment 0 to output                       */
    Segment_List[Num_Segments].type       = DECIMATE_SEGMENT_TYPE;
    Segment_List[Num_Segments].ref        = 0L;                               /* referred to main sampling frequency              */
    Segment_List[Num_Segments].frequency  = 0.0;
    Segment_List[Num_Segments].rate       = 1.0;
    Segment_List[Num_Segments].offset     = 0.0;
    Segment_List[Num_Segments].used1      = false;
    Segment_List[Num_Segments].used2      = false;
    Segment_List[Num_Segments].used3      = true;                             /* this new segment contains an output              */
    Segment_List[Num_Segments].periodic   = true;
    for (d = 0L; d < MAXDEPTH; d++) {
      Segment_List[Num_Segments].mline[d] = IO_List[out].mline[d];
      Segment_List[Num_Segments].mfile[d] = IO_List[out].mfile[d];
    }
    increment_segment_number("output");
  }
  return;
}
 
 
/* Due to netlist structure, it may happen that several segments are running under the same conditions. We will regroup all       */
/* elements in a minimum of segments to optimize the simulation. Process just after full segment conditon determination.          */
/* Do not process segment 0 as it contains the sampling frequency defined by user.                                                */
 
void compact_segment(void) {
  long newseg[MAXSEGMENTS];
  long nseg, nseg1, nseg2;
  long n;
  for (nseg = 0L; nseg < MAXSEGMENTS; nseg++) {                               /* default: new number is the current one           */
    if (nseg < Num_Segments) {
      newseg[nseg] = nseg;
    } else {
      newseg[nseg] = 0L;                                                      /* initialize all remaining potential segments      */
    }
  }
  for (nseg2 = 1L; nseg2 < Num_Segments; nseg2++) {                           /* renumber duplicate segment when identified       */
    if (DROP_SEGMENT_TYPE == Segment_List[nseg2].type) {
      continue;
    }
    for (nseg1 = 0L; nseg1 < nseg2; nseg1++) {                                /* search for candidate in a previous segment       */
      if ((ISEQUAL(Segment_List[nseg2].offset,    Segment_List[nseg1].offset    ))
       && (ISEQUAL(Segment_List[nseg2].rate,      Segment_List[nseg1].rate      ))
       && (ISEQUAL(Segment_List[nseg2].frequency, Segment_List[nseg1].frequency))) {
        Segment_List[nseg1].used1 = Segment_List[nseg1].used1 || Segment_List[nseg2].used1;                      /* combine usage */
        Segment_List[nseg1].used2 = Segment_List[nseg1].used2 || Segment_List[nseg2].used2;
        Segment_List[nseg1].used3 = Segment_List[nseg1].used3 || Segment_List[nseg2].used3;
        newseg[nseg2] = nseg1;                                                /* assign a new number to this segment              */
        Segment_List[nseg2].used1 = false;                                    /* old number is no more used                       */
        Segment_List[nseg2].used2 = false;                                    /* but data are not erased as they will used        */
        Segment_List[nseg2].used3 = false;                                    /* to document the C file                           */
        break;
      }
    }
  }
  for (n = 0L; n < Num_IOs; n++) {                                            /* actualize the segment for each element           */
    IO_List[n].segment     = newseg[IO_List[n].segment];
  }
  for (n = 0L; n < Num_Nodes; n++) {
    Node_List[n].segment   = newseg[Node_List[n].segment];
  }
  for (n = 0L; n < Num_Vars; n++) {
    Var_List[n].segment    = newseg[Var_List[n].segment];
  }
  for (n = 0L; n < Num_Updates; n++) {
    Update_List[n].segment = newseg[Update_List[n].segment];
  }
  for (n = 0L; n < Num_UserTools; n++) {
    UserTool_List[n].segment   = newseg[UserTool_List[n].segment];
  }
  for (n = 0L; n < Num_Posts; n++) {
    Post_List[n].segment   = newseg[Post_List[n].segment];
  }
  Dump_List.segment        = newseg[    Dump_List.segment];
  Gateway_List.segment     = newseg[ Gateway_List.segment];
  Sampling_List.segment    = newseg[Sampling_List.segment];
  return;
}
 
 
void process_aliases(void) {
  long  i, j, id;
  char  tok[STRLENGTH] = {'\0'};
  char *s = (char*) NULL;
  /* nodes and variables                                                                                                          */
  for (i = 0L; i < Num_Aliases; i++) {
    s = Alias_List[i].aliasof;                                                /* node or variable target of the alias             */
    (void) snprintf(tok, (size_t) (STRLENGTH-1L), "%s", s);
    id = node_id(tok);
    if (UNDEFINED != id) {
      if (Node_List[id].aliased) {                                            /* alias != name                                    */
        print_error_location("alias", Alias_List[i].mline, Alias_List[i].mfile);
        (void) fprintf(STDERR,   "    <%s> cannot be an alias of node <%s>,",     Alias_List[i].name, tok  );
        (void) fprintf(STDERR,   " as <%s> is already an alias\n",                Node_List[id].name1      );
        continue;
      }
      Node_List[id].aliased = true;
      strcpy_realloc(&(Node_List[id].name1), Alias_List[i].name, Alias_List[i].mline, Alias_List[i].mfile);
      continue;
    }
    id = var_id(tok);
    if (UNDEFINED != id) {
      if (Var_List[id].aliased) {                                             /* alias != name                                    */
        print_error_location("alias", Alias_List[i].mline, Alias_List[i].mfile);
        (void) fprintf(STDERR,   "    <%s> cannot be an alias of variable <%s>,", Alias_List[i].name, tok);
        (void) fprintf(STDERR,   " as <%s> is already an alias\n",                Var_List[id].name1     );
        continue;
      }
      Var_List[id].aliased = true;
      strcpy_realloc(&(Var_List[id].name1), Alias_List[i].name, Alias_List[i].mline, Alias_List[i].mfile);
      continue;
    }
    print_error_location("alias", Alias_List[i].mline, Alias_List[i].mfile);
    (void) fprintf(STDERR,       " no node and no variable correspond to target <%s> of alias <%s>\n", tok, Alias_List[i].name);
    process_node_error(tok);
    process_variable_error(tok);
  }
  /* command_line                                                                                                                 */
  for (i = 0L; i < Num_Cmdlines; i++) {                                       /* rework the line of parms                         */
    j = var_id(Cmdline_List[i].parms);
    if (UNDEFINED != j) {
      strcpy_realloc(&(Cmdline_List[i].parms), Var_List[j].name1, Cmdline_List[i].mline, Cmdline_List[i].mfile);
    }
  }
  return;
}
 
 
/* Greater Common Divider function. Recursive function !                                                                          */
 
double GCD(double a, double b) {
  if (a < b) {
    return GCD(b, a);
  }
  if (_SMALL_ >= b) {
    return a;
  } else {
    return GCD(b, fmod(a, b));
  }
}
 
 
/* Least Common Multiple function. Use the recursive function GCD !                                                               */
 
double LCM(double n1, double n2) {
  return ((n1 / GCD(n1, n2)) * n2);                                           /* ordered operation to avoid possible overflow !   */
}
 
 
/* Specific test to verify that the platform supports right shifts. It is normal that verification software flags this code,      */
/* as it is, on purpose, a non portable code !                                                                                    */
 
int verify_rshift(void) {
  long n1, n2;
  n1 = -0X0500L;
  n2 = n1 >> 2;    /* "Shifting a negative value is undefined behavior" : this is exactly the trick here to verify the platform ! */
  return ((0L != n2) ? true : false);
}
 
 
/* During file expansion, comments and blank lines are dropped                                                                    */
/* Only comments placed on single lines are ignored !                                                                             */
 
void cat_file(const char *fnam, const char *type, long command, const unsigned long *mlin, const unsigned long *mfil) {
  FILE *fp = (FILE*) NULL;
  char  lin1[LINLENGTH+2L] = {'\0'};
  char  lin2[LINLENGTH+2L] = {'\0'};
  long  i, j;
  int   flag1, flag2;
  flag1 = false;
  flag2 = false;
  if ((FILE*) NULL == (fp = fopen(fnam, "r"))) {
    print_error_location("file", mlin, mfil);
    (void) fprintf(STDERR,       " OUCH!- (%s) can't find or access file <\"%s\">\n", type, fnam);
    print_error_banner_and_exit();
  }
  if (EXPAND == command) {                                                    /* file expansion is requested                      */
    while ((char*) NULL != (fgets(lin1, LINLENGTH, fp))) {
      flag1 = true;
      j = 0L;
      for (i = 0L; i < LENGTH(lin1); i++) {                                   /* ignore comment area                              */
        if ((flag1) && ('/' == lin1[i]) && ('*' == lin1[i+1L]))  {
          i++;
          flag1 = false;
          continue;
        }
        if (flag1) {
          lin2[j] = lin1[i];
          j++;
        }
        if ((!flag1) && ('*' == lin1[i-1L]) && ('/' == lin1[i])) {
          flag1 = true;
          continue;
        }
      }
      if (flag1) {
        lin2[j] = '\0';
        (void) strcpy(lin1, lin2);
      }
      flag2 = false;
      for (i = 0L; i < LENGTH(lin1); i++) {
        if (!isspace((int) lin1[i])) {
          flag2 = true;                                                       /* line contents non blank element                  */
        }
      }
      if (flag2) {                                                            /* do not copy blank or all comment lines           */
        (void) fprintf(STDOUT, "%s", lin1);
      }
    }
  }
  if (EOF == fclose(fp)) {
    print_error_location("file", mlin, mfil);
    (void) fprintf(STDERR,       " OUCH!- (%s) can't close file <\"%s\"> opened for verification\n", type, fnam);
    print_error_banner_and_exit();
  }
  return;
}
 
 
void process_error_if_any(void) {
  (void) f1flush((FILE*) NULL);
  if (0 != Error_Flag) {
    print_error_banner_and_exit();
  }
  return;
}
 
 
void print_error_location(const char *type, const unsigned long *mlin, const unsigned long *mfil) {
  print_problem_location(type, mlin, mfil, "Error"  );
  (void) fprintf(STDERR,       "\n");
  Error_Flag++;
  return;
}
 
 
void print_warning_location(const char *type, const unsigned long *mlin, const unsigned long *mfil) {
  print_problem_location(type, mlin, mfil, "Warning");
  Warning_Flag = true;
  return;
}
 
 
void print_info_location(const char *type, const unsigned long *mlin, const unsigned long *mfil) {
  print_problem_location(type, mlin, mfil, "Note"   );
  return;
}
 
 
void print_problem_location(const char *type, const unsigned long *mlin, const unsigned long *mfil, const char *kind) {
  char tok[STRLENGTH] = {'\0'};
  if (0 == strcmp(type, "")) {
    (void) strcpy(tok, "");
  } else {
    (void) snprintf(tok, (size_t) (STRLENGTH-1L), " (%s)", type);
  }
  (void) fprintf(STDERR,       "\nNAPA %s: %s\n", kind, tok);
  print_location(mlin, mfil);
  return;
}
 
 
void print_location(const unsigned long *mlin, const unsigned long *mfil) {
  long d;
  if (((unsigned long*) NULL == mlin) || ((unsigned long*) NULL == mfil)) {
    return;
  }
  if (0UL == mlin[0]) {
    return;
  }
  (void) fprintf(STDERR,         " -> at line %3lu of main netlist\n", mlin[0]);
  for (d = 1L; d < MAXDEPTH; d++) {
    if (0UL == mlin[d]) {
      (void) fprintf(STDERR,     "   ");
      return;
    }
    (void) fprintf(STDERR,       " -> at line %3lu of file \"%s\"\n",  mlin[d], Record_Cell_File_Table[mfil[d]]);
  }
  (void) f1flush((FILE*) NULL);                                               /* flush ALL stream outputs                         */
  return;
}
 
 
/*  Danny Cohen introduced the terms Little-Endian and Big-Endian for byte ordering in an article published                       */
/*  by the Internet Engineering Task Force (IETF) in 1980.[1][2] In this technical and political examination                      */
/*  of byte ordering issues, the endian names were drawn from Jonathan Swift's 1726 satire, Gulliver's Travels,                   */
/*  in which civil war erupts over whether the big end or the little end of a boiled egg is the proper end to crack open.         */
/*  Intel x86, for example, is using LITTLE_ENDIAN.                                                                               */
 
int test_endianness(void) {
  short int word = (short int) 0X0001LL;
  char     *byte = (char*) &word;
  return byte[0] ? LITTLE_ENDIAN : BIG_ENDIAN;
}
 
 
void wall_clock(void) {
  NAPA_Compile_Stop = ((double) clock())/((double) CLOCKS_PER_SEC);
  (void) fprintf(STDERR,       "\n      wall clock: %6.3f s\n\n", (NAPA_Compile_Stop - NAPA_Compile_Start));
  (void) f1flush((FILE*) NULL);                                               /* flush ALL stream outputs                         */
  return;
}
 
 
void last_message(void) {                                                     /* this function is registered with 'atexit'        */
  if (0 != Error_Flag) {
    (void) fprintf(STDERR,     "\n ****\n"    );
    (void) fprintf(STDERR,       " ****  NAPA Compilation Error(s)\n");
    (void) fprintf(STDERR,       " ****\n\n\n");
  }
  (void) f1flush((FILE*) NULL);                                               /* flush ALL stream outputs                         */
  return;
}
 
 
/* ****************************************************************************************************************************** */
/* end of file                                                                                                                    */