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

Go to the documentation of this file.

/* ** SYNTAX UTILITIES ********************************************************************************************************** */
 
#undef  EXTERN
#define EXTERN extern
 
#include "./napa.h"
#include "./proto.h"
 
 
/* *** In this file: ************************************************************************************************************ */
 
/* long check_syntax(long to_be, long no_sign, const char *sgn, char *tok, long id, const char *txt)                              */
/* long something_else(const char *tok, long id)                                                                                  */
 
/* void authorize_option(long num, long id)                                                                                       */
/* void C_syntax_checker(char *str, unsigned long *mlin, unsigned long *mfil)                                                     */
/* void sanity_check(char *s, const unsigned long *mlin, const unsigned long *mfil)                                               */
/* void syntax_command_line(void)                                                                                                 */
/* void syntax_directives(void)                                                                                                   */
/* void syntax_fs(void)                                                                                                           */
/* void syntax_nodes(void)                                                                                                        */
/* void syntax_posts(void)                                                                                                        */
/* void syntax_records(void)                                                                                                      */
/* void syntax_segment_value(void)                                                                                                */
/* void syntax_terminate(void)                                                                                                    */
/* void syntax_updates(void)                                                                                                      */
/* void syntax_variables(void)                                                                                                    */
 
 
/* ****************************************************************************************************************************** */
/* The goal of "syntax_nodes" is to check the syntax of the nodes by inspection.                                                  */
/* Mandatory parameters, their nature (node, variable or constant) and their number are verified here.                            */
/* The presence of a sign is also verified.                                                                                       */
 
/* This process is done after node redefinition, before determination of the node type.                                           */
/* It takes one pass through the list of nodes.                                                                                   */
 
/* Types (analog, digital or string) and values of inputs are not verified here.                                                  */
 
/* The goal of "syntax_arrays" is to verify the list of variables for the array of pointers.                                      */
 
 
/* ****************************************************************************************************************************** */
 
void syntax_command_line(void) {
  char tok1[STRLENGTH] = {'\0'};
  char tok2[STRLENGTH] = {'\0'};
  char *s = (char*) NULL;
  char *t = (char*) NULL;
  long i, j, nu, nv;
  if (!Cmdline_Flag) {
    return;
  }
  for (i = 0L; i < Num_Cmdlines; i++) {                                       /* analyze each expected command line parameter     */
    if (0 == strcmp(Cmdline_List[i].parms, "fs")) {
      if (ISNOTEQUAL(1.0, Sampling_List.frequency)) {                         /* compare with default value                       */
        print_warning_location("command_line", Cmdline_List[i].mline, Cmdline_List[i].mfile);
        (void) fprintf(STDERR,     " the sampling frequency <fs> defined in NAPA netlist\n");
        print_location(Sampling_List.mline, Sampling_List.mfile);
        (void) fprintf(STDERR,     " will be superseded by user input at execution\n\n");
        Sampling_List.frequency = 1.0;
      }
      continue;
    }
    if (0 == strcmp(Cmdline_List[i].parms, "ts")) {
      if (ISNOTEQUAL(1.0, Sampling_List.frequency)) {                         /* compare with default value                       */
        print_warning_location("command_line", Cmdline_List[i].mline, Cmdline_List[i].mfile);
        (void) fprintf(STDERR,     " the sampling period <ts> defined in NAPA netlist\n");
        print_location(Sampling_List.mline, Sampling_List.mfile);
        (void) fprintf(STDERR,     " will be superseded by user input at execution\n\n");
        Sampling_List.frequency = 1.0;
      }
      continue;
    }
    nv = var_id(Cmdline_List[i].parms);
    if (UNDEFINED != nv) {                                                    /* defined, as definition already checked in "pr.c" */
      for (j = 1L; j < Num_FileCells; j++) {                                  /* 0L corresponds to the file name of the main      */
        if (STRING_DATA_TYPE == Var_List[nv].type) {                          /* a cell pathname cannot be part of command line   */
          (void) strcpy(tok1, Record_Cell_File_Table[j]);
          (void) strcpy(tok2, Var_List[nv].value);
          strip_quotes(tok1);
          strip_quotes(tok2);
          s = tok1;
          t = tok2;
#if (IS_WIN64 == PLATFORM)                                                    /* case-insensitive OS                              */
          s = upper_to_lower(s);
          t = upper_to_lower(t);
#endif
          if (0 == strcmp(s, t)) {
            print_error_location("command_line", Cmdline_List[i].mline, Cmdline_List[i].mfile);
            (void) fprintf(STDERR, " String parameter <%s> was used during the compilation of a NAPA cell.\n", Cmdline_List[i].parms);
            (void) fprintf(STDERR, " Its value is currently set to <%s>.\n", Var_List[nv].value);
            (void) fprintf(STDERR, " It cannot be redefined at execution and therefore cannot be a command line parameter.\n");
          }
        }
      }
      nu = update_id(Cmdline_List[i].parms, 1);
      if (UNDEFINED != nu) {
        if (0 != Var_List[nv].event) {                                        /* an event is automatically updated                */
          print_error_location("event", Update_List[nu].mline, Update_List[nu].mfile);
          (void) fprintf(STDERR,   " <%s>, being a variable of the command line, cannot be an event\n", Cmdline_List[i].parms);
        } else {
          print_error_location("update", Update_List[nu].mline, Update_List[nu].mfile);
          (void) fprintf(STDERR,   " <%s>, being a variable of the command line, cannot be updated\n",  Cmdline_List[i].parms);
        }
      }
    }
  }
  return;
}
 
 
void syntax_directives(void) {
  long i;
  char *s = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
  for (i = 0L; i < Num_Directives; i++) {
    s = Directive_List[i].value;
    for (;;) {
      s = get_token(s, tok, true);
      if (ISEMPTY(tok)) {
        break;
      }
      if (UNDEFINED != node_id(tok)) {
        print_error_location("directive", Directive_List[i].mline, Directive_List[i].mfile );
        (void) fprintf(STDERR,     " <%s>, a node cannot be used in a directive\n", tok    );
      }
      if ((UNDEFINED != var_id(tok)) && (STRING_DATA_TYPE != get_type(tok))) {  /* string is ok                                   */
        print_error_location("directive", Directive_List[i].mline, Directive_List[i].mfile );
        (void) fprintf(STDERR,     " <%s>, a variable cannot be used in a directive\n", tok);
      }
    }
  }
  return;
}
 
 
void syntax_fs(void) {
  long d;
  if ((!Fs_Flag) && (!Ts_Flag) && (Periodic_Flag) && (0 == Error_Flag)) {
    if ((Terminate_Flag) && (Loop_Flag) && (!Fs_Ext_Flag) && (!Ts_Ext_Flag)) {
      Sampling_List.frequency = 1.0;
      Sampling_List.period    = 1.0;
      for (d = 0L; d < MAXDEPTH; d++) {
        Sampling_List.mline[d] = 0UL;
        Sampling_List.mfile[d] = 0UL;
      }
      print_warning_location("fs", NULL, NULL);
      (void) fprintf(STDERR,     "\n No sampling frequency definition in netlist...\n");
      (void) fprintf(STDERR,       " Using default frequency  %.1f Hz\n", Sampling_List.frequency);
    }
    Fs_Flag = true;
    Ts_Flag = false;
  }
  return;
}
 
 
void syntax_nodes(void) {
  long out;
  long kd;
  long a, i, m, n;
  char *s    = (char*) NULL;
  char *str1 = (char*) NULL;
  char *str2 = (char*) NULL;
  char msg[STRLENGTH]  = {'\0'};
  char tok1[STRLENGTH] = {'\0'};
  char tok2[STRLENGTH] = {'\0'};
  char sgn[2]          = {'\0'};
  char brck[3]         = {'\0'};
  char *tg = (char*) NULL;
  unsigned long *ml = (unsigned long*) NULL;
  unsigned long *mf = (unsigned long*) NULL;
 
  for (out = 0L; out < Num_Nodes; out++) {
    str1 = Node_List[out].value;
    kd   = Node_List[out].kind;
    ml   = Node_List[out].mline;
    mf   = Node_List[out].mfile;
    tg   = Node_List[out].tag;
 
    switch (kd) {
 
    case DELAY1_KIND :
    case DELAY2_KIND :
    case DELAY3_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);                             /* skip number of delays                            */
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case DELAY_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "number of delays")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case DIFFERENTIATOR_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case INTEGRATOR_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case OSC_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NODE | NUMBER, DONTCARE, sgn, tok1, out, "offset" )) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NODE | NUMBER, NOSIGN, sgn, tok1, out, "amplitude")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out,   "frequency")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "phase"    )) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case SIN_KIND :
    case COS_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NODE | NUMBER, DONTCARE, sgn, tok1, out, "offset" )) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NODE | NUMBER, NOSIGN, sgn, tok1, out, "amplitude")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NODE | NUMBER, NOSIGN, sgn, tok1, out, "frequency")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NODE | NUMBER, DONTCARE, sgn, tok1, out, "phase"  )) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case TRIANGLE_KIND :
    case SQUARE_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "offset" )) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "amplitude")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "frequency")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "delay"    )) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);                             /* duty cycle is optional                           */
      if (ISNOTEMPTY(tok1)) {
        if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "duty cycle")) {
          break;
        }
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case STEP_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "first level" )) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "second level")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (ISEMPTY(str1)) {
        if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "step time"   )) {
          break;
        }
      } else {
        if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "first step time" )) {
          break;
        }
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "second step time")) {
          break;
        }
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case CLOCK_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 == strcmp(tok1, "\"\"")) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " pattern descriptor is empty\n");
        flag_node(out);
        break;
      }
      if (0 != check_syntax(DONTCARE, NOSIGN, sgn, tok1, out, "pattern descriptor")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "width descriptor")) {
        break;
      }                                                                       /* other checks will be made when building C code   */
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case CONST_KIND :
    case DC_KIND :
      authorize_option(-1, out);                                              /* no check, as a C expression is expected          */
      C_syntax_checker(str1, ml, mf);
      break;
 
    case GAIN_KIND :
    case OFFSET_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "parameter")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case ITOB_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NUMBER, NOSIGN, sgn, tok1, out, "bit number")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "")) {
        break;                                 /* empty msg "" and not msg "input" to be compatible with bit field automatic node */
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case CLIP_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "clipping level low")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "clipping level high")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case NOISE_KIND :
      authorize_option(NO, out);
      str2 = str1;
      str2 = get_sign_and_token(str2, sgn, tok1);                             /* DC level                                         */
      str2 = get_sign_and_token(str2, sgn, tok1);                             /* RMS level                                        */
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "DC value")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER,  NOSIGN, sgn, tok1, out, "RMS value")) {
        break;
      }
      break;
 
    case RSHIFT_KIND  :
    case RSHIFT1_KIND :
    case RSHIFT2_KIND :
      authorize_option(NO, out);
      if (!verify_rshift()) {
        if (0 == is_node_flagged(out)) {
          print_error_location(tg, ml, mf);
          (void) fprintf(STDERR,   " this platform (%s) does not support sign extension on right shifts!\n", MACHINE);
          flag_node(out);
        }
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NUMBER | NODE | VARIABLE, NOSIGN, sgn, tok1, out, "rshift value")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case BSHIFT_KIND :
    case LSHIFT_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (BSHIFT_KIND == kd) {
        if (0 != check_syntax(NUMBER | NODE | VARIABLE, DONTCARE, sgn, tok1, out,"bshift value")) {
          break;
        }
      } else {
        if (0 != check_syntax(NUMBER | NODE | VARIABLE, NOSIGN, sgn, tok1, out, "lshift value")) {
          break;
        }
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case RECT_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, "input"  )) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case COPY_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case DIV_KIND :
    case MOD_KIND :
      authorize_option(YES, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input #1")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "input #2")) {
        break;
      }
      if (((char*) NULL == strstr(Node_List[out].option, "none")) && ((char*) NULL == strstr(Node_List[out].option, "nocheck"))) {
        print_error_location(tg, ml, mf);
        replace_dollar(tok1);
        (void) fprintf(STDERR,     " (%s) is not a valid trigger qualifier\n\n", Node_List[out].option);
        (void) fprintf(STDERR,     " optional valid qualifier is (nocheck)\n");
        flag_node(out);
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case QUANT_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "quantification")) {
        break;
      }
       str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case SUB_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input #1")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, DONTCARE, sgn, tok1, out, "input #2")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case SUM_KIND :
    case PROD_KIND :
    case MIN_KIND :
    case MAX_KIND :
      authorize_option(NO, out);
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two input nodes are required\n");
        flag_node(out);
      }
      break;
 
    case AVERAGE_KIND :
      authorize_option(YES, out);
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two input nodes are required\n");
        flag_node(out);
      }
      if (((char*) NULL == strstr(Node_List[out].option, "arithmetic"))
       && ((char*) NULL == strstr(Node_List[out].option, "geometric" ))
       && ((char*) NULL == strstr(Node_List[out].option, "harmonic"  ))
       && ((char*) NULL == strstr(Node_List[out].option, "rms"       ))) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " (%s) is not a valid qualifier for node 'average'\n\n", Node_List[out].option);
        (void) fprintf(STDERR,     " valid qualifiers are:\n");
        (void) fprintf(STDERR,     "    (arithmetic)\n");
        (void) fprintf(STDERR,     "    (geometric)\n");
        (void) fprintf(STDERR,     "    (harmonic)\n");
        (void) fprintf(STDERR,     "    (rms)\n");
        flag_node(out);
        break;
      }
      break;
 
    case WSUM_KIND :
      authorize_option(NO, out);
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "parameter #%ld", i+1L);
        if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, msg)) {
          break;
        }
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          if (0 == is_node_flagged(out)) {
            print_error_location(tg, ml, mf);
            (void) fprintf(STDERR, " input node is missing\n");
            flag_node(out);
          }
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two input nodes are required\n");
        flag_node(out);
      }
      break;
 
    case ALU_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(DONTCARE, NOSIGN, sgn, tok1, out, "owner name")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, "opcode")) {
        break;
      }
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (1L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least one input node is required\n");
        flag_node(out);
      }
      break;
 
    case RIP_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NUMBER, NOSIGN, sgn, tok1, out, "mask")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case BUF_KIND :
    case INV_KIND :
    case BWINV_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case TOGGLE_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (ISNOTEMPTY(tok1)) {
        if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
          break;
        }
        if (0 != something_else(str1, out)) {
          break;
        }
      }
      break;
 
    case AND_KIND :
    case OR_KIND :
    case XOR_KIND :
    case NAND_KIND :
    case NOR_KIND :
    case XNOR_KIND :
    case MULLER_KIND :
      authorize_option(NO, out);
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two input nodes are required\n");
        flag_node(out);
      }
      break;
 
    case BWAND_KIND :
    case BWOR_KIND :
    case BWXOR_KIND :
    case BWNAND_KIND :
    case BWNOR_KIND :
    case BWXNOR_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if ((0 == is_node_flagged(out)) && ISEMPTY(tok1)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " input node or mask is missing\n");
        flag_node(out);
        break;
      }
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input #1")) {
        break;
      }
      i = 1L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (1L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two input nodes are required\n");
        flag_node(out);
      }
      break;
 
    case FZINV_KIND :
    case FZBUF_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case FZAND_KIND :
    case FZOR_KIND :
    case FZNAND_KIND :
    case FZNOR_KIND :
      authorize_option(NO, out);
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two input nodes are required\n");
        flag_node(out);
      }
      break;
 
    case FZXOR_KIND :
    case FZXNOR_KIND :
      authorize_option(NO, out);
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L != i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " two input nodes are required\n");
        flag_node(out);
      }
      break;
 
    case HOLD_KIND :
    case TRACK_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "control")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case RELAY_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "control")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (ISNOTEMPTY(str1)) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "setting value")) {
          break;
        }
        if (0 != something_else(str1, out)) {
          break;
        }
      }
      break;
 
    case ZERO_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NUMBER, NOSIGN, sgn, tok1, out, "decimation factor")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NUMBER, NOSIGN, sgn, tok1, out, "decimation offset")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case COMP_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "input #1")) {
        break;
      }
      m = node_id(tok1);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "input #2")) {
        break;
      }
      n = node_id(tok1);
      if ((UNDEFINED == m) && (UNDEFINED == n)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least one of the inputs #1 or #2 must be a node\n");
        flag_node(out);
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case EQUAL_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "input #1")) {
        break;
      }
      m = node_id(tok1);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "input #2")) {
        break;
      }
      n = node_id(tok1);
      if ((UNDEFINED == m) && (UNDEFINED == n)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least one of the inputs #1 or #2 must be a node\n");
        flag_node(out);
      }
      if (0 == strcmp(str1, "")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, NOSIGN, sgn, tok1, out, "precision")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case LATCH_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, "set")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok1, out, "reset")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case ALGEBRA_KIND  :
    case DALGEBRA_KIND  :
    case IALGEBRA_KIND :
    case TEST_KIND :
     authorize_option(-1, out);                                               /* no check, as a C expression is expected          */
      C_syntax_checker(str1, ml, mf);
      break;
 
    case ADC_KIND :
    case DAC_KIND :
    case UADC_KIND :
    case UDAC_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NUMBER, NOSIGN, sgn, tok1, out, "number of levels")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "reference")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case MUX_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | VARIABLE| NUMBER, NOSIGN, sgn, tok1, out, "control")) {
        break;
      }
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (0 == strcmp(tok1, "void")) {
          continue;
        }
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two input nodes are requested\n");
        flag_node(out);
        break;
      }
      break;
 
    case MERGE_KIND :
      authorize_option(YES, out);
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two input nodes are requested\n");
        flag_node(out);
        break;
      }
      break;
 
    case TRIG_KIND :
      authorize_option(YES, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, "trigger threshold")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (((char*) NULL == strstr(Node_List[out].option, "dual"))
       && ((char*) NULL == strstr(Node_List[out].option, "positive"))
       && ((char*) NULL == strstr(Node_List[out].option, "negative"))) {
        print_error_location(tg, ml, mf);
        replace_dollar(tok1);
        (void) fprintf(STDERR,     " (%s) is not a valid trigger qualifier\n\n", Node_List[out].option);
        (void) fprintf(STDERR,     " valid qualifiers are:\n");
        (void) fprintf(STDERR,     "       (negative)\n");
        (void) fprintf(STDERR,     "       (positive)\n");
        (void) fprintf(STDERR,     "       (dual)\n");
        flag_node(out);
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case SIGN_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case CHG_KIND :
      authorize_option(YES, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      if (((char*) NULL == strstr(Node_List[out].option, "dual"  ))
       && ((char*) NULL == strstr(Node_List[out].option, "both"    ))
       && ((char*) NULL == strstr(Node_List[out].option, "positive"))
       && ((char*) NULL == strstr(Node_List[out].option, "negative"))) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " (%s) is not a valid qualifier for node 'change'\n\n", Node_List[out].option);
        (void) fprintf(STDERR,     " valid qualifiers are:\n");
        (void) fprintf(STDERR,     "    (dual)\n");
        (void) fprintf(STDERR,     "    (both)\n");
        (void) fprintf(STDERR,     "    (positive)\n");
        (void) fprintf(STDERR,     "    (negative)\n");
        flag_node(out);
        break;
      }
      break;
 
    case DTOI_KIND :
    case ITOD_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, "input")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case BTOI_KIND :
      authorize_option(NO, out);
      i = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        (void) snprintf(msg, (size_t) 31, "input #%ld", i+1L);
        if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok1, out, msg)) {
          break;
        }
        i++;
      }
      if ((0 == is_node_flagged(out)) && (2L > i)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two inputs are required\n");
        flag_node(out);
      }
      break;
 
    case POLY_KIND :
      authorize_option(NO, out);
      s = str1;
      n = 0L;
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        n++;
      }
      if ((0 == is_node_flagged(out)) && (2L > n)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " at least two inputs are required\n");
        flag_node(out);
        break;
      }
      str1 = s;
      for (i = 0L; i < n-1L; i++) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        (void) snprintf(msg, (size_t) 31, "coefficient of x^%ld", i);
        if (0 != check_syntax(NODE | VARIABLE | NUMBER, DONTCARE, sgn, tok1, out, msg)) {
          break;
        }
      }
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(NODE, DONTCARE, sgn, tok1, out, "input")) {
        break;
      }
      break;
 
    case ROM_KIND :
    case ROM2_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(DONTCARE, NOSIGN, sgn, tok1, out, "ROM name")) {
        break;
      }
      a = record_id(tok1);
      if (UNDEFINED != a) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " the array <%s[]> is not a ROM but an array of pointers\n", tok1);
        flag_node(out);
        break;
      }
      a = array_id(tok1);
      if (UNDEFINED == a) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " ROM array <%s[]> is not declared\n", tok1);
        process_array_error(tok1);
        flag_node(out);
        break;
      }
      if ((0 == is_node_flagged(out)) && ((RAM_KIND == Array_List[a].kind) || (RAM2_KIND == Array_List[a].kind))) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " the array <%s[]> is already used as a RAM\n", tok1);
        flag_node(out);
        break;
      }
      if ((0 == is_node_flagged(out)) && (kd != Array_List[a].kind) && (0L < Array_List[a].port)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " ROM <%s[]> port definitions are not consistent (single or dual port?)\n", tok1);
        flag_node(out);
        break;
      }
      Array_List[a].kind = kd;
      (Array_List[a].port)++;                                                 /* number of ports                                  */
      if ((0 == is_node_flagged(out)) && (ROM_KIND == Array_List[a].kind) && (1L < Array_List[a].port)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " <%s[]>: single-port ROM cannot be used as a dual port ROM\n", tok1);
        flag_node(out);
        break;
      }
      Array_List[a].used = true;
      str1 = get_token_between_braces(str1, brck, tok2);
      if (((0 != strcmp(brck, "[]")) || ISEMPTY(tok2)) && (0 == is_node_flagged(out))) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " address of ROM <%s[]> is not correct\n", tok1);
        flag_node(out);
        break;
      }
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, " ", tok2, out, "address of ROM")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok2);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, NOSIGN, sgn, tok2, out, "ROM chip select")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case RAM_KIND :
    case RAM2_KIND :
      authorize_option(NO, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(DONTCARE, NOSIGN, sgn, tok1, out, "RAM name")) {
        break;
      }
      a = record_id(tok1);
      if (UNDEFINED != a) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " the array <%s[]> is not a RAM but an array of pointers\n", tok1);
        flag_node(out);
        break;
      }
      a = array_id(tok1);
      if (UNDEFINED == a) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " RAM array <%s[]> is not declared\n", tok1);
        process_array_error(tok1);
        flag_node(out);
        break;
      }
      if ((0 == is_node_flagged(out)) && ((ROM_KIND == Array_List[a].kind) || (ROM2_KIND == Array_List[a].kind))) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " the array <%s[]> is already used as a ROM\n", tok1);
        flag_node(out);
        break;
      }
      if ((0 == is_node_flagged(out)) && (kd != Array_List[a].kind) && (0L < Array_List[a].port)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " RAM <%s[]> port definitions are not consistent (single or dual port?)\n", tok1);
        flag_node(out);
        break;
      }
      Array_List[a].kind = kd;
      (Array_List[a].port)++;
      if ((0 == is_node_flagged(out)) && (RAM_KIND == Array_List[a].kind) && (1L < Array_List[a].port)) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " <%s[]>: single-port RAM cannot be used as a dual port RAM\n", tok1);
        flag_node(out);
        break;
      }
      str1 = get_token_between_braces(str1, brck, tok2);
      if ((0 == is_node_flagged(out)) && ((0 != strcmp(brck, "[]")) || ISEMPTY(tok2))) {
        print_error_location(tg, ml, mf);
        (void) fprintf(STDERR,     " address node of RAM <%s[]> is not correct\n", tok1);
        flag_node(out);
        break;
      }
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, " ", tok2, out, "address of RAM")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok2);
      if (0 != check_syntax(NODE | VARIABLE | NUMBER, NOSIGN, sgn, tok2, out, "RAM chip select")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok2);
      if (0 != check_syntax(NODE | NUMBER, NOSIGN, sgn, tok2, out, "read/write of RAM")) {
        break;
      }
      str1 = get_sign_and_token(str1, sgn, tok2);
      if (0 != check_syntax(NODE, NOSIGN, sgn, tok2, out, "input of RAM")) {
        break;
      }
      if (0 != something_else(str1, out)) {
        break;
      }
      break;
 
    case DTOOL_KIND :
    case ITOOL_KIND :
      authorize_option(999, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(DONTCARE, NOSIGN, sgn, tok1, out, "user defined tool")) {
        break;
      }
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        a = array_id(tok1);
        if (UNDEFINED != a) {
          print_error_location("user defined tool", ml, mf);
          (void) fprintf(STDERR,   " <%s[]> is declared as a memory array, arrays of \n", tok1);
          (void) fprintf(STDERR,   "    pointers are the only arrays allowed as parameters\n" );
          break;
        }
      }
      break;
 
    case DUSER_KIND :
    case IUSER_KIND :
      authorize_option(999, out);
      str1 = get_sign_and_token(str1, sgn, tok1);
      if (0 != check_syntax(DONTCARE, NOSIGN, sgn, tok1, out, "user defined function")) {
        break;
      }
      for (;;) {
        str1 = get_sign_and_token(str1, sgn, tok1);
        if (ISEMPTY(tok1)) {
          break;
        }
        a = array_id(tok1);
        if (UNDEFINED != a) {
          print_error_location("user defined function", ml, mf);
          (void) fprintf(STDERR,   " <%s[]> is declared as a memory array, arrays of\n", tok1);
          (void) fprintf(STDERR,   "    pointers are the only arrays allowed as parameters\n");
          break;
        }
      }
      break;
 
    case UNKNOWN_KIND :
    default :
      print_error_location(tg, ml, mf);
      (void) fprintf(STDERR,       " node kind is not recognized\n");
      process_node_error(tok1);
      flag_node(out);
      Node_List[out].type = UNKNOWN_TYPE;
      break;
 
    }
  }
  return;
}
 
 
void syntax_records(void) {
  long i, j, n, r, v;
  char *s = (char*) NULL;
  char *t = (char*) NULL;
  char sgn[2]          = {'\0'};
  char tok[STRLENGTH]  = {'\0'};
  for (i = 0L; i < Num_Records; i++) {
    j = 0L;
    s = Record_List[i].list1;                                                 /* list of parameters                               */
    for (;;) {
      s = get_sign_and_token(s, sgn, tok);
      if ((0 == strcmp(sgn, "-")) || (0 == strcmp(sgn, "+"))) {
        if (is_an_identifier(tok)) {
          print_error_location("record", Record_List[i].mline, Record_List[i].mfile);
          (void) fprintf(STDERR,   " no sign is allowed in the list of parameters of a record\n");
        }
      }
      if (ISEMPTY(tok)) {
        break;
      }
      t =  strstr(tok, "::");
      if ((char*) NULL != t) {
        (void) strcpy(tok, t+2);                                       /* passing by name, extract the variable for verification  */
      }
      n = node_id(tok);
      r = record_id(tok);
      v = var_id(tok);
      if ((UNDEFINED==n) && (UNDEFINED==r) && (UNDEFINED==v) && (UNKNOWN_TYPE==constant_type(tok)) && (0!=strcmp(tok, "void"))) {
        print_error_location("array", Record_List[i].mline, Record_List[i].mfile);
        (void) fprintf(STDERR,     " in array of pointers <%s[%ld]>,\n", Record_List[i].name, Record_List[i].size);
        (void) fprintf(STDERR,     "    <%s> is not an array of pointers, a variable, a node identifier, a number nor a string\n", tok);
        process_record_error(tok);
        process_variable_error(tok);
        continue;
      }
      j++;
    }
    if (0L == Record_List[i].size) {                                          /* store size if size was not indicated             */
      Record_List[i].size = j;
      Record_List[i].nrow = 1L;
      Record_List[i].ncol = j;
    } else if ((j != Record_List[i].size) && (0 == Error_Flag)) {
      print_error_location("array", Record_List[i].mline, Record_List[i].mfile);
      (void) fprintf(STDERR,       " Mismatch in array of pointers <%s[%ld]>,\n", Record_List[i].name, Record_List[i].size);
      (void) fprintf(STDERR,       "    the actual number #%ld of parameters is not compatible with declaration\n", j);
      continue;
    }
  }
  return;
}
 
 
void syntax_segment_value(void) {                                             /* 'drop' segment                                   */
  long nseg;
  char *str = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
 
  for (nseg = 0L; nseg < Num_Segments; nseg++) {
    if (DROP_SEGMENT_TYPE != Segment_List[nseg].type) {
      continue;
    }
    str = Segment_List[nseg].value;
    for (;;) {
      str = get_token(str, tok, false);
      if (0 == strcmp(tok, "when")) {
        print_error_location("drop", Segment_List[nseg].mline, Segment_List[nseg].mfile);
        (void) fprintf(STDERR, " keyword 'when' is not allowed in a drop statement\n");
      }
      if (ISEMPTY(tok)) {
        break;
      }
    }
    str = Segment_List[nseg].value;
    C_syntax_checker(str, Segment_List[nseg].mline, Segment_List[nseg].mfile);
  }
  return;
}
 
 
void syntax_terminate(void) {
  char *str = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
 
  str = Terminate_List.condition;
  for (;;) {
    str = get_token(str, tok, true);
    if (0 == strcmp(tok, "when")) {
      print_error_location("terminate", Terminate_List.mline, Terminate_List.mfile);
      (void) fprintf(STDERR,    " keyword 'when' is not allowed in a terminate statement\n");
    }
    if (ISEMPTY(tok)) {
      break;
    }
  }
  str = Terminate_List.condition;
  C_syntax_checker(str, Terminate_List.mline, Terminate_List.mfile);
  return;
}
 
 
void syntax_updates(void) {
  long out;
  long m, v;
  char *str = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
  unsigned long *ml = (unsigned long*) NULL;
  unsigned long *mf = (unsigned long*) NULL;
 
  for (out = 0L; out < Num_Updates; out++) {
    str = Update_List[out].value;
    ml  = Update_List[out].mline;
    mf  = Update_List[out].mfile;
    v = var_id(Update_List[out].name);
    if (UNDEFINED != v) {
      if (0 == strcmp(Var_List[v].value, "void")) {
        print_error_location("update", ml, mf);
        (void) fprintf(STDERR,   " the variable <%s> has been defined as (void) and cannot be updated\n", Update_List[out].name);
      }
    }
    C_syntax_checker(str, ml, mf);
    str = Update_List[out].value;
    for (;;) {
      str = get_token(str, tok, true);
      if (ISEMPTY(tok)) {
        break;
      }
      m = record_id(tok);
      if (UNDEFINED != m) {
        print_error_location("update", ml, mf);
        (void) fprintf(STDERR,   " array of pointers, here <%s>, cannot be used", Record_List[m].name);
        (void) fprintf(STDERR,   " in the update of variable <%s>\n",           Update_List[out].name);
      }
      m = array_id(tok);
      if (UNDEFINED != m) {
        print_error_location("update", ml, mf);
        (void) fprintf(STDERR,   " arrays, here <%s>, cannot be used",   Array_List[m].name);
        (void) fprintf(STDERR,   " in the update of variable <%s>\n", Update_List[out].name);
      }
    }
  }
  return;
}
 
 
void syntax_variables(void) {
  long out;
  long typ;
  long  m;
  char *str = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
  unsigned long *ml = (unsigned long*) NULL;
  unsigned long *mf = (unsigned long*) NULL;
  for (out = 0L; out < Num_Vars; out++) {
    typ = Var_List[out].type;
    if ((DIGITAL_DATA_TYPE != typ) && (ANALOG_DATA_TYPE != typ)) {
      continue;
    }
    str = Var_List[out].value;
    ml  = Var_List[out].mline;
    mf  = Var_List[out].mfile;
    if ((DIGITAL_DATA_TYPE == typ) || (ANALOG_DATA_TYPE == typ)) {
      if ((!Var_List[out].external) && (is_a_string(str))) {
        if (DIGITAL_DATA_TYPE == typ) {
          print_error_location("ivar", ml, mf);
        }
        if (ANALOG_DATA_TYPE == typ) {
          print_error_location("dvar", ml, mf);
        }
        (void) fprintf(STDERR,   " definition of the variable cannot be a string <%s>\n", str);
      }
    }
    C_syntax_checker(str, ml, mf);
    str = Var_List[out].value;
    for (;;) {
      str = get_token(str, tok, true);
      if (ISEMPTY(tok)) {
        break;
      }
      m = record_id(tok);
      if (UNDEFINED != m) {
        print_error_location("var", ml, mf);
        (void) fprintf(STDERR,   " array of pointers <%s> cannot be used", Record_List[m].name);
        (void) fprintf(STDERR,   " in the definition of variable <%s>\n",  Var_List[out].name1);
      }
 
    }
  }
  return;
}
 
 
/* ****************************************************************************************************************************** */
 
/* 'check_syntax' verifies the nature of a parameter (NODE, VARIABLE, NUMBER).                                                    */
/* - a parameter could be required to be a node, a var or a number                                                                */
/* - sign could be forbidden                                                                                                      */
/* DONTCARE means that no test on this parameter has to be made.                                                                  */
/* Print error message and returns 1 if an error has been detected, returns 0 otherwise.                                          */
 
long check_syntax(long to_be, long no_sign, const char *sgn, char *tok, long id, const char *txt) {
  int  not_to_be;
  int  test;
  unsigned long *ml = (unsigned long*) NULL;
  unsigned long *mf = (unsigned long*) NULL;
  char *tg = (char*) NULL;
  int  nflag, vflag;
 
  ml = Node_List[id].mline;
  mf = Node_List[id].mfile;
  tg = Node_List[id].tag;
  nflag = false;
  vflag = false;
  test  = false;
  not_to_be = (int) (((0L == to_be)) & 15L) ? 1L : 0L;
  if (ISEMPTY(tok) && ((0 == is_node_flagged(id)))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR, " %s is missing\n", txt);
    flag_node(id);
    return 1L;
  }
  if ((0 != (not_to_be & NODE)) && (UNDEFINED != node_id(tok)) && ((0 == is_node_flagged(id)))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " %s <%s> cannot be a node\n",     txt, tok);
    flag_node(id);
    return 1;
  }
  if ((0 != (not_to_be & VARIABLE)) && (UNDEFINED != var_id(tok)) && ((0 == is_node_flagged(id)))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " %s <%s> cannot be a variable\n", txt, tok);
    flag_node(id);
    return 1L;
  }
  if ((0 != (not_to_be & NUMBER)) && ((ANALOG_DATA_TYPE == constant_type(tok))
   || (HEX_DATA_TYPE == constant_type(tok)) || (DIGITAL_DATA_TYPE == constant_type(tok))) && ((0 == is_node_flagged(id)))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " %s <%s> cannot be a constant number\n", txt, tok);
    flag_node(id);
    return 1L;
  }
  if (((0 == strcmp(sgn, "-")) || (0 == strcmp(sgn, "+"))) && (NOSIGN == no_sign) && (0 == is_node_flagged(id))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " %s <%s> cannot be signed\n", txt, tok);
    flag_node(id);
    return 1L;
  }
  if ((0 != (DONTCARE != to_be)) && (UNDEFINED != array_id(tok)) && ((0 == is_node_flagged(id)))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " %s <%s> is invalid as it is declared as array\n", txt, tok);
    flag_node(id);
    return 1L;
  }
  if ((0 != (DONTCARE != to_be)) && (UNDEFINED != op_id(tok)) && ((0 == is_node_flagged(id)))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " %s <%s> is invalid as it is declared as opcode\n", txt, tok);
    flag_node(id);
    return 1L;
  }
  if ((0 != (to_be & NODE)) && (UNDEFINED != node_id(tok))) {
    test = true;
  }
  if ((0 != (to_be & VARIABLE)) && (UNDEFINED != var_id(tok))) {
    test = true;
  }
  if ((0 != (to_be & NUMBER)) && ((ANALOG_DATA_TYPE == constant_type(tok))
   || (HEX_DATA_TYPE == constant_type(tok)) || (DIGITAL_DATA_TYPE == constant_type(tok)))) {
    test = true;
  }
  if ((0 != (to_be & STRING)) && (STRING_DATA_TYPE == constant_type(tok))) {
    test = true;
  }
  if ((!test) && (0 != (DONTCARE != to_be)) && ((0 == is_node_flagged(id)))) {
    nflag = false;
    vflag = false;
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " %s <%s> must be", txt, tok);
    if (0 != (to_be & NODE)) {
      (void) fprintf(STDERR,     " a node");
      nflag = true;
    }
    if (0 != (to_be & VARIABLE)) {
      if (0 != (to_be & NODE)) {
        (void) fprintf(STDERR,   " or");
      }
      (void) fprintf(STDERR,     " a variable");
      vflag = true;
    }
    if (0 != (to_be & NUMBER)) {
      if ((0 != (to_be & NODE)) || (0 != (to_be & VARIABLE))) {
        (void) fprintf(STDERR,   " or");
      }
      (void) fprintf(STDERR,     " a constant number");
    }
    if (0 != (to_be & STRING)) {
      if ((0 != (to_be & NODE)) || (0 != (to_be & VARIABLE)) || (0 != (to_be & NUMBER))) {
        (void) fprintf(STDERR,   " or");
      }
      (void) fprintf(STDERR,     " a string");
    }
    (void) fprintf(STDERR, "\n");
    if (nflag) {
      process_node_error(tok);
    }
    if (vflag) {
      process_variable_error(tok);
    }
    flag_node(id);
    return 1L;
  }
  return 0L;
}
 
 
void authorize_option(long num, long id) {
  long i;
  char *tg = (char*) NULL;
  char *str = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
  char sgn[3]         = {'\0'};
  unsigned long *ml = (unsigned long*) NULL;
  unsigned long *mf = (unsigned long*) NULL;
  if (-1L == num) {                                                           /* no check                                         */
    return;
  }
  ml  = Node_List[id].mline;
  mf  = Node_List[id].mfile;
  tg  = Node_List[id].tag;
  str = Node_List[id].option;
  i   = 0L;
  for (;;) {
    str = get_sign_and_token(str, sgn, tok);
    if (ISEMPTY(tok)) {
      break;
    }
    i++;
  }
  if ((0L != i) && (0L == num) && (0 == is_node_flagged(id))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " no qualifier is expected for this node,\n");
    (void) fprintf(STDERR,       " current qualifier list is ");
    str = Node_List[id].option;
    for (;;) {
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      (void) fprintf(STDERR,     "(%s) ", tok);
    }
    (void) fprintf(STDERR,     "\n");
    flag_node(id);
  }
  if ((i > num) && (0 == is_node_flagged(id))) {
    print_error_location(tg, ml, mf);
    if (1L == num) {
      (void) fprintf(STDERR,     " up to %ld qualifier is expected for this node,\n",   num);
    } else {
      (void) fprintf(STDERR,     " up to %ld qualifiers are expected for this node,\n", num);
    }
    (void) fprintf(STDERR,       " current qualifier list is ");
    str = Node_List[id].option;
    for (;;) {
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      (void) fprintf(STDERR,     "(%s) ", tok);
    }
    (void) fprintf(STDERR,     "\n");
    flag_node(id);
  }
  return;
}
 
 
/* Print error message and returns 1 if an error has been detected, returns 0 otherwise.                                          */
 
long something_else(const char *tok, long id) {
  char *tg = (char*) NULL;
  unsigned long *ml = (unsigned long*) NULL;
  unsigned long *mf = (unsigned long*) NULL;
  ml = Node_List[id].mline;
  mf = Node_List[id].mfile;
  tg = Node_List[id].tag;
  if (ISNOTEMPTY(tok) && (0 == is_node_flagged(id))) {
    print_error_location(tg, ml, mf);
    (void) fprintf(STDERR,       " unexpected text appears at the end of node definition: <%s>\n", tok);
    flag_node(id);
    return 1L;
  }
  return 0L;
}
 
 
/* Check that parenthesis, curly and rectangular brackets are balanced and that single quotes and double quotes are paired.       */
/* Triangular brackets are NOT checked... (as comparisons symbols interfere: in '>=', '<=', '>', '<', they are not balanced)      */
/* Check that unary ANSI-C operators ++, --, += ... are not present (forbidden in the NAPA syntax).                               */
 
void sanity_check(char *s, const unsigned long *mlin, const unsigned long *mfil) {        /* check quotes, brackets               */
  char *t = (char*) NULL;
  long dq = 0L;                                                               /* 0: outside string                                */
  long c0 = 0L;                                                               /* counter of  '''                                  */
  long c1 = 0L;                                                               /* counter of  '"'                                  */
  long c2 = 0L;                                                               /* counter of  '(' and ')'                          */
  long c3 = 0L;                                                               /* counter of  '[' and ']'                          */
  long c4 = 0L;                                                               /* counter of  '{' and '}'                          */
  t = s;
  while ((isspace((int) *t)) && ('\0' != *t)) {                               /* take first non blank char                        */
    t++;
  }
  if ('#' == *t) {                                                            /* clear comment line                               */
    *s = '\0';
    return;
  }
  t = s;                                                                      /* start at 1st non blank char                      */
  while ('\0' != *t) {
    if ('"' == *t) {                                                          /* inside or outside string?                        */
      dq = (1L == dq) ? 0L : 1L;                                              /* toggle, 0/1: outside/inside double quote comment */
    }
    if ((t > s) && ('/' == *t) && ('/' == *(t-1)) && (0L == dq)) {
      break;                                                                  /* no verification after '//'                       */
    }
    if  (((t > s) && ('+' == *(t-1)) && ('+' == *t)) || ((t > s) && ('-' == *(t-1)) && ('-' == *t)))  {                /*  ++, -- */
      if (0L == dq) {                                                         /* error if outside a string                        */
        print_error_location( "syntax limitation", mlin, mfil);
        (void) fprintf(STDERR,   " Sorry!To avoid side effects, ANSI-C operator %c%c\n", *(t-1), *t);
        (void) fprintf(STDERR,   " cannot be used explicitely in the NAPA netlist description\n");
        print_error_banner_and_exit();
      }
    }
    if  (((t > s) && ('+' == *(t-1)) && ('=' == *t)) || ((t > s) && ('-' == *(t-1)) && ('=' == *t))                    /*  +=, -= */
      || ((t > s) && ('*' == *(t-1)) && ('=' == *t)) || ((t > s) && ('/' == *(t-1)) && ('=' == *t))                    /*  *=, &= */
      || ((t > s) && ('%' == *(t-1)) && ('=' == *t)) || ((t > s) && ('&' == *(t-1)) && ('=' == *t))                    /*  %=, &= */
      || ((t > s) && ('|' == *(t-1)) && ('=' == *t)) || ((t > s) && ('^' == *(t-1)) && ('=' == *t))) {                 /*  |=, ^= */
      if (0L == dq) {                                                         /* error if outside a string                        */
        print_error_location( "syntax limitation", mlin, mfil);
        (void) fprintf(STDERR,   " Sorry!To avoid side effects, ANSI-C assignation %c%c\n", *(t-1), *t);
        (void) fprintf(STDERR,   " cannot be used explicitely in the NAPA netlist description\n");
        print_error_banner_and_exit();
      }
    }
    if       (('\'' == *t) && (0 == dq)) {                                    /* do not count quotes inside double quote comment  */
      c0++;
    } else if ('"'  == *t) {
      c1++;
    } else {
      if ((0L == (c0 % 2L)) && (0L == (c1 % 2L))) {                           /* no verification inside '...' and "..."           */
        switch (*t) {
        case '(':
          c2++;
          break;
        case ')':
          c2--;
          if (0L > c2) {
            print_error_location( "syntax", mlin, mfil);
            (void) fprintf(STDERR, " unmatched closing parenthesis in <%s> ?\n", s);
            (void) fprintf(STDERR, "                              %*s^\n", (int) ABS(t-s), " ");
            print_error_banner_and_exit();
          }
          break;
        case '[':
          c3++;
          break;
        case ']':
          c3--;
          if (0L > c3) {
            print_error_location( "syntax", mlin, mfil);
            (void) fprintf(STDERR, " unmatched closing bracket in <%s> ?\n", s);
            (void) fprintf(STDERR, "                          %*s^\n", (int) ABS(t-s), " ");
            print_error_banner_and_exit();
          }
          break;
        case '{':
          c4++;
          break;
        case '}':
          c4--;
          if (0L > c4) {
            print_error_location( "syntax", mlin, mfil);
            (void) fprintf(STDERR, " unmatched closing curly bracket in <%s> ?\n", s);
            print_error_banner_and_exit();
          }
          break;
        default:
          break;
        }
      }
    }
    t++;
  }
  if (0L != (c0 % 2L)) {
    print_error_location( "syntax", mlin, mfil);
    (void) fprintf(STDERR,       " unmatched single quote in C expression <%s> ?\n", s);
    print_error_banner_and_exit();
  }
  if (0L != (c1 % 2L)) {
    print_error_location( "syntax", mlin, mfil);
    (void) fprintf(STDERR,       " unmatched double quote in C expression <%s> ?\n", s);
    print_error_banner_and_exit();
  }
  if (0L < c2) {
    print_error_location( "syntax", mlin, mfil);
    (void) fprintf(STDERR,       " missing closing parenthesis in C expression <%s> ?\n",   s);
    print_error_banner_and_exit();
  }
  if (0L > c2) {
    print_error_location( "syntax", mlin, mfil);
    (void) fprintf(STDERR,       " unmatched opening parenthesis in C expression <%s> ?\n", s);
    print_error_banner_and_exit();
  }
  if (0L < c3) {
    print_error_location( "syntax", mlin, mfil);
    (void) fprintf(STDERR,       " missing closing rectangular bracket in C expression <%s> ?\n",   s);
    print_error_banner_and_exit();
  }
  if (0L > c3) {
    print_error_location( "syntax", mlin, mfil);
    (void) fprintf(STDERR,       " unmatched opening rectangular bracket in C expression <%s> ?\n", s);
    print_error_banner_and_exit();
  }
  if (0L < c4) {
    print_error_location( "syntax", mlin, mfil);
    (void) fprintf(STDERR,       " missing closing curly bracket in C expression <%s> ?\n", s);
    print_error_banner_and_exit();
  }
  if (0L > c4) {
    print_error_location( "syntax", mlin, mfil);
    (void) fprintf(STDERR,       " unmatched curly bracket in C expression <%s> ?\n", s);
    print_error_banner_and_exit();
  }
  return;
}
 
 
/* Check C syntax (parenthesis, brackets, single and double quotes, and assignations in a wrong places                            */
 
void C_syntax_checker(char *str, const unsigned long *mlin, const unsigned long *mfil) {
  static int flag = false;
  char* s = (char*) NULL;
  sanity_check(str, mlin, mfil);
  s = str;
  while ('\0' != *(s+1)) {
    if ('=' == *(s+1)) {                                                      /* a character '=' is detected                      */
      if (('=' == *s) || ('!' == *s) || ('>' == *s) || ('<' == *s)) {         /* '==', '!=', '>=' or '<='      OK!                */
        s++;
        continue;
      } else {
        if ('=' == *(s+2)) {                                                  /* '=='                          OK!                */
          s++;
          continue;
        } else if (('>' == *(s+2)) || ('<' == *(s+2)) || ('!' == *(s+2))) {   /* '=!', '=>' or '=<'      mispelled                */
          print_error_location("syntax", mlin, mfil);
          (void) fprintf(STDERR, " no assignation is expected in expression ' %s '\n", str);
          if (flag) {
            flag = true;
            break;                                                            /* parsing of instruction may continue              */
          } else {
            print_error_banner_and_exit();
          }
        } else {                                                              /* single '='              assignation is forbidden */
          print_error_location("syntax", mlin, mfil);
          (void) fprintf(STDERR, " no assignation is expected in expression ' %s '\n", str);
          if (flag) {
            flag = true;
            break;                                                            /* parsing of instruction may continue              */
          } else {
            print_error_banner_and_exit();
          }
        }
      }
    }
    s++;
  }
  return;
}
 
 
/* ****************************************************************************************************************************** */
/* end of file                                                                                                                    */