#include <textual/parser_bits.h>
#include <textual/string_manipulation.h>
-//#define DEBUG_SYMBOL_TREE
+#define DEBUG_SYMBOL_TREE
// uncomment for totally noisy version.
+#include <loggers/program_wide_logger.h>
#undef LOG
-#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), s)
+#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), astring(s) + a_sprintf(" [obj=%p]", this))
+using namespace loggers;
using namespace basis;
using namespace structures;
namespace nodes {
+//hmmm: used for... explain please.
class symbol_tree_associations : public symbol_table<symbol_tree *>
{
public:
symbol_tree_associations(int estimated_elements)
: symbol_table<symbol_tree *>(estimated_elements) {}
+ virtual ~symbol_tree_associations() {
+
+//hmmm: below was really wrong and things are still wrong because we're letting the symtab destruct our trees?
+// real thing would be to just toss any pointers referenced in the sym tab here.
+// OR... not at all because sym tab stores objects, and expects objects, and since a pointer isn't an object it will not auto-delete?
+
+
+//hmmm: why was this here? was it ever needed?
+//hmmm: maybe it's the missing link?
+
+//probably we don't actually want to whack here???
+// for (int i = 0; i < symbols(); i++) {
+// WHACK(use(i));
+// }
+ }
};
//////////////
symbol_tree::~symbol_tree()
{
- WHACK(_name);
+ FUNCDEF("destructor");
+LOG("symtree dtor: prior to whacks");
WHACK(_associations);
+LOG("symtree dtor: after whacking associations");
+ WHACK(_name);
+LOG("symtree dtor: after all whacks");
}
int symbol_tree::children() const { return _associations->symbols(); }
FUNCDEF("prune");
#endif
symbol_tree *to_zap = dynamic_cast<symbol_tree *>(to_zap_in);
- if (!to_zap)
+ if (!to_zap) {
+#ifdef DEBUG_SYMBOL_TREE
+ LOG("about to barf due to null symtree after dynamic cast.");
+#endif
throw("error: symbol_tree::prune: wrong type of node in prune");
+ }
#ifdef DEBUG_SYMBOL_TREE
LOG(astring("zapping node for ") + to_zap->name());
#endif
#ifdef DEBUG_SYMBOL_TREE
FUNCDEF("find");
#endif
- if (comp == NIL) comp = astring_comparator;
+ if (comp == NULL_POINTER) comp = astring_comparator;
#ifdef DEBUG_SYMBOL_TREE
LOG(astring("finding node called ") + to_find);
#endif
// perform the upward recursion first, since it's pretty simple.
if (how == recurse_upward) {
symbol_tree *our_parent = dynamic_cast<symbol_tree *>(parent());
- if (!our_parent) return NIL; // done recursing.
+ if (!our_parent) return NULL_POINTER; // done recursing.
return our_parent->find(to_find, how, comp);
}
if (!found) {
if (how == recurse_downward) {
// see if we can't find that name in a sub-node.
- symbol_tree *answer = NIL;
+ symbol_tree *answer = NULL_POINTER;
for (int i = 0; i < branches(); i++) {
// we will try each branch in turn and see if it has a child named
// appropriately.
return answer;
}
}
- return NIL;
+ return NULL_POINTER;
}
return *found;
}