8000 WString: return bool instead of unsigned char (#7939) · arduino-collections/Arduino@0aaadd9 · GitHub
[go: up one dir, main page]
Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit 0aaadd9

Browse files
mcsprmcspr
authored
WString: return bool instead of unsigned char (esp8266#7939)
Clean up the intent, resulting assembly stays the same.
1 parent 3a3d1c6 commit 0aaadd9

File tree

2 files changed

+92
-99
lines changed

2 files changed

+92
-99
lines changed

‎cores/esp8266/WString.cpp

Lines changed: 55 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -147,18 +147,18 @@ void String::invalidate(void) {
147147
init();
148148
}
149149

150-
unsigned char String::reserve(unsigned int size) {
150+
bool String::reserve(unsigned int size) {
151151
if (buffer() && capacity() >= size)
152-
return 1;
152+
return true;
153153
if (changeBuffer(size)) {
154154
if (len() == 0)
155155
wbuffer()[0] = 0;
156-
return 1;
156+
return true;
157157
}
158-
return 0;
158+
return false;
159159
}
160160

161-
unsigned char String::changeBuffer(unsigned int maxStrLen) {
161+
bool String::changeBuffer(unsigned int maxStrLen) {
162162
// Can we use SSO here to avoid allocation?
163163
if (maxStrLen < sizeof(sso.buff) - 1) {
164164
if (isSSO() || !buffer()) {
@@ -175,7 +175,7 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
175175
memcpy(wbuffer(), temp, maxStrLen);
176176
free((void *)temp);
177177
}
178-
return 1;
178+
return true;
179179
}
180180
// Fallthrough to normal allocator
181181
size_t newSize = (maxStrLen + 16) & (~0xf);
@@ -189,7 +189,7 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
189189
#endif
190190
// Make sure we can fit newsize in the buffer
191191
if (newSize > CAPACITY_MAX) {
192-
return 0;
192+
return false;
193193
}
194194
uint16_t oldLen = len();
195195
char *newbuffer = (char *)realloc(isSSO() ? nullptr : wbuffer(), newSize);
@@ -206,9 +206,9 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
206206
setCapacity(newSize - 1);
207207
setLen(oldLen); // Needed in case of SSO where len() never existed
208208
setBuffer(newbuffer);
209-
return 1;
209+
return true;
210210
}
211-
return 0;
211+
return false;
212212
}
213213

214214
/*********************************************/
@@ -277,111 +277,111 @@ String &String::operator =(const __FlashStringHelper *pstr) {
277277
/* concat */
278278
/*********************************************/
279279

280-
unsigned char String::concat(const String &s) {
280+
bool String::concat(const String &s) {
281281
// Special case if we're concatting ourself (s += s;) since we may end up
282282
// realloc'ing the buffer and moving s.buffer in the method called
283283
if (&s == this) {
284284
unsigned int newlen = 2 * len();
285285
if (!s.buffer())
286-
return 0;
286+
return false;
287287
if (s.len() == 0)
288-
return 1;
288+
return true;
289289
if (!reserve(newlen))
290-
return 0;
290+
return false;
291291
memmove_P(wbuffer() + len(), buffer(), len());
292292
setLen(newlen);
293293
wbuffer()[newlen] = 0;
294-
return 1;
294+
return true;
295295
} else {
296296
return concat(s.buffer(), s.len());
297297
}
298298
}
299299

300-
unsigned char String::concat(const char *cstr, unsigned int length) {
300+
bool String::concat(const char *cstr, unsigned int length) {
301301
unsigned int newlen = len() + length;
302302
if (!cstr)
303-
return 0;
303+
return false;
304304
if (length == 0)
305-
return 1;
305+
return true;
306306
if (!reserve(newlen))
307-
return 0;
307+
return false;
308308
memmove_P(wbuffer() + len(), cstr, length + 1);
309309
setLen(newlen);
310310
wbuffer()[newlen] = 0;
311-
return 1;
311+
return true;
312312
}
313313

314-
unsigned char String::concat(const char *cstr) {
314+
bool String::concat(const char *cstr) {
315315
if (!cstr)
316-
return 0;
316+
return false;
317317
return concat(cstr, strlen(cstr));
318318
}
319319

320-
unsigned char String::concat(char c) {
320+
bool String::concat(char c) {
321321
return concat(&c, 1);
322322
}
323323

324-
unsigned char String::concat(unsigned char num) {
324+
bool String::concat(unsigned char num) {
325325
char buf[1 + 3 * sizeof(unsigned char)];
326326
return concat(buf, sprintf(buf, "%d", num));
327327
}
328328

329-
unsigned char String::concat(int num) {
329+
bool String::concat(int num) {
330330
char buf[2 + 3 * sizeof(int)];
331331
return concat(buf, sprintf(buf, "%d", num));
332332
}
333333

334-
unsigned char String::concat(unsigned int num) {
334+
bool String::concat(unsigned int num) {
335335
char buf[1 + 3 * sizeof(unsigned int)];
336336
utoa(num, buf, 10);
337337
return concat(buf, strlen(buf));
338338
}
339339

340-
unsigned char String::concat(long num) {
340+
bool String::concat(long num) {
341341
char buf[2 + 3 * sizeof(long)];
342342
return concat(buf, sprintf(buf, "%ld", num));
343343
}
344344

345-
unsigned char String::concat(unsigned long num) {
345+
bool String::concat(unsigned long num) {
346346
char buf[1 + 3 * sizeof(unsigned long)];
347347
ultoa(num, buf, 10);
348348
return concat(buf, strlen(buf));
349349
}
350350

351-
unsigned char String::concat(long long num) {
351+
bool String::concat(long long num) {
352352
char buf[2 + 3 * sizeof(long long)];
353353
return concat(buf, sprintf(buf, "%lld", num));
354354
}
355355

356-
unsigned char String::concat(unsigned long long num) {
356+
bool String::concat(unsigned long long num) {
357357
char buf[1 + 3 * sizeof(unsigned long long)];
358358
return concat(buf, sprintf(buf, "%llu", num));
359359
}
360360

361-
unsigned char String::concat(float num) {
361+
bool String::concat(float num) {
362362
char buf[20];
363363
char *string = dtostrf(num, 4, 2, buf);
364364
return concat(string, strlen(string));
365365
}
366366

367-
unsigned char String::concat(double num) {
367+
bool String::concat(double num) {
368368
char buf[20];
369369
char *string = dtostrf(num, 4, 2, buf);
370370
return concat(string, strlen(string));
371371
}
372372

373-
unsigned char String::concat(const __FlashStringHelper *str) {
373+
bool String::concat(const __FlashStringHelper *str) {
374374
if (!str)
375-
return 0;
375+
return false;
376376
int length = strlen_P((PGM_P)str);
377377
if (length == 0)
378-
return 1;
378+
return true;
379379
unsigned int newlen = len() + length;
380380
if (!reserve(newlen))
381-
return 0;
381+
return false;
382382
memcpy_P(wbuffer() + len(), (PGM_P)str, length + 1);
383383
setLen(newlen);
384-
return 1;
384+
return true;
385385
}
386386

387387
/*********************************************/
@@ -488,48 +488,48 @@ int String::compareTo(const String &s) const {
488488
return strcmp(buffer(), s.buffer());
489489
}
490490

491-
unsigned char String::equals(const String &s2) const {
491+
bool String::equals(const String &s2) const {
492492
return (len() == s2.len() && compareTo(s2) == 0);
493493
}
494494

495-
unsigned char String::equals(const char *cstr) const {
495+
bool String::equals(const char *cstr) const {
496496
if (len() == 0)
497497
return (cstr == NULL || *cstr == 0);
498498
if (cstr == NULL)
499499
return buffer()[0] == 0;
500500
return strcmp(buffer(), cstr) == 0;
501501
}
502502

503-
unsigned char String::operator<(const String &rhs) const {
503+
bool String::operator<(const String &rhs) const {
504504
return compareTo(rhs) < 0;
505505
}
506506

507-
unsigned char String::operator>(const String &rhs) const {
507+
bool String::operator>(const String &rhs) const {
508508
return compareTo(rhs) > 0;
509509
}
510510

511-
unsigned char String::operator<=(const String &rhs) const {
511+
bool String::operator<=(const String &rhs) const {
512512
return compareTo(rhs) <= 0;
513513
}
514514

515-
unsigned char String::operator>=(const String &rhs) const {
515+
bool String::operator>=(const String &rhs) const {
516516
return compareTo(rhs) >= 0;
517517
}
518518

519-
unsigned char String::equalsIgnoreCase(const String &s2) const {
519+
bool String::equalsIgnoreCase(const String &s2) const {
520520
if (this == &s 10000 2)
521-
return 1;
521+
return true;
522522
if (len() != s2.len())
523-
return 0;
523+
return false;
524524
if (len() == 0)
525-
return 1;
525+
return true;
526526
const char *p1 = buffer();
527527
const char *p2 = s2.buffer();
528528
while (*p1) {
529529
if (tolower(*p1++) != tolower(*p2++))
530-
return 0;
530+
return false;
531531
}
532-
return 1;
532+
return true;
533533
}
534534

535535
unsigned char String::equalsConstantTime(const String &s2) const {
@@ -559,21 +559,21 @@ unsigned char String::equalsConstantTime(const String &s2) const {
559559
return (equalcond & diffcond); //bitwise AND
560560
}
561561

562-
unsigned char String::startsWith(const String &s2) const {
562+
bool String::startsWith(const String &s2) const {
563563
if (len() < s2.len())
564-
return 0;
564+
return false;
565565
return startsWith(s2, 0);
566566
}
567567

568-
unsigned char String::startsWith(const String &s2, unsigned int offset) const {
568+
bool String::startsWith(const String &s2, unsigned int offset) const {
569569
if (offset > (unsigned)(len() - s2.len()) || !buffer() || !s2.buffer())
570-
return 0;
570+
return false;
571571
return strncmp(&buffer()[offset], s2.buffer(), s2.len()) == 0;
572572
}
573573

574-
unsigned char String::endsWith(const String &s2) const {
574+
bool String::endsWith(const String &s2) const {
575575
if (len() < s2.len() || !buffer() || !s2.buffer())
576-
return 0;
576+
return false;
577577
return strcmp(&buffer()[len() - s2.len()], s2.buffer()) == 0;
578578
}
579579

@@ -597,7 +597,7 @@ char &String::operator[](unsigned int index) {
597597

598598
char String::operator[](unsigned int index) const {
599599
if (index >= len() || !buffer())
600-
return 0;
600+
return '\0';
601601
return buffer()[index];
602602
}
603603

0 commit comments

Comments
 (0)
0