Replace regex with regex.h

esp8266 · devyte · Feb 22, 2020 · Oct 6, 2018 · Oct 6, 2018 · Oct 6, 2018
commit baa4c49e5b521f5769bac83a90282fe6af6128a7
diff --git a/libraries/ESP8266WebServer/src/Uri.h b/libraries/ESP8266WebServer/src/Uri.h
@@ -18,8 +18,6 @@ class Uri {
             return new Uri(_uri);
         };
 
-        virtual void initPathArgs(__attribute__((unused)) std::vector<String> &pathArgs) {}
-
         virtual bool canHandle(const String &requestUri, __attribute__((unused)) std::vector<String> &pathArgs) {
             return _uri == requestUri;
         }

diff --git a/libraries/ESP8266WebServer/src/detail/RequestHandlersImpl.h b/libraries/ESP8266WebServer/src/detail/RequestHandlersImpl.h
@@ -19,7 +19,6 @@ class FunctionRequestHandler : public RequestHandler<ServerType> {
     , _uri(uri.clone())
     , _method(method)
     {
-        _uri->initPathArgs(RequestHandler<ServerType>::pathArgs);
     }
 
     ~FunctionRequestHandler() {

diff --git a/libraries/ESP8266WebServer/src/uri/UriBraces.h b/libraries/ESP8266WebServer/src/uri/UriBraces.h
@@ -13,24 +13,13 @@ class UriBraces : public Uri {
             return new UriBraces(_uri);
         };
 
-        void initPathArgs(std::vector<String> &pathArgs) override final {
-            int numParams = 0, start = 0;
-            do {
-                start = _uri.indexOf("{}", start
8000
);
-                if (start > 0) {
-                    numParams++;
-                    start += 2;
-                }
-            } while (start > 0);
-            pathArgs.resize(numParams);
-        }
-
         bool canHandle(const String &requestUri, std::vector<String> &pathArgs) override final {
             if (Uri::canHandle(requestUri, pathArgs))
                 return true;
 
+            pathArgs.clear();
+
             size_t uriLength = _uri.length();
-            unsigned int pathArgIndex = 0;
             unsigned int requestUriIndex = 0;
             for (unsigned int i = 0; i < uriLength; i++, requestUriIndex++) {
                 char uriChar = _uri[i];
@@ -44,19 +33,18 @@ class UriBraces : public Uri {
                 i += 2; // index of char after '}'
                 if (i >= uriLength) {
                     // there is no char after '}'
-                    pathArgs[pathArgIndex] = requestUri.substring(requestUriIndex);
-                    return pathArgs[pathArgIndex].indexOf("/") == -1; // path argument may not contain a '/'
+                    pathArgs.push_back(requestUri.substring(requestUriIndex));
+                    return pathArgs.back().indexOf("/") == -1; // path argument may not contain a '/'
                 }
                 else
                 {
                     char charEnd = _uri[i];
                     int uriIndex = requestUri.indexOf(charEnd, requestUriIndex);
                     if (uriIndex < 0)
                         return false;
-                    pathArgs[pathArgIndex] = requestUri.substring(requestUriIndex, uriIndex);
+                    pathArgs.push_back(requestUri.substring(requestUriIndex, uriIndex));
                     requestUriIndex = (unsigned int) uriIndex;
                 }
-                pathArgIndex++;
             }
 
             return requestUriIndex >= requestUri.length();

diff --git a/libraries/ESP8266WebServer/src/uri/UriRegex.h b/libraries/ESP8266WebServer/src/uri/UriRegex.h
@@ -2,39 +2,49 @@
 #define URI_REGEX_H
 
 #include "Uri.h"
-#include <regex>
+#include <regex.h>
+#include <assert.h>
+
+#ifndef REGEX_MAX_GROUPS
+#define REGEX_MAX_GROUPS 10
+#endif
 
 class UriRegex : public Uri {
 
+    private:
+        regex_t _regexCompiled;
+
     public:
-        explicit UriRegex(const char *uri) : Uri(uri) {};
-        explicit UriRegex(const String &uri) : Uri(uri) {};
+        explicit UriRegex(const char *uri) : Uri(uri) {
+            assert(regcomp(&_regexCompiled, uri, REG_EXTENDED) == 0);
+        };
+        explicit UriRegex(const String &uri) : UriRegex(uri.c_str()) {};
+
+        ~UriRegex() {
+            regfree(&_regexCompiled);
+        }
 
         Uri* clone() const override final {
             return new UriRegex(_uri);
         };
 
-        void initPathArgs(std::vector<String> &pathArgs) override final {
-        
8EDC
    std::regex rgx((_uri + "|").c_str());
-            std::smatch matches;
-            std::string s{""};
-            std::regex_search(s, matches, rgx);
-            pathArgs.resize(matches.size() - 1);
-        }
-
         bool canHandle(const String &requestUri, std::vector<String> &pathArgs) override final {
             if (Uri::canHandle(requestUri, pathArgs))
                 return true;
 
-            unsigned int pathArgIndex = 0;
-            std::regex rgx(_uri.c_str());
-            std::smatch matches;
-            std::string s(requestUri.c_str());
-            if (std::regex_search(s, matches, rgx)) {
-                for (size_t i = 1; i < matches.size(); ++i) {  // skip first
-                    pathArgs[pathArgIndex] = String(matches[i].str().c_str());
-                    pathArgIndex++;
+            regmatch_t groupArray[REGEX_MAX_GROUPS];
+            if (regexec(&_regexCompiled, requestUri.c_str(), REGEX_MAX_GROUPS, groupArray, 0) == 0) {
+                // matches
+                pathArgs.clear();
+
+                unsigned int g = 1; 
+                for (; g < REGEX_MAX_GROUPS; g++) {
+                    if (groupArray[g].rm_so == (long int)-1)
+                        break;  // No more groups
+
+                    pathArgs.push_back(requestUri.substring(groupArray[g].rm_so, groupArray[g].rm_eo));
                 }
+
                 return true;
             }
             return false;