Avoid deprecated jsoncons features

8 files changed, 169 insertions, 107 deletions

diff --git a/src/include/tome/enum_string_map.hpp b/src/include/tome/enum_string_map.hpp
index 814827fe..bd554b5c 100644
--- a/src/include/tome/enum_string_map.hpp
+++ b/src/include/tome/enum_string_map.hpp
@@ -35,6 +35,10 @@ public:
 		return i->second.c_str();
 	}
 
+	E parse(std::string const &s) const {
+		return parse(s.c_str());
+	}
+
 	E parse(const char *s) const {
 		E e;
 		bool result = parse(s, &e);
@@ -42,6 +46,10 @@ public:
 		return e;
 	}
 
+	bool parse(std::string const &s, E *e) const {
+		return parse(s.c_str(), e);
+	}
+
 	bool parse(const char *s, E *e) const {
 		auto i = bimap.right.find(s);
 		if (i == bimap.right.end())
diff --git a/src/include/tome/squelch/condition.hpp b/src/include/tome/squelch/condition.hpp
index fcb0bdb4..cc5deb64 100644
--- a/src/include/tome/squelch/condition.hpp
+++ b/src/include/tome/squelch/condition.hpp
@@ -121,7 +121,7 @@ private:
 class NameCondition : public Condition
 {
 public:
-	NameCondition(std::string name) :
+	NameCondition(std::string const &name) :
 		Condition(match_type::NAME),
 		m_name(name) {
 	}
@@ -145,7 +145,7 @@ private:
 class ContainCondition : public Condition
 {
 public:
-	ContainCondition(std::string contain) :
+	ContainCondition(std::string const &contain) :
 		Condition(match_type::CONTAIN),
 		m_contain(contain) {
 	}
@@ -290,7 +290,7 @@ private:
 class RaceCondition : public Condition
 {
 public:
-	RaceCondition(std::string race)
+	RaceCondition(std::string const &race)
 		: Condition(match_type::RACE)
 		, m_race(race) {
 	}
@@ -314,7 +314,7 @@ private:
 class SubraceCondition : public Condition
 {
 public:
-	SubraceCondition(std::string subrace)
+	SubraceCondition(std::string const &subrace)
 		: Condition(match_type::SUBRACE)
 		, m_subrace(subrace) {
 	}
@@ -338,7 +338,7 @@ private:
 class ClassCondition : public Condition
 {
 public:
-	ClassCondition(std::string klass)
+	ClassCondition(std::string const &klass)
 		: Condition(match_type::CLASS)
 		, m_class(klass) {
 	}
@@ -362,7 +362,7 @@ private:
 class InscriptionCondition : public Condition
 {
 public:
-	InscriptionCondition(std::string inscription)
+	InscriptionCondition(std::string const &inscription)
 		: Condition(match_type::INSCRIBED)
 		, m_inscription(inscription) {
 	}
diff --git a/src/skills.cc b/src/skills.cc
index 8e0eeb74..44c85551 100644
--- a/src/skills.cc
+++ b/src/skills.cc
@@ -139,6 +139,11 @@ s16b find_skill(const char *needle)
 	return -1;
 }
 
+s16b find_skill_i(std::string const &needle)
+{
+	return find_skill_i(needle.c_str());
+}
+
 s16b find_skill_i(const char *needle)
 {
 	auto const &s_descriptors = game->edit_data.s_descriptors;
@@ -1553,6 +1558,11 @@ void do_get_new_skill()
 
 /**************************************** ABILITIES *****************************************/
 
+s16b find_ability(std::string const &name)
+{
+	return find_ability(name.c_str());
+}
+
 /*
  * Given the name of an ability, returns ability index or -1 if no
  * such ability is found
diff --git a/src/skills.hpp b/src/skills.hpp
index 166aae4e..39191e8a 100644
--- a/src/skills.hpp
+++ b/src/skills.hpp
@@ -3,10 +3,12 @@
 #include "h-basic.h"
 
 #include <cstddef>
+#include <string>
 
 /* Skill functions */
 void dump_skills(FILE *fff);
 s16b find_skill(const char *name);
+s16b find_skill_i(std::string const &name);
 s16b find_skill_i(const char *name);
 s16b get_skill(int skill);
 s16b get_skill_scale(int skill, u32b scale);
@@ -21,6 +23,7 @@ void compute_skills(s32b *v, s32b *m, std::size_t i);
 void select_default_melee();
 void do_get_new_skill();
 void init_skill(s32b value, s32b mod, std::size_t i);
+s16b find_ability(std::string const &name);
 s16b find_ability(const char *name);
 void dump_abilities(FILE *fff);
 void do_cmd_ability();
diff --git a/src/squelch/condition.cc b/src/squelch/condition.cc
index 8768774d..2872cae5 100644
--- a/src/squelch/condition.cc
+++ b/src/squelch/condition.cc
@@ -3,6 +3,7 @@
 
 #include <boost/algorithm/string/predicate.hpp>
 
+#include "jsoncons_helpers.hpp"
 #include "tome/squelch/cursor.hpp"
 #include "tome/squelch/tree_printer.hpp"
 #include "../ability_type.hpp"
@@ -109,17 +110,18 @@ std::shared_ptr<Condition> Condition::parse_condition(jsoncons::json const &cond
 		return nullptr;
 	}
 
-	const char *type_s = condition_json.get("type").as<const char *>();
-	if (!type_s)
+	auto maybe_type_s = get_optional<std::string>(condition_json, "type");
+	if (!maybe_type_s)
 	{
 		msg_print("Missing/invalid 'type' in condition");
 		return nullptr;
 	}
+	auto type_s = *maybe_type_s;
 
 	match_type match;
 	if (!match_mapping().parse(type_s, &match))
 	{
-		msg_format("Invalid 'type' in condition: %s", type_s);
+		msg_format("Invalid 'type' in condition: %s", type_s.c_str());
 		return nullptr;
 	}
 
@@ -138,7 +140,7 @@ jsoncons::json Condition::optional_to_json(std::shared_ptr<Condition> condition)
 {
 	return condition
 		? condition->to_json()
-		: jsoncons::json::null_type();
+		: jsoncons::null_type();
 }
 
 bool TvalCondition::is_match(object_type *o_ptr) const
@@ -148,16 +150,15 @@ bool TvalCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> TvalCondition::from_json(jsoncons::json const &j)
 {
-	auto tval_j = j.get("tval");
-	if (!tval_j.is_uinteger())
+	if (auto maybe_tval = get_optional<uint8_t>(j, "tval"))
+	{
+		return std::make_shared<TvalCondition>(*maybe_tval);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'tval' property");
 		return nullptr;
 	}
-
-	int tval = tval_j.as_uint();
-
-	return std::make_shared<TvalCondition>(tval);
 }
 
 void TvalCondition::to_json(jsoncons::json &j) const
@@ -186,15 +187,15 @@ bool NameCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> NameCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("name").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "name"))
+	{
+		return std::make_shared<NameCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'name' property");
 		return nullptr;
 	}
-
-	return std::make_shared<NameCondition>(s);
 }
 
 void NameCondition::write_tree(TreePrinter *p, Cursor *cursor, uint8_t ecol, uint8_t bcol) const
@@ -221,15 +222,15 @@ bool ContainCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> ContainCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("contain").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "contain"))
+	{
+		return std::make_shared<ContainCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'contain' property");
 		return nullptr;
 	}
-
-	return std::make_shared<ContainCondition>(s);
 }
 
 void ContainCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -256,23 +257,21 @@ bool SvalCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> SvalCondition::from_json(jsoncons::json const &j)
 {
-	auto min_j = j.get("min");
-	if (!min_j.is_uinteger())
+	auto min_j = get_optional<uint8_t>(j, "min");
+	if (!min_j)
 	{
 		msg_print("Missing/invalid 'min' property");
 		return nullptr;
 	}
 
-	auto max_j = j.get("max");
-	if (!max_j.is_uinteger())
+	auto max_j = get_optional<uint8_t>(j, "max");
+	if (!max_j)
 	{
 		msg_print("Missing/invalid 'max' property");
 		return nullptr;
 	}
 
-	return std::make_shared<SvalCondition>(
-		min_j.as_uint(),
-		max_j.as_uint());
+	return std::make_shared<SvalCondition>(*min_j, *max_j);
 }
 
 void SvalCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -373,7 +372,7 @@ std::shared_ptr<Condition> GroupingCondition::next_child(Condition *current)
 
 std::vector< std::shared_ptr<Condition> > GroupingCondition::parse_conditions(jsoncons::json const &j)
 {
-	auto conditions_j = j.get("conditions");
+	auto conditions_j = j.get_with_default<jsoncons::json>("conditions", jsoncons::null_type());
 
 	if (conditions_j.is_null())
 	{
@@ -489,22 +488,23 @@ bool StatusCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> StatusCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("status").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "status"))
 	{
-		msg_print("Missing/invalid 'status' property");
-		return nullptr;
-	}
+		std::string s = *maybe_s;
+		status_type status;
+		if (!status_mapping().parse(s, &status))
+		{
+			msg_format("Invalid 'status' property: %s", s.c_str());
+			return nullptr;
+		}
 
-	status_type status;
-	if (!status_mapping().parse(s, &status))
+		return std::make_shared<StatusCondition>(status);
+	}
+	else
 	{
-		msg_format("Invalid 'status' property: %s", s);
+		msg_print("Missing/invalid 'status' property");
 		return nullptr;
 	}
-
-	return std::make_shared<StatusCondition>(status);
 }
 
 void StatusCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -530,15 +530,15 @@ bool RaceCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> RaceCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("race").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "race"))
+	{
+		return std::make_shared<RaceCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'race' property");
 		return nullptr;
 	}
-
-	return std::make_shared<RaceCondition>(s);
 }
 
 void RaceCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -564,15 +564,15 @@ bool SubraceCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> SubraceCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("subrace").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "subrace"))
+	{
+		return std::make_shared<SubraceCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'subrace' property");
 		return nullptr;
 	}
-
-	return std::make_shared<SubraceCondition>(s);
 }
 
 void SubraceCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -598,15 +598,15 @@ bool ClassCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> ClassCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("class").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "class"))
+	{
+		return std::make_shared<ClassCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'class' property");
 		return nullptr;
 	}
-
-	return std::make_shared<ClassCondition>(s);
 }
 
 void ClassCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -634,15 +634,15 @@ bool InscriptionCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> InscriptionCondition::from_json(jsoncons::json const &j)
 {
-	const char *s = j.get("inscription").as<const char *>();
-
-	if (!s)
+	if (auto maybe_s = get_optional<std::string>(j, "inscription"))
+	{
+		return std::make_shared<InscriptionCondition>(*maybe_s);
+	}
+	else
 	{
 		msg_print("Missing/invalid 'inscription' property");
 		return nullptr;
 	}
-
-	return std::make_shared<InscriptionCondition>(s);
 }
 
 void InscriptionCondition::write_tree(TreePrinter *p, Cursor *, uint8_t ecol, uint8_t bcol) const
@@ -670,21 +670,21 @@ bool DiscountCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> DiscountCondition::from_json(jsoncons::json const &j)
 {
-	auto min_j = j.get("min");
-	if (!min_j.is_integer())
+	auto maybe_min = get_optional<int>(j, "min");
+	if (!maybe_min)
 	{
 		msg_print("Missing/invalid 'min' property");
 		return nullptr;
 	}
-	int min = min_j.as_int();
+	auto min = *maybe_min;
 
-	auto max_j = j.get("max");
-	if (!max_j.is_integer())
+	auto maybe_max = get_optional<int>(j, "max");
+	if (!maybe_max)
 	{
 		msg_print("Missing/invalid 'max' property");
 		return nullptr;
 	}
-	int max = max_j.as_int();
+	auto max = *maybe_max;
 
 	return std::make_shared<DiscountCondition>(min, max);
 }
@@ -714,21 +714,21 @@ bool LevelCondition::is_match(object_type *) const
 
 std::shared_ptr<Condition> LevelCondition::from_json(jsoncons::json const &j)
 {
-	auto min_j = j.get("min");
-	if (!min_j.is_integer())
+	auto maybe_min = get_optional<int>(j, "min");
+	if (!maybe_min)
 	{
 		msg_print("Missing/invalid 'min' property");
 		return nullptr;
 	}
-	int min = min_j.as_int();
+	auto min = *maybe_min;
 
-	auto max_j = j.get("max");
-	if (!max_j.is_integer())
+	auto maybe_max = get_optional<int>(j, "max");
+	if (!maybe_max)
 	{
 		msg_print("Missing/invalid 'max' property");
 		return nullptr;
 	}
-	int max = max_j.as_int();
+	int max = *maybe_max;
 
 	return std::make_shared<LevelCondition>(min, max);
 }
@@ -760,33 +760,34 @@ bool SkillCondition::is_match(object_type *) const
 
 std::shared_ptr<Condition> SkillCondition::from_json(jsoncons::json const &j)
 {
-	auto min_j = j.get("min");
-	if (!min_j.is_integer())
+	auto maybe_min = get_optional<int>(j, "min");
+	if (!maybe_min)
 	{
 		msg_print("Missing/invalid 'min' property");
 		return nullptr;
 	}
-	int min = min_j.as_int();
+	auto min = *maybe_min;
 
-	auto max_j = j.get("max");
-	if (!max_j.is_integer())
+	auto maybe_max = get_optional<int>(j, "max");
+	if (!maybe_max)
 	{
 		msg_print("Missing/invalid 'max' property");
 		return nullptr;
 	}
-	int max = max_j.as_int();
+	auto max = *maybe_max;
 
-	auto s = j.get("name").as<const char *>();
-	if (!s)
+	auto maybe_s = get_optional<std::string>(j, "name");
+	if (!maybe_s)
 	{
 		msg_print("Missing/invalid 'name' property");
 		return nullptr;
 	}
+	auto s = *maybe_s;
 
 	auto si = find_skill_i(s);
 	if (si < 0)
 	{
-		msg_print("Invalid 'name' property");
+		msg_format("Invalid 'name' property: %s", s.c_str());
 		return nullptr;
 	}
 
@@ -822,7 +823,7 @@ bool SymbolCondition::is_match(object_type *o_ptr) const
 
 std::shared_ptr<Condition> SymbolCondition::from_json(jsoncons::json const &j)
 {
-	auto s = j.get("symbol").as<std::string>();
+	auto s = get_optional<std::string>(j, "symbol").value_or("");
 
 	if (s.empty())
 	{
@@ -862,18 +863,18 @@ bool AbilityCondition::is_match(object_type *) const
 
 std::shared_ptr<Condition> AbilityCondition::from_json(jsoncons::json const &j)
 {
-	const char *a = j.get("ability").as<const char *>();
-
-	if (!a)
+	auto maybe_a = get_optional<std::string>(j, "ability");
+	if (!maybe_a)
 	{
 		msg_print("Missing/invalid 'ability' property");
 		return nullptr;
 	}
+	auto a = *maybe_a;
 
 	auto ai = find_ability(a);
 	if (ai < 0)
 	{
-		msg_print("Invalid 'ability' property");
+		msg_format("Invalid 'ability' property: %s", a.c_str());
 		return nullptr;
 	}
 
@@ -926,7 +927,7 @@ void SingleSubconditionCondition::to_json(jsoncons::json &j) const
 
 std::shared_ptr<Condition> SingleSubconditionCondition::parse_single_subcondition(jsoncons::json const &in_json)
 {
-	auto condition_j = in_json.get("condition");
+	auto condition_j = in_json.get_with_default<jsoncons::json>("condition", jsoncons::null_type());
 
 	if (condition_j.is_null())
 	{
diff --git a/src/squelch/jsoncons_helpers.hpp b/src/squelch/jsoncons_helpers.hpp
new file mode 100644
index 00000000..1ce6b094
--- /dev/null
+++ b/src/squelch/jsoncons_helpers.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <boost/optional.hpp>
+#include <jsoncons/json.hpp>
+#include <string>
+
+namespace squelch {
+
+template <class T>
+boost::optional<T> get_optional(jsoncons::json const &json, std::string const &key)
+{
+	if (!json.has_key(key))
+	{
+		return boost::none;
+	}
+
+	auto value = json.at(key);
+
+	if (!value.is<T>())
+	{
+		return boost::none;
+	}
+
+	return value.as<T>();
+}
+
+} // namespace squelch
diff --git a/src/squelch/rule.cc b/src/squelch/rule.cc
index c528bf8d..e79fc1f2 100644
--- a/src/squelch/rule.cc
+++ b/src/squelch/rule.cc
@@ -1,6 +1,7 @@
 #include "tome/squelch/rule_fwd.hpp"
 #include "tome/squelch/rule.hpp"
 
+#include "jsoncons_helpers.hpp"
 #include "tome/squelch/cursor.hpp"
 #include "tome/squelch/condition.hpp"
 #include "tome/squelch/tree_printer.hpp"
@@ -140,41 +141,44 @@ std::shared_ptr<Rule> Rule::parse_rule(jsoncons::json const &rule_json)
 	}
 
 	// Retrieve the attributes
-	char const *rule_name_s = rule_json.get("name").as<char const *>();
-	char const *rule_action_s = rule_json.get("action").as<char const *>();
-	char const *rule_module_s = rule_json.get("module").as<char const *>();
-	if ((!rule_name_s) || (!rule_action_s) || (!rule_module_s))
+	auto maybe_rule_name_s = get_optional<std::string>(rule_json, "name");
+	auto maybe_rule_action_s = get_optional<std::string>(rule_json, "action");
+	auto maybe_rule_module_s = get_optional<std::string>(rule_json, "module");
+	if ((!maybe_rule_name_s) || (!maybe_rule_action_s) || (!maybe_rule_module_s))
 	{
 		msg_print("Rule missing required field(s)");
 		return nullptr;
 	}
+	auto rule_name_s = *maybe_rule_name_s;
+	auto rule_action_s = *maybe_rule_action_s;
+	auto rule_module_s = *maybe_rule_module_s;
 
 	// Convert attributes
 	action_type action;
 	if (!action_mapping().parse(rule_action_s, &action))
 	{
-		msg_format("Invalid rule action '%s'", rule_action_s);
+		msg_format("Invalid rule action '%s'", rule_action_s.c_str());
 		return nullptr;
 	}
 
-	int module_idx = find_module(rule_module_s);
+	int module_idx = find_module(rule_module_s.c_str());
 	if (module_idx < 0)
 	{
 		msg_format("Skipping rule for unrecognized module '%s'",
-			   rule_module_s);
+			   rule_module_s.c_str());
 		return nullptr;
 	}
 
 	// Parse condition
 	std::shared_ptr<Condition> condition =
-		Condition::parse_condition(rule_json.get("condition"));
+		Condition::parse_condition(rule_json.get_with_default<jsoncons::json>("condition", jsoncons::null_type()));
 
 	// Parse rule
 	switch (action)
 	{
 	case action_type::AUTO_INSCRIBE:
 	{
-		auto rule_inscription_j = rule_json.get("inscription");
+		auto rule_inscription_j = rule_json.get_with_default<jsoncons::json>("inscription", jsoncons::null_type());
 
 		if (rule_inscription_j.is_null())
 		{
diff --git a/src/squeltch.cc b/src/squeltch.cc
index fa458c08..9e3d39af 100644
--- a/src/squeltch.cc
+++ b/src/squeltch.cc
@@ -205,10 +205,6 @@ static void automatizer_save_rules()
 		}
 	}
 
-	// Pretty-printing options
-	jsoncons::output_format format;
-	format.indent(2);
-
 	// Convert to a JSON document
 	auto rules_document = automatizer->to_json();
 
@@ -221,7 +217,9 @@ static void automatizer_save_rules()
 	}
 
 	// Write JSON to output
-	of << jsoncons::pretty_print(rules_document, format);
+	jsoncons::serialization_options serialization_options;
+	serialization_options.indent(2);
+	of << jsoncons::pretty_print(rules_document, serialization_options);
 	if (of.fail())
 	{
 		error();
@@ -585,7 +583,12 @@ bool automatizer_load(boost::filesystem::path const &path)
 	jsoncons::json rules_json;
 	try
 	{
-		rules_json = jsoncons::json::parse_file(path.string());
+		// Open
+		std::ifstream ifs(
+			path.string(),
+			std::ifstream::in | std::ifstream::binary);
+		// Parse
+		ifs >> rules_json;
 	}
 	catch (jsoncons::json_exception const &exc)
 	{
@@ -593,6 +596,12 @@ bool automatizer_load(boost::filesystem::path const &path)
 		msg_print(exc.what());
 		return false;
 	}
+	catch (const std::ifstream::failure &exc)
+	{
+		msg_format("I/O error reading automatizer rules from '%s'.", path.c_str());
+		msg_print(exc.what());
+		return false;
+	}
 
 	// We didn't return directly via an exception, so let's extract
 	// the rules.