style: Detabify indentation of the C code maintained by the core.

This just detabifies to get rid of the mixed tab/space indentation.

Applying consistent indentation and dealing with other tabs are another issue.

Done with `expand -i`.

* vutil.* left alone, it's part of version.
* Left regen managed files alone for now.

1 files changed, 247 insertions, 247 deletions

diff --git a/av.c b/av.c
index 67815fce90..ff0cb2340c 100644
--- 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--;
@@ -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;
 }