use const refs where relevant (aka stop being nasty with ram and cpu)

d-a-v · d-a-v · commit fb5e83c95924 · 2018-10-20T01:31:37.000+02:00
diff --git a/cores/esp8266/WString.cpp b/cores/esp8266/WString.cpp
@@ -796,3 +796,7 @@ float String::toFloat(void) const {
         return atof(buffer);
     return 0;
 }
+
+// global empty string to allow returning const String& with nothing
+
+const String emptyString;
diff --git a/cores/esp8266/WString.h b/cores/esp8266/WString.h
@@ -294,5 +294,7 @@ class StringSumHelper: public String {
         }
 };
 
+extern const String emptyString;
+
 #endif  // __cplusplus
 #endif  // String_class_h
diff --git a/libraries/ESP8266WebServer/src/ESP8266WebServer.cpp b/libraries/ESP8266WebServer/src/ESP8266WebServer.cpp
@@ -100,10 +100,10 @@ void ESP8266WebServer::begin(uint16_t port) {
   _server.begin(port);
 }
 
-String ESP8266WebServer::_extractParam(String& authReq,const String& param,const char delimit){
+String ESP8266WebServer::_extractParam(String& authReq,const String& param,const char delimit) const {
   int _begin = authReq.indexOf(param);
-  if (_begin == -1) 
-    return "";
+  if (_begin == -1)
+    return emptyString;
   return authReq.substring(_begin+param.length(),authReq.indexOf(delimit,_begin+param.length()));
 }
 
@@ -487,35 +487,35 @@ void ESP8266WebServer::_streamFileCore(const size_t fileSize, const String & fil
       contentType != String(FPSTR(mimeTable[none].mimeType))) {
     sendHeader(F("Content-Encoding"), F("gzip"));
   }
-  send(200, contentType, "");
+  send(200, contentType, emptyString);
 }
 
 
-String ESP8266WebServer::arg(String name) {
+const String& ESP8266WebServer::arg(String name) const {
   for (int i = 0; i < _currentArgCount; ++i) {
     if ( _currentArgs[i].key == name )
       return _currentArgs[i].value;
   }
-  return "";
+  return emptyString;
 }
 
-String ESP8266WebServer::arg(int i) {
+const String& ESP8266WebServer::arg(int i) const {
   if (i >= 0 && i < _currentArgCount)
     return _currentArgs[i].value;
-  return "";
+  return emptyString;
 }
 
-String ESP8266WebServer::argName(int i) {
+const String& ESP8266WebServer::argName(int i) const {
   if (i >= 0 && i < _currentArgCount)
     return _currentArgs[i].key;
-  return "";
+  return emptyString;
 }
 
-int ESP8266WebServer::args() {
+int ESP8266WebServer::args() const {
   return _currentArgCount;
 }
 
-bool ESP8266WebServer::hasArg(String  name) {
+bool ESP8266WebServer::hasArg(const String& name) const {
   for (int i = 0; i < _currentArgCount; ++i) {
     if (_currentArgs[i].key == name)
       return true;
@@ -524,12 +524,12 @@ bool ESP8266WebServer::hasArg(String  name) {
 }
 
 
-String ESP8266WebServer::header(String name) {
+const String& ESP8266WebServer::header(String name) const {
   for (int i = 0; i < _headerKeysCount; ++i) {
     if (_currentHeaders[i].key.equalsIgnoreCase(name))
       return _currentHeaders[i].value;
   }
-  return "";
+  return emptyString;
 }
 
 void ESP8266WebServer::collectHeaders(const char* headerKeys[], const size_t headerKeysCount) {
@@ -543,31 +543,31 @@ void ESP8266WebServer::collectHeaders(const char* headerKeys[], const size_t hea
   }
 }
 
-String ESP8266WebServer::header(int i) {
+const String& ESP8266WebServer::header(int i) const {
   if (i < _headerKeysCount)
     return _currentHeaders[i].value;
-  return "";
+  return emptyString;
 }
 
-String ESP8266WebServer::headerName(int i) {
+const String& ESP8266WebServer::headerName(int i) const {
   if (i < _headerKeysCount)
     return _currentHeaders[i].key;
-  return "";
+  return emptyString;
 }
 
-int ESP8266WebServer::headers() {
+int ESP8266WebServer::headers() const {
   return _headerKeysCount;
 }
 
-bool ESP8266WebServer::hasHeader(String name) {
+bool ESP8266WebServer::hasHeader(String name) const {
   for (int i = 0; i < _headerKeysCount; ++i) {
     if ((_currentHeaders[i].key.equalsIgnoreCase(name)) &&  (_currentHeaders[i].value.length() > 0))
       return true;
   }
   return false;
 }
 
-String ESP8266WebServer::hostHeader() {
+const String& ESP8266WebServer::hostHeader() const {
   return _hostHeader;
 }
 
@@ -612,11 +612,11 @@ void ESP8266WebServer::_handleRequest() {
 
 void ESP8266WebServer::_finalizeResponse() {
   if (_chunked) {
-    sendContent("");
+    sendContent(emptyString);
   }
 }
 
-String ESP8266WebServer::_responseCodeToString(int code) {
+const String ESP8266WebServer::_responseCodeToString(int code) {
   switch (code) {
     case 100: return F("Continue");
     case 101: return F("Switching Protocols");
diff --git a/libraries/ESP8266WebServer/src/ESP8266WebServer.h b/libraries/ESP8266WebServer/src/ESP8266WebServer.h
@@ -92,24 +92,23 @@ class ESP8266WebServer
   void onNotFound(THandlerFunction fn);  //called when handler is not assigned
   void onFileUpload(THandlerFunction fn); //handle file uploads
 
-  String uri() { return _currentUri; }
-  HTTPMethod method() { return _currentMethod; }
+  const String& uri() const { return _currentUri; }
+  HTTPMethod method() const { return _currentMethod; }
   virtual WiFiClient client() { return _currentClient; }
   HTTPUpload& upload() { return *_currentUpload; }
 
-  String arg(String name);        // get request argument value by name
-  String arg(int i);              // get request argument value by number
-  String argName(int i);          // get request argument name by number
-  int args();                     // get arguments count
-  bool hasArg(String name);       // check if argument exists
+  const String& arg(String name) const;    // get request argument value by name
+  const String& arg(int i) const;          // get request argument value by number
+  const String& argName(int i) const;      // get request argument name by number
+  int args() const;                        // get arguments count
+  bool hasArg(const String& name) const;   // check if argument exists
   void collectHeaders(const char* headerKeys[], const size_t headerKeysCount); // set the request headers to collect
-  String header(String name);      // get request header value by name
-  String header(int i);              // get request header value by number
-  String headerName(int i);          // get request header name by number
-  int headers();                     // get header count
-  bool hasHeader(String name);       // check if header exists
-
-  String hostHeader();            // get request host header if available or empty String if not
+  const String& header(String name) const; // get request header value by name
+  const String& header(int i) const;       // get request header value by number
+  const String& headerName(int i) const;   // get request header name by number
+  int headers() const;                     // get header count
+  bool hasHeader(String name) const;       // check if header exists
+  const String& hostHeader() const;        // get request host header if available or empty String if not
 
   // send response to the client
   // code - HTTP response code, can be 200 or 404
@@ -129,12 +128,12 @@ class ESP8266WebServer
 
   static String urlDecode(const String& text);
 
-  template<typename T> 
+  template<typename T>
   size_t streamFile(T &file, const String& contentType) {
     _streamFileCore(file.size(), file.name(), contentType);
     return _currentClient.write(file);
   }
-  
+
 protected:
   virtual size_t _currentClientWrite(const char* b, size_t l) { return _currentClient.write( b, l ); }
   virtual size_t _currentClientWrite_P(PGM_P b, size_t l) { return _currentClient.write_P( b, l ); }
@@ -144,19 +143,19 @@ class ESP8266WebServer
   bool _parseRequest(WiFiClient& client);
   void _parseArguments(const String& data);
   int _parseArgumentsPrivate(const String& data, std::function<void(String&,String&,const String&,int,int,int,int)> handler);
-  static String _responseCodeToString(int code);
-  bool _parseForm(WiFiClient& client, String boundary, uint32_t len);
+  static const String _responseCodeToString(int code);
+  bool _parseForm(WiFiClient& client, const String& boundary, uint32_t len);
   bool _parseFormUploadAborted();
   void _uploadWriteByte(uint8_t b);
   uint8_t _uploadReadByte(WiFiClient& client);
   void _prepareHeader(String& response, int code, const char* content_type, size_t contentLength);
   bool _collectHeader(const char* headerName, const char* headerValue);
- 
+
   void _streamFileCore(const size_t fileSize, const String & fileName, const String & contentType);
 
-  String _getRandomHexString();
+  static String _getRandomHexString();
   // for extracting Auth parameters
-  String _extractParam(String& authReq,const String& param,const char delimit = '"');
+  String _extractParam(String& authReq,const String& param,const char delimit = '"') const;
 
   struct RequestArgument {
     String key;
diff --git a/libraries/ESP8266WebServer/src/Parsing.cpp b/libraries/ESP8266WebServer/src/Parsing.cpp
@@ -35,37 +35,24 @@
 static const char Content_Type[] PROGMEM = "Content-Type";
 static const char filename[] PROGMEM = "filename";
 
-// XXX todo build a String instead of malloc/realloc and because final result is now put in a string
-static char* readBytesWithTimeout(WiFiClient& client, size_t maxLength, size_t& dataLength, int timeout_ms)
+static bool readBytesWithTimeout(WiFiClient& client, size_t maxLength, String& data, int timeout_ms)
 {
-  char *buf = nullptr;
-  dataLength = 0;
-  while (dataLength < maxLength) {
+  if (!data.reserve(maxLength + 1))
+    return false;
+  data[0] = 0;  // data.clear()??
+  while (data.length() < maxLength) {
     int tries = timeout_ms;
-    size_t newLength;
-    while (!(newLength = client.available()) && tries--) delay(1);
-    if (!newLength) {
+    size_t avail;
+    while (!(avail = client.available()) && tries--)
+      delay(1);
+    if (!avail)
       break;
-    }
-    if (!buf) {
-      buf = (char *) malloc(newLength + 1);
-      if (!buf) {
-        return nullptr;
-      }
-    }
-    else {
-      char* newBuf = (char *) realloc(buf, dataLength + newLength + 1);
-      if (!newBuf) {
-        free(buf);
-        return nullptr;
-      }
-      buf = newBuf;
-    }
-    client.readBytes(buf + dataLength, newLength);
-    dataLength += newLength;
-    buf[dataLength] = '\0';
+    if (data.length() + avail > maxLength)
+      avail = maxLength - data.length();
+    while (avail--)
+      data += (char)client.read();
   }
-  return buf;
+  return data.length() == maxLength;
 }
 
 bool ESP8266WebServer::_parseRequest(WiFiClient& client) {
@@ -186,13 +173,13 @@ bool ESP8266WebServer::_parseRequest(WiFiClient& client) {
     }
 
     String plainBuf;
-    if (!isForm) {
-      // read content into plainBuf
-      size_t plainLength;
-      char* plainBufTmp = readBytesWithTimeout(client, contentLength, plainLength, HTTP_MAX_POST_WAIT);
-      plainBuf = plainBufTmp;
-      free(plainBufTmp);
-      if (plainBuf.length() < contentLength)
+    if (   !isForm
+        && // read content into plainBuf
+           (   !readBytesWithTimeout(client, contentLength, plainBuf, HTTP_MAX_POST_WAIT)
+            || (plainBuf.length() < contentLength)
+           )
+       )
+    {
         return false;
     }
 
@@ -378,7 +365,7 @@ uint8_t ESP8266WebServer::_uploadReadByte(WiFiClient& client){
   return (uint8_t)res;
 }
 
-bool ESP8266WebServer::_parseForm(WiFiClient& client, String boundary, uint32_t len){
+bool ESP8266WebServer::_parseForm(WiFiClient& client, const String& boundary, uint32_t len){
   (void) len;
 #ifdef DEBUG_ESP_HTTP_SERVER
   DEBUG_OUTPUT.print("Parse Form: Boundary: ");

Original file line number	Diff line number	Diff line change
`@@ -796,3 +796,7 @@ float String::toFloat(void) const {`
`796`	`796`	`return atof(buffer);`
`797`	`797`	`return 0;`
`798`	`798`	`}`
	`799`	`+`
	`800`	`+// global empty string to allow returning const String& with nothing`
	`801`	`+`
	`802`	`+const String emptyString;`
Original file line number	Diff line number	Diff line change
`@@ -294,5 +294,7 @@ class StringSumHelper: public String {`
`294`	`294`	`}`
`295`	`295`	`};`
`296`	`296`
	`297`	`+extern const String emptyString;`
	`298`	`+`
`297`	`299`	`#endif // __cplusplus`
`298`	`300`	`#endif // String_class_h`
Original file line number	Diff line number	Diff line change
`@@ -100,10 +100,10 @@ void ESP8266WebServer::begin(uint16_t port) {`
`100`	`100`	`_server.begin(port);`
`101`	`101`	`}`
`102`	`102`
`103`		`-String ESP8266WebServer::_extractParam(String& authReq,const String& param,const char delimit){`
	`103`	`+String ESP8266WebServer::_extractParam(String& authReq,const String& param,const char delimit) const {`
`104`	`104`	`int _begin = authReq.indexOf(param);`
`105`		`- if (_begin == -1)`
`106`		`- return "";`
	`105`	`+ if (_begin == -1)`
	`106`	`+ return emptyString;`
`107`	`107`	`return authReq.substring(_begin+param.length(),authReq.indexOf(delimit,_begin+param.length()));`
`108`	`108`	`}`
`109`	`109`
`@@ -487,35 +487,35 @@ void ESP8266WebServer::_streamFileCore(const size_t fileSize, const String & fil`
`487`	`487`	`contentType != String(FPSTR(mimeTable[none].mimeType))) {`
`488`	`488`	`sendHeader(F("Content-Encoding"), F("gzip"));`
`489`	`489`	`}`
`490`		`- send(200, contentType, "");`
	`490`	`+ send(200, contentType, emptyString);`
`491`	`491`	`}`
`492`	`492`
`493`	`493`
`494`		`-String ESP8266WebServer::arg(String name) {`
	`494`	`+const String& ESP8266WebServer::arg(String name) const {`
`495`	`495`	`for (int i = 0; i < _currentArgCount; ++i) {`
`496`	`496`	`if ( _currentArgs[i].key == name )`
`497`	`497`	`return _currentArgs[i].value;`
`498`	`498`	`}`
`499`		`- return "";`
	`499`	`+ return emptyString;`
`500`	`500`	`}`
`501`	`501`
`502`		`-String ESP8266WebServer::arg(int i) {`
	`502`	`+const String& ESP8266WebServer::arg(int i) const {`
`503`	`503`	`if (i >= 0 && i < _currentArgCount)`
`504`	`504`	`return _currentArgs[i].value;`
`505`		`- return "";`
	`505`	`+ return emptyString;`
`506`	`506`	`}`
`507`	`507`
`508`		`-String ESP8266WebServer::argName(int i) {`
	`508`	`+const String& ESP8266WebServer::argName(int i) const {`
`509`	`509`	`if (i >= 0 && i < _currentArgCount)`
`510`	`510`	`return _currentArgs[i].key;`
`511`		`- return "";`
	`511`	`+ return emptyString;`
`512`	`512`	`}`
`513`	`513`
`514`		`-int ESP8266WebServer::args() {`
	`514`	`+int ESP8266WebServer::args() const {`
`515`	`515`	`return _currentArgCount;`
`516`	`516`	`}`
`517`	`517`
`518`		`-bool ESP8266WebServer::hasArg(String name) {`
	`518`	`+bool ESP8266WebServer::hasArg(const String& name) const {`
`519`	`519`	`for (int i = 0; i < _currentArgCount; ++i) {`
`520`	`520`	`if (_currentArgs[i].key == name)`
`521`	`521`	`return true;`
`@@ -524,12 +524,12 @@ bool ESP8266WebServer::hasArg(String name) {`
`524`	`524`	`}`
`525`	`525`
`526`	`526`
`527`		`-String ESP8266WebServer::header(String name) {`
	`527`	`+const String& ESP8266WebServer::header(String name) const {`
`528`	`528`	`for (int i = 0; i < _headerKeysCount; ++i) {`
`529`	`529`	`if (_currentHeaders[i].key.equalsIgnoreCase(name))`
`530`	`530`	`return _currentHeaders[i].value;`
`531`	`531`	`}`
`532`		`- return "";`
	`532`	`+ return emptyString;`
`533`	`533`	`}`
`534`	`534`
`535`	`535`	`void ESP8266WebServer::collectHeaders(const char* headerKeys[], const size_t headerKeysCount) {`
`@@ -543,31 +543,31 @@ void ESP8266WebServer::collectHeaders(const char* headerKeys[], const size_t hea`
`543`	`543`	`}`
`544`	`544`	`}`
`545`	`545`
`546`		`-String ESP8266WebServer::header(int i) {`
	`546`	`+const String& ESP8266WebServer::header(int i) const {`
`547`	`547`	`if (i < _headerKeysCount)`
`548`	`548`	`return _currentHeaders[i].value;`
`549`		`- return "";`
	`549`	`+ return emptyString;`
`550`	`550`	`}`
`551`	`551`
`552`		`-String ESP8266WebServer::headerName(int i) {`
	`552`	`+const String& ESP8266WebServer::headerName(int i) const {`
`553`	`553`	`if (i < _headerKeysCount)`
`554`	`554`	`return _currentHeaders[i].key;`
`555`		`- return "";`
	`555`	`+ return emptyString;`
`556`	`556`	`}`
`557`	`557`
`558`		`-int ESP8266WebServer::headers() {`
	`558`	`+int ESP8266WebServer::headers() const {`
`559`	`559`	`return _headerKeysCount;`
`560`	`560`	`}`
`561`	`561`
`562`		`-bool ESP8266WebServer::hasHeader(String name) {`
	`562`	`+bool ESP8266WebServer::hasHeader(String name) const {`
`563`	`563`	`for (int i = 0; i < _headerKeysCount; ++i) {`
`564`	`564`	`if ((_currentHeaders[i].key.equalsIgnoreCase(name)) && (_currentHeaders[i].value.length() > 0))`
`565`	`565`	`return true;`
`566`	`566`	`}`
`567`	`567`	`return false;`
`568`	`568`	`}`
`569`	`569`
`570`		`-String ESP8266WebServer::hostHeader() {`
	`570`	`+const String& ESP8266WebServer::hostHeader() const {`
`571`	`571`	`return _hostHeader;`
`572`	`572`	`}`
`573`	`573`
`@@ -612,11 +612,11 @@ void ESP8266WebServer::_handleRequest() {`
`612`	`612`
`613`	`613`	`void ESP8266WebServer::_finalizeResponse() {`
`614`	`614`	`if (_chunked) {`
`615`		`- sendContent("");`
	`615`	`+ sendContent(emptyString);`
`616`	`616`	`}`
`617`	`617`	`}`
`618`	`618`
`619`		`-String ESP8266WebServer::_responseCodeToString(int code) {`
	`619`	`+const String ESP8266WebServer::_responseCodeToString(int code) {`
`620`	`620`	`switch (code) {`
`621`	`621`	`case 100: return F("Continue");`
`622`	`622`	`case 101: return F("Switching Protocols");`