This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
regcomp.c: Change re_croak2 to re_croak
authorKarl Williamson <khw@cpan.org>
Thu, 27 Feb 2020 14:48:07 +0000 (07:48 -0700)
committerKarl Williamson <khw@cpan.org>
Sun, 1 Mar 2020 16:02:08 +0000 (09:02 -0700)
This changes this function from taking two format parameters to instead
taking a single one.  The reason is that the generality isn't actually
currently needed, and it prevents the function from being declared as
taking a format, which adds extra checking.  If this checking had been
in effect, GH #17574 would have generated a warning message.

The reason the second format isn't required is that in all cases, both
formats are literal strings.  In the macros that call this, simply
removing the comma separators between them causes the two literals to
automagically become one by the C preprocessor.

embed.fnc
proto.h
regcomp.c

index 935f75a..44d5fb9 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
@@ -2710,7 +2710,7 @@ ES        |SSize_t|study_chunk    |NN RExC_state_t *pRExC_state \
 ESR    |SV *   |get_ANYOFM_contents|NN const regnode * n
 ESRT   |U32    |add_data       |NN RExC_state_t* const pRExC_state \
                                |NN const char* const s|const U32 n
-rS     |void   |re_croak2      |bool utf8|NN const char* pat1|NN const char* pat2|...
+rS     |void   |re_croak       |bool utf8|NN const char* pat|...
 ES     |int    |handle_possible_posix                                      \
                                |NN RExC_state_t *pRExC_state               \
                                |NN const char* const s                     \
diff --git a/proto.h b/proto.h
index 441533f..582bd18 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -5686,10 +5686,10 @@ PERL_CALLCONV SV *      Perl_parse_uniprop_string(pTHX_ const char * const name, Size
 STATIC void    S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr);
 #define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST   \
        assert(node); assert(invlist_ptr)
-PERL_STATIC_NO_RET void        S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2, ...)
+PERL_STATIC_NO_RET void        S_re_croak(pTHX_ bool utf8, const char* pat, ...)
                        __attribute__noreturn__;
-#define PERL_ARGS_ASSERT_RE_CROAK2     \
-       assert(pat1); assert(pat2)
+#define PERL_ARGS_ASSERT_RE_CROAK      \
+       assert(pat)
 
 STATIC REGEXP* S_re_op_compile_wrapper(pTHX_ SV * const pattern, U32 orig_rx_flags, const U32 pm_flags)
                        __attribute__warn_unused_result__;
index efc1aac..dbe4f19 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -792,7 +792,7 @@ static const scan_data_t zero_scan_data = {
  * Like Simple_vFAIL(), but accepts two arguments.
  */
 #define        Simple_vFAIL2(m,a1) STMT_START {                        \
-    S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1,             \
+    S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1,               \
                       REPORT_LOCATION_ARGS(RExC_parse));       \
 } STMT_END
 
@@ -809,7 +809,7 @@ static const scan_data_t zero_scan_data = {
  * Like Simple_vFAIL(), but accepts three arguments.
  */
 #define        Simple_vFAIL3(m, a1, a2) STMT_START {                   \
-    S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1, a2,         \
+    S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1, a2,           \
            REPORT_LOCATION_ARGS(RExC_parse));                  \
 } STMT_END
 
@@ -825,7 +825,7 @@ static const scan_data_t zero_scan_data = {
  * Like Simple_vFAIL(), but accepts four arguments.
  */
 #define        Simple_vFAIL4(m, a1, a2, a3) STMT_START {               \
-    S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1, a2, a3,     \
+    S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1, a2, a3,       \
            REPORT_LOCATION_ARGS(RExC_parse));                  \
 } STMT_END
 
@@ -837,13 +837,13 @@ static const scan_data_t zero_scan_data = {
 /* A specialized version of vFAIL2 that works with UTF8f */
 #define vFAIL2utf8f(m, a1) STMT_START {             \
     PREPARE_TO_DIE;                                 \
-    S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1,  \
+    S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1,  \
             REPORT_LOCATION_ARGS(RExC_parse));      \
 } STMT_END
 
 #define vFAIL3utf8f(m, a1, a2) STMT_START {             \
     PREPARE_TO_DIE;                                     \
-    S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1, a2,  \
+    S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1, a2,  \
             REPORT_LOCATION_ARGS(RExC_parse));          \
 } STMT_END
 
@@ -21935,34 +21935,30 @@ Perl_regnext(pTHX_ regnode *p)
 #endif
 
 STATIC void
-S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2,...)
+S_re_croak(pTHX_ bool utf8, const char* pat,...)
 {
     va_list args;
-    STRLEN l1 = strlen(pat1);
-    STRLEN l2 = strlen(pat2);
+    STRLEN len = strlen(pat);
     char buf[512];
     SV *msv;
     const char *message;
 
-    PERL_ARGS_ASSERT_RE_CROAK2;
-
-    if (l1 > 510)
-       l1 = 510;
-    if (l1 + l2 > 510)
-       l2 = 510 - l1;
-    Copy(pat1, buf, l1 , char);
-    Copy(pat2, buf + l1, l2 , char);
-    buf[l1 + l2] = '\n';
-    buf[l1 + l2 + 1] = '\0';
-    va_start(args, pat2);
+    PERL_ARGS_ASSERT_RE_CROAK;
+
+    if (len > 510)
+       len = 510;
+    Copy(pat, buf, len , char);
+    buf[len] = '\n';
+    buf[len + 1] = '\0';
+    va_start(args, pat);
     msv = vmess(buf, &args);
     va_end(args);
-    message = SvPV_const(msv, l1);
-    if (l1 > 512)
-       l1 = 512;
-    Copy(message, buf, l1 , char);
-    /* l1-1 to avoid \n */
-    Perl_croak(aTHX_ "%" UTF8f, UTF8fARG(utf8, l1-1, buf));
+    message = SvPV_const(msv, len);
+    if (len > 512)
+       len = 512;
+    Copy(message, buf, len , char);
+    /* len-1 to avoid \n */
+    Perl_croak(aTHX_ "%" UTF8f, UTF8fARG(utf8, len-1, buf));
 }
 
 /* XXX Here's a total kludge.  But we need to re-enter for swash routines. */