//===----------------------------------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include <algorithm>

#include <iterator>

#include <regex>

_LIBCPP_BEGIN_NAMESPACE_STD

static

const char*

make_error_type_string(regex_constants::error_type ecode)

{

    switch (ecode)

    {

    case regex_constants::error_collate:

        return "The expression contained an invalid collating element name.";

    case regex_constants::error_ctype:

        return "The expression contained an invalid character class name.";

    case regex_constants::error_escape:

        return "The expression contained an invalid escaped character, or a "

               "trailing escape.";

    case regex_constants::error_backref:

        return "The expression contained an invalid back reference.";

    case regex_constants::error_brack:

        return "The expression contained mismatched [ and ].";

    case regex_constants::error_paren:

        return "The expression contained mismatched ( and ).";

    case regex_constants::error_brace:

        return "The expression contained mismatched { and }.";

    case regex_constants::error_badbrace:

        return "The expression contained an invalid range in a {} expression.";

    case regex_constants::error_range:

        return "The expression contained an invalid character range, "

               "such as [b-a] in most encodings.";

    case regex_constants::error_space:

        return "There was insufficient memory to convert the expression into "

               "a finite state machine.";

    case regex_constants::error_badrepeat:

        return "One of *?+{ was not preceded by a valid regular expression.";

    case regex_constants::error_complexity:

        return "The complexity of an attempted match against a regular "

               "expression exceeded a pre-set level.";

    case regex_constants::error_stack:

        return "There was insufficient memory to determine whether the regular "

               "expression could match the specified character sequence.";

    case regex_constants::__re_err_grammar:

        return "An invalid regex grammar has been requested.";

    case regex_constants::__re_err_empty:

        return "An empty regex is not allowed in the POSIX grammar.";

    case regex_constants::__re_err_parse:

        return "The parser did not consume the entire regular expression.";

    default:

        break;

    }

    return "Unknown error type";

}

regex_error::regex_error(regex_constants::error_type ecode)

    : runtime_error(make_error_type_string(ecode)),

      __code_(ecode)

{}

regex_error::~regex_error() throw() {}

namespace {

struct collationnames

{

    const char* elem_;

    char char_;

};

#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)

// EBCDIC IBM-1047

// Sorted via the EBCDIC collating sequence

const collationnames collatenames[] =

{

    {"a", 0x81},

    {"alert", 0x2f},

    {"ampersand", 0x50},

    {"apostrophe", 0x7d},

    {"asterisk", 0x5c},

    {"b", 0x82},

    {"backslash", 0xe0},

    {"backspace", 0x16},

    {"c", 0x83},

    {"carriage-return", 0xd},

    {"circumflex", 0x5f},

    {"circumflex-accent", 0x5f},

    {"colon", 0x7a},

    {"comma", 0x6b},

    {"commercial-at", 0x7c},

    {"d", 0x84},

    {"dollar-sign", 0x5b},

    {"e", 0x85},

    {"eight", 0xf8},

    {"equals-sign", 0x7e},

    {"exclamation-mark", 0x5a},

    {"f", 0x86},

    {"five", 0xf5},

    {"form-feed", 0xc},

    {"four", 0xf4},

    {"full-stop", 0x4b},

    {"g", 0x87},

    {"grave-accent", 0x79},

    {"greater-than-sign", 0x6e},

    {"h", 0x88},

    {"hyphen", 0x60},

    {"hyphen-minus", 0x60},

    {"i", 0x89},

    {"j", 0x91},

    {"k", 0x92},

    {"l", 0x93},

    {"left-brace", 0xc0},

    {"left-curly-bracket", 0xc0},

    {"left-parenthesis", 0x4d},

    {"left-square-bracket", 0xad},

    {"less-than-sign", 0x4c},

    {"low-line", 0x6d},

    {"m", 0x94},

    {"n", 0x95},

    {"newline", 0x15},

    {"nine", 0xf9},

    {"number-sign", 0x7b},

    {"o", 0x96},

    {"one", 0xf1},

    {"p", 0x97},

    {"percent-sign", 0x6c},

    {"period", 0x4b},

    {"plus-sign", 0x4e},

    {"q", 0x98},

    {"question-mark", 0x6f},

    {"quotation-mark", 0x7f},

    {"r", 0x99},

    {"reverse-solidus", 0xe0},

    {"right-brace", 0xd0},

    {"right-curly-bracket", 0xd0},

    {"right-parenthesis", 0x5d},

    {"right-square-bracket", 0xbd},

    {"s", 0xa2},

    {"semicolon", 0x5e},

    {"seven", 0xf7},

    {"six", 0xf6},

    {"slash", 0x61},

    {"solidus", 0x61},

    {"space", 0x40},

    {"t", 0xa3},

    {"tab", 0x5},

    {"three", 0xf3},

    {"tilde", 0xa1},

    {"two", 0xf2},

    {"u", 0xa4},

    {"underscore", 0x6d},

    {"v", 0xa5},

    {"vertical-line", 0x4f},

    {"vertical-tab", 0xb},

    {"w", 0xa6},

    {"x", 0xa7},

    {"y", 0xa8},

    {"z", 0xa9},

    {"zero", 0xf0},

    {"A", 0xc1},

    {"B", 0xc2},

    {"C", 0xc3},

    {"D", 0xc4},

    {"E", 0xc5},

    {"F", 0xc6},

    {"G", 0xc7},

    {"H", 0xc8},

    {"I", 0xc9},

    {"J", 0xd1},

    {"K", 0xd2},

    {"L", 0xd3},

    {"M", 0xd4},

    {"N", 0xd5},

    {"NUL", 0},

    {"O", 0xd6},

    {"P", 0xd7},

    {"Q", 0xd8},

    {"R", 0xd9},

    {"S", 0xe2},

    {"T", 0xe3},

    {"U", 0xe4},

    {"V", 0xe5},

    {"W", 0xe6},

    {"X", 0xe7},

    {"Y", 0xe8},

    {"Z", 0xe9}

};

#else

// ASCII

const collationnames collatenames[] =

{

    {"A", 0x41},

    {"B", 0x42},

    {"C", 0x43},

    {"D", 0x44},

    {"E", 0x45},

    {"F", 0x46},

    {"G", 0x47},

    {"H", 0x48},

    {"I", 0x49},

    {"J", 0x4a},

    {"K", 0x4b},

    {"L", 0x4c},

    {"M", 0x4d},

    {"N", 0x4e},

    {"NUL", 0x00},

    {"O", 0x4f},

    {"P", 0x50},

    {"Q", 0x51},

    {"R", 0x52},

    {"S", 0x53},

    {"T", 0x54},

    {"U", 0x55},

    {"V", 0x56},

    {"W", 0x57},

    {"X", 0x58},

    {"Y", 0x59},

    {"Z", 0x5a},

    {"a", 0x61},

    {"alert", 0x07},

    {"ampersand", 0x26},

    {"apostrophe", 0x27},

    {"asterisk", 0x2a},

    {"b", 0x62},

    {"backslash", 0x5c},

    {"backspace", 0x08},

    {"c", 0x63},

    {"carriage-return", 0x0d},

    {"circumflex", 0x5e},

    {"circumflex-accent", 0x5e},

    {"colon", 0x3a},

    {"comma", 0x2c},

    {"commercial-at", 0x40},

    {"d", 0x64},

    {"dollar-sign", 0x24},

    {"e", 0x65},

    {"eight", 0x38},

    {"equals-sign", 0x3d},

    {"exclamation-mark", 0x21},

    {"f", 0x66},

    {"five", 0x35},

    {"form-feed", 0x0c},

    {"four", 0x34},

    {"full-stop", 0x2e},

    {"g", 0x67},

    {"grave-accent", 0x60},

    {"greater-than-sign", 0x3e},

    {"h", 0x68},

    {"hyphen", 0x2d},

    {"hyphen-minus", 0x2d},

    {"i", 0x69},

    {"j", 0x6a},

    {"k", 0x6b},

    {"l", 0x6c},

    {"left-brace", 0x7b},

    {"left-curly-bracket", 0x7b},

    {"left-parenthesis", 0x28},

    {"left-square-bracket", 0x5b},

    {"less-than-sign", 0x3c},

    {"low-line", 0x5f},

    {"m", 0x6d},

    {"n", 0x6e},

    {"newline", 0x0a},

    {"nine", 0x39},

    {"number-sign", 0x23},

    {"o", 0x6f},

    {"one", 0x31},

    {"p", 0x70},

    {"percent-sign", 0x25},

    {"period", 0x2e},

    {"plus-sign", 0x2b},

    {"q", 0x71},

    {"question-mark", 0x3f},

    {"quotation-mark", 0x22},

    {"r", 0x72},

    {"reverse-solidus", 0x5c},

    {"right-brace", 0x7d},

    {"right-curly-bracket", 0x7d},

    {"right-parenthesis", 0x29},

    {"right-square-bracket", 0x5d},

    {"s", 0x73},

    {"semicolon", 0x3b},

    {"seven", 0x37},

    {"six", 0x36},

    {"slash", 0x2f},

    {"solidus", 0x2f},

    {"space", 0x20},

    {"t", 0x74},

    {"tab", 0x09},

    {"three", 0x33},

    {"tilde", 0x7e},

    {"two", 0x32},

    {"u", 0x75},

    {"underscore", 0x5f},

    {"v", 0x76},

    {"vertical-line", 0x7c},

    {"vertical-tab", 0x0b},

    {"w", 0x77},

    {"x", 0x78},

    {"y", 0x79},

    {"z", 0x7a},

    {"zero", 0x30}

};

#endif

struct classnames

{

    const char* elem_;

    regex_traits<char>::char_class_type mask_;

};

const classnames ClassNames[] =

{

    {"alnum",  ctype_base::alnum},

    {"alpha",  ctype_base::alpha},

    {"blank",  ctype_base::blank},

    {"cntrl",  ctype_base::cntrl},

    {"d",      ctype_base::digit},

    {"digit",  ctype_base::digit},

    {"graph",  ctype_base::graph},

    {"lower",  ctype_base::lower},

    {"print",  ctype_base::print},

    {"punct",  ctype_base::punct},

    {"s",      ctype_base::space},

    {"space",  ctype_base::space},

    {"upper",  ctype_base::upper},

    {"w",      regex_traits<char>::__regex_word},

    {"xdigit", ctype_base::xdigit}

};

struct use_strcmp

{

    bool operator()(const collationnames& x, const char* y)

        {return strcmp(x.elem_, y) < 0;}

    bool operator()(const classnames& x, const char* y)

        {return strcmp(x.elem_, y) < 0;}

};

}

string

__get_collation_name(const char* s)

{

    const collationnames* i =

            _VSTD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());

    string r;

    if (i != end(collatenames) && strcmp(s, i->elem_) == 0)

        r = char(i->char_);

    return r;

}

regex_traits<char>::char_class_type

__get_classname(const char* s, bool __icase)

{

    const classnames* i =

            _VSTD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());

    regex_traits<char>::char_class_type r = 0;

    if (i != end(ClassNames) && strcmp(s, i->elem_) == 0)

    {

        r = i->mask_;

        if (r == regex_traits<char>::__regex_word)

            r |= ctype_base::alnum | ctype_base::upper | ctype_base::lower;

        else if (__icase)

        {

            if (r & (ctype_base::lower | ctype_base::upper))

                r |= ctype_base::alpha;

        }

    }

    return r;

}

template <>

void

__match_any_but_newline<char>::__exec(__state& __s) const

{

    if (__s.__current_ != __s.__last_)

    {

        switch (*__s.__current_)

        {

        case '\r':

        case '\n':

            __s.__do_ = __state::__reject;

            __s.__node_ = nullptr;

            break;

        default:

            __s.__do_ = __state::__accept_and_consume;

            ++__s.__current_;

            __s.__node_ = this->first();

            break;

        }

    }

    else

    {

        __s.__do_ = __state::__reject;

        __s.__node_ = nullptr;

    }

}

template <>

void

__match_any_but_newline<wchar_t>::__exec(__state& __s) const

{

    if (__s.__current_ != __s.__last_)

    {

        switch (*__s.__current_)

        {

        case '\r':

        case '\n':

        case 0x2028:

        case 0x2029:

            __s.__do_ = __state::__reject;

            __s.__node_ = nullptr;

            break;

        default:

            __s.__do_ = __state::__accept_and_consume;

            ++__s.__current_;

            __s.__node_ = this->first();

            break;

        }

    }

    else

    {

        __s.__do_ = __state::__reject;

        __s.__node_ = nullptr;

    }

}

_LIBCPP_END_NAMESPACE_STD