Diff coverage report for

//

//

// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)

// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)

// Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com)

// Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com)

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/boostorg/url

// Official repository: https://github.com/boostorg/url

//

//

#include <boost/url/detail/config.hpp>

#include <boost/url/detail/config.hpp>

#include <boost/url/decode_view.hpp>

#include <boost/url/decode_view.hpp>

#include <boost/url/detail/decode.hpp>

#include <boost/url/detail/decode.hpp>

#include <boost/url/segments_encoded_view.hpp>

#include <boost/url/segments_encoded_view.hpp>

#include <boost/url/grammar/ci_string.hpp>

#include <boost/url/grammar/ci_string.hpp>

#include <boost/url/grammar/lut_chars.hpp>

#include <boost/url/grammar/lut_chars.hpp>

#include <boost/assert.hpp>

#include <boost/assert.hpp>

#include <boost/core/ignore_unused.hpp>

#include <boost/core/ignore_unused.hpp>

#include <cstring>

#include <cstring>

#include "normalize.hpp"

#include "normalize.hpp"

namespace boost {

namespace boost {

namespace urls {

namespace urls {

namespace detail {

namespace detail {

void

void

    core::string_view& s,

    core::string_view& s,

    char& c,

    char& c,

    std::size_t& n) noexcept

    std::size_t& n) noexcept

{

{

    {

    {

    }

    }

    else

    else

    {

    {

            &c,

            &c,

            &c + 1,

            &c + 1,

            s.substr(0, 3));

            s.substr(0, 3));

    }

    }

int

int

    core::string_view lhs,

    core::string_view lhs,

    core::string_view rhs) noexcept

    core::string_view rhs) noexcept

{

{

    {

    {

    }

    }

}

}

int

int

    core::string_view lhs,

    core::string_view lhs,

    core::string_view rhs) noexcept

    core::string_view rhs) noexcept

{

{

    static constexpr

    static constexpr

    grammar::lut_chars

    grammar::lut_chars

    query_compare_exception_lut = "&=+";

    query_compare_exception_lut = "&=+";

    {

    {

        // The decoded chars are the same, but

        // The decoded chars are the same, but

        // are these query exceptions that have

        // are these query exceptions that have

        // different meanings when decoded?

        // different meanings when decoded?

        {

        {

            // If so, we only continue if both

            // If so, we only continue if both

            // chars were decoded or encoded

            // chars were decoded or encoded

            // the same way.

            // the same way.

            // Otherwise, we return a value != 0

            // Otherwise, we return a value != 0

            // because these chars are not equal.

            // because these chars are not equal.

            // If rhs was the decoded one, it contains

            // If rhs was the decoded one, it contains

            // an ascii char higher than '%'

            // an ascii char higher than '%'

            else

            else

        }

        }

    }

    }

}

}

void

void

    core::string_view s,

    core::string_view s,

    fnv_1a& hasher) noexcept

    fnv_1a& hasher) noexcept

{

{

    {

    {

    }

    }

int

int

    core::string_view lhs,

    core::string_view lhs,

    core::string_view rhs) noexcept

    core::string_view rhs) noexcept

{

{

    {

    {

    }

    }

}

}

void

void

    core::string_view s,

    core::string_view s,

    fnv_1a& hasher) noexcept

    fnv_1a& hasher) noexcept

{

{

    {

    {

    }

    }

int

int

    core::string_view lhs,

    core::string_view lhs,

    core::string_view rhs) noexcept

    core::string_view rhs) noexcept

{

{

    {

    {

    }

    }

}

}

int

int

    core::string_view lhs,

    core::string_view lhs,

    core::string_view rhs) noexcept

    core::string_view rhs) noexcept

{

{

    {

    {

    }

    }

}

}

void

void

    core::string_view s,

    core::string_view s,

    fnv_1a& hasher) noexcept

    fnv_1a& hasher) noexcept

{

{

    {

    {

    }

    }

/* Check if a string ends with the specified suffix (decoded comparison)

/* Check if a string ends with the specified suffix (decoded comparison)

   This function determines if a string ends with the specified suffix

   This function determines if a string ends with the specified suffix

   when the string and suffix are compared after percent-decoding.

   when the string and suffix are compared after percent-decoding.

   @param str The string to check (percent-encoded)

   @param str The string to check (percent-encoded)

   @param suffix The suffix to check for (percent-decoded)

   @param suffix The suffix to check for (percent-decoded)

   @return The number of encoded chars consumed in the string

   @return The number of encoded chars consumed in the string

 */

 */

std::size_t

std::size_t

    core::string_view str,

    core::string_view str,

    core::string_view suffix) noexcept

    core::string_view suffix) noexcept

{

{

        core::string_view::iterator& it,

        core::string_view::iterator& it,

        core::string_view::iterator& end,

        core::string_view::iterator& end,

        char& c)

        char& c)

    {

    {

        {

        {

        }

        }

            &c,

            &c,

            &c + 1,

            &c + 1,

            core::string_view(std::prev(

            core::string_view(std::prev(

                end, 3), 3));

                end, 3), 3));

    };

    };

    {

    {

        // The suffix never contains an encoded slash (%2F), and a decoded

        // The suffix never contains an encoded slash (%2F), and a decoded

        // slash is not equivalent to an encoded slash

        // slash is not equivalent to an encoded slash

    }

    }

    {

    {

    }

    }

}

}

std::size_t

std::size_t

    char* dest0,

    char* dest0,

    char const* end,

    char const* end,

    core::string_view input) noexcept

    core::string_view input) noexcept

{

{

    // 1. The input buffer `s` is initialized with

    // 1. The input buffer `s` is initialized with

    // the now-appended path components and the

    // the now-appended path components and the

    // output buffer `dest0` is initialized to

    // output buffer `dest0` is initialized to

    // the empty string.

    // the empty string.

    // Step 2 is a loop through 5 production rules:

    // Step 2 is a loop through 5 production rules:

    // https://www.rfc-editor.org/rfc/rfc3986#section-5.2.4

    // https://www.rfc-editor.org/rfc/rfc3986#section-5.2.4

    //

    //

    // There are no transitions between all rules,

    // There are no transitions between all rules,

    // which enables some optimizations.

    // which enables some optimizations.

    //

    //

    // Initial:

    // Initial:

    // - Rule A: handle initial dots

    // - Rule A: handle initial dots

    // If the input buffer begins with a

    // If the input buffer begins with a

    // prefix of "../" or "./", then remove

    // prefix of "../" or "./", then remove

    // that prefix from the input buffer.

    // that prefix from the input buffer.

    // Rule A can only happen at the beginning.

    // Rule A can only happen at the beginning.

    // Errata 4547: Keep "../" in the beginning

    // Errata 4547: Keep "../" in the beginning

    // https://www.rfc-editor.org/errata/eid4547

    // https://www.rfc-editor.org/errata/eid4547

    //

    //

    // Then:

    // Then:

    // - Rule D: ignore a final ".." or "."

    // - Rule D: ignore a final ".." or "."

    // if the input buffer consists only  of "."

    // if the input buffer consists only  of "."

    // or "..", then remove that from the input

    // or "..", then remove that from the input

    // buffer.

    // buffer.

    // Rule D can only happen after Rule A because:

    // Rule D can only happen after Rule A because:

    // - B and C write "/" to the input

    // - B and C write "/" to the input

    // - E writes "/" to input or returns

    // - E writes "/" to input or returns

    //

    //

    // Then:

    // Then:

    // - Rule B: ignore ".": write "/" to the input

    // - Rule B: ignore ".": write "/" to the input

    // - Rule C: apply "..": remove seg and write "/"

    // - Rule C: apply "..": remove seg and write "/"

    // - Rule E: copy complete segment

    // - Rule E: copy complete segment

    auto append =

    auto append =

    {

    {

        // append `in` to `dest`

        // append `in` to `dest`

        ignore_unused(last);

        ignore_unused(last);

        core::string_view str, core::string_view dots, std::size_t& n)

        core::string_view str, core::string_view dots, std::size_t& n)

    {

    {

        // starts_with for encoded/decoded dots

        // starts_with for encoded/decoded dots

        // or decoded otherwise. return how many

        // or decoded otherwise. return how many

        // chars in str match the dots

        // chars in str match the dots

        {

        {

            {

            {

            }

            }

            // In the general case, we would need to

            // In the general case, we would need to

            // check if the next char is an encoded

            // check if the next char is an encoded

            // dot.

            // dot.

            // However, an encoded dot in `str`

            // However, an encoded dot in `str`

            // would have already been decoded in

            // would have already been decoded in

            // url_base::normalize_path().

            // url_base::normalize_path().

            // This needs to be undone if

            // This needs to be undone if

            // `remove_dot_segments` is used in a

            // `remove_dot_segments` is used in a

            // different context.

            // different context.

            // if (str.size() > 2 &&

            // if (str.size() > 2 &&

            //     c == '.'

            //     c == '.'

            //     &&

            //     &&

            //     str[0] == '%' &&

            //     str[0] == '%' &&

            //     str[1] == '2' &&

            //     str[1] == '2' &&

            //     (str[2] == 'e' ||

            //     (str[2] == 'e' ||

            //      str[2] == 'E'))

            //      str[2] == 'E'))

            // {

            // {

            //     str.remove_prefix(3);

            //     str.remove_prefix(3);

            //     n += 3;

            //     n += 3;

            //     continue;

            //     continue;

            // }

            // }

        }

        }

    };

    };

        core::string_view str, core::string_view dots)

        core::string_view str, core::string_view dots)

    {

    {

    // Rule A

    // Rule A

    std::size_t n;

    std::size_t n;

    {

    {

        {

        {

            // Errata 4547

            // Errata 4547

        }

        }

        {

        {

        }

        }

    }

    }

    // Rule D

    // Rule D

    {

    {

    }

    }

    {

    {

        // Errata 4547

        // Errata 4547

    }

    }

    // 2. While the input buffer is not empty,

    // 2. While the input buffer is not empty,

    // loop as follows:

    // loop as follows:

    {

    {

        // Rule B

        // Rule B

        {

        {

        }

        }

        {

        {

            // We can't remove "." from a core::string_view

            // We can't remove "." from a core::string_view

            // So what we do here is equivalent to

            // So what we do here is equivalent to

            // replacing s with '/' as required

            // replacing s with '/' as required

            // in Rule B and executing the next

            // in Rule B and executing the next

            // iteration, which would append this

            // iteration, which would append this

            // '/' to  the output, as required by

            // '/' to  the output, as required by

            // Rule E

            // Rule E

        }

        }

        // Rule C

        // Rule C

        {

        {

            {

            {

                // output has multiple segments

                // output has multiple segments

                // "erase" [p, end] if not "/.."

                // "erase" [p, end] if not "/.."

                {

                {

                }

                }

                else

                else

                {

                {

                }

                }

            }

            }

            {

            {

                // Only one segment in the output: remove it

                // Only one segment in the output: remove it

                {

                {

                    {

                    {

                    }

                    }

                }

                }

                else

                else

                {

                {

                }

                }

            }

            }

            else

            else

            {

            {

                // Output is empty

                // Output is empty

                {

                {

                }

                }

                else

                else

                {

                {

                    // AFREITAS: Although we have no formal proof

                    // AFREITAS: Although we have no formal proof

                    // for that, the output can't be relative

                    // for that, the output can't be relative

                    // and empty at this point because relative

                    // and empty at this point because relative

                    // paths will fall in the `dest0 != dest`

                    // paths will fall in the `dest0 != dest`

                    // case above of this rule C and then the

                    // case above of this rule C and then the

                    // general case of rule E for "..".

                    // general case of rule E for "..".

                }

                }

            }

            }