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

#include "./napa.h"
#include "./proto.h"

Go to the source code of this file.

Macros
#define	EXTERN   extern

Functions
void	print_limits (void)
char *	get_a_line (char *buf, unsigned long *nl, FILE *fp, unsigned long *mlin, const unsigned long *mfil)
long	f2printf (FILE *fp1, FILE *fp2, char *fmt,...)
void	default_control_variables (void)
void	complete_directives (void)
void	expand_string_variables (void)
void	expand_records (void)
void	check_array_usage (void)
void	check_record_usage (void)
void	check_directive_usage (void)
void	collect_export_definitions (void)
void	expand_update_definitions (void)
void	expand_IO_definitions (void)
void	expand_dump_definitions (void)
long	process_condition (char *str, const unsigned long *mlin, const unsigned long *mfil)
void	build_condition (char *cond, const unsigned long *mlin, const unsigned long *mfil)
void	build_to_be_delayed_node_list (void)
void	determine_simulation_rate (void)
void	determine_segment_processing_rate (void)
void	determine_output_segment_rate (void)
void	compact_segment (void)
void	process_aliases (void)
double	GCD (double a, double b)
double	LCM (double n1, double n2)
int	verify_rshift (void)
void	cat_file (const char *fnam, const char *type, long command, const unsigned long *mlin, const unsigned long *mfil)
void	process_error_if_any (void)
void	print_error_location (const char *type, const unsigned long *mlin, const unsigned long *mfil)
void	print_warning_location (const char *type, const unsigned long *mlin, const unsigned long *mfil)
void	print_info_location (const char *type, const unsigned long *mlin, const unsigned long *mfil)
void	print_problem_location (const char *type, const unsigned long *mlin, const unsigned long *mfil, const char *kind)
void	print_location (const unsigned long *mlin, const unsigned long *mfil)
int	test_endianness (void)
void	wall_clock (void)
void	last_message (void)

Macro Definition Documentation

EXTERN

#define EXTERN   extern

Definition at line 4 of file fc.c.

Function Documentation

build_condition()

void build_condition	(	char *	cond,
		const unsigned long *	mlin,
		const unsigned long *	mfil )

Definition at line 958 of file fc.c.

                                                                                       {
  long  in;
  char  sgn[2]          = {'\0'};
  char  tok[STRLENGTH]  = {'\0'};
  char  buf1[LINLENGTH] = {'\0'};
  char  buf2[LINLENGTH] = {'\0'};
  char *str = (char*) NULL;
  str  = cond;
  if (ISEMPTY(str)) {
    print_error_location("condition", mlin, mfil);
    (void) fprintf(STDERR,       " syntax error in condition <%s>, event is missing\n", str);
    return;
  }
  (void) fprintf(STDOUT,         "  if ( ");
  while (ISNOTEMPTY(str)) {
    str = get_sign_and_token(str, sgn, tok);
    in  = var_id(tok);
    if (UNDEFINED == in) {
      (void) strcpy(buf1, buf2);
      if ((0 == strcmp("&&", tok)) || (0 == strcmp("||", tok))) {
        (void) snprintf(buf2, (size_t) (LINLENGTH-1L), "%s %s ", buf1, tok);
      } else {
        (void) snprintf(buf2, (size_t) (LINLENGTH-1L), "%s%s",   buf1, tok);
      }
      continue;
    }
    (void) strcpy(buf1, buf2);
    (void) build_name(sgn, tok, RIGHT_VALUE);
    (void) snprintf(buf2, (size_t) (LINLENGTH-1L), "%s%s",       buf1, tok);
  }
  clean_parentheses(buf2);
  (void) fprintf(STDOUT,         "%s", buf2);
  (void) fprintf(STDOUT,         " ) {\n");
  return;
}

References build_name(), clean_parentheses(), get_sign_and_token(), ISEMPTY, ISNOTEMPTY, LINLENGTH, print_error_location(), RIGHT_VALUE, STDERR, STDOUT, STRLENGTH, UNDEFINED, and var_id().

Referenced by build_main_loop_block1(), build_main_loop_dump1(), build_output(), and print_output_banner_function().

build_to_be_delayed_node_list()

void build_to_be_delayed_node_list

(

void

)

Definition at line 998 of file fc.c.

                                         {
  long  in;
  long  out;
  long  k;
  char  sgn[2]         = {'\0'};
  char  tok[STRLENGTH] = {'\0'};
  char *str = (char*) NULL;
  for (out = 0L; out < Num_Nodes; out++) {
    k = Node_List[out].kind;
    if ((DELAY1_KIND == k) || (DELAY2_KIND == k) || (DELAY3_KIND == k) || (DELAY_KIND == k)) {
      str = Node_List[out].value;                                             /* get the unprocessed node_value                   */
      str = get_sign_and_token(str, sgn, tok);                                /* skip delay number                                */
      str = get_sign_and_token(str, sgn, tok);                                /* input_node name                                  */
      in  = node_id(tok);
      Delay_Input[Num_Delays] = Node_List[in].ID;
      Num_Delays++;
    }
  }
  return;
}

References DELAY1_KIND, DELAY2_KIND, DELAY3_KIND, Delay_Input, DELAY_KIND, get_sign_and_token(), node_id(), Node_List, Num_Delays, Num_Nodes, and STRLENGTH.

Referenced by main().

cat_file()

void cat_file	(	const char *	fnam,
		const char *	type,
		long	command,
		const unsigned long *	mlin,
		const unsigned long *	mfil )

Definition at line 1411 of file fc.c.

                                                                                                                      {
  FILE *fp = (FILE*) NULL;
  char  lin1[LINLENGTH+2L] = {'\0'};
  char  lin2[LINLENGTH+2L] = {'\0'};
  long  i, j;
  int   flag1, flag2;
  flag1 = false;
  flag2 = false;
  if ((FILE*) NULL == (fp = fopen(fnam, "r"))) {
    print_error_location("file", mlin, mfil);
    (void) fprintf(STDERR,       " OUCH!- (%s) can't find or access file <\"%s\">\n", type, fnam);
    print_error_banner_and_exit();
  }
  if (EXPAND == command) {                                                    /* file expansion is requested                      */
    while ((char*) NULL != (fgets(lin1, LINLENGTH, fp))) {
      flag1 = true;
      j = 0L;
      for (i = 0L; i < LENGTH(lin1); i++) {                                   /* ignore comment area                              */
        if ((flag1) && ('/' == lin1[i]) && ('*' == lin1[i+1L]))  {
          i++;
          flag1 = false;
          continue;
        }
        if (flag1) {
          lin2[j] = lin1[i];
          j++;
        }
        if ((!flag1) && ('*' == lin1[i-1L]) && ('/' == lin1[i])) {
          flag1 = true;
          continue;
        }
      }
      if (flag1) {
        lin2[j] = '\0';
        (void) strcpy(lin1, lin2);
      }
      flag2 = false;
      for (i = 0L; i < LENGTH(lin1); i++) {
        if (!isspace((int) lin1[i])) {
          flag2 = true;                                                       /* line contents non blank element                  */
        }
      }
      if (flag2) {                                                            /* do not copy blank or all comment lines           */
        (void) fprintf(STDOUT, "%s", lin1);
      }
    }
  }
  if (EOF == fclose(fp)) {
    print_error_location("file", mlin, mfil);
    (void) fprintf(STDERR,       " OUCH!- (%s) can't close file <\"%s\"> opened for verification\n", type, fnam);
    print_error_banner_and_exit();
  }
  return;
}

References EXPAND, LENGTH, LINLENGTH, print_error_banner_and_exit(), print_error_location(), STDERR, and STDOUT.

Referenced by include_napa_header_files(), and load_function().

check_array_usage()

void check_array_usage

(

void

)

Definition at line 503 of file fc.c.

                             {
  long  out;
  long  kd, m;
  char *s = (char*) NULL;
  char  sgn[2]          = {'\0'};
  char  tok1[STRLENGTH] = {'\0'};
  for (out = 0L; out < Num_Nodes; out++) {
    s  = Node_List[out].value;
    kd = Node_List[out].kind;
    switch (kd) {
    case ITOOL_KIND :
    case DTOOL_KIND :
    case IUSER_KIND :
    case DUSER_KIND :
    case DALGEBRA_KIND :
    case IALGEBRA_KIND :
    case ALGEBRA_KIND :
    case TEST_KIND :
    case CONST_KIND :
    case DC_KIND :
      for (;;) {
        s = get_token(s, tok1, true);
        if (ISEMPTY(tok1)) {
          break;
        }
        m = array_name_id(tok1);
        if (UNDEFINED != m) {                                                 /* detect use of array by file                      */
          Array_List[m].used = true;
        }
      }
      break;
    case RAM_KIND :
    case RAM2_KIND :
    case ROM_KIND :
    case ROM2_KIND :
      s = get_sign_and_token(s, sgn, tok1);
      m = array_id(tok1);
      if (UNDEFINED != m) {                                                   /* detect use of array by name                      */
        Array_List[m].used = true;
      }
      break;
    default:
      break;
    }
  }
  for (m = 0L; m < Num_Arrays; m++) {
    if ((Array_List[m].used) && (UNKNOWN_KIND != Array_List[m].kind)) {
      Array_Flag = true;
      continue;
    }
  }
  return;
}

References ALGEBRA_KIND, Array_Flag, array_id(), Array_List, array_name_id(), CONST_KIND, DALGEBRA_KIND, DC_KIND, DTOOL_KIND, DUSER_KIND, get_sign_and_token(), get_token(), IALGEBRA_KIND, ISEMPTY, ITOOL_KIND, IUSER_KIND, Node_List, Num_Arrays, Num_Nodes, RAM2_KIND, RAM_KIND, ROM2_KIND, ROM_KIND, STRLENGTH, TEST_KIND, UNDEFINED, and UNKNOWN_KIND.

Referenced by main().

check_directive_usage()

void check_directive_usage

(

void

)

Definition at line 631 of file fc.c.

                                 {
  long d;
  if ((0 >= Num_Directives) || (Cmdline_Flag)) {                              /* no directive in netlist, or standalone simulator */
    return;
  }
  mark_directives();                                                          /* inspect napa netlist for macro usage             */
  for (d = 0L; d < Num_Directives; d++) {                                     /* directives used in the C file produced by NAPA   */
    if ((0 == strcmp(Directive_List[d].name, "TIME_OFFSET"       )) || (0 == strcmp(Directive_List[d].name, "JITTER"   ))
     || (0 == strcmp(Directive_List[d].name, "STRICTLY_NO_BANNER")) || (0 == strcmp(Directive_List[d].name, "NO_BANNER"))
     || (0 == strcmp(Directive_List[d].name, "NO_TIME_OUTPUT"    )) || (0 == strcmp(Directive_List[d].name, "VERBOSE"  ))
     || (0 == strcmp(Directive_List[d].name, "NAPA_EXIT_STATUS"  )) ) {
      Directive_List[d].used = true;
      continue;
    }
    if (Assert_Flag) {
      if (0 == strcmp(Directive_List[d].name, "NO_ASSERT"  )) {
        Directive_List[d].used = true;
        continue;
      }
    }
    if (Dump_Flag) {
      if ((0 == strcmp(Directive_List[d].name, "DUMP"      )) || (0 == strcmp(Directive_List[d].name, "NO_GLOBAL"      ))
       || (0 == strcmp(Directive_List[d].name, "NO_ARRAY"  )) || (0 == strcmp(Directive_List[d].name, "NO_VAR"         ))
       || (0 == strcmp(Directive_List[d].name, "NO_NODE"   ))) {
        Directive_List[d].used = true;
        continue;
      }
    }
    if (Directive_List[d].function) {                                         /* this is a macro function, not a true directive   */
      Directive_List[d].used = true;
      continue;
    }
    Directive_Flag = true;
  }
  return;
}

References Assert_Flag, Cmdline_Flag, Directive_Flag, Directive_List, Dump_Flag, mark_directives(), and Num_Directives.

Referenced by main().

check_record_usage()

void check_record_usage

(

void

)

Definition at line 560 of file fc.c.

                              {
  long  out;
  long  kd, m;
  char *s  = (char*) NULL;
  char *s1 = (char*) NULL;
  char  sgn[2] = {'\0'};
  char  tok1[STRLENGTH] = {'\0'};
  for (out = 0L; out < Num_Nodes; out++) {
    s  = Node_List[out].value;
    kd = Node_List[out].kind;
    switch (kd) {
    case ITOOL_KIND :
    case DTOOL_KIND :
    case IUSER_KIND :
    case DUSER_KIND :
      for (;;) {
        s = get_token(s, tok1, false);
        if (ISEMPTY(tok1)) {
          break;
        }
        m = record_id(tok1);
        if (UNDEFINED != m) {                                                 /* detect use of array by name                      */
          Record_List[m].used = true;
        }
      }
      break;
    case DALGEBRA_KIND :
    case IALGEBRA_KIND :
    case ALGEBRA_KIND :
    case CONST_KIND :
    case DC_KIND :
    case TEST_KIND :
      for (;;) {
        s = get_token(s, tok1, true);
        if (ISEMPTY(tok1)) {
          break;
        }
        m = record_id(tok1);
        if (UNDEFINED != m) {                                                 /* detect use of array by name                      */
          Record_List[m].used = true;
        }
      }
      break;
    default:
      break;
    }
  }
  for (out = 0L; out < Num_Records; out++) {
    s1 = Record_List[out].list1;
    for (;;) {
      s1 = get_sign_and_token(s1, sgn, tok1);
      if (ISEMPTY(tok1)) {
        break;
      }
      m = var_id(tok1);
      if (UNDEFINED != m) {
        Var_List[m].used = true;
      }
    }
  }
  Pointer_Flag = false;
  for (out = 0L; out < Num_Records; out++) {
    if (Record_List[out].used) {
      Pointer_Flag = true;
      break;
    }
  }
  return;
}

References ALGEBRA_KIND, CONST_KIND, DALGEBRA_KIND, DC_KIND, DTOOL_KIND, DUSER_KIND, get_sign_and_token(), get_token(), IALGEBRA_KIND, ISEMPTY, ITOOL_KIND, IUSER_KIND, Node_List, Num_Nodes, Num_Records, Pointer_Flag, record_id(), Record_List, STRLENGTH, TEST_KIND, UNDEFINED, var_id(), and Var_List.

Referenced by main().

collect_export_definitions()

void collect_export_definitions

(

void

)

Definition at line 671 of file fc.c.

                                      {
  long  e, n, m;
  long  first;
  char *str = (char*) NULL;
  char  tok1[STRLENGTH] = {'\0'};
  char  tok2[STRLENGTH] = {'\0'};
  char  sgn[2]          = {'\0'};
  if (!Export_Flag) {
    return;
  }
  first = true;
  (void) strcpy(E_Format, "");                                                /* set E_Format with empty string                   */
  (void) strcpy(V_Format, "");                                                /* set V_Format with empty string                   */
  for (e = 0L; e < Num_Exports; e++) {                                        /* scan each export instruction to collect names    */
    str = Export_List[e].name;
    for (;;) {                                                                /* scan export list, identifier after identifier    */
      str = get_sign_and_token(str, sgn, tok1);
      if (ISEMPTY(tok1)) {
        break;                                                                /* end of list                                      */
      }
      if (!is_an_identifier(tok1)) {
        print_error_location("export", Export_List[e].mline, Export_List[e].mfile              );
        (void) fprintf(STDERR,   " export node or variable <%s> is not a NAPA identifier\n", tok1);
        process_node_error(tok1);
        process_variable_error(tok1);
        return;
      }
      if (ISNOTEMPTY(sgn)) {
        print_error_location("export", Export_List[e].mline, Export_List[e].mfile      );
        (void) fprintf(STDERR,   " export node or variable <%s> cannot be signed\n", tok1);
        return;
      }
      n = node_id(tok1);
      if (UNDEFINED != n) {                                                   /* is it a node ?                                   */
        Node_List[n].used = true;
        if (ANALOG_DATA_TYPE == Node_List[n].type) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   R_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, R_FORMAT_V);
          }
        } else {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   I_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, I_FORMAT_V);
          }
        }
      }
      m   = var_id(tok1);                                                     /* is it a variable ?                               */
      if (UNDEFINED != m) {
        Var_List[m].used = true;
        if (ANALOG_DATA_TYPE == Var_List[m].type) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   R_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, R_FORMAT_V);
          }
        } else if (DIGITAL_DATA_TYPE == Var_List[m].type) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   I_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, I_FORMAT_V);
          }
        } else {
          print_error_location("export", Export_List[e].mline, Export_List[e].mfile);
          (void) fprintf(STDERR, " a string variable cannot be exported <%s>", tok1);
        }
      }
      if ((UNDEFINED == n) && (UNDEFINED == m)) {                             /* an identifier known by NAPA                      */
        if (DIGITAL_DATA_TYPE == get_type(tok1)) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   I_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, I_FORMAT_V);
          }
        }
        if (ANALOG_DATA_TYPE == get_type(tok1)) {
          (void) strcat(E_Format,   " ");
          (void) strcat(E_Format,   R_FORMAT_V);
          if (first) {
            (void) strcat(V_Format, R_FORMAT_V);
          }
        }
      }
      (void) snprintf(tok2, (size_t) (STRLENGTH-1L), S_FORMAT_V, tok1);
      (void) strcat(Export0_Head_String, tok2);
      (void) build_name("", tok1, RIGHT_VALUE);
      (void) strcat(Export0_List_String, tok1);
      (void) strcat(Export0_List_String, ", ");
      if (first) {
        (void) strcpy(Export1_Head_String, Export0_Head_String);
        (void) strcpy(Export1_List_String, Export0_List_String);
      }
      first = false;
    }
  }
  Export0_List_String[LENGTH(Export0_List_String) - 2L] = '\0';               /* suppress last ", "                               */
  Export1_List_String[LENGTH(Export1_List_String) - 2L] = '\0';               /* suppress last ", "                               */
  return;
}

References ANALOG_DATA_TYPE, build_name(), DIGITAL_DATA_TYPE, E_Format, Export0_Head_String, Export0_List_String, Export1_Head_String, Export1_List_String, Export_Flag, Export_List, get_sign_and_token(), get_type(), I_FORMAT_V, is_an_identifier(), ISEMPTY, ISNOTEMPTY, LENGTH, node_id(), Node_List, Num_Exports, print_error_location(), process_node_error(), process_variable_error(), R_FORMAT_V, RIGHT_VALUE, S_FORMAT_V, STDERR, STRLENGTH, UNDEFINED, V_Format, var_id(), and Var_List.

Referenced by main().

compact_segment()

void compact_segment

(

void

)

Definition at line 1273 of file fc.c.

                           {
  long newseg[MAXSEGMENTS];
  long nseg, nseg1, nseg2;
  long n;
  for (nseg = 0L; nseg < MAXSEGMENTS; nseg++) {                               /* default: new number is the current one           */
    if (nseg < Num_Segments) {
      newseg[nseg] = nseg;
    } else {
      newseg[nseg] = 0L;                                                      /* initialize all remaining potential segments      */
    }
  }
  for (nseg2 = 1L; nseg2 < Num_Segments; nseg2++) {                           /* renumber duplicate segment when identified       */
    if (DROP_SEGMENT_TYPE == Segment_List[nseg2].type) {
      continue;
    }
    for (nseg1 = 0L; nseg1 < nseg2; nseg1++) {                                /* search for candidate in a previous segment       */
      if ((ISEQUAL(Segment_List[nseg2].offset,    Segment_List[nseg1].offset    ))
       && (ISEQUAL(Segment_List[nseg2].rate,      Segment_List[nseg1].rate      ))
       && (ISEQUAL(Segment_List[nseg2].frequency, Segment_List[nseg1].frequency))) {
        Segment_List[nseg1].used1 = Segment_List[nseg1].used1 || Segment_List[nseg2].used1;                      /* combine usage */
        Segment_List[nseg1].used2 = Segment_List[nseg1].used2 || Segment_List[nseg2].used2;
        Segment_List[nseg1].used3 = Segment_List[nseg1].used3 || Segment_List[nseg2].used3;
        newseg[nseg2] = nseg1;                                                /* assign a new number to this segment              */
        Segment_List[nseg2].used1 = false;                                    /* old number is no more used                       */
        Segment_List[nseg2].used2 = false;                                    /* but data are not erased as they will used        */
        Segment_List[nseg2].used3 = false;                                    /* to document the C file                           */
        break;
      }
    }
  }
  for (n = 0L; n < Num_IOs; n++) {                                            /* actualize the segment for each element           */
    IO_List[n].segment     = newseg[IO_List[n].segment];
  }
  for (n = 0L; n < Num_Nodes; n++) {
    Node_List[n].segment   = newseg[Node_List[n].segment];
  }
  for (n = 0L; n < Num_Vars; n++) {
    Var_List[n].segment    = newseg[Var_List[n].segment];
  }
  for (n = 0L; n < Num_Updates; n++) {
    Update_List[n].segment = newseg[Update_List[n].segment];
  }
  for (n = 0L; n < Num_UserTools; n++) {
    UserTool_List[n].segment   = newseg[UserTool_List[n].segment];
  }
  for (n = 0L; n < Num_Posts; n++) {
    Post_List[n].segment   = newseg[Post_List[n].segment];
  }
  Dump_List.segment        = newseg[    Dump_List.segment];
  Gateway_List.segment     = newseg[ Gateway_List.segment];
  Sampling_List.segment    = newseg[Sampling_List.segment];
  return;
}

References DROP_SEGMENT_TYPE, Dump_List, Gateway_List, IO_List, ISEQUAL, MAXSEGMENTS, Node_List, Num_IOs, Num_Nodes, Num_Posts, Num_Segments, Num_Updates, Num_UserTools, Num_Vars, Post_List, Sampling_List, Segment_List, Update_List, UserTool_List, and Var_List.

Referenced by main().

complete_directives()

void complete_directives

(

void

)

Definition at line 310 of file fc.c.

                               {
  if ((UNDEFINED == directive_id("NO_BANNER")) && (UNDEFINED != directive_id("STRICTLY_NO_BANNER"))) {
    strcpy_alloc(&(Directive_List[Num_Directives].name ), "NO_BANNER", NULL, NULL);
    strcpy_alloc(&(Directive_List[Num_Directives].parms), "",          NULL, NULL);
    strcpy_alloc(&(Directive_List[Num_Directives].value), "",          NULL, NULL);
    increment_directive_number("directive");
  }
  return;
}

References directive_id(), Directive_List, increment_directive_number(), Num_Directives, strcpy_alloc(), and UNDEFINED.

Referenced by main().

default_control_variables()

void default_control_variables

(

void

)

Definition at line 184 of file fc.c.

                                     {
  long i;
  char tok[STRLENGTH] = {'\0'};
  NAPA_Compile_Start = ((double) clock()) / ((double) CLOCKS_PER_SEC);
  if (0 != atexit(last_message)) {                                            /* register exit function                           */
    print_error_location("control variables", NULL, NULL);
    (void) fprintf(STDERR,       " Registering 'last_message()' did not succeed\n");
  }
  (void) strcpy(Title_String,    "");                                         /* default of title: empty string                   */
  for (i = 0L; i < MAXCOMMENTS; i++) {
    (void) strcpy(Comment_String[i], "");                                     /* default of comment: empty string                 */
  }
  (void) strcpy(Cmdline_String, "");                                          /* default of command_line parms                    */
  (void) strcpy(I_Format, DEFAULT_I_FORMAT);                                  /* default of output digital format                 */
  (void) strcpy(X_Format, DEFAULT_X_FORMAT);                                  /* default of output digital format (hexa)          */
  (void) strcpy(R_Format, DEFAULT_R_FORMAT);                                  /* default of output analog format                  */
  (void) strcpy(S_Format, DEFAULT_S_FORMAT);                                  /* default of output string format                  */
  (void) strcpy(Last_Instruction, "");                                        /* to trace instruction flow                        */
  (void) strcpy(Last_Postprocess, "");                                        /* to trace postprocess flow                        */
  Sampling_List.frequency = 1.0;                                              /* default of operating frequency                   */
  Seed_List.rndseed       = 0L;                                               /* default of seed for random number                */
  Interlude_List.number1  = 0L;                                               /* default of interlude number                      */
  Interlude_List.number2  = 0L;                                               /* default of interlude number                      */
  Loop_Flag           = true;
  Periodic_Flag       = true;
  Synchro_Flag        = true;
  Antithetic_Flag     = false;
  Array_Flag          = false;
  Assert_Flag         = false;
  Call_Flag           = false;
  Cmdline_Flag        = false;
  Comment_Flag        = false;
  Debug_Flag          = false;
  Delayed_Flag        = false;
  Directive_Flag      = false;
  Drop_Flag           = false;
  Dump_Flag           = false;
  Error_Flag          = false;
  Export_Flag         = false;
  Fs_Ext_Flag         = false;
  Fs_Flag             = false;
  Function_Flag       = false;
  Gateway_Flag        = false;
  Hierarchy_Flag      = false;
  Inject_Flag         = false;
  Input_Flag          = false;
  Interlude_Flag1     = false;
  Interlude_Flag2     = false;
  Interlude_Flag3     = false;
  Interpolate_Flag    = false;
  Load_Flag           = false;
  Multdelay_Flag      = false;
  Option_Flag         = false;
  Output_Flag         = false;
  Ping_Flag           = false;
  Pointer_Flag        = false;
  Post_Flag           = false;
  Seed_Flag           = false;
  Stuck_Flag          = false;
  Terminate_Flag      = false;
  Title_Flag          = false;
  Tool_Flag           = false;
  Tool_Index_Flag     = false;
  Ts_Flag             = false;
  Ts_Ext_Flag         = false;
  Update_Flag         = false;
  User_Flag           = false;
  UserTool_Flag       = false;
  Warning_Flag        = false;
  Num_Aliases         = 0L;
  Num_Arrays          = 0L;
  Num_Asserts         = 0L;
  Num_Calls           = 0L;
  Num_Cells           = 0L;
  Num_Cmdlines        = 0L;
  Num_Comments        = 0L;
  Num_Declare_Commons = 0L;
  Num_Consts          = 0L;
  Num_Creates         = 0L;
  Num_Debugs          = 0L;
  Num_Declares        = 0L;
  Num_Delays          = 0L;
  Max_Depth           = 0L;
  Num_Directives      = 0L;
  Num_Exports         = 0L;
  Num_FileCells       = 0L;
  Num_Functions       = 0L;
  Num_Generators      = 0L;
  Num_Groups          = 0L;
  Num_Headers         = 0L;
  Num_Inits           = 0L;
  Num_Injects         = 0L;
  Num_Instances       = 0L;
  Num_IOs             = 0L;
  Num_Macros          = 0L;
  Num_Nodes           = 0L;
  Num_Nulls           = 0L;
  Num_Opcodes         = 0L;
  Num_Posts           = 0L;
  Num_Records         = 0L;
  Num_Redefs          = 0L;
  Num_Restarts        = 0L;
  Num_Segments        = 0L;
  Num_Stucks          = 0L;
  Num_Tools           = 0L;
  Num_Updates         = 0L;
  Num_UserTools       = 0L;
  Num_Vars            = 0L;
  Num_Voids           = 0L;
  (void) snprintf(Condition_Assign,    (size_t) (LINLENGTH-1L), "%s", "");
  (void) snprintf(Export0_List_String, (size_t) (LINLENGTH-1L), "%s", "");
  (void) snprintf(Export0_Head_String, (size_t) (LINLENGTH-1L), "%s", "");
  (void) snprintf(tok, (size_t)  (STRLENGTH-1L), I_Format, (NAPA_DIGITAL_TYPE) 1LL);  /* eff. string len resulting of this format */
  (void) snprintf(I_String_Format,     (size_t) (STRLENGTH-1L), "%%%lds", LENGTH(tok)-1L);
  (void) snprintf(tok, (size_t)  (STRLENGTH-1L), X_Format, (NAPA_DIGITAL_TYPE) 1LL);  /* eff. string len resulting of this format */
  (void) snprintf(X_String_Format,     (size_t) (STRLENGTH-1L), "%%%lds", LENGTH(tok)-1L);
  (void) snprintf(tok, (size_t)  (STRLENGTH-1L), R_Format, (NAPA_ANALOG_TYPE)  1.0);  /* eff. string len resulting of this format */
  (void) snprintf(R_String_Format,     (size_t) (STRLENGTH-1L), "%%%lds", LENGTH(tok)-1L);
  (void) strcpy(S_String_Format, S_Format);                                           /* eff. string len resulting of this format */
  return;
}

References Antithetic_Flag, Array_Flag, Assert_Flag, Call_Flag, Cmdline_Flag, Cmdline_String, Comment_Flag, Comment_String, Condition_Assign, Debug_Flag, DEFAULT_I_FORMAT, DEFAULT_R_FORMAT, DEFAULT_S_FORMAT, DEFAULT_X_FORMAT, Delayed_Flag, Directive_Flag, Drop_Flag, Dump_Flag, Error_Flag, Export0_Head_String, Export0_List_String, Export_Flag, Fs_Ext_Flag, Fs_Flag, Function_Flag, Gateway_Flag, Hierarchy_Flag, I_Format, I_String_Format, Inject_Flag, Input_Flag, Interlude_Flag1, Interlude_Flag2, Interlude_Flag3, Interlude_List, Interpolate_Flag, Last_Instruction, last_message(), Last_Postprocess, LENGTH, LINLENGTH, Load_Flag, Loop_Flag, Max_Depth, MAXCOMMENTS, Multdelay_Flag, NAPA_ANALOG_TYPE, NAPA_Compile_Start, NAPA_DIGITAL_TYPE, Num_Aliases, Num_Arrays, Num_Asserts, Num_Calls, Num_Cells, Num_Cmdlines, Num_Comments, Num_Consts, Num_Creates, Num_Debugs, Num_Declare_Commons, Num_Declares, Num_Delays, Num_Directives, Num_Exports, Num_FileCells, Num_Functions, Num_Generators, Num_Groups, Num_Headers, Num_Inits, Num_Injects, Num_Instances, Num_IOs, Num_Macros, Num_Nodes, Num_Nulls, Num_Opcodes, Num_Posts, Num_Records, Num_Redefs, Num_Restarts, Num_Segments, Num_Stucks, Num_Tools, Num_Updates, Num_UserTools, Num_Vars, Num_Voids, Option_Flag, Output_Flag, Periodic_Flag, Ping_Flag, Pointer_Flag, Post_Flag, print_error_location(), R_Format, R_String_Format, S_Format, S_String_Format, Sampling_List, Seed_Flag, Seed_List, STDERR, STRLENGTH, Stuck_Flag, Synchro_Flag, Terminate_Flag, Title_Flag, Title_String, Tool_Flag, Tool_Index_Flag, Ts_Ext_Flag, Ts_Flag, Update_Flag, User_Flag, UserTool_Flag, Warning_Flag, X_Format, and X_String_Format.

Referenced by main().

determine_output_segment_rate()

void determine_output_segment_rate

(

void

)

Definition at line 1135 of file fc.c.

                                         {  /* determine the processing rate in function of the nodes and variables to be output  */
  int   ok, always, first, atleastone;
  long  out, seg;
  long  d, m, n, u;
  long  s;
  long  seglist[MAXSEGMENTS];
  char  sgn[2]          = {'\0'};
  char  lst[LINLENGTH]  = {'\0'};
  char  cnd1[LINLENGTH] = {'\0'};
  char  cnd2[LINLENGTH] = {'\0'};
  char  tok[STRLENGTH]  = {'\0'};
  char *str = (char*) NULL;
  for (out = 0L; out < Num_IOs; out++) {                                      /* process output after output                      */
    if (OUTPUT_TYPE != IO_List[out].type) {
      continue;
    }
    for (s = 0L; s < MAXSEGMENTS; s++) {
      seglist[s] = -1L;
    }
    atleastone = false;                                                       /* to detect at least one non constant parameter    */
    always     = false;
    first      = true;
    ok         = false;
    (void) strcpy(lst, IO_List[out].element);
    str    = lst;
    for (;;) {                                                                /* scan token after token in the output list        */
      seg = 0L;
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      m = 0L;
      for (;;) {                                                              /* consider only each updated variables             */
        m++;
        u = update_id(tok, m);                                                /* consider all the updates of a variable           */
        if (UNDEFINED != u)  {
          seg = Update_List[u].segment;
          ok  = true;
        } else {
          break;
        }
        if (!ok) {
          continue;
        }
        atleastone = true;
        if (ISEQUAL(1.0, Segment_List[seg].rate)) {
          always = true;                                                      /* one of the output is full rate                   */
          break;                                                              /* therefore the output rate is at max frequency    */
        }
        if (seglist[seg] != seg) {                                            /* avoid repetition                                 */
          if (first) {
            (void) snprintf(cnd2, (size_t) (LINLENGTH-1L),       "%s_%ld",       "napa_segment_run", seg);
            first = false;
          } else {
            (void) strcpy(cnd1, cnd2);
            (void) snprintf(cnd2, (size_t) (LINLENGTH-1L), "%s || %s_%ld", cnd1, "napa_segment_run", seg);
          }
          seglist[seg] = seg;                                                 /* record identified segment                        */
        }
      }
    }
 
    ok    = false;
    (void) strcpy(lst, IO_List[out].element);
    str   = lst;
    for (;;) {                                                                /* scan token after token in the output list        */
      seg = 0L;
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      n = node_id(tok);
      if (UNDEFINED != n) {
        if ((DC_KIND != Node_List[n].kind) && (CONST_KIND != Node_List[n].kind)) {                         /* ignore constants    */
          seg = Node_List[n].segment;
          ok  = true;
        }
      }
      if (!ok) {
        continue;
      }
      atleastone = true;
      if (ISEQUAL(1.0, Segment_List[seg].rate)) {
        always = true;                                                        /* one of the output is full rate                   */
        break;
      }
      if (seglist[seg] != seg) {                                              /* avoid repetition                                 */
        if (first) {
          (void) snprintf(cnd2, (size_t) (LINLENGTH-1L),       "%s_%ld",       "napa_segment_run", seg);
          first = false;
        } else {
          (void) strcpy(cnd1, cnd2);
          (void) snprintf(cnd2, (size_t) (LINLENGTH-1L), "%s || %s_%ld", cnd1, "napa_segment_run", seg);
        }
      }
      seglist[seg] = seg;                                                     /* record identified segment                        */
    }
    if (!atleastone) {
      (void) strcpy(cnd2, " 0LL == ABS_LOOP_INDEX ");                         /* only constants are output                        */
    }
    if (ISEMPTY(IO_List[out].condition)) {
      if (always) {                                                           /* at least one output is evaluated 'full rate'     */
        (void) strcpy(cnd1, "true");
      } else {
        (void) strcpy(cnd1, cnd2);
      }
    } else {
      if (always) {                                                           /* at least one output is evaluated 'full rate'     */
        (void) snprintf(cnd1, (size_t) (LINLENGTH-1L), "%s",               IO_List[out].condition);
      } else {
        (void) snprintf(cnd1, (size_t) (LINLENGTH-1L), "(%s) && %s", cnd2, IO_List[out].condition);
      }
    }
    strcpy_realloc(&(IO_List[out].condition), cnd1, IO_List[out].mline, IO_List[out].mfile);
    IO_List[out].segment = 0L;                                                /* assign segment 0 to output                       */
    Segment_List[Num_Segments].type       = DECIMATE_SEGMENT_TYPE;
    Segment_List[Num_Segments].ref        = 0L;                               /* referred to main sampling frequency              */
    Segment_List[Num_Segments].frequency  = 0.0;
    Segment_List[Num_Segments].rate       = 1.0;
    Segment_List[Num_Segments].offset     = 0.0;
    Segment_List[Num_Segments].used1      = false;
    Segment_List[Num_Segments].used2      = false;
    Segment_List[Num_Segments].used3      = true;                             /* this new segment contains an output              */
    Segment_List[Num_Segments].periodic   = true;
    for (d = 0L; d < MAXDEPTH; d++) {
      Segment_List[Num_Segments].mline[d] = IO_List[out].mline[d];
      Segment_List[Num_Segments].mfile[d] = IO_List[out].mfile[d];
    }
    increment_segment_number("output");
  }
  return;
}

References CONST_KIND, DC_KIND, DECIMATE_SEGMENT_TYPE, get_sign_and_token(), increment_segment_number(), IO_List, ISEMPTY, ISEQUAL, LINLENGTH, MAXDEPTH, MAXSEGMENTS, node_id(), Node_List, Num_IOs, Num_Segments, OUTPUT_TYPE, Segment_List, strcpy_realloc(), STRLENGTH, UNDEFINED, update_id(), and Update_List.

Referenced by main().

determine_segment_processing_rate()

void determine_segment_processing_rate

(

void

)

Definition at line 1080 of file fc.c.

                                             {
  double rn, sn;
  long   nseg;
  Segment_List[0].frequency = Sampling_List.frequency;                        /* the 'fs' frequency                               */
  Segment_List[0].offset    = 0.0;
  Segment_List[0].rate      = Simulation_Rate;
  for (nseg = 1L; nseg < Num_Segments; nseg++) {
    rn = Segment_List[nseg].rate;
    sn = Segment_List[nseg].offset;
    if (NOMINAL_SEGMENT_TYPE == Segment_List[nseg].type) {                    /* referred to global sampling rate                 */
      Segment_List[nseg].frequency   = Segment_List[0].frequency;
      Segment_List[nseg].rate        = Segment_List[0].rate;
      Segment_List[nseg].offset      = Segment_List[0].offset;
    }
    if (DECIMATE_SEGMENT_TYPE == Segment_List[nseg].type) {                   /* 'decimate': decrease rate                        */
      if (0L == Segment_List[nseg].ref) {                                     /* decreasing referred to previous segment rate     */
        Segment_List[nseg].frequency = Segment_List[nseg-1L].frequency / rn;
        Segment_List[nseg].rate      = Segment_List[nseg-1L].rate * rn;
        Segment_List[nseg].offset    = Segment_List[nseg-1L].offset + (Segment_List[nseg-1L].rate * sn);
      } else {                                                                /* decreasing referred to main loop sampling rate   */
        Segment_List[nseg].frequency = Segment_List[0].frequency / rn;
        Segment_List[nseg].rate      = Segment_List[0].rate * rn;
        Segment_List[nseg].offset    = Segment_List[0].offset + (Segment_List[0].rate * sn);
      }
    }
    if (INTERPOLATE_SEGMENT_TYPE == Segment_List[nseg].type) {                /* 'interpolate': increase rate                     */
      if (0L == Segment_List[nseg].ref) {                                     /* increasing referred to previous segment rate     */
        Segment_List[nseg].frequency = Segment_List[nseg-1L].frequency * rn;
        Segment_List[nseg].rate      = Segment_List[nseg-1L].rate / rn;
        Segment_List[nseg].offset    = Segment_List[nseg-1L].offset;
      } else {                                                                /* increasing referred to main loop sampling rate   */
        Segment_List[nseg].frequency = Segment_List[0].frequency * rn;
        Segment_List[nseg].rate      = Segment_List[0].rate / rn;
        Segment_List[nseg].offset    = Segment_List[0].offset;
      }
    }
    if (DROP_SEGMENT_TYPE == Segment_List[nseg].type) {
      if (0L == Segment_List[nseg].ref) {                                     /* ignore condition, using previous segment rate    */
        Segment_List[nseg].frequency = Segment_List[nseg-1L].frequency;
        Segment_List[nseg].rate      = Segment_List[nseg-1L].rate;
        Segment_List[nseg].offset    = Segment_List[nseg-1L].offset;
      } else {                                                                /* ignore condition, using main loop sampling rate  */
        Segment_List[nseg].frequency = Segment_List[0].frequency;
        Segment_List[nseg].rate      = Segment_List[0].rate;
        Segment_List[nseg].offset    = Segment_List[0].offset;
      }
    }
  }
  for (nseg = 1L; nseg < Num_Segments; nseg++) {
    Segment_List[nseg].offset = fmod(Segment_List[nseg].offset, Segment_List[nseg].rate);
  }
  return;
}

References DECIMATE_SEGMENT_TYPE, DROP_SEGMENT_TYPE, INTERPOLATE_SEGMENT_TYPE, NOMINAL_SEGMENT_TYPE, Num_Segments, Sampling_List, Segment_List, and Simulation_Rate.

Referenced by main().

determine_simulation_rate()

void determine_simulation_rate

(

void

)

Definition at line 1025 of file fc.c.

                                     {
  double numerator[MAXSEGMENTS];
  double denominator[MAXSEGMENTS];
  double gcd, lcm;
  long   nseg;
  /* First segment (could be empty) is always running as specified by the instruction NAPA 'fs' sampling frequency                */
  numerator[0L]   = 1.0;
  denominator[0L] = 1.0;
  /* Determination of the rate of each segment                                                                                    */
  for (nseg = 1L; nseg < Num_Segments; nseg++) {
    if (INTERPOLATE_SEGMENT_TYPE == Segment_List[nseg].type) {
      if (0L == Segment_List[nseg].ref) {                                     /* increase referred to previous segment rate       */
        numerator[nseg]   =   numerator[nseg-1L] * Segment_List[nseg].rate;
        denominator[nseg] = denominator[nseg-1L];
      } else {                                                                /* increase referred to global sampling rate        */
        numerator[nseg]   = Segment_List[nseg].rate;
        denominator[nseg] = 1.0;
      }
    }
    if (DECIMATE_SEGMENT_TYPE == Segment_List[nseg].type)    {
      if (0L == Segment_List[nseg].ref) {                                     /* decrease referred to previous segment rate       */
        numerator[nseg]   =   numerator[nseg-1L];
        denominator[nseg] = denominator[nseg-1L] * Segment_List[nseg].rate;
      } else {                                                                /* decrease referred to global sampling rate        */
        numerator[nseg]   = 1.0;
        denominator[nseg] = Segment_List[nseg].rate;
      }
    }
    if (NOMINAL_SEGMENT_TYPE == Segment_List[nseg].type)     {
      numerator[nseg]   = 1.0;
      denominator[nseg] = 1.0;
    }
    if (DROP_SEGMENT_TYPE == Segment_List[nseg].type)        {                /* no change but a conditional execution            */
      numerator[nseg]   =   numerator[nseg-1L];
      denominator[nseg] = denominator[nseg-1L];
    }
    gcd = GCD(numerator[nseg], denominator[nseg]);
    numerator[nseg]   /= gcd;
    denominator[nseg] /= gcd;
  }
  /* search for the lowest frequency for the simulation loop                                                                      */
  lcm   = 1.0;
  for (nseg = 0L; nseg < Num_Segments; nseg++) {
    if (!((Segment_List[nseg].used1) || (Segment_List[nseg].used2))) {
      continue;
    }
    lcm = LCM(lcm, numerator[nseg]);
  }
  Simulation_Rate = lcm;
  return;
}

References DECIMATE_SEGMENT_TYPE, DROP_SEGMENT_TYPE, GCD(), INTERPOLATE_SEGMENT_TYPE, LCM(), MAXSEGMENTS, NOMINAL_SEGMENT_TYPE, Num_Segments, Segment_List, and Simulation_Rate.

Referenced by main().

expand_dump_definitions()

void expand_dump_definitions

(

void

)

Definition at line 887 of file fc.c.

                                   {
  char *str = (char*) NULL;
  char  tok[STRLENGTH] = {'\0'};
  if (!Dump_Flag) {
    return;
  }
  str = Dump_List.condition;
  if (0 == strcmp(str, "false")) {
    strcpy_alloc(&(Dump_List.condition), "false", Dump_List.mline, Dump_List.mfile);
    return;
  }
  if ((0 == strcmp(str, "true")) || ISEMPTY(str)) {
    strcpy_alloc(&(Dump_List.condition), "true",  Dump_List.mline, Dump_List.mfile);
    return;
  }
  str = get_token(str, tok, true);
  if (ISEMPTY(tok) || (0 != strcmp(tok, "when"))) {
    print_error_location("dump", Dump_List.mline, Dump_List.mfile);
    (void) fprintf(STDERR,       " this instruction must be conditioned by an event\n");
    return;
  }
  (void) process_condition(str, Dump_List.mline, Dump_List.mfile);
  strcpy_alloc(&(Dump_List.condition), str, Dump_List.mline, Dump_List.mfile);
  return;
}

References Dump_Flag, Dump_List, get_token(), ISEMPTY, print_error_location(), process_condition(), STDERR, strcpy_alloc(), and STRLENGTH.

Referenced by main().

expand_IO_definitions()

void expand_IO_definitions

(

void

)

Definition at line 844 of file fc.c.

                                 {
  long  out;
  char *str = (char*) NULL;
  char *s   = (char*) NULL;
  char  tok[STRLENGTH] = {'\0'};
  int   flag;
  for (out = 0L; out < Num_IOs; out++) {
    if (INPUT_TYPE == IO_List[out].type) {
      str = IO_List[out].element;
      do {
        str = get_token(str, tok, true);
        if (0 == strcmp(tok, "when")) {
          print_error_location("input", IO_List[out].mline, IO_List[out].mfile);
          (void) fprintf(STDERR, " this instruction cannot be conditioned by an event\n");
          break;
        }
      } while (ISNOTEMPTY(tok));
      continue;
    }
    if (OUTPUT_TYPE == IO_List[out].type) {
      str = IO_List[out].element;
      do {
        s = str;                                                              /* remember location of 'when' token                */
        str = get_token(str, tok, true);
        if (0 == strcmp(tok, "when")) {
          break;
        }
      } while (ISNOTEMPTY(tok));
      flag = process_condition(str, IO_List[out].mline, IO_List[out].mfile);
      *(s) = '\0';                                                            /* split in value and condition                     */
      if (flag) {
        strcpy_alloc(&(IO_List[out].condition), str, IO_List[out].mline, IO_List[out].mfile);
      } else {
        strcpy_alloc(&(IO_List[out].condition), "",  IO_List[out].mline, IO_List[out].mfile);
      }
    }
  }
  return;
}

References get_token(), INPUT_TYPE, IO_List, ISNOTEMPTY, Num_IOs, OUTPUT_TYPE, print_error_location(), process_condition(), STDERR, strcpy_alloc(), and STRLENGTH.

Referenced by main().

expand_records()

void expand_records

(

void

)

Definition at line 377 of file fc.c.

                          {
  int   n;
  int   nflag, pflag;
  long  i, a, sz, nr, nc;
  long  first;
  char *s  = (char*) NULL;
  char *t1 = (char*) NULL;
  char *t2 = (char*) NULL;
  char  sgn[2] = {'\0'};
  char  tok[STRLENGTH]  = {'\0'};
  char  tok1[STRLENGTH] = {'\0'};
  char  tok2[STRLENGTH] = {'\0'};
  char  buf[LINLENGTH]  = {'\0'};
  char  buf1[LINLENGTH] = {'\0'};
  char  buf2[LINLENGTH] = {'\0'};
  if (0L == Num_Records) {
    return;
  }
  for (i = 0L; i < Num_Records; i++) {
    (void) strcpy(buf, "");
    s  = Record_List[i].list1;                                                /* list of parameters                               */
    sz = Record_List[i].size;
    nr = Record_List[i].nrow;
    nc = Record_List[i].ncol;
    first = true;
    for (;;) {
      s = get_sign_and_token(s, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      a = record_id(tok);
      if (UNDEFINED == a) {                                                   /* atom of the array                                */
        (void) strcat(buf, sgn);
        (void) strcat(buf, tok);
        (void) strcat(buf, " ");
        continue;
      }
      (void) strcat(buf, Record_List[a].list1);                               /* expand array                                     */
      (void) strcat(buf, " ");
      if (0L == Record_List[a].size) {
        sz = 0L;                                                              /* array with undefined size                        */
        nr = 0L;
        nc = 0L;
      } else {
        sz += Record_List[a].size - 1L;
        if ((!first) && (nc != Record_List[a].ncol)) {                        /* not rectangular                                  */
          nr = 1L;
          nc = sz;
        } else {
          if (!first) {
            nr++;
          }
          nc = Record_List[a].ncol;
        }
        first = false;
      }
    }
    clean_line(buf);
    strcpy_realloc(&(Record_List[i].list1), buf, Record_List[i].mline, Record_List[i].mfile);
    strcpy_realloc(&(Record_List[i].list2), buf, Record_List[i].mline, Record_List[i].mfile);
    Record_List[i].size = sz;                                                 /* new size                                         */
    Record_List[i].nrow = nr;
    if (0L != nr) {
      Record_List[i].ncol = sz / nr;                                          /* keep dimensions to 2 by flattening subarrays     */
    } else {
      Record_List[i].ncol = sz;
    }
  }
  for (i = 0L; i < Num_Records; i++) {
    s = Record_List[i].list1;                                                 /* list of parameters                               */
    n = 0;
    (void) strcpy(buf1, "");
    (void) strcpy(buf2, "");
    nflag = true;
    pflag = true;
    for (;;) {
 
      s = get_sign_and_token(s, sgn, tok1);
      (void) strcpy(tok,  sgn);
      (void) strcat(tok, tok1);
 
      if (ISEMPTY(tok)) {
        break;
      }
      (void) strcpy(tok1, tok);
      (void) strcpy(tok2, tok);
      t1 = strstr(tok1, "::");
      t2 = strstr(tok2, "::");
      if ((char*) NULL != t1) {
        pflag = false;
        nflag = nflag && true;
        (void) strcpy(tok1, t1+2);                                            /* passing by name, extract var for verification     */
        clean_line(tok1);
        (void) strcat(buf1, tok1);
        (void) strcat(buf1, " " );
        *t2 = '\0';
        (void) strcat(buf2, tok2);
        (void) strcat(buf2, " " );
      } else {                                                                /* passing by position                              */
        nflag = false;
        pflag = pflag && true;
        clean_line(tok1);
        (void) strcat(buf1, tok1);
        (void) strcat(buf1, " " );
        (void) snprintf(tok2, (size_t) (STRLENGTH-1L), "%d ", n);
        (void) strcat(buf2, tok2);
        n++;
      }
    }
    if (!(pflag || nflag)) {
      print_error_location("record", Record_List[i].mline, Record_List[i].mfile);
      (void) fprintf(STDERR,     " inconsistant parameters passing: by position or by name?\n");
    }
    Record_List[i].nflag = nflag;
    Record_List[i].pflag = pflag;
    clean_line(buf1);
    clean_line(buf2);
    strcpy_realloc(&(Record_List[i].list1), buf1, Record_List[i].mline, Record_List[i].mfile);
    strcpy_realloc(&(Record_List[i].list2), buf2, Record_List[i].mline, Record_List[i].mfile);
  }
  return;
}

References clean_line(), get_sign_and_token(), ISEMPTY, LINLENGTH, Num_Records, print_error_location(), record_id(), Record_List, STDERR, strcpy_realloc(), STRLENGTH, and UNDEFINED.

Referenced by main().

expand_string_variables()

void expand_string_variables

(

void

)

Definition at line 323 of file fc.c.

                                   {
  long  i, len;
  char *str = (char*) NULL;
  char  tok[LINLENGTH] = {'\0'};
  if (0L < Num_Vars) {
    for (i = 0L; i < Num_Vars; i++) {
      if (STRING_DATA_TYPE == Var_List[i].type) {
        (void) strcpy(tok, Var_List[i].value);
        expand_indirections(tok);
        if (0 != strcmp(tok, Var_List[i].value)) {
          strcpy_realloc(&(Var_List[i].value), tok, Var_List[i].mline, Var_List[i].mfile);
        }
      }
      str = Var_List[i].value;
      do {
        str = get_token(str, tok, true);
        if (0 == strcmp(tok, "when")) {
          print_error_location("var", Var_List[i].mline, Var_List[i].mfile);
          (void) fprintf(STDERR, " the definition of a variable cannot be conditioned by an event\n");
          break;
        }
      } while (ISNOTEMPTY(tok));
    }
  }
  expand_indirections(Title_String);                                          /* title is always expanded after variables         */
  (void) strcpy(Short_Title_String, Title_String);
  i = 0L;
  while ('\0' != Title_String[i]) {                                           /* extract first line of title                      */
    if (('/' == Title_String[i]) && ('n' == Title_String[i+1L])) {            /* the '\' was converted in '/'                     */
      Short_Title_String[i] = '\0';
      Title_String[i] = '\\';                                                 /* restore the '\'                                  */
    } else {
      Short_Title_String[i] = Title_String[i];
    }
    i++;
  }
  if (Comment_Flag) {
    len = 0L;
    for (i = 0L; i < Num_Comments; i++) {
      expand_indirections(Comment_String[i]);                                 /* comment is always expanded after variables       */
      len = MAX(LENGTH(Comment_String[i]), len);
    }
    len += 1L;
    for (i = 0L; i < Num_Comments; i++) {
      (void) strcpy(tok, Comment_String[i]);
      (void) snprintf(Comment_String[i], (size_t) (LINLENGTH-1L), "%s%*s", tok, (int) (len-LENGTH(tok))," ");
    }
  }
  return;
}

References Comment_Flag, Comment_String, expand_indirections(), get_token(), ISNOTEMPTY, LENGTH, LINLENGTH, MAX, Num_Comments, Num_Vars, print_error_location(), Short_Title_String, STDERR, strcpy_realloc(), STRING_DATA_TYPE, Title_String, and Var_List.

Referenced by main().

expand_update_definitions()

void expand_update_definitions

(

void

)

Definition at line 777 of file fc.c.

                                     {
  long  out;
  long  v;
  char *str = (char*) NULL;
  char *nam = (char*) NULL;
  char *s   = (char*) NULL;
  char  tok[STRLENGTH] = {'\0'};
  int   flag;
  for (out = 0L; out < Num_Updates; out++) {
    nam = Update_List[out].name;                                              /* search also for alias                            */
    if ((0 == strncmp(nam, "$call$",    (size_t) 6))
     || (0 == strncmp(nam, "$null$",    (size_t) 6))
     || (0 == strncmp(nam, "$restart$", (size_t) 9))) {
      strcpy_alloc(&(Update_List[out].condition), "", Update_List[out].mline, Update_List[out].mfile);
      continue;
    }
    if ((UNDEFINED == var_id(nam)) && (0 != strncmp(nam, "$assert$", (size_t) 8))) {
      print_error_location("update", Update_List[out].mline, Update_List[out].mfile);
      (void) fprintf(STDERR,     " variable to be updated <%s> does not exist!\n", nam );
      process_variable_error(nam);
      continue;
    }
    if (STRING_DATA_TYPE == Var_List[var_id(nam)].type) {
      print_error_location("update", Update_List[out].mline, Update_List[out].mfile);
      (void) fprintf(STDERR,     " string <%s>: a string cannot be updated!", nam      );
      continue;
    }
    str = Update_List[out].value;
    do {
      s = str;                                                                /* remember location of 'when' token                */
      str = get_token(str, tok, true);
      if (0 == strcmp(tok, "when")) {
        if (Update_List[out].event) {
          print_error_location("event", Update_List[out].mline, Update_List[out].mfile);
          (void) fprintf(STDERR, " an event cannot be conditioned\n");
          continue;
        }
        break;
      }
    } while (ISNOTEMPTY(tok));
    flag = process_condition(str, Update_List[out].mline, Update_List[out].mfile);
    *(s) = '\0';                                                              /* split in value and condition                     */
 
    if (flag) {
      strcpy_alloc(&(Update_List[out].condition), str, Update_List[out].mline, Update_List[out].mfile);
    } else {
      strcpy_alloc(&(Update_List[out].condition),  "", Update_List[out].mline, Update_List[out].mfile);
    }
    clean_line(Update_List[out].value);
    /* if update value is empty, use the definition of the corresponding variable                                                 */
    if (ISEMPTY(Update_List[out].value)) {
      v = var_id(Update_List[out].name);
      if (UNDEFINED != v) {
        strcpy_realloc(&(Update_List[out].value), Var_List[v].value, Update_List[out].mline, Update_List[out].mfile);
      } else {                                                                /* should never occur                               */
        print_error_location("update", Update_List[out].mline, Update_List[out].mfile);
        (void) fprintf(STDERR,   " no update expansion, as variable to be updated does not exist\n");
      }
    }
  }
  return;
}

References clean_line(), get_token(), ISEMPTY, ISNOTEMPTY, Num_Updates, print_error_location(), process_condition(), process_variable_error(), STDERR, strcpy_alloc(), strcpy_realloc(), STRING_DATA_TYPE, STRLENGTH, UNDEFINED, Update_List, var_id(), and Var_List.

Referenced by main().

f2printf()

long f2printf	(	FILE *	fp1,
		FILE *	fp2,
		char *	fmt,
			... )

Definition at line 157 of file fc.c.

                                                    {
  va_list argp;
  long n1 = 0L;
  long n2 = 0L;
  if ((FILE*) NULL != fp1) {
    va_start(argp, fmt);
    n1 = vfprintf(fp1, fmt, argp);
    va_end(argp);
  }
  if (fp1 == fp2) {
    return n1;
  }
  if ((FILE*) NULL != fp2) {
    va_start(argp, fmt);
    n2 = vfprintf(fp2, fmt, argp);
    va_end(argp);
  }
  return MAX(n1, n2);
}

References MAX.

Referenced by build_cross_reference(), get_data(), and line_parsing().

GCD()

double GCD	(	double	a,
		double	b )

Definition at line 1378 of file fc.c.

                               {
  if (a < b) {
    return GCD(b, a);
  }
  if (_SMALL_ >= b) {
    return a;
  } else {
    return GCD(b, fmod(a, b));
  }
}

References _SMALL_, and GCD().

Referenced by declare_global_values(), determine_simulation_rate(), GCD(), LCM(), and reset_simulator_variables().

get_a_line()

char * get_a_line	(	char *	buf,
		unsigned long *	nl,
		FILE *	fp,
		unsigned long *	mlin,
		const unsigned long *	mfil )

Definition at line 100 of file fc.c.

                                                                                                         {
  static char  tok[LINLENGTH + 1L] = {'\0'};
  static char *p = (char*) NULL;
  long   len;
  int    continue_on_next_line;
  (void) strcpy(buf, "");
  *nl = 0UL;
  do {
    p = fgets(tok, LINLENGTH, fp);                                            /* read a line from the input file                  */
    if ((char*) NULL == p) {
      if (0UL < *nl) {
        *mlin = *mlin + *nl;
        print_error_location("continuation line", mlin, mfil);
        (void) fprintf(STDERR,   " end of file is detected although a new line was expected\n");
        print_error_banner_and_exit();
      }
      break;
    }
    clean_line(tok);                                                          /* clear comments, process tabs, end of line spaces */
    len = LENGTH(tok);
    (*nl)++;
    if ((1UL < *nl) && (0L == len)) {                                         /* many subtle errors undetected if authorized!!!   */
      *mlin = *mlin + *nl;
      print_error_location("continuation line", mlin, mfil);
      (void) fprintf(STDERR,     " 'all blank' or 'all comment' lines are not allowed inside an instruction\n");
      print_error_banner_and_exit();
    }
    if (3L <= len) {
      continue_on_next_line = (int) (('.' == tok[len-3L]) && ('.' == tok[len-2L]) && ('.' == tok[len-1L]));
      /* could be true or false!*/
    } else {
      continue_on_next_line = false;
    }
    if (continue_on_next_line) {
      tok[len-3L] = ' ';
      tok[len-2L] = '\0';
      clean_line(tok);
    }
    if ((LENGTH(buf) + LENGTH(tok)) > LINLENGTH) {
      *mlin = *mlin + *nl;
      print_error_location("instruction", mlin, mfil);
      (void) fprintf(STDERR,     " the length of instruction exceeds maximum length (%ld)\n", LINLENGTH);
      print_limits();
      print_error_banner_and_exit();
    }
    if (1L < *nl) {                                                           /* insert blank before concatenating instr. lines   */
      (void) strcat(buf, " ");
    }
    (void) strcat(buf, tok);
  } while (continue_on_next_line);
  expand_iterative_identifiers(buf, mlin, mfil);                              /* iterative identifiers by extension               */
  return p;
}

References clean_line(), expand_iterative_identifiers(), LENGTH, LINLENGTH, print_error_banner_and_exit(), print_error_location(), print_limits(), and STDERR.

Referenced by get_data(), line_parsing(), and process_cell().

last_message()

void last_message

(

void

)

Definition at line 1552 of file fc.c.

                        {                                                     /* this function is registered with 'atexit'        */
  if (0 != Error_Flag) {
    (void) fprintf(STDERR,     "\n ****\n"    );
    (void) fprintf(STDERR,       " ****  NAPA Compilation Error(s)\n");
    (void) fprintf(STDERR,       " ****\n\n\n");
  }
  (void) f1flush((FILE*) NULL);                                               /* flush ALL stream outputs                         */
  return;
}

References Error_Flag, f1flush(), and STDERR.

Referenced by default_control_variables().

LCM()

double LCM	(	double	n1,
		double	n2 )

Definition at line 1392 of file fc.c.

                                 {
  return ((n1 / GCD(n1, n2)) * n2);                                           /* ordered operation to avoid possible overflow !   */
}

References GCD().

Referenced by determine_simulation_rate().

print_error_location()

void print_error_location	(	const char *	type,
		const unsigned long *	mlin,
		const unsigned long *	mfil )

Definition at line 1476 of file fc.c.

                                                                                                  {
  print_problem_location(type, mlin, mfil, "Error"  );
  (void) fprintf(STDERR,       "\n");
  Error_Flag++;
  return;
}

References Error_Flag, print_problem_location(), and STDERR.

Referenced by authorize_option(), build_condition(), build_input(), build_main_loop_inject(), build_name(), build_node(), build_node_dependencies(), build_output(), build_pathname(), build_record_dependencies(), build_update(), build_update_dependencies(), build_usage_comment(), build_var_dependencies(), C_syntax_checker(), cat_file(), check_option_function(), check_syntax(), check_types(), check_version(), collect_export_definitions(), collect_string_of_options(), create_automatic_node(), create_nodes(), declaration_type_A(), declaration_type_B(), declare_a_digital_node(), declare_an_analog_node(), declare_vars(), default_control_variables(), dump_function(), expand_dump_definitions(), expand_IO_definitions(), expand_iterative_identifiers(), expand_nodeset(), expand_records(), expand_string_variables(), expand_update_definitions(), f1flush(), get_a_line(), get_alias(), get_array(), get_assert(), get_call(), get_command_line(), get_comment(), get_data(), get_debug(), get_decimate(), get_declare(), get_directive(), get_drop(), get_dump(), get_export(), get_format(), get_fs_ts(), get_gateway(), get_header(), get_init(), get_inject(), get_input(), get_interlude(), get_interpolate(), get_load(), get_node(), get_nominal(), get_opcode(), get_output(), get_ping(), get_post(), get_random_seed(), get_restart(), get_sampling(), get_stuck(), get_synchronize(), get_terminate(), get_update(), get_var(), get_void(), include_napa_header_files(), inject_nodes(), inspect_short_form(), line_parsing(), node_determination(), node_id(), open_IO_files(), open_ping_file(), print_adc(), print_algebra(), print_alu(), print_bshift(), print_btoi(), print_C_code_banner_b(), print_dac(), print_delay(), print_dyadic7(), print_mux(), print_output_banner_2(), print_quant(), print_rip(), print_rlshift(), print_rshift1(), print_rshift2(), print_test(), print_uadc(), print_udac(), print_usertool(), print_zero(), process_aliases(), process_cell(), process_cell_line(), process_condition(), process_gen(), process_width(), purge_constants_in_options(), read_doub_format(), read_hex_format(), read_int_format(), read_str_format(), rearrange_data_interfaces(), record_cell_nam(), record_file_nam(), record_function_identifier(), redefine_node_segments(), redefine_nodes(), reset_a_dc_node(), reset_a_digital_node(), reset_an_analog_node(), reset_arrays_function(), reset_user_variables(), sanity_check(), something_else(), strcpy_alloc(), strcpy_realloc(), stuck_nodes(), syntax_command_line(), syntax_directives(), syntax_nodes(), syntax_records(), syntax_segment_value(), syntax_terminate(), syntax_updates(), syntax_variables(), trap_unconsistencies(), and var_id().

print_info_location()

void print_info_location	(	const char *	type,
		const unsigned long *	mlin,
		const unsigned long *	mfil )

Definition at line 1491 of file fc.c.

                                                                                                 {
  print_problem_location(type, mlin, mfil, "Note"   );
  return;
}

References print_problem_location().

print_limits()

void print_limits

(

void

)

Definition at line 56 of file fc.c.

                        {
  (void) fprintf(STDERR,     "\n\nCURRENT LIMITATION OF THE NAPA COMPILER:\n\n"                          );
  (void) fprintf(STDERR,         "  max number of nodes                    = %6ld\n",   MAXNODES         );
  (void) fprintf(STDERR,         "  max number of variables                = %6ld\n",   MAXVARS          );
  (void) fprintf(STDERR,         "  max number of updates                  = %6ld\n",   MAXUPDATES       );
  (void) fprintf(STDERR,         "  max number of arrays of pointers       = %6ld\n",   MAXRECORDS       );
  (void) fprintf(STDERR,         "  max number of instantiation of cells   = %6ld\n",   MAXINSTANCES     );
  (void) fprintf(STDERR,         "  max number of declarations             = %6ld\n",   MAXDECLARES      );
  (void) fprintf(STDERR,         "  max number of common declarations      = %6ld\n",   MAXDECLARECOMMONS);
  (void) fprintf(STDERR,         "  max number of opcodes                  = %6ld\n",   MAXOPCODES       );
  (void) fprintf(STDERR,         "  max number of cell file names recorded = %6ld\n",   MAXFILECELLS     );
  (void) fprintf(STDERR,         "  max number of functions to be recorded = %6ld\n",   MAXFUNCTIONS     );
  (void) fprintf(STDERR,         "  max number of options to be recorded   = %6ld\n",   MAXOPTIONS       );
  (void) fprintf(STDERR,         "  max number of user's defined functions = %6ld\n",   MAXUSERTOOLS     );
  (void) fprintf(STDERR,         "  max number of postprocessing functions = %6ld\n",   MAXPOSTS         );
  (void) fprintf(STDERR,         "  max number of inject to nodes          = %6ld\n",   MAXINJECTS       );
  (void) fprintf(STDERR,         "  max number of IO streams               = %6ld\n",   MAXIOS           );
  (void) fprintf(STDERR,         "  max number of open files (simulation)  = %6ld\n",   MAXFILES         );
  (void) fprintf(STDERR,         "  max number of headers                  = %6ld\n",   MAXHEADERS       );
  (void) fprintf(STDERR,         "  max number of directives               = %6ld\n",   MAXDIRS          );
  (void) fprintf(STDERR,         "  max number of cell parameters          = %6ld\n",   MAXPARMS         );
  (void) fprintf(STDERR,         "  max number of nodes stuck to a value   = %6ld\n",   MAXSTUCKS        );
  (void) fprintf(STDERR,         "  max number of command line parameters  = %6ld\n",   MAXCMDLINES      );
  (void) fprintf(STDERR,         "  max number of aliases                  = %6ld\n",   MAXALIASES       );
  (void) fprintf(STDERR,         "  max number of arrays                   = %6ld\n",   MAXARRAYS        );
  (void) fprintf(STDERR,         "  max number of simulation segments      = %6ld\n",   MAXSEGMENTS      );
  (void) fprintf(STDERR,         "  max number of exported variables       = %6ld\n\n", MAXEXPORTS       );
  (void) fprintf(STDERR,         "  max depth for cell hierarchy           = %6ld\n\n", MAXDEPTH         );
  (void) fprintf(STDERR,         "  max length of strings and tokens       = %6ld\n",   STRLENGTH        );
  (void) fprintf(STDERR,         "  max length of instructions             = %6ld\n\n", LINLENGTH        );
  (void) fprintf(STDERR,         "These limitations can be changed by a new compilation of the\n"        );
  (void) fprintf(STDERR,         "sources after reworking the limits in source file 'napa.h'. \n"        );
  (void) fprintf(STDERR,         "Please contact the author,   yves.leduc.be@gmail.com        \n\n"      );
 
  return;
}

References LINLENGTH, MAXALIASES, MAXARRAYS, MAXCMDLINES, MAXDECLARECOMMONS, MAXDECLARES, MAXDEPTH, MAXDIRS, MAXEXPORTS, MAXFILECELLS, MAXFILES, MAXFUNCTIONS, MAXHEADERS, MAXINJECTS, MAXINSTANCES, MAXIOS, MAXNODES, MAXOPCODES, MAXOPTIONS, MAXPARMS, MAXPOSTS, MAXRECORDS, MAXSEGMENTS, MAXSTUCKS, MAXUPDATES, MAXUSERTOOLS, MAXVARS, STDERR, and STRLENGTH.

Referenced by build_name(), get_a_line(), get_data(), increment_alias_number(), increment_array_number(), increment_assert_number(), increment_call_number(), increment_cmdline_number(), increment_comment_number(), increment_common_number(), increment_debug_number(), increment_declare_number(), increment_directive_number(), increment_export_number(), increment_filecell_number(), increment_function_number(), increment_group_number(), increment_header_number(), increment_init_number(), increment_inject_number(), increment_instance_number(), increment_IO_number(), increment_node_number(), increment_opcode_number(), increment_post_number(), increment_record_number(), increment_restart_number(), increment_segment_number(), increment_stuck_number(), increment_tool_number(), increment_update_number(), increment_usertool_number(), increment_var_number(), process_cell(), process_cell_line(), process_command_line(), and process_gen().

print_location()

void print_location	(	const unsigned long *	mlin,
		const unsigned long *	mfil )

Definition at line 1510 of file fc.c.

                                                                          {
  long d;
  if (((unsigned long*) NULL == mlin) || ((unsigned long*) NULL == mfil)) {
    return;
  }
  if (0UL == mlin[0]) {
    return;
  }
  (void) fprintf(STDERR,         " -> at line %3lu of main netlist\n", mlin[0]);
  for (d = 1L; d < MAXDEPTH; d++) {
    if (0UL == mlin[d]) {
      (void) fprintf(STDERR,     "   ");
      return;
    }
    (void) fprintf(STDERR,       " -> at line %3lu of file \"%s\"\n",  mlin[d], Record_Cell_File_Table[mfil[d]]);
  }
  (void) f1flush((FILE*) NULL);                                               /* flush ALL stream outputs                         */
  return;
}

References f1flush(), MAXDEPTH, Record_Cell_File_Table, and STDERR.

Referenced by declaration_type_A(), get_alias(), get_array(), get_command_line(), get_directive(), get_fs_ts(), get_node(), get_sampling(), get_var(), print_problem_location(), reset_a_digital_node(), reset_an_analog_node(), and syntax_command_line().

print_problem_location()

void print_problem_location	(	const char *	type,
		const unsigned long *	mlin,
		const unsigned long *	mfil,
		const char *	kind )

Definition at line 1497 of file fc.c.

                                                                                                                      {
  char tok[STRLENGTH] = {'\0'};
  if (0 == strcmp(type, "")) {
    (void) strcpy(tok, "");
  } else {
    (void) snprintf(tok, (size_t) (STRLENGTH-1L), " (%s)", type);
  }
  (void) fprintf(STDERR,       "\nNAPA %s: %s\n", kind, tok);
  print_location(mlin, mfil);
  return;
}

References print_location(), STDERR, and STRLENGTH.

Referenced by print_error_location(), print_info_location(), and print_warning_location().

print_warning_location()

void print_warning_location	(	const char *	type,
		const unsigned long *	mlin,
		const unsigned long *	mfil )

Definition at line 1484 of file fc.c.

                                                                                                    {
  print_problem_location(type, mlin, mfil, "Warning");
  Warning_Flag = true;
  return;
}

References print_problem_location(), and Warning_Flag.

Referenced by build_input(), build_main_loop(), build_update(), check_types(), check_version(), declare_vars(), get_alias(), get_assert(), get_command_line(), get_debug(), get_decimate(), get_declare(), get_directive(), get_drop(), get_dump(), get_format(), get_fs_ts(), get_gateway(), get_header(), get_interlude(), get_interpolate(), get_load(), get_node(), get_nominal(), get_ping(), get_post(), get_random_seed(), get_restart(), get_sampling(), get_synchronize(), get_terminate(), get_title(), get_var(), get_void(), line_parsing(), node_determination(), print_dyadic0(), print_dyadic7(), print_ram(), print_rom(), print_wsum(), read_doub_format(), read_hex_format(), read_int_format(), read_str_format(), redefine_nodes(), reset_user_variables(), syntax_command_line(), syntax_fs(), and trap_unconsistencies().

process_aliases()

void process_aliases

(

void

)

Definition at line 1328 of file fc.c.

                           {
  long  i, j, id;
  char  tok[STRLENGTH] = {'\0'};
  char *s = (char*) NULL;
  /* nodes and variables                                                                                                          */
  for (i = 0L; i < Num_Aliases; i++) {
    s = Alias_List[i].aliasof;                                                /* node or variable target of the alias             */
    (void) snprintf(tok, (size_t) (STRLENGTH-1L), "%s", s);
    id = node_id(tok);
    if (UNDEFINED != id) {
      if (Node_List[id].aliased) {                                            /* alias != name                                    */
        print_error_location("alias", Alias_List[i].mline, Alias_List[i].mfile);
        (void) fprintf(STDERR,   "    <%s> cannot be an alias of node <%s>,",     Alias_List[i].name, tok  );
        (void) fprintf(STDERR,   " as <%s> is already an alias\n",                Node_List[id].name1      );
        continue;
      }
      Node_List[id].aliased = true;
      strcpy_realloc(&(Node_List[id].name1), Alias_List[i].name, Alias_List[i].mline, Alias_List[i].mfile);
      continue;
    }
    id = var_id(tok);
    if (UNDEFINED != id) {
      if (Var_List[id].aliased) {                                             /* alias != name                                    */
        print_error_location("alias", Alias_List[i].mline, Alias_List[i].mfile);
        (void) fprintf(STDERR,   "    <%s> cannot be an alias of variable <%s>,", Alias_List[i].name, tok);
        (void) fprintf(STDERR,   " as <%s> is already an alias\n",                Var_List[id].name1     );
        continue;
      }
      Var_List[id].aliased = true;
      strcpy_realloc(&(Var_List[id].name1), Alias_List[i].name, Alias_List[i].mline, Alias_List[i].mfile);
      continue;
    }
    print_error_location("alias", Alias_List[i].mline, Alias_List[i].mfile);
    (void) fprintf(STDERR,       " no node and no variable correspond to target <%s> of alias <%s>\n", tok, Alias_List[i].name);
    process_node_error(tok);
    process_variable_error(tok);
  }
  /* command_line                                                                                                                 */
  for (i = 0L; i < Num_Cmdlines; i++) {                                       /* rework the line of parms                         */
    j = var_id(Cmdline_List[i].parms);
    if (UNDEFINED != j) {
      strcpy_realloc(&(Cmdline_List[i].parms), Var_List[j].name1, Cmdline_List[i].mline, Cmdline_List[i].mfile);
    }
  }
  return;
}

References Alias_List, Cmdline_List, node_id(), Node_List, Num_Aliases, Num_Cmdlines, print_error_location(), process_node_error(), process_variable_error(), STDERR, strcpy_realloc(), STRLENGTH, UNDEFINED, var_id(), and Var_List.

Referenced by main().

process_condition()

long process_condition	(	char *	str,
		const unsigned long *	mlin,
		const unsigned long *	mfil )

Definition at line 916 of file fc.c.

                                                                                        {
  long  in;
  char *s = (char*) NULL;
  char  sgn[2]         = {'\0'};
  char  brc[3]         = {'\0'};
  char  tok[LINLENGTH] = {'\0'};
  int   cond;
  cond = false;
  if (ISEMPTY(str)) {
    return false;
  }
  C_syntax_checker(str, mlin, mfil);
  while (ISNOTEMPTY(str)) {
    s = str;
    str = get_token_between_braces(str, brc, tok);
    if ((0 == strcmp(brc, "()")) && (0 == strcmp(tok, "new"))) {
      str = s;
    }
    str = get_sign_and_token(str, sgn, tok);
    in = node_id(tok);
    if (UNDEFINED != in) {
      print_error_location("condition", mlin, mfil);
      (void) fprintf(STDERR,     "<%s> cannot be a node but an event\n", tok);
      break;
    }
    in = var_id(tok);
    if ((UNDEFINED == in) && (isalpha((int) *tok))) {
      print_error_location("condition", mlin, mfil);
      (void) fprintf(STDERR,     "<%s>? Only events and operators on boolean are allowed in a condition\n", tok);
      break;
    }
    if ((UNDEFINED != in) && (!Var_List[in].event)) {
      print_error_location("condition", mlin, mfil);
      (void) fprintf(STDERR,     " <%s> cannot be a variable but an event\n", tok);
      break;
    }
    cond = true;
  }
  return cond;
}

References C_syntax_checker(), get_sign_and_token(), get_token_between_braces(), ISEMPTY, ISNOTEMPTY, LINLENGTH, node_id(), print_error_location(), STDERR, UNDEFINED, var_id(), and Var_List.

Referenced by expand_dump_definitions(), expand_IO_definitions(), and expand_update_definitions().

process_error_if_any()

void process_error_if_any

(

void

)

Definition at line 1467 of file fc.c.

                                {
  (void) f1flush((FILE*) NULL);
  if (0 != Error_Flag) {
    print_error_banner_and_exit();
  }
  return;
}

References Error_Flag, f1flush(), and print_error_banner_and_exit().

Referenced by main().

test_endianness()

int test_endianness

(

void

)

Definition at line 1537 of file fc.c.

                          {
  short int word = (short int) 0X0001LL;
  char     *byte = (char*) &word;
  return byte[0] ? LITTLE_ENDIAN : BIG_ENDIAN;
}

References BIG_ENDIAN, and LITTLE_ENDIAN.

Referenced by define_macros().

verify_rshift()

int verify_rshift

(

void

)

Definition at line 1400 of file fc.c.

                        {
  long n1, n2;
  n1 = -0X0500L;
  n2 = n1 >> 2;    /* "Shifting a negative value is undefined behavior" : this is exactly the trick here to verify the platform ! */
  return ((0L != n2) ? true : false);
}

Referenced by print_C_code_banner_a(), and syntax_nodes().

wall_clock()

void wall_clock

(

void

)

Definition at line 1544 of file fc.c.

                      {
  NAPA_Compile_Stop = ((double) clock())/((double) CLOCKS_PER_SEC);
  (void) fprintf(STDERR,       "\n      wall clock: %6.3f s\n\n", (NAPA_Compile_Stop - NAPA_Compile_Start));
  (void) f1flush((FILE*) NULL);                                               /* flush ALL stream outputs                         */
  return;
}

References f1flush(), NAPA_Compile_Start, NAPA_Compile_Stop, and STDERR.