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         350 : port_rule::
      25             : parse(
      26             :     char const*& it,
      27             :     char const* end) const noexcept ->
      28             :         system::result<value_type>
      29             : {
      30         350 :     value_type t;
      31         350 :     auto const start = it;
      32         124 :     while(
      33         474 :         it != end &&
      34         414 :         *it == '0')
      35             :     {
      36         124 :         ++it;
      37             :     }
      38             : 
      39         350 :     if (it != end)
      40             :     {
      41             :         grammar::unsigned_rule<std::uint16_t> r;
      42         290 :         auto it0 = it;
      43         290 :         auto rv = r.parse(it, end);
      44         290 :         if (rv)
      45             :         {
      46             :             // number < max uint16_t
      47         236 :             t.str = core::string_view(start, it);
      48         236 :             t.has_number = true;
      49         236 :             t.number = *rv;
      50         257 :             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          93 :     t.str = core::string_view(start, it);
      70          93 :     t.has_number = it != end;
      71          93 :     t.number = 0;
      72          93 :     return t;
      73             : }
      74             : 
      75             : auto
      76        1861 : port_part_rule_t::
      77             : parse(
      78             :     char const*& it,
      79             :     char const* end) const noexcept ->
      80             :         system::result<value_type>
      81             : {
      82        1861 :     value_type t;
      83        1861 :     if( it == end ||
      84        1266 :         *it != ':')
      85             :     {
      86        1601 :         t.has_port = false;
      87        1601 :         return t;
      88             :     }
      89         260 :     ++it;
      90             :     auto rv = grammar::parse(
      91         260 :         it, end, port_rule{});
      92         260 :     if(! rv)
      93           0 :         return rv.error();
      94         260 :     t.has_port = true;
      95         260 :     t.port = rv->str;
      96         260 :     t.has_number = rv->has_number;
      97         260 :     t.port_number = rv->number;
      98         260 :     return t;
      99             : }
     100             : 
     101             : } // detail
     102             : } // urls
     103             : } // boost
     104             :