[gitmo/Package-Stash-XS.git] / Stash.xs

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#define NEED_newRV_noinc
#define NEED_sv_2pv_flags
#include "ppport.h"

#ifndef gv_fetchsv
#define gv_fetchsv(n,f,t) gv_fetchpv(SvPV_nolen(n), f, t)
#endif

#ifndef mro_method_changed_in
#define mro_method_changed_in(x) PL_sub_generation++
#endif

#ifdef newSVhek
#define newSVhe(he) newSVhek(HeKEY_hek(he))
#else
#define newSVhe(he) newSVpv(HePV(he, PL_na), 0)
#endif

#ifndef savesvpv
#define savesvpv(s) savepv(SvPV_nolen(s))
#endif

/* HACK: scalar slots are always populated on perl < 5.10, so treat undef
 * as nonexistent. this is consistent with the previous behavior of the pure
 * perl version of this module (since this is the behavior that perl sees
 * in all versions */
#if PERL_VERSION < 10
#define GvSVOK(g) (GvSV(g) && SvTYPE(GvSV(g)) != SVt_NULL)
#else
#define GvSVOK(g) GvSV(g)
#endif

#define GvAVOK(g) GvAV(g)
#define GvHVOK(g) GvHV(g)
#define GvCVOK(g) GvCVu(g) /* XXX: should this really be GvCVu? or GvCV? */
#define GvIOOK(g) GvIO(g)

/* see above - don't let scalar slots become unpopulated, this breaks
 * assumptions in core */
#if PERL_VERSION < 10
#define GvSetSV(g,v) do {               \
    SV *_v = (SV*)(v);                  \
    SvREFCNT_dec(GvSV(g));              \
    if ((GvSV(g) = _v ? _v : newSV(0))) \
        GvIMPORTED_SV_on(g);            \
} while (0)
#else
#define GvSetSV(g,v) do {               \
    SvREFCNT_dec(GvSV(g));              \
    if ((GvSV(g) = (SV*)(v)))           \
        GvIMPORTED_SV_on(g);            \
} while (0)
#endif

#define GvSetAV(g,v) do {               \
    SvREFCNT_dec(GvAV(g));              \
    if ((GvAV(g) = (AV*)(v)))           \
        GvIMPORTED_AV_on(g);            \
} while (0)
#define GvSetHV(g,v) do {               \
    SvREFCNT_dec(GvHV(g));              \
    if ((GvHV(g) = (HV*)(v)))           \
        GvIMPORTED_HV_on(g);            \
} while (0)
#define GvSetCV(g,v) do {               \
    SvREFCNT_dec(GvCV(g));              \
    if ((GvCV(g) = (CV*)(v))) {         \
        GvIMPORTED_CV_on(g);            \
        GvASSUMECV_on(g);               \
    }                                   \
    GvCVGEN(g) = 0;                     \
    mro_method_changed_in(GvSTASH(g));  \
} while (0)
#define GvSetIO(g,v) do {               \
    SvREFCNT_dec(GvIO(g));              \
    GvIOp(g) = (IO*)(v);                \
} while (0)

/* XXX: the core implementation of caller() is private, so we need a
 * a reimplementation. luckily, padwalker already has done this. rafl says
 * that there should be a public interface in 5.14, so maybe look into
 * converting to use that at some point */
#include "stolen_bits_of_padwalker.c"

typedef enum {
    VAR_NONE = 0,
    VAR_SCALAR,
    VAR_ARRAY,
    VAR_HASH,
    VAR_CODE,
    VAR_IO,
    VAR_GLOB,  /* TODO: unimplemented */
    VAR_FORMAT /* TODO: unimplemented */
} vartype_t;

typedef struct {
    vartype_t type;
    char *name;
    I32 namelen;
} varspec_t;

static U32 name_hash, namespace_hash, type_hash;
static SV *name_key, *namespace_key, *type_key;

const char *vartype_to_string(vartype_t type)
{
    switch (type) {
    case VAR_SCALAR:
        return "SCALAR";
    case VAR_ARRAY:
        return "ARRAY";
    case VAR_HASH:
        return "HASH";
    case VAR_CODE:
        return "CODE";
    case VAR_IO:
        return "IO";
    default:
        return "unknown";
    }
}

I32 vartype_to_svtype(vartype_t type)
{
    switch (type) {
    case VAR_SCALAR:
        return SVt_PV; /* or whatever */
    case VAR_ARRAY:
        return SVt_PVAV;
    case VAR_HASH:
        return SVt_PVHV;
    case VAR_CODE:
        return SVt_PVCV;
    case VAR_IO:
        return SVt_PVIO;
    default:
        return SVt_NULL;
    }
}

vartype_t string_to_vartype(char *vartype)
{
    if (strEQ(vartype, "SCALAR")) {
        return VAR_SCALAR;
    }
    else if (strEQ(vartype, "ARRAY")) {
        return VAR_ARRAY;
    }
    else if (strEQ(vartype, "HASH")) {
        return VAR_HASH;
    }
    else if (strEQ(vartype, "CODE")) {
        return VAR_CODE;
    }
    else if (strEQ(vartype, "IO")) {
        return VAR_IO;
    }
    else {
        croak("Type must be one of 'SCALAR', 'ARRAY', 'HASH', 'CODE', or 'IO'");
    }
}

void _deconstruct_variable_name(SV *varsv, varspec_t *varspec)
{
    char *variable;
    STRLEN len;

    variable = SvPV(varsv, len);
    if (!variable[0])
        croak("You must pass a variable name");

    switch (variable[0]) {
    case '$':
        varspec->type = VAR_SCALAR;
        varspec->name = &variable[1];
        varspec->namelen = len - 1;
        break;
    case '@':
        varspec->type = VAR_ARRAY;
        varspec->name = &variable[1];
        varspec->namelen = len - 1;
        break;
    case '%':
        varspec->type = VAR_HASH;
        varspec->name = &variable[1];
        varspec->namelen = len - 1;
        break;
    case '&':
        varspec->type = VAR_CODE;
        varspec->name = &variable[1];
        varspec->namelen = len - 1;
        break;
    default:
        varspec->type = VAR_IO;
        varspec->name = variable;
        varspec->namelen = len;
        break;
    }
}

void _deconstruct_variable_hash(HV *variable, varspec_t *varspec)
{
    HE *val;
    char *valpv;
    STRLEN len;

    val = hv_fetch_ent(variable, name_key, 0, name_hash);
    if (!val)
        croak("The 'name' key is required in variable specs");

    valpv = HePV(val, len);
    varspec->name = savepvn(valpv, len);
    SAVEFREEPV(varspec->name);
    varspec->namelen = len;

    val = hv_fetch_ent(variable, type_key, 0, type_hash);
    if (!val)
        croak("The 'type' key is required in variable specs");

    valpv = HePV(val, len);
    varspec->type = string_to_vartype(valpv);
}

int _valid_for_type(SV *value, vartype_t type)
{
    svtype sv_type = SvROK(value) ? SvTYPE(SvRV(value)) : SVt_NULL;

    switch (type) {
    case VAR_SCALAR:
        return sv_type == SVt_NULL ||
               sv_type == SVt_IV   ||
               sv_type == SVt_NV   ||
               sv_type == SVt_PV   ||
               sv_type == SVt_RV;
    case VAR_ARRAY:
        return sv_type == SVt_PVAV;
    case VAR_HASH:
        return sv_type == SVt_PVHV;
    case VAR_CODE:
        return sv_type == SVt_PVCV;
    case VAR_IO:
        return sv_type == SVt_PVIO;
    default:
        return 0;
    }
}

HV *_get_namespace(SV *self)
{
    dSP;
    SV *ret;

    PUSHMARK(SP);
    XPUSHs(self);
    PUTBACK;

    call_method("namespace", G_SCALAR);

    SPAGAIN;
    ret = POPs;
    PUTBACK;

    return (HV*)SvRV(ret);
}

SV *_get_name(SV *self)
{
    dSP;
    SV *ret;

    PUSHMARK(SP);
    XPUSHs(self);
    PUTBACK;

    call_method("name", G_SCALAR);

    SPAGAIN;
    ret = POPs;
    PUTBACK;

    return ret;
}

void _expand_glob(SV *self, char *name)
{
    SV *namesv;

    namesv = newSVsv(_get_name(self));
    sv_catpvs(namesv, "::");
    sv_catpv(namesv, name);

    /* can't use gv_init here, because it screws up @ISA in a way that I
     * can't reproduce, but that CMOP triggers */
    gv_fetchsv(namesv, GV_ADD, SVt_NULL);
    SvREFCNT_dec(namesv);
}

SV *_get_symbol(SV *self, varspec_t *variable, int vivify)
{
    HV *namespace;
    SV **entry;
    GV *glob;

    namespace = _get_namespace(self);
    entry = hv_fetch(namespace, variable->name, variable->namelen, vivify);
    if (!entry)
        return NULL;

    glob = (GV*)(*entry);
    if (!isGV(glob))
        _expand_glob(self, variable->name);

    if (vivify) {
        switch (variable->type) {
        case VAR_SCALAR:
            if (!GvSVOK(glob))
                GvSetSV(glob, newSV(0));
            break;
        case VAR_ARRAY:
            if (!GvAVOK(glob))
                GvSetAV(glob, newAV());
            break;
        case VAR_HASH:
            if (!GvHVOK(glob))
                GvSetHV(glob, newHV());
            break;
        case VAR_CODE:
            croak("Don't know how to vivify CODE variables");
        case VAR_IO:
            if (!GvIOOK(glob))
                GvSetIO(glob, newIO());
            break;
        default:
            croak("Unknown type in vivication");
        }
    }

    switch (variable->type) {
    case VAR_SCALAR:
        return GvSV(glob);
    case VAR_ARRAY:
        return (SV*)GvAV(glob);
    case VAR_HASH:
        return (SV*)GvHV(glob);
    case VAR_CODE:
        return (SV*)GvCV(glob);
    case VAR_IO:
        return (SV*)GvIO(glob);
    default:
        return NULL;
    }
}

MODULE = Package::Stash  PACKAGE = Package::Stash

PROTOTYPES: DISABLE

SV*
new(class, package_name)
    char *class
    SV *package_name
  PREINIT:
    HV *instance;
    HV *namespace;
    SV *nsref;
  CODE:
    if (!SvPOK(package_name))
        croak("The constructor argument must be the name of a package");

    instance = newHV();

    if (!hv_store(instance, "name", 4, SvREFCNT_inc_simple_NN(package_name), 0)) {
        SvREFCNT_dec(package_name);
        SvREFCNT_dec(instance);
        croak("Couldn't initialize the 'name' key, hv_store failed");
    }
    namespace = gv_stashpv(SvPV_nolen(package_name), GV_ADD);
    nsref = newRV_inc((SV*)namespace);
    if (!hv_store(instance, "namespace", 9, nsref, 0)) {
        SvREFCNT_dec(nsref);
        SvREFCNT_dec(instance);
        croak("Couldn't initialize the 'namespace' key, hv_store failed");
    }

    RETVAL = sv_bless(newRV_noinc((SV*)instance), gv_stashpv(class, 0));
  OUTPUT:
    RETVAL

SV*
name(self)
    SV *self
  PREINIT:
    HE *slot;
  CODE:
    if (!sv_isobject(self))
        croak("Can't call name as a class method");
    slot = hv_fetch_ent((HV*)SvRV(self), name_key, 0, name_hash);
    RETVAL = slot ? SvREFCNT_inc_simple_NN(HeVAL(slot)) : &PL_sv_undef;
  OUTPUT:
    RETVAL

SV*
namespace(self)
    SV *self
  PREINIT:
    HE *slot;
  CODE:
    if (!sv_isobject(self))
        croak("Can't call namespace as a class method");
    slot = hv_fetch_ent((HV*)SvRV(self), namespace_key, 0, namespace_hash);
    RETVAL = slot ? SvREFCNT_inc_simple_NN(HeVAL(slot)) : &PL_sv_undef;
  OUTPUT:
    RETVAL

void
add_symbol(self, variable, initial=NULL, ...)
    SV *self
    varspec_t variable
    SV *initial
  PREINIT:
    SV *name;
    GV *glob;
  CODE:
    if (initial && !_valid_for_type(initial, variable.type))
        croak("%s is not of type %s",
              SvPV_nolen(initial), vartype_to_string(variable.type));

    name = newSVsv(_get_name(self));
    sv_catpvs(name, "::");
    sv_catpv(name, variable.name);

    if (items > 2 && (PL_perldb & 0x10) && variable.type == VAR_CODE) {
        int i;
        char *filename = NULL, *namepv;
        I32 first_line_num = -1, last_line_num = -1;
        STRLEN namelen;
        SV *dbval;
        HV *dbsub;

        if ((items - 3) % 2)
            croak("add_symbol: Odd number of elements in %%opts");

        for (i = 3; i < items; i += 2) {
            char *key;
            key = SvPV_nolen(ST(i));
            if (strEQ(key, "filename")) {
                if (!SvPOK(ST(i + 1)))
                    croak("add_symbol: filename must be a string");
                filename = SvPV_nolen(ST(i + 1));
            }
            else if (strEQ(key, "first_line_num")) {
                if (!SvIOK(ST(i + 1)))
                    croak("add_symbol: first_line_num must be an integer");
                first_line_num = SvIV(ST(i + 1));
            }
            else if (strEQ(key, "last_line_num")) {
                if (!SvIOK(ST(i + 1)))
                    croak("add_symbol: last_line_num must be an integer");
                last_line_num = SvIV(ST(i + 1));
            }
        }

        if (!filename || first_line_num == -1) {
            I32 cxix_from, cxix_to;
            PERL_CONTEXT *cx, *ccstack;
            COP *cop = NULL;

            cx = upcontext(0, &cop, &ccstack, &cxix_from, &cxix_to);
            if (!cop)
                cop = PL_curcop;

            if (!filename)
                filename = CopFILE(cop);
            if (first_line_num == -1)
                first_line_num = cop->cop_line;
        }

        if (last_line_num == -1)
            last_line_num = first_line_num;

        /* http://perldoc.perl.org/perldebguts.html#Debugger-Internals */
        dbsub = get_hv("DB::sub", 1);
        dbval = newSVpvf("%s:%d-%d", filename, first_line_num, last_line_num);
        namepv = SvPV(name, namelen);
        if (!hv_store(dbsub, namepv, namelen, dbval, 0)) {
            warn("Failed to update $DB::sub for subroutine %s", namepv);
            SvREFCNT_dec(dbval);
        }
    }

    /* GV_ADDMULTI rather than GV_ADD because otherwise you get 'used only
     * once' warnings in some situations... i can't reproduce this, but CMOP
     * triggers it */
    glob = gv_fetchsv(name, GV_ADDMULTI, vartype_to_svtype(variable.type));

    if (initial) {
        SV *val;

        if (SvROK(initial)) {
            val = SvRV(initial);
            SvREFCNT_inc_simple_void_NN(val);
        }
        else {
            val = newSVsv(initial);
        }

        switch (variable.type) {
        case VAR_SCALAR:
            GvSetSV(glob, val);
            break;
        case VAR_ARRAY:
            GvSetAV(glob, val);
            break;
        case VAR_HASH:
            GvSetHV(glob, val);
            break;
        case VAR_CODE:
            GvSetCV(glob, val);
            break;
        case VAR_IO:
            GvSetIO(glob, val);
            break;
        }
    }

    SvREFCNT_dec(name);

void
remove_glob(self, namesv)
    SV *self
    SV *namesv
  PREINIT:
    char *name;
    STRLEN len;
  CODE:
    name = SvPV(namesv, len);
    hv_delete(_get_namespace(self), name, len, G_DISCARD);

int
has_symbol(self, variable)
    SV *self
    varspec_t variable
  PREINIT:
    HV *namespace;
    SV **entry;
  CODE:
    namespace = _get_namespace(self);
    entry = hv_fetch(namespace, variable.name, variable.namelen, 0);
    if (!entry)
        XSRETURN_UNDEF;

    if (isGV(*entry)) {
        GV *glob = (GV*)(*entry);
        switch (variable.type) {
        case VAR_SCALAR:
            RETVAL = GvSVOK(glob) ? 1 : 0;
            break;
        case VAR_ARRAY:
            RETVAL = GvAVOK(glob) ? 1 : 0;
            break;
        case VAR_HASH:
            RETVAL = GvHVOK(glob) ? 1 : 0;
            break;
        case VAR_CODE:
            RETVAL = GvCVOK(glob) ? 1 : 0;
            break;
        case VAR_IO:
            RETVAL = GvIOOK(glob) ? 1 : 0;
            break;
        }
    }
    else {
        RETVAL = (variable.type == VAR_CODE);
    }
  OUTPUT:
    RETVAL

SV*
get_symbol(self, variable)
    SV *self
    varspec_t variable
  PREINIT:
    SV *val;
  CODE:
    val = _get_symbol(self, &variable, 0);
    if (!val)
        XSRETURN_UNDEF;
    RETVAL = newRV_inc(val);
  OUTPUT:
    RETVAL

SV*
get_or_add_symbol(self, variable)
    SV *self
    varspec_t variable
  PREINIT:
    SV *val;
  CODE:
    val = _get_symbol(self, &variable, 1);
    if (!val)
        XSRETURN_UNDEF;
    RETVAL = newRV_inc(val);
  OUTPUT:
    RETVAL

void
remove_symbol(self, variable)
    SV *self
    varspec_t variable
  PREINIT:
    HV *namespace;
    SV **entry;
  CODE:
    namespace = _get_namespace(self);
    entry = hv_fetch(namespace, variable.name, variable.namelen, 0);
    if (!entry)
        XSRETURN_EMPTY;

    if (isGV(*entry)) {
        GV *glob = (GV*)(*entry);
        switch (variable.type) {
        case VAR_SCALAR:
            GvSetSV(glob, NULL);
            break;
        case VAR_ARRAY:
            GvSetAV(glob, NULL);
            break;
        case VAR_HASH:
            GvSetHV(glob, NULL);
            break;
        case VAR_CODE:
            GvSetCV(glob, NULL);
            break;
        case VAR_IO:
            GvSetIO(glob, NULL);
            break;
        }
    }
    else {
        if (variable.type == VAR_CODE) {
            hv_delete(namespace, variable.name, variable.namelen, G_DISCARD);
        }
    }

void
list_all_symbols(self, vartype=VAR_NONE)
    SV *self
    vartype_t vartype
  PPCODE:
    if (vartype == VAR_NONE) {
        HV *namespace;
        HE *entry;
        int keys;

        namespace = _get_namespace(self);
        keys = hv_iterinit(namespace);
        EXTEND(SP, keys);
        while ((entry = hv_iternext(namespace))) {
            mPUSHs(newSVhe(entry));
        }
    }
    else {
        HV *namespace;
        SV *val;
        char *key;
        I32 len;

        namespace = _get_namespace(self);
        hv_iterinit(namespace);
        while ((val = hv_iternextsv(namespace, &key, &len))) {
            GV *gv = (GV*)val;
            if (isGV(gv)) {
                switch (vartype) {
                case VAR_SCALAR:
                    if (GvSVOK(val))
                        mXPUSHp(key, len);
                    break;
                case VAR_ARRAY:
                    if (GvAVOK(val))
                        mXPUSHp(key, len);
                    break;
                case VAR_HASH:
                    if (GvHVOK(val))
                        mXPUSHp(key, len);
                    break;
                case VAR_CODE:
                    if (GvCVOK(val))
                        mXPUSHp(key, len);
                    break;
                case VAR_IO:
                    if (GvIOOK(val))
                        mXPUSHp(key, len);
                    break;
                }
            }
            else if (vartype == VAR_CODE) {
                mXPUSHp(key, len);
            }
        }
    }

void
get_all_symbols(self, vartype=VAR_NONE)
    SV *self
    vartype_t vartype
  PREINIT:
    HV *namespace, *ret;
    SV *val;
    char *key;
    I32 len;
  PPCODE:
    namespace = _get_namespace(self);
    ret = newHV();

    hv_iterinit(namespace);
    while ((val = hv_iternextsv(namespace, &key, &len))) {
        GV *gv = (GV*)val;

        if (!isGV(gv))
            _expand_glob(self, key);

        switch (vartype) {
        case VAR_SCALAR:
            if (GvSVOK(val))
                hv_store(ret, key, len, newRV_inc(GvSV(gv)), 0);
            break;
        case VAR_ARRAY:
            if (GvAVOK(val))
                hv_store(ret, key, len, newRV_inc((SV*)GvAV(gv)), 0);
            break;
        case VAR_HASH:
            if (GvHVOK(val))
                hv_store(ret, key, len, newRV_inc((SV*)GvHV(gv)), 0);
            break;
        case VAR_CODE:
            if (GvCVOK(val))
                hv_store(ret, key, len, newRV_inc((SV*)GvCV(gv)), 0);
            break;
        case VAR_IO:
            if (GvIOOK(val))
                hv_store(ret, key, len, newRV_inc((SV*)GvIO(gv)), 0);
            break;
        case VAR_NONE:
            hv_store(ret, key, len, SvREFCNT_inc_simple_NN(val), 0);
            break;
        }
    }

    mPUSHs(newRV_noinc((SV*)ret));

BOOT:
    {
        name_key = newSVpvs("name");
        PERL_HASH(name_hash, "name", 4);

        namespace_key = newSVpvs("namespace");
        PERL_HASH(namespace_hash, "namespace", 9);

        type_key = newSVpvs("type");
        PERL_HASH(type_hash, "type", 4);
    }
Commit	Line	Data
59017825	1	#include "EXTERN.h"
	2	#include "perl.h"
	3	#include "XSUB.h"
	4
dfabcbae	5	#define NEED_newRV_noinc
	6	#define NEED_sv_2pv_flags
	7	#include "ppport.h"
	8
13f8a7b7	9	#ifndef gv_fetchsv
	10	#define gv_fetchsv(n,f,t) gv_fetchpv(SvPV_nolen(n), f, t)
	11	#endif
	12
	13	#ifndef mro_method_changed_in
	14	#define mro_method_changed_in(x) PL_sub_generation++
	15	#endif
	16
	17	#ifdef newSVhek
	18	#define newSVhe(he) newSVhek(HeKEY_hek(he))
	19	#else
3e37e315	20	#define newSVhe(he) newSVpv(HePV(he, PL_na), 0)
13f8a7b7	21	#endif
	22
	23	#ifndef savesvpv
	24	#define savesvpv(s) savepv(SvPV_nolen(s))
	25	#endif
	26
d551a208	27	/* HACK: scalar slots are always populated on perl < 5.10, so treat undef
	28	* as nonexistent. this is consistent with the previous behavior of the pure
	29	* perl version of this module (since this is the behavior that perl sees
	30	* in all versions */
	31	#if PERL_VERSION < 10
	32	#define GvSVOK(g) (GvSV(g) && SvTYPE(GvSV(g)) != SVt_NULL)
	33	#else
	34	#define GvSVOK(g) GvSV(g)
	35	#endif
	36
	37	#define GvAVOK(g) GvAV(g)
	38	#define GvHVOK(g) GvHV(g)
	39	#define GvCVOK(g) GvCVu(g) /* XXX: should this really be GvCVu? or GvCV? */
	40	#define GvIOOK(g) GvIO(g)
	41
9aa6fe4f	42	/* see above - don't let scalar slots become unpopulated, this breaks
9aa6fe4f	43	* assumptions in core */
3720d1a1	44	#if PERL_VERSION < 10
	45	#define GvSetSV(g,v) do { \
	46	SV _v = (SV)(v); \
	47	SvREFCNT_dec(GvSV(g)); \
	48	if ((GvSV(g) = _v ? _v : newSV(0))) \
	49	GvIMPORTED_SV_on(g); \
	50	} while (0)
	51	#else
d551a208	52	#define GvSetSV(g,v) do { \
	53	SvREFCNT_dec(GvSV(g)); \
	54	if ((GvSV(g) = (SV*)(v))) \
	55	GvIMPORTED_SV_on(g); \
	56	} while (0)
3720d1a1	57	#endif
3720d1a1	58
d551a208	59	#define GvSetAV(g,v) do { \
	60	SvREFCNT_dec(GvAV(g)); \
	61	if ((GvAV(g) = (AV*)(v))) \
	62	GvIMPORTED_AV_on(g); \
	63	} while (0)
	64	#define GvSetHV(g,v) do { \
	65	SvREFCNT_dec(GvHV(g)); \
	66	if ((GvHV(g) = (HV*)(v))) \
	67	GvIMPORTED_HV_on(g); \
	68	} while (0)
	69	#define GvSetCV(g,v) do { \
	70	SvREFCNT_dec(GvCV(g)); \
	71	if ((GvCV(g) = (CV*)(v))) { \
	72	GvIMPORTED_CV_on(g); \
	73	GvASSUMECV_on(g); \
	74	} \
	75	GvCVGEN(g) = 0; \
	76	mro_method_changed_in(GvSTASH(g)); \
	77	} while (0)
	78	#define GvSetIO(g,v) do { \
	79	SvREFCNT_dec(GvIO(g)); \
	80	GvIOp(g) = (IO*)(v); \
	81	} while (0)
	82
d1d0e437	83	/* XXX: the core implementation of caller() is private, so we need a
	84	* a reimplementation. luckily, padwalker already has done this. rafl says
	85	* that there should be a public interface in 5.14, so maybe look into
	86	* converting to use that at some point */
	87	#include "stolen_bits_of_padwalker.c"
	88
a382a84b	89	typedef enum {
	90	VAR_NONE = 0,
	91	VAR_SCALAR,
	92	VAR_ARRAY,
	93	VAR_HASH,
	94	VAR_CODE,
	95	VAR_IO,
	96	VAR_GLOB, /* TODO: unimplemented */
	97	VAR_FORMAT /* TODO: unimplemented */
	98	} vartype_t;
	99
	100	typedef struct {
	101	vartype_t type;
a382a84b	102	char *name;
64b79211	103	I32 namelen;
a382a84b	104	} varspec_t;
a382a84b	105
26f802f7	106	static U32 name_hash, namespace_hash, type_hash;
	107	static SV name_key, namespace_key, *type_key;
	108
76f7c306	109	const char *vartype_to_string(vartype_t type)
	110	{
	111	switch (type) {
	112	case VAR_SCALAR:
	113	return "SCALAR";
	114	case VAR_ARRAY:
	115	return "ARRAY";
	116	case VAR_HASH:
	117	return "HASH";
	118	case VAR_CODE:
	119	return "CODE";
	120	case VAR_IO:
	121	return "IO";
	122	default:
	123	return "unknown";
	124	}
	125	}
	126
	127	I32 vartype_to_svtype(vartype_t type)
	128	{
	129	switch (type) {
	130	case VAR_SCALAR:
	131	return SVt_PV; /* or whatever */
	132	case VAR_ARRAY:
	133	return SVt_PVAV;
	134	case VAR_HASH:
	135	return SVt_PVHV;
	136	case VAR_CODE:
	137	return SVt_PVCV;
	138	case VAR_IO:
	139	return SVt_PVIO;
	140	default:
	141	return SVt_NULL;
	142	}
	143	}
	144
a382a84b	145	vartype_t string_to_vartype(char *vartype)
	146	{
	147	if (strEQ(vartype, "SCALAR")) {
	148	return VAR_SCALAR;
	149	}
	150	else if (strEQ(vartype, "ARRAY")) {
	151	return VAR_ARRAY;
	152	}
	153	else if (strEQ(vartype, "HASH")) {
	154	return VAR_HASH;
	155	}
	156	else if (strEQ(vartype, "CODE")) {
	157	return VAR_CODE;
	158	}
	159	else if (strEQ(vartype, "IO")) {
	160	return VAR_IO;
	161	}
	162	else {
	163	croak("Type must be one of 'SCALAR', 'ARRAY', 'HASH', 'CODE', or 'IO'");
	164	}
	165	}
	166
64b79211	167	void _deconstruct_variable_name(SV varsv, varspec_t varspec)
a382a84b	168	{
64b79211	169	char *variable;
64b79211	170	STRLEN len;
a382a84b	171
64b79211	172	variable = SvPV(varsv, len);
	173	if (!variable[0])
	174	croak("You must pass a variable name");
a382a84b	175
	176	switch (variable[0]) {
	177	case '$':
	178	varspec->type = VAR_SCALAR;
64b79211	179	varspec->name = &variable[1];
64b79211	180	varspec->namelen = len - 1;
a382a84b	181	break;
	182	case '@':
	183	varspec->type = VAR_ARRAY;
64b79211	184	varspec->name = &variable[1];
64b79211	185	varspec->namelen = len - 1;
a382a84b	186	break;
	187	case '%':
	188	varspec->type = VAR_HASH;
64b79211	189	varspec->name = &variable[1];
64b79211	190	varspec->namelen = len - 1;
a382a84b	191	break;
	192	case '&':
	193	varspec->type = VAR_CODE;
a382a84b	194	varspec->name = &variable[1];
64b79211	195	varspec->namelen = len - 1;
	196	break;
	197	default:
a382a84b	198	varspec->type = VAR_IO;
a382a84b	199	varspec->name = variable;
64b79211	200	varspec->namelen = len;
64b79211	201	break;
a382a84b	202	}
	203	}
	204
	205	void _deconstruct_variable_hash(HV variable, varspec_t varspec)
	206	{
26f802f7	207	HE *val;
	208	char *valpv;
	209	STRLEN len;
a382a84b	210
26f802f7	211	val = hv_fetch_ent(variable, name_key, 0, name_hash);
a382a84b	212	if (!val)
	213	croak("The 'name' key is required in variable specs");
	214
26f802f7	215	valpv = HePV(val, len);
26f802f7	216	varspec->name = savepvn(valpv, len);
301f570b	217	SAVEFREEPV(varspec->name);
64b79211	218	varspec->namelen = len;
a382a84b	219
26f802f7	220	val = hv_fetch_ent(variable, type_key, 0, type_hash);
a382a84b	221	if (!val)
	222	croak("The 'type' key is required in variable specs");
	223
26f802f7	224	valpv = HePV(val, len);
26f802f7	225	varspec->type = string_to_vartype(valpv);
a382a84b	226	}
	227
	228	int _valid_for_type(SV *value, vartype_t type)
	229	{
	230	svtype sv_type = SvROK(value) ? SvTYPE(SvRV(value)) : SVt_NULL;
	231
	232	switch (type) {
	233	case VAR_SCALAR:
	234	return sv_type == SVt_NULL \|\|
	235	sv_type == SVt_IV \|\|
	236	sv_type == SVt_NV \|\|
	237	sv_type == SVt_PV \|\|
	238	sv_type == SVt_RV;
	239	case VAR_ARRAY:
	240	return sv_type == SVt_PVAV;
	241	case VAR_HASH:
	242	return sv_type == SVt_PVHV;
	243	case VAR_CODE:
	244	return sv_type == SVt_PVCV;
	245	case VAR_IO:
76f7c306	246	return sv_type == SVt_PVIO;
a382a84b	247	default:
	248	return 0;
	249	}
	250	}
	251
3fd56b4d	252	HV _get_namespace(SV self)
	253	{
	254	dSP;
	255	SV *ret;
	256
	257	PUSHMARK(SP);
	258	XPUSHs(self);
	259	PUTBACK;
	260
612dcf3b	261	call_method("namespace", G_SCALAR);
3fd56b4d	262
	263	SPAGAIN;
	264	ret = POPs;
	265	PUTBACK;
	266
	267	return (HV*)SvRV(ret);
	268	}
	269
76f7c306	270	SV _get_name(SV self)
	271	{
	272	dSP;
	273	SV *ret;
	274
	275	PUSHMARK(SP);
	276	XPUSHs(self);
	277	PUTBACK;
	278
612dcf3b	279	call_method("name", G_SCALAR);
76f7c306	280
	281	SPAGAIN;
	282	ret = POPs;
	283	PUTBACK;
	284
	285	return ret;
	286	}
	287
60b395a1	288	void _expand_glob(SV self, char name)
	289	{
	290	SV *namesv;
	291
	292	namesv = newSVsv(_get_name(self));
	293	sv_catpvs(namesv, "::");
	294	sv_catpv(namesv, name);
	295
	296	/* can't use gv_init here, because it screws up @ISA in a way that I
	297	* can't reproduce, but that CMOP triggers */
	298	gv_fetchsv(namesv, GV_ADD, SVt_NULL);
	299	SvREFCNT_dec(namesv);
	300	}
	301
15c104e2	302	SV _get_symbol(SV self, varspec_t *variable, int vivify)
4871b1a0	303	{
	304	HV *namespace;
	305	SV **entry;
	306	GV *glob;
	307
	308	namespace = _get_namespace(self);
64b79211	309	entry = hv_fetch(namespace, variable->name, variable->namelen, vivify);
4871b1a0	310	if (!entry)
	311	return NULL;
	312
	313	glob = (GV)(entry);
60b395a1	314	if (!isGV(glob))
60b395a1	315	_expand_glob(self, variable->name);
4871b1a0	316
	317	if (vivify) {
	318	switch (variable->type) {
	319	case VAR_SCALAR:
d551a208	320	if (!GvSVOK(glob))
d551a208	321	GvSetSV(glob, newSV(0));
4871b1a0	322	break;
4871b1a0	323	case VAR_ARRAY:
d551a208	324	if (!GvAVOK(glob))
d551a208	325	GvSetAV(glob, newAV());
4871b1a0	326	break;
4871b1a0	327	case VAR_HASH:
d551a208	328	if (!GvHVOK(glob))
d551a208	329	GvSetHV(glob, newHV());
4871b1a0	330	break;
	331	case VAR_CODE:
	332	croak("Don't know how to vivify CODE variables");
	333	case VAR_IO:
d551a208	334	if (!GvIOOK(glob))
d551a208	335	GvSetIO(glob, newIO());
4871b1a0	336	break;
	337	default:
	338	croak("Unknown type in vivication");
	339	}
	340	}
	341
	342	switch (variable->type) {
	343	case VAR_SCALAR:
	344	return GvSV(glob);
	345	case VAR_ARRAY:
	346	return (SV*)GvAV(glob);
	347	case VAR_HASH:
	348	return (SV*)GvHV(glob);
	349	case VAR_CODE:
	350	return (SV*)GvCV(glob);
	351	case VAR_IO:
	352	return (SV*)GvIO(glob);
	353	default:
	354	return NULL;
	355	}
	356	}
	357
59017825	358	MODULE = Package::Stash PACKAGE = Package::Stash
59017825	359
be2a7e99	360	PROTOTYPES: DISABLE
be2a7e99	361
59017825	362	SV*
	363	new(class, package_name)
	364	char *class
	365	SV *package_name
3496f1e8	366	PREINIT:
59017825	367	HV *instance;
59017825	368	HV *namespace;
1d6c978b	369	SV *nsref;
59017825	370	CODE:
	371	if (!SvPOK(package_name))
	372	croak("The constructor argument must be the name of a package");
	373
6c3e69c6	374	instance = newHV();
59017825	375
1d6c978b	376	if (!hv_store(instance, "name", 4, SvREFCNT_inc_simple_NN(package_name), 0)) {
1d6c978b	377	SvREFCNT_dec(package_name);
c86a1630	378	SvREFCNT_dec(instance);
e8d57afd	379	croak("Couldn't initialize the 'name' key, hv_store failed");
1d6c978b	380	}
59017825	381	namespace = gv_stashpv(SvPV_nolen(package_name), GV_ADD);
1d6c978b	382	nsref = newRV_inc((SV*)namespace);
	383	if (!hv_store(instance, "namespace", 9, nsref, 0)) {
	384	SvREFCNT_dec(nsref);
c86a1630	385	SvREFCNT_dec(instance);
e8d57afd	386	croak("Couldn't initialize the 'namespace' key, hv_store failed");
1d6c978b	387	}
59017825	388
6c3e69c6	389	RETVAL = sv_bless(newRV_noinc((SV*)instance), gv_stashpv(class, 0));
59017825	390	OUTPUT:
59017825	391	RETVAL
194acf47	392
	393	SV*
	394	name(self)
	395	SV *self
3496f1e8	396	PREINIT:
26f802f7	397	HE *slot;
194acf47	398	CODE:
	399	if (!sv_isobject(self))
	400	croak("Can't call name as a class method");
26f802f7	401	slot = hv_fetch_ent((HV*)SvRV(self), name_key, 0, name_hash);
26f802f7	402	RETVAL = slot ? SvREFCNT_inc_simple_NN(HeVAL(slot)) : &PL_sv_undef;
194acf47	403	OUTPUT:
	404	RETVAL
	405
	406	SV*
	407	namespace(self)
	408	SV *self
3496f1e8	409	PREINIT:
26f802f7	410	HE *slot;
194acf47	411	CODE:
	412	if (!sv_isobject(self))
	413	croak("Can't call namespace as a class method");
26f802f7	414	slot = hv_fetch_ent((HV*)SvRV(self), namespace_key, 0, namespace_hash);
26f802f7	415	RETVAL = slot ? SvREFCNT_inc_simple_NN(HeVAL(slot)) : &PL_sv_undef;
194acf47	416	OUTPUT:
194acf47	417	RETVAL
3fd56b4d	418
3fd56b4d	419	void
15c104e2	420	add_symbol(self, variable, initial=NULL, ...)
76f7c306	421	SV *self
	422	varspec_t variable
	423	SV *initial
	424	PREINIT:
	425	SV *name;
	426	GV *glob;
	427	CODE:
	428	if (initial && !_valid_for_type(initial, variable.type))
	429	croak("%s is not of type %s",
	430	SvPV_nolen(initial), vartype_to_string(variable.type));
	431
	432	name = newSVsv(_get_name(self));
	433	sv_catpvs(name, "::");
	434	sv_catpv(name, variable.name);
	435
76f7c306	436	if (items > 2 && (PL_perldb & 0x10) && variable.type == VAR_CODE) {
76f7c306	437	int i;
d1d0e437	438	char filename = NULL, namepv;
	439	I32 first_line_num = -1, last_line_num = -1;
	440	STRLEN namelen;
	441	SV *dbval;
	442	HV *dbsub;
76f7c306	443
76f7c306	444	if ((items - 3) % 2)
15c104e2	445	croak("add_symbol: Odd number of elements in %%opts");
76f7c306	446
	447	for (i = 3; i < items; i += 2) {
	448	char *key;
	449	key = SvPV_nolen(ST(i));
	450	if (strEQ(key, "filename")) {
	451	if (!SvPOK(ST(i + 1)))
15c104e2	452	croak("add_symbol: filename must be a string");
76f7c306	453	filename = SvPV_nolen(ST(i + 1));
	454	}
	455	else if (strEQ(key, "first_line_num")) {
	456	if (!SvIOK(ST(i + 1)))
15c104e2	457	croak("add_symbol: first_line_num must be an integer");
76f7c306	458	first_line_num = SvIV(ST(i + 1));
	459	}
	460	else if (strEQ(key, "last_line_num")) {
	461	if (!SvIOK(ST(i + 1)))
15c104e2	462	croak("add_symbol: last_line_num must be an integer");
76f7c306	463	last_line_num = SvIV(ST(i + 1));
	464	}
	465	}
	466
d1d0e437	467	if (!filename \|\| first_line_num == -1) {
	468	I32 cxix_from, cxix_to;
	469	PERL_CONTEXT cx, ccstack;
	470	COP *cop = NULL;
	471
	472	cx = upcontext(0, &cop, &ccstack, &cxix_from, &cxix_to);
	473	if (!cop)
	474	cop = PL_curcop;
	475
	476	if (!filename)
	477	filename = CopFILE(cop);
	478	if (first_line_num == -1)
	479	first_line_num = cop->cop_line;
	480	}
	481
	482	if (last_line_num == -1)
	483	last_line_num = first_line_num;
	484
	485	/* http://perldoc.perl.org/perldebguts.html#Debugger-Internals */
	486	dbsub = get_hv("DB::sub", 1);
	487	dbval = newSVpvf("%s:%d-%d", filename, first_line_num, last_line_num);
	488	namepv = SvPV(name, namelen);
	489	if (!hv_store(dbsub, namepv, namelen, dbval, 0)) {
	490	warn("Failed to update $DB::sub for subroutine %s", namepv);
	491	SvREFCNT_dec(dbval);
76f7c306	492	}
76f7c306	493	}
76f7c306	494
9aa6fe4f	495	/* GV_ADDMULTI rather than GV_ADD because otherwise you get 'used only
	496	* once' warnings in some situations... i can't reproduce this, but CMOP
	497	* triggers it */
fedea7f9	498	glob = gv_fetchsv(name, GV_ADDMULTI, vartype_to_svtype(variable.type));
76f7c306	499
	500	if (initial) {
	501	SV *val;
	502
	503	if (SvROK(initial)) {
	504	val = SvRV(initial);
a2fec41a	505	SvREFCNT_inc_simple_void_NN(val);
76f7c306	506	}
	507	else {
	508	val = newSVsv(initial);
	509	}
	510
	511	switch (variable.type) {
	512	case VAR_SCALAR:
d551a208	513	GvSetSV(glob, val);
76f7c306	514	break;
76f7c306	515	case VAR_ARRAY:
d551a208	516	GvSetAV(glob, val);
76f7c306	517	break;
76f7c306	518	case VAR_HASH:
d551a208	519	GvSetHV(glob, val);
76f7c306	520	break;
76f7c306	521	case VAR_CODE:
d551a208	522	GvSetCV(glob, val);
76f7c306	523	break;
76f7c306	524	case VAR_IO:
d551a208	525	GvSetIO(glob, val);
76f7c306	526	break;
	527	}
	528	}
	529
5bb2b07b	530	SvREFCNT_dec(name);
5bb2b07b	531
76f7c306	532	void
64b79211	533	remove_glob(self, namesv)
3fd56b4d	534	SV *self
64b79211	535	SV *namesv
	536	PREINIT:
	537	char *name;
	538	STRLEN len;
3fd56b4d	539	CODE:
64b79211	540	name = SvPV(namesv, len);
64b79211	541	hv_delete(_get_namespace(self), name, len, G_DISCARD);
9b608466	542
34805376	543	int
15c104e2	544	has_symbol(self, variable)
34805376	545	SV *self
	546	varspec_t variable
	547	PREINIT:
	548	HV *namespace;
	549	SV **entry;
	550	CODE:
	551	namespace = _get_namespace(self);
64b79211	552	entry = hv_fetch(namespace, variable.name, variable.namelen, 0);
34805376	553	if (!entry)
	554	XSRETURN_UNDEF;
	555
	556	if (isGV(*entry)) {
	557	GV glob = (GV)(*entry);
	558	switch (variable.type) {
	559	case VAR_SCALAR:
d551a208	560	RETVAL = GvSVOK(glob) ? 1 : 0;
34805376	561	break;
34805376	562	case VAR_ARRAY:
d551a208	563	RETVAL = GvAVOK(glob) ? 1 : 0;
34805376	564	break;
34805376	565	case VAR_HASH:
d551a208	566	RETVAL = GvHVOK(glob) ? 1 : 0;
34805376	567	break;
34805376	568	case VAR_CODE:
d551a208	569	RETVAL = GvCVOK(glob) ? 1 : 0;
34805376	570	break;
34805376	571	case VAR_IO:
d551a208	572	RETVAL = GvIOOK(glob) ? 1 : 0;
34805376	573	break;
	574	}
	575	}
	576	else {
	577	RETVAL = (variable.type == VAR_CODE);
	578	}
	579	OUTPUT:
	580	RETVAL
	581
e3ad44fd	582	SV*
15c104e2	583	get_symbol(self, variable)
e3ad44fd	584	SV *self
	585	varspec_t variable
	586	PREINIT:
fca4ed0c	587	SV *val;
e3ad44fd	588	CODE:
15c104e2	589	val = _get_symbol(self, &variable, 0);
4871b1a0	590	if (!val)
e3ad44fd	591	XSRETURN_UNDEF;
93c36417	592	RETVAL = newRV_inc(val);
4871b1a0	593	OUTPUT:
4871b1a0	594	RETVAL
e3ad44fd	595
4871b1a0	596	SV*
15c104e2	597	get_or_add_symbol(self, variable)
4871b1a0	598	SV *self
	599	varspec_t variable
	600	PREINIT:
	601	SV *val;
	602	CODE:
15c104e2	603	val = _get_symbol(self, &variable, 1);
fca4ed0c	604	if (!val)
fca4ed0c	605	XSRETURN_UNDEF;
93c36417	606	RETVAL = newRV_inc(val);
e3ad44fd	607	OUTPUT:
	608	RETVAL
	609
9b608466	610	void
15c104e2	611	remove_symbol(self, variable)
215f49f8	612	SV *self
	613	varspec_t variable
	614	PREINIT:
	615	HV *namespace;
	616	SV **entry;
	617	CODE:
	618	namespace = _get_namespace(self);
64b79211	619	entry = hv_fetch(namespace, variable.name, variable.namelen, 0);
215f49f8	620	if (!entry)
	621	XSRETURN_EMPTY;
	622
	623	if (isGV(*entry)) {
	624	GV glob = (GV)(*entry);
	625	switch (variable.type) {
	626	case VAR_SCALAR:
d551a208	627	GvSetSV(glob, NULL);
215f49f8	628	break;
215f49f8	629	case VAR_ARRAY:
d551a208	630	GvSetAV(glob, NULL);
215f49f8	631	break;
215f49f8	632	case VAR_HASH:
d551a208	633	GvSetHV(glob, NULL);
215f49f8	634	break;
215f49f8	635	case VAR_CODE:
d551a208	636	GvSetCV(glob, NULL);
215f49f8	637	break;
215f49f8	638	case VAR_IO:
d551a208	639	GvSetIO(glob, NULL);
215f49f8	640	break;
	641	}
	642	}
	643	else {
	644	if (variable.type == VAR_CODE) {
64b79211	645	hv_delete(namespace, variable.name, variable.namelen, G_DISCARD);
215f49f8	646	}
	647	}
	648
	649	void
15c104e2	650	list_all_symbols(self, vartype=VAR_NONE)
9b608466	651	SV *self
	652	vartype_t vartype
	653	PPCODE:
	654	if (vartype == VAR_NONE) {
	655	HV *namespace;
	656	HE *entry;
	657	int keys;
	658
	659	namespace = _get_namespace(self);
	660	keys = hv_iterinit(namespace);
	661	EXTEND(SP, keys);
ebcc8ba8	662	while ((entry = hv_iternext(namespace))) {
13f8a7b7	663	mPUSHs(newSVhe(entry));
9b608466	664	}
	665	}
	666	else {
	667	HV *namespace;
9b608466	668	SV *val;
9b608466	669	char *key;
64b79211	670	I32 len;
9b608466	671
	672	namespace = _get_namespace(self);
	673	hv_iterinit(namespace);
ebcc8ba8	674	while ((val = hv_iternextsv(namespace, &key, &len))) {
9b608466	675	GV gv = (GV)val;
	676	if (isGV(gv)) {
	677	switch (vartype) {
	678	case VAR_SCALAR:
d551a208	679	if (GvSVOK(val))
9b608466	680	mXPUSHp(key, len);
	681	break;
	682	case VAR_ARRAY:
d551a208	683	if (GvAVOK(val))
9b608466	684	mXPUSHp(key, len);
	685	break;
	686	case VAR_HASH:
d551a208	687	if (GvHVOK(val))
9b608466	688	mXPUSHp(key, len);
	689	break;
	690	case VAR_CODE:
d551a208	691	if (GvCVOK(val))
9b608466	692	mXPUSHp(key, len);
	693	break;
	694	case VAR_IO:
d551a208	695	if (GvIOOK(val))
9b608466	696	mXPUSHp(key, len);
	697	break;
	698	}
	699	}
	700	else if (vartype == VAR_CODE) {
	701	mXPUSHp(key, len);
	702	}
	703	}
	704	}
26f802f7	705
d2b55565	706	void
	707	get_all_symbols(self, vartype=VAR_NONE)
	708	SV *self
	709	vartype_t vartype
	710	PREINIT:
	711	HV namespace, ret;
	712	SV *val;
	713	char *key;
	714	I32 len;
	715	PPCODE:
	716	namespace = _get_namespace(self);
	717	ret = newHV();
	718
	719	hv_iterinit(namespace);
	720	while ((val = hv_iternextsv(namespace, &key, &len))) {
	721	GV gv = (GV)val;
	722
	723	if (!isGV(gv))
	724	_expand_glob(self, key);
	725
	726	switch (vartype) {
	727	case VAR_SCALAR:
	728	if (GvSVOK(val))
	729	hv_store(ret, key, len, newRV_inc(GvSV(gv)), 0);
	730	break;
	731	case VAR_ARRAY:
	732	if (GvAVOK(val))
	733	hv_store(ret, key, len, newRV_inc((SV*)GvAV(gv)), 0);
	734	break;
	735	case VAR_HASH:
	736	if (GvHVOK(val))
	737	hv_store(ret, key, len, newRV_inc((SV*)GvHV(gv)), 0);
	738	break;
	739	case VAR_CODE:
	740	if (GvCVOK(val))
	741	hv_store(ret, key, len, newRV_inc((SV*)GvCV(gv)), 0);
	742	break;
	743	case VAR_IO:
	744	if (GvIOOK(val))
	745	hv_store(ret, key, len, newRV_inc((SV*)GvIO(gv)), 0);
	746	break;
	747	case VAR_NONE:
	748	hv_store(ret, key, len, SvREFCNT_inc_simple_NN(val), 0);
	749	break;
	750	}
	751	}
	752
	753	mPUSHs(newRV_noinc((SV*)ret));
	754
26f802f7	755	BOOT:
	756	{
	757	name_key = newSVpvs("name");
	758	PERL_HASH(name_hash, "name", 4);
	759
	760	namespace_key = newSVpvs("namespace");
	761	PERL_HASH(namespace_hash, "namespace", 9);
	762
	763	type_key = newSVpvs("type");
	764	PERL_HASH(type_hash, "type", 4);
	765	}