/root/doris/be/src/gutil/strings/escaping.cc

Source (jump to first uncovered line)
// Copyright 2008 Google Inc. All Rights Reserved.
// Authors: Numerous. See the .h for contact people.

#include "gutil/strings/escaping.h"

#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <glog/logging.h>
#include <limits>
#include <ostream>

using std::numeric_limits;
#include <vector>

using std::vector;

#include "gutil/charmap.h"
#include "gutil/gscoped_ptr.h"
#include "gutil/integral_types.h"
#include "gutil/port.h"
#include "gutil/stl_util.h"
#include "gutil/utf/utf.h" // for runetochar
#include "gutil/strings/strcat.h"

namespace strings {

// These are used for the leave_nulls_escaped argument to CUnescapeInternal().
static bool kUnescapeNulls = false;
static bool kLeaveNullsEscaped = true;

// ----------------------------------------------------------------------
// EscapeStrForCSV()
//    Escapes the quotes in 'src' by doubling them. This is necessary
//    for generating CSV files (see SplitCSVLine).
//    Returns the number of characters written into dest (not counting
//    the \0) or -1 if there was insufficient space. Dest could end up
//    twice as long as src.
//
//    Example: [some "string" to test] --> [some ""string"" to test]
// ----------------------------------------------------------------------
int EscapeStrForCSV(const char* src, char* dest, int dest_len) {
    int used = 0;

    while (true) {
        if (*src == '\0' && used < dest_len) {
            dest[used] = '\0';
            return used;
        }

        if (used + 1 >= dest_len) // +1 because we might require two characters
            return -1;

        if (*src == '"') dest[used++] = '"';

        dest[used++] = *src++;
    }
}

// ----------------------------------------------------------------------
// UnescapeCEscapeSequences()
//    This does all the unescaping that C does: \ooo, \r, \n, etc
//    Returns length of resulting string.
//    The implementation of \x parses any positive number of hex digits,
//    but it is an error if the value requires more than 8 bits, and the
//    result is truncated to 8 bits. The same is true for octals.
//
//    The second call stores its errors in a supplied string vector.
//    If the string vector pointer is NULL, it reports the errors with LOG().
//
//    *** DEPRECATED: Use CUnescape() in new code ***
//
//    NOTE: any changes to this function must also be reflected in the newer
//    CUnescape().
// ----------------------------------------------------------------------

#define IS_OCTAL_DIGIT(c) (((c) >= '0') && ((c) <= '7'))

int UnescapeCEscapeSequences(const char* source, char* dest) {
    return UnescapeCEscapeSequences(source, dest, nullptr);
}

int UnescapeCEscapeSequences(const char* source, char* dest, vector<string>* errors) {
    char* d = dest;
    const char* p = source;

    // Small optimization for case where source = dest and there's no escaping
    while (p == d && *p != '\0' && *p != '\\') p++, d++;

    while (*p != '\0') {
        if (*p != '\\') {
            *d++ = *p++;
        } else {
            switch (*++p) { // skip past the '\\'
            case '\0':
                LOG_STRING(ERROR, errors) << "String cannot end with \\";
                *d = '\0';
                return d - dest; // we're done with p
            case 'a':
                *d++ = '\a';
                break;
            case 'b':
                *d++ = '\b';
                break;
            case 'f':
                *d++ = '\f';
                break;
            case 'n':
                *d++ = '\n';
                break;
            case 'r':
                *d++ = '\r';
                break;
            case 't':
                *d++ = '\t';
                break;
            case 'v':
                *d++ = '\v';
                break;
            case '\\':
                *d++ = '\\';
                break;
            case '?':
                *d++ = '\?';
                break; // \?  Who knew?
            case '\'':
                *d++ = '\'';
                break;
            case '"':
                *d++ = '\"';
                break;
            case '0':
            case '1':
            case '2':
            case '3': // octal digit: 1 to 3 digits
            case '4':
            case '5':
            case '6':
            case '7': {
                const char* octal_start = p;
                unsigned int ch = *p - '0';
                if (IS_OCTAL_DIGIT(p[1])) ch = ch * 8 + *++p - '0';
                if (IS_OCTAL_DIGIT(p[1]))     // safe (and easy) to do this twice
                    ch = ch * 8 + *++p - '0'; // now points at last digit
                if (ch > 0xFF)
                    LOG_STRING(ERROR, errors) << "Value of "
                                              << "\\" << string(octal_start, p + 1 - octal_start)
                                              << " exceeds 8 bits";
                *d++ = ch;
                break;
            }
            case 'x':
            case 'X': {
                if (!ascii_isxdigit(p[1])) {
                    if (p[1] == '\0') {
                        LOG_STRING(ERROR, errors) << "String cannot end with \\x";
                    } else {
                        LOG_STRING(ERROR, errors)
                                << "\\x cannot be followed by a non-hex digit: \\" << *p << p[1];
                    }
                    break;
                }
                unsigned int ch = 0;
                const char* hex_start = p;
                while (ascii_isxdigit(p[1])) // arbitrarily many hex digits
                    ch = (ch << 4) + hex_digit_to_int(*++p);
                if (ch > 0xFF)
                    LOG_STRING(ERROR, errors)
                            << "Value of "
                            << "\\" << string(hex_start, p + 1 - hex_start) << " exceeds 8 bits";
                *d++ = ch;
                break;
            }
            case 'u': {
                // \uhhhh => convert 4 hex digits to UTF-8
                char32 rune = 0;
                const char* hex_start = p;
                for (int i = 0; i < 4; ++i) {
                    if (ascii_isxdigit(p[1])) {                      // Look one char ahead.
                        rune = (rune << 4) + hex_digit_to_int(*++p); // Advance p.
                    } else {
                        LOG_STRING(ERROR, errors) << "\\u must be followed by 4 hex digits: \\"
                                                  << string(hex_start, p + 1 - hex_start);
                        break;
                    }
                }
                d += runetochar(d, &rune);
                break;
            }
            case 'U': {
                // \Uhhhhhhhh => convert 8 hex digits to UTF-8
                char32 rune = 0;
                const char* hex_start = p;
                for (int i = 0; i < 8; ++i) {
                    if (ascii_isxdigit(p[1])) { // Look one char ahead.
                        // Don't change rune until we're sure this
                        // is within the Unicode limit, but do advance p.
                        char32 newrune = (rune << 4) + hex_digit_to_int(*++p);
                        if (newrune > 0x10FFFF) {
                            LOG_STRING(ERROR, errors)
                                    << "Value of \\" << string(hex_start, p + 1 - hex_start)
                                    << " exceeds Unicode limit (0x10FFFF)";
                            break;
                        } else {
                            rune = newrune;
                        }
                    } else {
                        LOG_STRING(ERROR, errors) << "\\U must be followed by 8 hex digits: \\"
                                                  << string(hex_start, p + 1 - hex_start);
                        break;
                    }
                }
                d += runetochar(d, &rune);
                break;
            }
            default:
                LOG_STRING(ERROR, errors) << "Unknown escape sequence: \\" << *p;
            }
            p++; // read past letter we escaped
        }
    }
    *d = '\0';
    return d - dest;
}

// ----------------------------------------------------------------------
// UnescapeCEscapeString()
//    This does the same thing as UnescapeCEscapeSequences, but creates
//    a new string. The caller does not need to worry about allocating
//    a dest buffer. This should be used for non performance critical
//    tasks such as printing debug messages. It is safe for src and dest
//    to be the same.
//
//    The second call stores its errors in a supplied string vector.
//    If the string vector pointer is NULL, it reports the errors with LOG().
//
//    In the first and second calls, the length of dest is returned. In the
//    the third call, the new string is returned.
//
//    *** DEPRECATED: Use CUnescape() in new code ***
//
// ----------------------------------------------------------------------
int UnescapeCEscapeString(const string& src, string* dest) {
    return UnescapeCEscapeString(src, dest, nullptr);
}

int UnescapeCEscapeString(const string& src, string* dest, vector<string>* errors) {
    CHECK(dest);
    dest->resize(src.size() + 1);
    int len = UnescapeCEscapeSequences(src.c_str(), const_cast<char*>(dest->data()), errors);
    dest->resize(len);
    return len;
}

string UnescapeCEscapeString(const string& src) {
    gscoped_array<char> unescaped(new char[src.size() + 1]);
    int len = UnescapeCEscapeSequences(src.c_str(), unescaped.get(), nullptr);
    return string(unescaped.get(), len);
}

// ----------------------------------------------------------------------
// CUnescapeInternal()
//    Implements both CUnescape() and CUnescapeForNullTerminatedString().
//
//    Unescapes C escape sequences and is the reverse of CEscape().
//
//    If 'source' is valid, stores the unescaped string and its size in
//    'dest' and 'dest_len' respectively, and returns true. Otherwise
//    returns false and optionally stores the error description in
//    'error'. Set 'error' to NULL to disable error reporting.
//
//    'dest' should point to a buffer that is at least as big as 'source'.
//    'source' and 'dest' may be the same.
//
//     NOTE: any changes to this function must also be reflected in the older
//     UnescapeCEscapeSequences().
// ----------------------------------------------------------------------
static bool CUnescapeInternal(const StringPiece& source, bool leave_nulls_escaped, char* dest,
                              int* dest_len, string* error) {
    char* d = dest;
    const char* p = source.data();
    const char* end = source.end();
    const char* last_byte = end - 1;

    // Small optimization for case where source = dest and there's no escaping
    while (p == d && p < end && *p != '\\') p++, d++;

    while (p < end) {
        if (*p != '\\') {
            *d++ = *p++;
        } else {
            if (++p > last_byte) { // skip past the '\\'
                if (error) *error = "String cannot end with \\";
                return false;
            }
            switch (*p) {
            case 'a':
                *d++ = '\a';
                break;
            case 'b':
                *d++ = '\b';
                break;
            case 'f':
                *d++ = '\f';
                break;
            case 'n':
                *d++ = '\n';
                break;
            case 'r':
                *d++ = '\r';
                break;
            case 't':
                *d++ = '\t';
                break;
            case 'v':
                *d++ = '\v';
                break;
            case '\\':
                *d++ = '\\';
                break;
            case '?':
                *d++ = '\?';
                break; // \?  Who knew?
            case '\'':
                *d++ = '\'';
                break;
            case '"':
                *d++ = '\"';
                break;
            case '0':
            case '1':
            case '2':
            case '3': // octal digit: 1 to 3 digits
            case '4':
            case '5':
            case '6':
            case '7': {
                const char* octal_start = p;
                unsigned int ch = *p - '0';
                if (p < last_byte && IS_OCTAL_DIGIT(p[1])) ch = ch * 8 + *++p - '0';
                if (p < last_byte && IS_OCTAL_DIGIT(p[1]))
                    ch = ch * 8 + *++p - '0'; // now points at last digit
                if (ch > 0xff) {
                    if (error) {
                        *error = "Value of \\" + string(octal_start, p + 1 - octal_start) +
                                 " exceeds 0xff";
                    }
                    return false;
                }
                if ((ch == 0) && leave_nulls_escaped) {
                    // Copy the escape sequence for the null character
                    const int octal_size = p + 1 - octal_start;
                    *d++ = '\\';
                    memcpy(d, octal_start, octal_size);
                    d += octal_size;
                    break;
                }
                *d++ = ch;
                break;
            }
            case 'x':
            case 'X': {
                if (p >= last_byte) {
                    if (error) *error = "String cannot end with \\x";
                    return false;
                } else if (!ascii_isxdigit(p[1])) {
                    if (error) *error = "\\x cannot be followed by a non-hex digit";
                    return false;
                }
                unsigned int ch = 0;
                const char* hex_start = p;
                while (p < last_byte && ascii_isxdigit(p[1]))
                    // Arbitrarily many hex digits
                    ch = (ch << 4) + hex_digit_to_int(*++p);
                if (ch > 0xFF) {
                    if (error) {
                        *error = "Value of \\" + string(hex_start, p + 1 - hex_start) +
                                 " exceeds 0xff";
                    }
                    return false;
                }
                if ((ch == 0) && leave_nulls_escaped) {
                    // Copy the escape sequence for the null character
                    const int hex_size = p + 1 - hex_start;
                    *d++ = '\\';
                    memcpy(d, hex_start, hex_size);
                    d += hex_size;
                    break;
                }
                *d++ = ch;
                break;
            }
            case 'u': {
                // \uhhhh => convert 4 hex digits to UTF-8
                char32 rune = 0;
                const char* hex_start = p;
                if (p + 4 >= end) {
                    if (error) {
                        *error = "\\u must be followed by 4 hex digits: \\" +
                                 string(hex_start, p + 1 - hex_start);
                    }
                    return false;
                }
                for (int i = 0; i < 4; ++i) {
                    // Look one char ahead.
                    if (ascii_isxdigit(p[1])) {
                        rune = (rune << 4) + hex_digit_to_int(*++p); // Advance p.
                    } else {
                        if (error) {
                            *error = "\\u must be followed by 4 hex digits: \\" +
                                     string(hex_start, p + 1 - hex_start);
                        }
                        return false;
                    }
                }
                if ((rune == 0) && leave_nulls_escaped) {
                    // Copy the escape sequence for the null character
                    *d++ = '\\';
                    memcpy(d, hex_start, 5); // u0000
                    d += 5;
                    break;
                }
                d += runetochar(d, &rune);
                break;
            }
            case 'U': {
                // \Uhhhhhhhh => convert 8 hex digits to UTF-8
                char32 rune = 0;
                const char* hex_start = p;
                if (p + 8 >= end) {
                    if (error) {
                        *error = "\\U must be followed by 8 hex digits: \\" +
                                 string(hex_start, p + 1 - hex_start);
                    }
                    return false;
                }
                for (int i = 0; i < 8; ++i) {
                    // Look one char ahead.
                    if (ascii_isxdigit(p[1])) {
                        // Don't change rune until we're sure this
                        // is within the Unicode limit, but do advance p.
                        char32 newrune = (rune << 4) + hex_digit_to_int(*++p);
                        if (newrune > 0x10FFFF) {
                            if (error) {
                                *error = "Value of \\" + string(hex_start, p + 1 - hex_start) +
                                         " exceeds Unicode limit (0x10FFFF)";
                            }
                            return false;
                        } else {
                            rune = newrune;
                        }
                    } else {
                        if (error) {
                            *error = "\\U must be followed by 8 hex digits: \\" +
                                     string(hex_start, p + 1 - hex_start);
                        }
                        return false;
                    }
                }
                if ((rune == 0) && leave_nulls_escaped) {
                    // Copy the escape sequence for the null character
                    *d++ = '\\';
                    memcpy(d, hex_start, 9); // U00000000
                    d += 9;
                    break;
                }
                d += runetochar(d, &rune);
                break;
            }
            default: {
                if (error) *error = string("Unknown escape sequence: \\") + *p;
                return false;
            }
            }
            p++; // read past letter we escaped
        }
    }
    *dest_len = d - dest;
    return true;
}

// ----------------------------------------------------------------------
// CUnescapeInternal()
//
//    Same as above but uses a C++ string for output. 'source' and 'dest'
//    may be the same.
// ----------------------------------------------------------------------
bool CUnescapeInternal(const StringPiece& source, bool leave_nulls_escaped, string* dest,
                       string* error) {
    dest->resize(source.size());
    int dest_size;
    if (!CUnescapeInternal(source, leave_nulls_escaped, const_cast<char*>(dest->data()), &dest_size,
                           error)) {
        return false;
    }
    dest->resize(dest_size);
    return true;
}

// ----------------------------------------------------------------------
// CUnescape()
//
// See CUnescapeInternal() for implementation details.
// ----------------------------------------------------------------------
bool CUnescape(const StringPiece& source, char* dest, int* dest_len, string* error) {
    return CUnescapeInternal(source, kUnescapeNulls, dest, dest_len, error);
}

bool CUnescape(const StringPiece& source, string* dest, string* error) {
    return CUnescapeInternal(source, kUnescapeNulls, dest, error);
}

// ----------------------------------------------------------------------
// CUnescapeForNullTerminatedString()
//
// See CUnescapeInternal() for implementation details.
// ----------------------------------------------------------------------
bool CUnescapeForNullTerminatedString(const StringPiece& source, char* dest, int* dest_len,
                                      string* error) {
    return CUnescapeInternal(source, kLeaveNullsEscaped, dest, dest_len, error);
}

bool CUnescapeForNullTerminatedString(const StringPiece& source, string* dest, string* error) {
    return CUnescapeInternal(source, kLeaveNullsEscaped, dest, error);
}

// ----------------------------------------------------------------------
// CEscapeString()
// CHexEscapeString()
// Utf8SafeCEscapeString()
// Utf8SafeCHexEscapeString()
//    Copies 'src' to 'dest', escaping dangerous characters using
//    C-style escape sequences. This is very useful for preparing query
//    flags. 'src' and 'dest' should not overlap. The 'Hex' version uses
//    hexadecimal rather than octal sequences. The 'Utf8Safe' version doesn't
//    touch UTF-8 bytes.
//    Returns the number of bytes written to 'dest' (not including the \0)
//    or -1 if there was insufficient space.
//
//    Currently only \n, \r, \t, ", ', \ and !ascii_isprint() chars are escaped.
// ----------------------------------------------------------------------
int CEscapeInternal(const char* src, int src_len, char* dest, int dest_len, bool use_hex,
                    bool utf8_safe) {
    const char* src_end = src + src_len;
    int used = 0;
    bool last_hex_escape = false; // true if last output char was \xNN

    for (; src < src_end; src++) {
        if (dest_len - used < 2) // Need space for two letter escape
            return -1;

        bool is_hex_escape = false;
        switch (*src) {
        case '\n':
            dest[used++] = '\\';
            dest[used++] = 'n';
            break;
        case '\r':
            dest[used++] = '\\';
            dest[used++] = 'r';
            break;
        case '\t':
            dest[used++] = '\\';
            dest[used++] = 't';
            break;
        case '\"':
            dest[used++] = '\\';
            dest[used++] = '\"';
            break;
        case '\'':
            dest[used++] = '\\';
            dest[used++] = '\'';
            break;
        case '\\':
            dest[used++] = '\\';
            dest[used++] = '\\';
            break;
        default:
            // Note that if we emit \xNN and the src character after that is a hex
            // digit then that digit must be escaped too to prevent it being
            // interpreted as part of the character code by C.
            if ((!utf8_safe || *src < 0x80) &&
                (!ascii_isprint(*src) || (last_hex_escape && ascii_isxdigit(*src)))) {
                if (dest_len - used < 4) // need space for 4 letter escape
                    return -1;
                sprintf(dest + used, (use_hex ? "\\x%02x" : "\\%03o"), *src);
                is_hex_escape = use_hex;
                used += 4;
            } else {
                dest[used++] = *src;
                break;
            }
        }
        last_hex_escape = is_hex_escape;
    }

    if (dest_len - used < 1) // make sure that there is room for \0
        return -1;

    dest[used] = '\0'; // doesn't count towards return value though
    return used;
}

int CEscapeString(const char* src, int src_len, char* dest, int dest_len) {
    return CEscapeInternal(src, src_len, dest, dest_len, false, false);
}

int CHexEscapeString(const char* src, int src_len, char* dest, int dest_len) {
    return CEscapeInternal(src, src_len, dest, dest_len, true, false);
}

int Utf8SafeCEscapeString(const char* src, int src_len, char* dest, int dest_len) {
    return CEscapeInternal(src, src_len, dest, dest_len, false, true);
}

int Utf8SafeCHexEscapeString(const char* src, int src_len, char* dest, int dest_len) {
    return CEscapeInternal(src, src_len, dest, dest_len, true, true);
}

// ----------------------------------------------------------------------
// CEscape()
// CHexEscape()
// Utf8SafeCEscape()
// Utf8SafeCHexEscape()
//    Copies 'src' to result, escaping dangerous characters using
//    C-style escape sequences. This is very useful for preparing query
//    flags. 'src' and 'dest' should not overlap. The 'Hex' version
//    hexadecimal rather than octal sequences. The 'Utf8Safe' version
//    doesn't touch UTF-8 bytes.
//
//    Currently only \n, \r, \t, ", ', \ and !ascii_isprint() chars are escaped.
// ----------------------------------------------------------------------
string CEscape(const StringPiece& src) {
    const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
    gscoped_array<char> dest(new char[dest_length]);
    const int len = CEscapeInternal(src.data(), src.size(), dest.get(), dest_length, false, false);
    DCHECK_GE(len, 0);
    return string(dest.get(), len);
}

string CHexEscape(const StringPiece& src) {
    const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
    gscoped_array<char> dest(new char[dest_length]);
    const int len = CEscapeInternal(src.data(), src.size(), dest.get(), dest_length, true, false);
    DCHECK_GE(len, 0);
    return string(dest.get(), len);
}

string Utf8SafeCEscape(const StringPiece& src) {
    const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
    gscoped_array<char> dest(new char[dest_length]);
    const int len = CEscapeInternal(src.data(), src.size(), dest.get(), dest_length, false, true);
    DCHECK_GE(len, 0);
    return string(dest.get(), len);
}

string Utf8SafeCHexEscape(const StringPiece& src) {
    const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
    gscoped_array<char> dest(new char[dest_length]);
    const int len = CEscapeInternal(src.data(), src.size(), dest.get(), dest_length, true, true);
    DCHECK_GE(len, 0);
    return string(dest.get(), len);
}

// ----------------------------------------------------------------------
// BackslashEscape and BackslashUnescape
// ----------------------------------------------------------------------
void BackslashEscape(const StringPiece& src, const strings::CharSet& to_escape, string* dest) {
    dest->reserve(dest->size() + src.size());
    for (const char *p = src.data(), *end = src.data() + src.size(); p != end;) {
        // Advance to next character we need to escape, or to end of source
        const char* next = p;
        while (next < end && !to_escape.Test(*next)) {
            next++;
        }
        // Append the whole run of non-escaped chars
        dest->append(p, next - p);
        if (next == end) break;
        // Char at *next needs to be escaped.  Append backslash followed by *next
        char c[2];
        c[0] = '\\';
        c[1] = *next;
        dest->append(c, 2);
        p = next + 1;
    }
}

void BackslashUnescape(const StringPiece& src, const strings::CharSet& to_unescape, string* dest) {
    dest->reserve(dest->size() + src.size());
    bool escaped = false;
    for (const char *p = src.data(), *end = src.data() + src.size(); p != end; ++p) {
        if (escaped) {
            if (!to_unescape.Test(*p)) {
                // Keep the backslash
                dest->push_back('\\');
            }
            dest->push_back(*p);
            escaped = false;
        } else if (*p == '\\') {
            escaped = true;
        } else {
            dest->push_back(*p);
        }
    }
}

// ----------------------------------------------------------------------
// int QuotedPrintableUnescape()
//
// Check out http://www.cis.ohio-state.edu/htbin/rfc/rfc2045.html for
// more details, only briefly implemented. But from the web...
// Quoted-printable is an encoding method defined in the MIME
// standard. It is used primarily to encode 8-bit text (such as text
// that includes foreign characters) into 7-bit US ASCII, creating a
// document that is mostly readable by humans, even in its encoded
// form. All MIME compliant applications can decode quoted-printable
// text, though they may not necessarily be able to properly display the
// document as it was originally intended. As quoted-printable encoding
// is implemented most commonly, printable ASCII characters (values 33
// through 126, excluding 61), tabs and spaces that do not appear at the
// end of lines, and end-of-line characters are not encoded. Other
// characters are represented by an equal sign (=) immediately followed
// by that character's hexadecimal value. Lines that are longer than 76
// characters are shortened by line breaks, with the equal sign marking
// where the breaks occurred.
//
// Note that QuotedPrintableUnescape is different from 'Q'-encoding as
// defined in rfc2047. In particular, This does not treat '_'s as spaces.
// See QEncodingUnescape().
// ----------------------------------------------------------------------

int QuotedPrintableUnescape(const char* source, int slen, char* dest, int szdest) {
    char* d = dest;
    const char* p = source;

    while (p < source + slen && *p != '\0' && d < dest + szdest) {
        switch (*p) {
        case '=':
            // If it's valid, convert to hex and insert or remove line-wrap.
            // In the case of line-wrap removal, we allow LF as well as CRLF.
            if (p < source + slen - 1) {
                if (p[1] == '\n') {
                    p++;
                } else if (p < source + slen - 2) {
                    if (ascii_isxdigit(p[1]) && ascii_isxdigit(p[2])) {
                        *d++ = hex_digit_to_int(p[1]) * 16 + hex_digit_to_int(p[2]);
                        p += 2;
                    } else if (p[1] == '\r' && p[2] == '\n') {
                        p += 2;
                    }
                }
            }
            p++;
            break;
        default:
            *d++ = *p++;
            break;
        }
    }
    return (d - dest);
}

// ----------------------------------------------------------------------
// int QEncodingUnescape()
//
// This is very similar to QuotedPrintableUnescape except that we convert
// '_'s into spaces. (See RFC 2047)
// ----------------------------------------------------------------------
int QEncodingUnescape(const char* source, int slen, char* dest, int szdest) {
    char* d = dest;
    const char* p = source;

    while (p < source + slen && *p != '\0' && d < dest + szdest) {
        switch (*p) {
        case '=':
            // If it's valid, convert to hex and insert or remove line-wrap.
            // In the case of line-wrap removal, the assumption is that this
            // is an RFC-compliant message with lines terminated by CRLF.
            if (p < source + slen - 2) {
                if (ascii_isxdigit(p[1]) && ascii_isxdigit(p[2])) {
                    *d++ = hex_digit_to_int(p[1]) * 16 + hex_digit_to_int(p[2]);
                    p += 2;
                } else if (p[1] == '\r' && p[2] == '\n') {
                    p += 2;
                }
            }
            p++;
            break;
        case '_': // According to rfc2047, _'s are to be treated as spaces
            *d++ = ' ';
            p++;
            break;
        default:
            *d++ = *p++;
            break;
        }
    }
    return (d - dest);
}

int CalculateBase64EscapedLen(int input_len, bool do_padding) {
    // Base64 encodes three bytes of input at a time. If the input is not
    // divisible by three, we pad as appropriate.
    //
    // (from http://www.ietf.org/rfc/rfc3548.txt)
    // Special processing is performed if fewer than 24 bits are available
    // at the end of the data being encoded.  A full encoding quantum is
    // always completed at the end of a quantity.  When fewer than 24 input
    // bits are available in an input group, zero bits are added (on the
    // right) to form an integral number of 6-bit groups.  Padding at the
    // end of the data is performed using the '=' character.  Since all base
    // 64 input is an integral number of octets, only the following cases
    // can arise:

    // Base64 encodes each three bytes of input into four bytes of output.
    int len = (input_len / 3) * 4;

    if (input_len % 3 == 0) {
        // (from http://www.ietf.org/rfc/rfc3548.txt)
        // (1) the final quantum of encoding input is an integral multiple of 24
        // bits; here, the final unit of encoded output will be an integral
        // multiple of 4 characters with no "=" padding,
    } else if (input_len % 3 == 1) {
        // (from http://www.ietf.org/rfc/rfc3548.txt)
        // (2) the final quantum of encoding input is exactly 8 bits; here, the
        // final unit of encoded output will be two characters followed by two
        // "=" padding characters, or
        len += 2;
        if (do_padding) {
            len += 2;
        }
    } else { // (input_len % 3 == 2)
        // (from http://www.ietf.org/rfc/rfc3548.txt)
        // (3) the final quantum of encoding input is exactly 16 bits; here, the
        // final unit of encoded output will be three characters followed by one
        // "=" padding character.
        len += 3;
        if (do_padding) {
            len += 1;
        }
    }

    assert(len >= input_len); // make sure we didn't overflow
    return len;
}

// Base64Escape does padding, so this calculation includes padding.
int CalculateBase64EscapedLen(int input_len) {
    return CalculateBase64EscapedLen(input_len, true);
}

// ----------------------------------------------------------------------
// int Base64Unescape() - base64 decoder
// int Base64Escape() - base64 encoder
// int WebSafeBase64Unescape() - Google's variation of base64 decoder
// int WebSafeBase64Escape() - Google's variation of base64 encoder
//
// Check out
// http://www.cis.ohio-state.edu/htbin/rfc/rfc2045.html for formal
// description, but what we care about is that...
//   Take the encoded stuff in groups of 4 characters and turn each
//   character into a code 0 to 63 thus:
//           A-Z map to 0 to 25
//           a-z map to 26 to 51
//           0-9 map to 52 to 61
//           +(- for WebSafe) maps to 62
//           /(_ for WebSafe) maps to 63
//   There will be four numbers, all less than 64 which can be represented
//   by a 6 digit binary number (aaaaaa, bbbbbb, cccccc, dddddd respectively).
//   Arrange the 6 digit binary numbers into three bytes as such:
//   aaaaaabb bbbbcccc ccdddddd
//   Equals signs (one or two) are used at the end of the encoded block to
//   indicate that the text was not an integer multiple of three bytes long.
// In the sorted variation, we instead use the mapping
//           .   maps to 0
//           0-9 map to 1-10
//           A-Z map to 11-37
//           _   maps to 38
//           a-z map to 39-63
// This mapping has the property that the output will be sorted in the same
// order as the input, i.e. a < b iff map(a) < map(b). It is web-safe and
// filename-safe.
// ----------------------------------------------------------------------

int Base64UnescapeInternal(const char* src, int szsrc, char* dest, int szdest,
                           const signed char* unbase64) {
    static const char kPad64 = '=';

    int decode = 0;
    int destidx = 0;
    int state = 0;
    unsigned int ch = 0;
    unsigned int temp = 0;

    // The GET_INPUT macro gets the next input character, skipping
    // over any whitespace, and stopping when we reach the end of the
    // string or when we read any non-data character.  The arguments are
    // an arbitrary identifier (used as a label for goto) and the number
    // of data bytes that must remain in the input to avoid aborting the
    // loop.
#define GET_INPUT(label, remain)                              \
    label:                                                    \
    --szsrc;                                                  \
    ch = *src++;                                              \
    decode = unbase64[ch];                                    \
    if (decode < 0) {                                         \
        if (ascii_isspace(ch) && szsrc >= remain) goto label; \
        state = 4 - remain;                                   \
        break;                                                \
    }

    // if dest is null, we're just checking to see if it's legal input
    // rather than producing output.  (I suspect this could just be done
    // with a regexp...).  We duplicate the loop so this test can be
    // outside it instead of in every iteration.

    if (dest) {
        // This loop consumes 4 input bytes and produces 3 output bytes
        // per iteration.  We can't know at the start that there is enough
        // data left in the string for a full iteration, so the loop may
        // break out in the middle; if so 'state' will be set to the
        // number of input bytes read.

        while (szsrc >= 4) {
            // We'll start by optimistically assuming that the next four
            // bytes of the string (src[0..3]) are four good data bytes
            // (that is, no nulls, whitespace, padding chars, or illegal
            // chars).  We need to test src[0..2] for nulls individually
            // before constructing temp to preserve the property that we
            // never read past a null in the string (no matter how long
            // szsrc claims the string is).

            if (!src[0] || !src[1] || !src[2] ||
                (temp = ((unbase64[src[0]] << 18) | (unbase64[src[1]] << 12) |
                         (unbase64[src[2]] << 6) | (unbase64[src[3]]))) &
                        0x80000000) {
                // Iff any of those four characters was bad (null, illegal,
                // whitespace, padding), then temp's high bit will be set
                // (because unbase64[] is -1 for all bad characters).
                //
                // We'll back up and resort to the slower decoder, which knows
                // how to handle those cases.

                GET_INPUT(first, 4);
                temp = decode;
                GET_INPUT(second, 3);
                temp = (temp << 6) | decode;
                GET_INPUT(third, 2);
                temp = (temp << 6) | decode;
                GET_INPUT(fourth, 1);
                temp = (temp << 6) | decode;
            } else {
                // We really did have four good data bytes, so advance four
                // characters in the string.

                szsrc -= 4;
                src += 4;
                decode = -1;
                ch = '\0';
            }

            // temp has 24 bits of input, so write that out as three bytes.

            if (destidx + 3 > szdest) return -1;
            dest[destidx + 2] = temp;
            temp >>= 8;
            dest[destidx + 1] = temp;
            temp >>= 8;
            dest[destidx] = temp;
            destidx += 3;
        }
    } else {
        while (szsrc >= 4) {
            if (!src[0] || !src[1] || !src[2] ||
                (temp = ((unbase64[src[0]] << 18) | (unbase64[src[1]] << 12) |
                         (unbase64[src[2]] << 6) | (unbase64[src[3]]))) &
                        0x80000000) {
                GET_INPUT(first_no_dest, 4);
                GET_INPUT(second_no_dest, 3);
                GET_INPUT(third_no_dest, 2);
                GET_INPUT(fourth_no_dest, 1);
            } else {
                szsrc -= 4;
                src += 4;
                decode = -1;
                ch = '\0';
            }
            destidx += 3;
        }
    }

#undef GET_INPUT

    // if the loop terminated because we read a bad character, return
    // now.
    if (decode < 0 && ch != '\0' && ch != kPad64 && !ascii_isspace(ch)) return -1;

    if (ch == kPad64) {
        // if we stopped by hitting an '=', un-read that character -- we'll
        // look at it again when we count to check for the proper number of
        // equals signs at the end.
        ++szsrc;
        --src;
    } else {
        // This loop consumes 1 input byte per iteration.  It's used to
        // clean up the 0-3 input bytes remaining when the first, faster
        // loop finishes.  'temp' contains the data from 'state' input
        // characters read by the first loop.
        while (szsrc > 0) {
            --szsrc;
            ch = *src++;
            decode = unbase64[ch];
            if (decode < 0) {
                if (ascii_isspace(ch)) {
                    continue;
                } else if (ch == '\0') {
                    break;
                } else if (ch == kPad64) {
                    // back up one character; we'll read it again when we check
                    // for the correct number of equals signs at the end.
                    ++szsrc;
                    --src;
                    break;
                } else {
                    return -1;
                }
            }

            // Each input character gives us six bits of output.
            temp = (temp << 6) | decode;
            ++state;
            if (state == 4) {
                // If we've accumulated 24 bits of output, write that out as
                // three bytes.
                if (dest) {
                    if (destidx + 3 > szdest) return -1;
                    dest[destidx + 2] = temp;
                    temp >>= 8;
                    dest[destidx + 1] = temp;
                    temp >>= 8;
                    dest[destidx] = temp;
                }
                destidx += 3;
                state = 0;
                temp = 0;
            }
        }
    }

    // Process the leftover data contained in 'temp' at the end of the input.
    int expected_equals = 0;
    switch (state) {
    case 0:
        // Nothing left over; output is a multiple of 3 bytes.
        break;

    case 1:
        // Bad input; we have 6 bits left over.
        return -1;

    case 2:
        // Produce one more output byte from the 12 input bits we have left.
        if (dest) {
            if (destidx + 1 > szdest) return -1;
            temp >>= 4;
            dest[destidx] = temp;
        }
        ++destidx;
        expected_equals = 2;
        break;

    case 3:
        // Produce two more output bytes from the 18 input bits we have left.
        if (dest) {
            if (destidx + 2 > szdest) return -1;
            temp >>= 2;
            dest[destidx + 1] = temp;
            temp >>= 8;
            dest[destidx] = temp;
        }
        destidx += 2;
        expected_equals = 1;
        break;

    default:
        // state should have no other values at this point.
        LOG(FATAL) << "This can't happen; base64 decoder state = " << state;
    }

    // The remainder of the string should be all whitespace, mixed with
    // exactly 0 equals signs, or exactly 'expected_equals' equals
    // signs.  (Always accepting 0 equals signs is a google extension
    // not covered in the RFC.)

    int equals = 0;
    while (szsrc > 0 && *src) {
        if (*src == kPad64)
            ++equals;
        else if (!ascii_isspace(*src))
            return -1;
        --szsrc;
        ++src;
    }

    return (equals == 0 || equals == expected_equals) ? destidx : -1;
}

// The arrays below were generated by the following code
// #include <sys/time.h>
// #include <stdlib.h>
// #include <string.h>
// main()
// {
//   static const char Base64[] =
//     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
//   char *pos;
//   int idx, i, j;
//   printf("    ");
//   for (i = 0; i < 255; i += 8) {
//     for (j = i; j < i + 8; j++) {
//       pos = strchr(Base64, j);
//       if ((pos == NULL) || (j == 0))
//         idx = -1;
//       else
//         idx = pos - Base64;
//       if (idx == -1)
//         printf(" %2d,     ", idx);
//       else
//         printf(" %2d/*%c*/,", idx, j);
//     }
//     printf("\n    ");
//   }
// }
//
// where the value of "Base64[]" was replaced by one of the base-64 conversion
// tables from the functions below.
static const signed char kUnBase64[] = {
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       62 /*+*/, -1,
        -1,       -1,       63 /*/ */, 52 /*0*/, 53 /*1*/, 54 /*2*/, 55 /*3*/, 56 /*4*/, 57 /*5*/,
        58 /*6*/, 59 /*7*/, 60 /*8*/,  61 /*9*/, -1,       -1,       -1,       -1,       -1,
        -1,       -1,       0 /*A*/,   1 /*B*/,  2 /*C*/,  3 /*D*/,  4 /*E*/,  5 /*F*/,  6 /*G*/,
        07 /*H*/, 8 /*I*/,  9 /*J*/,   10 /*K*/, 11 /*L*/, 12 /*M*/, 13 /*N*/, 14 /*O*/, 15 /*P*/,
        16 /*Q*/, 17 /*R*/, 18 /*S*/,  19 /*T*/, 20 /*U*/, 21 /*V*/, 22 /*W*/, 23 /*X*/, 24 /*Y*/,
        25 /*Z*/, -1,       -1,        -1,       -1,       -1,       -1,       26 /*a*/, 27 /*b*/,
        28 /*c*/, 29 /*d*/, 30 /*e*/,  31 /*f*/, 32 /*g*/, 33 /*h*/, 34 /*i*/, 35 /*j*/, 36 /*k*/,
        37 /*l*/, 38 /*m*/, 39 /*n*/,  40 /*o*/, 41 /*p*/, 42 /*q*/, 43 /*r*/, 44 /*s*/, 45 /*t*/,
        46 /*u*/, 47 /*v*/, 48 /*w*/,  49 /*x*/, 50 /*y*/, 51 /*z*/, -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,        -1};
static const signed char kUnWebSafeBase64[] = {
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        62 /*-*/, -1,       -1,       52 /*0*/, 53 /*1*/, 54 /*2*/, 55 /*3*/, 56 /*4*/, 57 /*5*/,
        58 /*6*/, 59 /*7*/, 60 /*8*/, 61 /*9*/, -1,       -1,       -1,       -1,       -1,
        -1,       -1,       0 /*A*/,  1 /*B*/,  2 /*C*/,  3 /*D*/,  4 /*E*/,  5 /*F*/,  6 /*G*/,
        07 /*H*/, 8 /*I*/,  9 /*J*/,  10 /*K*/, 11 /*L*/, 12 /*M*/, 13 /*N*/, 14 /*O*/, 15 /*P*/,
        16 /*Q*/, 17 /*R*/, 18 /*S*/, 19 /*T*/, 20 /*U*/, 21 /*V*/, 22 /*W*/, 23 /*X*/, 24 /*Y*/,
        25 /*Z*/, -1,       -1,       -1,       -1,       63 /*_*/, -1,       26 /*a*/, 27 /*b*/,
        28 /*c*/, 29 /*d*/, 30 /*e*/, 31 /*f*/, 32 /*g*/, 33 /*h*/, 34 /*i*/, 35 /*j*/, 36 /*k*/,
        37 /*l*/, 38 /*m*/, 39 /*n*/, 40 /*o*/, 41 /*p*/, 42 /*q*/, 43 /*r*/, 44 /*s*/, 45 /*t*/,
        46 /*u*/, 47 /*v*/, 48 /*w*/, 49 /*x*/, 50 /*y*/, 51 /*z*/, -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,       -1,
        -1,       -1,       -1,       -1};

int Base64Unescape(const char* src, int szsrc, char* dest, int szdest) {
    return Base64UnescapeInternal(src, szsrc, dest, szdest, kUnBase64);
}

int WebSafeBase64Unescape(const char* src, int szsrc, char* dest, int szdest) {
    return Base64UnescapeInternal(src, szsrc, dest, szdest, kUnWebSafeBase64);
}

static bool Base64UnescapeInternal(const char* src, int slen, string* dest,
                                   const signed char* unbase64) {
    // Determine the size of the output string.  Base64 encodes every 3 bytes into
    // 4 characters.  any leftover chars are added directly for good measure.
    // This is documented in the base64 RFC: http://www.ietf.org/rfc/rfc3548.txt
    const int dest_len = 3 * (slen / 4) + (slen % 4);

    dest->clear();
    dest->resize(dest_len);

    // We are getting the destination buffer by getting the beginning of the
    // string and converting it into a char *.
    const int len =
            Base64UnescapeInternal(src, slen, string_as_array(dest), dest->size(), unbase64);
    if (len < 0) {
        dest->clear();
        return false;
    }

    // could be shorter if there was padding
    DCHECK_LE(len, dest_len);
    dest->resize(len);

    return true;
}

bool Base64Unescape(const char* src, int slen, string* dest) {
    return Base64UnescapeInternal(src, slen, dest, kUnBase64);
}

bool WebSafeBase64Unescape(const char* src, int slen, string* dest) {
    return Base64UnescapeInternal(src, slen, dest, kUnWebSafeBase64);
}

int Base64EscapeInternal(const unsigned char* src, int szsrc, char* dest, int szdest,
                         const char* base64, bool do_padding) {
    static const char kPad64 = '=';

    if (szsrc <= 0) return 0;

    char* cur_dest = dest;
    const unsigned char* cur_src = src;

    // Three bytes of data encodes to four characters of cyphertext.
    // So we can pump through three-byte chunks atomically.
    while (szsrc > 2) { /* keep going until we have less than 24 bits */
        if ((szdest -= 4) < 0) return 0;
        cur_dest[0] = base64[cur_src[0] >> 2];
        cur_dest[1] = base64[((cur_src[0] & 0x03) << 4) + (cur_src[1] >> 4)];
        cur_dest[2] = base64[((cur_src[1] & 0x0f) << 2) + (cur_src[2] >> 6)];
        cur_dest[3] = base64[cur_src[2] & 0x3f];

        cur_dest += 4;
        cur_src += 3;
        szsrc -= 3;
    }

    /* now deal with the tail (<=2 bytes) */
    switch (szsrc) {
    case 0:
        // Nothing left; nothing more to do.
        break;
    case 1:
        // One byte left: this encodes to two characters, and (optionally)
        // two pad characters to round out the four-character cypherblock.
        if ((szdest -= 2) < 0) return 0;
        cur_dest[0] = base64[cur_src[0] >> 2];
        cur_dest[1] = base64[(cur_src[0] & 0x03) << 4];
        cur_dest += 2;
        if (do_padding) {
            if ((szdest -= 2) < 0) return 0;
            cur_dest[0] = kPad64;
            cur_dest[1] = kPad64;
            cur_dest += 2;
        }
        break;
    case 2:
        // Two bytes left: this encodes to three characters, and (optionally)
        // one pad character to round out the four-character cypherblock.
        if ((szdest -= 3) < 0) return 0;
        cur_dest[0] = base64[cur_src[0] >> 2];
        cur_dest[1] = base64[((cur_src[0] & 0x03) << 4) + (cur_src[1] >> 4)];
        cur_dest[2] = base64[(cur_src[1] & 0x0f) << 2];
        cur_dest += 3;
        if (do_padding) {
            if ((szdest -= 1) < 0) return 0;
            cur_dest[0] = kPad64;
            cur_dest += 1;
        }
        break;
    default:
        // Should not be reached: blocks of 3 bytes are handled
        // in the while loop before this switch statement.
        LOG_ASSERT(false) << "Logic problem? szsrc = " << szsrc;
        break;
    }
    return (cur_dest - dest);
}

static const char kBase64Chars[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static const char kWebSafeBase64Chars[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

int Base64Escape(const unsigned char* src, int szsrc, char* dest, int szdest) {
    return Base64EscapeInternal(src, szsrc, dest, szdest, kBase64Chars, true);
}
int WebSafeBase64Escape(const unsigned char* src, int szsrc, char* dest, int szdest,
                        bool do_padding) {
    return Base64EscapeInternal(src, szsrc, dest, szdest, kWebSafeBase64Chars, do_padding);
}

void Base64EscapeInternal(const unsigned char* src, int szsrc, string* dest, bool do_padding,
                          const char* base64_chars) {
    const int calc_escaped_size = CalculateBase64EscapedLen(szsrc, do_padding);
    dest->clear();
    dest->resize(calc_escaped_size, '\0');
    const int escaped_len = Base64EscapeInternal(src, szsrc, string_as_array(dest), dest->size(),
                                                 base64_chars, do_padding);
    DCHECK_EQ(calc_escaped_size, escaped_len);
}

void Base64Escape(const unsigned char* src, int szsrc, string* dest, bool do_padding) {
    Base64EscapeInternal(src, szsrc, dest, do_padding, kBase64Chars);
}

void WebSafeBase64Escape(const unsigned char* src, int szsrc, string* dest, bool do_padding) {
    Base64EscapeInternal(src, szsrc, dest, do_padding, kWebSafeBase64Chars);
}

void Base64Escape(const string& src, string* dest) {
    Base64Escape(reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, true);
}

void WebSafeBase64Escape(const string& src, string* dest) {
    WebSafeBase64Escape(reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest,
                        false);
}

void WebSafeBase64EscapeWithPadding(const string& src, string* dest) {
    WebSafeBase64Escape(reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, true);
}

// Returns true iff c is in the Base 32 alphabet.
bool ValidBase32Byte(char c) {
    return (c >= 'A' && c <= 'Z') || (c >= '2' && c <= '7') || c == '=';
}

// Mapping from number of Base32 escaped characters (0 through 8) to number of
// unescaped bytes.  8 Base32 escaped characters represent 5 unescaped bytes.
// For N < 8, then number of unescaped bytes is less than 5.  Note that in
// valid input, N can only be 0, 2, 4, 5, 7, or 8 (corresponding to 0, 1, 2,
// 3, 4, or 5 unescaped bytes).
//
// We use 5 for invalid values of N to be safe, since this is used to compute
// the length of the buffer to hold unescaped data.
//
// See http://tools.ietf.org/html/rfc4648#section-6 for details.
static const int kBase32NumUnescapedBytes[] = {0, 5, 1, 5, 2, 3, 5, 4, 5};

int Base32Unescape(const char* src, int slen, char* dest, int szdest) {
    int destidx = 0;
    char escaped_bytes[8];
    unsigned char unescaped_bytes[5];
    while (slen > 0) {
        // Collect the next 8 escaped bytes and convert to upper case.  If there
        // are less than 8 bytes left, pad with '=', but keep track of the number
        // of non-padded bytes for later.
        int non_padded_len = 8;
        for (int i = 0; i < 8; ++i) {
            escaped_bytes[i] = (i < slen) ? ascii_toupper(src[i]) : '=';
            if (!ValidBase32Byte(escaped_bytes[i])) {
                return -1;
            }
            // Stop counting escaped bytes at first '='.
            if (escaped_bytes[i] == '=' && non_padded_len == 8) {
                non_padded_len = i;
            }
        }

        // Convert the 8 escaped bytes to 5 unescaped bytes and copy to dest.
        EightBase32DigitsToFiveBytes(escaped_bytes, unescaped_bytes);
        const int num_unescaped = kBase32NumUnescapedBytes[non_padded_len];
        for (int i = 0; i < num_unescaped; ++i) {
            if (destidx == szdest) {
                // No more room in dest, so terminate early.
                return -1;
            }
            dest[destidx] = unescaped_bytes[i];
            ++destidx;
        }
        src += 8;
        slen -= 8;
    }
    return destidx;
}

bool Base32Unescape(const char* src, int slen, string* dest) {
    // Determine the size of the output string.
    const int dest_len = 5 * (slen / 8) + kBase32NumUnescapedBytes[slen % 8];

    dest->clear();
    dest->resize(dest_len);

    // We are getting the destination buffer by getting the beginning of the
    // string and converting it into a char *.
    const int len = Base32Unescape(src, slen, string_as_array(dest), dest->size());
    if (len < 0) {
        dest->clear();
        return false;
    }

    // Could be shorter if there was padding.
    DCHECK_LE(len, dest_len);
    dest->resize(len);

    return true;
}

void GeneralFiveBytesToEightBase32Digits(const unsigned char* in_bytes, char* out,
                                         const char* alphabet) {
    // It's easier to just hard code this.
    // The conversion isbased on the following picture of the division of a
    // 40-bit block into 8 5-byte words:
    //
    //       5   3  2  5  1  4   4 1  5  2  3   5
    //     |:::::::|:::::::|:::::::|:::::::|:::::::
    //     +----+----+----+----+----+----+----+----
    //
    out[0] = alphabet[in_bytes[0] >> 3];
    out[1] = alphabet[(in_bytes[0] & 0x07) << 2 | in_bytes[1] >> 6];
    out[2] = alphabet[(in_bytes[1] & 0x3E) >> 1];
    out[3] = alphabet[(in_bytes[1] & 0x01) << 4 | in_bytes[2] >> 4];
    out[4] = alphabet[(in_bytes[2] & 0x0F) << 1 | in_bytes[3] >> 7];
    out[5] = alphabet[(in_bytes[3] & 0x7C) >> 2];
    out[6] = alphabet[(in_bytes[3] & 0x03) << 3 | in_bytes[4] >> 5];
    out[7] = alphabet[(in_bytes[4] & 0x1F)];
}

static int GeneralBase32Escape(const unsigned char* src, size_t szsrc, char* dest, size_t szdest,
                               const char* alphabet) {
    static const char kPad32 = '=';

    if (szsrc == 0) return 0;

    char* cur_dest = dest;
    const unsigned char* cur_src = src;

    // Five bytes of data encodes to eight characters of cyphertext.
    // So we can pump through three-byte chunks atomically.
    while (szsrc > 4) { // keep going until we have less than 40 bits
        if (szdest < 8) return 0;
        szdest -= 8;

        GeneralFiveBytesToEightBase32Digits(cur_src, cur_dest, alphabet);

        cur_dest += 8;
        cur_src += 5;
        szsrc -= 5;
    }

    // Now deal with the tail (<=4 bytes).
    if (szsrc > 0) {
        if (szdest < 8) return 0;
        szdest -= 8;
        unsigned char last_chunk[5];
        memcpy(last_chunk, cur_src, szsrc);

        for (size_t i = szsrc; i < 5; ++i) {
            last_chunk[i] = '\0';
        }

        GeneralFiveBytesToEightBase32Digits(last_chunk, cur_dest, alphabet);
        int filled = (szsrc * 8) / 5 + 1;
        cur_dest += filled;

        // Add on the padding.
        for (int i = 0; i < (8 - filled); ++i) {
            *(cur_dest++) = kPad32;
        }
    }

    return cur_dest - dest;
}

static bool GeneralBase32Escape(const string& src, string* dest, const char* alphabet) {
    const int max_escaped_size = CalculateBase32EscapedLen(src.length());
    dest->clear();
    dest->resize(max_escaped_size + 1, '\0');
    const int escaped_len =
            GeneralBase32Escape(reinterpret_cast<const unsigned char*>(src.c_str()), src.length(),
                                &*dest->begin(), dest->size(), alphabet);

    DCHECK_LE(max_escaped_size, escaped_len);

    if (escaped_len < 0) {
        dest->clear();
        return false;
    }

    dest->resize(escaped_len);
    return true;
}

static const char Base32Alphabet[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
                                      'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
                                      'W', 'X', 'Y', 'Z', '2', '3', '4', '5', '6', '7'};

int Base32Escape(const unsigned char* src, size_t szsrc, char* dest, size_t szdest) {
    return GeneralBase32Escape(src, szsrc, dest, szdest, Base32Alphabet);
}

bool Base32Escape(const string& src, string* dest) {
    return GeneralBase32Escape(src, dest, Base32Alphabet);
}

void FiveBytesToEightBase32Digits(const unsigned char* in_bytes, char* out) {
    GeneralFiveBytesToEightBase32Digits(in_bytes, out, Base32Alphabet);
}

static const char Base32HexAlphabet[] = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
        'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
};

int Base32HexEscape(const unsigned char* src, size_t szsrc, char* dest, size_t szdest) {
    return GeneralBase32Escape(src, szsrc, dest, szdest, Base32HexAlphabet);
}

bool Base32HexEscape(const string& src, string* dest) {
    return GeneralBase32Escape(src, dest, Base32HexAlphabet);
}

int CalculateBase32EscapedLen(size_t input_len) {
    DCHECK_LE(input_len, numeric_limits<size_t>::max() / 8);
    size_t intermediate_result = 8 * input_len + 4;
    size_t len = intermediate_result / 5;
    len = (len + 7) & ~7;
    return len;
}

// ----------------------------------------------------------------------
// EightBase32DigitsToTenHexDigits()
//   Converts an 8-digit base32 string to a 10-digit hex string.
//
//   *in must point to 8 base32 digits.
//   *out must point to 10 bytes.
//
//   Base32 uses A-Z,2-7 to represent the numbers 0-31.
//   See RFC3548 at http://www.ietf.org/rfc/rfc3548.txt
//   for details on base32.
// ----------------------------------------------------------------------

void EightBase32DigitsToTenHexDigits(const char* in, char* out) {
    unsigned char bytes[5];
    EightBase32DigitsToFiveBytes(in, bytes);
    b2a_hex(bytes, out, 5);
}

void EightBase32DigitsToFiveBytes(const char* in, unsigned char* bytes_out) {
    static const char Base32InverseAlphabet[] = {
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       26 /*2*/, 27 /*3*/, 28 /*4*/, 29 /*5*/, 30 /*6*/, 31 /*7*/,
            99,       99,       99,       99,       99,       00 /*=*/, 99,       99,
            99,       0 /*A*/,  1 /*B*/,  2 /*C*/,  3 /*D*/,  4 /*E*/,  5 /*F*/,  6 /*G*/,
            7 /*H*/,  8 /*I*/,  9 /*J*/,  10 /*K*/, 11 /*L*/, 12 /*M*/, 13 /*N*/, 14 /*O*/,
            15 /*P*/, 16 /*Q*/, 17 /*R*/, 18 /*S*/, 19 /*T*/, 20 /*U*/, 21 /*V*/, 22 /*W*/,
            23 /*X*/, 24 /*Y*/, 25 /*Z*/, 99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99,
            99,       99,       99,       99,       99,       99,       99,       99};

    // Convert to raw bytes. It's easier to just hard code this.
    bytes_out[0] = Base32InverseAlphabet[in[0]] << 3 | Base32InverseAlphabet[in[1]] >> 2;

    bytes_out[1] = Base32InverseAlphabet[in[1]] << 6 | Base32InverseAlphabet[in[2]] << 1 |
                   Base32InverseAlphabet[in[3]] >> 4;

    bytes_out[2] = Base32InverseAlphabet[in[3]] << 4 | Base32InverseAlphabet[in[4]] >> 1;

    bytes_out[3] = Base32InverseAlphabet[in[4]] << 7 | Base32InverseAlphabet[in[5]] << 2 |
                   Base32InverseAlphabet[in[6]] >> 3;

    bytes_out[4] = Base32InverseAlphabet[in[6]] << 5 | Base32InverseAlphabet[in[7]];
}

// ----------------------------------------------------------------------
// TenHexDigitsToEightBase32Digits()
//   Converts a 10-digit hex string to an 8-digit base32 string.
//
//   *in must point to 10 hex digits.
//   *out must point to 8 bytes.
//
//   See RFC3548 at http://www.ietf.org/rfc/rfc3548.txt
//   for details on base32.
// ----------------------------------------------------------------------
void TenHexDigitsToEightBase32Digits(const char* in, char* out) {
    unsigned char bytes[5];

    // Convert hex to raw bytes.
    a2b_hex(in, bytes, 5);
    FiveBytesToEightBase32Digits(bytes, out);
}

// ----------------------------------------------------------------------
// EscapeFileName / UnescapeFileName
// ----------------------------------------------------------------------
static const Charmap escape_file_name_exceptions(
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" // letters
        "0123456789"                                           // digits
        "-_.");

void EscapeFileName(const StringPiece& src, string* dst) {
    // Reserve at least src.size() chars
    dst->reserve(dst->size() + src.size());

    for (char c : src) {
        // We do not use "isalpha" because we want the behavior to be
        // independent of the current locale settings.
        if (escape_file_name_exceptions.contains(c)) {
            dst->push_back(c);

        } else if (c == '/') {
            dst->push_back('~');

        } else {
            char tmp[2];
            b2a_hex(reinterpret_cast<const unsigned char*>(&c), tmp, 1);
            dst->push_back('%');
            dst->append(tmp, 2);
        }
    }
}

void UnescapeFileName(const StringPiece& src_piece, string* dst) {
    const char* src = src_piece.data();
    const int len = src_piece.size();
    for (int i = 0; i < len; ++i) {
        const char c = src[i];
        if (c == '~') {
            dst->push_back('/');

        } else if ((c == '%') && (i + 2 < len)) {
            unsigned char tmp[1];
            a2b_hex(src + i + 1, &tmp[0], 1);
            dst->push_back(tmp[0]);
            i += 2;

        } else {
            dst->push_back(c);
        }
    }
}

static char hex_value[256] = {
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,
        0, 1,  2,  3,  4,  5,  6,  7, 8, 9, 0, 0, 0, 0, 0, 0, // '0'..'9'
        0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'A'..'F'
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15, 0,
        0, 0,  0,  0,  0,  0,  0,  0, // 'a'..'f'
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0,
        0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,  0};

static char hex_char[] = "0123456789abcdef";

// This is a templated function so that T can be either a char*
// or a string.  This works because we use the [] operator to access
// individual characters at a time.
template <typename T>
void a2b_hex_t(const char* a, T b, int num) {
    for (int i = 0; i < num; i++) {
        b[i] = (hex_value[a[i * 2] & 0xFF] << 4) + (hex_value[a[i * 2 + 1] & 0xFF]);
    }
}

string a2b_bin(const string& a, bool byte_order_msb) {
    string result;
    const char* data = a.c_str();
    int num_bytes = (a.size() + 7) / 8;
    for (int byte_offset = 0; byte_offset < num_bytes; ++byte_offset) {
        unsigned char c = 0;
        for (int bit_offset = 0; bit_offset < 8; ++bit_offset) {
            if (*data == '\0') break;
            if (*data++ != '0') {
                int bits_to_shift = (byte_order_msb) ? 7 - bit_offset : bit_offset;
                c |= (1 << bits_to_shift);
            }
        }
        result.append(1, c);
    }
    return result;
}

// This is a templated function so that T can be either a char*
// or a string.  This works because we use the [] operator to access
// individual characters at a time.
template <typename T>
void b2a_hex_t(const unsigned char* b, T a, int num) {
    for (int i = 0; i < num; i++) {
        a[i * 2 + 0] = hex_char[b[i] >> 4];
        a[i * 2 + 1] = hex_char[b[i] & 0xf];
    }
}

string b2a_bin(const string& b, bool byte_order_msb) {
    string result;
    for (char c : b) {
        for (int bit_offset = 0; bit_offset < 8; ++bit_offset) {
            int x = (byte_order_msb) ? 7 - bit_offset : bit_offset;
            result.append(1, (c & (1 << x)) ? '1' : '0');
        }
    }
    return result;
}

void b2a_hex(const unsigned char* b, char* a, int num) {
    b2a_hex_t<char*>(b, a, num);
}

void a2b_hex(const char* a, unsigned char* b, int num) {
    a2b_hex_t<unsigned char*>(a, b, num);
}

void a2b_hex(const char* a, char* b, int num) {
    a2b_hex_t<char*>(a, b, num);
}

string b2a_hex(const char* b, int len) {
    string result;
    result.resize(len << 1);
    b2a_hex_t<string&>(reinterpret_cast<const unsigned char*>(b), result, len);
    return result;
}

string b2a_hex(const StringPiece& b) {
    return b2a_hex(b.data(), b.size());
}

string a2b_hex(const string& a) {
    string result;
    a2b_hex(a.c_str(), &result, a.size() / 2);

    return result;
}

void b2a_hex(const unsigned char* from, string* to, int num) {
    to->resize(num << 1);
    b2a_hex_t<string&>(from, *to, num);
}

void a2b_hex(const char* from, string* to, int num) {
    to->resize(num);
    a2b_hex_t<string&>(from, *to, num);
}

const char* kDontNeedShellEscapeChars =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.=/:,@";

string ShellEscape(StringPiece src) {
    if (!src.empty() && // empty string needs quotes
        src.find_first_not_of(kDontNeedShellEscapeChars) == StringPiece::npos) {
        // only contains chars that don't need quotes; it's fine
        return src.ToString();
    } else if (src.find('\'') == StringPiece::npos) {
        // no single quotes; just wrap it in single quotes
        return StrCat("'", src, "'");
    } else {
        // needs double quote escaping
        string result = "\"";
        for (char c : src) {
            switch (c) {
            case '\\':
            case '$':
            case '"':
            case '`':
                result.push_back('\\');
            };
            result.push_back(c);
        }
        result.push_back('"');
        return result;
    }
}

static const char kHexTable[513] =
        "000102030405060708090a0b0c0d0e0f"
        "101112131415161718191a1b1c1d1e1f"
        "202122232425262728292a2b2c2d2e2f"
        "303132333435363738393a3b3c3d3e3f"
        "404142434445464748494a4b4c4d4e4f"
        "505152535455565758595a5b5c5d5e5f"
        "606162636465666768696a6b6c6d6e6f"
        "707172737475767778797a7b7c7d7e7f"
        "808182838485868788898a8b8c8d8e8f"
        "909192939495969798999a9b9c9d9e9f"
        "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
        "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
        "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
        "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
        "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
        "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";

//------------------------------------------------------------------------
// ByteStringToAscii
//  Reads at most bytes_to_read from binary_string and prints it to
//  ascii_string in downcased hex.
//------------------------------------------------------------------------
void ByteStringToAscii(string const& binary_string, int bytes_to_read, string* ascii_string) {
    if (binary_string.size() < bytes_to_read) {
        bytes_to_read = binary_string.size();
    }

    CHECK_GE(bytes_to_read, 0);
    ascii_string->resize(bytes_to_read * 2);

    string::const_iterator in = binary_string.begin();
    string::iterator out = ascii_string->begin();

    for (int i = 0; i < bytes_to_read; i++) {
        *out++ = kHexTable[(*in) * 2];
        *out++ = kHexTable[(*in) * 2 + 1];
        ++in;
    }
}

//------------------------------------------------------------------------
// ByteStringFromAscii
//  Converts the hex from ascii_string into binary data and
//  writes the binary data into binary_string.
//  Empty input successfully converts to empty output.
//  Returns false and may modify output if it is
//  unable to parse the hex string.
//------------------------------------------------------------------------
bool ByteStringFromAscii(string const& hex_string, string* binary_string) {
    binary_string->clear();

    if ((hex_string.size() % 2) != 0) {
        return false;
    }

    int value = 0;
    for (int i = 0; i < hex_string.size(); i++) {
        char c = hex_string[i];

        if (!ascii_isxdigit(c)) {
            return false;
        }

        if (ascii_isdigit(c)) {
            value += c - '0';
        } else if (ascii_islower(c)) {
            value += 10 + c - 'a';
        } else {
            value += 10 + c - 'A';
        }

        if (i & 1) {
            binary_string->push_back(value);
            value = 0;
        } else {
            value <<= 4;
        }
    }

    return true;
}

// ----------------------------------------------------------------------
// CleanStringLineEndings()
//   Clean up a multi-line string to conform to Unix line endings.
//   Reads from src and appends to dst, so usually dst should be empty.
//
//   If there is no line ending at the end of a non-empty string, it can
//   be added automatically.
//
//   Four different types of input are correctly handled:
//
//     - Unix/Linux files: line ending is LF, pass through unchanged
//
//     - DOS/Windows files: line ending is CRLF: convert to LF
//
//     - Legacy Mac files: line ending is CR: convert to LF
//
//     - Garbled files: random line endings, covert gracefully
//                      lonely CR, lonely LF, CRLF: convert to LF
//
//   @param src The multi-line string to convert
//   @param dst The converted string is appended to this string
//   @param auto_end_last_line Automatically terminate the last line
//
//   Limitations:
//
//     This does not do the right thing for CRCRLF files created by
//     broken programs that do another Unix->DOS conversion on files
//     that are already in CRLF format.  For this, a two-pass approach
//     brute-force would be needed that
//
//       (1) determines the presence of LF (first one is ok)
//       (2) if yes, removes any CR, else convert every CR to LF

void CleanStringLineEndings(const string& src, string* dst, bool auto_end_last_line) {
    if (dst->empty()) {
        dst->append(src);
        CleanStringLineEndings(dst, auto_end_last_line);
    } else {
        string tmp = src;
        CleanStringLineEndings(&tmp, auto_end_last_line);
        dst->append(tmp);
    }
}

void CleanStringLineEndings(string* str, bool auto_end_last_line) {
    int output_pos = 0;
    bool r_seen = false;
    int len = str->size();

    char* p = string_as_array(str);

    for (int input_pos = 0; input_pos < len;) {
        if (!r_seen && input_pos + 8 < len) {
            uint64 v = UNALIGNED_LOAD64(p + input_pos);
            // Loop over groups of 8 bytes at a time until we come across
            // a word that has a byte whose value is less than or equal to
            // '\r' (i.e. could contain a \n (0x0a) or a \r (0x0d) ).
            //
            // We use a has_less macro that quickly tests a whole 64-bit
            // word to see if any of the bytes has a value < N.
            //
            // For more details, see:
            //   http://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord
#define has_less(x, n) (((x) - ~0ULL / 255 * (n)) & ~(x) & ~0ULL / 255 * 128)
            if (!has_less(v, '\r' + 1)) {
#undef has_less
                // No byte in this word has a value that could be a \r or a \n
                if (output_pos != input_pos) UNALIGNED_STORE64(p + output_pos, v);
                input_pos += 8;
                output_pos += 8;
                continue;
            }
        }
        string::const_reference in = p[input_pos];
        if (in == '\r') {
            if (r_seen) p[output_pos++] = '\n';
            r_seen = true;
        } else if (in == '\n') {
            if (input_pos != output_pos)
                p[output_pos++] = '\n';
            else
                output_pos++;
            r_seen = false;
        } else {
            if (r_seen) p[output_pos++] = '\n';
            r_seen = false;
            if (input_pos != output_pos)
                p[output_pos++] = in;
            else
                output_pos++;
        }
        input_pos++;
    }
    if (r_seen || (auto_end_last_line && output_pos > 0 && p[output_pos - 1] != '\n')) {
        str->resize(output_pos + 1);
        str->operator[](output_pos) = '\n';
    } else if (output_pos < len) {
        str->resize(output_pos);
    }
}

} // namespace strings

Coverage Report

Created: 2024-11-21 14:46