fix(api): Update Arduino Stream class (espressif#10328)

* fix(api): Update Arduino Stream class

Upstream code contains some fixes

* Update Stream.h

* ci(pre-commit): Apply automatic fixes

---------

Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>

Author: me-no-dev

cores/esp32/Stream.cpp

@@ -18,14 +18,14 @@
 
  Created July 2011
  parsing functions based on TextFinder library by Michael Margolis
+
+ findMulti/findUntil routines written by Jim Leonard/Xuth
  */
 
 #include "Arduino.h"
 #include "Stream.h"
-#include "esp32-hal.h"
 
 #define PARSE_TIMEOUT 1000  // default number of milli-seconds to wait
-#define NO_SKIP_CHAR  1     // a magic char not found in a valid ASCII numeric field
 
 // private method to read stream with timeout
 int Stream::timedRead() {
@@ -55,18 +55,26 @@ int Stream::timedPeek() {
 
 // returns peek of the next digit in the stream or -1 if timeout
 // discards non-numeric characters
-int Stream::peekNextDigit() {
+int Stream::peekNextDigit(LookaheadMode lookahead, bool detectDecimal) {
   int c;
   while (1) {
     c = timedPeek();
-    if (c < 0) {
-      return c;  // timeout
-    }
-    if (c == '-') {
+
+    if (c < 0 || c == '-' || (c >= '0' && c <= '9') || (detectDecimal && c == '.')) {
       return c;
     }
-    if (c >= '0' && c <= '9') {
-      return c;
+
+    switch (lookahead) {
+      case SKIP_NONE: return -1;  // Fail code.
+      case SKIP_WHITESPACE:
+        switch (c) {
+          case ' ':
+          case '\t':
+          case '\r':
+          case '\n': break;
+          default:   return -1;  // Fail code.
+        }
+      case SKIP_ALL: break;
     }
     read();  // discard non-numeric
   }
@@ -79,9 +87,6 @@ void Stream::setTimeout(unsigned long timeout)  // sets the maximum number of mi
 {
   _timeout = timeout;
 }
-unsigned long Stream::getTimeout(void) {
-  return _timeout;
-}
 
 // find returns true if the target string is found
 bool Stream::find(const char *target) {
@@ -105,115 +110,40 @@ bool Stream::findUntil(const char *target, const char *terminator) {
 bool Stream::findUntil(const char *target, size_t targetLen, const char *terminator, size_t termLen) {
   if (terminator == NULL) {
     MultiTarget t[1] = {{target, targetLen, 0}};
-    return findMulti(t, 1) == 0 ? true : false;
+    return findMulti(t, 1) == 0;
   } else {
     MultiTarget t[2] = {{target, targetLen, 0}, {terminator, termLen, 0}};
-    return findMulti(t, 2) == 0 ? true : false;
+    return findMulti(t, 2) == 0;
   }
 }
 
-int Stream::findMulti(struct Stream::MultiTarget *targets, int tCount) {
-  // any zero length target string automatically matches and would make
-  // a mess of the rest of the algorithm.
-  for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
-    if (t->len <= 0) {
-      return t - targets;
-    }
-  }
-
-  while (1) {
-    int c = timedRead();
-    if (c < 0) {
-      return -1;
-    }
-
-    for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
-      // the simple case is if we match, deal with that first.
-      if (c == t->str[t->index]) {
-        if (++t->index == t->len) {
-          return t - targets;
-        } else {
-          continue;
-        }
-      }
-
-      // if not we need to walk back and see if we could have matched further
-      // down the stream (ie '1112' doesn't match the first position in '11112'
-      // but it will match the second position so we can't just reset the current
-      // index to 0 when we find a mismatch.
-      if (t->index == 0) {
-        continue;
-      }
-
-      int origIndex = t->index;
-      do {
-        --t->index;
-        // first check if current char works against the new current index
-        if (c != t->str[t->index]) {
-          continue;
-        }
-
-        // if it's the only char then we're good, nothing more to check
-        if (t->index == 0) {
-          t->index++;
-          break;
-        }
-
-        // otherwise we need to check the rest of the found string
-        int diff = origIndex - t->index;
-        size_t i;
-        for (i = 0; i < t->index; ++i) {
-          if (t->str[i] != t->str[i + diff]) {
-            break;
-          }
-        }
-
-        // if we successfully got through the previous loop then our current
-        // index is good.
-        if (i == t->index) {
-          t->index++;
-          break;
-        }
-
-        // otherwise we just try the next index
-      } while (t->index);
-    }
-  }
-  // unreachable
-  return -1;
-}
-
 // returns the first valid (long) integer value from the current position.
-// initial characters that are not digits (or the minus sign) are skipped
-// function is terminated by the first character that is not a digit.
-long Stream::parseInt() {
-  return parseInt(NO_SKIP_CHAR);  // terminate on first non-digit character (or timeout)
-}
-
-// as above but a given skipChar is ignored
-// this allows format characters (typically commas) in values to be ignored
-long Stream::parseInt(char skipChar) {
-  boolean isNegative = false;
+// lookahead determines how parseInt looks ahead in the stream.
+// See LookaheadMode enumeration at the top of the file.
+// Lookahead is terminated by the first character that is not a valid part of an integer.
+// Once parsing commences, 'ignore' will be skipped in the stream.
+long Stream::parseInt(LookaheadMode lookahead, char ignore) {
+  bool isNegative = false;
   long value = 0;
   int c;
 
-  c = peekNextDigit();
+  c = peekNextDigit(lookahead, false);
   // ignore non numeric leading characters
   if (c < 0) {
     return 0;  // zero returned if timeout
   }
 
   do {
-    if (c == skipChar) {
-    }  // ignore this character
+    if ((char)c == ignore)
+      ;  // ignore this character
     else if (c == '-') {
       isNegative = true;
     } else if (c >= '0' && c <= '9') {  // is c a digit?
       value = value * 10 + c - '0';
     }
     read();  // consume the character we got with peek
     c = timedPeek();
-  } while ((c >= '0' && c <= '9') || c == skipChar);
+  } while ((c >= '0' && c <= '9') || (char)c == ignore);
 
   if (isNegative) {
     value = -value;
@@ -222,50 +152,43 @@ long Stream::parseInt(char skipChar) {
 }
 
 // as parseInt but returns a floating point value
-float Stream::parseFloat() {
-  return parseFloat(NO_SKIP_CHAR);
-}
-
-// as above but the given skipChar is ignored
-// this allows format characters (typically commas) in values to be ignored
-float Stream::parseFloat(char skipChar) {
-  boolean isNegative = false;
-  boolean isFraction = false;
-  long value = 0;
+float Stream::parseFloat(LookaheadMode lookahead, char ignore) {
+  bool isNegative = false;
+  bool isFraction = false;
+  double value = 0.0;
   int c;
-  float fraction = 1.0;
+  double fraction = 1.0;
 
-  c = peekNextDigit();
+  c = peekNextDigit(lookahead, true);
   // ignore non numeric leading characters
   if (c < 0) {
     return 0;  // zero returned if timeout
   }
 
   do {
-    if (c == skipChar) {
-    }  // ignore
+    if ((char)c == ignore)
+      ;  // ignore
     else if (c == '-') {
       isNegative = true;
     } else if (c == '.') {
       isFraction = true;
     } else if (c >= '0' && c <= '9') {  // is c a digit?
-      value = value * 10 + c - '0';
       if (isFraction) {
-        fraction *= 0.1f;
+        fraction *= 0.1;
+        value = value + fraction * (c - '0');
+      } else {
+        value = value * 10 + c - '0';
       }
     }
     read();  // consume the character we got with peek
     c = timedPeek();
-  } while ((c >= '0' && c <= '9') || c == '.' || c == skipChar);
+  } while ((c >= '0' && c <= '9') || (c == '.' && !isFraction) || (char)c == ignore);
 
   if (isNegative) {
     value = -value;
   }
-  if (isFraction) {
-    return value * fraction;
-  } else {
-    return value;
-  }
+
+  return value;
 }
 
 // read characters from stream into buffer
@@ -291,13 +214,10 @@ size_t Stream::readBytes(char *buffer, size_t length) {
 // returns the number of characters placed in the buffer (0 means no valid data found)
 
 size_t Stream::readBytesUntil(char terminator, char *buffer, size_t length) {
-  if (length < 1) {
-    return 0;
-  }
   size_t index = 0;
   while (index < length) {
     int c = timedRead();
-    if (c < 0 || c == terminator) {
+    if (c < 0 || (char)c == terminator) {
       break;
     }
     *buffer++ = (char)c;
@@ -319,9 +239,80 @@ String Stream::readString() {
 String Stream::readStringUntil(char terminator) {
   String ret;
   int c = timedRead();
-  while (c >= 0 && c != terminator) {
+  while (c >= 0 && (char)c != terminator) {
     ret += (char)c;
     c = timedRead();
   }
   return ret;
 }
+
+int Stream::findMulti(struct Stream::MultiTarget *targets, int tCount) {
+  // any zero length target string automatically matches and would make
+  // a mess of the rest of the algorithm.
+  for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
+    if (t->len <= 0) {
+      return t - targets;
+    }
+  }
+
+  while (1) {
+    int c = timedRead();
+    if (c < 0) {
+      return -1;
+    }
+
+    for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
+      // the simple case is if we match, deal with that first.
+      if ((char)c == t->str[t->index]) {
+        if (++t->index == t->len) {
+          return t - targets;
+        } else {
+          continue;
+        }
+      }
+
+      // if not we need to walk back and see if we could have matched further
+      // down the stream (ie '1112' doesn't match the first position in '11112'
+      // but it will match the second position so we can't just reset the current
+      // index to 0 when we find a mismatch.
+      if (t->index == 0) {
+        continue;
+      }
+
+      int origIndex = t->index;
+      do {
+        --t->index;
+        // first check if current char works against the new current index
+        if ((char)c != t->str[t->index]) {
+          continue;
+        }
+
+        // if it's the only char then we're good, nothing more to check
+        if (t->index == 0) {
+          t->index++;
+          break;
+        }
+
+        // otherwise we need to check the rest of the found string
+        int diff = origIndex - t->index;
+        size_t i;
+        for (i = 0; i < t->index; ++i) {
+          if (t->str[i] != t->str[i + diff]) {
+            break;
+          }
+        }
+
+        // if we successfully got through the previous loop then our current
+        // index is good.
+        if (i == t->index) {
+          t->index++;
+          break;
+        }
+
+        // otherwise we just try the next index
+      } while (t->index);
+    }
+  }
+  // unreachable
+  return -1;
+}