/* Sun-$Revision: 23.4 $ */
/* Copyright 1992-9 Sun Microsystems, Inc. and Stanford University.
See the LICENSE file for license information. */
# pragma interface
struct TableElem: CListEntry {
CListEntry* key;
CListEntry* value;
TableElem(CListEntry* k, CListEntry* v) { key = k; value = v; }
~TableElem() {
if (key) delete key;
if (value) delete value;
}
CListEntry* realDeepCopy() {
return (CListEntry *)new TableElem(key->realDeepCopy(),
value->realDeepCopy());
}
void print_short();
void print();
};
class TableIterator;
IdentityListTemplate(Table, TableElem*)
struct Table: TableList {
friend class ::TableIterator;
Table() {}
Table(CListEntry* key, CListEntry* value)
: TableList(new TableElem(key, value)) {}
TableElem* find(CListEntry* k);
TableElem* identityFind(CListEntry* k);
TableElem* findContents(CListEntry* v);
TableElem* identityFindContents(CListEntry* v);
void remove(CListEntry* k);
void identityRemove(CListEntry* k);
Table* copy();
CListEntry* realDeepCopy();
Table* deepCopy() {
if (isEmpty()) {
return EMPTY;
} else {
return (Table*)realDeepCopy();
}
}
bool includes(CListEntry* k) { return find(k) != NULL; }
bool identityIncludes(CListEntry* k) { return identityFind(k) != NULL; }
bool contains(CListEntry* v) { return findContents(v) != NULL; }
bool identityContains(CListEntry* v) {
return identityFindContents(v) != NULL; }
CListEntry* lookup(CListEntry* k) {
TableElem* d = find(k);
return d ? d->value : NULL; }
CListEntry* identityLookup(CListEntry* k) {
TableElem* d = identityFind(k);
return d ? d->value : NULL; }
Table* append(TableElem* e) { return (Table*) TableList::append(e); }
Table* store(CListEntry* k, CListEntry* v) {
TableElem* d = find(k);
return d ? (d->value = v, this) : append(new TableElem(k, v)); }
Table* storeNew(CListEntry* k, CListEntry* v) {
assert(!includes(k), "shouldn't already be there");
return append(new TableElem(k, v)); }
Table* identityStore(CListEntry* k, CListEntry* v) {
TableElem* d = identityFind(k);
return d ? (d->value = v, this) : append(new TableElem(k, v)); }
Table* identityStoreNew(CListEntry* k, CListEntry* v) {
assert(!identityIncludes(k), "shouldn't already be there");
return append(new TableElem(k, v)); }
TableElem* first() { return (TableElem*) TableList::first(); }
bool EQ(CListEntry* e) {
Unused(e); ShouldNotCallThis(); // == not implemented for tables
return false; }
inline TableIterator* iterator(); // inlined below
};
struct TableIterator: ResourceObj {
TableListElem* elem;
TableIterator(Table* t) { elem = t->head(); }
bool done() { return elem == NULL; }
TableElem* data() {
assert(!done(), "iteration done"); return (TableElem*) elem->data(); }
void* next() { // cfront wants a return value to use in a for stmt
assert(!done(), "iteration done"); elem = elem->next(); return 0; }
};
inline TableIterator* Table::iterator() { return new TableIterator(this); }
# define ValueValueTableTemplate(nm, keyType, keyName, valueType, valueName) \
struct CONC(nm,TableElem): CListEntry { \
keyType keyName; \
valueType valueName; \
}; \
\
struct CONC(nm,TableIterator): TableIterator { \
CONC(nm,TableIterator) (Table* t) : TableIterator(t) {} \
CONC(nm,TableElem)* data() { \
return (CONC(nm,TableElem)*) TableIterator::data(); } \
}; \
\
struct CONC(nm,TableListElem): CListElem { \
CONC(nm,TableListElem) (CListEntry* d, CListElem* n = NULL) \
: CListElem(d, n) {} \
CONC(nm,TableElem)* data() { \
return (CONC(nm,TableElem)*) CListElem::data(); } \
void setData(CONC(nm,TableElem)* d) { CListElem::setData(d); } \
CONC(nm,TableListElem)* next() { \
return (CONC(nm,TableListElem)*) CListElem::next(); } \
void setNext(CONC(nm,TableListElem)* n) { CListElem::setNext(n); } \
}; \
\
struct CONC(nm,Table): Table { \
CONC(nm,Table)(keyType key, valueType value) \
: Table((CListEntry*) key, (CListEntry*) value) {} \
CONC(nm,Table)() {} \
CONC(nm,TableListElem)* head() { \
return (CONC(nm,TableListElem)*) Table::head(); } \
CONC(nm,TableElem)* find(keyType n) { \
return (CONC(nm,TableElem)*) Table::find((CListEntry*) n); } \
CONC(nm,TableElem)* findContents(valueType v) { \
return (CONC(nm,TableElem)*) Table::findContents((CListEntry*) v); } \
valueType lookup(keyType n) { \
return (valueType) Table::lookup((CListEntry*) n); } \
CONC(nm,Table)* store(keyType n, valueType t) { \
return (CONC(nm,Table)*) Table::store((CListEntry*) n, \
(CListEntry*) t); } \
CONC(nm,Table)* storeNew(keyType n, valueType t) { \
return (CONC(nm,Table)*) Table::storeNew((CListEntry*) n, \
(CListEntry*) t); } \
bool includes(keyType n) { return Table::includes((CListEntry*) n); } \
bool contains(valueType v) { return Table::contains((CListEntry*) v); } \
void remove(keyType n) { Table::remove((CListEntry*) n); } \
CONC(nm,TableListElem)* spliceOutNext(CONC(nm,TableListElem)* e) { \
return (CONC(nm,TableListElem)*) \
Table::spliceOutNext((TableListElem*) e); } \
CONC(nm,Table)* copy() { \
return (CONC(nm,Table)*) Table::copy(); } \
CONC(nm,Table)* deepCopy() { \
return (CONC(nm,Table)*) Table::deepCopy(); } \
CONC(nm,TableElem)* first() { \
return (CONC(nm,TableElem)*) Table::first(); } \
CONC(nm,TableIterator)* iterator() { \
return (CONC(nm,TableIterator)*) Table::iterator(); } \
};
# define ValueIdentityTableTemplate(nm, keyType, keyName, valueType, valueName) \
struct CONC(nm,TableElem): CListEntry { \
keyType keyName; \
valueType valueName; \
}; \
\
struct CONC(nm,TableIterator): TableIterator { \
CONC(nm,TableIterator) (Table* t) : TableIterator(t) {} \
CONC(nm,TableElem)* data() { \
return (CONC(nm,TableElem)*) TableIterator::data(); } \
}; \
\
struct CONC(nm,TableListElem): CListElem { \
CONC(nm,TableListElem) (CListEntry* d, CListElem* n = NULL) \
: CListElem(d, n) {} \
CONC(nm,TableElem)* data() { \
return (CONC(nm,TableElem)*) CListElem::data(); } \
void setData(CONC(nm,TableElem)* d) { CListElem::setData(d); } \
CONC(nm,TableListElem)* next() { \
return (CONC(nm,TableListElem)*) CListElem::next(); } \
void setNext(CONC(nm,TableListElem)* n) { CListElem::setNext(n); } \
}; \
\
struct CONC(nm,Table): Table { \
CONC(nm,Table)(keyType key, valueType value) \
: Table((CListEntry*) key, (CListEntry*) value) {} \
CONC(nm,Table)() {} \
CONC(nm,TableListElem)* head() { \
return (CONC(nm,TableListElem)*) Table::head(); } \
CONC(nm,TableElem)* find(keyType n) { \
return (CONC(nm,TableElem)*) Table::find((CListEntry*) n); } \
CONC(nm,TableElem)* findContents(valueType v) { \
return (CONC(nm,TableElem)*) \
Table::identityFindContents((CListEntry*) v); } \
valueType lookup(keyType n) { \
return (valueType) Table::lookup((CListEntry*) n); } \
CONC(nm,Table)* store(keyType n, valueType t) { \
return (CONC(nm,Table)*) Table::store((CListEntry*) n, \
(CListEntry*) t); } \
CONC(nm,Table)* storeNew(keyType n, valueType t) { \
return (CONC(nm,Table)*) Table::storeNew((CListEntry*) n, \
(CListEntry*) t); } \
bool includes(keyType n) { return Table::includes((CListEntry*) n); } \
bool contains(valueType v) { \
return Table::identityContains((CListEntry*) v); } \
void remove(keyType n) { Table::remove((CListEntry*) n); } \
CONC(nm,TableListElem)* spliceOutNext(CONC(nm,TableListElem)* e) { \
return (CONC(nm,TableListElem)*) \
Table::spliceOutNext((TableListElem*) e); } \
CONC(nm,Table)* copy() { \
return (CONC(nm,Table)*) Table::copy(); } \
CONC(nm,TableElem)* first() { \
return (CONC(nm,TableElem)*) Table::first(); } \
CONC(nm,TableIterator)* iterator() { \
return (CONC(nm,TableIterator)*) Table::iterator(); } \
};
# define IdentityValueTableTemplate(nm, keyType, keyName, valueType, valueName) \
struct CONC(nm,TableElem): CListEntry { \
keyType keyName; \
valueType valueName; \
}; \
\
struct CONC(nm,TableIterator): TableIterator { \
CONC(nm,TableIterator) (Table* t) : TableIterator(t) {} \
CONC(nm,TableElem)* data() { \
return (CONC(nm,TableElem)*) TableIterator::data(); } \
}; \
\
struct CONC(nm,TableListElem): CListElem { \
CONC(nm,TableListElem) (CListEntry* d, CListElem* n = NULL) \
: CListElem(d, n) {} \
CONC(nm,TableElem)* data() { \
return (CONC(nm,TableElem)*) CListElem::data(); } \
void setData(CONC(nm,TableElem)* d) { CListElem::setData(d); } \
CONC(nm,TableListElem)* next() { \
return (CONC(nm,TableListElem)*) CListElem::next(); } \
void setNext(CONC(nm,TableListElem)* n) { CListElem::setNext(n); } \
}; \
\
struct CONC(nm,Table): Table { \
CONC(nm,Table)(keyType key, valueType value) \
: Table((CListEntry*) key, (CListEntry*) value) {} \
CONC(nm,Table)() {} \
CONC(nm,TableListElem)* head() { \
return (CONC(nm,TableListElem)*) Table::head(); } \
CONC(nm,TableElem)* find(keyType n) { \
return (CONC(nm,TableElem)*) Table::identityFind((CListEntry*) n); } \
CONC(nm,TableElem)* findContents(valueType v) { \
return (CONC(nm,TableElem)*) Table::findContents((CListEntry*) v); } \
valueType lookup(keyType n) { \
return (valueType) Table::identityLookup((CListEntry*) n); } \
CONC(nm,Table)* store(keyType n, valueType t) { \
return (CONC(nm,Table)*) Table::identityStore((CListEntry*) n, \
(CListEntry*) t); } \
CONC(nm,Table)* storeNew(keyType n, valueType t) { \
return (CONC(nm,Table)*) Table::identityStoreNew((CListEntry*) n, \
(CListEntry*) t); } \
bool includes(keyType n) { \
return Table::identityIncludes((CListEntry*) n); } \
bool contains(valueType v) { return Table::contains((CListEntry*) v); } \
void remove(keyType n) { Table::identityRemove((CListEntry*) n); } \
CONC(nm,TableListElem)* spliceOutNext(CONC(nm,TableListElem)* e) { \
return (CONC(nm,TableListElem)*) \
Table::spliceOutNext((TableListElem*) e); } \
CONC(nm,Table)* copy() { \
return (CONC(nm,Table)*) Table::copy(); } \
CONC(nm,TableElem)* first() { \
return (CONC(nm,TableElem)*) Table::first(); } \
CONC(nm,TableIterator)* iterator() { \
return (CONC(nm,TableIterator)*) Table::iterator(); } \
};
# define IdentityIdentityTableTemplate( \
nm, keyType, keyName, valueType, valueName) \
\
struct CONC(nm,TableElem): CListEntry { \
keyType keyName; \
valueType valueName; \
}; \
\
struct CONC(nm,TableIterator): TableIterator { \
CONC(nm,TableIterator) (Table* t) : TableIterator(t) {} \
CONC(nm,TableElem)* data() { \
return (CONC(nm,TableElem)*) TableIterator::data(); } \
}; \
\
struct CONC(nm,TableListElem): CListElem { \
CONC(nm,TableListElem) (CListEntry* d, CListElem* n = NULL) \
: CListElem(d, n) {} \
CONC(nm,TableElem)* data() { \
return (CONC(nm,TableElem)*) CListElem::data(); } \
void setData(CONC(nm,TableElem)* d) { CListElem::setData(d); } \
CONC(nm,TableListElem)* next() { \
return (CONC(nm,TableListElem)*) CListElem::next(); } \
void setNext(CONC(nm,TableListElem)* n) { CListElem::setNext(n); } \
}; \
\
struct CONC(nm,Table): Table { \
CONC(nm,Table)(keyType key, valueType value) \
: Table((CListEntry*) key, (CListEntry*) value) {} \
CONC(nm,Table)() {} \
CONC(nm,TableListElem)* head() { \
return (CONC(nm,TableListElem)*) Table::head(); } \
CONC(nm,TableElem)* find(keyType n) { \
return (CONC(nm,TableElem)*) Table::identityFind((CListEntry*) n); } \
CONC(nm,TableElem)* findContents(valueType v) { \
return (CONC(nm,TableElem)*) \
Table::identityFindContents((CListEntry*) v); } \
valueType lookup(keyType n) { \
return (valueType) Table::identityLookup((CListEntry*) n); } \
CONC(nm,Table)* store(keyType n, valueType t) { \
return (CONC(nm,Table)*) Table::identityStore((CListEntry*) n, \
(CListEntry*) t); } \
CONC(nm,Table)* storeNew(keyType n, valueType t) { \
return (CONC(nm,Table)*) Table::identityStoreNew((CListEntry*) n, \
(CListEntry*) t); } \
bool includes(keyType n) { \
return Table::identityIncludes((CListEntry*) n); } \
bool contains(valueType v) { \
return Table::identityContains((CListEntry*) v); } \
void remove(keyType n) { Table::identityRemove((CListEntry*) n); } \
CONC(nm,TableListElem)* spliceOutNext(CONC(nm,TableListElem)* e) { \
return (CONC(nm,TableListElem)*) \
Table::spliceOutNext((TableListElem*) e); } \
CONC(nm,Table)* copy() { \
return (CONC(nm,Table)*) Table::copy(); } \
CONC(nm,Table)* deepCopy() { \
return (CONC(nm,Table)*) Table::deepCopy(); } \
CONC(nm,TableElem)* first() { \
return (CONC(nm,TableElem)*) Table::first(); } \
CONC(nm,TableIterator)* iterator() { \
return (CONC(nm,TableIterator)*) Table::iterator(); } \
};
IdentityIdentityTableTemplate(OopOop, oop, oop1, oop, oop2)
