// Copyright Contributors to the Pystring project.

// SPDX-License-Identifier: BSD-3-Clause

// https://github.com/imageworks/pystring/blob/master/LICENSE

#include <algorithm>

#include <cctype>

#include <cstring>

#include <iostream>

#include <sstream>

namespace pystring

{

#if defined(_WIN32) || defined(_WIN64) || defined(_WINDOWS) || defined(_MSC_VER)

#ifndef WINDOWS

#define WINDOWS

#endif

#endif

// This definition codes from configure.in in the python src.

// Strictly speaking this limits us to str sizes of 2**31.

// Should we wish to handle this limit, we could use an architecture

// specific #defines and read from ssize_t (unistd.h) if the header exists.

// But in the meantime, the use of int assures maximum arch compatibility.

// This must also equal the size used in the end = MAX_32BIT_INT default arg.

typedef int Py_ssize_t;

const std::string forward_slash = "/";

const std::string double_forward_slash = "//";

const std::string triple_forward_slash = "///";

const std::string double_back_slash = "\\";

const std::string empty_string = "";

const std::string dot = ".";

const std::string double_dot = "..";

const std::string colon = ":";

/* helper macro to fixup start/end slice values */

#define PYSTRING_ADJUST_INDICES(start, end, len) \

if (end > len) \

end = len; \

else if (end < 0) { \

end += len; \

if (end < 0) \

end = 0; \

} \

if (start < 0) { \

start += len; \

if (start < 0) \

start = 0; \

}

namespace {

//////////////////////////////////////////////////////////////////////////////////////////////

/// why doesn't the std::reverse work?

///

void reverse_strings( std::vector< std::string > & result)

{

for (std::vector< std::string >::size_type i = 0; i < result.size() / 2; i++ )

{

std::swap(result[i], result[result.size() - 1 - i]);

}

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

void split_whitespace( const std::string & str, std::vector< std::string > & result, int maxsplit )

{

std::string::size_type i, j, len = str.size();

for (i = j = 0; i < len; )

{

while ( i < len && ::isspace( str[i] ) ) i++;

j = i;

while ( i < len && ! ::isspace( str[i]) ) i++;

if (j < i)

{

if ( maxsplit-- <= 0 ) break;

result.push_back( str.substr( j, i - j ));

while ( i < len && ::isspace( str[i])) i++;

j = i;

}

}

if (j < len)

{

result.push_back( str.substr( j, len - j ));

}

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

void rsplit_whitespace( const std::string & str, std::vector< std::string > & result, int maxsplit )

{

std::string::size_type len = str.size();

std::string::size_type i, j;

for (i = j = len; i > 0; )

{

while ( i > 0 && ::isspace( str[i - 1] ) ) i--;

j = i;

while ( i > 0 && ! ::isspace( str[i - 1]) ) i--;

if (j > i)

{

if ( maxsplit-- <= 0 ) break;

result.push_back( str.substr( i, j - i ));

while ( i > 0 && ::isspace( str[i - 1])) i--;

j = i;

}

}

if (j > 0)

{

result.push_back( str.substr( 0, j ));

}

//std::reverse( result, result.begin(), result.end() );

reverse_strings( result );

}

} //anonymous namespace

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

void split( const std::string & str, std::vector< std::string > & result, const std::string & sep, int maxsplit )

{

result.clear();

if ( maxsplit < 0 ) maxsplit = MAX_32BIT_INT;//result.max_size();

if ( sep.size() == 0 )

{

split_whitespace( str, result, maxsplit );

return;

}

std::string::size_type i,j, len = str.size(), n = sep.size();

i = j = 0;

while ( i+n <= len )

{

if ( str[i] == sep[0] && str.substr( i, n ) == sep )

{

if ( maxsplit-- <= 0 ) break;

result.push_back( str.substr( j, i - j ) );

i = j = i + n;

}

else

{

i++;

}

}

result.push_back( str.substr( j, len-j ) );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

void rsplit( const std::string & str, std::vector< std::string > & result, const std::string & sep, int maxsplit )

{

if ( maxsplit < 0 )

{

split( str, result, sep, maxsplit );

return;

}

result.clear();

if ( sep.size() == 0 )

{

rsplit_whitespace( str, result, maxsplit );

return;

}

Py_ssize_t i,j, len = (Py_ssize_t) str.size(), n = (Py_ssize_t) sep.size();

i = j = len;

while ( i >= n )

{

if ( str[i - 1] == sep[n - 1] && str.substr( i - n, n ) == sep )

{

if ( maxsplit-- <= 0 ) break;

result.push_back( str.substr( i, j - i ) );

i = j = i - n;

}

else

{

i--;

}

}

result.push_back( str.substr( 0, j ) );

reverse_strings( result );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

#define PYSTRING_LEFTSTRIP 0

#define PYSTRING_RIGHTSTRIP 1

#define PYSTRING_BOTHSTRIP 2

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string do_strip( const std::string & str, int striptype, const std::string & chars )

{

Py_ssize_t len = (Py_ssize_t) str.size(), i, j, charslen = (Py_ssize_t) chars.size();

if ( charslen == 0 )

{

i = 0;

if ( striptype != PYSTRING_RIGHTSTRIP )

{

while ( i < len && ::isspace( str[i] ) )

{

i++;

}

}

j = len;

if ( striptype != PYSTRING_LEFTSTRIP )

{

do

{

j--;

}

while (j >= i && ::isspace(str[j]));

j++;

}

}

else

{

const char * sep = chars.c_str();

i = 0;

if ( striptype != PYSTRING_RIGHTSTRIP )

{

while ( i < len && memchr(sep, str[i], charslen) )

{

i++;

}

}

j = len;

if (striptype != PYSTRING_LEFTSTRIP)

{

do

{

j--;

}

while (j >= i && memchr(sep, str[j], charslen) );

j++;

}

}

if ( i == 0 && j == len )

{

return str;

}

else

{

return str.substr( i, j - i );

}

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

void partition( const std::string & str, const std::string & sep, std::vector< std::string > & result )

{

result.resize(3);

int index = find( str, sep );

if ( index < 0 )

{

result[0] = str;

result[1] = empty_string;

result[2] = empty_string;

}

else

{

result[0] = str.substr( 0, index );

result[1] = sep;

result[2] = str.substr( index + sep.size(), str.size() );

}

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

void rpartition( const std::string & str, const std::string & sep, std::vector< std::string > & result )

{

result.resize(3);

int index = rfind( str, sep );

if ( index < 0 )

{

result[0] = empty_string;

result[1] = empty_string;

result[2] = str;

}

else

{

result[0] = str.substr( 0, index );

result[1] = sep;

result[2] = str.substr( index + sep.size(), str.size() );

}

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string strip( const std::string & str, const std::string & chars )

{

return do_strip( str, PYSTRING_BOTHSTRIP, chars );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string lstrip( const std::string & str, const std::string & chars )

{

return do_strip( str, PYSTRING_LEFTSTRIP, chars );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string rstrip( const std::string & str, const std::string & chars )

{

return do_strip( str, PYSTRING_RIGHTSTRIP, chars );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string join( const std::string & str, const std::vector< std::string > & seq )

{

std::vector< std::string >::size_type seqlen = seq.size(), i;

if ( seqlen == 0 ) return empty_string;

if ( seqlen == 1 ) return seq[0];

std::string result( seq[0] );

for ( i = 1; i < seqlen; ++i )

{

result += str + seq[i];

}

return result;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

namespace

{

/* Matches the end (direction >= 0) or start (direction < 0) of self

* against substr, using the start and end arguments. Returns

* -1 on error, 0 if not found and 1 if found.

*/

int _string_tailmatch(const std::string & self, const std::string & substr,

Py_ssize_t start, Py_ssize_t end,

int direction)

{

Py_ssize_t len = (Py_ssize_t) self.size();

Py_ssize_t slen = (Py_ssize_t) substr.size();

const char* sub = substr.c_str();

const char* str = self.c_str();

PYSTRING_ADJUST_INDICES(start, end, len);

if (direction < 0) {

// startswith

if (start+slen > len)

return 0;

} else {

// endswith

if (end-start < slen || start > len)

return 0;

if (end-slen > start)

start = end - slen;

}

if (end-start >= slen)

return (!std::memcmp(str+start, sub, slen));

return 0;

}

}

bool endswith( const std::string & str, const std::string & suffix, int start, int end )

{

int result = _string_tailmatch(str, suffix,

(Py_ssize_t) start, (Py_ssize_t) end, +1);

//if (result == -1) // TODO: Error condition

return static_cast<bool>(result);

}

bool startswith( const std::string & str, const std::string & prefix, int start, int end )

{

int result = _string_tailmatch(str, prefix,

(Py_ssize_t) start, (Py_ssize_t) end, -1);

//if (result == -1) // TODO: Error condition

return static_cast<bool>(result);

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

bool isalnum( const std::string & str )

{

std::string::size_type len = str.size(), i;

if ( len == 0 ) return false;

if( len == 1 )

{

return ::isalnum( str[0] );

}

for ( i = 0; i < len; ++i )

{

if ( !::isalnum( str[i] ) ) return false;

}

return true;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

bool isalpha( const std::string & str )

{

std::string::size_type len = str.size(), i;

if ( len == 0 ) return false;

if( len == 1 ) return ::isalpha( (int) str[0] );

for ( i = 0; i < len; ++i )

{

if ( !::isalpha( (int) str[i] ) ) return false;

}

return true;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

bool isdigit( const std::string & str )

{

std::string::size_type len = str.size(), i;

if ( len == 0 ) return false;

if( len == 1 ) return ::isdigit( str[0] );

for ( i = 0; i < len; ++i )

{

if ( ! ::isdigit( str[i] ) ) return false;

}

return true;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

bool islower( const std::string & str )

{

std::string::size_type len = str.size(), i;

if ( len == 0 ) return false;

if( len == 1 ) return ::islower( str[0] );

// python's islower is a lot more leniant than c++

// this will match the python behavior so that something like

// islower("hello123") is true

bool has_cased = false;

for (i = 0; i < len; ++i) {

if (::islower(str[i]))

has_cased = true;

else if (::isupper(str[i]))

return false;

}

return has_cased;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

bool isspace( const std::string & str )

{

std::string::size_type len = str.size(), i;

if ( len == 0 ) return false;

if( len == 1 ) return ::isspace( str[0] );

for ( i = 0; i < len; ++i )

{

if ( !::isspace( str[i] ) ) return false;

}

return true;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

bool istitle( const std::string & str )

{

std::string::size_type len = str.size(), i;

if ( len == 0 ) return false;

if ( len == 1 ) return ::isupper( str[0] );

bool cased = false, previous_is_cased = false;

for ( i = 0; i < len; ++i )

{

if ( ::isupper( str[i] ) )

{

if ( previous_is_cased )

{

return false;

}

previous_is_cased = true;

cased = true;

}

else if ( ::islower( str[i] ) )

{

if (!previous_is_cased)

{

return false;

}

previous_is_cased = true;

cased = true;

}

else

{

previous_is_cased = false;

}

}

return cased;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

bool isupper( const std::string & str )

{

std::string::size_type len = str.size(), i;

if ( len == 0 ) return false;

if( len == 1 ) return ::isupper( str[0] );

// python's isupper is a lot more leniant than c++

// this will match the python behavior so that something like

// isupper("HELLO123") is true

bool has_cased = false;

for (std::string::size_type i = 0; i < str.size(); ++i) {

if (::isupper(str[i]))

has_cased = true;

else if (::islower(str[i]))

return false;

}

return has_cased;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string capitalize( const std::string & str )

{

std::string s( str );

std::string::size_type len = s.size(), i;

if ( len > 0)

{

if (::islower(s[0])) s[0] = (char) ::toupper( s[0] );

}

for ( i = 1; i < len; ++i )

{

if (::isupper(s[i])) s[i] = (char) ::tolower( s[i] );

}

return s;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string lower( const std::string & str )

{

std::string s( str );

std::string::size_type len = s.size(), i;

for ( i = 0; i < len; ++i )

{

if ( ::isupper( s[i] ) ) s[i] = (char) ::tolower( s[i] );

}

return s;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string upper( const std::string & str )

{

std::string s( str ) ;

std::string::size_type len = s.size(), i;

for ( i = 0; i < len; ++i )

{

if ( ::islower( s[i] ) ) s[i] = (char) ::toupper( s[i] );

}

return s;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string swapcase( const std::string & str )

{

std::string s( str );

std::string::size_type len = s.size(), i;

for ( i = 0; i < len; ++i )

{

if ( ::islower( s[i] ) ) s[i] = (char) ::toupper( s[i] );

else if (::isupper( s[i] ) ) s[i] = (char) ::tolower( s[i] );

}

return s;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string title( const std::string & str )

{

std::string s( str );

std::string::size_type len = s.size(), i;

bool previous_is_cased = false;

for ( i = 0; i < len; ++i )

{

int c = s[i];

if ( ::islower(c) )

{

if ( !previous_is_cased )

{

s[i] = (char) ::toupper(c);

}

previous_is_cased = true;

}

else if ( ::isupper(c) )

{

if ( previous_is_cased )

{

s[i] = (char) ::tolower(c);

}

previous_is_cased = true;

}

else

{

previous_is_cased = false;

}

}

return s;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string translate( const std::string & str, const std::string & table, const std::string & deletechars )

{

std::string s;

std::string::size_type len = str.size(), dellen = deletechars.size();

if ( table.size() != 256 )

{

// TODO : raise exception instead

return str;

}

//if nothing is deleted, use faster code

if ( dellen == 0 )

{

s = str;

for ( std::string::size_type i = 0; i < len; ++i )

{

s[i] = table[ s[i] ];

}

return s;

}

int trans_table[256];

for ( int i = 0; i < 256; i++)

{

trans_table[i] = table[i];

}

for ( std::string::size_type i = 0; i < dellen; i++)

{

trans_table[(int) deletechars[i] ] = -1;

}

for ( std::string::size_type i = 0; i < len; ++i )

{

if ( trans_table[ (int) str[i] ] != -1 )

{

s += table[ str[i] ];

}

}

return s;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string zfill( const std::string & str, int width )

{

int len = (int)str.size();

if ( len >= width )

{

return str;

}

std::string s( str );

int fill = width - len;

s = std::string( fill, '0' ) + s;

if ( s[fill] == '+' || s[fill] == '-' )

{

s[0] = s[fill];

s[fill] = '0';

}

return s;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string ljust( const std::string & str, int width )

{

std::string::size_type len = str.size();

if ( (( int ) len ) >= width ) return str;

return str + std::string( width - len, ' ' );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string rjust( const std::string & str, int width )

{

std::string::size_type len = str.size();

if ( (( int ) len ) >= width ) return str;

return std::string( width - len, ' ' ) + str;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string center( const std::string & str, int width )

{

int len = (int) str.size();

int marg, left;

if ( len >= width ) return str;

marg = width - len;

left = marg / 2 + (marg & width & 1);

return std::string( left, ' ' ) + str + std::string( marg - left, ' ' );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string slice( const std::string & str, int start, int end )

{

PYSTRING_ADJUST_INDICES(start, end, (int) str.size());

if ( start >= end ) return empty_string;

return str.substr( start, end - start );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

int find( const std::string & str, const std::string & sub, int start, int end )

{

PYSTRING_ADJUST_INDICES(start, end, (int) str.size());

std::string::size_type result = str.find( sub, start );

// If we cannot find the string, or if the end-point of our found substring is past

// the allowed end limit, return that it can't be found.

if( result == std::string::npos ||

(result + sub.size() > (std::string::size_type)end) )

{

return -1;

}

return (int) result;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

int index( const std::string & str, const std::string & sub, int start, int end )

{

return find( str, sub, start, end );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

int rfind( const std::string & str, const std::string & sub, int start, int end )

{

PYSTRING_ADJUST_INDICES(start, end, (int) str.size());

std::string::size_type result = str.rfind( sub, end );

if( result == std::string::npos ||

result < (std::string::size_type)start ||

(result + sub.size() > (std::string::size_type)end))

return -1;

return (int)result;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

int rindex( const std::string & str, const std::string & sub, int start, int end )

{

return rfind( str, sub, start, end );

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string expandtabs( const std::string & str, int tabsize )

{

std::string s( str );

std::string::size_type len = str.size(), i = 0;

int offset = 0;

int j = 0;

for ( i = 0; i < len; ++i )

{

if ( str[i] == '\t' )

{

if ( tabsize > 0 )

{

int fillsize = tabsize - (j % tabsize);

j += fillsize;

s.replace( i + offset, 1, std::string( fillsize, ' ' ));

offset += fillsize - 1;

}

else

{

s.replace( i + offset, 1, empty_string );

offset -= 1;

}

}

else

{

j++;

if (str[i] == '\n' || str[i] == '\r')

{

j = 0;

}

}

}

return s;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

int count( const std::string & str, const std::string & substr, int start, int end )

{

int nummatches = 0;

int cursor = start;

// special handling for an empty substring

// this will match python's behavior of

// "bob".count("") == 4

// "".count("") == 1

if ( substr.empty() )

{

PYSTRING_ADJUST_INDICES(start, end, (int)str.size());

return end - start + 1;

}

while ( 1 )

{

cursor = find( str, substr, cursor, end );

if ( cursor < 0 ) break;

cursor += (int) substr.size();

nummatches += 1;

}

return nummatches;

}

//////////////////////////////////////////////////////////////////////////////////////////////

///

///

std::string replace( const std::string & str, const std::string & oldstr, const std::string & newstr, int count )

{

int sofar = 0;

int cursor = 0;

std::string s( str );

std::string::size_type oldlen = oldstr.size(), newlen = newstr.size();

cursor = find( s, oldstr, cursor );

while ( cursor != -1 && cursor <= (int)s.size() )

{

if ( count > -1 && sofar >= count )

{

break;

}

s.replace( cursor, oldlen, newstr );

cursor += (int) newlen;

if ( oldlen != 0)

{

cursor = find( s, oldstr, cursor );

}

else

{

++cursor;

}