Line data    Source code

       1              : //
       2              : // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
       3              : //
       4              : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       5              : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       6              : //
       7              : // Official repository: https://github.com/boostorg/url
       8              : //
       9              : 
      10              : #ifndef BOOST_URL_RFC_IMPL_PCT_ENCODED_RULE_HPP
      11              : #define BOOST_URL_RFC_IMPL_PCT_ENCODED_RULE_HPP
      12              : 
      13              : #include <boost/url/grammar/charset.hpp>
      14              : #include <boost/url/grammar/error.hpp>
      15              : #include <boost/url/grammar/hexdig_chars.hpp>
      16              : 
      17              : namespace boost {
      18              : namespace urls {
      19              : 
      20              : namespace detail {
      21              : 
      22              : template<class CharSet>
      23              : auto
      24         9268 : parse_encoded(
      25              :     char const*& it,
      26              :     char const* end,
      27              :     CharSet const& cs) noexcept ->
      28              :         system::result<pct_string_view>
      29              : {
      30         9268 :     auto const start = it;
      31         9268 :     std::size_t n = 0;
      32              :     char const* it0;
      33         9579 : skip:
      34         9579 :     it0 = it;
      35         9579 :     it = grammar::find_if_not(
      36              :         it0, end, cs);
      37         9579 :     n += it - it0;
      38         9579 :     if(it == end)
      39         2804 :         goto finish;
      40         6775 :     if(*it != '%')
      41         6365 :         goto finish;
      42          212 :     for(;;)
      43              :     {
      44          622 :         ++it;
      45          622 :         if(it == end)
      46              :         {
      47              :             // expected HEXDIG
      48           14 :             BOOST_URL_RETURN_EC(
      49              :                 grammar::error::invalid);
      50              :         }
      51          608 :         auto r = grammar::hexdig_value(*it);
      52          608 :         if(r < 0)
      53              :         {
      54              :             // expected HEXDIG
      55           12 :             BOOST_URL_RETURN_EC(
      56              :                 grammar::error::invalid);
      57              :         }
      58          596 :         ++it;
      59          596 :         if(it == end)
      60              :         {
      61              :             // expected HEXDIG
      62            5 :             BOOST_URL_RETURN_EC(
      63              :                 grammar::error::invalid);
      64              :         }
      65          591 :         r = grammar::hexdig_value(*it);
      66          591 :         if(r < 0)
      67              :         {
      68              :             // expected HEXDIG
      69            8 :             BOOST_URL_RETURN_EC(
      70              :                 grammar::error::invalid);
      71              :         }
      72          583 :         ++n;
      73          583 :         ++it;
      74          583 :         if(it == end)
      75           60 :             break;
      76          523 :         if(*it != '%')
      77          311 :             goto skip;
      78              :     }
      79         9229 : finish:
      80         9229 :     return make_pct_string_view_unsafe(
      81         9229 :         start, it - start, n);
      82              : }
      83              : 
      84              : } // detail
      85              : 
      86              : //------------------------------------------------
      87              : 
      88              : template<class CharSet>
      89              : auto
      90         9268 : implementation_defined::pct_encoded_rule_t<CharSet>::
      91              : parse(
      92              :     char const*& it,
      93              :     char const* end) const noexcept ->
      94              :         system::result<value_type>
      95              : {
      96         9268 :     return detail::parse_encoded(
      97         9268 :         it, end, cs_);
      98              : }
      99              : 
     100              : } // urls
     101              : } // boost
     102              : 
     103              : #endif