This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Bump Data::Dumper version
[perl5.git] / av.c
diff --git a/av.c b/av.c
index ed67df1..ff0cb23 100644 (file)
--- a/av.c
+++ b/av.c
@@ -28,22 +28,22 @@ Perl_av_reify(pTHX_ AV *av)
     assert(SvTYPE(av) == SVt_PVAV);
 
     if (AvREAL(av))
-       return;
+        return;
 #ifdef DEBUGGING
     if (SvTIED_mg((const SV *)av, PERL_MAGIC_tied))
-       Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "av_reify called on tied array");
+        Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "av_reify called on tied array");
 #endif
     key = AvMAX(av) + 1;
     while (key > AvFILLp(av) + 1)
-       AvARRAY(av)[--key] = NULL;
+        AvARRAY(av)[--key] = NULL;
     while (key) {
-       SV * const sv = AvARRAY(av)[--key];
-       if (sv != &PL_sv_undef)
-           SvREFCNT_inc_simple_void(sv);
+        SV * const sv = AvARRAY(av)[--key];
+        if (sv != &PL_sv_undef)
+            SvREFCNT_inc_simple_void(sv);
     }
     key = AvARRAY(av) - AvALLOC(av);
     while (key)
-       AvALLOC(av)[--key] = NULL;
+        AvALLOC(av)[--key] = NULL;
     AvREIFY_off(av);
     AvREAL_on(av);
 }
@@ -72,7 +72,7 @@ Perl_av_extend(pTHX_ AV *av, SSize_t key)
 
     mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied);
     if (mg) {
-       SV *arg1 = sv_newmortal();
+        SV *arg1 = sv_newmortal();
         /* NOTE: the API for av_extend() is NOT the same as the tie method EXTEND.
          *
          * The C function takes an *index* (assumes 0 indexed arrays) and ensures
@@ -82,10 +82,10 @@ Perl_av_extend(pTHX_ AV *av, SSize_t key)
          * is at least that many elements large. Thus we have to +1 the key when
          * we call the tied method.
          */
-       sv_setiv(arg1, (IV)(key + 1));
-       Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(EXTEND), G_DISCARD, 1,
-                           arg1);
-       return;
+        sv_setiv(arg1, (IV)(key + 1));
+        Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(EXTEND), G_DISCARD, 1,
+                            arg1);
+        return;
     }
     av_extend_guts(av,key,&AvMAX(av),&AvALLOC(av),&AvARRAY(av));
 }    
@@ -225,23 +225,23 @@ S_adjust_index(pTHX_ AV *av, const MAGIC *mg, SSize_t *keyp)
 {
     bool adjust_index = 1;
     if (mg) {
-       /* Handle negative array indices 20020222 MJD */
-       SV * const ref = SvTIED_obj(MUTABLE_SV(av), mg);
-       SvGETMAGIC(ref);
-       if (SvROK(ref) && SvOBJECT(SvRV(ref))) {
-           SV * const * const negative_indices_glob =
-               hv_fetchs(SvSTASH(SvRV(ref)), NEGATIVE_INDICES_VAR, 0);
-
-           if (negative_indices_glob && isGV(*negative_indices_glob)
-            && SvTRUE(GvSV(*negative_indices_glob)))
-               adjust_index = 0;
-       }
+        /* Handle negative array indices 20020222 MJD */
+        SV * const ref = SvTIED_obj(MUTABLE_SV(av), mg);
+        SvGETMAGIC(ref);
+        if (SvROK(ref) && SvOBJECT(SvRV(ref))) {
+            SV * const * const negative_indices_glob =
+                hv_fetchs(SvSTASH(SvRV(ref)), NEGATIVE_INDICES_VAR, 0);
+
+            if (negative_indices_glob && isGV(*negative_indices_glob)
+             && SvTRUE(GvSV(*negative_indices_glob)))
+                adjust_index = 0;
+        }
     }
 
     if (adjust_index) {
-       *keyp += AvFILL(av) + 1;
-       if (*keyp < 0)
-           return FALSE;
+        *keyp += AvFILL(av) + 1;
+        if (*keyp < 0)
+            return FALSE;
     }
     return TRUE;
 }
@@ -257,22 +257,22 @@ Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
 
     if (UNLIKELY(SvRMAGICAL(av))) {
         const MAGIC * const tied_magic
-           = mg_find((const SV *)av, PERL_MAGIC_tied);
+            = mg_find((const SV *)av, PERL_MAGIC_tied);
         if (tied_magic || mg_find((const SV *)av, PERL_MAGIC_regdata)) {
-           SV *sv;
-           if (key < 0) {
-               if (!S_adjust_index(aTHX_ av, tied_magic, &key))
-                       return NULL;
-           }
+            SV *sv;
+            if (key < 0) {
+                if (!S_adjust_index(aTHX_ av, tied_magic, &key))
+                        return NULL;
+            }
 
             sv = sv_newmortal();
-           sv_upgrade(sv, SVt_PVLV);
-           mg_copy(MUTABLE_SV(av), sv, 0, key);
-           if (!tied_magic) /* for regdata, force leavesub to make copies */
-               SvTEMP_off(sv);
-           LvTYPE(sv) = 't';
-           LvTARG(sv) = sv; /* fake (SV**) */
-           return &(LvTARG(sv));
+            sv_upgrade(sv, SVt_PVLV);
+            mg_copy(MUTABLE_SV(av), sv, 0, key);
+            if (!tied_magic) /* for regdata, force leavesub to make copies */
+                SvTEMP_off(sv);
+            LvTYPE(sv) = 't';
+            LvTARG(sv) = sv; /* fake (SV**) */
+            return &(LvTARG(sv));
         }
     }
 
@@ -283,14 +283,14 @@ Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
     /* the cast from SSize_t to Size_t allows both (key < 0) and (key >= size)
      * to be tested as a single condition */
     if ((Size_t)key >= (Size_t)size) {
-       if (UNLIKELY(neg))
-           return NULL;
+        if (UNLIKELY(neg))
+            return NULL;
         goto emptyness;
     }
 
     if (!AvARRAY(av)[key]) {
       emptyness:
-       return lval ? av_store(av,key,newSV(0)) : NULL;
+        return lval ? av_store(av,key,newSV(0)) : NULL;
     }
 
     return &AvARRAY(av)[key];
@@ -334,59 +334,59 @@ Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val)
         const MAGIC * const tied_magic = mg_find((const SV *)av, PERL_MAGIC_tied);
         if (tied_magic) {
             if (key < 0) {
-               if (!S_adjust_index(aTHX_ av, tied_magic, &key))
+                if (!S_adjust_index(aTHX_ av, tied_magic, &key))
                         return 0;
             }
-           if (val) {
-               mg_copy(MUTABLE_SV(av), val, 0, key);
-           }
-           return NULL;
+            if (val) {
+                mg_copy(MUTABLE_SV(av), val, 0, key);
+            }
+            return NULL;
         }
     }
 
 
     if (key < 0) {
-       key += AvFILL(av) + 1;
-       if (key < 0)
-           return NULL;
+        key += AvFILL(av) + 1;
+        if (key < 0)
+            return NULL;
     }
 
     if (SvREADONLY(av) && key >= AvFILL(av))
-       Perl_croak_no_modify();
+        Perl_croak_no_modify();
 
     if (!AvREAL(av) && AvREIFY(av))
-       av_reify(av);
+        av_reify(av);
     if (key > AvMAX(av))
-       av_extend(av,key);
+        av_extend(av,key);
     ary = AvARRAY(av);
     if (AvFILLp(av) < key) {
-       if (!AvREAL(av)) {
-           if (av == PL_curstack && key > PL_stack_sp - PL_stack_base)
-               PL_stack_sp = PL_stack_base + key;      /* XPUSH in disguise */
-           do {
-               ary[++AvFILLp(av)] = NULL;
-           } while (AvFILLp(av) < key);
-       }
-       AvFILLp(av) = key;
+        if (!AvREAL(av)) {
+            if (av == PL_curstack && key > PL_stack_sp - PL_stack_base)
+                PL_stack_sp = PL_stack_base + key;     /* XPUSH in disguise */
+            do {
+                ary[++AvFILLp(av)] = NULL;
+            } while (AvFILLp(av) < key);
+        }
+        AvFILLp(av) = key;
     }
     else if (AvREAL(av))
-       SvREFCNT_dec(ary[key]);
+        SvREFCNT_dec(ary[key]);
     ary[key] = val;
     if (SvSMAGICAL(av)) {
-       const MAGIC *mg = SvMAGIC(av);
-       bool set = TRUE;
-       for (; mg; mg = mg->mg_moremagic) {
-         if (!isUPPER(mg->mg_type)) continue;
-         if (val) {
-           sv_magic(val, MUTABLE_SV(av), toLOWER(mg->mg_type), 0, key);
-         }
-         if (PL_delaymagic && mg->mg_type == PERL_MAGIC_isa) {
-           PL_delaymagic |= DM_ARRAY_ISA;
-           set = FALSE;
-         }
-       }
-       if (set)
-          mg_set(MUTABLE_SV(av));
+        const MAGIC *mg = SvMAGIC(av);
+        bool set = TRUE;
+        for (; mg; mg = mg->mg_moremagic) {
+          if (!isUPPER(mg->mg_type)) continue;
+          if (val) {
+            sv_magic(val, MUTABLE_SV(av), toLOWER(mg->mg_type), 0, key);
+          }
+          if (PL_delaymagic && mg->mg_type == PERL_MAGIC_isa) {
+            PL_delaymagic |= DM_ARRAY_ISA;
+            set = FALSE;
+          }
+        }
+        if (set)
+           mg_set(MUTABLE_SV(av));
     }
     return &ary[key];
 }
@@ -416,29 +416,29 @@ Perl_av_make(pTHX_ SSize_t size, SV **strp)
         SSize_t i;
         SSize_t orig_ix;
 
-       Newx(ary,size,SV*);
-       AvALLOC(av) = ary;
-       AvARRAY(av) = ary;
-       AvMAX(av) = size - 1;
+        Newx(ary,size,SV*);
+        AvALLOC(av) = ary;
+        AvARRAY(av) = ary;
+        AvMAX(av) = size - 1;
         /* avoid av being leaked if croak when calling magic below */
         EXTEND_MORTAL(1);
         PL_tmps_stack[++PL_tmps_ix] = (SV*)av;
         orig_ix = PL_tmps_ix;
 
-       for (i = 0; i < size; i++) {
-           assert (*strp);
+        for (i = 0; i < size; i++) {
+            assert (*strp);
 
-           /* Don't let sv_setsv swipe, since our source array might
-              have multiple references to the same temp scalar (e.g.
-              from a list slice) */
+            /* Don't let sv_setsv swipe, since our source array might
+               have multiple references to the same temp scalar (e.g.
+               from a list slice) */
 
-           SvGETMAGIC(*strp); /* before newSV, in case it dies */
-           AvFILLp(av)++;
-           ary[i] = newSV(0);
-           sv_setsv_flags(ary[i], *strp,
-                          SV_DO_COW_SVSETSV|SV_NOSTEAL);
-           strp++;
-       }
+            SvGETMAGIC(*strp); /* before newSV, in case it dies */
+            AvFILLp(av)++;
+            ary[i] = newSV(0);
+            sv_setsv_flags(ary[i], *strp,
+                           SV_DO_COW_SVSETSV|SV_NOSTEAL);
+            strp++;
+        }
         /* disarm av's leak guard */
         if (LIKELY(PL_tmps_ix == orig_ix))
             PL_tmps_ix--;
@@ -451,7 +451,7 @@ Perl_av_make(pTHX_ SSize_t size, SV **strp)
 /*
 =for apidoc av_clear
 
-Frees the all the elements of an array, leaving it empty.
+Frees all the elements of an array, leaving it empty.
 The XS equivalent of C<@array = ()>.  See also L</av_undef>.
 
 Note that it is possible that the actions of a destructor called directly
@@ -476,46 +476,46 @@ Perl_av_clear(pTHX_ AV *av)
 
 #ifdef DEBUGGING
     if (SvREFCNT(av) == 0) {
-       Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "Attempt to clear deleted array");
+        Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "Attempt to clear deleted array");
     }
 #endif
 
     if (SvREADONLY(av))
-       Perl_croak_no_modify();
+        Perl_croak_no_modify();
 
     /* Give any tie a chance to cleanup first */
     if (SvRMAGICAL(av)) {
-       const MAGIC* const mg = SvMAGIC(av);
-       if (PL_delaymagic && mg && mg->mg_type == PERL_MAGIC_isa)
-           PL_delaymagic |= DM_ARRAY_ISA;
+        const MAGIC* const mg = SvMAGIC(av);
+        if (PL_delaymagic && mg && mg->mg_type == PERL_MAGIC_isa)
+            PL_delaymagic |= DM_ARRAY_ISA;
         else
-           mg_clear(MUTABLE_SV(av)); 
+            mg_clear(MUTABLE_SV(av)); 
     }
 
     if (AvMAX(av) < 0)
-       return;
+        return;
 
     if ((real = cBOOL(AvREAL(av)))) {
-       SV** const ary = AvARRAY(av);
-       SSize_t index = AvFILLp(av) + 1;
+        SV** const ary = AvARRAY(av);
+        SSize_t index = AvFILLp(av) + 1;
 
         /* avoid av being freed when calling destructors below */
         EXTEND_MORTAL(1);
         PL_tmps_stack[++PL_tmps_ix] = SvREFCNT_inc_simple_NN(av);
         orig_ix = PL_tmps_ix;
 
-       while (index) {
-           SV * const sv = ary[--index];
-           /* undef the slot before freeing the value, because a
-            * destructor might try to modify this array */
-           ary[index] = NULL;
-           SvREFCNT_dec(sv);
-       }
+        while (index) {
+            SV * const sv = ary[--index];
+            /* undef the slot before freeing the value, because a
+             * destructor might try to modify this array */
+            ary[index] = NULL;
+            SvREFCNT_dec(sv);
+        }
     }
     extra = AvARRAY(av) - AvALLOC(av);
     if (extra) {
-       AvMAX(av) += extra;
-       AvARRAY(av) = AvALLOC(av);
+        AvMAX(av) += extra;
+        AvARRAY(av) = AvALLOC(av);
     }
     AvFILLp(av) = -1;
     if (real) {
@@ -553,19 +553,19 @@ Perl_av_undef(pTHX_ AV *av)
 
     /* Give any tie a chance to cleanup first */
     if (SvTIED_mg((const SV *)av, PERL_MAGIC_tied)) 
-       av_fill(av, -1);
+        av_fill(av, -1);
 
     real = cBOOL(AvREAL(av));
     if (real) {
-       SSize_t key = AvFILLp(av) + 1;
+        SSize_t key = AvFILLp(av) + 1;
 
         /* avoid av being freed when calling destructors below */
         EXTEND_MORTAL(1);
         PL_tmps_stack[++PL_tmps_ix] = SvREFCNT_inc_simple_NN(av);
         orig_ix = PL_tmps_ix;
 
-       while (key)
-           SvREFCNT_dec(AvARRAY(av)[--key]);
+        while (key)
+            SvREFCNT_dec(AvARRAY(av)[--key]);
     }
 
     Safefree(AvALLOC(av));
@@ -600,7 +600,7 @@ Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val)
     PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH;
 
     if (!*avp)
-       *avp = newAV();
+        *avp = newAV();
     av_push(*avp, val);
 }
 
@@ -624,12 +624,12 @@ Perl_av_push(pTHX_ AV *av, SV *val)
     assert(SvTYPE(av) == SVt_PVAV);
 
     if (SvREADONLY(av))
-       Perl_croak_no_modify();
+        Perl_croak_no_modify();
 
     if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
-       Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(PUSH), G_DISCARD, 1,
-                           val);
-       return;
+        Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(PUSH), G_DISCARD, 1,
+                            val);
+        return;
     }
     av_store(av,AvFILLp(av)+1,val);
 }
@@ -656,19 +656,19 @@ Perl_av_pop(pTHX_ AV *av)
     assert(SvTYPE(av) == SVt_PVAV);
 
     if (SvREADONLY(av))
-       Perl_croak_no_modify();
+        Perl_croak_no_modify();
     if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
-       retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(POP), 0, 0);
-       if (retval)
-           retval = newSVsv(retval);
-       return retval;
+        retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(POP), 0, 0);
+        if (retval)
+            retval = newSVsv(retval);
+        return retval;
     }
     if (AvFILL(av) < 0)
-       return &PL_sv_undef;
+        return &PL_sv_undef;
     retval = AvARRAY(av)[AvFILLp(av)];
     AvARRAY(av)[AvFILLp(av)--] = NULL;
     if (SvSMAGICAL(av))
-       mg_set(MUTABLE_SV(av));
+        mg_set(MUTABLE_SV(av));
     return retval ? retval : &PL_sv_undef;
 }
 
@@ -689,7 +689,7 @@ Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val)
     PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE;
 
     if (!*avp)
-       *avp = newAV();
+        *avp = newAV();
     av_unshift(*avp, 1);
     return av_store(*avp, 0, val);
 }
@@ -715,45 +715,45 @@ Perl_av_unshift(pTHX_ AV *av, SSize_t num)
     assert(SvTYPE(av) == SVt_PVAV);
 
     if (SvREADONLY(av))
-       Perl_croak_no_modify();
+        Perl_croak_no_modify();
 
     if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
-       Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(UNSHIFT),
-                           G_DISCARD | G_UNDEF_FILL, num);
-       return;
+        Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(UNSHIFT),
+                            G_DISCARD | G_UNDEF_FILL, num);
+        return;
     }
 
     if (num <= 0)
       return;
     if (!AvREAL(av) && AvREIFY(av))
-       av_reify(av);
+        av_reify(av);
     i = AvARRAY(av) - AvALLOC(av);
     if (i) {
-       if (i > num)
-           i = num;
-       num -= i;
+        if (i > num)
+            i = num;
+        num -= i;
     
-       AvMAX(av) += i;
-       AvFILLp(av) += i;
-       AvARRAY(av) = AvARRAY(av) - i;
+        AvMAX(av) += i;
+        AvFILLp(av) += i;
+        AvARRAY(av) = AvARRAY(av) - i;
     }
     if (num) {
-       SV **ary;
-       const SSize_t i = AvFILLp(av);
-       /* Create extra elements */
-       const SSize_t slide = i > 0 ? i : 0;
-       num += slide;
-       av_extend(av, i + num);
-       AvFILLp(av) += num;
-       ary = AvARRAY(av);
-       Move(ary, ary + num, i + 1, SV*);
-       do {
-           ary[--num] = NULL;
-       } while (num);
-       /* Make extra elements into a buffer */
-       AvMAX(av) -= slide;
-       AvFILLp(av) -= slide;
-       AvARRAY(av) = AvARRAY(av) + slide;
+        SV **ary;
+        const SSize_t i = AvFILLp(av);
+        /* Create extra elements */
+        const SSize_t slide = i > 0 ? i : 0;
+        num += slide;
+        av_extend(av, i + num);
+        AvFILLp(av) += num;
+        ary = AvARRAY(av);
+        Move(ary, ary + num, i + 1, SV*);
+        do {
+            ary[--num] = NULL;
+        } while (num);
+        /* Make extra elements into a buffer */
+        AvMAX(av) -= slide;
+        AvFILLp(av) -= slide;
+        AvARRAY(av) = AvARRAY(av) + slide;
     }
 }
 
@@ -779,23 +779,23 @@ Perl_av_shift(pTHX_ AV *av)
     assert(SvTYPE(av) == SVt_PVAV);
 
     if (SvREADONLY(av))
-       Perl_croak_no_modify();
+        Perl_croak_no_modify();
     if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
-       retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(SHIFT), 0, 0);
-       if (retval)
-           retval = newSVsv(retval);
-       return retval;
+        retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(SHIFT), 0, 0);
+        if (retval)
+            retval = newSVsv(retval);
+        return retval;
     }
     if (AvFILL(av) < 0)
       return &PL_sv_undef;
     retval = *AvARRAY(av);
     if (AvREAL(av))
-       *AvARRAY(av) = NULL;
+        *AvARRAY(av) = NULL;
     AvARRAY(av) = AvARRAY(av) + 1;
     AvMAX(av)--;
     AvFILLp(av)--;
     if (SvSMAGICAL(av))
-       mg_set(MUTABLE_SV(av));
+        mg_set(MUTABLE_SV(av));
     return retval ? retval : &PL_sv_undef;
 }
 
@@ -856,35 +856,35 @@ Perl_av_fill(pTHX_ AV *av, SSize_t fill)
     assert(SvTYPE(av) == SVt_PVAV);
 
     if (fill < 0)
-       fill = -1;
+        fill = -1;
     if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
-       SV *arg1 = sv_newmortal();
-       sv_setiv(arg1, (IV)(fill + 1));
-       Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(STORESIZE), G_DISCARD,
-                           1, arg1);
-       return;
+        SV *arg1 = sv_newmortal();
+        sv_setiv(arg1, (IV)(fill + 1));
+        Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, SV_CONST(STORESIZE), G_DISCARD,
+                            1, arg1);
+        return;
     }
     if (fill <= AvMAX(av)) {
-       SSize_t key = AvFILLp(av);
-       SV** const ary = AvARRAY(av);
-
-       if (AvREAL(av)) {
-           while (key > fill) {
-               SvREFCNT_dec(ary[key]);
-               ary[key--] = NULL;
-           }
-       }
-       else {
-           while (key < fill)
-               ary[++key] = NULL;
-       }
-           
-       AvFILLp(av) = fill;
-       if (SvSMAGICAL(av))
-           mg_set(MUTABLE_SV(av));
+        SSize_t key = AvFILLp(av);
+        SV** const ary = AvARRAY(av);
+
+        if (AvREAL(av)) {
+            while (key > fill) {
+                SvREFCNT_dec(ary[key]);
+                ary[key--] = NULL;
+            }
+        }
+        else {
+            while (key < fill)
+                ary[++key] = NULL;
+        }
+            
+        AvFILLp(av) = fill;
+        if (SvSMAGICAL(av))
+            mg_set(MUTABLE_SV(av));
     }
     else
-       (void)av_store(av,fill,NULL);
+        (void)av_store(av,fill,NULL);
 }
 
 /*
@@ -909,16 +909,16 @@ Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)
     assert(SvTYPE(av) == SVt_PVAV);
 
     if (SvREADONLY(av))
-       Perl_croak_no_modify();
+        Perl_croak_no_modify();
 
     if (SvRMAGICAL(av)) {
         const MAGIC * const tied_magic
-           = mg_find((const SV *)av, PERL_MAGIC_tied);
+            = mg_find((const SV *)av, PERL_MAGIC_tied);
         if ((tied_magic || mg_find((const SV *)av, PERL_MAGIC_regdata))) {
             SV **svp;
             if (key < 0) {
-               if (!S_adjust_index(aTHX_ av, tied_magic, &key))
-                       return NULL;
+                if (!S_adjust_index(aTHX_ av, tied_magic, &key))
+                        return NULL;
             }
             svp = av_fetch(av, key, TRUE);
             if (svp) {
@@ -928,39 +928,39 @@ Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)
                     sv_unmagic(sv, PERL_MAGIC_tiedelem); /* No longer an element */
                     return sv;
                 }
-               return NULL;
+                return NULL;
             }
         }
     }
 
     if (key < 0) {
-       key += AvFILL(av) + 1;
-       if (key < 0)
-           return NULL;
+        key += AvFILL(av) + 1;
+        if (key < 0)
+            return NULL;
     }
 
     if (key > AvFILLp(av))
-       return NULL;
+        return NULL;
     else {
-       if (!AvREAL(av) && AvREIFY(av))
-           av_reify(av);
-       sv = AvARRAY(av)[key];
-       AvARRAY(av)[key] = NULL;
-       if (key == AvFILLp(av)) {
-           do {
-               AvFILLp(av)--;
-           } while (--key >= 0 && !AvARRAY(av)[key]);
-       }
-       if (SvSMAGICAL(av))
-           mg_set(MUTABLE_SV(av));
+        if (!AvREAL(av) && AvREIFY(av))
+            av_reify(av);
+        sv = AvARRAY(av)[key];
+        AvARRAY(av)[key] = NULL;
+        if (key == AvFILLp(av)) {
+            do {
+                AvFILLp(av)--;
+            } while (--key >= 0 && !AvARRAY(av)[key]);
+        }
+        if (SvSMAGICAL(av))
+            mg_set(MUTABLE_SV(av));
     }
     if(sv != NULL) {
-       if (flags & G_DISCARD) {
-           SvREFCNT_dec_NN(sv);
-           return NULL;
-       }
-       else if (AvREAL(av))
-           sv_2mortal(sv);
+        if (flags & G_DISCARD) {
+            SvREFCNT_dec_NN(sv);
+            return NULL;
+        }
+        else if (AvREAL(av))
+            sv_2mortal(sv);
     }
     return sv;
 }
@@ -985,14 +985,14 @@ Perl_av_exists(pTHX_ AV *av, SSize_t key)
 
     if (SvRMAGICAL(av)) {
         const MAGIC * const tied_magic
-           = mg_find((const SV *)av, PERL_MAGIC_tied);
+            = mg_find((const SV *)av, PERL_MAGIC_tied);
         const MAGIC * const regdata_magic
             = mg_find((const SV *)av, PERL_MAGIC_regdata);
         if (tied_magic || regdata_magic) {
             MAGIC *mg;
             /* Handle negative array indices 20020222 MJD */
             if (key < 0) {
-               if (!S_adjust_index(aTHX_ av, tied_magic, &key))
+                if (!S_adjust_index(aTHX_ av, tied_magic, &key))
                         return FALSE;
             }
 
@@ -1002,36 +1002,36 @@ Perl_av_exists(pTHX_ AV *av, SSize_t key)
                 else
                     return FALSE;
             }
-           {
-               SV * const sv = sv_newmortal();
-               mg_copy(MUTABLE_SV(av), sv, 0, key);
-               mg = mg_find(sv, PERL_MAGIC_tiedelem);
-               if (mg) {
-                   magic_existspack(sv, mg);
-                   {
-                       I32 retbool = SvTRUE_nomg_NN(sv);
-                       return cBOOL(retbool);
-                   }
-               }
-           }
+            {
+                SV * const sv = sv_newmortal();
+                mg_copy(MUTABLE_SV(av), sv, 0, key);
+                mg = mg_find(sv, PERL_MAGIC_tiedelem);
+                if (mg) {
+                    magic_existspack(sv, mg);
+                    {
+                        I32 retbool = SvTRUE_nomg_NN(sv);
+                        return cBOOL(retbool);
+                    }
+                }
+            }
         }
     }
 
     if (key < 0) {
-       key += AvFILL(av) + 1;
-       if (key < 0)
-           return FALSE;
+        key += AvFILL(av) + 1;
+        if (key < 0)
+            return FALSE;
     }
 
     if (key <= AvFILLp(av) && AvARRAY(av)[key])
     {
-       if (SvSMAGICAL(AvARRAY(av)[key])
-        && mg_find(AvARRAY(av)[key], PERL_MAGIC_nonelem))
-           return FALSE;
-       return TRUE;
+        if (SvSMAGICAL(AvARRAY(av)[key])
+         && mg_find(AvARRAY(av)[key], PERL_MAGIC_nonelem))
+            return FALSE;
+        return TRUE;
     }
     else
-       return FALSE;
+        return FALSE;
 }
 
 static MAGIC *
@@ -1044,11 +1044,11 @@ S_get_aux_mg(pTHX_ AV *av) {
     mg = mg_find((const SV *)av, PERL_MAGIC_arylen_p);
 
     if (!mg) {
-       mg = sv_magicext(MUTABLE_SV(av), 0, PERL_MAGIC_arylen_p,
-                        &PL_vtbl_arylen_p, 0, 0);
-       assert(mg);
-       /* sv_magicext won't set this for us because we pass in a NULL obj  */
-       mg->mg_flags |= MGf_REFCOUNTED;
+        mg = sv_magicext(MUTABLE_SV(av), 0, PERL_MAGIC_arylen_p,
+                         &PL_vtbl_arylen_p, 0, 0);
+        assert(mg);
+        /* sv_magicext won't set this for us because we pass in a NULL obj  */
+        mg->mg_flags |= MGf_REFCOUNTED;
     }
     return mg;
 }
@@ -1071,15 +1071,15 @@ Perl_av_iter_p(pTHX_ AV *av) {
     assert(SvTYPE(av) == SVt_PVAV);
 
     if (sizeof(IV) == sizeof(SSize_t)) {
-       return (IV *)&(mg->mg_len);
+        return (IV *)&(mg->mg_len);
     } else {
-       if (!mg->mg_ptr) {
-           IV *temp;
-           mg->mg_len = IVSIZE;
-           Newxz(temp, 1, IV);
-           mg->mg_ptr = (char *) temp;
-       }
-       return (IV *)mg->mg_ptr;
+        if (!mg->mg_ptr) {
+            IV *temp;
+            mg->mg_len = IVSIZE;
+            Newxz(temp, 1, IV);
+            mg->mg_ptr = (char *) temp;
+        }
+        return (IV *)mg->mg_ptr;
     }
 }
 
@@ -1088,7 +1088,7 @@ Perl_av_nonelem(pTHX_ AV *av, SSize_t ix) {
     SV * const sv = newSV(0);
     PERL_ARGS_ASSERT_AV_NONELEM;
     if (!av_store(av,ix,sv))
-       return sv_2mortal(sv); /* has tie magic */
+        return sv_2mortal(sv); /* has tie magic */
     sv_magic(sv, NULL, PERL_MAGIC_nonelem, NULL, 0);
     return sv;
 }