lSymTab.H

Go to the documentation of this file.

/*-----------------------------------------------------------------
 * Name:         lSymTab.H
 * Designer:     Willie Glover
 * Description:  In memory symbol table for LEGO IR variables
 *
 * 2/5/97 WAH:  Fixing elementSize assumption, AllocVar guessing.
 * 2/6/97 WAH:  Changed nameTable structure radically to avoid
 *              guessing and AllocVar altogether.
 * 2/26/97 WAH: Made datum::FindOffset, datum::append, and
 *              ~datum nonrecursive.
 * 2/27/97 WAH: Made default varType LIR_BYTE.
 * 2/28/97 WAH: Verified capability to have (long ... (s ""));
 *              (with tinker.y) takes in / prints out text data
 * 4/7/97 WAH:  Improved copy constructor, destructor. Default type
 *              changed to LIR_LONG.
 * 7/18/97 WAH: Added LIR_LABELASINT varType.
 * 7/29/97 WAH: Changed initType() to InitType(), append() to Append().
 * 12/8/97 WAH: Lots of cleanup; changed some int fields to enums;
 *              removed sVarType field from nameTable; added couple
 *              of checks for LIR_LABELASINT where missing; changed
 *              procName field of symbolTable to regionName; added
 *              symbolTable::GetSDataType; moved
 *              some functions to lSymTab.C.
 * 1/9/98 WAH:  Fixed several string-setting functions to handle NULL.
 *----------------------------------------------------------------*/
#ifndef LSYMBOLTABLE_H
#define LSYMBOLTABLE_H

#include <stdio.h>
#include <string.h>
#include "legoErr.H"

enum importTypes {
LIR_GLOBAL,
LIR_GNU_WEAK,
LIR_LOCAL
};

enum tableTypes {
LIR_PROC,
LIR_MODULE
};
//HZ: 12/17/01 added the segments of SDATA (short data), SBSS (short
// uninitialized data), COMMENT (COMMENT segment) for IA-64
enum sDataTypes {
LIR_DATA,
LIR_DATA1,
LIR_BSS,
LIR_TEXT,
LIR_SDATA,
LIR_SBSS,
LIR_COMMENT,
LIR_CTORS,
LIR_DTORS
};

enum varTypes {
LIR_VOID,
LIR_BYTE,
LIR_USBYTE,
LIR_WORD,
LIR_USWORD,
LIR_LONG,
LIR_USLONG,
LIR_LONGLONG,
LIR_USLONGLONG,
LIR_FLOAT,
LIR_DOUBLE,
LIR_STRING,       // used for ascii / asciz and ws data
LIR_STRINGASINT,  // for wi and long storing a string
LIR_LABEL,        // used for function pointers stored with wi
LIR_LABELASINT,   // for wi and long storing a label
};

enum initTypes {
  LIR_WRITTEN,    // using wi, ww, et al.
  LIR_PLACED      // using byte, word, et al.
};

/*
 * class datum
 *
 * A single piece of data, specifying its type, relative
 * location, and actual value.
 */
class datum
{
  enum varTypes varType;  // see varTypes
  int offset;             // byte offset
  int isDummy;            // marks data as empty (uninitialized data)
  class datum *next;      // next datum
  union                   // anon. union of values
  {
    long Byte;
    long usByte;
    long Word;
    long usWord;
    long Long;
    unsigned long usLong;
    long long Longlong;
    unsigned long long usLonglong;
    float Float;
    double Double;
    char *String;
    char *Label;
  };

public:

  datum()
  {
    //    fprintf(stderr,"Creating DATUM %p\n", this);
    varType = LIR_LONG;
    offset = -1;
    isDummy = 0;
    next = NULL;
    usLonglong = 0;
  } // end constructor
  datum (const datum &oldD)  // copy constructor
  {
    //    fprintf(stderr,"Creating DATUM %p\n", this);
    varType = oldD.varType;
    offset = oldD.offset;
    isDummy = oldD.isDummy;
    if (varType != LIR_STRING && varType != LIR_STRINGASINT &&
        varType != LIR_LABEL && varType != LIR_LABELASINT)
      usLonglong = oldD.usLonglong;
    else
      {
        String = new char [strlen (oldD.String) + 1]; // works for label too!
        strcpy (String, oldD.String);
      } // end else
    next = new datum (*(oldD.next));
  } // end copy constructor

  ~datum()
  {
    datum *temp;

    if (varType == LIR_STRING || varType == LIR_STRINGASINT ||
        varType == LIR_LABEL || varType == LIR_LABELASINT)
      delete[] String;
    while (next != NULL)
      {
        temp = next;
        next = temp->next;
        temp->next = NULL;
        delete temp;
      } // end while
    //    fprintf(stderr,"Deleting DATUM %p\n", this);
    
  } // end destructor

  enum varTypes GetVarType (void) {return varType;}
  void SetVarType (enum varTypes vt) {varType = vt;}

  int GetOffset (void) {return offset;}
  void SetOffset (int o) {offset = o;}

  int IsDummy (void) {return isDummy;}
  void SetDummy (int d) {isDummy = d;}

  datum *GetNext (void) {return next;}
  void SetNext (datum *n) {next = n;}

  // Data retrieval methods

  // Because there seems to be no specification as to whether byte and
  // word data in LCODE is signed or unsigned, these data sizes are
  // stored internally as longs, so that either case will be covered!

  long GetByte (void) {return Byte;}
  void SetByte (long b) {Byte = b;}

  long GetUsByte (void) {return usByte;}
  void SetUsByte (long b) {usByte = b;}

  long GetWord (void) {return Word;}
  void SetWord (long w) {Word = w;}

  long GetUsWord (void) {return usWord;}
  void SetUsWord (long w) {usWord = w;}

  long GetLong (void) {return Long;}
  void SetLong (long l) {Long = l;}

  unsigned long GetUsLong (void) {return usLong;}
  void SetUsLong (unsigned long l) {usLong = l;}

  long long GetLongLong (void) {return Longlong;}
  void SetLongLong (long long l) {Longlong = l;}

  unsigned long long GetUsLongLong (void) {return usLonglong;}
  void SetUsLongLong (unsigned long long l) {usLonglong = l;}

  float GetFloat (void) {return Float;}
  void SetFloat (float f) {Float = f;}

  double GetDouble (void) {return Double;}
  void SetDouble (double d) {Double = d;}

  char *GetString (void) {return String;}
  void SetString (char *s)
  {
    if (varType == LIR_STRING || varType == LIR_STRINGASINT)
      delete[] String;
    if (varType == LIR_LABEL || varType == LIR_LABELASINT)
      delete[] Label;
    if (s != NULL)
      {
        String = new char [strlen (s) + 1];
        strcpy (String, s);
      } // end if
    else String = NULL;
  } // end SetString

  char *GetLabel (void) {return Label;}
  void SetLabel (char *s)
  {
    if (varType == LIR_STRING || varType == LIR_STRINGASINT)
      delete[] String;
    if (varType == LIR_LABEL || varType == LIR_LABELASINT)
      delete[] Label;
    if (s != NULL)
      {
        Label = new char [strlen (s) + 1];
        strcpy (Label, s);
      } // end if
    else Label = NULL;
  } // end SetString

  // Find the datum with a given offset.

  datum *FindOffset (int o)
  {
    datum *candidate;

    for (candidate = this; candidate != NULL;
         candidate = candidate->next)
      {
        if ((candidate->offset == o) && !(candidate->isDummy))
          return candidate;
      } // end for
  } // end FindOffset

  // Find the datum with a given index, assuming an element size.

  datum *FindIndex (int idx, int elsize)
  {
    return FindOffset (idx * elsize);
  } // end FindIndex

  // Append a new datum on the end of this list.

  void Append (datum *newd)
  {
    datum *tail;

    for (tail = this; tail->next != NULL; tail = tail->next) ;
    tail->next = newd;
    return;
  } // end Append

  // Write out the datum in Rebel.
  void WriteRebel (FILE *, char *, int);
};

class symbolTable;

/*
 * class nameTable
 *
 * A single variable, possibly an array or struct.
 */
class nameTable {

    char *varName;      /* variable name                               */
    int elementSize;    /* size of the data type, in bytes             */
    int reserve;        /* total space requirements, in # bytes        */
    int numElements;    /* # of elements                               */
    int align;          /* addresee allignment (used for REBEL format) */
    //void *info;       /* ptr to additional info (code, entry, etc)   */
    //HZ:
    char *info;
    enum importTypes importType;        /* global or local             */
    symbolTable* STPtr; /* points to parent symbolTable                */

  int numData;  // true number of data elements
  int totalSize;  // true total space occupied
  datum *data;  // first piece of data
  datum *datatail;  // last piece of data (for speed in appending)

public:

   nameTable()
   {
        varName         = NULL;
        //      sVarType        = LIR_DATA; WAH 12/8/97
        //      elementSize     = 4; WAH 2/5/97
        elementSize     = 0;
        reserve         = 0;
        numElements     = 0; 
        //      align           = 4; WAH 2/5/97
        align           = 0;
        info            = NULL;
        importType      = LIR_LOCAL;
        STPtr           = NULL;
        //      dataValue.longPtr = NULL;
        numData         = 0;
        totalSize       = 0;
        data            = NULL;
        datatail        = NULL;
   } // end no-arg constructor
  ~nameTable()
   {
        delete[] varName;
        delete data;
        //
        if(info != NULL) delete [] info;
        // NOT DELETING INFO - don't know how, its a void * !
   } // end destructor

/*
 *  Below is the copy constructor for class nameTable.
 */
   nameTable(const nameTable &oldVar)
   {
     if (oldVar.varName != NULL)
       {
         varName                = new char[strlen(oldVar.varName)+1];
         strcpy(varName,oldVar.varName);
       } // end if
     else
       varName = NULL;
     elementSize        = oldVar.elementSize;
     reserve            = oldVar.reserve;
     numElements        = oldVar.numElements;
     align              = oldVar.align;
     info               = oldVar.info;
     importType         = oldVar.importType;
     STPtr              = oldVar.STPtr;
     numData            = oldVar.numData;
     totalSize          = oldVar.totalSize;
     if (oldVar.data != NULL)
       {
         data               = new datum (*(oldVar.data));
         for (datatail = data; datatail->GetNext() != NULL;
              datatail = datatail->GetNext()) /* do nothing */ ;
       } // end if
     else
       data = datatail = NULL;

   } // end copy constructor

/*
 *  Below is the operator = copy constructor for nameTable.
 */
   nameTable& operator=(const nameTable& oldVar)
   {
     if ( varName != oldVar.varName ) {
        delete[] varName;
        if (oldVar.varName != NULL)
          {
            varName     = new char[strlen(oldVar.varName)+1];
            strcpy(varName,oldVar.varName);
          } // end if
        else
          varName = NULL;
        elementSize     = oldVar.elementSize;
        reserve         = oldVar.reserve;
        numElements     = oldVar.numElements; 
        align           = oldVar.align;
        info            = oldVar.info;
        importType      = oldVar.importType;
        STPtr           = oldVar.STPtr;
        numData         = oldVar.numData;
        totalSize       = oldVar.totalSize;
        delete data;
        if (oldVar.data != NULL)
          {
            data            = new datum (*(oldVar.data));
            for (datatail = data; datatail->GetNext() != NULL;
                 datatail = datatail->GetNext()) /* do nothing */ ;
          } // end if
        else
          data = datatail = NULL;
     }  // end if
     return *this;
   } // end operator=

  // --- Get methods ------------------------------------------

   void SetVarName(char *newVarName) {
     delete[] varName;
     if (newVarName != NULL)
       {
         varName = new char[strlen(newVarName)+1];
         strcpy(varName,newVarName);
       } // end if
     else varName = NULL;
   }

  //   void SetSVarType(int newSVarType) { sVarType = newSVarType; }

   void SetElementSize(int newElementSize)
   { 
     elementSize = newElementSize; 
   }

   void SetReserve(int newReserve) 
   { 
     reserve = newReserve; 
   } 

   void SetNumElements(int newNumElements)
     { numElements = newNumElements; }

   void SetAlign(int newAlign) { align = newAlign; }

   //void SetInfo(void *newInfo) { info = newInfo; }
   //HZ:
   void SetInfo(char *newInfo) 
   { 
       if(info != NULL)
       {
           delete [] info;
           info = NULL;
       }
       if(newInfo != NULL)
       {
           info = new char[strlen(newInfo) + 1];
           strcpy(info, newInfo);
       }
   }
   
   void AppendInfo(char *newInfo)
   {
       char *a;
       
       if(info != NULL)
       {
           a = new char[strlen(info) + strlen(newInfo) + 1];
           strcpy(a, info);
           strcat(a, newInfo);
           delete [] info;
           info = a;
       }
       else
       {
           info = new char[strlen(newInfo) + 1];
           strcpy(info, newInfo);
       }
   }

   void SetImportType(enum importTypes newImportType)
     { importType = newImportType; }

   void SetSTPtr(symbolTable *newTablePtr) { STPtr = newTablePtr; }

   void SetNumData(int newNumData) { numData = newNumData; }

   void SetTotalSize(int newTotalSize) { totalSize = newTotalSize; }

  // These next methods are generic ways to set and get values
  // from the data.

  void SetOffset (enum varTypes, int, void *, int = 1);
  void SetArray (enum varTypes, int, void *, int = 1);

  datum *GetOffset (int offset)  // returns a datum, NOT the value
  {
    if (data != NULL)
      return data->FindOffset (offset);
    else
      return NULL;
  } // end GetOffset

  datum *GetArray (enum varTypes, int);  // returns a datum, NOT value

  // --- Get methods ------------------------------------------

   char *GetVarName(void) { return varName; }

  //   int       GetSVarType(void) { return sVarType; }

   int   GetElementSize(void) {return elementSize; }

   int   GetReserve(void) { return reserve; }

   int   GetNumElements(void) { return numElements; }

   int  GetAlign(void) { return align; }

   //void *GetInfo(void) { return info; }
   //HZ:
   char *GetInfo(void) { return info; }

   int   GetImportType(void) { return importType; }

   symbolTable *GetSTPtr(void) { return STPtr; }

  int GetNumData(void) { return numData; }

  int GetTotalSize(void) { return totalSize; }

  datum *GetData(void) { return data; }

  datum *GetDataTail(void) { return datatail; }

/*---------------------------------------------------------------
 * There are two sets of Get- methods for the variable data.
 *
 * One returns an element from the variable array and requires
 * the element index, arrIdx, as input.
 *
 * The other returns the pointer to the array and does not require
 * any inputs.
 *
 * The methods which return the pointers have "Ptr" as the last
 * three characters of the method name.
 *
 * 2/6/97 WAH: Not any more.  To get the variable array use
 *             GetData.  The first set of methods will work the
 *             same, however.
 * 12/8/97 WAH: Commented out the first set of methods. Will remove
 *              completely soon.
 *---------------------------------------------------------------*/
  /*
  char GetByte (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_BYTE, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetByte", "No byte at index %d.", arrIdx);
        exit;
      } // end if
    return (char) target->GetByte();
  } // end GetByte
  unsigned char GetUsByte (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_USBYTE, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetUsByte",
                   "No unsigned byte at index %d.", arrIdx);
        exit;
      } // end if
    return (unsigned char) target->GetUsByte();
  } // end GetUsByte
  short int GetWord (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_WORD, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetWord", "No word at index %d.", arrIdx);
        exit;
      } // end if
    return (short int) target->GetWord();
  } // end GetWord
  unsigned short int GetUsWord (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_USWORD, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetUsWord", "No unsigned word at index %d.",
                   arrIdx);
        exit;
      } // end if
    return (unsigned short int) target->GetUsWord();
  } // end GetUsWord
  long GetLong (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_LONG, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetLong()", "No long at index %d.", arrIdx);
        exit;
      } // end if
    return target->GetLong();
  } // end GetLong
  unsigned long GetUsLong (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_USLONG, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetUsLong", "No unsigned long at index %d.",
                   arrIdx);
        exit;
      } // end if
    return target->GetUsLong();
  } // end GetUsLong
  long long GetLongLong (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_LONGLONG, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetLongLong", "No long long at index %d.",
                   arrIdx);
        exit;
      } // end if
    return target->GetLongLong();
  } // end GetLongLong
  unsigned long long GetUsLongLong (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_USLONGLONG, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetUsLongLong",
                   " No unsigned long long at index %d.", arrIdx);
        exit;
      } // end if
    return target->GetUsLongLong();
  } // end GetUsLongLong
  float GetFloat (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_FLOAT, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetFloat", "No float at index %d.", arrIdx);
        exit;
      } // end if
    return target->GetFloat();
  } // end GetFloat
  double GetDouble (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_DOUBLE, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetDouble", "No double at index %d.", arrIdx);
        exit;
      } // end if
    return target->GetDouble();
  } // end GetDouble
  char *GetString (int arrIdx=0)
  {
    datum *target;

    target = GetArray (LIR_STRING, arrIdx);
    if (target == NULL)
      {
        LegoFatal ("nameTable::GetString", "No string at index %d.", arrIdx);
        exit;
      } // end if
    return target->GetString();
  } // end GetString
  */

  // Determine whether the data was initialized by placement (byte, word)
  // or by writing (wi, ww).
  int InitType(void)
  {
    if (numElements != 0) return LIR_PLACED;
    else return LIR_WRITTEN;
  } // end InitType

  void ClearData (void)
  {
    delete data;
    data = datatail = NULL;
    numData = 0;
    totalSize = 0;
  } // end ClearData

  // Write out the name table in Rebel.
  void WriteRebel (FILE *);
}; // end class nameTable

// ===================================================================

class symbolTable {

   char *regionName;        /* name of table owner                  */
   enum tableTypes tableType;       /* type of table                */
   enum sDataTypes sDataType;       /* data segment type            */
   int   varCount;          /* number of variables in nameTable     */
   int   tableSize;         /* size of nametable initialize to 10   */
   int   parmCount;         /* number of formal parameters (unused) */
   nameTable **varTablePtr; /* pointer to nameTable                 */

public:

/*---------------------------------------------------------------------
 * Default constructor initializes the nameTable size to 10 entries.
 *--------------------------------------------------------------------*/
  symbolTable()
  {
    regionName  = NULL;
    tableType   = LIR_PROC;
    sDataType   = LIR_DATA;
    varCount    = 0;
    tableSize   = 10;
    parmCount   = 0;
    varTablePtr         = new nameTable*[tableSize];
  }

/*---------------------------------------------------------------------
 * Constructor initializes the nameTable size  to initSize entries.
 *--------------------------------------------------------------------*/
  symbolTable(int initSize)
  {
    regionName  = NULL;
    tableType   = LIR_PROC;
    sDataType   = LIR_DATA;
    varCount    = 0;
    tableSize   = initSize;
    parmCount   = 0;
    varTablePtr         = new nameTable*[tableSize];
  }

  ~symbolTable()
  {
    delete[] regionName;
    for (int i = 0; i < varCount; i++)
      delete varTablePtr[i];
    delete[] varTablePtr;
  }

/*---------------------------------------------------------------------
 * Copy a variable to the table.  Input is a pointer to class nameTable.
 * A new entry is created and copied into the table at the current
 * variable index.  This method _does_not_ delete the storage pointed
 * to by the input variable.
 *--------------------------------------------------------------------*/
  void AddVar(nameTable *inputVar)
  {
    if ( varCount >= (tableSize - 1) ) { 
      //                fprintf(stderr,"   Want to resize table\n");
      ResizeNameTable(); 
    }
    varTablePtr[varCount] = inputVar;
    varCount++;
/* 
        fprintf(stderr,"   At the end of AddVar, the whole table look like this:\n"); 
        for(int i=0;i<varCount;i++){
                fprintf(stderr,"\t___Name Table name %s,type %d,numElements %d,importType %d,NumBytes %d.\n",
                varTablePtr[i]->GetVarName(),
                varTablePtr[i]->GetVarType(),
                varTablePtr[i]->GetNumElements(),
                varTablePtr[i]->GetImportType(),
                varTablePtr[i]->GetNumBytes()); 
        } 
*/ 
  }
/*---------------------------------------------------------------------
 * Update the region name.
 *--------------------------------------------------------------------*/
  void SetRegionName (char *newRegionName) {
    delete[] regionName;
    if (newRegionName != NULL)
      {
        regionName = new char[strlen(newRegionName)+1];
        strcpy(regionName,newRegionName);
      } // end if
    else regionName = NULL;
  }

/*---------------------------------------------------------------------
 * Update the table type.
 *--------------------------------------------------------------------*/
  void SetTableType(enum tableTypes newTableType) { tableType = newTableType; }

/*---------------------------------------------------------------------
 * Update the data type.
 *--------------------------------------------------------------------*/
  void SetSDataType(enum sDataTypes newDataType) { sDataType = newDataType; }

/*---------------------------------------------------------------------
 * Update the variable count.  Note that the variable count is _not_
 * automatically increased when a new item is added to the nameTable
 * unless the AddVar() method is used.
 *--------------------------------------------------------------------*/
  void SetVarCount(int newVarCount) { varCount = newVarCount; }

/*---------------------------------------------------------------------
 * Update the nametable size.  If an attempt is made to resize the nametable
 *  to a size which is smaller than the variable count,  The routine exits
 *  without modifying the size of the table.
 *--------------------------------------------------------------------*/
  void SetTableSize(int newTableSize)
  {
    if (newTableSize < varCount) {
      LegoNonFatal ("nameTable::SetTableSize",
                    "New size of nameTable too small.");
      return;
    }
    nameTable **tmpVarTablePtr = new nameTable*[newTableSize];
    if ( varCount != 0 ) {
      for (int idx=0; idx<varCount; idx++) {
        tmpVarTablePtr[idx] = varTablePtr[idx];
      }
    }
    delete [] varTablePtr;
    varTablePtr = tmpVarTablePtr;
    tableSize = newTableSize;
  }

/*---------------------------------------------------------------------
 * update the number of parameters.
 *--------------------------------------------------------------------*/
  void SetParmCount(int newParmCount) { parmCount = newParmCount; }

/*---------------------------------------------------------------------
 * increment by one - the number of parameters field.
 *--------------------------------------------------------------------*/
  void IncParmCount(void) { parmCount++; }

/*---------------------------------------------------------------------
 * No method is provided to update the nameTable pointer.
 *--------------------------------------------------------------------*/

/*---------------------------------------------------------------------
 * get the region name.
 *--------------------------------------------------------------------*/
  char *GetRegionName(void) { return regionName; }

/*---------------------------------------------------------------------
 * get the table type.
 *--------------------------------------------------------------------*/
  enum tableTypes GetTableType(void) { return tableType; }

/*---------------------------------------------------------------------
 * get the data type.
 *--------------------------------------------------------------------*/
  enum sDataTypes GetSDataType(void) { return sDataType; }

/*---------------------------------------------------------------------
 * get the number of variables currently in the nametable.
 *--------------------------------------------------------------------*/
  int    GetVarCount(void) { return varCount; }

/*---------------------------------------------------------------------
 * get the maximum size of the nametable.
 *--------------------------------------------------------------------*/
  int    GetTableSize(void) { return tableSize; }

/*---------------------------------------------------------------------
 * get the parameter count.
 *--------------------------------------------------------------------*/
  int    GetParmCount(void) { return parmCount; }

/*---------------------------------------------------------------------
 * get the pointer to this symbol table's nametable.
 *--------------------------------------------------------------------*/
  nameTable **GetVarTablePtr(void) { return varTablePtr; }

// Larin 

  nameTable *GetVarTablePtr(int indx) { return varTablePtr[indx];  } 

/*---------------------------------------------------------------------
 * Double the size of this symboltable's nameTable.
 *--------------------------------------------------------------------*/
  void ResizeNameTable(void)
  {
    nameTable **tmpVarTablePtr = new nameTable*[2 * tableSize];
    if ( varCount != 0 ) {
      for (int idx=0; idx<varCount; idx++) {
        tmpVarTablePtr[idx] = varTablePtr[idx];
      }
    }
    delete [] varTablePtr;
    varTablePtr = tmpVarTablePtr;
    tableSize = 2 * tableSize;
  }

/*---------------------------------------------------------------------
 * Resize an array in this symboltable's nameTable.
 *--------------------------------------------------------------------*/
  void ResizeVariableArray(int entryIdx, int newElementSize);

  // Find a given variable name in the table.

  nameTable *LocateVar (char *name)
  {
    int i;
    nameTable *candidate;

    for (i = 0; i < parmCount; i++)
      {
        candidate = varTablePtr[i];
        if (candidate == NULL) continue;
        if (strcmp (candidate->GetVarName(), name) == 0)
          return candidate;
      } // end for
    return NULL;
  } // end LocateVar

  // Write out the symbol table in Rebel.
  void symbolTable::WriteRebel (FILE *rebelfile)
  {
    int i;

    fprintf (rebelfile,"  (ms ");
    switch (sDataType)
      {
      case LIR_DATA:
        fprintf (rebelfile, "data)\n"); break;
      case LIR_DATA1:
        fprintf (rebelfile, "data1)\n"); break;
      case LIR_BSS:
        fprintf (rebelfile, "bss)\n"); break;
      case LIR_TEXT:
        fprintf (rebelfile, "text)\n"); break;
      
      //HZ: adding support for other data type
      case LIR_SDATA:
        fprintf (rebelfile, "sdata)\n"); break;
      case LIR_SBSS:
        fprintf (rebelfile, "sbss)\n"); break;
      case LIR_COMMENT:
        fprintf (rebelfile, "dcomment)\n"); break;
      case LIR_CTORS:
        fprintf (rebelfile, "ctors)\n"); break;
      case LIR_DTORS:
        fprintf (rebelfile, "dtors)\n"); break;
      default:
              fprintf(stderr, "WriteRebel Error: data type unrecognized.\n");
              exit (-1);      
      } // end switch

    for (i = 0; i < varCount; i++)
      varTablePtr[i]->WriteRebel (rebelfile);
    return;
  } // end WriteRebel

};

class tableEntry {

   symbolTable *tablePtr;   /* pointer to symbol table                   */
   int   entryIndex;        /* index of entry in symbolTable's nameTable */

public:

   tableEntry() {
      tablePtr = NULL;
      entryIndex = 0;
   }

  ~tableEntry() {}

/*---------------------------------------------------------------------
 * Update the symbol table pointer.
 *--------------------------------------------------------------------*/
   void SetTablePtr(symbolTable *newTablePtr) { tablePtr = newTablePtr; }

/*---------------------------------------------------------------------
 * Update the entry index.
 *--------------------------------------------------------------------*/
   void SetEntryIndex(int newEntryIndex) { entryIndex = newEntryIndex; }

/*---------------------------------------------------------------------
 * get the symbol table pointer.
 *--------------------------------------------------------------------*/
   symbolTable *GetTablePtr(void) { return tablePtr; }

/*---------------------------------------------------------------------
 * get the entry index.
 *--------------------------------------------------------------------*/
   int GetEntryIndex(void) { return entryIndex; }
};

#endif // LSYMBOLTABLE_H

---