Re^2: (Placeholder) Imagine!

what's the issue with opcodes? what problem(s) are you trying to solve?

It's not really about "solving a problem"; more, 'providing some entertainment with the possible side effect of producing something useful'; and, perhaps, widening the pool of people with internals skills.

The perl opcodes are very clearly defined set of essentially stand-alone functions with a gazzilion existing tests. If their textual descriptions aren't yet readily available, they should be relatively easy to derive from the existing code.

But, why not throw one problem up here and test market the concept? ;)

I'm not sure this is the best way to go about this; but here goes. This is the latest relased version of substr:

PP(pp_substr)
{
    dSP; dTARGET;
    SV *sv;
    STRLEN curlen;
    STRLEN utf8_curlen;
    SV *   pos_sv;
    IV     pos1_iv;
    int    pos1_is_uv;
    SV *   len_sv;
    IV     len_iv = 0;
    int    len_is_uv = 0;
    I32 lvalue = PL_op->op_flags & OPf_MOD || LVRET;
    const bool rvalue = (GIMME_V != G_VOID);
    const char *tmps;
    SV *repl_sv = NULL;
    const char *repl = NULL;
    STRLEN repl_len;
    int num_args = PL_op->op_private & 7;
    bool repl_need_utf8_upgrade = FALSE;

    if (num_args > 2) {
    if (num_args > 3) {
      if(!(repl_sv = POPs)) num_args--;
    }
    if ((len_sv = POPs)) {
        len_iv    = SvIV(len_sv);
        len_is_uv = len_iv ? SvIOK_UV(len_sv) : 1;
    }
    else num_args--;
    }
    pos_sv     = POPs;
    pos1_iv    = SvIV(pos_sv);
    pos1_is_uv = SvIOK_UV(pos_sv);
    sv = POPs;
    if (PL_op->op_private & OPpSUBSTR_REPL_FIRST) {
    assert(!repl_sv);
    repl_sv = POPs;
    }
    if (lvalue && !repl_sv) {
    SV * ret;
    ret = sv_2mortal(newSV_type(SVt_PVLV));  /* Not TARG RT#67838 */
    sv_magic(ret, NULL, PERL_MAGIC_substr, NULL, 0);
    LvTYPE(ret) = 'x';
    LvTARG(ret) = SvREFCNT_inc_simple(sv);
    LvTARGOFF(ret) =
        pos1_is_uv || pos1_iv >= 0
        ? (STRLEN)(UV)pos1_iv
        : (LvFLAGS(ret) |= 1, (STRLEN)(UV)-pos1_iv);
    LvTARGLEN(ret) =
        len_is_uv || len_iv > 0
        ? (STRLEN)(UV)len_iv
        : (LvFLAGS(ret) |= 2, (STRLEN)(UV)-len_iv);

    PUSHs(ret);    /* avoid SvSETMAGIC here */
    RETURN;
    }
    if (repl_sv) {
    repl = SvPV_const(repl_sv, repl_len);
    SvGETMAGIC(sv);
    if (SvROK(sv))
        Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR),
                "Attempt to use reference as lvalue in substr"
        );
    tmps = SvPV_force_nomg(sv, curlen);
    if (DO_UTF8(repl_sv) && repl_len) {
        if (!DO_UTF8(sv)) {
        sv_utf8_upgrade_nomg(sv);
        curlen = SvCUR(sv);
        }
    }
    else if (DO_UTF8(sv))
        repl_need_utf8_upgrade = TRUE;
    }
    else tmps = SvPV_const(sv, curlen);
    if (DO_UTF8(sv)) {
        utf8_curlen = sv_or_pv_len_utf8(sv, tmps, curlen);
    if (utf8_curlen == curlen)
        utf8_curlen = 0;
    else
        curlen = utf8_curlen;
    }
    else
    utf8_curlen = 0;

    {
    STRLEN pos, len, byte_len, byte_pos;

    if (!translate_substr_offsets(
        curlen, pos1_iv, pos1_is_uv, len_iv, len_is_uv, &pos, &len
    )) goto bound_fail;

    byte_len = len;
    byte_pos = utf8_curlen
        ? sv_or_pv_pos_u2b(sv, tmps, pos, &byte_len) : pos;

    tmps += byte_pos;

    if (rvalue) {
        SvTAINTED_off(TARG);            /* decontaminate */
        SvUTF8_off(TARG);            /* decontaminate */
        sv_setpvn(TARG, tmps, byte_len);
#ifdef USE_LOCALE_COLLATE
        sv_unmagic(TARG, PERL_MAGIC_collxfrm);
#endif
        if (utf8_curlen)
        SvUTF8_on(TARG);
    }

    if (repl) {
        SV* repl_sv_copy = NULL;

        if (repl_need_utf8_upgrade) {
        repl_sv_copy = newSVsv(repl_sv);
        sv_utf8_upgrade(repl_sv_copy);
        repl = SvPV_const(repl_sv_copy, repl_len);
        }
        if (!SvOK(sv))
                SvPVCLEAR(sv);
        sv_insert_flags(sv, byte_pos, byte_len, repl, repl_len, 0);
        SvREFCNT_dec(repl_sv_copy);
    }
    }
    if (PL_op->op_private & OPpSUBSTR_REPL_FIRST)
    SP++;
    else if (rvalue) {
    SvSETMAGIC(TARG);
    PUSHs(TARG);
    }
    RETURN;

  bound_fail:
    if (repl)
    Perl_croak(aTHX_ "substr outside of string");
    Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR), "substr outside of str
+ing");
    RETPUSHUNDEF;
}
[download]

Can it be improved?

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority". The enemy of (IT) success is complexity.

In the absence of evidence, opinion is indistinguishable from prejudice.

Comment on Re^2: (Placeholder) Imagine! Download Code

Replies are listed 'Best First'.
Re^3: (Placeholder) Imagine! by dave_the_m (Monsignor) on Nov 30, 2016 at 23:34 UTC
Can it be improved? Possibly. Possibly not. But that one function does quite nicely demonstrate why perl internals are complex and hard to work with. That "clearly defined" op has to cope with (from a quick perusal of the src): both byte- or utf8-encoded strings - and having to convert between byte and char offsets - with a caching scheme for sometimes O(1) performance on long utf8 strings; delayed lvalue assignment, with sometimes the lvalueness only known at runtime depending on how a :lvalue sub has been called; being called in void, scalar or list context; handling a variable number of args; integer-valued args being either signed or unsigned (both are supported); get and set magic; being passed a reference rather than a string; issuing appropriate warnings; tainting; locales; Putting all that together makes it really easy to break things, even with an extensive test suite. Dave.	[reply]
Re^4: (Placeholder) Imagine! by BrowserUk (Patriarch) on Dec 01, 2016 at 00:28 UTC
Putting all that together makes it really easy to break things, even with an extensive test suite. Indeed. That's why for it to have any merit at all it would need the indulgence of someone like you. Not to do the testing, but to guide us on how best to test. To establish some procedure that would allow us to arrive at a high degree of certainty before we request someone from p5p take a look at what has evolved. If anything. Maybe the idea is just too half-baked, but I've seen some extraordinary results produced here ... I was just looking to see if there is a way to tap into that for the benefit of Perl5. With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday' Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error. "Science is about questioning the status quo. Questioning authority". The enemy of (IT) success is complexity. In the absence of evidence, opinion is indistinguishable from prejudice.	[reply]
Re^5: (Placeholder) Imagine! by stevieb (Canon) on Dec 01, 2016 at 03:48 UTC
It's not half-baked at all. I think it's a great idea, even though I don't know the innards all that well. If there are questions here on PM that I've never faced before, very often I research, test, research more, test, fail, cry a bit from frustration, research, test again and the odd time, I've found that I produced something useful I can post as an answer to someone else's question. Compound that with two or more monks going at a problem, bantering and throwing ideas back and forth, and good usually comes from it. I really like your idea. I like challenges. There are many other monks here (imho) that also like to work on challenges, and some like the environment where many monks are working on it, and they happen to be able to bridge ideas from multiple separate monks' replies into a great solution that benefits everyone (you said this earlier in this thread). In this case, it has the potential to benefit Perl/perl directly, so count me in, even though it may be a mountain of studying I may have to do (I've reached the summit of many mountains on foot, as well as tech/coding, and am always ready to learn more). Doesn't matter what the 'weekly' challenge is... if opcodes don't get much traction, start another challenge, and leave that one in the queue. It can always be looked at later. Perhaps list a known bug once per week that as a collective, we can look at and help the p5p. Perhaps a couple of docs get thrown up once per week... we look through and make sure the doc says what the code actually does, or better, we write patches for the docs where we know tricks that may or may not be bugs (but will never go away due to perlpolicy) that others may not know about because it's not listed, or not listed prominently enough.	[reply]
Re^6: (Placeholder) Imagine! by BrowserUk (Patriarch) on Dec 01, 2016 at 08:12 UTC
Re^5: (Placeholder) Imagine! by dave_the_m (Monsignor) on Dec 01, 2016 at 10:14 UTC
Not to do the testing, but to guide us on how best to test. To establish some procedure that would allow us to arrive at a high degree of certainty before we request someone from p5p take a look at what has evolved. If anything. I have not the slightest idea of what such a procedure would look like - it sounds like wishful thinking to me. Dave.	[reply]
Re^6: (Placeholder) Imagine! by BrowserUk (Patriarch) on Dec 01, 2016 at 15:41 UTC


We don't bite newbies here... much
	PerlMonks