diff options
97 files changed, 10794 insertions, 224 deletions
diff --git a/SConstruct b/SConstruct index 6f5cda6f019..b6168a75de9 100644 --- a/SConstruct +++ b/SConstruct @@ -293,6 +293,8 @@ add_option( "use-system-v8", "use system version of v8 library", 0, True ) add_option( "use-system-stemmer", "use system version of stemmer", 0, True ) +add_option( "use-system-yaml", "use system version of yaml", 0, True ) + add_option( "use-system-all" , "use all system libraries", 0 , True ) add_option( "use-cpu-profiler", @@ -1367,6 +1369,9 @@ def doConfigure(myenv): if use_system_version_of_library("stemmer"): conf.FindSysLibDep("stemmer", ["stemmer"]) + if use_system_version_of_library("yaml"): + conf.FindSysLibDep("yaml", ["yaml"]) + if use_system_version_of_library("boost"): if not conf.CheckCXXHeader( "boost/filesystem/operations.hpp" ): print( "can't find boost headers" ) diff --git a/distsrc/THIRD-PARTY-NOTICES b/distsrc/THIRD-PARTY-NOTICES index 481e64c4b11..5735bf00240 100644 --- a/distsrc/THIRD-PARTY-NOTICES +++ b/distsrc/THIRD-PARTY-NOTICES @@ -369,6 +369,25 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +11) License notice for yaml-cpp +Copyright (c) 2008 Jesse Beder. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. End diff --git a/src/mongo/util/options_parser/SConscript b/src/mongo/util/options_parser/SConscript index 0ca160f82a1..029e1aced4f 100644 --- a/src/mongo/util/options_parser/SConscript +++ b/src/mongo/util/options_parser/SConscript @@ -11,7 +11,9 @@ env.StaticLibrary('options_parser', ['environment.cpp', 'startup_option_init.cpp', 'startup_options.cpp', ], - LIBDEPS=['$BUILD_DIR/mongo/bson']) + LIBDEPS=['$BUILD_DIR/mongo/bson', + '$BUILD_DIR/third_party/shim_yaml' + ]) env.CppUnitTest('options_parser_test', 'options_parser_test.cpp', diff --git a/src/mongo/util/options_parser/options_parser.cpp b/src/mongo/util/options_parser/options_parser.cpp index 93bae6b2636..3aa81c24dea 100644 --- a/src/mongo/util/options_parser/options_parser.cpp +++ b/src/mongo/util/options_parser/options_parser.cpp @@ -21,6 +21,7 @@ #include <fstream> #include <stdio.h> +#include "mongo/base/parse_number.h" #include "mongo/base/status.h" #include "mongo/db/jsobj.h" #include "mongo/db/json.h" @@ -29,6 +30,7 @@ #include "mongo/util/options_parser/option_description.h" #include "mongo/util/options_parser/option_section.h" #include "mongo/util/scopeguard.h" +#include "third_party/yaml-cpp-0.5.1/include/yaml-cpp/yaml.h" namespace mongo { namespace optionenvironment { @@ -47,11 +49,11 @@ namespace optionenvironment { // mongo JSON parser for JSON config files. Our destination storage in both cases is an // Environment which stores Value objects. // - // 1. JSON Config Files - // The mongo JSON parser parses a JSON string into a BSON object. Therefore, we need: - // a. A function to convert a BSONElement to a Value (BSONElementToValue) - // b. A function to iterate a BSONObj, convert the BSONElements to Values, and add - // them to our Environment (addBSONElementsToEnvironment) + // 1. YAML Config Files + // The YAML parser parses a YAML config file into a YAML::Node. Therefore, we need: + // a. A function to convert a YAML::Node to a Value (YAMLNodeToValue) + // b. A function to iterate a YAML::Node, convert the leaf Nodes to Values, and add + // them to our Environment (addYAMLNodesToEnvironment) // // 2. INI Config Files and command line // The boost::program_options parsers store their output in a @@ -103,6 +105,123 @@ namespace optionenvironment { return Status::OK(); } + // Convert a YAML::Node to a Value. See comments at the beginning of this section. + Status YAMLNodeToValue(const YAML::Node& YAMLNode, + const std::vector<OptionDescription>& options_vector, + const Key& key, Value* value) { + + bool isRegistered = false; + + // The logic below should ensure that we don't use this uninitialized, but we need to + // initialize it here to avoid a compiler warning. Initializing it to a "Bool" since + // that's the most restricted type we have and is most likely to result in an early + // failure if we have a logic error. + OptionType type = Bool; + + // Get expected type + for (std::vector<OptionDescription>::const_iterator iterator = options_vector.begin(); + iterator != options_vector.end(); iterator++) { + if (key == iterator->_dottedName && (iterator->_sources & SourceJSONConfig)) { + isRegistered = true; + type = iterator->_type; + } + } + + if (!isRegistered) { + StringBuilder sb; + sb << "Unrecognized option: " << key; + return Status(ErrorCodes::BadValue, sb.str()); + } + + // Handle multi keys + if (type == StringVector) { + if (!YAMLNode.IsSequence()) { + StringBuilder sb; + sb << "Option: " << key + << " is of type StringVector, but value in YAML config is not a list type"; + return Status(ErrorCodes::BadValue, sb.str()); + } + std::vector<std::string> stringVector; + for (YAML::const_iterator it = YAMLNode.begin(); it != YAMLNode.end(); ++it) { + if (it->IsSequence()) { + StringBuilder sb; + sb << "Option: " << key + << " has nested lists, which is not allowed"; + return Status(ErrorCodes::BadValue, sb.str()); + } + stringVector.push_back(it->Scalar()); + } + *value = Value(stringVector); + return Status::OK(); + } + + Status ret = Status::OK(); + std::string stringVal = YAMLNode.Scalar(); + switch (type) { + double doubleVal; + int intVal; + long longVal; + unsigned long long unsignedLongLongVal; + unsigned unsignedVal; + case Switch: + case Bool: + if (stringVal == "true") { + *value = Value(true); + return Status::OK(); + } + else if (stringVal == "true") { + *value = Value(false); + return Status::OK(); + } + else { + StringBuilder sb; + sb << "Expected boolean but found string: " << stringVal + << " for option: " << key; + return Status(ErrorCodes::BadValue, sb.str()); + } + case Double: + ret = parseNumberFromString(stringVal, &doubleVal); + if (!ret.isOK()) { + return ret; + } + *value = Value(doubleVal); + return Status::OK(); + case Int: + ret = parseNumberFromString(stringVal, &intVal); + if (!ret.isOK()) { + return ret; + } + *value = Value(intVal); + return Status::OK(); + case Long: + ret = parseNumberFromString(stringVal, &longVal); + if (!ret.isOK()) { + return ret; + } + *value = Value(longVal); + return Status::OK(); + case String: + *value = Value(stringVal); + return Status::OK(); + case UnsignedLongLong: + ret = parseNumberFromString(stringVal, &unsignedLongLongVal); + if (!ret.isOK()) { + return ret; + } + *value = Value(unsignedLongLongVal); + return Status::OK(); + case Unsigned: + ret = parseNumberFromString(stringVal, &unsignedVal); + if (!ret.isOK()) { + return ret; + } + *value = Value(unsignedVal); + return Status::OK(); + default: /* XXX: should not get here */ + return Status(ErrorCodes::InternalError, "Unrecognized option type"); + } + } + // Add all the values in the given variables_map to our environment. See comments at the // beginning of this section. Status addBoostVariablesToEnvironment(const po::variables_map& vm, @@ -232,6 +351,82 @@ namespace optionenvironment { } } + // Add all the values in the given YAML Node to our environment. See comments at the + // beginning of this section. + Status addYAMLNodesToEnvironment(const YAML::Node& root, + const OptionSection& options, + const std::string parentPath, + Environment* environment) { + + std::vector<OptionDescription> options_vector; + Status ret = options.getAllOptions(&options_vector); + if (!ret.isOK()) { + return ret; + } + + // Don't return an error on empty config files + if (root.IsNull()) { + return Status::OK(); + } + + if (!root.IsMap() && parentPath.empty()) { + StringBuilder sb; + sb << "No map found at top level of YAML config"; + return Status(ErrorCodes::BadValue, sb.str()); + } + + for (YAML::const_iterator it = root.begin(); it != root.end(); ++it) { + std::string fieldName = it->first.Scalar(); + YAML::Node YAMLNode = it->second; + + std::string dottedName; + if (parentPath.empty()) { + + // We are at the top level, so the full specifier is just the current field name + dottedName = fieldName; + } + else { + + // If our field name is "value", assume this contains the value for the parent + if (fieldName == "value") { + dottedName = parentPath; + } + + // If this is not a special field name, and we are in a sub object, append our + // current fieldName to the selector for the sub object we are traversing + else { + dottedName = parentPath + '.' + fieldName; + } + } + + if (YAMLNode.IsMap()) { + addYAMLNodesToEnvironment(YAMLNode, options, dottedName, environment); + } + else { + Value optionValue; + Status ret = YAMLNodeToValue(YAMLNode, options_vector, dottedName, + &optionValue); + if (!ret.isOK()) { + return ret; + } + + Value dummyVal; + if (environment->get(dottedName, &dummyVal).isOK()) { + StringBuilder sb; + sb << "Error parsing YAML config: duplcate key: " << dottedName; + return Status(ErrorCodes::BadValue, sb.str()); + } + + ret = environment->set(dottedName, optionValue); + if (!ret.isOK()) { + return ret; + } + } + } + + return Status::OK(); + } + // Add all the values in the given BSONObj to our environment. See comments at the // beginning of this section. Status addBSONElementsToEnvironment(const BSONObj& obj, @@ -560,6 +755,51 @@ namespace optionenvironment { return Status::OK(); } +namespace { + + /** + * This function delegates the YAML config parsing to the third party YAML parser. It does no + * error checking other than the parse error checking done by the YAML parser. + */ + Status parseYAMLConfigFile(const std::string& config, + YAML::Node* YAMLConfig) { + + try { + *YAMLConfig = YAML::Load(config); + } catch (const YAML::Exception &e) { + StringBuilder sb; + sb << "Error parsing YAML config file: " << e.what(); + return Status(ErrorCodes::BadValue, sb.str()); + } catch (const std::runtime_error &e) { + StringBuilder sb; + sb << "Unexpected exception parsing YAML config file: " << e.what(); + return Status(ErrorCodes::BadValue, sb.str()); + } + + return Status::OK(); + } + + bool isYAMLConfig(const YAML::Node& config) { + // The YAML parser is very forgiving, and for the INI config files we've parsed so far using + // the YAML parser, the YAML parser just slurps the entire config file into a single string + // rather than erroring out. Thus, we assume that having a scalar (string) as the root node + // means that this is not meant to be a YAML config file, since even a very simple YAML + // config file should be parsed as a Map, and thus "config.IsScalar()" would return false. + // + // This requires more testing, both to ensure that all INI style files get parsed as a + // single string, and to ensure that the user experience does not suffer (in terms of this + // causing confusing error messages for users writing a brand new YAML config file that + // incorrectly triggers this check). + if (config.IsScalar()) { + return false; + } + else { + return true; + } + } + +} // namespace + /** * This function delegates the JSON config parsing to the MongoDB JSON parser. * @@ -746,16 +986,14 @@ namespace optionenvironment { return ret; } - if (isJSONConfig(config_file)) { - ret = parseJSONConfigFile(options, config_file, &configEnvironment); - if (!ret.isOK()) { - return ret; - } - ret = addTypeConstraints(options, &configEnvironment); - if (!ret.isOK()) { - return ret; - } - ret = configEnvironment.validate(); + YAML::Node YAMLConfig; + ret = parseYAMLConfigFile(config_file, &YAMLConfig); + if (!ret.isOK()) { + return ret; + } + + if (isYAMLConfig(YAMLConfig)) { + ret = addYAMLNodesToEnvironment(YAMLConfig, options, "", &configEnvironment); if (!ret.isOK()) { return ret; } diff --git a/src/mongo/util/options_parser/options_parser_test.cpp b/src/mongo/util/options_parser/options_parser_test.cpp index 6d6f0f78330..5ebe022638f 100644 --- a/src/mongo/util/options_parser/options_parser_test.cpp +++ b/src/mongo/util/options_parser/options_parser_test.cpp @@ -1181,19 +1181,32 @@ namespace { argv.push_back("config.json"); std::map<std::string, std::string> env_map; - parser.setConfig("config.json", "{ multival : [ 1 ] }"); + // NOTE: The yaml config file just reads things as strings, and it's up to us to decide what + // the type should be later. This means that we can't tell the difference between when a + // user provides a non string value or a string value in some cases. + parser.setConfig("config.json", "{ multival : [ 1, true ] }"); - ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment)); + moe::Value value; + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + ASSERT_OK(environment.get(moe::Key("multival"), &value)); + std::vector<std::string> multival; + std::vector<std::string>::iterator multivalit; + ASSERT_OK(value.get(&multival)); + multivalit = multival.begin(); + ASSERT_EQUALS(*multivalit, "1"); + multivalit++; + ASSERT_EQUALS(*multivalit, "true"); } TEST(JSONConfigFile, Over16Megabytes) { - // Test to make sure that we fail gracefully when we try to parse a JSON config file that - // results in a BSON object larger than the current limit of 16MB + // Test to make sure that we can parse a JSON config file that results in a BSON object + // larger than the current limit of 16MB, now that we no longer store the result in BSON OptionsParserTester parser; moe::Environment environment; moe::OptionSection testOpts; testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("largeArray", "largeArray", moe::StringVector, "Large array"); std::vector<std::string> argv; argv.push_back("binaryname"); @@ -1237,7 +1250,7 @@ namespace { parser.setConfig("config.json", largeConfigString); moe::Value value; - ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment)); + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); } TEST(JSONConfigFile, DefaultValueOverride) { @@ -1485,209 +1498,6 @@ namespace { } } - TEST(JSONConfigFile, NestedComments) { - OptionsParserTester parser; - moe::Environment environment; - - moe::OptionSection testOpts; - testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); - testOpts.addOptionChaining("port", "port", moe::Int, "Port"); - testOpts.addOptionChaining("host", "host", moe::String, "Host"); - - std::vector<std::string> argv; - argv.push_back("binaryname"); - argv.push_back("--config"); - argv.push_back("config.json"); - std::map<std::string, std::string> env_map; - - parser.setConfig("config.json", - "{ port : { comment : \"comment on port\", value : 5 }," - "host : { comment : \"comment on host\", value : \"localhost\" } }"); - - moe::Value value; - ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); - ASSERT_OK(environment.get(moe::Key("port"), &value)); - int port; - ASSERT_OK(value.get(&port)); - ASSERT_EQUALS(port, 5); - ASSERT_OK(environment.get(moe::Key("host"), &value)); - std::string host; - ASSERT_OK(value.get(&host)); - ASSERT_EQUALS(host, "localhost"); - } - - TEST(JSONConfigFile, FlatComments) { - OptionsParserTester parser; - moe::Environment environment; - - moe::OptionSection testOpts; - testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); - testOpts.addOptionChaining("port", "port", moe::Int, "Port"); - testOpts.addOptionChaining("host", "host", moe::String, "Host"); - - std::vector<std::string> argv; - argv.push_back("binaryname"); - argv.push_back("--config"); - argv.push_back("config.json"); - std::map<std::string, std::string> env_map; - - parser.setConfig("config.json", - "{ comment : \"comment on port\", port : 5 ," - " comment : \"comment on host\", host : \"localhost\" }"); - - moe::Value value; - ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); - ASSERT_OK(environment.get(moe::Key("port"), &value)); - int port; - ASSERT_OK(value.get(&port)); - ASSERT_EQUALS(port, 5); - ASSERT_OK(environment.get(moe::Key("host"), &value)); - std::string host; - ASSERT_OK(value.get(&host)); - ASSERT_EQUALS(host, "localhost"); - } - - TEST(JSONConfigFile, MixedComments) { - OptionsParserTester parser; - moe::Environment environment; - - moe::OptionSection testOpts; - testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); - testOpts.addOptionChaining("port", "port", moe::Int, "Port"); - testOpts.addOptionChaining("host", "host", moe::String, "Host"); - - std::vector<std::string> argv; - argv.push_back("binaryname"); - argv.push_back("--config"); - argv.push_back("config.json"); - std::map<std::string, std::string> env_map; - - parser.setConfig("config.json", - "{ port : { comment : \"comment on port\", value : 5 }," - " comment : \"comment on host\", host : \"localhost\" }"); - - moe::Value value; - ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); - ASSERT_OK(environment.get(moe::Key("port"), &value)); - int port; - ASSERT_OK(value.get(&port)); - ASSERT_EQUALS(port, 5); - ASSERT_OK(environment.get(moe::Key("host"), &value)); - std::string host; - ASSERT_OK(value.get(&host)); - ASSERT_EQUALS(host, "localhost"); - } - - TEST(JSONConfigFile, NestedCommentsBadValue) { - OptionsParserTester parser; - moe::Environment environment; - - moe::OptionSection testOpts; - testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); - testOpts.addOptionChaining("port", "port", moe::Int, "Port"); - testOpts.addOptionChaining("host", "host", moe::String, "Host"); - - std::vector<std::string> argv; - argv.push_back("binaryname"); - argv.push_back("--config"); - argv.push_back("config.json"); - std::map<std::string, std::string> env_map; - - parser.setConfig("config.json", - "{ port : { comment : \"comment on port\", value : \"string\" }," - "host : { comment : \"comment on host\", value : \"localhost\" } }"); - - moe::Value value; - ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment)); - } - - TEST(JSONConfigFile, FlatCommentsBadValue) { - OptionsParserTester parser; - moe::Environment environment; - - moe::OptionSection testOpts; - testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); - testOpts.addOptionChaining("port", "port", moe::Int, "Port"); - testOpts.addOptionChaining("host", "host", moe::String, "Host"); - - std::vector<std::string> argv; - argv.push_back("binaryname"); - argv.push_back("--config"); - argv.push_back("config.json"); - std::map<std::string, std::string> env_map; - - parser.setConfig("config.json", - "{ comment : \"comment on port\", port : \"string\" ," - " comment : \"comment on host\", host : \"localhost\" }"); - - moe::Value value; - ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment)); - } - - TEST(JSONConfigFile, NestedCommentsOtherTypes) { - OptionsParserTester parser; - moe::Environment environment; - - moe::OptionSection testOpts; - testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); - testOpts.addOptionChaining("port", "port", moe::Int, "Port"); - testOpts.addOptionChaining("host", "host", moe::String, "Host"); - - std::vector<std::string> argv; - argv.push_back("binaryname"); - argv.push_back("--config"); - argv.push_back("config.json"); - std::map<std::string, std::string> env_map; - - parser.setConfig("config.json", - "{ port : { comment : [ \"can\", \"be\", \"array\", true ], value : 5 }," - " host : { comment : { nestedcomment : \"really descriptive\" }," - " value : \"localhost\" } }"); - - moe::Value value; - ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); - ASSERT_OK(environment.get(moe::Key("port"), &value)); - int port; - ASSERT_OK(value.get(&port)); - ASSERT_EQUALS(port, 5); - ASSERT_OK(environment.get(moe::Key("host"), &value)); - std::string host; - ASSERT_OK(value.get(&host)); - ASSERT_EQUALS(host, "localhost"); - } - - TEST(JSONConfigFile, FlatCommentsOtherTypes) { - OptionsParserTester parser; - moe::Environment environment; - - moe::OptionSection testOpts; - testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); - testOpts.addOptionChaining("port", "port", moe::Int, "Port"); - testOpts.addOptionChaining("host", "host", moe::String, "Host"); - - std::vector<std::string> argv; - argv.push_back("binaryname"); - argv.push_back("--config"); - argv.push_back("config.json"); - std::map<std::string, std::string> env_map; - - parser.setConfig("config.json", - "{ comment : [ \"can\", \"be\", \"array\", true ], port : 5," - " comment : { nestedcomment : \"really descriptive\" }," - " host : \"localhost\" }"); - - moe::Value value; - ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); - ASSERT_OK(environment.get(moe::Key("port"), &value)); - int port; - ASSERT_OK(value.get(&port)); - ASSERT_EQUALS(port, 5); - ASSERT_OK(environment.get(moe::Key("host"), &value)); - std::string host; - ASSERT_OK(value.get(&host)); - ASSERT_EQUALS(host, "localhost"); - } - TEST(ChainingInterface, GoodReference) { OptionsParserTester parser; moe::Environment environment; @@ -2553,4 +2363,318 @@ namespace { ASSERT_OK(value.get(&port)); ASSERT_EQUALS(port, 1000); } + + TEST(YAMLConfigFile, Basic) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("port", "port", moe::Int, "Port"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "port: 5"); + + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + moe::Value value; + ASSERT_OK(environment.get(moe::Key("port"), &value)); + int port; + ASSERT_OK(value.get(&port)); + ASSERT_EQUALS(port, 5); + } + + TEST(YAMLConfigFile, Empty) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", ""); + + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + } + + TEST(YAMLConfigFile, Override) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("port", "port", moe::Int, "Port"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + argv.push_back("--port"); + argv.push_back("6"); + std::map<std::string, std::string> env_map; + + + parser.setConfig("config.yaml", "port: 5"); + + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + moe::Value value; + ASSERT_OK(environment.get(moe::Key("port"), &value)); + int port; + ASSERT_OK(value.get(&port)); + ASSERT_EQUALS(port, 6); + } + + TEST(YAMLConfigFile, UnregisteredOption) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "port: 5"); + + ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment)); + } + + TEST(YAMLConfigFile, DuplicateOption) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("port", "port", moe::Int, "Port"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "port: 5\nport: 5"); + + ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment)); + } + + TEST(YAMLConfigFile, BadType) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("port", "port", moe::Int, "Port"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "port: \"string\""); + + ASSERT_NOT_OK(parser.run(testOpts, argv, env_map, &environment)); + } + + TEST(YAMLConfigFile, Nested) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("nested.port", "port", moe::Int, "Port"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "nested:\n port: 5"); + + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + moe::Value value; + ASSERT_OK(environment.get(moe::Key("nested.port"), &value)); + int port; + ASSERT_OK(value.get(&port)); + ASSERT_EQUALS(port, 5); + } + + TEST(YAMLConfigFile, Dotted) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("dotted.port", "port", moe::Int, "Port"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "dotted.port: 5"); + + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + moe::Value value; + ASSERT_OK(environment.get(moe::Key("dotted.port"), &value)); + int port; + ASSERT_OK(value.get(&port)); + ASSERT_EQUALS(port, 5); + } + + TEST(YAMLConfigFile, DottedAndNested) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("dottednested.var1", "var1", moe::Int, "Var1"); + testOpts.addOptionChaining("dottednested.var2", "var2", moe::Int, "Var2"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", + "dottednested.var1: 5\ndottednested:\n var2: 6"); + + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + moe::Value value; + ASSERT_OK(environment.get(moe::Key("dottednested.var1"), &value)); + int var1; + ASSERT_OK(value.get(&var1)); + ASSERT_EQUALS(var1, 5); + ASSERT_OK(environment.get(moe::Key("dottednested.var2"), &value)); + int var2; + ASSERT_OK(value.get(&var2)); + ASSERT_EQUALS(var2, 6); + } + + TEST(YAMLConfigFile, ListBrackets) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("multival", "multival", moe::StringVector, "Multiple Values"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "multival: [ \"val1\", \"val2\" ]"); + + moe::Value value; + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + ASSERT_OK(environment.get(moe::Key("multival"), &value)); + std::vector<std::string> multival; + std::vector<std::string>::iterator multivalit; + ASSERT_OK(value.get(&multival)); + multivalit = multival.begin(); + ASSERT_EQUALS(*multivalit, "val1"); + multivalit++; + ASSERT_EQUALS(*multivalit, "val2"); + } + + TEST(YAMLConfigFile, ListDashes) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("multival", "multival", moe::StringVector, "Multiple Values"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "multival:\n - \"val1\"\n - \"val2\""); + + moe::Value value; + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + ASSERT_OK(environment.get(moe::Key("multival"), &value)); + std::vector<std::string> multival; + std::vector<std::string>::iterator multivalit; + ASSERT_OK(value.get(&multival)); + multivalit = multival.begin(); + ASSERT_EQUALS(*multivalit, "val1"); + multivalit++; + ASSERT_EQUALS(*multivalit, "val2"); + } + + TEST(YAMLConfigFile, DefaultValueOverride) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("port", "port", moe::Int, "Port").setDefault(moe::Value(5)); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", "port: 6"); + + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + moe::Value value; + ASSERT_OK(environment.get(moe::Key("port"), &value)); + int port; + ASSERT_OK(value.get(&port)); + ASSERT_EQUALS(port, 6); + } + + TEST(YAMLConfigFile, Comments) { + OptionsParserTester parser; + moe::Environment environment; + + moe::OptionSection testOpts; + testOpts.addOptionChaining("config", "config", moe::String, "Config file to parse"); + testOpts.addOptionChaining("port", "port", moe::Int, "Port"); + testOpts.addOptionChaining("host", "host", moe::String, "Host"); + + std::vector<std::string> argv; + argv.push_back("binaryname"); + argv.push_back("--config"); + argv.push_back("config.yaml"); + std::map<std::string, std::string> env_map; + + parser.setConfig("config.yaml", + "# comment on port\nport: 5\n" + "# comment on host\nhost: localhost\n"); + + moe::Value value; + ASSERT_OK(parser.run(testOpts, argv, env_map, &environment)); + ASSERT_OK(environment.get(moe::Key("port"), &value)); + int port; + ASSERT_OK(value.get(&port)); + ASSERT_EQUALS(port, 5); + ASSERT_OK(environment.get(moe::Key("host"), &value)); + std::string host; + ASSERT_OK(value.get(&host)); + ASSERT_EQUALS(host, "localhost"); + } } // unnamed namespace diff --git a/src/third_party/SConscript b/src/third_party/SConscript index 774161295c9..95dc24013a6 100644 --- a/src/third_party/SConscript +++ b/src/third_party/SConscript @@ -76,3 +76,14 @@ else: env.SConscript('libstemmer_c/SConscript') env.StaticLibrary("shim_stemmer", ['shim_stemmer.cpp'], LIBDEPS=['libstemmer_c/stemmer']) + +if use_system_version_of_library("yaml"): + env.StaticLibrary("shim_yaml", ['shim_yaml.cpp'], + SYSLIBDEPS=[ + env['LIBDEPS_YAML_SYSLIBDEP'] + ] ) +else: + env.Append(CPPPATH='$BUILD_DIR/third_party/yaml-cpp-0.5.1/include') + env.SConscript('yaml-cpp-0.5.1/SConscript') + env.StaticLibrary("shim_yaml", ['shim_yaml.cpp'], + LIBDEPS=['yaml-cpp-0.5.1/yaml']) diff --git a/src/third_party/shim_yaml.cpp b/src/third_party/shim_yaml.cpp new file mode 100644 index 00000000000..a9a63b2d27e --- /dev/null +++ b/src/third_party/shim_yaml.cpp @@ -0,0 +1,3 @@ +// This file intentionally blank. shim_yaml.cpp is part of the +// third_party/yaml library, which is just a placeholder for forwarding +// library dependencies. diff --git a/src/third_party/yaml-cpp-0.5.1/SConscript b/src/third_party/yaml-cpp-0.5.1/SConscript new file mode 100644 index 00000000000..b9feb2e8f3c --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/SConscript @@ -0,0 +1,43 @@ +Import("env") + +# Create a new environment since this one doesn't build without errors when using -Wno-virtual-dtor +env = env.Clone() + +try: + env['CXXFLAGS'].remove('-Wnon-virtual-dtor') + env['CCFLAGS'].remove('-Wall') +except ValueError: + pass + +env.Library("yaml", + [ + "src/binary.cpp", + "src/graphbuilder.cpp", + "src/graphbuilderadapter.cpp", + "src/convert.cpp", + "src/directives.cpp", + "src/emit.cpp", + "src/emitfromevents.cpp", + "src/emitter.cpp", + "src/emitterstate.cpp", + "src/emitterutils.cpp", + "src/exp.cpp", + "src/memory.cpp", + "src/node.cpp", + "src/node_data.cpp", + "src/nodebuilder.cpp", + "src/nodeevents.cpp", + "src/null.cpp", + "src/ostream_wrapper.cpp", + "src/parse.cpp", + "src/parser.cpp", + "src/regex.cpp", + "src/scanner.cpp", + "src/scanscalar.cpp", + "src/scantag.cpp", + "src/scantoken.cpp", + "src/simplekey.cpp", + "src/singledocparser.cpp", + "src/stream.cpp", + "src/tag.cpp", + ]) diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/anchor.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/anchor.h new file mode 100644 index 00000000000..433f2fa5361 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/anchor.h @@ -0,0 +1,16 @@ +#ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include <cstddef> + +namespace YAML +{ + typedef std::size_t anchor_t; + const anchor_t NullAnchor = 0; +} + +#endif // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/binary.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/binary.h new file mode 100644 index 00000000000..edc0b2c18d6 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/binary.h @@ -0,0 +1,62 @@ +#ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include <string> +#include <vector> + +namespace YAML +{ + std::string EncodeBase64(const unsigned char *data, std::size_t size); + std::vector<unsigned char> DecodeBase64(const std::string& input); + + class Binary { + public: + Binary(): m_unownedData(0), m_unownedSize(0) {} + Binary(const unsigned char *data_, std::size_t size_): m_unownedData(data_), m_unownedSize(size_) {} + + bool owned() const { return !m_unownedData; } + std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; } + const unsigned char *data() const { return owned() ? &m_data[0] : m_unownedData; } + + void swap(std::vector<unsigned char>& rhs) { + if(m_unownedData) { + m_data.swap(rhs); + rhs.clear(); + rhs.resize(m_unownedSize); + std::copy(m_unownedData, m_unownedData + m_unownedSize, &rhs[0]); + m_unownedData = 0; + m_unownedSize = 0; + } else { + m_data.swap(rhs); + } + } + + bool operator == (const Binary& rhs) const { + const std::size_t s = size(); + if(s != rhs.size()) + return false; + const unsigned char *d1 = data(); + const unsigned char *d2 = rhs.data(); + for(std::size_t i=0;i<s;i++) { + if(*d1++ != *d2++) + return false; + } + return true; + } + + bool operator != (const Binary& rhs) const { + return !(*this == rhs); + } + + private: + std::vector<unsigned char> m_data; + const unsigned char *m_unownedData; + std::size_t m_unownedSize; + }; +} + +#endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/contrib/anchordict.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/contrib/anchordict.h new file mode 100644 index 00000000000..e483dc4b5d9 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/contrib/anchordict.h @@ -0,0 +1,42 @@ +#ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include <vector> + +#include "../anchor.h" + +namespace YAML +{ + /// AnchorDict + /// . An object that stores and retrieves values correlating to anchor_t + /// values. + /// . Efficient implementation that can make assumptions about how anchor_t + /// values are assigned by the Parser class. + template <class T> + class AnchorDict + { + public: + void Register(anchor_t anchor, T value) + { + if (anchor > m_data.size()) + { + m_data.resize(anchor); + } + m_data[anchor - 1] = value; + } + + T Get(anchor_t anchor) const + { + return m_data[anchor - 1]; + } + + private: + std::vector<T> m_data; + }; +} + +#endif // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/contrib/graphbuilder.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/contrib/graphbuilder.h new file mode 100644 index 00000000000..6739a12b5cc --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/contrib/graphbuilder.h @@ -0,0 +1,133 @@ +#ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/mark.h" +#include <string> + +namespace YAML +{ + class Parser; + + // GraphBuilderInterface + // . Abstraction of node creation + // . pParentNode is always NULL or the return value of one of the NewXXX() + // functions. + class GraphBuilderInterface + { + public: + // Create and return a new node with a null value. + virtual void *NewNull(const Mark& mark, void *pParentNode) = 0; + + // Create and return a new node with the given tag and value. + virtual void *NewScalar(const Mark& mark, const std::string& tag, void *pParentNode, const std::string& value) = 0; + + // Create and return a new sequence node + virtual void *NewSequence(const Mark& mark, const std::string& tag, void *pParentNode) = 0; + // Add pNode to pSequence. pNode was created with one of the NewXxx() + // functions and pSequence with NewSequence(). + virtual void AppendToSequence(void *pSequence, void *pNode) = 0; + // Note that no moew entries will be added to pSequence + virtual void SequenceComplete(void *pSequence) {(void)pSequence;} + + // Create and return a new map node + virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) = 0; + // Add the pKeyNode => pValueNode mapping to pMap. pKeyNode and pValueNode + // were created with one of the NewXxx() methods and pMap with NewMap(). + virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0; + // Note that no more assignments will be made in pMap + virtual void MapComplete(void *pMap) {(void)pMap;} + + // Return the node that should be used in place of an alias referencing + // pNode (pNode by default) + virtual void *AnchorReference(const Mark& mark, void *pNode) {(void)mark; return pNode;} + }; + + // Typesafe wrapper for GraphBuilderInterface. Assumes that Impl defines + // Node, Sequence, and Map types. Sequence and Map must derive from Node + // (unless Node is defined as void). Impl must also implement function with + // all of the same names as the virtual functions in GraphBuilderInterface + // -- including the ones with default implementations -- but with the + // prototypes changed to accept an explicit Node*, Sequence*, or Map* where + // appropriate. + template <class Impl> + class GraphBuilder : public GraphBuilderInterface + { + public: + typedef typename Impl::Node Node; + typedef typename Impl::Sequence Sequence; + typedef typename Impl::Map Map; + + GraphBuilder(Impl& impl) : m_impl(impl) + { + Map* pMap = NULL; + Sequence* pSeq = NULL; + Node* pNode = NULL; + + // Type consistency checks + pNode = pMap; + pNode = pSeq; + } + + GraphBuilderInterface& AsBuilderInterface() {return *this;} + + virtual void *NewNull(const Mark& mark, void* pParentNode) { + return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode))); + } + + virtual void *NewScalar(const Mark& mark, const std::string& tag, void *pParentNode, const std::string& value) { + return CheckType<Node>(m_impl.NewScalar(mark, tag, AsNode(pParentNode), value)); + } + + virtual void *NewSequence(const Mark& mark, const std::string& tag, void *pParentNode) { + return CheckType<Sequence>(m_impl.NewSequence(mark, tag, AsNode(pParentNode))); + } + virtual void AppendToSequence(void *pSequence, void *pNode) { + m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode)); + } + virtual void SequenceComplete(void *pSequence) { + m_impl.SequenceComplete(AsSequence(pSequence)); + } + + virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) { + return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode))); + } + virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) { + m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode)); + } + virtual void MapComplete(void *pMap) { + m_impl.MapComplete(AsMap(pMap)); + } + + virtual void *AnchorReference(const Mark& mark, void *pNode) { + return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode))); + } + + private: + Impl& m_impl; + + // Static check for pointer to T + template <class T, class U> + static T* CheckType(U* p) {return p;} + + static Node *AsNode(void *pNode) {return static_cast<Node*>(pNode);} + static Sequence *AsSequence(void *pSeq) {return static_cast<Sequence*>(pSeq);} + static Map *AsMap(void *pMap) {return static_cast<Map*>(pMap);} + }; + + void *BuildGraphOfNextDocument(Parser& parser, GraphBuilderInterface& graphBuilder); + + template <class Impl> + typename Impl::Node *BuildGraphOfNextDocument(Parser& parser, Impl& impl) + { + GraphBuilder<Impl> graphBuilder(impl); + return static_cast<typename Impl::Node *>(BuildGraphOfNextDocument( + parser, graphBuilder + )); + } +} + +#endif // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/dll.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/dll.h new file mode 100644 index 00000000000..ea138401c6d --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/dll.h @@ -0,0 +1,28 @@ +#ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +// The following ifdef block is the standard way of creating macros which make exporting +// from a DLL simpler. All files within this DLL are compiled with the yaml_cpp_EXPORTS +// symbol defined on the command line. this symbol should not be defined on any project +// that uses this DLL. This way any other project whose source files include this file see +// YAML_CPP_API functions as being imported from a DLL, whereas this DLL sees symbols +// defined with this macro as being exported. +#undef YAML_CPP_API + +#ifdef YAML_CPP_DLL // Using or Building YAML-CPP DLL (definition defined manually) + #ifdef yaml_cpp_EXPORTS // Building YAML-CPP DLL (definition created by CMake or defined manually) + // #pragma message( "Defining YAML_CPP_API for DLL export" ) + #define YAML_CPP_API __declspec(dllexport) + #else // yaml_cpp_EXPORTS + // #pragma message( "Defining YAML_CPP_API for DLL import" ) + #define YAML_CPP_API __declspec(dllimport) + #endif // yaml_cpp_EXPORTS +#else //YAML_CPP_DLL +#define YAML_CPP_API +#endif // YAML_CPP_DLL + +#endif // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitfromevents.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitfromevents.h new file mode 100644 index 00000000000..e11ae640eff --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitfromevents.h @@ -0,0 +1,45 @@ +#ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/eventhandler.h" +#include <stack> + +namespace YAML +{ + class Emitter; + + class EmitFromEvents: public EventHandler + { + public: + EmitFromEvents(Emitter& emitter); + + virtual void OnDocumentStart(const Mark& mark); + virtual void OnDocumentEnd(); + + virtual void OnNull(const Mark& mark, anchor_t anchor); + virtual void OnAlias(const Mark& mark, anchor_t anchor); + virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value); + + virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor); + virtual void OnSequenceEnd(); + + virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor); + virtual void OnMapEnd(); + + private: + void BeginNode(); + void EmitProps(const std::string& tag, anchor_t anchor); + + private: + Emitter& m_emitter; + + struct State { enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue }; }; + std::stack<State::value> m_stateStack; + }; +} + +#endif // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitter.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitter.h new file mode 100644 index 00000000000..927fe6c382e --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitter.h @@ -0,0 +1,209 @@ +#ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/binary.h" +#include "yaml-cpp/emitterdef.h" +#include "yaml-cpp/emittermanip.h" +#include "yaml-cpp/noncopyable.h" +#include "yaml-cpp/null.h" +#include "yaml-cpp/ostream_wrapper.h" +#include <memory> +#include <string> +#include <sstream> + +namespace YAML +{ + class EmitterState; + + class YAML_CPP_API Emitter: private noncopyable + { + public: + Emitter(); + explicit Emitter(std::ostream& stream); + ~Emitter(); + + // output + const char *c_str() const; + std::size_t size() const; + + // state checking + bool good() const; + const std::string GetLastError() const; + + // global setters + bool SetOutputCharset(EMITTER_MANIP value); + bool SetStringFormat(EMITTER_MANIP value); + bool SetBoolFormat(EMITTER_MANIP value); + bool SetIntBase(EMITTER_MANIP value); + bool SetSeqFormat(EMITTER_MANIP value); + bool SetMapFormat(EMITTER_MANIP value); + bool SetIndent(unsigned n); + bool SetPreCommentIndent(unsigned n); + bool SetPostCommentIndent(unsigned n); + bool SetFloatPrecision(unsigned n); + bool SetDoublePrecision(unsigned n); + + // local setters + Emitter& SetLocalValue(EMITTER_MANIP value); + Emitter& SetLocalIndent(const _Indent& indent); + Emitter& SetLocalPrecision(const _Precision& precision); + + // overloads of write + Emitter& Write(const std::string& str); + Emitter& Write(bool b); + Emitter& Write(char ch); + Emitter& Write(const _Alias& alias); + Emitter& Write(const _Anchor& anchor); + Emitter& Write(const _Tag& tag); + Emitter& Write(const _Comment& comment); + Emitter& Write(const _Null& n); + Emitter& Write(const Binary& binary); + + template <typename T> + Emitter& WriteIntegralType(T value); + + template <typename T> + Emitter& WriteStreamable(T value); + + private: + template<typename T> void SetStreamablePrecision(std::stringstream&) {} + unsigned GetFloatPrecision() const; + unsigned GetDoublePrecision() const; + + void PrepareIntegralStream(std::stringstream& stream) const; + void StartedScalar(); + + private: + void EmitBeginDoc(); + void EmitEndDoc(); + void EmitBeginSeq(); + void EmitEndSeq(); + void EmitBeginMap(); + void EmitEndMap(); + void EmitNewline(); + void EmitKindTag(); + void EmitTag(bool verbatim, const _Tag& tag); + + void PrepareNode(EmitterNodeType::value child); + void PrepareTopNode(EmitterNodeType::value child); + void FlowSeqPrepareNode(EmitterNodeType::value child); + void BlockSeqPrepareNode(EmitterNodeType::value child); + + void FlowMapPrepareNode(EmitterNodeType::value child); + + void FlowMapPrepareLongKey(EmitterNodeType::value child); + void FlowMapPrepareLongKeyValue(EmitterNodeType::value child); + void FlowMapPrepareSimpleKey(EmitterNodeType::value child); + void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child); + + void BlockMapPrepareNode(EmitterNodeType::value child); + + void BlockMapPrepareLongKey(EmitterNodeType::value child); + void BlockMapPrepareLongKeyValue(EmitterNodeType::value child); + void BlockMapPrepareSimpleKey(EmitterNodeType::value child); + void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child); + + void SpaceOrIndentTo(bool requireSpace, unsigned indent); + + const char *ComputeFullBoolName(bool b) const; + bool CanEmitNewline() const; + + private: + std::auto_ptr<EmitterState> m_pState; + ostream_wrapper m_stream; + }; + + template <typename T> + inline Emitter& Emitter::WriteIntegralType(T value) + { + if(!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + + std::stringstream stream; + PrepareIntegralStream(stream); + stream << value; + m_stream << stream.str(); + + StartedScalar(); + + return *this; + } + + template <typename T> + inline Emitter& Emitter::WriteStreamable(T value) + { + if(!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + + std::stringstream stream; + SetStreamablePrecision<T>(stream); + stream << value; + m_stream << stream.str(); + + StartedScalar(); + + return *this; + } + + template<> + inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) + { + stream.precision(GetFloatPrecision()); + } + + template<> + inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) + { + stream.precision(GetDoublePrecision()); + } + + // overloads of insertion + inline Emitter& operator << (Emitter& emitter, const std::string& v) { return emitter.Write(v); } + inline Emitter& operator << (Emitter& emitter, bool v) { return emitter.Write(v); } + inline Emitter& operator << (Emitter& emitter, char v) { return emitter.Write(v); } + inline Emitter& operator << (Emitter& emitter, unsigned char v) { return emitter.Write(static_cast<char>(v)); } + inline Emitter& operator << (Emitter& emitter, const _Alias& v) { return emitter.Write(v); } + inline Emitter& operator << (Emitter& emitter, const _Anchor& v) { return emitter.Write(v); } + inline Emitter& operator << (Emitter& emitter, const _Tag& v) { return emitter.Write(v); } + inline Emitter& operator << (Emitter& emitter, const _Comment& v) { return emitter.Write(v); } + inline Emitter& operator << (Emitter& emitter, const _Null& v) { return emitter.Write(v); } + inline Emitter& operator << (Emitter& emitter, const Binary& b) { return emitter.Write(b); } + + inline Emitter& operator << (Emitter& emitter, const char *v) { return emitter.Write(std::string(v)); } + + inline Emitter& operator << (Emitter& emitter, int v) { return emitter.WriteIntegralType(v); } + inline Emitter& operator << (Emitter& emitter, unsigned int v) { return emitter.WriteIntegralType(v); } + inline Emitter& operator << (Emitter& emitter, short v) { return emitter.WriteIntegralType(v); } + inline Emitter& operator << (Emitter& emitter, unsigned short v) { return emitter.WriteIntegralType(v); } + inline Emitter& operator << (Emitter& emitter, long v) { return emitter.WriteIntegralType(v); } + inline Emitter& operator << (Emitter& emitter, unsigned long v) { return emitter.WriteIntegralType(v); } + inline Emitter& operator << (Emitter& emitter, long long v) { return emitter.WriteIntegralType(v); } + inline Emitter& operator << (Emitter& emitter, unsigned long long v) { return emitter.WriteIntegralType(v); } + + inline Emitter& operator << (Emitter& emitter, float v) { return emitter.WriteStreamable(v); } + inline Emitter& operator << (Emitter& emitter, double v) { return emitter.WriteStreamable(v); } + + inline Emitter& operator << (Emitter& emitter, EMITTER_MANIP value) { + return emitter.SetLocalValue(value); + } + + inline Emitter& operator << (Emitter& emitter, _Indent indent) { + return emitter.SetLocalIndent(indent); + } + + inline Emitter& operator << (Emitter& emitter, _Precision precision) { + return emitter.SetLocalPrecision(precision); + } +} + +#endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitterdef.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitterdef.h new file mode 100644 index 00000000000..c5ca00b29eb --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emitterdef.h @@ -0,0 +1,13 @@ +#ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +namespace YAML +{ + struct EmitterNodeType { enum value { None, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap }; }; +} + +#endif // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emittermanip.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emittermanip.h new file mode 100644 index 00000000000..a8ec64a4116 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/emittermanip.h @@ -0,0 +1,149 @@ +#ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <string> + +namespace YAML +{ + enum EMITTER_MANIP { + // general manipulators + Auto, + TagByKind, + Newline, + + // output character set + EmitNonAscii, + EscapeNonAscii, + + // string manipulators + // Auto, // duplicate + SingleQuoted, + DoubleQuoted, + Literal, + + // bool manipulators + YesNoBool, // yes, no + TrueFalseBool, // true, false + OnOffBool, // on, off + UpperCase, // TRUE, N + LowerCase, // f, yes + CamelCase, // No, Off + LongBool, // yes, On + ShortBool, // y, t + + // int manipulators + Dec, + Hex, + Oct, + + // document manipulators + BeginDoc, + EndDoc, + + // sequence manipulators + BeginSeq, + EndSeq, + Flow, + Block, + + // map manipulators + BeginMap, + EndMap, + Key, + Value, + // Flow, // duplicate + // Block, // duplicate + // Auto, // duplicate + LongKey + }; + + struct _Indent { + _Indent(int value_): value(value_) {} + int value; + }; + + inline _Indent Indent(int value) { + return _Indent(value); + } + + struct _Alias { + _Alias(const std::string& content_): content(content_) {} + std::string content; + }; + + inline _Alias Alias(const std::string content) { + return _Alias(content); + } + + struct _Anchor { + _Anchor(const std::string& content_): content(content_) {} + std::string content; + }; + + inline _Anchor Anchor(const std::string content) { + return _Anchor(content); + } + + struct _Tag { + struct Type { enum value { Verbatim, PrimaryHandle, NamedHandle }; }; + + explicit _Tag(const std::string& prefix_, const std::string& content_, Type::value type_) + : prefix(prefix_), content(content_), type(type_) + { + } + std::string prefix; + std::string content; + Type::value type; + }; + + inline _Tag VerbatimTag(const std::string content) { + return _Tag("", content, _Tag::Type::Verbatim); + } + + inline _Tag LocalTag(const std::string content) { + return _Tag("", content, _Tag::Type::PrimaryHandle); + } + + inline _Tag LocalTag(const std::string& prefix, const std::string content) { + return _Tag(prefix, content, _Tag::Type::NamedHandle); + } + + inline _Tag SecondaryTag(const std::string content) { + return _Tag("", content, _Tag::Type::NamedHandle); + } + + struct _Comment { + _Comment(const std::string& content_): content(content_) {} + std::string content; + }; + + inline _Comment Comment(const std::string content) { + return _Comment(content); + } + + struct _Precision { + _Precision(int floatPrecision_, int doublePrecision_): floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {} + + int floatPrecision; + int doublePrecision; + }; + + inline _Precision FloatPrecision(int n) { + return _Precision(n, -1); + } + + inline _Precision DoublePrecision(int n) { + return _Precision(-1, n); + } + + inline _Precision Precision(int n) { + return _Precision(n, n); + } +} + +#endif // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/eventhandler.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/eventhandler.h new file mode 100644 index 00000000000..3173a1fbb9f --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/eventhandler.h @@ -0,0 +1,36 @@ +#ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/anchor.h" +#include <string> + +namespace YAML +{ + struct Mark; + + class EventHandler + { + public: + virtual ~EventHandler() {} + + virtual void OnDocumentStart(const Mark& mark) = 0; + virtual void OnDocumentEnd() = 0; + + virtual void OnNull(const Mark& mark, anchor_t anchor) = 0; + virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0; + virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value) = 0; + + virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor) = 0; + virtual void OnSequenceEnd() = 0; + + virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor) = 0; + virtual void OnMapEnd() = 0; + }; +} + +#endif // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/exceptions.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/exceptions.h new file mode 100644 index 00000000000..ffbf7bd16db --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/exceptions.h @@ -0,0 +1,208 @@ +#ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/mark.h" +#include "yaml-cpp/traits.h" +#include <stdexcept> +#include <string> +#include <sstream> + +namespace YAML +{ + // error messages + namespace ErrorMsg + { + const char * const YAML_DIRECTIVE_ARGS = "YAML directives must have exactly one argument"; + const char * const YAML_VERSION = "bad YAML version: "; + const char * const YAML_MAJOR_VERSION = "YAML major version too large"; + const char * const REPEATED_YAML_DIRECTIVE= "repeated YAML directive"; + const char * const TAG_DIRECTIVE_ARGS = "TAG directives must have exactly two arguments"; + const char * const REPEATED_TAG_DIRECTIVE = "repeated TAG directive"; + const char * const CHAR_IN_TAG_HANDLE = "illegal character found while scanning tag handle"; + const char * const TAG_WITH_NO_SUFFIX = "tag handle with no suffix"; + const char * const END_OF_VERBATIM_TAG = "end of verbatim tag not found"; + const char * const END_OF_MAP = "end of map not found"; + const char * const END_OF_MAP_FLOW = "end of map flow not found"; + const char * const END_OF_SEQ = "end of sequence not found"; + const char * const END_OF_SEQ_FLOW = "end of sequence flow not found"; + const char * const MULTIPLE_TAGS = "cannot assign multiple tags to the same node"; + const char * const MULTIPLE_ANCHORS = "cannot assign multiple anchors to the same node"; + const char * const MULTIPLE_ALIASES = "cannot assign multiple aliases to the same node"; + const char * const ALIAS_CONTENT = "aliases can't have any content, *including* tags"; + const char * const INVALID_HEX = "bad character found while scanning hex number"; + const char * const INVALID_UNICODE = "invalid unicode: "; + const char * const INVALID_ESCAPE = "unknown escape character: "; + const char * const UNKNOWN_TOKEN = "unknown token"; + const char * const DOC_IN_SCALAR = "illegal document indicator in scalar"; + const char * const EOF_IN_SCALAR = "illegal EOF in scalar"; + const char * const CHAR_IN_SCALAR = "illegal character in scalar"; + const char * const TAB_IN_INDENTATION = "illegal tab when looking for indentation"; + const char * const FLOW_END = "illegal flow end"; + const char * const BLOCK_ENTRY = "illegal block entry"; + const char * const MAP_KEY = "illegal map key"; + const char * const MAP_VALUE = "illegal map value"; + const char * const ALIAS_NOT_FOUND = "alias not found after *"; + const char * const ANCHOR_NOT_FOUND = "anchor not found after &"; + const char * const CHAR_IN_ALIAS = "illegal character found while scanning alias"; + const char * const CHAR_IN_ANCHOR = "illegal character found while scanning anchor"; + const char * const ZERO_INDENT_IN_BLOCK = "cannot set zero indentation for a block scalar"; + const char * const CHAR_IN_BLOCK = "unexpected character in block scalar"; + const char * const AMBIGUOUS_ANCHOR = "cannot assign the same alias to multiple nodes"; + const char * const UNKNOWN_ANCHOR = "the referenced anchor is not defined"; + + const char * const INVALID_NODE = "invalid node; this may result from using a map iterator as a sequence iterator, or vice-versa"; + const char * const INVALID_SCALAR = "invalid scalar"; + const char * const KEY_NOT_FOUND = "key not found"; + const char * const BAD_CONVERSION = "bad conversion"; + const char * const BAD_DEREFERENCE = "bad dereference"; + const char * const BAD_SUBSCRIPT = "operator[] call on a scalar"; + const char * const BAD_PUSHBACK = "appending to a non-sequence"; + const char * const BAD_INSERT = "inserting in a non-convertible-to-map"; + + const char * const UNMATCHED_GROUP_TAG = "unmatched group tag"; + const char * const UNEXPECTED_END_SEQ = "unexpected end sequence token"; + const char * const UNEXPECTED_END_MAP = "unexpected end map token"; + const char * const SINGLE_QUOTED_CHAR = "invalid character in single-quoted string"; + const char * const INVALID_ANCHOR = "invalid anchor"; + const char * const INVALID_ALIAS = "invalid alias"; + const char * const INVALID_TAG = "invalid tag"; + const char * const BAD_FILE = "bad file"; + + template <typename T> + inline const std::string KEY_NOT_FOUND_WITH_KEY(const T&, typename disable_if<is_numeric<T> >::type * = 0) { + return KEY_NOT_FOUND; + } + + inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) { + std::stringstream stream; + stream << KEY_NOT_FOUND << ": " << key; + return stream.str(); + } + + template <typename T> + inline const std::string KEY_NOT_FOUND_WITH_KEY(const T& key, typename enable_if<is_numeric<T> >::type * = 0) { + std::stringstream stream; + stream << KEY_NOT_FOUND << ": " << key; + return stream.str(); + } + } + + class Exception: public std::runtime_error { + public: + Exception(const Mark& mark_, const std::string& msg_) + : std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {} + virtual ~Exception() throw() {} + + Mark mark; + std::string msg; + + private: + static const std::string build_what(const Mark& mark, const std::string& msg) { + std::stringstream output; + output << "yaml-cpp: error at line " << mark.line+1 << ", column " << mark.column+1 << ": " << msg; + return output.str(); + } + }; + + class ParserException: public Exception { + public: + ParserException(const Mark& mark_, const std::string& msg_) + : Exception(mark_, msg_) {} + }; + + class RepresentationException: public Exception { + public: + RepresentationException(const Mark& mark_, const std::string& msg_) + : Exception(mark_, msg_) {} + }; + + // representation exceptions + class InvalidScalar: public RepresentationException { + public: + InvalidScalar(const Mark& mark_) + : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {} + }; + + class KeyNotFound: public RepresentationException { + public: + template <typename T> + KeyNotFound(const Mark& mark_, const T& key_) + : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {} + }; + + template <typename T> + class TypedKeyNotFound: public KeyNotFound { + public: + TypedKeyNotFound(const Mark& mark_, const T& key_) + : KeyNotFound(mark_, key_), key(key_) {} + virtual ~TypedKeyNotFound() throw() {} + + T key; + }; + + template <typename T> + inline TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) { + return TypedKeyNotFound <T> (mark, key); + } + + class InvalidNode: public RepresentationException { + public: + InvalidNode() + : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {} + }; + + class BadConversion: public RepresentationException { + public: + BadConversion() + : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_CONVERSION) {} + }; + + template<typename T> + class TypedBadConversion: public BadConversion { + public: + TypedBadConversion() + : BadConversion() {} + }; + + class BadDereference: public RepresentationException { + public: + BadDereference() + : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {} + }; + + class BadSubscript: public RepresentationException { + public: + BadSubscript() + : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {} + }; + + class BadPushback: public RepresentationException { + public: + BadPushback() + : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {} + }; + + class BadInsert: public RepresentationException { + public: + BadInsert() + : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {} + }; + + class EmitterException: public Exception { + public: + EmitterException(const std::string& msg_) + : Exception(Mark::null_mark(), msg_) {} + }; + + class BadFile: public Exception { + public: + BadFile(): Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {} + }; +} + +#endif // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/mark.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/mark.h new file mode 100644 index 00000000000..e07b317bdcb --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/mark.h @@ -0,0 +1,26 @@ +#ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" + +namespace YAML +{ + struct YAML_CPP_API Mark { + Mark(): pos(0), line(0), column(0) {} + + static const Mark null_mark() { return Mark(-1, -1, -1); } + + int pos; + int line, column; + + private: + Mark(int pos_, int line_, int column_): pos(pos_), line(line_), column(column_) {} + }; +} + +#endif // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/convert.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/convert.h new file mode 100644 index 00000000000..d73f2843d9e --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/convert.h @@ -0,0 +1,280 @@ +#ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/binary.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/iterator.h" +#include "yaml-cpp/null.h" +#include <limits> +#include <list> +#include <map> +#include <sstream> +#include <vector> + +namespace YAML +{ + namespace conversion { + inline bool IsInfinity(const std::string& input) { + return input == ".inf" || input == ".Inf" || input == ".INF" || input == "+.inf" || input == "+.Inf" || input == "+.INF"; + } + + inline bool IsNegativeInfinity(const std::string& input) { + return input == "-.inf" || input == "-.Inf" || input == "-.INF"; + } + + inline bool IsNaN(const std::string& input) { + return input == ".nan" || input == ".NaN" || input == ".NAN"; + } + } + + // std::string + template<> + struct convert<std::string> { + static Node encode(const std::string& rhs) { + return Node(rhs); + } + + static bool decode(const Node& node, std::string& rhs) { + if(!node.IsScalar()) + return false; + rhs = node.Scalar(); + return true; + } + }; + + // C-strings can only be encoded + template<> + struct convert<const char *> { + static Node encode(const char *&rhs) { + return Node(rhs); + } + }; + + template<std::size_t N> + struct convert<const char[N]> { + static Node encode(const char (&rhs)[N]) { + return Node(rhs); + } + }; + + template<> + struct convert<_Null> { + static Node encode(const _Null& /* rhs */) { + return Node(); + } + + static bool decode(const Node& node, _Null& /* rhs */) { + return node.IsNull(); + } + }; + +#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op)\ + template<>\ + struct convert<type> {\ + static Node encode(const type& rhs) {\ + std::stringstream stream;\ + stream.precision(std::numeric_limits<type>::digits10 + 1);\ + stream << rhs;\ + return Node(stream.str());\ + }\ + \ + static bool decode(const Node& node, type& rhs) {\ + if(node.Type() != NodeType::Scalar)\ + return false;\ + const std::string& input = node.Scalar();\ + std::stringstream stream(input);\ + stream.unsetf(std::ios::dec);\ + if((stream >> rhs) && (stream >> std::ws).eof())\ + return true;\ + if(std::numeric_limits<type>::has_infinity) {\ + if(conversion::IsInfinity(input)) {\ + rhs = std::numeric_limits<type>::infinity();\ + return true;\ + } else if(conversion::IsNegativeInfinity(input)) {\ + rhs = negative_op std::numeric_limits<type>::infinity();\ + return true;\ + }\ + }\ + \ + if(std::numeric_limits<type>::has_quiet_NaN && conversion::IsNaN(input)) {\ + rhs = std::numeric_limits<type>::quiet_NaN();\ + return true;\ + }\ + \ + return false;\ + }\ + } + +#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type)\ + YAML_DEFINE_CONVERT_STREAMABLE(type, -) + +#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type)\ + YAML_DEFINE_CONVERT_STREAMABLE(type, +) + + YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int); + YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short); + YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long); + YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long long); + YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned); + YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned short); + YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long); + YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long long); + + YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(char); + YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned char); + + YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(float); + YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(double); + YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long double); + +#undef YAML_DEFINE_CONVERT_STREAMABLE_SIGNED +#undef YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED +#undef YAML_DEFINE_CONVERT_STREAMABLE + + // bool + template<> + struct convert<bool> { + static Node encode(bool rhs) { + return rhs ? Node("true") : Node("false"); + } + + static bool decode(const Node& node, bool& rhs); + }; + + // std::map + template<typename K, typename V> + struct convert<std::map<K, V> > { + static Node encode(const std::map<K, V>& rhs) { + Node node(NodeType::Map); + for(typename std::map<K, V>::const_iterator it=rhs.begin();it!=rhs.end();++it) + node.force_insert(it->first, it->second); + return node; + } + + static bool decode(const Node& node, std::map<K, V>& rhs) { + if(!node.IsMap()) + return false; + + rhs.clear(); + for(const_iterator it=node.begin();it!=node.end();++it) +#if defined(__GNUC__) && __GNUC__ < 4 +//workaround for GCC 3: + rhs[it->first.template as<K>()] = it->second.template as<V>(); +#else + rhs[it->first.as<K>()] = it->second.as<V>(); +#endif + return true; + } + }; + + // std::vector + template<typename T> + struct convert<std::vector<T> > { + static Node encode(const std::vector<T>& rhs) { + Node node(NodeType::Sequence); + for(typename std::vector<T>::const_iterator it=rhs.begin();it!=rhs.end();++it) + node.push_back(*it); + return node; + } + + static bool decode(const Node& node, std::vector<T>& rhs) { + if(!node.IsSequence()) + return false; + + rhs.clear(); + for(const_iterator it=node.begin();it!=node.end();++it) +#if defined(__GNUC__) && __GNUC__ < 4 +//workaround for GCC 3: + rhs.push_back(it->template as<T>()); +#else + rhs.push_back(it->as<T>()); +#endif + return true; + } + }; + + // std::list + template<typename T> + struct convert<std::list<T> > { + static Node encode(const std::list<T>& rhs) { + Node node(NodeType::Sequence); + for(typename std::list<T>::const_iterator it=rhs.begin();it!=rhs.end();++it) + node.push_back(*it); + return node; + } + + static bool decode(const Node& node, std::list<T>& rhs) { + if(!node.IsSequence()) + return false; + + rhs.clear(); + for(const_iterator it=node.begin();it!=node.end();++it) +#if defined(__GNUC__) && __GNUC__ < 4 +//workaround for GCC 3: + rhs.push_back(it->template as<T>()); +#else + rhs.push_back(it->as<T>()); +#endif + return true; + } + }; + + // std::pair + template<typename T, typename U> + struct convert<std::pair<T, U> > { + static Node encode(const std::pair<T, U>& rhs) { + Node node(NodeType::Sequence); + node.push_back(rhs.first); + node.push_back(rhs.second); + return node; + } + + static bool decode(const Node& node, std::pair<T, U>& rhs) { + if(!node.IsSequence()) + return false; + if (node.size() != 2) + return false; + +#if defined(__GNUC__) && __GNUC__ < 4 +//workaround for GCC 3: + rhs.first = node[0].template as<T>(); +#else + rhs.first = node[0].as<T>(); +#endif +#if defined(__GNUC__) && __GNUC__ < 4 +//workaround for GCC 3: + rhs.second = node[1].template as<U>(); +#else + rhs.second = node[1].as<U>(); +#endif + return true; + } + }; + + // binary + template<> + struct convert<Binary> { + static Node encode(const Binary& rhs) { + return Node(EncodeBase64(rhs.data(), rhs.size())); + } + + static bool decode(const Node& node, Binary& rhs) { + if(!node.IsScalar()) + return false; + + std::vector<unsigned char> data = DecodeBase64(node.Scalar()); + if(data.empty() && !node.Scalar().empty()) + return false; + + rhs.swap(data); + return true; + } + }; +} + +#endif // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/bool_type.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/bool_type.h new file mode 100644 index 00000000000..80ed9a4b37d --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/bool_type.h @@ -0,0 +1,26 @@ +#ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +namespace YAML +{ + namespace detail + { + struct unspecified_bool { + struct NOT_ALLOWED; + static void true_value(NOT_ALLOWED*) {} + }; + typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*); + } +} + +#define YAML_CPP_OPERATOR_BOOL()\ +operator YAML::detail::unspecified_bool_type() const\ +{\ + return this->operator!() ? 0 : &YAML::detail::unspecified_bool::true_value;\ +} + +#endif // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/impl.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/impl.h new file mode 100644 index 00000000000..ce5fd573f2c --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/impl.h @@ -0,0 +1,168 @@ +#ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/node/detail/node.h" +#include "yaml-cpp/node/detail/node_data.h" +#include <boost/type_traits.hpp> + +namespace YAML +{ + namespace detail + { + template<typename Key, typename Enable = void> + struct get_idx { + static node *get(const std::vector<node *>& /* sequence */, const Key& /* key */, shared_memory_holder /* pMemory */) { + return 0; + } + }; + + template<typename Key> + struct get_idx<Key, typename boost::enable_if_c<boost::is_unsigned<Key>::value && !boost::is_same<Key, bool>::value>::type> { + static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder /* pMemory */) { + return key < sequence.size() ? sequence[key] : 0; + } + + static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) { + if(key > sequence.size()) + return 0; + if(key == sequence.size()) + sequence.push_back(&pMemory->create_node()); + return sequence[key]; + } + }; + + template<typename Key> + struct get_idx<Key, typename boost::enable_if<boost::is_signed<Key> >::type> { + static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) { + return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0; + } + static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) { + return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0; + } + }; + + // indexing + template<typename Key> + inline node& node_data::get(const Key& key, shared_memory_holder pMemory) const + { + switch(m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + return pMemory->create_node(); + case NodeType::Sequence: + if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory)) + return *pNode; + return pMemory->create_node(); + case NodeType::Scalar: + throw BadSubscript(); + } + + for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) { + if(equals(*it->first, key, pMemory)) + return *it->second; + } + + return pMemory->create_node(); + } + + template<typename Key> + inline node& node_data::get(const Key& key, shared_memory_holder pMemory) + { + switch(m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + case NodeType::Sequence: + if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory)) { + m_type = NodeType::Sequence; + return *pNode; + } + + convert_to_map(pMemory); + break; + case NodeType::Scalar: + throw BadSubscript(); + } + + for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) { + if(equals(*it->first, key, pMemory)) + return *it->second; + } + + node& k = convert_to_node(key, pMemory); + node& v = pMemory->create_node(); + insert_map_pair(k, v); + return v; + } + + template<typename Key> + inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) + { + if(m_type != NodeType::Map) + return false; + + for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) { + if(equals(*it->first, key, pMemory)) { + m_map.erase(it); + return true; + } + } + + return false; + } + + // map + template<typename Key, typename Value> + inline void node_data::force_insert(const Key& key, const Value& value, shared_memory_holder pMemory) + { + switch(m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + case NodeType::Sequence: + convert_to_map(pMemory); + break; + case NodeType::Scalar: + throw BadInsert(); + } + + node& k = convert_to_node(key, pMemory); + node& v = convert_to_node(value, pMemory); + insert_map_pair(k, v); + } + + template<typename T> + inline bool node_data::equals(node& node, const T& rhs, shared_memory_holder pMemory) + { + T lhs; + if(convert<T>::decode(Node(node, pMemory), lhs)) + return lhs == rhs; + return false; + } + + inline bool node_data::equals(node& node, const char *rhs, shared_memory_holder pMemory) + { + return equals<std::string>(node, rhs, pMemory); + } + + template<typename T> + inline node& node_data::convert_to_node(const T& rhs, shared_memory_holder pMemory) + { + Node value = convert<T>::encode(rhs); + value.EnsureNodeExists(); + pMemory->merge(*value.m_pMemory); + return *value.m_pNode; + } + } +} + +#endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/iterator.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/iterator.h new file mode 100644 index 00000000000..dc699f4761d --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/iterator.h @@ -0,0 +1,64 @@ +#ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/detail/node_iterator.h" +#include <boost/iterator/iterator_adaptor.hpp> +#include <boost/utility.hpp> + +namespace YAML +{ + namespace detail + { + struct iterator_value; + + template<typename V> + class iterator_base: public boost::iterator_adaptor< + iterator_base<V>, + node_iterator, + V, + std::forward_iterator_tag, + V> + { + private: + template<typename> friend class iterator_base; + struct enabler {}; + typedef typename iterator_base::base_type base_type; + + public: + typedef typename iterator_base::value_type value_type; + + public: + iterator_base() {} + explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {} + + template<class W> + iterator_base(const iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()): iterator_base::iterator_adaptor_(rhs.base()), m_pMemory(rhs.m_pMemory) {} + + private: + friend class boost::iterator_core_access; + + void increment() { this->base_reference() = boost::next(this->base()); } + + value_type dereference() const { + const typename base_type::value_type& v = *this->base(); + if(v.pNode) + return value_type(Node(*v, m_pMemory)); + if(v.first && v.second) + return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory)); + return value_type(); + } + + private: + shared_memory_holder m_pMemory; + }; + } +} + +#endif // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/iterator_fwd.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/iterator_fwd.h new file mode 100644 index 00000000000..c4efb2c1fa6 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/iterator_fwd.h @@ -0,0 +1,27 @@ +#ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include <list> +#include <utility> +#include <vector> + +namespace YAML +{ + class node; + + namespace detail { + struct iterator_value; + template<typename V> class iterator_base; + } + + typedef detail::iterator_base<detail::iterator_value> iterator; + typedef detail::iterator_base<const detail::iterator_value> const_iterator; +} + +#endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/memory.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/memory.h new file mode 100644 index 00000000000..243a81a9661 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/memory.h @@ -0,0 +1,39 @@ +#ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/node/ptr.h" +#include <set> +#include <boost/shared_ptr.hpp> + +namespace YAML +{ + namespace detail + { + class memory { + public: + node& create_node(); + void merge(const memory& rhs); + + private: + typedef std::set<shared_node> Nodes; + Nodes m_nodes; + }; + + class memory_holder { + public: + memory_holder(): m_pMemory(new memory) {} + + node& create_node() { return m_pMemory->create_node(); } + void merge(memory_holder& rhs); + + private: + boost::shared_ptr<memory> m_pMemory; + }; + } +} + +#endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node.h new file mode 100644 index 00000000000..ce3a76d30ae --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node.h @@ -0,0 +1,130 @@ +#ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/type.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/detail/node_ref.h" +#include <set> +#include <boost/utility.hpp> + +namespace YAML +{ + namespace detail + { + class node: private boost::noncopyable + { + public: + node(): m_pRef(new node_ref) {} + + bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; } + const node_ref *ref() const { return m_pRef.get(); } + + bool is_defined() const { return m_pRef->is_defined(); } + NodeType::value type() const { return m_pRef->type(); } + + const std::string& scalar() const { return m_pRef->scalar(); } + const std::string& tag() const { return m_pRef->tag(); } + + void mark_defined() { + if(is_defined()) + return; + + m_pRef->mark_defined(); + for(nodes::iterator it=m_dependencies.begin();it!=m_dependencies.end();++it) + (*it)->mark_defined(); + m_dependencies.clear(); + } + + void add_dependency(node& rhs) { + if(is_defined()) + rhs.mark_defined(); + else + m_dependencies.insert(&rhs); + } + + void set_ref(const node& rhs) { + if(rhs.is_defined()) + mark_defined(); + m_pRef = rhs.m_pRef; + } + void set_data(const node& rhs) { + if(rhs.is_defined()) + mark_defined(); + m_pRef->set_data(*rhs.m_pRef); + } + + void set_type(NodeType::value type) { + if(type != NodeType::Undefined) + mark_defined(); + m_pRef->set_type(type); + } + void set_null() { + mark_defined(); + m_pRef->set_null(); + } + void set_scalar(const std::string& scalar) { + mark_defined(); + m_pRef->set_scalar(scalar); + } + void set_tag(const std::string& tag) { + mark_defined(); + m_pRef->set_tag(tag); + } + + // size/iterator + std::size_t size() const { return m_pRef->size(); } + + const_node_iterator begin() const { return static_cast<const node_ref&>(*m_pRef).begin(); } + node_iterator begin() { return m_pRef->begin(); } + + const_node_iterator end() const { return static_cast<const node_ref&>(*m_pRef).end(); } + node_iterator end() { return m_pRef->end(); } + + // sequence + void push_back(node& node, shared_memory_holder pMemory) { + m_pRef->push_back(node, pMemory); + node.add_dependency(*this); + } + void insert(node& key, node& value, shared_memory_holder pMemory) { + m_pRef->insert(key, value, pMemory); + key.add_dependency(*this); + value.add_dependency(*this); + } + + // indexing + template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); } + template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) { + node& value = m_pRef->get(key, pMemory); + value.add_dependency(*this); + return value; + } + template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); } + + node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); } + node& get(node& key, shared_memory_holder pMemory) { + node& value = m_pRef->get(key, pMemory); + key.add_dependency(*this); + value.add_dependency(*this); + return value; + } + bool remove(node& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); } + + // map + template<typename Key, typename Value> + void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory){ m_pRef->force_insert(key, value, pMemory); } + + private: + shared_node_ref m_pRef; + typedef std::set<node *> nodes; + nodes m_dependencies; + }; + } +} + +#endif // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_data.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_data.h new file mode 100644 index 00000000000..413da5fb1d9 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_data.h @@ -0,0 +1,110 @@ +#ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/iterator.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/type.h" +#include <boost/utility.hpp> +#include <list> +#include <utility> +#include <vector> + +namespace YAML +{ + namespace detail + { + class node_data: private boost::noncopyable + { + public: + node_data(); + + void mark_defined(); + void set_type(NodeType::value type); + void set_tag(const std::string& tag); + void set_null(); + void set_scalar(const std::string& scalar); + + bool is_defined() const { return m_isDefined; } + NodeType::value type() const { return m_isDefined ? m_type : NodeType::Undefined; } + const std::string& scalar() const { return m_scalar; } + const std::string& tag() const { return m_tag; } + + // size/iterator + std::size_t size() const; + + const_node_iterator begin() const; + node_iterator begin(); + + const_node_iterator end() const; + node_iterator end(); + + // sequence + void push_back(node& node, shared_memory_holder pMemory); + void insert(node& key, node& value, shared_memory_holder pMemory); + + // indexing + template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const; + template<typename Key> node& get(const Key& key, shared_memory_holder pMemory); + template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory); + + node& get(node& key, shared_memory_holder pMemory) const; + node& get(node& key, shared_memory_holder pMemory); + bool remove(node& key, shared_memory_holder pMemory); + + // map + template<typename Key, typename Value> + void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory); + + public: + static std::string empty_scalar; + + private: + void compute_seq_size() const; + void compute_map_size() const; + + void reset_sequence(); + void reset_map(); + + void insert_map_pair(node& key, node& value); + void convert_to_map(shared_memory_holder pMemory); + void convert_sequence_to_map(shared_memory_holder pMemory); + + template<typename T> + static bool equals(node& node, const T& rhs, shared_memory_holder pMemory); + static bool equals(node& node, const char *rhs, shared_memory_holder pMemory); + + template<typename T> + static node& convert_to_node(const T& rhs, shared_memory_holder pMemory); + + private: + bool m_isDefined; + NodeType::value m_type; + std::string m_tag; + + // scalar + std::string m_scalar; + + // sequence + typedef std::vector<node *> node_seq; + node_seq m_sequence; + + mutable std::size_t m_seqSize; + + // map + typedef std::map<node *, node *> node_map; + node_map m_map; + + typedef std::pair<node *, node *> kv_pair; + typedef std::list<kv_pair> kv_pairs; + mutable kv_pairs m_undefinedPairs; + }; + } +} + +#endif // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_iterator.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_iterator.h new file mode 100644 index 00000000000..294921b34aa --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_iterator.h @@ -0,0 +1,139 @@ +#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/ptr.h" +#include <boost/iterator/iterator_facade.hpp> +#include <boost/utility/enable_if.hpp> +#include <map> +#include <utility> +#include <vector> + +namespace YAML +{ + namespace detail + { + struct iterator_type { enum value { None, Sequence, Map }; }; + + template<typename V> + struct node_iterator_value: public std::pair<V*, V*> { + typedef std::pair<V*, V*> kv; + + node_iterator_value(): kv(), pNode(0) {} + explicit node_iterator_value(V& rhs): kv(), pNode(&rhs) {} + explicit node_iterator_value(V& key, V& value): kv(&key, &value), pNode(0) {} + + V& operator *() const { return *pNode; } + V& operator ->() const { return *pNode; } + + V *pNode; + }; + + typedef std::vector<node *> node_seq; + typedef std::map<node *, node *> node_map; + + template<typename V> + struct node_iterator_type { + typedef node_seq::iterator seq; + typedef node_map::iterator map; + }; + + template<typename V> + struct node_iterator_type<const V> { + typedef node_seq::const_iterator seq; + typedef node_map::const_iterator map; + }; + + + template<typename V> + class node_iterator_base: public boost::iterator_facade< + node_iterator_base<V>, + node_iterator_value<V>, + std::forward_iterator_tag, + node_iterator_value<V> > + { + private: + struct enabler {}; + + public: + typedef typename node_iterator_type<V>::seq SeqIter; + typedef typename node_iterator_type<V>::map MapIter; + typedef node_iterator_value<V> value_type; + + node_iterator_base(): m_type(iterator_type::None) {} + explicit node_iterator_base(SeqIter seqIt): m_type(iterator_type::Sequence), m_seqIt(seqIt) {} + explicit node_iterator_base(MapIter mapIt, MapIter mapEnd): m_type(iterator_type::Map), m_mapIt(mapIt), m_mapEnd(mapEnd) { + m_mapIt = increment_until_defined(m_mapIt); + } + + template<typename W> + node_iterator_base(const node_iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()) + : m_type(rhs.m_type), m_seqIt(rhs.m_seqIt), m_mapIt(rhs.m_mapIt), m_mapEnd(rhs.m_mapEnd) {} + + private: + friend class boost::iterator_core_access; + template<typename> friend class node_iterator_base; + + template<typename W> + bool equal(const node_iterator_base<W>& rhs) const { + if(m_type != rhs.m_type) + return false; + + switch(m_type) { + case iterator_type::None: return true; + case iterator_type::Sequence: return m_seqIt == rhs.m_seqIt; + case iterator_type::Map: return m_mapIt == rhs.m_mapIt; + } + return true; + } + + void increment() { + switch(m_type) { + case iterator_type::None: break; + case iterator_type::Sequence: + ++m_seqIt; + break; + case iterator_type::Map: + ++m_mapIt; + m_mapIt = increment_until_defined(m_mapIt); + break; + } + } + + value_type dereference() const { + switch(m_type) { + case iterator_type::None: return value_type(); + case iterator_type::Sequence: return value_type(**m_seqIt); + case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second); + } + return value_type(); + } + + MapIter increment_until_defined(MapIter it) { + while(it != m_mapEnd && !is_defined(it)) + ++it; + return it; + } + + bool is_defined(MapIter it) const { + return it->first->is_defined() && it->second->is_defined(); + } + + private: + typename iterator_type::value m_type; + + SeqIter m_seqIt; + MapIter m_mapIt, m_mapEnd; + }; + + typedef node_iterator_base<node> node_iterator; + typedef node_iterator_base<const node> const_node_iterator; + } +} + +#endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_ref.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_ref.h new file mode 100644 index 00000000000..64cdb9868ca --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/detail/node_ref.h @@ -0,0 +1,69 @@ +#ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/type.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/detail/node_data.h" +#include <boost/utility.hpp> + +namespace YAML +{ + namespace detail + { + class node_ref: private boost::noncopyable + { + public: + node_ref(): m_pData(new node_data) {} + + bool is_defined() const { return m_pData->is_defined(); } + 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(); } + + void mark_defined() { m_pData->mark_defined(); } + void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; } + + 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(); } + void set_scalar(const std::string& scalar) { m_pData->set_scalar(scalar); } + + // size/iterator + std::size_t size() const { return m_pData->size(); } + + const_node_iterator begin() const { return static_cast<const node_data&>(*m_pData).begin(); } + node_iterator begin() {return m_pData->begin(); } + + const_node_iterator end() const { return static_cast<const node_data&>(*m_pData).end(); } + node_iterator end() {return m_pData->end(); } + + // sequence + void push_back(node& node, shared_memory_holder pMemory) { m_pData->push_back(node, pMemory); } + void insert(node& key, node& value, shared_memory_holder pMemory) { m_pData->insert(key, value, pMemory); } + + // indexing + template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); } + template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); } + template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); } + + node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); } + node& get(node& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); } + bool remove(node& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); } + + // map + template<typename Key, typename Value> + void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory) { m_pData->force_insert(key, value, pMemory); } + + private: + shared_node_data m_pData; + }; + } +} + +#endif // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/emit.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/emit.h new file mode 100644 index 00000000000..7abf80b12c3 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/emit.h @@ -0,0 +1,23 @@ +#ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include <string> +#include <iosfwd> + +namespace YAML +{ + class Emitter; + class Node; + + Emitter& operator << (Emitter& out, const Node& node); + std::ostream& operator << (std::ostream& out, const Node& node); + + std::string Dump(const Node& node); +} + +#endif // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/impl.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/impl.h new file mode 100644 index 00000000000..41c2fcd3105 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/impl.h @@ -0,0 +1,451 @@ +#ifndef NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/iterator.h" +#include "yaml-cpp/node/detail/memory.h" +#include "yaml-cpp/node/detail/node.h" +#include "yaml-cpp/exceptions.h" +#include <string> + +namespace YAML +{ + inline Node::Node(): m_isValid(true), m_pNode(NULL) + { + } + + inline Node::Node(NodeType::value type): m_isValid(true), m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node()) + { + m_pNode->set_type(type); + } + + template<typename T> + inline Node::Node(const T& rhs): m_isValid(true), m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node()) + { + Assign(rhs); + } + + inline Node::Node(const detail::iterator_value& rhs): m_isValid(rhs.m_isValid), m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode) + { + } + + inline Node::Node(const Node& rhs): m_isValid(rhs.m_isValid), m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode) + { + } + + inline Node::Node(Zombie): m_isValid(false), m_pNode(NULL) + { + } + + inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory): m_isValid(true), m_pMemory(pMemory), m_pNode(&node) + { + } + + inline Node::~Node() + { + } + + inline void Node::EnsureNodeExists() const + { + if(!m_isValid) + throw InvalidNode(); + if(!m_pNode) { + m_pMemory.reset(new detail::memory_holder); + m_pNode = &m_pMemory->create_node(); + m_pNode->set_null(); + } + } + + inline bool Node::IsDefined() const + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? m_pNode->is_defined() : true; + } + + inline NodeType::value Node::Type() const + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? m_pNode->type() : NodeType::Null; + } + + // access + + // template helpers + template<typename T, typename S> + struct as_if { + explicit as_if(const Node& node_): node(node_) {} + const Node& node; + + const T operator()(const S& fallback) const { + if(!node.m_pNode) + return fallback; + + T t; + if(convert<T>::decode(node, t)) + return t; + return fallback; + } + }; + + template<typename S> + struct as_if<std::string, S> { + explicit as_if(const Node& node_): node(node_) {} + const Node& node; + + const std::string operator()(const S& fallback) const { + if(node.Type() != NodeType::Scalar) + return fallback; + return node.Scalar(); + } + }; + + template<typename T> + struct as_if<T, void> { + explicit as_if(const Node& node_): node(node_) {} + const Node& node; + + const T operator()() const { + if(!node.m_pNode) + throw TypedBadConversion<T>(); + + T t; + if(convert<T>::decode(node, t)) + return t; + throw TypedBadConversion<T>(); + } + }; + + template<> + struct as_if<std::string, void> { + explicit as_if(const Node& node_): node(node_) {} + const Node& node; + + const std::string operator()() const { + if(node.Type() != NodeType::Scalar) + throw TypedBadConversion<std::string>(); + return node.Scalar(); + } + }; + + // access functions + template<typename T> + inline const T Node::as() const + { + if(!m_isValid) + throw InvalidNode(); + return as_if<T, void>(*this)(); + } + + template<typename T, typename S> + inline const T Node::as(const S& fallback) const + { + if(!m_isValid) + throw InvalidNode(); + return as_if<T, S>(*this)(fallback); + } + + inline const std::string& Node::Scalar() const + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar; + } + + inline const std::string& Node::Tag() const + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar; + } + + inline void Node::SetTag(const std::string& tag) + { + if(!m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + m_pNode->set_tag(tag); + } + + // assignment + inline bool Node::is(const Node& rhs) const + { + if(!m_isValid || !rhs.m_isValid) + throw InvalidNode(); + if(!m_pNode || !rhs.m_pNode) + return false; + return m_pNode->is(*rhs.m_pNode); + } + + template<typename T> + inline Node& Node::operator=(const T& rhs) + { + if(!m_isValid) + throw InvalidNode(); + Assign(rhs); + return *this; + } + + inline void Node::reset(const YAML::Node& rhs) + { + if(!m_isValid || !rhs.m_isValid) + throw InvalidNode(); + m_pMemory = rhs.m_pMemory; + m_pNode = rhs.m_pNode; + } + + template<typename T> + inline void Node::Assign(const T& rhs) + { + if(!m_isValid) + throw InvalidNode(); + AssignData(convert<T>::encode(rhs)); + } + + template<> + inline void Node::Assign(const std::string& rhs) + { + if(!m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + m_pNode->set_scalar(rhs); + } + + inline void Node::Assign(const char *rhs) + { + if(!m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + m_pNode->set_scalar(rhs); + } + + inline void Node::Assign(char *rhs) + { + if(!m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + m_pNode->set_scalar(rhs); + } + + inline Node& Node::operator=(const Node& rhs) + { + if(!m_isValid || !rhs.m_isValid) + throw InvalidNode(); + if(is(rhs)) + return *this; + AssignNode(rhs); + return *this; + } + + inline void Node::AssignData(const Node& rhs) + { + if(!m_isValid || !rhs.m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + rhs.EnsureNodeExists(); + + m_pNode->set_data(*rhs.m_pNode); + m_pMemory->merge(*rhs.m_pMemory); + } + + inline void Node::AssignNode(const Node& rhs) + { + if(!m_isValid || !rhs.m_isValid) + throw InvalidNode(); + rhs.EnsureNodeExists(); + + if(!m_pNode) { + m_pNode = rhs.m_pNode; + m_pMemory = rhs.m_pMemory; + return; + } + + m_pNode->set_ref(*rhs.m_pNode); + m_pMemory->merge(*rhs.m_pMemory); + m_pNode = rhs.m_pNode; + } + + // size/iterator + inline std::size_t Node::size() const + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? m_pNode->size() : 0; + } + + inline const_iterator Node::begin() const + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory) : const_iterator(); + } + + inline iterator Node::begin() + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator(); + } + + inline const_iterator Node::end() const + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator(); + } + + inline iterator Node::end() + { + if(!m_isValid) + throw InvalidNode(); + return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator(); + } + + // sequence + template<typename T> + inline void Node::push_back(const T& rhs) + { + if(!m_isValid) + throw InvalidNode(); + push_back(Node(rhs)); + } + + inline void Node::push_back(const Node& rhs) + { + if(!m_isValid || !rhs.m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + rhs.EnsureNodeExists(); + + m_pNode->push_back(*rhs.m_pNode, m_pMemory); + m_pMemory->merge(*rhs.m_pMemory); + } + + // helpers for indexing + namespace detail { + template<typename T> + struct to_value_t { + explicit to_value_t(const T& t_): t(t_) {} + const T& t; + typedef const T& return_type; + + const T& operator()() const { return t; } + }; + + template<> + struct to_value_t<const char*> { + explicit to_value_t(const char *t_): t(t_) {} + const char *t; + typedef std::string return_type; + + const std::string operator()() const { return t; } + }; + + template<> + struct to_value_t<char*> { + explicit to_value_t(char *t_): t(t_) {} + const char *t; + typedef std::string return_type; + + const std::string operator()() const { return t; } + }; + + template<std::size_t N> + struct to_value_t<char [N]> { + explicit to_value_t(const char *t_): t(t_) {} + const char *t; + typedef std::string return_type; + + const std::string operator()() const { return t; } + }; + + // converts C-strings to std::strings so they can be copied + template<typename T> + inline typename to_value_t<T>::return_type to_value(const T& t) { + return to_value_t<T>(t)(); + } + } + + // indexing + template<typename Key> + inline const Node Node::operator[](const Key& key) const + { + if(!m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + detail::node& value = static_cast<const detail::node&>(*m_pNode).get(detail::to_value(key), m_pMemory); + return Node(value, m_pMemory); + } + + template<typename Key> + inline Node Node::operator[](const Key& key) + { + if(!m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory); + return Node(value, m_pMemory); + } + + template<typename Key> + inline bool Node::remove(const Key& key) + { + if(!m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + return m_pNode->remove(detail::to_value(key), m_pMemory); + } + + inline const Node Node::operator[](const Node& key) const + { + if(!m_isValid || !key.m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + key.EnsureNodeExists(); + detail::node& value = static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory); + return Node(value, m_pMemory); + } + + inline Node Node::operator[](const Node& key) + { + if(!m_isValid || !key.m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + key.EnsureNodeExists(); + detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory); + return Node(value, m_pMemory); + } + + inline bool Node::remove(const Node& key) + { + if(!m_isValid || !key.m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + key.EnsureNodeExists(); + return m_pNode->remove(*key.m_pNode, m_pMemory); + } + + // map + template<typename Key, typename Value> + inline void Node::force_insert(const Key& key, const Value& value) + { + if(!m_isValid) + throw InvalidNode(); + EnsureNodeExists(); + m_pNode->force_insert(detail::to_value(key), detail::to_value(value), m_pMemory); + } + + // free functions + inline bool operator==(const Node& lhs, const Node& rhs) + { + return lhs.is(rhs); + } +} + +#endif // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/iterator.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/iterator.h new file mode 100644 index 00000000000..98c8851cfcd --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/iterator.h @@ -0,0 +1,28 @@ +#ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/detail/iterator_fwd.h" +#include "yaml-cpp/node/detail/iterator.h" +#include <list> +#include <utility> +#include <vector> + +namespace YAML +{ + namespace detail { + struct iterator_value: public Node, std::pair<Node, Node> { + iterator_value() {} + explicit iterator_value(const Node& rhs): Node(rhs), std::pair<Node, Node>(Node(Node::ZombieNode), Node(Node::ZombieNode)) {} + explicit iterator_value(const Node& key, const Node& value): Node(Node::ZombieNode), std::pair<Node, Node>(key, value) {} + }; + } +} + +#endif // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/node.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/node.h new file mode 100644 index 00000000000..b9498509c0e --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/node.h @@ -0,0 +1,116 @@ +#ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/type.h" +#include "yaml-cpp/node/detail/iterator_fwd.h" +#include "yaml-cpp/node/detail/bool_type.h" +#include <stdexcept> + +namespace YAML +{ + class Node + { + public: + friend class NodeBuilder; + friend class NodeEvents; + friend struct detail::iterator_value; + friend class detail::node_data; + template<typename> friend class detail::iterator_base; + template<typename T, typename S> friend struct as_if; + + typedef YAML::iterator iterator; + typedef YAML::const_iterator const_iterator; + + Node(); + explicit Node(NodeType::value type); + template<typename T> explicit Node(const T& rhs); + explicit Node(const detail::iterator_value& rhs); + Node(const Node& rhs); + ~Node(); + + NodeType::value Type() const; + bool IsDefined() const; + bool IsNull() const { return Type() == NodeType::Null; } + bool IsScalar() const { return Type() == NodeType::Scalar; } + bool IsSequence() const { return Type() == NodeType::Sequence; } + bool IsMap() const { return Type() == NodeType::Map; } + + // bool conversions + YAML_CPP_OPERATOR_BOOL(); + bool operator!() const { return !IsDefined(); } + + // access + template<typename T> const T as() const; + template<typename T, typename S> const T as(const S& fallback) const; + const std::string& Scalar() const; + const std::string& Tag() const; + void SetTag(const std::string& tag); + + // assignment + bool is(const Node& rhs) const; + template<typename T> Node& operator=(const T& rhs); + Node& operator=(const Node& rhs); + void reset(const Node& rhs = Node()); + + // size/iterator + std::size_t size() const; + + const_iterator begin() const; + iterator begin(); + + const_iterator end() const; + iterator end(); + + // sequence + template<typename T> void push_back(const T& rhs); + void push_back(const Node& rhs); + + // indexing + template<typename Key> const Node operator[](const Key& key) const; + template<typename Key> Node operator[](const Key& key); + template<typename Key> bool remove(const Key& key); + + const Node operator[](const Node& key) const; + Node operator[](const Node& key); + bool remove(const Node& key); + + // map + template<typename Key, typename Value> + void force_insert(const Key& key, const Value& value); + + private: + enum Zombie { ZombieNode }; + explicit Node(Zombie); + explicit Node(detail::node& node, detail::shared_memory_holder pMemory); + + void EnsureNodeExists() const; + + template<typename T> void Assign(const T& rhs); + void Assign(const char *rhs); + void Assign(char *rhs); + + void AssignData(const Node& rhs); + void AssignNode(const Node& rhs); + + private: + bool m_isValid; + mutable detail::shared_memory_holder m_pMemory; + mutable detail::node *m_pNode; + }; + + bool operator==(const Node& lhs, const Node& rhs); + + Node Clone(const Node& node); + + template<typename T> + struct convert; +} + +#endif // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/parse.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/parse.h new file mode 100644 index 00000000000..82dbdc1bb21 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/parse.h @@ -0,0 +1,28 @@ +#ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include <iosfwd> +#include <string> +#include <vector> + +namespace YAML +{ + class Node; + + Node Load(const std::string& input); + Node Load(const char *input); + Node Load(std::istream& input); + Node LoadFile(const std::string& filename); + + std::vector<Node> LoadAll(const std::string& input); + std::vector<Node> LoadAll(const char *input); + std::vector<Node> LoadAll(std::istream& input); + std::vector<Node> LoadAllFromFile(const std::string& filename); +} + +#endif // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/ptr.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/ptr.h new file mode 100644 index 00000000000..316dbd26b6a --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/ptr.h @@ -0,0 +1,29 @@ +#ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include <boost/shared_ptr.hpp> + +namespace YAML +{ + namespace detail { + class node; + class node_ref; + class node_data; + class memory; + class memory_holder; + + typedef boost::shared_ptr<node> shared_node; + typedef boost::shared_ptr<node_ref> shared_node_ref; + typedef boost::shared_ptr<node_data> shared_node_data; + typedef boost::shared_ptr<memory_holder> shared_memory_holder; + typedef boost::shared_ptr<memory> shared_memory; + } +} + +#endif // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/type.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/type.h new file mode 100644 index 00000000000..5ac8041c852 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/node/type.h @@ -0,0 +1,14 @@ +#ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +namespace YAML +{ + struct NodeType { enum value { Undefined, Null, Scalar, Sequence, Map }; }; +} + +#endif // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/noncopyable.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/noncopyable.h new file mode 100644 index 00000000000..8e61e4338f8 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/noncopyable.h @@ -0,0 +1,25 @@ +#ifndef NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" + +namespace YAML +{ + // this is basically boost::noncopyable + class YAML_CPP_API noncopyable + { + protected: + noncopyable() {} + ~noncopyable() {} + + private: + noncopyable(const noncopyable&); + const noncopyable& operator = (const noncopyable&); + }; +} + +#endif // NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/null.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/null.h new file mode 100644 index 00000000000..711f18c3359 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/null.h @@ -0,0 +1,25 @@ +#ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" + +namespace YAML +{ + class Node; + + struct YAML_CPP_API _Null {}; + inline bool operator == (const _Null&, const _Null&) { return true; } + inline bool operator != (const _Null&, const _Null&) { return false; } + + YAML_CPP_API bool IsNull(const Node& node); // old API only + + extern YAML_CPP_API _Null Null; +} + +#endif // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/ostream_wrapper.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/ostream_wrapper.h new file mode 100644 index 00000000000..a6d96c57023 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/ostream_wrapper.h @@ -0,0 +1,69 @@ +#ifndef OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <string> +#include <vector> + +namespace YAML +{ + class ostream_wrapper + { + public: + ostream_wrapper(); + explicit ostream_wrapper(std::ostream& stream); + ~ostream_wrapper(); + + void write(const std::string& str); + void write(const char *str, std::size_t size); + + void set_comment() { m_comment = true; } + + const char *str() const { + if(m_pStream) { + return 0; + } else { + m_buffer[m_pos] = '\0'; + return &m_buffer[0]; + } + } + + std::size_t row() const { return m_row; } + std::size_t col() const { return m_col; } + std::size_t pos() const { return m_pos; } + bool comment() const { return m_comment; } + + private: + void update_pos(char ch); + + private: + mutable std::vector<char> m_buffer; + std::ostream *m_pStream; + + std::size_t m_pos; + std::size_t m_row, m_col; + bool m_comment; + }; + + template<std::size_t N> + inline ostream_wrapper& operator << (ostream_wrapper& stream, const char (&str)[N]) { + stream.write(str, N-1); + return stream; + } + + inline ostream_wrapper& operator << (ostream_wrapper& stream, const std::string& str) { + stream.write(str); + return stream; + } + + inline ostream_wrapper& operator << (ostream_wrapper& stream, char ch) { + stream.write(&ch, 1); + return stream; + } +} + +#endif // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/parser.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/parser.h new file mode 100644 index 00000000000..8ec926be188 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/parser.h @@ -0,0 +1,47 @@ +#ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/noncopyable.h" +#include <ios> +#include <memory> + +namespace YAML +{ + struct Directives; + struct Token; + class EventHandler; + class Scanner; + + class YAML_CPP_API Parser: private noncopyable + { + public: + Parser(); + Parser(std::istream& in); + ~Parser(); + + operator bool() const; + + void Load(std::istream& in); + bool HandleNextDocument(EventHandler& eventHandler); + + void PrintTokens(std::ostream& out); + + private: + void ParseDirectives(); + void HandleDirective(const Token& token); + void HandleYamlDirective(const Token& token); + void HandleTagDirective(const Token& token); + + private: + std::auto_ptr<Scanner> m_pScanner; + std::auto_ptr<Directives> m_pDirectives; + }; +} + +#endif // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/stlemitter.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/stlemitter.h new file mode 100644 index 00000000000..f8ff20ea873 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/stlemitter.h @@ -0,0 +1,51 @@ +#ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <vector> +#include <list> +#include <set> +#include <map> + +namespace YAML +{ + template<typename Seq> + inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) { + emitter << BeginSeq; + for(typename Seq::const_iterator it=seq.begin();it!=seq.end();++it) + emitter << *it; + emitter << EndSeq; + return emitter; + } + + template<typename T> + inline Emitter& operator << (Emitter& emitter, const std::vector<T>& v) { + return EmitSeq(emitter, v); + } + + template<typename T> + inline Emitter& operator << (Emitter& emitter, const std::list<T>& v) { + return EmitSeq(emitter, v); + } + + template<typename T> + inline Emitter& operator << (Emitter& emitter, const std::set<T>& v) { + return EmitSeq(emitter, v); + } + + template <typename K, typename V> + inline Emitter& operator << (Emitter& emitter, const std::map<K, V>& m) { + typedef typename std::map <K, V> map; + emitter << BeginMap; + for(typename map::const_iterator it=m.begin();it!=m.end();++it) + emitter << Key << it->first << Value << it->second; + emitter << EndMap; + return emitter; + } +} + +#endif // STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/traits.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/traits.h new file mode 100644 index 00000000000..09eead44075 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/traits.h @@ -0,0 +1,57 @@ +#ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +namespace YAML +{ + template <typename> + struct is_numeric { enum { value = false }; }; + + template <> struct is_numeric <char> { enum { value = true }; }; + template <> struct is_numeric <unsigned char> { enum { value = true }; }; + template <> struct is_numeric <int> { enum { value = true }; }; + template <> struct is_numeric <unsigned int> { enum { value = true }; }; + template <> struct is_numeric <long int> { enum { value = true }; }; + template <> struct is_numeric <unsigned long int> { enum { value = true }; }; + template <> struct is_numeric <short int> { enum { value = true }; }; + template <> struct is_numeric <unsigned short int> { enum { value = true }; }; +#if defined(_MSC_VER) && (_MSC_VER < 1310) + template <> struct is_numeric <__int64> { enum { value = true }; }; + template <> struct is_numeric <unsigned __int64> { enum { value = true }; }; +#else + template <> struct is_numeric <long long> { enum { value = true }; }; + template <> struct is_numeric <unsigned long long> { enum { value = true }; }; +#endif + template <> struct is_numeric <float> { enum { value = true }; }; + template <> struct is_numeric <double> { enum { value = true }; }; + template <> struct is_numeric <long double> { enum { value = true }; }; + + template <bool, class T = void> + struct enable_if_c { + typedef T type; + }; + + template <class T> + struct enable_if_c<false, T> {}; + + template <class Cond, class T = void> + struct enable_if : public enable_if_c<Cond::value, T> {}; + + template <bool, class T = void> + struct disable_if_c { + typedef T type; + }; + + template <class T> + struct disable_if_c<true, T> {}; + + template <class Cond, class T = void> + struct disable_if : public disable_if_c<Cond::value, T> {}; +} + +#endif // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/yaml.h b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/yaml.h new file mode 100644 index 00000000000..4e634087ed8 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/include/yaml-cpp/yaml.h @@ -0,0 +1,21 @@ +#ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/parser.h" +#include "yaml-cpp/emitter.h" +#include "yaml-cpp/stlemitter.h" +#include "yaml-cpp/exceptions.h" + +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/impl.h" +#include "yaml-cpp/node/convert.h" +#include "yaml-cpp/node/iterator.h" +#include "yaml-cpp/node/detail/impl.h" +#include "yaml-cpp/node/parse.h" +#include "yaml-cpp/node/emit.h" + +#endif // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/license.txt b/src/third_party/yaml-cpp-0.5.1/license.txt new file mode 100644 index 00000000000..5bd9e1a12e1 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/license.txt @@ -0,0 +1,19 @@ +Copyright (c) 2008 Jesse Beder. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/src/third_party/yaml-cpp-0.5.1/src/binary.cpp b/src/third_party/yaml-cpp-0.5.1/src/binary.cpp new file mode 100644 index 00000000000..62a60324c8c --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/binary.cpp @@ -0,0 +1,93 @@ +#include "yaml-cpp/binary.h" + +namespace YAML +{ + static const char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + std::string EncodeBase64(const unsigned char *data, std::size_t size) + { + const char PAD = '='; + + std::string ret; + ret.resize(4 * size / 3 + 3); + char *out = &ret[0]; + + std::size_t chunks = size / 3; + std::size_t remainder = size % 3; + + for(std::size_t i=0;i<chunks;i++, data += 3) { + *out++ = encoding[data[0] >> 2]; + *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)]; + *out++ = encoding[((data[1] & 0xf) << 2) | (data[2] >> 6)]; + *out++ = encoding[data[2] & 0x3f]; + } + + switch(remainder) { + case 0: + break; + case 1: + *out++ = encoding[data[0] >> 2]; + *out++ = encoding[((data[0] & 0x3) << 4)]; + *out++ = PAD; + *out++ = PAD; + break; + case 2: + *out++ = encoding[data[0] >> 2]; + *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)]; + *out++ = encoding[((data[1] & 0xf) << 2)]; + *out++ = PAD; + break; + } + + ret.resize(out - &ret[0]); + return ret; + } + + static const unsigned char decoding[] = { + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255, 0,255,255, + 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255, + 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + }; + + std::vector<unsigned char> DecodeBase64(const std::string& input) + { + typedef std::vector<unsigned char> ret_type; + if(input.empty()) + return ret_type(); + + ret_type ret(3 * input.size() / 4 + 1); + unsigned char *out = &ret[0]; + + unsigned value = 0; + for(std::size_t i=0;i<input.size();i++) { + unsigned char d = decoding[static_cast<unsigned>(input[i])]; + if(d == 255) + return ret_type(); + + value = (value << 6) | d; + if(i % 4 == 3) { + *out++ = value >> 16; + if(i > 0 && input[i - 1] != '=') + *out++ = value >> 8; + if(input[i] != '=') + *out++ = value; + } + } + + ret.resize(out - &ret[0]); + return ret; + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/collectionstack.h b/src/third_party/yaml-cpp-0.5.1/src/collectionstack.h new file mode 100644 index 00000000000..4a986bc9826 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/collectionstack.h @@ -0,0 +1,35 @@ +#ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <stack> +#include <cassert> + +namespace YAML +{ + struct CollectionType { + enum value { None, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap }; + }; + + class CollectionStack + { + public: + CollectionType::value GetCurCollectionType() const { + if(collectionStack.empty()) + return CollectionType::None; + return collectionStack.top(); + } + + void PushCollectionType(CollectionType::value type) { collectionStack.push(type); } + void PopCollectionType(CollectionType::value type) { assert(type == GetCurCollectionType()); collectionStack.pop(); } + + private: + std::stack<CollectionType::value> collectionStack; + }; +} + +#endif // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/convert.cpp b/src/third_party/yaml-cpp-0.5.1/src/convert.cpp new file mode 100644 index 00000000000..dc715f71489 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/convert.cpp @@ -0,0 +1,83 @@ +#include "yaml-cpp/node/convert.h" +#include "yaml-cpp/node/impl.h" +#include <algorithm> + +namespace +{ + // we're not gonna mess with the mess that is all the isupper/etc. functions + bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; } + bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; } + char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; } + + std::string tolower(const std::string& str) + { + std::string s(str); + std::transform(s.begin(), s.end(), s.begin(), ToLower); + return s; + } + + template <typename T> + bool IsEntirely(const std::string& str, T func) + { + for(std::size_t i=0;i<str.size();i++) + if(!func(str[i])) + return false; + + return true; + } + + // IsFlexibleCase + // . Returns true if 'str' is: + // . UPPERCASE + // . lowercase + // . Capitalized + bool IsFlexibleCase(const std::string& str) + { + if(str.empty()) + return true; + + if(IsEntirely(str, IsLower)) + return true; + + bool firstcaps = IsUpper(str[0]); + std::string rest = str.substr(1); + return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper)); + } +} + +namespace YAML +{ + bool convert<bool>::decode(const Node& node, bool& rhs) { + if(!node.IsScalar()) + return false; + + // we can't use iostream bool extraction operators as they don't + // recognize all possible values in the table below (taken from + // http://yaml.org/type/bool.html) + static const struct { + std::string truename, falsename; + } names[] = { + { "y", "n" }, + { "yes", "no" }, + { "true", "false" }, + { "on", "off" }, + }; + + if(!IsFlexibleCase(node.Scalar())) + return false; + + for(unsigned i=0;i<sizeof(names)/sizeof(names[0]);i++) { + if(names[i].truename == tolower(node.Scalar())) { + rhs = true; + return true; + } + + if(names[i].falsename == tolower(node.Scalar())) { + rhs = false; + return true; + } + } + + return false; + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/directives.cpp b/src/third_party/yaml-cpp-0.5.1/src/directives.cpp new file mode 100644 index 00000000000..faf1483bd2e --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/directives.cpp @@ -0,0 +1,24 @@ +#include "directives.h" + +namespace YAML +{ + Directives::Directives() + { + // version + version.isDefault = true; + version.major = 1; + version.minor = 2; + } + + const std::string Directives::TranslateTagHandle(const std::string& handle) const + { + std::map <std::string, std::string>::const_iterator it = tags.find(handle); + if(it == tags.end()) { + if(handle == "!!") + return "tag:yaml.org,2002:"; + return handle; + } + + return it->second; + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/directives.h b/src/third_party/yaml-cpp-0.5.1/src/directives.h new file mode 100644 index 00000000000..a3308f72e59 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/directives.h @@ -0,0 +1,29 @@ +#ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <string> +#include <map> + +namespace YAML +{ + struct Version { + bool isDefault; + int major, minor; + }; + + struct Directives { + Directives(); + + const std::string TranslateTagHandle(const std::string& handle) const; + + Version version; + std::map<std::string, std::string> tags; + }; +} + +#endif // DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/emit.cpp b/src/third_party/yaml-cpp-0.5.1/src/emit.cpp new file mode 100644 index 00000000000..1f0a647d627 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/emit.cpp @@ -0,0 +1,29 @@ +#include "yaml-cpp/node/emit.h" +#include "yaml-cpp/emitfromevents.h" +#include "yaml-cpp/emitter.h" +#include "nodeevents.h" + +namespace YAML +{ + Emitter& operator << (Emitter& out, const Node& node) + { + EmitFromEvents emitFromEvents(out); + NodeEvents events(node); + events.Emit(emitFromEvents); + return out; + } + + std::ostream& operator << (std::ostream& out, const Node& node) + { + Emitter emitter(out); + emitter << node; + return out; + } + + std::string Dump(const Node& node) + { + Emitter emitter; + emitter << node; + return emitter.c_str(); + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/emitfromevents.cpp b/src/third_party/yaml-cpp-0.5.1/src/emitfromevents.cpp new file mode 100644 index 00000000000..49fc10b29e3 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/emitfromevents.cpp @@ -0,0 +1,105 @@ +#include "yaml-cpp/emitfromevents.h" +#include "yaml-cpp/emitter.h" +#include "yaml-cpp/null.h" +#include <cassert> +#include <sstream> + +namespace { + std::string ToString(YAML::anchor_t anchor) { + std::stringstream stream; + stream << anchor; + return stream.str(); + } +} + +namespace YAML +{ + EmitFromEvents::EmitFromEvents(Emitter& emitter): m_emitter(emitter) + { + } + + void EmitFromEvents::OnDocumentStart(const Mark&) + { + } + + void EmitFromEvents::OnDocumentEnd() + { + } + + void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) + { + BeginNode(); + EmitProps("", anchor); + m_emitter << Null; + } + + void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor) + { + BeginNode(); + m_emitter << Alias(ToString(anchor)); + } + + void EmitFromEvents::OnScalar(const Mark&, const std::string& tag, anchor_t anchor, const std::string& value) + { + BeginNode(); + EmitProps(tag, anchor); + m_emitter << value; + } + + void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag, anchor_t anchor) + { + BeginNode(); + EmitProps(tag, anchor); + m_emitter << BeginSeq; + m_stateStack.push(State::WaitingForSequenceEntry); + } + + void EmitFromEvents::OnSequenceEnd() + { + m_emitter << EndSeq; + assert(m_stateStack.top() == State::WaitingForSequenceEntry); + m_stateStack.pop(); + } + + void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag, anchor_t anchor) + { + BeginNode(); + EmitProps(tag, anchor); + m_emitter << BeginMap; + m_stateStack.push(State::WaitingForKey); + } + + void EmitFromEvents::OnMapEnd() + { + m_emitter << EndMap; + assert(m_stateStack.top() == State::WaitingForKey); + m_stateStack.pop(); + } + + void EmitFromEvents::BeginNode() + { + if(m_stateStack.empty()) + return; + + switch(m_stateStack.top()) { + case State::WaitingForKey: + m_emitter << Key; + m_stateStack.top() = State::WaitingForValue; + break; + case State::WaitingForValue: + m_emitter << Value; + m_stateStack.top() = State::WaitingForKey; + break; + default: + break; + } + } + + void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) + { + if(!tag.empty() && tag != "?") + m_emitter << VerbatimTag(tag); + if(anchor) + m_emitter << Anchor(ToString(anchor)); + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/emitter.cpp b/src/third_party/yaml-cpp-0.5.1/src/emitter.cpp new file mode 100644 index 00000000000..8a5a7069c85 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/emitter.cpp @@ -0,0 +1,951 @@ +#include "yaml-cpp/emitter.h" +#include "emitterstate.h" +#include "emitterutils.h" +#include "indentation.h" +#include "yaml-cpp/exceptions.h" +#include <sstream> + +namespace YAML +{ + Emitter::Emitter(): m_pState(new EmitterState) + { + } + + Emitter::Emitter(std::ostream& stream): m_pState(new EmitterState), m_stream(stream) + { + } + + Emitter::~Emitter() + { + } + + const char *Emitter::c_str() const + { + return m_stream.str(); + } + + std::size_t Emitter::size() const + { + return m_stream.pos(); + } + + // state checking + bool Emitter::good() const + { + return m_pState->good(); + } + + const std::string Emitter::GetLastError() const + { + return m_pState->GetLastError(); + } + + // global setters + bool Emitter::SetOutputCharset(EMITTER_MANIP value) + { + return m_pState->SetOutputCharset(value, FmtScope::Global); + } + + bool Emitter::SetStringFormat(EMITTER_MANIP value) + { + return m_pState->SetStringFormat(value, FmtScope::Global); + } + + bool Emitter::SetBoolFormat(EMITTER_MANIP value) + { + bool ok = false; + if(m_pState->SetBoolFormat(value, FmtScope::Global)) + ok = true; + if(m_pState->SetBoolCaseFormat(value, FmtScope::Global)) + ok = true; + if(m_pState->SetBoolLengthFormat(value, FmtScope::Global)) + ok = true; + return ok; + } + + bool Emitter::SetIntBase(EMITTER_MANIP value) + { + return m_pState->SetIntFormat(value, FmtScope::Global); + } + + bool Emitter::SetSeqFormat(EMITTER_MANIP value) + { + return m_pState->SetFlowType(GroupType::Seq, value, FmtScope::Global); + } + + bool Emitter::SetMapFormat(EMITTER_MANIP value) + { + bool ok = false; + if(m_pState->SetFlowType(GroupType::Map, value, FmtScope::Global)) + ok = true; + if(m_pState->SetMapKeyFormat(value, FmtScope::Global)) + ok = true; + return ok; + } + + bool Emitter::SetIndent(unsigned n) + { + return m_pState->SetIndent(n, FmtScope::Global); + } + + bool Emitter::SetPreCommentIndent(unsigned n) + { + return m_pState->SetPreCommentIndent(n, FmtScope::Global); + } + + bool Emitter::SetPostCommentIndent(unsigned n) + { + return m_pState->SetPostCommentIndent(n, FmtScope::Global); + } + + bool Emitter::SetFloatPrecision(unsigned n) + { + return m_pState->SetFloatPrecision(n, FmtScope::Global); + } + + bool Emitter::SetDoublePrecision(unsigned n) + { + return m_pState->SetDoublePrecision(n, FmtScope::Global); + } + + // SetLocalValue + // . Either start/end a group, or set a modifier locally + Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) + { + if(!good()) + return *this; + + switch(value) { + case BeginDoc: + EmitBeginDoc(); + break; + case EndDoc: + EmitEndDoc(); + break; + case BeginSeq: + EmitBeginSeq(); + break; + case EndSeq: + EmitEndSeq(); + break; + case BeginMap: + EmitBeginMap(); + break; + case EndMap: + EmitEndMap(); + break; + case Key: + case Value: + // deprecated (these can be deduced by the parity of nodes in a map) + break; + case TagByKind: + EmitKindTag(); + break; + case Newline: + EmitNewline(); + break; + default: + m_pState->SetLocalValue(value); + break; + } + return *this; + } + + Emitter& Emitter::SetLocalIndent(const _Indent& indent) + { + m_pState->SetIndent(indent.value, FmtScope::Local); + return *this; + } + + Emitter& Emitter::SetLocalPrecision(const _Precision& precision) + { + if(precision.floatPrecision >= 0) + m_pState->SetFloatPrecision(precision.floatPrecision, FmtScope::Local); + if(precision.doublePrecision >= 0) + m_pState->SetDoublePrecision(precision.doublePrecision, FmtScope::Local); + return *this; + } + + // EmitBeginDoc + void Emitter::EmitBeginDoc() + { + if(!good()) + return; + + if(m_pState->CurGroupType() != GroupType::None) { + m_pState->SetError("Unexpected begin document"); + return; + } + + if(m_pState->HasAnchor() || m_pState->HasTag()) { + m_pState->SetError("Unexpected begin document"); + return; + } + + if(m_stream.col() > 0) + m_stream << "\n"; + m_stream << "---\n"; + + m_pState->StartedDoc(); + } + + // EmitEndDoc + void Emitter::EmitEndDoc() + { + if(!good()) + return; + + if(m_pState->CurGroupType() != GroupType::None) { + m_pState->SetError("Unexpected begin document"); + return; + } + + if(m_pState->HasAnchor() || m_pState->HasTag()) { + m_pState->SetError("Unexpected begin document"); + return; + } + + if(m_stream.col() > 0) + m_stream << "\n"; + m_stream << "...\n"; + } + + // EmitBeginSeq + void Emitter::EmitBeginSeq() + { + if(!good()) + return; + + PrepareNode(m_pState->NextGroupType(GroupType::Seq)); + + m_pState->StartedGroup(GroupType::Seq); + } + + // EmitEndSeq + void Emitter::EmitEndSeq() + { + if(!good()) + return; + + if(m_pState->CurGroupChildCount() == 0) + m_pState->ForceFlow(); + + if(m_pState->CurGroupFlowType() == FlowType::Flow) { + if(m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(m_pState->CurIndent()); + if(m_pState->CurGroupChildCount() == 0) + m_stream << "["; + m_stream << "]"; + } + + m_pState->EndedGroup(GroupType::Seq); + } + + // EmitBeginMap + void Emitter::EmitBeginMap() + { + if(!good()) + return; + + PrepareNode(m_pState->NextGroupType(GroupType::Map)); + + m_pState->StartedGroup(GroupType::Map); + } + + // EmitEndMap + void Emitter::EmitEndMap() + { + if(!good()) + return; + + if(m_pState->CurGroupChildCount() == 0) + m_pState->ForceFlow(); + + if(m_pState->CurGroupFlowType() == FlowType::Flow) { + if(m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(m_pState->CurIndent()); + if(m_pState->CurGroupChildCount() == 0) + m_stream << "{"; + m_stream << "}"; + } + + m_pState->EndedGroup(GroupType::Map); + } + + // EmitNewline + void Emitter::EmitNewline() + { + if(!good()) + return; + + PrepareNode(EmitterNodeType::None); + m_stream << "\n"; + m_pState->SetNonContent(); + } + + bool Emitter::CanEmitNewline() const + { + return true; + } + + // Put the stream in a state so we can simply write the next node + // E.g., if we're in a sequence, write the "- " + void Emitter::PrepareNode(EmitterNodeType::value child) + { + switch(m_pState->CurGroupNodeType()) { + case EmitterNodeType::None: + PrepareTopNode(child); + break; + case EmitterNodeType::FlowSeq: + FlowSeqPrepareNode(child); + break; + case EmitterNodeType::BlockSeq: + BlockSeqPrepareNode(child); + break; + case EmitterNodeType::FlowMap: + FlowMapPrepareNode(child); + break; + case EmitterNodeType::BlockMap: + BlockMapPrepareNode(child); + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + assert(false); + break; + } + } + + void Emitter::PrepareTopNode(EmitterNodeType::value child) + { + if(child == EmitterNodeType::None) + return; + + if(m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) { + if(child != EmitterNodeType::None) + EmitBeginDoc(); + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + // TODO: if we were writing null, and + // we wanted it blank, we wouldn't want a space + SpaceOrIndentTo(m_pState->HasBegunContent(), 0); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + if(m_pState->HasBegunNode()) + m_stream << "\n"; + break; + } + } + + void Emitter::FlowSeqPrepareNode(EmitterNodeType::value child) + { + const unsigned lastIndent = m_pState->LastIndent(); + + if(!m_pState->HasBegunNode()) { + if(m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + if(m_pState->CurGroupChildCount() == 0) + m_stream << "["; + else + m_stream << ","; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } + } + + void Emitter::BlockSeqPrepareNode(EmitterNodeType::value child) + { + const unsigned curIndent = m_pState->CurIndent(); + const unsigned nextIndent = curIndent + m_pState->CurGroupIndent(); + + if(child == EmitterNodeType::None) + return; + + if(!m_pState->HasBegunContent()) { + if(m_pState->CurGroupChildCount() > 0 || m_stream.comment()) { + m_stream << "\n"; + } + m_stream << IndentTo(curIndent); + m_stream << "-"; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent(), nextIndent); + break; + case EmitterNodeType::BlockSeq: + m_stream << "\n"; + break; + case EmitterNodeType::BlockMap: + if(m_pState->HasBegunContent() || m_stream.comment()) + m_stream << "\n"; + break; + } + } + + void Emitter::FlowMapPrepareNode(EmitterNodeType::value child) + { + if(m_pState->CurGroupChildCount() % 2 == 0) { + if(m_pState->GetMapKeyFormat() == LongKey) + m_pState->SetLongKey(); + + if(m_pState->CurGroupLongKey()) + FlowMapPrepareLongKey(child); + else + FlowMapPrepareSimpleKey(child); + } else { + if(m_pState->CurGroupLongKey()) + FlowMapPrepareLongKeyValue(child); + else + FlowMapPrepareSimpleKeyValue(child); + } + } + + void Emitter::FlowMapPrepareLongKey(EmitterNodeType::value child) + { + const unsigned lastIndent = m_pState->LastIndent(); + + if(!m_pState->HasBegunNode()) { + if(m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + if(m_pState->CurGroupChildCount() == 0) + m_stream << "{ ?"; + else + m_stream << ", ?"; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } + } + + void Emitter::FlowMapPrepareLongKeyValue(EmitterNodeType::value child) + { + const unsigned lastIndent = m_pState->LastIndent(); + + if(!m_pState->HasBegunNode()) { + if(m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + m_stream << ":"; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } + } + + void Emitter::FlowMapPrepareSimpleKey(EmitterNodeType::value child) + { + const unsigned lastIndent = m_pState->LastIndent(); + + if(!m_pState->HasBegunNode()) { + if(m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + if(m_pState->CurGroupChildCount() == 0) + m_stream << "{"; + else + m_stream << ","; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } + } + + void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child) + { + const unsigned lastIndent = m_pState->LastIndent(); + + if(!m_pState->HasBegunNode()) { + if(m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + m_stream << ":"; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } + } + + void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) + { + if(m_pState->CurGroupChildCount() % 2 == 0) { + if(m_pState->GetMapKeyFormat() == LongKey) + m_pState->SetLongKey(); + if(child == EmitterNodeType::BlockSeq || child == EmitterNodeType::BlockMap) + m_pState->SetLongKey(); + + if(m_pState->CurGroupLongKey()) + BlockMapPrepareLongKey(child); + else + BlockMapPrepareSimpleKey(child); + } else { + if(m_pState->CurGroupLongKey()) + BlockMapPrepareLongKeyValue(child); + else + BlockMapPrepareSimpleKeyValue(child); + } + } + + void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) + { + const unsigned curIndent = m_pState->CurIndent(); + const std::size_t childCount = m_pState->CurGroupChildCount(); + + if(child == EmitterNodeType::None) + return; + + if(!m_pState->HasBegunContent()) { + if(childCount > 0) { + m_stream << "\n"; + } + if(m_stream.comment()) { + m_stream << "\n"; + } + m_stream << IndentTo(curIndent); + m_stream << "?"; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(true, curIndent + 1); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + break; + } + } + + void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) + { + const unsigned curIndent = m_pState->CurIndent(); + + if(child == EmitterNodeType::None) + return; + + if(!m_pState->HasBegunContent()) { + m_stream << "\n"; + m_stream << IndentTo(curIndent); + m_stream << ":"; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + SpaceOrIndentTo(true, curIndent + 1); + break; + } + } + + void Emitter::BlockMapPrepareSimpleKey(EmitterNodeType::value child) + { + const unsigned curIndent = m_pState->CurIndent(); + const std::size_t childCount = m_pState->CurGroupChildCount(); + + if(child == EmitterNodeType::None) + return; + + if(!m_pState->HasBegunNode()) { + if(childCount > 0) { + m_stream << "\n"; + } + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent(), curIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + break; + } + } + + void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child) + { + const unsigned curIndent = m_pState->CurIndent(); + const unsigned nextIndent = curIndent + m_pState->CurGroupIndent(); + + if(!m_pState->HasBegunNode()) { + m_stream << ":"; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(true, nextIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + m_stream << "\n"; + break; + } + } + + // SpaceOrIndentTo + // . Prepares for some more content by proper spacing + void Emitter::SpaceOrIndentTo(bool requireSpace, unsigned indent) + { + if(m_stream.comment()) + m_stream << "\n"; + if(m_stream.col() > 0 && requireSpace) + m_stream << " "; + m_stream << IndentTo(indent); + } + + void Emitter::PrepareIntegralStream(std::stringstream& stream) const + { + + switch(m_pState->GetIntFormat()) { + case Dec: + stream << std::dec; + break; + case Hex: + stream << "0x"; + stream << std::hex; + break; + case Oct: + stream << "0"; + stream << std::oct; + break; + default: + assert(false); + } + } + + void Emitter::StartedScalar() + { + m_pState->StartedScalar(); + } + + // ******************************************************************************************* + // overloads of Write + + Emitter& Emitter::Write(const std::string& str) + { + if(!good()) + return *this; + + const bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii; + const StringFormat::value strFormat = Utils::ComputeStringFormat(str, m_pState->GetStringFormat(), m_pState->CurGroupFlowType(), escapeNonAscii); + + if(strFormat == StringFormat::Literal) + m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local); + + PrepareNode(EmitterNodeType::Scalar); + + switch(strFormat) { + case StringFormat::Plain: + m_stream << str; + break; + case StringFormat::SingleQuoted: + Utils::WriteSingleQuotedString(m_stream, str); + break; + case StringFormat::DoubleQuoted: + Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii); + break; + case StringFormat::Literal: + Utils::WriteLiteralString(m_stream, str, m_pState->CurIndent() + m_pState->GetIndent()); + break; + } + + StartedScalar(); + + return *this; + } + + unsigned Emitter::GetFloatPrecision() const + { + return m_pState->GetFloatPrecision(); + } + + unsigned Emitter::GetDoublePrecision() const + { + return m_pState->GetDoublePrecision(); + } + + const char *Emitter::ComputeFullBoolName(bool b) const + { + const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool ? YesNoBool : m_pState->GetBoolFormat()); + const EMITTER_MANIP caseFmt = m_pState->GetBoolCaseFormat(); + switch(mainFmt) { + case YesNoBool: + switch(caseFmt) { + case UpperCase: return b ? "YES" : "NO"; + case CamelCase: return b ? "Yes" : "No"; + case LowerCase: return b ? "yes" : "no"; + default: break; + } + break; + case OnOffBool: + switch(caseFmt) { + case UpperCase: return b ? "ON" : "OFF"; + case CamelCase: return b ? "On" : "Off"; + case LowerCase: return b ? "on" : "off"; + default: break; + } + break; + case TrueFalseBool: + switch(caseFmt) { + case UpperCase: return b ? "TRUE" : "FALSE"; + case CamelCase: return b ? "True" : "False"; + case LowerCase: return b ? "true" : "false"; + default: break; + } + break; + default: + break; + } + return b ? "y" : "n"; // should never get here, but it can't hurt to give these answers + } + + Emitter& Emitter::Write(bool b) + { + if(!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + + const char *name = ComputeFullBoolName(b); + if(m_pState->GetBoolLengthFormat() == ShortBool) + m_stream << name[0]; + else + m_stream << name; + + StartedScalar(); + + return *this; + } + + Emitter& Emitter::Write(char ch) + { + if(!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + Utils::WriteChar(m_stream, ch); + StartedScalar(); + + return *this; + } + + Emitter& Emitter::Write(const _Alias& alias) + { + if(!good()) + return *this; + + if(m_pState->HasAnchor() || m_pState->HasTag()) { + m_pState->SetError(ErrorMsg::INVALID_ALIAS); + return *this; + } + + PrepareNode(EmitterNodeType::Scalar); + + if(!Utils::WriteAlias(m_stream, alias.content)) { + m_pState->SetError(ErrorMsg::INVALID_ALIAS); + return *this; + } + + StartedScalar(); + + return *this; + } + + Emitter& Emitter::Write(const _Anchor& anchor) + { + if(!good()) + return *this; + + if(m_pState->HasAnchor()) { + m_pState->SetError(ErrorMsg::INVALID_ANCHOR); + return *this; + } + + PrepareNode(EmitterNodeType::Property); + + if(!Utils::WriteAnchor(m_stream, anchor.content)) { + m_pState->SetError(ErrorMsg::INVALID_ANCHOR); + return *this; + } + + m_pState->SetAnchor(); + + return *this; + } + + Emitter& Emitter::Write(const _Tag& tag) + { + if(!good()) + return *this; + + if(m_pState->HasTag()) { + m_pState->SetError(ErrorMsg::INVALID_TAG); + return *this; + } + + PrepareNode(EmitterNodeType::Property); + + bool success = false; + if(tag.type == _Tag::Type::Verbatim) + success = Utils::WriteTag(m_stream, tag.content, true); + else if(tag.type == _Tag::Type::PrimaryHandle) + success = Utils::WriteTag(m_stream, tag.content, false); + else + success = Utils::WriteTagWithPrefix(m_stream, tag.prefix, tag.content); + + if(!success) { + m_pState->SetError(ErrorMsg::INVALID_TAG); + return *this; + } + + m_pState->SetTag(); + + return *this; + } + + void Emitter::EmitKindTag() + { + Write(LocalTag("")); + } + + Emitter& Emitter::Write(const _Comment& comment) + { + if(!good()) + return *this; + + PrepareNode(EmitterNodeType::None); + + if(m_stream.col() > 0) + m_stream << Indentation(m_pState->GetPreCommentIndent()); + Utils::WriteComment(m_stream, comment.content, m_pState->GetPostCommentIndent()); + + m_pState->SetNonContent(); + + return *this; + } + + Emitter& Emitter::Write(const _Null& /*null*/) + { + if(!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + + m_stream << "~"; + + StartedScalar(); + + return *this; + } + + Emitter& Emitter::Write(const Binary& binary) + { + Write(SecondaryTag("binary")); + + if(!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + Utils::WriteBinary(m_stream, binary); + StartedScalar(); + + return *this; + } +} + diff --git a/src/third_party/yaml-cpp-0.5.1/src/emitterstate.cpp b/src/third_party/yaml-cpp-0.5.1/src/emitterstate.cpp new file mode 100644 index 00000000000..10c3976d1ca --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/emitterstate.cpp @@ -0,0 +1,384 @@ +#include "emitterstate.h" +#include "yaml-cpp/exceptions.h" +#include <limits> + +namespace YAML +{ + EmitterState::EmitterState(): m_isGood(true), m_curIndent(0), m_hasAnchor(false), m_hasTag(false), m_hasNonContent(false), m_docCount(0) + { + // set default global manipulators + m_charset.set(EmitNonAscii); + m_strFmt.set(Auto); + m_boolFmt.set(TrueFalseBool); + m_boolLengthFmt.set(LongBool); + m_boolCaseFmt.set(LowerCase); + m_intFmt.set(Dec); + m_indent.set(2); + m_preCommentIndent.set(2); + m_postCommentIndent.set(1); + m_seqFmt.set(Block); + m_mapFmt.set(Block); + m_mapKeyFmt.set(Auto); + m_floatPrecision.set(std::numeric_limits<float>::digits10 + 1); + m_doublePrecision.set(std::numeric_limits<double>::digits10 + 1); + } + + EmitterState::~EmitterState() + { + } + + // SetLocalValue + // . We blindly tries to set all possible formatters to this value + // . Only the ones that make sense will be accepted + void EmitterState::SetLocalValue(EMITTER_MANIP value) + { + SetOutputCharset(value, FmtScope::Local); + SetStringFormat(value, FmtScope::Local); + SetBoolFormat(value, FmtScope::Local); + SetBoolCaseFormat(value, FmtScope::Local); + SetBoolLengthFormat(value, FmtScope::Local); + SetIntFormat(value, FmtScope::Local); + SetFlowType(GroupType::Seq, value, FmtScope::Local); + SetFlowType(GroupType::Map, value, FmtScope::Local); + SetMapKeyFormat(value, FmtScope::Local); + } + + void EmitterState::SetAnchor() + { + m_hasAnchor = true; + } + + void EmitterState::SetTag() + { + m_hasTag = true; + } + + void EmitterState::SetNonContent() + { + m_hasNonContent = true; + } + + void EmitterState::SetLongKey() + { + assert(!m_groups.empty()); + if(m_groups.empty()) + return; + + assert(m_groups.top().type == GroupType::Map); + m_groups.top().longKey = true; + } + + void EmitterState::ForceFlow() + { + assert(!m_groups.empty()); + if(m_groups.empty()) + return; + + m_groups.top().flowType = FlowType::Flow; + } + + void EmitterState::StartedNode() + { + if(m_groups.empty()) { + m_docCount++; + } else { + m_groups.top().childCount++; + if(m_groups.top().childCount % 2 == 0) + m_groups.top().longKey = false; + } + + m_hasAnchor = false; + m_hasTag = false; + m_hasNonContent = false; + } + + EmitterNodeType::value EmitterState::NextGroupType(GroupType::value type) const + { + if(type == GroupType::Seq) { + if(GetFlowType(type) == Block) + return EmitterNodeType::BlockSeq; + else + return EmitterNodeType::FlowSeq; + } else { + if(GetFlowType(type) == Block) + return EmitterNodeType::BlockMap; + else + return EmitterNodeType::FlowMap; + } + + // can't happen + assert(false); + return EmitterNodeType::None; + } + + void EmitterState::StartedDoc() + { + m_hasAnchor = false; + m_hasTag = false; + m_hasNonContent = false; + } + + void EmitterState::EndedDoc() + { + m_hasAnchor = false; + m_hasTag = false; + m_hasNonContent = false; + } + + void EmitterState::StartedScalar() + { + StartedNode(); + ClearModifiedSettings(); + } + + void EmitterState::StartedGroup(GroupType::value type) + { + StartedNode(); + + const int lastGroupIndent = (m_groups.empty() ? 0 : m_groups.top().indent); + m_curIndent += lastGroupIndent; + + std::auto_ptr<Group> pGroup(new Group(type)); + + // transfer settings (which last until this group is done) + pGroup->modifiedSettings = m_modifiedSettings; + + // set up group + if(GetFlowType(type) == Block) + pGroup->flowType = FlowType::Block; + else + pGroup->flowType = FlowType::Flow; + pGroup->indent = GetIndent(); + + m_groups.push(pGroup); + } + + void EmitterState::EndedGroup(GroupType::value type) + { + if(m_groups.empty()) { + if(type == GroupType::Seq) + return SetError(ErrorMsg::UNEXPECTED_END_SEQ); + else + return SetError(ErrorMsg::UNEXPECTED_END_MAP); + } + + // get rid of the current group + { + std::auto_ptr<Group> pFinishedGroup = m_groups.pop(); + if(pFinishedGroup->type != type) + return SetError(ErrorMsg::UNMATCHED_GROUP_TAG); + } + + // reset old settings + unsigned lastIndent = (m_groups.empty() ? 0 : m_groups.top().indent); + assert(m_curIndent >= lastIndent); + m_curIndent -= lastIndent; + + // some global settings that we changed may have been overridden + // by a local setting we just popped, so we need to restore them + m_globalModifiedSettings.restore(); + + ClearModifiedSettings(); + } + + EmitterNodeType::value EmitterState::CurGroupNodeType() const + { + if(m_groups.empty()) + return EmitterNodeType::None; + + return m_groups.top().NodeType(); + } + + GroupType::value EmitterState::CurGroupType() const + { + return m_groups.empty() ? GroupType::None : m_groups.top().type; + } + + FlowType::value EmitterState::CurGroupFlowType() const + { + return m_groups.empty() ? FlowType::None : m_groups.top().flowType; + } + + int EmitterState::CurGroupIndent() const + { + return m_groups.empty() ? 0 : m_groups.top().indent; + } + + std::size_t EmitterState::CurGroupChildCount() const + { + return m_groups.empty() ? m_docCount : m_groups.top().childCount; + } + + bool EmitterState::CurGroupLongKey() const + { + return m_groups.empty() ? false : m_groups.top().longKey; + } + + int EmitterState::LastIndent() const + { + if(m_groups.size() <= 1) + return 0; + + return m_curIndent - m_groups.top(-1).indent; + } + + void EmitterState::ClearModifiedSettings() + { + m_modifiedSettings.clear(); + } + + bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope) + { + switch(value) { + case EmitNonAscii: + case EscapeNonAscii: + _Set(m_charset, value, scope); + return true; + default: + return false; + } + } + + bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope) + { + switch(value) { + case Auto: + case SingleQuoted: + case DoubleQuoted: + case Literal: + _Set(m_strFmt, value, scope); + return true; + default: + return false; + } + } + + bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope) + { + switch(value) { + case OnOffBool: + case TrueFalseBool: + case YesNoBool: + _Set(m_boolFmt, value, scope); + return true; + default: + return false; + } + } + + bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope) + { + switch(value) { + case LongBool: + case ShortBool: + _Set(m_boolLengthFmt, value, scope); + return true; + default: + return false; + } + } + + bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope) + { + switch(value) { + case UpperCase: + case LowerCase: + case CamelCase: + _Set(m_boolCaseFmt, value, scope); + return true; + default: + return false; + } + } + + bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) + { + switch(value) { + case Dec: + case Hex: + case Oct: + _Set(m_intFmt, value, scope); + return true; + default: + return false; + } + } + + bool EmitterState::SetIndent(unsigned value, FmtScope::value scope) + { + if(value <= 1) + return false; + + _Set(m_indent, value, scope); + return true; + } + + bool EmitterState::SetPreCommentIndent(unsigned value, FmtScope::value scope) + { + if(value == 0) + return false; + + _Set(m_preCommentIndent, value, scope); + return true; + } + + bool EmitterState::SetPostCommentIndent(unsigned value, FmtScope::value scope) + { + if(value == 0) + return false; + + _Set(m_postCommentIndent, value, scope); + return true; + } + + bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope) + { + switch(value) { + case Block: + case Flow: + _Set(groupType == GroupType::Seq ? m_seqFmt : m_mapFmt, value, scope); + return true; + default: + return false; + } + } + + EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const + { + // force flow style if we're currently in a flow + if(CurGroupFlowType() == FlowType::Flow) + return Flow; + + // otherwise, go with what's asked of us + return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get()); + } + + bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) + { + switch(value) { + case Auto: + case LongKey: + _Set(m_mapKeyFmt, value, scope); + return true; + default: + return false; + } + } + + bool EmitterState::SetFloatPrecision(int value, FmtScope::value scope) + { + if(value < 0 || value > std::numeric_limits<float>::digits10 + 1) + return false; + _Set(m_floatPrecision, value, scope); + return true; + } + + bool EmitterState::SetDoublePrecision(int value, FmtScope::value scope) + { + if(value < 0 || value > std::numeric_limits<double>::digits10 + 1) + return false; + _Set(m_doublePrecision, value, scope); + return true; + } +} + diff --git a/src/third_party/yaml-cpp-0.5.1/src/emitterstate.h b/src/third_party/yaml-cpp-0.5.1/src/emitterstate.h new file mode 100644 index 00000000000..f43f471345f --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/emitterstate.h @@ -0,0 +1,190 @@ +#ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "ptr_stack.h" +#include "setting.h" +#include "yaml-cpp/emitterdef.h" +#include "yaml-cpp/emittermanip.h" +#include <cassert> +#include <vector> +#include <stack> +#include <memory> +#include <stdexcept> + +namespace YAML +{ + struct FmtScope { enum value { Local, Global }; }; + struct GroupType { enum value { None, Seq, Map }; }; + struct FlowType { enum value { None, Flow, Block }; }; + + class EmitterState + { + public: + EmitterState(); + ~EmitterState(); + + // basic state checking + bool good() const { return m_isGood; } + const std::string GetLastError() const { return m_lastError; } + void SetError(const std::string& error) { m_isGood = false; m_lastError = error; } + + // node handling + void SetAnchor(); + void SetTag(); + void SetNonContent(); + void SetLongKey(); + void ForceFlow(); + void StartedDoc(); + void EndedDoc(); + void StartedScalar(); + void StartedGroup(GroupType::value type); + void EndedGroup(GroupType::value type); + + EmitterNodeType::value NextGroupType(GroupType::value type) const; + EmitterNodeType::value CurGroupNodeType() const; + + GroupType::value CurGroupType() const; + FlowType::value CurGroupFlowType() const; + int CurGroupIndent() const; + std::size_t CurGroupChildCount() const; + bool CurGroupLongKey() const; + + int LastIndent() const; + int CurIndent() const { return m_curIndent; } + bool HasAnchor() const { return m_hasAnchor; } + bool HasTag() const { return m_hasTag; } + bool HasBegunNode() const { return m_hasAnchor || m_hasTag || m_hasNonContent; } + bool HasBegunContent() const { return m_hasAnchor || m_hasTag; } + + void ClearModifiedSettings(); + + // formatters + void SetLocalValue(EMITTER_MANIP value); + + bool SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); } + + bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); } + + bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); } + + bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); } + + bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); } + + bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); } + + bool SetIndent(unsigned value, FmtScope::value scope); + int GetIndent() const { return m_indent.get(); } + + bool SetPreCommentIndent(unsigned value, FmtScope::value scope); + int GetPreCommentIndent() const { return m_preCommentIndent.get(); } + bool SetPostCommentIndent(unsigned value, FmtScope::value scope); + int GetPostCommentIndent() const { return m_postCommentIndent.get(); } + + bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetFlowType(GroupType::value groupType) const; + + bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); } + + bool SetFloatPrecision(int value, FmtScope::value scope); + unsigned GetFloatPrecision() const { return m_floatPrecision.get(); } + bool SetDoublePrecision(int value, FmtScope::value scope); + unsigned GetDoublePrecision() const { return m_doublePrecision.get(); } + + private: + template <typename T> + void _Set(Setting<T>& fmt, T value, FmtScope::value scope); + + void StartedNode(); + + private: + // basic state ok? + bool m_isGood; + std::string m_lastError; + + // other state + Setting<EMITTER_MANIP> m_charset; + Setting<EMITTER_MANIP> m_strFmt; + Setting<EMITTER_MANIP> m_boolFmt; + Setting<EMITTER_MANIP> m_boolLengthFmt; + Setting<EMITTER_MANIP> m_boolCaseFmt; + Setting<EMITTER_MANIP> m_intFmt; + Setting<unsigned> m_indent; + Setting<unsigned> m_preCommentIndent, m_postCommentIndent; + Setting<EMITTER_MANIP> m_seqFmt; + Setting<EMITTER_MANIP> m_mapFmt; + Setting<EMITTER_MANIP> m_mapKeyFmt; + Setting<int> m_floatPrecision; + Setting<int> m_doublePrecision; + + SettingChanges m_modifiedSettings; + SettingChanges m_globalModifiedSettings; + + struct Group { + explicit Group(GroupType::value type_): type(type_), indent(0), childCount(0), longKey(false) {} + + GroupType::value type; + FlowType::value flowType; + int indent; + std::size_t childCount; + bool longKey; + + SettingChanges modifiedSettings; + + EmitterNodeType::value NodeType() const { + if(type == GroupType::Seq) { + if(flowType == FlowType::Flow) + return EmitterNodeType::FlowSeq; + else + return EmitterNodeType::BlockSeq; + } else { + if(flowType == FlowType::Flow) + return EmitterNodeType::FlowMap; + else + return EmitterNodeType::BlockMap; + } + + // can't get here + assert(false); + return EmitterNodeType::None; + } + }; + + ptr_stack<Group> m_groups; + unsigned m_curIndent; + bool m_hasAnchor; + bool m_hasTag; + bool m_hasNonContent; + std::size_t m_docCount; + }; + + template <typename T> + void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) { + switch(scope) { + case FmtScope::Local: + m_modifiedSettings.push(fmt.set(value)); + break; + case FmtScope::Global: + fmt.set(value); + m_globalModifiedSettings.push(fmt.set(value)); // this pushes an identity set, so when we restore, + // it restores to the value here, and not the previous one + break; + default: + assert(false); + } + } +} + +#endif // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/emitterutils.cpp b/src/third_party/yaml-cpp-0.5.1/src/emitterutils.cpp new file mode 100644 index 00000000000..09780d00b06 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/emitterutils.cpp @@ -0,0 +1,424 @@ +#include "emitterutils.h" +#include "exp.h" +#include "indentation.h" +#include "yaml-cpp/binary.h" +#include "yaml-cpp/exceptions.h" +#include "stringsource.h" +#include <sstream> +#include <iomanip> + +namespace YAML +{ + namespace Utils + { + namespace { + enum {REPLACEMENT_CHARACTER = 0xFFFD}; + + bool IsAnchorChar(int ch) { // test for ns-anchor-char + switch (ch) { + case ',': case '[': case ']': case '{': case '}': // c-flow-indicator + case ' ': case '\t': // s-white + case 0xFEFF: // c-byte-order-mark + case 0xA: case 0xD: // b-char + return false; + case 0x85: + return true; + } + + if (ch < 0x20) + return false; + + if (ch < 0x7E) + return true; + + if (ch < 0xA0) + return false; + if (ch >= 0xD800 && ch <= 0xDFFF) + return false; + if ((ch & 0xFFFE) == 0xFFFE) + return false; + if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) + return false; + if (ch > 0x10FFFF) + return false; + + return true; + } + + int Utf8BytesIndicated(char ch) { + int byteVal = static_cast<unsigned char>(ch); + switch (byteVal >> 4) { + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: + return 1; + case 12: case 13: + return 2; + case 14: + return 3; + case 15: + return 4; + default: + return -1; + } + } + + bool IsTrailingByte(char ch) { + return (ch & 0xC0) == 0x80; + } + + bool GetNextCodePointAndAdvance(int& codePoint, std::string::const_iterator& first, std::string::const_iterator last) { + if (first == last) + return false; + + int nBytes = Utf8BytesIndicated(*first); + if (nBytes < 1) { + // Bad lead byte + ++first; + codePoint = REPLACEMENT_CHARACTER; + return true; + } + + if (nBytes == 1) { + codePoint = *first++; + return true; + } + + // Gather bits from trailing bytes + codePoint = static_cast<unsigned char>(*first) & ~(0xFF << (7 - nBytes)); + ++first; + --nBytes; + for (; nBytes > 0; ++first, --nBytes) { + if ((first == last) || !IsTrailingByte(*first)) { + codePoint = REPLACEMENT_CHARACTER; + break; + } + codePoint <<= 6; + codePoint |= *first & 0x3F; + } + + // Check for illegal code points + if (codePoint > 0x10FFFF) + codePoint = REPLACEMENT_CHARACTER; + else if (codePoint >= 0xD800 && codePoint <= 0xDFFF) + codePoint = REPLACEMENT_CHARACTER; + else if ((codePoint & 0xFFFE) == 0xFFFE) + codePoint = REPLACEMENT_CHARACTER; + else if (codePoint >= 0xFDD0 && codePoint <= 0xFDEF) + codePoint = REPLACEMENT_CHARACTER; + return true; + } + + void WriteCodePoint(ostream_wrapper& out, int codePoint) { + if (codePoint < 0 || codePoint > 0x10FFFF) { + codePoint = REPLACEMENT_CHARACTER; + } + if (codePoint < 0x7F) { + out << static_cast<char>(codePoint); + } else if (codePoint < 0x7FF) { + out << static_cast<char>(0xC0 | (codePoint >> 6)) + << static_cast<char>(0x80 | (codePoint & 0x3F)); + } else if (codePoint < 0xFFFF) { + out << static_cast<char>(0xE0 | (codePoint >> 12)) + << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)) + << static_cast<char>(0x80 | (codePoint & 0x3F)); + } else { + out << static_cast<char>(0xF0 | (codePoint >> 18)) + << static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F)) + << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)) + << static_cast<char>(0x80 | (codePoint & 0x3F)); + } + } + + bool IsValidPlainScalar(const std::string& str, FlowType::value flowType, bool allowOnlyAscii) { + if(str.empty()) + return false; + + // first check the start + const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow() : Exp::PlainScalar()); + if(!start.Matches(str)) + return false; + + // and check the end for plain whitespace (which can't be faithfully kept in a plain scalar) + if(!str.empty() && *str.rbegin() == ' ') + return false; + + // then check until something is disallowed + const RegEx& disallowed = (flowType == FlowType::Flow ? Exp::EndScalarInFlow() : Exp::EndScalar()) + || (Exp::BlankOrBreak() + Exp::Comment()) + || Exp::NotPrintable() + || Exp::Utf8_ByteOrderMark() + || Exp::Break() + || Exp::Tab(); + StringCharSource buffer(str.c_str(), str.size()); + while(buffer) { + if(disallowed.Matches(buffer)) + return false; + if(allowOnlyAscii && (0x80 <= static_cast<unsigned char>(buffer[0]))) + return false; + ++buffer; + } + + return true; + } + + bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) + { + // TODO: check for non-printable characters? + for(std::size_t i=0;i<str.size();i++) { + if(escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) + return false; + if(str[i] == '\n') + return false; + } + return true; + } + + bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType, bool escapeNonAscii) + { + if(flowType == FlowType::Flow) + return false; + + // TODO: check for non-printable characters? + for(std::size_t i=0;i<str.size();i++) { + if(escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) + return false; + } + return true; + } + + void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint) { + static const char hexDigits[] = "0123456789abcdef"; + + out << "\\"; + int digits = 8; + if(codePoint < 0xFF) { + out << "x"; + digits = 2; + } else if(codePoint < 0xFFFF) { + out << "u"; + digits = 4; + } else { + out << "U"; + digits = 8; + } + + // Write digits into the escape sequence + for (; digits > 0; --digits) + out << hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF]; + } + + bool WriteAliasName(ostream_wrapper& out, const std::string& str) { + int codePoint; + for(std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end()); + ) + { + if (!IsAnchorChar(codePoint)) + return false; + + WriteCodePoint(out, codePoint); + } + return true; + } + } + + StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, FlowType::value flowType, bool escapeNonAscii) + { + switch(strFormat) { + case Auto: + if(IsValidPlainScalar(str, flowType, escapeNonAscii)) + return StringFormat::Plain; + return StringFormat::DoubleQuoted; + case SingleQuoted: + if(IsValidSingleQuotedScalar(str, escapeNonAscii)) + return StringFormat::SingleQuoted; + return StringFormat::DoubleQuoted; + case DoubleQuoted: + return StringFormat::DoubleQuoted; + case Literal: + if(IsValidLiteralScalar(str, flowType, escapeNonAscii)) + return StringFormat::Literal; + return StringFormat::DoubleQuoted; + default: + break; + } + + return StringFormat::DoubleQuoted; + } + + bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) + { + out << "'"; + int codePoint; + for(std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end()); + ) + { + if (codePoint == '\n') + return false; // We can't handle a new line and the attendant indentation yet + + if (codePoint == '\'') + out << "''"; + else + WriteCodePoint(out, codePoint); + } + out << "'"; + return true; + } + + bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, bool escapeNonAscii) + { + out << "\""; + int codePoint; + for(std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end()); + ) + { + switch(codePoint) { + case '\"': out << "\\\""; break; + case '\\': out << "\\\\"; break; + case '\n': out << "\\n"; break; + case '\t': out << "\\t"; break; + case '\r': out << "\\r"; break; + case '\b': out << "\\b"; break; + default: + if(codePoint < 0x20 || (codePoint >= 0x80 && codePoint <= 0xA0)) // Control characters and non-breaking space + WriteDoubleQuoteEscapeSequence(out, codePoint); + else if (codePoint == 0xFEFF) // Byte order marks (ZWNS) should be escaped (YAML 1.2, sec. 5.2) + WriteDoubleQuoteEscapeSequence(out, codePoint); + else if (escapeNonAscii && codePoint > 0x7E) + WriteDoubleQuoteEscapeSequence(out, codePoint); + else + WriteCodePoint(out, codePoint); + } + } + out << "\""; + return true; + } + + bool WriteLiteralString(ostream_wrapper& out, const std::string& str, int indent) + { + out << "|\n"; + out << IndentTo(indent); + int codePoint; + for(std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end()); + ) + { + if (codePoint == '\n') + out << "\n" << IndentTo(indent); + else + WriteCodePoint(out, codePoint); + } + return true; + } + + bool WriteChar(ostream_wrapper& out, char ch) + { + if(('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) + out << ch; + else if((0x20 <= ch && ch <= 0x7e) || ch == ' ') + out << "\"" << ch << "\""; + else if(ch == '\t') + out << "\"\\t\""; + else if(ch == '\n') + out << "\"\\n\""; + else if(ch == '\b') + out << "\"\\b\""; + else { + out << "\""; + WriteDoubleQuoteEscapeSequence(out, ch); + out << "\""; + } + return true; + } + + bool WriteComment(ostream_wrapper& out, const std::string& str, int postCommentIndent) + { + const unsigned curIndent = out.col(); + out << "#" << Indentation(postCommentIndent); + out.set_comment(); + int codePoint; + for(std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end()); + ) + { + if(codePoint == '\n') { + out << "\n" << IndentTo(curIndent) << "#" << Indentation(postCommentIndent); + out.set_comment(); + } else { + WriteCodePoint(out, codePoint); + } + } + return true; + } + + bool WriteAlias(ostream_wrapper& out, const std::string& str) + { + out << "*"; + return WriteAliasName(out, str); + } + + bool WriteAnchor(ostream_wrapper& out, const std::string& str) + { + out << "&"; + return WriteAliasName(out, str); + } + + bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim) + { + out << (verbatim ? "!<" : "!"); + StringCharSource buffer(str.c_str(), str.size()); + const RegEx& reValid = verbatim ? Exp::URI() : Exp::Tag(); + while(buffer) { + int n = reValid.Match(buffer); + if(n <= 0) + return false; + + while(--n >= 0) { + out << buffer[0]; + ++buffer; + } + } + if (verbatim) + out << ">"; + return true; + } + + bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, const std::string& tag) + { + out << "!"; + StringCharSource prefixBuffer(prefix.c_str(), prefix.size()); + while(prefixBuffer) { + int n = Exp::URI().Match(prefixBuffer); + if(n <= 0) + return false; + + while(--n >= 0) { + out << prefixBuffer[0]; + ++prefixBuffer; + } + } + + out << "!"; + StringCharSource tagBuffer(tag.c_str(), tag.size()); + while(tagBuffer) { + int n = Exp::Tag().Match(tagBuffer); + if(n <= 0) + return false; + + while(--n >= 0) { + out << tagBuffer[0]; + ++tagBuffer; + } + } + return true; + } + + bool WriteBinary(ostream_wrapper& out, const Binary& binary) + { + WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()), false); + return true; + } + } +} + diff --git a/src/third_party/yaml-cpp-0.5.1/src/emitterutils.h b/src/third_party/yaml-cpp-0.5.1/src/emitterutils.h new file mode 100644 index 00000000000..50b37f0477a --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/emitterutils.h @@ -0,0 +1,36 @@ +#ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "emitterstate.h" +#include "yaml-cpp/ostream_wrapper.h" +#include <string> + +namespace YAML +{ + class Binary; + + struct StringFormat { enum value { Plain, SingleQuoted, DoubleQuoted, Literal }; }; + + namespace Utils + { + StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, FlowType::value flowType, bool escapeNonAscii); + + bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str); + bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, bool escapeNonAscii); + bool WriteLiteralString(ostream_wrapper& out, const std::string& str, int indent); + bool WriteChar(ostream_wrapper& out, char ch); + bool WriteComment(ostream_wrapper& out, const std::string& str, int postCommentIndent); + bool WriteAlias(ostream_wrapper& out, const std::string& str); + bool WriteAnchor(ostream_wrapper& out, const std::string& str); + bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim); + bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, const std::string& tag); + bool WriteBinary(ostream_wrapper& out, const Binary& binary); + } +} + +#endif // EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/exp.cpp b/src/third_party/yaml-cpp-0.5.1/src/exp.cpp new file mode 100644 index 00000000000..7bc545466fa --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/exp.cpp @@ -0,0 +1,113 @@ +#include "exp.h" +#include "yaml-cpp/exceptions.h" +#include <sstream> + +namespace YAML +{ + namespace Exp + { + unsigned ParseHex(const std::string& str, const Mark& mark) + { + unsigned value = 0; + for(std::size_t i=0;i<str.size();i++) { + char ch = str[i]; + int digit = 0; + if('a' <= ch && ch <= 'f') + digit = ch - 'a' + 10; + else if('A' <= ch && ch <= 'F') + digit = ch - 'A' + 10; + else if('0' <= ch && ch <= '9') + digit = ch - '0'; + else + throw ParserException(mark, ErrorMsg::INVALID_HEX); + + value = (value << 4) + digit; + } + + return value; + } + + std::string Str(unsigned ch) + { + return std::string(1, static_cast<char>(ch)); + } + + // Escape + // . Translates the next 'codeLength' characters into a hex number and returns the result. + // . Throws if it's not actually hex. + std::string Escape(Stream& in, int codeLength) + { + // grab string + std::string str; + for(int i=0;i<codeLength;i++) + str += in.get(); + + // get the value + unsigned value = ParseHex(str, in.mark()); + + // legal unicode? + if((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) { + std::stringstream msg; + msg << ErrorMsg::INVALID_UNICODE << value; + throw ParserException(in.mark(), msg.str()); + } + + // now break it up into chars + if(value <= 0x7F) + return Str(value); + else if(value <= 0x7FF) + return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F)); + else if(value <= 0xFFFF) + return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F)); + else + return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) + + Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F)); + } + + // Escape + // . Escapes the sequence starting 'in' (it must begin with a '\' or single quote) + // and returns the result. + // . Throws if it's an unknown escape character. + std::string Escape(Stream& in) + { + // eat slash + char escape = in.get(); + + // switch on escape character + char ch = in.get(); + + // first do single quote, since it's easier + if(escape == '\'' && ch == '\'') + return "\'"; + + // now do the slash (we're not gonna check if it's a slash - you better pass one!) + switch(ch) { + case '0': return std::string(1, '\x00'); + case 'a': return "\x07"; + case 'b': return "\x08"; + case 't': + case '\t': return "\x09"; + case 'n': return "\x0A"; + case 'v': return "\x0B"; + case 'f': return "\x0C"; + case 'r': return "\x0D"; + case 'e': return "\x1B"; + case ' ': return "\x20"; + case '\"': return "\""; + case '\'': return "\'"; + case '\\': return "\\"; + case '/': return "/"; + case 'N': return "\x85"; + case '_': return "\xA0"; + case 'L': return "\xE2\x80\xA8"; // LS (#x2028) + case 'P': return "\xE2\x80\xA9"; // PS (#x2029) + case 'x': return Escape(in, 2); + case 'u': return Escape(in, 4); + case 'U': return Escape(in, 8); + } + + std::stringstream msg; + throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch); + } + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/exp.h b/src/third_party/yaml-cpp-0.5.1/src/exp.h new file mode 100644 index 00000000000..52bfd0a011f --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/exp.h @@ -0,0 +1,196 @@ +#ifndef EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "regex.h" +#include <string> +#include <ios> +#include "stream.h" + +namespace YAML +{ + //////////////////////////////////////////////////////////////////////////////// + // Here we store a bunch of expressions for matching different parts of the file. + + namespace Exp + { + // misc + inline const RegEx& Space() { + static const RegEx e = RegEx(' '); + return e; + } + inline const RegEx& Tab() { + static const RegEx e = RegEx('\t'); + return e; + } + inline const RegEx& Blank() { + static const RegEx e = Space() || Tab(); + return e; + } + inline const RegEx& Break() { + static const RegEx e = RegEx('\n') || RegEx("\r\n"); + return e; + } + inline const RegEx& BlankOrBreak() { + static const RegEx e = Blank() || Break(); + return e; + } + inline const RegEx& Digit() { + static const RegEx e = RegEx('0', '9'); + return e; + } + inline const RegEx& Alpha() { + static const RegEx e = RegEx('a', 'z') || RegEx('A', 'Z'); + return e; + } + inline const RegEx& AlphaNumeric() { + static const RegEx e = Alpha() || Digit(); + return e; + } + inline const RegEx& Word() { + static const RegEx e = AlphaNumeric() || RegEx('-'); + return e; + } + inline const RegEx& Hex() { + static const RegEx e = Digit() || RegEx('A', 'F') || RegEx('a', 'f'); + return e; + } + // Valid Unicode code points that are not part of c-printable (YAML 1.2, sec. 5.1) + inline const RegEx& NotPrintable() { + static const RegEx e = RegEx(0) || + RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) || + RegEx(0x0E, 0x1F) || + (RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F'))); + return e; + } + inline const RegEx& Utf8_ByteOrderMark() { + static const RegEx e = RegEx("\xEF\xBB\xBF"); + return e; + } + + // actual tags + + inline const RegEx& DocStart() { + static const RegEx e = RegEx("---") + (BlankOrBreak() || RegEx()); + return e; + } + inline const RegEx& DocEnd() { + static const RegEx e = RegEx("...") + (BlankOrBreak() || RegEx()); + return e; + } + inline const RegEx& DocIndicator() { + static const RegEx e = DocStart() || DocEnd(); + return e; + } + inline const RegEx& BlockEntry() { + static const RegEx e = RegEx('-') + (BlankOrBreak() || RegEx()); + return e; + } + inline const RegEx& Key() { + static const RegEx e = RegEx('?') + BlankOrBreak(); + return e; + } + inline const RegEx& KeyInFlow() { + static const RegEx e = RegEx('?') + BlankOrBreak(); + return e; + } + inline const RegEx& Value() { + static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx()); + return e; + } + inline const RegEx& ValueInFlow() { + static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx(",}", REGEX_OR)); + return e; + } + inline const RegEx& ValueInJSONFlow() { + static const RegEx e = RegEx(':'); + return e; + } + inline const RegEx Comment() { + static const RegEx e = RegEx('#'); + return e; + } + inline const RegEx& Anchor() { + static const RegEx e = !(RegEx("[]{},", REGEX_OR) || BlankOrBreak()); + return e; + } + inline const RegEx& AnchorEnd() { + static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak(); + return e; + } + inline const RegEx& URI() { + static const RegEx e = Word() || RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) || (RegEx('%') + Hex() + Hex()); + return e; + } + inline const RegEx& Tag() { + static const RegEx e = Word() || RegEx("#;/?:@&=+$_.~*'", REGEX_OR) || (RegEx('%') + Hex() + Hex()); + return e; + } + + // Plain scalar rules: + // . Cannot start with a blank. + // . Can never start with any of , [ ] { } # & * ! | > \' \" % @ ` + // . In the block context - ? : must be not be followed with a space. + // . In the flow context ? is illegal and : and - must not be followed with a space. + inline const RegEx& PlainScalar() { + static const RegEx e = !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx()))); + return e; + } + inline const RegEx& PlainScalarInFlow() { + static const RegEx e = !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-:", REGEX_OR) + Blank())); + return e; + } + inline const RegEx& EndScalar() { + static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx()); + return e; + } + inline const RegEx& EndScalarInFlow() { + static const RegEx e = (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) || RegEx(",?[]{}", REGEX_OR); + return e; + } + + inline const RegEx& EscSingleQuote() { + static const RegEx e = RegEx("\'\'"); + return e; + } + inline const RegEx& EscBreak() { + static const RegEx e = RegEx('\\') + Break(); + return e; + } + + inline const RegEx& ChompIndicator() { + static const RegEx e = RegEx("+-", REGEX_OR); + return e; + } + inline const RegEx& Chomp() { + static const RegEx e = (ChompIndicator() + Digit()) || (Digit() + ChompIndicator()) || ChompIndicator() || Digit(); + return e; + } + + // and some functions + std::string Escape(Stream& in); + } + + namespace Keys + { + const char Directive = '%'; + const char FlowSeqStart = '['; + const char FlowSeqEnd = ']'; + const char FlowMapStart = '{'; + const char FlowMapEnd = '}'; + const char FlowEntry = ','; + const char Alias = '*'; + const char Anchor = '&'; + const char Tag = '!'; + const char LiteralScalar = '|'; + const char FoldedScalar = '>'; + const char VerbatimTagStart = '<'; + const char VerbatimTagEnd = '>'; + } +} + +#endif // EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/graphbuilder.cpp b/src/third_party/yaml-cpp-0.5.1/src/graphbuilder.cpp new file mode 100644 index 00000000000..ab5159cca1d --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/graphbuilder.cpp @@ -0,0 +1,16 @@ +#include "yaml-cpp/parser.h" +#include "yaml-cpp/contrib/graphbuilder.h" +#include "graphbuilderadapter.h" + +namespace YAML +{ + void *BuildGraphOfNextDocument(Parser& parser, GraphBuilderInterface& graphBuilder) + { + GraphBuilderAdapter eventHandler(graphBuilder); + if (parser.HandleNextDocument(eventHandler)) { + return eventHandler.RootNode(); + } else { + return NULL; + } + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/graphbuilderadapter.cpp b/src/third_party/yaml-cpp-0.5.1/src/graphbuilderadapter.cpp new file mode 100644 index 00000000000..557e97c8929 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/graphbuilderadapter.cpp @@ -0,0 +1,96 @@ +#include "graphbuilderadapter.h" + +namespace YAML +{ + int GraphBuilderAdapter::ContainerFrame::sequenceMarker; + + void GraphBuilderAdapter::OnNull(const Mark& mark, anchor_t anchor) + { + void *pParent = GetCurrentParent(); + void *pNode = m_builder.NewNull(mark, pParent); + RegisterAnchor(anchor, pNode); + + DispositionNode(pNode); + } + + void GraphBuilderAdapter::OnAlias(const Mark& mark, anchor_t anchor) + { + void *pReffedNode = m_anchors.Get(anchor); + DispositionNode(m_builder.AnchorReference(mark, pReffedNode)); + } + + void GraphBuilderAdapter::OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value) + { + void *pParent = GetCurrentParent(); + void *pNode = m_builder.NewScalar(mark, tag, pParent, value); + RegisterAnchor(anchor, pNode); + + DispositionNode(pNode); + } + + void GraphBuilderAdapter::OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor) + { + void *pNode = m_builder.NewSequence(mark, tag, GetCurrentParent()); + m_containers.push(ContainerFrame(pNode)); + RegisterAnchor(anchor, pNode); + } + + void GraphBuilderAdapter::OnSequenceEnd() + { + void *pSequence = m_containers.top().pContainer; + m_containers.pop(); + + DispositionNode(pSequence); + } + + void GraphBuilderAdapter::OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor) + { + void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent()); + m_containers.push(ContainerFrame(pNode, m_pKeyNode)); + m_pKeyNode = NULL; + RegisterAnchor(anchor, pNode); + } + + void GraphBuilderAdapter::OnMapEnd() + { + void *pMap = m_containers.top().pContainer; + m_pKeyNode = m_containers.top().pPrevKeyNode; + m_containers.pop(); + DispositionNode(pMap); + } + + void *GraphBuilderAdapter::GetCurrentParent() const + { + if (m_containers.empty()) { + return NULL; + } + return m_containers.top().pContainer; + } + + void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode) + { + if (anchor) { + m_anchors.Register(anchor, pNode); + } + } + + void GraphBuilderAdapter::DispositionNode(void *pNode) + { + if (m_containers.empty()) { + m_pRootNode = pNode; + return; + } + + void *pContainer = m_containers.top().pContainer; + if (m_containers.top().isMap()) { + if (m_pKeyNode) { + m_builder.AssignInMap(pContainer, m_pKeyNode, pNode); + m_pKeyNode = NULL; + } else { + m_pKeyNode = pNode; + } + } else { + m_builder.AppendToSequence(pContainer, pNode); + } + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/graphbuilderadapter.h b/src/third_party/yaml-cpp-0.5.1/src/graphbuilderadapter.h new file mode 100644 index 00000000000..3ef8ab6c68d --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/graphbuilderadapter.h @@ -0,0 +1,73 @@ +#ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include <cstdlib> +#include <map> +#include <stack> +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/contrib/anchordict.h" +#include "yaml-cpp/contrib/graphbuilder.h" + +namespace YAML +{ + class GraphBuilderAdapter : public EventHandler + { + public: + GraphBuilderAdapter(GraphBuilderInterface& builder) + : m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL) + { + } + + virtual void OnDocumentStart(const Mark& mark) {(void)mark;} + virtual void OnDocumentEnd() {} + + virtual void OnNull(const Mark& mark, anchor_t anchor); + virtual void OnAlias(const Mark& mark, anchor_t anchor); + virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value); + + virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor); + virtual void OnSequenceEnd(); + + virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor); + virtual void OnMapEnd(); + + void *RootNode() const {return m_pRootNode;} + + private: + struct ContainerFrame + { + ContainerFrame(void *pSequence) + : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) + {} + ContainerFrame(void *pMap, void* pPrevKeyNode) + : pContainer(pMap), pPrevKeyNode(pPrevKeyNode) + {} + + void *pContainer; + void *pPrevKeyNode; + + bool isMap() const {return pPrevKeyNode != &sequenceMarker;} + + private: + static int sequenceMarker; + }; + typedef std::stack<ContainerFrame> ContainerStack; + typedef AnchorDict<void*> AnchorMap; + + GraphBuilderInterface& m_builder; + ContainerStack m_containers; + AnchorMap m_anchors; + void *m_pRootNode; + void *m_pKeyNode; + + void *GetCurrentParent() const; + void RegisterAnchor(anchor_t anchor, void *pNode); + void DispositionNode(void *pNode); + }; +} + +#endif // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/indentation.h b/src/third_party/yaml-cpp-0.5.1/src/indentation.h new file mode 100644 index 00000000000..426fcb53848 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/indentation.h @@ -0,0 +1,38 @@ +#ifndef INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/ostream_wrapper.h" +#include <iostream> + +namespace YAML +{ + struct Indentation { + Indentation(unsigned n_): n(n_) {} + unsigned n; + }; + + inline ostream_wrapper& operator << (ostream_wrapper& out, const Indentation& indent) { + for(unsigned i=0;i<indent.n;i++) + out << ' '; + return out; + } + + struct IndentTo { + IndentTo(unsigned n_): n(n_) {} + unsigned n; + }; + + inline ostream_wrapper& operator << (ostream_wrapper& out, const IndentTo& indent) { + while(out.col() < indent.n) + out << ' '; + return out; + } +} + + +#endif // INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/memory.cpp b/src/third_party/yaml-cpp-0.5.1/src/memory.cpp new file mode 100644 index 00000000000..98d0dfb0caa --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/memory.cpp @@ -0,0 +1,29 @@ +#include "yaml-cpp/node/detail/memory.h" +#include "yaml-cpp/node/detail/node.h" + +namespace YAML +{ + namespace detail + { + void memory_holder::merge(memory_holder& rhs) + { + if(m_pMemory == rhs.m_pMemory) + return; + + m_pMemory->merge(*rhs.m_pMemory); + rhs.m_pMemory = m_pMemory; + } + + node& memory::create_node() + { + shared_node pNode(new node); + m_nodes.insert(pNode); + return *pNode; + } + + void memory::merge(const memory& rhs) + { + m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end()); + } + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/node.cpp b/src/third_party/yaml-cpp-0.5.1/src/node.cpp new file mode 100644 index 00000000000..2d21aa9598c --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/node.cpp @@ -0,0 +1,14 @@ +#include "yaml-cpp/node/node.h" +#include "nodebuilder.h" +#include "nodeevents.h" + +namespace YAML +{ + Node Clone(const Node& node) + { + NodeEvents events(node); + NodeBuilder builder; + events.Emit(builder); + return builder.Root(); + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/node_data.cpp b/src/third_party/yaml-cpp-0.5.1/src/node_data.cpp new file mode 100644 index 00000000000..6f82f7b4bf8 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/node_data.cpp @@ -0,0 +1,295 @@ +#include "yaml-cpp/node/detail/node_data.h" +#include "yaml-cpp/node/detail/memory.h" +#include "yaml-cpp/node/detail/node.h" +#include "yaml-cpp/exceptions.h" +#include <sstream> + +namespace YAML +{ + namespace detail + { + std::string node_data::empty_scalar; + + node_data::node_data(): m_isDefined(false), m_type(NodeType::Null), m_seqSize(0) + { + } + + void node_data::mark_defined() + { + if(m_type == NodeType::Undefined) + m_type = NodeType::Null; + m_isDefined = true; + } + + void node_data::set_type(NodeType::value type) + { + if(type == NodeType::Undefined) { + m_type = type; + m_isDefined = false; + return; + } + + + m_isDefined = true; + if(type == m_type) + return; + + m_type = type; + + switch(m_type) { + case NodeType::Null: + break; + case NodeType::Scalar: + m_scalar.clear(); + break; + case NodeType::Sequence: + reset_sequence(); + break; + case NodeType::Map: + reset_map(); + break; + case NodeType::Undefined: + assert(false); + break; + } + } + + void node_data::set_tag(const std::string& tag) + { + m_tag = tag; + } + + void node_data::set_null() + { + m_isDefined = true; + m_type = NodeType::Null; + } + + void node_data::set_scalar(const std::string& scalar) + { + m_isDefined = true; + m_type = NodeType::Scalar; + m_scalar = scalar; + } + + // size/iterator + std::size_t node_data::size() const + { + if(!m_isDefined) + return 0; + + switch(m_type) { + case NodeType::Sequence: compute_seq_size(); return m_seqSize; + case NodeType::Map: compute_map_size(); return m_map.size() - m_undefinedPairs.size(); + default: + return 0; + } + return 0; + } + + void node_data::compute_seq_size() const + { + while(m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined()) + m_seqSize++; + } + + void node_data::compute_map_size() const + { + kv_pairs::iterator it = m_undefinedPairs.begin(); + while(it != m_undefinedPairs.end()) { + kv_pairs::iterator jt = boost::next(it); + if(it->first->is_defined() && it->second->is_defined()) + m_undefinedPairs.erase(it); + it = jt; + } + } + + const_node_iterator node_data::begin() const + { + if(!m_isDefined) + return const_node_iterator(); + + switch(m_type) { + case NodeType::Sequence: return const_node_iterator(m_sequence.begin()); + case NodeType::Map: return const_node_iterator(m_map.begin(), m_map.end()); + default: return const_node_iterator(); + } + } + + node_iterator node_data::begin() + { + if(!m_isDefined) + return node_iterator(); + + switch(m_type) { + case NodeType::Sequence: return node_iterator(m_sequence.begin()); + case NodeType::Map: return node_iterator(m_map.begin(), m_map.end()); + default: return node_iterator(); + } + } + + const_node_iterator node_data::end() const + { + if(!m_isDefined) + return const_node_iterator(); + + switch(m_type) { + case NodeType::Sequence: return const_node_iterator(m_sequence.end()); + case NodeType::Map: return const_node_iterator(m_map.end(), m_map.end()); + default: return const_node_iterator(); + } + } + + node_iterator node_data::end() + { + if(!m_isDefined) + return node_iterator(); + + switch(m_type) { + case NodeType::Sequence: return node_iterator(m_sequence.end()); + case NodeType::Map: return node_iterator(m_map.end(), m_map.end()); + default: return node_iterator(); + } + } + + // sequence + void node_data::push_back(node& node, shared_memory_holder /* pMemory */) + { + if(m_type == NodeType::Undefined || m_type == NodeType::Null) { + m_type = NodeType::Sequence; + reset_sequence(); + } + + if(m_type != NodeType::Sequence) + throw BadPushback(); + + m_sequence.push_back(&node); + } + + void node_data::insert(node& key, node& value, shared_memory_holder pMemory) + { + switch(m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + case NodeType::Sequence: + convert_to_map(pMemory); + break; + case NodeType::Scalar: + throw BadSubscript(); + } + + insert_map_pair(key, value); + } + + // indexing + node& node_data::get(node& key, shared_memory_holder pMemory) const + { + if(m_type != NodeType::Map) + return pMemory->create_node(); + + for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) { + if(it->first->is(key)) + return *it->second; + } + + return pMemory->create_node(); + } + + node& node_data::get(node& key, shared_memory_holder pMemory) + { + switch(m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + case NodeType::Sequence: + convert_to_map(pMemory); + break; + case NodeType::Scalar: + throw BadSubscript(); + } + + for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) { + if(it->first->is(key)) + return *it->second; + } + + node& value = pMemory->create_node(); + insert_map_pair(key, value); + return value; + } + + bool node_data::remove(node& key, shared_memory_holder /* pMemory */) + { + if(m_type != NodeType::Map) + return false; + + for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) { + if(it->first->is(key)) { + m_map.erase(it); + return true; + } + } + + return false; + } + + void node_data::reset_sequence() + { + m_sequence.clear(); + m_seqSize = 0; + } + + void node_data::reset_map() + { + m_map.clear(); + m_undefinedPairs.clear(); + } + + void node_data::insert_map_pair(node& key, node& value) + { + m_map[&key] = &value; + if(!key.is_defined() || !value.is_defined()) + m_undefinedPairs.push_back(kv_pair(&key, &value)); + } + + void node_data::convert_to_map(shared_memory_holder pMemory) + { + switch(m_type) { + case NodeType::Undefined: + case NodeType::Null: + reset_map(); + m_type = NodeType::Map; + break; + case NodeType::Sequence: + convert_sequence_to_map(pMemory); + break; + case NodeType::Map: + break; + case NodeType::Scalar: + assert(false); + break; + } + } + + void node_data::convert_sequence_to_map(shared_memory_holder pMemory) + { + assert(m_type == NodeType::Sequence); + + reset_map(); + for(std::size_t i=0;i<m_sequence.size();i++) { + std::stringstream stream; + stream << i; + + node& key = pMemory->create_node(); + key.set_scalar(stream.str()); + insert_map_pair(key, *m_sequence[i]); + } + + reset_sequence(); + m_type = NodeType::Map; + } + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/nodebuilder.cpp b/src/third_party/yaml-cpp-0.5.1/src/nodebuilder.cpp new file mode 100644 index 00000000000..6735f733e7e --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/nodebuilder.cpp @@ -0,0 +1,138 @@ +#include "nodebuilder.h" +#include "yaml-cpp/mark.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/impl.h" +#include <cassert> + +namespace YAML +{ + NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0) + { + m_anchors.push_back(0); // since the anchors start at 1 + } + + NodeBuilder::~NodeBuilder() + { + } + + Node NodeBuilder::Root() + { + if(!m_pRoot) + return Node(); + + return Node(*m_pRoot, m_pMemory); + } + + void NodeBuilder::OnDocumentStart(const Mark&) + { + } + + void NodeBuilder::OnDocumentEnd() + { + } + + void NodeBuilder::OnNull(const Mark& /* mark */, anchor_t anchor) + { + detail::node& node = Push(anchor); + node.set_null(); + Pop(); + } + + void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) + { + detail::node& node = *m_anchors[anchor]; + Push(node); + Pop(); + } + + void NodeBuilder::OnScalar(const Mark& /* mark */, const std::string& tag, anchor_t anchor, const std::string& value) + { + detail::node& node = Push(anchor); + node.set_scalar(value); + node.set_tag(tag); + Pop(); + } + + void NodeBuilder::OnSequenceStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor) + { + detail::node& node = Push(anchor); + node.set_tag(tag); + node.set_type(NodeType::Sequence); + } + + void NodeBuilder::OnSequenceEnd() + { + Pop(); + } + + void NodeBuilder::OnMapStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor) + { + detail::node& node = Push(anchor); + node.set_type(NodeType::Map); + node.set_tag(tag); + m_mapDepth++; + } + + void NodeBuilder::OnMapEnd() + { + assert(m_mapDepth > 0); + m_mapDepth--; + Pop(); + } + + detail::node& NodeBuilder::Push(anchor_t anchor) + { + detail::node& node = m_pMemory->create_node(); + RegisterAnchor(anchor, node); + Push(node); + return node; + } + + void NodeBuilder::Push(detail::node& node) + { + const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth); + + m_stack.push_back(&node); + if(needsKey) + m_keys.push_back(PushedKey(&node, false)); + } + + void NodeBuilder::Pop() + { + assert(!m_stack.empty()); + if(m_stack.size() == 1) { + m_pRoot = m_stack[0]; + m_stack.pop_back(); + return; + } + + detail::node& node = *m_stack.back(); + m_stack.pop_back(); + + detail::node& collection = *m_stack.back(); + + if(collection.type() == NodeType::Sequence) { + collection.push_back(node, m_pMemory); + } else if(collection.type() == NodeType::Map) { + assert(!m_keys.empty()); + PushedKey& key = m_keys.back(); + if(key.second) { + collection.insert(*key.first, node, m_pMemory); + m_keys.pop_back(); + } else { + key.second = true; + } + } else { + assert(false); + m_stack.clear(); + } + } + + void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) + { + if(anchor) { + assert(anchor == m_anchors.size()); + m_anchors.push_back(&node); + } + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/nodebuilder.h b/src/third_party/yaml-cpp-0.5.1/src/nodebuilder.h new file mode 100644 index 00000000000..cce91d359b6 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/nodebuilder.h @@ -0,0 +1,58 @@ +#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/node/ptr.h" +#include <vector> + +namespace YAML +{ + class Node; + + class NodeBuilder: public EventHandler + { + public: + NodeBuilder(); + virtual ~NodeBuilder(); + + Node Root(); + + virtual void OnDocumentStart(const Mark& mark); + virtual void OnDocumentEnd(); + + virtual void OnNull(const Mark& mark, anchor_t anchor); + virtual void OnAlias(const Mark& mark, anchor_t anchor); + virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value); + + virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor); + virtual void OnSequenceEnd(); + + virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor); + virtual void OnMapEnd(); + + private: + detail::node& Push(anchor_t anchor); + void Push(detail::node& node); + void Pop(); + void RegisterAnchor(anchor_t anchor, detail::node& node); + + private: + detail::shared_memory_holder m_pMemory; + detail::node *m_pRoot; + + typedef std::vector<detail::node *> Nodes; + Nodes m_stack; + Nodes m_anchors; + + typedef std::pair<detail::node *, bool> PushedKey; + std::vector<PushedKey> m_keys; + std::size_t m_mapDepth; + }; +} + +#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/src/nodeevents.cpp b/src/third_party/yaml-cpp-0.5.1/src/nodeevents.cpp new file mode 100644 index 00000000000..721f9c6f4f6 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/nodeevents.cpp @@ -0,0 +1,99 @@ +#include "nodeevents.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/impl.h" +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/mark.h" + +namespace YAML +{ + void NodeEvents::AliasManager::RegisterReference(const detail::node& node) + { + m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor())); + } + + anchor_t NodeEvents::AliasManager::LookupAnchor(const detail::node& node) const + { + AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref()); + if(it == m_anchorByIdentity.end()) + return 0; + return it->second; + } + + NodeEvents::NodeEvents(const Node& node): m_pMemory(node.m_pMemory), m_root(*node.m_pNode) + { + Setup(m_root); + } + + void NodeEvents::Setup(const detail::node& node) + { + int& refCount = m_refCount[node.ref()]; + refCount++; + if(refCount > 1) + return; + + if(node.type() == NodeType::Sequence) { + for(detail::const_node_iterator it=node.begin();it!=node.end();++it) + Setup(**it); + } else if(node.type() == NodeType::Map) { + for(detail::const_node_iterator it=node.begin();it!=node.end();++it) { + Setup(*it->first); + Setup(*it->second); + } + } + } + + void NodeEvents::Emit(EventHandler& handler) + { + AliasManager am; + + handler.OnDocumentStart(Mark()); + Emit(m_root, handler, am); + handler.OnDocumentEnd(); + } + + void NodeEvents::Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const + { + anchor_t anchor = NullAnchor; + if(IsAliased(node)) { + anchor = am.LookupAnchor(node); + if(anchor) { + handler.OnAlias(Mark(), anchor); + return; + } + + am.RegisterReference(node); + anchor = am.LookupAnchor(node); + } + + switch(node.type()) { + case NodeType::Undefined: + break; + case NodeType::Null: + handler.OnNull(Mark(), anchor); + break; + case NodeType::Scalar: + handler.OnScalar(Mark(), node.tag(), anchor, node.scalar()); + break; + case NodeType::Sequence: + handler.OnSequenceStart(Mark(), node.tag(), anchor); + for(detail::const_node_iterator it=node.begin();it!=node.end();++it) + Emit(**it, handler, am); + handler.OnSequenceEnd(); + break; + case NodeType::Map: + handler.OnMapStart(Mark(), node.tag(), anchor); + for(detail::const_node_iterator it=node.begin();it!=node.end();++it) { + Emit(*it->first, handler, am); + Emit(*it->second, handler, am); + } + handler.OnMapEnd(); + break; + } + } + + bool NodeEvents::IsAliased(const detail::node& node) const + { + RefCount::const_iterator it = m_refCount.find(node.ref()); + return it != m_refCount.end() && it->second > 1; + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/nodeevents.h b/src/third_party/yaml-cpp-0.5.1/src/nodeevents.h new file mode 100644 index 00000000000..d1421155312 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/nodeevents.h @@ -0,0 +1,57 @@ +#ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/anchor.h" +#include "yaml-cpp/node/ptr.h" +#include <map> +#include <vector> + +namespace YAML +{ + class EventHandler; + class Node; + + class NodeEvents + { + public: + explicit NodeEvents(const Node& node); + + void Emit(EventHandler& handler); + + private: + class AliasManager { + public: + AliasManager(): m_curAnchor(0) {} + + void RegisterReference(const detail::node& node); + anchor_t LookupAnchor(const detail::node& node) const; + + private: + anchor_t _CreateNewAnchor() { return ++m_curAnchor; } + + private: + typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity; + AnchorByIdentity m_anchorByIdentity; + + anchor_t m_curAnchor; + }; + + void Setup(const detail::node& node); + void Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const; + bool IsAliased(const detail::node& node) const; + + private: + detail::shared_memory_holder m_pMemory; + detail::node& m_root; + + typedef std::map<const detail::node_ref *, int> RefCount; + RefCount m_refCount; + }; +} + +#endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/src/null.cpp b/src/third_party/yaml-cpp-0.5.1/src/null.cpp new file mode 100644 index 00000000000..37f319735c5 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/null.cpp @@ -0,0 +1,6 @@ +#include "yaml-cpp/null.h" + +namespace YAML +{ + _Null Null; +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/ostream_wrapper.cpp b/src/third_party/yaml-cpp-0.5.1/src/ostream_wrapper.cpp new file mode 100644 index 00000000000..15d9f0fd1f0 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/ostream_wrapper.cpp @@ -0,0 +1,56 @@ +#include "yaml-cpp/ostream_wrapper.h" +#include <cstring> +#include <iostream> + +namespace YAML +{ + ostream_wrapper::ostream_wrapper(): m_pStream(0), m_pos(0), m_row(0), m_col(0), m_comment(false) + { + } + + ostream_wrapper::ostream_wrapper(std::ostream& stream): m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) + { + } + + ostream_wrapper::~ostream_wrapper() + { + } + + void ostream_wrapper::write(const std::string& str) + { + if(m_pStream) { + m_pStream->write(str.c_str(), str.size()); + } else { + m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1)); + std::copy(str.begin(), str.end(), &m_buffer[m_pos]); + } + + for(std::size_t i=0;i<str.size();i++) + update_pos(str[i]); + } + + void ostream_wrapper::write(const char *str, std::size_t size) + { + if(m_pStream) { + m_pStream->write(str, size); + } else { + m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1)); + std::copy(str, str + size, &m_buffer[m_pos]); + } + + for(std::size_t i=0;i<size;i++) + update_pos(str[i]); + } + + void ostream_wrapper::update_pos(char ch) + { + m_pos++; + m_col++; + + if(ch == '\n') { + m_row++; + m_col = 0; + m_comment = false; + } + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/parse.cpp b/src/third_party/yaml-cpp-0.5.1/src/parse.cpp new file mode 100644 index 00000000000..1537d55788a --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/parse.cpp @@ -0,0 +1,68 @@ +#include "yaml-cpp/node/parse.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/impl.h" +#include "yaml-cpp/parser.h" +#include "nodebuilder.h" + +#include <fstream> +#include <sstream> + +namespace YAML +{ + Node Load(const std::string& input) { + std::stringstream stream(input); + return Load(stream); + } + + Node Load(const char *input) { + std::stringstream stream(input); + return Load(stream); + } + + Node Load(std::istream& input) { + Parser parser(input); + NodeBuilder builder; + if(!parser.HandleNextDocument(builder)) + return Node(); + + return builder.Root(); + } + + Node LoadFile(const std::string& filename) { + std::ifstream fin(filename.c_str()); + if(!fin) + throw BadFile(); + return Load(fin); + } + + std::vector<Node> LoadAll(const std::string& input) { + std::stringstream stream(input); + return LoadAll(stream); + } + + std::vector<Node> LoadAll(const char *input) { + std::stringstream stream(input); + return LoadAll(stream); + } + + std::vector<Node> LoadAll(std::istream& input) { + std::vector<Node> docs; + + Parser parser(input); + while(1) { + NodeBuilder builder; + if(!parser.HandleNextDocument(builder)) + break; + docs.push_back(builder.Root()); + } + + return docs; + } + + std::vector<Node> LoadAllFromFile(const std::string& filename) { + std::ifstream fin(filename.c_str()); + if(!fin) + throw BadFile(); + return LoadAll(fin); + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/parser.cpp b/src/third_party/yaml-cpp-0.5.1/src/parser.cpp new file mode 100644 index 00000000000..7861ec17fb8 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/parser.cpp @@ -0,0 +1,141 @@ +#include "yaml-cpp/parser.h" +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/exceptions.h" +#include "directives.h" +#include "scanner.h" +#include "singledocparser.h" +#include "tag.h" +#include "token.h" +#include <sstream> +#include <cstdio> + +namespace YAML +{ + Parser::Parser() + { + } + + Parser::Parser(std::istream& in) + { + Load(in); + } + + Parser::~Parser() + { + } + + Parser::operator bool() const + { + return m_pScanner.get() && !m_pScanner->empty(); + } + + void Parser::Load(std::istream& in) + { + m_pScanner.reset(new Scanner(in)); + m_pDirectives.reset(new Directives); + } + + // HandleNextDocument + // . Handles the next document + // . Throws a ParserException on error. + // . Returns false if there are no more documents + bool Parser::HandleNextDocument(EventHandler& eventHandler) + { + if(!m_pScanner.get()) + return false; + + ParseDirectives(); + if(m_pScanner->empty()) + return false; + + SingleDocParser sdp(*m_pScanner, *m_pDirectives); + sdp.HandleDocument(eventHandler); + return true; + } + + // ParseDirectives + // . Reads any directives that are next in the queue. + void Parser::ParseDirectives() + { + bool readDirective = false; + + while(1) { + if(m_pScanner->empty()) + break; + + Token& token = m_pScanner->peek(); + if(token.type != Token::DIRECTIVE) + break; + + // we keep the directives from the last document if none are specified; + // but if any directives are specific, then we reset them + if(!readDirective) + m_pDirectives.reset(new Directives); + + readDirective = true; + HandleDirective(token); + m_pScanner->pop(); + } + } + + void Parser::HandleDirective(const Token& token) + { + if(token.value == "YAML") + HandleYamlDirective(token); + else if(token.value == "TAG") + HandleTagDirective(token); + } + + // HandleYamlDirective + // . Should be of the form 'major.minor' (like a version number) + void Parser::HandleYamlDirective(const Token& token) + { + if(token.params.size() != 1) + throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS); + + if(!m_pDirectives->version.isDefault) + throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE); + + std::stringstream str(token.params[0]); + str >> m_pDirectives->version.major; + str.get(); + str >> m_pDirectives->version.minor; + if(!str || str.peek() != EOF) + throw ParserException(token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]); + + if(m_pDirectives->version.major > 1) + throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION); + + m_pDirectives->version.isDefault = false; + // TODO: warning on major == 1, minor > 2? + } + + // HandleTagDirective + // . Should be of the form 'handle prefix', where 'handle' is converted to 'prefix' in the file. + void Parser::HandleTagDirective(const Token& token) + { + if(token.params.size() != 2) + throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS); + + const std::string& handle = token.params[0]; + const std::string& prefix = token.params[1]; + if(m_pDirectives->tags.find(handle) != m_pDirectives->tags.end()) + throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE); + + m_pDirectives->tags[handle] = prefix; + } + + void Parser::PrintTokens(std::ostream& out) + { + if(!m_pScanner.get()) + return; + + while(1) { + if(m_pScanner->empty()) + break; + + out << m_pScanner->peek() << "\n"; + m_pScanner->pop(); + } + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/ptr_stack.h b/src/third_party/yaml-cpp-0.5.1/src/ptr_stack.h new file mode 100644 index 00000000000..eec0fb89d38 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/ptr_stack.h @@ -0,0 +1,49 @@ +#ifndef PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/noncopyable.h" +#include <cstddef> +#include <cstdlib> +#include <memory> +#include <vector> + +template <typename T> +class ptr_stack: private YAML::noncopyable +{ +public: + ptr_stack() {} + ~ptr_stack() { clear(); } + + void clear() { + for(unsigned i=0;i<m_data.size();i++) + delete m_data[i]; + m_data.clear(); + } + + std::size_t size() const { return m_data.size(); } + bool empty() const { return m_data.empty(); } + + void push(std::auto_ptr<T> t) { + m_data.push_back(NULL); + m_data.back() = t.release(); + } + std::auto_ptr<T> pop() { + std::auto_ptr<T> t(m_data.back()); + m_data.pop_back(); + return t; + } + T& top() { return *m_data.back(); } + const T& top() const { return *m_data.back(); } + + T& top(std::ptrdiff_t diff) { return **(m_data.end() - 1 + diff); } + const T& top(std::ptrdiff_t diff) const { return **(m_data.end() - 1 + diff); } + +private: + std::vector<T*> m_data; +}; + +#endif // PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/ptr_vector.h b/src/third_party/yaml-cpp-0.5.1/src/ptr_vector.h new file mode 100644 index 00000000000..7b936cb5fed --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/ptr_vector.h @@ -0,0 +1,47 @@ +#ifndef PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/noncopyable.h" +#include <cstddef> +#include <cstdlib> +#include <memory> +#include <vector> + +namespace YAML { + + template <typename T> + class ptr_vector: private YAML::noncopyable + { + public: + ptr_vector() {} + ~ptr_vector() { clear(); } + + void clear() { + for(unsigned i=0;i<m_data.size();i++) + delete m_data[i]; + m_data.clear(); + } + + std::size_t size() const { return m_data.size(); } + bool empty() const { return m_data.empty(); } + + void push_back(std::auto_ptr<T> t) { + m_data.push_back(NULL); + m_data.back() = t.release(); + } + T& operator[](std::size_t i) { return *m_data[i]; } + const T& operator[](std::size_t i) const { return *m_data[i]; } + + T& back() { return *m_data.back(); } + const T& back() const { return *m_data.back(); } + + private: + std::vector<T*> m_data; + }; +} + +#endif // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/regex.cpp b/src/third_party/yaml-cpp-0.5.1/src/regex.cpp new file mode 100644 index 00000000000..b35b1f43354 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/regex.cpp @@ -0,0 +1,60 @@ +#include "regex.h" + +namespace YAML +{ + // constructors + RegEx::RegEx(): m_op(REGEX_EMPTY) + { + } + + RegEx::RegEx(REGEX_OP op): m_op(op) + { + } + + RegEx::RegEx(char ch): m_op(REGEX_MATCH), m_a(ch) + { + } + + RegEx::RegEx(char a, char z): m_op(REGEX_RANGE), m_a(a), m_z(z) + { + } + + RegEx::RegEx(const std::string& str, REGEX_OP op): m_op(op) + { + for(std::size_t i=0;i<str.size();i++) + m_params.push_back(RegEx(str[i])); + } + + // combination constructors + RegEx operator ! (const RegEx& ex) + { + RegEx ret(REGEX_NOT); + ret.m_params.push_back(ex); + return ret; + } + + RegEx operator || (const RegEx& ex1, const RegEx& ex2) + { + RegEx ret(REGEX_OR); + ret.m_params.push_back(ex1); + ret.m_params.push_back(ex2); + return ret; + } + + RegEx operator && (const RegEx& ex1, const RegEx& ex2) + { + RegEx ret(REGEX_AND); + ret.m_params.push_back(ex1); + ret.m_params.push_back(ex2); + return ret; + } + + RegEx operator + (const RegEx& ex1, const RegEx& ex2) + { + RegEx ret(REGEX_SEQ); + ret.m_params.push_back(ex1); + ret.m_params.push_back(ex2); + return ret; + } +} + diff --git a/src/third_party/yaml-cpp-0.5.1/src/regex.h b/src/third_party/yaml-cpp-0.5.1/src/regex.h new file mode 100644 index 00000000000..8722e62666b --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/regex.h @@ -0,0 +1,67 @@ +#ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <vector> +#include <string> + +namespace YAML +{ + class Stream; + + enum REGEX_OP { REGEX_EMPTY, REGEX_MATCH, REGEX_RANGE, REGEX_OR, REGEX_AND, REGEX_NOT, REGEX_SEQ }; + + // simplified regular expressions + // . Only straightforward matches (no repeated characters) + // . Only matches from start of string + class RegEx + { + public: + RegEx(); + RegEx(char ch); + RegEx(char a, char z); + RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ); + ~RegEx() {} + + friend RegEx operator ! (const RegEx& ex); + friend RegEx operator || (const RegEx& ex1, const RegEx& ex2); + friend RegEx operator && (const RegEx& ex1, const RegEx& ex2); + friend RegEx operator + (const RegEx& ex1, const RegEx& ex2); + + bool Matches(char ch) const; + bool Matches(const std::string& str) const; + bool Matches(const Stream& in) const; + template <typename Source> bool Matches(const Source& source) const; + + int Match(const std::string& str) const; + int Match(const Stream& in) const; + template <typename Source> int Match(const Source& source) const; + + private: + RegEx(REGEX_OP op); + + template <typename Source> bool IsValidSource(const Source& source) const; + template <typename Source> int MatchUnchecked(const Source& source) const; + + template <typename Source> int MatchOpEmpty(const Source& source) const; + template <typename Source> int MatchOpMatch(const Source& source) const; + template <typename Source> int MatchOpRange(const Source& source) const; + template <typename Source> int MatchOpOr(const Source& source) const; + template <typename Source> int MatchOpAnd(const Source& source) const; + template <typename Source> int MatchOpNot(const Source& source) const; + template <typename Source> int MatchOpSeq(const Source& source) const; + + private: + REGEX_OP m_op; + char m_a, m_z; + std::vector <RegEx> m_params; + }; +} + +#include "regeximpl.h" + +#endif // REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/regeximpl.h b/src/third_party/yaml-cpp-0.5.1/src/regeximpl.h new file mode 100644 index 00000000000..d5c20d74c8e --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/regeximpl.h @@ -0,0 +1,186 @@ +#ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "stream.h" +#include "stringsource.h" +#include "streamcharsource.h" + +namespace YAML +{ + // query matches + inline bool RegEx::Matches(char ch) const { + std::string str; + str += ch; + return Matches(str); + } + + inline bool RegEx::Matches(const std::string& str) const { + return Match(str) >= 0; + } + + inline bool RegEx::Matches(const Stream& in) const { + return Match(in) >= 0; + } + + template <typename Source> + inline bool RegEx::Matches(const Source& source) const { + return Match(source) >= 0; + } + + // Match + // . Matches the given string against this regular expression. + // . Returns the number of characters matched. + // . Returns -1 if no characters were matched (the reason for + // not returning zero is that we may have an empty regex + // which is ALWAYS successful at matching zero characters). + // . REMEMBER that we only match from the start of the buffer! + inline int RegEx::Match(const std::string& str) const + { + StringCharSource source(str.c_str(), str.size()); + return Match(source); + } + + inline int RegEx::Match(const Stream& in) const + { + StreamCharSource source(in); + return Match(source); + } + + template <typename Source> + inline bool RegEx::IsValidSource(const Source& source) const + { + return source; + } + + template<> + inline bool RegEx::IsValidSource<StringCharSource>(const StringCharSource&source) const + { + switch(m_op) { + case REGEX_MATCH: + case REGEX_RANGE: + return source; + default: + return true; + } + } + + template <typename Source> + inline int RegEx::Match(const Source& source) const + { + return IsValidSource(source) ? MatchUnchecked(source) : -1; + } + + template <typename Source> + inline int RegEx::MatchUnchecked(const Source& source) const + { + switch(m_op) { + case REGEX_EMPTY: + return MatchOpEmpty(source); + case REGEX_MATCH: + return MatchOpMatch(source); + case REGEX_RANGE: + return MatchOpRange(source); + case REGEX_OR: + return MatchOpOr(source); + case REGEX_AND: + return MatchOpAnd(source); + case REGEX_NOT: + return MatchOpNot(source); + case REGEX_SEQ: + return MatchOpSeq(source); + } + + return -1; + } + + ////////////////////////////////////////////////////////////////////////////// + // Operators + // Note: the convention MatchOp*<Source> is that we can assume IsSourceValid(source). + // So we do all our checks *before* we call these functions + + // EmptyOperator + template <typename Source> + inline int RegEx::MatchOpEmpty(const Source& source) const { + return source[0] == Stream::eof() ? 0 : -1; + } + + template <> + inline int RegEx::MatchOpEmpty<StringCharSource>(const StringCharSource& source) const { + return !source ? 0 : -1; // the empty regex only is successful on the empty string + } + + // MatchOperator + template <typename Source> + inline int RegEx::MatchOpMatch(const Source& source) const { + if(source[0] != m_a) + return -1; + return 1; + } + + // RangeOperator + template <typename Source> + inline int RegEx::MatchOpRange(const Source& source) const { + if(m_a > source[0] || m_z < source[0]) + return -1; + return 1; + } + + // OrOperator + template <typename Source> + inline int RegEx::MatchOpOr(const Source& source) const { + for(std::size_t i=0;i<m_params.size();i++) { + int n = m_params[i].MatchUnchecked(source); + if(n >= 0) + return n; + } + return -1; + } + + // AndOperator + // Note: 'AND' is a little funny, since we may be required to match things + // of different lengths. If we find a match, we return the length of + // the FIRST entry on the list. + template <typename Source> + inline int RegEx::MatchOpAnd(const Source& source) const { + int first = -1; + for(std::size_t i=0;i<m_params.size();i++) { + int n = m_params[i].MatchUnchecked(source); + if(n == -1) + return -1; + if(i == 0) + first = n; + } + return first; + } + + // NotOperator + template <typename Source> + inline int RegEx::MatchOpNot(const Source& source) const { + if(m_params.empty()) + return -1; + if(m_params[0].MatchUnchecked(source) >= 0) + return -1; + return 1; + } + + // SeqOperator + template <typename Source> + inline int RegEx::MatchOpSeq(const Source& source) const { + int offset = 0; + for(std::size_t i=0;i<m_params.size();i++) { + int n = m_params[i].Match(source + offset); // note Match, not MatchUnchecked because we need to check validity after the offset + if(n == -1) + return -1; + offset += n; + } + + return offset; + } +} + +#endif // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/scanner.cpp b/src/third_party/yaml-cpp-0.5.1/src/scanner.cpp new file mode 100644 index 00000000000..66cce0af9e8 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/scanner.cpp @@ -0,0 +1,394 @@ +#include "scanner.h" +#include "token.h" +#include "yaml-cpp/exceptions.h" +#include "exp.h" +#include <cassert> +#include <memory> + +namespace YAML +{ + Scanner::Scanner(std::istream& in) + : INPUT(in), m_startedStream(false), m_endedStream(false), m_simpleKeyAllowed(false), m_canBeJSONFlow(false) + { + } + + Scanner::~Scanner() + { + } + + // empty + // . Returns true if there are no more tokens to be read + bool Scanner::empty() + { + EnsureTokensInQueue(); + return m_tokens.empty(); + } + + // pop + // . Simply removes the next token on the queue. + void Scanner::pop() + { + EnsureTokensInQueue(); + if(!m_tokens.empty()) + m_tokens.pop(); + } + + // peek + // . Returns (but does not remove) the next token on the queue. + Token& Scanner::peek() + { + EnsureTokensInQueue(); + assert(!m_tokens.empty()); // should we be asserting here? I mean, we really just be checking + // if it's empty before peeking. + +#if 0 + static Token *pLast = 0; + if(pLast != &m_tokens.front()) + std::cerr << "peek: " << m_tokens.front() << "\n"; + pLast = &m_tokens.front(); +#endif + + return m_tokens.front(); + } + + // mark + // . Returns the current mark in the stream + Mark Scanner::mark() const + { + return INPUT.mark(); + } + + // EnsureTokensInQueue + // . Scan until there's a valid token at the front of the queue, + // or we're sure the queue is empty. + void Scanner::EnsureTokensInQueue() + { + while(1) { + if(!m_tokens.empty()) { + Token& token = m_tokens.front(); + + // if this guy's valid, then we're done + if(token.status == Token::VALID) + return; + + // here's where we clean up the impossible tokens + if(token.status == Token::INVALID) { + m_tokens.pop(); + continue; + } + + // note: what's left are the unverified tokens + } + + // no token? maybe we've actually finished + if(m_endedStream) + return; + + // no? then scan... + ScanNextToken(); + } + } + + // ScanNextToken + // . The main scanning function; here we branch out and + // scan whatever the next token should be. + void Scanner::ScanNextToken() + { + if(m_endedStream) + return; + + if(!m_startedStream) + return StartStream(); + + // get rid of whitespace, etc. (in between tokens it should be irrelevent) + ScanToNextToken(); + + // maybe need to end some blocks + PopIndentToHere(); + + // ***** + // And now branch based on the next few characters! + // ***** + + // end of stream + if(!INPUT) + return EndStream(); + + if(INPUT.column() == 0 && INPUT.peek() == Keys::Directive) + return ScanDirective(); + + // document token + if(INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) + return ScanDocStart(); + + if(INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) + return ScanDocEnd(); + + // flow start/end/entry + if(INPUT.peek() == Keys::FlowSeqStart || INPUT.peek() == Keys::FlowMapStart) + return ScanFlowStart(); + + if(INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) + return ScanFlowEnd(); + + if(INPUT.peek() == Keys::FlowEntry) + return ScanFlowEntry(); + + // block/map stuff + if(Exp::BlockEntry().Matches(INPUT)) + return ScanBlockEntry(); + + if((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) + return ScanKey(); + + if(GetValueRegex().Matches(INPUT)) + return ScanValue(); + + // alias/anchor + if(INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) + return ScanAnchorOrAlias(); + + // tag + if(INPUT.peek() == Keys::Tag) + return ScanTag(); + + // special scalars + if(InBlockContext() && (INPUT.peek() == Keys::LiteralScalar || INPUT.peek() == Keys::FoldedScalar)) + return ScanBlockScalar(); + + if(INPUT.peek() == '\'' || INPUT.peek() == '\"') + return ScanQuotedScalar(); + + // plain scalars + if((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow()).Matches(INPUT)) + return ScanPlainScalar(); + + // don't know what it is! + throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN); + } + + // ScanToNextToken + // . Eats input until we reach the next token-like thing. + void Scanner::ScanToNextToken() + { + while(1) { + // first eat whitespace + while(INPUT && IsWhitespaceToBeEaten(INPUT.peek())) { + if(InBlockContext() && Exp::Tab().Matches(INPUT)) + m_simpleKeyAllowed = false; + INPUT.eat(1); + } + + // then eat a comment + if(Exp::Comment().Matches(INPUT)) { + // eat until line break + while(INPUT && !Exp::Break().Matches(INPUT)) + INPUT.eat(1); + } + + // if it's NOT a line break, then we're done! + if(!Exp::Break().Matches(INPUT)) + break; + + // otherwise, let's eat the line break and keep going + int n = Exp::Break().Match(INPUT); + INPUT.eat(n); + + // oh yeah, and let's get rid of that simple key + InvalidateSimpleKey(); + + // new line - we may be able to accept a simple key now + if(InBlockContext()) + m_simpleKeyAllowed = true; + } + } + + /////////////////////////////////////////////////////////////////////// + // Misc. helpers + + // IsWhitespaceToBeEaten + // . We can eat whitespace if it's a space or tab + // . Note: originally tabs in block context couldn't be eaten + // "where a simple key could be allowed + // (i.e., not at the beginning of a line, or following '-', '?', or ':')" + // I think this is wrong, since tabs can be non-content whitespace; it's just + // that they can't contribute to indentation, so once you've seen a tab in a + // line, you can't start a simple key + bool Scanner::IsWhitespaceToBeEaten(char ch) + { + if(ch == ' ') + return true; + + if(ch == '\t') + return true; + + return false; + } + + // GetValueRegex + // . Get the appropriate regex to check if it's a value token + const RegEx& Scanner::GetValueRegex() const + { + if(InBlockContext()) + return Exp::Value(); + + return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow(); + } + + // StartStream + // . Set the initial conditions for starting a stream. + void Scanner::StartStream() + { + m_startedStream = true; + m_simpleKeyAllowed = true; + std::auto_ptr<IndentMarker> pIndent(new IndentMarker(-1, IndentMarker::NONE)); + m_indentRefs.push_back(pIndent); + m_indents.push(&m_indentRefs.back()); + } + + // EndStream + // . Close out the stream, finish up, etc. + void Scanner::EndStream() + { + // force newline + if(INPUT.column() > 0) + INPUT.ResetColumn(); + + PopAllIndents(); + PopAllSimpleKeys(); + + m_simpleKeyAllowed = false; + m_endedStream = true; + } + + Token *Scanner::PushToken(Token::TYPE type) + { + m_tokens.push(Token(type, INPUT.mark())); + return &m_tokens.back(); + } + + Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const + { + switch(type) { + case IndentMarker::SEQ: return Token::BLOCK_SEQ_START; + case IndentMarker::MAP: return Token::BLOCK_MAP_START; + case IndentMarker::NONE: assert(false); break; + } + assert(false); + throw std::runtime_error("yaml-cpp: internal error, invalid indent type"); + } + + // PushIndentTo + // . Pushes an indentation onto the stack, and enqueues the + // proper token (sequence start or mapping start). + // . Returns the indent marker it generates (if any). + Scanner::IndentMarker *Scanner::PushIndentTo(int column, IndentMarker::INDENT_TYPE type) + { + // are we in flow? + if(InFlowContext()) + return 0; + + std::auto_ptr<IndentMarker> pIndent(new IndentMarker(column, type)); + IndentMarker& indent = *pIndent; + const IndentMarker& lastIndent = *m_indents.top(); + + // is this actually an indentation? + if(indent.column < lastIndent.column) + return 0; + if(indent.column == lastIndent.column && !(indent.type == IndentMarker::SEQ && lastIndent.type == IndentMarker::MAP)) + return 0; + + // push a start token + indent.pStartToken = PushToken(GetStartTokenFor(type)); + + // and then the indent + m_indents.push(&indent); + m_indentRefs.push_back(pIndent); + return &m_indentRefs.back(); + } + + // PopIndentToHere + // . Pops indentations off the stack until we reach the current indentation level, + // and enqueues the proper token each time. + // . Then pops all invalid indentations off. + void Scanner::PopIndentToHere() + { + // are we in flow? + if(InFlowContext()) + return; + + // now pop away + while(!m_indents.empty()) { + const IndentMarker& indent = *m_indents.top(); + if(indent.column < INPUT.column()) + break; + if(indent.column == INPUT.column() && !(indent.type == IndentMarker::SEQ && !Exp::BlockEntry().Matches(INPUT))) + break; + + PopIndent(); + } + + while(!m_indents.empty() && m_indents.top()->status == IndentMarker::INVALID) + PopIndent(); + } + + // PopAllIndents + // . Pops all indentations (except for the base empty one) off the stack, + // and enqueues the proper token each time. + void Scanner::PopAllIndents() + { + // are we in flow? + if(InFlowContext()) + return; + + // now pop away + while(!m_indents.empty()) { + const IndentMarker& indent = *m_indents.top(); + if(indent.type == IndentMarker::NONE) + break; + + PopIndent(); + } + } + + // PopIndent + // . Pops a single indent, pushing the proper token + void Scanner::PopIndent() + { + const IndentMarker& indent = *m_indents.top(); + m_indents.pop(); + + if(indent.status != IndentMarker::VALID) { + InvalidateSimpleKey(); + return; + } + + if(indent.type == IndentMarker::SEQ) + m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark())); + else if(indent.type == IndentMarker::MAP) + m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark())); + } + + // GetTopIndent + int Scanner::GetTopIndent() const + { + if(m_indents.empty()) + return 0; + return m_indents.top()->column; + } + + // ThrowParserException + // . Throws a ParserException with the current token location + // (if available). + // . Does not parse any more tokens. + void Scanner::ThrowParserException(const std::string& msg) const + { + Mark mark = Mark::null_mark(); + if(!m_tokens.empty()) { + const Token& token = m_tokens.front(); + mark = token.mark; + } + throw ParserException(mark, msg); + } +} + diff --git a/src/third_party/yaml-cpp-0.5.1/src/scanner.h b/src/third_party/yaml-cpp-0.5.1/src/scanner.h new file mode 100644 index 00000000000..fe71124c5c6 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/scanner.h @@ -0,0 +1,133 @@ +#ifndef SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <ios> +#include <string> +#include <queue> +#include <stack> +#include <set> +#include <map> +#include "ptr_vector.h" +#include "stream.h" +#include "token.h" + +namespace YAML +{ + class Node; + class RegEx; + + class Scanner + { + public: + Scanner(std::istream& in); + ~Scanner(); + + // token queue management (hopefully this looks kinda stl-ish) + bool empty(); + void pop(); + Token& peek(); + Mark mark() const; + + private: + struct IndentMarker { + enum INDENT_TYPE { MAP, SEQ, NONE }; + enum STATUS { VALID, INVALID, UNKNOWN }; + IndentMarker(int column_, INDENT_TYPE type_): column(column_), type(type_), status(VALID), pStartToken(0) {} + + int column; + INDENT_TYPE type; + STATUS status; + Token *pStartToken; + }; + + enum FLOW_MARKER { FLOW_MAP, FLOW_SEQ }; + + private: + // scanning + void EnsureTokensInQueue(); + void ScanNextToken(); + void ScanToNextToken(); + void StartStream(); + void EndStream(); + Token *PushToken(Token::TYPE type); + + bool InFlowContext() const { return !m_flows.empty(); } + bool InBlockContext() const { return m_flows.empty(); } + int GetFlowLevel() const { return m_flows.size(); } + + Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const; + IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type); + void PopIndentToHere(); + void PopAllIndents(); + void PopIndent(); + int GetTopIndent() const; + + // checking input + bool CanInsertPotentialSimpleKey() const; + bool ExistsActiveSimpleKey() const; + void InsertPotentialSimpleKey(); + void InvalidateSimpleKey(); + bool VerifySimpleKey(); + void PopAllSimpleKeys(); + + void ThrowParserException(const std::string& msg) const; + + bool IsWhitespaceToBeEaten(char ch); + const RegEx& GetValueRegex() const; + + struct SimpleKey { + SimpleKey(const Mark& mark_, int flowLevel_); + + void Validate(); + void Invalidate(); + + Mark mark; + int flowLevel; + IndentMarker *pIndent; + Token *pMapStart, *pKey; + }; + + // and the tokens + void ScanDirective(); + void ScanDocStart(); + void ScanDocEnd(); + void ScanBlockSeqStart(); + void ScanBlockMapSTart(); + void ScanBlockEnd(); + void ScanBlockEntry(); + void ScanFlowStart(); + void ScanFlowEnd(); + void ScanFlowEntry(); + void ScanKey(); + void ScanValue(); + void ScanAnchorOrAlias(); + void ScanTag(); + void ScanPlainScalar(); + void ScanQuotedScalar(); + void ScanBlockScalar(); + + private: + // the stream + Stream INPUT; + + // the output (tokens) + std::queue<Token> m_tokens; + + // state info + bool m_startedStream, m_endedStream; + bool m_simpleKeyAllowed; + bool m_canBeJSONFlow; + std::stack<SimpleKey> m_simpleKeys; + std::stack<IndentMarker *> m_indents; + ptr_vector<IndentMarker> m_indentRefs; // for "garbage collection" + std::stack<FLOW_MARKER> m_flows; + }; +} + +#endif // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/src/scanscalar.cpp b/src/third_party/yaml-cpp-0.5.1/src/scanscalar.cpp new file mode 100644 index 00000000000..064c0867a59 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/scanscalar.cpp @@ -0,0 +1,214 @@ +#include "scanscalar.h" +#include "scanner.h" +#include "exp.h" +#include "yaml-cpp/exceptions.h" +#include "token.h" + +namespace YAML +{ + // ScanScalar + // . This is where the scalar magic happens. + // + // . We do the scanning in three phases: + // 1. Scan until newline + // 2. Eat newline + // 3. Scan leading blanks. + // + // . Depending on the parameters given, we store or stop + // and different places in the above flow. + std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) + { + bool foundNonEmptyLine = false; + bool pastOpeningBreak = (params.fold == FOLD_FLOW); + bool emptyLine = false, moreIndented = false; + int foldedNewlineCount = 0; + bool foldedNewlineStartedMoreIndented = false; + std::size_t lastEscapedChar = std::string::npos; + std::string scalar; + params.leadingSpaces = false; + + while(INPUT) { + // ******************************** + // Phase #1: scan until line ending + + std::size_t lastNonWhitespaceChar = scalar.size(); + bool escapedNewline = false; + while(!params.end.Matches(INPUT) && !Exp::Break().Matches(INPUT)) { + if(!INPUT) + break; + + // document indicator? + if(INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) { + if(params.onDocIndicator == BREAK) + break; + else if(params.onDocIndicator == THROW) + throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR); + } + + foundNonEmptyLine = true; + pastOpeningBreak = true; + + // escaped newline? (only if we're escaping on slash) + if(params.escape == '\\' && Exp::EscBreak().Matches(INPUT)) { + // eat escape character and get out (but preserve trailing whitespace!) + INPUT.get(); + lastNonWhitespaceChar = scalar.size(); + lastEscapedChar = scalar.size(); + escapedNewline = true; + break; + } + + // escape this? + if(INPUT.peek() == params.escape) { + scalar += Exp::Escape(INPUT); + lastNonWhitespaceChar = scalar.size(); + lastEscapedChar = scalar.size(); + continue; + } + + // otherwise, just add the damn character + char ch = INPUT.get(); + scalar += ch; + if(ch != ' ' && ch != '\t') + lastNonWhitespaceChar = scalar.size(); + } + + // eof? if we're looking to eat something, then we throw + if(!INPUT) { + if(params.eatEnd) + throw ParserException(INPUT.mark(), ErrorMsg::EOF_IN_SCALAR); + break; + } + + // doc indicator? + if(params.onDocIndicator == BREAK && INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) + break; + + // are we done via character match? + int n = params.end.Match(INPUT); + if(n >= 0) { + if(params.eatEnd) + INPUT.eat(n); + break; + } + + // do we remove trailing whitespace? + if(params.fold == FOLD_FLOW) + scalar.erase(lastNonWhitespaceChar); + + // ******************************** + // Phase #2: eat line ending + n = Exp::Break().Match(INPUT); + INPUT.eat(n); + + // ******************************** + // Phase #3: scan initial spaces + + // first the required indentation + while(INPUT.peek() == ' ' && (INPUT.column() < params.indent || (params.detectIndent && !foundNonEmptyLine))) + INPUT.eat(1); + + // update indent if we're auto-detecting + if(params.detectIndent && !foundNonEmptyLine) + params.indent = std::max(params.indent, INPUT.column()); + + // and then the rest of the whitespace + while(Exp::Blank().Matches(INPUT)) { + // we check for tabs that masquerade as indentation + if(INPUT.peek() == '\t'&& INPUT.column() < params.indent && params.onTabInIndentation == THROW) + throw ParserException(INPUT.mark(), ErrorMsg::TAB_IN_INDENTATION); + + if(!params.eatLeadingWhitespace) + break; + + INPUT.eat(1); + } + + // was this an empty line? + bool nextEmptyLine = Exp::Break().Matches(INPUT); + bool nextMoreIndented = Exp::Blank().Matches(INPUT); + if(params.fold == FOLD_BLOCK && foldedNewlineCount == 0 && nextEmptyLine) + foldedNewlineStartedMoreIndented = moreIndented; + + // for block scalars, we always start with a newline, so we should ignore it (not fold or keep) + if(pastOpeningBreak) { + switch(params.fold) { + case DONT_FOLD: + scalar += "\n"; + break; + case FOLD_BLOCK: + if(!emptyLine && !nextEmptyLine && !moreIndented && !nextMoreIndented && INPUT.column() >= params.indent) + scalar += " "; + else if(nextEmptyLine) + foldedNewlineCount++; + else + scalar += "\n"; + + if(!nextEmptyLine && foldedNewlineCount > 0) { + scalar += std::string(foldedNewlineCount - 1, '\n'); + if(foldedNewlineStartedMoreIndented || nextMoreIndented | !foundNonEmptyLine) + scalar += "\n"; + foldedNewlineCount = 0; + } + break; + case FOLD_FLOW: + if(nextEmptyLine) + scalar += "\n"; + else if(!emptyLine && !nextEmptyLine && !escapedNewline) + scalar += " "; + break; + } + } + + emptyLine = nextEmptyLine; + moreIndented = nextMoreIndented; + pastOpeningBreak = true; + + // are we done via indentation? + if(!emptyLine && INPUT.column() < params.indent) { + params.leadingSpaces = true; + break; + } + } + + // post-processing + if(params.trimTrailingSpaces) { + std::size_t pos = scalar.find_last_not_of(' '); + if(lastEscapedChar != std::string::npos) { + if(pos < lastEscapedChar || pos == std::string::npos) + pos = lastEscapedChar; + } + if(pos < scalar.size()) + scalar.erase(pos + 1); + } + + switch(params.chomp) { + case CLIP: { + std::size_t pos = scalar.find_last_not_of('\n'); + if(lastEscapedChar != std::string::npos) { + if(pos < lastEscapedChar || pos == std::string::npos) + pos = lastEscapedChar; + } + if(pos == std::string::npos) + scalar.erase(); + else if(pos + 1 < scalar.size()) + scalar.erase(pos + 2); + } break; + case STRIP: { + std::size_t pos = scalar.find_last_not_of('\n'); + if(lastEscapedChar != std::string::npos) { + if(pos < lastEscapedChar || pos == std::string::npos) + pos = lastEscapedChar; + } + if(pos == std::string::npos) + scalar.erase(); + else if(pos < scalar.size()) + scalar.erase(pos + 1); + } break; + default: + break; + } + + return scalar; + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/scanscalar.h b/src/third_party/yaml-cpp-0.5.1/src/scanscalar.h new file mode 100644 index 00000000000..c198cb18b4b --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/scanscalar.h @@ -0,0 +1,45 @@ +#ifndef SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <string> +#include "regex.h" +#include "stream.h" + +namespace YAML +{ + enum CHOMP { STRIP = -1, CLIP, KEEP }; + enum ACTION { NONE, BREAK, THROW }; + enum FOLD { DONT_FOLD, FOLD_BLOCK, FOLD_FLOW }; + + struct ScanScalarParams { + ScanScalarParams(): eatEnd(false), indent(0), detectIndent(false), eatLeadingWhitespace(0), escape(0), fold(DONT_FOLD), + trimTrailingSpaces(0), chomp(CLIP), onDocIndicator(NONE), onTabInIndentation(NONE), leadingSpaces(false) {} + + // input: + RegEx end; // what condition ends this scalar? + bool eatEnd; // should we eat that condition when we see it? + int indent; // what level of indentation should be eaten and ignored? + bool detectIndent; // should we try to autodetect the indent? + bool eatLeadingWhitespace; // should we continue eating this delicious indentation after 'indent' spaces? + char escape; // what character do we escape on (i.e., slash or single quote) (0 for none) + FOLD fold; // how do we fold line ends? + bool trimTrailingSpaces; // do we remove all trailing spaces (at the very end) + CHOMP chomp; // do we strip, clip, or keep trailing newlines (at the very end) + // Note: strip means kill all, clip means keep at most one, keep means keep all + ACTION onDocIndicator; // what do we do if we see a document indicator? + ACTION onTabInIndentation; // what do we do if we see a tab where we should be seeing indentation spaces + + // output: + bool leadingSpaces; + }; + + std::string ScanScalar(Stream& INPUT, ScanScalarParams& info); +} + +#endif // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/src/scantag.cpp b/src/third_party/yaml-cpp-0.5.1/src/scantag.cpp new file mode 100644 index 00000000000..b71cbcc49f4 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/scantag.cpp @@ -0,0 +1,84 @@ +#include "scanner.h" +#include "regex.h" +#include "exp.h" +#include "yaml-cpp/exceptions.h" + +namespace YAML +{ + const std::string ScanVerbatimTag(Stream& INPUT) + { + std::string tag; + + // eat the start character + INPUT.get(); + + while(INPUT) { + if(INPUT.peek() == Keys::VerbatimTagEnd) { + // eat the end character + INPUT.get(); + return tag; + } + + int n = Exp::URI().Match(INPUT); + if(n <= 0) + break; + + tag += INPUT.get(n); + } + + throw ParserException(INPUT.mark(), ErrorMsg::END_OF_VERBATIM_TAG); + } + + const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle) + { + std::string tag; + canBeHandle = true; + Mark firstNonWordChar; + + while(INPUT) { + if(INPUT.peek() == Keys::Tag) { + if(!canBeHandle) + throw ParserException(firstNonWordChar, ErrorMsg::CHAR_IN_TAG_HANDLE); + break; + } + + int n = 0; + if(canBeHandle) { + n = Exp::Word().Match(INPUT); + if(n <= 0) { + canBeHandle = false; + firstNonWordChar = INPUT.mark(); + } + } + + if(!canBeHandle) + n = Exp::Tag().Match(INPUT); + + if(n <= 0) + break; + + tag += INPUT.get(n); + } + + return tag; + } + + const std::string ScanTagSuffix(Stream& INPUT) + { + std::string tag; + + while(INPUT) { + int n = Exp::Tag().Match(INPUT); + if(n <= 0) + break; + + tag += INPUT.get(n); + } + + if(tag.empty()) + throw ParserException(INPUT.mark(), ErrorMsg::TAG_WITH_NO_SUFFIX); + + return tag; + } +} + diff --git a/src/third_party/yaml-cpp-0.5.1/src/scantag.h b/src/third_party/yaml-cpp-0.5.1/src/scantag.h new file mode 100644 index 00000000000..38437c039df --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/scantag.h @@ -0,0 +1,20 @@ +#ifndef SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <string> +#include "stream.h" + +namespace YAML +{ + const std::string ScanVerbatimTag(Stream& INPUT); + const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle); + const std::string ScanTagSuffix(Stream& INPUT); +} + +#endif // SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + diff --git a/src/third_party/yaml-cpp-0.5.1/src/scantoken.cpp b/src/third_party/yaml-cpp-0.5.1/src/scantoken.cpp new file mode 100644 index 00000000000..06d9cd623d6 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/scantoken.cpp @@ -0,0 +1,439 @@ +#include "scanner.h" +#include "token.h" +#include "yaml-cpp/exceptions.h" +#include "exp.h" +#include "scanscalar.h" +#include "scantag.h" +#include "tag.h" +#include <sstream> + +namespace YAML +{ + /////////////////////////////////////////////////////////////////////// + // Specialization for scanning specific tokens + + // Directive + // . Note: no semantic checking is done here (that's for the parser to do) + void Scanner::ScanDirective() + { + std::string name; + std::vector <std::string> params; + + // pop indents and simple keys + PopAllIndents(); + PopAllSimpleKeys(); + + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + // store pos and eat indicator + Token token(Token::DIRECTIVE, INPUT.mark()); + INPUT.eat(1); + + // read name + while(INPUT && !Exp::BlankOrBreak().Matches(INPUT)) + token.value += INPUT.get(); + + // read parameters + while(1) { + // first get rid of whitespace + while(Exp::Blank().Matches(INPUT)) + INPUT.eat(1); + + // break on newline or comment + if(!INPUT || Exp::Break().Matches(INPUT) || Exp::Comment().Matches(INPUT)) + break; + + // now read parameter + std::string param; + while(INPUT && !Exp::BlankOrBreak().Matches(INPUT)) + param += INPUT.get(); + + token.params.push_back(param); + } + + m_tokens.push(token); + } + + // DocStart + void Scanner::ScanDocStart() + { + PopAllIndents(); + PopAllSimpleKeys(); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(3); + m_tokens.push(Token(Token::DOC_START, mark)); + } + + // DocEnd + void Scanner::ScanDocEnd() + { + PopAllIndents(); + PopAllSimpleKeys(); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(3); + m_tokens.push(Token(Token::DOC_END, mark)); + } + + // FlowStart + void Scanner::ScanFlowStart() + { + // flows can be simple keys + InsertPotentialSimpleKey(); + m_simpleKeyAllowed = true; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + char ch = INPUT.get(); + FLOW_MARKER flowType = (ch == Keys::FlowSeqStart ? FLOW_SEQ : FLOW_MAP); + m_flows.push(flowType); + Token::TYPE type = (flowType == FLOW_SEQ ? Token::FLOW_SEQ_START : Token::FLOW_MAP_START); + m_tokens.push(Token(type, mark)); + } + + // FlowEnd + void Scanner::ScanFlowEnd() + { + if(InBlockContext()) + throw ParserException(INPUT.mark(), ErrorMsg::FLOW_END); + + // we might have a solo entry in the flow context + if(InFlowContext()) { + if(m_flows.top() == FLOW_MAP && VerifySimpleKey()) + m_tokens.push(Token(Token::VALUE, INPUT.mark())); + else if(m_flows.top() == FLOW_SEQ) + InvalidateSimpleKey(); + } + + m_simpleKeyAllowed = false; + m_canBeJSONFlow = true; + + // eat + Mark mark = INPUT.mark(); + char ch = INPUT.get(); + + // check that it matches the start + FLOW_MARKER flowType = (ch == Keys::FlowSeqEnd ? FLOW_SEQ : FLOW_MAP); + if(m_flows.top() != flowType) + throw ParserException(mark, ErrorMsg::FLOW_END); + m_flows.pop(); + + Token::TYPE type = (flowType ? Token::FLOW_SEQ_END : Token::FLOW_MAP_END); + m_tokens.push(Token(type, mark)); + } + + // FlowEntry + void Scanner::ScanFlowEntry() + { + // we might have a solo entry in the flow context + if(InFlowContext()) { + if(m_flows.top() == FLOW_MAP && VerifySimpleKey()) + m_tokens.push(Token(Token::VALUE, INPUT.mark())); + else if(m_flows.top() == FLOW_SEQ) + InvalidateSimpleKey(); + } + + m_simpleKeyAllowed = true; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(1); + m_tokens.push(Token(Token::FLOW_ENTRY, mark)); + } + + // BlockEntry + void Scanner::ScanBlockEntry() + { + // we better be in the block context! + if(InFlowContext()) + throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY); + + // can we put it here? + if(!m_simpleKeyAllowed) + throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY); + + PushIndentTo(INPUT.column(), IndentMarker::SEQ); + m_simpleKeyAllowed = true; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(1); + m_tokens.push(Token(Token::BLOCK_ENTRY, mark)); + } + + // Key + void Scanner::ScanKey() + { + // handle keys diffently in the block context (and manage indents) + if(InBlockContext()) { + if(!m_simpleKeyAllowed) + throw ParserException(INPUT.mark(), ErrorMsg::MAP_KEY); + + PushIndentTo(INPUT.column(), IndentMarker::MAP); + } + + // can only put a simple key here if we're in block context + m_simpleKeyAllowed = InBlockContext(); + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(1); + m_tokens.push(Token(Token::KEY, mark)); + } + + // Value + void Scanner::ScanValue() + { + // and check that simple key + bool isSimpleKey = VerifySimpleKey(); + m_canBeJSONFlow = false; + + if(isSimpleKey) { + // can't follow a simple key with another simple key (dunno why, though - it seems fine) + m_simpleKeyAllowed = false; + } else { + // handle values diffently in the block context (and manage indents) + if(InBlockContext()) { + if(!m_simpleKeyAllowed) + throw ParserException(INPUT.mark(), ErrorMsg::MAP_VALUE); + + PushIndentTo(INPUT.column(), IndentMarker::MAP); + } + + // can only put a simple key here if we're in block context + m_simpleKeyAllowed = InBlockContext(); + } + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(1); + m_tokens.push(Token(Token::VALUE, mark)); + } + + // AnchorOrAlias + void Scanner::ScanAnchorOrAlias() + { + bool alias; + std::string name; + + // insert a potential simple key + InsertPotentialSimpleKey(); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + // eat the indicator + Mark mark = INPUT.mark(); + char indicator = INPUT.get(); + alias = (indicator == Keys::Alias); + + // now eat the content + while(INPUT && Exp::Anchor().Matches(INPUT)) + name += INPUT.get(); + + // we need to have read SOMETHING! + if(name.empty()) + throw ParserException(INPUT.mark(), alias ? ErrorMsg::ALIAS_NOT_FOUND : ErrorMsg::ANCHOR_NOT_FOUND); + + // and needs to end correctly + if(INPUT && !Exp::AnchorEnd().Matches(INPUT)) + throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS : ErrorMsg::CHAR_IN_ANCHOR); + + // and we're done + Token token(alias ? Token::ALIAS : Token::ANCHOR, mark); + token.value = name; + m_tokens.push(token); + } + + // Tag + void Scanner::ScanTag() + { + // insert a potential simple key + InsertPotentialSimpleKey(); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + Token token(Token::TAG, INPUT.mark()); + + // eat the indicator + INPUT.get(); + + if(INPUT && INPUT.peek() == Keys::VerbatimTagStart){ + std::string tag = ScanVerbatimTag(INPUT); + + token.value = tag; + token.data = Tag::VERBATIM; + } else { + bool canBeHandle; + token.value = ScanTagHandle(INPUT, canBeHandle); + if(!canBeHandle && token.value.empty()) + token.data = Tag::NON_SPECIFIC; + else if(token.value.empty()) + token.data = Tag::SECONDARY_HANDLE; + else + token.data = Tag::PRIMARY_HANDLE; + + // is there a suffix? + if(canBeHandle && INPUT.peek() == Keys::Tag) { + // eat the indicator + INPUT.get(); + token.params.push_back(ScanTagSuffix(INPUT)); + token.data = Tag::NAMED_HANDLE; + } + } + + m_tokens.push(token); + } + + // PlainScalar + void Scanner::ScanPlainScalar() + { + std::string scalar; + + // set up the scanning parameters + ScanScalarParams params; + params.end = (InFlowContext() ? Exp::EndScalarInFlow() : Exp::EndScalar()) || (Exp::BlankOrBreak() + Exp::Comment()); + params.eatEnd = false; + params.indent = (InFlowContext() ? 0 : GetTopIndent() + 1); + params.fold = FOLD_FLOW; + params.eatLeadingWhitespace = true; + params.trimTrailingSpaces = true; + params.chomp = STRIP; + params.onDocIndicator = BREAK; + params.onTabInIndentation = THROW; + + // insert a potential simple key + InsertPotentialSimpleKey(); + + Mark mark = INPUT.mark(); + scalar = ScanScalar(INPUT, params); + + // can have a simple key only if we ended the scalar by starting a new line + m_simpleKeyAllowed = params.leadingSpaces; + m_canBeJSONFlow = false; + + // finally, check and see if we ended on an illegal character + //if(Exp::IllegalCharInScalar.Matches(INPUT)) + // throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_SCALAR); + + Token token(Token::PLAIN_SCALAR, mark); + token.value = scalar; + m_tokens.push(token); + } + + // QuotedScalar + void Scanner::ScanQuotedScalar() + { + std::string scalar; + + // peek at single or double quote (don't eat because we need to preserve (for the time being) the input position) + char quote = INPUT.peek(); + bool single = (quote == '\''); + + // setup the scanning parameters + ScanScalarParams params; + params.end = (single ? RegEx(quote) && !Exp::EscSingleQuote() : RegEx(quote)); + params.eatEnd = true; + params.escape = (single ? '\'' : '\\'); + params.indent = 0; + params.fold = FOLD_FLOW; + params.eatLeadingWhitespace = true; + params.trimTrailingSpaces = false; + params.chomp = CLIP; + params.onDocIndicator = THROW; + + // insert a potential simple key + InsertPotentialSimpleKey(); + + Mark mark = INPUT.mark(); + + // now eat that opening quote + INPUT.get(); + + // and scan + scalar = ScanScalar(INPUT, params); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = true; + + Token token(Token::NON_PLAIN_SCALAR, mark); + token.value = scalar; + m_tokens.push(token); + } + + // BlockScalarToken + // . These need a little extra processing beforehand. + // . We need to scan the line where the indicator is (this doesn't count as part of the scalar), + // and then we need to figure out what level of indentation we'll be using. + void Scanner::ScanBlockScalar() + { + std::string scalar; + + ScanScalarParams params; + params.indent = 1; + params.detectIndent = true; + + // eat block indicator ('|' or '>') + Mark mark = INPUT.mark(); + char indicator = INPUT.get(); + params.fold = (indicator == Keys::FoldedScalar ? FOLD_BLOCK : DONT_FOLD); + + // eat chomping/indentation indicators + params.chomp = CLIP; + int n = Exp::Chomp().Match(INPUT); + for(int i=0;i<n;i++) { + char ch = INPUT.get(); + if(ch == '+') + params.chomp = KEEP; + else if(ch == '-') + params.chomp = STRIP; + else if(Exp::Digit().Matches(ch)) { + if(ch == '0') + throw ParserException(INPUT.mark(), ErrorMsg::ZERO_INDENT_IN_BLOCK); + + params.indent = ch - '0'; + params.detectIndent = false; + } + } + + // now eat whitespace + while(Exp::Blank().Matches(INPUT)) + INPUT.eat(1); + + // and comments to the end of the line + if(Exp::Comment().Matches(INPUT)) + while(INPUT && !Exp::Break().Matches(INPUT)) + INPUT.eat(1); + + // if it's not a line break, then we ran into a bad character inline + if(INPUT && !Exp::Break().Matches(INPUT)) + throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_BLOCK); + + // set the initial indentation + if(GetTopIndent() >= 0) + params.indent += GetTopIndent(); + + params.eatLeadingWhitespace = false; + params.trimTrailingSpaces = false; + params.onTabInIndentation = THROW; + + scalar = ScanScalar(INPUT, params); + + // simple keys always ok after block scalars (since we're gonna start a new line anyways) + m_simpleKeyAllowed = true; + m_canBeJSONFlow = false; + + Token token(Token::NON_PLAIN_SCALAR, mark); + token.value = scalar; + m_tokens.push(token); + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/setting.h b/src/third_party/yaml-cpp-0.5.1/src/setting.h new file mode 100644 index 00000000000..806ccdae96d --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/setting.h @@ -0,0 +1,105 @@ +#ifndef SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <memory> +#include <vector> +#include "yaml-cpp/noncopyable.h" + +namespace YAML +{ + class SettingChangeBase; + + template <typename T> + class Setting + { + public: + Setting(): m_value() {} + + const T get() const { return m_value; } + std::auto_ptr <SettingChangeBase> set(const T& value); + void restore(const Setting<T>& oldSetting) { + m_value = oldSetting.get(); + } + + private: + T m_value; + }; + + class SettingChangeBase + { + public: + virtual ~SettingChangeBase() {} + virtual void pop() = 0; + }; + + template <typename T> + class SettingChange: public SettingChangeBase + { + public: + SettingChange(Setting<T> *pSetting): m_pCurSetting(pSetting) { + // copy old setting to save its state + m_oldSetting = *pSetting; + } + + virtual void pop() { + m_pCurSetting->restore(m_oldSetting); + } + + private: + Setting<T> *m_pCurSetting; + Setting<T> m_oldSetting; + }; + + template <typename T> + inline std::auto_ptr <SettingChangeBase> Setting<T>::set(const T& value) { + std::auto_ptr <SettingChangeBase> pChange(new SettingChange<T> (this)); + m_value = value; + return pChange; + } + + class SettingChanges: private noncopyable + { + public: + SettingChanges() {} + ~SettingChanges() { clear(); } + + void clear() { + restore(); + + for(setting_changes::const_iterator it=m_settingChanges.begin();it!=m_settingChanges.end();++it) + delete *it; + m_settingChanges.clear(); + } + + void restore() { + for(setting_changes::const_iterator it=m_settingChanges.begin();it!=m_settingChanges.end();++it) + (*it)->pop(); + } + + void push(std::auto_ptr <SettingChangeBase> pSettingChange) { + m_settingChanges.push_back(pSettingChange.release()); + } + + // like std::auto_ptr - assignment is transfer of ownership + SettingChanges& operator = (SettingChanges& rhs) { + if(this == &rhs) + return *this; + + clear(); + m_settingChanges = rhs.m_settingChanges; + rhs.m_settingChanges.clear(); + return *this; + } + + private: + typedef std::vector <SettingChangeBase *> setting_changes; + setting_changes m_settingChanges; + }; +} + +#endif // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/simplekey.cpp b/src/third_party/yaml-cpp-0.5.1/src/simplekey.cpp new file mode 100644 index 00000000000..857a9e0b8d7 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/simplekey.cpp @@ -0,0 +1,139 @@ +#include "scanner.h" +#include "token.h" +#include "yaml-cpp/exceptions.h" +#include "exp.h" + +namespace YAML +{ + Scanner::SimpleKey::SimpleKey(const Mark& mark_, int flowLevel_) + : mark(mark_), flowLevel(flowLevel_), pIndent(0), pMapStart(0), pKey(0) + { + } + + void Scanner::SimpleKey::Validate() + { + // Note: pIndent will *not* be garbage here; + // we "garbage collect" them so we can + // always refer to them + if(pIndent) + pIndent->status = IndentMarker::VALID; + if(pMapStart) + pMapStart->status = Token::VALID; + if(pKey) + pKey->status = Token::VALID; + } + + void Scanner::SimpleKey::Invalidate() + { + if(pIndent) + pIndent->status = IndentMarker::INVALID; + if(pMapStart) + pMapStart->status = Token::INVALID; + if(pKey) + pKey->status = Token::INVALID; + } + + // CanInsertPotentialSimpleKey + bool Scanner::CanInsertPotentialSimpleKey() const + { + if(!m_simpleKeyAllowed) + return false; + + return !ExistsActiveSimpleKey(); + } + + // ExistsActiveSimpleKey + // . Returns true if there's a potential simple key at our flow level + // (there's allowed at most one per flow level, i.e., at the start of the flow start token) + bool Scanner::ExistsActiveSimpleKey() const + { + if(m_simpleKeys.empty()) + return false; + + const SimpleKey& key = m_simpleKeys.top(); + return key.flowLevel == GetFlowLevel(); + } + + // InsertPotentialSimpleKey + // . If we can, add a potential simple key to the queue, + // and save it on a stack. + void Scanner::InsertPotentialSimpleKey() + { + if(!CanInsertPotentialSimpleKey()) + return; + + SimpleKey key(INPUT.mark(), GetFlowLevel()); + + // first add a map start, if necessary + if(InBlockContext()) { + key.pIndent = PushIndentTo(INPUT.column(), IndentMarker::MAP); + if(key.pIndent) { + key.pIndent->status = IndentMarker::UNKNOWN; + key.pMapStart = key.pIndent->pStartToken; + key.pMapStart->status = Token::UNVERIFIED; + } + } + + // then add the (now unverified) key + m_tokens.push(Token(Token::KEY, INPUT.mark())); + key.pKey = &m_tokens.back(); + key.pKey->status = Token::UNVERIFIED; + + m_simpleKeys.push(key); + } + + // InvalidateSimpleKey + // . Automatically invalidate the simple key in our flow level + void Scanner::InvalidateSimpleKey() + { + if(m_simpleKeys.empty()) + return; + + // grab top key + SimpleKey& key = m_simpleKeys.top(); + if(key.flowLevel != GetFlowLevel()) + return; + + key.Invalidate(); + m_simpleKeys.pop(); + } + + // VerifySimpleKey + // . Determines whether the latest simple key to be added is valid, + // and if so, makes it valid. + bool Scanner::VerifySimpleKey() + { + if(m_simpleKeys.empty()) + return false; + + // grab top key + SimpleKey key = m_simpleKeys.top(); + + // only validate if we're in the correct flow level + if(key.flowLevel != GetFlowLevel()) + return false; + + m_simpleKeys.pop(); + + bool isValid = true; + + // needs to be less than 1024 characters and inline + if(INPUT.line() != key.mark.line || INPUT.pos() - key.mark.pos > 1024) + isValid = false; + + // invalidate key + if(isValid) + key.Validate(); + else + key.Invalidate(); + + return isValid; + } + + void Scanner::PopAllSimpleKeys() + { + while(!m_simpleKeys.empty()) + m_simpleKeys.pop(); + } +} + diff --git a/src/third_party/yaml-cpp-0.5.1/src/singledocparser.cpp b/src/third_party/yaml-cpp-0.5.1/src/singledocparser.cpp new file mode 100644 index 00000000000..e9f3222f1ad --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/singledocparser.cpp @@ -0,0 +1,394 @@ +#include "singledocparser.h" +#include "collectionstack.h" +#include "directives.h" +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/exceptions.h" +#include "scanner.h" +#include "tag.h" +#include "token.h" +#include <sstream> +#include <cstdio> +#include <algorithm> + +namespace YAML +{ + SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives): m_scanner(scanner), m_directives(directives), m_pCollectionStack(new CollectionStack), m_curAnchor(0) + { + } + + SingleDocParser::~SingleDocParser() + { + } + + // HandleDocument + // . Handles the next document + // . Throws a ParserException on error. + void SingleDocParser::HandleDocument(EventHandler& eventHandler) + { + assert(!m_scanner.empty()); // guaranteed that there are tokens + assert(!m_curAnchor); + + eventHandler.OnDocumentStart(m_scanner.peek().mark); + + // eat doc start + if(m_scanner.peek().type == Token::DOC_START) + m_scanner.pop(); + + // recurse! + HandleNode(eventHandler); + + eventHandler.OnDocumentEnd(); + + // and finally eat any doc ends we see + while(!m_scanner.empty() && m_scanner.peek().type == Token::DOC_END) + m_scanner.pop(); + } + + void SingleDocParser::HandleNode(EventHandler& eventHandler) + { + // an empty node *is* a possibility + if(m_scanner.empty()) { + eventHandler.OnNull(m_scanner.mark(), NullAnchor); + return; + } + + // save location + Mark mark = m_scanner.peek().mark; + + // special case: a value node by itself must be a map, with no header + if(m_scanner.peek().type == Token::VALUE) { + eventHandler.OnMapStart(mark, "?", NullAnchor); + HandleMap(eventHandler); + eventHandler.OnMapEnd(); + return; + } + + // special case: an alias node + if(m_scanner.peek().type == Token::ALIAS) { + eventHandler.OnAlias(mark, LookupAnchor(mark, m_scanner.peek().value)); + m_scanner.pop(); + return; + } + + std::string tag; + anchor_t anchor; + ParseProperties(tag, anchor); + + const Token& token = m_scanner.peek(); + + if(token.type == Token::PLAIN_SCALAR && token.value == "null") { + eventHandler.OnNull(mark, anchor); + m_scanner.pop(); + return; + } + + // add non-specific tags + if(tag.empty()) + tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?"); + + // now split based on what kind of node we should be + switch(token.type) { + case Token::PLAIN_SCALAR: + case Token::NON_PLAIN_SCALAR: + eventHandler.OnScalar(mark, tag, anchor, token.value); + m_scanner.pop(); + return; + case Token::FLOW_SEQ_START: + case Token::BLOCK_SEQ_START: + eventHandler.OnSequenceStart(mark, tag, anchor); + HandleSequence(eventHandler); + eventHandler.OnSequenceEnd(); + return; + case Token::FLOW_MAP_START: + case Token::BLOCK_MAP_START: + eventHandler.OnMapStart(mark, tag, anchor); + HandleMap(eventHandler); + eventHandler.OnMapEnd(); + return; + case Token::KEY: + // compact maps can only go in a flow sequence + if(m_pCollectionStack->GetCurCollectionType() == CollectionType::FlowSeq) { + eventHandler.OnMapStart(mark, tag, anchor); + HandleMap(eventHandler); + eventHandler.OnMapEnd(); + return; + } + break; + default: + break; + } + + if(tag == "?") + eventHandler.OnNull(mark, anchor); + else + eventHandler.OnScalar(mark, tag, anchor, ""); + } + + void SingleDocParser::HandleSequence(EventHandler& eventHandler) + { + // split based on start token + switch(m_scanner.peek().type) { + case Token::BLOCK_SEQ_START: HandleBlockSequence(eventHandler); break; + case Token::FLOW_SEQ_START: HandleFlowSequence(eventHandler); break; + default: break; + } + } + + void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) + { + // eat start token + m_scanner.pop(); + m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq); + + while(1) { + if(m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ); + + Token token = m_scanner.peek(); + if(token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END) + throw ParserException(token.mark, ErrorMsg::END_OF_SEQ); + + m_scanner.pop(); + if(token.type == Token::BLOCK_SEQ_END) + break; + + // check for null + if(!m_scanner.empty()) { + const Token& token = m_scanner.peek(); + if(token.type == Token::BLOCK_ENTRY || token.type == Token::BLOCK_SEQ_END) { + eventHandler.OnNull(token.mark, NullAnchor); + continue; + } + } + + HandleNode(eventHandler); + } + + m_pCollectionStack->PopCollectionType(CollectionType::BlockSeq); + } + + void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) + { + // eat start token + m_scanner.pop(); + m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq); + + while(1) { + if(m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW); + + // first check for end + if(m_scanner.peek().type == Token::FLOW_SEQ_END) { + m_scanner.pop(); + break; + } + + // then read the node + HandleNode(eventHandler); + + if(m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW); + + // now eat the separator (or could be a sequence end, which we ignore - but if it's neither, then it's a bad node) + Token& token = m_scanner.peek(); + if(token.type == Token::FLOW_ENTRY) + m_scanner.pop(); + else if(token.type != Token::FLOW_SEQ_END) + throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW); + } + + m_pCollectionStack->PopCollectionType(CollectionType::FlowSeq); + } + + void SingleDocParser::HandleMap(EventHandler& eventHandler) + { + // split based on start token + switch(m_scanner.peek().type) { + case Token::BLOCK_MAP_START: HandleBlockMap(eventHandler); break; + case Token::FLOW_MAP_START: HandleFlowMap(eventHandler); break; + case Token::KEY: HandleCompactMap(eventHandler); break; + case Token::VALUE: HandleCompactMapWithNoKey(eventHandler); break; + default: break; + } + } + + void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) + { + // eat start token + m_scanner.pop(); + m_pCollectionStack->PushCollectionType(CollectionType::BlockMap); + + while(1) { + if(m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP); + + Token token = m_scanner.peek(); + if(token.type != Token::KEY && token.type != Token::VALUE && token.type != Token::BLOCK_MAP_END) + throw ParserException(token.mark, ErrorMsg::END_OF_MAP); + + if(token.type == Token::BLOCK_MAP_END) { + m_scanner.pop(); + break; + } + + // grab key (if non-null) + if(token.type == Token::KEY) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(token.mark, NullAnchor); + } + + // now grab value (optional) + if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(token.mark, NullAnchor); + } + } + + m_pCollectionStack->PopCollectionType(CollectionType::BlockMap); + } + + void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) + { + // eat start token + m_scanner.pop(); + m_pCollectionStack->PushCollectionType(CollectionType::FlowMap); + + while(1) { + if(m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW); + + Token& token = m_scanner.peek(); + const Mark mark = token.mark; + // first check for end + if(token.type == Token::FLOW_MAP_END) { + m_scanner.pop(); + break; + } + + // grab key (if non-null) + if(token.type == Token::KEY) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(mark, NullAnchor); + } + + // now grab value (optional) + if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(mark, NullAnchor); + } + + if(m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW); + + // now eat the separator (or could be a map end, which we ignore - but if it's neither, then it's a bad node) + Token& nextToken = m_scanner.peek(); + if(nextToken.type == Token::FLOW_ENTRY) + m_scanner.pop(); + else if(nextToken.type != Token::FLOW_MAP_END) + throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW); + } + + m_pCollectionStack->PopCollectionType(CollectionType::FlowMap); + } + + // . Single "key: value" pair in a flow sequence + void SingleDocParser::HandleCompactMap(EventHandler& eventHandler) + { + m_pCollectionStack->PushCollectionType(CollectionType::CompactMap); + + // grab key + Mark mark = m_scanner.peek().mark; + m_scanner.pop(); + HandleNode(eventHandler); + + // now grab value (optional) + if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(mark, NullAnchor); + } + + m_pCollectionStack->PopCollectionType(CollectionType::CompactMap); + } + + // . Single ": value" pair in a flow sequence + void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler) + { + m_pCollectionStack->PushCollectionType(CollectionType::CompactMap); + + // null key + eventHandler.OnNull(m_scanner.peek().mark, NullAnchor); + + // grab value + m_scanner.pop(); + HandleNode(eventHandler); + + m_pCollectionStack->PopCollectionType(CollectionType::CompactMap); + } + + // ParseProperties + // . Grabs any tag or anchor tokens and deals with them. + void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor) + { + tag.clear(); + anchor = NullAnchor; + + while(1) { + if(m_scanner.empty()) + return; + + switch(m_scanner.peek().type) { + case Token::TAG: ParseTag(tag); break; + case Token::ANCHOR: ParseAnchor(anchor); break; + default: return; + } + } + } + + void SingleDocParser::ParseTag(std::string& tag) + { + Token& token = m_scanner.peek(); + if(!tag.empty()) + throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS); + + Tag tagInfo(token); + tag = tagInfo.Translate(m_directives); + m_scanner.pop(); + } + + void SingleDocParser::ParseAnchor(anchor_t& anchor) + { + Token& token = m_scanner.peek(); + if(anchor) + throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS); + + anchor = RegisterAnchor(token.value); + m_scanner.pop(); + } + + anchor_t SingleDocParser::RegisterAnchor(const std::string& name) + { + if(name.empty()) + return NullAnchor; + + return m_anchors[name] = ++m_curAnchor; + } + + anchor_t SingleDocParser::LookupAnchor(const Mark& mark, const std::string& name) const + { + Anchors::const_iterator it = m_anchors.find(name); + if(it == m_anchors.end()) + throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR); + + return it->second; + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/singledocparser.h b/src/third_party/yaml-cpp-0.5.1/src/singledocparser.h new file mode 100644 index 00000000000..3798dccf25d --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/singledocparser.h @@ -0,0 +1,65 @@ +#ifndef SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/anchor.h" +#include "yaml-cpp/noncopyable.h" +#include <string> +#include <map> +#include <memory> + +namespace YAML +{ + struct Directives; + struct Mark; + struct Token; + class CollectionStack; + class EventHandler; + class Node; + class Scanner; + + class SingleDocParser: private noncopyable + { + public: + SingleDocParser(Scanner& scanner, const Directives& directives); + ~SingleDocParser(); + + void HandleDocument(EventHandler& eventHandler); + + private: + void HandleNode(EventHandler& eventHandler); + + void HandleSequence(EventHandler& eventHandler); + void HandleBlockSequence(EventHandler& eventHandler); + void HandleFlowSequence(EventHandler& eventHandler); + + void HandleMap(EventHandler& eventHandler); + void HandleBlockMap(EventHandler& eventHandler); + void HandleFlowMap(EventHandler& eventHandler); + void HandleCompactMap(EventHandler& eventHandler); + void HandleCompactMapWithNoKey(EventHandler& eventHandler); + + void ParseProperties(std::string& tag, anchor_t& anchor); + void ParseTag(std::string& tag); + void ParseAnchor(anchor_t& anchor); + + anchor_t RegisterAnchor(const std::string& name); + anchor_t LookupAnchor(const Mark& mark, const std::string& name) const; + + private: + Scanner& m_scanner; + const Directives& m_directives; + std::auto_ptr<CollectionStack> m_pCollectionStack; + + typedef std::map<std::string, anchor_t> Anchors; + Anchors m_anchors; + + anchor_t m_curAnchor; + }; +} + +#endif // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/stream.cpp b/src/third_party/yaml-cpp-0.5.1/src/stream.cpp new file mode 100644 index 00000000000..efab7e2bcc7 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/stream.cpp @@ -0,0 +1,447 @@ +#include "stream.h" +#include <iostream> +#include "exp.h" + +#ifndef YAML_PREFETCH_SIZE +#define YAML_PREFETCH_SIZE 2048 +#endif + +#define S_ARRAY_SIZE( A ) (sizeof(A)/sizeof(*(A))) +#define S_ARRAY_END( A ) ((A) + S_ARRAY_SIZE(A)) + +#define CP_REPLACEMENT_CHARACTER (0xFFFD) + +namespace YAML +{ + enum UtfIntroState { + uis_start, + uis_utfbe_b1, + uis_utf32be_b2, + uis_utf32be_bom3, + uis_utf32be, + uis_utf16be, + uis_utf16be_bom1, + uis_utfle_bom1, + uis_utf16le_bom2, + uis_utf32le_bom3, + uis_utf16le, + uis_utf32le, + uis_utf8_imp, + uis_utf16le_imp, + uis_utf32le_imp3, + uis_utf8_bom1, + uis_utf8_bom2, + uis_utf8, + uis_error + }; + + enum UtfIntroCharType { + uict00, + uictBB, + uictBF, + uictEF, + uictFE, + uictFF, + uictAscii, + uictOther, + uictMax + }; + + static bool s_introFinalState[] = { + false, //uis_start + false, //uis_utfbe_b1 + false, //uis_utf32be_b2 + false, //uis_utf32be_bom3 + true, //uis_utf32be + true, //uis_utf16be + false, //uis_utf16be_bom1 + false, //uis_utfle_bom1 + false, //uis_utf16le_bom2 + false, //uis_utf32le_bom3 + true, //uis_utf16le + true, //uis_utf32le + false, //uis_utf8_imp + false, //uis_utf16le_imp + false, //uis_utf32le_imp3 + false, //uis_utf8_bom1 + false, //uis_utf8_bom2 + true, //uis_utf8 + true, //uis_error + }; + + static UtfIntroState s_introTransitions[][uictMax] = { + // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther + {uis_utfbe_b1, uis_utf8, uis_utf8, uis_utf8_bom1, uis_utf16be_bom1, uis_utfle_bom1, uis_utf8_imp, uis_utf8}, + {uis_utf32be_b2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16be, uis_utf8}, + {uis_utf32be, uis_utf8, uis_utf8, uis_utf8, uis_utf32be_bom3, uis_utf8, uis_utf8, uis_utf8}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf32be, uis_utf8, uis_utf8}, + {uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be}, + {uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16be, uis_utf8, uis_utf8}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16le_bom2, uis_utf8, uis_utf8, uis_utf8}, + {uis_utf32le_bom3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le}, + {uis_utf16le_imp, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8}, + {uis_utf32le_imp3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf8, uis_utf8_bom2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8}, + }; + + static char s_introUngetCount[][uictMax] = { + // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther + {0, 1, 1, 0, 0, 0, 0, 1}, + {0, 2, 2, 2, 2, 2, 2, 2}, + {3, 3, 3, 3, 0, 3, 3, 3}, + {4, 4, 4, 4, 4, 0, 4, 4}, + {1, 1, 1, 1, 1, 1, 1, 1}, + {1, 1, 1, 1, 1, 1, 1, 1}, + {2, 2, 2, 2, 2, 0, 2, 2}, + {2, 2, 2, 2, 0, 2, 2, 2}, + {0, 1, 1, 1, 1, 1, 1, 1}, + {0, 2, 2, 2, 2, 2, 2, 2}, + {1, 1, 1, 1, 1, 1, 1, 1}, + {1, 1, 1, 1, 1, 1, 1, 1}, + {0, 2, 2, 2, 2, 2, 2, 2}, + {0, 3, 3, 3, 3, 3, 3, 3}, + {4, 4, 4, 4, 4, 4, 4, 4}, + {2, 0, 2, 2, 2, 2, 2, 2}, + {3, 3, 0, 3, 3, 3, 3, 3}, + {1, 1, 1, 1, 1, 1, 1, 1}, + }; + + inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) + { + if (std::istream::traits_type::eof() == ch) { + return uictOther; + } + + switch (ch) { + case 0: return uict00; + case 0xBB: return uictBB; + case 0xBF: return uictBF; + case 0xEF: return uictEF; + case 0xFE: return uictFE; + case 0xFF: return uictFF; + } + + if ((ch > 0) && (ch < 0xFF)) { + return uictAscii; + } + + return uictOther; + } + + inline char Utf8Adjust(unsigned long ch, unsigned char lead_bits, unsigned char rshift) + { + const unsigned char header = ((1 << lead_bits) - 1) << (8 - lead_bits); + const unsigned char mask = (0xFF >> (lead_bits + 1)); + return static_cast<char>(static_cast<unsigned char>( + header | ((ch >> rshift) & mask) + )); + } + + inline void QueueUnicodeCodepoint(std::deque<char>& q, unsigned long ch) + { + // We are not allowed to queue the Stream::eof() codepoint, so + // replace it with CP_REPLACEMENT_CHARACTER + if (static_cast<unsigned long>(Stream::eof()) == ch) + { + ch = CP_REPLACEMENT_CHARACTER; + } + + if (ch < 0x80) + { + q.push_back(Utf8Adjust(ch, 0, 0)); + } + else if (ch < 0x800) + { + q.push_back(Utf8Adjust(ch, 2, 6)); + q.push_back(Utf8Adjust(ch, 1, 0)); + } + else if (ch < 0x10000) + { + q.push_back(Utf8Adjust(ch, 3, 12)); + q.push_back(Utf8Adjust(ch, 1, 6)); + q.push_back(Utf8Adjust(ch, 1, 0)); + } + else + { + q.push_back(Utf8Adjust(ch, 4, 18)); + q.push_back(Utf8Adjust(ch, 1, 12)); + q.push_back(Utf8Adjust(ch, 1, 6)); + q.push_back(Utf8Adjust(ch, 1, 0)); + } + } + + Stream::Stream(std::istream& input) + : m_input(input), + m_pPrefetched(new unsigned char[YAML_PREFETCH_SIZE]), + m_nPrefetchedAvailable(0), m_nPrefetchedUsed(0) + { + typedef std::istream::traits_type char_traits; + + if(!input) + return; + + // Determine (or guess) the character-set by reading the BOM, if any. See + // the YAML specification for the determination algorithm. + char_traits::int_type intro[4]; + int nIntroUsed = 0; + UtfIntroState state = uis_start; + for(; !s_introFinalState[state]; ) { + std::istream::int_type ch = input.get(); + intro[nIntroUsed++] = ch; + UtfIntroCharType charType = IntroCharTypeOf(ch); + UtfIntroState newState = s_introTransitions[state][charType]; + int nUngets = s_introUngetCount[state][charType]; + if(nUngets > 0) { + input.clear(); + for(; nUngets > 0; --nUngets) { + if(char_traits::eof() != intro[--nIntroUsed]) + input.putback(char_traits::to_char_type(intro[nIntroUsed])); + } + } + state = newState; + } + + switch (state) { + case uis_utf8: m_charSet = utf8; break; + case uis_utf16le: m_charSet = utf16le; break; + case uis_utf16be: m_charSet = utf16be; break; + case uis_utf32le: m_charSet = utf32le; break; + case uis_utf32be: m_charSet = utf32be; break; + default: m_charSet = utf8; break; + } + + ReadAheadTo(0); + } + + Stream::~Stream() + { + delete[] m_pPrefetched; + } + + char Stream::peek() const + { + if (m_readahead.empty()) + { + return Stream::eof(); + } + + return m_readahead[0]; + } + + Stream::operator bool() const + { + return m_input.good() || (!m_readahead.empty() && m_readahead[0] != Stream::eof()); + } + + // get + // . Extracts a character from the stream and updates our position + char Stream::get() + { + char ch = peek(); + AdvanceCurrent(); + m_mark.column++; + + if(ch == '\n') { + m_mark.column = 0; + m_mark.line++; + } + + return ch; + } + + // get + // . Extracts 'n' characters from the stream and updates our position + std::string Stream::get(int n) + { + std::string ret; + ret.reserve(n); + for(int i=0;i<n;i++) + ret += get(); + return ret; + } + + // eat + // . Eats 'n' characters and updates our position. + void Stream::eat(int n) + { + for(int i=0;i<n;i++) + get(); + } + + void Stream::AdvanceCurrent() + { + if (!m_readahead.empty()) + { + m_readahead.pop_front(); + m_mark.pos++; + } + + ReadAheadTo(0); + } + + bool Stream::_ReadAheadTo(size_t i) const + { + while (m_input.good() && (m_readahead.size() <= i)) + { + switch (m_charSet) + { + case utf8: StreamInUtf8(); break; + case utf16le: StreamInUtf16(); break; + case utf16be: StreamInUtf16(); break; + case utf32le: StreamInUtf32(); break; + case utf32be: StreamInUtf32(); break; + } + } + + // signal end of stream + if(!m_input.good()) + m_readahead.push_back(Stream::eof()); + + return m_readahead.size() > i; + } + + void Stream::StreamInUtf8() const + { + unsigned char b = GetNextByte(); + if (m_input.good()) + { + m_readahead.push_back(b); + } + } + + void Stream::StreamInUtf16() const + { + unsigned long ch = 0; + unsigned char bytes[2]; + int nBigEnd = (m_charSet == utf16be) ? 0 : 1; + + bytes[0] = GetNextByte(); + bytes[1] = GetNextByte(); + if (!m_input.good()) + { + return; + } + ch = (static_cast<unsigned long>(bytes[nBigEnd]) << 8) | + static_cast<unsigned long>(bytes[1 ^ nBigEnd]); + + if (ch >= 0xDC00 && ch < 0xE000) + { + // Trailing (low) surrogate...ugh, wrong order + QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); + return; + } + else if (ch >= 0xD800 && ch < 0xDC00) + { + // ch is a leading (high) surrogate + + // Four byte UTF-8 code point + + // Read the trailing (low) surrogate + for (;;) + { + bytes[0] = GetNextByte(); + bytes[1] = GetNextByte(); + if (!m_input.good()) + { + QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); + return; + } + unsigned long chLow = (static_cast<unsigned long>(bytes[nBigEnd]) << 8) | + static_cast<unsigned long>(bytes[1 ^ nBigEnd]); + if (chLow < 0xDC00 || ch >= 0xE000) + { + // Trouble...not a low surrogate. Dump a REPLACEMENT CHARACTER into the stream. + QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); + + // Deal with the next UTF-16 unit + if (chLow < 0xD800 || ch >= 0xE000) + { + // Easiest case: queue the codepoint and return + QueueUnicodeCodepoint(m_readahead, ch); + return; + } + else + { + // Start the loop over with the new high surrogate + ch = chLow; + continue; + } + } + + // Select the payload bits from the high surrogate + ch &= 0x3FF; + ch <<= 10; + + // Include bits from low surrogate + ch |= (chLow & 0x3FF); + + // Add the surrogacy offset + ch += 0x10000; + } + } + + QueueUnicodeCodepoint(m_readahead, ch); + } + + inline char* ReadBuffer(unsigned char* pBuffer) + { + return reinterpret_cast<char*>(pBuffer); + } + + unsigned char Stream::GetNextByte() const + { + if (m_nPrefetchedUsed >= m_nPrefetchedAvailable) + { + std::streambuf *pBuf = m_input.rdbuf(); + m_nPrefetchedAvailable = static_cast<std::size_t>(pBuf->sgetn(ReadBuffer(m_pPrefetched), YAML_PREFETCH_SIZE)); + m_nPrefetchedUsed = 0; + if (!m_nPrefetchedAvailable) + { + m_input.setstate(std::ios_base::eofbit); + } + + if (0 == m_nPrefetchedAvailable) + { + return 0; + } + } + + return m_pPrefetched[m_nPrefetchedUsed++]; + } + + void Stream::StreamInUtf32() const + { + static int indexes[2][4] = { + {3, 2, 1, 0}, + {0, 1, 2, 3} + }; + + unsigned long ch = 0; + unsigned char bytes[4]; + int* pIndexes = (m_charSet == utf32be) ? indexes[1] : indexes[0]; + + bytes[0] = GetNextByte(); + bytes[1] = GetNextByte(); + bytes[2] = GetNextByte(); + bytes[3] = GetNextByte(); + if (!m_input.good()) + { + return; + } + + for (int i = 0; i < 4; ++i) + { + ch <<= 8; + ch |= bytes[pIndexes[i]]; + } + + QueueUnicodeCodepoint(m_readahead, ch); + } +} diff --git a/src/third_party/yaml-cpp-0.5.1/src/stream.h b/src/third_party/yaml-cpp-0.5.1/src/stream.h new file mode 100644 index 00000000000..87f48dc890e --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/stream.h @@ -0,0 +1,79 @@ +#ifndef STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/noncopyable.h" +#include "yaml-cpp/mark.h" +#include <cstddef> +#include <deque> +#include <ios> +#include <iostream> +#include <set> +#include <string> + +namespace YAML +{ + class Stream: private noncopyable + { + public: + friend class StreamCharSource; + + Stream(std::istream& input); + ~Stream(); + + operator bool() const; + bool operator !() const { return !static_cast <bool>(*this); } + + char peek() const; + char get(); + std::string get(int n); + void eat(int n = 1); + + static char eof() { return 0x04; } + + const Mark mark() const { return m_mark; } + int pos() const { return m_mark.pos; } + int line() const { return m_mark.line; } + int column() const { return m_mark.column; } + void ResetColumn() { m_mark.column = 0; } + + private: + enum CharacterSet {utf8, utf16le, utf16be, utf32le, utf32be}; + + std::istream& m_input; + Mark m_mark; + + CharacterSet m_charSet; + mutable std::deque<char> m_readahead; + unsigned char* const m_pPrefetched; + mutable size_t m_nPrefetchedAvailable; + mutable size_t m_nPrefetchedUsed; + + void AdvanceCurrent(); + char CharAt(size_t i) const; + bool ReadAheadTo(size_t i) const; + bool _ReadAheadTo(size_t i) const; + void StreamInUtf8() const; + void StreamInUtf16() const; + void StreamInUtf32() const; + unsigned char GetNextByte() const; + }; + + // CharAt + // . Unchecked access + inline char Stream::CharAt(size_t i) const { + return m_readahead[i]; + } + + inline bool Stream::ReadAheadTo(size_t i) const { + if(m_readahead.size() > i) + return true; + return _ReadAheadTo(i); + } +} + +#endif // STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/streamcharsource.h b/src/third_party/yaml-cpp-0.5.1/src/streamcharsource.h new file mode 100644 index 00000000000..21fae4e1f56 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/streamcharsource.h @@ -0,0 +1,48 @@ +#ifndef STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/noncopyable.h" +#include <cstddef> + +namespace YAML +{ + class StreamCharSource + { + public: + StreamCharSource(const Stream& stream): m_offset(0), m_stream(stream) {} + StreamCharSource(const StreamCharSource& source): m_offset(source.m_offset), m_stream(source.m_stream) {} + ~StreamCharSource() {} + + operator bool() const; + char operator [] (std::size_t i) const { return m_stream.CharAt(m_offset + i); } + bool operator !() const { return !static_cast<bool>(*this); } + + const StreamCharSource operator + (int i) const; + + private: + std::size_t m_offset; + const Stream& m_stream; + + StreamCharSource& operator = (const StreamCharSource&); // non-assignable + }; + + inline StreamCharSource::operator bool() const { + return m_stream.ReadAheadTo(m_offset); + } + + inline const StreamCharSource StreamCharSource::operator + (int i) const { + StreamCharSource source(*this); + if(static_cast<int> (source.m_offset) + i >= 0) + source.m_offset += i; + else + source.m_offset = 0; + return source; + } +} + +#endif // STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/stringsource.h b/src/third_party/yaml-cpp-0.5.1/src/stringsource.h new file mode 100644 index 00000000000..21be3c9a499 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/stringsource.h @@ -0,0 +1,47 @@ +#ifndef STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include <cstddef> + +namespace YAML +{ + class StringCharSource + { + public: + StringCharSource(const char *str, std::size_t size): m_str(str), m_size(size), m_offset(0) {} + + operator bool() const { return m_offset < m_size; } + char operator [] (std::size_t i) const { return m_str[m_offset + i]; } + bool operator !() const { return !static_cast<bool>(*this); } + + const StringCharSource operator + (int i) const { + StringCharSource source(*this); + if(static_cast<int> (source.m_offset) + i >= 0) + source.m_offset += i; + else + source.m_offset = 0; + return source; + } + + StringCharSource& operator ++ () { + ++m_offset; + return *this; + } + + StringCharSource& operator += (std::size_t offset) { + m_offset += offset; + return *this; + } + private: + const char *m_str; + std::size_t m_size; + std::size_t m_offset; + }; +} + +#endif // STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/tag.cpp b/src/third_party/yaml-cpp-0.5.1/src/tag.cpp new file mode 100644 index 00000000000..82a47047768 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/tag.cpp @@ -0,0 +1,52 @@ +#include "tag.h" +#include "directives.h" +#include "token.h" +#include <cassert> +#include <stdexcept> + +namespace YAML +{ + Tag::Tag(const Token& token): type(static_cast<TYPE>(token.data)) + { + switch(type) { + case VERBATIM: + value = token.value; + break; + case PRIMARY_HANDLE: + value = token.value; + break; + case SECONDARY_HANDLE: + value = token.value; + break; + case NAMED_HANDLE: + handle = token.value; + value = token.params[0]; + break; + case NON_SPECIFIC: + break; + default: + assert(false); + } + } + + const std::string Tag::Translate(const Directives& directives) + { + switch(type) { + case VERBATIM: + return value; + case PRIMARY_HANDLE: + return directives.TranslateTagHandle("!") + value; + case SECONDARY_HANDLE: + return directives.TranslateTagHandle("!!") + value; + case NAMED_HANDLE: + return directives.TranslateTagHandle("!" + handle + "!") + value; + case NON_SPECIFIC: + // TODO: + return "!"; + default: + assert(false); + } + throw std::runtime_error("yaml-cpp: internal error, bad tag type"); + } +} + diff --git a/src/third_party/yaml-cpp-0.5.1/src/tag.h b/src/third_party/yaml-cpp-0.5.1/src/tag.h new file mode 100644 index 00000000000..5f77548d8b7 --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/tag.h @@ -0,0 +1,28 @@ +#ifndef TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include <string> + +namespace YAML +{ + struct Token; + struct Directives; + + struct Tag { + enum TYPE { + VERBATIM, PRIMARY_HANDLE, SECONDARY_HANDLE, NAMED_HANDLE, NON_SPECIFIC + }; + + Tag(const Token& token); + const std::string Translate(const Directives& directives); + + TYPE type; + std::string handle, value; + }; +} + +#endif // TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/third_party/yaml-cpp-0.5.1/src/token.h b/src/third_party/yaml-cpp-0.5.1/src/token.h new file mode 100644 index 00000000000..9807e25879b --- /dev/null +++ b/src/third_party/yaml-cpp-0.5.1/src/token.h @@ -0,0 +1,85 @@ +#ifndef TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + + +#include "yaml-cpp/mark.h" +#include <iostream> +#include <string> +#include <vector> + +namespace YAML +{ + const std::string TokenNames[] = { + "DIRECTIVE", + "DOC_START", + "DOC_END", + "BLOCK_SEQ_START", + "BLOCK_MAP_START", + "BLOCK_SEQ_END", + "BLOCK_MAP_END", + "BLOCK_ENTRY", + "FLOW_SEQ_START", + "FLOW_MAP_START", + "FLOW_SEQ_END", + "FLOW_MAP_END", + "FLOW_MAP_COMPACT", + "FLOW_ENTRY", + "KEY", + "VALUE", + "ANCHOR", + "ALIAS", + "TAG", + "SCALAR" + }; + + struct Token { + // enums + enum STATUS { VALID, INVALID, UNVERIFIED }; + enum TYPE { + DIRECTIVE, + DOC_START, + DOC_END, + BLOCK_SEQ_START, + BLOCK_MAP_START, + BLOCK_SEQ_END, + BLOCK_MAP_END, + BLOCK_ENTRY, + FLOW_SEQ_START, + FLOW_MAP_START, + FLOW_SEQ_END, + FLOW_MAP_END, + FLOW_MAP_COMPACT, + FLOW_ENTRY, + KEY, + VALUE, + ANCHOR, + ALIAS, + TAG, + PLAIN_SCALAR, + NON_PLAIN_SCALAR + }; + + // data + Token(TYPE type_, const Mark& mark_): status(VALID), type(type_), mark(mark_), data(0) {} + + friend std::ostream& operator << (std::ostream& out, const Token& token) { + out << TokenNames[token.type] << std::string(": ") << token.value; + for(std::size_t i=0;i<token.params.size();i++) + out << std::string(" ") << token.params[i]; + return out; + } + + STATUS status; + TYPE type; + Mark mark; + std::string value; + std::vector <std::string> params; + int data; + }; +} + +#endif // TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 |