Commit 1d8c04d825 for perl

commit 1d8c04d82539478a6e135184ce7f935848d767b8
Author: Paul Evans <leonerd@leonerd.org.uk>
Date:   Wed Oct 28 14:36:11 2026 +0000

    Whitespace fixes in recent magic-v2 code

    Adds whitespace in `if (COND)`, `while (COND)`, and similar syntax, in
    recent code I have written relating to magic-v2.

diff --git a/dump.c b/dump.c
index 92c4924f08..07f1edb07d 100644
--- a/dump.c
+++ b/dump.c
@@ -2011,7 +2011,7 @@ Perl_do_magicv2_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I
     dump_indent(level, file, "  MAGICv2 = 0x%" UVxf "\n", PTR2UV(mg));

     const struct MagicFunctions *funcs = MgFUNCS(mg);
-    if(funcs->debug_name)
+    if (funcs->debug_name)
         dump_indent(level, file, "    FUNCS = %s (0x%" UVxf ")\n",
                 funcs->debug_name, PTR2UV(funcs));
     else
@@ -2028,14 +2028,14 @@ Perl_do_magicv2_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I
             case MGv2s_SCALARVALUE:
                                   shapename = "SCALARVALUE"; break;
         }
-        if(shapename)
+        if (shapename)
             dump_indent(level, file, "      SHAPE = %s\n", shapename);
         else
             dump_indent(level, file, "      SHAPE = (%d)\n", funcs->shape);

-        if(funcs->free_mg)
+        if (funcs->free_mg)
             dump_indent(level, file, "      FREE_MG\n");
-        if(funcs->clone_mg)
+        if (funcs->clone_mg)
             dump_indent(level, file, "      CLONE_MG\n");

         switch(funcs->shape) {
@@ -2045,9 +2045,9 @@ Perl_do_magicv2_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I
             case MGv2s_SCALARVAR:
             {
                 const struct ScalarVarMagicFunctions *funcs = MgSCALARVARFUNCS(mg);
-                if(funcs->pre_get)
+                if (funcs->pre_get)
                     dump_indent(level, file, "      PRE_GET\n");
-                if(funcs->post_set)
+                if (funcs->post_set)
                     dump_indent(level, file, "      POST_SET\n");
                 break;
             }
@@ -2055,7 +2055,7 @@ Perl_do_magicv2_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I
             case MGv2s_ARRAYVAR:
             {
                 const struct ArrayVarMagicFunctions *funcs = MgARRAYVARFUNCS(mg);
-                if(funcs->clear)
+                if (funcs->clear)
                     dump_indent(level, file, "      CLEAR\n");
                 break;
             }
@@ -2063,14 +2063,14 @@ Perl_do_magicv2_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I
             case MGv2s_HASHVAR:
             {
                 const struct HashVarMagicFunctions *funcs = MgHASHVARFUNCS(mg);
-                if(funcs->clear)
+                if (funcs->clear)
                     dump_indent(level, file, "      CLEAR\n");
                 break;
             }
             case MGv2s_SCALARVALUE:
             {
                 const struct ScalarValueMagicFunctions *funcs = MgSCALARVALUEFUNCS(mg);
-                if(funcs->propagate)
+                if (funcs->propagate)
                     Perl_dump_indent(aTHX_ level, file, "      PROPAGATE\n");
                 break;
             }
@@ -2087,41 +2087,42 @@ Perl_do_magicv2_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I
             case MGv2f_WITH_KEYHEK: sv_catpvs(flagsv, "WITH_KEYHEK,"); break;
             case MGv2f_WITH_KEYSV:  sv_catpvs(flagsv, "WITH_KEYSV,");  break;
         }
-        if(SvCUR(flagsv))  /* trim trailing comma */
+        if (SvCUR(flagsv))  /* trim trailing comma */
             SvPVX(flagsv)[SvCUR(flagsv)-1] = '\0';
         dump_indent(level, file, "    FLAGS = (%s)\n", SvPVX(flagsv));
     }

-    if(MgPRIV(mg))
+    if (MgPRIV(mg))
         dump_indent(level, file, "    PRIV = 0x%04" UVxf "\n", (UV)MgPRIV(mg));

-    if(MgAUXSV(mg)) {
+    if (MgAUXSV(mg)) {
         dump_indent(level, file, "    AUXSV = 0x%" UVxf "\n", PTR2UV(MgAUXSV(mg)));
         do_sv_dump(level+2, file, MgAUXSV(mg), nest+1, maxnest, dumpops, pvlim); /* MG is already +1 */
     }

-    if(MgPTR(mg) && MgPTRLEN(mg)) {
+    if (MgPTR(mg) && MgPTRLEN(mg)) {
         size_t printlen = MgPTRLEN(mg);
-        if(printlen > 32) printlen = 32;
+        if (printlen > 32)
+            printlen = 32;
         SV *tmpsv = newSVpvs_flags("", SVs_TEMP);
         dump_indent(level, file, "    PTR = \"%s\"%s (LEN = %zd)\n",
                 generic_pv_escape(tmpsv, (char *)MgPTR(mg), printlen, 0),
                 MgPTRLEN(mg) > 32 ? "..." : "",
                 MgPTRLEN(mg));
     }
-    else if(MgPTR(mg)) {
+    else if (MgPTR(mg)) {
         dump_indent(level, file, "    PTR = 0x%" UVxf "\n",
                 PTR2UV(MgPTR(mg)));
     }
-    else if(MgPTRLEN(mg)) {
+    else if (MgPTRLEN(mg)) {
         dump_indent(level, file, "    PTRLEN = %zd\n",
                 MgPTRLEN(mg));
     }

-    if(MgHasKEYIV(mg)) {
+    if (MgHasKEYIV(mg)) {
         dump_indent(level, file, "    KEYIV = %" IVdf "\n", MgKEYIV(mg));
     }
-    else if(MgHasKEYSV(mg)) {
+    else if (MgHasKEYSV(mg)) {
         dump_indent(level, file, "    KEYSV = 0x%" UVxf "\n", PTR2UV(MgKEYSV(mg)));
         do_sv_dump(level+2, file, MgKEYSV(mg), nest+1, maxnest, dumpops, pvlim); /* MG is already +1 */
     }
diff --git a/mg.c b/mg.c
index ad6fe0a04f..63f6dcef1e 100644
--- a/mg.c
+++ b/mg.c
@@ -511,7 +511,7 @@ Perl_mg_magical(SV *sv)

                     case MGv2s_SCALARVALUE:
                         SvRMAGICAL_on(sv);
-                        if(SvTYPE(sv) <= SVt_PVMG)
+                        if (SvTYPE(sv) <= SVt_PVMG)
                             /* Only regular scalars can use the SVs_VMG flag.
                              * If this was a SVt_REGEXP or similar, we'll just
                              * have to ignore it and go the long way round
@@ -789,10 +789,10 @@ Perl_mg_propagate(pTHX_ SV *ssv, SV *dsv)
 {
     PERL_ARGS_ASSERT_MG_PROPAGATE;

-    if(SvTYPE(ssv) < SVt_PVMG || !SvMAGICAL(ssv))
+    if (SvTYPE(ssv) < SVt_PVMG || !SvMAGICAL(ssv))
         return;

-    for(MAGIC *smg = SvMAGIC(ssv); smg; smg = smg->mg_moremagic) {
+    for (MAGIC *smg = SvMAGIC(ssv); smg; smg = smg->mg_moremagic) {
         if (!MgIsV2(smg))
             continue;

@@ -804,12 +804,12 @@ Perl_mg_propagate(pTHX_ SV *ssv, SV *dsv)
         const struct ScalarValueMagicFunctions *funcs = MgSCALARVALUEFUNCS(smg);

         MAGIC *dmg = NULL;
-        if(funcs->flags & MGv2f_SCALARVALUE_AUTOPROPAGATE) {
+        if (funcs->flags & MGv2f_SCALARVALUE_AUTOPROPAGATE) {
             dmg = sv_magicv2_attach(dsv, MgFUNCS(smg), MgFLAGS(smg));
             mgv2_copy(smg, dmg);
         }

-        if(funcs->propagate)
+        if (funcs->propagate)
             (*funcs->propagate)(aTHX_ ssv, smg, dsv, dmg);
     }
 }
@@ -961,17 +961,17 @@ Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
                     break;

                 case MGv2s_SCALARVAR:
-                    if(MgSCALARVARFUNCS(mg)->localize_mg)
+                    if (MgSCALARVARFUNCS(mg)->localize_mg)
                         (*MgSCALARVARFUNCS(mg)->localize_mg)(aTHX_ nsv, sv, mg);
                     break;

                 case MGv2s_ARRAYVAR:
-                    if(MgARRAYVARFUNCS(mg)->localize_mg)
+                    if (MgARRAYVARFUNCS(mg)->localize_mg)
                         (*MgARRAYVARFUNCS(mg)->localize_mg)(aTHX_ nsv, sv, mg);
                     break;

                 case MGv2s_HASHVAR:
-                    if(MgHASHVARFUNCS(mg)->localize_mg)
+                    if (MgHASHVARFUNCS(mg)->localize_mg)
                         (*MgHASHVARFUNCS(mg)->localize_mg)(aTHX_ nsv, sv, mg);
                     break;
             }
@@ -1064,22 +1064,22 @@ Perl_mg_free_struct(pTHX_ SV *sv, MAGIC *mg)
 {
     PERL_ARGS_ASSERT_MG_FREE_STRUCT;

-    if(MgIsV2(mg)) {
+    if (MgIsV2(mg)) {
         const struct MagicFunctions *funcs = MgFUNCS(mg);
         if (funcs->free_mg)
             funcs->free_mg(aTHX_ sv, mg);

-        if(MgHasKEYSV(mg))
+        if (MgHasKEYSV(mg))
             SvREFCNT_dec(MgKEYSV(mg));

-        if(MgPTR(mg) && MgPTRLEN(mg)) {
+        if (MgPTR(mg) && MgPTRLEN(mg)) {
             /* can't
                 Safefree(MgPTR(mg));
               here because Safefree() requires an lvalue under -DPERL_POISON */
             Safefree(mg->mg_ptr);
         }

-        if(MgAUXSV(mg) && !MgWEAK_AUXSV(mg)) {
+        if (MgAUXSV(mg) && !MgWEAK_AUXSV(mg)) {
             SvREFCNT_dec(MgAUXSV(mg));
         }
     }
@@ -1088,7 +1088,7 @@ Perl_mg_free_struct(pTHX_ SV *sv, MAGIC *mg)
         if (vtbl && vtbl->svt_free)
             vtbl->svt_free(aTHX_ sv, mg);

-        if(mg->mg_ptr) {
+        if (mg->mg_ptr) {
             if (mg->mg_type == PERL_MAGIC_regex_global)
                 NOOP;
             else if (mg->mg_len > 0)
diff --git a/sv.c b/sv.c
index 71458822ed..2a7106ccb1 100644
--- a/sv.c
+++ b/sv.c
@@ -4575,7 +4575,7 @@ Perl_sv_setsv_flags(pTHX_ SV *dsv, SV* ssv, const I32 flags)
     SV_CHECK_THINKFIRST_COW_DROP(dsv);
     dtype = SvTYPE(dsv); /* THINKFIRST may have changed type */

-    if(dtype >= SVt_PVMG)
+    if (dtype >= SVt_PVMG)
         mg_unpropagate(dsv);

     /* There's a lot of redundancy below but we're going for speed here
@@ -6706,7 +6706,7 @@ Perl_sv_magicv2_add(pTHX_ SV *sv, const struct MagicFunctions *funcs, U32 flags,
     PERL_ARGS_ASSERT_SV_MAGICV2_ADD;
     U8 svt = SvTYPE(sv);

-    if(funcs->ver != 2)
+    if (funcs->ver != 2)
         croak("Unsupported MagicFunctions->ver value of %u", (unsigned int)funcs->ver);

     switch(funcs->shape) {
@@ -6715,22 +6715,22 @@ Perl_sv_magicv2_add(pTHX_ SV *sv, const struct MagicFunctions *funcs, U32 flags,
             break;

         case MGv2s_SCALARVAR:
-            if(svt > SVt_PVMG && svt != SVt_PVLV)
+            if (svt > SVt_PVMG && svt != SVt_PVLV)
                 goto bad_shape;
             break;

         case MGv2s_ARRAYVAR:
-            if(svt != SVt_PVAV)
+            if (svt != SVt_PVAV)
                 goto bad_shape;
             break;

         case MGv2s_HASHVAR:
-            if(svt != SVt_PVHV)
+            if (svt != SVt_PVHV)
                 goto bad_shape;
             break;

         case MGv2s_SCALARVALUE:
-            if(svt > SVt_PVMG && svt != SVt_PVLV && svt != SVt_REGEXP)
+            if (svt > SVt_PVMG && svt != SVt_PVLV && svt != SVt_REGEXP)
                 goto bad_shape;
             break;

@@ -6746,11 +6746,11 @@ bad_shape:

     MgPRIV(mg)  = 0;

-    if(!(funcs->flags & MGv2f_ALWAYS_WEAK_AUXSV))
+    if (!(funcs->flags & MGv2f_ALWAYS_WEAK_AUXSV))
         MgFLAGS(mg) |= MGv2f_REFCOUNTED_AUXSV;

-    if(funcs->shape == MGv2s_SCALARVALUE)
-        if(!PL_valuemagic_annotations) {
+    if (funcs->shape == MGv2s_SCALARVALUE)
+        if (!PL_valuemagic_annotations) {
             PL_valuemagic_annotations = newSV_type(SVt_PVMG);
         }

@@ -6832,28 +6832,28 @@ Perl_mg_ptr_store(pTHX_ MAGIC *mg, const void *ptr, STRLEN len)
     MgPTR_set(mg, new_ptr);
     MgPTRLEN_set(mg, len);

-    if(was_ptr && was_len)
+    if (was_ptr && was_len)
         Safefree(was_ptr);
 }

 static MAGIC *
 S_sv_magicv2_find(pTHX_ const SV *sv, bool (*filter)(pTHX_ MAGIC *mg, const void *key), const void *key, MAGIC *mg)
 {
-    if(SvTYPE(sv) < SVt_PVMG || !SvMAGICAL(sv))
+    if (SvTYPE(sv) < SVt_PVMG || !SvMAGICAL(sv))
         return NULL;

-    if(mg)
+    if (mg)
         mg = mg->mg_moremagic;
     else
         mg = SvMAGIC(sv);
-    for(/**/; mg; mg = mg->mg_moremagic) {
+    for (/**/; mg; mg = mg->mg_moremagic) {
         /* Don't really need to look at mg->mg_type since we're going to
          * filter on the virtual table anyway
          */
-        if(!MgIsV2(mg))
+        if (!MgIsV2(mg))
             continue;

-        if((*filter)(aTHX_ (MAGIC *)mg, key))
+        if ((*filter)(aTHX_ (MAGIC *)mg, key))
             return (MAGIC *)mg;
     }

@@ -6950,21 +6950,21 @@ S_sv_magicv2_remove(pTHX_ SV *sv, bool (*filter)(pTHX_ MAGIC *mg, const void *ke
      * functions are running. This permits us to remove the very magic that
      * is actively running, allowing magics to remove themselves
      */
-    if(SvTYPE(sv) < SVt_PVMG)
+    if (SvTYPE(sv) < SVt_PVMG)
         return;

     bool mg_magical_again = false;

     MAGIC *prevmg = NULL, *nextmg;
-    for(MAGIC *mg = SvMAGIC(sv); mg; prevmg = mg, mg = nextmg) {
+    for (MAGIC *mg = SvMAGIC(sv); mg; prevmg = mg, mg = nextmg) {
         nextmg = mg->mg_moremagic;
-        if(!MgIsV2(mg))
+        if (!MgIsV2(mg))
             continue;

-        if(!(*filter)(aTHX_ (MAGIC *)mg, key))
+        if (!(*filter)(aTHX_ (MAGIC *)mg, key))
             continue;

-        if(prevmg)
+        if (prevmg)
             prevmg->mg_moremagic = nextmg;
         else
             SvMAGIC_set(sv, nextmg);
@@ -6975,7 +6975,7 @@ S_sv_magicv2_remove(pTHX_ SV *sv, bool (*filter)(pTHX_ MAGIC *mg, const void *ke
         mg = prevmg;
     }

-    if(mg_magical_again)
+    if (mg_magical_again)
         mg_magical(sv);
 }

@@ -6997,7 +6997,7 @@ Perl_sv_magicv2_find_or_add(pTHX_ SV *sv, const struct MagicFunctions *funcs)
     PERL_ARGS_ASSERT_SV_MAGICV2_FIND_OR_ADD;

     MAGIC *mg = sv_magicv2_find_by_funcs(sv, funcs);
-    if(!mg)
+    if (!mg)
         mg = sv_magicv2_add(sv, funcs, 0, NULL);

     return mg;
@@ -15725,22 +15725,22 @@ Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param)

             void *optr  = MgPTR(mg);
             STRLEN olen = MgPTRLEN(mg);
-            if(optr && olen) {
+            if (optr && olen) {
                 MgPTR_set(nmg, savepvn((char *)optr, olen));
             }

-            if(MgAUXSV(nmg)) {
-                if(MgWEAK_AUXSV(nmg))
+            if (MgAUXSV(nmg)) {
+                if (MgWEAK_AUXSV(nmg))
                     nmg->mg_obj = sv_dup    (MgAUXSV(nmg), param);
                 else
                     nmg->mg_obj = sv_dup_inc(MgAUXSV(nmg), param);
             }

-            if(MgHasKEYSV(nmg)) {
+            if (MgHasKEYSV(nmg)) {
                 MgKEYSV(nmg) = sv_dup_inc(MgKEYSV(nmg), param);
             }

-            if(funcs->clone_mg) {
+            if (funcs->clone_mg) {
                 /* TODO: Once we are no longer layered on top of MAGIC, then we should
                  * have direct access to the osv and nsv values. For now we will just
                  * pass them in as NULL