godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d8223ffa75
godot/core/ustring.cpp
Rémi Verschelde d8223ffa75 Welcome in 2017, dear changelog reader! 
That year should bring the long-awaited OpenGL ES 3.0 compatible renderer
with state-of-the-art rendering techniques tuned to work as low as middle
end handheld devices - without compromising with the possibilities given
for higher end desktop games of course. Great times ahead for the Godot
community and the gamers that will play our games!

(cherry picked from commit c7bc44d5ad)
2017-01-12 19:15:30 +01:00

4165 lines
74 KiB
C++
Raw Blame History

/*************************************************************************/
/* ustring.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include <wchar.h>
#include "ustring.h"
#include "os/memory.h"
#include "print_string.h"
#include "math_funcs.h"
#include "io/md5.h"
#include "io/sha256.h"
#include "ucaps.h"
#include "color.h"
#include "variant.h"
#define MAX_DIGITS 6
#define UPPERCASE(m_c) (((m_c)>='a' && (m_c)<='z')?((m_c)-('a'-'A')):(m_c))
#define LOWERCASE(m_c) (((m_c)>='A' && (m_c)<='Z')?((m_c)+('a'-'A')):(m_c))
#ifndef NO_USE_STDLIB
#include <stdlib.h>
#include <stdio.h>
#endif
#if defined(MINGW_ENABLED) || defined(_MSC_VER)
#define snprintf _snprintf
#endif
/** STRING **/
const char *CharString::get_data() const {
if (size())
return &operator[](0);
else
return "";
}
void String::copy_from(const char *p_cstr) {
int len=0;
const char *ptr=p_cstr;
while (*(ptr++)!=0)
len++;
if (len==0) {
resize(0);
return;
}
resize(len+1); // include 0
CharType *dst = this->ptr();
for (int i=0;i<len+1;i++) {
dst[i]=p_cstr[i];
}
}
void String::copy_from(const CharType* p_cstr, int p_clip_to) {
int len=0;
const CharType *ptr=p_cstr;
while (*(ptr++)!=0)
len++;
if (p_clip_to>=0 && len>p_clip_to)
len=p_clip_to;
if (len==0) {
resize(0);
return;
}
resize(len+1);
set(len,0);
CharType *dst = &operator[](0);
for (int i=0;i<len;i++) {
dst[i]=p_cstr[i];
}
}
void String::copy_from(const CharType& p_char) {
resize(2);
set(0,p_char);
set(1,0);
}
bool String::operator==(const String& p_str) const {
if (length()!=p_str.length())
return false;
if (empty())
return true;
int l=length();
const CharType *src = c_str();
const CharType *dst = p_str.c_str();
/* Compare char by char */
for (int i=0;i<l;i++) {
if (src[i]!=dst[i])
return false;
}
return true;
}
bool String::operator!=(const String& p_str) const {
return !(*this==p_str);
}
String String::operator+(const String& p_str) const {
String res=*this;
res+=p_str;
return res;
}
/*
String String::operator+(CharType p_chr) const {
String res=*this;
res+=p_chr;
return res;
}
*/
String& String::operator+=(const String &p_str) {
if (empty()) {
*this=p_str;
return *this;
}
if (p_str.empty())
return *this;
int from=length();
resize( length() + p_str.size() );
const CharType *src = p_str.c_str();
CharType *dst = &operator[](0);
set( length(), 0 );
for (int i=0;i<p_str.length();i++)
dst[from+i]=src[i];
return *this;
}
String& String::operator+=(const CharType *p_str) {
*this+=String(p_str);
return *this;
}
String& String::operator+=(CharType p_char) {
resize( size() ? size() + 1 : 2);
set( length(), 0 );
set( length() -1, p_char );
return *this;
}
String& String::operator+=(const char * p_str) {
if (!p_str || p_str[0]==0)
return *this;
int src_len=0;
const char *ptr=p_str;
while (*(ptr++)!=0)
src_len++;
int from=length();
resize( from + src_len + 1 );
CharType *dst = &operator[](0);
set( length(), 0 );
for (int i=0;i<src_len;i++)
dst[from+i]=p_str[i];
return *this;
}
void String::operator=(const char *p_str) {
copy_from(p_str);
}
void String::operator=(const CharType *p_str) {
copy_from(p_str);
}
bool String::operator==(const StrRange &p_range) const {
int len=p_range.len;
if (length()!=len)
return false;
if (empty())
return true;
const CharType *c_str=p_range.c_str;
const CharType *dst = &operator[](0);
/* Compare char by char */
for (int i=0;i<len;i++) {
if (c_str[i]!=dst[i])
return false;
}
return true;
}
bool String::operator==(const char *p_str) const {
int len=0;
const char *aux=p_str;
while (*(aux++)!=0)
len++;
if (length()!=len)
return false;
if (empty())
return true;
int l=length();
const CharType *dst = c_str();
/* Compare char by char */
for (int i=0;i<l;i++) {
if (p_str[i]!=dst[i])
return false;
}
return true;
}
bool String::operator==(const CharType *p_str) const {
int len=0;
const CharType *aux=p_str;
while (*(aux++)!=0)
len++;
if (length()!=len)
return false;
if (empty())
return true;
int l=length();
const CharType *dst = c_str();
/* Compare char by char */
for (int i=0;i<l;i++) {
if (p_str[i]!=dst[i])
return false;
}
return true;
}
bool String::operator!=(const char *p_str) const {
return (! ( *this==p_str ) );
}
bool String::operator!=(const CharType *p_str) const {
return (! ( *this==p_str ) );
}
bool String::operator<(const CharType *p_str) const {
if (empty() && p_str[0]==0)
return false;
if (empty())
return true;
const CharType *this_str=c_str();
while (true) {
if (*p_str==0 && *this_str==0)
return false; //this can't be equal, sadly
else if (*this_str==0)
return true; //if this is empty, and the other one is not, then we're less.. I think?
else if (*p_str==0)
return false; //otherwise the other one is smaller..
else if (*this_str < *p_str ) //more than
return true;
else if (*this_str > *p_str ) //less than
return false;
this_str++;
p_str++;
}
return false; //should never reach here anyway
}
bool String::operator<=(String p_str) const {
return (*this<p_str) || (*this==p_str);
}
bool String::operator<(const char *p_str) const {
if (empty() && p_str[0]==0)
return false;
if (empty())
return true;
const CharType *this_str=c_str();
while (true) {
if (*p_str==0 && *this_str==0)
return false; //this can't be equal, sadly
else if (*this_str==0)
return true; //if this is empty, and the other one is not, then we're less.. I think?
else if (*p_str==0)
return false; //otherwise the other one is smaller..
else if (*this_str < *p_str ) //more than
return true;
else if (*this_str > *p_str ) //less than
return false;
this_str++;
p_str++;
}
return false; //should never reach here anyway
}
bool String::operator<(String p_str) const {
return operator<(p_str.c_str());
}
signed char String::nocasecmp_to(const String &p_str) const {
if (empty() && p_str.empty())
return 0;
if (empty())
return -1;
if (p_str.empty())
return 1;
const CharType *that_str=p_str.c_str();
const CharType *this_str=c_str();
while (true) {
if (*that_str==0 && *this_str==0)
return 0; //we're equal
else if (*this_str==0)
return -1; //if this is empty, and the other one is not, then we're less.. I think?
else if (*that_str==0)
return 1; //otherwise the other one is smaller..
else if (_find_upper(*this_str) < _find_upper(*that_str) ) //more than
return -1;
else if (_find_upper(*this_str) > _find_upper(*that_str) ) //less than
return 1;
this_str++;
that_str++;
}
return 0; //should never reach anyway
}
signed char String::casecmp_to(const String &p_str) const {
if (empty() && p_str.empty())
return 0;
if (empty())
return -1;
if (p_str.empty())
return 1;
const CharType *that_str=p_str.c_str();
const CharType *this_str=c_str();
while (true) {
if (*that_str==0 && *this_str==0)
return 0; //we're equal
else if (*this_str==0)
return -1; //if this is empty, and the other one is not, then we're less.. I think?
else if (*that_str==0)
return 1; //otherwise the other one is smaller..
else if (*this_str < *that_str ) //more than
return -1;
else if (*this_str > *that_str ) //less than
return 1;
this_str++;
that_str++;
}
return 0; //should never reach anyway
}
void String::erase(int p_pos, int p_chars) {
*this=left(p_pos)+substr( p_pos + p_chars , length() - ( (p_pos+p_chars) ) );
}
String String::capitalize() const {
String aux=this->replace("_"," ").to_lower();
String cap;
for (int i=0;i<aux.get_slice_count(" ");i++) {
String slice=aux.get_slicec(' ',i);
if (slice.length()>0) {
slice[0]=_find_upper(slice[0]);
if (i>0)
cap+=" ";
cap+=slice;
}
}
return cap;
}
String String::camelcase_to_underscore(bool lowercase) const {
const CharType * cstr = c_str();
String new_string;
const char A = 'A', Z = 'Z';
const char a = 'a', z = 'z';
int start_index = 0;
for ( size_t i = 1; i < this->size(); i++ ) {
bool is_upper = cstr[i] >= A && cstr[i] <= Z;
bool are_next_2_lower = false;
bool was_precedent_upper = cstr[i-1] >= A && cstr[i-1] <= Z;
if (i+2 < this->size()) {
are_next_2_lower = cstr[i+1] >= a && cstr[i+1] <= z && cstr[i+2] >= a && cstr[i+2] <= z;
}
bool should_split = ((is_upper && !was_precedent_upper) || (was_precedent_upper && is_upper && are_next_2_lower));
if (should_split) {
new_string += this->substr(start_index, i - start_index) + "_";
start_index = i;
}
}
new_string += this->substr(start_index, this->size() - start_index);
return lowercase ? new_string.to_lower() : new_string;
}
int String::get_slice_count(String p_splitter) const{
if (empty())
return 0;
if (p_splitter.empty())
return 0;
int pos=0;
int slices=1;
while ( (pos=find(p_splitter,pos))>=0) {
slices++;
pos+=p_splitter.length();
}
return slices;
}
String String::get_slice(String p_splitter, int p_slice) const {
if (empty() || p_splitter.empty())
return "";
int pos=0;
int prev_pos=0;
// int slices=1;
if (p_slice<0)
return "";
if (find(p_splitter)==-1)
return *this;
int i=0;
while(true) {
pos=find(p_splitter,pos);
if (pos==-1)
pos=length(); //reached end
int from=prev_pos;
// int to=pos;
if (p_slice==i) {
return substr( from, pos-from );
}
if (pos==length()) //reached end and no find
break;
pos+=p_splitter.length();
prev_pos=pos;
i++;
}
return ""; //no find!
}
String String::get_slicec(CharType p_splitter, int p_slice) const {
if (empty())
return String();
if (p_slice<0)
return String();
const CharType *c=this->ptr();
int i=0;
int prev=0;
int count=0;
while(true) {
if (c[i]==0 || c[i]==p_splitter) {
if (p_slice==count) {
return substr(prev,i-prev);
} else {
count++;
prev=i+1;
}
}
i++;
}
return String(); //no find!
}
Vector<String> String::split_spaces() const {
Vector<String> ret;
int from=0;
int i=0;
int len = length();
bool inside=false;
while(true) {
bool empty=operator[](i)<33;
if (i==0)
inside=!empty;
if (!empty && !inside) {
inside=true;
from=i;
}
if (empty && inside) {
ret.push_back(substr(from,i-from));
inside=false;
}
if (i==len)
break;
i++;
}
return ret;
}
Vector<String> String::split(const String &p_splitter,bool p_allow_empty) const {
Vector<String> ret;
int from=0;
int len = length();
while(true) {
int end=find(p_splitter,from);
if (end<0)
end=len;
if (p_allow_empty || (end>from))
ret.push_back(substr(from,end-from));
if (end==len)
break;
from = end+p_splitter.length();
}
return ret;
}
Vector<float> String::split_floats(const String &p_splitter,bool p_allow_empty) const {
Vector<float> ret;
int from=0;
int len = length();
while(true) {
int end=find(p_splitter,from);
if (end<0)
end=len;
if (p_allow_empty || (end>from))
ret.push_back(String::to_double(&c_str()[from]));
if (end==len)
break;
from = end+p_splitter.length();
}
return ret;
}
Vector<float> String::split_floats_mk(const Vector<String> &p_splitters,bool p_allow_empty) const {
Vector<float> ret;
int from=0;
int len = length();
while(true) {
int idx;
int end=findmk(p_splitters,from,&idx);
int spl_len=1;
if (end<0) {
end=len;
} else {
spl_len=p_splitters[idx].length();
}
if (p_allow_empty || (end>from)) {
ret.push_back(String::to_double(&c_str()[from]));
}
if (end==len)
break;
from = end+spl_len;
}
return ret;
}
Vector<int> String::split_ints(const String &p_splitter,bool p_allow_empty) const {
Vector<int> ret;
int from=0;
int len = length();
while(true) {
int end=find(p_splitter,from);
if (end<0)
end=len;
if (p_allow_empty || (end>from))
ret.push_back(String::to_int(&c_str()[from],end-from));
if (end==len)
break;
from = end+p_splitter.length();
}
return ret;
}
Vector<int> String::split_ints_mk(const Vector<String> &p_splitters,bool p_allow_empty) const {
Vector<int> ret;
int from=0;
int len = length();
while(true) {
int idx;
int end=findmk(p_splitters,from,&idx);
int spl_len=1;
if (end<0) {
end=len;
} else {
spl_len=p_splitters[idx].length();
}
if (p_allow_empty || (end>from))
ret.push_back(String::to_int(&c_str()[from],end-from));
if (end==len)
break;
from = end+spl_len;
}
return ret;
}
CharType String::char_uppercase(CharType p_char) {
return _find_upper(p_char);
}
CharType String::char_lowercase(CharType p_char){
return _find_lower(p_char);
}
String String::to_upper() const {
String upper=*this;
for(int i=0;i<upper.size();i++) {
upper[i]=_find_upper(upper[i]);
}
return upper;
}
String String::to_lower() const {
String upper=*this;
for(int i=0;i<upper.size();i++) {
upper[i]=_find_lower(upper[i]);
}
return upper;
}
int String::length() const {
int s=size();
return s?(s-1):0; // length does not include zero
}
const CharType * String::c_str() const {
static const CharType zero=0;
return size()?&operator[](0):&zero;
}
String String::md5(const uint8_t *p_md5) {
return String::hex_encode_buffer(p_md5, 16);
}
String String::hex_encode_buffer(const uint8_t *p_buffer, int p_len) {
static const char hex[16]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
String ret;
char v[2]={0,0};
for(int i=0;i<p_len;i++) {
v[0]=hex[p_buffer[i]>>4];
ret+=v;
v[0]=hex[p_buffer[i]&0xF];
ret+=v;
}
return ret;
}
String String::chr(CharType p_char) {
CharType c[2]={p_char,0};
return String(c);
}
String String::num(double p_num,int p_decimals) {
#ifndef NO_USE_STDLIB
if (p_decimals>12)
p_decimals=12;
char fmt[7];
fmt[0]='%';
fmt[1]='.';
if (p_decimals<0) {
fmt[1]='l';
fmt[2]='f';
fmt[3]=0;
} else if(p_decimals<10) {
fmt[2]='0'+p_decimals;
fmt[3]='l';
fmt[4]='f';
fmt[5]=0;
} else {
fmt[2]='0'+(p_decimals/10);
fmt[3]='0'+(p_decimals%10);
fmt[4]='l';
fmt[5]='f';
fmt[6]=0;
}
char buf[256];
#if defined(__GNUC__) || defined(_MSC_VER)
snprintf(buf,256,fmt,p_num);
#else
sprintf(buf,fmt,p_num);
#endif
buf[255]=0;
//destroy trailing zeroes
{
bool period=false;
int z=0;
while(buf[z]) {
if (buf[z]=='.')
period=true;
z++;
}
if (period) {
z--;
while(z>0) {
if (buf[z]=='0') {
buf[z]=0;
} else if (buf[z]=='.') {
buf[z]=0;
break;
} else {
break;
}
z--;
}
}
}
return buf;
#else
String s;
String sd;
/* integer part */
bool neg=p_num<0;
p_num=ABS(p_num);
int intn=(int)p_num;
/* decimal part */
if (p_decimals>0 || (p_decimals==-1 && (int)p_num!=p_num)) {
double dec=p_num-(float)((int)p_num);
int digit=0;
if (p_decimals>MAX_DIGITS)
p_decimals=MAX_DIGITS;
int dec_int=0;
int dec_max=0;
while (true) {
dec*=10.0;
dec_int=dec_int*10+(int)dec%10;
dec_max=dec_max*10+9;
digit++;
if (p_decimals==-1) {
if (digit==MAX_DIGITS) //no point in going to infinite
break;
if ((dec-(float)((int)dec))<1e-6)
break;
}
if (digit==p_decimals)
break;
}
dec*=10;
int last=(int)dec%10;
if (last>5) {
if (dec_int==dec_max) {
dec_int=0;
intn++;
} else {
dec_int++;
}
}
String decimal;
for (int i=0;i<digit;i++) {
char num[2]={0,0};
num[0]='0'+dec_int%10;
decimal=num+decimal;
dec_int/=10;
}
sd='.'+decimal;
}
if (intn==0)
s="0";
else {
while(intn) {
CharType num='0'+(intn%10);
intn/=10;
s=num+s;
}
}
s=s+sd;
if (neg)
s="-"+s;
return s;
#endif
}
String String::num_int64(int64_t p_num, int base, bool capitalize_hex) {
bool sign=p_num<0;
int64_t num=ABS(p_num);
int64_t n=num;
int chars=0;
do {
n/=base;
chars++;
} while(n);
if (sign)
chars++;
String s;
s.resize(chars+1);
CharType *c=s.ptr();
c[chars]=0;
n=num;
do {
int mod = n%base;
if (mod >= 10) {
char a = (capitalize_hex ? 'A' : 'a');
c[--chars]=a+(mod - 10);
} else {
c[--chars]='0'+mod;
}
n/=base;
} while(n);
if (sign)
c[0]='-';
return s;
}
String String::num_real(double p_num) {
String s;
String sd;
/* integer part */
bool neg=p_num<0;
p_num=ABS(p_num);
int intn=(int)p_num;
/* decimal part */
if ((int)p_num!=p_num) {
double dec=p_num-(float)((int)p_num);
int digit=0;
int decimals=MAX_DIGITS;
int dec_int=0;
int dec_max=0;
while (true) {
dec*=10.0;
dec_int=dec_int*10+(int)dec%10;
dec_max=dec_max*10+9;
digit++;
if ((dec-(float)((int)dec))<1e-6)
break;
if (digit==decimals)
break;
}
dec*=10;
int last=(int)dec%10;
if (last>5) {
if (dec_int==dec_max) {
dec_int=0;
intn++;
} else {
dec_int++;
}
}
String decimal;
for (int i=0;i<digit;i++) {
char num[2]={0,0};
num[0]='0'+dec_int%10;
decimal=num+decimal;
dec_int/=10;
}
sd='.'+decimal;
} else {
sd=".0";
}
if (intn==0)
s="0";
else {
while(intn) {
CharType num='0'+(intn%10);
intn/=10;
s=num+s;
}
}
s=s+sd;
if (neg)
s="-"+s;
return s;
}
String String::num_scientific(double p_num) {
#ifndef NO_USE_STDLIB
char buf[256];
#if defined(__GNUC__) || defined(_MSC_VER)
snprintf(buf,256,"%lg",p_num);
#else
sprintf(buf,"%.16lg",p_num);
#endif
buf[255]=0;
return buf;
#else
return String::num(p_num);
#endif
}
CharString String::ascii(bool p_allow_extended) const {
if (!length())
return CharString();
CharString cs;
cs.resize(size());
for (int i=0;i<size();i++)
cs[i]=operator[](i);
return cs;
}
String String::utf8(const char* p_utf8,int p_len) {
String ret;
ret.parse_utf8(p_utf8,p_len);
return ret;
};
#if 0
_FORCE_INLINE static int parse_utf8_char(const char *p_utf8,unsigned int *p_ucs4,int p_left) { //return len
int len=0;
/* Determine the number of characters in sequence */
if ((*p_utf8 & 0x80)==0)
len=1;
else if ((*p_utf8 & 0xE0)==0xC0)
len=2;
else if ((*p_utf8 & 0xF0)==0xE0)
len=3;
else if ((*p_utf8 & 0xF8)==0xF0)
len=4;
else if ((*p_utf8 & 0xFC)==0xF8)
len=5;
else if ((*p_utf8 & 0xFE)==0xFC)
len=6;
else
return -1; //invalid UTF8
if (len>p_left)
return -1; //not enough space
if (len==2 && (*p_utf8&0x1E)==0) {
//printf("overlong rejected\n");
return -1; //reject overlong
}
/* Convert the first character */
unsigned int unichar=0;
if (len == 1)
unichar=*p_utf8;
else {
unichar=(0xFF >> (len +1)) & *p_utf8;;
for (int i=1;i<len;i++) {
if ((p_utf8[i] & 0xC0) != 0x80) {
//printf("invalid utf8\n");
return -1; //invalid utf8
}
if (unichar==0 && i==2 && ((p_utf8[i] & 0x7F) >> (7 - len)) == 0) {
//printf("no overlong\n");
return -1; //no overlong
}
unichar = (unichar << 6) | (p_utf8[i] & 0x3F);
}
}
*p_ucs4=unichar;
return len;
}
#endif
bool String::parse_utf8(const char* p_utf8,int p_len) {
#define _UNICERROR(m_err) print_line("unicode error: "+String(m_err));
String aux;
int cstr_size=0;
int str_size=0;
/* HANDLE BOM (Byte Order Mark) */
if (p_len<0 || p_len>=3) {
bool has_bom = uint8_t(p_utf8[0])==0xEF && uint8_t(p_utf8[1])==0xBB && uint8_t(p_utf8[2])==0xBF;
if (has_bom) {
//just skip it
if (p_len>=0)
p_len-=3;
p_utf8+=3;
}
}
{
const char *ptrtmp=p_utf8;
const char *ptrtmp_limit=&p_utf8[p_len];
int skip=0;
while (ptrtmp!=ptrtmp_limit && *ptrtmp) {
if (skip==0) {
uint8_t c = *ptrtmp;
/* Determine the number of characters in sequence */
if ((c & 0x80)==0)
skip=0;
else if ((c & 0xE0)==0xC0)
skip=1;
else if ((c & 0xF0)==0xE0)
skip=2;
else if ((c & 0xF8)==0xF0)
skip=3;
else if ((c & 0xFC)==0xF8)
skip=4;
else if ((c & 0xFE)==0xFC)
skip=5;
else {
_UNICERROR("invalid skip");
return true; //invalid utf8
}
if (skip==1 && (c&0x1E)==0) {
//printf("overlong rejected\n");
_UNICERROR("overlong rejected");
return true; //reject overlong
}
str_size++;
} else {
--skip;
}
cstr_size++;
ptrtmp++;
}
if (skip) {
_UNICERROR("no space left");
return true; //not enough spac
}
}
if (str_size==0) {
clear();
return false;
}
resize(str_size+1);
CharType *dst = &operator[](0);
dst[str_size]=0;
while (cstr_size) {
int len=0;
/* Determine the number of characters in sequence */
if ((*p_utf8 & 0x80)==0)
len=1;
else if ((*p_utf8 & 0xE0)==0xC0)
len=2;
else if ((*p_utf8 & 0xF0)==0xE0)
len=3;
else if ((*p_utf8 & 0xF8)==0xF0)
len=4;
else if ((*p_utf8 & 0xFC)==0xF8)
len=5;
else if ((*p_utf8 & 0xFE)==0xFC)
len=6;
else {
_UNICERROR("invalid len");
return true; //invalid UTF8
}
if (len>cstr_size) {
_UNICERROR("no space left");
return true; //not enough space
}
if (len==2 && (*p_utf8&0x1E)==0) {
//printf("overlong rejected\n");
_UNICERROR("no space left");
return true; //reject overlong
}
/* Convert the first character */
uint32_t unichar=0;
if (len == 1)
unichar=*p_utf8;
else {
unichar=(0xFF >> (len +1)) & *p_utf8;;
for (int i=1;i<len;i++) {
if ((p_utf8[i] & 0xC0) != 0x80) {
_UNICERROR("invalid utf8");
return true; //invalid utf8
}
if (unichar==0 && i==2 && ((p_utf8[i] & 0x7F) >> (7 - len)) == 0) {
_UNICERROR("invalid utf8 overlong");
return true; //no overlong
}
unichar = (unichar << 6) | (p_utf8[i] & 0x3F);
}
}
// printf("char %i, len %i\n",unichar,len);
if (sizeof(wchar_t)==2 && unichar>0xFFFF) {
unichar=' '; //too long for windows
}
*(dst++) = unichar;
cstr_size-=len;
p_utf8 += len;
}
return false;
}
CharString String::utf8() const {
int l = length();
if (!l)
return CharString();
const CharType *d=&operator[](0);
int fl=0;
for (int i=0;i<l;i++) {
uint32_t c=d[i];
if (c <= 0x7f) // 7 bits.
fl+=1;
else if (c <= 0x7ff) { // 11 bits
fl+=2;
} else if (c <= 0xffff) { // 16 bits
fl+=3;
} else if (c <= 0x001fffff) { // 21 bits
fl+=4;
} else if (c <= 0x03ffffff) { // 26 bits
fl+=5;
} else if (c <= 0x7fffffff) { // 31 bits
fl+=6;
}
}
CharString utf8s;
if (fl==0) {
return utf8s;
}
utf8s.resize(fl+1);
uint8_t *cdst=(uint8_t*)utf8s.get_data();
#define APPEND_CHAR( m_c ) *(cdst++) = m_c
for (int i=0;i<l;i++) {
uint32_t c=d[i];
if (c <= 0x7f) // 7 bits.
APPEND_CHAR( c );
else if (c <= 0x7ff) { // 11 bits
APPEND_CHAR( uint32_t(0xc0 | ((c >> 6) & 0x1f)) ); // Top 5 bits.
APPEND_CHAR( uint32_t(0x80 | (c & 0x3f)) ); // Bottom 6 bits.
} else if (c <= 0xffff) { // 16 bits
APPEND_CHAR( uint32_t(0xe0 | ((c >> 12) & 0x0f)) ); // Top 4 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 6) & 0x3f)) ); // Middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | (c & 0x3f)) ); // Bottom 6 bits.
} else if (c <= 0x001fffff) { // 21 bits
APPEND_CHAR( uint32_t(0xf0 | ((c >> 18) & 0x07)) ); // Top 3 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 12) & 0x3f)) ); // Upper middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 6) & 0x3f)) ); // Lower middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | (c & 0x3f)) ); // Bottom 6 bits.
} else if (c <= 0x03ffffff) { // 26 bits
APPEND_CHAR( uint32_t(0xf8 | ((c >> 24) & 0x03)) ); // Top 2 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 18) & 0x3f)) ); // Upper middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 12) & 0x3f)) ); // middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 6) & 0x3f)) ); // Lower middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | (c & 0x3f)) ); // Bottom 6 bits.
} else if (c <= 0x7fffffff) { // 31 bits
APPEND_CHAR( uint32_t(0xfc | ((c >> 30) & 0x01)) ); // Top 1 bit.
APPEND_CHAR( uint32_t(0x80 | ((c >> 24) & 0x3f)) ); // Upper upper middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 18) & 0x3f)) ); // Lower upper middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 12) & 0x3f)) ); // Upper lower middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | ((c >> 6) & 0x3f)) ); // Lower lower middle 6 bits.
APPEND_CHAR( uint32_t(0x80 | (c & 0x3f)) ); // Bottom 6 bits.
}
}
#undef APPEND_CHAR
*cdst=0; //trailing zero
return utf8s;
}
/*
String::String(CharType p_char) {
shared=NULL;
copy_from(p_char);
}
*/
String::String(const char *p_str) {
copy_from(p_str);
}
String::String(const CharType *p_str,int p_clip_to_len) {
copy_from(p_str,p_clip_to_len);
}
String::String(const StrRange& p_range) {
if (!p_range.c_str)
return;
copy_from(p_range.c_str,p_range.len);
}
int String::hex_to_int(bool p_with_prefix) const {
int l = length();
if (p_with_prefix && l<3)
return 0;
const CharType *s=ptr();
int sign = s[0]=='-' ? -1 : 1;
if (sign<0) {
s++;
l--;
if (p_with_prefix && l<2)
return 0;
}
if (p_with_prefix) {
if (s[0]!='0' || s[1]!='x')
return 0;
s+=2;
l-=2;
};
int hex=0;
while(*s) {
CharType c = LOWERCASE(*s);
int n;
if (c>='0' && c<='9') {
n=c-'0';
} else if (c>='a' && c<='f') {
n=(c-'a')+10;
} else {
return 0;
}
hex*=16;
hex+=n;
s++;
}
return hex*sign;
}
int String::to_int() const {
if (length()==0)
return 0;
int to=(find(".")>=0) ? find(".") : length() ;
int integer=0;
int sign=1;
for (int i=0;i<to;i++) {
CharType c=operator[](i);
if (c>='0' && c<='9') {
integer*=10;
integer+=c-'0';
} else if (integer==0 && c=='-') {
sign=-sign;
}
}
return integer*sign;
}
int64_t String::to_int64() const {
if (length()==0)
return 0;
int to=(find(".")>=0) ? find(".") : length() ;
int64_t integer=0;
int64_t sign=1;
for (int i=0;i<to;i++) {
CharType c=operator[](i);
if (c>='0' && c<='9') {
integer*=10;
integer+=c-'0';
} else if (integer==0 && c=='-') {
sign=-sign;
}
}
return integer*sign;
}
int String::to_int(const char* p_str,int p_len) {
int to=0;
if (p_len>=0)
to=p_len;
else {
while(p_str[to]!=0 && p_str[to]!='.')
to++;
}
int integer=0;
int sign=1;
for (int i=0;i<to;i++) {
char c=p_str[i];
if (c>='0' && c<='9') {
integer*=10;
integer+=c-'0';
} else if (c=='-' && integer==0) {
sign=-sign;
} else if (c!=' ')
break;
}
return integer*sign;
}
bool String::is_numeric() const {
if (length() == 0) {
return false;
};
int s = 0;
if (operator[](0) == '-') ++s;
bool dot = false;
for (int i=s; i<length(); i++) {
CharType c = operator[](i);
if (c == '.') {
if (dot) {
return false;
};
dot = true;
}
if (c < '0' || c > '9') {
return false;
};
};
return true; // TODO: Use the parser below for this instead
};
#define IS_DIGIT(m_d) ( (m_d)>='0' && (m_d)<='9' )
#define IS_HEX_DIGIT(m_d) ( ( (m_d)>='0' && (m_d)<='9' ) || ( (m_d)>='a' && (m_d)<='f' ) || ( (m_d)>='A' && (m_d)<='F' ) )
template<class C>
static double built_in_strtod(const C *string, /* A decimal ASCII floating-point number,
* optionally preceded by white space. Must
* have form "-I.FE-X", where I is the integer
* part of the mantissa, F is the fractional
* part of the mantissa, and X is the
* exponent. Either of the signs may be "+",
* "-", or omitted. Either I or F may be
* omitted, or both. The decimal point isn't
* necessary unless F is present. The "E" may
* actually be an "e". E and X may both be
* omitted (but not just one). */
C **endPtr=NULL) /* If non-NULL, store terminating Cacter's
* address here. */
{
static const int maxExponent = 511; /* Largest possible base 10 exponent. Any
* exponent larger than this will already
* produce underflow or overflow, so there's
* no need to worry about additional digits.
*/
static const double powersOf10[] = { /* Table giving binary powers of 10. Entry */
10., /* is 10^2^i. Used to convert decimal */
100., /* exponents into floating-point numbers. */
1.0e4,
1.0e8,
1.0e16,
1.0e32,
1.0e64,
1.0e128,
1.0e256
};
int sign, expSign = false;
double fraction, dblExp;
const double *d;
register const C *p;
register int c;
int exp = 0; /* Exponent read from "EX" field. */
int fracExp = 0; /* Exponent that derives from the fractional
* part. Under normal circumstatnces, it is
* the negative of the number of digits in F.
* However, if I is very long, the last digits
* of I get dropped (otherwise a long I with a
* large negative exponent could cause an
* unnecessary overflow on I alone). In this
* case, fracExp is incremented one for each
* dropped digit. */
int mantSize; /* Number of digits in mantissa. */
int decPt; /* Number of mantissa digits BEFORE decimal
* point. */
const C *pExp; /* Temporarily holds location of exponent in
* string. */
/*
* Strip off leading blanks and check for a sign.
*/
p = string;
while (*p == ' ' || *p=='\t' || *p=='\n') {
p += 1;
}
if (*p == '-') {
sign = true;
p += 1;
} else {
if (*p == '+') {
p += 1;
}
sign = false;
}
/*
* Count the number of digits in the mantissa (including the decimal
* point), and also locate the decimal point.
*/
decPt = -1;
for (mantSize = 0; ; mantSize += 1)
{
c = *p;
if (!IS_DIGIT(c)) {
if ((c != '.') || (decPt >= 0)) {
break;
}
decPt = mantSize;
}
p += 1;
}
/*
* Now suck up the digits in the mantissa. Use two integers to collect 9
* digits each (this is faster than using floating-point). If the mantissa
* has more than 18 digits, ignore the extras, since they can't affect the
* value anyway.
*/
pExp = p;
p -= mantSize;
if (decPt < 0) {
decPt = mantSize;
} else {
mantSize -= 1; /* One of the digits was the point. */
}
if (mantSize > 18) {
fracExp = decPt - 18;
mantSize = 18;
} else {
fracExp = decPt - mantSize;
}
if (mantSize == 0) {
fraction = 0.0;
p = string;
goto done;
} else {
int frac1, frac2;
frac1 = 0;
for ( ; mantSize > 9; mantSize -= 1) {
c = *p;
p += 1;
if (c == '.') {
c = *p;
p += 1;
}
frac1 = 10*frac1 + (c - '0');
}
frac2 = 0;
for (; mantSize > 0; mantSize -= 1) {
c = *p;
p += 1;
if (c == '.') {
c = *p;
p += 1;
}
frac2 = 10*frac2 + (c - '0');
}
fraction = (1.0e9 * frac1) + frac2;
}
/*
* Skim off the exponent.
*/
p = pExp;
if ((*p == 'E') || (*p == 'e')) {
p += 1;
if (*p == '-') {
expSign = true;
p += 1;
} else {
if (*p == '+') {
p += 1;
}
expSign = false;
}
if (!IS_DIGIT(CharType(*p))) {
p = pExp;
goto done;
}
while (IS_DIGIT(CharType(*p))) {
exp = exp * 10 + (*p - '0');
p += 1;
}
}
if (expSign) {
exp = fracExp - exp;
} else {
exp = fracExp + exp;
}
/*
* Generate a floating-point number that represents the exponent. Do this
* by processing the exponent one bit at a time to combine many powers of
* 2 of 10. Then combine the exponent with the fraction.
*/
if (exp < 0) {
expSign = true;
exp = -exp;
} else {
expSign = false;
}
if (exp > maxExponent) {
exp = maxExponent;
WARN_PRINT("Exponent too high");
}
dblExp = 1.0;
for (d = powersOf10; exp != 0; exp >>= 1, ++d) {
if (exp & 01) {
dblExp *= *d;
}
}
if (expSign) {
fraction /= dblExp;
} else {
fraction *= dblExp;
}
done:
if (endPtr != NULL) {
*endPtr = (C *) p;
}
if (sign) {
return -fraction;
}
return fraction;
}
#define READING_SIGN 0
#define READING_INT 1
#define READING_DEC 2
#define READING_EXP 3
#define READING_DONE 4
double String::to_double(const char* p_str) {
#ifndef NO_USE_STDLIB
return built_in_strtod<char>(p_str);
//return atof(p_str); DOES NOT WORK ON ANDROID(??)
#else
return built_in_strtod<char>(p_str);
#endif
#if 0
#if 0
return atof(p_str);
#else
if (!p_str[0])
return 0;
///@todo make more exact so saving and loading does not lose precision
double integer=0;
double decimal=0;
double decimal_mult=0.1;
double sign=1.0;
double exp=0;
double exp_sign=1.0;
int reading=READING_SIGN;
const char *str=p_str;
while(*str && reading!=READING_DONE) {
CharType c=*(str++);
switch(reading) {
case READING_SIGN: {
if (c>='0' && c<='9')
reading=READING_INT;
// let it fallthrough
else if (c=='-') {
sign=-1.0;
reading=READING_INT;
break;
} else if (c=='.') {
reading=READING_DEC;
break;
} else {
break;
}
}
case READING_INT: {
if (c>='0' && c<='9') {
integer*=10;
integer+=c-'0';
} else if (c=='.') {
reading=READING_DEC;
} else if (c=='e') {
reading=READING_EXP;
} else {
reading=READING_DONE;
}
} break;
case READING_DEC: {
if (c>='0' && c<='9') {
decimal+=(c-'0')*decimal_mult;
decimal_mult*=0.1;
} else if (c=='e') {
reading=READING_EXP;
} else {
reading=READING_DONE;
}
} break;
case READING_EXP: {
if (c>='0' && c<='9') {
exp*=10.0;
exp+=(c-'0');
} else if (c=='-' && exp==0) {
exp_sign=-1.0;
} else if (exp_sign>=0 && c=='+') {
//redundant...
exp_sign=1.0;
} else {
reading=READING_DONE;
}
} break;
}
}
return sign*(integer+decimal)*Math::pow(10,exp_sign*exp);
#endif
#endif
}
float String::to_float() const {
return to_double();
}
double String::to_double(const CharType* p_str, const CharType **r_end) {
return built_in_strtod<CharType>(p_str,(CharType**)r_end);
#if 0
#if 0
//ndef NO_USE_STDLIB
return wcstod(p_str,p_len<0?NULL:p_str+p_len);
#else
if (p_len==0 || !p_str[0])
return 0;
///@todo make more exact so saving and loading does not lose precision
double integer=0;
double decimal=0;
double decimal_mult=0.1;
double sign=1.0;
double exp=0;
double exp_sign=1.0;
int reading=READING_SIGN;
const CharType *str=p_str;
const CharType *limit=&p_str[p_len];
while(reading!=READING_DONE && str!=limit) {
CharType c=*(str++);
switch(reading) {
case READING_SIGN: {
if (c>='0' && c<='9')
reading=READING_INT;
// let it fallthrough
else if (c=='-') {
sign=-1.0;
reading=READING_INT;
break;
} else if (c=='.') {
reading=READING_DEC;
break;
} else if (c==0) {
reading=READING_DONE;
break;
} else {
break;
}
}
case READING_INT: {
if (c>='0' && c<='9') {
integer*=10;
integer+=c-'0';
} else if (c=='.') {
reading=READING_DEC;
} else if (c=='e' || c=='E') {
reading=READING_EXP;
} else {
reading=READING_DONE;
}
} break;
case READING_DEC: {
if (c>='0' && c<='9') {
decimal+=(c-'0')*decimal_mult;
decimal_mult*=0.1;
} else if (c=='e' || c=='E') {
reading=READING_EXP;
} else {
reading=READING_DONE;
}
} break;
case READING_EXP: {
if (c>='0' && c<='9') {
exp*=10.0;
exp+=(c-'0');
} else if (c=='-' && exp==0) {
exp_sign=-1.0;
} else if (exp_sign>=0 && c=='+') {
//redundant...
exp_sign=1.0;
} else {
reading=READING_DONE;
}
} break;
}
}
if (r_end)
*r_end=str-1;
return sign*(integer+decimal)*Math::pow(10,exp_sign*exp);
#endif
#endif
}
int64_t String::to_int(const CharType* p_str,int p_len) {
if (p_len==0 || !p_str[0])
return 0;
///@todo make more exact so saving and loading does not lose precision
int64_t integer=0;
int64_t sign=1;
int reading=READING_SIGN;
const CharType *str=p_str;
const CharType *limit=&p_str[p_len];
while(*str && reading!=READING_DONE && str!=limit) {
CharType c=*(str++);
switch(reading) {
case READING_SIGN: {
if (c>='0' && c<='9') {
reading=READING_INT;
// let it fallthrough
} else if (c=='-') {
sign=-1;
reading=READING_INT;
break;
} else if (c=='+') {
sign=1;
reading=READING_INT;
break;
} else {
break;
}
}
case READING_INT: {
if (c>='0' && c<='9') {
integer*=10;
integer+=c-'0';
} else {
reading=READING_DONE;
}
} break;
}
}
return sign*integer;
}
double String::to_double() const {
if (empty())
return 0;
#ifndef NO_USE_STDLIB
return built_in_strtod<CharType>(c_str());
//return wcstod(c_str(),NULL); DOES NOT WORK ON ANDROID :(
#else
return built_in_strtod<CharType>(c_str());
#endif
#if 0
#ifndef NO_USE_STDLIB
return atof(utf8().get_data());
#else
double integer=0;
double decimal=0;
double decimal_mult=0.1;
double sign=1.0;
double exp=0;
double exp_sign=1.0;
int reading=READING_SIGN;
const CharType *str=&operator[](0);
while(*str && reading!=READING_DONE) {
CharType c=*(str++);
switch(reading) {
case READING_SIGN: {
if (c>='0' && c<='9')
reading=READING_INT;
// let it fallthrough
else if (c=='-') {
sign=-1.0;
reading=READING_INT;
break;
} else if (c=='.') {
reading=READING_DEC;
break;
} else {
break;
}
}
case READING_INT: {
if (c>='0' && c<='9') {
integer*=10;
integer+=c-'0';
} else if (c=='.') {
reading=READING_DEC;
} else if (c=='e') {
reading=READING_EXP;
} else {
reading=READING_DONE;
}
} break;
case READING_DEC: {
if (c>='0' && c<='9') {
decimal+=(c-'0')*decimal_mult;
decimal_mult*=0.1;
} else if (c=='e') {
reading=READING_EXP;
} else {
reading=READING_DONE;
}
} break;
case READING_EXP: {
if (c>='0' && c<='9') {
exp*=10.0;
exp+=(c-'0');
} else if (c=='-' && exp==0) {
exp_sign=-1.0;
} else if (exp_sign>=0 && c=='+') {
//redundant...
exp_sign=1.0;
} else {
reading=READING_DONE;
}
} break;
}
}
return sign*(integer+decimal)*Math::pow(10,exp_sign*exp);
#endif
#if 0
double ret=sign*(integer+decimal)*Math::pow(10,exp_sign*exp);
print_line(*this +" == "+rtos(ret));
return ret;
#endif
#endif
}
bool operator==(const char*p_chr, const String& p_str) {
return p_str==p_chr;
}
String operator+(const char*p_chr, const String& p_str) {
String tmp=p_chr;
tmp+=p_str;
return tmp;
}
String operator+(CharType p_chr, const String& p_str) {
return (String::chr(p_chr)+p_str);
}
uint32_t String::hash(const char* p_cstr) {
uint32_t hashv = 5381;
uint32_t c;
while ((c = *p_cstr++))
hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */
return hashv;
}
uint32_t String::hash(const char* p_cstr,int p_len) {
uint32_t hashv = 5381;
for(int i=0;i<p_len;i++)
hashv = ((hashv << 5) + hashv) + p_cstr[i]; /* hash * 33 + c */
return hashv;
}
uint32_t String::hash(const CharType* p_cstr,int p_len) {
uint32_t hashv = 5381;
for(int i=0;i<p_len;i++)
hashv = ((hashv << 5) + hashv) + p_cstr[i]; /* hash * 33 + c */
return hashv;
}
uint32_t String::hash(const CharType* p_cstr) {
uint32_t hashv = 5381;
uint32_t c;
while ((c = *p_cstr++))
hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */
return hashv;
}
uint32_t String::hash() const {
/* simple djb2 hashing */
const CharType * chr = c_str();
uint32_t hashv = 5381;
uint32_t c;
while ((c = *chr++))
hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */
return hashv;
}
uint64_t String::hash64() const {
/* simple djb2 hashing */
const CharType * chr = c_str();
uint64_t hashv = 5381;
uint64_t c;
while ((c = *chr++))
hashv = ((hashv << 5) + hashv) + c; /* hash * 33 + c */
return hashv;
}
String String::md5_text() const {
CharString cs=utf8();
MD5_CTX ctx;
MD5Init(&ctx);
MD5Update(&ctx,(unsigned char*)cs.ptr(),cs.length());
MD5Final(&ctx);
return String::md5(ctx.digest);
}
String String::sha256_text() const {
CharString cs=utf8();
unsigned char hash[32];
sha256_context ctx;
sha256_init(&ctx);
sha256_hash(&ctx,(unsigned char*)cs.ptr(),cs.length());
sha256_done(&ctx, hash);
return String::hex_encode_buffer(hash, 32);
}
Vector<uint8_t> String::md5_buffer() const {
CharString cs=utf8();
MD5_CTX ctx;
MD5Init(&ctx);
MD5Update(&ctx,(unsigned char*)cs.ptr(),cs.length());
MD5Final(&ctx);
Vector<uint8_t> ret;
ret.resize(16);
for (int i=0; i<16; i++) {
ret[i] = ctx.digest[i];
};
return ret;
};
Vector<uint8_t> String::sha256_buffer() const {
CharString cs = utf8();
unsigned char hash[32];
sha256_context ctx;
sha256_init(&ctx);
sha256_hash(&ctx, (unsigned char*)cs.ptr(), cs.length());
sha256_done(&ctx, hash);
Vector<uint8_t> ret;
ret.resize(32);
for (int i = 0; i < 32; i++) {
ret[i] = hash[i];
}
return ret;
}
String String::insert(int p_at_pos,String p_string) const {
if (p_at_pos<0)
return *this;
if (p_at_pos>length())
p_at_pos=length();
String pre;
if (p_at_pos>0)
pre=substr( 0, p_at_pos );
String post;
if (p_at_pos<length())
post=substr( p_at_pos, length()-p_at_pos);
return pre+p_string+post;
}
String String::substr(int p_from,int p_chars) const{
if (empty() || p_from<0 || p_from>=length() || p_chars<=0)
return "";
if ( (p_from+p_chars)>length()) {
p_chars=length()-p_from;
}
return String(&c_str()[p_from],p_chars);
}
int String::find_last(String p_str) const {
int pos=-1;
int findfrom=0;
int findres=-1;
while((findres=find(p_str,findfrom))!=-1) {
pos=findres;
findfrom=pos+1;
}
return pos;
}
int String::find(String p_str,int p_from) const {
if (p_from<0)
return -1;
int src_len=p_str.length();
int len=length();
if(src_len==0 || len==0)
return -1; //wont find anything!
const CharType *src = c_str();
for (int i=p_from;i<=(len-src_len);i++) {
bool found=true;
for (int j=0;j<src_len;j++) {
int read_pos=i+j;
if (read_pos>=len) {
ERR_PRINT("read_pos>=len");
return -1;
};
if (src[read_pos]!=p_str[j]) {
found=false;
break;
}
}
if (found)
return i;
}
return -1;
}
int String::findmk(const Vector<String>& p_keys,int p_from,int *r_key) const {
if (p_from<0)
return -1;
if (p_keys.size()==0)
return -1;
//int src_len=p_str.length();
const String *keys=&p_keys[0];
int key_count=p_keys.size();
int len = length();
if(len==0)
return -1; //wont find anything!
const CharType *src = c_str();
for (int i=p_from;i<len;i++) {
bool found=true;
for(int k=0;k<key_count;k++) {
found=true;
if (r_key)
*r_key=k;
const CharType *cmp=keys[k].c_str();
int l=keys[k].length();
for (int j=0;j<l;j++) {
int read_pos=i+j;
if (read_pos>=len) {
found=false;
break;
};
if (src[read_pos]!=cmp[j]) {
found=false;
break;
}
}
if (found)
break;
}
if (found)
return i;
}
return -1;
}
int String::findn(String p_str,int p_from) const {
if (p_from<0)
return -1;
int src_len=p_str.length();
if(src_len==0 || length()==0)
return -1; //wont find anything!
const CharType *srcd = c_str();
for (int i=p_from;i<=(length()-src_len);i++) {
bool found=true;
for (int j=0;j<src_len;j++) {
int read_pos=i+j;
if (read_pos>=length()) {
ERR_PRINT("read_pos>=length()");
return -1;
};
CharType src=_find_lower(srcd[read_pos]);
CharType dst=_find_lower(p_str[j]);
if (src!=dst) {
found=false;
break;
}
}
if (found)
return i;
}
return -1;
}
int String::rfind(String p_str,int p_from) const {
//stabilish a limit
int limit = length()-p_str.length();
if (limit<0)
return -1;
//stabilish a starting point
if (p_from<0)
p_from=limit;
else if (p_from>limit)
p_from=limit;
int src_len=p_str.length();
int len=length();
if(src_len==0 || len==0)
return -1; //wont find anything!
const CharType *src = c_str();
for (int i=p_from;i>=0;i--) {
bool found=true;
for (int j=0;j<src_len;j++) {
int read_pos=i+j;
if (read_pos>=len) {
ERR_PRINT("read_pos>=len");
return -1;
};
if (src[read_pos]!=p_str[j]) {
found=false;
break;
}
}
if (found)
return i;
}
return -1;
}
int String::rfindn(String p_str,int p_from) const {
//stabilish a limit
int limit = length()-p_str.length();
if (limit<0)
return -1;
//stabilish a starting point
if (p_from<0)
p_from=limit;
else if (p_from>limit)
p_from=limit;
int src_len=p_str.length();
int len=length();
if(src_len==0 || len==0)
return -1; //wont find anything!
const CharType *src = c_str();
for (int i=p_from;i>=0;i--) {
bool found=true;
for (int j=0;j<src_len;j++) {
int read_pos=i+j;
if (read_pos>=len) {
ERR_PRINT("read_pos>=len");
return -1;
};
CharType srcc=_find_lower(src[read_pos]);
CharType dstc=_find_lower(p_str[j]);
if (srcc!=dstc) {
found=false;
break;
}
}
if (found)
return i;
}
return -1;
}
bool String::ends_with(const String& p_string) const {
int pos = find_last(p_string);
if (pos==-1)
return false;
return pos+p_string.length()==length();
}
bool String::begins_with(const String& p_string) const {
if (p_string.length() > length())
return false;
int l=p_string.length();
if (l==0)
return true;
const CharType *src=&p_string[0];
const CharType *str=&operator[](0);
int i = 0;
for (;i<l;i++) {
if (src[i]!=str[i])
return false;
}
// only if i == l the p_string matches the beginning
return i == l;
}
bool String::begins_with(const char* p_string) const {
int l=length();
if (l==0||!p_string)
return false;
const CharType *str=&operator[](0);
int i=0;
while (*p_string && i<l) {
if (*p_string != str[i])
return false;
i++;
p_string++;
}
return *p_string == 0;
}
bool String::is_subsequence_of(const String& p_string) const {
return _base_is_subsequence_of(p_string, false);
}
bool String::is_subsequence_ofi(const String& p_string) const {
return _base_is_subsequence_of(p_string, true);
}
bool String::_base_is_subsequence_of(const String& p_string, bool case_insensitive) const {
int len=length();
if (len == 0) {
// Technically an empty string is subsequence of any string
return true;
}
if (len > p_string.length()) {
return false;
}
const CharType *src = &operator[](0);
const CharType *tgt = &p_string[0];
for (;*src && *tgt;tgt++) {
bool match = false;
if (case_insensitive) {
CharType srcc = _find_lower(*src);
CharType tgtc = _find_lower(*tgt);
match = srcc == tgtc;
} else {
match = *src == *tgt;
}
if (match) {
src++;
if(!*src) {
return true;
}
}
}
return false;
}
Vector<String> String::bigrams() const {
int n_pairs = length() - 1;
Vector<String> b;
if(n_pairs <= 0) {
return b;
}
b.resize(n_pairs);
for(int i = 0; i < n_pairs; i++) {
b[i] = substr(i,2);
}
return b;
}
// Similarity according to Sorensen-Dice coefficient
float String::similarity(const String& p_string) const {
if(operator==(p_string)) {
// Equal strings are totally similar
return 1.0f;
}
if (length() < 2 || p_string.length() < 2) {
// No way to calculate similarity without a single bigram
return 0.0f;
}
Vector<String> src_bigrams = bigrams();
Vector<String> tgt_bigrams = p_string.bigrams();
int src_size = src_bigrams.size();
int tgt_size = tgt_bigrams.size();
float sum = src_size + tgt_size;
float inter = 0;
for (int i = 0; i < src_size; i++) {
for (int j = 0; j < tgt_size; j++) {
if (src_bigrams[i] == tgt_bigrams[j]) {
inter++;
break;
}
}
}
return (2.0f * inter)/sum;
}
static bool _wildcard_match(const CharType* p_pattern, const CharType* p_string,bool p_case_sensitive) {
switch (*p_pattern) {
case '\0':
return !*p_string;
case '*' :
return _wildcard_match(p_pattern+1, p_string,p_case_sensitive) || (*p_string && _wildcard_match(p_pattern, p_string+1,p_case_sensitive));
case '?' :
return *p_string && (*p_string != '.') && _wildcard_match(p_pattern+1, p_string+1,p_case_sensitive);
default :
return (p_case_sensitive?(*p_string==*p_pattern):(_find_upper(*p_string)==_find_upper(*p_pattern))) && _wildcard_match(p_pattern+1, p_string+1,p_case_sensitive);
}
}
bool String::match(const String& p_wildcard) const {
if (!p_wildcard.length() || !length())
return false;
return _wildcard_match(p_wildcard.c_str(),c_str(),true);
}
bool String::matchn(const String& p_wildcard) const {
if (!p_wildcard.length() || !length())
return false;
return _wildcard_match(p_wildcard.c_str(),c_str(),false);
}
String String::replace(String p_key,String p_with) const {
String new_string;
int search_from=0;
int result=0;
while( (result=find(p_key,search_from))>=0 ) {
new_string+=substr(search_from,result-search_from);
new_string+=p_with;
search_from=result+p_key.length();
}
new_string+=substr(search_from,length()-search_from);
return new_string;
}
String String::replace_first(String p_key,String p_with) const {
String new_string;
int search_from=0;
int result=0;
while( (result=find(p_key,search_from))>=0 ) {
new_string+=substr(search_from,result-search_from);
new_string+=p_with;
search_from=result+p_key.length();
break;
}
new_string+=substr(search_from,length()-search_from);
return new_string;
}
String String::replacen(String p_key,String p_with) const {
String new_string;
int search_from=0;
int result=0;
while( (result=findn(p_key,search_from))>=0 ) {
new_string+=substr(search_from,result-search_from);
new_string+=p_with;
search_from=result+p_key.length();
}
new_string+=substr(search_from,length()-search_from);
return new_string;
}
String String::left(int p_pos) const {
if (p_pos<=0)
return "";
if (p_pos>=length())
return *this;
return substr(0,p_pos);
}
String String::right(int p_pos) const {
if (p_pos>=size())
return *this;
if (p_pos<0)
return "";
return substr(p_pos,(length()-p_pos));
}
CharType String::ord_at(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, length(), 0);
return operator[](p_idx);
}
String String::strip_edges(bool left, bool right) const {
int len=length();
int beg=0,end=len;
if(left) {
for (int i=0;i<len;i++) {
if (operator[](i)<=32)
beg++;
else
break;
}
}
if(right) {
for (int i=(int)(len-1);i>=0;i--) {
if (operator[](i)<=32)
end--;
else
break;
}
}
if (beg==0 && end==len)
return *this;
return substr(beg,end-beg);
}
String String::strip_escapes() const {
int len=length();
int beg=0,end=len;
for (int i=0;i<length();i++) {
if (operator[](i)<=31)
beg++;
else
break;
}
for (int i=(int)(length()-1);i>=0;i--) {
if (operator[](i)<=31)
end--;
else
break;
}
if (beg==0 && end==len)
return *this;
return substr(beg,end-beg);
}
String String::simplify_path() const {
String s = *this;
String drive;
if (s.begins_with("local://")) {
drive="local://";
s=s.substr(8,s.length());
} else if (s.begins_with("res://")) {
drive="res://";
s=s.substr(6,s.length());
} else if (s.begins_with("user://")) {
drive="user://";
s=s.substr(6,s.length());
} else if (s.begins_with("/") || s.begins_with("\\")) {
drive=s.substr(0,1);
s=s.substr(1,s.length()-1);
} else {
int p = s.find(":/");
if (p==-1)
p=s.find(":\\");
if (p!=-1 && p < s.find("/")) {
drive=s.substr(0,p+2);
s=s.substr(p+2,s.length());
}
}
s =s.replace("\\","/");
while(true){ // in case of using 2 or more slash
String compare = s.replace("//","/");
if (s==compare) break;
else s=compare;
}
Vector<String> dirs = s.split("/",false);
for(int i=0;i<dirs.size();i++) {
String d = dirs[i];
if (d==".") {
dirs.remove(i);
i--;
} else if (d=="..") {
if (i==0) {
dirs.remove(i);
i--;
} else {
dirs.remove(i);
dirs.remove(i-1);
i-=2;
}
}
}
s="";
for(int i=0;i<dirs.size();i++) {
if (i>0)
s+="/";
s+=dirs[i];
}
return drive+s;
}
static int _humanize_digits(int p_num) {
if (p_num<10)
return 2;
else if (p_num<100)
return 2;
else if (p_num<1024)
return 1;
else
return 0;
}
String String::humanize_size(size_t p_size) {
uint64_t _div=1;
static const char* prefix[]={" Bytes"," KB"," MB"," GB","TB"," PB","HB",""};
int prefix_idx=0;
while(p_size>(_div*1024) && prefix[prefix_idx][0]) {
_div*=1024;
prefix_idx++;
}
int digits=prefix_idx>0?_humanize_digits(p_size/_div):0;
double divisor = prefix_idx>0?_div:1;
return String::num(p_size/divisor,digits)+prefix[prefix_idx];
}
bool String::is_abs_path() const {
if (length()>1)
return (operator[](0)=='/' || operator[](0)=='\\' || find(":/")!=-1 || find(":\\")!=-1);
else if ((length())==1)
return (operator[](0)=='/' || operator[](0)=='\\');
else
return false;
}
bool String::is_valid_identifier() const {
int len = length();
if (len==0)
return false;
const wchar_t * str = &operator[](0);
for(int i=0;i<len;i++) {
if (i==0) {
if (str[0]>='0' && str[0]<='9')
return false; // no start with number plz
}
bool valid_char = (str[i]>='0' && str[i]<='9') || (str[i]>='a' && str[i]<='z') || (str[i]>='A' && str[i]<='Z') || str[i]=='_';
if (!valid_char)
return false;
}
return true;
}
//kind of poor should be rewritten properly
String String::word_wrap(int p_chars_per_line) const {
int from=0;
int last_space=0;
String ret;
for(int i=0;i<length();i++) {
if (i-from>=p_chars_per_line) {
if (last_space==-1) {
ret+=substr(from,i-from+1)+"\n";
} else {
ret+=substr(from,last_space-from)+"\n";
i=last_space; //rewind
}
from=i+1;
last_space=-1;
} else if (operator[](i)==' ' || operator[](i)=='\t') {
last_space=i;
} else if (operator[](i)=='\n') {
ret+=substr(from,i-from)+"\n";
from=i+1;
last_space=-1;
}
}
if (from<length()) {
ret+=substr(from,length());
}
return ret;
}
String String::http_escape() const {
const CharString temp = utf8();
String res;
for (int i = 0; i < length(); ++i) {
CharType ord = temp[i];
if (ord == '.' || ord == '-' || ord == '_' || ord == '~' ||
(ord >= 'a' && ord <= 'z') ||
(ord >= 'A' && ord <= 'Z') ||
(ord >= '0' && ord <= '9')) {
res += ord;
} else {
char h_Val[3];
#if defined(__GNUC__) || defined(_MSC_VER)
snprintf(h_Val, 3, "%.2X", ord);
#else
sprintf(h_Val, "%.2X", ord);
#endif
res += "%";
res += h_Val;
}
}
return res;
}
String String::http_unescape() const {
String res;
for (int i = 0; i < length(); ++i) {
if (ord_at(i) == '%' && i+2 < length()) {
CharType ord1 = ord_at(i+1);
if ((ord1 >= '0' && ord1 <= '9') || (ord1 >= 'A' && ord1 <= 'Z')) {
CharType ord2 = ord_at(i+2);
if ((ord2 >= '0' && ord2 <= '9') || (ord2 >= 'A' && ord2 <= 'Z')) {
char bytes[2] = {ord1, ord2};
res += (char)strtol(bytes, NULL, 16);
i+=2;
}
} else {
res += ord_at(i);
}
} else {
res += ord_at(i);
}
}
return String::utf8(res.ascii());
}
String String::c_unescape() const {
String escaped=*this;
escaped=escaped.replace("\\a","\a");
escaped=escaped.replace("\\b","\b");
escaped=escaped.replace("\\f","\f");
escaped=escaped.replace("\\n","\n");
escaped=escaped.replace("\\r","\r");
escaped=escaped.replace("\\t","\t");
escaped=escaped.replace("\\v","\v");
escaped=escaped.replace("\\'","\'");
escaped=escaped.replace("\\\"","\"");
escaped=escaped.replace("\\?","\?");
escaped=escaped.replace("\\\\","\\");
return escaped;
}
String String::c_escape() const {
String escaped=*this;
escaped=escaped.replace("\\","\\\\");
escaped=escaped.replace("\a","\\a");
escaped=escaped.replace("\b","\\b");
escaped=escaped.replace("\f","\\f");
escaped=escaped.replace("\n","\\n");
escaped=escaped.replace("\r","\\r");
escaped=escaped.replace("\t","\\t");
escaped=escaped.replace("\v","\\v");
escaped=escaped.replace("\'","\\'");
escaped=escaped.replace("\"","\\\"");
escaped=escaped.replace("\?","\\?");
return escaped;
}
String String::json_escape() const {
String escaped=*this;
escaped=escaped.replace("\\","\\\\");
escaped=escaped.replace("\b","\\b");
escaped=escaped.replace("\f","\\f");
escaped=escaped.replace("\n","\\n");
escaped=escaped.replace("\r","\\r");
escaped=escaped.replace("\t","\\t");
escaped=escaped.replace("\v","\\v");
escaped=escaped.replace("\"","\\\"");
return escaped;
}
String String::xml_escape(bool p_escape_quotes) const {
String str=*this;
str=str.replace("&","&amp;");
str=str.replace("<","&lt;");
str=str.replace(">","&gt;");
if (p_escape_quotes) {
str=str.replace("'","&apos;");
str=str.replace("\"","&quot;");
}
/*
for (int i=1;i<32;i++) {
char chr[2]={i,0};
str=str.replace(chr,"&#"+String::num(i)+";");
}*/
return str;
}
static _FORCE_INLINE_ int _xml_unescape(const CharType *p_src,int p_src_len,CharType *p_dst) {
int len=0;
while(p_src_len) {
if (*p_src=='&') {
int eat=0;
if (p_src_len>=4 && p_src[1]=='#') {
CharType c=0;
for(int i=2;i<p_src_len;i++) {
eat=i+1;
CharType ct=p_src[i];
if (ct==';') {
break;
} else if (ct>='0' && ct<='9') {
ct=ct-'0';
} else if (ct>='a' && ct<='f') {
ct=(ct-'a')+10;
} else if (ct>='A' && ct<='F') {
ct=(ct-'A')+10;
} else {
continue;
}
c<<=4;
c|=ct;
}
if (p_dst)
*p_dst=c;
} else if (p_src_len>=4 && p_src[1]=='g' && p_src[2]=='t' && p_src[3]==';') {
if (p_dst)
*p_dst='>';
eat=4;
} else if (p_src_len>=4 && p_src[1]=='l' && p_src[2]=='t' && p_src[3]==';') {
if (p_dst)
*p_dst='<';
eat=4;
} else if (p_src_len>=5 && p_src[1]=='a' && p_src[2]=='m' && p_src[3]=='p' && p_src[4]==';') {
if (p_dst)
*p_dst='&';
eat=5;
} else if (p_src_len>=6 && p_src[1]=='q' && p_src[2]=='u' && p_src[3]=='o' && p_src[4]=='t' && p_src[5]==';') {
if (p_dst)
*p_dst='"';
eat=6;
} else if (p_src_len>=6 && p_src[1]=='a' && p_src[2]=='p' && p_src[3]=='o' && p_src[4]=='s' && p_src[5]==';') {
if (p_dst)
*p_dst='\'';
eat=6;
} else {
if (p_dst)
*p_dst=*p_src;
eat=1;
}
if (p_dst)
p_dst++;
len++;
p_src+=eat;
p_src_len-=eat;
} else {
if (p_dst) {
*p_dst=*p_src;
p_dst++;
}
len++;
p_src++;
p_src_len--;
}
}
return len;
}
String String::xml_unescape() const {
String str;
int l = length();
int len = _xml_unescape(c_str(),l,NULL);
if (len==0)
return String();
str.resize(len+1);
_xml_unescape(c_str(),l,&str[0]);
str[len]=0;
return str;
}
String String::pad_decimals(int p_digits) const {
String s=*this;
int c = s.find(".");
if (c==-1) {
if (p_digits<=0) {
return s;
}
s+=".";
c=s.length()-1;
} else {
if (p_digits<=0) {
return s.substr(0,c);
}
}
if (s.length()-(c+1) > p_digits) {
s=s.substr(0,c+p_digits+1);
} else {
while(s.length()-(c+1) < p_digits) {
s+="0";
}
}
return s;
}
String String::pad_zeros(int p_digits) const {
String s=*this;
int end = s.find(".");
if (end==-1) {
end=s.length();
}
if (end==0)
return s;
int begin=0;
while (begin<end && (s[begin]<'0' || s[begin]>'9')) {
begin++;
}
if (begin>=end)
return s;
while(end-begin < p_digits) {
s=s.insert(begin,"0");
end++;
}
return s;
}
bool String::is_valid_integer() const {
int len = length();
if (len==0)
return false;
int from=0;
if (len!=1 && (operator[](0)=='+' || operator[](0)=='-'))
from++;
for(int i=from;i<len;i++) {
if (operator[](i)<'0' || operator[](i)>'9')
return false; // no start with number plz
}
return true;
}
bool String::is_valid_hex_number(bool p_with_prefix) const {
int from = 0;
int len = length();
if (len!=1 && (operator[](0)=='+' || operator[](0)=='-'))
from++;
if (p_with_prefix) {
if (len < 2)
return false;
if (operator[](from) != '0' || operator[](from+1) != 'x') {
return false;
};
from += 2;
};
for (int i=from; i<len; i++) {
CharType c = operator[](i);
if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
continue;
return false;
};
return true;
};
bool String::is_valid_float() const {
int len = length();
if (len==0)
return false;
int from=0;
if (operator[](0)=='+' || operator[](0)=='-') {
from++;
}
//this was pulled out of my ass, i wonder if it's correct...
bool exponent_found=false;
bool period_found=false;
bool sign_found=false;
bool exponent_values_found=false;
bool numbers_found=false;
for(int i=from;i<len;i++) {
if (operator[](i)>='0' && operator[](i)<='9') {
if (exponent_found)
exponent_values_found=true;
else
numbers_found=true;
} else if (numbers_found && !exponent_found && operator[](i)=='e') {
exponent_found=true;
} else if (!period_found && !exponent_found && operator[](i)=='.') {
period_found=true;
} else if ((operator[](i)=='-' || operator[](i)=='+') && exponent_found && !exponent_values_found && !sign_found) {
sign_found=true;
} else
return false; // no start with number plz
}
return numbers_found;
}
String String::path_to_file(const String& p_path) const {
String src=this->replace("\\","/").get_base_dir();
String dst=p_path.replace("\\","/").get_base_dir();
String rel = src.path_to(dst);
if (rel==dst) // failed
return p_path;
else
return rel+p_path.get_file();
}
String String::path_to(const String& p_path) const {
String src=this->replace("\\","/");
String dst=p_path.replace("\\","/");
if (!src.ends_with("/"))
src+="/";
if (!dst.ends_with("/"))
dst+="/";
String base;
if (src.begins_with("res://") && dst.begins_with("res://")) {
base="res:/";
src=src.replace("res://","/");
dst=dst.replace("res://","/");
} else if (src.begins_with("user://") && dst.begins_with("user://")) {
base="user:/";
src=src.replace("user://","/");
dst=dst.replace("user://","/");
} else if (src.begins_with("/") && dst.begins_with("/")) {
//nothing
} else {
//dos style
String src_begin=src.get_slicec('/',0);
String dst_begin=dst.get_slicec('/',0);
if (src_begin!=dst_begin)
return p_path; //impossible to do this
base=src_begin;
src=src.substr(src_begin.length(),src.length());
dst=dst.substr(dst_begin.length(),dst.length());
}
//remove leading and trailing slash and split
Vector<String> src_dirs=src.substr(1,src.length()-2).split("/");
Vector<String> dst_dirs=dst.substr(1,dst.length()-2).split("/");
//find common parent
int common_parent=0;
while(true) {
if (src_dirs.size()==common_parent)
break;
if (dst_dirs.size()==common_parent)
break;
if (src_dirs[common_parent]!=dst_dirs[common_parent])
break;
common_parent++;
}
common_parent--;
String dir;
for(int i=src_dirs.size()-1;i>common_parent;i--) {
dir+="../";
}
for(int i=common_parent+1;i<dst_dirs.size();i++) {
dir+=dst_dirs[i]+"/";
}
if (dir.length()==0)
dir="./";
return dir;
}
bool String::is_valid_html_color() const {
return Color::html_is_valid(*this);
}
bool String::is_valid_ip_address() const {
if (find(":") >= 0) {
Vector<String> ip = split(":");
for (int i=0; i<ip.size(); i++) {
String n = ip[i];
if (n.empty())
continue;
if (n.is_valid_hex_number(false)) {
int nint = n.hex_to_int(false);
if (nint < 0 || nint > 0xffff)
return false;
continue;
};
if (!n.is_valid_ip_address())
return false;
};
} else {
Vector<String> ip = split(".");
if (ip.size()!=4)
return false;
for(int i=0;i<ip.size();i++) {
String n = ip[i];
if (!n.is_valid_integer())
return false;
int val = n.to_int();
if (val<0 || val>255)
return false;
}
};
return true;
}
bool String::is_resource_file() const {
return begins_with("res://") && find("::")==-1;
}
bool String::is_rel_path() const {
return !is_abs_path();
}
String String::get_base_dir() const {
int basepos = find("://");
String rs;
String base;
if (basepos!=-1) {
int end = basepos+3;
rs = substr(end,length());
base = substr(0,end);
} else {
if (begins_with("/")) {
rs=substr(1,length());
base="/";
} else {
rs=*this;
}
}
int sep = MAX( rs.find_last("/"), rs.find_last("\\") );
if (sep==-1)
return base;
return base+rs.substr(0,sep);
}
String String::get_file() const {
int sep = MAX( find_last("/"), find_last("\\") );
if (sep==-1)
return *this;
return substr(sep+1,length());
}
String String::extension() const {
int pos = find_last(".");
if (pos<0)
return *this;
return substr( pos+1, length() );
}
String String::plus_file(const String& p_file) const {
if (length()>0 && operator [](length()-1)=='/')
return *this+p_file;
else
return *this+"/"+p_file;
}
String String::percent_encode() const {
CharString cs = utf8();
String encoded;
for(int i=0;i<cs.length();i++) {
uint8_t c = cs[i];
if ( (c>='A' && c<='Z') || (c>='a' && c<='z') || (c>='0' && c<='9') || c=='-' || c=='_' || c=='~' || c=='.') {
char p[2]={(char)c,0};
encoded+=p;
} else {
char p[4]={'%',0,0,0};
static const char hex[16]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
p[1]=hex[c>>4];
p[2]=hex[c&0xF];
encoded+=p;
}
}
return encoded;
}
String String::percent_decode() const {
CharString pe;
CharString cs = utf8();
for(int i=0;i<cs.length();i++) {
uint8_t c = cs[i];
if (c=='%' && i<length()-2) {
uint8_t a = LOWERCASE(cs[i+1]);
uint8_t b = LOWERCASE(cs[i+2]);
c=0;
if (a>='0' && a<='9')
c=(a-'0')<<4;
else if (a>='a' && a<='f')
c=(a-'a'+10)<<4;
else
continue;
uint8_t d=0;
if (b>='0' && b<='9')
d=(b-'0');
else if (b>='a' && b<='f')
d=(b-'a'+10);
else
continue;
c+=d;
i+=2;
}
pe.push_back(c);
}
pe.push_back(0);
return String::utf8(pe.ptr());
}
String String::basename() const {
int pos = find_last(".");
if (pos<0)
return *this;
return substr( 0, pos );
}
String itos(int64_t p_val) {
return String::num_int64(p_val);
}
String rtos(double p_val) {
return String::num(p_val);
}
String rtoss(double p_val) {
return String::num_scientific(p_val);
}
// Right-pad with a character.
String String::rpad(int min_length, const String& character) const {
String s = *this;
int padding = min_length - s.length();
if (padding > 0) {
for (int i = 0; i < padding; i++) s = s + character;
}
return s;
}
// Left-pad with a character.
String String::lpad(int min_length, const String& character) const {
String s = *this;
int padding = min_length - s.length();
if (padding > 0) {
for (int i = 0; i < padding; i++) s = character + s;
}
return s;
}
// sprintf is implemented in GDScript via:
// "fish %s pie" % "frog"
// "fish %s %d pie" % ["frog", 12]
// In case of an error, the string returned is the error description and "error" is true.
String String::sprintf(const Array& values, bool* error) const {
String formatted;
CharType* self = (CharType*)c_str();
bool in_format = false;
int value_index = 0;
int min_chars;
int min_decimals;
bool in_decimals;
bool pad_with_zeroes;
bool left_justified;
bool show_sign;
*error = true;
for (; *self; self++) {
const CharType c = *self;
if (in_format) { // We have % - lets see what else we get.
switch (c) {
case '%': { // Replace %% with %
formatted += chr(c);
in_format = false;
break;
}
case 'd': // Integer (signed)
case 'o': // Octal
case 'x': // Hexadecimal (lowercase)
case 'X': { // Hexadecimal (uppercase)
if (value_index >= values.size()) {
return "not enough arguments for format string";
}
if (!values[value_index].is_num()) {
return "a number is required";
}
int64_t value = values[value_index];
int base;
bool capitalize = false;
switch (c) {
case 'd': base = 10; break;
case 'o': base = 8; break;
case 'x': base = 16; break;
case 'X': base = 16; capitalize = true; break;
}
// Get basic number.
String str = String::num_int64(value, base, capitalize);
// Sign.
if (show_sign && value >= 0) {
str = str.insert(0, "+");
}
// Padding.
String pad_char = pad_with_zeroes ? String("0") : String(" ");
if (left_justified) {
str = str.rpad(min_chars, pad_char);
} else {
str = str.lpad(min_chars, pad_char);
}
formatted += str;
++value_index;
in_format = false;
break;
}
case 'f': { // Float
if (value_index >= values.size()) {
return "not enough arguments for format string";
}
if (!values[value_index].is_num()) {
return "a number is required";
}
double value = values[value_index];
String str = String::num(value, min_decimals);
// Pad decimals out.
str = str.pad_decimals(min_decimals);
// Show sign
if (show_sign && value >= 0) {
str = str.insert(0, "+");
}
// Padding
if (left_justified) {
str = str.rpad(min_chars);
} else {
str = str.lpad(min_chars);
}
formatted += str;
++value_index;
in_format = false;
break;
}
case 's': { // String
if (value_index >= values.size()) {
return "not enough arguments for format string";
}
String str = values[value_index];
// Padding.
if (left_justified) {
str = str.rpad(min_chars);
} else {
str = str.lpad(min_chars);
}
formatted += str;
++value_index;
in_format = false;
break;
}
case 'c': {
if (value_index >= values.size()) {
return "not enough arguments for format string";
}
// Convert to character.
String str;
if (values[value_index].is_num()) {
int value = values[value_index];
if (value < 0) {
return "unsigned byte integer is lower than maximum";
} else if (value > 255) {
return "unsigned byte integer is greater than maximum";
}
str = chr(values[value_index]);
} else if (values[value_index].get_type() == Variant::STRING) {
str = values[value_index];
if (str.length() != 1) {
return "%c requires number or single-character string";
}
} else {
return "%c requires number or single-character string";
}
// Padding.
if (left_justified) {
str = str.rpad(min_chars);
} else {
str = str.lpad(min_chars);
}
formatted += str;
++value_index;
in_format = false;
break;
}
case '-': { // Left justify
left_justified = true;
break;
}
case '+': { // Show + if positive.
show_sign = true;
break;
}
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
int n = c - '0';
if (in_decimals) {
min_decimals *= 10;
min_decimals += n;
} else {
if (c == '0' && min_chars == 0) {
pad_with_zeroes = true;
} else {
min_chars *= 10;
min_chars += n;
}
}
break;
}
case '.': { // Float separtor.
if (in_decimals) {
return "too many decimal points in format";
}
in_decimals = true;
min_decimals = 0; // We want to add the value manually.
break;
}
case '*': { // Dyanmic width, based on value.
if (value_index >= values.size()) {
return "not enough arguments for format string";
}
if (!values[value_index].is_num()) {
return "* wants number";
}
int size = values[value_index];
if (in_decimals) {
min_decimals = size;
} else {
min_chars = size;
}
++value_index;
break;
}
default: {
return "unsupported format character";
}
}
} else { // Not in format string.
switch (c) {
case '%':
in_format = true;
// Back to defaults:
min_chars = 0;
min_decimals = 6;
pad_with_zeroes = false;
left_justified = false;
show_sign = false;
in_decimals = false;
break;
default:
formatted += chr(c);
}
}
}
if (in_format) {
return "incomplete format";
}
if (value_index != values.size()) {
return "not all arguments converted during string formatting";
}
*error = false;
return formatted;
}
#include "translation.h"
#ifdef TOOLS_ENABLED
String TTR(const String& p_text) {
if (TranslationServer::get_singleton()) {
return TranslationServer::get_singleton()->tool_translate(p_text);
}
return p_text;
}
#endif
String RTR(const String& p_text) {
if (TranslationServer::get_singleton()) {
String rtr = TranslationServer::get_singleton()->tool_translate(p_text);
if (rtr==String() || rtr==p_text) {
return TranslationServer::get_singleton()->translate(p_text);
} else {
return rtr;
}
}
return p_text;
}
Reference in New Issue View Git Blame Copy Permalink