#define sv_cmp_static Perl_sv_cmp
#define sv_cmp_locale_static Perl_sv_cmp_locale
-#define SORTHINTS(hintsv) \
- (((hintsv) = GvSV(gv_fetchpv("sort::hints", GV_ADDMULTI, SVt_IV))), \
- (SvIOK(hintsv) ? ((I32)SvIV(hintsv)) : 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)
* 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 original mergesort algorithm worked.
* Suppose we have five runs (each typically of length 2 after dynprep).
STATIC void
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];
}
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 */
** and -1 when equality should look high.
*/
-
+ register gptr *q;
if (cmp(aTHX_ *f1, *f2) <= 0) {
q = f2; b = f1; t = l1;
sense = -1;
/* 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 = (size_t)(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;
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;
if ((sense = PL_sort_RealCmp(aTHX_ *ap, *bp)) == 0)
sense = (ap > bp) ? 1 : ((ap < bp) ? -1 : 0);
cmpindir_desc(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;
/* Reverse the default */
if ((sense = PL_sort_RealCmp(aTHX_ *ap, *bp)))
STATIC void
S_qsortsv(pTHX_ gptr *list1, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
{
- SV *hintsv;
- if (SORTHINTS(hintsv) & 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++;
{
void (*sortsvp)(pTHX_ SV **array, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
= S_mergesortsv;
- SV *hintsv;
- I32 hints;
-
- /* Sun's Compiler (cc: WorkShop Compilers 4.2 30 Oct 1996 C 4.2) used
- to miscompile this function under optimization -O. If you get test
- errors related to picking the correct sort() function, try recompiling
- this file without optimiziation. -- A.D. 4/2002.
- */
- hints = SORTHINTS(hintsv);
+ dSORTHINTS;
+ const I32 hints = SORTHINTS;
if (hints & HINT_SORT_QUICKSORT) {
sortsvp = S_qsortsv;
}
{
void (*sortsvp)(pTHX_ SV **array, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
= S_mergesortsv;
- SV *hintsv;
- I32 hints;
-
- /* Sun's Compiler (cc: WorkShop Compilers 4.2 30 Oct 1996 C 4.2) used
- to miscompile this function under optimization -O. If you get test
- errors related to picking the correct sort() function, try recompiling
- this file without optimiziation. -- A.D. 4/2002.
- */
- hints = SORTHINTS(hintsv);
+ dSORTHINTS;
+ const I32 hints = SORTHINTS;
if (hints & HINT_SORT_QUICKSORT) {
sortsvp = S_qsortsv;
}
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)
{
dVAR; dSP; dMARK; dORIGMARK;
bool hasargs = FALSE;
I32 is_xsub = 0;
I32 sorting_av = 0;
- U8 priv = PL_op->op_private;
- U8 flags = PL_op->op_flags;
+ 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;
else {
cv = sv_2cv(*++MARK, &stash, &gv, 0);
if (cv && SvPOK(cv)) {
- char *proto = SvPV_nolen((SV*)cv);
+ const char *proto = SvPV_nolen_const((SV*)cv);
if (proto && strEQ(proto, "$$")) {
hasargs = TRUE;
}
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];
-
- PAD_SET_CUR(CvPADLIST(cv), 1);
- }
}
}
else {
}
}
else {
+ if (SvREADONLY(av))
+ Perl_croak(aTHX_ PL_no_modify);
+ else
+ SvREADONLY_on(av);
p1 = p2 = AvARRAY(av);
sorting_av = 1;
}
}
}
else {
- if (!SvNOK(*p1)) {
+ if (!SvNSIOK(*p1)) {
if (SvAMAGIC(*p1))
overloading = 1;
else
(void)sv_2nv(*p1);
}
+ if (all_SIVs && !SvSIOK(*p1))
+ all_SIVs = 0;
}
}
else {
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;
- }
+ 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));
}
cx->cx_type = CXt_SUB;
cx->blk_gimme = G_SCALAR;
PUSHSUB(cx);
- }
- PL_sortcxix = cxstack_ix;
+ if (!is_xsub) {
+ AV* 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 && !is_xsub) {
- /* This is mostly copied from pp_entersub */
- AV *av = (AV*)PAD_SVl(0);
+ 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;
+ 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;
+ }
+
+ }
}
+ 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)--;
+ }
POPBLOCK(cx,PL_curpm);
PL_stack_sp = newsp;
POPSTACK;
start = sorting_av ? AvARRAY(av) : ORIGMARK+1;
sortsvp(aTHX_ start, max,
(priv & OPpSORT_NUMERIC)
- ? ( (priv & OPpSORT_INTEGER)
+ ? ( ( ( 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
}
}
}
- if (av && !sorting_av) {
+ if (sorting_av)
+ SvREADONLY_off(av);
+ else if (av && !sorting_av) {
/* simulate pp_aassign of tied AV */
- SV *sv;
- SV** base, **didstore;
- for (base = ORIGMARK+1, i=0; i < max; i++) {
- sv = newSVsv(base[i]);
- base[i] = sv;
+ 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 = base[i];
- didstore = av_store(av, i, sv);
+ SV * const sv = base[i];
+ SV ** const didstore = av_store(av, i, sv);
if (SvSMAGICAL(sv))
mg_set(sv);
if (!didstore)
sortcv(pTHX_ SV *a, SV *b)
{
dVAR;
- I32 oldsaveix = PL_savestack_ix;
- I32 oldscopeix = PL_scopestack_ix;
+ const I32 oldsaveix = PL_savestack_ix;
+ const I32 oldscopeix = PL_scopestack_ix;
I32 result;
GvSV(PL_firstgv) = a;
GvSV(PL_secondgv) = b;
sortcv_stacked(pTHX_ SV *a, SV *b)
{
dVAR;
- I32 oldsaveix = PL_savestack_ix;
- I32 oldscopeix = PL_scopestack_ix;
+ const I32 oldsaveix = PL_savestack_ix;
+ const I32 oldscopeix = PL_scopestack_ix;
I32 result;
- AV *av;
-
- av = GvAV(PL_defgv);
+ AV * const av = GvAV(PL_defgv);
if (AvMAX(av) < 1) {
SV** ary = AvALLOC(av);
sortcv_xsub(pTHX_ SV *a, SV *b)
{
dVAR; dSP;
- I32 oldsaveix = PL_savestack_ix;
- I32 oldscopeix = PL_scopestack_ix;
+ 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);
}