Strings without null-termination

When working with the Arduino String class, I've found that I couldn't
efficiently combine it with some external libraries that explicitely
pass char* and length around, without nul-terminating their strings.
This prompted me to modify and expose the concat (const char* cstr,
unsigned int length) method, add a new String(const char* cstr, unsigned
int length) constructor. While I was going over the string class, I
found some other minor improvements, which are included here.

This is a port of arduino/Arduino#1936. The commits are identical,
except for some improved commit messages and one commit was dropped
since that change was already made by someone else in the meantime.

I've provided some testcases by updating the string examples:
arduino/Arduino#9239

If this is ok to merge, I'll also provide a PR for the reference
documentation.

cherry-pick from: arduino/ArduinoCore-API#97

Author: matthijskooijman

Diff for: core/WString.cpp

@@ -45,6 +45,12 @@ String::String(const char *cstr)
     if (cstr) copy(cstr, strlen(cstr));
 }
 
+String::String(const char *cstr, unsigned int length)
+{
+	init();
+	if (cstr) copy(cstr, length);
+}
+
 String::String(const String &value)
 {
     init();
@@ -178,7 +184,8 @@ String & String::copy(const char *cstr, unsigned int length)
         return *this;
     }
     len = length;
-    strcpy(buffer, cstr);
+	memcpy(buffer, cstr, length);
+	buffer[len] = '\0';
     return *this;
 }
 
@@ -260,8 +267,9 @@ unsigned char String::concat(const char *cstr, unsigned int length)
     if (!cstr) return 0;
     if (length == 0) return 1;
     if (!reserve(newlen)) return 0;
-    strcpy(buffer + len, cstr);
+    memcpy(buffer + len, cstr, length);
     len = newlen;
+    buffer[len] = '\0';
     return 1;
 }
 
@@ -273,59 +281,56 @@ unsigned char String::concat(const char *cstr)
 
 unsigned char String::concat(char c)
 {
-    char buf[2];
-    buf[0] = c;
-    buf[1] = 0;
-    return concat(buf, 1);
+    return concat(&c, 1);
 }
 
 unsigned char String::concat(unsigned char num)
 {
     char buf[1 + 3 * sizeof(unsigned char)];
     itoa(num, buf, 10);
-    return concat(buf, strlen(buf));
+    return concat(buf);
 }
 
 unsigned char String::concat(int num)
 {
     char buf[2 + 3 * sizeof(int)];
     itoa(num, buf, 10);
-    return concat(buf, strlen(buf));
+    return concat(buf);
 }
 
 unsigned char String::concat(unsigned int num)
 {
     char buf[1 + 3 * sizeof(unsigned int)];
     utoa(num, buf, 10);
-    return concat(buf, strlen(buf));
+    return concat(buf);
 }
 
 unsigned char String::concat(long num)
 {
     char buf[2 + 3 * sizeof(long)];
     ltoa(num, buf, 10);
-    return concat(buf, strlen(buf));
+    return concat(buf);
 }
 
 unsigned char String::concat(unsigned long num)
 {
     char buf[1 + 3 * sizeof(unsigned long)];
     ultoa(num, buf, 10);
-    return concat(buf, strlen(buf));
+    return concat(buf);
 }
 
 unsigned char String::concat(float num)
 {
     char buf[20];
     char* string = dtostrnf(num, 4, 2, buf, sizeof(buf));
-    return concat(string, strlen(string));
+    return concat(string);
 }
 
 unsigned char String::concat(double num)
 {
     char buf[20];
     char* string = dtostrnf(num, 4, 2, buf, sizeof(buf));
-    return concat(string, strlen(string));
+    return concat(string);
 }
 
 unsigned char String::concat(const __FlashStringHelper * str)
@@ -354,7 +359,7 @@ StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs)
 StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
 {
     StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-    if (!cstr || !a.concat(cstr, strlen(cstr))) a.invalidate();
+    if (!cstr || !a.concat(cstr)) a.invalidate();
     return a;
 }
 
@@ -615,10 +620,7 @@ String String::substring(unsigned int left, unsigned int right) const
     String out;
     if (left >= len) return out;
     if (right > len) right = len;
-    char temp = buffer[right];  // save the replaced character
-    buffer[right] = '\0';
-    out = buffer + left;  // pointer arithmetic
-    buffer[right] = temp;  //restore character
+    out.copy(buffer + left, right - left);
     return out;
 }
 

Diff for: core/WString.h

@@ -35,6 +35,7 @@
 #define String_class_h
 #ifdef __cplusplus
 
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
@@ -68,6 +69,8 @@ class String
     // fails, the string will be marked as invalid (i.e. "if (s)" will
     // be false).
     String(const char *cstr = "");
+    String(const char *cstr, unsigned int length);
+    String(const uint8_t *cstr, unsigned int length) : String((const char*)cstr, length) {}
     String(const String &str);
     String(const __FlashStringHelper *str);
 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
@@ -107,6 +110,8 @@ class String
     // 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);
@@ -208,7 +213,6 @@ class String
     void init(void);
     void invalidate(void);
     unsigned char changeBuffer(unsigned int maxStrLen);
-    unsigned char concat(const char *cstr, unsigned int length);
 
     // copy and move
     String & copy(const char *cstr, unsigned int length);