/* pp_sort.c
*
- * Copyright (c) 1991-2001, Larry Wall
+ * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ * 2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
* rear!' the slave-driver shouted. 'Three files up. And stay there...
*/
+/* This file contains pp ("push/pop") functions that
+ * execute the opcodes that make up a perl program. A typical pp function
+ * expects to find its arguments on the stack, and usually pushes its
+ * results onto the stack, hence the 'pp' terminology. Each OP structure
+ * contains a pointer to the relevant pp_foo() function.
+ *
+ * This particular file just contains pp_sort(), which is complex
+ * enough to merit its own file! See the other pp*.c files for the rest of
+ * the pp_ functions.
+ */
+
#include "EXTERN.h"
#define PERL_IN_PP_SORT_C
#include "perl.h"
+#if defined(UNDER_CE)
+/* looks like 'small' is reserved word for WINCE (or somesuch)*/
+#define small xsmall
+#endif
+
static I32 sortcv(pTHX_ SV *a, SV *b);
static I32 sortcv_stacked(pTHX_ SV *a, SV *b);
static I32 sortcv_xsub(pTHX_ SV *a, SV *b);
#define sv_cmp_static Perl_sv_cmp
#define sv_cmp_locale_static Perl_sv_cmp_locale
-#define SORTHINTS(hintsvp) \
- ((PL_hintgv && \
- (hintsvp = hv_fetch(GvHV(PL_hintgv), "SORT", 4, FALSE))) ? \
- (I32)SvIV(*hintsvp) : 0)
+#define dSORTHINTS SV *hintsv = GvSV(gv_fetchpv("sort::hints", GV_ADDMULTI, SVt_IV))
+#define SORTHINTS (SvIOK(hintsv) ? ((I32)SvIV(hintsv)) : 0)
#ifndef SMALLSORT
#define SMALLSORT (200)
**
** Unless otherwise specified, pair pointers address the first of two elements.
**
-** b and b+1 are a pair that compare with sense ``sense''.
-** b is the ``bottom'' of adjacent pairs that might form a longer run.
+** b and b+1 are a pair that compare with sense "sense".
+** b is the "bottom" of adjacent pairs that might form a longer run.
**
** p2 parallels b in the list2 array, where runs are defined by
** a pointer chain.
**
-** t represents the ``top'' of the adjacent pairs that might extend
+** t represents the "top" of the adjacent pairs that might extend
** the run beginning at b. Usually, t addresses a pair
** that compares with opposite sense from (b,b+1).
** However, it may also address a singleton element at the end of list1,
-** or it may be equal to ``last'', the first element beyond list1.
+** or it may be equal to "last", the first element beyond list1.
**
** r addresses the Nth pair following b. If this would be beyond t,
** we back it off to t. Only when r is less than t do we consider the
}
-/* Overview of bmerge variables:
-**
-** list1 and list2 address the main and auxiliary arrays.
-** They swap identities after each merge pass.
-** Base points to the original list1, so we can tell if
-** the pointers ended up where they belonged (or must be copied).
-**
-** When we are merging two lists, f1 and f2 are the next elements
-** on the respective lists. l1 and l2 mark the end of the lists.
-** tp2 is the current location in the merged list.
-**
-** p1 records where f1 started.
-** After the merge, a new descriptor is built there.
-**
-** p2 is a ``parallel'' pointer in (what starts as) descriptor space.
-** It is used to identify and delimit the runs.
-**
-** In the heat of determining where q, the greater of the f1/f2 elements,
-** belongs in the other list, b, t and p, represent bottom, top and probe
-** locations, respectively, in the other list.
-** They make convenient temporary pointers in other places.
-*/
-
-STATIC void
-S_mergesortsv(pTHX_ gptr *list1, size_t nmemb, SVCOMPARE_t cmp)
-{
- int i, run;
- int sense;
- register gptr *f1, *f2, *t, *b, *p, *tp2, *l1, *l2, *q;
- gptr *aux, *list2, *p2, *last;
- gptr *base = list1;
- gptr *p1;
- gptr small[SMALLSORT];
-
- if (nmemb <= 1) return; /* sorted trivially */
- if (nmemb <= SMALLSORT) list2 = small; /* use stack for aux array */
- else { New(799,list2,nmemb,gptr); } /* allocate auxilliary array */
- aux = list2;
- dynprep(aTHX_ list1, list2, nmemb, cmp);
- last = PINDEX(list2, nmemb);
- while (NEXT(list2) != last) {
- /* More than one run remains. Do some merging to reduce runs. */
- l2 = p1 = list1;
- for (tp2 = p2 = list2; p2 != last;) {
- /* The new first run begins where the old second list ended.
- ** Use the p2 ``parallel'' pointer to identify the end of the run.
- */
- f1 = l2;
- t = NEXT(p2);
- f2 = l1 = POTHER(t, list2, list1);
- if (t != last) t = NEXT(t);
- l2 = POTHER(t, list2, list1);
- p2 = t;
- while (f1 < l1 && f2 < l2) {
- /* If head 1 is larger than head 2, find ALL the elements
- ** in list 2 strictly less than head1, write them all,
- ** then head 1. Then compare the new heads, and repeat,
- ** until one or both lists are exhausted.
- **
- ** In all comparisons (after establishing
- ** which head to merge) the item to merge
- ** (at pointer q) is the first operand of
- ** the comparison. When we want to know
- ** if ``q is strictly less than the other'',
- ** we can't just do
- ** cmp(q, other) < 0
- ** because stability demands that we treat equality
- ** as high when q comes from l2, and as low when
- ** q was from l1. So we ask the question by doing
- ** cmp(q, other) <= sense
- ** and make sense == 0 when equality should look low,
- ** and -1 when equality should look high.
- */
-
-
- if (cmp(aTHX_ *f1, *f2) <= 0) {
- q = f2; b = f1; t = l1;
- sense = -1;
- } else {
- q = f1; b = f2; t = l2;
- sense = 0;
- }
-
-
- /* ramp up
- **
- ** Leave t at something strictly
- ** greater than q (or at the end of the list),
- ** and b at something strictly less than q.
- */
- for (i = 1, run = 0 ;;) {
- if ((p = PINDEX(b, i)) >= t) {
- /* off the end */
- if (((p = PINDEX(t, -1)) > b) &&
- (cmp(aTHX_ *q, *p) <= sense))
- t = p;
- else b = p;
- break;
- } else if (cmp(aTHX_ *q, *p) <= sense) {
- t = p;
- break;
- } else b = p;
- if (++run >= RTHRESH) i += i;
- }
-
-
- /* q is known to follow b and must be inserted before t.
- ** Increment b, so the range of possibilities is [b,t).
- ** Round binary split down, to favor early appearance.
- ** Adjust b and t until q belongs just before t.
- */
-
- b++;
- while (b < t) {
- p = PINDEX(b, (PNELEM(b, t) - 1) / 2);
- if (cmp(aTHX_ *q, *p) <= sense) {
- t = p;
- } else b = p + 1;
- }
-
-
- /* Copy all the strictly low elements */
-
- if (q == f1) {
- FROMTOUPTO(f2, tp2, t);
- *tp2++ = *f1++;
- } else {
- FROMTOUPTO(f1, tp2, t);
- *tp2++ = *f2++;
- }
- }
-
-
- /* Run out remaining list */
- if (f1 == l1) {
- if (f2 < l2) FROMTOUPTO(f2, tp2, l2);
- } else FROMTOUPTO(f1, tp2, l1);
- p1 = NEXT(p1) = POTHER(tp2, list2, list1);
- }
- t = list1;
- list1 = list2;
- list2 = t;
- last = PINDEX(list2, nmemb);
- }
- if (base == list2) {
- last = PINDEX(list1, nmemb);
- FROMTOUPTO(list1, list2, last);
- }
- if (aux != small) Safefree(aux); /* free iff allocated */
- return;
-}
-
-
-/* What perl needs (least) is another sort implementation in the core.
- * So what's the story? The short (by jpl's standards) story is that
- * the merge sort above, in use since 5.7, is as fast as, or faster than,
+/* The original merge sort, in use since 5.7, was as fast as, or faster than,
* qsort on many platforms, but slower than qsort, conspicuously so,
- * on others. The most likely explanation is platform-specific
+ * on others. The most likely explanation was platform-specific
* differences in cache sizes and relative speeds.
*
* The quicksort divide-and-conquer algorithm guarantees that, as the
* problem is subdivided into smaller and smaller parts, the parts
* fit into smaller (and faster) caches. So it doesn't matter how
* many levels of cache exist, quicksort will "find" them, and,
- * as long as smaller is faster, take advanatge of them.
+ * as long as smaller is faster, take advantage of them.
*
- * By contrast, consider how the quicksort algorithm above works.
+ * By contrast, consider how the original mergesort algorithm worked.
* Suppose we have five runs (each typically of length 2 after dynprep).
*
* pass base aux
* The actual cache-friendly implementation will use a pseudo-stack
* to avoid recursion, and will unroll processing of runs of length 2,
* but it is otherwise similar to the recursive implementation.
- * If it's as good as the original mergesort implementation on all
- * platforms, it should replace that implementation. For benchmarking,
- * though, it is convenient to have both implementations available.
*/
typedef struct {
IV runs; /* how many runs must be combined into 1 */
} off_runs; /* pseudo-stack element */
+
+static I32
+cmp_desc(pTHX_ gptr a, gptr b)
+{
+ return -PL_sort_RealCmp(aTHX_ a, b);
+}
+
STATIC void
-S_cfmergesortsv(pTHX_ gptr *base, size_t nmemb, SVCOMPARE_t cmp)
+S_mergesortsv(pTHX_ gptr *base, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
{
- IV i, run, runs, offset;
+ IV i, run, offset;
I32 sense, level;
+ register gptr *f1, *f2, *t, *b, *p;
int iwhich;
- register gptr *f1, *f2, *t, *b, *p, *tp2, *l1, *l2, *q;
- gptr *aux, *list1, *list2;
+ gptr *aux;
gptr *p1;
gptr small[SMALLSORT];
gptr *which[3];
off_runs stack[60], *stackp;
+ SVCOMPARE_t savecmp = 0;
if (nmemb <= 1) return; /* sorted trivially */
+
+ if (flags) {
+ savecmp = PL_sort_RealCmp; /* Save current comparison routine, if any */
+ PL_sort_RealCmp = cmp; /* Put comparison routine where cmp_desc can find it */
+ cmp = cmp_desc;
+ }
+
if (nmemb <= SMALLSORT) aux = small; /* use stack for aux array */
- else { New(799,aux,nmemb,gptr); } /* allocate auxilliary array */
+ else { Newx(aux,nmemb,gptr); } /* allocate auxilliary array */
level = 0;
stackp = stack;
stackp->runs = dynprep(aTHX_ base, aux, nmemb, cmp);
* is needed at the next level up. Hop up a level, and,
* as long as stackp->runs is 0, keep merging.
*/
- if ((runs = stackp->runs) == 0) {
+ IV runs = stackp->runs;
+ if (runs == 0) {
+ gptr *list1, *list2;
iwhich = level & 1;
list1 = which[iwhich]; /* area where runs are now */
list2 = which[++iwhich]; /* area for merged runs */
do {
+ register gptr *l1, *l2, *tp2;
offset = stackp->offset;
f1 = p1 = list1 + offset; /* start of first run */
p = tp2 = list2 + offset; /* where merged run will go */
** which head to merge) the item to merge
** (at pointer q) is the first operand of
** the comparison. When we want to know
- ** if ``q is strictly less than the other'',
+ ** if "q is strictly less than the other",
** we can't just do
** cmp(q, other) < 0
** because stability demands that we treat equality
** and -1 when equality should look high.
*/
-
+ register gptr *q;
if (cmp(aTHX_ *f1, *f2) <= 0) {
q = f2; b = f1; t = l1;
sense = -1;
}
done:
if (aux != small) Safefree(aux); /* free iff allocated */
+ if (flags) {
+ PL_sort_RealCmp = savecmp; /* Restore current comparison routine, if any */
+ }
return;
}
/* Innoculate large partitions against quadratic behavior */
if (num_elts > QSORT_PLAY_SAFE) {
- register size_t n, j;
- register SV **q;
- for (n = num_elts, q = array; n > 1; ) {
- j = n-- * Drand01();
+ register size_t n;
+ register SV ** const q = array;
+ for (n = num_elts; n > 1; ) {
+ register const size_t j = (size_t)(n-- * Drand01());
temp = q[j];
q[j] = q[n];
q[n] = temp;
qsort_break_even *= 2;
#endif
#if QSORT_ORDER_GUESS == 3
- int prev_break = qsort_break_even;
+ const int prev_break = qsort_break_even;
qsort_break_even *= qsort_break_even;
if (qsort_break_even < prev_break) {
qsort_break_even = (part_right - part_left) + 1;
* dictated by the indirect array.
*/
-static SVCOMPARE_t RealCmp;
static I32
cmpindir(pTHX_ gptr a, gptr b)
{
- I32 sense;
- gptr *ap = (gptr *)a;
- gptr *bp = (gptr *)b;
+ gptr * const ap = (gptr *)a;
+ gptr * const bp = (gptr *)b;
+ const I32 sense = PL_sort_RealCmp(aTHX_ *ap, *bp);
+
+ if (sense)
+ return sense;
+ return (ap > bp) ? 1 : ((ap < bp) ? -1 : 0);
+}
+
+static I32
+cmpindir_desc(pTHX_ gptr a, gptr b)
+{
+ gptr * const ap = (gptr *)a;
+ gptr * const bp = (gptr *)b;
+ const I32 sense = PL_sort_RealCmp(aTHX_ *ap, *bp);
+
+ /* Reverse the default */
+ if (sense)
+ return -sense;
+ /* But don't reverse the stability test. */
+ return (ap > bp) ? 1 : ((ap < bp) ? -1 : 0);
- if ((sense = RealCmp(aTHX_ *ap, *bp)) == 0)
- sense = (ap > bp) ? 1 : ((ap < bp) ? -1 : 0);
- return sense;
}
STATIC void
-S_qsortsv(pTHX_ gptr *list1, size_t nmemb, SVCOMPARE_t cmp)
+S_qsortsv(pTHX_ gptr *list1, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
{
- SV **hintsvp;
- if (SORTHINTS(hintsvp) & HINT_SORT_STABLE) {
+ dSORTHINTS;
+
+ if (SORTHINTS & HINT_SORT_STABLE) {
register gptr **pp, *q;
register size_t n, j, i;
gptr *small[SMALLSORT], **indir, tmp;
/* Small arrays can use the stack, big ones must be allocated */
if (nmemb <= SMALLSORT) indir = small;
- else { New(1799, indir, nmemb, gptr *); }
+ else { Newx(indir, nmemb, gptr *); }
/* Copy pointers to original array elements into indirect array */
for (n = nmemb, pp = indir, q = list1; n--; ) *pp++ = q++;
- savecmp = RealCmp; /* Save current comparison routine, if any */
- RealCmp = cmp; /* Put comparison routine where cmpindir can find it */
+ savecmp = PL_sort_RealCmp; /* Save current comparison routine, if any */
+ PL_sort_RealCmp = cmp; /* Put comparison routine where cmpindir can find it */
/* sort, with indirection */
- S_qsortsvu(aTHX_ (gptr *)indir, nmemb, cmpindir);
+ S_qsortsvu(aTHX_ (gptr *)indir, nmemb,
+ flags ? cmpindir_desc : cmpindir);
pp = indir;
q = list1;
/* free iff allocated */
if (indir != small) { Safefree(indir); }
/* restore prevailing comparison routine */
- RealCmp = savecmp;
+ PL_sort_RealCmp = savecmp;
+ } else if (flags) {
+ SVCOMPARE_t savecmp = PL_sort_RealCmp; /* Save current comparison routine, if any */
+ PL_sort_RealCmp = cmp; /* Put comparison routine where cmp_desc can find it */
+ cmp = cmp_desc;
+ S_qsortsvu(aTHX_ list1, nmemb, cmp);
+ /* restore prevailing comparison routine */
+ PL_sort_RealCmp = savecmp;
} else {
S_qsortsvu(aTHX_ list1, nmemb, cmp);
}
}
/*
+=head1 Array Manipulation Functions
+
=for apidoc sortsv
Sort an array. Here is an example:
sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale);
+See lib/sort.pm for details about controlling the sorting algorithm.
+
=cut
*/
void
Perl_sortsv(pTHX_ SV **array, size_t nmemb, SVCOMPARE_t cmp)
{
- void (*sortsvp)(pTHX_ SV **array, size_t nmemb, SVCOMPARE_t cmp) =
- S_mergesortsv;
- SV **hintsvp;
- I32 hints;
-
- if ((hints = SORTHINTS(hintsvp))) {
- if (hints & HINT_SORT_QUICKSORT)
- sortsvp = S_qsortsv;
- else {
- if (hints & HINT_SORT_MERGESORT)
- sortsvp = S_cfmergesortsv;
- else
- sortsvp = S_mergesortsv;
- }
+ void (*sortsvp)(pTHX_ SV **array, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
+ = S_mergesortsv;
+ dSORTHINTS;
+ const I32 hints = SORTHINTS;
+ if (hints & HINT_SORT_QUICKSORT) {
+ sortsvp = S_qsortsv;
+ }
+ else {
+ /* The default as of 5.8.0 is mergesort */
+ sortsvp = S_mergesortsv;
}
- sortsvp(aTHX_ array, nmemb, cmp);
+ sortsvp(aTHX_ array, nmemb, cmp, 0);
}
+
+static void
+S_sortsv_desc(pTHX_ SV **array, size_t nmemb, SVCOMPARE_t cmp)
+{
+ void (*sortsvp)(pTHX_ SV **array, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
+ = S_mergesortsv;
+ dSORTHINTS;
+ const I32 hints = SORTHINTS;
+ if (hints & HINT_SORT_QUICKSORT) {
+ sortsvp = S_qsortsv;
+ }
+ else {
+ /* The default as of 5.8.0 is mergesort */
+ sortsvp = S_mergesortsv;
+ }
+
+ sortsvp(aTHX_ array, nmemb, cmp, 1);
+}
+
+#define SvNSIOK(sv) ((SvFLAGS(sv) & SVf_NOK) || ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV)) == SVf_IOK))
+#define SvSIOK(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV)) == SVf_IOK)
+#define SvNSIV(sv) ( SvNOK(sv) ? SvNVX(sv) : ( SvSIOK(sv) ? SvIVX(sv) : sv_2nv(sv) ) )
+
PP(pp_sort)
{
- dSP; dMARK; dORIGMARK;
- register SV **up;
- SV **myorigmark = ORIGMARK;
- register I32 max;
+ dVAR; dSP; dMARK; dORIGMARK;
+ register SV **p1 = ORIGMARK+1, **p2;
+ register I32 max, i;
+ AV* av = Nullav;
HV *stash;
GV *gv;
CV *cv = 0;
I32 gimme = GIMME;
- OP* nextop = PL_op->op_next;
+ OP* const nextop = PL_op->op_next;
I32 overloading = 0;
bool hasargs = FALSE;
I32 is_xsub = 0;
+ I32 sorting_av = 0;
+ const U8 priv = PL_op->op_private;
+ const U8 flags = PL_op->op_flags;
+ void (*sortsvp)(pTHX_ SV **array, size_t nmemb, SVCOMPARE_t cmp)
+ = Perl_sortsv;
+ I32 all_SIVs = 1;
if (gimme != G_ARRAY) {
SP = MARK;
+ EXTEND(SP,1);
RETPUSHUNDEF;
}
ENTER;
SAVEVPTR(PL_sortcop);
- if (PL_op->op_flags & OPf_STACKED) {
- if (PL_op->op_flags & OPf_SPECIAL) {
+ if (flags & OPf_STACKED) {
+ if (flags & OPf_SPECIAL) {
OP *kid = cLISTOP->op_first->op_sibling; /* pass pushmark */
kid = kUNOP->op_first; /* pass rv2gv */
kid = kUNOP->op_first; /* pass leave */
else {
cv = sv_2cv(*++MARK, &stash, &gv, 0);
if (cv && SvPOK(cv)) {
- STRLEN n_a;
- char *proto = SvPV((SV*)cv, n_a);
+ const char *proto = SvPV_nolen_const((SV*)cv);
if (proto && strEQ(proto, "$$")) {
hasargs = TRUE;
}
else if (gv) {
SV *tmpstr = sv_newmortal();
gv_efullname3(tmpstr, gv, Nullch);
- DIE(aTHX_ "Undefined sort subroutine \"%s\" called",
- SvPVX(tmpstr));
+ DIE(aTHX_ "Undefined sort subroutine \"%"SVf"\" called",
+ tmpstr);
}
else {
DIE(aTHX_ "Undefined subroutine in sort");
if (is_xsub)
PL_sortcop = (OP*)cv;
- else {
+ else
PL_sortcop = CvSTART(cv);
- SAVEVPTR(CvROOT(cv)->op_ppaddr);
- CvROOT(cv)->op_ppaddr = PL_ppaddr[OP_NULL];
-
- SAVEVPTR(PL_curpad);
- PL_curpad = AvARRAY((AV*)AvARRAY(CvPADLIST(cv))[1]);
- }
}
}
else {
stash = CopSTASH(PL_curcop);
}
- up = myorigmark + 1;
- while (MARK < SP) { /* This may or may not shift down one here. */
- /*SUPPRESS 560*/
- if ((*up = *++MARK)) { /* Weed out nulls. */
- SvTEMP_off(*up);
- if (!PL_sortcop && !SvPOK(*up)) {
- STRLEN n_a;
- if (SvAMAGIC(*up))
- overloading = 1;
- else
- (void)sv_2pv(*up, &n_a);
+ /* optimiser converts "@a = sort @a" to "sort \@a";
+ * in case of tied @a, pessimise: push (@a) onto stack, then assign
+ * result back to @a at the end of this function */
+ if (priv & OPpSORT_INPLACE) {
+ assert( MARK+1 == SP && *SP && SvTYPE(*SP) == SVt_PVAV);
+ (void)POPMARK; /* remove mark associated with ex-OP_AASSIGN */
+ av = (AV*)(*SP);
+ max = AvFILL(av) + 1;
+ if (SvMAGICAL(av)) {
+ MEXTEND(SP, max);
+ p2 = SP;
+ for (i=0; i < max; i++) {
+ SV **svp = av_fetch(av, i, FALSE);
+ *SP++ = (svp) ? *svp : Nullsv;
}
- up++;
+ }
+ else {
+ if (SvREADONLY(av))
+ Perl_croak(aTHX_ PL_no_modify);
+ else
+ SvREADONLY_on(av);
+ p1 = p2 = AvARRAY(av);
+ sorting_av = 1;
}
}
- max = --up - myorigmark;
- if (PL_sortcop) {
- if (max > 1) {
+ else {
+ p2 = MARK+1;
+ max = SP - MARK;
+ }
+
+ if (priv & OPpSORT_DESCEND) {
+ sortsvp = S_sortsv_desc;
+ }
+
+ /* shuffle stack down, removing optional initial cv (p1!=p2), plus
+ * any nulls; also stringify or converting to integer or number as
+ * required any args */
+ for (i=max; i > 0 ; i--) {
+ if ((*p1 = *p2++)) { /* Weed out nulls. */
+ SvTEMP_off(*p1);
+ if (!PL_sortcop) {
+ if (priv & OPpSORT_NUMERIC) {
+ if (priv & OPpSORT_INTEGER) {
+ if (!SvIOK(*p1)) {
+ if (SvAMAGIC(*p1))
+ overloading = 1;
+ else
+ (void)sv_2iv(*p1);
+ }
+ }
+ else {
+ if (!SvNSIOK(*p1)) {
+ if (SvAMAGIC(*p1))
+ overloading = 1;
+ else
+ (void)sv_2nv(*p1);
+ }
+ if (all_SIVs && !SvSIOK(*p1))
+ all_SIVs = 0;
+ }
+ }
+ else {
+ if (!SvPOK(*p1)) {
+ if (SvAMAGIC(*p1))
+ overloading = 1;
+ else
+ (void)sv_2pv_flags(*p1, 0,
+ SV_GMAGIC|SV_CONST_RETURN);
+ }
+ }
+ }
+ p1++;
+ }
+ else
+ max--;
+ }
+ if (sorting_av)
+ AvFILLp(av) = max-1;
+
+ if (max > 1) {
+ SV **start;
+ if (PL_sortcop) {
PERL_CONTEXT *cx;
SV** newsp;
- bool oldcatch = CATCH_GET;
+ const bool oldcatch = CATCH_GET;
SAVETMPS;
SAVEOP();
CATCH_SET(TRUE);
PUSHSTACKi(PERLSI_SORT);
if (!hasargs && !is_xsub) {
- if (PL_sortstash != stash || !PL_firstgv || !PL_secondgv) {
- SAVESPTR(PL_firstgv);
- SAVESPTR(PL_secondgv);
- PL_firstgv = gv_fetchpv("a", TRUE, SVt_PV);
- PL_secondgv = gv_fetchpv("b", TRUE, SVt_PV);
- PL_sortstash = stash;
- }
-#ifdef USE_5005THREADS
- sv_lock((SV *)PL_firstgv);
- sv_lock((SV *)PL_secondgv);
-#endif
+ SAVESPTR(PL_firstgv);
+ SAVESPTR(PL_secondgv);
+ SAVESPTR(PL_sortstash);
+ PL_firstgv = gv_fetchpv("a", TRUE, SVt_PV);
+ PL_secondgv = gv_fetchpv("b", TRUE, SVt_PV);
+ PL_sortstash = stash;
SAVESPTR(GvSV(PL_firstgv));
SAVESPTR(GvSV(PL_secondgv));
}
PUSHBLOCK(cx, CXt_NULL, PL_stack_base);
- if (!(PL_op->op_flags & OPf_SPECIAL)) {
+ if (!(flags & OPf_SPECIAL)) {
cx->cx_type = CXt_SUB;
cx->blk_gimme = G_SCALAR;
PUSHSUB(cx);
- if (!CvDEPTH(cv))
- (void)SvREFCNT_inc(cv); /* in preparation for POPSUB */
+ if (!is_xsub) {
+ AV* const padlist = CvPADLIST(cv);
+
+ if (++CvDEPTH(cv) >= 2) {
+ PERL_STACK_OVERFLOW_CHECK();
+ pad_push(padlist, CvDEPTH(cv));
+ }
+ SAVECOMPPAD();
+ PAD_SET_CUR_NOSAVE(padlist, CvDEPTH(cv));
+
+ if (hasargs) {
+ /* This is mostly copied from pp_entersub */
+ AV *av = (AV*)PAD_SVl(0);
+
+ cx->blk_sub.savearray = GvAV(PL_defgv);
+ GvAV(PL_defgv) = (AV*)SvREFCNT_inc(av);
+ CX_CURPAD_SAVE(cx->blk_sub);
+ cx->blk_sub.argarray = av;
+ }
+
+ }
}
- PL_sortcxix = cxstack_ix;
-
- if (hasargs && !is_xsub) {
- /* This is mostly copied from pp_entersub */
- AV *av = (AV*)PL_curpad[0];
-
-#ifndef USE_5005THREADS
- cx->blk_sub.savearray = GvAV(PL_defgv);
- GvAV(PL_defgv) = (AV*)SvREFCNT_inc(av);
-#endif /* USE_5005THREADS */
- cx->blk_sub.oldcurpad = PL_curpad;
- cx->blk_sub.argarray = av;
+ cx->cx_type |= CXp_MULTICALL;
+
+ start = p1 - max;
+ sortsvp(aTHX_ start, max,
+ is_xsub ? sortcv_xsub : hasargs ? sortcv_stacked : sortcv);
+
+ if (!(flags & OPf_SPECIAL)) {
+ LEAVESUB(cv);
+ if (!is_xsub)
+ CvDEPTH(cv)--;
}
- sortsv((myorigmark+1), max,
- is_xsub ? sortcv_xsub : hasargs ? sortcv_stacked : sortcv);
-
POPBLOCK(cx,PL_curpm);
PL_stack_sp = newsp;
POPSTACK;
CATCH_SET(oldcatch);
}
- }
- else {
- if (max > 1) {
+ else {
MEXTEND(SP, 20); /* Can't afford stack realloc on signal. */
- sortsv(ORIGMARK+1, max,
- (PL_op->op_private & OPpSORT_NUMERIC)
- ? ( (PL_op->op_private & OPpSORT_INTEGER)
+ start = sorting_av ? AvARRAY(av) : ORIGMARK+1;
+ sortsvp(aTHX_ start, max,
+ (priv & OPpSORT_NUMERIC)
+ ? ( ( ( priv & OPpSORT_INTEGER) || all_SIVs)
? ( overloading ? amagic_i_ncmp : sv_i_ncmp)
- : ( overloading ? amagic_ncmp : sv_ncmp))
+ : ( overloading ? amagic_ncmp : sv_ncmp ) )
: ( IN_LOCALE_RUNTIME
? ( overloading
? amagic_cmp_locale
: sv_cmp_locale_static)
: ( overloading ? amagic_cmp : sv_cmp_static)));
- if (PL_op->op_private & OPpSORT_REVERSE) {
- SV **p = ORIGMARK+1;
- SV **q = ORIGMARK+max;
- while (p < q) {
- SV *tmp = *p;
- *p++ = *q;
- *q-- = tmp;
- }
+ }
+ if (priv & OPpSORT_REVERSE) {
+ SV **q = start+max-1;
+ while (start < q) {
+ SV * const tmp = *start;
+ *start++ = *q;
+ *q-- = tmp;
}
}
}
+ if (sorting_av)
+ SvREADONLY_off(av);
+ else if (av && !sorting_av) {
+ /* simulate pp_aassign of tied AV */
+ SV** const base = ORIGMARK+1;
+ for (i=0; i < max; i++) {
+ base[i] = newSVsv(base[i]);
+ }
+ av_clear(av);
+ av_extend(av, max);
+ for (i=0; i < max; i++) {
+ SV * const sv = base[i];
+ SV ** const didstore = av_store(av, i, sv);
+ if (SvSMAGICAL(sv))
+ mg_set(sv);
+ if (!didstore)
+ sv_2mortal(sv);
+ }
+ }
LEAVE;
- PL_stack_sp = ORIGMARK + max;
+ PL_stack_sp = ORIGMARK + (sorting_av ? 0 : max);
return nextop;
}
static I32
sortcv(pTHX_ SV *a, SV *b)
{
- I32 oldsaveix = PL_savestack_ix;
- I32 oldscopeix = PL_scopestack_ix;
+ dVAR;
+ const I32 oldsaveix = PL_savestack_ix;
+ const I32 oldscopeix = PL_scopestack_ix;
I32 result;
GvSV(PL_firstgv) = a;
GvSV(PL_secondgv) = b;
static I32
sortcv_stacked(pTHX_ SV *a, SV *b)
{
- I32 oldsaveix = PL_savestack_ix;
- I32 oldscopeix = PL_scopestack_ix;
+ dVAR;
+ const I32 oldsaveix = PL_savestack_ix;
+ const I32 oldscopeix = PL_scopestack_ix;
I32 result;
- AV *av;
-
-#ifdef USE_5005THREADS
- av = (AV*)PL_curpad[0];
-#else
- av = GvAV(PL_defgv);
-#endif
+ AV * const av = GvAV(PL_defgv);
if (AvMAX(av) < 1) {
SV** ary = AvALLOC(av);
if (AvARRAY(av) != ary) {
AvMAX(av) += AvARRAY(av) - AvALLOC(av);
- SvPVX(av) = (char*)ary;
+ SvPV_set(av, (char*)ary);
}
if (AvMAX(av) < 1) {
AvMAX(av) = 1;
Renew(ary,2,SV*);
- SvPVX(av) = (char*)ary;
+ SvPV_set(av, (char*)ary);
}
}
AvFILLp(av) = 1;
static I32
sortcv_xsub(pTHX_ SV *a, SV *b)
{
- dSP;
- I32 oldsaveix = PL_savestack_ix;
- I32 oldscopeix = PL_scopestack_ix;
+ dVAR; dSP;
+ const I32 oldsaveix = PL_savestack_ix;
+ const I32 oldscopeix = PL_scopestack_ix;
+ CV * const cv=(CV*)PL_sortcop;
I32 result;
- CV *cv=(CV*)PL_sortcop;
SP = PL_stack_base;
PUSHMARK(SP);
static I32
sv_ncmp(pTHX_ SV *a, SV *b)
{
- NV nv1 = SvNV(a);
- NV nv2 = SvNV(b);
+ const NV nv1 = SvNSIV(a);
+ const NV nv2 = SvNSIV(b);
return nv1 < nv2 ? -1 : nv1 > nv2 ? 1 : 0;
}
static I32
sv_i_ncmp(pTHX_ SV *a, SV *b)
{
- IV iv1 = SvIV(a);
- IV iv2 = SvIV(b);
+ const IV iv1 = SvIV(a);
+ const IV iv2 = SvIV(b);
return iv1 < iv2 ? -1 : iv1 > iv2 ? 1 : 0;
}
-#define tryCALL_AMAGICbin(left,right,meth,svp) STMT_START { \
- *svp = Nullsv; \
- if (PL_amagic_generation) { \
- if (SvAMAGIC(left)||SvAMAGIC(right))\
- *svp = amagic_call(left, \
- right, \
- CAT2(meth,_amg), \
- 0); \
- } \
- } STMT_END
+
+#define tryCALL_AMAGICbin(left,right,meth) \
+ (PL_amagic_generation && (SvAMAGIC(left)||SvAMAGIC(right))) \
+ ? amagic_call(left, right, CAT2(meth,_amg), 0) \
+ : Nullsv;
static I32
amagic_ncmp(pTHX_ register SV *a, register SV *b)
{
- SV *tmpsv;
- tryCALL_AMAGICbin(a,b,ncmp,&tmpsv);
+ SV * const tmpsv = tryCALL_AMAGICbin(a,b,ncmp);
if (tmpsv) {
- NV d;
-
if (SvIOK(tmpsv)) {
- I32 i = SvIVX(tmpsv);
+ const I32 i = SvIVX(tmpsv);
if (i > 0)
return 1;
return i? -1 : 0;
}
- d = SvNV(tmpsv);
- if (d > 0)
- return 1;
- return d? -1 : 0;
+ else {
+ const NV d = SvNV(tmpsv);
+ if (d > 0)
+ return 1;
+ return d ? -1 : 0;
+ }
}
return sv_ncmp(aTHX_ a, b);
}
static I32
amagic_i_ncmp(pTHX_ register SV *a, register SV *b)
{
- SV *tmpsv;
- tryCALL_AMAGICbin(a,b,ncmp,&tmpsv);
+ SV * const tmpsv = tryCALL_AMAGICbin(a,b,ncmp);
if (tmpsv) {
- NV d;
-
if (SvIOK(tmpsv)) {
- I32 i = SvIVX(tmpsv);
+ const I32 i = SvIVX(tmpsv);
if (i > 0)
return 1;
return i? -1 : 0;
}
- d = SvNV(tmpsv);
- if (d > 0)
- return 1;
- return d? -1 : 0;
+ else {
+ const NV d = SvNV(tmpsv);
+ if (d > 0)
+ return 1;
+ return d ? -1 : 0;
+ }
}
return sv_i_ncmp(aTHX_ a, b);
}
static I32
amagic_cmp(pTHX_ register SV *str1, register SV *str2)
{
- SV *tmpsv;
- tryCALL_AMAGICbin(str1,str2,scmp,&tmpsv);
+ SV * const tmpsv = tryCALL_AMAGICbin(str1,str2,scmp);
if (tmpsv) {
- NV d;
-
if (SvIOK(tmpsv)) {
- I32 i = SvIVX(tmpsv);
+ const I32 i = SvIVX(tmpsv);
if (i > 0)
return 1;
return i? -1 : 0;
}
- d = SvNV(tmpsv);
- if (d > 0)
- return 1;
- return d? -1 : 0;
+ else {
+ const NV d = SvNV(tmpsv);
+ if (d > 0)
+ return 1;
+ return d? -1 : 0;
+ }
}
return sv_cmp(str1, str2);
}
static I32
amagic_cmp_locale(pTHX_ register SV *str1, register SV *str2)
{
- SV *tmpsv;
- tryCALL_AMAGICbin(str1,str2,scmp,&tmpsv);
+ SV * const tmpsv = tryCALL_AMAGICbin(str1,str2,scmp);
if (tmpsv) {
- NV d;
-
if (SvIOK(tmpsv)) {
- I32 i = SvIVX(tmpsv);
+ const I32 i = SvIVX(tmpsv);
if (i > 0)
return 1;
return i? -1 : 0;
}
- d = SvNV(tmpsv);
- if (d > 0)
- return 1;
- return d? -1 : 0;
+ else {
+ const NV d = SvNV(tmpsv);
+ if (d > 0)
+ return 1;
+ return d? -1 : 0;
+ }
}
return sv_cmp_locale(str1, str2);
}
+
+/*
+ * Local variables:
+ * c-indentation-style: bsd
+ * c-basic-offset: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * ex: set ts=8 sts=4 sw=4 noet:
+ */