Bool as return value for logical operations

mcspr · mcspr · commit a010db7849f4 · 2021-05-15T23:53:49.000+03:00
diff --git a/api/String.cpp b/api/String.cpp
@@ -166,25 +166,25 @@ void String::invalidate(void)
 	capacity = len = 0;
 }
 
-unsigned char String::reserve(unsigned int size)
+bool String::reserve(unsigned int size)
 {
 	if (buffer && capacity >= size) return 1;
 	if (changeBuffer(size)) {
 		if (len == 0) buffer[0] = 0;
-		return 1;
+		return true;
 	}
-	return 0;
+	return false;
 }
 
-unsigned char String::changeBuffer(unsigned int maxStrLen)
+bool String::changeBuffer(unsigned int maxStrLen)
 {
 	char *newbuffer = (char *)realloc(buffer, maxStrLen + 1);
 	if (newbuffer) {
 		buffer = newbuffer;
 		capacity = maxStrLen;
-		return 1;
+		return true;
 	}
-	return 0;
+	return false;
 }
 
 /*********************************************/
@@ -281,93 +281,93 @@ String & String::operator = (const __FlashStringHelper *pstr)
 /*  concat                                   */
 /*********************************************/
 
-unsigned char String::concat(const String &s)
+bool String::concat(const String &s)
 {
 	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;
-	if (length == 0) return 1;
-	if (!reserve(newlen)) return 0;
+	if (!cstr) return false;
+	if (length == 0) return true;
+	if (!reserve(newlen)) return false;
 	memcpy(buffer + len, cstr, length);
 	len = newlen;
 	buffer[len] = '\0';
-	return 1;
+	return true;
 }
 
-unsigned char String::concat(const char *cstr)
+bool String::concat(const char *cstr)
 {
-	if (!cstr) return 0;
+	if (!cstr) return false;
 	return concat(cstr, strlen(cstr));
 }
 
-unsigned char String::concat(char c)
+bool String::concat(char c)
 {
 	return concat(&c, 1);
 }
 
-unsigned char String::concat(unsigned char num)
+bool String::concat(unsigned char num)
 {
 	char buf[1 + 3 * sizeof(unsigned char)];
 	itoa(num, buf, 10);
 	return concat(buf);
 }
 
-unsigned char String::concat(int num)
+bool String::concat(int num)
 {
 	char buf[2 + 3 * sizeof(int)];
 	itoa(num, buf, 10);
 	return concat(buf);
 }
 
-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);
 }
 
-unsigned char String::concat(long num)
+bool String::concat(long num)
 {
 	char buf[2 + 3 * sizeof(long)];
 	ltoa(num, buf, 10);
 	return concat(buf);
 }
 
-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);
 }
 
-unsigned char String::concat(float num)
+bool String::concat(float num)
 {
 	char buf[20];
 	char* string = dtostrf(num, 4, 2, buf);
 	return concat(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);
 }
 
-unsigned char String::concat(const __FlashStringHelper * str)
+bool String::concat(const __FlashStringHelper * str)
 {
-	if (!str) return 0;
+	if (!str) return false;
 	int length = strlen_P((const char *) 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;
 	strcpy_P(buffer + len, (const char *) str);
 	len = newlen;
-	return 1;
+	return true;
 }
 
 /*********************************************/
@@ -475,46 +475,46 @@ int String::compareTo(const char *cstr) const
 	return strcmp(buffer, cstr);
 }
 
-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) return buffer[0] == 0;
 	return strcmp(buffer, cstr) == 0;
 }
 
-unsigned char String::equalsIgnoreCase( const String &s2 ) const
+bool String::equalsIgnoreCase( const String &s2 ) const
 {
-	if (this == &s2) return 1;
-	if (len != s2.len) return 0;
-	if (len == 0) return 1;
+	if (this == &s2) return true;
+	if (len != s2.len) return false;
+	if (len == 0) return true;
 	const char *p1 = buffer;
 	const char *p2 = s2.buffer;
 	while (*p1) {
-		if (tolower(*p1++) != tolower(*p2++)) return 0;
+		if (tolower(*p1++) != tolower(*p2++)) return false;
 	} 
-	return 1;
+	return true;
 }
 
-unsigned char String::startsWith( const String &s2 ) const
+bool String::startsWith( const String &s2 ) const
 {
-	if (len < s2.len) return 0;
+	if (len < s2.len) 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 > len - s2.len || !buffer || !s2.buffer) return 0;
+	if (offset > len - s2.len || !buffer || !s2.buffer) 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;
+	if ( len < s2.len || !buffer || !s2.buffer) return false;
 	return strcmp(&buffer[len - s2.len], s2.buffer) == 0;
 }
 
diff --git a/api/String.h b/api/String.h
@@ -90,7 +90,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 {return len;}
 
 	// creates a copy of the assigned value.  if the value is null or
@@ -109,19 +109,19 @@ 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 unsucessful.
-	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 num);
-	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(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 num);
+	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(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)
@@ -153,33 +153,33 @@ class String
 	operator StringIfHelperType() const { return buffer ? &String::StringIfHelper : 0; }
 	int compareTo(const String &s) const;
 	int compareTo(const char *cstr) const;
-	unsigned char equals(const String &s) const;
-	unsigned char equals(const char *cstr) const;
-
-	friend unsigned char operator == (const String &a, const String &b) { return a.equals(b); }
-	friend unsigned char operator == (const String &a, const char   *b) { return a.equals(b); }
-	friend unsigned char operator == (const char   *a, const String &b) { return b == a; }
-	friend unsigned char operator <  (const String &a, const String &b) { return a.compareTo(b) < 0; }
-	friend unsigned char operator <  (const String &a, const char   *b) { return a.compareTo(b) < 0; }
-	friend unsigned char operator <  (const char   *a, const String &b) { return b.compareTo(a) > 0; }
-
-	friend unsigned char operator != (const String &a, const String &b) { return !(a == b); }
-	friend unsigned char operator != (const String &a, const char   *b) { return !(a == b); }
-	friend unsigned char operator != (const char   *a, const String &b) { return !(a == b); }
-	friend unsigned char operator >  (const String &a, const String &b) { return b < a; }
-	friend unsigned char operator >  (const String &a, const char   *b) { return b < a; }
-	friend unsigned char operator >  (const char   *a, const String &b) { return b < a; }
-	friend unsigned char operator <= (const String &a, const String &b) { return !(b < a); }
-	friend unsigned char operator <= (const String &a, const char   *b) { return !(b < a); }
-	friend unsigned char operator <= (const char   *a, const String &b) { return !(b < a); }
-	friend unsigned char operator >= (const String &a, const String &b) { return !(a < b); }
-	friend unsigned char operator >= (const String &a, const char   *b) { return !(a < b); }
-	friend unsigned char operator >= (const char   *a, const String &b) { return !(a < b); }
-
-	unsigned char equalsIgnoreCase(const String &s) const;
-	unsigned char startsWith( const String &prefix) const;
-	unsigned char startsWith(const String &prefix, unsigned int offset) const;
-	unsigned char endsWith(const String &suffix) const;
+	bool equals(const String &s) const;
+	bool equals(const char *cstr) const;
+
+	friend bool operator == (const String &a, const String &b) { return a.equals(b); }
+	friend bool operator == (const String &a, const char   *b) { return a.equals(b); }
+	friend bool operator == (const char   *a, const String &b) { return b == a; }
+	friend bool operator <  (const String &a, const String &b) { return a.compareTo(b) < 0; }
+	friend bool operator <  (const String &a, const char   *b) { return a.compareTo(b) < 0; }
+	friend bool operator <  (const char   *a, const String &b) { return b.compareTo(a) > 0; }
+
+	friend bool operator != (const String &a, const String &b) { return !(a == b); }
+	friend bool operator != (const String &a, const char   *b) { return !(a == b); }
+	friend bool operator != (const char   *a, const String &b) { return !(a == b); }
+	friend bool operator >  (const String &a, const String &b) { return b < a; }
+	friend bool operator >  (const String &a, const char   *b) { return b < a; }
+	friend bool operator >  (const char   *a, const String &b) { return b < a; }
+	friend bool operator <= (const String &a, const String &b) { return !(b < a); }
+	friend bool operator <= (const String &a, const char   *b) { return !(b < a); }
+	friend bool operator <= (const char   *a, const String &b) { return !(b < a); }
+	friend bool operator >= (const String &a, const String &b) { return !(a < b); }
+	friend bool operator >= (const String &a, const char   *b) { return !(a < b); }
+	friend bool operator >= (const char   *a, const String &b) { return !(a < b); }
+
+	bool equalsIgnoreCase(const String &s) const;
+	bool startsWith( const String &prefix) const;
+	bool startsWith(const String &prefix, unsigned int offset) const;
+	bool endsWith(const String &suffix) const;
 
 	// character acccess
 	char charAt(unsigned int index) const;
@@ -228,7 +228,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);

Original file line number	Diff line number	Diff line change
`@@ -166,25 +166,25 @@ void String::invalidate(void)`
`166`	`166`	`capacity = len = 0;`
`167`	`167`	`}`
`168`	`168`
`169`		`-unsigned char String::reserve(unsigned int size)`
	`169`	`+bool String::reserve(unsigned int size)`
`170`	`170`	`{`
`171`	`171`	`if (buffer && capacity >= size) return 1;`
`172`	`172`	`if (changeBuffer(size)) {`
`173`	`173`	`if (len == 0) buffer[0] = 0;`
`174`		`- return 1;`
	`174`	`+ return true;`
`175`	`175`	`}`
`176`		`- return 0;`
	`176`	`+ return false;`
`177`	`177`	`}`
`178`	`178`
`179`		`-unsigned char String::changeBuffer(unsigned int maxStrLen)`
	`179`	`+bool String::changeBuffer(unsigned int maxStrLen)`
`180`	`180`	`{`
`181`	`181`	`char newbuffer = (char )realloc(buffer, maxStrLen + 1);`
`182`	`182`	`if (newbuffer) {`
`183`	`183`	`buffer = newbuffer;`
`184`	`184`	`capacity = maxStrLen;`
`185`		`- return 1;`
	`185`	`+ return true;`
`186`	`186`	`}`
`187`		`- return 0;`
	`187`	`+ return false;`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`/*********************************************/`
`@@ -281,93 +281,93 @@ String & String::operator = (const __FlashStringHelper *pstr)`
`281`	`281`	`/* concat */`
`282`	`282`	`/*********************************************/`
`283`	`283`
`284`		`-unsigned char String::concat(const String &s)`
	`284`	`+bool String::concat(const String &s)`
`285`	`285`	`{`
`286`	`286`	`return concat(s.buffer, s.len);`
`287`	`287`	`}`
`288`	`288`
`289`		`-unsigned char String::concat(const char *cstr, unsigned int length)`
	`289`	`+bool String::concat(const char *cstr, unsigned int length)`
`290`	`290`	`{`
`291`	`291`	`unsigned int newlen = len + length;`
`292`		`- if (!cstr) return 0;`
`293`		`- if (length == 0) return 1;`
`294`		`- if (!reserve(newlen)) return 0;`
	`292`	`+ if (!cstr) return false;`
	`293`	`+ if (length == 0) return true;`
	`294`	`+ if (!reserve(newlen)) return false;`
`295`	`295`	`memcpy(buffer + len, cstr, length);`
`296`	`296`	`len = newlen;`
`297`	`297`	`buffer[len] = '\0';`
`298`		`- return 1;`
	`298`	`+ return true;`
`299`	`299`	`}`
`300`	`300`
`301`		`-unsigned char String::concat(const char *cstr)`
	`301`	`+bool String::concat(const char *cstr)`
`302`	`302`	`{`
`303`		`- if (!cstr) return 0;`
	`303`	`+ if (!cstr) return false;`
`304`	`304`	`return concat(cstr, strlen(cstr));`
`305`	`305`	`}`
`306`	`306`
`307`		`-unsigned char String::concat(char c)`
	`307`	`+bool String::concat(char c)`
`308`	`308`	`{`
`309`	`309`	`return concat(&c, 1);`
`310`	`310`	`}`
`311`	`311`
`312`		`-unsigned char String::concat(unsigned char num)`
	`312`	`+bool String::concat(unsigned char num)`
`313`	`313`	`{`
`314`	`314`	`char buf[1 + 3 * sizeof(unsigned char)];`
`315`	`315`	`itoa(num, buf, 10);`
`316`	`316`	`return concat(buf);`
`317`	`317`	`}`
`318`	`318`
`319`		`-unsigned char String::concat(int num)`
	`319`	`+bool String::concat(int num)`
`320`	`320`	`{`
`321`	`321`	`char buf[2 + 3 * sizeof(int)];`
`322`	`322`	`itoa(num, buf, 10);`
`323`	`323`	`return concat(buf);`
`324`	`324`	`}`
`325`	`325`
`326`		`-unsigned char String::concat(unsigned int num)`
	`326`	`+bool String::concat(unsigned int num)`
`327`	`327`	`{`
`328`	`328`	`char buf[1 + 3 * sizeof(unsigned int)];`
`329`	`329`	`utoa(num, buf, 10);`
`330`	`330`	`return concat(buf);`
`331`	`331`	`}`
`332`	`332`
`333`		`-unsigned char String::concat(long num)`
	`333`	`+bool String::concat(long num)`
`334`	`334`	`{`
`335`	`335`	`char buf[2 + 3 * sizeof(long)];`
`336`	`336`	`ltoa(num, buf, 10);`
`337`	`337`	`return concat(buf);`
`338`	`338`	`}`
`339`	`339`
`340`		`-unsigned char String::concat(unsigned long num)`
	`340`	`+bool String::concat(unsigned long num)`
`341`	`341`	`{`
`342`	`342`	`char buf[1 + 3 * sizeof(unsigned long)];`
`343`	`343`	`ultoa(num, buf, 10);`
`344`	`344`	`return concat(buf);`
`345`	`345`	`}`
`346`	`346`
`347`		`-unsigned char String::concat(float num)`
	`347`	`+bool String::concat(float num)`
`348`	`348`	`{`
`349`	`349`	`char buf[20];`
`350`	`350`	`char* string = dtostrf(num, 4, 2, buf);`
`351`	`351`	`return concat(string);`
`352`	`352`	`}`
`353`	`353`
`354`		`-unsigned char String::concat(double num)`
	`354`	`+bool String::concat(double num)`
`355`	`355`	`{`
`356`	`356`	`char buf[20];`
`357`	`357`	`char* string = dtostrf(num, 4, 2, buf);`
`358`	`358`	`return concat(string);`
`359`	`359`	`}`
`360`	`360`
`361`		`-unsigned char String::concat(const __FlashStringHelper * str)`
	`361`	`+bool String::concat(const __FlashStringHelper * str)`
`362`	`362`	`{`
`363`		`- if (!str) return 0;`
	`363`	`+ if (!str) return false;`
`364`	`364`	`int length = strlen_P((const char *) str);`
`365`		`- if (length == 0) return 1;`
	`365`	`+ if (length == 0) return true;`
`366`	`366`	`unsigned int newlen = len + length;`
`367`		`- if (!reserve(newlen)) return 0;`
	`367`	`+ if (!reserve(newlen)) return false;`
`368`	`368`	`strcpy_P(buffer + len, (const char *) str);`
`369`	`369`	`len = newlen;`
`370`		`- return 1;`
	`370`	`+ return true;`
`371`	`371`	`}`
`372`	`372`
`373`	`373`	`/*********************************************/`
`@@ -475,46 +475,46 @@ int String::compareTo(const char *cstr) const`
`475`	`475`	`return strcmp(buffer, cstr);`
`476`	`476`	`}`
`477`	`477`
`478`		`-unsigned char String::equals(const String &s2) const`
	`478`	`+bool String::equals(const String &s2) const`
`479`	`479`	`{`
`480`	`480`	`return (len == s2.len && compareTo(s2) == 0);`
`481`	`481`	`}`
`482`	`482`
`483`		`-unsigned char String::equals(const char *cstr) const`
	`483`	`+bool String::equals(const char *cstr) const`
`484`	`484`	`{`
`485`	`485`	`if (len == 0) return (cstr == NULL \|\| *cstr == 0);`
`486`	`486`	`if (cstr == NULL) return buffer[0] == 0;`
`487`	`487`	`return strcmp(buffer, cstr) == 0;`
`488`	`488`	`}`
`489`	`489`
`490`		`-unsigned char String::equalsIgnoreCase( const String &s2 ) const`
	`490`	`+bool String::equalsIgnoreCase( const String &s2 ) const`
`491`	`491`	`{`
`492`		`- if (this == &s2) return 1;`
`493`		`- if (len != s2.len) return 0;`
`494`		`- if (len == 0) return 1;`
	`492`	`+ if (this == &s2) return true;`
	`493`	`+ if (len != s2.len) return false;`
	`494`	`+ if (len == 0) return true;`
`495`	`495`	`const char *p1 = buffer;`
`496`	`496`	`const char *p2 = s2.buffer;`
`497`	`497`	`while (*p1) {`
`498`		`- if (tolower(p1++) != tolower(p2++)) return 0;`
	`498`	`+ if (tolower(p1++) != tolower(p2++)) return false;`
`499`	`499`	`}`
`500`		`- return 1;`
	`500`	`+ return true;`
`501`	`501`	`}`
`502`	`502`
`503`		`-unsigned char String::startsWith( const String &s2 ) const`
	`503`	`+bool String::startsWith( const String &s2 ) const`
`504`	`504`	`{`
`505`		`- if (len < s2.len) return 0;`
	`505`	`+ if (len < s2.len) return false;`
`506`	`506`	`return startsWith(s2, 0);`
`507`	`507`	`}`
`508`	`508`
`509`		`-unsigned char String::startsWith( const String &s2, unsigned int offset ) const`
	`509`	`+bool String::startsWith( const String &s2, unsigned int offset ) const`
`510`	`510`	`{`
`511`		`- if (offset > len - s2.len \|\| !buffer \|\| !s2.buffer) return 0;`
	`511`	`+ if (offset > len - s2.len \|\| !buffer \|\| !s2.buffer) return false;`
`512`	`512`	`return strncmp( &buffer[offset], s2.buffer, s2.len ) == 0;`
`513`	`513`	`}`
`514`	`514`
`515`		`-unsigned char String::endsWith( const String &s2 ) const`
	`515`	`+bool String::endsWith( const String &s2 ) const`
`516`	`516`	`{`
`517`		`- if ( len < s2.len \|\| !buffer \|\| !s2.buffer) return 0;`
	`517`	`+ if ( len < s2.len \|\| !buffer \|\| !s2.buffer) return false;`
`518`	`518`	`return strcmp(&buffer[len - s2.len], s2.buffer) == 0;`
`519`	`519`	`}`
`520`	`520`