Esempio n. 1
0
void
Perl_set_version(pTHX_ const char *name, STRLEN nlen, const char *strval, STRLEN plen, NV nvval)
{
    SV* ver = GvSV(gv_add_by_type(gv_fetchpvn(name, nlen, GV_ADD, SVt_PVNV),
                                  SVt_PVNV));
    PERL_ARGS_ASSERT_SET_VERSION;
    SvREADONLY_off(ver);
    SvUPGRADE(ver, SVt_PVNV);
    SvPVX(ver) = SvGROW(ver, plen+1);
    Move(strval, SvPVX(ver), plen, char);
    SvCUR_set(ver, plen);
    SvNVX(ver) = nvval;
    /* not the PROTECT bit */
    SvFLAGS(ver) |= (SVf_NOK|SVp_NOK|SVf_POK|SVp_POK|SVf_READONLY);
}
Esempio n. 2
0
// This function reads the various JavaBin datatypes and returns a Perl SV.
// Different datatypes are jumped to view a lookup in an array of computed gotos.
//
// The first group (undef to enum) use the entire tag for the index of the type.
//
// The second are matched by taking the tag byte, shifting it by 5 so to only read
// the first 3 bits of the tag byte, giving it a range or 0-7 inclusive.
//
// To store both in one array the second group have 18 added to them. See DISPATCH.
//
// The remaining 5 bits can then be used to store the size of the datatype, e.g. how
// many chars in a string, this therefore has a range of 0-31, if the size exceeds or
// matches this then an additional vint is added.
//
// The overview of the tag byte is therefore TTTSSSSS with T and S being type and size.
static SV* read_sv(pTHX) {
    void* dispatch[] = {
        &&read_undef,
        &&read_bool,
        &&read_bool,
        &&read_byte,
        &&read_short,
        &&read_double,
        &&read_int,
        &&read_long,
        &&read_float,
        &&read_date,
        &&read_map,
        &&read_solr_doc,
        &&read_solr_doc_list,
        &&read_byte_array,
        &&read_iterator,
        NULL,
        NULL,
        NULL,
        &&read_enum,
        &&read_string,
        &&read_small_int,
        &&read_small_long,
        &&read_array,
        &&read_map,
        &&read_map,
    };

    in++;

    goto *dispatch[in[-1] >> 5 ? (in[-1] >> 5) + 18 : in[-1]];

read_undef:
    return &PL_sv_undef;
read_bool: {
        SV *rv = newSV_type(SVt_IV), *sv = in[-1] == 1 ? bool_true : bool_false;

        SvREFCNT(sv)++;
        SvROK_on(rv);
        SvRV_set(rv, sv);

        return rv;
    }
read_byte:
    return newSViv((int8_t) *in++);
read_short: {
        const int16_t s = in[0] << 8 | in[1];

        in += 2;

        return newSViv(s);
    }
read_double: {
        // For perls with double length NVs this conversion is simple.
        // Read 8 bytes, cast to double, return. For long double perls
        // more magic is used, see read_float for more details.

        const int_double u = { (uint64_t) in[0] << 56 |
                               (uint64_t) in[1] << 48 |
                               (uint64_t) in[2] << 40 |
                               (uint64_t) in[3] << 32 |
                               (uint64_t) in[4] << 24 |
                               (uint64_t) in[5] << 16 |
                               (uint64_t) in[6] << 8  |
                               (uint64_t) in[7] };

        in += 8;

    #ifdef USE_LONG_DOUBLE
        char *str = alloca(snprintf(NULL, 0, "%.14f", u.d));

        sprintf(str, "%.14f", u.d);

        return newSVnv(strtold(str, NULL));
    #else
        return newSVnv(u.d);
    #endif
    }
read_int: {
        const int32_t i = in[0] << 24 | in[1] << 16 | in[2] << 8 | in[3];

        in += 4;

        return newSViv(i);
    }
read_long: {
        const int64_t l = (uint64_t) in[0] << 56 |
                          (uint64_t) in[1] << 48 |
                          (uint64_t) in[2] << 40 |
                          (uint64_t) in[3] << 32 |
                          (uint64_t) in[4] << 24 |
                          (uint64_t) in[5] << 16 |
                          (uint64_t) in[6] << 8  |
                          (uint64_t) in[7];

        in += 8;

        return newSViv(l);
    }
read_float: {
        // JavaBin has a 4byte float format, NVs in perl are double or long double,
        // therefore a little magic is required. Read the 4 bytes into an int in the
        // correct endian order. Re-read these bits as a float, stringify this float,
        // then finally numify the string into a double or long double.
        const int_float u = { in[0] << 24 | in[1] << 16 | in[2] << 8 | in[3] };

        in += 4;

        char *str = alloca(snprintf(NULL, 0, "%f", u.f));

        sprintf(str, "%f", u.f);

    #ifdef USE_LONG_DOUBLE
        return newSVnv(strtold(str, NULL));
    #else
        return newSVnv(strtod(str, NULL));
    #endif
    }
read_date: {
        const int64_t date_ms = (uint64_t) in[0] << 56 |
                                (uint64_t) in[1] << 48 |
                                (uint64_t) in[2] << 40 |
                                (uint64_t) in[3] << 32 |
                                (uint64_t) in[4] << 24 |
                                (uint64_t) in[5] << 16 |
                                (uint64_t) in[6] << 8  |
                                (uint64_t) in[7];

        in += 8;

        const time_t date = date_ms / 1000;

        const struct tm *t = gmtime(&date);

        char date_str[25];

        sprintf(date_str, "%u-%02u-%02uT%02u:%02u:%02u.%03uZ", t->tm_year + 1900,
                t->tm_mon + 1,
                t->tm_mday,
                t->tm_hour,
                t->tm_min,
                t->tm_sec,
                (uint32_t) (date_ms % 1000));

        return newSVpvn(date_str, 24);
    }
read_solr_doc:
    in++;     // Assume a solr doc is a map.
read_map: {
        HV *hv = (HV*)newSV_type(SVt_PVHV);

        uint32_t len = in[-1] >> 5 ? READ_LEN : read_v_int();

        while (len--) {
            cached_key key;

            in++;

            const uint32_t i = READ_LEN;

            if (i)
                key = cached_keys[i];
            else {
                in++;

                cached_keys[++cache_pos] = key = (cached_key){ (char*)in, 0, READ_LEN };

                uint8_t *key_str = in;

                in += key.len;

                // Set the UTF8 flag if we hit a high byte.
                while (key_str != in) {
                    if (*key_str++ & 128) {
                        key.flags = HVhek_UTF8;
                        break;
                    }
                }
            }

            hv_common(hv, NULL, key.key, key.len, key.flags, HV_FETCH_ISSTORE, read_sv(aTHX), 0);
        }

        SV *rv = newSV_type(SVt_IV);

        SvROK_on(rv);
        SvRV_set(rv, (SV*)hv);

        return rv;
    }
read_solr_doc_list: {
        HV *hv = (HV*)newSV_type(SVt_PVHV);

        // Assume values are in an array, skip tag & read_sv.
        in++;

        hv_set(hv, "numFound", read_sv(aTHX), numFound);
        hv_set(hv, "start",    read_sv(aTHX), start);
        hv_set(hv, "maxScore", read_sv(aTHX), maxScore);
        hv_set(hv, "docs",     read_sv(aTHX), docs);

        SV *rv = newSV_type(SVt_IV);

        SvROK_on(rv);
        SvRV_set(rv, (SV*)hv);

        return rv;
    }
read_byte_array: {
        AV *av = (AV*)newSV_type(SVt_PVAV);

        SSize_t len = read_v_int();

        SV **ary = safemalloc(len * sizeof(SV*));

        AvALLOC(av) = AvARRAY(av) = ary;
        AvFILLp(av) = AvMAX(av) = len - 1;

        while (len--)
            *ary++ = newSViv((int8_t) *in++);

        SV *rv = newSV_type(SVt_IV);

        SvROK_on(rv);
        SvRV_set(rv, (SV*)av);

        return rv;
    }
read_iterator: {
        AV *av = (AV*)newSV_type(SVt_PVAV);

        uint32_t len = 0;

        while (*in != 15)
            av_store(av, len++, read_sv(aTHX));

        in++;

        SV *rv = newSV_type(SVt_IV);

        SvROK_on(rv);
        SvRV_set(rv, (SV*)av);

        return rv;
    }
read_enum: {
        SV *sv = read_sv(aTHX); // small_int if +ve, int otherwise.

        sv_upgrade(sv, SVt_PVMG);

        in++;

        const STRLEN len = READ_LEN;

        char *str = sv_grow(sv, len + 1);

        memcpy(str, in, len);

        in += len;

        str[len] = '\0';

        SvCUR(sv) = len;

        SvFLAGS(sv) = SVf_IOK | SVp_IOK | SVs_OBJECT | SVf_POK | SVp_POK | SVt_PVMG | SVf_UTF8;

        HV *stash = CALL(gv_stashpvn, STR_WITH_LEN("JavaBin::Enum"), 0);

        SvREFCNT(stash)++;
        SvSTASH_set(sv, stash);

        SV *rv = newSV_type(SVt_IV);

        SvROK_on(rv);
        SvRV_set(rv, sv);

        return rv;
    }
read_string: {
        const STRLEN len = READ_LEN;

        SV *sv = newSV_type(SVt_PV);

        char *str = SvPVX(sv) = (char*)safemalloc(len);

        memcpy(str, in, len);

        SvCUR(sv) = SvLEN(sv) = len;
        SvFLAGS(sv) |= SVf_POK | SVp_POK | SVf_UTF8;

        in += len;

        return sv;
    }
read_small_int: {
        uint32_t result = in[-1] & 15;

        if (in[-1] & 16)
            result |= read_v_int() << 4;

        return newSViv(result);
    }
read_small_long: {
        uint64_t result = in[-1] & 15;

        // Inlined variable-length +ve long code, see read_v_int().
        if (in[-1] & 16) {
            uint8_t shift = 4;

            do result |= (*in++ & 127) << shift;
            while (in[-1] & 128 && (shift += 7));
        }

        return newSViv(result);
    }
read_array: {
        AV *av = (AV*)newSV_type(SVt_PVAV);

        SSize_t len = READ_LEN;

        SV **ary = safemalloc(len * sizeof(SV*));

        AvALLOC(av) = AvARRAY(av) = ary;
        AvFILLp(av) = AvMAX(av) = len - 1;

        while (len--)
            *ary++ = read_sv(aTHX);

        SV *rv = newSV_type(SVt_IV);

        SvROK_on(rv);
        SvRV(rv) = (SV*)av;

        return rv;
    }
}

static void grow_out(pTHX_ const STRLEN want) {
    const STRLEN len = out_buf - (uint8_t *)SvPVX(out_sv);

    // If we want more than we have, realloc the string.
    if (len + want >= SvLEN(out_sv)) {
        sv_grow(out_sv, len + want);

        out_buf = (uint8_t *)SvPVX(out_sv) + len;
    }
}

static void write_v_int(uint32_t i) {
    while (i & ~127) {
        *out_buf++ = (i & 127) | 128;

        i >>= 7;
    }

    *out_buf++ = i;
}

static void write_shifted_tag(uint8_t tag, uint32_t len) {
    if (len < 31)
        *out_buf++ = tag | len;
    else {
        *out_buf++ = tag | 31;

        write_v_int(len - 31);
    }
}

static void write_sv(pTHX_ SV *sv) {
    SvGETMAGIC(sv);

    if (SvPOKp(sv)) {
        const STRLEN len = SvCUR(sv);

        grow_out(aTHX_ len + 5);

        write_shifted_tag(32, len);

        memcpy(out_buf, SvPVX(sv), len);

        out_buf += len;
    }
    else if (SvNOKp(sv)) {
        const int_double u = { .d = SvNV(sv) };

        grow_out(aTHX_ 9);

        *out_buf++ = 5;
        *out_buf++ = u.i >> 56;
        *out_buf++ = u.i >> 48;
        *out_buf++ = u.i >> 40;
        *out_buf++ = u.i >> 32;
        *out_buf++ = u.i >> 24;
        *out_buf++ = u.i >> 16;
        *out_buf++ = u.i >> 8;
        *out_buf++ = u.i;
    }
    else if (SvIOKp(sv)) {
Esempio n. 3
0
static int perl_init_aaaa()
{
	dTARG;
	dSP;
	listop_list[0].op_ppaddr = PL_ppaddr[OP_LEAVE];
	op_list[0].op_ppaddr = PL_ppaddr[OP_ENTER];
	cop_list[0].op_ppaddr = PL_ppaddr[OP_NEXTSTATE];
	cop_list[0].cop_warnings = pWARN_STD;
	CopFILE_set(&cop_list[0], "hello.p");
	CopSTASHPV_set(&cop_list[0], "main");
	listop_list[1].op_ppaddr = PL_ppaddr[OP_PRINT];
	op_list[1].op_ppaddr = PL_ppaddr[OP_PUSHMARK];
	svop_list[0].op_ppaddr = PL_ppaddr[OP_CONST];
	gv_list[0] = gv_fetchpv("main::/", TRUE, SVt_PV);
	SvFLAGS(gv_list[0]) = 0x600d;
	GvFLAGS(gv_list[0]) = 0xa;
	GvLINE(gv_list[0]) = 0;
	SvPVX(gv_list[0]) = emptystring;

	SvREFCNT(gv_list[0]) += 4;
	GvREFCNT(gv_list[0]) += 1;
	gv_list[1] = gv_fetchpv("main::stderr", TRUE, SVt_PV);
	SvFLAGS(gv_list[1]) = 0x600d;
	GvFLAGS(gv_list[1]) = 0x2;
	GvLINE(gv_list[1]) = 0;
	SvPVX(gv_list[1]) = emptystring;

	SvREFCNT(gv_list[1]) += 2;
	GvREFCNT(gv_list[1]) += 1;
	GvSV(gv_list[1]) = &sv_list[0];
	GvFILE(gv_list[1]) = "hello.p";
	IoIFP((IO*)&sv_list[1])=PerlIO_stderr();
	IoOFP((IO*)&sv_list[1])=PerlIO_stderr();
	hv0 = gv_stashpv("FileHandle", TRUE);
	SvSTASH((IO*)&sv_list[1]) = hv0;
	GvIOp(gv_list[1]) = (IO*)&sv_list[1];
	gv_list[2] = gv_fetchpv("main::SIG", TRUE, SVt_PV);
	SvFLAGS(gv_list[2]) = 0x600d;
	GvFLAGS(gv_list[2]) = 0xa;
	GvLINE(gv_list[2]) = 62;
	SvPVX(gv_list[2]) = emptystring;

	SvREFCNT(gv_list[2]) += 12;
	GvREFCNT(gv_list[2]) += 1;
	gv_list[3] = gv_fetchpv("main::,", TRUE, SVt_PV);
	SvFLAGS(gv_list[3]) = 0x600d;
	GvFLAGS(gv_list[3]) = 0xa;
	GvLINE(gv_list[3]) = 474;
	SvPVX(gv_list[3]) = emptystring;

	SvREFCNT(gv_list[3]) += 6;
	GvREFCNT(gv_list[3]) += 1;
	gv_list[4] = gv_fetchpv("utf8::unicode_to_native", TRUE, SVt_PV);
	SvFLAGS(gv_list[4]) = 0x600d;
	GvFLAGS(gv_list[4]) = 0xa;
	GvLINE(gv_list[4]) = 0;
	SvPVX(gv_list[4]) = emptystring;

	SvREFCNT(gv_list[4]) += 3;
	GvREFCNT(gv_list[4]) += 1;
	GvSV(gv_list[4]) = &sv_list[2];
	GvCV(gv_list[4]) = (CV*)((perl_get_cv("utf8::unicode_to_native",TRUE)));
	GvFILE(gv_list[4]) = "hello.p";
	gv_list[5] = gv_fetchpv("utf8::encode", TRUE, SVt_PV);
	SvFLAGS(gv_list[5]) = 0x600d;
	GvFLAGS(gv_list[5]) = 0x2;
	GvLINE(gv_list[5]) = 0;
	SvPVX(gv_list[5]) = emptystring;

	SvREFCNT(gv_list[5]) += 2;
	GvREFCNT(gv_list[5]) += 1;
	GvSV(gv_list[5]) = &sv_list[3];
	GvCV(gv_list[5]) = (CV*)((perl_get_cv("utf8::encode",TRUE)));
	GvFILE(gv_list[5]) = "hello.p";
	gv_list[6] = gv_fetchpv("utf8::valid", TRUE, SVt_PV);
	SvFLAGS(gv_list[6]) = 0x600d;
	GvFLAGS(gv_list[6]) = 0x2;
	GvLINE(gv_list[6]) = 0;
	SvPVX(gv_list[6]) = emptystring;

	SvREFCNT(gv_list[6]) += 2;
	GvREFCNT(gv_list[6]) += 1;
	GvSV(gv_list[6]) = &sv_list[4];
	GvCV(gv_list[6]) = (CV*)((perl_get_cv("utf8::valid",TRUE)));
	GvFILE(gv_list[6]) = "hello.p";
	gv_list[7] = gv_fetchpv("utf8::native_to_unicode", TRUE, SVt_PV);
	SvFLAGS(gv_list[7]) = 0x600d;
	GvFLAGS(gv_list[7]) = 0x2;
	GvLINE(gv_list[7]) = 0;
	SvPVX(gv_list[7]) = emptystring;

	SvREFCNT(gv_list[7]) += 2;
	GvREFCNT(gv_list[7]) += 1;
	GvSV(gv_list[7]) = &sv_list[5];
	GvCV(gv_list[7]) = (CV*)((perl_get_cv("utf8::native_to_unicode",TRUE)));
	GvFILE(gv_list[7]) = "hello.p";
	gv_list[8] = gv_fetchpv("utf8::decode", TRUE, SVt_PV);
	SvFLAGS(gv_list[8]) = 0x600d;
	GvFLAGS(gv_list[8]) = 0x2;
	GvLINE(gv_list[8]) = 0;
	SvPVX(gv_list[8]) = emptystring;

	SvREFCNT(gv_list[8]) += 2;
	GvREFCNT(gv_list[8]) += 1;
	GvSV(gv_list[8]) = &sv_list[6];
	GvCV(gv_list[8]) = (CV*)((perl_get_cv("utf8::decode",TRUE)));
	GvFILE(gv_list[8]) = "hello.p";
	gv_list[9] = gv_fetchpv("utf8::downgrade", TRUE, SVt_PV);
	SvFLAGS(gv_list[9]) = 0x600d;
	GvFLAGS(gv_list[9]) = 0x2;
	GvLINE(gv_list[9]) = 0;
	SvPVX(gv_list[9]) = emptystring;

	SvREFCNT(gv_list[9]) += 2;
	GvREFCNT(gv_list[9]) += 1;
	GvSV(gv_list[9]) = &sv_list[7];
	GvCV(gv_list[9]) = (CV*)((perl_get_cv("utf8::downgrade",TRUE)));
	GvFILE(gv_list[9]) = "hello.p";
	gv_list[10] = gv_fetchpv("utf8::upgrade", TRUE, SVt_PV);
	SvFLAGS(gv_list[10]) = 0x600d;
	GvFLAGS(gv_list[10]) = 0x2;
	GvLINE(gv_list[10]) = 0;
	SvPVX(gv_list[10]) = emptystring;

	SvREFCNT(gv_list[10]) += 2;
	GvREFCNT(gv_list[10]) += 1;
	GvSV(gv_list[10]) = &sv_list[8];
	GvCV(gv_list[10]) = (CV*)((perl_get_cv("utf8::upgrade",TRUE)));
	GvFILE(gv_list[10]) = "hello.p";
	gv_list[11] = gv_fetchpv("utf8::is_utf8", TRUE, SVt_PV);
	SvFLAGS(gv_list[11]) = 0x600d;
	GvFLAGS(gv_list[11]) = 0x2;
	GvLINE(gv_list[11]) = 0;
	SvPVX(gv_list[11]) = emptystring;

	SvREFCNT(gv_list[11]) += 2;
	GvREFCNT(gv_list[11]) += 1;
	GvSV(gv_list[11]) = &sv_list[9];
	GvCV(gv_list[11]) = (CV*)((perl_get_cv("utf8::is_utf8",TRUE)));
	GvFILE(gv_list[11]) = "hello.p";
	gv_list[12] = gv_fetchpv("main::\"", TRUE, SVt_PV);
	SvFLAGS(gv_list[12]) = 0x600d;
	GvFLAGS(gv_list[12]) = 0xa;
	GvLINE(gv_list[12]) = 0;
	SvPVX(gv_list[12]) = emptystring;

	SvREFCNT(gv_list[12]) += 10;
	GvREFCNT(gv_list[12]) += 1;
	gv_list[13] = gv_fetchpv("main::stdout", TRUE, SVt_PV);
	SvFLAGS(gv_list[13]) = 0x600d;
	GvFLAGS(gv_list[13]) = 0x2;
	GvLINE(gv_list[13]) = 0;
	SvPVX(gv_list[13]) = emptystring;

	SvREFCNT(gv_list[13]) += 2;
	GvREFCNT(gv_list[13]) += 1;
	GvSV(gv_list[13]) = &sv_list[10];
	GvFILE(gv_list[13]) = "hello.p";
	IoIFP((IO*)&sv_list[11])=PerlIO_stdout();
	IoOFP((IO*)&sv_list[11])=PerlIO_stdout();
	SvSTASH((IO*)&sv_list[11]) = hv0;
	GvIOp(gv_list[13]) = (IO*)&sv_list[11];
	gv_list[14] = gv_fetchpv("main::\022", TRUE, SVt_PV);
	SvFLAGS(gv_list[14]) = 0x600d;
	GvFLAGS(gv_list[14]) = 0x2;
	GvLINE(gv_list[14]) = 0;
	SvPVX(gv_list[14]) = emptystring;

	SvREFCNT(gv_list[14]) += 2;
	GvREFCNT(gv_list[14]) += 1;
	gv_list[15] = gv_fetchpv("main::|", TRUE, SVt_PV);
	SvFLAGS(gv_list[15]) = 0x600d;
	GvFLAGS(gv_list[15]) = 0xa;
	GvLINE(gv_list[15]) = 466;
	SvPVX(gv_list[15]) = emptystring;

	SvREFCNT(gv_list[15]) += 5;
	GvREFCNT(gv_list[15]) += 1;
	gv_list[16] = gv_fetchpv("Regexp::DESTROY", TRUE, SVt_PV);
	SvFLAGS(gv_list[16]) = 0x600d;
	GvFLAGS(gv_list[16]) = 0x2;
	GvLINE(gv_list[16]) = 0;
	SvPVX(gv_list[16]) = emptystring;

	SvREFCNT(gv_list[16]) += 2;
	GvREFCNT(gv_list[16]) += 1;
	GvSV(gv_list[16]) = &sv_list[12];
	GvCV(gv_list[16]) = (CV*)((perl_get_cv("Regexp::DESTROY",TRUE)));
	GvFILE(gv_list[16]) = "hello.p";
	gv_list[17] = gv_fetchpv("main::\f", TRUE, SVt_PV);
	SvFLAGS(gv_list[17]) = 0x600d;
	GvFLAGS(gv_list[17]) = 0xa;
	GvLINE(gv_list[17]) = 554;
	SvPVX(gv_list[17]) = emptystring;

	SvREFCNT(gv_list[17]) += 4;
	GvREFCNT(gv_list[17]) += 1;
	gv_list[18] = gv_fetchpv("main::^", TRUE, SVt_PV);
	SvFLAGS(gv_list[18]) = 0x600d;
	GvFLAGS(gv_list[18]) = 0xa;
	GvLINE(gv_list[18]) = 538;
	SvPVX(gv_list[18]) = emptystring;

	SvREFCNT(gv_list[18]) += 4;
	GvREFCNT(gv_list[18]) += 1;
	gv_list[19] = gv_fetchpv("main::\001", TRUE, SVt_PV);
	SvFLAGS(gv_list[19]) = 0x600d;
	GvFLAGS(gv_list[19]) = 0xa;
	GvLINE(gv_list[19]) = 562;
	SvPVX(gv_list[19]) = emptystring;

	SvREFCNT(gv_list[19]) += 5;
	GvREFCNT(gv_list[19]) += 1;
	gv_list[20] = gv_fetchpv("main::$", TRUE, SVt_PV);
	SvFLAGS(gv_list[20]) = 0x600d;
	GvFLAGS(gv_list[20]) = 0x2;
	GvLINE(gv_list[20]) = 0;
	SvPVX(gv_list[20]) = emptystring;

	SvREFCNT(gv_list[20]) += 2;
	GvREFCNT(gv_list[20]) += 1;
	gv_list[21] = gv_fetchpv("main::\\", TRUE, SVt_PV);
	SvFLAGS(gv_list[21]) = 0x600d;
	GvFLAGS(gv_list[21]) = 0xa;
	GvLINE(gv_list[21]) = 441;
	SvPVX(gv_list[21]) = emptystring;

	SvREFCNT(gv_list[21]) += 9;
	GvREFCNT(gv_list[21]) += 1;
	gv_list[22] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm", TRUE, SVt_PV);
	SvFLAGS(gv_list[22]) = 0x600d;
	GvFLAGS(gv_list[22]) = 0x2;
	GvLINE(gv_list[22]) = 4294967295;
	SvPVX(gv_list[22]) = emptystring;

	SvREFCNT(gv_list[22]) += 2;
	GvREFCNT(gv_list[22]) += 1;
	xpv_list[0].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm", 56);
	GvSV(gv_list[22]) = &sv_list[13];
	GvFILE(gv_list[22]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
	gv_list[23] = gv_fetchpv("main::~", TRUE, SVt_PV);
	SvFLAGS(gv_list[23]) = 0x600d;
	GvFLAGS(gv_list[23]) = 0xa;
	GvLINE(gv_list[23]) = 530;
	SvPVX(gv_list[23]) = emptystring;

	SvREFCNT(gv_list[23]) += 4;
	GvREFCNT(gv_list[23]) += 1;
	gv_list[24] = gv_fetchpv("main::-", TRUE, SVt_PV);
	SvFLAGS(gv_list[24]) = 0x600d;
	GvFLAGS(gv_list[24]) = 0xa;
	GvLINE(gv_list[24]) = 0;
	SvPVX(gv_list[24]) = emptystring;

	SvREFCNT(gv_list[24]) += 4;
	GvREFCNT(gv_list[24]) += 1;
	gv_list[25] = gv_fetchpv("main::_<perlmain.c", TRUE, SVt_PV);
	SvFLAGS(gv_list[25]) = 0x600d;
	GvFLAGS(gv_list[25]) = 0x2;
	GvLINE(gv_list[25]) = 0;
	SvPVX(gv_list[25]) = emptystring;

	SvREFCNT(gv_list[25]) += 2;
	GvREFCNT(gv_list[25]) += 1;
	xpv_list[1].xpv_pv = savepvn("perlmain.c", 10);
	GvSV(gv_list[25]) = &sv_list[14];
	GvFILE(gv_list[25]) = "hello.p";
	gv_list[26] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/File/Spec/Unix.pm", TRUE, SVt_PV);
	SvFLAGS(gv_list[26]) = 0x600d;
	GvFLAGS(gv_list[26]) = 0x2;
	GvLINE(gv_list[26]) = 98;
	SvPVX(gv_list[26]) = emptystring;

	SvREFCNT(gv_list[26]) += 2;
	GvREFCNT(gv_list[26]) += 1;
	xpv_list[2].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/File/Spec/Unix.pm", 38);
	GvSV(gv_list[26]) = &sv_list[15];
	GvFILE(gv_list[26]) = "x/\031\b q\024\b\332T\305";
	gv_list[27] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/B/C/C.so", TRUE, SVt_PV);
	SvFLAGS(gv_list[27]) = 0x600d;
	GvFLAGS(gv_list[27]) = 0x2;
	GvLINE(gv_list[27]) = 87;
	SvPVX(gv_list[27]) = emptystring;

	SvREFCNT(gv_list[27]) += 2;
	GvREFCNT(gv_list[27]) += 1;
	xpv_list[3].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/B/C/C.so", 58);
	GvSV(gv_list[27]) = &sv_list[16];
	GvFILE(gv_list[27]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
	gv_list[28] = gv_fetchpv("main::_<universal.c", TRUE, SVt_PV);
	SvFLAGS(gv_list[28]) = 0x600d;
	GvFLAGS(gv_list[28]) = 0x2;
	GvLINE(gv_list[28]) = 0;
	SvPVX(gv_list[28]) = emptystring;

	SvREFCNT(gv_list[28]) += 2;
	GvREFCNT(gv_list[28]) += 1;
	xpv_list[4].xpv_pv = savepvn("universal.c", 11);
	GvSV(gv_list[28]) = &sv_list[17];
	GvFILE(gv_list[28]) = "hello.p";
	gv_list[29] = gv_fetchpv("main::BEGIN", TRUE, SVt_PV);
	SvFLAGS(gv_list[29]) = 0x600d;
	GvFLAGS(gv_list[29]) = 0x2;
	GvLINE(gv_list[29]) = 0;
	SvPVX(gv_list[29]) = emptystring;

	SvREFCNT(gv_list[29]) += 2;
	GvREFCNT(gv_list[29]) += 1;
	GvSV(gv_list[29]) = &sv_list[18];
	GvFILE(gv_list[29]) = "hello.p";
	gv_list[30] = gv_fetchpv("main::_<xsutils.c", TRUE, SVt_PV);
	SvFLAGS(gv_list[30]) = 0x600d;
	GvFLAGS(gv_list[30]) = 0x2;
	GvLINE(gv_list[30]) = 0;
	SvPVX(gv_list[30]) = emptystring;

	SvREFCNT(gv_list[30]) += 2;
	GvREFCNT(gv_list[30]) += 1;
	xpv_list[5].xpv_pv = savepvn("xsutils.c", 9);
	GvSV(gv_list[30]) = &sv_list[19];
	GvFILE(gv_list[30]) = "hello.p";
	gv_list[31] = gv_fetchpv("main::!", TRUE, SVt_PV);
	SvFLAGS(gv_list[31]) = 0x600d;
	GvFLAGS(gv_list[31]) = 0xa;
	GvLINE(gv_list[31]) = 2054;
	SvPVX(gv_list[31]) = emptystring;

	SvREFCNT(gv_list[31]) += 3;
	GvREFCNT(gv_list[31]) += 1;
	GvFILE(gv_list[31]) = "";
	gv_list[32] = gv_fetchpv("main::\024AINT", TRUE, SVt_PV);
	SvFLAGS(gv_list[32]) = 0x600d;
	GvFLAGS(gv_list[32]) = 0xa;
	GvLINE(gv_list[32]) = 1589;
	SvPVX(gv_list[32]) = emptystring;

	SvREFCNT(gv_list[32]) += 3;
	GvREFCNT(gv_list[32]) += 1;
	sv_magic((SV*)&sv_list[20], (SV*)gv_list[32], '\000', "\024AINT", 5);
	GvSV(gv_list[32]) = &sv_list[20];
	GvFILE(gv_list[32]) = "";
	gv_list[33] = gv_fetchpv("main::\017", TRUE, SVt_PV);
	SvFLAGS(gv_list[33]) = 0x600d;
	GvFLAGS(gv_list[33]) = 0xa;
	GvLINE(gv_list[33]) = 55;
	SvPVX(gv_list[33]) = emptystring;

	SvREFCNT(gv_list[33]) += 4;
	GvREFCNT(gv_list[33]) += 1;
	gv_list[34] = gv_fetchpv("main::%", TRUE, SVt_PV);
	SvFLAGS(gv_list[34]) = 0x600d;
	GvFLAGS(gv_list[34]) = 0xa;
	GvLINE(gv_list[34]) = 506;
	SvPVX(gv_list[34]) = emptystring;

	SvREFCNT(gv_list[34]) += 4;
	GvREFCNT(gv_list[34]) += 1;
	gv_list[35] = gv_fetchpv("main::\030", TRUE, SVt_PV);
	SvFLAGS(gv_list[35]) = 0x600d;
	GvFLAGS(gv_list[35]) = 0x2;
	GvLINE(gv_list[35]) = 0;
	SvPVX(gv_list[35]) = emptystring;

	SvREFCNT(gv_list[35]) += 2;
	GvREFCNT(gv_list[35]) += 1;
	gv_list[36] = gv_fetchpv("main::_", TRUE, SVt_PV);
	SvFLAGS(gv_list[36]) = 0x630d;
	GvFLAGS(gv_list[36]) = 0xa;
	GvLINE(gv_list[36]) = 0;
	SvPVX(gv_list[36]) = emptystring;

	SvREFCNT(gv_list[36]) += 470;
	GvREFCNT(gv_list[36]) += 1;
	gv_list[37] = gv_fetchpv("main::+", TRUE, SVt_PV);
	SvFLAGS(gv_list[37]) = 0x600d;
	GvFLAGS(gv_list[37]) = 0x2;
	GvLINE(gv_list[37]) = 0;
	SvPVX(gv_list[37]) = emptystring;

	SvREFCNT(gv_list[37]) += 2;
	GvREFCNT(gv_list[37]) += 1;
	gv_list[38] = gv_fetchpv("Internals::SvREFCNT", TRUE, SVt_PV);
	SvFLAGS(gv_list[38]) = 0x600d;
	GvFLAGS(gv_list[38]) = 0x2;
	GvLINE(gv_list[38]) = 0;
	SvPVX(gv_list[38]) = emptystring;

	SvREFCNT(gv_list[38]) += 2;
	GvREFCNT(gv_list[38]) += 1;
	GvSV(gv_list[38]) = &sv_list[21];
	GvCV(gv_list[38]) = (CV*)((perl_get_cv("Internals::SvREFCNT",TRUE)));
	GvFILE(gv_list[38]) = "hello.p";
	gv_list[39] = gv_fetchpv("Internals::hv_clear_placeholders", TRUE, SVt_PV);
	SvFLAGS(gv_list[39]) = 0x600d;
	GvFLAGS(gv_list[39]) = 0x2;
	GvLINE(gv_list[39]) = 0;
	SvPVX(gv_list[39]) = emptystring;

	SvREFCNT(gv_list[39]) += 2;
	GvREFCNT(gv_list[39]) += 1;
	GvSV(gv_list[39]) = &sv_list[22];
	GvCV(gv_list[39]) = (CV*)((perl_get_cv("Internals::hv_clear_placeholders",TRUE)));
	GvFILE(gv_list[39]) = "hello.p";
	gv_list[40] = gv_fetchpv("Internals::hash_seed", TRUE, SVt_PV);
	SvFLAGS(gv_list[40]) = 0x600d;
	GvFLAGS(gv_list[40]) = 0x2;
	GvLINE(gv_list[40]) = 0;
	SvPVX(gv_list[40]) = emptystring;

	SvREFCNT(gv_list[40]) += 2;
	GvREFCNT(gv_list[40]) += 1;
	GvSV(gv_list[40]) = &sv_list[23];
	GvCV(gv_list[40]) = (CV*)((perl_get_cv("Internals::hash_seed",TRUE)));
	GvFILE(gv_list[40]) = "hello.p";
	gv_list[41] = gv_fetchpv("Internals::SvREADONLY", TRUE, SVt_PV);
	SvFLAGS(gv_list[41]) = 0x600d;
	GvFLAGS(gv_list[41]) = 0x2;
	GvLINE(gv_list[41]) = 0;
	SvPVX(gv_list[41]) = emptystring;

	SvREFCNT(gv_list[41]) += 2;
	GvREFCNT(gv_list[41]) += 1;
	GvSV(gv_list[41]) = &sv_list[24];
	GvCV(gv_list[41]) = (CV*)((perl_get_cv("Internals::SvREADONLY",TRUE)));
	GvFILE(gv_list[41]) = "hello.p";
	gv_list[42] = gv_fetchpv("Internals::HvREHASH", TRUE, SVt_PV);
	SvFLAGS(gv_list[42]) = 0x600d;
	GvFLAGS(gv_list[42]) = 0x2;
	GvLINE(gv_list[42]) = 0;
	SvPVX(gv_list[42]) = emptystring;

	SvREFCNT(gv_list[42]) += 2;
	GvREFCNT(gv_list[42]) += 1;
	GvSV(gv_list[42]) = &sv_list[25];
	GvCV(gv_list[42]) = (CV*)((perl_get_cv("Internals::HvREHASH",TRUE)));
	GvFILE(gv_list[42]) = "hello.p";
	gv_list[43] = gv_fetchpv("Internals::rehash_seed", TRUE, SVt_PV);
	SvFLAGS(gv_list[43]) = 0x600d;
	GvFLAGS(gv_list[43]) = 0x2;
	GvLINE(gv_list[43]) = 0;
	SvPVX(gv_list[43]) = emptystring;

	SvREFCNT(gv_list[43]) += 2;
	GvREFCNT(gv_list[43]) += 1;
	GvSV(gv_list[43]) = &sv_list[26];
	GvCV(gv_list[43]) = (CV*)((perl_get_cv("Internals::rehash_seed",TRUE)));
	GvFILE(gv_list[43]) = "hello.p";
	gv_list[44] = gv_fetchpv("main::STDIN", TRUE, SVt_PV);
	SvFLAGS(gv_list[44]) = 0x600d;
	GvFLAGS(gv_list[44]) = 0xa;
	GvLINE(gv_list[44]) = 0;
	SvPVX(gv_list[44]) = emptystring;

	SvREFCNT(gv_list[44]) += 2;
	GvREFCNT(gv_list[44]) += 1;
	gv_list[45] = gv_fetchpv("DB::args", TRUE, SVt_PV);
	SvFLAGS(gv_list[45]) = 0x600d;
	GvFLAGS(gv_list[45]) = 0xa;
	GvLINE(gv_list[45]) = 431;
	SvPVX(gv_list[45]) = emptystring;

	SvREFCNT(gv_list[45]) += 4;
	GvREFCNT(gv_list[45]) += 1;
	GvSV(gv_list[45]) = &sv_list[27];
	GvAV(gv_list[45]) = (AV*)&sv_list[28];
	GvFILE(gv_list[45]) = "\260\r\016\b";
	gv_list[46] = gv_fetchpv("main::\026", TRUE, SVt_PV);
	SvFLAGS(gv_list[46]) = 0x600d;
	GvFLAGS(gv_list[46]) = 0xa;
	GvLINE(gv_list[46]) = 30;
	SvPVX(gv_list[46]) = emptystring;

	SvREFCNT(gv_list[46]) += 2;
	GvREFCNT(gv_list[46]) += 1;
	gv_list[47] = gv_fetchpv("main::=", TRUE, SVt_PV);
	SvFLAGS(gv_list[47]) = 0x600d;
	GvFLAGS(gv_list[47]) = 0xa;
	GvLINE(gv_list[47]) = 514;
	SvPVX(gv_list[47]) = emptystring;

	SvREFCNT(gv_list[47]) += 4;
	GvREFCNT(gv_list[47]) += 1;
	gv_list[48] = gv_fetchpv("main::2", TRUE, SVt_PV);
	SvFLAGS(gv_list[48]) = 0x600d;
	GvFLAGS(gv_list[48]) = 0xa;
	GvLINE(gv_list[48]) = 257;
	SvPVX(gv_list[48]) = emptystring;

	SvREFCNT(gv_list[48]) += 6;
	GvREFCNT(gv_list[48]) += 1;
	gv_list[49] = gv_fetchpv("main::_<Fcntl.c", TRUE, SVt_PV);
	SvFLAGS(gv_list[49]) = 0x600d;
	GvFLAGS(gv_list[49]) = 0x2;
	GvLINE(gv_list[49]) = 92;
	SvPVX(gv_list[49]) = emptystring;

	SvREFCNT(gv_list[49]) += 2;
	GvREFCNT(gv_list[49]) += 1;
	xpv_list[6].xpv_pv = savepvn("Fcntl.c", 7);
	GvSV(gv_list[49]) = &sv_list[29];
	GvFILE(gv_list[49]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
	gv_list[50] = gv_fetchpv("main::1", TRUE, SVt_PV);
	SvFLAGS(gv_list[50]) = 0x600d;
	GvFLAGS(gv_list[50]) = 0xa;
	GvLINE(gv_list[50]) = 74;
	SvPVX(gv_list[50]) = emptystring;

	SvREFCNT(gv_list[50]) += 28;
	GvREFCNT(gv_list[50]) += 1;
	gv_list[51] = gv_fetchpv("main::_<IO.c", TRUE, SVt_PV);
	SvFLAGS(gv_list[51]) = 0x600d;
	GvFLAGS(gv_list[51]) = 0x2;
	GvLINE(gv_list[51]) = 92;
	SvPVX(gv_list[51]) = emptystring;

	SvREFCNT(gv_list[51]) += 2;
	GvREFCNT(gv_list[51]) += 1;
	xpv_list[7].xpv_pv = savepvn("IO.c", 4);
	GvSV(gv_list[51]) = &sv_list[30];
	GvFILE(gv_list[51]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
	gv_list[52] = gv_fetchpv("main::\027ARNING_BITS", TRUE, SVt_PV);
	SvFLAGS(gv_list[52]) = 0x600d;
	GvFLAGS(gv_list[52]) = 0xa;
	GvLINE(gv_list[52]) = 341;
	SvPVX(gv_list[52]) = emptystring;

	SvREFCNT(gv_list[52]) += 6;
	GvREFCNT(gv_list[52]) += 1;
	sv_magic((SV*)&sv_list[31], (SV*)gv_list[52], '\000', "\027ARNING_BITS", 12);
	GvSV(gv_list[52]) = &sv_list[31];
	GvFILE(gv_list[52]) = "\260\r\016\b";
	gv_list[53] = gv_fetchpv("main::_<B.c", TRUE, SVt_PV);
	SvFLAGS(gv_list[53]) = 0x600d;
	GvFLAGS(gv_list[53]) = 0x2;
	GvLINE(gv_list[53]) = 92;
	SvPVX(gv_list[53]) = emptystring;

	SvREFCNT(gv_list[53]) += 2;
	GvREFCNT(gv_list[53]) += 1;
	xpv_list[8].xpv_pv = savepvn("B.c", 3);
	GvSV(gv_list[53]) = &sv_list[32];
	GvFILE(gv_list[53]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
	gv_list[54] = gv_fetchpv("main::_<DynaLoader.c", TRUE, SVt_PV);
	SvFLAGS(gv_list[54]) = 0x600d;
	GvFLAGS(gv_list[54]) = 0x2;
	GvLINE(gv_list[54]) = 16;
	SvPVX(gv_list[54]) = emptystring;

	SvREFCNT(gv_list[54]) += 2;
	GvREFCNT(gv_list[54]) += 1;
	xpv_list[9].xpv_pv = savepvn("DynaLoader.c", 12);
	GvSV(gv_list[54]) = &sv_list[33];
	GvFILE(gv_list[54]) = "\335\367\302";
	gv_list[55] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/IO/IO.so", TRUE, SVt_PV);
	SvFLAGS(gv_list[55]) = 0x600d;
	GvFLAGS(gv_list[55]) = 0x2;
	GvLINE(gv_list[55]) = 87;
	SvPVX(gv_list[55]) = emptystring;

	SvREFCNT(gv_list[55]) += 2;
	GvREFCNT(gv_list[55]) += 1;
	xpv_list[10].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/IO/IO.so", 58);
	GvSV(gv_list[55]) = &sv_list[34];
	GvFILE(gv_list[55]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
	gv_list[56] = gv_fetchpv("attributes::bootstrap", TRUE, SVt_PV);
	SvFLAGS(gv_list[56]) = 0x600d;
	GvFLAGS(gv_list[56]) = 0x2;
	GvLINE(gv_list[56]) = 0;
	SvPVX(gv_list[56]) = emptystring;

	SvREFCNT(gv_list[56]) += 2;
	GvREFCNT(gv_list[56]) += 1;
	GvSV(gv_list[56]) = &sv_list[35];
	GvFILE(gv_list[56]) = "hello.p";
	gv_list[57] = gv_fetchpv("main::stdin", TRUE, SVt_PV);
	SvFLAGS(gv_list[57]) = 0x600d;
	GvFLAGS(gv_list[57]) = 0x2;
	GvLINE(gv_list[57]) = 0;
	SvPVX(gv_list[57]) = emptystring;

	SvREFCNT(gv_list[57]) += 2;
	GvREFCNT(gv_list[57]) += 1;
	GvSV(gv_list[57]) = &sv_list[36];
	GvFILE(gv_list[57]) = "hello.p";
	IoIFP((IO*)&sv_list[37])=PerlIO_stdin();
	IoOFP((IO*)&sv_list[37])=PerlIO_stdin();
	SvSTASH((IO*)&sv_list[37]) = hv0;
	GvIOp(gv_list[57]) = (IO*)&sv_list[37];
	gv_list[58] = gv_fetchpv("main::ARGV", TRUE, SVt_PV);
	SvFLAGS(gv_list[58]) = 0x600d;
	GvFLAGS(gv_list[58]) = 0x2;
	GvLINE(gv_list[58]) = 0;
	SvPVX(gv_list[58]) = emptystring;

	SvREFCNT(gv_list[58]) += 2;
	GvREFCNT(gv_list[58]) += 1;
	gv_list[59] = gv_fetchpv("main::INC", TRUE, SVt_PV);
	SvFLAGS(gv_list[59]) = 0x600d;
	GvFLAGS(gv_list[59]) = 0xa;
	GvLINE(gv_list[59]) = 0;
	SvPVX(gv_list[59]) = emptystring;

	SvREFCNT(gv_list[59]) += 7;
	GvREFCNT(gv_list[59]) += 1;
	GvSV(gv_list[59]) = &sv_list[38];
	xpv_list[11].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi", 44);
	xpv_list[12].xpv_pv = savepvn("/usr/lib/perl5/5.8.5", 20);
	xpv_list[13].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.5/i386-linux-thread-multi", 54);
	xpv_list[14].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.4/i386-linux-thread-multi", 54);
	xpv_list[15].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.3/i386-linux-thread-multi", 54);
	xpv_list[16].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.2/i386-linux-thread-multi", 54);
	xpv_list[17].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.1/i386-linux-thread-multi", 54);
	xpv_list[18].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.0/i386-linux-thread-multi", 54);
	xpv_list[19].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.5", 30);
	xpv_list[20].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.4", 30);
	xpv_list[21].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.3", 30);
	xpv_list[22].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.2", 30);
	xpv_list[23].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.1", 30);
	xpv_list[24].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.0", 30);
	xpv_list[25].xpv_pv = savepvn("/usr/lib/perl5/site_perl", 24);
	xpv_list[26].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.5/i386-linux-thread-multi", 56);
	xpv_list[27].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.4/i386-linux-thread-multi", 56);
	xpv_list[28].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.3/i386-linux-thread-multi", 56);
	xpv_list[29].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.2/i386-linux-thread-multi", 56);
	xpv_list[30].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.1/i386-linux-thread-multi", 56);
	xpv_list[31].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.0/i386-linux-thread-multi", 56);
	xpv_list[32].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.5", 32);
	xpv_list[33].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.4", 32);
	xpv_list[34].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.3", 32);
	xpv_list[35].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.2", 32);
	xpv_list[36].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.1", 32);
	xpv_list[37].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.0", 32);
	xpv_list[38].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl", 26);
	xpv_list[39].xpv_pv = savepvn(".", 1);
	xpv_list[40].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi", 44);
	xpv_list[41].xpv_pv = savepvn("/usr/lib/perl5/5.8.5", 20);
	xpv_list[42].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.5/i386-linux-thread-multi", 54);
	xpv_list[43].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.4/i386-linux-thread-multi", 54);
	xpv_list[44].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.3/i386-linux-thread-multi", 54);
	xpv_list[45].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.2/i386-linux-thread-multi", 54);
	xpv_list[46].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.1/i386-linux-thread-multi", 54);
	xpv_list[47].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.0/i386-linux-thread-multi", 54);
	xpv_list[48].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.5", 30);
	xpv_list[49].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.4", 30);
	xpv_list[50].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.3", 30);
	xpv_list[51].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.2", 30);
	xpv_list[52].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.1", 30);
	xpv_list[53].xpv_pv = savepvn("/usr/lib/perl5/site_perl/5.8.0", 30);
	xpv_list[54].xpv_pv = savepvn("/usr/lib/perl5/site_perl", 24);
	xpv_list[55].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.5/i386-linux-thread-multi", 56);
	xpv_list[56].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.4/i386-linux-thread-multi", 56);
	xpv_list[57].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.3/i386-linux-thread-multi", 56);
	xpv_list[58].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.2/i386-linux-thread-multi", 56);
	xpv_list[59].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.1/i386-linux-thread-multi", 56);
	xpv_list[60].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.0/i386-linux-thread-multi", 56);
	xpv_list[61].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.5", 32);
	xpv_list[62].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.4", 32);
	xpv_list[63].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.3", 32);
	xpv_list[64].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.2", 32);
	xpv_list[65].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.1", 32);
	xpv_list[66].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl/5.8.0", 32);
	xpv_list[67].xpv_pv = savepvn("/usr/lib/perl5/vendor_perl", 26);
	xpv_list[68].xpv_pv = savepvn(".", 1);
	{
		SV **svp;
		AV *av = (AV*)&sv_list[39];
		av_extend(av, 57);
		svp = AvARRAY(av);
		*svp++ = (SV*)&sv_list[40];
		*svp++ = (SV*)&sv_list[41];
		*svp++ = (SV*)&sv_list[42];
		*svp++ = (SV*)&sv_list[43];
		*svp++ = (SV*)&sv_list[44];
		*svp++ = (SV*)&sv_list[45];
		*svp++ = (SV*)&sv_list[46];
		*svp++ = (SV*)&sv_list[47];
		*svp++ = (SV*)&sv_list[48];
		*svp++ = (SV*)&sv_list[49];
		*svp++ = (SV*)&sv_list[50];
		*svp++ = (SV*)&sv_list[51];
		*svp++ = (SV*)&sv_list[52];
		*svp++ = (SV*)&sv_list[53];
		*svp++ = (SV*)&sv_list[54];
		*svp++ = (SV*)&sv_list[55];
		*svp++ = (SV*)&sv_list[56];
		*svp++ = (SV*)&sv_list[57];
		*svp++ = (SV*)&sv_list[58];
		*svp++ = (SV*)&sv_list[59];
		*svp++ = (SV*)&sv_list[60];
		*svp++ = (SV*)&sv_list[61];
		*svp++ = (SV*)&sv_list[62];
		*svp++ = (SV*)&sv_list[63];
		*svp++ = (SV*)&sv_list[64];
		*svp++ = (SV*)&sv_list[65];
		*svp++ = (SV*)&sv_list[66];
		*svp++ = (SV*)&sv_list[67];
		*svp++ = (SV*)&sv_list[68];
		*svp++ = (SV*)&sv_list[69];
		*svp++ = (SV*)&sv_list[70];
		*svp++ = (SV*)&sv_list[71];
		*svp++ = (SV*)&sv_list[72];
		*svp++ = (SV*)&sv_list[73];
		*svp++ = (SV*)&sv_list[74];
		*svp++ = (SV*)&sv_list[75];
		*svp++ = (SV*)&sv_list[76];
		*svp++ = (SV*)&sv_list[77];
		*svp++ = (SV*)&sv_list[78];
		*svp++ = (SV*)&sv_list[79];
		*svp++ = (SV*)&sv_list[80];
		*svp++ = (SV*)&sv_list[81];
		*svp++ = (SV*)&sv_list[82];
		*svp++ = (SV*)&sv_list[83];
		*svp++ = (SV*)&sv_list[84];
		*svp++ = (SV*)&sv_list[85];
		*svp++ = (SV*)&sv_list[86];
		*svp++ = (SV*)&sv_list[87];
		*svp++ = (SV*)&sv_list[88];
		*svp++ = (SV*)&sv_list[89];
		*svp++ = (SV*)&sv_list[90];
		*svp++ = (SV*)&sv_list[91];
		*svp++ = (SV*)&sv_list[92];
		*svp++ = (SV*)&sv_list[93];
		*svp++ = (SV*)&sv_list[94];
		*svp++ = (SV*)&sv_list[95];
		*svp++ = (SV*)&sv_list[96];
		*svp++ = (SV*)&sv_list[97];
	

		AvFILLp(av) = 57;
	}
	GvAV(gv_list[59]) = (AV*)&sv_list[39];
	GvHV(gv_list[59]) = (HV*)&sv_list[98];
	GvFILE(gv_list[59]) = "";
	gv_list[60] = gv_fetchpv("main::ENV", TRUE, SVt_PV);
	SvFLAGS(gv_list[60]) = 0x600d;
	GvFLAGS(gv_list[60]) = 0xa;
	GvLINE(gv_list[60]) = 0;
	SvPVX(gv_list[60]) = emptystring;

	SvREFCNT(gv_list[60]) += 5;
	GvREFCNT(gv_list[60]) += 1;
	gv_list[61] = gv_fetchpv("main::_<perlio.c", TRUE, SVt_PV);
	SvFLAGS(gv_list[61]) = 0x600d;
	GvFLAGS(gv_list[61]) = 0x2;
	GvLINE(gv_list[61]) = 0;
	SvPVX(gv_list[61]) = emptystring;

	SvREFCNT(gv_list[61]) += 2;
	GvREFCNT(gv_list[61]) += 1;
	xpv_list[69].xpv_pv = savepvn("perlio.c", 8);
	GvSV(gv_list[61]) = &sv_list[99];
	GvFILE(gv_list[61]) = "hello.p";
	gv_list[62] = gv_fetchpv("main:::", TRUE, SVt_PV);
	SvFLAGS(gv_list[62]) = 0x600d;
	GvFLAGS(gv_list[62]) = 0xa;
	GvLINE(gv_list[62]) = 546;
	SvPVX(gv_list[62]) = emptystring;

	SvREFCNT(gv_list[62]) += 4;
	GvREFCNT(gv_list[62]) += 1;
	gv_list[63] = gv_fetchpv("PerlIO::get_layers", TRUE, SVt_PV);
	SvFLAGS(gv_list[63]) = 0x600d;
	GvFLAGS(gv_list[63]) = 0x2;
	GvLINE(gv_list[63]) = 0;
	SvPVX(gv_list[63]) = emptystring;

	SvREFCNT(gv_list[63]) += 2;
	GvREFCNT(gv_list[63]) += 1;
	GvSV(gv_list[63]) = &sv_list[100];
	GvCV(gv_list[63]) = (CV*)((perl_get_cv("PerlIO::get_layers",TRUE)));
	GvFILE(gv_list[63]) = "hello.p";
	gv_list[64] = gv_fetchpv("PerlIO::Layer::NoWarnings", TRUE, SVt_PV);
	SvFLAGS(gv_list[64]) = 0x600d;
	GvFLAGS(gv_list[64]) = 0x2;
	GvLINE(gv_list[64]) = 0;
	SvPVX(gv_list[64]) = emptystring;

	SvREFCNT(gv_list[64]) += 2;
	GvREFCNT(gv_list[64]) += 1;
	GvSV(gv_list[64]) = &sv_list[101];
	GvCV(gv_list[64]) = (CV*)((perl_get_cv("PerlIO::Layer::NoWarnings",TRUE)));
	GvFILE(gv_list[64]) = "hello.p";
	gv_list[65] = gv_fetchpv("PerlIO::Layer::find", TRUE, SVt_PV);
	SvFLAGS(gv_list[65]) = 0x600d;
	GvFLAGS(gv_list[65]) = 0x2;
	GvLINE(gv_list[65]) = 0;
	SvPVX(gv_list[65]) = emptystring;

	SvREFCNT(gv_list[65]) += 2;
	GvREFCNT(gv_list[65]) += 1;
	GvSV(gv_list[65]) = &sv_list[102];
	GvCV(gv_list[65]) = (CV*)((perl_get_cv("PerlIO::Layer::find",TRUE)));
	GvFILE(gv_list[65]) = "hello.p";
	gv_list[66] = gv_fetchpv("main::0", TRUE, SVt_PV);
	SvFLAGS(gv_list[66]) = 0x600d;
	GvFLAGS(gv_list[66]) = 0xa;
	GvLINE(gv_list[66]) = 0;
	SvPVX(gv_list[66]) = emptystring;

	SvREFCNT(gv_list[66]) += 5;
	GvREFCNT(gv_list[66]) += 1;
	gv_list[67] = gv_fetchpv("main::.", TRUE, SVt_PV);
	SvFLAGS(gv_list[67]) = 0x600d;
	GvFLAGS(gv_list[67]) = 0xa;
	GvLINE(gv_list[67]) = 496;
	SvPVX(gv_list[67]) = emptystring;

	SvREFCNT(gv_list[67]) += 5;
	GvREFCNT(gv_list[67]) += 1;
	gv_list[68] = gv_fetchpv("main::\b", TRUE, SVt_PV);
	SvFLAGS(gv_list[68]) = 0x600d;
	GvFLAGS(gv_list[68]) = 0xa;
	GvLINE(gv_list[68]) = 0;
	SvPVX(gv_list[68]) = emptystring;

	SvREFCNT(gv_list[68]) += 5;
	GvREFCNT(gv_list[68]) += 1;
	gv_list[69] = gv_fetchpv("main::@", TRUE, SVt_PV);
	SvFLAGS(gv_list[69]) = 0x600d;
	GvFLAGS(gv_list[69]) = 0xa;
	GvLINE(gv_list[69]) = 0;
	SvPVX(gv_list[69]) = emptystring;

	SvREFCNT(gv_list[69]) += 13;
	GvREFCNT(gv_list[69]) += 1;
	gv_list[70] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/base.pm", TRUE, SVt_PV);
	SvFLAGS(gv_list[70]) = 0x600d;
	GvFLAGS(gv_list[70]) = 0x2;
	GvLINE(gv_list[70]) = 8;
	SvPVX(gv_list[70]) = emptystring;

	SvREFCNT(gv_list[70]) += 2;
	GvREFCNT(gv_list[70]) += 1;
	xpv_list[70].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/base.pm", 28);
	GvSV(gv_list[70]) = &sv_list[103];
	GvFILE(gv_list[70]) = "\270/\r\b";
	gv_list[71] = gv_fetchpv("main::STDOUT", TRUE, SVt_PV);
	SvFLAGS(gv_list[71]) = 0x630d;
	GvFLAGS(gv_list[71]) = 0xa;
	GvLINE(gv_list[71]) = 0;
	SvPVX(gv_list[71]) = emptystring;

	SvREFCNT(gv_list[71]) += 13;
	GvREFCNT(gv_list[71]) += 1;
	gv_list[72] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/B/C.pm", TRUE, SVt_PV);
	SvFLAGS(gv_list[72]) = 0x600d;
	GvFLAGS(gv_list[72]) = 0x2;
	GvLINE(gv_list[72]) = 1096;
	SvPVX(gv_list[72]) = emptystring;

	SvREFCNT(gv_list[72]) += 2;
	GvREFCNT(gv_list[72]) += 1;
	xpv_list[71].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/B/C.pm", 51);
	GvSV(gv_list[72]) = &sv_list[104];
	GvFILE(gv_list[72]) = "";
	gv_list[73] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/B.pm", TRUE, SVt_PV);
	SvFLAGS(gv_list[73]) = 0x600d;
	GvFLAGS(gv_list[73]) = 0x2;
	GvLINE(gv_list[73]) = 87;
	SvPVX(gv_list[73]) = emptystring;

	SvREFCNT(gv_list[73]) += 2;
	GvREFCNT(gv_list[73]) += 1;
	xpv_list[72].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/B.pm", 49);
	GvSV(gv_list[73]) = &sv_list[105];
	GvFILE(gv_list[73]) = "\210\327\a\b\b";
	gv_list[74] = gv_fetchpv("main::]", TRUE, SVt_PV);
	SvFLAGS(gv_list[74]) = 0x600d;
	GvFLAGS(gv_list[74]) = 0xa;
	GvLINE(gv_list[74]) = 41;
	SvPVX(gv_list[74]) = emptystring;

	SvREFCNT(gv_list[74]) += 2;
	GvREFCNT(gv_list[74]) += 1;
	gv_list[75] = gv_fetchpv("main::\027", TRUE, SVt_PV);
	SvFLAGS(gv_list[75]) = 0x600d;
	GvFLAGS(gv_list[75]) = 0xa;
	GvLINE(gv_list[75]) = 227;
	SvPVX(gv_list[75]) = emptystring;

	SvREFCNT(gv_list[75]) += 4;
	GvREFCNT(gv_list[75]) += 1;
	gv_list[76] = gv_fetchpv("main::STDERR", TRUE, SVt_PV);
	SvFLAGS(gv_list[76]) = 0x630d;
	GvFLAGS(gv_list[76]) = 0xa;
	GvLINE(gv_list[76]) = 0;
	SvPVX(gv_list[76]) = emptystring;

	SvREFCNT(gv_list[76]) += 4;
	GvREFCNT(gv_list[76]) += 1;
	gv_list[77] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/B/B.so", TRUE, SVt_PV);
	SvFLAGS(gv_list[77]) = 0x600d;
	GvFLAGS(gv_list[77]) = 0x2;
	GvLINE(gv_list[77]) = 87;
	SvPVX(gv_list[77]) = emptystring;

	SvREFCNT(gv_list[77]) += 2;
	GvREFCNT(gv_list[77]) += 1;
	xpv_list[73].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/B/B.so", 56);
	GvSV(gv_list[77]) = &sv_list[106];
	GvFILE(gv_list[77]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
	gv_list[78] = gv_fetchpv("main::_</usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/Fcntl/Fcntl.so", TRUE, SVt_PV);
	SvFLAGS(gv_list[78]) = 0x600d;
	GvFLAGS(gv_list[78]) = 0x2;
	GvLINE(gv_list[78]) = 87;
	SvPVX(gv_list[78]) = emptystring;

	SvREFCNT(gv_list[78]) += 2;
	GvREFCNT(gv_list[78]) += 1;
	xpv_list[74].xpv_pv = savepvn("/usr/lib/perl5/5.8.5/i386-linux-thread-multi/auto/Fcntl/Fcntl.so", 64);
	GvSV(gv_list[78]) = &sv_list[107];
	GvFILE(gv_list[78]) = "/usr/lib/perl5/5.8.5/i386-linux-thread-multi/XSLoader.pm";
	    PL_dowarn = ( 0 ) ? G_WARN_ON : G_WARN_OFF;
	PL_main_root = (OP*)&listop_list[0];
	PL_main_start = &op_list[0];
	PL_initav = (AV *) Nullsv;
	PL_endav = (AV*) Nullsv;
	xpv_list[75].xpv_pv = savepvn("Hello World\n", 12);
	{
		SV **svp;
		AV *av = (AV*)&sv_list[109];
		av_extend(av, 2);
		svp = AvARRAY(av);
		*svp++ = (SV*)&PL_sv_undef;
		*svp++ = (SV*)&sv_list[110];
		*svp++ = (SV*)&sv_list[111];
	

		AvFILLp(av) = 2;
	}
	PL_curpad = AvARRAY((AV*)&sv_list[109]);
	GvHV(PL_incgv) = (HV*)&sv_list[98];
	GvAV(PL_incgv) = (AV*)&sv_list[39];
	av_store(CvPADLIST(PL_main_cv),0,SvREFCNT_inc((AV*)&sv_list[108]));
	av_store(CvPADLIST(PL_main_cv),1,SvREFCNT_inc((AV*)&sv_list[109]));
	PL_amagic_generation= 0;
	return 0;
}
Esempio n. 4
0
/* helper for the default modify handler for builtin attributes */
static int
modify_SV_attributes(pTHX_ SV *sv, SV **retlist, SV **attrlist, int numattrs)
{
    SV *attr;
    int nret;

    for (nret = 0 ; numattrs && (attr = *attrlist++); numattrs--) {
	STRLEN len;
	const char *name = SvPV_const(attr, len);
	const bool negated = (*name == '-');
        HV *typestash;

	if (negated) {
	    name++;
	    len--;
	}
	switch (SvTYPE(sv)) {
	case SVt_PVCV:
	    switch ((int)len) {
	    case 4:
		if (memEQ(name, "pure", 4)) {
		    if (negated)
			Perl_croak(aTHX_ "Illegal :-pure attribute");
                    CvPURE_on(sv);
		    goto next_attr;
                }
		break;
	    case 5:
		if (memEQ(name, "const", 5)) {
		    if (negated)
			CvCONST_off(sv);
		    else {
#ifndef USE_CPERL
                        const bool warn = (!CvANON(sv) || CvCLONED(sv))
                                        && !CvCONST(sv);
                        CvCONST_on(sv);
                        if (warn)
                            break;
#else
                        CvCONST_on(sv);
#endif
		    }
		    goto next_attr;
		}
		break;
	    case 6:
		switch (name[3]) {
		case 'l':
		    if (memEQ(name, "lvalue", 6)) {
			bool warn =
			    !CvISXSUB(MUTABLE_CV(sv))
			 && CvROOT(MUTABLE_CV(sv))
			 && !CvLVALUE(MUTABLE_CV(sv)) != negated;
			if (negated)
			    CvFLAGS(MUTABLE_CV(sv)) &= ~CVf_LVALUE;
			else
			    CvFLAGS(MUTABLE_CV(sv)) |= CVf_LVALUE;
			if (warn) break;
                        goto next_attr;
		    }
		    break;
		case 'h':
		    if (memEQ(name, "method", 6)) {
			if (negated)
			    CvFLAGS(MUTABLE_CV(sv)) &= ~CVf_METHOD;
			else
			    CvFLAGS(MUTABLE_CV(sv)) |= CVf_METHOD;
                        goto next_attr;
		    }
		    break;
		}
		break;
	    default:
		if (len > 10 && memEQ(name, "prototype(", 10)) {
		    SV * proto = newSVpvn(name+10,len-11);
		    HEK *const hek = CvNAME_HEK((CV *)sv);
		    SV *subname;
		    if (name[len-1] != ')')
			Perl_croak(aTHX_ "Unterminated attribute parameter in attribute list");
		    if (hek)
			subname = sv_2mortal(newSVhek(hek));
		    else
			subname=(SV *)CvGV((const CV *)sv);
		    if (ckWARN(WARN_ILLEGALPROTO))
			Perl_validate_proto(aTHX_ subname, proto, TRUE);
		    Perl_cv_ckproto_len_flags(aTHX_ (const CV *)sv,
		                                    (const GV *)subname,
		                                    name+10,
		                                    len-11,
		                                    SvUTF8(attr));
		    sv_setpvn(MUTABLE_SV(sv), name+10, len-11);
		    if (SvUTF8(attr)) SvUTF8_on(MUTABLE_SV(sv));
		    goto next_attr;
		}
		break;
	    }
            if (!negated && (typestash = gv_stashpvn(name, len, SvUTF8(attr)))) {
                CvTYPED_on(sv);
                CvTYPE_set((CV*)sv, typestash);
                continue;
            }
	    break;
	case SVt_IV:
	case SVt_PVIV:
	case SVt_PVMG:
            if (memEQ(name, "unsigned", 8)
                && (SvIOK(sv) || SvUOK(sv)))
            {
                if (negated) /* :-unsigned alias for :signed */
                    SvIsUV_off(sv);
                else
                    SvIsUV_on(sv);
                continue;
            }
            /* fallthru - all other data types */
	default:
            if (memEQ(name, "const", 5)
                && !(SvFLAGS(sv) & SVf_PROTECT))
            {
                if (negated)
                    SvREADONLY_off(sv);
                else
                    SvREADONLY_on(sv);
                continue;
            }
	    if (memEQs(name, len, "shared")) {
                if (negated)
                    Perl_croak(aTHX_ "A variable may not be unshared");
                SvSHARE(sv);
                continue;
	    }
	    break;
	}
	/* anything recognized had a 'continue' above */
	*retlist++ = attr;
	nret++;
    next_attr:
        ;
    }

    return nret;
}