view release on metacpan or  search on metacpan

src/dynamic.cpp  view on Meta::CPAN

#include "dynamic.h"
#include "mapper.h"
#include "servicedef.h"

#include "pb/gpb_mapping.h"

#include <sstream>

using namespace gpd;
using namespace std;
using namespace UMS_NS;
using namespace google::protobuf;
using namespace upb;
using namespace upb::googlepb;

#if PERL_VERSION < 10
    #undef  newCONSTSUB
    #define newCONSTSUB(a, b,c) Perl_newCONSTSUB(aTHX_ a, const_cast<char *>(b), c)

    #undef newXS
    #define newXS(a, b, c) Perl_newXS(aTHX_ const_cast<char *>(a), b, const_cast<char *>(c))
#endif

namespace {
    SV *get_stack_trace(pTHX) {
        dSP;

        PUSHMARK(SP);
        PUTBACK;

        call_pv("Google::ProtocolBuffers::Dynamic::_stack_trace", G_SCALAR);

        SPAGAIN;
        SV *stack_trace = POPs;
        PUTBACK;

        return stack_trace;
    }

    const string
        sym_ARGV    = "ARGV",
        sym_ARGVOUT = "ARGVOUT",
        sym_ENV     = "ENV",
        sym_INC     = "INC",
        sym_SIG     = "SIG",
        sym_STDIN   = "STDIN",
        sym_STDOUT  = "STDOUT",
        sym_STDERR  = "STDERR",

        sym_BEGIN     = "BEGIN",
        sym_CHECK     = "CHECK",
        sym_END       = "END",
        sym_INIT      = "INIT",
        sym_UNITCHECK = "UNITCHECK";

    // does the same job as S_gv_is_in_main in gv.c
    bool is_in_main(const string &name) {
        size_t length = name.length();

        switch (name[0]) {
        case '_':
            return length == 1;
        case 'A':
            return name == sym_ARGV || name == sym_ARGVOUT;
        case 'E':
            return name == sym_ENV;
        case 'I':
            return name == sym_INC;
        case 'S':
            return name == sym_SIG || name == sym_STDIN ||
                   name == sym_STDOUT || name == sym_STDERR;
        default:
            return false;
        }
    }

    bool is_special_sub(const string &name) {
        switch (name[0]) {
        case 'B':
            return name == sym_BEGIN;
        case 'C':
            return name == sym_CHECK;
        case 'E':
            return name == sym_END;
        case 'I':
            return name == sym_INIT;
        case 'U':
            return name == sym_UNITCHECK;
        default:
            return false;
        }
    }
}

MappingOptions::MappingOptions(pTHX_ SV *options_ref) :
        use_bigints(sizeof(IV) < sizeof(int64_t)),
        check_required_fields(true),
        explicit_defaults(false),
        encode_defaults(false),
        encode_defaults_proto3(false),
        check_enum_values(true),
        generic_extension_methods(true),
        implicit_maps(false),
        decode_blessed(true),
        fail_ref_coercion(false),
        no_redefine_perl_names(false),
        ignore_undef_fields(false),
        boolean_style(Perl),
        accessor_style(GetAndSet),
        client_services(Disable),
        default_decoder(Upb) {
    stack_trace = get_stack_trace(aTHX);

    if (options_ref == NULL || !SvOK(options_ref))
        return;
    if (!SvROK(options_ref) || SvTYPE(SvRV(options_ref)) != SVt_PVHV)
        croak("options must be a hash reference");
    HV *options = (HV *) SvRV(options_ref);

#define BOOLEAN_OPTION(field, name) { \
        SV **value = hv_fetchs(options, #name, 0); \
        if (value) \
            field = SvTRUE(*value); \
    }

    BOOLEAN_OPTION(use_bigints, use_bigints);
    BOOLEAN_OPTION(check_required_fields, check_required_fields);
    BOOLEAN_OPTION(explicit_defaults, explicit_defaults);
    BOOLEAN_OPTION(encode_defaults, encode_defaults);
    BOOLEAN_OPTION(encode_defaults_proto3, encode_defaults_proto3);
    BOOLEAN_OPTION(check_enum_values, check_enum_values);
    BOOLEAN_OPTION(generic_extension_methods, generic_extension_methods);
    BOOLEAN_OPTION(implicit_maps, implicit_maps);
    BOOLEAN_OPTION(decode_blessed, decode_blessed);
    BOOLEAN_OPTION(fail_ref_coercion, fail_ref_coercion);
    BOOLEAN_OPTION(ignore_undef_fields, ignore_undef_fields);

#undef BOOLEAN_OPTION

#define START_STRING_VALUE(name) \
    if (SV **value = hv_fetchs(options, #name, 0)) { \
        const char *buf = SvPV_nolen(*value); \
        \
        if (0 == 1)

#define STRING_VALUE(field, string, value) \
        else if (strEQ(buf, #string)) \
            field = value