interned_string: drop magic c_str() implementation

It turns out that while it was right for boost::string_ref not to
provide it, we can, because our interned_string's backing stores
are full (read-only) std::strings, which always carry a \0.  This
shrinks down our interned_string to 2*sizeof(void*) bytes.

Author: fche

INTERNALS

@@ -144,6 +144,6 @@ Peculiarities
 
   OTOH, it costs CPU (for management of the interned string set, or if
   copied between std::string and interned_string unnecessarily), and
-  RAM (3 pointers when empty, vs. 1 for std::string), and its
+  RAM (2 pointers when empty, vs. 1 for std::string), and its
   instances are not modifiable, so tradeoffs must be confirmed with
   tools like memusage, massif, perf-stat, etc.

stringtable.cxx

@@ -103,11 +103,11 @@ interned_string interned_string::intern(const string& value)
 }
 
 
-interned_string::interned_string(const char* value): string_ref(intern(value)), _c_str(0)
+interned_string::interned_string(const char* value): string_ref(intern(value))
 {
 }
 
-interned_string::interned_string(const string& value): string_ref(intern(value)), _c_str(0)
+interned_string::interned_string(const string& value): string_ref(intern(value))
 {
 }
 
@@ -155,17 +155,5 @@ size_t interned_string::find (const char *f) const
 }
 #endif
 
-// The result of c_str() is basically strdup()'d, in anticipation
-// that interning may result in string_refs that are not followed by \0,
-// so we can't just pass back ->data().  The strdup()'d memory is
-// saved in a member variable and freed in the destructor.
-const char* interned_string::c_str() const
-{
-  free (_c_str);
-  _c_str = (char*) malloc(this->length()+1);
-  strncpy(_c_str, this->data(), this->length());
-  _c_str[this->length()]='\0';
-  return _c_str;
-}
 
 /* vim: set sw=2 ts=8 cino=>4,n-2,{2,^-2,t0,(0,u0,w1,M1 : */

stringtable.h

@@ -21,25 +21,20 @@
 struct interned_string: public boost::string_ref
 {
   // all these construction operations intern the incoming string
-  interned_string(): boost::string_ref(), _c_str(0) {}
+  interned_string(): boost::string_ref() {}
   interned_string(const char* value);
   interned_string(const std::string& value);
-  interned_string(const boost::string_ref& value): boost::string_ref(value), _c_str(0) {}
-  interned_string(const interned_string& value): boost::string_ref(value), _c_str(0) {}
-  interned_string& operator = (const interned_string& value) {
-    if (&value==this) return *this;
-    boost::string_ref::operator = (value);
-    // NB: don't propagate _c_str!
-    return *this;
-  }
+  interned_string(const boost::string_ref& value): boost::string_ref(value) {}
+  interned_string(const interned_string& value): boost::string_ref(value) {}
   interned_string& operator = (const std::string& value);
   interned_string& operator = (const char* value);
 
-  ~interned_string() { if (_c_str) free (_c_str); }
-  
   // easy out-conversion operators
   operator std::string () const { return this->to_string(); }
-  const char* c_str() const;
+
+  // NB: this is OK because we always use a std::string as a backing
+  // store, and as of c++0x, those always store a \0 in their data().
+  const char* c_str() const { return this->size() ? (const char*)this->data() : ""; }
 
   // boost oversights
   template <typename F>
@@ -65,7 +60,6 @@ struct interned_string: public boost::string_ref
 #endif
 
 private:
-  mutable char *_c_str; // last value copied out
   interned_string intern(const std::string& value);
 };