another missing change

mcspr · mcspr · commit afd713e6507c · 2025-05-14T00:58:23.000+03:00
diff --git a/cores/esp8266/HardwareSerial.h b/cores/esp8266/HardwareSerial.h
@@ -136,14 +136,14 @@ class HardwareSerial: public Stream
         return uart_peek_char(_uart);
     }
 
-    virtual bool hasPeekBufferAPI () const override
+    bool hasPeekBufferAPI () const override
     {
         return true;
     }
 
     // return a pointer to available data buffer (size = available())
     // semantic forbids any kind of read() before calling peekConsume()
-    const char* peekBuffer () override
+    const void* peekBuffer () override
     {
         return uart_peek_buffer(_uart);
     }
diff --git a/cores/esp8266/Print.h b/cores/esp8266/Print.h
@@ -56,7 +56,7 @@ class Print {
         size_t write(const char *str) {
             if(str == NULL)
                 return 0;
-            return write((const uint8_t *) str, strlen_P(str));
+            return write((const uint8_t *) str, strlen(str));
         }
         virtual size_t write(const uint8_t *buffer, size_t size);
         size_t write(const char *buffer, size_t size) {
diff --git a/cores/esp8266/Stream.h b/cores/esp8266/Stream.h
@@ -134,7 +134,7 @@ class Stream: public Print {
         // semantic forbids any kind of ::read()
         //     - after calling peekBuffer()
         //     - and before calling peekConsume()
-        virtual const char* peekBuffer () { return nullptr; }
+        virtual const void* peekBuffer () { return nullptr; }
 
         // consumes bytes after peekBuffer() use
         // (then ::read() is allowed)
diff --git a/cores/esp8266/StreamDev.h b/cores/esp8266/StreamDev.h
@@ -34,64 +34,64 @@ class StreamNull: public Stream
 public:
 
     // Print
-    virtual size_t write(uint8_t) override
+    size_t write(uint8_t) override
     {
         return 1;
     }
 
-    virtual size_t write(const uint8_t* buffer, size_t size) override
+    size_t write(const uint8_t* buffer, size_t size) override
     {
         (void)buffer;
         (void)size;
         return size;
     }
 
-    virtual int availableForWrite() override
+    int availableForWrite() override
     {
         return std::numeric_limits<int16_t>::max();
     }
 
     // Stream
-    virtual int available() override
+    int available() override
     {
         return 0;
     }
 
-    virtual int read() override
+    int read() override
     {
         return -1;
     }
 
-    virtual int peek() override
+    int peek() override
     {
         return -1;
     }
 
-    virtual size_t readBytes(char* buffer, size_t len) override
+    size_t readBytes(char* buffer, size_t len) override
     {
         (void)buffer;
         (void)len;
         return 0;
     }
 
-    virtual int read(uint8_t* buffer, size_t len) override
+    int read(uint8_t* buffer, size_t len) override
     {
         (void)buffer;
         (void)len;
         return 0;
     }
 
-    virtual bool outputCanTimeout() override
+    bool outputCanTimeout() override
     {
         return false;
     }
 
-    virtual bool inputCanTimeout() override
+    bool inputCanTimeout() override
     {
         return false;
     }
 
-    virtual ssize_t streamRemaining() override
+    ssize_t streamRemaining() override
     {
         return 0;
     }
@@ -113,34 +113,34 @@ class StreamZero: public StreamNull
     StreamZero(char zero = 0): _zero(zero) { }
 
     // Stream
-    virtual int available() override
+    int available() override
     {
         return std::numeric_limits<int16_t>::max();
     }
 
-    virtual int read() override
+    int read() override
     {
         return _zero;
     }
 
-    virtual int peek() override
+    int peek() override
     {
         return _zero;
     }
 
-    virtual size_t readBytes(char* buffer, size_t len) override
+    size_t readBytes(char* buffer, size_t len) override
     {
         memset(buffer, _zero, len);
         return len;
     }
 
-    virtual int read(uint8_t* buffer, size_t len) override
+    int read(uint8_t* buffer, size_t len) override
     {
         memset((char*)buffer, _zero, len);
         return len;
     }
 
-    virtual ssize_t streamRemaining() override
+    ssize_t streamRemaining() override
     {
         return std::numeric_limits<int16_t>::max();
     }
@@ -160,7 +160,11 @@ class StreamConstPtr: public StreamNull
     size_t _peekPointer = 0;
 
 public:
-    StreamConstPtr(const String&& string) = delete; // prevents passing String temporary, use ctor(buffer,size) if you know what you are doing
+    // prevents passing String temporary, use ctor(buffer,size) if you know what you are doing
+    StreamConstPtr(const String&&) = delete;
+    StreamConstPtr(String&&) = delete;
+
+    // reference arbitrary pointer
     StreamConstPtr(const String& string): _buffer(string.c_str()), _size(string.length()), _byteAddressable(true) { }
     StreamConstPtr(const char* buffer, size_t size): _buffer(buffer), _size(size), _byteAddressable(__byteAddressable(buffer)) { }
     StreamConstPtr(const uint8_t* buffer, size_t size): _buffer((const char*)buffer), _size(size), _byteAddressable(__byteAddressable(buffer)) { }
@@ -173,24 +177,24 @@ class StreamConstPtr: public StreamNull
     }
 
     // Stream
-    virtual int available() override
+    int available() override
     {
         return peekAvailable();
     }
 
-    virtual int read() override
+    int read() override
     {
         // valid with dram, iram and flash
         return _peekPointer < _size ? pgm_read_byte(&_buffer[_peekPointer++]) : -1;
     }
 
-    virtual int peek() override
+    int peek() override
     {
         // valid with dram, iram and flash
         return _peekPointer < _size ? pgm_read_byte(&_buffer[_peekPointer]) : -1;
     }
 
-    virtual size_t readBytes(char* buffer, size_t len) override
+    size_t readBytes(char* buffer, size_t len) override
     {
         if (_peekPointer >= _size)
         {
@@ -202,33 +206,33 @@ class StreamConstPtr: public StreamNull
         return cpylen;
     }
 
-    virtual int read(uint8_t* buffer, size_t len) override
+    int read(uint8_t* buffer, size_t len) override
     {
         return readBytes((char*)buffer, len);
     }
 
-    virtual ssize_t streamRemaining() override
+    ssize_t streamRemaining() override
     {
         return _size;
     }
 
     // peekBuffer
-    virtual bool hasPeekBufferAPI() const override
+    bool hasPeekBufferAPI() const override
     {
-        return _byteAddressable;
+        return true;
     }
 
-    virtual size_t peekAvailable() override
+    size_t peekAvailable() override
     {
         return _peekPointer < _size ? _size - _peekPointer : 0;
     }
 
-    virtual const char* peekBuffer() override
+    const void* peekBuffer() override
     {
         return _peekPointer < _size ? _buffer + _peekPointer : nullptr;
     }
 
-    virtual void peekConsume(size_t consume) override
+    void peekConsume(size_t consume) override
     {
         _peekPointer += consume;
     }
diff --git a/cores/esp8266/StreamSend.cpp b/cores/esp8266/StreamSend.cpp
@@ -22,6 +22,17 @@
 #include <Arduino.h>
 #include <StreamDev.h>
 
+namespace {
+
+// 'last' is memchr result, always in advance of current
+size_t last_consume(size_t previous, const void* last, const void* current)
+{
+    return std::min(previous, static_cast<size_t>(
+        reinterpret_cast<intptr_t>(last) - reinterpret_cast<intptr_t>(current)));
+}
+
+} // namespace
+
 size_t Stream::sendGeneric(Stream* to, const ssize_t len, const int readUntilChar,
                            const esp8266::polledTimeout::oneShotFastMs::timeType timeoutMs)
 {
@@ -132,18 +143,18 @@ Stream::SendGenericPeekBuffer(Print* to, const ssize_t len, const int readUntilC
         }
         if (w)
         {
-            const char* directbuf = peekBuffer();
+            const auto* directbuf = peekBuffer();
             bool        foundChar = false;
             if (readUntilChar >= 0)
             {
-                const char* last = (const char*)memchr(directbuf, readUntilChar, w);
+                const auto* last = memchr(directbuf, readUntilChar, w);
                 if (last)
                 {
-                    w         = std::min((size_t)(last - directbuf), w);
+                    w = last_consume(w, last, directbuf);
                     foundChar = true;
                 }
             }
-            if (w && ((w = to->write(directbuf, w))))
+            if (w && ((w = to->write((const uint8_t*)directbuf, w))))
             {
                 peekConsume(w);
                 written += w;
diff --git a/cores/esp8266/StreamString.h b/cores/esp8266/StreamString.h
@@ -39,17 +39,18 @@ class S2Stream: public Stream
 
     S2Stream(String* string, int peekPointer = -1) : string(string), peekPointer(peekPointer) { }
 
-    virtual int available() override
+    // Stream
+    int available() override
     {
         return string->length();
     }
 
-    virtual int availableForWrite() override
+    int availableForWrite() override
     {
         return std::numeric_limits<int16_t>::max();
     }
 
-    virtual int read() override
+    int read() override
     {
         if (peekPointer < 0)
         {
@@ -71,12 +72,12 @@ class S2Stream: public Stream
         return -1;
     }
 
-    virtual size_t write(uint8_t data) override
+    size_t write(uint8_t data) override
     {
         return string->concat((char)data);
     }
 
-    virtual int read(uint8_t* buffer, size_t len) override
+    int read(uint8_t* buffer, size_t len) override
     {
         if (peekPointer < 0)
         {
@@ -99,12 +100,12 @@ class S2Stream: public Stream
         return l;
     }
 
-    virtual size_t write(const uint8_t* buffer, size_t len) override
+    size_t write(const uint8_t* buffer, size_t len) override
     {
         return string->concat((const char*)buffer, len) ? len : 0;
     }
 
-    virtual int peek() override
+    int peek() override
     {
         if (peekPointer < 0)
         {
@@ -121,29 +122,28 @@ class S2Stream: public Stream
         return -1;
     }
 
-    virtual void flush() override
+    void flush() override
     {
         // nothing to do
     }
 
-    virtual bool inputCanTimeout() override
+    bool inputCanTimeout() override
     {
         return false;
     }
 
-    virtual bool outputCanTimeout() override
+    bool outputCanTimeout() override
     {
         return false;
     }
 
-    //// Stream's peekBufferAPI
-
-    virtual bool hasPeekBufferAPI() const override
+    // peekBufferAPI
+    bool hasPeekBufferAPI() const override
     {
         return true;
     }
 
-    virtual size_t peekAvailable()
+    size_t peekAvailable()
     {
         if (peekPointer < 0)
         {
@@ -152,7 +152,7 @@ class S2Stream: public Stream
         return string->length() - peekPointer;
     }
 
-    virtual const char* peekBuffer() override
+    const void* peekBuffer() override
     {
         if (peekPointer < 0)
         {
@@ -165,7 +165,7 @@ class S2Stream: public Stream
         return nullptr;
     }
 
-    virtual void peekConsume(size_t consume) override
+    void peekConsume(size_t consume) override
     {
         if (peekPointer < 0)
         {
@@ -179,7 +179,7 @@ class S2Stream: public Stream
         }
     }
 
-    virtual ssize_t streamRemaining() override
+    ssize_t streamRemaining() override
     {
         return peekPointer < 0 ? string->length() : string->length() - peekPointer;
     }

Original file line number	Diff line number	Diff line change
`@@ -136,14 +136,14 @@ class HardwareSerial: public Stream`
`136`	`136`	`return uart_peek_char(_uart);`
`137`	`137`	`}`
`138`	`138`
`139`		`- virtual bool hasPeekBufferAPI () const override`
	`139`	`+ bool hasPeekBufferAPI () const override`
`140`	`140`	`{`
`141`	`141`	`return true;`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`// return a pointer to available data buffer (size = available())`
`145`	`145`	`// semantic forbids any kind of read() before calling peekConsume()`
`146`		`- const char* peekBuffer () override`
	`146`	`+ const void* peekBuffer () override`
`147`	`147`	`{`
`148`	`148`	`return uart_peek_buffer(_uart);`
`149`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ class Print {`
`56`	`56`	`size_t write(const char *str) {`
`57`	`57`	`if(str == NULL)`
`58`	`58`	`return 0;`
`59`		`- return write((const uint8_t *) str, strlen_P(str));`
	`59`	`+ return write((const uint8_t *) str, strlen(str));`
`60`	`60`	`}`
`61`	`61`	`virtual size_t write(const uint8_t *buffer, size_t size);`
`62`	`62`	`size_t write(const char *buffer, size_t size) {`
Original file line number	Diff line number	Diff line change
`@@ -34,64 +34,64 @@ class StreamNull: public Stream`
`34`	`34`	`public:`
`35`	`35`
`36`	`36`	`// Print`
`37`		`- virtual size_t write(uint8_t) override`
	`37`	`+ size_t write(uint8_t) override`
`38`	`38`	`{`
`39`	`39`	`return 1;`
`40`	`40`	`}`
`41`	`41`
`42`		`- virtual size_t write(const uint8_t* buffer, size_t size) override`
	`42`	`+ size_t write(const uint8_t* buffer, size_t size) override`
`43`	`43`	`{`
`44`	`44`	`(void)buffer;`
`45`	`45`	`(void)size;`
`46`	`46`	`return size;`
`47`	`47`	`}`
`48`	`48`
`49`		`- virtual int availableForWrite() override`
	`49`	`+ int availableForWrite() override`
`50`	`50`	`{`
`51`	`51`	`return std::numeric_limits<int16_t>::max();`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`// Stream`
`55`		`- virtual int available() override`
	`55`	`+ int available() override`
`56`	`56`	`{`
`57`	`57`	`return 0;`
`58`	`58`	`}`
`59`	`59`
`60`		`- virtual int read() override`
	`60`	`+ int read() override`
`61`	`61`	`{`
`62`	`62`	`return -1;`
`63`	`63`	`}`
`64`	`64`
`65`		`- virtual int peek() override`
	`65`	`+ int peek() override`
`66`	`66`	`{`
`67`	`67`	`return -1;`
`68`	`68`	`}`
`69`	`69`
`70`		`- virtual size_t readBytes(char* buffer, size_t len) override`
	`70`	`+ size_t readBytes(char* buffer, size_t len) override`
`71`	`71`	`{`
`72`	`72`	`(void)buffer;`
`73`	`73`	`(void)len;`
`74`	`74`	`return 0;`
`75`	`75`	`}`
`76`	`76`
`77`		`- virtual int read(uint8_t* buffer, size_t len) override`
	`77`	`+ int read(uint8_t* buffer, size_t len) override`
`78`	`78`	`{`
`79`	`79`	`(void)buffer;`
`80`	`80`	`(void)len;`
`81`	`81`	`return 0;`
`82`	`82`	`}`
`83`	`83`
`84`		`- virtual bool outputCanTimeout() override`
	`84`	`+ bool outputCanTimeout() override`
`85`	`85`	`{`
`86`	`86`	`return false;`
`87`	`87`	`}`
`88`	`88`
`89`		`- virtual bool inputCanTimeout() override`
	`89`	`+ bool inputCanTimeout() override`
`90`	`90`	`{`
`91`	`91`	`return false;`
`92`	`92`	`}`
`93`	`93`
`94`		`- virtual ssize_t streamRemaining() override`
	`94`	`+ ssize_t streamRemaining() override`
`95`	`95`	`{`
`96`	`96`	`return 0;`
`97`	`97`	`}`
`@@ -113,34 +113,34 @@ class StreamZero: public StreamNull`
`113`	`113`	`StreamZero(char zero = 0): _zero(zero) { }`
`114`	`114`
`115`	`115`	`// Stream`
`116`		`- virtual int available() override`
	`116`	`+ int available() override`
`117`	`117`	`{`
`118`	`118`	`return std::numeric_limits<int16_t>::max();`
`119`	`119`	`}`
`120`	`120`
`121`		`- virtual int read() override`
	`121`	`+ int read() override`
`122`	`122`	`{`
`123`	`123`	`return _zero;`
`124`	`124`	`}`
`125`	`125`
`126`		`- virtual int peek() override`
	`126`	`+ int peek() override`
`127`	`127`	`{`
`128`	`128`	`return _zero;`
`129`	`129`	`}`
`130`	`130`
`131`		`- virtual size_t readBytes(char* buffer, size_t len) override`
	`131`	`+ size_t readBytes(char* buffer, size_t len) override`
`132`	`132`	`{`
`133`	`133`	`memset(buffer, _zero, len);`
`134`	`134`	`return len;`
`135`	`135`	`}`
`136`	`136`
`137`		`- virtual int read(uint8_t* buffer, size_t len) override`
	`137`	`+ int read(uint8_t* buffer, size_t len) override`
`138`	`138`	`{`
`139`	`139`	`memset((char*)buffer, _zero, len);`
`140`	`140`	`return len;`
`141`	`141`	`}`
`142`	`142`
`143`		`- virtual ssize_t streamRemaining() override`
	`143`	`+ ssize_t streamRemaining() override`
`144`	`144`	`{`
`145`	`145`	`return std::numeric_limits<int16_t>::max();`
`146`	`146`	`}`
`@@ -160,7 +160,11 @@ class StreamConstPtr: public StreamNull`
`160`	`160`	`size_t _peekPointer = 0;`
`161`	`161`
`162`	`162`	`public:`
`163`		`- StreamConstPtr(const String&& string) = delete; // prevents passing String temporary, use ctor(buffer,size) if you know what you are doing`
	`163`	`+ // prevents passing String temporary, use ctor(buffer,size) if you know what you are doing`
	`164`	`+ StreamConstPtr(const String&&) = delete;`
	`165`	`+ StreamConstPtr(String&&) = delete;`
	`166`	`+`
	`167`	`+ // reference arbitrary pointer`
`164`	`168`	`StreamConstPtr(const String& string): _buffer(string.c_str()), _size(string.length()), _byteAddressable(true) { }`
`165`	`169`	`StreamConstPtr(const char* buffer, size_t size): _buffer(buffer), _size(size), _byteAddressable(__byteAddressable(buffer)) { }`
`166`	`170`	`StreamConstPtr(const uint8_t* buffer, size_t size): _buffer((const char*)buffer), _size(size), _byteAddressable(__byteAddressable(buffer)) { }`
`@@ -173,24 +177,24 @@ class StreamConstPtr: public StreamNull`
`173`	`177`	`}`
`174`	`178`
`175`	`179`	`// Stream`
`176`		`- virtual int available() override`
	`180`	`+ int available() override`
`177`	`181`	`{`
`178`	`182`	`return peekAvailable();`
`179`	`183`	`}`
`180`	`184`
`181`		`- virtual int read() override`
	`185`	`+ int read() override`
`182`	`186`	`{`
`183`	`187`	`// valid with dram, iram and flash`
`184`	`188`	`return _peekPointer < _size ? pgm_read_byte(&_buffer[_peekPointer++]) : -1;`
`185`	`189`	`}`
`186`	`190`
`187`		`- virtual int peek() override`
	`191`	`+ int peek() override`
`188`	`192`	`{`
`189`	`193`	`// valid with dram, iram and flash`
`190`	`194`	`return _peekPointer < _size ? pgm_read_byte(&_buffer[_peekPointer]) : -1;`
`191`	`195`	`}`
`192`	`196`
`193`		`- virtual size_t readBytes(char* buffer, size_t len) override`
	`197`	`+ size_t readBytes(char* buffer, size_t len) override`
`194`	`198`	`{`
`195`	`199`	`if (_peekPointer >= _size)`
`196`	`200`	`{`
`@@ -202,33 +206,33 @@ class StreamConstPtr: public StreamNull`
`202`	`206`	`return cpylen;`
`203`	`207`	`}`
`204`	`208`
`205`		`- virtual int read(uint8_t* buffer, size_t len) override`
	`209`	`+ int read(uint8_t* buffer, size_t len) override`
`206`	`210`	`{`
`207`	`211`	`return readBytes((char*)buffer, len);`
`208`	`212`	`}`
`209`	`213`
`210`		`- virtual ssize_t streamRemaining() override`
	`214`	`+ ssize_t streamRemaining() override`
`211`	`215`	`{`
`212`	`216`	`return _size;`
`213`	`217`	`}`
`214`	`218`
`215`	`219`	`// peekBuffer`
`216`		`- virtual bool hasPeekBufferAPI() const override`
	`220`	`+ bool hasPeekBufferAPI() const override`
`217`	`221`	`{`
`218`		`- return _byteAddressable;`
	`222`	`+ return true;`
`219`	`223`	`}`
`220`	`224`
`221`		`- virtual size_t peekAvailable() override`
	`225`	`+ size_t peekAvailable() override`
`222`	`226`	`{`
`223`	`227`	`return _peekPointer < _size ? _size - _peekPointer : 0;`
`224`	`228`	`}`
`225`	`229`
`226`		`- virtual const char* peekBuffer() override`
	`230`	`+ const void* peekBuffer() override`
`227`	`231`	`{`
`228`	`232`	`return _peekPointer < _size ? _buffer + _peekPointer : nullptr;`
`229`	`233`	`}`
`230`	`234`
`231`		`- virtual void peekConsume(size_t consume) override`
	`235`	`+ void peekConsume(size_t consume) override`
`232`	`236`	`{`
`233`	`237`	`_peekPointer += consume;`
`234`	`238`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,17 @@`
`22`	`22`	`#include <Arduino.h>`
`23`	`23`	`#include <StreamDev.h>`
`24`	`24`
	`25`	`+namespace {`
	`26`	`+`
	`27`	`+// 'last' is memchr result, always in advance of current`
	`28`	`+size_t last_consume(size_t previous, const void* last, const void* current)`
	`29`	`+{`
	`30`	`+ return std::min(previous, static_cast<size_t>(`
	`31`	`+ reinterpret_cast<intptr_t>(last) - reinterpret_cast<intptr_t>(current)));`
	`32`	`+}`
	`33`	`+`
	`34`	`+} // namespace`
	`35`	`+`
`25`	`36`	`size_t Stream::sendGeneric(Stream* to, const ssize_t len, const int readUntilChar,`
`26`	`37`	`const esp8266::polledTimeout::oneShotFastMs::timeType timeoutMs)`
`27`	`38`	`{`
`@@ -132,18 +143,18 @@ Stream::SendGenericPeekBuffer(Print* to, const ssize_t len, const int readUntilC`
`132`	`143`	`}`
`133`	`144`	`if (w)`
`134`	`145`	`{`
`135`		`- const char* directbuf = peekBuffer();`
	`146`	`+ const auto* directbuf = peekBuffer();`
`136`	`147`	`bool foundChar = false;`
`137`	`148`	`if (readUntilChar >= 0)`
`138`	`149`	`{`
`139`		`- const char* last = (const char*)memchr(directbuf, readUntilChar, w);`
	`150`	`+ const auto* last = memchr(directbuf, readUntilChar, w);`
`140`	`151`	`if (last)`
`141`	`152`	`{`
`142`		`- w = std::min((size_t)(last - directbuf), w);`
	`153`	`+ w = last_consume(w, last, directbuf);`
`143`	`154`	`foundChar = true;`
`144`	`155`	`}`
`145`	`156`	`}`
`146`		`- if (w && ((w = to->write(directbuf, w))))`
	`157`	`+ if (w && ((w = to->write((const uint8_t*)directbuf, w))))`
`147`	`158`	`{`
`148`	`159`	`peekConsume(w);`
`149`	`160`	`written += w;`
Original file line number	Diff line number	Diff line change
`@@ -39,17 +39,18 @@ class S2Stream: public Stream`
`39`	`39`
`40`	`40`	`S2Stream(String* string, int peekPointer = -1) : string(string), peekPointer(peekPointer) { }`
`41`	`41`
`42`		`- virtual int available() override`
	`42`	`+ // Stream`
	`43`	`+ int available() override`
`43`	`44`	`{`
`44`	`45`	`return string->length();`
`45`	`46`	`}`
`46`	`47`
`47`		`- virtual int availableForWrite() override`
	`48`	`+ int availableForWrite() override`
`48`	`49`	`{`
`49`	`50`	`return std::numeric_limits<int16_t>::max();`
`50`	`51`	`}`
`51`	`52`
`52`		`- virtual int read() override`
	`53`	`+ int read() override`
`53`	`54`	`{`
`54`	`55`	`if (peekPointer < 0)`
`55`	`56`	`{`
`@@ -71,12 +72,12 @@ class S2Stream: public Stream`
`71`	`72`	`return -1;`
`72`	`73`	`}`
`73`	`74`
`74`		`- virtual size_t write(uint8_t data) override`
	`75`	`+ size_t write(uint8_t data) override`
`75`	`76`	`{`
`76`	`77`	`return string->concat((char)data);`
`77`	`78`	`}`
`78`	`79`
`79`		`- virtual int read(uint8_t* buffer, size_t len) override`
	`80`	`+ int read(uint8_t* buffer, size_t len) override`
`80`	`81`	`{`
`81`	`82`	`if (peekPointer < 0)`
`82`	`83`	`{`
`@@ -99,12 +100,12 @@ class S2Stream: public Stream`
`99`	`100`	`return l;`
`100`	`101`	`}`
`101`	`102`
`102`		`- virtual size_t write(const uint8_t* buffer, size_t len) override`
	`103`	`+ size_t write(const uint8_t* buffer, size_t len) override`
`103`	`104`	`{`
`104`	`105`	`return string->concat((const char*)buffer, len) ? len : 0;`
`105`	`106`	`}`
`106`	`107`
`107`		`- virtual int peek() override`
	`108`	`+ int peek() override`
`108`	`109`	`{`
`109`	`110`	`if (peekPointer < 0)`
`110`	`111`	`{`
`@@ -121,29 +122,28 @@ class S2Stream: public Stream`
`121`	`122`	`return -1;`
`122`	`123`	`}`
`123`	`124`
`124`		`- virtual void flush() override`
	`125`	`+ void flush() override`
`125`	`126`	`{`
`126`	`127`	`// nothing to do`
`127`	`128`	`}`
`128`	`129`
`129`		`- virtual bool inputCanTimeout() override`
	`130`	`+ bool inputCanTimeout() override`
`130`	`131`	`{`
`131`	`132`	`return false;`
`132`	`133`	`}`
`133`	`134`
`134`		`- virtual bool outputCanTimeout() override`
	`135`	`+ bool outputCanTimeout() override`
`135`	`136`	`{`
`136`	`137`	`return false;`
`137`	`138`	`}`
`138`	`139`
`139`		`- //// Stream's peekBufferAPI`
`140`		`-`
`141`		`- virtual bool hasPeekBufferAPI() const override`
	`140`	`+ // peekBufferAPI`
	`141`	`+ bool hasPeekBufferAPI() const override`
`142`	`142`	`{`
`143`	`143`	`return true;`
`144`	`144`	`}`
`145`	`145`
`146`		`- virtual size_t peekAvailable()`
	`146`	`+ size_t peekAvailable()`
`147`	`147`	`{`
`148`	`148`	`if (peekPointer < 0)`
`149`	`149`	`{`
`@@ -152,7 +152,7 @@ class S2Stream: public Stream`
`152`	`152`	`return string->length() - peekPointer;`
`153`	`153`	`}`
`154`	`154`
`155`		`- virtual const char* peekBuffer() override`
	`155`	`+ const void* peekBuffer() override`
`156`	`156`	`{`
`157`	`157`	`if (peekPointer < 0)`
`158`	`158`	`{`
`@@ -165,7 +165,7 @@ class S2Stream: public Stream`
`165`	`165`	`return nullptr;`
`166`	`166`	`}`
`167`	`167`
`168`		`- virtual void peekConsume(size_t consume) override`
	`168`	`+ void peekConsume(size_t consume) override`
`169`	`169`	`{`
`170`	`170`	`if (peekPointer < 0)`
`171`	`171`	`{`
`@@ -179,7 +179,7 @@ class S2Stream: public Stream`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`182`		`- virtual ssize_t streamRemaining() override`
	`182`	`+ ssize_t streamRemaining() override`
`183`	`183`	`{`
`184`	`184`	`return peekPointer < 0 ? string->length() : string->length() - peekPointer;`
`185`	`185`	`}`