3 files changed, 196 insertions, 0 deletions
diff --git a/external_libs/cpp/yaml-cpp/util/CMakeLists.txt b/external_libs/cpp/yaml-cpp/util/CMakeLists.txt
new file mode 100755
index 00000000..22339f02
--- /dev/null
+++ b/external_libs/cpp/yaml-cpp/util/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_executable(parse parse.cpp)
+target_link_libraries(parse yaml-cpp)
diff --git a/external_libs/cpp/yaml-cpp/util/api.cpp b/external_libs/cpp/yaml-cpp/util/api.cpp
new file mode 100755
index 00000000..e5180a8a
--- /dev/null
+++ b/external_libs/cpp/yaml-cpp/util/api.cpp
@@ -0,0 +1,129 @@
+// a sketch of what the new API might look like
+
+#include "yaml-cpp/yaml.h"
+#include <iostream>
+
+int main()
+{
+	{
+		// test.yaml
+		// - foo
+		// - primes: [2, 3, 5, 7, 11]
+		//   odds: [1, 3, 5, 7, 9, 11]
+		// - [x, y]
+		
+		// move-like semantics
+		YAML::Value root = YAML::Parse("test.yaml");
+		
+		std::cout << root[0].as<std::string>(); // "foo"
+		std::cout << str(root[0]); // "foo", shorthand?
+		std::cout << root[1]["primes"][3].as<int>(); // "7"
+		std::cout << root[1]["odds"][6].as<int>(); // throws?
+		
+		root[2].push_back(5);
+		root[3] = "Hello, World";
+		root[0].reset();
+		root[0]["key"] = "value";
+		
+		std::cout << root;
+		// # not sure about formatting
+		// - {key: value}
+		// - primes: [2, 3, 5, 7, 11]
+		//   odds: [1, 3, 5, 7, 9, 11]
+		// - [x, y, 5]
+		// - Hello, World
+	}
+
+	{
+		// for all copy-like commands, think of python's "name/value" semantics
+		YAML::Value root = "Hello";  // Hello
+		root = YAML::Sequence();     // []
+		root[0] = 0;                 // [0]
+		root[2] = "two";             // [0, ~, two]  # forces root[1] to be initialized to null
+
+		YAML::Value other = root;    // both point to the same thing
+		other[0] = 5;                // now root[0] is 0 also
+		other.push_back(root);       // &1 [5, ~, two, *1]
+		other[3][0] = 0;             // &1 [0, ~, two, *1]   # since it's a true alias
+		other.push_back(Copy(root)); // &1 [0, ~, two, *1, &2 [0, ~, two, *2]]
+		other[4][0] = 5;             // &1 [0, ~, two, *1, &2 [5, ~, two, *2]]  # they're really different
+	}
+	
+	{
+		YAML::Value node;            // ~
+		node[0] = 1;                 // [1]  # auto-construct a sequence
+		node["key"] = 5;             // {0: 1, key: 5}  # auto-turn it into a map
+		node.push_back(10);          // error, can't turn a map into a sequence
+		node.erase("key");           // {0: 1}  # still a map, even if we remove the key that caused the problem
+		node = "Hello";              // Hello  # assignment overwrites everything, so it's now just a plain scalar
+	}
+	
+	{
+		YAML::Value map;             // ~
+		map[3] = 1;                  // {3: 1}  # auto-constructs a map, *not* a sequence
+		
+		YAML::Value seq;             // ~ 
+		seq = YAML::Sequence();      // []
+		seq[3] = 1;                  // [~, ~, ~, 1]
+	}
+	
+	{
+		YAML::Value node;            // ~
+		node[0] = node;              // &1 [*1]  # fun stuff
+	}
+	
+	{
+		YAML::Value node;
+		YAML::Value subnode = node["key"]; // 'subnode' is not instantiated ('node' is still null)
+		subnode = "value";           // {key: value}  # now it is
+		YAML::Value subnode2 = node["key2"];
+		node["key3"] = subnode2;     // subnode2 is still not instantiated, but node["key3"] is "pseudo" aliased to it
+		subnode2 = "monkey";         // {key: value, key2: &1 monkey, key3: *1}  # bam! it instantiates both
+	}
+	
+	{
+		YAML::Value seq = YAML::Sequence();
+		seq[0] = "zero";             // [zero]
+		seq[1] = seq[0];             // [&1 zero, *1]
+		seq[0] = seq[1];             // [&1 zero, *1]  # no-op (they both alias the same thing, so setting them equal is nothing)
+		Is(seq[0], seq[1]);          // true
+		seq[1] = "one";              // [&1 one, *1]
+		UnAlias(seq[1]);             // [one, one]
+		Is(seq[0], seq[1]);          // false
+	}
+	
+	{
+		YAML::Value root;
+		root.push_back("zero");
+		root.push_back("one");
+		root.push_back("two");
+		YAML::Value two = root[2];
+		root = "scalar";             // 'two' is still "two", even though 'root' is "scalar" (the sequence effectively no longer exists)
+		
+		// Note: in all likelihood, the memory for nodes "zero" and "one" is still allocated. How can it go away? Weak pointers?
+	}
+	
+	{
+		YAML::Value root;            // ~
+		root[0] = root;              // &1 [*1]
+		root[0] = 5;                 // [5]
+	}
+	
+	{
+		YAML::Value root;
+		YAML::Value key;
+		key["key"] = "value";
+		root[key] = key;             // &1 {key: value}: *1
+	}
+	
+	{
+		YAML::Value root;
+		root[0] = "hi";
+		root[1][0] = "bye";
+		root[1][1] = root;           // &1 [hi, [bye, *1]]  # root
+		YAML::Value sub = root[1];   // &1 [bye, [hi, *1]]  # sub
+		root = "gone";               // [bye, gone]  # sub
+	}
+
+	return 0;
+}
diff --git a/external_libs/cpp/yaml-cpp/util/parse.cpp b/external_libs/cpp/yaml-cpp/util/parse.cpp
new file mode 100755
index 00000000..d02a76a7
--- /dev/null
+++ b/external_libs/cpp/yaml-cpp/util/parse.cpp
@@ -0,0 +1,65 @@
+#include "yaml-cpp/yaml.h"
+#include "yaml-cpp/eventhandler.h"
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+struct Params {
+	bool hasFile;
+	std::string fileName;
+};
+
+Params ParseArgs(int argc, char **argv) {
+	Params p;
+
+	std::vector<std::string> args(argv + 1, argv + argc);
+	
+	return p;
+}
+
+class NullEventHandler: public YAML::EventHandler
+{
+public:
+	virtual void OnDocumentStart(const YAML::Mark&) {}
+	virtual void OnDocumentEnd() {}
+	
+	virtual void OnNull(const YAML::Mark&, YAML::anchor_t) {}
+	virtual void OnAlias(const YAML::Mark&, YAML::anchor_t) {}
+	virtual void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t, const std::string&) {}
+	
+	virtual void OnSequenceStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
+	virtual void OnSequenceEnd() {}
+	
+	virtual void OnMapStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
+	virtual void OnMapEnd() {}
+};
+
+void parse(std::istream& input)
+{
+	try {
+		YAML::Parser parser(input);
+		YAML::Node doc;
+		while(parser.GetNextDocument(doc)) {
+			YAML::Emitter emitter;
+			emitter << doc;
+			std::cout << emitter.c_str() << "\n";
+		}
+	} catch(const YAML::Exception& e) {
+		std::cerr << e.what() << "\n";
+	}
+}
+
+int main(int argc, char **argv)
+{
+	Params p = ParseArgs(argc, argv);
+
+	if(argc > 1) {
+		std::ifstream fin;
+		fin.open(argv[1]);
+		parse(fin);
+	} else {
+		parse(std::cin);
+	}
+
+	return 0;
+}