sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'Kojoley-spirit-rule-placeholders'

Browse source
This commit is contained in:
Artem Pavlenko 2019-07-02 10:56:15 +01:00
commit f104edbefb
54 changed files with 98 additions and 339 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
include/mapnik/css_color_grammar_x3.hpp
View file

@ -41,15 +41,10 @@ namespace css_color_grammar
struct css_color_class;
using css_color_grammar_type = x3::rule<css_color_class, mapnik::color>;
css_color_grammar_type const css_color = "css_color";
BOOST_SPIRIT_DECLARE(css_color_grammar_type);
}}
namespace mapnik
{
css_color_grammar::css_color_grammar_type const& color_grammar();
}
#endif // MAPNIK_CSS_COLOR_GRAMMAR_X3_HPP

8
include/mapnik/css_color_grammar_x3_def.hpp
View file

@ -220,8 +220,6 @@ x3::uint_parser<std::uint8_t, 16, 2, 2> hex2;
x3::uint_parser<std::uint8_t, 16, 1, 1> hex1;
x3::uint_parser<std::uint16_t, 10, 1, 3> dec3;
// starting rule
css_color_grammar_type const css_color("css_color");
// rules
x3::rule<class hex2_color, color> const hex2_color("hex2_color");
x3::rule<class hex1_color, color> const hex1_color("hex1_color");
@ -443,12 +441,6 @@ BOOST_SPIRIT_DEFINE(
#pragma GCC diagnostic pop
} // ns
css_color_grammar::css_color_grammar_type const& color_grammar()
{
return css_color_grammar::css_color;
}
} //ns mapnik
#endif //MAPNIK_CSS_COLOR_GRAMMAR_X3_DEF_HPP

2
include/mapnik/csv/csv_grammar_x3.hpp
View file

@ -60,6 +60,8 @@ struct quote_tag;
struct csv_line_class;
using csv_line_grammar_type = x3::rule<csv_line_class, csv_line>;
csv_line_grammar_type const line = "csv-line";
BOOST_SPIRIT_DECLARE(csv_line_grammar_type);
}}

8
include/mapnik/csv/csv_grammar_x3_def.hpp
View file

@ -81,8 +81,6 @@ struct literal : x3::parser<literal<T>>
auto static const separator = literal<separator_tag>{};
auto static const quote = literal<quote_tag>{};
// starting rule
csv_line_grammar_type const line("csv-line");
// rules
x3::rule<class csv_column, csv_value> column("csv-column");
x3::rule<class csv_text, csv_value> text("csv-text");
@ -108,12 +106,6 @@ BOOST_SPIRIT_DEFINE (
);
} // grammar
grammar::csv_line_grammar_type const& csv_line_grammar()
{
return grammar::line;
}
} // namespace mapnik

9
include/mapnik/expression_grammar_x3.hpp
View file

@ -44,15 +44,10 @@ struct transcoder_tag;
struct expression_class; // top-most ID
using expression_grammar_type = x3::rule<expression_class, expr_node>;
expression_grammar_type const expression("expression");
BOOST_SPIRIT_DECLARE(expression_grammar_type);
}}
namespace mapnik
{
grammar::expression_grammar_type const& expression_grammar();
}
#endif // MAPNIK_EXPRESSIONS_GRAMMAR_X3_HPP

11
include/mapnik/expression_grammar_x3_def.hpp
View file

@ -300,8 +300,7 @@ namespace mapnik { namespace grammar {
;
}
} unesc_char;
// starting rule
expression_grammar_type const expression("expression");
// rules
x3::rule<class logical_expression, mapnik::expr_node> const logical_expression("logical expression");
x3::rule<class not_expression, mapnik::expr_node> const not_expression("not expression");
@ -451,12 +450,4 @@ namespace mapnik { namespace grammar {
}}
namespace mapnik
{
grammar::expression_grammar_type const& expression_grammar()
{
return grammar::expression;
}
}
#endif // MAPNIK_EXPRESSIONS_GRAMMAR_X3_DEF_HPP

9
include/mapnik/image_filter_grammar_x3.hpp
View file

@ -41,15 +41,10 @@ namespace image_filter
struct image_filter_class;
using image_filter_grammar_type = x3::rule<image_filter_class, std::vector<filter::filter_type> >;
BOOST_SPIRIT_DECLARE(image_filter_grammar_type);
image_filter_grammar_type const start = "start";
BOOST_SPIRIT_DECLARE(image_filter_grammar_type);
}}
namespace mapnik {
image_filter::image_filter_grammar_type const& image_filter_grammar();
}
#endif // MAPNIK_IMAGE_FILTER_GRAMMAR_X3_HPP

10
include/mapnik/image_filter_grammar_x3_def.hpp
View file

@ -108,10 +108,8 @@ auto percent = [](auto & ctx)
x3::uint_parser<unsigned, 10, 1, 3> radius;
// Import the expression rule
namespace { auto const& css_color = color_grammar(); }
namespace { using css_color_grammar::css_color; }
// starting rule
image_filter_grammar_type const start("start");
// rules
x3::rule<class filter_class, filter::filter_type > const filter("filter");
@ -250,12 +248,6 @@ BOOST_SPIRIT_DEFINE(
#pragma GCC diagnostic pop
} // image_filter
image_filter::image_filter_grammar_type const& image_filter_grammar()
{
return image_filter::start;
}
} //ns mapnik
#endif //MAPNIK_IMAGE_FILTER_GRAMMAR_X3_DEF_HPP

34
include/mapnik/init_priority.hpp
View file

@ -1,34 +0,0 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2017 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef MAPNIK_INIT_PRIORITY_HPP
#define MAPNIK_INIT_PRIORITY_HPP
// helper macro for dealing with static variables initialising order fiasco (#3821)
#if defined(__GNUC__) || defined(__clang__)
#define MAPNIK_INIT_PRIORITY(priority) __attribute__((init_priority(priority)))
#else
#define MAPNIK_INIT_PRIORITY
// TODO: anything we can do on windows?
#endif
#endif //MAPNIK_INIT_PRIORITY_HPP

11
include/mapnik/json/feature_grammar_x3.hpp
View file

@ -36,15 +36,12 @@ namespace x3 = boost::spirit::x3;
using feature_grammar_type = x3::rule<class feature_rule_tag>;
using geometry_grammar_type = x3::rule<struct geomerty_rule_tag, mapnik::geometry::geometry<double> >;
feature_grammar_type const feature_rule = "Feature Rule";
geometry_grammar_type const geometry_rule = "Geometry Rule";
BOOST_SPIRIT_DECLARE(feature_grammar_type);
BOOST_SPIRIT_DECLARE(geometry_grammar_type);
}
grammar::feature_grammar_type const& feature_grammar();
grammar::geometry_grammar_type const& geometry_grammar();
}}
}}}
#endif // MAPNIK_JSON_FEATURE_GRAMMAR_X3_HPP

10
include/mapnik/json/feature_grammar_x3_def.hpp
View file

@ -141,11 +141,9 @@ using x3::char_;
namespace {
// import unicode string rule
auto const& geojson_string = unicode_string_grammar();
auto const& geojson_string = unicode_string;
// import positions rule
auto const& positions_rule = positions_grammar();
// import generic rule
auto const& value = generic_json_grammar();
auto const& positions_rule = positions;
}
// geometry types symbols
@ -234,10 +232,6 @@ auto assign_property = [](auto const& ctx)
};
//exported rules
feature_grammar_type const feature_rule = "Feature Rule";
geometry_grammar_type const geometry_rule = "Geometry Rule";
// rules
x3::rule<struct feature_type_tag> const feature_type = "Feature Type";
x3::rule<struct geometry_type_tag, mapnik::geometry::geometry_types> const geometry_type = "Geometry Type";

10
include/mapnik/json/generic_json_grammar_x3.hpp
View file

@ -39,13 +39,13 @@ namespace grammar {
using generic_json_grammar_type = x3::rule<class generic_json_tag, json_value>;
using generic_json_key_value_type = x3::rule<class json_object_element_tag, json_object_element>;
generic_json_grammar_type const value = "JSON Value";
generic_json_key_value_type const key_value = "JSON Object element";
BOOST_SPIRIT_DECLARE(generic_json_grammar_type);
BOOST_SPIRIT_DECLARE(generic_json_key_value_type);
}
grammar::generic_json_grammar_type const& generic_json_grammar();
grammar::generic_json_key_value_type const& generic_json_key_value();
}}
}}}
#endif // MAPNIK_JSON_GENERIC_JSON_GRAMMAR_X3_HPP

7
include/mapnik/json/generic_json_grammar_x3_def.hpp
View file

@ -26,7 +26,6 @@
#include <boost/fusion/include/std_pair.hpp>
#include <mapnik/json/generic_json_grammar_x3.hpp>
#include <mapnik/json/unicode_string_grammar_x3.hpp>
#include <mapnik/init_priority.hpp>
namespace mapnik { namespace json { namespace grammar {
@ -70,12 +69,8 @@ using x3::lit;
using x3::string;
// import unicode string rule
namespace { auto const& json_string = mapnik::json::unicode_string_grammar(); }
namespace { auto const& json_string = mapnik::json::grammar::unicode_string; }
// exported rules
// start
generic_json_grammar_type const value MAPNIK_INIT_PRIORITY(102) ("JSON Value");
generic_json_key_value_type const key_value("JSON Object element");
// rules
x3::rule<class json_object_tag, json_object> const object("JSON Object");
x3::rule<class json_array_tag, json_array> const array("JSON Array");

12
include/mapnik/json/geojson_grammar_x3.hpp
View file

@ -71,13 +71,13 @@ struct geojson_value : geojson_value_base
namespace grammar {
using geojson_grammar_type = x3::rule<class geojson_tag, geojson_value>;
using key_value_type = x3::rule<class key_value_tag, geojson_object_element>;
BOOST_SPIRIT_DECLARE(geojson_grammar_type, key_value_type);
}
using geojson_key_value_type = x3::rule<class geojson_key_value_type_tag, geojson_object_element>;
grammar::geojson_grammar_type const& geojson_grammar();
grammar::key_value_type const& key_value_grammar();
geojson_grammar_type const geojson_value = "GeoJSON Value";
geojson_key_value_type const geojson_key_value = "GeoJSON Key/Value Type";
}}
BOOST_SPIRIT_DECLARE(geojson_grammar_type, geojson_key_value_type);
}}}
#endif // MAPNIK_JSON_GEOJSON_GRAMMAR_X3_HPP

26
include/mapnik/json/geojson_grammar_x3_def.hpp
View file

@ -26,7 +26,6 @@
#include <mapnik/json/geojson_grammar_x3.hpp>
#include <mapnik/json/unicode_string_grammar_x3.hpp>
#include <mapnik/json/positions_grammar_x3.hpp>
#include <mapnik/init_priority.hpp>
#include <boost/fusion/include/std_pair.hpp>
@ -88,40 +87,35 @@ struct geometry_type_ : x3::symbols<mapnik::geometry::geometry_types>
}
} geometry_type_sym;
// exported rules
// start
geojson_grammar_type const value MAPNIK_INIT_PRIORITY(106) ("JSON Value");
key_value_type const key_value MAPNIK_INIT_PRIORITY(107) ("JSON key/value");
// rules
x3::rule<class json_object_tag, geojson_object> const object("JSON Object");
x3::rule<class json_array_tag, geojson_array> const array("JSON Array");
x3::rule<class json_number_tag, geojson_value> const number("JSON Number");
//x3::rule<class key_value_tag, geojson_object_element> key_value("JSON key/value");
x3::rule<class json_number_tag, json::geojson_value> const number("JSON Number");
x3::rule<class key_value_tag, geojson_object_element> key_value("JSON key/value");
// GeoJSON
x3::rule<class geojson_coordinates_tag, geojson_object_element> const coordinates("GeoJSON Coordinates");
x3::rule<class geojson_geometry_type_tag, geojson_object_element> const geometry_type("GeoJSON Geometry Type");
x3::rule<class geojson_key_value_type_tag, geojson_object_element> const geojson_key_value("GeoJSON Key/Value Type");
auto const geojson_double = x3::real_parser<value_double, x3::strict_real_policies<value_double>>();
auto const geojson_integer = x3::int_parser<value_integer, 10, 1, -1>();
// import unicode string rule
namespace { auto const& geojson_string = mapnik::json::unicode_string_grammar(); }
namespace { auto const& geojson_string = unicode_string; }
// import positions rule
namespace { auto const& positions_rule = mapnik::json::positions_grammar(); }
namespace { auto const& positions_rule = positions; }
// GeoJSON types
auto const value_def = object | array | geojson_string | number
auto const geojson_value_def = object | array | geojson_string | number
;
auto const coordinates_def = lexeme[lit('"') >> (string("coordinates") > lit('"'))][assign_key]
> lit(':') > (positions_rule[assign_value] | value[assign_value])
> lit(':') > (positions_rule[assign_value] | geojson_value[assign_value])
;
auto const geometry_type_def = lexeme[lit('"') >> (string("type") > lit('"'))][assign_key]
> lit(':') > (geometry_type_sym[assign_value] | value[assign_value])
> lit(':') > (geometry_type_sym[assign_value] | geojson_value[assign_value])
;
auto const key_value_def = geojson_string[assign_key] > lit(':') > value[assign_value]
auto const key_value_def = geojson_string[assign_key] > lit(':') > geojson_value[assign_value]
;
auto const geojson_key_value_def =
@ -138,7 +132,7 @@ auto const object_def = lit('{')
;
auto const array_def = lit('[')
> -(value % lit(','))
> -(geojson_value % lit(','))
> lit(']')
;
@ -153,7 +147,7 @@ auto const number_def = geojson_double[assign]
#include <mapnik/warning_ignore.hpp>
BOOST_SPIRIT_DEFINE(
value,
geojson_value,
geometry_type,
coordinates,
object,

8
include/mapnik/json/positions_grammar_x3.hpp
View file

@ -39,12 +39,10 @@ namespace grammar {
namespace x3 = boost::spirit::x3;
using positions_grammar_type = x3::rule<class positions_tag, positions>;
positions_grammar_type const positions = "Positions";
BOOST_SPIRIT_DECLARE(positions_grammar_type);
}
grammar::positions_grammar_type const& positions_grammar();
}}
}}}
#endif // MAPNIK_JSON_POSITIONS_GRAMMAR_X3_HPP

3
include/mapnik/json/positions_grammar_x3_def.hpp
View file

@ -25,7 +25,6 @@
#include <mapnik/json/positions_grammar_x3.hpp>
#include <mapnik/geometry/fusion_adapted.hpp>
#include <mapnik/init_priority.hpp>
namespace mapnik { namespace json { namespace grammar {
@ -42,8 +41,6 @@ auto assign_helper = [](auto const& ctx)
};
} // anonymous ns
// start rule
positions_grammar_type const positions MAPNIK_INIT_PRIORITY(103) ("Positions");
// rules
x3::rule<class point_class, point> const point("Position");
x3::rule<class ring_class, ring> const ring("Ring");

8
include/mapnik/json/topojson_grammar_x3.hpp
View file

@ -37,12 +37,10 @@ namespace x3 = boost::spirit::x3;
using topojson_grammar_type = x3::rule<class topojson_rule_tag, topojson::topology>;
topojson_grammar_type const topology = "Topology";
BOOST_SPIRIT_DECLARE(topojson_grammar_type);
}
grammar::topojson_grammar_type const& topojson_grammar();
}}
}}}
#endif //MAPNIK_TOPOJSON_GRAMMAR_X3_HPP

7
include/mapnik/json/topojson_grammar_x3_def.hpp
View file

@ -26,7 +26,6 @@
#include <mapnik/json/unicode_string_grammar_x3.hpp>
#include <mapnik/json/generic_json_grammar_x3.hpp>
#include <mapnik/json/topojson_grammar_x3.hpp>
#include <mapnik/init_priority.hpp>
#pragma GCC diagnostic push
#include <mapnik/warning_ignore.hpp>
@ -280,9 +279,9 @@ using x3::omit;
namespace
{
// import unicode string rule
auto const& json_string = json::unicode_string_grammar();
auto const& json_string = json::grammar::unicode_string;
// json value
auto const& json_value = json::generic_json_grammar();
auto const& json_value = json::grammar::value;
}
using coordinates_type = util::variant<topojson::coordinate,std::vector<topojson::coordinate>>;
@ -305,8 +304,6 @@ struct topojson_geometry_type_ : x3::symbols<int>
}
} topojson_geometry_type;
// start rule
topojson_grammar_type const topology MAPNIK_INIT_PRIORITY(104) ("Topology");
// rules
x3::rule<class transform_tag, mapnik::topojson::transform> const transform = "Transform";
x3::rule<class bbox_tag, mapnik::topojson::bounding_box> const bbox = "Bounding Box";

8
include/mapnik/json/unicode_string_grammar_x3.hpp
View file

@ -34,12 +34,10 @@ namespace mapnik { namespace json { namespace grammar {
namespace x3 = boost::spirit::x3;
using unicode_string_grammar_type = x3::rule<class unicode_string_tag, std::string>;
unicode_string_grammar_type const unicode_string = "Unicode String";
BOOST_SPIRIT_DECLARE(unicode_string_grammar_type);
}
grammar::unicode_string_grammar_type const& unicode_string_grammar();
}}
}}}
#endif // MAPNIK_JSON_UNICODE_STRING_GRAMMAR_X3_HPP

3
include/mapnik/json/unicode_string_grammar_x3_def.hpp
View file

@ -24,7 +24,6 @@
#define MAPNIK_JSON_UNICODE_STRING_GRAMMAR_X3_DEF_HPP
#include <mapnik/json/unicode_string_grammar_x3.hpp>
#include <mapnik/init_priority.hpp>
// boost
#include <boost/regex/pending/unicode_iterator.hpp>
//
@ -109,8 +108,6 @@ x3::uint_parser<std::uint8_t, 16, 2, 2> const hex2 {};
x3::uint_parser<std::uint16_t, 16, 4, 4> const hex4 {};
x3::uint_parser<uchar, 16, 8, 8> const hex8 {};
// start rule
unicode_string_grammar_type const unicode_string MAPNIK_INIT_PRIORITY(101) ("Unicode String");
// rules
x3::rule<class double_quoted_tag, std::string> const double_quoted("Double-quoted string");
x3::rule<class escaped_tag, std::string> const escaped("Escaped Character");

8
include/mapnik/path_expression_grammar_x3.hpp
View file

@ -37,12 +37,10 @@ namespace x3 = boost::spirit::x3;
struct path_expression_class; // top-most ID
using path_expression_grammar_type = x3::rule<path_expression_class, path_expression>;
path_expression_grammar_type const path_expression = "path_expression";
BOOST_SPIRIT_DECLARE(path_expression_grammar_type);
}
grammar::path_expression_grammar_type const& path_expression_grammar();
}
}}
#endif // MAPNIK_PATH_EXPRESSIONS_GRAMMAR_X3_HPP

11
include/mapnik/path_expression_grammar_x3_def.hpp
View file

@ -33,8 +33,6 @@ using x3::standard_wide::char_;
using x3::lexeme;
auto create_string = [](auto & ctx) { _val(ctx).push_back(_attr(ctx)); };
auto create_attribute = [](auto & ctx) { _val(ctx).push_back(mapnik::attribute(_attr(ctx))); };
// top-most rule
path_expression_grammar_type const path_expression("path_expression");
// rules
x3::rule<class attr_expression, std::string> const attr_expression("attribute");
x3::rule<class str_expression, std::string> const str_expression("string");
@ -51,13 +49,4 @@ BOOST_SPIRIT_DEFINE(
}}
namespace mapnik {
grammar::path_expression_grammar_type const& path_expression_grammar()
{
return grammar::path_expression;
}
}
#endif //MAPNIK_PATH_EXPRESSIONS_GRAMMAR_X3_DEF_HPP

11
include/mapnik/svg/svg_path_grammar_x3.hpp
View file

@ -32,15 +32,12 @@ namespace x3 = boost::spirit::x3;
using svg_path_grammar_type = x3::rule<class svg_path_rule_tag>;
using svg_points_grammar_type = x3::rule<class svg_points_rule_tag>;
svg_path_grammar_type const svg_path = "SVG Path";
svg_points_grammar_type const svg_points = "SVG_Points";
BOOST_SPIRIT_DECLARE(svg_path_grammar_type,
svg_points_grammar_type);
}
grammar::svg_path_grammar_type const& svg_path_grammar();
grammar::svg_points_grammar_type const& svg_points_grammar();
}}
}}}
#endif // MAPNIK_SVG_PATH_GRAMMAR_X3_HPP

18
include/mapnik/svg/svg_path_grammar_x3_def.hpp
View file

@ -146,10 +146,6 @@ auto const absolute = [] (auto const& ctx)
extract_relative(ctx) = false;
};
// exported rules
svg_path_grammar_type const svg_path = "SVG Path";
svg_points_grammar_type const svg_points = "SVG_Points";
// rules
auto const coord = x3::rule<class coord_tag, coord_type>{} = double_ > -lit(',') > double_;
@ -200,18 +196,6 @@ BOOST_SPIRIT_DEFINE(
);
#pragma GCC diagnostic pop
}
grammar::svg_path_grammar_type const& svg_path_grammar()
{
return grammar::svg_path;
}
grammar::svg_points_grammar_type const& svg_points_grammar()
{
return grammar::svg_points;
}
}}
}}}
#endif // MAPNIK_SVG_PATH_GRAMMAR_X3_HPP

8
include/mapnik/svg/svg_transform_grammar_x3.hpp
View file

@ -32,12 +32,10 @@ using namespace boost::spirit::x3;
using svg_transform_grammar_type = x3::rule<class svg_transform_rule_tag>;
svg_transform_grammar_type const svg_transform = "SVG Transform";
BOOST_SPIRIT_DECLARE(svg_transform_grammar_type);
}
grammar::svg_transform_grammar_type const& svg_transform_grammar();
}}
}}}
#endif // MAPNIK_SVG_TRANSFORM_GRAMMAR_X3_HPP

12
include/mapnik/svg/svg_transform_grammar_x3_def.hpp
View file

@ -118,8 +118,6 @@ auto const skewY_action = [] (auto const& ctx)
tr = agg::trans_affine_skewing(0.0, agg::deg2rad(skew_y)) * tr;
};
//exported rule
svg_transform_grammar_type const svg_transform = "SVG Transform";
// rules
auto const matrix = x3::rule<class matrix_tag> {} = no_case[lit("matrix")]
> lit('(') > (double_ > -lit(',')
@ -157,14 +155,6 @@ BOOST_SPIRIT_DEFINE(
);
#pragma GCC diagnostic pop
}
grammar::svg_transform_grammar_type const& svg_transform_grammar()
{
return grammar::svg_transform;
}
}}
}}}
#endif // MAPNIK_SVG_TRANSFORM_GRAMMAR_X3_HPP

7
include/mapnik/transform/transform_expression_grammar_x3.hpp
View file

@ -39,13 +39,10 @@ namespace grammar {
struct transform_expression_class; // top-most ID
using transform_expression_grammar_type = x3::rule<transform_expression_class, mapnik::transform_list>;
transform_expression_grammar_type const transform("transform");
BOOST_SPIRIT_DECLARE(transform_expression_grammar_type);
}} // ns
namespace mapnik
{
grammar::transform_expression_grammar_type const& transform_expression_grammar();
}
#endif

12
include/mapnik/transform/transform_expression_grammar_x3_def.hpp
View file

@ -127,8 +127,6 @@ auto const construct_rotate = [](auto const& ctx)
_val(ctx) = mapnik::rotate_node(a, sx, sy);
};
// starting rule
transform_expression_grammar_type const transform("transform");
// rules
x3::rule<class transform_list_class, mapnik::transform_list> transform_list_rule("transform list");
x3::rule<class transform_node_class, mapnik::transform_node> transform_node_rule("transform node");
@ -155,7 +153,7 @@ auto const atom = x3::rule<class atom_tag, expr_node> {} = double_[create_expr_n
auto const sep_atom = x3::rule<class sep_atom_tag, expr_node> {} = -lit(',') >> double_[create_expr_node]
;
auto const expr_def = expression_grammar();
auto const expr_def = expression;
// Individual arguments in lists containing one or more compound
// expressions are separated by a comma.
auto const sep_expr_def = lit(',') > expr
@ -212,12 +210,4 @@ BOOST_SPIRIT_DEFINE (
}} // ns
namespace mapnik
{
grammar::transform_expression_grammar_type const& transform_expression_grammar()
{
return grammar::transform;
}
}
#endif

7
include/mapnik/wkt/wkt_grammar_x3.hpp
View file

@ -36,14 +36,11 @@ namespace x3 = boost::spirit::x3;
struct wkt_class; // top-most ID
using wkt_grammar_type = x3::rule<wkt_class, mapnik::geometry::geometry<double>>;
wkt_grammar_type const wkt("wkt");
BOOST_SPIRIT_DECLARE(wkt_grammar_type);
}}
namespace mapnik
{
grammar::wkt_grammar_type const& wkt_grammar();
}
#endif // MAPNIK_WKT_GRAMMAR_X3_HPP

10
include/mapnik/wkt/wkt_grammar_x3_def.hpp
View file

@ -57,8 +57,6 @@ auto add_ring = [](auto const& ctx)
_val(ctx).push_back(std::move(ring));
};
// start rule
wkt_grammar_type const wkt("wkt");
// rules
x3::rule<class empty, mapnik::geometry::geometry_empty> const empty("EMPTY");
x3::rule<class point, mapnik::geometry::geometry<double> > const point("POINT");
@ -126,12 +124,4 @@ BOOST_SPIRIT_DEFINE(
);
}}
namespace mapnik
{
grammar::wkt_grammar_type const& wkt_grammar()
{
return grammar::wkt;
}
}
#endif // MAPNIK_WKT_GRAMMAR_X3_DEF_HPP

2
plugins/input/csv/csv_utils.cpp
View file

@ -197,7 +197,7 @@ mapnik::csv_line parse_line(char const* start, char const* end, char separator,
namespace x3 = boost::spirit::x3;
auto parser = x3::with<mapnik::grammar::quote_tag>(quote)
[ x3::with<mapnik::grammar::separator_tag>(separator)
[ mapnik::csv_line_grammar()]
[ mapnik::grammar::line ]
];
mapnik::csv_line values;

2
plugins/input/topojson/topojson_datasource.cpp
View file

@ -184,7 +184,7 @@ void topojson_datasource::parse_topojson(T const& buffer)
using space_type = boost::spirit::x3::standard::space_type;
try
{
boost::spirit::x3::phrase_parse(itr, end, mapnik::json::topojson_grammar(), space_type(), topo_);
boost::spirit::x3::phrase_parse(itr, end, mapnik::json::grammar::topology, space_type(), topo_);
}
catch (boost::spirit::x3::expectation_failure<char const*> const& ex)
{

2
src/color_factory.cpp
View file

@ -31,7 +31,7 @@ namespace mapnik {
color parse_color(std::string const& str)
{
// TODO - early return for @color?
auto const& grammar = mapnik::color_grammar();
auto const& grammar = mapnik::css_color_grammar::css_color;
color c;
std::string::const_iterator first = str.begin();
std::string::const_iterator last = str.end();

4
src/expression.cpp
View file

@ -38,12 +38,12 @@ expression_ptr parse_expression(std::string const& str)
#if BOOST_VERSION >=106700
auto parser = boost::spirit::x3::with<mapnik::grammar::transcoder_tag>(tr)
[
mapnik::expression_grammar()
mapnik::grammar::expression
];
#else
auto parser = boost::spirit::x3::with<mapnik::grammar::transcoder_tag>(std::ref(tr))
[
mapnik::expression_grammar()
mapnik::grammar::expression
];
#endif
bool r = false;

5
src/json/extract_bounding_boxes_x3.cpp
View file

@ -92,11 +92,10 @@ auto on_feature_callback = [] (auto const& ctx)
x3::get<feature_callback_tag>(ctx)(_attr(ctx));
};
namespace { auto const& geojson_value = geojson_grammar();}
// import unicode string rule
namespace { auto const& geojson_string = unicode_string_grammar(); }
namespace { auto const& geojson_string = unicode_string; }
// import positions rule
namespace { auto const& positions_rule = positions_grammar(); }
namespace { auto const& positions_rule = positions; }
// extract bounding box from GeoJSON Feature

14
src/json/feature_grammar_x3.cpp
View file

@ -29,16 +29,4 @@ BOOST_SPIRIT_INSTANTIATE(feature_grammar_type, iterator_type, feature_context_ty
BOOST_SPIRIT_INSTANTIATE(geometry_grammar_type, iterator_type, phrase_parse_context_type);
BOOST_SPIRIT_INSTANTIATE_UNUSED(feature_grammar_type, iterator_type, feature_context_const_type);
}
grammar::feature_grammar_type const& feature_grammar()
{
return grammar::feature_rule;
}
grammar::geometry_grammar_type const& geometry_grammar()
{
return grammar::geometry_rule;
}
}}
}}}

13
src/json/generic_json_grammar_x3.cpp
View file

@ -34,15 +34,4 @@ BOOST_SPIRIT_INSTANTIATE_UNUSED(generic_json_grammar_type, iterator_type, phrase
BOOST_SPIRIT_INSTANTIATE_UNUSED(generic_json_grammar_type, iterator_type, feature_context_type);
BOOST_SPIRIT_INSTANTIATE_UNUSED(generic_json_grammar_type, iterator_type, feature_context_const_type);
}
grammar::generic_json_grammar_type const& generic_json_grammar()
{
return grammar::value;
}
grammar::generic_json_key_value_type const& generic_json_key_value()
{
return grammar::key_value;
}
}}
}}}

16
src/json/geojson_grammar_x3.cpp
View file

@ -28,7 +28,7 @@
namespace mapnik { namespace json { namespace grammar {
BOOST_SPIRIT_INSTANTIATE(geojson_grammar_type, iterator_type, context_type);
BOOST_SPIRIT_INSTANTIATE(key_value_type, iterator_type, context_type);
BOOST_SPIRIT_INSTANTIATE(geojson_key_value_type, iterator_type, context_type);
BOOST_SPIRIT_INSTANTIATE(geojson_grammar_type, iterator_type, extract_bounding_boxes_context_type);
@ -38,16 +38,4 @@ BOOST_SPIRIT_INSTANTIATE_UNUSED(geojson_grammar_type, iterator_type, extract_bou
BOOST_SPIRIT_INSTANTIATE_UNUSED(geojson_grammar_type, iterator_type, extract_bounding_boxes_context_type_f);
BOOST_SPIRIT_INSTANTIATE_UNUSED(geojson_grammar_type, iterator_type, extract_bounding_boxes_reverse_context_type_f);
}
grammar::geojson_grammar_type const& geojson_grammar()
{
return grammar::value;
}
grammar::key_value_type const& key_value_grammar()
{
return grammar::key_value;
}
}}
}}}

2
src/json/geometry_from_geojson.cpp
View file

@ -32,7 +32,7 @@ bool from_geojson(std::string const& json, mapnik::geometry::geometry<double> &
{
namespace x3 = boost::spirit::x3;
using space_type = mapnik::json::grammar::space_type;
auto grammar = mapnik::json::geometry_grammar();
auto grammar = mapnik::json::grammar::geometry_rule;
try
{
const char* start = json.c_str();

6
src/json/parse_feature.cpp
View file

@ -34,11 +34,11 @@ void parse_feature(Iterator start, Iterator end, feature_impl& feature, mapnik::
#if BOOST_VERSION >= 106700
auto grammar = x3::with<mapnik::json::grammar::transcoder_tag>(tr)
[x3::with<mapnik::json::grammar::feature_tag>(feature)
[ mapnik::json::feature_grammar() ]];
[ mapnik::json::grammar::feature_rule ]];
#else
auto grammar = x3::with<mapnik::json::grammar::transcoder_tag>(std::ref(tr))
[x3::with<mapnik::json::grammar::feature_tag>(std::ref(feature))
[ mapnik::json::feature_grammar() ]];
[ mapnik::json::grammar::feature_rule ]];
#endif
if (!x3::phrase_parse(start, end, grammar, space_type()))
{
@ -51,7 +51,7 @@ void parse_geometry(Iterator start, Iterator end, feature_impl& feature)
{
namespace x3 = boost::spirit::x3;
using space_type = mapnik::json::grammar::space_type;
auto grammar = mapnik::json::geometry_grammar();
auto grammar = mapnik::json::grammar::geometry_rule;
if (!x3::phrase_parse(start, end, grammar, space_type(), feature.get_geometry()))
{
throw std::runtime_error("Can't parser GeoJSON Geometry");

9
src/json/positions_grammar_x3.cpp
View file

@ -41,11 +41,4 @@ BOOST_SPIRIT_INSTANTIATE_UNUSED(positions_grammar_type, iterator_type, extract_b
BOOST_SPIRIT_INSTANTIATE_UNUSED(positions_grammar_type, iterator_type, extract_bounding_boxes_context_type_f);
BOOST_SPIRIT_INSTANTIATE_UNUSED(positions_grammar_type, iterator_type, extract_bounding_boxes_reverse_context_type_f);
}
grammar::positions_grammar_type const& positions_grammar()
{
return grammar::positions;
}
}}
}}}

9
src/json/topojson_grammar_x3.cpp
View file

@ -27,11 +27,4 @@ namespace mapnik { namespace json { namespace grammar {
BOOST_SPIRIT_INSTANTIATE(topojson_grammar_type, iterator_type, phrase_parse_context_type);
}
grammar::topojson_grammar_type const& topojson_grammar()
{
return grammar::topology;
}
}}
}}}

8
src/json/unicode_string_grammar_x3.cpp
View file

@ -42,11 +42,5 @@ BOOST_SPIRIT_INSTANTIATE_UNUSED(unicode_string_grammar_type, iterator_type, extr
BOOST_SPIRIT_INSTANTIATE_UNUSED(unicode_string_grammar_type, iterator_type, extract_bounding_boxes_reverse_context_type);
BOOST_SPIRIT_INSTANTIATE_UNUSED(unicode_string_grammar_type, iterator_type, extract_bounding_boxes_context_type_f);
BOOST_SPIRIT_INSTANTIATE_UNUSED(unicode_string_grammar_type, iterator_type, extract_bounding_boxes_reverse_context_type_f);
}
grammar::unicode_string_grammar_type const& unicode_string_grammar()
{
return grammar::unicode_string;
}
}}
}}}

2
src/parse_image_filters.cpp
View file

@ -32,7 +32,7 @@ namespace filter {
bool parse_image_filters(std::string const& str, std::vector<filter_type> & image_filters)
{
auto const& grammar = mapnik::image_filter_grammar();
auto const& grammar = mapnik::image_filter::start;
auto itr = str.begin();
auto end = str.end();

2
src/parse_path.cpp
View file

@ -40,7 +40,7 @@ path_expression_ptr parse_path(std::string const& str)
using boost::spirit::x3::standard_wide::space;
std::string::const_iterator itr = str.begin();
std::string::const_iterator end = str.end();
bool r = x3::phrase_parse(itr, end, path_expression_grammar(), space, *path);
bool r = x3::phrase_parse(itr, end, grammar::path_expression, space, *path);
if (r && itr == end)
{
return path;

4
src/parse_transform.cpp
View file

@ -40,12 +40,12 @@ transform_list_ptr parse_transform(std::string const& str, std::string const& en
#if BOOST_VERSION >= 106700
auto const parser = boost::spirit::x3::with<mapnik::grammar::transcoder_tag>(tr)
[
mapnik::transform_expression_grammar()
mapnik::grammar::transform
];
#else
auto const parser = boost::spirit::x3::with<mapnik::grammar::transcoder_tag>(std::ref(tr))
[
mapnik::transform_expression_grammar()
mapnik::grammar::transform
];
#endif

4
src/svg/svg_path_parser.cpp
View file

@ -43,11 +43,11 @@ bool parse_path(const char* wkt, PathType& p)
#if BOOST_VERSION >= 106700
auto const grammar = x3::with<mapnik::svg::grammar::svg_path_tag>(p)
[ x3::with<mapnik::svg::grammar::relative_tag>(relative)
[mapnik::svg::svg_path_grammar()]];
[mapnik::svg::grammar::svg_path]];
#else
auto const grammar = x3::with<mapnik::svg::grammar::svg_path_tag>(std::ref(p))
[ x3::with<mapnik::svg::grammar::relative_tag>(std::ref(relative))
[mapnik::svg::svg_path_grammar()]];
[mapnik::svg::grammar::svg_path]];
#endif
try
{

4
src/svg/svg_points_parser.cpp
View file

@ -43,11 +43,11 @@ bool parse_points(const char* wkt, PathType& p)
#if BOOST_VERSION >= 106700
auto const grammar = x3::with<mapnik::svg::grammar::svg_path_tag>(p)
[ x3::with<mapnik::svg::grammar::relative_tag>(relative)
[mapnik::svg::svg_points_grammar()]];
[mapnik::svg::grammar::svg_points]];
#else
auto const grammar = x3::with<mapnik::svg::grammar::svg_path_tag>(std::ref(p))
[ x3::with<mapnik::svg::grammar::relative_tag>(std::ref(relative))
[mapnik::svg::svg_points_grammar()]];
[mapnik::svg::grammar::svg_points]];
#endif
try
{

4
src/svg/svg_transform_parser.cpp
View file

@ -40,11 +40,11 @@ bool parse_svg_transform(const char* wkt, Transform& tr)
#if BOOST_VERSION >= 106700
auto const grammar = x3::with<mapnik::svg::grammar::svg_transform_tag>(tr)
[mapnik::svg::svg_transform_grammar()];
[mapnik::svg::grammar::svg_transform];
#else
auto const grammar = x3::with<mapnik::svg::grammar::svg_transform_tag>(std::ref(tr))
[mapnik::svg::svg_transform_grammar()];
[mapnik::svg::grammar::svg_transform];
#endif
try

2
src/wkt/wkt_factory.cpp
View file

@ -35,7 +35,7 @@ bool from_wkt(std::string const& wkt, mapnik::geometry::geometry<double> & geom)
bool result;
try
{
result = x3::phrase_parse(itr, end, wkt_grammar(), space, geom);
result = x3::phrase_parse(itr, end, grammar::wkt, space, geom);
}
catch (x3::expectation_failure<std::string::const_iterator> const& ex)
{

2
test/unit/color/css_color.cpp
View file

@ -21,7 +21,7 @@ TEST_CASE("CSS color") {
SECTION("CSS colors")
{
auto const& color_grammar = mapnik::color_grammar();
auto const& color_grammar = mapnik::css_color_grammar::css_color;
boost::spirit::x3::ascii::space_type space;
{
// rgb

2
test/unit/datasource/topojson.cpp
View file

@ -58,7 +58,7 @@ bool parse_topology_string(std::string const& buffer, mapnik::topojson::topology
char const* end = itr + buffer.length();
try
{
boost::spirit::x3::phrase_parse(itr, end, mapnik::json::topojson_grammar(), space_type() , topo);
boost::spirit::x3::phrase_parse(itr, end, mapnik::json::grammar::topology, space_type() , topo);
}
catch (boost::spirit::x3::expectation_failure<char const*> const& ex)
{

2
utils/mapnik-index/process_geojson_file_x3.cpp
View file

@ -224,7 +224,7 @@ using box_type = mapnik::box2d<float>;
using boxes_type = std::vector<std::pair<box_type, std::pair<std::uint64_t, std::uint64_t>>>;
using base_iterator_type = char const*;
auto const& geojson_value = mapnik::json::geojson_grammar();
auto const& geojson_value = mapnik::json::grammar::geojson_value;
}