regexec.c: Change static function API

Sometimes this functionality is needed to also skip over certain
intervening classes of characters while backing up in the parse string.
This commit creates two macros to call the modified underlying function
with a boolean flag.  This names of the macros make it easy to know
what's happening.

Author: khwilliamson

embed.fnc

@@ -5651,9 +5651,10 @@ ERS	|WB_enum|advance_one_WB_|NN U8 **curpos 			\
 ERS	|GCB_enum|backup_one_GCB|NN const U8 * const strbeg		\
 				|NN U8 **curpos 			\
 				|const bool utf8_target
-ERS	|LB_enum|backup_one_LB	|NN const U8 * const strbeg		\
+ERS	|LB_enum|backup_one_LB_ |NN const U8 * const strbeg		\
 				|NN U8 **curpos 			\
-				|const bool utf8_target
+				|const bool utf8_target 		\
+				|bool skip_CM_ZWJ
 ERS	|SB_enum|backup_one_SB	|NN const U8 * const strbeg		\
 				|NN U8 **curpos 			\
 				|const bool utf8_target

embed.h

@@ -2014,7 +2014,7 @@
 #     define advance_one_SB(a,b,c)              S_advance_one_SB(aTHX_ a,b,c)
 #     define advance_one_WB_(a,b,c,d)           S_advance_one_WB_(aTHX_ a,b,c,d)
 #     define backup_one_GCB(a,b,c)              S_backup_one_GCB(aTHX_ a,b,c)
-#     define backup_one_LB(a,b,c)               S_backup_one_LB(aTHX_ a,b,c)
+#     define backup_one_LB_(a,b,c,d)            S_backup_one_LB_(aTHX_ a,b,c,d)
 #     define backup_one_SB(a,b,c)               S_backup_one_SB(aTHX_ a,b,c)
 #     define backup_one_WB_but_over_Extend_FO(a,b,c,d) S_backup_one_WB_but_over_Extend_FO(aTHX_ a,b,c,d)
 #     define capture_clear(a,b,c,d)             S_capture_clear(aTHX_ a,b,c,d comma_aDEPTH)

proto.h

@@ -5375,6 +5375,11 @@ S_backup_one_GCB(pTHX_ const U8 * const strbeg, U8 ** curpos, const bool utf8_ta
                                      || isLB_Space(prev)                \
                                      || isLB_ZWSpace(prev)))
 
+#define backup_one_LB(begin, cur, utf8)                                 \
+                                backup_one_LB_(begin, cur, utf8, false)
+#define backup_one_LB_but_over_CM_ZWJ(begin, cur, utf8)                 \
+                                backup_one_LB_(begin, cur, utf8, true)
+
 STATIC bool
 S_isLB(pTHX_ LB_enum before,
              LB_enum after,
@@ -5491,11 +5496,8 @@ S_isLB(pTHX_ LB_enum before,
 
             /* We don't know how to treat the CM except by looking at the first
              * non-CM character preceding it.  ZWJ is treated as CM */
-            do {
-                prev = backup_one_LB(strbeg, &temp_pos, utf8_target);
-            }
-            while (isLB_Combining_Mark(prev) || isLB_ZWJ(prev));
-
+            prev = backup_one_LB_but_over_CM_ZWJ(strbeg, &temp_pos,
+                                                 utf8_target);
             /* Here, 'prev' is that first earlier non-CM character.  If the CM
              * attaches to it, then it inherits the behavior of 'prev'.  If it
              * doesn't attach, it is to be treated as an AL */
@@ -5630,41 +5632,55 @@ S_advance_one_LB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_ta
 }
 
 STATIC LB_enum
-S_backup_one_LB(pTHX_ const U8 * const strbeg, U8 ** curpos, const bool utf8_target)
+S_backup_one_LB_(pTHX_ const U8 * const strbeg,
+                       U8 ** curpos,
+                       const bool utf8_target,
+                       bool skip_CM_ZWJ)
 {
-    LB_enum lb;
+    PERL_ARGS_ASSERT_BACKUP_ONE_LB_;
 
-    PERL_ARGS_ASSERT_BACKUP_ONE_LB;
+    LB_enum isLB_scratch;   /* Used by generated isLB_foo() macros */
 
     if (*curpos < strbeg) {
         return LB_EDGE;
     }
 
+    LB_enum lb;
+
     if (utf8_target) {
         U8 * prev_char_pos = reghopmaybe3(*curpos, -1, strbeg);
-        U8 * prev_prev_char_pos;
-
         if (! prev_char_pos) {
             return LB_EDGE;
         }
 
-        if ((prev_prev_char_pos = reghopmaybe3((U8 *) prev_char_pos, -1, strbeg))) {
-            lb = getLB_VAL_UTF8(prev_prev_char_pos, prev_char_pos);
-            *curpos = prev_char_pos;
-            prev_char_pos = prev_prev_char_pos;
-        }
-        else {
-            *curpos = (U8 *) strbeg;
-            return LB_EDGE;
-        }
+        /* Back up one.  Keep going if result is CM or ZWJ and caller wants
+         * those skipped.  curpos is always just to the right of the character
+         * whose value we are getting */
+        do {
+            U8 * prev_prev_char_pos;
+            if ((prev_prev_char_pos = reghopmaybe3((U8 *) prev_char_pos,
+                                                   -1,
+                                                   strbeg)))
+            {
+                lb = getLB_VAL_UTF8(prev_prev_char_pos, prev_char_pos);
+                *curpos = prev_char_pos;
+                prev_char_pos = prev_prev_char_pos;
+            }
+            else {
+                *curpos = (U8 *) strbeg;
+                return LB_EDGE;
+            }
+        } while (skip_CM_ZWJ && (isLB_CM(lb) || isLB_ZWJ(lb)));
     }
     else {
-        if (*curpos - 2 < strbeg) {
-            *curpos = (U8 *) strbeg;
-            return LB_EDGE;
-        }
-        (*curpos)--;
-        lb = getLB_VAL_CP(*(*curpos - 1));
+        do {
+            if (*curpos - 2 < strbeg) {
+                *curpos = (U8 *) strbeg;
+                return LB_EDGE;
+            }
+            (*curpos)--;
+            lb = getLB_VAL_CP(*(*curpos - 1));
+        } while (skip_CM_ZWJ && (isLB_CM(lb) || isLB_ZWJ(lb)));
     }
 
     return lb;