Added match length support

Author: ToriningenGames

README.md

@@ -20,34 +20,20 @@ I think you should test the patterns you are going to use. You can easily modify
 The main design goal of this library is to be small, correct, self contained and use few resources while retaining acceptable performance and feature completeness. Clarity of the code is also highly valued.
 
 ### Notable features and omissions
-- Small code and binary size: <500 SLOC, ~3kb binary for x86. Statically #define'd memory usage / allocation.
+- Small code and binary size: 500 SLOC, ~3kb binary for x86. Statically #define'd memory usage / allocation.
 - No use of dynamic memory allocation (i.e. no calls to `malloc` / `free`).
 - To avoid call-stack exhaustion, iterative searching is preferred over recursive by default (can be changed with a pre-processor flag).
 - No support for capturing groups or named capture: `(^P<name>group)` etc.
 - Thorough testing : [exrex](https://github.com/asciimoo/exrex) is used to randomly generate test-cases from regex patterns, which are fed into the regex code for verification. Try `make test` to generate a few thousand tests cases yourself.
-- Compiled for x86 using GCC 4.7.4 and optimizing for size, the binary takes up ~2-3kb code space and allocates ~0.5kb RAM :
+- Provides character length of matches.
+- Compiled for x86 using GCC 7.2.0 and optimizing for size, the binary takes up ~2-3kb code space and allocates ~0.5kb RAM :
   ```
   > gcc -Os -c re.c
   > size re.o
       text     data     bss     dec     hex filename
-      2319        0     544    2863     b2f re.o
+      2440      160     544    3144     c48 re.o
       
   ```
-  For ARM/Thumb using GCC 4.8.1 it's around 1.5kb code and less RAM :
-  ```
-  > arm-none-eabi-gcc -Os -mthumb -c re.c
-  > size re.o
-      text     data     bss     dec     hex filename
-      1418        0     280    1698     6a2 re.o
-
-  ```
-  For 8-bit AVR using AVR-GCC 4.8.1 it's around 2kb code and less RAM :
-  ```
-  > avr-gcc -Os -c re.c
-  > size re.o
-      text     data     bss     dec     hex filename
-      2128        0     130    2258     8d2 re.o
-  ```
 
 
 
@@ -61,10 +47,10 @@ typedef struct regex_t* re_t;
 re_t re_compile(const char* pattern);
 
 /* Finds matches of the compiled pattern inside text. */
-int  re_matchp(re_t pattern, const char* text);
+int  re_matchp(re_t pattern, const char* text, int* matchlength);
 
 /* Finds matches of pattern inside text (compiles first automatically). */
-int  re_match(const char* pattern, const char* text);
+int  re_match(const char* pattern, const char* text, int* matchlength);
 ```
 
 ### Supported regex-operators
@@ -97,22 +83,25 @@ Search a text-string for a regex and get an index into the string, using `re_mat
 
 The returned index points to the first place in the string, where the regex pattern matches.
 
+The integer pointer passed will hold the length of the match.
+
 If the regular expression doesn't match, the matching function returns an index of -1 to indicate failure.
 
 ### Examples
 Example of usage:
 ```C
+/* Standard int to hold length of match */
 /* Standard null-terminated C-string to search: */
 const char* string_to_search = "ahem.. 'hello world !' ..";
 
 /* Compile a simple regular expression using character classes, meta-char and greedy + non-greedy quantifiers: */
 re_t pattern = re_compile("[Hh]ello [Ww]orld\\s*[!]?");
 
 /* Check if the regex matches the text: */
-int match_idx = re_matchp(pattern, string_to_search);
+int match_idx = re_matchp(pattern, string_to_search, &match_length);
 if (match_idx != -1)
 {
-  printf("match at idx %d.\n", match_idx);
+  printf("match at idx %d, %i chars long.\n", match_idx, match_length);
 }
 ```
 
@@ -128,7 +117,7 @@ For more usage examples I encourage you to look at the code in the `tests`-folde
 ### FAQ
 - *Q: What differentiates this library from other C regex implementations?*
 
-  A: Well, the small size for one. <500 lines of C-code compiling to 2-3kb ROM, using very little RAM.
+  A: Well, the small size for one. 500 lines of C-code compiling to 2-3kb ROM, using very little RAM.
 
 ### License
 All material in this repository is in the public domain.

re.c

@@ -53,10 +53,10 @@ typedef struct regex_t
 
 
 /* Private function declarations: */
-static int matchpattern(regex_t* pattern, const char* text);
+static int matchpattern(regex_t* pattern, const char* text, int* matchlength);
 static int matchcharclass(char c, const char* str);
-static int matchstar(regex_t p, regex_t* pattern, const char* text);
-static int matchplus(regex_t p, regex_t* pattern, const char* text);
+static int matchstar(regex_t p, regex_t* pattern, const char* text, int* matchlength);
+static int matchplus(regex_t p, regex_t* pattern, const char* text, int* matchlength);
 static int matchone(regex_t p, char c);
 static int matchdigit(char c);
 static int matchalpha(char c);
@@ -68,18 +68,19 @@ static int ismetachar(char c);
 
 
 /* Public functions: */
-int re_match(const char* pattern, const char* text)
+int re_match(const char* pattern, const char* text, int* matchlength)
 {
-  return re_matchp(re_compile(pattern), text);
+  return re_matchp(re_compile(pattern), text, matchlength);
 }
 
-int re_matchp(re_t pattern, const char* text)
+int re_matchp(re_t pattern, const char* text, int* matchlength)
 {
+  *matchlength = 0;
   if (pattern != 0)
   {
     if (pattern[0].type == BEGIN)
     {
-      return ((matchpattern(&pattern[1], text)) ? 0 : -1);
+      return ((matchpattern(&pattern[1], text, matchlength)) ? 0 : -1);
     }
     else
     {
@@ -89,7 +90,7 @@ int re_matchp(re_t pattern, const char* text)
       {
         idx += 1;
 
-        if (matchpattern(pattern, text))
+        if (matchpattern(pattern, text, matchlength))
         {
           if (text[0] == '\0')
             return -1;
@@ -367,89 +368,115 @@ static int matchone(regex_t p, char c)
   }
 }
 
-static int matchstar(regex_t p, regex_t* pattern, const char* text)
+static int matchstar(regex_t p, regex_t* pattern, const char* text, int* matchlength)
 {
-  do
+  int prelen = *matchlength;
+  const char* prepoint = text;
+  while ((text[0] != '\0') && matchone(p, *text))
+  {
+    text++;
+    (*matchlength)++;
+  }
+  while (text >= prepoint)
   {
-    if (matchpattern(pattern, text))
+    if (matchpattern(pattern, text--, matchlength))
       return 1;
+    (*matchlength)--;
   }
-  while ((text[0] != '\0') && matchone(p, *text++));
-
+  
+  *matchlength = prelen;
   return 0;
 }
 
-static int matchplus(regex_t p, regex_t* pattern, const char* text)
+static int matchplus(regex_t p, regex_t* pattern, const char* text, int* matchlength)
 {
-  while ((text[0] != '\0') && matchone(p, *text++))
+  const char* prepoint = text;
+  while ((text[0] != '\0') && matchone(p, *text))
+  {
+    text++;
+    (*matchlength)++;
+  }
+  while (text > prepoint)
   {
-    if (matchpattern(pattern, text))
+    if (matchpattern(pattern, text--, matchlength))
       return 1;
+    (*matchlength)--;
   }
+  
   return 0;
 }
 
-static int matchquestion(regex_t p, regex_t* pattern, const char* text)
+static int matchquestion(regex_t p, regex_t* pattern, const char* text, int* matchlength)
 {
   if (p.type == UNUSED)
     return 1;
-  if (matchpattern(pattern, text))
+  if (matchpattern(pattern, text, matchlength))
       return 1;
   if (*text && matchone(p, *text++))
-    return matchpattern(pattern, text);
+  {
+    if (matchpattern(pattern, text, matchlength))
+    {
+      (*matchlength)++;
+      return 1;
+    }
+  }
   return 0;
 }
 
 
 #if 0
 
 /* Recursive matching */
-static int matchpattern(regex_t* pattern, const char* text)
+static int matchpattern(regex_t* pattern, const char* text, int *matchlength)
 {
+  int pre = *matchlength;
   if ((pattern[0].type == UNUSED) || (pattern[1].type == QUESTIONMARK))
   {
-    return matchquestion(pattern[1], &pattern[2], text);
+    return matchquestion(pattern[1], &pattern[2], text, matchlength);
   }
   else if (pattern[1].type == STAR)
   {
-    return matchstar(pattern[0], &pattern[2], text);
+    return matchstar(pattern[0], &pattern[2], text, matchlength);
   }
   else if (pattern[1].type == PLUS)
   {
-    return matchplus(pattern[0], &pattern[2], text);
+    return matchplus(pattern[0], &pattern[2], text, matchlength);
   }
   else if ((pattern[0].type == END) && pattern[1].type == UNUSED)
   {
     return text[0] == '\0';
   }
   else if ((text[0] != '\0') && matchone(pattern[0], text[0]))
   {
+    (*matchlength)++;
     return matchpattern(&pattern[1], text+1);
   }
   else
   {
+    *matchlength = pre;
     return 0;
   }
 }
 
 #else
 
 /* Iterative matching */
-static int matchpattern(regex_t* pattern, const char* text)
+static int matchpattern(regex_t* pattern, const char* text, int* matchlength)
 {
+  int pre = *matchlength;
   do
   {
     if ((pattern[0].type == UNUSED) || (pattern[1].type == QUESTIONMARK))
     {
-      return matchquestion(pattern[0], &pattern[2], text);
+      return matchquestion(pattern[0], &pattern[2], text, matchlength);
     }
     else if (pattern[1].type == STAR)
     {
-      return matchstar(pattern[0], &pattern[2], text);
+      return matchstar(pattern[0], &pattern[2], text, matchlength);
     }
     else if (pattern[1].type == PLUS)
     {
-      return matchplus(pattern[0], &pattern[2], text);
+      return matchplus(pattern[0], &pattern[2], text, matchlength);
     }
     else if ((pattern[0].type == END) && pattern[1].type == UNUSED)
     {
@@ -461,9 +488,11 @@ static int matchpattern(regex_t* pattern, const char* text)
       return (matchpattern(pattern, text) || matchpattern(&pattern[2], text));
     }
 */
+  (*matchlength)++;
   }
   while ((text[0] != '\0') && matchone(*pattern++, *text++));
 
+  *matchlength = pre;
   return 0;
 }
 

re.h

@@ -42,11 +42,11 @@ re_t re_compile(const char* pattern);
 
 
 /* Find matches of the compiled pattern inside text. */
-int  re_matchp(re_t pattern, const char* text);
+int  re_matchp(re_t pattern, const char* text, int* matchlenght);
 
 
 /* Find matches of the txt pattern inside text (will compile automatically first). */
-int  re_match(const char* pattern, const char* text);
+int  re_match(const char* pattern, const char* text, int* matchlenght);
 
 
 #ifdef __cplusplus