src/rst/rstGroup.c

Go to the documentation of this file.

#include <stdio.h>
#include "rstInt.h"
#include "cmd.h"
#include "varInt.h"

static char rcsid[] UNUSED = "$Id: rstGroup.c,v 1.9 2005/05/16 06:22:35 fabio Exp $";

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/

/*
#define RST_GROUP_DEBUG 1
*/

/*---------------------------------------------------------------------------*/
/* Structure declarations                                                    */
/*---------------------------------------------------------------------------*/

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

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

#define Rst_VarForEachVarInArray( \
  /* array_t* */          array,  \
  /* int, local */        i,      \
  /* Var_Variable_t* */   var     \
)                                 \
arrayForEachItem(Var_Variable_t*, array, i, var)

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


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



/*
  This was moved to VAR package by Yuji on 11/8 and renamed to
  Var_VariableResetNumFanoutTables()
  
  void
Var_VariableResetNumFanout(
  Var_Variable_t* var)
{
  var->numFanoutTables = 0;
}
*/


Tbl_Table_t*
Tbl_TableDupAndSubstVars(
  Tbl_Table_t* Table,
  st_table* VartoVar)
{
  int tblIndx, retVal;
  Var_Variable_t *var, *newVar;
  Tbl_Table_t* newTbl = Tbl_TableHardDup(Table);
  
  Tbl_TableForEachInputVar(newTbl, tblIndx, var) {
    retVal = st_lookup(VartoVar, (char*) var, &newVar);
    assert(retVal);
    Tbl_TableSubstituteVar(newTbl, var, newVar);
    Var_VariableIncrementNumFanoutTables(newVar);
  }
  Tbl_TableForEachOutputVar(newTbl, tblIndx, var) {
    retVal = st_lookup(VartoVar, (char*) var,&newVar);
    assert(retVal);
    Tbl_TableSubstituteVar(newTbl, var, newVar);
  }
  return newTbl;
}

array_t*
Rst_VartoVarLookup(
  array_t* VarArray,
  st_table* VartoVarOne,
  st_table* VartoVarTwo)
{
  int i, retVal;
  Var_Variable_t *var, *newVar, *tmpVar;
  array_t* newVarArray = array_alloc(Var_Variable_t*, array_n(VarArray));

  Rst_VarForEachVarInArray(VarArray, i, var) {
    retVal = st_lookup(VartoVarOne, (char*) var, &newVar);
    assert(retVal);
    if (VartoVarTwo) {
      tmpVar = newVar;
      retVal = st_lookup(VartoVarTwo, (char*) tmpVar, &newVar);
    }
    assert(retVal);
    array_insert(Var_Variable_t*, newVarArray, i, newVar);
  }
  return newVarArray;
}

array_t*
Rst_GetNamesUntilNextOption(
  array_t* nameArray,
  int argc,
  char **argv)
{
  char* name;

  while ((util_optind < argc) && (*argv[util_optind] != '-')) {
    name = util_strcat3(argv[util_optind], "", "");
    array_insert_last(char*, nameArray, name);
    util_optind++;
  }
  return nameArray;
}

array_t*
Rst_LoadNameArrayFromFile(
  array_t* nameArray,
  FILE* fp)
{
  char* name;
  char buffer[1024];

  while (fscanf(fp, "%s", buffer) != EOF) {
    name = util_strcat3(buffer, "", "");
    array_insert_last(char*, nameArray, name);
  }
  return nameArray;
}

Rst_Group_t*
RstGroupComponents(
  Hrc_Model_t* CurModel,
  char* NewName,
  array_t* VarGroup,
  array_t* Subcircuits)
{
  int i, j, tblIndx;
  long inGroup;  
  char* latchName, *subcktName;
  Hrc_Latch_t* latch;
  Hrc_Subckt_t* subckt;
  Hrc_Node_t* curMaster;
  st_generator* sgen;
  Tbl_Table_t* tbl;
  Var_Variable_t* var = NIL(Var_Variable_t);
  array_t* subOutputs;
  Rst_Group_t* group = RstGroupAlloc(NewName);

  curMaster = Hrc_ModelReadMasterNode(CurModel);

  /* Make sure there is something to group */
  i=0;
  if (VarGroup) {
    i += array_n(VarGroup);
  }
  if (Subcircuits) {
    i += array_n(Subcircuits);
  }
  if (i == 0) {
    return 0;
  }

  /* Determine Input/Output Formal list from implied partitioning */

  if (VarGroup) {
    /* Store group variables (ie outputs of tables/latches) in hash
       table */
    Rst_VarForEachVarInArray(VarGroup, i, var) {
      if ((var) && (! Var_VariableTestIsPI(var))) {
        st_insert(group->Vars, (char*) var, (char*) (long) 1);
      } else if ((var) && (Var_VariableTestIsPI(var))) {
        (void) fprintf(vis_stderr,
                       "Warning: can't group a PI: %s\n",
                       Var_VariableReadName(var));
      }
    }
  }

  if (Subcircuits) {
    /* Store Subckt in group Subcircuits hashtable.
       Store output vars of all group Subckts in var hash table */
    for (i = 0; i < array_n(Subcircuits); i++) {
      subckt = array_fetch(Hrc_Subckt_t*, Subcircuits, i);
      st_insert(group->Subcircuits, (char*) subckt, (char*) (long) 1);
      Rst_VarForEachVarInArray(Hrc_SubcktReadActualOutputVars(subckt),
                               j, var) {
        if (! st_lookup(group->Vars, (char*) var, &inGroup)) {
          st_insert(group->Vars, (char*) var, (char*) (long) 1);
        }
      }
    }
  }

  /* Table and Latch outputs which are group vars become members of the group
   */
  
  Hrc_NodeForEachLatch(curMaster, sgen, latchName, latch) {
    if (st_lookup(group->Vars, (char*) Hrc_LatchReadOutput(latch), &inGroup)) {
      st_insert(group->Latches, (char*) latch, (char*) (long) 1);
    }
  }
  
  Hrc_NodeForEachNameTable(curMaster, tblIndx, tbl) {
    Tbl_TableForEachOutputVar(tbl, j, var) {
      inGroup = 0;
      if (st_lookup(group->Vars, (char*) var, &inGroup)) {
        st_insert(group->Tables, (char*) tbl, (char*) (long) 1);
        break;
      }
    }
    /* FIXME: Table Splitting here */
    
    if ((inGroup)  && (Tbl_TableReadNumOutputs(tbl) > 1)) {
      (void) fprintf(vis_stderr,
                     "WARNING: multi-output table %s moved to group %s\n",
                     Var_VariableReadName(var), group->name);
    }
  }
  /* If outputs of a subckt are in a group, the subckt moves
     into the group */
  
  Hrc_ModelForEachSubckt(CurModel, sgen, subcktName, subckt) {
    Var_Variable_t* outVar = NIL(Var_Variable_t); /* initialize to pacify */
    if (! st_lookup(group->Subcircuits, (char*) subckt, &inGroup)) {
      subOutputs = Hrc_SubcktReadActualOutputVars(subckt);
      Rst_VarForEachVarInArray(subOutputs, i, outVar) {
        if (st_lookup(group->Vars, (char*) outVar, &inGroup)) {
          break;
        }
      }
      if (i < array_n(subOutputs)) {
        Rst_VarForEachVarInArray(subOutputs, j, var) {
          if (! st_lookup(group->Vars, (char*) var, &inGroup)) {
            st_insert(group->Vars, (char*) var, (char*) (long) 1);
          }
        }
        st_insert(group->Subcircuits, (char*) subckt, (char*) (long) 1);
        (void) fprintf(vis_stderr,
                       "Warning: instance %s becomes member of group %s",
                       subcktName, group->name);
        (void) fprintf(vis_stderr, " because of output variable %s\n",
                       Var_VariableReadName(outVar));
      }
    }
  }
  
  /* Group Outputs: Scan parent outputs for group vars. Scan non-group
     component (Subcircuits/Latches/Tables) inputs for group vars */

  Hrc_NodeForEachFormalOutput(curMaster, i, var) {
    if ((st_lookup(group->Vars, (char*) var, &inGroup)) &&
        (! st_lookup(group->Outputs, (char*) var, &inGroup))) {
      st_insert(group->Outputs, (char*) var, (char*) (long) 1);
    }
  }

  Hrc_ModelForEachSubckt(CurModel, sgen, subcktName, subckt) {
    if (! st_lookup(group->Subcircuits, (char*) subckt, &inGroup)) {
      Rst_VarForEachVarInArray(Hrc_SubcktReadActualInputVars(subckt), i, var) {
        if ((st_lookup(group->Vars, (char*) var, &inGroup)) &&
            (! st_lookup(group->Outputs, (char*) var, &inGroup))) {
            st_insert(group->Outputs, (char*) var, (char*) (long) 1);
        }
      }
    }
  }
  Hrc_NodeForEachLatch(curMaster, sgen, latchName, latch) {
    if (! st_lookup(group->Latches, (char*) latch, &inGroup)) {
      var = Hrc_LatchReadInput(latch);
      if ((st_lookup(group->Vars, (char*) var, &inGroup)) &&
          (! st_lookup(group->Outputs, (char*) var, &inGroup))) {
        st_insert(group->Outputs, (char*) var, (char*) (long) 1);
      }
    }
  }
  Hrc_NodeForEachNameTable(curMaster, i, tbl) {
    if (! st_lookup(group->Tables, (char*) tbl, &inGroup)) {
      Tbl_TableForEachInputVar(tbl, j, var) {
        if ((st_lookup(group->Vars, (char*) var, &inGroup)) &&
            (! st_lookup(group->Outputs, (char*) var, &inGroup))) {
          st_insert(group->Outputs, (char*) var, (char*) (long) 1);
        }
      }
    }
  }
  
  /* Group Inputs:  Scan group subcomponent inputs for non-group vars */

  /* Formal inputs are never vars of a group.  Thus, they are always
     non-group vars when are inputs to group subcomponents, and are
     caught by the code below*/
  
  Hrc_ModelForEachSubckt(CurModel, sgen, subcktName, subckt) {
    if (st_lookup(group->Subcircuits, (char*) subckt, &inGroup)) {
      Rst_VarForEachVarInArray(Hrc_SubcktReadActualInputVars(subckt), i, var) {
        if ((! st_lookup(group->Vars, (char*) var, &inGroup)) &&
            (! st_lookup(group->Inputs, (char*) var, &inGroup))) {
          st_insert(group->Inputs, (char*) var, (char*) (long) 1);
        }
      }
    }
  }
  Hrc_NodeForEachLatch(curMaster, sgen, latchName, latch) {
    if (st_lookup(group->Latches, (char*) latch, &inGroup)) {
      var = Hrc_LatchReadInput(latch);
      if ((! st_lookup(group->Vars, (char*) var, &inGroup)) &&
          (! st_lookup(group->Inputs, (char*) var, &inGroup))) {
        st_insert(group->Inputs, (char*) var, (char*) (long) 1);
      }
      /* Reset table here */
      tbl = Hrc_LatchReadResetTable(latch);
      Tbl_TableForEachInputVar(tbl, j, var) {
        if (! st_lookup(group->Vars, (char*) var, &inGroup))
          st_insert(group->Vars, (char*) var, (char*) (long) 1);
      }
    }
  }
  Hrc_NodeForEachNameTable(curMaster, tblIndx, tbl) {
    if (st_lookup(group->Tables, (char*) tbl, &inGroup)) {
      Tbl_TableForEachInputVar(tbl, j, var) {
        if ((! st_lookup(group->Vars, (char*) var, &inGroup)) &&
            (! st_lookup(group->Inputs, (char*) var, &inGroup))) {
          st_insert(group->Inputs, (char*) var, (char*) (long) 1);
        }
      }
    }
  }

  return group;
}

Hrc_Model_t*
Rst_GroupRestructureModel(
  Hrc_Manager_t* Hmgr,
  Hrc_Model_t* ParentModel,
  array_t* GroupArray)
{
  int i, j;
  char *newModelName;
  st_generator *sgen;
  Var_Variable_t *var, *newVar;
  Hrc_Model_t *newModel, *newParentModel;
  Hrc_Node_t *newMaster;
  Rst_Group_t *group, *parentGroup;
  st_table *varForwPtr;
  array_t *newModelArray, *newMasterArray, *newNodeArray;

  for (i = 0; i < array_n(GroupArray); i++) {
    group = array_fetch(Rst_Group_t*, GroupArray, i);
#ifdef RST_GROUP_DEBUG
    RstGroupPrint(group);
#endif
  }
  /* Check group components for disjointness */

  if (RstGroupDisjointCheck(GroupArray))
    return 0;

  /* Construct a level of hierarchy for each group */

  newModelArray = array_alloc(Hrc_Model_t*, array_n(GroupArray));
  newMasterArray = array_alloc(Hrc_Node_t*, array_n(GroupArray));
  newNodeArray = array_alloc(Hrc_Node_t*, array_n(GroupArray));
  
  for (i = 0; i < array_n(GroupArray); i++) {
    group = array_fetch(Rst_Group_t*, GroupArray, i);
    newModel = RstGroupBuildModel(Hmgr, group);
    if (! newModel) {
      return 0;
    }
    newMaster = Hrc_ModelReadMasterNode(newModel);
    array_insert(Hrc_Model_t*, newModelArray, i, newModel);
    array_insert(Hrc_Node_t*, newMasterArray, i, newMaster);
  }

  /* Build the new parent hierarchy */
  
  newModelName = RstGroupNewParentName(Hrc_ModelReadName(ParentModel));
  parentGroup = RstCreateParentGroup(Hmgr, ParentModel, newModelName,
                                      GroupArray);
  FREE(newModelName);
  if (! parentGroup) {
    return 0;
  }
#ifdef RST_GROUP_DEBUG
  RstGroupPrint(parentGroup);
#endif
  newParentModel = RstGroupBuildModel(Hmgr, parentGroup);

  /* Computing actuals:  Group IO vars USED to be in the old parent.
     1) lookup what the new IO vars used to be in the old parent
     2) In the old parent, find the correspond new parent vars
     */
  
  /* Build Table: Parent to New Parent Vars, by reversing back pointers */

  varForwPtr = st_init_table(st_ptrcmp, st_ptrhash);
  st_foreach_item(parentGroup->VarBackPtr, sgen, &newVar, &var) {
    st_insert(varForwPtr, (char*) var, (char*) newVar);
  }

  /* Free parent group now */
  RstGroupFree(parentGroup); parentGroup = 0;
  
  /* Instantiate groups as subckts */

  for (i = 0; i < array_n(GroupArray); i++) {
    array_t* actualInputArray, *actualOutputArray;

    group = array_fetch(Rst_Group_t*, GroupArray, i);
    newModel = array_fetch(Hrc_Model_t*, newModelArray, i);
    newMaster = Hrc_ModelReadMasterNode(newModel);

    actualInputArray =
      Rst_VartoVarLookup(Hrc_NodeReadFormalInputs(newMaster),
                         group->VarBackPtr, varForwPtr);
    actualOutputArray =
      Rst_VartoVarLookup(Hrc_NodeReadFormalOutputs(newMaster),
                         group->VarBackPtr, varForwPtr);

    Hrc_ModelAddSubckt(newParentModel, newModel, group->name, 
                       actualInputArray, actualOutputArray);
    Rst_VarForEachVarInArray(actualInputArray, j, var) {
      Var_VariableSetSI(var);
    }
    Rst_VarForEachVarInArray(actualOutputArray, j, var) {
      Var_VariableSetSO(var);
    }
  }
  array_free(newModelArray);
  array_free(newMasterArray);
  array_free(newNodeArray);

  st_free_table(varForwPtr);
  return newParentModel;
}

Hrc_Node_t*
Rst_GroupRestructureNode(
  Hrc_Manager_t* Hmgr,
  Hrc_Node_t* CurNode,
  array_t* GroupArray)
{
  int retVal;
#ifdef RST_GROUP_DEBUG
  st_generator* sgen;
  char* childName;
  Hrc_Node_t *child;
#endif  
  Hrc_Model_t *newParentModel;
  Hrc_Node_t *newNode = 0;
  Hrc_Model_t* CurModel=
    Hrc_ManagerFindModelByName(Hmgr, Hrc_NodeReadModelName(CurNode));

  newParentModel = Rst_GroupRestructureModel(Hmgr, CurModel, GroupArray);
  if (newParentModel) {

    newNode = Hrc_ModelCreateHierarchy(Hmgr, newParentModel,
                                       Hrc_NodeReadInstanceName(CurNode));

#ifdef RST_GROUP_DEBUG
    (void) fprintf(vis_stderr, "Checking New Node\n");
    assert(Hrc_NodeCheckVariableConsistency(newNode));
    (void) fprintf(vis_stderr, "Checking Subcircuits\n");
    Hrc_NodeForEachChild(newNode, sgen, childName, child) {
      assert(Hrc_NodeCheckVariableConsistency(child));
    }
#endif
  
    retVal = Hrc_TreeReplace(CurNode, newNode);
    assert(retVal);
    Hrc_ManagerSetCurrentNode(Hmgr, newNode);
  }
  return newNode;
}

Hrc_Model_t*
Rst_GroupGroupCombLogic(
  Hrc_Manager_t* Hmgr,
  Hrc_Model_t* CurModel)
{
  long inGroup;
  int tblIndx, varIndx;
  Var_Variable_t *var;
  Tbl_Table_t* tbl;
  array_t* varArray = array_alloc(Var_Variable_t*, 0);
  Rst_Group_t *group;
  st_table *tableOutputs = st_init_table(st_ptrcmp, st_ptrhash);
  Hrc_Node_t *curMaster;
  Hrc_Model_t* newModel;

  /* Perhaps this is better done with the NameTables so that we drop
     subckts from inclusion */

  curMaster = Hrc_ModelReadMasterNode(CurModel);

  Hrc_NodeForEachNameTable(curMaster, tblIndx, tbl) {
    Tbl_TableForEachOutputVar(tbl, varIndx, var) {
      if (! st_lookup(tableOutputs, (char*) var, &inGroup)) {
        st_insert(tableOutputs, (char*) var, (char*) (long) 1);
        array_insert_last(Var_Variable_t*, varArray, var);
      }
    }
  }
  st_free_table(tableOutputs);
  group = RstGroupComponents(CurModel,
                              util_strcat3(Hrc_ModelReadName(CurModel),
                                           "_comb", ""),
                              varArray, NULL);
  array_free(varArray);

  if (group) {
    array_t *groupArray = array_alloc(Rst_Group_t*, 1);
    array_insert_last(Rst_Group_t*, groupArray, group);
    newModel = Rst_GroupRestructureModel(Hmgr, CurModel, groupArray);
    array_free(groupArray);
    return newModel;
  }
  return 0;
}

Hrc_Model_t*
Rst_GroupGroupLatches(
  Hrc_Manager_t* Hmgr,
  Hrc_Model_t* CurModel)
{
  char *latchName;
  st_generator *sgen;
  Hrc_Latch_t *latch;
  array_t* varArray = array_alloc(Var_Variable_t*, 0);
  Rst_Group_t *group;
  Hrc_Node_t* curMaster = Hrc_ModelReadMasterNode(CurModel);
  Hrc_Model_t* newModel;

  Hrc_NodeForEachLatch(curMaster, sgen, latchName, latch) {
    array_insert_last(Var_Variable_t*, varArray, Hrc_LatchReadOutput(latch));
  }
  
  group = RstGroupComponents(CurModel,
                              util_strcat3(Hrc_ModelReadName(CurModel),
                                           "_latch", ""),
                              varArray, NULL);
  array_free(varArray);

  if (group) {
    array_t *groupArray = array_alloc(Rst_Group_t*, 1);
    array_insert_last(Rst_Group_t*, groupArray, group);
    newModel = Rst_GroupRestructureModel(Hmgr, CurModel, groupArray);
    array_free(groupArray);
    return newModel;
  }
  return 0;
}

int
Rst_CommandGroupComponents(
  Hrc_Manager_t** Hmgr,
  int  argc,
  char ** argv)
{
  enum { SUBCKT_GROUP, VAR_GROUP } readType = SUBCKT_GROUP;
  int c, i, retVal, tblIndx;
  st_generator *sgen;
  Rst_Group_t* group;
  Var_Variable_t* var;
  Hrc_Subckt_t* child;
  char *fileName, *varName, *childName, *latchName;
  char* groupName = 0;
  array_t *vars = 0, *children = 0;
  Hrc_Latch_t* latch;
  Tbl_Table_t* tbl;
  array_t* nameArray = 0;
  array_t* groupArray = array_alloc(Rst_Group_t*, 1);
  Hrc_Node_t* curNode = Hrc_ManagerReadCurrentNode(*Hmgr);
  Hrc_Node_t* curMaster;
  FILE* fp;
  Hrc_Model_t* CurModel;
  
  if (! curNode) {
    /* No node has been read in. The only sane thing we
       support is the -h option */
    array_free(groupArray); groupArray = 0;
    util_getopt_reset();
    if ((c = util_getopt(argc,argv,"h")) !=  EOF) {
      goto usage;
    }
    (void) fprintf(vis_stderr, "ERROR: no current Node\n");
    return 1;
  }

  CurModel=
      Hrc_ManagerFindModelByName(Hrc_NodeReadManager(curNode),
                                 Hrc_NodeReadModelName(curNode));
  curMaster = Hrc_ModelReadMasterNode(CurModel);

  /* This command processing loop is conceptually simple, but almost
    'goto' like and needs explanation.  The command line is a sequence
    of groups between which are specified component names to group.

    A group is started with a Naming operation '-n'. We get a list of
    component names to group either from the command line or from a
    file.  Names can be anywhere on the command line (except between
    -n/-f and their argument).  The names are interpreted as Variables
    or Children depending on the last -v or -c flag.  Children is the
    default setting on entry.

    After every option, we can read more names off command line, so we
    drop into this mode after completing a -n <name> or -f <file>
    operation.  This means we always drop into the outer 'default'.

     The goal is to collect a set of Variable and Child names for each
     Group Name specified.  */
  
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "n:f:cvtlh")) != EOF) {
    switch(c) {
        case 'n':               /* expects a Name arg */
        case 'f':               /* expects a filename arg */
          switch(c) {
              case 'n':         /* Name a new group */
                if (groupName != NULL) {
                  group = RstGroupComponents(CurModel, groupName,
                                              vars, children);
                  array_free(vars); vars = 0;
                  array_free(children); children = 0;
                  FREE(groupName);
                  if (group) {
                    array_insert_last(Rst_Group_t*, groupArray, group);
                  } else {
                    (void) fprintf(vis_stderr,
                                   "Warning: Incomplete group %s -- ignored\n",
                                   groupName);
                    RstGroupFree(group); group = 0;
                  }
                }
                vars = array_alloc(Var_Variable_t*, 0);
                children = array_alloc(Hrc_Subckt_t*, 0);
                groupName = util_strcat3(argv[util_optind -1], "","");
                break;
              case 'f':         /* Read component names from file */
                fileName = argv[util_optind - 1];
                fp = Cmd_FileOpen(util_optarg, "r", &fileName, 1);
                if (fp == NIL(FILE)) {
                  (void) fprintf(vis_stderr,
                                 "Could not open file %s\n", fileName);
                  return 1;
                }
                nameArray = array_alloc(char*, 0);
                Rst_LoadNameArrayFromFile(nameArray, fp);
                fclose(fp);
                break;
          }
          /* WE ALWAYS DROP IN HERE ON EVERY FLAG */
        default:
          if (! groupName && (c != 'h')) {
            (void) fprintf(vis_stderr, "ERROR: Group not defined yet\n");
            goto usage;
          }
          if (! nameArray) nameArray = array_alloc(char*, 0);
          switch(c) {
              case 'n':
              case 'f':
                break;
              case 'c': readType = SUBCKT_GROUP; break;
              case 'v': readType = VAR_GROUP; break;
              case 'l':
                /* Put latch ouput vars into group*/
                Hrc_NodeForEachLatch(curMaster, sgen, latchName, latch) {
                  var = Hrc_LatchReadOutput(latch);
                  array_insert_last(Var_Variable_t*, vars, var);
                }
                break;
              case 't':
                /* Put table ouput vars into group*/
                Hrc_NodeForEachNameTable(curMaster, tblIndx, tbl) {
                  Tbl_TableForEachOutputVar(tbl, i, var) {
                      array_insert_last(Var_Variable_t*, vars, var);
                  }
                }
                break;
              default: goto usage;
          }
          /* Grab any more names off the command line, appending if
             possible to nameArray */
          
          Rst_GetNamesUntilNextOption(nameArray, argc, argv);

          /* We store names read as either variable names or child names */
          
          switch(readType) {
              case VAR_GROUP:
                for (i=0; i < array_n(nameArray); i++) {
                  varName = array_fetch(char*, nameArray, i);
                  var = Hrc_NodeFindVariableByName(curMaster, varName);
                  if (var) {
                    array_insert_last(Var_Variable_t*, vars, var);
                  } else {
                    (void) fprintf(vis_stderr, "Could not find variable %s\n",
                                   varName);
                  }
                }
                break;
              case SUBCKT_GROUP:
                for (i=0; i < array_n(nameArray); i++) {
                  childName = array_fetch(char*, nameArray, i);
                  retVal = st_lookup(Hrc_ModelReadSubcktTable(CurModel),
                                     childName, &child);
                  if (retVal) {
                    array_insert_last(Hrc_Subckt_t*, children, child);
                  } else {
                    (void) fprintf(vis_stderr, "Could not find instance %s\n",
                                   childName);
                  }
                }
                break;
              default:          /* Unreached */
                break;
          }
          break;
    }
    for (i=0; i < array_n(nameArray); i++) {
      varName = array_fetch(char*, nameArray, i);
      FREE(varName);
    }
    array_free(nameArray); nameArray = 0;
  }
  if (groupName) {
    group = RstGroupComponents(CurModel, groupName, vars, children);
    if (group) 
      array_insert_last(Rst_Group_t*, groupArray, group);
    else
      (void) fprintf(vis_stderr, "Incomplete group %s\n", groupName);
    array_free(vars); vars = 0;
    array_free(children); children = 0;
    FREE(groupName);
  }

  if (array_n(groupArray) > 0) {
    Rst_GroupRestructureNode(*Hmgr, curNode, groupArray);
    for (i=0; i < array_n(groupArray); i++) {
      group = array_fetch(Rst_Group_t*, groupArray, i);
      RstGroupFree(group);
    }
    array_free(groupArray); groupArray = 0;
  } else {
    (void) fprintf(vis_stderr, "ERROR: no groups defined\n");
    array_free(groupArray);
    return 1;
  }
  return 0;                     /* normal exit */

usage:
   if (vars) array_free(vars); vars = 0;
   if (children) array_free(children); children = 0;
  FREE(groupName); groupName = 0;
  array_free(nameArray); nameArray = 0;
  array_free(groupArray);
  (void) fprintf(vis_stderr, "usage: decompose_child -n <groupname>");
  (void) fprintf(vis_stderr, " [-f <filename>] [-c] [-v] [<names>] [-t] [-l] [-h] \n");
  (void) fprintf(vis_stderr, "   -n\t\tName of new child group \n");
  (void) fprintf(vis_stderr, "   -f\t\tLoad names from file \n");
  (void) fprintf(vis_stderr, "   -c\t\tGroup by children toggle (default)\n");
  (void) fprintf(vis_stderr, "   -v\t\tGroup by variable toggle \n");
  (void) fprintf(vis_stderr, "   -l\t\tGroup latches\n");
  (void) fprintf(vis_stderr, "   -t\t\tGroup combinational logic tables \n");
  (void) fprintf(vis_stderr, "   -h\t\thelp \n");
  return 1;                     /* error exit */

}

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


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

Rst_Group_t*
RstGroupAlloc(char* Name)
{
  Rst_Group_t* group = ALLOC(Rst_Group_t, 1);

  group->Vars = st_init_table(st_ptrcmp, st_ptrhash);
  group->Latches = st_init_table(st_ptrcmp, st_ptrhash);
  group->Tables = st_init_table(st_ptrcmp, st_ptrhash);
  group->Subcircuits = st_init_table(st_ptrcmp, st_ptrhash);
  group->Inputs = st_init_table(st_ptrcmp, st_ptrhash);
  group->Outputs = st_init_table(st_ptrcmp, st_ptrhash);
  group->VarBackPtr = st_init_table(st_ptrcmp, st_ptrhash);
  group->name = ALLOC(char, strlen(Name) + 1);
  strcpy(group->name, Name);
  return group;
}

void
RstGroupFree(Rst_Group_t* Group)
{
  st_free_table(Group->Vars);
  st_free_table(Group->Latches);
  st_free_table(Group->Tables);
  st_free_table(Group->Subcircuits);
  st_free_table(Group->Inputs);
  st_free_table(Group->Outputs);
  st_free_table(Group->VarBackPtr);
  FREE(Group->name);
  FREE(Group);                  /* Watch for dangling references  */
}

char*
RstGroupNewParentName(
  char* Name)
{
  char* newName = util_strcat3(Name, "_N", "");
  return newName;
}

void
RstGroupPrint(
  Rst_Group_t* group)
{
  st_generator* sgen;
  Var_Variable_t* var;
  Hrc_Subckt_t* subckt;
  Hrc_Latch_t* latch;
  
  printf("GROUP: %s\n\tInputs:\t", group->name);
  st_foreach_item(group->Inputs, sgen, &var, NIL(char *)) {
    printf("%s ", Var_VariableReadName(var));
  }
  printf("\n\tOutputs:\t");
  st_foreach_item(group->Outputs, sgen, &var, NIL(char *)) {
    printf("%s ", Var_VariableReadName(var));
  }
  printf("\n\tSubcircuits:\t");
  st_foreach_item(group->Subcircuits, sgen, &subckt, NIL(char *)) {
    printf("%s ", Hrc_SubcktReadInstanceName(subckt));
  }
  printf("\n\tLatches:\t");
  st_foreach_item(group->Latches, sgen, &latch, NIL(char *)) {
    printf("%s ", Var_VariableReadName(Hrc_LatchReadOutput(latch)));
  }
  printf("\n\tVars:\t");
  st_foreach_item(group->Vars, sgen, &var, NIL(char *)) {
    printf("%s ", Var_VariableReadName(var));
  }
  printf("\n");
}

int
RstGroupDisjointCheck(
  array_t* GroupArray)
{
  int i, j, retVal;
  st_generator *sgen;
  Hrc_Subckt_t* subckt;
  Rst_Group_t* group1, *group2;
  Hrc_Latch_t* latch;
  Tbl_Table_t* tbl;
  Var_Variable_t* var;

  for (i = 0; i < array_n(GroupArray); i++) {
      group1 = array_fetch(Rst_Group_t*, GroupArray, i);
    for (j = i + 1; j < array_n(GroupArray); j++) {
      group2 = array_fetch(Rst_Group_t*, GroupArray, j);
      
      st_foreach_item(group1->Subcircuits, sgen, &subckt, NULL) {
        retVal = st_lookup(group2->Subcircuits, (char*) subckt, NIL(char *));
        if (retVal) {
          (void) fprintf(vis_stderr,
                         "ERROR: component %s assigned to groups %s and %s\n",
                         Hrc_SubcktReadInstanceName(subckt),
                         group1->name, group2->name);
          return 1;
        }
      }
      st_foreach_item(group1->Vars, sgen, &var, NULL) {
        retVal = st_lookup(group2->Vars, (char*) var, NIL(char *));
        if (retVal) {
          (void) fprintf(vis_stderr,
                         "ERROR: var %s assigned to groups %s and %s\n",
                         Var_VariableReadName(var),
                         group1->name, group2->name);
          return 1;
        }
      }
      st_foreach_item(group1->Tables, sgen, &tbl, NULL) {
        retVal = st_lookup(group2->Tables, (char*) tbl, NIL(char *));
        if (retVal) {
          (void) fprintf(vis_stderr,
                         "ERROR: table assigned to groups %s and %s\n",
                         group1->name, group2->name);
          return 1;
        }
      }
      st_foreach_item(group1->Latches, sgen, &latch, NULL) {
        retVal = st_lookup(group2->Latches, (char*) latch, NIL(char *));
        if (retVal) {
          (void) fprintf(vis_stderr,
                         "ERROR: latch %s assigned to groups %s and %s\n",
                         Var_VariableReadName(Hrc_LatchReadOutput(latch)),
                         group1->name, group2->name);
          return 1;
        }
      }
    }
  }
  return 0;
} 

Rst_Group_t*
RstCreateParentGroup(
  Hrc_Manager_t* Hmgr,
  Hrc_Model_t* ParentModel,
  char* NewModelName,
  array_t* GroupArray)
{
  int i, j, tblIndx, varIndx;
  long inGroup;  
  char *latchName, *subcktName, *varName;
  st_generator* sgen;
  Var_Variable_t* var;
  Tbl_Table_t* tbl;
  Hrc_Latch_t* latch;
  Hrc_Subckt_t *subckt;
  Hrc_Node_t *parentMaster;
  Rst_Group_t *group, *parentGroup;
  array_t* subOutputs;

  /* Build a parent group */

  parentGroup = RstGroupAlloc(NewModelName);
  parentMaster = Hrc_ModelReadMasterNode(ParentModel);

  /* IO of latches of parent group are parent group vars */
  
  Hrc_NodeForEachLatch(parentMaster, sgen, latchName, latch) {
    for (i = 0; i < array_n(GroupArray); i++) {
      group = array_fetch(Rst_Group_t*, GroupArray, i);
      if (st_lookup(group->Latches, (char*) latch, &inGroup)) {
        break;
      }
    }
    if (i >= array_n(GroupArray)) {
      st_insert(parentGroup->Latches, (char*) latch, (char*) (long) 1);
      var = Hrc_LatchReadInput(latch);
      if (! st_lookup(parentGroup->Vars, (char*) var, &inGroup)) {
        st_insert(parentGroup->Vars, (char*) var, (char*) (long) 1);
      }
      var = Hrc_LatchReadOutput(latch);
      if (! st_lookup(parentGroup->Vars, (char*) var, &inGroup)) {
        st_insert(parentGroup->Vars, (char*) var, (char*) (long) 1);
      }
    }
  }

  /* IO of parent group tables (that stay in parent) are parent group vars */
  
  Hrc_NodeForEachNameTable(parentMaster, tblIndx, tbl) {
    for (i = 0; i < array_n(GroupArray); i++) {
      group = array_fetch(Rst_Group_t*, GroupArray, i);
      if (st_lookup(group->Tables, (char*) tbl, &inGroup)) {
        break;
      }
    }
    if (i >= array_n(GroupArray)) {
      /* Table stays in parent */
      st_insert(parentGroup->Tables, (char*) tbl, (char*) (long) 1);
      Tbl_TableForEachInputVar(tbl, varIndx, var) {
        if (! st_lookup(parentGroup->Vars, (char*) var, &inGroup)) {
          st_insert(parentGroup->Vars, (char*) var, (char*) (long) 1);
        }
      }
      Tbl_TableForEachOutputVar(tbl, varIndx, var) {
        if (! st_lookup(parentGroup->Vars, (char*) var, &inGroup)) {
          st_insert(parentGroup->Vars, (char*) var, (char*) (long) 1);
        }
      }
    }
  }
  
  /* IO of groups are group Vars of the parent.  Note that inputs are
   never group vars of a group EXCEPT in the case of the parent group */
  
  Hrc_NodeForEachVariable(parentMaster, sgen, varName, var) {
    if (! st_lookup(parentGroup->Vars, (char*) var, &inGroup)) {
      for (i = 0; i < array_n(GroupArray); i++) {
        group = array_fetch(Rst_Group_t*, GroupArray, i);
        if ((st_lookup(group->Inputs, (char*) var, &inGroup)) ||
            (st_lookup(group->Outputs, (char*) var, &inGroup))) {
          break;
        }
      }
      if (i < array_n(GroupArray)) {
        st_insert(parentGroup->Vars, (char*) var, (char*) (long) 1);
      }
    }
  }

  /* All formal IO of old parent remains part of the parent group */
  
  Hrc_NodeForEachFormalInput(parentMaster, i, var)
    st_insert(parentGroup->Inputs, (char*) var, (char*) (long) 1);

  Hrc_NodeForEachFormalOutput(parentMaster, i, var)
    st_insert(parentGroup->Outputs, (char*) var, (char*) (long) 1);

  /* Outputs of subckts of parent group are parent group vars
   We do this last to catch this possible dangling input scenario*/
  
  Hrc_ModelForEachSubckt(ParentModel, sgen, subcktName, subckt) {
    for (i = 0; i < array_n(GroupArray); i++) {
      group = array_fetch(Rst_Group_t*, GroupArray, i);
      if (st_lookup(group->Subcircuits, (char*) subckt, &inGroup)) {
        break;
      }
    }
    if (i >= array_n(GroupArray)) {
      st_insert(parentGroup->Subcircuits, (char*) subckt, (char*) (long) 1);
      subOutputs = Hrc_SubcktReadActualOutputVars(subckt);
      Rst_VarForEachVarInArray(subOutputs, j, var) {
        if (! st_lookup(parentGroup->Vars, (char*) var, &inGroup)) {
          st_insert(parentGroup->Vars, (char*) var, (char*) (long) 1);
        }
      }
      /* FIXME: Possible bug: inputs are caught because they are
         outputs of other components.  But a dangling input (ie, one
         with no connection to anything) might get dropped. But adding
         an input var might cause it's driving component to be
         incorporated!  We opt for a warning here.  */
      /* FIXME: Hack-using same array */
      subOutputs = Hrc_SubcktReadActualInputVars(subckt); 
      Rst_VarForEachVarInArray(subOutputs, j, var) {
        if ((! st_lookup(parentGroup->Vars, (char*) var, &inGroup)) &&
            (! st_lookup(parentGroup->Inputs, (char*) var, &inGroup))) {
          (void) fprintf(vis_stderr,
                         "Warning: subcircuit %s has input variable %s ",
                         subcktName, Var_VariableReadName(var));
          (void) fprintf(vis_stderr, "that has no driver in parent %s\n",
                         parentGroup->name);
        }
      }
    }
  }
  return parentGroup;
}

void
RstModelPrint(
  Hrc_Model_t* newModel)
{
  Hrc_Node_t* newMaster;
  int i;
  st_generator* sgen;
  char* varName;
  Var_Variable_t* var;

  /* Print out new model  */
  printf("Model %s\n", Hrc_ModelReadName(newModel));
  newMaster = Hrc_ModelReadMasterNode(newModel);
  printf("\tInputs :\t");
  Rst_VarForEachVarInArray(Hrc_NodeReadFormalInputs(newMaster), i, var) {
    printf("%s ", Var_VariableReadName(var));
  }
  printf("\n\tOutputs:\t");
  Rst_VarForEachVarInArray(Hrc_NodeReadFormalOutputs(newMaster), i, var) {
    printf("%s ", Var_VariableReadName(var));
  }
  printf("\n\tVars:\t");
  Hrc_NodeForEachVariable(Hrc_ModelReadMasterNode(newModel),
                          sgen, varName, var) {
    printf("%s ", Var_VariableReadName(var));
  }
  printf("\n");
}

Hrc_Model_t*
RstGroupBuildModel(
  Hrc_Manager_t* Hmgr,
  Rst_Group_t* Group)
{
  long inGroup;  
  int retVal, i;
  st_generator* sgen;
  Var_Variable_t* var, *newVar, *newLatchInput, *newLatchOutput;
  Tbl_Table_t* tbl, *newTbl;
  Hrc_Latch_t* latch, *newLatch;
  st_table* varForwPtr;
  Hrc_Node_t* newMaster;
  Hrc_Subckt_t *subckt;
  Hrc_Model_t* subcktModel;
  Hrc_Model_t* newModel = Hrc_ModelAlloc(Hmgr, Group->name);
  array_t* actualInputArray, *actualOutputArray;

  if (! newModel) {
    (void) fprintf(vis_stderr, "ERROR: could not create Model %s\n",
                   Group->name);
    return 0;
  }
  
  newMaster = Hrc_ModelReadMasterNode(newModel);
  assert(newMaster);

  varForwPtr = st_init_table(st_ptrcmp, st_ptrhash);
  /* Add group's Variables: Inputs, Outputs */
  st_foreach_item(Group->Inputs, sgen, &var, &inGroup) {
    if (! st_lookup(varForwPtr, (char*) var, &newVar)) {
      newVar = Var_VariableDup(var, newMaster);
      Var_VariableResetAllTypes(newVar);
      Var_VariableResetNumFanoutTables(newVar);
      Hrc_NodeAddFormalInput(newMaster, newVar);
      Var_VariableSetPI(newVar);
      st_insert(Group->VarBackPtr, (char*) newVar, (char*) var);
      st_insert(varForwPtr, (char*) var, (char*) newVar);
    }
  }
  st_foreach_item(Group->Outputs, sgen, &var, &inGroup) {
    if (! st_lookup(varForwPtr, (char*) var, &newVar)) {
      newVar = Var_VariableDup(var, newMaster);
      Var_VariableResetAllTypes(newVar);
      Var_VariableResetNumFanoutTables(newVar);
      Hrc_NodeAddFormalOutput(newMaster, newVar);
      Var_VariableSetPO(newVar);
      st_insert(Group->VarBackPtr, (char*) newVar, (char*) var);
      st_insert(varForwPtr, (char*) var, (char*) newVar);
    }
  }
  st_foreach_item(Group->Vars, sgen, &var, &inGroup) {
    if (! st_lookup(varForwPtr, (char*) var, &newVar)) {
      newVar = Var_VariableDup(var, newMaster);
      Var_VariableResetAllTypes(newVar);
      Var_VariableResetNumFanoutTables(newVar);
      st_insert(Group->VarBackPtr, (char*) newVar, (char*) var);
      st_insert(varForwPtr, (char*) var, (char*) newVar);
    }
  }
      
  /* Add group's Tables */
  st_foreach_item(Group->Tables, sgen, &tbl, &inGroup) {
    Hrc_NodeAddNameTable(newMaster, Tbl_TableDupAndSubstVars(tbl, varForwPtr));
  }

  /* Add group's Latches */
  st_foreach_item(Group->Latches, sgen, &latch, &inGroup) {
    retVal = st_lookup(varForwPtr, (char*) Hrc_LatchReadInput(latch),
                       &newLatchInput);
    assert(retVal);
    retVal = st_lookup(varForwPtr, (char*) Hrc_LatchReadOutput(latch),
                       &newLatchOutput);
    assert(retVal);
    
    newLatch = Hrc_LatchCreate(newModel, newLatchInput, newLatchOutput);
    assert(newLatch != NULL);
    Var_VariableSetNS(newLatchInput);
    Var_VariableSetPS(newLatchOutput);
    
    /* Duplicate and attach Reset Table */
    tbl = Hrc_LatchReadResetTable(latch);
    newTbl = Tbl_TableDupAndSubstVars(tbl, varForwPtr);
    /* HACK: For some reason, we don't count latches in fanout count  */
    retVal = Hrc_LatchSetResetTable(newLatch, newTbl);
/*    newTbl = Hrc_LatchReadResetTable(latch); */
    assert(retVal);
    Tbl_TableForEachInputVar(tbl, i, var) {
      retVal = st_lookup(varForwPtr, (char*) var, &newVar);
      assert(retVal);
      Var_VariableResetAllTypes(newVar);
      Var_VariableResetNumFanoutTables(newVar);
    }
    Hrc_NodeAddLatch(newMaster, newLatch);
  }

  /* Add group's Subckts */
  
  st_foreach_item(Group->Subcircuits, sgen, &subckt, &inGroup) {
    actualInputArray =
      Rst_VartoVarLookup(Hrc_SubcktReadActualInputVars(subckt),
                         varForwPtr, 0);
    actualOutputArray =
      Rst_VartoVarLookup(Hrc_SubcktReadActualOutputVars(subckt),
                         varForwPtr, 0);
    subcktModel = Hrc_SubcktReadModel(subckt);
    Hrc_ModelAddSubckt(newModel, subcktModel,
                       Hrc_SubcktReadInstanceName(subckt),
                       actualInputArray, actualOutputArray);
    Rst_VarForEachVarInArray(actualInputArray, i, var) {
      Var_VariableSetSI(var);
    }
    Rst_VarForEachVarInArray(actualOutputArray, i, var) {
      Var_VariableSetSO(var);
    }
  }

  st_free_table(varForwPtr);

#ifdef RST_GROUP_DEBUG
  RstModelPrint(newModel);
#endif
  return newModel;
}

/* Overrides for Emacs so that we follow VIS tabbing style.
 * Must remain at end of file.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 2
 * c-indent-level: 2
 * c-brace-imaginary-offset: 0
 * c-brace-offset: -2
 * c-argdecl-indent: 2
 * c-comment-only-line-offset: 0
 * c-label-offset: -4
 * c-continued-statement-offset: 2
 * c-continued-brace-offset: 0
 * End: */