ParseResult FormatExpression::parse(const Convertible& value, ParsingContext& ctx) {
std::size_t argsLength = arrayLength(value);
if (argsLength < 3) {
ctx.error("Expected at least two arguments.");
return ParseResult();
}
if ((argsLength - 1) % 2 != 0) {
ctx.error("Expected an even number of arguments.");
return ParseResult();
}
std::vector<FormatExpressionSection> sections;
for (std::size_t i = 1; i < argsLength - 1; i += 2) {
auto textArg = arrayMember(value, i);
ParseResult text = ctx.parse(textArg, 1, {type::Value});
if (!text) {
return ParseResult();
}
auto options = arrayMember(value, i + 1);
if (!isObject(options)) {
ctx.error("Format options argument must be an object.");
return ParseResult();
}
const optional<Convertible> fontScaleOption = objectMember(options, kFormattedSectionFontScale);
ParseResult fontScale;
if (fontScaleOption) {
fontScale = ctx.parse(*fontScaleOption, 1, {type::Number});
if (!fontScale) {
return ParseResult();
}
}
const optional<Convertible> textFontOption = objectMember(options, kFormattedSectionTextFont);
ParseResult textFont;
if (textFontOption) {
textFont = ctx.parse(*textFontOption, 1, {type::Array(type::String)});
if (!textFont) {
return ParseResult();
}
}
const optional<Convertible> textColorOption = objectMember(options, kFormattedSectionTextColor);
ParseResult textColor;
if (textColorOption) {
textColor = ctx.parse(*textColorOption, 1, {type::Color});
if (!textColor) {
return ParseResult();
}
}
sections.emplace_back(std::move(*text),
std::move(fontScale),
std::move(textFont),
std::move(textColor));
}
return ParseResult(std::make_unique<FormatExpression>(std::move(sections)));
}
static ParseResult create(type::Type outputType,
std::unique_ptr<Expression>input,
std::vector<std::pair<std::vector<InputType>,
std::unique_ptr<Expression>>> branches,
std::unique_ptr<Expression> otherwise,
ParsingContext& ctx) {
typename Match<T>::Branches typedBranches;
std::size_t index = 2;
typedBranches.reserve(branches.size());
for (std::pair<std::vector<InputType>,
std::unique_ptr<Expression>>& pair : branches) {
std::shared_ptr<Expression> result = std::move(pair.second);
for (const InputType& label : pair.first) {
const auto& typedLabel = label.template get<T>();
if (typedBranches.find(typedLabel) != typedBranches.end()) {
ctx.error("Branch labels must be unique.", index);
return ParseResult();
}
typedBranches.emplace(typedLabel, result);
}
index += 2;
}
return ParseResult(std::make_unique<Match<T>>(
outputType,
std::move(input),
std::move(typedBranches),
std::move(otherwise)
));
}
ParseResult Assertion::parse(const Convertible& value, ParsingContext& ctx) {
static std::unordered_map<std::string, type::Type> types {
{"string", type::String},
{"number", type::Number},
{"boolean", type::Boolean},
{"object", type::Object}
};
std::size_t length = arrayLength(value);
if (length < 2) {
ctx.error("Expected at least one argument.");
return ParseResult();
}
auto it = types.find(*toString(arrayMember(value, 0)));
assert(it != types.end());
std::vector<std::unique_ptr<Expression>> parsed;
parsed.reserve(length - 1);
for (std::size_t i = 1; i < length; i++) {
ParseResult input = ctx.parse(arrayMember(value, i), i, {type::Value});
if (!input) return ParseResult();
parsed.push_back(std::move(*input));
}
return ParseResult(std::make_unique<Assertion>(it->second, std::move(parsed)));
}
ParseResult Coalesce::parse(const Convertible& value, ParsingContext& ctx) {
assert(isArray(value));
auto length = arrayLength(value);
if (length < 2) {
ctx.error("Expected at least one argument.");
return ParseResult();
}
optional<type::Type> outputType;
if (ctx.getExpected() && *ctx.getExpected() != type::Value) {
outputType = ctx.getExpected();
}
Coalesce::Args args;
args.reserve(length - 1);
for (std::size_t i = 1; i < length; i++) {
auto parsed = ctx.parse(arrayMember(value, i), i, outputType);
if (!parsed) {
return parsed;
}
if (!outputType) {
outputType = (*parsed)->getType();
}
args.push_back(std::move(*parsed));
}
assert(outputType);
return ParseResult(std::make_unique<Coalesce>(*outputType, std::move(args)));
}
ParseResult CollatorExpression::parse(const Convertible& value, ParsingContext& ctx) {
if (arrayLength(value) != 2) {
ctx.error("Expected one argument.");
return ParseResult();
}
auto options = arrayMember(value, 1);
if (!isObject(options)) {
ctx.error("Collator options argument must be an object.");
return ParseResult();
}
const optional<Convertible> caseSensitiveOption = objectMember(options, "case-sensitive");
ParseResult caseSensitive;
if (caseSensitiveOption) {
caseSensitive = ctx.parse(*caseSensitiveOption, 1, {type::Boolean});
} else {
caseSensitive = { std::make_unique<Literal>(false) };
}
if (!caseSensitive) {
return ParseResult();
}
const optional<Convertible> diacriticSensitiveOption = objectMember(options, "diacritic-sensitive");
ParseResult diacriticSensitive;
if (diacriticSensitiveOption) {
diacriticSensitive = ctx.parse(*diacriticSensitiveOption, 1, {type::Boolean});
} else {
diacriticSensitive = { std::make_unique<Literal>(false) };
}
if (!diacriticSensitive) {
return ParseResult();
}
const optional<Convertible> localeOption = objectMember(options, "locale");
ParseResult locale;
if (localeOption) {
locale = ctx.parse(*localeOption, 1, {type::String});
if (!locale) {
return ParseResult();
}
}
return ParseResult(std::make_unique<CollatorExpression>(std::move(*caseSensitive), std::move(*diacriticSensitive), std::move(locale)));
}
ParseResult Var::parse(const Convertible& value_, ParsingContext& ctx) {
assert(isArray(value_));
if (arrayLength(value_) != 2 || !toString(arrayMember(value_, 1))) {
ctx.error("'var' expression requires exactly one string literal argument.");
return ParseResult();
}
std::string name_ = *toString(arrayMember(value_, 1));
optional<std::shared_ptr<Expression>> bindingValue = ctx.getBinding(name_);
if (!bindingValue) {
ctx.error(R"(Unknown variable ")" + name_ + R"(". Make sure ")" +
name_ + R"(" has been bound in an enclosing "let" expression before using it.)", 1);
return ParseResult();
}
return ParseResult(std::make_unique<Var>(name_, std::move(*bindingValue)));
}
ParseResult Let::parse(const Convertible& value, ParsingContext& ctx) {
assert(isArray(value));
std::size_t length = arrayLength(value);
if (length < 4) {
ctx.error("Expected at least 3 arguments, but found " + util::toString(length - 1) + " instead.");
return ParseResult();
}
std::map<std::string, std::shared_ptr<Expression>> bindings_;
for(std::size_t i = 1; i < length - 1; i += 2) {
optional<std::string> name = toString(arrayMember(value, i));
if (!name) {
ctx.error("Expected string, but found " + getJSONType(arrayMember(value, i)) + " instead.", i);
return ParseResult();
}
bool isValidName = std::all_of(name->begin(), name->end(), [](unsigned char c) {
return ::isalnum(c) || c == '_';
});
if (!isValidName) {
ctx.error("Variable names must contain only alphanumeric characters or '_'.", 1);
return ParseResult();
}
ParseResult bindingValue = ctx.parse(arrayMember(value, i + 1), i + 1);
if (!bindingValue) {
return ParseResult();
}
bindings_.emplace(*name, std::move(*bindingValue));
}
ParseResult result_ = ctx.parse(arrayMember(value, length - 1), length - 1, ctx.getExpected(), bindings_);
if (!result_) {
return ParseResult();
}
return ParseResult(std::make_unique<Let>(std::move(bindings_), std::move(*result_)));
}
ParseResult At::parse(const Convertible& value, ParsingContext& ctx) {
assert(isArray(value));
std::size_t length = arrayLength(value);
if (length != 3) {
ctx.error("Expected 2 arguments, but found " + util::toString(length - 1) + " instead.");
return ParseResult();
}
ParseResult index = ctx.parse(arrayMember(value, 1), 1, {type::Number});
type::Type inputType = type::Array(ctx.getExpected() ? *ctx.getExpected() : type::Value);
ParseResult input = ctx.parse(arrayMember(value, 2), 2, {inputType});
if (!index || !input) return ParseResult();
return ParseResult(std::make_unique<At>(std::move(*index), std::move(*input)));
}
ParseResult parseMatch(const Convertible& value, ParsingContext& ctx) {
assert(isArray(value));
auto length = arrayLength(value);
if (length < 5) {
ctx.error(
"Expected at least 4 arguments, but found only " + util::toString(length - 1) + "."
);
return ParseResult();
}
// Expect odd-length array: ["match", input, 2 * (n pairs)..., otherwise]
if (length % 2 != 1) {
ctx.error("Expected an even number of arguments.");
return ParseResult();
}
optional<type::Type> inputType;
optional<type::Type> outputType;
if (ctx.getExpected() && *ctx.getExpected() != type::Value) {
outputType = ctx.getExpected();
}
std::vector<std::pair<std::vector<InputType>,
std::unique_ptr<Expression>>> branches;
branches.reserve((length - 3) / 2);
for (size_t i = 2; i + 1 < length; i += 2) {
const auto& label = arrayMember(value, i);
std::vector<InputType> labels;
// Match pair inputs are provided as either a literal value or a
// raw JSON array of string / number / boolean values.
if (isArray(label)) {
auto groupLength = arrayLength(label);
if (groupLength == 0) {
ctx.error("Expected at least one branch label.", i);
return ParseResult();
}
labels.reserve(groupLength);
for (size_t j = 0; j < groupLength; j++) {
const optional<InputType> inputValue = parseInputValue(arrayMember(label, j), ctx, i, inputType);
if (!inputValue) {
return ParseResult();
}
labels.push_back(*inputValue);
}
} else {
const optional<InputType> inputValue = parseInputValue(label, ctx, i, inputType);
if (!inputValue) {
return ParseResult();
}
labels.push_back(*inputValue);
}
ParseResult output = ctx.parse(arrayMember(value, i + 1), i + 1, outputType);
if (!output) {
return ParseResult();
}
if (!outputType) {
outputType = (*output)->getType();
}
branches.emplace_back(std::move(labels), std::move(*output));
}
auto input = ctx.parse(arrayMember(value, 1), 1, {type::Value});
if (!input) {
return ParseResult();
}
auto otherwise = ctx.parse(arrayMember(value, length - 1), length - 1, outputType);
if (!otherwise) {
return ParseResult();
}
assert(inputType && outputType);
optional<std::string> err;
if ((*input)->getType() != type::Value && (err = type::checkSubtype(*inputType, (*input)->getType()))) {
ctx.error(*err, 1);
return ParseResult();
}
return inputType->match(
[&](const type::NumberType&) {
return create<int64_t>(*outputType, std::move(*input), std::move(branches), std::move(*otherwise), ctx);
},
[&](const type::StringType&) {
return create<std::string>(*outputType, std::move(*input), std::move(branches), std::move(*otherwise), ctx);
},
[&](const auto&) {
// unreachable: inputType is set by parseInputValue(), which only
// accepts string and (integer) numeric values.
assert(false);
return ParseResult();
}
);
}
optional<InputType> parseInputValue(const Convertible& input, ParsingContext& parentContext, std::size_t index, optional<type::Type>& inputType) {
using namespace mbgl::style::conversion;
optional<InputType> result;
optional<type::Type> type;
auto value = toValue(input);
if (value) {
value->match(
[&] (uint64_t n) {
if (!Value::isSafeInteger(n)) {
parentContext.error("Branch labels must be integers no larger than " + util::toString(Value::maxSafeInteger()) + ".", index);
} else {
type = {type::Number};
result = optional<InputType>{static_cast<int64_t>(n)};
}
},
[&] (int64_t n) {
if (!Value::isSafeInteger(n)) {
parentContext.error("Branch labels must be integers no larger than " + util::toString(Value::maxSafeInteger()) + ".", index);
} else {
type = {type::Number};
result = optional<InputType>{n};
}
},
[&] (double n) {
if (!Value::isSafeInteger(n)) {
parentContext.error("Branch labels must be integers no larger than " + util::toString(Value::maxSafeInteger()) + ".", index);
} else if (n != std::floor(n)) {
parentContext.error("Numeric branch labels must be integer values.", index);
} else {
type = {type::Number};
result = optional<InputType>{static_cast<int64_t>(n)};
}
},
[&] (const std::string& s) {
type = {type::String};
result = {s};
},
[&] (const auto&) {
parentContext.error("Branch labels must be numbers or strings.", index);
}
);
} else {
parentContext.error("Branch labels must be numbers or strings.", index);
}
if (!type) {
return result;
}
if (!inputType) {
inputType = type;
} else {
optional<std::string> err = type::checkSubtype(*inputType, *type);
if (err) {
parentContext.error(*err, index);
return optional<InputType>();
}
}
return result;
}