More useful error messages.

Applied the patch given in jbeder/yaml-cpp#200 with the correct code
style.

include/yaml-cpp/exceptions.h

@@ -120,6 +120,10 @@ class Exception : public std::runtime_error {
  private:
   static const std::string build_what(const Mark& mark,
                                       const std::string& msg) {
+    if (mark.is_null()) {
+      return msg.c_str();
+    }
+
     std::stringstream output;
     output << "yaml-cpp: error at line " << mark.line + 1 << ", column "
            << mark.column + 1 << ": " << msg;
@@ -178,14 +182,14 @@ class InvalidNode : public RepresentationException {
 
 class BadConversion : public RepresentationException {
  public:
-  BadConversion()
-      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_CONVERSION) {}
+  explicit BadConversion(const Mark& mark_)
+      : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {}
 };
 
 template <typename T>
 class TypedBadConversion : public BadConversion {
  public:
-  TypedBadConversion() : BadConversion() {}
+  explicit TypedBadConversion(const Mark& mark_) : BadConversion(mark_) {}
 };
 
 class BadDereference : public RepresentationException {

include/yaml-cpp/mark.h

@@ -15,6 +15,8 @@ struct YAML_CPP_API Mark {
 
   static const Mark null_mark() { return Mark(-1, -1, -1); }
 
+  bool is_null() const { return pos == -1 && line == -1 && column == -1; }
+
   int pos;
   int line, column;
 

include/yaml-cpp/node/detail/node.h

@@ -25,6 +25,7 @@ class node : private boost::noncopyable {
   const node_ref* ref() const { return m_pRef.get(); }
 
   bool is_defined() const { return m_pRef->is_defined(); }
+  const Mark& mark() const { return m_pRef->mark(); }
   NodeType::value type() const { return m_pRef->type(); }
 
   const std::string& scalar() const { return m_pRef->scalar(); }
@@ -64,6 +65,10 @@ class node : private boost::noncopyable {
     m_pRef->set_data(*rhs.m_pRef);
   }
 
+  void set_mark(const Mark& mark) {
+    m_pRef->set_mark(mark);
+  }
+
   void set_type(NodeType::value type) {
     if (type != NodeType::Undefined)
       mark_defined();

include/yaml-cpp/node/detail/node_data.h

@@ -34,6 +34,7 @@ class YAML_CPP_API node_data : private boost::noncopyable {
   node_data();
 
   void mark_defined();
+  void set_mark(const Mark& mark);
   void set_type(NodeType::value type);
   void set_tag(const std::string& tag);
   void set_null();
@@ -41,6 +42,7 @@ class YAML_CPP_API node_data : private boost::noncopyable {
   void set_style(EmitterStyle::value style);
 
   bool is_defined() const { return m_isDefined; }
+  const Mark& mark() const { return m_mark; }
   NodeType::value type() const {
     return m_isDefined ? m_type : NodeType::Undefined;
   }
@@ -97,6 +99,7 @@ class YAML_CPP_API node_data : private boost::noncopyable {
 
  private:
   bool m_isDefined;
+  Mark m_mark;
   NodeType::value m_type;
   std::string m_tag;
   EmitterStyle::value m_style;

include/yaml-cpp/node/detail/node_ref.h

@@ -20,6 +20,7 @@ class node_ref : private boost::noncopyable {
   node_ref() : m_pData(new node_data) {}
 
   bool is_defined() const { return m_pData->is_defined(); }
+  const Mark& mark() const { return m_pData->mark(); }
   NodeType::value type() const { return m_pData->type(); }
   const std::string& scalar() const { return m_pData->scalar(); }
   const std::string& tag() const { return m_pData->tag(); }
@@ -28,6 +29,7 @@ class node_ref : private boost::noncopyable {
   void mark_defined() { m_pData->mark_defined(); }
   void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; }
 
+  void set_mark(const Mark& mark) { m_pData->set_mark(mark); }
   void set_type(NodeType::value type) { m_pData->set_type(type); }
   void set_tag(const std::string& tag) { m_pData->set_tag(tag); }
   void set_null() { m_pData->set_null(); }

include/yaml-cpp/node/impl.h

@@ -66,6 +66,13 @@ inline bool Node::IsDefined() const {
   return m_pNode ? m_pNode->is_defined() : true;
 }
 
+inline Mark Node::Mark() const {
+  if (!m_isValid) {
+    throw InvalidNode();
+  }
+  return m_pNode ? m_pNode->mark() : Mark::null_mark();
+}
+
 inline NodeType::value Node::Type() const {
   if (!m_isValid)
     throw InvalidNode();
@@ -110,12 +117,12 @@ struct as_if<T, void> {
 
   const T operator()() const {
     if (!node.m_pNode)
-      throw TypedBadConversion<T>();
+      throw TypedBadConversion<T>(node.Mark());
 
     T t;
     if (convert<T>::decode(node, t))
       return t;
-    throw TypedBadConversion<T>();
+    throw TypedBadConversion<T>(node.Mark());
   }
 };
 
@@ -126,7 +133,7 @@ struct as_if<std::string, void> {
 
   const std::string operator()() const {
     if (node.Type() != NodeType::Scalar)
-      throw TypedBadConversion<std::string>();
+      throw TypedBadConversion<std::string>(node.Mark());
     return node.Scalar();
   }
 };

include/yaml-cpp/node/node.h

@@ -11,6 +11,7 @@
 
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/mark.h"
 #include "yaml-cpp/node/detail/bool_type.h"
 #include "yaml-cpp/node/detail/iterator_fwd.h"
 #include "yaml-cpp/node/ptr.h"
@@ -48,6 +49,7 @@ class YAML_CPP_API Node {
   Node(const Node& rhs);
   ~Node();
 
+  YAML::Mark Mark() const;
   NodeType::value Type() const;
   bool IsDefined() const;
   bool IsNull() const { return Type() == NodeType::Null; }