expr.patch

diff --git a/src/expr.cc b/src/expr.cc
index 8c8e995..b22572f 100644
--- a/src/expr.cc
+++ b/src/expr.cc
@@ -37,6 +37,59 @@
 
 namespace ledger {
 
+expr_t::expr_t() : base_type()
+{
+  TRACE_CTOR(expr_t, "");
+}
+
+expr_t::expr_t(const expr_t& other) : base_type(other), ptr(other.ptr)
+{
+  TRACE_CTOR(expr_t, "copy");
+}
+expr_t::expr_t(ptr_op_t _ptr, scope_t * _context)
+  : base_type(_context), ptr(_ptr)
+{
+  TRACE_CTOR(expr_t, "const ptr_op_t&, scope_t *");
+}
+
+expr_t::expr_t(const string& _str, const parse_flags_t& flags)
+  : base_type()
+{
+  TRACE_CTOR(expr_t, "string, parse_flags_t");
+  if (! _str.empty())
+    parse(_str, flags);
+}
+
+expr_t::expr_t(std::istream& in, const parse_flags_t& flags)
+  : base_type()
+{
+  TRACE_CTOR(expr_t, "std::istream&, parse_flags_t");
+  parse(in, flags);
+}
+
+expr_t::~expr_t() {
+  TRACE_DTOR(expr_t);
+}
+
+expr_t& expr_t::operator=(const expr_t& _expr)
+{
+  if (this != &_expr) {
+    base_type::operator=(_expr);
+    ptr = _expr.ptr;
+  }
+  return *this;
+}
+
+expr_t::operator bool() const throw()
+{
+  return ptr.get() != NULL;
+}
+
+expr_t::ptr_op_t expr_t::get_op() throw()
+{
+  return ptr;
+}
+
 void expr_t::parse(std::istream& in, const parse_flags_t& flags,
                    const optional<string>& original_string)
 {
@@ -204,6 +257,24 @@ void merged_expr_t::compile(scope_t& scope)
   expr_t::compile(scope);
 }
 
+expr_t::ptr_op_t as_expr(const value_t& val)
+{
+  VERIFY(val.is_any());
+  return val.as_any<expr_t::ptr_op_t>();
+}
+
+void set_expr(value_t& val, expr_t::ptr_op_t op)
+{
+  val.set_any(op);
+}
+
+value_t expr_value(expr_t::ptr_op_t op)
+{
+  value_t temp;
+  temp.set_any(op);
+  return temp;
+}
+
 value_t source_command(call_scope_t& args)
 {
   std::istream * in = NULL;
diff --git a/src/expr.h b/src/expr.h
index cad2e90..2b3fb00 100644
--- a/src/expr.h
+++ b/src/expr.h
@@ -74,49 +74,20 @@ protected:
   ptr_op_t ptr;
 
 public:
-  expr_t() : base_type() {
-    TRACE_CTOR(expr_t, "");
-  }
-  expr_t(const expr_t& other)
-    : base_type(other), ptr(other.ptr) {
-    TRACE_CTOR(expr_t, "copy");
-  }
-  expr_t(ptr_op_t _ptr, scope_t * _context = NULL)
-    : base_type(_context), ptr(_ptr) {
-    TRACE_CTOR(expr_t, "const ptr_op_t&, scope_t *");
-  }
+  expr_t();
+  expr_t(const expr_t& other);
+  expr_t(ptr_op_t _ptr, scope_t * _context = NULL);
 
-  expr_t(const string& _str, const parse_flags_t& flags = PARSE_DEFAULT)
-    : base_type() {
-    TRACE_CTOR(expr_t, "string, parse_flags_t");
-    if (! _str.empty())
-      parse(_str, flags);
-  }
-  expr_t(std::istream& in, const parse_flags_t& flags = PARSE_DEFAULT)
-    : base_type() {
-    TRACE_CTOR(expr_t, "std::istream&, parse_flags_t");
-    parse(in, flags);
-  }
+  expr_t(const string& _str, const parse_flags_t& flags = PARSE_DEFAULT);
+  expr_t(std::istream& in, const parse_flags_t& flags = PARSE_DEFAULT);
 
-  virtual ~expr_t() {
-    TRACE_DTOR(expr_t);
-  }
+  virtual ~expr_t();
 
-  expr_t& operator=(const expr_t& _expr) {
-    if (this != &_expr) {
-      base_type::operator=(_expr);
-      ptr = _expr.ptr;
-    }
-    return *this;
-  }
+  expr_t& operator=(const expr_t& _expr);
 
-  virtual operator bool() const throw() {
-    return ptr.get() != NULL;
-  }
+  virtual operator bool() const throw();
 
-  ptr_op_t get_op() throw() {
-    return ptr;
-  }
+  ptr_op_t get_op() throw();
 
   void parse(const string& str, const parse_flags_t& flags = PARSE_DEFAULT) {
     std::istringstream stream(str);
@@ -159,18 +130,10 @@ private:
 inline bool is_expr(const value_t& val) {
   return val.is_any() && val.as_any().type() == typeid(expr_t::ptr_op_t);
 }
-inline expr_t::ptr_op_t as_expr(const value_t& val) {
-  VERIFY(val.is_any());
-  return val.as_any<expr_t::ptr_op_t>();
-}
-inline void set_expr(value_t& val, expr_t::ptr_op_t op) {
-  val.set_any(op);
-}
-inline value_t expr_value(expr_t::ptr_op_t op) {
-  value_t temp;
-  temp.set_any(op);
-  return temp;
-}
+
+expr_t::ptr_op_t as_expr(const value_t& val);
+void             set_expr(value_t& val, expr_t::ptr_op_t op);
+value_t          expr_value(expr_t::ptr_op_t op);
 
 // A merged expression allows one to set an expression term, "foo", and
 // a base expression, "bar", and then merge in later expressions that