Renamed input enum flags for cregex functions.

8 files changed, 40 insertions, 35 deletions

diff --git a/README.md b/README.md
index af9ce1ad..ab350488 100644
--- a/README.md
+++ b/README.md
@@ -625,6 +625,7 @@ STC is generally very memory efficient. Memory usage for the different container
     - Define i_import before #include <stc/cstr.h> will also define utf8 case conversions.
     - Define i_import before #include <stc/cregex.h> will also define cstr + utf8 tables.
 - Renamed c_make() => c_init() macro for initialization lists.
+- Renamed input enum flags for cregex functions.
 - Removed deprecated crandom.h. Use crand.h with new API.
 - Removed deprecated uppercase flow-control macro names.
 - Improved default string hash function.
diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index f21f2eaf..7569bb5b 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -369,8 +369,8 @@ int main()
 ### Coroutine API
 To resume the coroutine from where it was suspended with *cco_yield()*: call the coroutine again.
 
-**Note**: *cco_yield()* / *cco_await()* may not be called inside a `switch` statement; use 
-`if-else-if` constructs instead.
+**Note**: *cco_yield()* / *cco_await()* may not be called inside a `switch` statement from a
+cco_routine scope; Use `if-else-if` constructs instead.
 
 |           |  Function / operator                 | Description                             |
 |:----------|:-------------------------------------|:----------------------------------------|
@@ -384,11 +384,11 @@ To resume the coroutine from where it was suspended with *cco_yield()*: call the
 |           | `cco_yield_v();`                     | Yield/suspend execution (return void)   |
 |           | `cco_yield_v(ret);`                  | Yield/suspend execution (return ret)    |
 |           | `cco_yield_final();`                 | Yield final time, enables cleanup-state |
-|           | `cco_yield_final(val);`              | Yield a final value (e.g. CCO_ERROR) |
+|           | `cco_yield_final(ret);`              | Yield a final value (e.g. CCO_ERROR) |
 |           | `cco_await(condition);`              | Suspend until condition is true (return CCO_AWAIT)|
 |           | `cco_await_v(condition);`            | Suspend until condition is true (return void) |
 |           | `cco_await_v(condition, ret);`       | Suspend until condition is true (return ret)|
-|           | `cco_await_on(cocall);`              | Await on sub-coroutine to finish        |
+|           | `cco_await_on(cocall);`              | Await on sub-coroutine to finish (return its ret) |
 |           | `cco_return;`                        | Return from coroutine (inside cco_routine) |
 |           | `cco_closure(Closure, ...);`         | Define a coroutine closure struct (optional) |
 |           | Semaphores:                          |                                         | 
diff --git a/docs/cregex_api.md b/docs/cregex_api.md
index ff69c549..f87240f8 100644
--- a/docs/cregex_api.md
+++ b/docs/cregex_api.md
@@ -12,16 +12,16 @@ The API is simple and includes powerful string pattern matches and replace funct
 ```c
 enum {
     // compile-flags
-    CREG_C_DOTALL = 1<<0,    // dot matches newline too: can be set/overridden by (?s) and (?-s) in RE
-    CREG_C_ICASE = 1<<1,     // ignore case mode: can be set/overridden by (?i) and (?-i) in RE
+    CREG_DOTALL = 1<<0,    // dot matches newline too: can be set/overridden by (?s) and (?-s) in RE
+    CREG_ICASE = 1<<1,     // ignore case mode: can be set/overridden by (?i) and (?-i) in RE
 
     // match-flags
-    CREG_M_FULLMATCH = 1<<2, // like start-, end-of-line anchors were in pattern: "^ ... $"
-    CREG_M_NEXT = 1<<3,      // use end of previous match[0] as start of input
-    CREG_M_STARTEND = 1<<4,  // use match[0] as start+end of input
+    CREG_FULLMATCH = 1<<2, // like start-, end-of-line anchors were in pattern: "^ ... $"
+    CREG_NEXT = 1<<3,      // use end of previous match[0] as start of input
+    CREG_STARTEND = 1<<4,  // use match[0] as start+end of input
 
     // replace-flags
-    CREG_R_STRIP = 1<<5,     // only keep the replaced matches, strip the rest
+    CREG_STRIP = 1<<5,     // only keep the replaced matches, strip the rest
 };
 
 cregex      cregex_init(void);
@@ -138,7 +138,7 @@ In order to use a callback function in the replace call, see `examples/regex_rep
 To iterate multiple matches in an input string, you may use
 ```c
 csview match[5] = {0};
-while (cregex_find(&re, input, match, CREG_M_NEXT) == CREG_OK)
+while (cregex_find(&re, input, match, CREG_NEXT) == CREG_OK)
     for (int k = 1; i <= cregex_captures(&re); ++k)
         printf("submatch %d: %.*s\n", k, c_SV(match[k]));
 ```
@@ -181,8 +181,8 @@ For reference, **cregex** uses the following files:
 | \B | Not UTF8 word boundary | * |
 | \Q | Start literal input mode | * |
 | \E | End literal input mode | * |
-| (?i) (?-i)  | Ignore case on/off (override CREG_C_ICASE) | * |
-| (?s) (?-s)  | Dot matches newline on/off (override CREG_C_DOTALL) | * |
+| (?i) (?-i)  | Ignore case on/off (override CREG_ICASE) | * |
+| (?s) (?-s)  | Dot matches newline on/off (override CREG_DOTALL) | * |
 | \n \t \r | Match UTF8 newline, tab, carriage return | |
 | \d \s \w | Match UTF8 digit, whitespace, alphanumeric character | |
 | \D \S \W | Do not match the groups described above | |
diff --git a/include/stc/cregex.h b/include/stc/cregex.h
index 1d1d441f..bce94b04 100644
--- a/include/stc/cregex.h
+++ b/include/stc/cregex.h
@@ -39,15 +39,19 @@ THE SOFTWARE.
 
 enum {
     CREG_DEFAULT = 0,
+
     /* compile-flags */
-    CREG_C_DOTALL = 1<<0,    /* dot matches newline too */
-    CREG_C_ICASE = 1<<1,     /* ignore case */
+    CREG_DOTALL = 1<<0,    /* dot matches newline too */
+    CREG_ICASE = 1<<1,     /* ignore case */
+
     /* match-flags */
-    CREG_M_FULLMATCH = 1<<2, /* like start-, end-of-line anchors were in pattern: "^ ... $" */
-    CREG_M_NEXT = 1<<3,      /* use end of previous match[0] as start of input */
-    CREG_M_STARTEND = 1<<4,  /* use match[0] as start+end of input */
+    CREG_FULLMATCH = 1<<2, /* like start-, end-of-line anchors were in pattern: "^ ... $" */
+    CREG_NEXT = 1<<3,      /* use end of previous match[0] as start of input */
+    CREG_STARTEND = 1<<4,  /* use match[0] as start+end of input */
+
     /* replace-flags */
-    CREG_R_STRIP = 1<<5,     /* only keep the matched strings, strip rest */
+    CREG_STRIP = 1<<5,     /* only keep the matched strings, strip rest */
+
     /* limits */
     CREG_MAX_CLASSES = 16,
     CREG_MAX_CAPTURES = 32,
@@ -83,7 +87,7 @@ typedef struct {
 
 #define c_formatch(it, Re, Input) \
     for (cregex_iter it = {Re, Input}; \
-         cregex_find_4(it.re, it.input, it.match, CREG_M_NEXT) == CREG_OK; )
+         cregex_find_4(it.re, it.input, it.match, CREG_NEXT) == CREG_OK; )
 
 STC_INLINE cregex cregex_init(void) {
     cregex re = {0};
@@ -117,7 +121,7 @@ int cregex_find_4(const cregex* re, const char* input, csview match[], int mflag
 STC_INLINE int cregex_find_sv(const cregex* re, csview input, csview match[]) {
     csview *mp = NULL;
     if (match) { match[0] = input; mp = match; }
-    return cregex_find(re, input.str, mp, CREG_M_STARTEND);
+    return cregex_find(re, input.str, mp, CREG_STARTEND);
 }
 
 /* match + compile RE pattern */
diff --git a/misc/examples/regex_match.c b/misc/examples/regex_match.c
index ebda366f..310e0797 100644
--- a/misc/examples/regex_match.c
+++ b/misc/examples/regex_match.c
@@ -28,7 +28,7 @@ int main()
         printf("  %g\n", (double)*i.ref);
 
     // extracts the numbers only to a comma separated string.
-    cstr nums = cregex_replace_sv(&re, csview_from(str), " $0,", 0, NULL, CREG_R_STRIP);
+    cstr nums = cregex_replace_sv(&re, csview_from(str), " $0,", 0, NULL, CREG_STRIP);
     printf("\n%s\n", cstr_str(&nums));
 
     cstr_drop(&nums);
diff --git a/misc/examples/regex_replace.c b/misc/examples/regex_replace.c
index 2c7794af..3a33efde 100644
--- a/misc/examples/regex_replace.c
+++ b/misc/examples/regex_replace.c
@@ -48,7 +48,7 @@ int main()
         printf("euros: %s\n", cstr_str(&str));
 
         /* Strip out everything but the matches */
-        cstr_take(&str, cregex_replace_sv(&re, csview_from(input), "$3.$2.$1;", 0, NULL, CREG_R_STRIP));
+        cstr_take(&str, cregex_replace_sv(&re, csview_from(input), "$3.$2.$1;", 0, NULL, CREG_STRIP));
         printf("strip: %s\n", cstr_str(&str));
 
         /* Wrap all words in ${} */
diff --git a/misc/tests/cregex_test.c b/misc/tests/cregex_test.c
index 3ddcc608..4e192de6 100644
--- a/misc/tests/cregex_test.c
+++ b/misc/tests/cregex_test.c
@@ -15,7 +15,7 @@ CTEST(cregex, compile_match_char)
     ASSERT_EQ(re.error, 0);
 
     csview match;
-    ASSERT_EQ(cregex_find(&re, inp="äsdf", &match, CREG_M_FULLMATCH), CREG_OK);
+    ASSERT_EQ(cregex_find(&re, inp="äsdf", &match, CREG_FULLMATCH), CREG_OK);
     ASSERT_EQ(M_START(match), 0);
     ASSERT_EQ(M_END(match), 5); // ä is two bytes wide
 
@@ -193,14 +193,14 @@ CTEST(cregex, search_all)
         int res;
         ASSERT_EQ(re.error, CREG_OK);
         inp="ab,ab,ab";
-        res = cregex_find(&re, inp, &m, CREG_M_NEXT);
+        res = cregex_find(&re, inp, &m, CREG_NEXT);
         ASSERT_EQ(M_START(m), 0);
-        res = cregex_find(&re, inp, &m, CREG_M_NEXT);
+        res = cregex_find(&re, inp, &m, CREG_NEXT);
         ASSERT_EQ(res, CREG_OK);
         ASSERT_EQ(M_START(m), 3);
-        res = cregex_find(&re, inp, &m, CREG_M_NEXT);
+        res = cregex_find(&re, inp, &m, CREG_NEXT);
         ASSERT_EQ(M_START(m), 6);
-        res = cregex_find(&re, inp, &m, CREG_M_NEXT);
+        res = cregex_find(&re, inp, &m, CREG_NEXT);
         ASSERT_NE(res, CREG_OK);
     }
 }
@@ -280,7 +280,7 @@ CTEST(cregex, replace)
         ASSERT_STREQ(cstr_str(&str), "start date: 31.12.2015, end date: 28.02.2022");
 
         // Strip out everything but the matches
-        cstr_take(&str, cregex_replace_sv(&re, csview_from(input), "$3.$2.$1;", 0, NULL, CREG_R_STRIP));
+        cstr_take(&str, cregex_replace_sv(&re, csview_from(input), "$3.$2.$1;", 0, NULL, CREG_STRIP));
         ASSERT_STREQ(cstr_str(&str), "31.12.2015;28.02.2022;");
     }
 }
diff --git a/src/cregex.c b/src/cregex.c
index 9b7179b6..ac94a5dd 100644
--- a/src/cregex.c
+++ b/src/cregex.c
@@ -870,8 +870,8 @@ _regcomp1(_Reprog *pp, _Parser *par, const char *s, int cflags)
         par->error = CREG_OUTOFMEMORY;
         return NULL;
     }
-    pp->flags.icase = (cflags & CREG_C_ICASE) != 0;
-    pp->flags.dotall = (cflags & CREG_C_DOTALL) != 0;
+    pp->flags.icase = (cflags & CREG_ICASE) != 0;
+    pp->flags.dotall = (cflags & CREG_DOTALL) != 0;
     par->freep = pp->firstinst;
     par->classp = pp->cclass;
     par->error = 0;
@@ -1116,7 +1116,7 @@ _regexec1(const _Reprog *progp,  /* program to run */
                     /* efficiency: advance and re-evaluate */
                     continue;
                 case TOK_END:    /* Match! */
-                    match = !(mflags & CREG_M_FULLMATCH) ||
+                    match = !(mflags & CREG_FULLMATCH) ||
                             ((s == j->eol || r == 0 || r == '\n') &&
                             (tlp->se.m[0].str == bol || tlp->se.m[0].str[-1] == '\n'));
                     tlp->se.m[0].size = (s - tlp->se.m[0].str);
@@ -1184,9 +1184,9 @@ _regexec(const _Reprog *progp,    /* program to run */
     j.eol = NULL;
 
     if (mp && mp[0].size) {
-        if (mflags & CREG_M_STARTEND)
+        if (mflags & CREG_STARTEND)
             j.starts = mp[0].str, j.eol = mp[0].str + mp[0].size;
-        else if (mflags & CREG_M_NEXT)
+        else if (mflags & CREG_NEXT)
             j.starts = mp[0].str + mp[0].size;
     }
 
@@ -1298,7 +1298,7 @@ cregex_replace_sv_6(const cregex* re, csview input, const char* replace, int cou
     csview match[CREG_MAX_CAPTURES];
     int nmatch = cregex_captures(re) + 1;
     if (!count) count = INT32_MAX;
-    bool copy = !(rflags & CREG_R_STRIP);
+    bool copy = !(rflags & CREG_STRIP);
 
     while (count-- && cregex_find_sv(re, input, match) == CREG_OK) {
         _build_subst(replace, nmatch, match, mfun, &subst);