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

Go to the documentation of this file.

/* ** SORT RECORDS, UPDATES and VARIABLES *************************************************************************************** */
 
#undef  EXTERN
#define EXTERN extern
 
#include "./napa.h"
#include "./proto.h"
 
 
/* *** In this file: ************************************************************************************************************ */
 
/* void build_record_dependencies(void)                                                                                           */
/* void build_update_dependencies(void)                                                                                           */
/* void build_var_dependencies(void)                                                                                              */
/* void sort_records(void)                                                                                                        */
/* void sort_updates(void)                                                                                                        */
/* void sort_vars(void)                                                                                                           */
 
 
/* ****************************************************************************************************************************** */
 
/* "sort_vars" will rearrange the list of vars to guarantee a correct order of definition. No circular definiton is expected.     */
 
/* A variable is determined if it is not depending on any other variables, or if it is depending on determined variables only.    */
/* It is assumed that no variable is determined at the beginning of the process. A pointer is set to the first entry at start.    */
 
/* This process is awfully long as soon as the number of variables becomes large.                                                 */
/* A thousand of variables is enough to slow down significantly the sorting process.                                              */
 
/* "sort_updates" and "sort_records" are using a similar algorithm.                                                               */
 
 
/* ****************************************************************************************************************************** */
 
/* Build the list of variable dependencies, smash directives if any.                                                              */
/* Directives are smashed to detect non obvious dependencies                                                                      */
 
/* List of dependencies is a list of ID corresponding to variables in the var definition.                                         */
 
void build_var_dependencies(void) {
  long in, out;
  long *p   = (long*) NULL;
  char *str = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
  char sgn[2]         = {'\0'};
  long num;
 
  for (out = 0L; out < Num_Vars; out++) {                                     /* analyze each var, one by one for dependencies    */
    num = 0L;
    str = Var_List[out].value;
    for (;;) {                                                                /* count the number of var in the var definition    */
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      in = var_id(tok);
      if (UNDEFINED != in) {
        num++;
      }
    }
    Var_List[out].depend = (long*) malloc((size_t) ((long) sizeof (long) * (num+1L)));
    if ((long*) NULL == Var_List[out].depend) {
      print_error_location("variable dependency", Var_List[out].mline, Var_List[out].mfile);
      (void) fprintf(STDERR, " dynamic memory allocation error\n");
      print_error_banner_and_exit();
    }
    p   = Var_List[out].depend;
    str = Var_List[out].value;
    for (;;) {
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      in = var_id(tok);
      if (UNDEFINED != in) {
        *p = Var_List[in].ID;                                                 /* add variable ID to dependency list               */
        p++;
      }
    }
    *p = -1L;                                                                 /* to terminate the array                           */
  }
  return;
}
 
 
/* Build the list of update variable dependencies, smash directives if any. Don't forget that if the update value is empty,       */
/* variable definition must be USED!An update value can contain a reference to the variable itself!                               */
/* Directives are smashed to detect non obvious dependencies.                                                                     */
 
/* List of dependencies is a list of ID corresponding to variables in the update definition AND in the update condition!!         */
 
void build_update_dependencies(void) {
  long in, out;
  long *p   = (long*) NULL;
  char *str = (char*) NULL;
  char *nam = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
  char buffer[LINLENGTH] = {'\0'};
  char sgn[2]            = {'\0'};
  long k, num;
 
  for (out = 0L; out < Num_Updates; out++) {
    nam = Update_List[out].name;
    /* add temporarily here update conditions, if any, to the list of updates                                                     */
    (void) strcpy(buffer, Update_List[out].value);
    (void) strcat(buffer, " ");
    (void) strcat(buffer, Update_List[out].condition);
    num = 0L;
    /* scan buffer to number the dependencies                                                                                     */
    str = buffer;
    for (;;) {
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      k  =    0L;
      in = -999L;
      while (UNDEFINED != in) {
        k++;
        in = update_id(tok, k);
        if ((UNDEFINED != in) && (0 != strcmp(tok, nam))) {
          num++;
        }
      }
    }
    Update_List[out].depend = (long*) malloc((size_t) ((long) sizeof (long) * (num+1L)));
    if ((long*) NULL == Update_List[out].depend) {
      print_error_location("update dependency", Update_List[out].mline, Update_List[out].mfile);
      (void) fprintf(STDERR, " dynamic memory allocation error\n");
      print_error_banner_and_exit();
    }
    /* scan again the buffer to store the dependencies                                                                            */
    p   = Update_List[out].depend;
    str = buffer;
    for (;;) {
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      k  =    0L;
      in = -999L;
      while (UNDEFINED != in) {
        k++;
        in = update_id(tok, k);                                               /* detect dependencies on -updated- var only        */
        if ((UNDEFINED != in) && (0 != strcmp(tok, nam))) {
          *p = Update_List[in].ID;
          p++;
        }
      }
    }
    *p = -1L;                                                                 /* to terminate the array                           */
  }
  return;
}
 
 
/* List of dependencies is a list of ID corresponding to arrays in the array definition                                           */
 
void build_record_dependencies(void) {
  long in, out;
  long *p =   (long*) NULL;
  char *str = (char*) NULL;
  char tok[STRLENGTH] = {'\0'};
  char sgn[2]         = {'\0'};
  long num;
 
  for (out = 0L; out < Num_Records; out++) {
    num = 0L;
    str = Record_List[out].list1;
    for (;;) {                                                                /* count number of arrays in the array definition   */
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      in = record_id(tok);
      if (UNDEFINED != in) {
        num++;
      }
    }
    Record_List[out].depend = (long*) malloc((size_t) ((long) sizeof (long) * (num+1L)));
    if ((long*) NULL == Record_List[out].depend) {
      print_error_location("array of pointers dependency", Record_List[out].mline, Record_List[out].mfile);
      (void) fprintf(STDERR, " dynamic memory allocation error\n");
      print_error_banner_and_exit();
    }
    p   = Record_List[out].depend;
    str = Record_List[out].list1;
    for (;;) {
      str = get_sign_and_token(str, sgn, tok);
      if (ISEMPTY(tok)) {
        break;
      }
      in = record_id(tok);
      if (UNDEFINED != in) {
        *p = Record_List[in].ID;                                              /* add array ID to dependency list                  */
        p++;
      }
    }
    *p = -1L;                                                                 /* to terminate the array                           */
  }
  return;
}
 
 
/* Process instruction 'init' AS SOON AS POSSIBLE as it could contain acceptance test                                             */
/* like a test to prevent a division by zero in a variable definition.                                                            */
/* We hope to produce a documented error message before a system message signalling a crash                                       */
 
void sort_vars(void) {
  long out1, out2;
  long nseg;
  long determined_ptr;
  long i, j;
  long *p =   (long*) NULL;
  char *str = (char*) NULL;
  int  first, flag;
 
  flag = true;
  determined_ptr = 0L;
 
  for (out1 = 0L; out1 < Num_Vars; out1++) {
    flag  = true;
    first = true;
    p = Var_List[out1].depend;
    for (;;) {                                                                /* get the vars and check that they are determined  */
      j = *p;
      if (-1L >= j) {
        break;
      }
      flag = false;
      for (i = 0L; i < determined_ptr; i++) {
        if (j == Var_List[i].ID) {
          flag = true;
          break;
        }
      }
      if (!flag) {                                                            /* this input is not yet determined                 */
        if (!first) {
          *p      = *(p-1L);                                                  /* to speed up, move to beginning of dependencies   */
          *(p-1L) = j;
        }
        break;
      }
      p++;
      first = false;
    }
    if (flag) {                                                               /* this variable depends on determined input        */
      Var_List[out1].determined = true;
      swap_vars(out1, determined_ptr);
      out1 = determined_ptr;                                                  /* start from the position after last determined    */
      determined_ptr++;
    }
  }
 
  /* Verify that all variables are determined                                                                                     */
  if ((Num_Vars - 1L) > determined_ptr) {
    Error_Flag++;
    (void) fprintf(STDERR, "\nNAPA Error:  (static loop)\n");
    (void) fprintf(STDERR, "\n These variables are involved in one or several loops:\n");
    for (out1 = determined_ptr; out1 < Num_Vars; out1++) {                    /* review each undetermined var                     */
      flag = false;
      for (out2 = determined_ptr; out2 < Num_Vars; out2++) {                  /* check dependency                                 */
        if (out1 == out2) {
          continue;
        }
        p = Var_List[out2].depend;                                            /* dependencies of out2                             */
        for (;;) {                                                            /* check if var out1 is in dependency list of out2  */
          j = *p;
          if (-1L >= j) {                                                     /* reached end of dependency list                   */
            break;
          }
          if (j == Var_List[out1].ID) {
            flag = true;                                                      /* var is part of the dependency list               */
            break;
          }
          p++;
        }
        if (flag) {
          break;
        }
      }
      if (!flag) {                                                            /* this var does not participate to a loop          */
        swap_vars(out1, determined_ptr);
        determined_ptr++;                                                     /* in this search, we mark it as determined         */
        out1 = determined_ptr;                                                /* restart the search                               */
      }
    }
  }
 
  for (nseg = 0L; nseg < Num_Segments; nseg++) {
    flag = true;
    for (out1 = determined_ptr; out1 < Num_Vars; out1++) {
      if (Var_List[out1].segment == nseg) {
        flag = ((Var_List[out1].determined) && (flag)) ? true : false;
      }
    }
    if (!flag) {                                                              /* there is a problem in this segment               */
      (void) fprintf(STDERR, "\n variable undetermination");
      if (1L < Num_Segments) {
        (void) fprintf(STDERR,   " in segment [%ld]\n", nseg);
      } else {
        (void) fprintf(STDERR,   " in netlist\n");
      }
      for (out1 = determined_ptr; out1 < Num_Vars; out1++) {
        if (Var_List[out1].segment == nseg) {
          if (!Var_List[out1].determined) {
            if ('_' == Var_List[out1].name1[0]) {
              str = Var_List[out1].name1 + 1;                                 /* suppress underscore in void name                 */
            } else {
              str = Var_List[out1].name1;
            }
            (void) fprintf(STDERR, "   -> var  %s\n", str);
          }
        }
      }
    }
  }
  return;
}
 
 
/* Process instruction 'assert' AS SOON AS POSSIBLE as it could contain acceptance test like a test to prevent a division by zero */
/* in a variable update. We hope to produce a documented error message before a system message signalling a crash.                */
 
void sort_updates(void) {
  long out1, out2;
  long nseg;
  long determined_ptr, ptr;
  long i, j;
  long *p   = (long*) NULL;
  char *str = (char*) NULL;
  int  first, flag;
 
  flag = true;
  determined_ptr = 0L;
 
  for (out1 = 0L; out1 < Num_Updates; out1++) {
    ptr = determined_ptr + 1;
    for (out2 = ptr; out2 < Num_Updates; out2++) {                            /* prioritize $assert$                              */
      if (0 == strncmp(Update_List[out2].name, "$assert$", (size_t) 8)) {
        swap_updates(out2, ptr);
        out2 = ptr;
        ptr++;
      }
    }
    flag  = true;
    first = true;
    p = Update_List[out1].depend;
    for (;;) {                                                                /* get updates and check that they are determined   */
      j = *p;
      if (-1L >= j) {
        break;
      }
      flag = false;
      for (i = 0L; i < determined_ptr; i++) {
        if (j == Update_List[i].ID) {
          flag = true;
          break;
        }
      }
      if (!flag) {
        if (!first) {
          *p      = *(p-1L);
          *(p-1L) = j;
        }
        break;
      }
      p++;
      first = false;
    }
    if (flag) {
      Update_List[out1].determined = true;
      swap_updates(out1, determined_ptr);
      out1 = determined_ptr;
      determined_ptr++;
    }
  }
 
  /* Verify that all updates are determined                                                                                       */
 
  if ((Num_Updates - 1L) > determined_ptr) {
    Error_Flag++;
    (void) fprintf(STDERR, "\nNAPA Error:  (static loop)\n");
    (void) fprintf(STDERR, "\n These updates are involved in one or several loops:\n");
 
    for (out1 = determined_ptr; out1 < Num_Updates; out1++) {                 /* review undetermined updates                      */
      flag = false;
      for (out2 = determined_ptr; out2 < Num_Updates; out2++) {               /* check dependency                                 */
        if (out1 == out2) {
          continue;
        }
        p = Update_List[out2].depend;                                         /* dependencies of out2                             */
        for (;;) {                                                            /* check if update out1 is in out2 dependency list  */
          j = *p;
          if (-1L >= j) {                                                     /* reached end of dependency list                   */
            break;
          }
          if (j == Update_List[out1].ID) {
            flag = true;                                                      /* update is part of the dependency list            */
            break;
          }
          p++;
        }
        if (flag) {
          break;
        }
      }
      if (!flag) {                                                            /* this update does not participate to a loop       */
        swap_updates(out1, determined_ptr);
        determined_ptr++;                                                     /* in this search, we mark it as determined         */
        out1 = determined_ptr;                                                /* restart the search                               */
      }
    }
  }
 
  for (nseg = 0L; nseg < Num_Segments; nseg++) {
    flag = true;
    for (out1 = determined_ptr; out1 < Num_Updates; out1++) {
      if (Update_List[out1].segment == nseg) {
        flag = ((Update_List[out1].determined) && (flag)) ? true : false;
      }
    }
    if (!flag) {                                                              /* there is a problem in this segment               */
      (void) fprintf(STDERR, "\n");
      if (1L < Num_Segments) {
        (void) fprintf(STDERR,   " In Segment [%ld]\n", nseg);
      }
      for (out1 = determined_ptr; out1 < Num_Updates; out1++) {
        if ((!Update_List[out1].determined) && (Update_List[out1].segment == nseg)) {
          if ('_' == Update_List[out1].name[0]) {
            str = Update_List[out1].name + 1;                                 /* suppress underscore in void name                 */
          } else {
            str = Update_List[out1].name;
          }
          (void) fprintf(STDERR, "   -> update  %s\n", str);
        }
      }
    }
  }
  return;
}
 
 
void sort_records(void) {
  long out1, out2;
  long determined_ptr;
  long i, j;
  long *p   = (long*) NULL;
  char *str = (char*) NULL;
  int  first, flag;
 
  determined_ptr = 0L;
 
  for (out1 = 0L; out1 < Num_Records; out1++) {
    flag  = true;
    first = true;
    p = Record_List[out1].depend;
    for (;;) {                                                                /* get arrays of pointers, check if determined      */
      j = *p;
      if (-1L >= j) {
        break;
      }
      flag = false;
      for (i = 0L; i < determined_ptr; i++) {
        if (j == Record_List[i].ID) {
          flag = true;
          break;
        }
      }
      if (!flag) {
        if (!first) {
          *p      = *(p-1L);
          *(p-1L) = j;
        }
        break;
      }
      p++;
      first = false;
    }
    if (flag) {
      Record_List[out1].determined = true;
      swap_records(out1, determined_ptr);
      out1 = determined_ptr;
      determined_ptr++;
    }
  }
 
  /* Verify that all Records are determined                                                                                       */
 
  if ((Num_Records - 1L) > determined_ptr) {
    Error_Flag++;
    (void) fprintf(STDERR, "\nNAPA Error:  (static loop)\n");
    (void) fprintf(STDERR, "\n These arrays of pointers are involved in one or several loops:\n");
    for (out1 = determined_ptr; out1 < Num_Records; out1++) {                 /* review undetermined records                      */
      flag = false;
      for (out2 = determined_ptr; out2 < Num_Records; out2++) {               /* check dependency                                 */
        if (out1 == out2) {
          continue;
        }
        p = Record_List[out2].depend;                                         /* dependencies of out2                             */
        for (;;) {                                                            /* check if record out1 is in out2 dependency list  */
          j = *p;
          if (-1L >= j) {                                                     /* reached end of dependency list                   */
            break;
          }
          if (j == Record_List[out1].ID) {
            flag = true;                                                      /* record is part of the dependency list            */
            break;
          }
          p++;
        }
        if (flag) {
          break;
        }
      }
      if (!flag) {                                                            /* this record does not participate to a loop       */
        swap_records(out1, determined_ptr);
        determined_ptr++;                                                     /* in this search, we mark it as determined         */
        out1 = determined_ptr;                                                /* restart the search                               */
      }
    }
  }
  for (out1 = determined_ptr; out1 < Num_Records; out1++) {
    if (!Record_List[out1].determined) {
      str = Record_List[out1].name;
      (void) fprintf(STDERR, "    -> array %s\n", str);
    }
  }
  return;
}
 
 
/* ****************************************************************************************************************************** */
/* end of file                                                                                                                    */