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             : 
      11             : #include <boost/url/detail/config.hpp>
      12             : #include "port_rule.hpp"
      13             : #include <boost/url/grammar/parse.hpp>
      14             : #include <boost/url/grammar/token_rule.hpp>
      15             : #include <boost/url/grammar/unsigned_rule.hpp>
      16             : #include <boost/static_assert.hpp>
      17             : #include <type_traits>
      18             : 
      19             : namespace boost {
      20             : namespace urls {
      21             : namespace detail {
      22             : 
      23             : auto
      24         363 : port_rule::
      25             : parse(
      26             :     char const*& it,
      27             :     char const* end) const noexcept ->
      28             :         system::result<value_type>
      29             : {
      30         363 :     value_type t;
      31         363 :     auto const start = it;
      32         128 :     while(
      33         491 :         it != end &&
      34         429 :         *it == '0')
      35             :     {
      36         128 :         ++it;
      37             :     }
      38             : 
      39         363 :     if (it != end)
      40             :     {
      41             :         grammar::unsigned_rule<std::uint16_t> r;
      42         301 :         auto it0 = it;
      43         301 :         auto rv = r.parse(it, end);
      44         301 :         if (rv)
      45             :         {
      46             :             // number < max uint16_t
      47         247 :             t.str = core::string_view(start, it);
      48         247 :             t.has_number = true;
      49         247 :             t.number = *rv;
      50         268 :             return t;
      51             :         }
      52          54 :         it = it0;
      53          54 :         if (grammar::digit_chars(*it))
      54             :         {
      55             :             // number > max uint16_t
      56         168 :             while (
      57         366 :                 it != end &&
      58         177 :                 grammar::digit_chars(*it))
      59             :             {
      60         168 :                 ++it;
      61             :             }
      62          21 :             t.str = core::string_view(start, it);
      63          21 :             t.has_number = true;
      64          21 :             t.number = 0;
      65          21 :             return t;
      66             :         }
      67             :     }
      68             :     // no digits
      69          95 :     t.str = core::string_view(start, it);
      70          95 :     t.has_number = it != end;
      71          95 :     t.number = 0;
      72          95 :     return t;
      73             : }
      74             : 
      75             : auto
      76        1879 : port_part_rule_t::
      77             : parse(
      78             :     char const*& it,
      79             :     char const* end) const noexcept ->
      80             :         system::result<value_type>
      81             : {
      82        1879 :     value_type t;
      83        1879 :     if( it == end ||
      84        1281 :         *it != ':')
      85             :     {
      86        1606 :         t.has_port = false;
      87        1606 :         return t;
      88             :     }
      89         273 :     ++it;
      90             :     auto rv = grammar::parse(
      91         273 :         it, end, port_rule{});
      92         273 :     if(! rv)
      93           0 :         return rv.error();
      94         273 :     t.has_port = true;
      95         273 :     t.port = rv->str;
      96         273 :     t.has_number = rv->has_number;
      97         273 :     t.port_number = rv->number;
      98         273 :     return t;
      99             : }
     100             : 
     101             : } // detail
     102             : } // urls
     103             : } // boost
     104             :