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

Go to the documentation of this file.

/* ** ID RELATED FUNCTIONS DEFINITIONS ****************************************************************************************** */
 
#undef  EXTERN
#define EXTERN extern
 
#include "./napa.h"
#include "./proto.h"
 
 
/* *** In this file: ************************************************************************************************************ */
 
/* int  is_an_instruction(const char *identifier)                                                                                 */
/* int  is_an_operator(const char *identifier)                                                                                    */
/* int  is_a_keyword(const char *identifier)                                                                                      */
/* int  is_a_known_function(const char *identifier)                                                                               */
/* int  is_a_known_pure_function(const char *identifier)                                                                          */
/* int  is_a_constant_or_a_macro_constant(const char *identifier)                                                                 */
/* int  is_a_modifier(const char *identifier)                                                                                     */
/* int  is_node_flagged(long num)                                                                                                 */
/* int  node_update_block(void)                                                                                                   */
/* int  time_output_block(void)                                                                                                   */
/* int  variable_update_block(void)                                                                                               */
 
/* long alias_id(char *identifier)                                                                                                */
/* long array_id(char *identifier)                                                                                                */
/* long array_name_id(char *identifier)                                                                                           */
/* long cmdline_id(char *identifier)                                                                                              */
/* long constant_type(char *identifier)                                                                                           */
/* long debug_id(char *identifier)                                                                                                */
/* long declare_id(char *identifier)                                                                                              */
/* long directive_id(char *identifier)                                                                                            */
/* long get_type(char *identifier)                                                                                                */
/* long node_kind(char *identifier)                                                                                               */
/* long node_id(char *identifier)                                                                                                 */
/* long op_id(char *identifier)                                                                                                   */
/* long postprocess_id(char *identifier)                                                                                          */
/* long record_id(char *identifier)                                                                                               */
/* long sort_names(const void*, const void*)                                                                                      */
/* long update_id(char *identifier, long num)                                                                                     */
/* long user_id(char *identifier)                                                                                                 */
/* long usertool_num(const char *nam)                                                                                             */
/* long var_id(char *identifier)                                                                                                  */
 
/* void flag_node(long num)                                                                                                       */
/* void increment_alias_number(const char *kind)                                                                                  */
/* void increment_array_number(const char *kind)                                                                                  */
/* void increment_assert_number(const char *kind)                                                                                 */
/* void increment_call_number(const char *kind)                                                                                   */
/* void increment_cmdline_number(const char *kind)                                                                                */
/* void increment_comment_number(const char *kind)                                                                                */
/* void increment_common_number(const char *kind)                                                                                 */
/* void increment_const_number(void)                                                                                              */
/* void increment_debug_number(const char *kind)                                                                                  */
/* void increment_declare_number(const char *kind)                                                                                */
/* void increment_directive_number(const char *kind)                                                                              */
/* void increment_export_number(const char *kind)                                                                                 */
/* void increment_filecell_number(const char *kind)                                                                               */
/* void increment_function_number(const char *kind)                                                                               */
/* void increment_generator_number(const char *kind)                                                                              */
/* void increment_group_number(const char *kind)                                                                                  */
/* void increment_header_number(const char *kind)                                                                                 */
/* void increment_inject_number(const char *kind)                                                                                 */
/* void increment_init_number(const char *kind)                                                                                   */
/* void increment_instance_number(const char *kind)                                                                               */
/* void increment_IO_number(const char *kind)                                                                                     */
/* void increment_node_number(const char *kind)                                                                                   */
/* void increment_opcode_number(const char *kind)                                                                                 */
/* void increment_post_number(const char *kind)                                                                                   */
/* void increment_record_number(const char *kind)                                                                                 */
/* void increment_segment_number(const char *kind)                                                                                */
/* void increment_stuck_number(const char *kind)                                                                                  */
/* void increment_tool_number(const char *kind)                                                                                   */
/* void increment_update_number(const char *kind)                                                                                 */
/* void increment_usertool_number(const char *kind)                                                                               */
/* void increment_var_number(const char *kind)                                                                                    */
/* void increment_void_number(void)                                                                                               */
/* void mark_constants(void)                                                                                                      */
/* void mark_updates_if_constant(void)                                                                                            */
/* void strcpy_alloc(char **dest, const char *sour, const unsigned long *mlin, const unsigned long * mfil)                        */
/* void strcpy_realloc(char **dest, const char *sour, const unsigned long *mlin, const unsigned long *mfil)                       */
/* void swap_delay_inputs(long i, long j)                                                                                         */
/* void swap_nodes(long i, long j)                                                                                                */
/* void swap_records(long i, long j)                                                                                              */
/* void swap_updates(long i, long j)                                                                                              */
/* void swap_vars(long i, long j)                                                                                                 */
 
 
/* ***** MACROS USED IN THIS FILE *********************************************************************************************** */
 
#define IS_IDENTIFIER(x)    (0 == strcmp(identifier, x))
 
#define IS_NAPA_PREFIX()    (0 == strncmp(identifier, "napa_",    (size_t) 5))
#define IS_DEBUG_PREFIX()   (0 == strncmp(identifier, "DEBUG_",   (size_t) 6))
#define IS_COMPILE_PREFIX() (0 == strncmp(identifier, "COMPILE_", (size_t) 8))
 
 
/* ****************************************************************************************************************************** */
 
void flag_node(long num) {                                                    /* set to -1 a node flagged in error                */
  Node_List[num].errflag = -1;
  return;
}
 
 
int is_node_flagged(long num) {                                               /* node flagged in error is set to -1               */
  return (int) (-1 >= Node_List[num].errflag);
}
 
 
/* ****************************************************************************************************************************** */
 
/* copy string after appropriate memory allocation                                                                                */
 
void strcpy_alloc(char **dest, const char *sour, const unsigned long *mlin, const unsigned long *mfil) {
  *dest = (char*) malloc((size_t) (LENGTH(sour) + 1L));
  if ((char*) NULL == *dest) {
    print_error_location("malloc", mlin, mfil);
    (void) fprintf(STDERR,       " dynamic memory allocation error\n");
    print_error_banner_and_exit();
  } else {
    (void) strcpy(*dest, sour);
  }
  return;
}
 
 
/* Copy string after appropriate memory reallocation                                                                              */
 
void strcpy_realloc(char **dest, const char *sour, const unsigned long *mlin, const unsigned long *mfil) {
  if ((char*) NULL == *dest) {
    print_error_location("malloc", mlin, mfil);
    (void) fprintf(STDERR,       " impossible to reallocate memory for something not yet allocated\n");
    (void) fprintf(STDERR,       " when processing data <%s>\n", sour);
    print_error_banner_and_exit();
  }
  free(*dest);
  *dest = (char*) NULL;
  *dest = (char*) malloc((size_t) (LENGTH(sour) + 1L));
  if ((char*) NULL == *dest) {
    print_error_location("malloc", mlin, mfil);
    (void) fprintf(STDERR,       " dynamic memory allocation error during reallocation when processing data <%s>\n", sour);
    print_error_banner_and_exit();
  } else {
    (void) strcpy(*dest, sour);
  }
  return;
}
 
 
void increment_alias_number(const char *kind) {
  if ((MAXALIASES - 1L) <= Num_Aliases) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many aliases (current max = %ld)\n", MAXALIASES);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Aliases++;
  return;
}
 
 
void increment_array_number(const char *kind) {
  if ((MAXARRAYS - 1L) <= Num_Arrays) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many node arrays (current max = %ld)\n", MAXARRAYS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Arrays++;
  return;
}
 
 
void increment_assert_number(const char *kind) {
  if ((MAXUPDATES - 2L) <= Num_Updates) {                                     /* YES! 'update' to prevent cryptic error message   */
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s / update) internal array overflow!", kind);
    (void) fprintf(STDERR,       " assert instruction is overflowing the update table\n");
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Asserts++;
  return;
}
 
 
void increment_call_number(const char *kind) {
  if ((MAXUPDATES - 2L) <= Num_Updates) {                                     /* YES! 'update' to prevent cryptic error message   */
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s / update) internal array overflow!", kind);
    (void) fprintf(STDERR,       " call instruction is overflowing the update table\n");
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Calls++;
  return;
}
 
 
void increment_cmdline_number(const char *kind) {
  if ((MAXCMDLINES - 1L) <= Num_Cmdlines) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal command line overflow!", kind);
    (void) fprintf(STDERR,       " too many parameters in 'command_line' instructions (current max = %ld)\n", MAXCMDLINES);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Cmdlines++;
  return;
}
 
 
void increment_comment_number(const char *kind) {
  if ((MAXCOMMENTS - 1L) <= Num_Comments) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many comments (current max = %ld)\n", MAXCOMMENTS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Comments++;
  return;
}
 
 
void increment_common_number(const char *kind) {
  if ((MAXDECLARECOMMONS - 1L) <= Num_Declare_Commons) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many declare() instructions (current max = %ld)\n", MAXDECLARECOMMONS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Declare_Commons++;
  return;
}
 
 
void increment_debug_number(const char *kind) {
  if ((MAXDEBUGS - 1L) <= Num_Debugs) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many debug instructions (current max = %ld)\n", MAXDEBUGS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Debugs++;
  return;
}
 
 
void increment_declare_number(const char *kind) {
  if ((MAXDECLARES - 1L) <= Num_Declares) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many declare instructions (current max = %ld)\n", MAXDECLARES);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Declares++;
  return;
}
 
 
void increment_directive_number(const char *kind) {
  if ((MAXDIRS - 1L) <= Num_Directives) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many user's directives (current max = %ld)\n", MAXDIRS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Directives++;
  return;
}
 
 
void increment_export_number(const char *kind) {
  if ((MAXEXPORTS - 1L) <= Num_Exports) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many export variables (current max = %ld)\n", MAXEXPORTS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Exports++;
  return;
}
 
 
void increment_filecell_number(const char *kind) {
  if ((MAXFILECELLS - 1L) <= Num_FileCells) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many different cells (current max = %ld)\n", MAXFILECELLS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_FileCells++;
  return;
}
 
 
void increment_function_number(const char *kind) {
  Function_Flag = true;
  if ((MAXFUNCTIONS - 1L) <= Num_Functions) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many external functions (current max = %ld)\n", MAXFUNCTIONS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Functions++;
  return;
}
 
 
void increment_generator_number(const char *kind) {
  /* no limit to number of generators, but each generator adds a cell instantiation                                               */
  static int flag = false;
  if ((!flag) && ((MAXINSTANCES / 2L) <= Num_Generators)) {
    flag = true;
    (void) fprintf(STDERR,     "\nNAPA Compiler Warning:\n");
    (void) fprintf(STDERR,       " (%s) large number of generators!", kind);
    (void) fprintf(STDERR,       " consider to review the number of authorized instances (current max = %ld)\n", MAXINSTANCES);
  }
  Num_Generators++;
  return;
}
 
 
void increment_group_number(const char *kind) {
  if ((MAXGROUPS - 1L) <= Num_Groups) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many groups of postprocess functions (current max = %ld)\n", MAXGROUPS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Groups++;
  return;
}
 
 
void increment_header_number(const char *kind) {
  if ((MAXHEADERS - 1L) <= Num_Headers) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many header files (current max = %ld)\n", MAXHEADERS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Headers++;
  return;
}
 
 
void increment_init_number(const char *kind) {
  if ((MAXVARS - 2L) <= Num_Vars) {                                           /* YES! 'var' to prevent cryptic error message      */
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s / var) internal array overflow!", kind);
    (void) fprintf(STDERR,       " %s instruction is overflowing the var table\n", kind);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Inits++;
  return;
}
 
 
void increment_inject_number(const char *kind) {
  if ((MAXINJECTS - 1L) <= Num_Injects) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many node injections (current max = %ld)\n", MAXINJECTS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Injects++;
  return;
}
 
 
void increment_instance_number(const char *kind) {
  if ((MAXINSTANCES - 1L) <= Num_Instances) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " cell name registering overflow (current max = %ld)\n", MAXINSTANCES);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Instances++;
  return;
}
 
 
void increment_IO_number(const char *kind) {
  if ((MAXIOS - 1L) <= Num_IOs) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many input and output instructions (current max = %ld)\n", MAXIOS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Groups = 0L;
  Num_IOs++;
  return;
}
 
 
void increment_node_number(const char *kind) {
  if ((MAXNODES - 1L) <= Num_Nodes) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many nodes (current max = %ld)\n", MAXNODES);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Groups = 0L;
  Num_Nodes++;
  return;
}
 
 
void increment_opcode_number(const char *kind) {
  if ((MAXOPCODES - 1L) <= Num_Opcodes) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many opcodes (current max = %ld)\n", MAXOPCODES);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Opcodes++;
  return;
}
 
 
void increment_post_number(const char *kind) {
  if ((MAXPOSTS - 1L) <= Num_Posts) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many postprocessing functions (current max = %ld)\n", MAXPOSTS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Posts++;
  return;
}
 
 
void increment_record_number(const char *kind) {
  if ((MAXRECORDS - 1L) <= Num_Records) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " array of pointers name registering overflow (current max = %ld)\n", MAXRECORDS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Records++;
  return;
}
 
 
void increment_restart_number(const char *kind) {
  if ((MAXUPDATES - 2L) <= Num_Updates) {                                     /* YES! 'update' to prevent cryptic error message   */
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s / update) internal array overflow!", kind);
    (void) fprintf(STDERR,       " call instruction is overflowing the update table\n");
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Restarts++;
  return;
}
 
 
void increment_segment_number(const char *kind) {
  if ((MAXSEGMENTS - 1L) <= Num_Segments) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many simulation segments (current max = %ld)\n", MAXSEGMENTS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Segments++;
  return;
}
 
 
void increment_stuck_number(const char *kind) {
  if ((MAXSTUCKS - 1L) <= Num_Stucks) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many stuck nodes (current max = %ld)\n", MAXSTUCKS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Stucks++;
  return;
}
 
 
void increment_tool_number(const char *kind) {
  if ((MAXUSERTOOLS - 1L) <= Num_Tools) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many tool functions (current max = %ld)\n", MAXUSERTOOLS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Tools++;
  return;
}
 
 
void increment_update_number(const char *kind) {
  if ((MAXUPDATES - 1L) <= Num_Updates) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many update of variables (current max = %ld)\n", MAXUPDATES);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Updates++;
  return;
}
 
 
void increment_usertool_number(const char *kind) {
  UserTool_Flag = true;
  if ((MAXUSERTOOLS - 1L) <= Num_UserTools) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many user functions (current max = %ld)\n", MAXUSERTOOLS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_UserTools++;
  return;
}
 
 
void increment_var_number(const char *kind) {
  if ((MAXVARS - 1L) <= Num_Vars) {
    (void) fprintf(STDERR,     "\nNAPA Compiler Error:\n");
    (void) fprintf(STDERR,       " (%s) internal array overflow!", kind);
    (void) fprintf(STDERR,       " too many variables (current max = %ld)\n", MAXVARS);
    print_limits();
    print_error_banner_and_exit();
  }
  Num_Vars++;
  return;
}
 
 
void increment_const_number(void) {                                           /* there is no limit to const numbering             */
  Num_Consts++;
  return;
}
 
 
void increment_void_number(void) {                                            /* there is no limit to void numbering              */
  Num_Voids++;
  return;
}
 
 
/* ****************************************************************************************************************************** */
 
int sort_names(const void *a, const void *b) {                                /* function 'sort_names(...) used by 'qsort'        */
  int num;
  num = strcmp(*(char**) a, *(char**) b);
  return num;
}
 
 
/* ****************************************************************************************************************************** */
 
void swap_delay_inputs(long i, long j) {
  long k;
  k              = Delay_Input[j];
  Delay_Input[j] = Delay_Input[i];
  Delay_Input[i] = k;
  return;
}
 
 
void swap_nodes(long i, long j) {                                             /* use last location as storage for node swapping   */
  Node_List[Num_Nodes] = Node_List[i];
  Node_List[i]         = Node_List[j];
  Node_List[j]         = Node_List[Num_Nodes];
  return;
}
 
 
void swap_records(long i, long j) {                                           /* use last location as storage for array swap      */
  Record_List[Num_Records] = Record_List[i];
  Record_List[i]           = Record_List[j];
  Record_List[j]           = Record_List[Num_Records];
  return;
}
 
 
void swap_vars(long i, long j) {                                              /* use last location as storage for var swapping    */
  Var_List[Num_Vars] = Var_List[i];
  Var_List[i]        = Var_List[j];
  Var_List[j]        = Var_List[Num_Vars];
  return;
}
 
 
void swap_updates(long i, long j) {                                           /* use last location as storage for var swapping    */
  Update_List[Num_Updates] = Update_List[i];
  Update_List[i]           = Update_List[j];
  Update_List[j]           = Update_List[Num_Updates];
  return;
}
 
 
/* ****************************************************************************************************************************** */
 
long alias_id(const char *identifier) {                                             /* get alias ID if already defined                  */
  long i;
  for (i = 0L; i < Num_Aliases; i++) {
    if (IS_IDENTIFIER(Alias_List[i].name)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long array_id(const char *identifier) {                                             /* get array ID if -array- already defined          */
  long i;
  for (i = 0L; i < Num_Arrays; i++) {
    if (IS_IDENTIFIER(Array_List[i].name)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long array_name_id(const char *identifier) {                                        /* get array ID if -file- already defined           */
  long i;
  for (i = 0L; i < Num_Arrays; i++) {
    if (IS_IDENTIFIER(Array_List[i].fname)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long cmdline_id(const char *identifier) {                                           /* get ID if already defined                        */
  long  i, v;
  char tok[STRLENGTH] = {'\0'};
  if (!Cmdline_Flag) {
    return UNDEFINED;
  }
  v = var_id(identifier);
  if (UNDEFINED == v) {
    return UNDEFINED;
  }
  (void) strcpy(tok, Var_List[v].name1);
  for (i = 0L; i < Num_Cmdlines; i++) {
    if (0 == strcmp(tok, Cmdline_List[i].parms)) {
      return i;
    }
  }
  if (Var_List[v].aliased) {                                                  /* search also for aliased name if any              */
    (void) strcpy(tok, Var_List[v].name2);
    for (i = 0L; i < Num_Cmdlines; i++) {
      if (0 == strcmp(tok, Cmdline_List[i].parms)) {
        return i;
      }
    }
  }
  return UNDEFINED;
}
 
 
long debug_id(const char *identifier) {                                             /* get ID if already defined                        */
  long i;
  for (i = 0L; i < Num_Debugs; i++) {
    if (IS_IDENTIFIER(Debug_List[i].name)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long declare_id(const char *identifier) {                                           /* get declare ID if already defined                */
  long i;
  for (i = 0L; i < Num_Declares; i++) {
    if (IS_IDENTIFIER(Declare_List[i].name)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long directive_id(const char *identifier) {                                         /* get directive ID if already defined              */
  long i;
  for (i = 0L; i < Num_Directives; i++) {
    if (IS_IDENTIFIER(Directive_List[i].name)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long node_id(const char *identifier) {                                              /* get node ID if already defined                   */
  long i, j, m, n;
  char tok1[STRLENGTH] = {'\0'};
  char tok2[STRLENGTH] = {'\0'};
  char tok3[STRLENGTH] = {'\0'};
  char buf[LINLENGTH]  = {'\0'};
  char *str = (char*) NULL;
  if (IS_IDENTIFIER("TOOL_INDEX")) {
    Tool_Index_Flag = true;                                                   /* to know if TOOL_INDEX is explicitely used        */
  }
  for (i = 0L; i < Num_Nodes; i++) {
    if (IS_IDENTIFIER(Node_List[i].name1)) {
      return i;
    }
    if (IS_IDENTIFIER(Node_List[i].name2)) {
      return i;
    }
  }
  for (i = 0L; i < Num_Records; i++) {                                        /* get node through an 'array_id'.'number' id       */
    (void) strcpy(tok1, identifier);
    str = strchr(tok1, '.');
    if ((char*) NULL == str) {
      continue;
    }
    (void) strcpy(tok2, str + 1);                                             /* 'tok2' contains the right part of the identifier */
    *str = '\0';                                                              /* 'tok1' contains the id of the array              */
    if (0 == strcmp(tok1, Record_List[i].name)) {                             /* record matches !                                 */
      if ((1 != sscanf(tok2, "%li", &m)) || (1L > m)) {
        print_error_location("array", Record_List[i].mline, Record_List[i].mfile);
        (void) fprintf(STDERR,   " <%s.%s> is not a correct identifier, <%s> must be a strictly positive integer\n",tok1,tok2,tok2);
        exit(EXIT_FAILURE);
      }
      (void) strcpy(buf, Record_List[i].list1);
      str = buf;
      j   = 0L;
      while (ISNOTEMPTY(str) && (j < m)) {
        str = get_token(str, tok3, false);
        j++;
      }
      if (j != m) {
        print_error_location("array", Record_List[i].mline, Record_List[i].mfile);
        (void) fprintf(STDERR,   " there is no element #%s in array <%s>\n", tok2, tok1);
        exit(EXIT_FAILURE);
      }
      n = node_id(tok3);                                                      /* recursive call                                   */
      if (UNDEFINED != n) {
        return n;
      } else {
        continue;
      }
    }
  }
  return UNDEFINED;
}
 
 
long op_id(const char *identifier) {                                                /* get FIRST opcode ID if already defined           */
  long i;
  for (i = 0L; i < Num_Opcodes; i++) {
    if (IS_IDENTIFIER(Opcode_List[i].name)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long postprocess_id(const char *identifier) {                                       /* get postprocess function ID if already defined   */
  long i;
  for (i = 0L; i < Num_Posts; i++) {
    if (IS_IDENTIFIER(Post_List[i].function)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long record_id(const char *identifier) {                                            /* get record ID if -record- already defined        */
  long i;
  for (i = 0L; i < Num_Records; i++) {
    if (IS_IDENTIFIER(Record_List[i].name)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long update_id(const char *identifier, long num) {                                  /* get the #num-th update ID if already defined     */
  long  i, k, v;
  char tok[STRLENGTH] = {'\0'};
  if (IS_IDENTIFIER("TOOL_INDEX")) {
    Tool_Index_Flag = true;                                                   /* to know if TOOL_INDEX is explicitely used        */
    return UNDEFINED;                                                         /* there is no update as TOOL_INDEX is not defined  */
  }
  v = var_id(identifier);
  if (UNDEFINED == v) {
    return UNDEFINED;                                                         /* there is no update as variable does not exist    */
  }
  (void) strcpy(tok, Var_List[v].name1);
  k = 0L;
  for (i = 0L; i < Num_Updates; i++) {
    if (0 == strcmp(tok, Update_List[i].name)) {
      k++;
      if (k == num) {
        return i;
      }
    }
  }
  if (Var_List[v].aliased) {                                                  /* search also for aliased name if any              */
    (void) strcpy(tok, Var_List[v].name2);
    k = 0L;
    for (i = 0L; i < Num_Updates; i++) {
      if (0 == strcmp(tok, Update_List[i].name)) {
        k++;
        if (k == num) {
          return i;
        }
      }
    }
  }
  return UNDEFINED;
}
 
 
long user_id(const char *identifier) {                                              /* get user defined function ID if already defined  */
  long i;
  for (i = 0L; i < Num_UserTools; i++) {
    if (IS_IDENTIFIER(UserTool_List[i].name)) {
      return i;
    }
  }
  return UNDEFINED;
}
 
 
long var_id(const char *identifier) {                                               /* get var ID if already defined                    */
  long i, j, m, v;
  char tok1[STRLENGTH] = {'\0'};
  char tok2[STRLENGTH] = {'\0'};
  char tok3[STRLENGTH] = {'\0'};
  char buf[LINLENGTH]  = {'\0'};
  char *str = (char*) NULL;
  if (IS_IDENTIFIER("TOOL_INDEX")) {
    Tool_Index_Flag = true;                                                   /* to know if TOOL_INDEX is explicitely used        */
  }
  for (i = 0L; i < Num_Vars; i++) {
    if (IS_IDENTIFIER(Var_List[i].name1)) {
      return i;
    }
    if (IS_IDENTIFIER(Var_List[i].name2)) {
      return i;
    }
  }
  for (i = 0L; i < Num_Records; i++) {                                        /* get var through an 'array_id'.'number' id        */
    (void) strcpy(tok1, identifier);
    str = strchr(tok1, '.');
    if ((char*) NULL == str) {
      continue;
    }
    (void) strcpy(tok2, str + 1);                                             /* 'tok2' contains the right part of the identifier */
    *str = '\0';                                                              /* 'tok1' contains the id of the array              */
    if (0 == strcmp(tok1, Record_List[i].name)) {                             /* record matches !                                 */
      if ((1 != sscanf(tok2, "%li", &m)) || (1L > m)) {
        print_error_location("array", Record_List[i].mline, Record_List[i].mfile);
        (void) fprintf(STDERR,   " <%s.%s> is not a correct identifier, <%s> must be a strictly positive integer\n",tok1,tok2,tok2);
        exit(EXIT_FAILURE);
      }
      (void) strcpy(buf, Record_List[i].list1);
      str = buf;
      j   = 0L;
      while (ISNOTEMPTY(str) && (j < m)) {
        str = get_token(str, tok3, false);
        j++;
      }
      if (j != m) {
        print_error_location("array", Record_List[i].mline, Record_List[i].mfile);
        (void) fprintf(STDERR,   " there is no element #%s in array <%s>\n", tok2, tok1);
        exit(EXIT_FAILURE);
      }
      v = var_id(tok3);                                                       /* recursive call                                   */
      if (UNDEFINED != v) {
        return v;
      } else {
        continue;
      }
    }
  }
  return UNDEFINED;
}
 
 
/* ****************************************************************************************************************************** */
 
/* Mark update of constants. Their updates will be skipped in the simulator.                                                      */
 
/* by default, if not already set-up to false for good reasons, the status is MAYBE.                                              */
/* Updates tagged with MAYBE are analysed could be tagged false during this process.                                              */
/* Updates tagged with false are tagged false for ever. At the end of this process, all MAYBE are transformed in false.           */
 
void mark_updates_if_constant(void) {
  long i, j, k, m, n, u, v;
  char *nam = (char*) NULL;
  char *str = (char*) NULL;
  char tok[LINLENGTH] = {'\0'};
  int  flag;
  if (0L >= Num_Updates) {
    return;
  }
  /* fix obvious update definitions to constant or not constant                                                                   */
  for (i = 0L; i < Num_Updates; i++) {
    nam = Update_List[i].name;
    if ((0 == strncmp(nam, "$call$",   (size_t) 6)) || (0 == strncmp(nam, "$null$",    (size_t) 6))
     || (0 == strncmp(nam, "$assert$", (size_t) 8)) || (0 == strncmp(nam, "$restart$", (size_t) 9))) {
      Update_List[i].constant = false;                                        /* must be always processed                         */
      continue;
    }
    if (0 == strcmp(nam, Update_List[i].value)) {                             /* identity! weird but OK                           */
      Update_List[i].constant = true;
      continue;
    }
    v = var_id(nam);
    if (UNDEFINED != v) {
      if (0 != strcmp(Update_List[i].value, Var_List[v].value)) {             /* update != variable                               */
        Update_List[i].constant = false;                                      /* must be updated!                                 */
      }
    }
  }
  do {
    flag = false;
    for (i = 0L; i < Num_Updates; i++) {
      if (MAYBE != Update_List[i].constant) {                                 /* already determined                               */
        continue;
      }
      Update_List[i].constant = true;                                         /* if there is no doubt, it will be a constant      */
      nam = Update_List[i].name;
      str = Update_List[i].value;
      for (;;) {                                                              /* scanning the update definition, token by token   */
        v = UNDEFINED;
        n = UNDEFINED;
        str = get_token(str, tok, true);
        if (ISEMPTY(tok)) {                                                   /* end of scan of the update definition of ID i     */
          break;
        }
        if (UNKNOWN_TYPE != constant_type(tok)) {                             /* a known constant, continue scanning              */
          continue;
        }
        if (is_a_constant_or_a_macro_constant(tok)) {                         /* a known constant, continue scanning              */
          continue;
        }
        if (STRING_DATA_TYPE == get_type(tok)) {                              /* a known constant, continue scanning              */
          continue;
        }
        if (is_a_known_pure_function(tok)) {                                  /* harmless, continue scanning                      */
          continue;
        }
        if (is_an_operator(tok)) {                                            /* harmless as ++ and -- are forbidden              */
          continue;
        }
        if (is_a_modifier(tok)) {                                             /* harmless, continue scanning                      */
          continue;
        }
        n = node_id(tok);
        if (UNDEFINED != n) {
          if ((DC_KIND == Node_List[n].kind) || (CONST_KIND == Node_List[n].kind)) {
            continue;
          } else {                                                            /* nodes are not constant (DC excepted)             */
            flag = true;
            Update_List[i].constant = false;
            break;
          }
        }
        v = var_id(tok);                                                      /* this is searching for alias also                 */
        if (UNDEFINED != v) {                                                 /* this is a variable                               */
          if ((0 == strcmp(nam, Var_List[v].name1)) || (0 == strcmp(nam, Var_List[v].name2))) {
            flag = true;                                                      /* self-reference: not a constant !                 */
            Update_List[i].constant = false;
            break;
          }
          k =    0L;
          u = -999L;
          while (UNDEFINED != u) {
            k++;
            u = update_id(tok, k);                                            /* this is searching for alias also                 */
            if (UNDEFINED != u) {                                             /* reference to an updated variable                 */
              if        (true  == Update_List[u].constant) {                  /* true, false or MAYBE                             */
                continue;
              } else if (!Update_List[u].constant) {
                flag = true;
                Update_List[i].constant = false;
                break;
              } else {                                                        /* undetermined, continue scanning                  */
                flag = true;
                Update_List[i].constant = MAYBE;
                continue;
              }
            } else {
              continue;                                                       /* a constant, continue scanning                    */
            }
          }
        }
        if ((UNDEFINED == n) && (UNDEFINED == v)) {
          flag = true;                                                        /* depends on unknown identifier                    */
          Update_List[i].constant = false;
        }
      }
      flag = true;
    }
  } while (flag);                                                             /* repeat until everything is stable                */
  for (i = 0L; i < Num_Updates; i++) {
    if (MAYBE == Update_List[i].constant) {
      Update_List[i].constant = false;                                        /* for some reason, not proven to be a constant     */
    }
  }
  /* We have to spread the status for multiple updates of the same variables                                                      */
  for (i = 0L; i < Num_Updates; i++) {
    if (!Update_List[i].constant) {
      continue;
    }
    for (j = 0L; j < Num_Updates; j++) {
      if (i == j) {
        continue;
      }
      if (!Update_List[j].constant) {
        m = var_id(Update_List[i].name);
        n = var_id(Update_List[j].name);
        if (m == n) {
          Update_List[i].constant = false;
          break;
        }
      }
    }
  }
  /* We have to tag the segment including an effective update as used                                                             */
  for (i = 0L; i < Num_Updates; i++) {
    if (!Update_List[i].constant) {
      Segment_List[Update_List[i].segment].used1 = true;
    }
  }
  return;
}
 
 
/* Identify true constants among variables.                                                                                       */
 
void mark_constants(void) {
  long i, v;
  if (0L >= Num_Updates) {
    return;
  }
  for (i = 0L; i < Num_Updates; i++) {
    if (!Update_List[i].constant) {
      v = var_id(Update_List[i].name);
      if (UNDEFINED != v) {
        Var_List[v].constant = false;
      }
    }
  }
  return;
}
 
 
/* ****************************************************************************************************************************** */
 
int variable_update_block(void) {
  long nseg;
  long u;
  u = 0L;
  for (nseg = 0L; nseg < Num_Segments; nseg++) {
    u += (long) (Segment_List[nseg].used1);
  }
  if (Inject_Flag) {
    u++;
  }
  if (0L < u) {
    return true;
  }
  return false;
}
 
 
int node_update_block(void) {
  long nseg;
  long u;
  u = 0L;
  for (nseg = 0L; nseg < Num_Segments; nseg++) {
    u += (long) (Segment_List[nseg].used2);
  }
  if (0L < u) {
    return true;
  }
  return false;
}
 
 
int time_output_block(void) {
 
  long nseg;
  long u;
  u = 0L;
  for (nseg = 0L; nseg < Num_Segments; nseg++) {
    u += (long) (Segment_List[nseg].used3);
  }
  if (0L < u) {
    return true;
  }
  return false;
}
 
/* ****************************************************************************************************************************** */
 
long constant_type(char *identifier) {                                        /* returns the number type of string                */
  char *str = (char*) NULL;
  double r;
  unsigned long long x;
  if (IS_IDENTIFIER("true")      || IS_IDENTIFIER("false")
   || IS_IDENTIFIER("TRUE")      || IS_IDENTIFIER("FALSE")
   || IS_IDENTIFIER("YES")       || IS_IDENTIFIER("NO")
   || IS_IDENTIFIER("START")     || IS_IDENTIFIER("STOP")
   || IS_IDENTIFIER("DIGITAL_INI")
   || IS_IDENTIFIER("ANTITHETIC")
   || IS_IDENTIFIER("RANDOM_SEED")
   || IS_IDENTIFIER("NUM_OF_SEGMENTS")
   || IS_IDENTIFIER("NUM_OF_TIME_OUTPUTS")
   || IS_IDENTIFIER("PERIODIC")
   || IS_IDENTIFIER("INT_MAX")   || IS_IDENTIFIER("INT_MIN")
   || IS_IDENTIFIER("LONG_MAX")  || IS_IDENTIFIER("LONG_MIN")
   || IS_IDENTIFIER("LLONG_MAX") || IS_IDENTIFIER("LLONG_MIN")) {
    return DIGITAL_DATA_TYPE;
  }
  if (IS_IDENTIFIER("_PI_")      || IS_IDENTIFIER("_pi_")
   || IS_IDENTIFIER("_2PI_")     || IS_IDENTIFIER("_2pi_")
   || IS_IDENTIFIER("_PI2_")     || IS_IDENTIFIER("_pi2_")
   || IS_IDENTIFIER("_PI4_")     || IS_IDENTIFIER("_pi4_")
   || IS_IDENTIFIER("_PI8_")     || IS_IDENTIFIER("_pi8_")
   || IS_IDENTIFIER("_E_")       || IS_IDENTIFIER("_e_")
   || IS_IDENTIFIER("FLT_MAX")   || IS_IDENTIFIER("FLT_MIN")
   || IS_IDENTIFIER("DBL_MAX")   || IS_IDENTIFIER("DBL_MIN")
   || IS_IDENTIFIER("LDBL_MAX")  || IS_IDENTIFIER("LDBL_MIN")
   || IS_IDENTIFIER("EPSILON")
   || IS_IDENTIFIER("ANALOG_INI")
   || IS_IDENTIFIER("FS")        || IS_IDENTIFIER("FSL")
   || IS_IDENTIFIER("SIM_RATE")) {
    return ANALOG_DATA_TYPE;
  }
  if (('0' == *identifier) && ('x' == *(identifier+1))) {
    if (1 == sscanf(identifier, "%llux", &x)) {
      return HEX_DATA_TYPE;
    }
  }
  if (1 != sscanf(identifier, "%lf", &r)) {                                   /* not analog                                       */
    if (('"' == identifier[0]) && ('"' == identifier[LENGTH(identifier)-1L])) {
      return STRING_DATA_TYPE;
    } else {
      return UNKNOWN_TYPE;
    }
  }
  if (ISNOTEQUAL(floor(r), r)) {                                              /* non zero decimal part. Analog type.              */
    return ANALOG_DATA_TYPE;
  }
  str = identifier;
  while ('\0' != *str) {                                                      /* decimal point. Analog type!                      */
    if ('.' == *str) {
      return ANALOG_DATA_TYPE;
    }
    str++;
  }
  return DIGITAL_DATA_TYPE;                                                   /* 'true' integer type                              */
}
 
 
long get_type(char *identifier) {
  long n;
  n = node_id(identifier);
  if (UNDEFINED != n) {
    return Node_List[n].type;
  }
  n = var_id(identifier);
  if (UNDEFINED != n) {
    return Var_List[n].type;
  }
  n = array_id(identifier);
  if (UNDEFINED != n) {
    return Array_List[n].type;
  }
  if ((0 == strcmp(identifier, "LOOP_INDEX"))
   || (0 == strcmp(identifier, "ABS_LOOP_INDEX"))
   || (0 == strcmp(identifier, "REL_LOOP_INDEX"))
   || (0 == strcmp(identifier, "RANDOM_SEED"))) {
    return DIGITAL_DATA_TYPE;
  }
  if ((0 == strcmp(identifier, "ABS_TIME"))
   || (0 == strcmp(identifier, "REF_TIME"))
   || (0 == strcmp(identifier, "REL_TIME"))
   || (0 == strcmp(identifier, "TIME"))
   || (0 == strcmp(identifier, "WALL_CLOCK"))
   || (0 == strcmp(identifier, "SIM_RATE"))
   || (0 == strcmp(identifier, "FS"))
   || (0 == strcmp(identifier, "FSL"))) {
    return ANALOG_DATA_TYPE;
  }
  return constant_type(identifier);                                           /* could be UNKNOWN_TYPE                            */
}
 
 
long usertool_num(const char *nam) {                                          /* number of user functions defined with same name  */
  long i;
  long c = 0L;
  for (i = 0L; i < Num_UserTools; i++) {
    if (0 == strcmp(nam, UserTool_List[i].function)) {
      c++;
    }
  }
  return c;
}
 
 
long node_kind(const char *identifier) {
  if        (IS_IDENTIFIER("adc"             )) { return ADC_KIND           ;
  } else if (IS_IDENTIFIER("algebra"         )) { return ALGEBRA_KIND       ;
  } else if (IS_IDENTIFIER("alu"             )) { return ALU_KIND           ;
  } else if (IS_IDENTIFIER("and"             )) { return AND_KIND           ;
  } else if (IS_IDENTIFIER("average"         )) { return AVERAGE_KIND       ;
  } else if (IS_IDENTIFIER("bshift"          )) { return BSHIFT_KIND        ;
  } else if (IS_IDENTIFIER("btoi"            )) { return BTOI_KIND          ;
  } else if (IS_IDENTIFIER("buffer"          )) { return BUF_KIND           ; /* NOT a copy!                                      */
  } else if (IS_IDENTIFIER("bwand"           )) { return BWAND_KIND         ;
  } else if (IS_IDENTIFIER("bwbuffer"        )) { return COPY_KIND          ; /* a strict copy!                                   */
  } else if (IS_IDENTIFIER("bwinv"           )) { return BWINV_KIND         ;
  } else if (IS_IDENTIFIER("bwnand"          )) { return BWNAND_KIND        ;
  } else if (IS_IDENTIFIER("bwnor"           )) { return BWNOR_KIND         ;
  } else if (IS_IDENTIFIER("bwnot"           )) { return BWINV_KIND         ; /* alias of bwinv                                   */
  } else if (IS_IDENTIFIER("bwor"            )) { return BWOR_KIND          ;
  } else if (IS_IDENTIFIER("bwxnor"          )) { return BWXNOR_KIND        ;
  } else if (IS_IDENTIFIER("bwxor"           )) { return BWXOR_KIND         ;
  } else if (IS_IDENTIFIER("cell"            )) { return CELL_KIND          ; /* special process                                  */
  } else if (IS_IDENTIFIER("change"          )) { return CHG_KIND           ;
  } else if (IS_IDENTIFIER("clip"            )) { return CLIP_KIND          ;
  } else if (IS_IDENTIFIER("clock"           )) { return CLOCK_KIND         ;
  } else if (IS_IDENTIFIER("comp"            )) { return COMP_KIND          ;
  } else if (IS_IDENTIFIER("const"           )) { return CONST_KIND         ; /* -> DC_KIND                                       */
  } else if (IS_IDENTIFIER("copy"            )) { return COPY_KIND          ;
  } else if (IS_IDENTIFIER("cosine"          )) { return COS_KIND           ;
  } else if (IS_IDENTIFIER("dac"             )) { return DAC_KIND           ;
  } else if (IS_IDENTIFIER("dalgebra"        )) { return DALGEBRA_KIND      ;
  } else if (IS_IDENTIFIER("dc"              )) { return DC_KIND            ;
  } else if (IS_IDENTIFIER("delay"           )) { return DELAY_KIND         ;
  } else if (IS_IDENTIFIER("differentiator"  )) { return DIFFERENTIATOR_KIND;
  } else if (IS_IDENTIFIER("div"             )) { return DIV_KIND           ;
  } else if (IS_IDENTIFIER("dtoi"            )) { return DTOI_KIND          ;
  } else if (IS_IDENTIFIER("dtool"           )) { return DTOOL_KIND         ;
  } else if (IS_IDENTIFIER("duser"           )) { return DUSER_KIND         ;
  } else if (IS_IDENTIFIER("equal"           )) { return EQUAL_KIND         ;
  } else if (IS_IDENTIFIER("fzand"           )) { return FZAND_KIND         ;
  } else if (IS_IDENTIFIER("fzbuffer"        )) { return FZBUF_KIND         ;
  } else if (IS_IDENTIFIER("fzinv"           )) { return FZINV_KIND         ;
  } else if (IS_IDENTIFIER("fznand"          )) { return FZNAND_KIND        ;
  } else if (IS_IDENTIFIER("fznor"           )) { return FZNOR_KIND         ;
  } else if (IS_IDENTIFIER("fznot"           )) { return FZINV_KIND         ; /* alias of fzinv                                   */
  } else if (IS_IDENTIFIER("fzor"            )) { return FZOR_KIND          ;
  } else if (IS_IDENTIFIER("fzxnor"          )) { return FZXNOR_KIND        ;
  } else if (IS_IDENTIFIER("fzxor"           )) { return FZXOR_KIND         ;
  } else if (IS_IDENTIFIER("gain"            )) { return GAIN_KIND          ;
  } else if (IS_IDENTIFIER("generator"       )) { return GEN_KIND           ; /* special process                                  */
  } else if (IS_IDENTIFIER("hold"            )) { return HOLD_KIND          ;
  } else if (IS_IDENTIFIER("ialgebra"        )) { return IALGEBRA_KIND      ;
  } else if (IS_IDENTIFIER("integrator"      )) { return INTEGRATOR_KIND    ;
  } else if (IS_IDENTIFIER("inv"             )) { return INV_KIND           ;
  } else if (IS_IDENTIFIER("itob"            )) { return ITOB_KIND          ;
  } else if (IS_IDENTIFIER("itod"            )) { return ITOD_KIND          ;
  } else if (IS_IDENTIFIER("itool"           )) { return ITOOL_KIND         ;
  } else if (IS_IDENTIFIER("iuser"           )) { return IUSER_KIND         ;
  } else if (IS_IDENTIFIER("latch"           )) { return LATCH_KIND         ;
  } else if (IS_IDENTIFIER("lshift"          )) { return LSHIFT_KIND        ;
  } else if (IS_IDENTIFIER("max"             )) { return MAX_KIND           ;
  } else if (IS_IDENTIFIER("merge"           )) { return MERGE_KIND         ;
  } else if (IS_IDENTIFIER("min"             )) { return MIN_KIND           ;
  } else if (IS_IDENTIFIER("mod"             )) { return MOD_KIND           ;
  } else if (IS_IDENTIFIER("muller"          )) { return MULLER_KIND        ;
  } else if (IS_IDENTIFIER("mux"             )) { return MUX_KIND           ;
  } else if (IS_IDENTIFIER("nand"            )) { return NAND_KIND          ;
  } else if (IS_IDENTIFIER("noise"           )) { return NOISE_KIND         ;
  } else if (IS_IDENTIFIER("nor"             )) { return NOR_KIND           ;
  } else if (IS_IDENTIFIER("not"             )) { return INV_KIND           ; /* alias of inv                                     */
  } else if (IS_IDENTIFIER("offset"          )) { return OFFSET_KIND        ;
  } else if (IS_IDENTIFIER("or"              )) { return OR_KIND            ;
  } else if (IS_IDENTIFIER("osc"             )) { return OSC_KIND           ;
  } else if (IS_IDENTIFIER("poly"            )) { return POLY_KIND          ;
  } else if (IS_IDENTIFIER("prod"            )) { return PROD_KIND          ;
  } else if (IS_IDENTIFIER("quant"           )) { return QUANT_KIND         ;
  } else if (IS_IDENTIFIER("ram"             )) { return RAM_KIND           ;
  } else if (IS_IDENTIFIER("ram2"            )) { return RAM2_KIND          ;
  } else if (IS_IDENTIFIER("rect"            )) { return RECT_KIND          ;
  } else if (IS_IDENTIFIER("register"        )) { return TRACK_KIND         ; /* alias of track                                   */
  } else if (IS_IDENTIFIER("relay"           )) { return RELAY_KIND         ;
  } else if (IS_IDENTIFIER("rip"             )) { return RIP_KIND           ;
  } else if (IS_IDENTIFIER("rom"             )) { return ROM_KIND           ;
  } else if (IS_IDENTIFIER("rom2"            )) { return ROM2_KIND          ;
  } else if (IS_IDENTIFIER("rshift"          )) { return RSHIFT_KIND        ;
  } else if (IS_IDENTIFIER("rshift1"         )) { return RSHIFT1_KIND       ;
  } else if (IS_IDENTIFIER("rshift2"         )) { return RSHIFT2_KIND       ;
  } else if (IS_IDENTIFIER("sign"            )) { return SIGN_KIND          ;
  } else if (IS_IDENTIFIER("sine"            )) { return SIN_KIND           ;
  } else if (IS_IDENTIFIER("square"          )) { return SQUARE_KIND        ;
  } else if (IS_IDENTIFIER("step"            )) { return STEP_KIND          ;
  } else if (IS_IDENTIFIER("sub"             )) { return SUB_KIND           ;
  } else if (IS_IDENTIFIER("sum"             )) { return SUM_KIND           ;
  } else if (IS_IDENTIFIER("test"            )) { return TEST_KIND          ;
  } else if (IS_IDENTIFIER("toggle"          )) { return TOGGLE_KIND        ;
  } else if (IS_IDENTIFIER("tool"            )) { return ITOOL_KIND         ; /* instruction tool is expanded as a node itool     */
  } else if (IS_IDENTIFIER("track"           )) { return TRACK_KIND         ;
  } else if (IS_IDENTIFIER("triangle"        )) { return TRIANGLE_KIND      ;
  } else if (IS_IDENTIFIER("trig"            )) { return TRIG_KIND          ;
  } else if (IS_IDENTIFIER("uadc"            )) { return UADC_KIND          ;
  } else if (IS_IDENTIFIER("udac"            )) { return UDAC_KIND          ;
  } else if (IS_IDENTIFIER("wsum"            )) { return WSUM_KIND          ;
  } else if (IS_IDENTIFIER("xnor"            )) { return XNOR_KIND          ;
  } else if (IS_IDENTIFIER("xor"             )) { return XOR_KIND           ;
  } else if (IS_IDENTIFIER("zero"            )) { return ZERO_KIND          ;
  } else {                                        return UNKNOWN_KIND       ;
  }
}
 
 
/* A precompiler directive is issued for any unknown function. Known functions and macros                                         */
/* functions are listed here to limit such directives to a minimum.                                                               */
 
int is_a_known_function(const char *identifier) {
  if (is_a_known_pure_function(identifier)) {        return true;
  } else if (IS_IDENTIFIER("GETPARMADDRESS"     )) { return true;
  } else if (IS_IDENTIFIER("IO_COMMAND_NAME"    )) { return true;
  } else if (IS_IDENTIFIER("ISTIME"             )) { return true;
  } else if (IS_IDENTIFIER("RAND_01"            )) { return true;
  } else if (IS_IDENTIFIER("RAND_01_X"          )) { return true;
  } else if (IS_IDENTIFIER("ISDELAYED"          )) { return true;
  } else if (IS_IDENTIFIER("ISOPTION"           )) { return true;
  } else if (IS_IDENTIFIER("ISPARAMETER"        )) { return true;
  } else if (IS_IDENTIFIER("ISNOTOPTION"        )) { return true;
  } else if (IS_IDENTIFIER("TIMER"              )) { return true;
  } else if (IS_IDENTIFIER("PING"               )) { return true;
  } else if (IS_IDENTIFIER("PING_FAIL"          )) { return true;
  } else {                                          return false;
  }
}
 
 
/* It is MANDATORY to list only PURE functions or PURE macro functions, as this procedure                                         */
/* will be used to determine if an update is built from constant or not.                                                          */
 
int is_a_known_pure_function(const char *identifier) {
  if        (IS_IDENTIFIER("abs"                  )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("acos"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("acosh"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("acosl"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("asin"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("asinh"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("asinl"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("atan"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("atanh"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("atanl"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("atan2"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("atan2l"               )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("ceil"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("cos"                  )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("cosh"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("cosl"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("erf"                  )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("erfc"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("exp"                  )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("fabs"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("floor"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("fmod"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("fprintf"              )) { return true;           /* C function   (stdio.h)                           */
  } else if (IS_IDENTIFIER("labs"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("log"                  )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("log2"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("log10"                )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("napa_array_setup"     )) { return true;           /* NAPA C function                                  */
  } else if (IS_IDENTIFIER("napa_check_directives")) { return true;           /* NAPA C function                                  */
                      /*   "napa_check_for_option"  .........................    NAPA C function is NOT A PURE FUNCTION           */
                      /*   "napa_rand_integer"      .........................    NAPA C function is NOT A PURE FUNCTION           */
  } else if (IS_IDENTIFIER("napa_record_manager"  )) { return true;           /* NAPA C function                                  */
  } else if (IS_IDENTIFIER("napa_record_setup"    )) { return true;           /* NAPA C function                                  */
  } else if (IS_IDENTIFIER("pow"                  )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("sin"                  )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("sinh"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("sinl"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("sizeof"               )) { return true;           /* C function                                       */
  } else if (IS_IDENTIFIER("sqrt"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("tan"                  )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("tanh"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("tanl"                 )) { return true;           /* C function   (math.h)                            */
  } else if (IS_IDENTIFIER("ABS"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("B2A"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("CLIP"                 )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("COS"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("DB2LIN"               )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("DB2POW"               )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("DEG2RAD"              )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("D2I"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("FSS"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("IONAME"               )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISEQUAL"              )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISEVEN"               )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISINSIDE"             )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISINTEGER"            )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISINTEGER"            )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISNAN"                )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISNOTSMALL"           )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISODD"                )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISOUTSIDE"            )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ISSMALL"              )) { return true;           /* NAPA macro                                       */
                      /*   "ISTIME"     .....................................    NAPA macro, NOT A PURE FUNCTION !!!              */
  } else if (IS_IDENTIFIER("I2D"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("LENGTH"               )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("LIN2DB"               )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("LINDOMAIN"            )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("LINSWEEP"             )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("LOGDOMAIN"            )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("LOGSWEEP"             )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("LOG"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("LOG10"                )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("MAX"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("MIN"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("MODULO"               )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("NIS"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("POW"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("POWEROF2"             )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("POW2DB"               )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("POW2LIN"              )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("POW10"                )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("RAD2DEG"              )) { return true;           /* NAPA macro                                       */
                      /*   "RAND_01"    .....................................    NAPA macro NOT A PURE FUNCTION                   */
                      /*   "RAND_01_X"  .....................................    NAPA macro NOT A PURE FUNCTION                   */
  } else if (IS_IDENTIFIER("RANDOM_SEED"          )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ROOT"                 )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("SQR"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("SQRT"                 )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("SIGN"                 )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("SIN"                  )) { return true;           /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("STS"                  )) { return true;           /* NAPA macro                                       */
  } else {                                          return false;             /* Not a known function                             */
  }
}
 
 
/* It is important to avoid side effects from identifiers collision or misuse. Critical identifiers are listed here.              */
/* The choice between error or warning depends mainly on the possible consequence of the misuse.                                  */
 
int is_an_instruction(const char *identifier) {
  if        (IS_IDENTIFIER("alias"           )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("assert"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("array"           )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("call"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("cell"            )) { return true;                /* NAPA instruction keyword                         */
  } else if (IS_IDENTIFIER("cell_interface"  )) { return true;                /* NAPA cell keyword                                */
  } else if (IS_IDENTIFIER("command_line"    )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("comment"         )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("data"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("data_interface"  )) { return true;                /* NAPA data keyword                                */
  } else if (IS_IDENTIFIER("debug"           )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("decimate"        )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("declare"         )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("directive"       )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("drop"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("dump"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("dvar"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("error"           )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("event"           )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("export"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("format"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("fs"              )) { return false;               /* NAPA special instruction !                       */
  } else if (IS_IDENTIFIER("gateway"         )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("ganging"         )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("header"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("init"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("inject"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("input"           )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("interlude"       )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("interface"       )) { return true;                /* NAPA cell and data keyword                       */
  } else if (IS_IDENTIFIER("interpolate"     )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("ivar"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("load"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("napa_short_title")) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("napa_title"      )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("napa_version"    )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("node"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("nominal"         )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("opcode"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("output"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("ping"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("post"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("random_seed"     )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("restart"         )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("sampling"        )) { return true;                /* NAPA instruction (new feature under test)        */
  } else if (IS_IDENTIFIER("string"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("stuck"           )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("synchronize"     )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("terminate"       )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("tool"            )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("ts"              )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("update"          )) { return true;                /* NAPA instruction                                 */
  } else if (IS_IDENTIFIER("warning"         )) { return true;                /* NAPA instruction                                 */
  } else {                                        return false;
  }
}
 
 
int is_a_keyword(const char *identifier) {
  if        (UNKNOWN_KIND != node_kind(identifier)   ) {
    return WARNING;                                                           /* NAPA node kind                                   */
  } else if (is_an_instruction(identifier)  ) {
    return WARNING;                                                           /* NAPA instruction                                 */
  } else if (is_a_known_function(identifier)) {
    return ERROR;                                                             /* 'standard' C function                            */
  }
  if        (IS_NAPA_PREFIX()                    ) { return ERROR;            /* NAPA reserved prefix                             */
  } else if (IS_DEBUG_PREFIX()                   ) { return ERROR;            /* NAPA reserved prefix                             */
  } else if (IS_COMPILE_PREFIX()                 ) { return ERROR;            /* NAPA reserved prefix                             */
  } else if (IS_IDENTIFIER("after"              )) { return ERROR;            /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("analog"             )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("arithmetic"         )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("before"             )) { return ERROR;            /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("char"               )) { return ERROR;            /* C keyword                                        */
  } else if (IS_IDENTIFIER("constant"           )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("digital"            )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("double"             )) { return ERROR;            /* C keyword                                        */
  } else if (IS_IDENTIFIER("dual"               )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("expand"             )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("false"              )) { return ERROR;            /* C keyword and C keyword                          */
  } else if (IS_IDENTIFIER("float"              )) { return ERROR;            /* C keyword                                        */
  } else if (IS_IDENTIFIER("geometric"          )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("harmonic"           )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("hex"                )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("int"                )) { return ERROR;            /* C keyword                                        */
  } else if (IS_IDENTIFIER("interface"          )) { return WARNING;          /* NAPA cell keyword                                */
  } else if (IS_IDENTIFIER("negative"           )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("new"                )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("noexpand"           )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("long"               )) { return ERROR;            /* C keyword                                        */
  } else if (IS_IDENTIFIER("normal"             )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("pointer"            )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("positive"           )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("rms"                )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("short"              )) { return ERROR;            /* C keyword                                        */
  } else if (IS_IDENTIFIER("string"             )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("true"               )) { return ERROR;            /* NAPA qualifier and C keyword                     */
  } else if (IS_IDENTIFIER("uniform"            )) { return WARNING;          /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("unsigned"           )) { return ERROR;            /* C keyword                                        */
  } else if (IS_IDENTIFIER("when"               )) { return ERROR;            /* NAPA qualifier                                   */
  } else if (IS_IDENTIFIER("with"               )) { return ERROR;            /* NAPA qualifier                                   */
  }
  if        (IS_IDENTIFIER("ABS_LOOP_INDEX"     )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ABS_TIME"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ALLOCATE"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ANALOG_INI"         )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ANTITHETIC"         )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ASSERT_FLAG"        )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("CELLS_LIB"          )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("C_TYPE"             )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("CLOSE"              )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("CODE"               )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("COMMAND_LINE"       )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("COMMAND_PARMS"      )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("COMMENT"            )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("CREATED"            )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("DATA_RECORD"        )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("DEBUG"              )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("DELETE"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("DIGITAL_INI"        )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("DUMP_FLAG"          )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("E_FORMAT"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("E_HEAD"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("E_LIST"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("EPSILON"            )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("ERROR_FLAG"         )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("EXPORT"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("false"              )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("FREE"               )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("FS"                 )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("FSL"                )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("GENERATORS_LIB"     )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("HEADERS_LIB"        )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("I_FORMAT"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("IO_RECORD"          )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("I_TYPE"             )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("LOOP_INDEX"         )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("MAILBOX"            )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("MAILBOX_RECORD"     )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("NO"                 )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("NUM_OF_SEGMENTS"    )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("NUM_OF_TIME_OUTPUTS")) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("OPENAPPEND"         )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("OPENAPPEND_BINARY"  )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("OPENREAD"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("OPENREAD_BINARY"    )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("OPENWRITE"          )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("OPENWRITE_BINARY"   )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ORIGIN"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("P_TYPE"             )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("PACKET"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("PERIODIC"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("PLATFORM"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("QUERY"              )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("RAM_I_RECORD"       )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("RAM2_I_RECORD"      )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("RAM_R_RECORD"       )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("RAM2_R_RECORD"      )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("RANDOM_SEED"        )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("REF_TIME"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("REL_LOOP_INDEX"     )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("REL_TIME"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("RESET"              )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("REWIND"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("REWRITE"            )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("R_FORMAT"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("ROM_I_RECORD"       )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("ROM2_I_RECORD"      )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("ROM_R_RECORD"       )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("ROM2_R_RECORD"      )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("R_TYPE"             )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("SEGMENT"            )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("SEPARATOR"          )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("S_FORMAT"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("SHORT_TITLE"        )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("SIM_RATE"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("SOURCE"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("START"              )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("STL"                )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("STOP"               )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("SYNCHRONIZE"        )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("TERMINATE"          )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("TIME"               )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("TITLE"              )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("TOOL_INDEX"         )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("true"               )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("UNKNOWN"            )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("_2PI_"              )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("USER"               )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("V_FORMAT"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("V_HEAD"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("V_NAME"             )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("V_TYPE"             )) { return ERROR;            /* C code internal typdef                           */
  } else if (IS_IDENTIFIER("WALL_CLOCK"         )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("X_FORMAT"           )) { return ERROR;            /* NAPA macro                                       */
  } else if (IS_IDENTIFIER("YES"                )) { return ERROR;            /* NAPA macro                                       */
  }
  if        (IS_IDENTIFIER("_e_"                )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_pi_"               )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_pi2_"              )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_pi4_"              )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_pi8_"              )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_E_"                )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_PI_"               )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_PI2_"              )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_PI4_"              )) { return ERROR;            /* C code internal const                            */
  } else if (IS_IDENTIFIER("_PI8_"              )) { return ERROR;            /* C code internal const                            */
  }
  return false;                                                               /* Not a keyword !                                  */
}
 
 
int is_an_operator(const char *identifier) {
  if        (IS_IDENTIFIER("+"                  )) { return true;
  } else if (IS_IDENTIFIER("-"                  )) { return true;
  } else if (IS_IDENTIFIER("*"                  )) { return true;
  } else if (IS_IDENTIFIER("/"                  )) { return true;
  } else if (IS_IDENTIFIER("%"                  )) { return true;
  } else if (IS_IDENTIFIER("="                  )) { return true;
  } else if (IS_IDENTIFIER("!"                  )) { return true;
  } else if (IS_IDENTIFIER(">"                  )) { return true;
  } else if (IS_IDENTIFIER("<"                  )) { return true;
  } else if (IS_IDENTIFIER("&"                  )) { return true;
  } else if (IS_IDENTIFIER("~"                  )) { return true;
  } else if (IS_IDENTIFIER("^"                  )) { return true;
  } else if (IS_IDENTIFIER("|"                  )) { return true;
  } else if (IS_IDENTIFIER("("                  )) { return true;
  } else if (IS_IDENTIFIER(")"                  )) { return true;
  } else if (IS_IDENTIFIER("["                  )) { return true;
  } else if (IS_IDENTIFIER("]"                  )) { return true;
  } else if (IS_IDENTIFIER("{"                  )) { return true;
  } else if (IS_IDENTIFIER("}"                  )) { return true;
  } else if (IS_IDENTIFIER("?"                  )) { return true;
  } else if (IS_IDENTIFIER(":"                  )) { return true;
  } else if (IS_IDENTIFIER(","                  )) { return true;
  } else {                                           return false;            /* Not an operator                                  */
  }
}
 
 
/* A collection of constants or macro constants defined in NAPA at the exception of                                               */
/* too specialized macros which are not used in regular expressions (like OPEN_WRITE...)                                          */
 
int is_a_constant_or_a_macro_constant(const char *identifier) {
  if        (IS_IDENTIFIER("ANALOG_INI"         )) { return true;
  } else if (IS_IDENTIFIER("ANTITHETIC"         )) { return true;
  } else if (IS_IDENTIFIER("BIG_ENDIAN"         )) { return true;
  } else if (IS_IDENTIFIER("CODE"               )) { return true;
  } else if (IS_IDENTIFIER("CREATED"            )) { return true;
  } else if (IS_IDENTIFIER("DIGITAL_INI"        )) { return true;
  } else if (IS_IDENTIFIER("_e_"                )) { return true;
  } else if (IS_IDENTIFIER("_E_"                )) { return true;
  } else if (IS_IDENTIFIER("EPSILON"            )) { return true;
  } else if (IS_IDENTIFIER("false"              )) { return true;
  } else if (IS_IDENTIFIER("FALSE"              )) { return true;
  } else if (IS_IDENTIFIER("FS"                 )) { return true;
  } else if (IS_IDENTIFIER("FSL"                )) { return true;
  } else if (IS_IDENTIFIER("I_FORMAT"           )) { return true;
  } else if (IS_IDENTIFIER("LITTLE_ENDIAN"      )) { return true;
  } else if (IS_IDENTIFIER("NO"                 )) { return true;
  } else if (IS_IDENTIFIER("ORIGIN"             )) { return true;
  } else if (IS_IDENTIFIER("PERIODIC"           )) { return true;
  } else if (IS_IDENTIFIER("_pi_"               )) { return true;
  } else if (IS_IDENTIFIER("_pi_2"              )) { return true;
  } else if (IS_IDENTIFIER("_pi_4"              )) { return true;
  } else if (IS_IDENTIFIER("_pi_8"              )) { return true;
  } else if (IS_IDENTIFIER("_2pi_"              )) { return true;
  } else if (IS_IDENTIFIER("_PI_"               )) { return true;
  } else if (IS_IDENTIFIER("_PI_2"              )) { return true;
  } else if (IS_IDENTIFIER("_PI_4"              )) { return true;
  } else if (IS_IDENTIFIER("_PI_8"              )) { return true;
  } else if (IS_IDENTIFIER("_2PI_"              )) { return true;
  } else if (IS_IDENTIFIER("NAPA_JOB_ID"        )) { return true;
  } else if (IS_IDENTIFIER("NAPA_VERSION"       )) { return true;
  } else if (IS_IDENTIFIER("NUM_OF_SEGMENTS"    )) { return true;
  } else if (IS_IDENTIFIER("NUM_OF_TIME_OUTPUTS")) { return true;
  } else if (IS_IDENTIFIER("RANDOM_SEED"        )) { return true;
  } else if (IS_IDENTIFIER("R_FORMAT"           )) { return true;
  } else if (IS_IDENTIFIER("S_FORMAT"           )) { return true;
  } else if (IS_IDENTIFIER("SEPARATOR"          )) { return true;
  } else if (IS_IDENTIFIER("SHORT_TITLE"        )) { return true;
  } else if (IS_IDENTIFIER("SIM_RATE"           )) { return true;
  } else if (IS_IDENTIFIER("SOURCE"             )) { return true;
  } else if (IS_IDENTIFIER("START"              )) { return true;
  } else if (IS_IDENTIFIER("STL"                )) { return true;
  } else if (IS_IDENTIFIER("STOP"               )) { return true;
  } else if (IS_IDENTIFIER("TITLE"              )) { return true;
  } else if (IS_IDENTIFIER("true"               )) { return true;
  } else if (IS_IDENTIFIER("TRUE"               )) { return true;
  } else if (IS_IDENTIFIER("USER"               )) { return true;
  } else if (IS_IDENTIFIER("X_FORMAT"           )) { return true;
  } else if (IS_IDENTIFIER("YES"                )) { return true;
 
  } else {                                           return false;            /* not a constant                                   */
  }
}
 
 
int is_a_modifier(const char *identifier) {
  if        (IS_IDENTIFIER("long"               )) { return true;
  } else if (IS_IDENTIFIER("int"                )) { return true;
  } else if (IS_IDENTIFIER("short"              )) { return true;
  } else if (IS_IDENTIFIER("double"             )) { return true;
  } else if (IS_IDENTIFIER("float"              )) { return true;
  } else if (IS_IDENTIFIER("char"               )) { return true;
  } else if (IS_IDENTIFIER("unsigned"           )) { return true;
  } else if (IS_IDENTIFIER("FILE"               )) { return true;
  } else if (IS_IDENTIFIER("R_TYPE"             )) { return true;
  } else if (IS_IDENTIFIER("I_TYPE"             )) { return true;
  } else if (IS_IDENTIFIER("S_TYPE"             )) { return true;
  } else if (IS_IDENTIFIER("P_TYPE"             )) { return true;
  } else if (IS_IDENTIFIER("V_TYPE"             )) { return true;
  } else if (IS_IDENTIFIER("L_PREC"             )) { return true;
  } else if (IS_IDENTIFIER("H_PREC"             )) { return true;
  } else {                                           return false;            /* not a modifier                                   */
  }
}
 
 
/* ****************************************************************************************************************************** */
/* end of file                                                                                                                    */