// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

**********************************************************************

*   Copyright (c) 2001-2011, International Business Machines

*   Corporation and others.  All Rights Reserved.

**********************************************************************

*   Date        Name        Description

*   11/19/2001  aliu        Creation.

**********************************************************************

*/

#include "unicode/unimatch.h"

#include "unicode/utf16.h"

#include "patternprops.h"

#include "util.h"

// Define UChar constants using hex for EBCDIC compatibility

static const UChar BACKSLASH  = 0x005C; /*\*/

static const UChar UPPER_U    = 0x0055; /*U*/

static const UChar LOWER_U    = 0x0075; /*u*/

static const UChar APOSTROPHE = 0x0027; // '\''

static const UChar SPACE      = 0x0020; // ' '

// "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

static const UChar DIGITS[] = {

    48,49,50,51,52,53,54,55,56,57,

    65,66,67,68,69,70,71,72,73,74,

    75,76,77,78,79,80,81,82,83,84,

    85,86,87,88,89,90

};

U_NAMESPACE_BEGIN

UnicodeString& ICU_Utility::appendNumber(UnicodeString& result, int32_t n,

                                     int32_t radix, int32_t minDigits) {

    if (radix < 2 || radix > 36) {

        // Bogus radix

        return result.append((UChar)63/*?*/);

    }

    // Handle negatives

    if (n < 0) {

        n = -n;

        result.append((UChar)45/*-*/);

    }

    // First determine the number of digits

    int32_t nn = n;

    int32_t r = 1;

    while (nn >= radix) {

        nn /= radix;

        r *= radix;

        --minDigits;

    }

    // Now generate the digits

    while (--minDigits > 0) {

        result.append(DIGITS[0]);

    }

    while (r > 0) {

        int32_t digit = n / r;

        result.append(DIGITS[digit]);

        n -= digit * r;

        r /= radix;

    }

    return result;

}

/**

 * Return true if the character is NOT printable ASCII.

 */

UBool ICU_Utility::isUnprintable(UChar32 c) {

    return !(c >= 0x20 && c <= 0x7E);

}

/**

 * Escape unprintable characters using \uxxxx notation for U+0000 to

 * U+FFFF and \Uxxxxxxxx for U+10000 and above.  If the character is

 * printable ASCII, then do nothing and return FALSE.  Otherwise,

 * append the escaped notation and return TRUE.

 */

UBool ICU_Utility::escapeUnprintable(UnicodeString& result, UChar32 c) {

    if (isUnprintable(c)) {

        result.append(BACKSLASH);

        if (c & ~0xFFFF) {

            result.append(UPPER_U);

            result.append(DIGITS[0xF&(c>>28)]);

            result.append(DIGITS[0xF&(c>>24)]);

            result.append(DIGITS[0xF&(c>>20)]);

            result.append(DIGITS[0xF&(c>>16)]);

        } else {

            result.append(LOWER_U);

        }

        result.append(DIGITS[0xF&(c>>12)]);

        result.append(DIGITS[0xF&(c>>8)]);

        result.append(DIGITS[0xF&(c>>4)]);

        result.append(DIGITS[0xF&c]);

        return TRUE;

    }

    return FALSE;

}

/**

 * Returns the index of a character, ignoring quoted text.

 * For example, in the string "abc'hide'h", the 'h' in "hide" will not be

 * found by a search for 'h'.

 */

// FOR FUTURE USE.  DISABLE FOR NOW for coverage reasons.

/*

int32_t ICU_Utility::quotedIndexOf(const UnicodeString& text,

                               int32_t start, int32_t limit,

                               UChar charToFind) {

    for (int32_t i=start; i<limit; ++i) {

        UChar c = text.charAt(i);

        if (c == BACKSLASH) {

            ++i;

        } else if (c == APOSTROPHE) {

            while (++i < limit

                   && text.charAt(i) != APOSTROPHE) {}

        } else if (c == charToFind) {

            return i;

        }

    }

    return -1;

}

*/

/**

 * Skip over a sequence of zero or more white space characters at pos.

 * @param advance if true, advance pos to the first non-white-space

 * character at or after pos, or str.length(), if there is none.

 * Otherwise leave pos unchanged.

 * @return the index of the first non-white-space character at or

 * after pos, or str.length(), if there is none.

 */

int32_t ICU_Utility::skipWhitespace(const UnicodeString& str, int32_t& pos,

                                    UBool advance) {

    int32_t p = pos;

    const UChar* s = str.getBuffer();

    p = (int32_t)(PatternProps::skipWhiteSpace(s + p, str.length() - p) - s);

    if (advance) {

        pos = p;

    }

    return p;

}

/**

 * Skip over Pattern_White_Space in a Replaceable.

 * Skipping may be done in the forward or

 * reverse direction.  In either case, the leftmost index will be

 * inclusive, and the rightmost index will be exclusive.  That is,

 * given a range defined as [start, limit), the call

 * skipWhitespace(text, start, limit) will advance start past leading

 * whitespace, whereas the call skipWhitespace(text, limit, start),

 * will back up limit past trailing whitespace.

 * @param text the text to be analyzed

 * @param pos either the start or limit of a range of 'text', to skip

 * leading or trailing whitespace, respectively

 * @param stop either the limit or start of a range of 'text', to skip

 * leading or trailing whitespace, respectively

 * @return the new start or limit, depending on what was passed in to

 * 'pos'

 */

//?FOR FUTURE USE.  DISABLE FOR NOW for coverage reasons.

//?int32_t ICU_Utility::skipWhitespace(const Replaceable& text,

//?                                    int32_t pos, int32_t stop) {

//?    UChar32 c;

//?    UBool isForward = (stop >= pos);

//?

//?    if (!isForward) {

//?        --pos; // pos is a limit, so back up by one

//?    }

//?    

//?    while (pos != stop &&

//?           PatternProps::isWhiteSpace(c = text.char32At(pos))) {

//?        if (isForward) {

//?            pos += U16_LENGTH(c);

//?        } else {

//?            pos -= U16_LENGTH(c);

//?        }

//?    }

//?

//?    if (!isForward) {

//?        ++pos; // make pos back into a limit

//?    }

//?

//?    return pos;

//?}

/**

 * Parse a single non-whitespace character 'ch', optionally

 * preceded by whitespace.

 * @param id the string to be parsed

 * @param pos INPUT-OUTPUT parameter.  On input, pos[0] is the

 * offset of the first character to be parsed.  On output, pos[0]

 * is the index after the last parsed character.  If the parse

 * fails, pos[0] will be unchanged.

 * @param ch the non-whitespace character to be parsed.

 * @return true if 'ch' is seen preceded by zero or more

 * whitespace characters.

 */

UBool ICU_Utility::parseChar(const UnicodeString& id, int32_t& pos, UChar ch) {

    int32_t start = pos;

    skipWhitespace(id, pos, TRUE);

    if (pos == id.length() ||

        id.charAt(pos) != ch) {

        pos = start;

        return FALSE;

    }

    ++pos;

    return TRUE;

}

/**

 * Parse a pattern string within the given Replaceable and a parsing

 * pattern.  Characters are matched literally and case-sensitively

 * except for the following special characters:

 *

 * ~  zero or more Pattern_White_Space chars

 *

 * If end of pattern is reached with all matches along the way,

 * pos is advanced to the first unparsed index and returned.

 * Otherwise -1 is returned.

 * @param pat pattern that controls parsing

 * @param text text to be parsed, starting at index

 * @param index offset to first character to parse

 * @param limit offset after last character to parse

 * @return index after last parsed character, or -1 on parse failure.

 */

int32_t ICU_Utility::parsePattern(const UnicodeString& pat,

                                  const Replaceable& text,

                                  int32_t index,

                                  int32_t limit) {

    int32_t ipat = 0;

    // empty pattern matches immediately

    if (ipat == pat.length()) {

        return index;

    }

    UChar32 cpat = pat.char32At(ipat);

    while (index < limit) {

        UChar32 c = text.char32At(index);

        // parse \s*

        if (cpat == 126 /*~*/) {

            if (PatternProps::isWhiteSpace(c)) {

                index += U16_LENGTH(c);

                continue;

            } else {

                if (++ipat == pat.length()) {

                    return index; // success; c unparsed

                }

                // fall thru; process c again with next cpat

            }

        }

        // parse literal

        else if (c == cpat) {

            index += U16_LENGTH(c);

            ipat += U16_LENGTH(cpat);

            if (ipat == pat.length()) {

                return index; // success; c parsed

            }

            // fall thru; get next cpat

        }

        // match failure of literal

        else {

            return -1;

        }

        cpat = pat.char32At(ipat);

    }

    return -1; // text ended before end of pat

}

int32_t ICU_Utility::parseAsciiInteger(const UnicodeString& str, int32_t& pos) {

    int32_t result = 0;

    UChar c;

    while (pos < str.length() && (c = str.charAt(pos)) >= u'0' && c <= u'9') {

        result = result * 10 + (c - u'0');

        pos++;

    }

    return result;

}

/**

 * Append a character to a rule that is being built up.  To flush

 * the quoteBuf to rule, make one final call with isLiteral == TRUE.

 * If there is no final character, pass in (UChar32)-1 as c.

 * @param rule the string to append the character to

 * @param c the character to append, or (UChar32)-1 if none.

 * @param isLiteral if true, then the given character should not be

 * quoted or escaped.  Usually this means it is a syntactic element

 * such as > or $

 * @param escapeUnprintable if true, then unprintable characters

 * should be escaped using \uxxxx or \Uxxxxxxxx.  These escapes will

 * appear outside of quotes.

 * @param quoteBuf a buffer which is used to build up quoted

 * substrings.  The caller should initially supply an empty buffer,

 * and thereafter should not modify the buffer.  The buffer should be

 * cleared out by, at the end, calling this method with a literal

 * character.

 */

void ICU_Utility::appendToRule(UnicodeString& rule,

                               UChar32 c,

                               UBool isLiteral,

                               UBool escapeUnprintable,

                               UnicodeString& quoteBuf) {

    // If we are escaping unprintables, then escape them outside

    // quotes.  \u and \U are not recognized within quotes.  The same

    // logic applies to literals, but literals are never escaped.

    if (isLiteral ||

        (escapeUnprintable && ICU_Utility::isUnprintable(c))) {

        if (quoteBuf.length() > 0) {

            // We prefer backslash APOSTROPHE to double APOSTROPHE

            // (more readable, less similar to ") so if there are

            // double APOSTROPHEs at the ends, we pull them outside

            // of the quote.

            // If the first thing in the quoteBuf is APOSTROPHE

            // (doubled) then pull it out.

            while (quoteBuf.length() >= 2 &&

                   quoteBuf.charAt(0) == APOSTROPHE &&

                   quoteBuf.charAt(1) == APOSTROPHE) {

                rule.append(BACKSLASH).append(APOSTROPHE);

                quoteBuf.remove(0, 2);

            }

            // If the last thing in the quoteBuf is APOSTROPHE

            // (doubled) then remove and count it and add it after.

            int32_t trailingCount = 0;

            while (quoteBuf.length() >= 2 &&

                   quoteBuf.charAt(quoteBuf.length()-2) == APOSTROPHE &&

                   quoteBuf.charAt(quoteBuf.length()-1) == APOSTROPHE) {

                quoteBuf.truncate(quoteBuf.length()-2);

                ++trailingCount;

            }

            if (quoteBuf.length() > 0) {

                rule.append(APOSTROPHE);

                rule.append(quoteBuf);

                rule.append(APOSTROPHE);

                quoteBuf.truncate(0);

            }

            while (trailingCount-- > 0) {

                rule.append(BACKSLASH).append(APOSTROPHE);

            }

        }

        if (c != (UChar32)-1) {

            /* Since spaces are ignored during parsing, they are

             * emitted only for readability.  We emit one here

             * only if there isn't already one at the end of the

             * rule.

             */

            if (c == SPACE) {

                int32_t len = rule.length();

                if (len > 0 && rule.charAt(len-1) != c) {

                    rule.append(c);

                }

            } else if (!escapeUnprintable || !ICU_Utility::escapeUnprintable(rule, c)) {

                rule.append(c);

            }

        }

    }

    // Escape ' and '\' and don't begin a quote just for them

    else if (quoteBuf.length() == 0 &&

             (c == APOSTROPHE || c == BACKSLASH)) {

        rule.append(BACKSLASH);

        rule.append(c);

    }

    // Specials (printable ascii that isn't [0-9a-zA-Z]) and

    // whitespace need quoting.  Also append stuff to quotes if we are

    // building up a quoted substring already.

    else if (quoteBuf.length() > 0 ||

             (c >= 0x0021 && c <= 0x007E &&

              !((c >= 0x0030/*'0'*/ && c <= 0x0039/*'9'*/) ||

                (c >= 0x0041/*'A'*/ && c <= 0x005A/*'Z'*/) ||

                (c >= 0x0061/*'a'*/ && c <= 0x007A/*'z'*/))) ||

             PatternProps::isWhiteSpace(c)) {

        quoteBuf.append(c);

        // Double ' within a quote

        if (c == APOSTROPHE) {

            quoteBuf.append(c);

        }

    }

    // Otherwise just append

    else {

        rule.append(c);

    }

}

void ICU_Utility::appendToRule(UnicodeString& rule,

                               const UnicodeString& text,

                               UBool isLiteral,

                               UBool escapeUnprintable,

                               UnicodeString& quoteBuf) {

    for (int32_t i=0; i<text.length(); ++i) {

        appendToRule(rule, text[i], isLiteral, escapeUnprintable, quoteBuf);

    }

}

/**

 * Given a matcher reference, which may be null, append its

 * pattern as a literal to the given rule.

 */

void ICU_Utility::appendToRule(UnicodeString& rule,

                               const UnicodeMatcher* matcher,

                               UBool escapeUnprintable,

                               UnicodeString& quoteBuf) {

    if (matcher != NULL) {

        UnicodeString pat;

        appendToRule(rule, matcher->toPattern(pat, escapeUnprintable),

                     TRUE, escapeUnprintable, quoteBuf);

    }

}

U_NAMESPACE_END