EIC code displayed by LXR master/​include/​boost/​property_tree/​json_parser/​detail/​parser.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-07-14 08:45:41

 #ifndef BOOST_PROPERTY_TREE_DETAIL_JSON_PARSER_PARSER_HPP
 #define BOOST_PROPERTY_TREE_DETAIL_JSON_PARSER_PARSER_HPP
 
 #include <boost/property_tree/json_parser/error.hpp>
 
 #include <boost/core/ref.hpp>
 #include <boost/bind/bind.hpp>
 #include <boost/bind/placeholders.hpp>
 
 #include <iterator>
 #include <sstream>
 #include <string>
 
 namespace boost { namespace property_tree {
     namespace json_parser { namespace detail
 {
 
     template <typename Encoding, typename Iterator, typename Sentinel>
     class source
     {
     public:
         typedef typename std::iterator_traits<Iterator>::value_type
             code_unit;
         typedef bool (Encoding::*encoding_predicate)(code_unit c) const;
 
         explicit source(Encoding& encoding) : encoding(encoding) {}
 
         template <typename Range>
         void set_input(const std::string& filename, const Range& r)
         {
             this->filename = filename;
             cur = r.begin();
             end = r.end();
             // Note that there is no backtracking, so if e.g. a UTF-8 file
             // starts with something that initially looks like a BOM but isn't,
             // there's trouble.
             // However, no valid JSON file can start with a UTF-8 EF byte.
             encoding.skip_introduction(cur, end);
             line = 1;
             offset = 0;
         }
 
         bool done() const { return cur == end; }
 
         void parse_error(const char* msg) {
             BOOST_PROPERTY_TREE_THROW(
                 json_parser_error(msg, filename, line));
         }
 
         void next() {
             if (encoding.is_nl(*cur)) {
                 ++line;
                 offset = 0;
             } else {
                 ++offset;
             }
             ++cur;
         }
 
         template <typename Action>
         bool have(encoding_predicate p, Action& a) {
             bool found = cur != end && (encoding.*p)(*cur);
             if (found) {
                 a(*cur);
                 next();
             }
             return found;
         }
 
         bool have(encoding_predicate p) {
             DoNothing n;
             return have(p, n);
         }
 
         template <typename Action>
         void expect(encoding_predicate p, const char* msg, Action& a) {
             if (!have(p, a)) {
                 parse_error(msg);
             }
         }
 
         void expect(encoding_predicate p, const char* msg) {
             DoNothing n;
             expect(p, msg, n);
         }
 
         code_unit need_cur(const char* msg) {
             if (cur == end) {
                 parse_error(msg);
             }
             return *cur;
         }
 
         Iterator& raw_cur() { return cur; }
         Sentinel raw_end() { return end; }
 
     private:
         struct DoNothing {
             void operator ()(code_unit) const {}
         };
 
         Encoding& encoding;
         Iterator cur;
         Sentinel end;
         std::string filename;
         int line;
         int offset;
     };
 
     template <typename Callbacks, typename Encoding, typename Iterator,
         typename = typename std::iterator_traits<Iterator>
             ::iterator_category>
     class number_callback_adapter
     {
     public:
         number_callback_adapter(Callbacks& callbacks, Encoding& encoding,
                                 Iterator& cur)
             : callbacks(callbacks), encoding(encoding), first(cur), cur(cur)
         {}
 
         void operator ()(typename Encoding::external_char) {}
 
         void finish() const {
             callbacks.on_number(encoding.to_internal(first, cur));
         }
 
     private:
         number_callback_adapter(const number_callback_adapter&);
 
         Callbacks& callbacks;
         Encoding& encoding;
         Iterator first;
         Iterator& cur;
     };
 
     template <typename Callbacks, typename Encoding, typename Iterator>
     class number_callback_adapter<Callbacks, Encoding, Iterator,
                                   std::input_iterator_tag>
     {
     public:
         number_callback_adapter(Callbacks& callbacks, Encoding& encoding,
                                 Iterator&)
             : callbacks(callbacks), encoding(encoding), first(true)
         {}
 
         void operator ()(typename Encoding::external_char c) {
             if (first) {
                 callbacks.on_begin_number();
                 first = false;
             }
             callbacks.on_digit(encoding.to_internal_trivial(c));
         }
 
         void finish() const {
             callbacks.on_end_number();
         }
     private:
         number_callback_adapter(const number_callback_adapter&);
 
         Callbacks& callbacks;
         Encoding& encoding;
         bool first;
     };
 
     template <typename Callbacks, typename Encoding, typename Iterator,
         typename = typename std::iterator_traits<Iterator>
             ::iterator_category>
     class string_callback_adapter
     {
     public:
         string_callback_adapter(Callbacks& callbacks, Encoding& encoding,
                                 Iterator& cur)
             : callbacks(callbacks), encoding(encoding), cur(cur),
               run_begin(cur)
         {}
 
         void start_run() {
             run_begin = cur;
         }
 
         void finish_run() {
             callbacks.on_code_units(encoding.to_internal(run_begin, cur));
         }
 
         template <typename Sentinel, typename EncodingErrorFn>
         void process_codepoint(Sentinel end, EncodingErrorFn error_fn) {
             encoding.skip_codepoint(cur, end, error_fn);
         }
 
     private:
         string_callback_adapter(const string_callback_adapter&);
 
         Callbacks& callbacks;
         Encoding& encoding;
         Iterator& cur;
         Iterator run_begin;
     };
 
     template <typename Callbacks, typename Encoding, typename Iterator>
     class string_callback_adapter<Callbacks, Encoding, Iterator,
                                   std::input_iterator_tag>
     {
     public:
         string_callback_adapter(Callbacks& callbacks, Encoding& encoding,
                                 Iterator& cur)
             : callbacks(callbacks), encoding(encoding), cur(cur)
         {}
 
         void start_run() {}
 
         void finish_run() {}
 
         template <typename Sentinel, typename EncodingErrorFn>
         void process_codepoint(Sentinel end, EncodingErrorFn error_fn) {
             encoding.transcode_codepoint(cur, end,
                 boost::bind(&Callbacks::on_code_unit,
                             boost::ref(callbacks), boost::placeholders::_1),
                 error_fn);
         }
 
     private:
         string_callback_adapter(const string_callback_adapter&);
 
         Callbacks& callbacks;
         Encoding& encoding;
         Iterator& cur;
     };
 
     template <typename Callbacks, typename Encoding, typename Iterator,
               typename Sentinel>
     class parser
     {
         typedef detail::number_callback_adapter<Callbacks, Encoding, Iterator>
             number_adapter;
         typedef detail::string_callback_adapter<Callbacks, Encoding, Iterator>
             string_adapter;
         typedef detail::source<Encoding, Iterator, Sentinel> source;
         typedef typename source::code_unit code_unit;
 
     public:
         parser(Callbacks& callbacks, Encoding& encoding)
             : callbacks(callbacks), encoding(encoding), src(encoding)
         {}
 
         template <typename Range>
         void set_input(const std::string& filename, const Range& r) {
             src.set_input(filename, r);
         }
 
         void finish() {
             skip_ws();
             if (!src.done()) {
                 parse_error("garbage after data");
             }
         }
 
         void parse_value() {
             if (parse_object()) return;
             if (parse_array()) return;
             if (parse_string()) return;
             if (parse_boolean()) return;
             if (parse_null()) return;
             if (parse_number()) return;
             parse_error("expected value");
         }
 
         bool parse_null() {
             skip_ws();
             if (!have(&Encoding::is_n)) {
                 return false;
             }
             expect(&Encoding::is_u, "expected 'null'");
             expect(&Encoding::is_l, "expected 'null'");
             expect(&Encoding::is_l, "expected 'null'");
             callbacks.on_null();
             return true;
         }
 
         bool parse_boolean() {
             skip_ws();
             if (have(&Encoding::is_t)) {
                 expect(&Encoding::is_r, "expected 'true'");
                 expect(&Encoding::is_u, "expected 'true'");
                 expect(&Encoding::is_e, "expected 'true'");
                 callbacks.on_boolean(true);
                 return true;
             }
             if (have(&Encoding::is_f)) {
                 expect(&Encoding::is_a, "expected 'false'");
                 expect(&Encoding::is_l, "expected 'false'");
                 expect(&Encoding::is_s, "expected 'false'");
                 expect(&Encoding::is_e, "expected 'false'");
                 callbacks.on_boolean(false);
                 return true;
             }
             return false;
         }
 
         bool parse_number() {
             skip_ws();
 
             number_adapter adapter(callbacks, encoding, src.raw_cur());
             bool started = false;
             if (have(&Encoding::is_minus, adapter)) {
                 started = true;
             }
             if (!have(&Encoding::is_0, adapter) && !parse_int_part(adapter)) {
                 if (started) {
                     parse_error("expected digits after -");
                 }
                 return false;
             }
             parse_frac_part(adapter);
             parse_exp_part(adapter);
             adapter.finish();
             return true;
         }
 
         bool parse_string() {
             skip_ws();
 
             if (!have(&Encoding::is_quote)) {
                 return false;
             }
 
             callbacks.on_begin_string();
             string_adapter adapter(callbacks, encoding, src.raw_cur());
             while (!encoding.is_quote(need_cur("unterminated string"))) {
                 if (encoding.is_backslash(*src.raw_cur())) {
                     adapter.finish_run();
                     next();
                     parse_escape();
                     adapter.start_run();
                 } else {
                     adapter.process_codepoint(src.raw_end(),
                         boost::bind(&parser::parse_error,
                                     this, "invalid code sequence"));
                 }
             }
             adapter.finish_run();
             callbacks.on_end_string();
             next();
             return true;
         }
 
         bool parse_array() {
             skip_ws();
 
             if (!have(&Encoding::is_open_bracket)) {
                 return false;
             }
 
             callbacks.on_begin_array();
             skip_ws();
             if (have(&Encoding::is_close_bracket)) {
                 callbacks.on_end_array();
                 return true;
             }
             do {
                 parse_value();
                 skip_ws();
             } while (have(&Encoding::is_comma));
             expect(&Encoding::is_close_bracket, "expected ']' or ','");
             callbacks.on_end_array();
             return true;
         }
 
         bool parse_object() {
             skip_ws();
 
             if (!have(&Encoding::is_open_brace)) {
                 return false;
             }
 
             callbacks.on_begin_object();
             skip_ws();
             if (have(&Encoding::is_close_brace)) {
                 callbacks.on_end_object();
                 return true;
             }
             do {
                 if (!parse_string()) {
                     parse_error("expected key string");
                 }
                 skip_ws();
                 expect(&Encoding::is_colon, "expected ':'");
                 parse_value();
                 skip_ws();
             } while (have(&Encoding::is_comma));
             expect(&Encoding::is_close_brace, "expected '}' or ','");
             callbacks.on_end_object();
             return true;
         }
 
     private:
         typedef typename source::encoding_predicate encoding_predicate;
 
         void parse_error(const char* msg) { src.parse_error(msg); }
         void next() { src.next(); }
         template <typename Action>
         bool have(encoding_predicate p, Action& a) { return src.have(p, a); }
         bool have(encoding_predicate p) { return src.have(p); }
         template <typename Action>
         void expect(encoding_predicate p, const char* msg, Action& a) {
             src.expect(p, msg, a);
         }
         void expect(encoding_predicate p, const char* msg) {
             src.expect(p, msg);
         }
         code_unit need_cur(const char* msg) { return src.need_cur(msg); }
 
         void skip_ws() {
             while (have(&Encoding::is_ws)) {
             }
         }
 
         bool parse_int_part(number_adapter& action) {
             if (!have(&Encoding::is_digit0, action)) {
                 return false;
             }
             parse_digits(action);
             return true;
         }
 
         void parse_frac_part(number_adapter& action) {
             if (!have(&Encoding::is_dot, action)) {
                 return;
             }
             expect(&Encoding::is_digit, "need at least one digit after '.'",
                    action);
             parse_digits(action);
         }
 
         void parse_exp_part(number_adapter& action) {
             if (!have(&Encoding::is_eE, action)) {
                 return;
             }
             have(&Encoding::is_plusminus, action);
             expect(&Encoding::is_digit, "need at least one digit in exponent",
                    action);
             parse_digits(action);
         }
 
         void parse_digits(number_adapter& action) {
             while (have(&Encoding::is_digit, action)) {
             }
         }
 
         void parse_escape() {
             if (have(&Encoding::is_quote)) {
                 feed(0x22);
             } else if (have(&Encoding::is_backslash)) {
                 feed(0x5c);
             } else if (have(&Encoding::is_slash)) {
                 feed(0x2f);
             } else if (have(&Encoding::is_b)) {
                 feed(0x08); // backspace
             } else if (have(&Encoding::is_f)) {
                 feed(0x0c); // formfeed
             } else if (have(&Encoding::is_n)) {
                 feed(0x0a); // line feed
             } else if (have(&Encoding::is_r)) {
                 feed(0x0d); // carriage return
             } else if (have(&Encoding::is_t)) {
                 feed(0x09); // horizontal tab
             } else if (have(&Encoding::is_u)) {
                 parse_codepoint_ref();
             } else {
                 parse_error("invalid escape sequence");
             }
         }
 
         unsigned parse_hex_quad() {
             unsigned codepoint = 0;
             for (int i = 0; i < 4; ++i) {
                 int value = encoding.decode_hexdigit(
                     need_cur("invalid escape sequence"));
                 if (value < 0) {
                     parse_error("invalid escape sequence");
                 }
                 codepoint *= 16;
                 codepoint += value;
                 next();
             }
             return codepoint;
         }
 
         static bool is_surrogate_high(unsigned codepoint) {
             return (codepoint & 0xfc00) == 0xd800;
         }
         static bool is_surrogate_low(unsigned codepoint) {
             return (codepoint & 0xfc00) == 0xdc00;
         }
         static unsigned combine_surrogates(unsigned high, unsigned low) {
             return 0x010000 + (((high & 0x3ff) << 10) | (low & 0x3ff));
         }
 
         void parse_codepoint_ref() {
             unsigned codepoint = parse_hex_quad();
             if (is_surrogate_low(codepoint)) {
                 parse_error("invalid codepoint, stray low surrogate");
             }
             if (is_surrogate_high(codepoint)) {
                 expect(&Encoding::is_backslash,
                     "invalid codepoint, stray high surrogate");
                 expect(&Encoding::is_u,
                     "expected codepoint reference after high surrogate");
                 int low = parse_hex_quad();
                 if (!is_surrogate_low(low)) {
                     parse_error("expected low surrogate after high surrogate");
                 }
                 codepoint = combine_surrogates(codepoint, low);
             }
             feed(codepoint);
         }
 
         void feed(unsigned codepoint) {
             encoding.feed_codepoint(codepoint,
                                     boost::bind(&Callbacks::on_code_unit,
                                                 boost::ref(callbacks), boost::placeholders::_1));
         }
 
         Callbacks& callbacks;
         Encoding& encoding;
         source src;
     };
 
 }}}}
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team