---

SymbolTable.cpp

#define TRACE_NAME "SymbolTable"

#include "Symbol.h"      // Not SymbolTable.h, to avoid loop
// $Id: SymbolTable_8cpp-source.html,v 1.5 2001/10/10 20:40:58 sandro Exp $

#include <hash_set>
#include <hash_map>



//
//  Standard Member Functions
//

size_t SymbolTable::nextTableNumber = 0;

SymbolTable::SymbolTable()
    : first_hole(0), count(0)
{
    tableNumber = nextTableNumber++;
}

#if 0  /* omit definitions until they are implemented */

SymbolTable::SymbolTable(const SymbolTable& other)
{
    NOT_IMPLEMENTED
}

const SymbolTable& SymbolTable::operator=(const SymbolTable& other)
{
    NOT_IMPLEMENTED
}

bool SymbolTable::operator==(const SymbolTable& other) const
{
    NOT_IMPLEMENTED
}

bool SymbolTable::operator<(const SymbolTable& other) const
{
    NOT_IMPLEMENTED
}

size_t SymbolTable::hash() const
{
    NOT_IMPLEMENTED
}

std::ostream& SymbolTable::print_to(std::ostream& stream) const
{
    NOT_IMPLEMENTED
}

#endif /* omit definitions until they are implemented */
    
SymbolTable::~SymbolTable()
{
    // Um -- what if people still have references?  Might just be loops...
    // let's just free the char*
    for (unsigned int i = 0; i<records.size(); i++) {
    reclaim(i);
    }
}

//
//  Additional Public Member Functions
//

SymbolTable::Index SymbolTable::lookupOrAdd(SymbolTable::Type type, 
                        const char* text,
                        bool* added_ptr)
{
    Index index;
    /*
      Look up this type/text combintion in our tables; if it's
      not found, then copy the information and add it.
    */

    TRACE "looking for symbol type=" << type << " text=" << text << std::endl;
    Iter iter;

    if (type >= map.size()) {
    TRACE "vector of maps (by type) being expanded from " <<
        map.size() << " to " << type+1 << std::endl;
    map.resize(type+1);
    }

    // we can't just use [] because if it's not found, we'll be
    // making the entry in the hash_map use a copy of this char* 
    // at a different address.
    if (text) {
    iter = map[type].find( const_cast<char *> (text) );
    if (iter != map[type].end()) {
        index = (*iter).second;
        records[index].refCount++;
        TRACE "  found it, index=" << index << std::endl;
        return index;
    }
    TRACE "  not found" << std::endl;
    }

    if (added_ptr) *added_ptr = true;

    // find a slot in the table and use it, add to table
    if (first_hole) {
    TRACE "  using hole" << std::endl;
    index = first_hole;
    // in the blank record spot, the refCount there should the index of
    // the next hole (or zero if no more)
    first_hole = records[first_hole].nextHole;
    } else {
    // no holes
    TRACE "  expanding vector" << std::endl;
    index = records.size();
    records.push_back(Record());
    assert(records.size() == index+1);
    }

    ++count;
    records[index].type = type;
    records[index].refCount = 1;
    records[index].boundTo = Symbol(0,0);
    TRACE "  created as index " << index << std::endl;

    if (text) {
    char *key = strdup(text);
    records[index].text = key;
    map[type][key] = index;
    iter = map[type].find( const_cast<char *> (text) );
    if (iter != map[type].end()) {
        TRACE "  and it's present now" << std::endl;
    } else {
        TRACE "  BUT IT'S MISSING" << std::endl;
        TRACE const_cast<char *> (text) << "<>" << key << std::endl;
    }
    } else {
    records[index].text = 0;
    }

    return index;
}



//
//  Additional Private Member Functions
//


void SymbolTable::reclaim(Index index) 
{

#ifdef DO_RECLAIM
    turn this off for an urgent demo; theres some bug

    TRACE "reclaiming Symbol " << index << std::endl;

    map[records[index].type].erase(records[index].text);
    delete records[index].text;

    records[index].nextHole = first_hole;
    first_hole = index;

    count--;
#endif

#if DO_TRACE
    TRACE "Holes: ";
    int i = first_hole;
    while (i) {
    TRACE i << " ";
    i = records[i].nextHole;
    }
    TRACE std::endl;
#endif
}
#undef TRACE_NAME

---

Home to blindfold. This page generated via doxygen 1.2.11.1 Wed Oct 10 16:40:33 2001.