--verify works again, but the memory totals at the end still need work.

amount.cc

@@ -87,7 +87,7 @@ struct amount_t::bigint_t : public supports_flags<>
     mpz_init_set(val, _val);
   }
   bigint_t(const bigint_t& other)
-    : supports_flags<>(other.flags() & BIGINT_KEEP_PREC),
+    : supports_flags<>(other.flags() & ~BIGINT_BULK_ALLOC),
       prec(other.prec), ref(1), index(0) {
     TRACE_CTOR(bigint_t, "copy");
     mpz_init_set(val, other.val);

commodity.cc

@@ -478,6 +478,7 @@ bool compare_amount_commodities::operator()(const amount_t * left,
 
 commodity_pool_t::commodity_pool_t() : default_commodity(NULL)
 {
+  TRACE_CTOR(commodity_pool_t, "");
   null_commodity = create("");
   null_commodity->add_flags(COMMODITY_STYLE_NOMARKET |
 			    COMMODITY_STYLE_BUILTIN);

commodity.h

@@ -231,7 +231,17 @@ struct annotation_t : public equality_comparable<annotation_t>
     (const optional<amount_t>&	 _price = none,
      const optional<datetime_t>& _date  = none,
      const optional<string>&     _tag	= none)
-    : price(_price), date(_date), tag(_tag) {}
+    : price(_price), date(_date), tag(_tag) {
+    TRACE_CTOR(annotation_t, "const optional<amount_t>& + datetime_t + string");
+  }
+  annotation_t(const annotation_t& other)
+    : price(other.price), date(other.date), tag(other.tag) {
+    TRACE_CTOR(annotation_t, "copy");
+  }
+
+  ~annotation_t() {
+    TRACE_DTOR(annotation_t);
+  }
 
   operator bool() const {
     return price || date || tag;
@@ -378,6 +388,7 @@ public:
   explicit commodity_pool_t();
 
   ~commodity_pool_t() {
+    TRACE_DTOR(commodity_pool_t);
     commodities_by_ident& ident_index = commodities.get<0>();
     for (commodities_by_ident::iterator i = ident_index.begin();
 	 i != ident_index.end();

csv.h

@@ -8,11 +8,19 @@ namespace ledger {
 
 class format_csv_transactions : public item_handler<transaction_t>
 {
- protected:
+  format_csv_transactions();
+
+protected:
   std::ostream&	out;
 
- public:
+public:
-  format_csv_transactions(std::ostream& _out) : out(_out) {}
+  format_csv_transactions(std::ostream& _out) : out(_out) {
+    TRACE_CTOR(format_csv_transactions, "std::ostream&");
+  }
+  ~format_csv_transactions() {
+    TRACE_DTOR(format_csv_transactions);
+  }
+
   virtual void flush() {
     out.flush();
   }

emacs.h

@@ -8,13 +8,20 @@ namespace ledger {
 
 class format_emacs_transactions : public item_handler<transaction_t>
 {
- protected:
+  format_emacs_transactions();
+
+protected:
   std::ostream& out;
   entry_t *     last_entry;
 
- public:
+public:
   format_emacs_transactions(std::ostream& _out)
-    : out(_out), last_entry(NULL) {}
+    : out(_out), last_entry(NULL) {
+    TRACE_CTOR(format_emacs_transactions, "std::ostream&");
+  }
+  ~format_emacs_transactions() {
+    TRACE_DTOR(format_emacs_transactions);
+  }
 
   virtual void write_entry(entry_t& entry);
   virtual void flush() {

error.h

@@ -12,7 +12,7 @@ namespace ledger {
 
 class error_context
 {
- public:
+public:
   string desc;
 
   error_context(const string& _desc) throw() : desc(_desc) {}

flags.h

@@ -42,8 +42,15 @@ protected:
   flags_t flags_;
 
 public:
-  supports_flags() : flags_(0) {}
+  supports_flags() : flags_(0) {
-  supports_flags(const flags_t arg) : flags_(arg) {}
+    TRACE_CTOR(supports_flags, "");
+  }
+  supports_flags(const flags_t& arg) : flags_(arg) {
+    TRACE_CTOR(supports_flags, "copy");
+  }
+  ~supports_flags() throw() {
+    TRACE_DTOR(supports_flags);
+  }
 
   flags_t flags() const {
     return flags_;
@@ -76,8 +83,15 @@ protected:
   supports_flags<T>& flags_;
 
 public:
-  delegates_flags() : flags_() {}
+  delegates_flags() : flags_() {
-  delegates_flags(supports_flags<T>& arg) : flags_(arg) {}
+    TRACE_CTOR(delegates_flags, "");
+  }
+  delegates_flags(supports_flags<T>& arg) : flags_(arg) {
+    TRACE_CTOR(delegates_flags, "const supports_flags<T>&");
+  }
+  ~delegates_flags() throw() {
+    TRACE_DTOR(delegates_flags);
+  }
 
   flags_t flags() const {
     return flags_.flags();

format.cc

@@ -757,6 +757,8 @@ format_transactions::format_transactions(std::ostream& _output_stream,
 					 const string& format)
   : output_stream(_output_stream), last_entry(NULL), last_xact(NULL)
 {
+  TRACE_CTOR(format_transactions, "std::ostream&, const string&");
+
   const char * f = format.c_str();
   if (const char * p = std::strstr(f, "%/")) {
     first_line_format.reset(string(f, 0, p - f));

format.h

@@ -16,7 +16,7 @@ string partial_account_name(const account_t&   account,
 #define ELEMENT_ALIGN_LEFT 0x01
 #define ELEMENT_HIGHLIGHT  0x02
 
-struct element_t
+struct element_t : public noncopyable
 {
   enum kind_t {
     STRING,
@@ -59,16 +59,16 @@ struct element_t
 
   element_t() : type(STRING), flags(false),
 		min_width(0), max_width(0), next(NULL) {
-    DEBUG("ledger.memory.ctors", "ctor element_t");
+    TRACE_CTOR(element_t, "");
   }
 
   ~element_t() {
-    DEBUG("ledger.memory.dtors", "dtor element_t");
+    TRACE_DTOR(element_t);
     if (next) delete next;	// recursive, but not too deep
   }
 };
 
-struct format_t
+struct format_t : public noncopyable
 {
   string format_string;
   element_t * elements;
@@ -87,14 +87,14 @@ struct format_t
   static bool ansi_invert;
 
   format_t() : elements(NULL) {
-    DEBUG("ledger.memory.ctors", "ctor format_t");
+    TRACE_CTOR(format_t, "");
   }
   format_t(const string& _format) : elements(NULL) {
-    DEBUG("ledger.memory.ctors", "ctor format_t");
+    TRACE_CTOR(format_t, "const string&");
     reset(_format);
   }
   ~format_t() {
-    DEBUG("ledger.memory.dtors", "dtor format_t");
+    TRACE_DTOR(format_t);
     if (elements) delete elements;
   }
 
@@ -115,16 +115,19 @@ struct format_t
 
 class format_transactions : public item_handler<transaction_t>
 {
- protected:
+protected:
   std::ostream&   output_stream;
   format_t	  first_line_format;
   format_t	  next_lines_format;
   entry_t *       last_entry;
   transaction_t * last_xact;
 
- public:
+public:
   format_transactions(std::ostream& _output_stream,
 		      const string& format);
+  ~format_transactions() throw() {
+    TRACE_DTOR(format_transactions);
+  }
 
   virtual void flush() {
     output_stream.flush();
@@ -136,7 +139,12 @@ class format_entries : public format_transactions
 {
  public:
   format_entries(std::ostream& output_stream, const string& format)
-    : format_transactions(output_stream, format) {}
+    : format_transactions(output_stream, format) {
+    TRACE_CTOR(format_entries, "std::ostream&, const string&");
+  }
+  ~format_entries() throw() {
+    TRACE_DTOR(format_entries);
+  }
 
   virtual void format_last_entry();
 
@@ -174,11 +182,16 @@ class format_account : public item_handler<account_t>
  public:
   format_t format;
 
-  format_account(std::ostream&      _output_stream,
+  format_account(std::ostream& _output_stream,
 		 const string& _format,
 		 const string& display_predicate = NULL)
     : output_stream(_output_stream), disp_pred(display_predicate),
-      format(_format) {}
+      format(_format) {
+    TRACE_CTOR(format_account, "std::ostream&, const string&, const string&");
+  }
+  ~format_account() throw() {
+    TRACE_DTOR(format_account);
+  }
 
   virtual void flush() {
     output_stream.flush();
@@ -206,7 +219,8 @@ class format_equity : public item_handler<account_t>
   virtual void operator()(account_t& account);
 };
 
-class format_error : public error {
+class format_error : public error
+{
  public:
   format_error(const string& reason, error_context * ctxt = NULL) throw()
     : error(reason, ctxt) {}

journal.cc

@@ -375,6 +375,7 @@ entry_t::entry_t(const entry_t& e)
     code(e.code), payee(e.payee)
 {
   TRACE_CTOR(entry_t, "copy");
+
   for (transactions_list::const_iterator i = transactions.begin();
        i != transactions.end();
        i++)

journal.h

@@ -75,23 +75,23 @@ class transaction_t : public supports_flags<>
   static bool	 use_effective_date;
 
   transaction_t(account_t * _account = NULL,
-		unsigned int _flags  = TRANSACTION_NORMAL)
+		flags_t     _flags   = TRANSACTION_NORMAL)
     : supports_flags<>(_flags), entry(NULL),
       state(UNCLEARED), account(_account),
       beg_pos(0), beg_line(0), end_pos(0), end_line(0), data(NULL)
   {
-    TRACE_CTOR(transaction_t, "account_t *");
+    TRACE_CTOR(transaction_t, "account_t *, flags_t");
   }
-  transaction_t(account_t *	       _account,
+  transaction_t(account_t *	_account,
-		const amount_t&        _amount,
+		const amount_t& _amount,
-		unsigned int           _flags = TRANSACTION_NORMAL,
+		flags_t         _flags = TRANSACTION_NORMAL,
-		const optional<string> _note  = none)
+		const optional<string>& _note = none)
     : supports_flags<>(_flags), entry(NULL), state(UNCLEARED),
       account(_account), amount(_amount), note(_note),
       beg_pos(0), beg_line(0), end_pos(0), end_line(0), data(NULL)
   {
     TRACE_CTOR(transaction_t,
-	       "account_t *, const amount_t&, unsigned int, const string&");
+	       "account_t *, const amount_t&, flags_t, const string&");
   }
   transaction_t(const transaction_t& xact)
     : supports_flags<>(xact),
@@ -168,8 +168,10 @@ class entry_base_t
 	 i++)
       transactions.push_back(new transaction_t(**i));
   }
+
   virtual ~entry_base_t() {
     TRACE_DTOR(entry_base_t);
+
     for (transactions_list::iterator i = transactions.begin();
 	 i != transactions.end();
 	 i++)
@@ -250,8 +252,7 @@ class entry_context : public error_context {
 };
 
 
-template <typename T>
+template <typename T> class item_predicate;
-class item_predicate;
 
 class auto_entry_t : public entry_base_t
 {
@@ -261,6 +262,10 @@ public:
   auto_entry_t() {
     TRACE_CTOR(auto_entry_t, "");
   }
+  auto_entry_t(const auto_entry_t& other)
+  : predicate(other.predicate) {
+    TRACE_CTOR(auto_entry_t, "copy");
+  }
   auto_entry_t(const string& _predicate)
     : predicate(_predicate)
   {
@@ -277,9 +282,24 @@ public:
   }
 };
 
-struct auto_entry_finalizer_t : public entry_finalizer_t {
+struct auto_entry_finalizer_t : public entry_finalizer_t
+{
   journal_t * journal;
-  auto_entry_finalizer_t(journal_t * _journal) : journal(_journal) {}
+
+  auto_entry_finalizer_t() : journal(NULL) {
+    TRACE_CTOR(auto_entry_finalizer_t, "");
+  }
+  auto_entry_finalizer_t(const auto_entry_finalizer_t& other)
+    : journal(other.journal) {
+    TRACE_CTOR(auto_entry_finalizer_t, "copy");
+  }
+  auto_entry_finalizer_t(journal_t * _journal) : journal(_journal) {
+    TRACE_CTOR(auto_entry_finalizer_t, "journal_t *");
+  }
+  ~auto_entry_finalizer_t() throw() {
+    TRACE_DTOR(auto_entry_finalizer_t);
+  }
+
   virtual bool operator()(entry_t& entry, bool post);
 };
 
@@ -293,16 +313,16 @@ class period_entry_t : public entry_base_t
   period_entry_t() {
     TRACE_CTOR(period_entry_t, "");
   }
-  period_entry_t(const string& _period)
-    : period(_period), period_string(_period) {
-    TRACE_CTOR(period_entry_t, "const string&");
-  }
   period_entry_t(const period_entry_t& e)
     : entry_base_t(e), period(e.period), period_string(e.period_string) {
     TRACE_CTOR(period_entry_t, "copy");
   }
+  period_entry_t(const string& _period)
+    : period(_period), period_string(_period) {
+    TRACE_CTOR(period_entry_t, "const string&");
+  }
 
-  virtual ~period_entry_t() {
+  virtual ~period_entry_t() throw() {
     TRACE_DTOR(period_entry_t);
   }
 
@@ -337,6 +357,19 @@ class account_t
       depth(parent ? parent->depth + 1 : 0), data(NULL), ident(0) {
     TRACE_CTOR(account_t, "account_t *, const string&, const string&");
   }
+  account_t(const account_t& other)
+    : journal(other.journal),
+      parent(other.parent),
+      name(other.name),
+      note(other.note),
+      depth(other.depth),
+      accounts(other.accounts),
+      data(NULL),
+      ident(0) {
+    TRACE_CTOR(account_t, "copy");
+    assert(other.data == NULL);
+    assert(other.ident == 0);
+  }
   ~account_t();
 
   operator string() const {
@@ -364,12 +397,26 @@ class account_t
 std::ostream& operator<<(std::ostream& out, const account_t& account);
 
 
-struct func_finalizer_t : public entry_finalizer_t {
+class func_finalizer_t : public entry_finalizer_t
-  typedef bool (*func_t)(entry_t& entry, bool post);
+{
+  func_finalizer_t();
+
+public:
+  typedef function<bool (entry_t& entry, bool post)> func_t;
+
   func_t func;
-  func_finalizer_t(func_t _func) : func(_func) {}
+
+  func_finalizer_t(func_t _func) : func(_func) {
+    TRACE_CTOR(func_finalizer_t, "func_t");
+  }
   func_finalizer_t(const func_finalizer_t& other) :
-    entry_finalizer_t(), func(other.func) {}
+    entry_finalizer_t(), func(other.func) {
+    TRACE_CTOR(func_finalizer_t, "copy");
+  }
+  ~func_finalizer_t() throw() {
+    TRACE_DTOR(func_finalizer_t);
+  }
+
   virtual bool operator()(entry_t& entry, bool post) {
     return func(entry, post);
   }
@@ -407,7 +454,7 @@ typedef std::list<string>	    strings_list;
 
 class session_t;
 
-class journal_t
+class journal_t : public noncopyable
 {
  public:
   session_t *	 owner;

mask.cc

@@ -35,6 +35,8 @@ namespace ledger {
 
 mask_t::mask_t(const string& pat) : exclude(false)
 {
+  TRACE_CTOR(mask_t, "const string&");
+
   const char * p = pat.c_str();
 
   if (*p == '-') {

mask.h

@@ -38,12 +38,19 @@ namespace ledger {
 
 class mask_t
 {
- public:
+  mask_t();
+
+public:
   bool	       exclude;
   boost::regex expr;
 
   explicit mask_t(const string& pattern);
-  mask_t(const mask_t& m) : exclude(m.exclude), expr(m.expr) {}
+  mask_t(const mask_t& m) : exclude(m.exclude), expr(m.expr) {
+    TRACE_CTOR(mask_t, "copy");
+  }
+  ~mask_t() throw() {
+    TRACE_DTOR(mask_t);
+  }
 
   bool match(const string& str) const {
     return boost::regex_match(str, expr) && ! exclude;

ofx.h

@@ -7,7 +7,7 @@ namespace ledger {
 
 class ofx_parser_t : public parser_t
 {
- public:
+public:
   virtual bool test(std::istream& in) const;
 
   virtual unsigned int parse(std::istream& in,

parser.h

@@ -9,10 +9,15 @@ class account_t;
 class journal_t;
 class session_t;
 
-class parser_t
+class parser_t : public noncopyable
 {
- public:
+public:
-  virtual ~parser_t() {}
+  parser_t() {
+    TRACE_CTOR(parser_t, "");
+  }
+  virtual ~parser_t() {
+    TRACE_DTOR(parser_t);
+  }
 
   virtual bool test(std::istream& in) const = 0;
 
@@ -41,8 +46,9 @@ unsigned int parse_ledger_data(session_t& session,
 			       parser_t * xml_parser   = NULL,
 			       parser_t * stdin_parser = NULL);
 
-class parse_error : public error {
+class parse_error : public error
- public:
+{
+public:
   parse_error(const string& reason, error_context * ctxt = NULL) throw()
     : error(reason, ctxt) {}
   virtual ~parse_error() throw() {}

parsexp.h

@@ -39,7 +39,7 @@ namespace expr {
 
 DECLARE_EXCEPTION(error, parse_error);
 
-class parser_t
+class parser_t : public noncopyable
 {
 #define EXPR_PARSE_NORMAL     0x00
 #define EXPR_PARSE_PARTIAL    0x01
@@ -52,7 +52,7 @@ public:
   typedef uint_least8_t flags_t;
 
 private:
-  struct token_t
+  struct token_t : public noncopyable
   {
     enum kind_t {
       VALUE,			// any kind of literal value
@@ -112,12 +112,14 @@ private:
     explicit token_t() : kind(UNKNOWN), length(0) {
       TRACE_CTOR(token_t, "");
     }
+#if 0
     token_t(const token_t& other) {
       assert(false);
       TRACE_CTOR(token_t, "copy");
       *this = other;
     }
-    ~token_t() {
+#endif
+    ~token_t() throw() {
       TRACE_DTOR(token_t);
     }
 

pushvar.h

@@ -43,22 +43,35 @@
 template <typename T>
 class push_variable : public boost::noncopyable
 {
+  push_variable();
+
+public:
   T&   var;
   T    prev;
   bool enabled;
 
-public:
   explicit push_variable(T& _var)
-    : var(_var), prev(var), enabled(true) {}
+    : var(_var), prev(var), enabled(true) {
+    TRACE_CTOR(push_variable, "T&");
+  }
   explicit push_variable(T& _var, const T& value)
     : var(_var), prev(var), enabled(true) {
+    TRACE_CTOR(push_variable, "T&, constT&");
     var = value;
   }
-  ~push_variable() {
+  ~push_variable() throw() {
+    TRACE_DTOR(push_variable);
     if (enabled)
       var = prev;
   }
 
+  T& operator*() {
+    return var;
+  }
+  T * operator->() {
+    return &var;
+  }
+
   void clear() {
     enabled = false;
   }

pyfstream.h

@@ -35,14 +35,23 @@
 // pyofstream
 // - a stream that writes on a Python file object
 
-class pyoutbuf : public std::streambuf {
+class pyoutbuf : public boost::noncopyable, public std::streambuf
- protected:
+{
-  PyFileObject * fo;    // Python file object
+  pyoutbf();
- public:
-  // constructor
-  pyoutbuf (PyFileObject * _fo) : fo(_fo) {}
 
- protected:
+protected:
+  PyFileObject * fo;    // Python file object
+
+public:
+  // constructor
+  pyoutbuf(PyFileObject * _fo) : fo(_fo) {
+    TRACE_CTOR(pyoutbuf, "PyFileObject *");
+  }
+  ~pyoutbuf() : throw() {
+    TRACE_DTOR(pyoutbuf);
+  }
+
+protected:
   // write one character
   virtual int_type overflow (int_type c) {
     if (c != EOF) {
@@ -68,22 +77,34 @@ class pyoutbuf : public std::streambuf {
   }
 };
 
-class pyofstream : public std::ostream {
+class pyofstream : public noncopyable, public std::ostream
- protected:
+{
+  pyofstream();
+
+protected:
   pyoutbuf buf;
- public:
+
+public:
   pyofstream (PyFileObject * fo) : std::ostream(0), buf(fo) {
+    TRACE_CTOR(pyofstream, "PyFileObject *");
     rdbuf(&buf);
   }
+  ~pyofstream() throw() {
+    TRACE_DTOR(pyofstream);
+  }
 };
 
 // pyifstream
 // - a stream that reads on a file descriptor
 
-class pyinbuf : public std::streambuf {
+class pyinbuf : public noncopyable, public std::streambuf
- protected:
+{
+  pyinbuf();
+
+protected:
   PyFileObject * fo;    // Python file object
- protected:
+
+protected:
   /* data buffer:
    * - at most, pbSize characters in putback area plus
    * - at most, bufSize characters in ordinary read buffer
@@ -92,7 +113,7 @@ class pyinbuf : public std::streambuf {
   static const int bufSize = 1024; // size of the data buffer
   char buffer[bufSize + pbSize];   // data buffer
 
- public:
+public:
   /* constructor
    * - initialize file descriptor
    * - initialize empty data buffer
@@ -100,12 +121,17 @@ class pyinbuf : public std::streambuf {
    * => force underflow()
    */
   pyinbuf (PyFileObject * _fo) : fo(_fo) {
+    TRACE_CTOR(pyinbuf, "PyFileObject *");
+
     setg (buffer+pbSize,     // beginning of putback area
 	  buffer+pbSize,     // read position
 	  buffer+pbSize);    // end position
   }
+  ~pyinbuf() throw() {
+    TRACE_DTOR(pyinbuf);
+  }
 
- protected:
+protected:
   // insert new characters into the buffer
   virtual int_type underflow () {
 #ifndef _MSC_VER
@@ -157,13 +183,21 @@ class pyinbuf : public std::streambuf {
   }
 };
 
-class pyifstream : public std::istream {
+class pyifstream : public noncopyable, public std::istream
- protected:
+{
+  pyifstream();
+
+protected:
   pyinbuf buf;
- public:
+
+public:
   pyifstream (PyFileObject * fo) : std::istream(0), buf(fo) {
+    TRACE_CTOR(pyifstream, "PyFileObject *");
     rdbuf(&buf);
   }
+  ~pyifstream() throw() {
+    TRACE_DTOR(pyifstream);
+  }
 };
 
 #endif // _PYFSTREAM_H

pyinterp.cc

@@ -86,11 +86,13 @@ struct python_run
   }
 };
 
-python_interpreter_t::python_interpreter_t(xml::xpath_t::scope_t& parent)
+python_interpreter_t::python_interpreter_t(expr::scope_t& parent)
-  : xml::xpath_t::symbol_scope_t(parent),
+  : expr::symbol_scope_t(parent),
     mmodule(borrowed(PyImport_AddModule("__main__"))),
     nspace(handle<>(borrowed(PyModule_GetDict(mmodule.get()))))
 {
+  TRACE_CTOR(python_interpreter_t, "expr::scope_t&");
+
   Py_Initialize();
   boost::python::detail::init_module("ledger", &initialize_for_python);
 }
@@ -177,7 +179,7 @@ object python_interpreter_t::eval(const string& str, py_eval_mode_t mode)
 }
 
 value_t python_interpreter_t::functor_t::operator()
-  (xml::xpath_t::call_scope_t& args)
+  (expr::call_scope_t& args)
 {
   try {
     if (! PyCallable_Check(func.ptr())) {
@@ -200,7 +202,7 @@ value_t python_interpreter_t::functor_t::operator()
 	}
 	else if (PyObject * err = PyErr_Occurred()) {
 	  PyErr_Print();
-	  throw_(xml::xpath_t::calc_error,
+	  throw_(expr::calc_error,
 		 "While calling Python function '" /*<< name() <<*/ "': " << err);
 	} else {
 	  assert(false);
@@ -212,14 +214,14 @@ value_t python_interpreter_t::functor_t::operator()
   }
   catch (const error_already_set&) {
     PyErr_Print();
-    throw_(xml::xpath_t::calc_error,
+    throw_(expr::calc_error,
 	   "While calling Python function '" /*<< name() <<*/ "'");
   }
   return NULL_VALUE;
 }
 
 value_t python_interpreter_t::lambda_t::operator()
-  (xml::xpath_t::call_scope_t& args)
+  (expr::call_scope_t& args)
 {
   try {
     assert(args.size() == 1);
@@ -229,7 +231,7 @@ value_t python_interpreter_t::lambda_t::operator()
   }
   catch (const error_already_set&) {
     PyErr_Print();
-    throw_(xml::xpath_t::calc_error,
+    throw_(expr::calc_error,
 	   "While evaluating Python lambda expression");
   }
   return NULL_VALUE;

pyinterp.h

@@ -39,16 +39,21 @@
 
 namespace ledger {
 
-class python_interpreter_t : public xml::xpath_t::symbol_scope_t
+class python_interpreter_t
+  : public noncopyable, public expr::symbol_scope_t
 {
   boost::python::handle<> mmodule;
 
- public:
+  python_interpreter_t();
+
+public:
   boost::python::dict nspace;
 
-  python_interpreter_t(xml::xpath_t::scope_t& parent);
+  python_interpreter_t(expr::scope_t& parent);
 
   virtual ~python_interpreter_t() {
+    TRACE_DTOR(python_interpreter_t);
+
     Py_Finalize();
   }
 
@@ -71,25 +76,42 @@ class python_interpreter_t : public xml::xpath_t::symbol_scope_t
   }
 
   class functor_t {
+    functor_t();
   protected:
     boost::python::object func;
   public:
-    functor_t(const string& name, boost::python::object _func) : func(_func) {}
+    functor_t(const string& name, boost::python::object _func) : func(_func) {
-    virtual ~functor_t() {}
+      TRACE_CTOR(functor_t, "const string&, boost::python::object");
-    virtual value_t operator()(xml::xpath_t::call_scope_t& args);
+    }
+    functor_t(const functor_t& other) : func(other.func) {
+      TRACE_CTOR(functor_t, "copy");
+    }
+    virtual ~functor_t() throw() {
+      TRACE_DTOR(functor_t);
+    }
+    virtual value_t operator()(expr::call_scope_t& args);
   };
 
-  virtual xml::xpath_t::ptr_op_t lookup(const string& name) {
+  virtual expr::ptr_op_t lookup(const string& name) {
     if (boost::python::object func = eval(name))
       return WRAP_FUNCTOR(functor_t(name, func));
     else
-      return xml::xpath_t::symbol_scope_t::lookup(name);
+      return expr::symbol_scope_t::lookup(name);
   }
 
   class lambda_t : public functor_t {
-   public:
+    lambda_t();
-    lambda_t(boost::python::object code) : functor_t("<lambda>", code) {}
+  public:
-    virtual value_t operator()(xml::xpath_t::call_scope_t& args);
+    lambda_t(boost::python::object code) : functor_t("<lambda>", code) {
+      TRACE_CTOR(functor_t, "boost::python::object");
+    }
+    lambda_t(const lambda_t& other) : functor_t(other) {
+      TRACE_CTOR(lambda_t, "copy");
+    }
+    virtual ~lambda_t() throw() {
+      TRACE_DTOR(lambda_t);
+    }
+    virtual value_t operator()(expr::call_scope_t& args);
   };
 };
 

quotes.h

@@ -5,18 +5,26 @@
 
 namespace ledger {
 
-class quotes_by_script : public commodity_t::base_t::updater_t
+class quotes_by_script
+  : public noncopyable, commodity_t::base_t::updater_t
 {
-  string   price_db;
+  string	price_db;
   unsigned long pricing_leeway;
   bool&         cache_dirty;
 
- public:
+  quotes_by_script();
+
+public:
   quotes_by_script(path		 _price_db,
 		   unsigned long _pricing_leeway,
 		   bool&         _cache_dirty)
     : price_db(_price_db), pricing_leeway(_pricing_leeway),
-      cache_dirty(_cache_dirty) {}
+      cache_dirty(_cache_dirty) {
+    TRACE_CTOR(quotes_by_script, "path, unsigned long, bool&");
+  }
+  ~quotes_by_script() throw() {
+    TRACE_DTOR(quotes_by_script);
+  }
 
   virtual void operator()(commodity_base_t& commodity,
 			  const datetime_t& moment,

reconcile.h

@@ -13,12 +13,20 @@ class reconcile_transactions : public item_handler<transaction_t>
 
   transactions_list xacts;
 
- public:
+  reconcile_transactions();
+
+public:
   reconcile_transactions(item_handler<transaction_t> * handler,
 			 const value_t&    _balance,
 			 const datetime_t& _cutoff)
     : item_handler<transaction_t>(handler),
-      balance(_balance), cutoff(_cutoff) {}
+      balance(_balance), cutoff(_cutoff) {
+    TRACE_CTOR(reconcile_transactions,
+	       "item_handler<transaction_t> *, const value_t&, const datetime_t&");
+  }
+  virtual ~reconcile_transactions() throw() {
+    TRACE_DTOR(reconcile_transactions);
+  }
 
   void push_to_handler(transaction_t * first);
 

report.cc

@@ -33,11 +33,6 @@
 
 namespace ledger {
 
-report_t::~report_t()
-{
-  TRACE_DTOR(report_t);
-}
-
 void report_t::apply_transforms(expr::scope_t& scope)
 {
 #if 0

report.h

@@ -36,10 +36,10 @@
 
 namespace ledger {
 
-typedef std::list<string> strings_list;
-
 class report_t : public expr::symbol_scope_t
 {
+  report_t();
+
 public:
   optional<path> output_file;
   string	 format_string;
@@ -78,7 +78,9 @@ public:
 #endif
   }
 
-  virtual ~report_t();
+  virtual ~report_t() throw() {
+    TRACE_DTOR(report_t);
+  }
 
   void apply_transforms(expr::scope_t& scope);
 

session.cc

@@ -118,7 +118,7 @@ session_t::session_t()
     ansi_codes(false),
     ansi_invert(false)
 {
-  TRACE_CTOR(session_t, "expr::scope_t&");
+  TRACE_CTOR(session_t, "");
 }
 
 std::size_t session_t::read_journal(journal_t&	  journal,

session.h

@@ -80,7 +80,7 @@ class session_t : public expr::symbol_scope_t
   ptr_list<parser_t>  parsers;
 
   session_t();
-  virtual ~session_t() {
+  virtual ~session_t() throw() {
     TRACE_DTOR(session_t);
   }
 

textual.cc

@@ -23,20 +23,29 @@ static accounts_map account_aliases;
 static std::list<std::pair<path, int> > include_stack;
 
 #ifdef TIMELOG_SUPPORT
-struct time_entry_t {
+struct time_entry_t
+{
   datetime_t  checkin;
   account_t * account;
   string      desc;
 
-  time_entry_t() : account(NULL) {}
+  time_entry_t() : account(NULL) {
-  time_entry_t(datetime_t  _checkin,
+    TRACE_CTOR(time_entry_t, "");
-	       account_t * _account = NULL,
+  }
-	       std::string _desc    = "")
+  time_entry_t(const datetime_t& _checkin,
-    : checkin(_checkin), account(_account), desc(_desc) {}
+	       account_t *	 _account = NULL,
-
+	       const string&     _desc	  = "")
+    : checkin(_checkin), account(_account), desc(_desc) {
+    TRACE_CTOR(time_entry_t, "const datetime_t&, account_t *, const string&");
+  }
   time_entry_t(const time_entry_t& entry)
     : checkin(entry.checkin), account(entry.account),
-      desc(entry.desc) {}
+      desc(entry.desc) {
+    TRACE_CTOR(time_entry_t, "copy");
+  }
+  ~time_entry_t() throw() {
+    TRACE_DTOR(time_entry_t);
+  }
 };
 #endif
 
@@ -457,14 +466,6 @@ entry_t * parse_entry(std::istream& in, char * line, account_t * master,
   return curr.release();
 }
 
-template <typename T>
-struct push_var {
-  T& var;
-  T prev;
-  push_var(T& _var) : var(_var), prev(var) {}
-  ~push_var() { var = prev; }
-};
-
 static inline void parse_symbol(char *& p, string& symbol)
 {
   if (*p == '"') {
@@ -803,13 +804,12 @@ unsigned int textual_parser_t::parse(std::istream& in,
 	char * p = next_element(line);
 	string word(line + 1);
 	if (word == "include") {
-	  push_var<path>	  save_pathname(pathname);
+	  push_variable<path>	       save_pathname(pathname);
-	  push_var<unsigned int>  save_src_idx(src_idx);
+	  push_variable<unsigned int>  save_src_idx(src_idx);
-	  push_var<unsigned long> save_beg_pos(beg_pos);
+	  push_variable<unsigned long> save_beg_pos(beg_pos);
-	  push_var<unsigned long> save_end_pos(end_pos);
+	  push_variable<unsigned long> save_end_pos(end_pos);
-	  push_var<unsigned int>  save_linenum(linenum);
+	  push_variable<unsigned int>  save_linenum(linenum);
 
-	  // jww (2008-04-22): Fix this!
 	  pathname = p;
 #if 0
 	  if (pathname[0] != '/' && pathname[0] != '\\' && pathname[0] != '~') {
@@ -820,12 +820,10 @@ unsigned int textual_parser_t::parse(std::istream& in,
 	      pathname = string(save_pathname.prev, 0, pos + 1) + pathname;
 	  }
 	  pathname = resolve_path(pathname);
-#endif
 
 	  DEBUG("ledger.textual.include", "line " << linenum << ": " <<
 		      "Including path '" << pathname << "'");
 
-#if 0
 	  include_stack.push_back(std::pair<path, int>
 				  (journal.sources.back(), linenum - 1));
 	  count += parse_journal_file(pathname, config, journal,

textual.h

@@ -27,7 +27,8 @@ void write_textual_journal(journal_t& journal, path pathname,
 			   const string& write_hdr_format,
 			   std::ostream& out);
 
-class include_context : public file_context {
+class include_context : public file_context
+{
  public:
   include_context(const path& file, unsigned long line,
 		  const string& desc = "") throw()

times.h

@@ -86,6 +86,20 @@ struct interval_t
     TRACE_CTOR(interval_t,
 	       "int, int, int, const datetime_t&, const datetime_t&");
   }
+  interval_t(const interval_t& other)
+    : years(other.years),
+      months(other.months),
+      days(other.days),
+      hours(other.hours),
+      minutes(other.minutes),
+      seconds(other.seconds),
+
+      begin(other.begin),
+      end(other.end),
+
+      advanced(other.advanced) {
+    TRACE_CTOR(interval_t, "copy");
+  }
 
   interval_t(const string& desc)
     : years(0), months(0), days(0),
@@ -149,7 +163,7 @@ extern bool        day_before_month;
 #if 0
 struct intorchar
 {
-  int	      ival;
+  int	 ival;
   string sval;
 
   intorchar() : ival(-1) {}

utils.cc

@@ -306,7 +306,11 @@ void trace_dtor_func(void * ptr, const char * cls_name, std::size_t cls_size)
   DEBUG("memory.debug", "TRACE_DTOR " << ptr << " " << cls_name);
 
   live_objects_map::iterator i = live_objects->find(ptr);
-  VERIFY(i != live_objects->end());
+  if (i == live_objects->end()) {
+    std::cerr << "Attempting to delete " << ptr << " a non-living " << cls_name
+	      << std::endl;
+    assert(false);
+  }
 
   int ptr_count = live_objects->count(ptr);
   for (int x = 0; x < ptr_count; x++, i++) {
@@ -389,7 +393,7 @@ string::string() : std::string() {
   TRACE_CTOR(string, "");
 }
 string::string(const string& str) : std::string(str) {
-  TRACE_CTOR(string, "const string&");
+  TRACE_CTOR(string, "copy");
 }
 string::string(const std::string& str) : std::string(str) {
   TRACE_CTOR(string, "const std::string&");
@@ -415,7 +419,7 @@ string::string(const char * str, int x) : std::string(str, x) {
 string::string(const char * str, int x, int y) : std::string(str, x, y) {
   TRACE_CTOR(string, "const char *, int, int");
 }
-string::~string() {
+string::~string() throw() {
   TRACE_DTOR(string);
 }
 
@@ -541,7 +545,8 @@ optional<std::string> _log_category;
 
 namespace ledger {
 
-struct timer_t {
+struct timer_t
+{
   log_level_t	level;
   ptime		begin;
   time_duration	spent;

utils.h

@@ -95,6 +95,8 @@ namespace ledger {
   typedef std::string string;
 #endif
 
+  typedef std::list<string> strings_list;
+
   typedef posix_time::ptime	    ptime;
   typedef ptime::time_duration_type time_duration;
   typedef gregorian::date	    date;
@@ -161,9 +163,11 @@ void trace_ctor_func(void * ptr, const char * cls_name, const char * args,
 void trace_dtor_func(void * ptr, const char * cls_name, std::size_t cls_size);
 
 #define TRACE_CTOR(cls, args) \
-  (DO_VERIFY() ? trace_ctor_func(this, #cls, args, sizeof(cls)) : ((void)0))
+  (DO_VERIFY() ? \
+   ledger::trace_ctor_func(this, #cls, args, sizeof(cls)) : ((void)0))
 #define TRACE_DTOR(cls) \
-  (DO_VERIFY() ? trace_dtor_func(this, #cls, sizeof(cls)) : ((void)0))
+  (DO_VERIFY() ? \
+   ledger::trace_dtor_func(this, #cls, sizeof(cls)) : ((void)0))
 
 void report_memory(std::ostream& out, bool report_all = false);
 
@@ -184,7 +188,7 @@ public:
   string(const string& str, int x, int y);
   string(const char * str, int x);
   string(const char * str, int x, int y);
-  ~string();
+  ~string() throw();
 };
 
 inline string operator+(const string& __lhs, const string& __rhs)

valexpr.cc

@@ -47,7 +47,7 @@ datetime_t terminus;
 details_t::details_t(const transaction_t& _xact)
   : entry(_xact.entry), xact(&_xact), account(xact_account(_xact))
 {
-  DEBUG("ledger.memory.ctors", "ctor details_t");
+  TRACE_CTOR(details_t, "const transaction_t&");
 }
 
 bool compute_amount(ptr_op_t expr, amount_t& amt,

valexpr.h

@@ -101,21 +101,27 @@ struct details_t
   const transaction_t * xact;
   const account_t *     account;
 
-  details_t() : entry(NULL), xact(NULL), account(NULL) {}
+  details_t() : entry(NULL), xact(NULL), account(NULL) {
+    TRACE_CTOR(details_t, "");
+  }
+  details_t(const details_t& other)
+    : entry(other.entry),
+      xact(other.xact),
+      account(other.account) {
+    TRACE_CTOR(details_t, "copy");
+  }
   details_t(const entry_t& _entry)
     : entry(&_entry), xact(NULL), account(NULL) {
-    DEBUG("ledger.memory.ctors", "ctor details_t");
+    TRACE_CTOR(details_t, "const entry_t&");
   }
   details_t(const transaction_t& _xact);
   details_t(const account_t& _account)
     : entry(NULL), xact(NULL), account(&_account) {
-    DEBUG("ledger.memory.ctors", "ctor details_t");
+    TRACE_CTOR(details_t, "const account_t&");
   }
-#ifdef DEBUG_ENABLED
+  ~details_t() throw() {
-  ~details_t() {
+    TRACE_DTOR(details_t);
-    DEBUG("ledger.memory.dtors", "dtor details_t");
   }
-#endif
 };
 
 struct op_t;
@@ -130,6 +136,8 @@ typedef function<value_t (call_scope_t&)> function_t;
 
 class scope_t : public noncopyable
 {
+  scope_t();
+
 public:
   enum type_t {
     CHILD_SCOPE,
@@ -139,10 +147,10 @@ public:
   } type_;
 
   explicit scope_t(type_t _type) : type_(_type) {
-    TRACE_CTOR(expr::scope_t, "type_t");
+    TRACE_CTOR(scope_t, "type_t");
   }
-  virtual ~scope_t() {
+  virtual ~scope_t() throw() {
-    TRACE_DTOR(expr::scope_t);
+    TRACE_DTOR(scope_t);
   }
 
   const type_t type() const {
@@ -174,17 +182,19 @@ class child_scope_t : public scope_t
 {
   scope_t * parent;
 
+  child_scope_t();
+
 public:
   explicit child_scope_t(type_t _type = CHILD_SCOPE)
     : scope_t(_type), parent(NULL) {
-    TRACE_CTOR(expr::child_scope_t, "type_t");
+    TRACE_CTOR(child_scope_t, "type_t");
   }
   explicit child_scope_t(scope_t& _parent, type_t _type = CHILD_SCOPE)
     : scope_t(_type), parent(&_parent) {
-    TRACE_CTOR(expr::child_scope_t, "scope_t&, type_t");
+    TRACE_CTOR(child_scope_t, "scope_t&, type_t");
   }
-  virtual ~child_scope_t() {
+  virtual ~child_scope_t() throw() {
-    TRACE_DTOR(expr::child_scope_t);
+    TRACE_DTOR(child_scope_t);
   }
 public:
   virtual void     define(const string& name, ptr_op_t def) {
@@ -229,14 +239,14 @@ class symbol_scope_t : public child_scope_t
 public:
   explicit symbol_scope_t()
     : child_scope_t(SYMBOL_SCOPE) {
-    TRACE_CTOR(expr::symbol_scope_t, "");
+    TRACE_CTOR(symbol_scope_t, "");
   }
   explicit symbol_scope_t(scope_t& _parent)
     : child_scope_t(_parent, SYMBOL_SCOPE) {
-    TRACE_CTOR(expr::symbol_scope_t, "scope_t&");
+    TRACE_CTOR(symbol_scope_t, "scope_t&");
   }
-  virtual ~symbol_scope_t() {
+  virtual ~symbol_scope_t() throw() {
-    TRACE_DTOR(expr::symbol_scope_t);
+    TRACE_DTOR(symbol_scope_t);
   }
 
   virtual void     define(const string& name, ptr_op_t def);
@@ -250,13 +260,15 @@ class call_scope_t : public child_scope_t
 {
   value_t args;
 
+  call_scope_t();
+
 public:
   explicit call_scope_t(scope_t& _parent)
     : child_scope_t(_parent, CALL_SCOPE) {
-    TRACE_CTOR(expr::call_scope_t, "scope_t&");
+    TRACE_CTOR(call_scope_t, "scope_t&");
   }
-  virtual ~call_scope_t() {
+  virtual ~call_scope_t() throw() {
-    TRACE_DTOR(expr::call_scope_t);
+    TRACE_DTOR(call_scope_t);
   }
 
   void set_args(const value_t& _args) {
@@ -289,20 +301,31 @@ public:
 };
 
 template <typename T>
-struct var_t
+class var_t : public noncopyable
 {
   T * value;
 
+  var_t();
+
+public:
   // jww (2008-07-21): Give a good exception here if we can't find "name"
   var_t(scope_t& scope, const string& name)
-    : value(scope.resolve(name).template as_pointer<T>()) {}
+    : value(scope.resolve(name).template as_pointer<T>()) {
+    TRACE_CTOR(var_t, "scope_t&, const string&");
+  }
   var_t(call_scope_t& scope, const unsigned int idx)
-    : value(scope[idx].template as_pointer<T>()) {}
+    : value(scope[idx].template as_pointer<T>()) {
+    TRACE_CTOR(var_t, "call_scope_t&, const unsigned int");
+  }
+  ~var_t() throw() {
+    TRACE_DTOR(var_t);
+  }
 
   T& operator *() { return *value; }
   T * operator->() { return value; }
 };
 
+#if 0
 class context_scope_t : public child_scope_t
 {
 public:
@@ -334,9 +357,13 @@ public:
     return current_element;
   }
 };
+#endif
 
-struct op_t : public noncopyable
+class op_t : public noncopyable
 {
+  op_t();
+
+public:
   enum kind_t {
     // Constants
     VALUE,
@@ -441,12 +468,10 @@ struct op_t : public noncopyable
   data;
 
   explicit op_t(const kind_t _kind) : kind(_kind), refc(0){
-    TRACE_CTOR(expr::op_t, "const kind_t");
+    TRACE_CTOR(op_t, "const kind_t");
   }
   ~op_t() {
-    TRACE_DTOR(expr::op_t);
+    TRACE_DTOR(op_t);
-
-    DEBUG("ledger.xpath.memory", "Destroying " << this);
     assert(refc == 0);
   }
 
@@ -656,18 +681,27 @@ struct op_t : public noncopyable
   }
 };
 
-class op_predicate {
+class op_predicate : public noncopyable
+{
   ptr_op_t op;
 
+  op_predicate();
+
 public:
-  explicit op_predicate(ptr_op_t _op) : op(_op) {}
+  explicit op_predicate(ptr_op_t _op) : op(_op) {
+    TRACE_CTOR(op_predicate, "ptr_op_t");
+  }
+  ~op_predicate() throw() {
+    TRACE_DTOR(op_predicate);
+  }
   bool operator()(scope_t& scope) {
     return op->calc(scope).to_boolean();
   }
 };
 
-class valexpr_context : public error_context {
+class valexpr_context : public error_context
- public:
+{
+public:
   ptr_op_t expr;
   ptr_op_t error_node;
 
@@ -679,15 +713,17 @@ class valexpr_context : public error_context {
   virtual void describe(std::ostream& out) const throw();
 };
 
-class compute_error : public error {
+class compute_error : public error
- public:
+{
+public:
   compute_error(const string& reason, error_context * ctxt = NULL) throw()
     : error(reason, ctxt) {}
   virtual ~compute_error() throw() {}
 };
 
-class value_expr_error : public error {
+class value_expr_error : public error
- public:
+{
+public:
   value_expr_error(const string& reason,
 		   error_context * ctxt = NULL) throw()
     : error(reason, ctxt) {}
@@ -748,6 +784,7 @@ scope_t::find_scope<call_scope_t>(bool skip_this) {
   return downcast<call_scope_t>(*scope);
 }
 
+#if 0
 template<>
 inline context_scope_t&
 scope_t::find_scope<context_scope_t>(bool skip_this) {
@@ -755,6 +792,7 @@ scope_t::find_scope<context_scope_t>(bool skip_this) {
   assert(scope);
   return downcast<context_scope_t>(*scope);
 }
+#endif
 
 #define FIND_SCOPE(scope_type, scope_ref) \
   downcast<scope_t>(scope_ref).find_scope<scope_type>()
@@ -763,8 +801,10 @@ scope_t::find_scope<context_scope_t>(bool skip_this) {
   FIND_SCOPE(call_scope_t, scope_ref)
 #define SYMBOL_SCOPE(scope_ref) \
   FIND_SCOPE(symbol_scope_t, scope_ref)
+#if 0
 #define CONTEXT_SCOPE(scope_ref) \
   FIND_SCOPE(context_scope_t, scope_ref)
+#endif
 
 inline ptr_op_t op_t::new_node(kind_t _kind, ptr_op_t _left, ptr_op_t _right) {
   ptr_op_t node(new op_t(_kind));
@@ -798,7 +838,9 @@ public:
 
   typedef expr::details_t details_t;
 
-  value_expr() {}
+  value_expr() {
+    TRACE_CTOR(value_expr, "");
+  }
 
   value_expr(const string& _expr_str);
   value_expr(const expr::ptr_op_t _ptr, const string& _expr_str = "")
@@ -809,16 +851,16 @@ public:
     : ptr(other.ptr), expr_str(other.expr_str) {
     TRACE_CTOR(value_expr, "copy");
   }
+  virtual ~value_expr() throw() {
+    TRACE_DTOR(value_expr);
+  }
+
   value_expr& operator=(const value_expr& _expr) {
     expr_str = _expr.expr_str;
     reset(_expr.get());
     return *this;
   }
 
-  virtual ~value_expr() throw() {
-    TRACE_DTOR(value_expr);
-  }
-
   operator bool() const throw() {
     return ptr.get() != NULL;
   }
@@ -900,14 +942,16 @@ public:
   item_predicate() {
     TRACE_CTOR(item_predicate, "");
   }
+  item_predicate(const item_predicate& other) : predicate(other.predicate) {
+    TRACE_CTOR(item_predicate, "copy");
+  }
   item_predicate(const value_expr& _predicate) : predicate(_predicate) {
     TRACE_CTOR(item_predicate, "const value_expr&");
   }
   item_predicate(const string& _predicate) : predicate(_predicate) {
     TRACE_CTOR(item_predicate, "const string&");
   }
-
+  ~item_predicate() throw() {
-  ~item_predicate() {
     TRACE_DTOR(item_predicate);
   }
 

value.h

@@ -163,7 +163,7 @@ private:
      */
     explicit storage_t(const storage_t& rhs)
       : type(rhs.type), refc(0) {
-      TRACE_CTOR(value_t::storage_t, "");
+      TRACE_CTOR(value_t::storage_t, "copy");
       *this = rhs;
     }
     storage_t& operator=(const storage_t& rhs);

walk.cc

@@ -424,8 +424,7 @@ void subtotal_transactions::operator()(transaction_t& xact)
     value_t temp;
     add_transaction_to(xact, temp);
     std::pair<values_map::iterator, bool> result
-      = values.insert(values_pair(acct->fullname(),
+      = values.insert(values_pair(acct->fullname(), acct_value_t(acct, temp)));
-				  acct_value_t(acct, temp)));
     assert(result.second);
 
     if (remember_components)
@@ -507,6 +506,8 @@ void interval_transactions::operator()(transaction_t& xact)
 
 by_payee_transactions::~by_payee_transactions()
 {
+  TRACE_DTOR(by_payee_transactions);
+
   for (payee_subtotals_map::iterator i = payee_subtotals.begin();
        i != payee_subtotals.end();
        i++)

walk.h

@@ -12,18 +12,19 @@
 namespace ledger {
 
 template <typename T>
-struct item_handler {
+struct item_handler : public noncopyable
+{
   item_handler * handler;
 
- public:
+public:
   item_handler() : handler(NULL) {
-    DEBUG("ledger.memory.ctors", "ctor item_handler<T>");
+    TRACE_CTOR(item_handler, "");
   }
   item_handler(item_handler * _handler) : handler(_handler) {
-    DEBUG("ledger.memory.ctors", "ctor item_handler<T>");
+    TRACE_CTOR(item_handler, "item_handler *");
   }
   virtual ~item_handler() {
-    DEBUG("ledger.memory.dtors", "dtor item_handler<T>");
+    TRACE_DTOR(item_handler);
   }
 
   virtual void flush() {
@@ -37,10 +38,22 @@ struct item_handler {
 };
 
 template <typename T>
-class compare_items {
+class compare_items
+{
   value_expr sort_order;
- public:
+
-  compare_items(value_expr _sort_order) : sort_order(_sort_order) {}
+  compare_items();
+  
+public:
+  compare_items(const compare_items& other) : sort_order(other.sort_order) {
+    TRACE_CTOR(compare_items, "copy");
+  }
+  compare_items(const value_expr& _sort_order) : sort_order(_sort_order) {
+    TRACE_CTOR(compare_items, "const value_expr&");
+  }
+  ~compare_items() throw() {
+    TRACE_DTOR(compare_items);
+  }
   bool operator()(const T * left, const T * right);
 };
 
@@ -79,7 +92,7 @@ bool compare_items<account_t>::operator()(const account_t * left,
 #define TRANSACTION_COMPOUND   0x0040
 #define TRANSACTION_MATCHES    0x0080
 
-struct transaction_xdata_t
+struct transaction_xdata_t : public noncopyable
 {
   value_t	 total;
   value_t	 sort_value;
@@ -95,13 +108,13 @@ struct transaction_xdata_t
   transaction_xdata_t()
     : index(0), dflags(0),
       account(NULL), ptr(NULL), component_xacts(NULL) {
-    DEBUG("ledger.memory.ctors", "ctor transaction_xdata_t " << this);
+    TRACE_CTOR(transaction_xdata_t, "");
   }
 
   ~transaction_xdata_t() {
-    DEBUG("ledger.memory.dtors", "dtor transaction_xdata_t " << this);
+    TRACE_DTOR(transaction_xdata_t);
     if (component_xacts)
-      delete component_xacts;
+      checked_delete(component_xacts);
   }
 
   void remember_xact(transaction_t& xact) {
@@ -181,13 +194,13 @@ inline void walk_entries(entries_list& list,
 
 class ignore_transactions : public item_handler<transaction_t>
 {
- public:
+public:
   virtual void operator()(transaction_t& xact) {}
 };
 
 class clear_transaction_xdata : public item_handler<transaction_t>
 {
- public:
+public:
   virtual void operator()(transaction_t& xact) {
     if (xact.data) {
       delete (transaction_xdata_t *) xact.data;
@@ -203,11 +216,18 @@ class truncate_entries : public item_handler<transaction_t>
 
   transactions_list xacts;
 
- public:
+  truncate_entries();
+
+public:
   truncate_entries(item_handler<transaction_t> * handler,
 		   int _head_count, int _tail_count)
     : item_handler<transaction_t>(handler),
-      head_count(_head_count), tail_count(_tail_count) {}
+      head_count(_head_count), tail_count(_tail_count) {
+    TRACE_CTOR(truncate_entries, "item_handler<transaction_t> *, int, int");
+  }
+  virtual ~truncate_entries() {
+    TRACE_DTOR(truncate_entries);
+  }
 
   virtual void flush();
   virtual void operator()(transaction_t& xact) {
@@ -217,7 +237,7 @@ class truncate_entries : public item_handler<transaction_t>
 
 class set_account_value : public item_handler<transaction_t>
 {
- public:
+public:
   set_account_value(item_handler<transaction_t> * handler = NULL)
     : item_handler<transaction_t>(handler) {}
 
@@ -226,11 +246,18 @@ class set_account_value : public item_handler<transaction_t>
 
 class push_to_transactions_list : public item_handler<transaction_t>
 {
- public:
+  push_to_transactions_list();
+
+public:
   transactions_list& xact_list;
 
   push_to_transactions_list(transactions_list& _xact_list)
-    : xact_list(_xact_list) {}
+    : xact_list(_xact_list) {
+    TRACE_CTOR(push_to_transactions_list, "transactions_list&");
+  }
+  virtual ~push_to_transactions_list() {
+    TRACE_DTOR(push_to_transactions_list);
+  }
 
   virtual void operator()(transaction_t& xact) {
     xact_list.push_back(&xact);
@@ -244,16 +271,26 @@ class sort_transactions : public item_handler<transaction_t>
   transactions_deque transactions;
   const value_expr   sort_order;
 
- public:
+  sort_transactions();
+
+public:
   sort_transactions(item_handler<transaction_t> * handler,
 		    const value_expr& _sort_order)
     : item_handler<transaction_t>(handler),
-      sort_order(_sort_order) {}
+      sort_order(_sort_order) {
-
+    TRACE_CTOR(sort_transactions,
+	       "item_handler<transaction_t> *, const value_expr&");
+  }
   sort_transactions(item_handler<transaction_t> * handler,
 		    const string& _sort_order)
     : item_handler<transaction_t>(handler),
-      sort_order(_sort_order) {}
+      sort_order(_sort_order) {
+    TRACE_CTOR(sort_transactions,
+	       "item_handler<transaction_t> *, const string&");
+  }
+  virtual ~sort_transactions() {
+    TRACE_DTOR(sort_transactions);
+  }
 
   virtual void post_accumulated_xacts();
 
@@ -270,16 +307,26 @@ class sort_transactions : public item_handler<transaction_t>
 class sort_entries : public item_handler<transaction_t>
 {
   sort_transactions sorter;
-  entry_t * last_entry;
+  entry_t *	    last_entry;
 
- public:
+  sort_entries();
+
+public:
   sort_entries(item_handler<transaction_t> * handler,
 	       const value_expr& _sort_order)
-    : sorter(handler, _sort_order) {}
+    : sorter(handler, _sort_order) {
-
+    TRACE_CTOR(sort_entries,
+	       "item_handler<transaction_t> *, const value_expr&");
+  }
   sort_entries(item_handler<transaction_t> * handler,
 	       const string& _sort_order)
-    : sorter(handler, _sort_order) {}
+    : sorter(handler, _sort_order) {
+    TRACE_CTOR(sort_entries,
+	       "item_handler<transaction_t> *, const string&");
+  }
+  virtual ~sort_entries() {
+    TRACE_DTOR(sort_entries);
+  }
 
   virtual void flush() {
     sorter.flush();
@@ -300,14 +347,25 @@ class filter_transactions : public item_handler<transaction_t>
 {
   item_predicate<transaction_t> pred;
 
- public:
+  filter_transactions();
+
+public:
   filter_transactions(item_handler<transaction_t> * handler,
 		      const value_expr& predicate)
-    : item_handler<transaction_t>(handler), pred(predicate) {}
+    : item_handler<transaction_t>(handler), pred(predicate) {
+    TRACE_CTOR(filter_transactions,
+	       "item_handler<transaction_t> *, const value_expr&");
+  }
 
   filter_transactions(item_handler<transaction_t> * handler,
 		      const string& predicate)
-    : item_handler<transaction_t>(handler), pred(predicate) {}
+    : item_handler<transaction_t>(handler), pred(predicate) {
+    TRACE_CTOR(filter_transactions,
+	       "item_handler<transaction_t> *, const string&");
+  }
+  virtual ~filter_transactions() {
+    TRACE_DTOR(filter_transactions);
+  }
 
   virtual void operator()(transaction_t& xact) {
     if (pred(xact)) {
@@ -321,16 +379,25 @@ class calc_transactions : public item_handler<transaction_t>
 {
   transaction_t * last_xact;
 
- public:
+  calc_transactions();
+
+public:
   calc_transactions(item_handler<transaction_t> * handler)
-    : item_handler<transaction_t>(handler), last_xact(NULL) {}
+    : item_handler<transaction_t>(handler), last_xact(NULL) {
+    TRACE_CTOR(calc_transactions, "item_handler<transaction_t> *");
+  }
+  virtual ~calc_transactions() {
+    TRACE_DTOR(calc_transactions);
+  }
 
   virtual void operator()(transaction_t& xact);
 };
 
 class invert_transactions : public item_handler<transaction_t>
 {
- public:
+  invert_transactions();
+
+public:
   invert_transactions(item_handler<transaction_t> * handler)
     : item_handler<transaction_t>(handler) {}
 
@@ -355,13 +422,17 @@ class collapse_transactions : public item_handler<transaction_t>
   std::list<entry_t>       entry_temps;
   std::list<transaction_t> xact_temps;
 
- public:
+  collapse_transactions();
+
+public:
   collapse_transactions(item_handler<transaction_t> * handler)
     : item_handler<transaction_t>(handler), count(0),
       last_entry(NULL), last_xact(NULL),
-      totals_account(NULL, "<Total>") {}
+      totals_account(NULL, "<Total>") {
-
+    TRACE_CTOR(collapse_transactions, "item_handler<transaction_t> *");
-  ~collapse_transactions() {
+  }
+  virtual ~collapse_transactions() {
+    TRACE_DTOR(collapse_transactions);
     clear_entries_transactions(entry_temps);
   }
 
@@ -380,14 +451,24 @@ class component_transactions : public item_handler<transaction_t>
 {
   item_predicate<transaction_t> pred;
 
- public:
+  component_transactions();
+
+public:
   component_transactions(item_handler<transaction_t> * handler,
 			 const value_expr& predicate)
-    : item_handler<transaction_t>(handler), pred(predicate) {}
+    : item_handler<transaction_t>(handler), pred(predicate) {
-
+    TRACE_CTOR(component_transactions,
+	       "item_handler<transaction_t> *, const value_expr&");
+  }
   component_transactions(item_handler<transaction_t> * handler,
 			 const string& predicate)
-    : item_handler<transaction_t>(handler), pred(predicate) {}
+    : item_handler<transaction_t>(handler), pred(predicate) {
+    TRACE_CTOR(component_transactions,
+	       "item_handler<transaction_t> *, const string&");
+  }
+  virtual ~component_transactions() throw() {
+    TRACE_DTOR(component_transactions);
+  }
 
   virtual void operator()(transaction_t& xact);
 };
@@ -397,11 +478,19 @@ class related_transactions : public item_handler<transaction_t>
   transactions_list transactions;
   bool		    also_matching;
 
- public:
+  related_transactions();
+
+public:
   related_transactions(item_handler<transaction_t> * handler,
 		       const bool _also_matching = false)
     : item_handler<transaction_t>(handler),
-      also_matching(_also_matching) {}
+      also_matching(_also_matching) {
+    TRACE_CTOR(related_transactions,
+	       "item_handler<transaction_t> *, const bool");
+  }
+  virtual ~related_transactions() throw() {
+    TRACE_DTOR(related_transactions);
+  }
 
   virtual void flush();
   virtual void operator()(transaction_t& xact) {
@@ -422,13 +511,18 @@ class changed_value_transactions : public item_handler<transaction_t>
   std::list<entry_t>       entry_temps;
   std::list<transaction_t> xact_temps;
 
- public:
+  changed_value_transactions();
+
+public:
   changed_value_transactions(item_handler<transaction_t> * handler,
 			     bool _changed_values_only)
     : item_handler<transaction_t>(handler),
-      changed_values_only(_changed_values_only), last_xact(NULL) {}
+      changed_values_only(_changed_values_only), last_xact(NULL) {
-
+    TRACE_CTOR(changed_value_transactions,
-  ~changed_value_transactions() {
+	       "item_handler<transaction_t> *, bool");
+  }
+  virtual ~changed_value_transactions() {
+    TRACE_DTOR(changed_value_transactions);
     clear_entries_transactions(entry_temps);
   }
 
@@ -447,42 +541,57 @@ class changed_value_transactions : public item_handler<transaction_t>
 
 class subtotal_transactions : public item_handler<transaction_t>
 {
-  struct acct_value_t {
+  class acct_value_t
+  {
+    acct_value_t();
+
+  public:
     account_t *	account;
     value_t	value;
 
     transactions_list components;
 
-    acct_value_t(account_t * a) : account(a) {}
+    acct_value_t(account_t * a) : account(a) {
-    acct_value_t(account_t * a, value_t& v) : account(a), value(v) {}
+      TRACE_CTOR(acct_value_t, "acount_t *");
+    }
+    acct_value_t(account_t * a, value_t& v) : account(a), value(v) {
+      TRACE_CTOR(acct_value_t, "acount_t *, value_t&");
+    }
     acct_value_t(const acct_value_t& av)
-      : account(av.account), value(av.value) {}
+      : account(av.account), value(av.value),
+	components(av.components) {
+      TRACE_CTOR(acct_value_t, "copy");
+    }
+    ~acct_value_t() throw() {
+      TRACE_DTOR(acct_value_t);
+    }
   };
 
   typedef std::map<string, acct_value_t>  values_map;
   typedef std::pair<string, acct_value_t> values_pair;
 
- protected:
+  subtotal_transactions();
+
+protected:
   values_map values;
   bool       remember_components;
 
   std::list<entry_t>       entry_temps;
   std::list<transaction_t> xact_temps;
 
- public:
+public:
   datetime_t start;
   datetime_t finish;
 
   subtotal_transactions(item_handler<transaction_t> * handler,
 			bool _remember_components = false)
     : item_handler<transaction_t>(handler),
-      remember_components(_remember_components) {}
+      remember_components(_remember_components) {
-#ifdef DEBUG_ENABLED
+    TRACE_CTOR(subtotal_transactions,
-  subtotal_transactions(const subtotal_transactions&) {
+	       "item_handler<transaction_t> *, bool");
-    assert(false);
   }
-#endif
   virtual ~subtotal_transactions() {
+    TRACE_DTOR(subtotal_transactions);
     clear_entries_transactions(entry_temps);
   }
 
@@ -510,18 +619,28 @@ class interval_transactions : public subtotal_transactions
   transaction_t * last_xact;
   bool            started;
 
- public:
+  interval_transactions();
+
+public:
   interval_transactions(item_handler<transaction_t> * _handler,
 			const interval_t& _interval,
 			bool remember_components = false)
     : subtotal_transactions(_handler, remember_components),
-      interval(_interval), last_xact(NULL), started(false) {}
+      interval(_interval), last_xact(NULL), started(false) {
-
+    TRACE_CTOR(interval_transactions,
+	       "item_handler<transaction_t> *, const interval_t&, bool");
+  }
   interval_transactions(item_handler<transaction_t> * _handler,
 			const string& _interval,
 			bool remember_components = false)
     : subtotal_transactions(_handler, remember_components),
-      interval(_interval), last_xact(NULL), started(false) {}
+      interval(_interval), last_xact(NULL), started(false) {
+    TRACE_CTOR(interval_transactions,
+	       "item_handler<transaction_t> *, const string&, bool");
+  }
+  virtual ~interval_transactions() throw() {
+    TRACE_DTOR(interval_transactions);
+  }
 
   void report_subtotal(const datetime_t& moment = datetime_t());
 
@@ -539,13 +658,18 @@ class by_payee_transactions : public item_handler<transaction_t>
   typedef std::pair<string, subtotal_transactions *> payee_subtotals_pair;
 
   payee_subtotals_map payee_subtotals;
-  bool remember_components;
+  bool		      remember_components;
+
+  by_payee_transactions();
 
  public:
   by_payee_transactions(item_handler<transaction_t> * handler,
 			bool _remember_components = false)
     : item_handler<transaction_t>(handler),
-      remember_components(_remember_components) {}
+      remember_components(_remember_components) {
+    TRACE_CTOR(by_payee_transactions,
+	       "item_handler<transaction_t> *, bool");
+  }
   virtual ~by_payee_transactions();
 
   virtual void flush();
@@ -557,11 +681,15 @@ class set_comm_as_payee : public item_handler<transaction_t>
   std::list<entry_t>       entry_temps;
   std::list<transaction_t> xact_temps;
 
- public:
+  set_comm_as_payee();
-  set_comm_as_payee(item_handler<transaction_t> * handler)
-    : item_handler<transaction_t>(handler) {}
 
-  ~set_comm_as_payee() {
+public:
+  set_comm_as_payee(item_handler<transaction_t> * handler)
+    : item_handler<transaction_t>(handler) {
+    TRACE_CTOR(set_comm_as_payee, "item_handler<transaction_t> *");
+  }
+  virtual ~set_comm_as_payee() {
+    TRACE_DTOR(set_comm_as_payee);
     clear_entries_transactions(entry_temps);
   }
 
@@ -573,11 +701,15 @@ class set_code_as_payee : public item_handler<transaction_t>
   std::list<entry_t>       entry_temps;
   std::list<transaction_t> xact_temps;
 
- public:
+  set_code_as_payee();
-  set_code_as_payee(item_handler<transaction_t> * handler)
-    : item_handler<transaction_t>(handler) {}
 
-  ~set_code_as_payee() {
+public:
+  set_code_as_payee(item_handler<transaction_t> * handler)
+    : item_handler<transaction_t>(handler) {
+    TRACE_CTOR(set_code_as_payee, "item_handler<transaction_t> *");
+  }
+  virtual ~set_code_as_payee() {
+    TRACE_DTOR(set_code_as_payee);
     clear_entries_transactions(entry_temps);
   }
 
@@ -588,10 +720,17 @@ class dow_transactions : public subtotal_transactions
 {
   transactions_list days_of_the_week[7];
 
- public:
+  dow_transactions();
+
+public:
   dow_transactions(item_handler<transaction_t> * handler,
 		   bool remember_components = false)
-    : subtotal_transactions(handler, remember_components) {}
+    : subtotal_transactions(handler, remember_components) {
+    TRACE_CTOR(dow_transactions, "item_handler<transaction_t> *, bool");
+  }
+  virtual ~dow_transactions() throw() {
+    TRACE_DTOR(dow_transactions);
+  }
 
   virtual void flush();
   virtual void operator()(transaction_t& xact) {
@@ -601,7 +740,9 @@ class dow_transactions : public subtotal_transactions
 
 class generate_transactions : public item_handler<transaction_t>
 {
- protected:
+  generate_transactions();
+
+protected:
   typedef std::pair<interval_t, transaction_t *> pending_xacts_pair;
   typedef std::list<pending_xacts_pair>          pending_xacts_list;
 
@@ -609,11 +750,14 @@ class generate_transactions : public item_handler<transaction_t>
   std::list<entry_t>	   entry_temps;
   std::list<transaction_t> xact_temps;
 
- public:
+public:
   generate_transactions(item_handler<transaction_t> * handler)
-    : item_handler<transaction_t>(handler) {}
+    : item_handler<transaction_t>(handler) {
+    TRACE_CTOR(dow_transactions, "item_handler<transaction_t> *");
+  }
 
-  ~generate_transactions() {
+  virtual ~generate_transactions() {
+    TRACE_DTOR(generate_transactions);
     clear_entries_transactions(entry_temps);
   }
 
@@ -630,10 +774,18 @@ class budget_transactions : public generate_transactions
 {
   unsigned short flags;
 
- public:
+  budget_transactions();
+
+public:
   budget_transactions(item_handler<transaction_t> * handler,
 		      unsigned long _flags = BUDGET_BUDGETED)
-    : generate_transactions(handler), flags(_flags) {}
+    : generate_transactions(handler), flags(_flags) {
+    TRACE_CTOR(budget_transactions,
+	       "item_handler<transaction_t> *, unsigned long");
+  }
+  virtual ~budget_transactions() throw() {
+    TRACE_DTOR(budget_transactions);
+  }
 
   void report_budget_items(const datetime_t& moment);
 
@@ -647,11 +799,19 @@ class forecast_transactions : public generate_transactions
  public:
   forecast_transactions(item_handler<transaction_t> * handler,
 			const value_expr& predicate)
-    : generate_transactions(handler), pred(predicate) {}
+    : generate_transactions(handler), pred(predicate) {
-
+    TRACE_CTOR(forecast_transactions,
+	       "item_handler<transaction_t> *, const value_expr&");
+  }
   forecast_transactions(item_handler<transaction_t> * handler,
 			const string& predicate)
-    : generate_transactions(handler), pred(predicate) {}
+    : generate_transactions(handler), pred(predicate) {
+    TRACE_CTOR(forecast_transactions,
+	       "item_handler<transaction_t> *, const string&");
+  }
+  virtual ~forecast_transactions() throw() {
+    TRACE_DTOR(forecast_transactions);
+  }
 
   virtual void add_transaction(const interval_t& period,
 			       transaction_t&	 xact);
@@ -670,7 +830,7 @@ class forecast_transactions : public generate_transactions
 #define ACCOUNT_HAS_NON_VIRTUALS 0x0008
 #define ACCOUNT_HAS_UNB_VIRTUALS 0x0010
 
-struct account_xdata_t
+struct account_xdata_t : public noncopyable
 {
   value_t	 value;
   value_t	 total;
@@ -680,7 +840,12 @@ struct account_xdata_t
   unsigned int   virtuals;
   unsigned short dflags;
 
-  account_xdata_t() : count(0), total_count(0), virtuals(0), dflags(0) {}
+  account_xdata_t() : count(0), total_count(0), virtuals(0), dflags(0) {
+    TRACE_CTOR(account_xdata_t, "");
+  }
+  ~account_xdata_t() throw() {
+    TRACE_DTOR(account_xdata_t);
+  }
 };
 
 inline bool account_has_xdata(const account_t& account) {
@@ -697,7 +862,7 @@ account_xdata_t& account_xdata(const account_t& account);
 
 class clear_account_xdata : public item_handler<account_t>
 {
- public:
+public:
   virtual void operator()(account_t& acct) {
     if (acct.data) {
       delete (account_xdata_t *) acct.data;

xml.h

@@ -25,13 +25,20 @@ class xml_parser_t : public parser_t
 class format_xml_entries : public format_entries
 {
   bool show_totals;
- public:
+
+  format_xml_entries();
+
+public:
   format_xml_entries(std::ostream& output_stream,
 		     const bool _show_totals = false)
     : format_entries(output_stream, ""), show_totals(_show_totals) {
+    TRACE_CTOR(format_xml_entries, "std::ostream&, const bool");
     output_stream << "<?xml version=\"1.0\"?>\n"
 		  << "<ledger version=\"2.5\">\n";
   }
+  virtual ~format_xml_entries() throw() {
+    TRACE_DTOR(format_xml_entries);
+  }
 
   virtual void flush() {
     format_entries::flush();