TLA  Line data    Source code

       1                 : //
       2                 : // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
       3                 : // Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
       4                 : //
       5                 : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       6                 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       7                 : //
       8                 : // Official repository: https://github.com/boostorg/url
       9                 : //
      10                 : 
      11                 : #ifndef BOOST_URL_RFC_DETAIL_IMPL_IP_LITERAL_RULE_HPP
      12                 : #define BOOST_URL_RFC_DETAIL_IMPL_IP_LITERAL_RULE_HPP
      13                 : 
      14                 : #include <boost/url/detail/config.hpp>
      15                 : #include <boost/url/rfc/ipv6_address_rule.hpp>
      16                 : #include <boost/url/rfc/detail/ipv6_addrz_rule.hpp>
      17                 : #include <boost/url/rfc/detail/ipvfuture_rule.hpp>
      18                 : #include <boost/url/grammar/delim_rule.hpp>
      19                 : #include <boost/url/grammar/error.hpp>
      20                 : #include <boost/url/grammar/parse.hpp>
      21                 : #include <boost/url/grammar/tuple_rule.hpp>
      22                 : 
      23                 : namespace boost {
      24                 : namespace urls {
      25                 : namespace detail {
      26                 : 
      27                 : BOOST_URL_CXX20_CONSTEXPR_OR_INLINE
      28                 : auto
      29 HIT          64 : ip_literal_rule_t::
      30                 : parse(
      31                 :     char const*& it,
      32                 :     char const* const end
      33                 :         ) const noexcept ->
      34                 :     system::result<value_type>
      35                 : {
      36              64 :     value_type t;
      37                 : 
      38                 :     // '['
      39                 :     {
      40              64 :         auto rv = grammar::parse(
      41              64 :             it, end, grammar::delim_rule('['));
      42              64 :         if(! rv)
      43 MIS           0 :             return rv.error();
      44                 :     }
      45 HIT          64 :     if(it == end)
      46                 :     {
      47                 :         // end
      48               1 :         BOOST_URL_CONSTEXPR_RETURN_EC(
      49                 :             grammar::error::invalid);
      50                 :     }
      51              63 :     if(*it != 'v')
      52                 :     {
      53                 :         // IPv6address
      54              58 :         auto it0 = it;
      55              58 :         auto rv = grammar::parse(
      56                 :             it, end,
      57              58 :             grammar::tuple_rule(
      58                 :                 ipv6_address_rule,
      59              58 :                 grammar::squelch(
      60              58 :                     grammar::delim_rule(']'))));
      61              58 :         if(! rv)
      62                 :         {
      63                 :             // IPv6addrz: https://datatracker.ietf.org/doc/html/rfc6874
      64              29 :             it = it0;
      65              29 :             auto rv2 = grammar::parse(
      66                 :                 it, end,
      67              29 :                 grammar::tuple_rule(
      68                 :                     ipv6_addrz_rule,
      69              29 :                     grammar::squelch(
      70              29 :                         grammar::delim_rule(']'))));
      71              29 :             if(! rv2)
      72              24 :                 return rv2.error();
      73               5 :             t.ipv6 = rv2->ipv6;
      74               5 :             t.is_ipv6 = true;
      75               5 :             return t;
      76                 :         }
      77              29 :         t.ipv6 = *rv;
      78              29 :         t.is_ipv6 = true;
      79              29 :         return t;
      80                 :     }
      81                 :     {
      82                 :         // IPvFuture
      83               5 :         auto rv = grammar::parse(
      84                 :             it, end,
      85               5 :             grammar::tuple_rule(
      86                 :                 ipvfuture_rule,
      87               5 :                 grammar::squelch(
      88               5 :                     grammar::delim_rule(']'))));
      89               5 :         if(! rv)
      90 MIS           0 :             return rv.error();
      91 HIT           5 :         t.is_ipv6 = false;
      92               5 :         t.ipvfuture = rv->str;
      93               5 :         return t;
      94                 :     }
      95                 : }
      96                 : 
      97                 : } // detail
      98                 : } // urls
      99                 : } // boost
     100                 : 
     101                 : 
     102                 : #endif