src/io/ioCmd.c

Go to the documentation of this file.

#include "ioInt.h"

static char rcsid[] UNUSED = "$Id: ioCmd.c,v 1.16 2005/05/19 02:34:33 awedh Exp $";

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/
#ifndef NAWK
#define NAWK "gawk"
#endif
/*---------------------------------------------------------------------------*/
/* Stucture declarations                                                     */
/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
/* Type declarations                                                         */
/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
/* Variable declarations                                                     */
/*---------------------------------------------------------------------------*/
extern FILE *yyin;

/*---------------------------------------------------------------------------*/
/* Macro declarations                                                        */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* Static function prototypes                                                */
/*---------------------------------------------------------------------------*/

static int CommandReadBlifMv(Hrc_Manager_t **hmgr, int argc, char **argv);
static int CommandWriteBlifMv(Hrc_Manager_t **hmgr, int argc, char **argv);
static int CommandReadVerilog(Hrc_Manager_t **hmgr, int argc, char **argv);
static int CommandReadBlif(Hrc_Manager_t **hmgr, int argc, char **argv);
static int CommandWriteBlif(Hrc_Manager_t **hmgr, int argc, char **argv);
static int CommandWriteSmv(Hrc_Manager_t **hmgr, int argc, char **argv);
 
/*---------------------------------------------------------------------------*/
/* Definition of exported functions                                          */
/*---------------------------------------------------------------------------*/

void
Io_Init(void)
{
  Cmd_CommandAdd("read_blif_mv", CommandReadBlifMv, 0);
  Cmd_CommandAdd("write_blif_mv", CommandWriteBlifMv, 0);
  Cmd_CommandAdd("write_smv", CommandWriteSmv, 0);
  Cmd_CommandAdd("read_verilog", CommandReadVerilog, 0);
  Cmd_CommandAdd("read_blif", CommandReadBlif, 0);
  Cmd_CommandAdd("write_blif", CommandWriteBlif, 0);
}

void
Io_End(void)
{
}

/*---------------------------------------------------------------------------*/
/* Definition of static functions                                            */
/*---------------------------------------------------------------------------*/

static int
CommandReadBlifMv(
  Hrc_Manager_t **hmgr,
  int argc,
  char **argv)
{
  int status, c;
  boolean isCanonical, isIncremental, isVerbose;
  char *fileName;
  FILE *fp;
  Hrc_Manager_t *newHmgr;
  
  isCanonical = 0;
  isIncremental = 0;
  isVerbose = 0;
  util_getopt_reset();
  while ((c = util_getopt(argc,argv,"chrv")) != EOF){
    switch(c){
      case 'c':
        isCanonical = 1;
        break;
      case 'h':
        goto usage;
      case 'r':
        isIncremental = 1;
        break;
      case 'v':
        isVerbose = 1;
        break;
      default:
        goto usage;
    }
  }
  
  /* check to see if there is only one argument left for a file name */
  if (argc-1 != util_optind){
    goto usage;
  }
  fileName = argv[util_optind];

  fp = Cmd_FileOpen(fileName, "r", NIL(char *), 1);
  
  if (fp == NIL(FILE)){
    (void)fprintf(vis_stderr,"File %s cannot be opened\n", fileName);
    return 1;
  }
  error_init();

  newHmgr = Io_BlifMvRead(fp,*hmgr,isCanonical,isIncremental,isVerbose);
  /* success */
  if (newHmgr != NIL(Hrc_Manager_t)){
    status = 0;
    if (isIncremental == 0){
      Hrc_ManagerFree(*hmgr);
      *hmgr = newHmgr;
    }
  }
  /* failure */
  else {
    status = 1;
  }
  (void)fprintf(vis_stderr,"%s",error_string());
  fflush(vis_stderr);
  if (fp != stdin) {
    (void) fclose(fp);
  }
  return (status);

  usage:
    (void)fprintf(vis_stderr, "usage: read_blif_mv [-c] [-h] [-r] [-v] file\n");
    (void)fprintf(vis_stderr, "   -c  semi-canonicalize all the tables\n");
    (void)fprintf(vis_stderr, "   -h  print the command usage\n");  
    (void)fprintf(vis_stderr, "   -r  replace the current subhierarchy\n");
    (void)fprintf(vis_stderr, "   -v  verbose\n");
    return 1 ;
}


static int
CommandWriteBlifMv(
  Hrc_Manager_t **hmgr,
  int argc,
  char **argv)
{
  FILE *fp;
  int c;
  Hrc_Node_t *currentNode;

  util_getopt_reset();
  while ((c = util_getopt(argc,argv,"h")) != EOF){
    switch(c){
      case 'h':
        goto usage;
      default:
        goto usage;
    }
  }

  currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
  if (currentNode == NIL(Hrc_Node_t)){
    (void)fprintf(vis_stderr,"No file has been read in.\n");
    return 1;
  }

  if (argc == 1){
    fp = stdout;
  }
  else if (argc == 2){
    fp = Cmd_FileOpen(*(++argv), "w", NIL(char *), 1);
    if (fp == NIL(FILE)){
      (void)fprintf(vis_stderr,"Cannot write to %s\n", *argv);
      return 1;
    }
  }
  else {
    goto usage; 
  }
  
  error_init();
  IoBlifMvWrite(fp,*hmgr);
  (void)fprintf(vis_stderr,"%s",error_string());
  fflush(fp);
  if (fp != stdout) {
    (void) fclose(fp);
  }
  return 0;

  usage:
    (void)fprintf(vis_stderr, "usage: write_blif_mv [-h] [file]\n");
    (void)fprintf(vis_stderr, "   -h  print the command usage\n");  
    return 1;
}

static int
CommandWriteSmv(
  Hrc_Manager_t **hmgr,
  int argc,
  char **argv)
{
  FILE *fp;
  int c;
  Hrc_Node_t *currentNode;

  util_getopt_reset();
  while ((c = util_getopt(argc,argv,"h")) != EOF){
    switch(c){
      case 'h':
        goto usage;
      default:
        goto usage;
    }
  }

  currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
  if (currentNode == NIL(Hrc_Node_t)){
    (void)fprintf(vis_stderr,"No file has been read in.\n");
    return 1;
  }

  if (argc == 1){
    fp = stdout;
  }else if (argc == 2){
    fp = Cmd_FileOpen(*(++argv), "w", NIL(char *), 1);
    if (fp == NIL(FILE)){
      (void)fprintf(vis_stderr,"Cannot write to %s\n", *argv);
      return 1;
    }
  }else {
    goto usage; 
  }
  
  error_init();
  IoSmvWrite(fp,*hmgr);
  (void)fprintf(vis_stderr,"%s",error_string());
  fflush(fp);
  if (fp != stdout) {
    (void) fclose(fp);
  }
  return 0;

  usage:
    (void)fprintf(vis_stderr, "usage: write_smv [-h] [file]\n");
    (void)fprintf(vis_stderr, "   -h  print the command usage\n");  
    return 1;
}


static int
CommandReadVerilog(Hrc_Manager_t **hmgr, int argc, char **argv)
{
  int c;
  char *realFileName, *verilogFileName;
#if HAVE_MKSTEMP && HAVE_CLOSE
  char outFileName[] = "/tmp/vis.XXXXXX";
  int  fd;
#else
  char *outFileName;
  char buffer[512];
#endif
  FILE *fp;
  static char parseBuffer[1024];
  int vl2mvStatus;
  int cSet = 0;
  int uSet = 0;
  int FSet = 0;

  util_getopt_reset();
  while ((c = util_getopt(argc,argv,"chuF")) != EOF){
    switch(c){
      case 'c':
        cSet = 1;
        break;
      case 'h': 
        goto usage;
      case 'u':
        uSet = 1;
        break;
      case 'F':
        FSet = 1;
        break;
      default:
        goto usage;
    }
  }
  
  /* check to see if there is only one argument left for a file name */
  if (argc-1 != util_optind){
    goto usage;
  }
  verilogFileName = argv[util_optind];

  fp = Cmd_FileOpen(verilogFileName, "r", &realFileName, /* silent */ 1);
  
  if (fp == NIL(FILE)){
    FREE(realFileName);
    (void)fprintf(vis_stderr,"File %s  cannot be opened\n", verilogFileName);
    return 1;
  }
  fclose(fp);

#if HAVE_MKSTEMP && HAVE_CLOSE
  fd = mkstemp(outFileName);
  if (fd == -1){
#else
  outFileName = util_strsav(tmpnam(buffer));
  if (outFileName == NIL(char)){
#endif
    FREE(realFileName);
    (void)fprintf(vis_stderr,"Can not create temporary file. ");
    (void)fprintf(vis_stderr,"Clean up /tmp an try again.\n");
    return  1;
  }  
 
  strcpy(parseBuffer,"vl2mv ");
  strcat(parseBuffer,"-o ");
  strcat(parseBuffer,outFileName);
  strcat(parseBuffer," ");
  /* start inserting options for vl2mv */
  if (cSet){
    strcat(parseBuffer,"-c ");
  }
  if (uSet){
    strcat(parseBuffer,"-u ");
  }
  if (FSet){
    strcat(parseBuffer,"-F ");
  }
  strcat(parseBuffer, realFileName);
  FREE(realFileName);
#if HAVE_MKSTEMP && HAVE_CLOSE
  close(fd);
#endif
  vl2mvStatus = system(parseBuffer);
  if (vl2mvStatus != 0){
    return 1;
  }
  sprintf(parseBuffer,"read_blif_mv %s",outFileName);
  Cmd_CommandExecute(hmgr, parseBuffer);
#if HAVE_UNLINK
  unlink(outFileName);
#endif
  return 0;
  
  usage:
    (void)fprintf(vis_stderr, "usage: read_verilog [-c] [-h] [-u] [-F] file\n");
    (void)fprintf(vis_stderr, "   -c  use explicit clocking\n");
    (void)fprintf(vis_stderr, "   -h  print the command usage\n");
    (void)fprintf(vis_stderr, "   -u  turn off unroling\n");
    (void)fprintf(vis_stderr, "   -F  ignore all timing\n");
    return 1;
}

static int
CommandReadBlif(
  Hrc_Manager_t **hmgr,
  int argc,
  char **argv)
{
  int c, status;
  boolean isCanonical = 0;
  boolean isIncremental = 0;
  boolean isVerbose = 0;
  char *fileName, *realFileName, *visDirectoryName, *blifMvFileName;
  char *encodingFileName;
  char command[512];
  FILE *fp;
#if HAVE_MKSTEMP && HAVE_CLOSE
  int  fd;
#else
  char buffer[512];
#endif
  Hrc_Manager_t *newHmgr;
  
  util_getopt_reset();
  while ((c = util_getopt(argc,argv,"ce:hv")) != EOF){
    switch(c){
      case 'c':
        isCanonical = 1;
        break;
      case 'e':
        isIncremental = 1;
        fp = Cmd_FileOpen(util_optarg, "r", &encodingFileName, 1);
        if (fp == NIL(FILE)){
          (void)fprintf(vis_stderr,"Encoding file %s is not found\n", util_optarg);
          return 1;
        }
        if (fp != stdin){
          (void)fclose(fp);
        }
        break;
      case 'h':
        goto usage;
      case 'v':
        isVerbose = 1;
        break;
      default:
        goto usage;
    }
  }

  /* check to see if there is only one argument left for a file name */
  if (argc-1 != util_optind){
    goto usage;
  }
  fileName = argv[util_optind];

  fp = Cmd_FileOpen(fileName, "r", &realFileName, 1);
  
  if (fp == NIL(FILE)){
    /*
    FREE(realFileName);
    */
    (void)fprintf(vis_stderr,"File %s cannot be opened\n", fileName);
    return 1;
  }
  if (fp != stdin){
    (void)fclose(fp);
  }

#if HAVE_MKSTEMP && HAVE_CLOSE
  blifMvFileName = util_strsav("/tmp/vis.XXXXXX");
  fd = mkstemp(blifMvFileName);
  if (fd == -1){
#else
  blifMvFileName = util_strsav(tmpnam(buffer));
  if (blifMvFileName == NIL(char)){
#endif
    FREE(realFileName);
    (void)fprintf(vis_stderr,"Could not create temporary file. ");
    (void)fprintf(vis_stderr,"Clean up /tmp an try again.\n");
    return 1;
  }
#if HAVE_MKSTEMP && HAVE_CLOSE
  close(fd);
#endif
  /* Invoking an awk script */
  visDirectoryName = Vm_VisObtainLibrary();
  if (isIncremental == 0){
    (void)sprintf(command,"sed 's/^\\./@/g' %s | sed 's/\\./$/g' | sed 's/^@/\\./g' | sed 's/{/</g' | sed 's/}/>/g'| sed 's/(/<</g' | sed 's/)/>>/g'| %s -f %s/ioBlifToMv.nawk > %s", realFileName, NAWK, visDirectoryName, blifMvFileName);
  }
  else {
    (void)sprintf(command,"sed 's/^\\./@/g' %s | sed 's/\\./$/g' | sed 's/^@/\\./g' | sed 's/{/</g' | sed 's/}/>/g'| %s -f %s/ioBlifToMvForIncremental.nawk > %s", realFileName, NAWK, visDirectoryName, blifMvFileName);
  }
  (void)system(command);
  FREE(visDirectoryName);
  FREE(realFileName);

  error_init();

  if (isIncremental == 0){
    fp = Cmd_FileOpen(blifMvFileName, "r", NIL(char *), 1);
  }
  else {
    char *finalBlifMvFileName;
    
#if HAVE_MKSTEMP && HAVE_CLOSE
    finalBlifMvFileName = util_strsav("/tmp/vis.XXXXXX");
    fd = mkstemp(finalBlifMvFileName);
    if (fd == -1){
#else
    finalBlifMvFileName = util_strsav(tmpnam(buffer));
    if (finalBlifMvFileName == NIL(char)){
#endif
      FREE(blifMvFileName);
      (void)fprintf(vis_stderr,"Could not create temporary file. ");
      (void)fprintf(vis_stderr,"Clean up /tmp an try again.\n");
      return 1;
    }
#if HAVE_MKSTEMP && HAVE_CLOSE
    close(fd);
#endif

    (void)sprintf(command,"cat %s %s > %s",encodingFileName,blifMvFileName,finalBlifMvFileName);
    (void)system(command);
    FREE(encodingFileName);
#if HAVE_UNLINK
    unlink(blifMvFileName);
#endif
    FREE(blifMvFileName);
    blifMvFileName = finalBlifMvFileName;

    fp = Cmd_FileOpen(blifMvFileName, "r", NIL(char *), 1);
  }
  assert(fp != NIL(FILE));
  newHmgr = Io_BlifMvRead(fp,*hmgr,isCanonical,isIncremental,isVerbose);
  if (newHmgr != NIL(Hrc_Manager_t)){
    status = 0;
    if (isIncremental == 0){
      Hrc_ManagerFree(*hmgr);
      *hmgr = newHmgr;
    }
  }
  else {
    status = 1;
  }

  (void)fprintf(vis_stderr,"%s",error_string());
  fflush(vis_stderr);
  if (fp != stdin) {
    (void) fclose(fp);
#if HAVE_UNLINK
    unlink(blifMvFileName);
#endif
  }
  FREE(blifMvFileName);
  return (status);

  usage:
    (void)fprintf(vis_stderr, "usage: read_blif [-c] [-e encoding_file] [-h] [-v] file\n");
    (void)fprintf(vis_stderr, "   -c  table canonicalization\n");
    (void)fprintf(vis_stderr, "   -e  read a file into the current node using encoding file\n");
    (void)fprintf(vis_stderr, "   -h  print the command usage\n");    
    (void)fprintf(vis_stderr, "   -v  verbose\n");
    return 1 ;
}


static int
CommandWriteBlif(
  Hrc_Manager_t **hmgr,
  int argc, 
  char **argv)
{
  FILE *enc_fp, *fp;
  char *modelName, *dupname;
  int status, verbosity, combinationalOnly, makeLatchIOsPOs;
  Io_Encoding_Type_t encoding_type;
  Hrc_Node_t *hnode;
  int c;
  boolean recursive;

  fp = stdout;
  enc_fp = NIL(FILE);
  verbosity = 0;
  combinationalOnly = 0;
  makeLatchIOsPOs = 0;
  recursive = 0;

  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "clRe:hv:")) != EOF) {
      switch(c) {
      case 'c':
          combinationalOnly = 1;
          break;
      case 'l':
          makeLatchIOsPOs = 1;
          break;
      case 'R':
          recursive = 1;
          break;
      case 'e':
          enc_fp = Cmd_FileOpen(util_optarg, "w", NIL(char *), 1);
          if (enc_fp == NIL(FILE)){
              (void)fprintf(vis_stderr,"Cannot write to %s\n", util_optarg);
              return 1;
          }
          break;
      case 'h':
          goto usage;
      case 'v':
          verbosity = atoi(util_optarg);
          break;
      default:
          goto usage;
      }
  }

  if(makeLatchIOsPOs && combinationalOnly){
    (void)fprintf(vis_stderr,"Cannot use -c and -l options simultaneously.\n");
    goto usage;
  }
  if(recursive){
    if(makeLatchIOsPOs || combinationalOnly){
      (void)fprintf(vis_stderr,"Cannot use -c or -l options with -R option.\n");      
      goto usage;
    }
    if(enc_fp != NIL(FILE)){
      (void)fprintf(vis_stderr,"Cannot use -e option with -R option.\n");            
      goto usage;
    }
  }
  hnode = Hrc_ManagerReadCurrentNode(*hmgr);
  if (hnode == NIL(Hrc_Node_t)){
    (void)fprintf(vis_stderr,"No file has been read in.\n");
    return 1;
  }

  /* check to see if there is only one argument left for a file name */
  if (argc == util_optind){
    fp = stdout;
  }
  else if (argc-1 == util_optind){
    fp = Cmd_FileOpen(argv[util_optind], "w", NIL(char *), 1);
    if (fp == NIL(FILE)){
      (void)fprintf(vis_stderr,"Cannot write to %s\n", argv[util_optind]);
       if (enc_fp != NIL(FILE)){
         fclose(enc_fp);
       }
       return 1;
    }
  }
  else {
    if (enc_fp != NIL(FILE)){
      fclose(enc_fp);
    }
    goto usage;
  }

  if((enc_fp == NIL(FILE)) && !recursive){
      modelName = Hrc_NodeReadModelName(hnode);
      dupname = ALLOC(char, strlen(modelName) + strlen(".enc") + 1);
      sprintf(dupname, "%s%s", modelName, ".enc");
      enc_fp = Cmd_FileOpen(dupname, "w", NIL(char *), 1);
      if (enc_fp == NIL(FILE)){
        (void)fprintf(vis_stderr,"Cannot write to %s\n", dupname);
        return 1;
      }
      (void)fprintf(stdout, "Writing encoding information to %s\n",dupname);
      FREE(dupname);
  }

  if(!recursive){
    if(!(makeLatchIOsPOs || combinationalOnly)){
      (void)fprintf(vis_stderr,"Warning - The blif and encoding files generated cannot be read back into \n");
      (void)fprintf(vis_stderr, "VIS. If you would like to read the optimized blif file back into VIS, then \n");
      (void)fprintf(vis_stderr, "please use 'write_blif -l' or 'write_blif -c' instead.\n");
    }
  }

  error_init();
  encoding_type = SIMPLE;
  if(recursive){
    status = Io_HnodeWriteBlifTotal(encoding_type, hnode, fp, verbosity);
  }
  else{
    status = Io_HnodeWriteBlif(encoding_type, hnode, fp, enc_fp, verbosity, combinationalOnly, makeLatchIOsPOs);
  }
  (void)fprintf(vis_stderr,"%s",error_string());
  fflush(fp);
  if (fp != stdout) {
    (void) fclose(fp);
  }

  if(status == 0){
    return 0;
  }
  else{
    return 1;
  }

  usage:
    (void)fprintf(vis_stderr, "usage: write_blif [-c] [-l] [-e encoding_file] [-R] [-h] [-v verbosity] [blif_file]\n");
    (void)fprintf(vis_stderr, "   -c write only combinational part to blif file\n");  
    (void)fprintf(vis_stderr, "   -l make latch IOs primary outputs in the blif file\n");  
    (void)fprintf(vis_stderr, "   -e encoding_file, default is <model_name>.enc\n");
    (void)fprintf(vis_stderr, "   -R recursively write out the hierarchy rooted at the current hnode.\n");
    (void)fprintf(vis_stderr, "      In this sub-hierarchy, all tables must be deterministic and all\n");
    (void)fprintf(vis_stderr, "      variables must be boolean. Either of the -c, -l, or -e options \n");
    (void)fprintf(vis_stderr, "      cannot be simultaneously with the -R option \n");
    (void)fprintf(vis_stderr, "   -h print this usage message\n");  
    (void)fprintf(vis_stderr, "   -v verbosity, an integer < 3, default is 0\n");
    (void)fprintf(vis_stderr, "Note: * If neither the -c or -l options are chosen, then latches will \n");
    (void)fprintf(vis_stderr, "        be written out to the blif file. Latch IOs will not be made\n");
    (void)fprintf(vis_stderr, "        into primary outputs in the blif file\n");
    (void)fprintf(vis_stderr, "      * After optimizing the blif file in SIS, do not write out the\n");
    (void)fprintf(vis_stderr, "        optimized file using 'write_blif -s' if you want to read\n");
    (void)fprintf(vis_stderr, "        it back into VIS. Use 'write_blif' instead \n");
    return 1 ;
    
}