src/cmd/cmdMisc.c

Go to the documentation of this file.

#include "cmdInt.h"
#include <errno.h>

static char rcsid[] UNUSED = "$Id: cmdMisc.c,v 1.59 2009/04/11 18:25:50 fabio Exp $";

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/
/* The maximum length of an input line */
#define MAX_STR         32768


/*---------------------------------------------------------------------------*/
/* Variable declarations                                                     */
/*---------------------------------------------------------------------------*/
avl_tree *cmdAliasTable;
avl_tree *cmdFlagTable;

static boolean fileCreated;


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

static int CommandTime(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandEcho(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandSetBddParameters(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandMemoryProfile(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandQuit(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandUsage(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandWhich(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandHistory(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandAlias(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandUnalias(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandSetVariable(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandUnsetVariable(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandHelp(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandSource(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static void print_alias(char * value);
static char * command_alias_help(char * command);
static void FlushBuffers(int sigtype);

/*---------------------------------------------------------------------------*/
/* Definition of exported functions                                          */
/*---------------------------------------------------------------------------*/


char *
Cmd_FlagReadByName(
  char * flag)
{
  char *value;

  if (avl_lookup(cmdFlagTable, flag, &value)) {
    return value;
  }
  else {
    return NIL(char);
  }
}


void
Cmd_FlagUpdateValue(
  char * key, char * value)
{
  char *oldValue, *newValue;

  if (!key)
    return;
  if (value)
    newValue = util_strsav(value);
  else
    newValue = util_strsav("");

  if (avl_delete(cmdFlagTable, &key, &oldValue))
    FREE(oldValue);

  (void) avl_insert(cmdFlagTable, key, newValue);
}


void
Cmd_FlagDeleteByName(
  char * key)
{
  char *value;

  if (!key)
    return;

  if (avl_delete(cmdFlagTable, &key, &value)) {
    FREE(key);
    FREE(value);
  }
}


void
Cmd_Init(void)
{
  char *path;
  char *lib_name;


  cmdCommandTable = avl_init_table((int(*)(const void *, const void *))strcmp);
  cmdFlagTable = avl_init_table((int(*)(const void *, const void *))strcmp);
  cmdAliasTable = avl_init_table((int(*)(const void *, const void *))strcmp);

  Cmd_CommandAdd("alias", CommandAlias, 0);
  Cmd_CommandAdd("echo", CommandEcho, 0);
  Cmd_CommandAdd("help", CommandHelp, 0);
  Cmd_CommandAdd("quit", CommandQuit, 0);
  Cmd_CommandAdd("source", CommandSource, 0);
/*  Cmd_CommandAdd("undo", CommandUndo, 0); */
  Cmd_CommandAdd("set", CommandSetVariable, 0);
  Cmd_CommandAdd("unalias", CommandUnalias, 0);
  Cmd_CommandAdd("unset", CommandUnsetVariable, 0);
  Cmd_CommandAdd("time", CommandTime, 0);
  Cmd_CommandAdd("usage", CommandUsage, 0);
  Cmd_CommandAdd("history", CommandHistory, 0);
  Cmd_CommandAdd("which", CommandWhich, 0);
  Cmd_CommandAdd("set_bdd_parameters" , CommandSetBddParameters, 0);
  Cmd_CommandAdd("_memory_profile", CommandMemoryProfile, 0);
  fileCreated = FALSE;

  /* Program the signal of type USR1 to flush vis_stdout and vis_stderr */
#ifdef SIGUSR1
  (void) signal(SIGUSR1, FlushBuffers);
#endif

  /* set the default open_path */
  lib_name = Vm_VisObtainLibrary();
  path = ALLOC(char, strlen(lib_name) + 20);
  sprintf(path, "set open_path .:%s", lib_name);
  Cmd_CommandExecute(NULL, path);
  FREE(lib_name);
  FREE(path);
}


void
Cmd_End(void)
{
  avl_free_table(cmdFlagTable, (void (*)(char *))free, (void (*)(char *))free);
  avl_free_table(cmdCommandTable, (void (*)(char *)) 0, CmdCommandFree);
  avl_free_table(cmdAliasTable, (void (*)(char *)) 0, CmdAliasFree);
  if (cmdBackupHmgr != NIL(Hrc_Manager_t)) {
    Hrc_ManagerFree(cmdBackupHmgr);
  }
  error_cleanup();

  if (fileCreated == TRUE) {
    (void) fprintf(vis_stdout, "Purify has created a temporary file. The file");
    (void) fprintf(vis_stdout, " must be deleted.\n");
  }
}


int
Cmd_StringCheckIsInteger(
  char *string,
  int *value)
{
  char *ptr;
  long l;

  errno = 0 ;
  l = strtol (string, &ptr, 0) ;
  if(*ptr != '\0')
    return 0;
  if (errno != 0)
    return 1;
  if ((l > MAXINT) || (l < -1 - MAXINT))
    return 1 ;
  *value = (int) l;
  return 2 ;
}


/*---------------------------------------------------------------------------*/
/* Definition of internal functions                                          */
/*---------------------------------------------------------------------------*/


void
CmdFreeArgv(int  argc,  char ** argv)
{
  int i;

  for(i = 0; i < argc; i++) {
    FREE(argv[i]);
  }
  FREE(argv);
}


void
CmdAliasFree(
  char * value)
{
  CmdAliasDescr_t *alias = (CmdAliasDescr_t *) value;

  CmdFreeArgv(alias->argc, alias->argv);
  FREE(alias->name);            /* same as key */
  FREE(alias);
}



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

static int
CommandTime(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  static long last_time_u = 0;
  static long last_time_c = 0;
  long time;
  int c;
  boolean excludeChildren = FALSE;

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

  if (argc != util_optind) {
    goto usage;
  }

  if (excludeChildren) {
    time = util_cpu_time();
    (void) fprintf(vis_stdout,
                   "elapse: %2.1f seconds, total: %2.1f seconds\n",
                   (time - last_time_u) / 1000.0, time / 1000.0);
    last_time_u = time;
  } else {
    time = util_cpu_ctime();
    (void) fprintf(vis_stdout,
                   "elapse: %2.1f seconds, total: %2.1f seconds\n",
                   (time - last_time_c) / 1000.0, time / 1000.0);
    last_time_c = time;
  }
  return 0;

usage:
  (void) fprintf(vis_stderr, "usage: time [-h][-u]\n");
  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
  (void) fprintf(vis_stderr, "   -u \t\texclude child process time\n");
  return 1;
}

static int
CommandEcho(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int i;
  int c;

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

  for(i = 1; i < argc; i++) {
    (void) fprintf(vis_stdout, "%s ", argv[i]);
  }
  (void) fprintf(vis_stdout, "\n");
  return 0;

  usage:
  (void) fprintf(vis_stderr, "usage: echo [-h] string \n");
  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
  return (1);
}

static int
CommandSetBddParameters(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  Ntk_Network_t *network;
  boolean  showAfter;
  int      c;

  showAfter = FALSE;
  network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);

  /*
   * Parse the command line.
   */
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "hs")) != EOF) {
    switch (c) {
      case 'h':
        goto usage;
      case 's':
        showAfter = TRUE;
        break;
      default:
        goto usage;
    }
  }

  /* flatten_hierarchy and static_order must have been invoked already. */
  if (network == NIL(Ntk_Network_t)) {
    return 1;
  }
  if (!Ntk_NetworkReadMddManager(network)) {
    (void) fprintf(vis_stderr, "The MDD variables have not been ordered. ");
    (void) fprintf(vis_stderr, "Use static_order.\n");
    return 1;
  }

  /* Create the table of variable->value */
  bdd_set_parameters(Ntk_NetworkReadMddManager(network), cmdFlagTable,
                     vis_stdout);

  if (showAfter) {
    bdd_print_stats(Ntk_NetworkReadMddManager(network), vis_stdout);
  }

  return 0;  /* Everything okay */

usage:
  (void) fprintf(vis_stderr, "usage: set_bdd_parameters [-h] [-s]\n");
  (void) fprintf(vis_stderr, "   -h  print the command usage\n");
  (void) fprintf(vis_stderr, "   -s  print also the bdd statistics\n");

  return 1;
}

static int
CommandMemoryProfile(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{

  int   c;
  char  options[128];
#ifdef PURIFY
  char  tmpFileName[128];
  FILE  *fp;
  char  command[256];
  char  *visDirectoryName;
  int   systemStatus;
#endif

  /*
   * Parse command line options.
   */
  options[0] = 0;
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "f:hpu:")) != EOF) {
    switch(c) {
      case 'f':
        strcat(options, " -f ");
        strcat(options, util_optarg);
        break;
      case 'h':
        goto usage;
      case 'p':
        strcat(options, " -p ");
        break;
      case 'u':
        strcat(options, " -u ");
        strcat(options, util_optarg);
        break;
      default:
        goto usage;
    }
  }


#ifdef PURIFY
  /* Flag to remember that a file has been created by purify */
  fileCreated = TRUE;

  /* Obtain the name of a temporary file */
  tmpnam(tmpFileName);

  /* Kick purify to dump the data in the file */
  purify_all_inuse();

  /* Obtain the path to the perl script */
  visDirectoryName = Vm_VisObtainLibrary();

  /* Prepare the string to be sent to a shell */
  (void)sprintf(command, "%s/memoryaccount %s %s/.fmap ./.fmap >%s",
                visDirectoryName, options, visDirectoryName,
                tmpFileName);

  /* Effectively execute the perlscript */
  systemStatus = system(command);
  if (systemStatus != 0) {
    return 1;
  }

  fp = Cmd_FileOpen(tmpFileName, "r", NIL(char *), 1);

  /* Check if the open has been successful */
  if (fp == NIL(FILE)) {
    (void) fprintf(vis_stderr, "** cmd error: File %s was not found\n", tmpFileName);
    return 1;
  }

  /* Dump the contents of the result file in vis_stdout */
  while(fgets(command, 128, fp) != NIL(char)) {
    (void) fprintf(vis_stdout, "%s", command);
  }
  fclose(fp);

  /* Remove the temporary file */
#if HAVE_UNLINK
  unlink(tmpFileName);
#endif
#else
  (void) fprintf(vis_stderr, "** cmd error: Command not available: Vis has not been ");
  (void) fprintf(vis_stderr, "compiled with purify.\n");
#endif

  return 0;             /* normal exit */

  usage:
  (void) fprintf(vis_stderr, "usage: _memory_profile [-f <filename>] [-h] ");
  (void) fprintf(vis_stderr, "[-p] [-u <units>] <filenames>\n");
  (void) fprintf(vis_stderr, "   -f <file>\tFile to read the purify dump");
  (void) fprintf(vis_stderr, " from. The default is purify.log\n");
  (void) fprintf(vis_stderr, "   -h\t\tprint the command usage\n");
  (void) fprintf(vis_stderr, "   -p\t\tPrint also the packages that do not ");
  (void) fprintf(vis_stderr, " allocate any memory\n");
  (void) fprintf(vis_stderr, "   -u <units>\tUnits to print the memory usage");
  (void) fprintf(vis_stderr, " in. It may be b for bytes\n");
  (void) fprintf(vis_stderr, "     \t\tk for kilobytes, m for megabytes and ");
  (void) fprintf(vis_stderr, "g for gigabutes.\n");
  return 1;             /* error exit */
}


static int
CommandQuit(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int c;

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

  if ( argc != util_optind){
    goto usage;
  }
  return -1;

  usage:
    (void)fprintf(vis_stderr, "usage: quit [-h] [-s]\n");
    (void)fprintf(vis_stderr, "   -h  print the command usage\n");
    (void)fprintf(vis_stderr, "   -s  frees all the memory before quitting\n");
    return 1;
}

static int
CommandUsage(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int c;

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

  if (argc != util_optind){
    goto usage;
  }
  util_print_cpu_stats(vis_stdout);
  return 0;

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

static int
CommandWhich(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  FILE *fp;
  char *filename;
  int c;

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

  if (argc-1 != util_optind){
    goto usage;
  }

  fp = Cmd_FileOpen(argv[1], "r", &filename, 0);
  if (fp != 0) {
    (void) fprintf(vis_stdout, "%s\n", filename);
    (void) fclose(fp);
  }
  FREE(filename);
  return 0;

  usage:
    (void)fprintf(vis_stderr,"usage: which [-h] file_name\n");
    (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
    return 1;
}


static int
CommandHistory(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int i, num, lineno;
  int size;
  int c;

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

  if (argc > 3) {
    goto usage;
  }
  num = 30;
  lineno = 1;
  for (i = 1; i < argc; i++) {
    if (argv[i][0] == '-') {
      if (argv[i][1] == 'h') {
        lineno = 0;
      }
      else {
        goto usage;
      }
    }
    else {
      num = atoi(argv[i]);
      if (num <= 0) {
        goto usage;
      }
    }
  }
  size = array_n(vm_commandHistoryArray);
  num = (num < size) ? num : size;
  for (i = size - num; i < size; i++) {
    if (lineno != 0) {
      (void) fprintf(vis_stdout, "%d\t", i + 1);
    }
    (void) fprintf(vis_stdout, "%s\n", array_fetch(char *, vm_commandHistoryArray, i));
  }
  return(0);

usage:
  (void) fprintf(vis_stderr, "usage: history [-h] [num]\n");
  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
  (void) fprintf(vis_stderr, "   num \t\tprint the last num commands\n");
  return(1);
}




static int
CommandAlias(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int i;
  char *key, *value;
  CmdAliasDescr_t *alias;
  avl_generator *gen;
  int status;
  int c;

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


  if (argc == 1) {
    avl_foreach_item(cmdAliasTable, gen, AVL_FORWARD, &key, &value) {
      print_alias(value);
    }
    return 0;

  }
  else if (argc == 2) {
    if (avl_lookup(cmdAliasTable, argv[1], &value)) {
      print_alias(value);
    }
    return 0;
  }

  /* delete any existing alias */
  key = argv[1];
  if (avl_delete(cmdAliasTable, &key, &value)) {
    CmdAliasFree(value);
  }

  alias = ALLOC(CmdAliasDescr_t, 1);
  alias->name = util_strsav(argv[1]);
  alias->argc = argc - 2;
  alias->argv = ALLOC(char *, alias->argc);
  for(i = 2; i < argc; i++) {
    alias->argv[i-2] = util_strsav(argv[i]);
  }
  status = avl_insert(cmdAliasTable, alias->name, (char *) alias);
  assert(!status);  /* error here in SIS version, TRS, 8/4/95 */
  return 0;

  usage:
    (void) fprintf(vis_stderr, "usage: alias [-h] [command [string]]\n");
    (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
    return (1);
}


static int
CommandUnalias(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int i;
  char *key, *value;
  int c;

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

  if (argc < 2) {
    goto usage;
  }

  for(i = 1; i < argc; i++) {
    key = argv[i];
    if (avl_delete(cmdAliasTable, &key, &value)) {
      CmdAliasFree(value);
    }
  }
  return 0;

  usage:
    (void) fprintf(vis_stderr, "usage: unalias [-h] alias_names\n");
    (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
    return 1;
}


static int
CommandSetVariable(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  char *flag_value, *key, *value;
  avl_generator *gen;
  int c;

  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "h")) != EOF) {
    switch(c) {
      case 'h':
        goto usage;
      default:
        goto usage;
    }
  }
  if (argc == 0 || argc > 3) {
    goto usage ;
  }
  else if (argc == 1) {
    avl_foreach_item(cmdFlagTable, gen, AVL_FORWARD, &key, &value) {
      (void) fprintf(vis_stdout, "%s\t%s\n", key, value);
    }
    return 0;
  }
  else {
    key = argv[1];
    if (avl_delete(cmdFlagTable, &key, &value)) {
      FREE(key);
      FREE(value);
    }

    flag_value = argc == 2 ? util_strsav("") : util_strsav(argv[2]);

    (void) avl_insert(cmdFlagTable, util_strsav(argv[1]), flag_value);

    if (strcmp(argv[1], "vis_stdout") == 0) {
      if (vis_stdout != stdout) {
        (void) fclose(vis_stdout);
      }
      if (strcmp(flag_value, "") == 0) {
        flag_value = "-";
      }
      vis_stdout = Cmd_FileOpen(flag_value, "w", NIL(char *), 0);
      if (vis_stdout == NULL) {
        vis_stdout = stdout;
      }
#if HAVE_SETVBUF
      setvbuf(vis_stdout, (char *)NULL, _IOLBF, 0);
#endif
    }
    if (strcmp(argv[1], "vis_stderr") == 0) {
      if (vis_stderr != stderr) {
        (void) fclose(vis_stderr);
      }
      if (strcmp(flag_value, "") == 0) {
        flag_value = "-";
      }
      vis_stderr = Cmd_FileOpen(flag_value, "w", NIL(char *), 0);
      if (vis_stderr == NULL) {
        vis_stderr = stderr;
      }
#if HAVE_SETVBUF
      setvbuf(vis_stderr, (char *)NULL, _IOLBF, 0);
#endif
    }
    if (strcmp(argv[1], "history") == 0) {
      if (vis_historyFile != NIL(FILE)) {
        (void) fclose(vis_historyFile);
      }
      if (strcmp(flag_value, "") == 0) {
        vis_historyFile = NIL(FILE);
      }
      else {
        vis_historyFile = Cmd_FileOpen(flag_value, "w", NIL(char *), 0);
        if (vis_historyFile == NULL) {
          vis_historyFile = NIL(FILE);
        }
      }
    }
    return 0;
  }

  usage:
      (void) printf("usage: set [-h] [name] [value]\n");
      (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
      return 1;

}


static int
CommandUnsetVariable(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int i;
  char *key, *value;
  int c;

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

  if (argc < 2) {
    goto usage;
  }

  for(i = 1; i < argc; i++) {
    key = argv[i];
    if (avl_delete(cmdFlagTable, &key, &value)) {
      FREE(key);
      FREE(value);
    }
  }
  return 0;


  usage:
    (void) fprintf(vis_stderr, "usage: unset [-h] variables \n");
    (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");
    return 1;
}

static int
CommandHelp(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int c, i, all;
  char *key;
  avl_generator *gen;
  char buffer[1024];
  char *command;
  char *lib_name;
#if HAVE_GETENV
  char *pager;
#endif


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

  if (argc - util_optind == 0) {
    fprintf(vis_stderr,"List of commands:\n");
    i = 0;
    avl_foreach_item(cmdCommandTable, gen, AVL_FORWARD, &key, NIL(char *)) {
      if ((key[0] == '_') == all) {
        (void) fprintf(vis_stdout, "%-26s", key);
        if ((++i%3) == 0) {
          (void) fprintf(vis_stdout, "\n");
        }
      }
    }
    if ((i%3) != 0) {
      (void) fprintf(vis_stdout, "\n");
    }
  }
  else if (argc - util_optind == 1) {
    command = command_alias_help(argv[util_optind]);
    lib_name = Vm_VisObtainLibrary();
#if HAVE_GETENV
    pager = getenv("PAGER");
    if (pager != NULL) {
      (void) sprintf(buffer, "%s %s/help/%sCmd.txt", pager, lib_name, command);
    } else {
      (void) sprintf(buffer, "more %s/help/%sCmd.txt", lib_name, command);
    }
#else
    (void) sprintf(buffer, "more %s/help/%sCmd.txt", lib_name, command);
#endif
    (void) system(buffer);
    FREE(lib_name);
  }
  else {
    goto usage;
  }

  return 0;

usage:
  (void) fprintf(vis_stderr, "usage: help [-a] [-h] [command]\n");
  (void) fprintf(vis_stderr, "   -a \t\tprint help for all commands\n");
  (void) fprintf(vis_stderr, "   -h \t\tprint the command usage\n");

  return 1;
}

#if 0
Change "/*!*Function" to "/**Function" when reactivate command
/*!*Function********************************************************************

  Synopsis          [Implements the undo command.]

  CommandName       [undo]

  CommandSynopsis   [undo the result of the last command which changed the network]

  CommandDescription [ A simple 1-level undo is supported.
  It reverts the network to its state before the last command which
  changed the network.  Note that interrupting a command (with ^C)
  which changes the network uses up the one level of undo.<p> ]

  SideEffects        []

******************************************************************************/
static int
CommandUndo(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  if (argc != 1) {
    (void) fprintf(vis_stderr, "usage: undo\n");
    return 1;
  }

  (void) fprintf(vis_stderr, "** cmd error: undo: not yet implemented\n");
  return 1;

#if 0

  /*
   * FIX (Tom): can't enable "undo" until network_dup and hmgr_dup exist.
   */
  if (cmdBackupHmgr == NIL(Hrc_Manager_t)) {
    (void) fprintf(vis_stderr, "undo: no hmgr currently saved\n");
    return 1;
  }
  else {

    /* Swap the current and backup. */
    Hrc_Manager_t *temp = *hmgr;
    *hmgr = cmdBackupHmgr;
    cmdBackupHmgr = temp;
    return 0;
  }
#endif
}
#endif



static int
CommandSource(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int c, echo, prompt, silent, interactive, quit_count, lp_count;
  int status = 0; /* initialize so that lint doesn't complain */
  int lp_file_index, did_subst;
  char *prompt_string, *real_filename, line[MAX_STR], *command;
  FILE *fp;

  interactive = silent = prompt = echo = 0;

  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "hipsx")) != EOF) {
    switch(c) {
        case 'h':
          goto usage ;
        case 'i':               /* a hack to distinguish EOF from stdin */
          interactive = 1;
          break;
        case 'p':
          prompt = 1;
          break;
        case 's':
          silent = 1;
          break;
        case 'x':
          echo = 1;
          break;
      default:
          goto usage;
    }
  }

  /* added to avoid core-dumping when no script file is specified */
  if (argc == util_optind){
    goto usage;
  }

  lp_file_index = util_optind;
  lp_count = 0;

  /*
   * FIX (Tom, 5/7/95):  I'm not sure what the purpose of this outer do loop
   * is. In particular, lp_file_index is never modified in the loop, so it
   * looks it would just read the same file over again.  Also, SIS had
   * lp_count initialized to -1, and hence, any file sourced by SIS (if -l or
   * -t options on "source" were used in SIS) would actually be executed
   * twice.
   */
  do {
    lp_count ++; /* increment the loop counter */

    fp = Cmd_FileOpen(argv[lp_file_index], "r", &real_filename, silent);
    if (fp == NULL) {
      FREE(real_filename);
      return ! silent;  /* error return if not silent */
    }

    quit_count = 0;
    do {
      if (prompt) {
        prompt_string = Cmd_FlagReadByName("prompt");
        if (prompt_string == NIL(char)) {
          prompt_string = "vis> ";
        }

      }
      else {
        prompt_string = NIL(char);
      }

      /* clear errors -- e.g., EOF reached from stdin */
      clearerr(fp);

      /* read another command line */
      if (CmdFgetsFilec(line, MAX_STR, fp, prompt_string) == NULL) {
        if (interactive) {
          if (quit_count++ < 5) {
            (void) fprintf(vis_stderr, "\nUse \"quit\" to leave VIS.\n");
            continue;
          }
          status = -1;          /* fake a 'quit' */
        }
        else {
          status = 0;           /* successful end of 'source' ; loop? */
        }
        break;
      }
      quit_count = 0;

      if (echo) {
        (void) fprintf(vis_stdout, "%s", line);
      }
      command = CmdHistorySubstitution(line, &did_subst);
      if (command == NIL(char)) {
        status = 1;
        break;
      }
      if (did_subst) {
        if (interactive) {
          (void) fprintf(stdout, "%s\n", command);
        }
      }
      if (command != line) {
        (void) strcpy(line, command);
      }
      if (interactive && *line != '\0') {
        array_insert_last(char *, vm_commandHistoryArray, util_strsav(line));
        if (vis_historyFile != NIL(FILE)) {
          (void) fprintf(vis_historyFile, "%s\n", line);
          (void) fflush(vis_historyFile);
        }
      }

      status = Cmd_CommandExecute(hmgr, line);
    } while (status == 0);

    if (fp != stdin) {
      if (status > 0) {
        (void) fprintf(vis_stderr, "** cmd error: aborting 'source %s'\n", real_filename);
      }
      (void) fclose(fp);
    }
    FREE(real_filename);

  } while ((status == 0) && (lp_count <= 0));

  return status;

usage:
  (void) fprintf(vis_stderr, "source [-h] [-p] [-s] [-x] file_name\n");
  (void) fprintf(vis_stderr, "\t-h print the command usage\n");
  (void) fprintf(vis_stderr, "\t-p supply prompt before reading each line\n");
  (void) fprintf(vis_stderr, "\t-s silently ignore nonexistent file\n");
  (void) fprintf(vis_stderr, "\t-x echo each line as it is executed\n");
  return 1;
}

static void
print_alias(
  char * value)
{
  int i;
  CmdAliasDescr_t *alias;

  alias = (CmdAliasDescr_t *) value;
  (void) fprintf(vis_stdout, "%s\t", alias->name);
  for(i = 0; i < alias->argc; i++) {
    (void) fprintf(vis_stdout, " %s", alias->argv[i]);
  }
  (void) fprintf(vis_stdout, "\n");
}


static char *
command_alias_help(
  char * command)
{
  char *value;
  CmdAliasDescr_t *alias;

  if (!avl_lookup(cmdAliasTable, command, &value)) {
    return command;
  }
  alias = (CmdAliasDescr_t *) value;
  return alias->argv[0];
}

static void
FlushBuffers(
  int sigtype)
{
  fflush(vis_stdout);
  fflush(vis_stderr);

  /* Reprogram again the handler */
#ifdef SIGUSR1
  (void) signal(SIGUSR1, FlushBuffers);
#endif
} /* End of FlushBuffers */