attr.H

Go to the documentation of this file.

/*----------------------------------------------------------------
 *   Name:        attr.h
 *
 *   Designer:    Willie Glover
 *
 *   Created:     4/02/96
 *
 *   Description: This file contains the LEGO header file which
 *                defines the attr structure of the LEGO IR.
 *
 *   Location:    /ncsu/tinker/LEGO/src/base/attr.h
 *
 *
 * 4/02/96 WTG:  Added structure for attrs. Used by op and graph.
 * 8/10/96 WTG:  Added support for operands and list of values.
 * 8/18/96 WTG:  Added support for writing REBEL.
 * 12/3/96 WAH:  Added copy constructors.
 * 2/26/97 WAH:  Fixed ~attrs to delete nextLcEntryPtr.
 * 3/20/97 WAH:  Renamed SetValue SetValid (was a mistake).
 * 4/7/97 WAH:   Filled in intList destructor.
 * 9/5/97 WAH:   Switched to enums in globals.H.
 * 10/10/97 WAH: Added support for legoOprd::parentPtr.
 * 1/9/98 WAH:   Fixed SetAttrString to handle NULL.
 * 1/27/98 WAH:  Fixed destructor to delete operand & intList.
 * 4/22/98 WAH:  Updated legoOprd::parentPtr; added legoOp *
 *               parameter to copy constructor.
 *---------------------------------------------------------------*/

#ifndef ATTR_H
#define ATTR_H

//class legoOprd;
#include "legoOprd.H"
#include "globals.H"

class intList {
   int      attrValue;        // attribute value
   int      valid;            // 0=invalid
   intList* nextIntListPtr;   // ptr to next item
public:
  intList()
  {
    //    fprintf(stderr,"Creating INTLIST %p\n", this);
    attrValue = 0;
    valid = 0;
    nextIntListPtr = NULL;
  }
  intList (const intList &orig)
  {
    attrValue = orig.attrValue;
    valid = orig.valid;
    if (orig.nextIntListPtr != NULL)
      nextIntListPtr = new intList (*(orig.nextIntListPtr));
    else
      nextIntListPtr = NULL;
    //    fprintf(stderr,"Creating INTLIST %p\n", this);
  } // end copy constructor
  ~intList()
  {
    intList *tmpIntListPtr = NULL;
    while (nextIntListPtr != NULL)
      {
        tmpIntListPtr = nextIntListPtr;
        nextIntListPtr = tmpIntListPtr->nextIntListPtr;
        tmpIntListPtr->nextIntListPtr = NULL;
        delete tmpIntListPtr;
      } // end while
    //    fprintf(stderr,"Deleting ATTRS %p\n", this);
  } // end destructor

/*--------------------------------------------------------
 * Get attrValue
 *--------------------------------------------------------*/
int     GetAttrValue(void) { return attrValue; }

/*--------------------------------------------------------
 * Get valid
 *--------------------------------------------------------*/
int     GetValid(void) { return valid; }

/*--------------------------------------------------------
 * Get nextIntListPtr
 *--------------------------------------------------------*/
intList  *GetNextIntListPtr(void) { return nextIntListPtr; }

/*---------------------------------------------------------
 * Set attrValue
 *-------------------------------------------------------*/
void    SetAttrValue(unsigned newValue) {attrValue = newValue; }

/*---------------------------------------------------------
 * Set valid
 *-------------------------------------------------------*/
void    SetValid(unsigned newValid) {valid = newValid; }

/*---------------------------------------------------------
 * Set nextIntListPtr
 *-------------------------------------------------------*/
void    SetNextIntListPtr(intList *newPtr) {nextIntListPtr = newPtr; }

};

class attrs {
   enum attrTypes attrType;  // See enumeration below (globals.H)
   int attrId;            // current index value in REBEL dictionary
   int oldAttrId;         // original index in REBEL dictionary
   intList *attrValPtr;   // NULL unless attrType is bb_id or freq
                          //  note that bb_id takes only 1 value
   char* attrString;      // ptr to attr string
                          // NULL if attrType is not lc
   attrs *nextLcEntryPtr; // Use this pointer to build list of string/oprd
                          //  when the attrType = lc and there is more than
                          //  one parameter.
   legoOprd *attrOprdPtr; // ptr to list of operands
                          // NULL if attrType is not live or lc
   attrs *nextAttrPtr;    // pointer to next attr entry

public:

       attrs(void)
       {
         //      fprintf(stderr,"Creating ATTRS %p\n", this);
         attrType = ATTR_UNDEF;  // undefined
         attrId = 0;           // undefined
         oldAttrId = 0;        // undefined
         attrValPtr = NULL;
         attrString = NULL;
         nextLcEntryPtr = NULL;
         attrOprdPtr = NULL;
         nextAttrPtr = NULL;
       }

  attrs(attrs &orig, legoOp *op, int newId = -1)
  {
    //    fprintf(stderr,"Creating ATTRS %p\n", this);
    attrType = orig.attrType;
    if (newId == -1)
      attrId = orig.attrId;  // id will be changed anyway
    else
      attrId = newId;
    oldAttrId = orig.oldAttrId;
    if (orig.attrValPtr != NULL)
      attrValPtr = new intList (*(orig.attrValPtr));
    else
      attrValPtr = NULL;
    if (orig.attrString != NULL)
      {
        attrString = new char [strlen (orig.attrString) + 1];
        strcpy (attrString, orig.attrString);
      } // end if
    else
      attrString = NULL;
    if (orig.nextLcEntryPtr != NULL)
      nextLcEntryPtr = new attrs (*(orig.nextLcEntryPtr), op, newId);
    else
      nextLcEntryPtr = NULL;
    if (orig.attrOprdPtr != NULL)
      {
        attrOprdPtr = new legoOprd (*(orig.attrOprdPtr));
        attrOprdPtr->SetParentOpPtr (op);
        attrOprdPtr->SetParentAttrPtr (this);
      } // end if
    else
      attrOprdPtr = NULL;
    nextAttrPtr = NULL;  // don't duplicate (dictionary;will be changed anyway)
  } // end copy constructor

  ~attrs(void)
  {
    delete[] attrString;
    delete attrOprdPtr;
    delete attrValPtr;
    /*
     * Remove storage associated with all attributes linked
     * as lcode attributes.
     */
    attrs *tmpAttrPtr = NULL;
    while (nextLcEntryPtr != NULL) {
      tmpAttrPtr = nextLcEntryPtr;
      nextLcEntryPtr = tmpAttrPtr->nextLcEntryPtr;
      tmpAttrPtr->nextLcEntryPtr = NULL;
      delete tmpAttrPtr;
    }
    /*
     * Remove storage associated with all attributes linked
     * in this chain.
     */
    while (nextAttrPtr != NULL) {
      tmpAttrPtr = nextAttrPtr;
      nextAttrPtr = tmpAttrPtr->nextAttrPtr;
      tmpAttrPtr->nextAttrPtr = NULL;
      delete tmpAttrPtr;
    }
    //    fprintf(stderr,"Deleting ATTRS %p\n", this);
  } // end destructor

/*---------------------------------------------------------
 * Get attribute type
 *-------------------------------------------------------*/
enum attrTypes GetAttrType(void) { return attrType; }

/*---------------------------------------------------------
 * Get attribute index
 *-------------------------------------------------------*/
int GetAttrId(void) { return attrId; }

/*---------------------------------------------------------
 * Get original REBEL file library index
 *-------------------------------------------------------*/
int GetOldAttrId(void) { return oldAttrId; }

/*---------------------------------------------------------
 * Get pointer to value of freq attribute or bb_id attribute.
 * Undefined for other attributes.
 *-------------------------------------------------------*/
intList  *GetAttrValPtr(void) { return attrValPtr; }

/*---------------------------------------------------------
 * Get string associated with lc attributes
 *-------------------------------------------------------*/
char *GetAttrString(void) { return attrString; }

/*---------------------------------------------------------
 * Get pointer to next lc parameter of this attribute.
 * NULL for other attribute types.
 *-------------------------------------------------------*/
attrs  *GetNextLcEntryPtr(void) { return nextLcEntryPtr; }

/*---------------------------------------------------------
 * Get operand list associated with live and lc attributes
 *-------------------------------------------------------*/
legoOprd *GetAttrOprdPtr(void) { return attrOprdPtr; }

/*---------------------------------------------------------
 * Get pointer to next attribute
 *-------------------------------------------------------*/
attrs *GetNextAttrPtr(void) { return nextAttrPtr; }

/*---------------------------------------------------------
 * Update attribute type
 *-------------------------------------------------------*/
void SetAttrType(enum attrTypes newType) {attrType = newType; }

/*---------------------------------------------------------
 * Update attribute index.
 *-------------------------------------------------------*/
void SetAttrId(unsigned newIndex) {attrId = newIndex; }

/*---------------------------------------------------------
 * Update original REBEL file library index.
 * This method should only be used by the REBEL parser.
 *-------------------------------------------------------*/
void SetOldAttrId(unsigned newIndex) {oldAttrId = newIndex; }

/*---------------------------------------------------------------
 * Updtae pointer to value of freq attribute or bb_id attribute.
 *--------------------------------------------------------------*/
void SetAttrValPtr(intList *newValPtr) {attrValPtr = newValPtr; }

/*---------------------------------------------------------
 * Update string associated with lc attributes
 *-------------------------------------------------------*/
void SetAttrString(char *newString)
  {
    delete[] attrString;
    if (newString != NULL)
      {
        attrString = new char[strlen(newString)+1];
        (void)strcpy(attrString,newString);
      } // end if
    else attrString = NULL;
  }

/*---------------------------------------------------------
 * Update pointer to next lc parameter of this attribute.
 * This operation is undefined for other attribute types.
 *-------------------------------------------------------*/
void SetNextLcEntryPtr(attrs *newEntryPtr)
  { nextLcEntryPtr = newEntryPtr; }

/*---------------------------------------------------------
 * Update pointer to operand list for live and lc attributes
 *-------------------------------------------------------*/
void SetAttrOprdPtr(legoOprd *newOprdPtr)
  {attrOprdPtr = newOprdPtr; }

/*---------------------------------------------------------
 * Update pointer to next attribute
 *-------------------------------------------------------*/
void SetNextAttrPtr(attrs *newPtr) {nextAttrPtr = newPtr; }

};
//--------------------------------------------------------------
//  attribute type
//   0 = ATTR_UNDEF
//   1 = ATTR_LC
//   2 = ATTR_MS     *** not implemented ***
//   3 = ATTR_BBID
//   4 = ATTR_FREQ
//   5 = ATTR_LIVE
//--------------------------------------------------------------
#endif

---