why regexec() in posix c always return the first match,how can it return all match positions only run once?

Question

Now when I want to return all match positions in str, such as:

abcd123abcd123abcd

Suppose I want to get all "abcd", I must use regexec(),get the first position:0, 3, then I will use:

123abcd123abcd

as the new string to use regexec() again, and so on. I read the manual about regexec(), it says:

int regexec(const regex_t *preg, const char *string, size_t nmatch,
               regmatch_t pmatch[], int eflags);
nmatch and pmatch are used to provide information regarding the location of any 
matches.

but why doesn't this work? This is my code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <regex.h>

int main(int argc, char **argv)
{
   int i = 0;
   int res;
   int len;
   char result[BUFSIZ];
   char err_buf[BUFSIZ];
   char* src = argv[1];  

   const char* pattern = "\\<[^,;]+\\>";
   regex_t preg;

   regmatch_t pmatch[10];

   if( (res = regcomp(&preg, pattern, REG_EXTENDED)) != 0)
   {
      regerror(res, &preg, err_buf, BUFSIZ);
      printf("regcomp: %s\n", err_buf);
      exit(res);
   }

   res = regexec(&preg, src, 10, pmatch, REG_NOTBOL);
   //~ res = regexec(&preg, src, 10, pmatch, 0);
   //~ res = regexec(&preg, src, 10, pmatch, REG_NOTEOL);
   if(res == REG_NOMATCH)
   {
      printf("NO match\n");
      exit(0);
   }
   for (i = 0; pmatch[i].rm_so != -1; i++)
   {
      len = pmatch[i].rm_eo - pmatch[i].rm_so;
      memcpy(result, src + pmatch[i].rm_so, len);
      result[len] = 0;
      printf("num %d: '%s'\n", i, result);
   }
   regfree(&preg);
   return 0;
}

./regex 'hello, world'

the output:

num 0: 'hello'

this is my respect outputs:

num 0: 'hello'
num 1: 'world'

Solution

regexec performs a regex match. Once a match has been found regexec will return zero (i.e. successful match). The parameter pmatch will contain information about that one match. The first array index (i.e. zero) will contain the entire match, subsequent array indices contain information about capture groups/sub-expressions.

To demonstrate:

const char* pattern = "(\\w+) (\\w+)";

matched on "hello world" will output:

num 0: 'hello world'  - entire match
num 1: 'hello'        - capture group 1
num 2: 'world'        - capture group 2

(see it in action)

In most regex environments the behaviour you seek could have been gotten by using the global modifier: /g. Regexec does not provide this modifier as a flag nor does it support modifiers. You will therefore have to loop while regexec returns zero starting from the last character of the previous match to get all matches.

The global modifier is also not available using the PCRE library (famous regex C library). The PCRE man pages have this to say about it:

By calling pcre_exec() multiple times with appropriate arguments, you can mimic Perl's /g option

Comments

[pellucidcoder]

What is the difference between that pattern and "([[:digit:]]+) ([[:digit:]]+)" ?

[Lodewijk Bogaards]

To be clear, your question is not relevant to my answer at all. The regex I used as an example was only for demonstration purposes, as my answer pertains to the workings of regexec. But to answer your question: \w matches all alphanumeric characters, whereas [:digit:] only matches digits.