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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
#include <mbgl/style/expression/parse.hpp>
#include <mbgl/style/expression/compound_expression.hpp>
#include <mbgl/style/expression/parse/at.hpp>
#include <mbgl/style/expression/parse/array_assertion.hpp>
#include <mbgl/style/expression/parse/case.hpp>
#include <mbgl/style/expression/parse/coalesce.hpp>
#include <mbgl/style/expression/parse/compound_expression.hpp>
#include <mbgl/style/expression/parse/curve.hpp>
#include <mbgl/style/expression/parse/in.hpp>
#include <mbgl/style/expression/parse/let.hpp>
#include <mbgl/style/expression/parse/literal.hpp>
#include <mbgl/style/expression/parse/match.hpp>
#include <mbgl/style/expression/type.hpp>
#include <mbgl/style/conversion/get_json_type.hpp>
#include <mbgl/style/expression/check_subtype.hpp>
namespace mbgl {
namespace style {
namespace expression {
ParseResult parseExpression(const mbgl::style::conversion::Value& value, ParsingContext context)
{
using namespace mbgl::style::conversion;
ParseResult parsed;
if (isArray(value)) {
const std::size_t length = arrayLength(value);
if (length == 0) {
context.error(R"(Expected an array with at least one element. If you wanted a literal array, use ["literal", []].)");
return ParseResult();
}
const optional<std::string> op = toString(arrayMember(value, 0));
if (!op) {
context.error(
"Expression name must be a string, but found " + getJSONType(arrayMember(value, 0)) +
R"( instead. If you wanted a literal array, use ["literal", [...]].)",
0
);
return ParseResult();
}
if (*op == "literal") {
if (length != 2) {
context.error(
"'literal' expression requires exactly one argument, but found " + std::to_string(length - 1) + " instead."
);
return ParseResult();
}
parsed = ParseLiteral::parse(arrayMember(value, 1), context);
} else if (*op == "match") {
parsed = ParseMatch::parse(value, context);
} else if (*op == "curve") {
parsed = ParseCurve::parse(value, context);
} else if (*op == "coalesce") {
parsed = ParseCoalesce::parse(value, context);
} else if (*op == "case") {
parsed = ParseCase::parse(value, context);
} else if (*op == "array") {
parsed = ParseArrayAssertion::parse(value, context);
} else if (*op == "let") {
parsed = ParseLet::parse(value, context);
} else if (*op == "var") {
parsed = ParseVar::parse(value, context);
} else if (*op == "at") {
parsed = ParseAt::parse(value, context);
} else if (*op == "contains") {
parsed = ParseIn::parse(value, context);
} else {
parsed = ParseCompoundExpression::parse(*op, value, context);
}
} else {
if (isObject(value)) {
context.error(R"(Bare objects invalid. Use ["literal", {...}] instead.)");
return ParseResult();
}
parsed = ParseLiteral::parse(value, context);
}
if (!parsed) {
assert(context.errors.size() > 0);
} else if (context.expected) {
auto wrapForType = [&](const std::string& wrapper, std::unique_ptr<Expression> expression) {
std::vector<std::unique_ptr<Expression>> args;
args.push_back(std::move(expression));
return createCompoundExpression(wrapper, std::move(args), context);
};
const type::Type actual = (*parsed)->getType();
const type::Type expected = *context.expected;
if (expected == type::Color && (actual == type::String || actual == type::Value)) {
parsed = wrapForType("to-color", std::move(*parsed));
} else if (expected != type::Value && actual == type::Value) {
if (expected == type::String) {
parsed = wrapForType("string", std::move(*parsed));
} else if (expected == type::Number) {
parsed = wrapForType("number", std::move(*parsed));
} else if (expected == type::Boolean) {
parsed = wrapForType("boolean", std::move(*parsed));
}
}
checkSubtype(*(context.expected), (*parsed)->getType(), context);
if (context.errors.size() > 0) {
return ParseResult();
}
}
return parsed;
}
} // namespace expression
} // namespace style
} // namespace mbgl
|
