diff --git a/cores/esp32/WString.cpp b/cores/esp32/WString.cpp
index f31024ea8ba..9b92fb84559 100644
--- a/cores/esp32/WString.cpp
+++ b/cores/esp32/WString.cpp
@@ -176,26 +176,25 @@ void String::invalidate(void) {
init();
}
-unsigned char String::reserve(unsigned int size) {
+bool String::reserve(unsigned int size) {
if(buffer() && capacity() >= size)
- return 1;
+ return true;
if(changeBuffer(size)) {
if(len() == 0)
wbuffer()[0] = 0;
- return 1;
+ return true;
}
- return 0;
+ return false;
}
-unsigned char String::changeBuffer(unsigned int maxStrLen) {
+bool String::changeBuffer(unsigned int maxStrLen) {
// Can we use SSO here to avoid allocation?
if (maxStrLen < sizeof(sso.buff) - 1) {
if (isSSO() || !buffer()) {
// Already using SSO, nothing to do
- uint16_t oldLen = len();
+ uint16_t oldLen = len();
setSSO(true);
setLen(oldLen);
- return 1;
} else { // if bufptr && !isSSO()
// Using bufptr, need to shrink into sso.buff
char temp[sizeof(sso.buff)];
@@ -205,8 +204,8 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
setSSO(true);
memcpy(wbuffer(), temp, maxStrLen);
setLen(oldLen);
- return 1;
}
+ return true;
}
// Fallthrough to normal allocator
size_t newSize = (maxStrLen + 16) & (~0xf);
@@ -230,9 +229,9 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
setCapacity(newSize - 1);
setBuffer(newbuffer);
setLen(oldLen); // Needed in case of SSO where len() never existed
- return 1;
+ return true;
}
- return 0;
+ return false;
}
// /*********************************************/
@@ -338,34 +337,34 @@ String & String::operator =(const __FlashStringHelper *pstr) {
// /* concat */
// /*********************************************/
-unsigned char String::concat(const String &s) {
+bool String::concat(const String &s) {
// Special case if we're concatting ourself (s += s;) since we may end up
// realloc'ing the buffer and moving s.buffer in the method called
if (&s == this) {
unsigned int newlen = 2 * len();
if (!s.buffer())
- return 0;
+ return false;
if (s.len() == 0)
- return 1;
+ return true;
if (!reserve(newlen))
- return 0;
+ return false;
memmove(wbuffer() + len(), buffer(), len());
setLen(newlen);
wbuffer()[len()] = 0;
- return 1;
+ return true;
} else {
return concat(s.buffer(), s.len());
}
}
-unsigned char String::concat(const char *cstr, unsigned int length) {
+bool String::concat(const char *cstr, unsigned int length) {
unsigned int newlen = len() + length;
if(!cstr)
- return 0;
+ return false;
if(length == 0)
- return 1;
+ return true;
if(!reserve(newlen))
- return 0;
+ return false;
if (cstr >= wbuffer() && cstr < wbuffer() + len())
// compatible with SSO in ram #6155 (case "x += x.c_str()")
memmove(wbuffer() + len(), cstr, length + 1);
@@ -373,79 +372,82 @@ unsigned char String::concat(const char *cstr, unsigned int length) {
// compatible with source in flash #6367
memcpy_P(wbuffer() + len(), cstr, length + 1);
setLen(newlen);
- return 1;
+ return true;
}
-unsigned char String::concat(const char *cstr) {
+bool String::concat(const char *cstr) {
if(!cstr)
- return 0;
+ return false;
return concat(cstr, strlen(cstr));
}
-unsigned char String::concat(char c) {
+bool String::concat(char c) {
char buf[] = { c, '\0' };
return concat(buf, 1);
}
-unsigned char String::concat(unsigned char num) {
+bool String::concat(unsigned char num) {
char buf[1 + 3 * sizeof(unsigned char)];
return concat(buf, sprintf(buf, "%d", num));
}
-unsigned char String::concat(int num) {
+bool String::concat(int num) {
char buf[2 + 3 * sizeof(int)];
return concat(buf, sprintf(buf, "%d", num));
}
-unsigned char String::concat(unsigned int num) {
+bool String::concat(unsigned int num) {
char buf[1 + 3 * sizeof(unsigned int)];
utoa(num, buf, 10);
return concat(buf, strlen(buf));
}
-unsigned char String::concat(long num) {
+bool String::concat(long num) {
char buf[2 + 3 * sizeof(long)];
return concat(buf, sprintf(buf, "%ld", num));
}
-unsigned char String::concat(unsigned long num) {
+bool String::concat(unsigned long num) {
char buf[1 + 3 * sizeof(unsigned long)];
ultoa(num, buf, 10);
return concat(buf, strlen(buf));
}
-unsigned char String::concat(float num) {
+bool String::concat(float num) {
char buf[20];
char* string = dtostrf(num, 4, 2, buf);
return concat(string, strlen(string));
}
-unsigned char String::concat(double num) {
+bool String::concat(double num) {
char buf[20];
char* string = dtostrf(num, 4, 2, buf);
return concat(string, strlen(string));
}
-unsigned char String::concat(long long num) {
+bool String::concat(long long num) {
char buf[2 + 3 * sizeof(long long)];
return concat(buf, sprintf(buf, "%lld", num)); // NOT SURE - NewLib Nano ... does it support %lld?
}
-unsigned char String::concat(unsigned long long num) {
+bool String::concat(unsigned long long num) {
char buf[1 + 3 * sizeof(unsigned long long)];
ulltoa(num, buf, 10);
return concat(buf, strlen(buf));
}
-unsigned char String::concat(const __FlashStringHelper * str) {
- if (!str) return 0;
+bool String::concat(const __FlashStringHelper * str) {
+ if (!str)
+ return false;
int length = strlen_P((PGM_P)str);
- if (length == 0) return 1;
+ if (length == 0)
+ return true;
unsigned int newlen = len() + length;
- if (!reserve(newlen)) return 0;
+ if (!reserve(newlen))
+ return false;
memcpy_P(wbuffer() + len(), (PGM_P)str, length + 1);
setLen(newlen);
- return 1;
+ return true;
}
/*********************************************/
@@ -559,11 +561,11 @@ int String::compareTo(const String &s) const {
return strcmp(buffer(), s.buffer());
}
-unsigned char String::equals(const String &s2) const {
+bool String::equals(const String &s2) const {
return (len() == s2.len() && compareTo(s2) == 0);
}
-unsigned char String::equals(const char *cstr) const {
+bool String::equals(const char *cstr) const {
if(len() == 0)
return (cstr == NULL || *cstr == 0);
if(cstr == NULL)
@@ -571,36 +573,36 @@ unsigned char String::equals(const char *cstr) const {
return strcmp(buffer(), cstr) == 0;
}
-unsigned char String::operator<(const String &rhs) const {
+bool String::operator<(const String &rhs) const {
return compareTo(rhs) < 0;
}
-unsigned char String::operator>(const String &rhs) const {
+bool String::operator>(const String &rhs) const {
return compareTo(rhs) > 0;
}
-unsigned char String::operator<=(const String &rhs) const {
+bool String::operator<=(const String &rhs) const {
return compareTo(rhs) <= 0;
}
-unsigned char String::operator>=(const String &rhs) const {
+bool String::operator>=(const String &rhs) const {
return compareTo(rhs) >= 0;
}
-unsigned char String::equalsIgnoreCase(const String &s2) const {
+bool String::equalsIgnoreCase(const String &s2) const {
if(this == &s2)
- return 1;
+ return true;
if(len() != s2.len())
- return 0;
+ return false;
if(len() == 0)
- return 1;
+ return true;
const char *p1 = buffer();
const char *p2 = s2.buffer();
while(*p1) {
if(tolower(*p1++) != tolower(*p2++))
- return 0;
+ return false;
}
- return 1;
+ return true;
}
unsigned char String::equalsConstantTime(const String &s2) const {
@@ -630,21 +632,21 @@ unsigned char String::equalsConstantTime(const String &s2) const {
return (equalcond & diffcond); //bitwise AND
}
-unsigned char String::startsWith(const String &s2) const {
+bool String::startsWith(const String &s2) const {
if(len() < s2.len())
- return 0;
+ return false;
return startsWith(s2, 0);
}
-unsigned char String::startsWith(const String &s2, unsigned int offset) const {
+bool String::startsWith(const String &s2, unsigned int offset) const {
if(offset > (unsigned)(len() - s2.len()) || !buffer() || !s2.buffer())
- return 0;
+ return false;
return strncmp(&buffer()[offset], s2.buffer(), s2.len()) == 0;
}
-unsigned char String::endsWith(const String &s2) const {
+bool String::endsWith(const String &s2) const {
if(len() < s2.len() || !buffer() || !s2.buffer())
- return 0;
+ return false;
return strcmp(&buffer()[len() - s2.len()], s2.buffer()) == 0;
}
diff --git a/cores/esp32/WString.h b/cores/esp32/WString.h
index 99e85e0df52..f7f0d814ddc 100644
--- a/cores/esp32/WString.h
+++ b/cores/esp32/WString.h
@@ -81,7 +81,7 @@ class String {
// return true on success, false on failure (in which case, the string
// is left unchanged). reserve(0), if successful, will validate an
// invalid string (i.e., "if (s)" will be true afterwards)
- unsigned char reserve(unsigned int size);
+ bool reserve(unsigned int size);
inline unsigned int length(void) const {
if(buffer()) {
return len();
@@ -112,21 +112,21 @@ class String {
// returns true on success, false on failure (in which case, the string
// is left unchanged). if the argument is null or invalid, the
// concatenation is considered unsuccessful.
- unsigned char concat(const String &str);
- unsigned char concat(const char *cstr);
- unsigned char concat(const char *cstr, unsigned int length);
- unsigned char concat(const uint8_t *cstr, unsigned int length) {return concat((const char*)cstr, length);}
- unsigned char concat(char c);
- unsigned char concat(unsigned char c);
- unsigned char concat(int num);
- unsigned char concat(unsigned int num);
- unsigned char concat(long num);
- unsigned char concat(unsigned long num);
- unsigned char concat(float num);
- unsigned char concat(double num);
- unsigned char concat(long long num);
- unsigned char concat(unsigned long long num);
- unsigned char concat(const __FlashStringHelper * str);
+ bool concat(const String &str);
+ bool concat(const char *cstr);
+ bool concat(const char *cstr, unsigned int length);
+ bool concat(const uint8_t *cstr, unsigned int length) {return concat((const char*)cstr, length);}
+ bool concat(char c);
+ bool concat(unsigned char c);
+ bool concat(int num);
+ bool concat(unsigned int num);
+ bool concat(long num);
+ bool concat(unsigned long num);
+ bool concat(float num);
+ bool concat(double num);
+ bool concat(long long num);
+ bool concat(unsigned long long num);
+ bool concat(const __FlashStringHelper * str);
// if there's not enough memory for the concatenated value, the string
// will be left unchanged (but this isn't signalled in any way)
@@ -202,39 +202,39 @@ class String {
return buffer() ? &String::StringIfHelper : 0;
}
int compareTo(const String &s) const;
- unsigned char equals(const String &s) const;
- unsigned char equals(const char *cstr) const;
- unsigned char operator ==(const String &rhs) const {
+ bool equals(const String &s) const;
+ bool equals(const char *cstr) const;
+ bool operator ==(const String &rhs) const {
return equals(rhs);
}
- unsigned char operator ==(const char *cstr) const {
+ bool operator ==(const char *cstr) const {
return equals(cstr);
}
- unsigned char operator !=(const String &rhs) const {
+ bool operator !=(const String &rhs) const {
return !equals(rhs);
}
- unsigned char operator !=(const char *cstr) const {
+ bool operator !=(const char *cstr) const {
return !equals(cstr);
}
- unsigned char operator <(const String &rhs) const;
- unsigned char operator >(const String &rhs) const;
- unsigned char operator <=(const String &rhs) const;
- unsigned char operator >=(const String &rhs) const;
- unsigned char equalsIgnoreCase(const String &s) const;
+ bool operator <(const String &rhs) const;
+ bool operator >(const String &rhs) const;
+ bool operator <=(const String &rhs) const;
+ bool operator >=(const String &rhs) const;
+ bool equalsIgnoreCase(const String &s) const;
unsigned char equalsConstantTime(const String &s) const;
- unsigned char startsWith(const String &prefix) const;
- unsigned char startsWith(const char *prefix) const {
+ bool startsWith(const String &prefix) const;
+ bool startsWith(const char *prefix) const {
return this->startsWith(String(prefix));
}
- unsigned char startsWith(const __FlashStringHelper *prefix) const {
+ bool startsWith(const __FlashStringHelper *prefix) const {
return this->startsWith(String(prefix));
}
- unsigned char startsWith(const String &prefix, unsigned int offset) const;
- unsigned char endsWith(const String &suffix) const;
- unsigned char endsWith(const char *suffix) const {
+ bool startsWith(const String &prefix, unsigned int offset) const;
+ bool endsWith(const String &suffix) const;
+ bool endsWith(const char *suffix) const {
return this->endsWith(String(suffix));
}
- unsigned char endsWith(const __FlashStringHelper * suffix) const {
+ bool endsWith(const __FlashStringHelper * suffix) const {
return this->endsWith(String(suffix));
}
@@ -345,7 +345,7 @@ class String {
protected:
void init(void);
void invalidate(void);
- unsigned char changeBuffer(unsigned int maxStrLen);
+ bool changeBuffer(unsigned int maxStrLen);
// copy and move
String & copy(const char *cstr, unsigned int length);