Qstruct.xs - metacpan.org

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

#include <stdint.h>
#include <stdlib.h>


#define MATH_INT64_NATIVE_IF_AVAILABLE
#include "perl_math_int64.h"


#include "qstruct/utils.h"
#include "qstruct/compiler.h"
#include "qstruct/loader.h"
#include "qstruct/builder.h"


typedef struct qstruct_definition * Qstruct_Definitions;
typedef struct qstruct_item * Qstruct_Item;
typedef struct qstruct_builder * Qstruct_Builder;


MODULE = Qstruct         PACKAGE = Qstruct
PROTOTYPES: ENABLE


BOOT:
  PERL_MATH_INT64_LOAD_OR_CROAK;


Qstruct_Definitions
parse_schema(schema_sv)
        SV *schema_sv
    CODE:
        char *schema;
        size_t schema_size;
        struct qstruct_definition *def;
        char err_buf[1024];

        if (!SvPOK(schema_sv)) croak("schema must be a string");
        schema_size = SvCUR(schema_sv);
        schema = SvPV(schema_sv, schema_size);

        def = parse_qstructs(schema, schema_size, err_buf, sizeof(err_buf));

        if (!def) croak("Qstruct::parse error: %s", err_buf);

        RETVAL = def;
    OUTPUT:
        RETVAL


MODULE = Qstruct         PACKAGE = Qstruct::Definitions
PROTOTYPES: ENABLE



void
iterate(def, callback)
        Qstruct_Definitions def
        SV *callback
    CODE:
        HV *def_info, *items_iterator;

        for(; def; def = def->next) {
          ENTER;
          SAVETMPS;

          PUSHMARK(SP);

          def_info = (HV *) sv_2mortal ((SV *) newHV ());
          hv_store(def_info, "def_addr", 8, newSViv((size_t)def), 0);
          hv_store(def_info, "name", 4, newSVpvn(def->name, def->name_len), 0);
          hv_store(def_info, "body_size", 9, newSVnv(def->body_size), 0);
          hv_store(def_info, "num_items", 9, newSVnv(def->num_items), 0);
          XPUSHs(newRV((SV*)def_info));

          PUTBACK;

          call_sv(callback, G_SCALAR);

          FREETMPS;
          LEAVE;
        }


SV *
get_item(def_addr, item_index)
        unsigned long def_addr
        unsigned long item_index
    CODE:
        Qstruct_Definitions def = (Qstruct_Definitions) def_addr; // FIXME: must be better way to do this in XS
        HV * rh;
        struct qstruct_item *item = def->items + item_index;

        rh = (HV *) sv_2mortal ((SV *) newHV ());
        hv_store(rh, "name", 4, newSVpvn(item->name, item->name_len), 0);
        hv_store(rh, "type", 4, newSVnv(item->type), 0);
        hv_store(rh, "fixed_array_size", 16, newSVnv(item->fixed_array_size), 0);
        hv_store(rh, "byte_offset", 11, newSVnv(item->byte_offset), 0);
        hv_store(rh, "bit_offset", 10, newSVnv(item->bit_offset), 0);
        hv_store(rh, "nested_type", 11, newSVpvn(item->nested_name, item->nested_name_len), 0);
        hv_store(rh, "order", 5, newSVnv(item->item_order), 0);

        RETVAL = newRV((SV *)rh);
    OUTPUT:
        RETVAL



void
DESTROY(def)
        Qstruct_Definitions def
    CODE:
        free_qstruct_definitions(def);




MODULE = Qstruct         PACKAGE = Qstruct::Runtime
PROTOTYPES: ENABLE


int
sanity_check(buf_sv)
        SV *buf_sv
    CODE:
        char *buf;
        size_t buf_size;

        if (!SvPOK(buf_sv)) croak("buf is not a string");
        buf_size = SvCUR(buf_sv);
        buf = SvPV(buf_sv, buf_size);

        RETVAL = qstruct_sanity_check(buf, buf_size);
    OUTPUT:
        RETVAL



AV *
unpack_header(buf_sv)
        SV *buf_sv
    CODE:
        char *buf;
        size_t buf_size;
        AV *rv;
        uint64_t magic_id;
        uint32_t body_size, body_count;
        int ret;

        if (!SvPOK(buf_sv)) croak("buf is not a string");
        buf_size = SvCUR(buf_sv);
        buf = SvPV(buf_sv, buf_size);

        if (buf_size > 0) {
          ret = qstruct_unpack_header(buf, buf_size, &magic_id, &body_size, &body_count);
          if (ret) croak("unable to unpack header");
        } else {
          magic_id = body_size = body_count;
        }

        rv = newAV();
        sv_2mortal((SV*)rv);

        av_push(rv, newSViv(0)); // FIXME: magic id
        av_push(rv, newSViv(body_size));
        av_push(rv, newSViv(body_count));

        RETVAL = rv;
    OUTPUT:
        RETVAL



INCLUDE_COMMAND: $^X gen_getters.pl



int
get_bool(buf_sv, body_index, byte_offset, bit_offset)
        SV *buf_sv
        uint32_t body_index
        uint32_t byte_offset
        int bit_offset
    CODE:
        char *buf;
        size_t buf_size;
        int output;
        int ret;

        if (!SvPOK(buf_sv)) croak("buf is not a string");
        buf_size = SvCUR(buf_sv);
        buf = SvPV(buf_sv, buf_size);

        ret = qstruct_get_bool(buf, buf_size, body_index, byte_offset, bit_offset, &output);

        if (ret) croak("malformed qstruct");

        RETVAL = output;
    OUTPUT:
        RETVAL


void
get_string(buf_sv, body_index, byte_offset, output_sv)
        SV *buf_sv
        uint32_t body_index
        uint32_t byte_offset
        SV *output_sv
    CODE:
        char *buf, *output;
        size_t buf_size, output_size;
        int ret;

        if (!SvPOK(buf_sv)) croak("buf is not a string");
        buf_size = SvCUR(buf_sv);
        buf = SvPV(buf_sv, buf_size);

        ret = qstruct_get_pointer(buf, buf_size, body_index, byte_offset, &output, &output_size, 1);

        if (ret) croak("malformed qstruct (%d)", ret);

        SvUPGRADE(output_sv, SVt_PV);

        // Link the reference counts together
        sv_magicext(output_sv, buf_sv, PERL_MAGIC_ext, NULL, NULL, 0);

        SvCUR_set(output_sv, output_size);
        SvPV_set(output_sv, output);
        SvPOK_only(output_sv);

        // Don't try to free this memory: it's owned by buf_sv
        SvLEN_set(output_sv, 0);

        SvREADONLY_on(output_sv);
        SvREADONLY_on(buf_sv);



void
get_raw_bytes(buf_sv, body_index, byte_offset, length, output_sv)
        SV *buf_sv
        uint32_t body_index
        uint32_t byte_offset
        size_t length
        SV *output_sv
    CODE:
        char *buf, *output;
        size_t buf_size, output_size;
        int ret;

        if (!SvPOK(buf_sv)) croak("buf is not a string");
        buf_size = SvCUR(buf_sv);
        buf = SvPV(buf_sv, buf_size);

        ret = qstruct_get_raw_bytes(buf, buf_size, body_index, byte_offset, length, &output, &output_size);
        if (ret) croak("malformed qstruct");

        SvUPGRADE(output_sv, SVt_PV);

        // Link the reference counts together
        sv_magicext(output_sv, buf_sv, PERL_MAGIC_ext, NULL, NULL, 0);

        SvCUR_set(output_sv, output_size);
        SvPV_set(output_sv, output);
        SvPOK_only(output_sv);

        // Don't try to free this memory: it's owned by buf_sv
        SvLEN_set(output_sv, 0);

        SvREADONLY_on(output_sv);
        SvREADONLY_on(buf_sv);



MODULE = Qstruct         PACKAGE = Qstruct::Builder
PROTOTYPES: ENABLE

Qstruct_Builder
new(package, magic_id, body_size, body_count)
        char *package
        uint64_t magic_id
        uint32_t body_size
        uint32_t body_count
    CODE:
        RETVAL = qstruct_builder_new(magic_id, body_size, body_count);
    OUTPUT:
        RETVAL



INCLUDE_COMMAND: $^X gen_setters.pl



void
set_bool(self, body_index, byte_offset, bit_offset, value)
        Qstruct_Builder self
        uint32_t body_index
        uint32_t byte_offset
        int bit_offset
        int value
    CODE:
        if (qstruct_builder_set_bool(self, body_index, byte_offset, bit_offset, value)) croak("out of memory");

void
set_string(self, body_index, byte_offset, value_sv, int alignment)
        Qstruct_Builder self
        uint32_t body_index
        uint32_t byte_offset
        SV *value_sv
    CODE:
        char *value;
        size_t value_size;
        int ret;

        if (!SvPOK(value_sv)) croak("value is not a string");
        value_size = SvCUR(value_sv);
        value = SvPV(value_sv, value_size);

        if (ret = qstruct_builder_set_pointer(self, body_index, byte_offset, value, value_size, alignment, NULL)) croak("out of memory (%d)", ret);


void
set_raw_bytes(self, body_index, byte_offset, bytes)
        Qstruct_Builder self
        uint32_t body_index
        uint32_t byte_offset
        SV *bytes
    CODE:
        size_t bytes_size;
        char *bytesp;

        if (!SvPOK(bytes)) croak("bytes is not a string");
        bytes_size = SvCUR(bytes);
        bytesp = SvPV(bytes, bytes_size);

        if (qstruct_builder_set_raw_bytes(self, body_index, byte_offset, bytesp, bytes_size)) croak("out of memory");



SV *
render(builder)
        Qstruct_Builder builder
    CODE:
        char *msg;
        size_t msg_size;

        msg_size = qstruct_builder_get_msg_size(builder);

        msg = qstruct_builder_get_buf(builder);

        RETVAL = newSVpvn(msg, msg_size);
    OUTPUT:
        RETVAL


void
DESTROY(builder)
        Qstruct_Builder builder
    CODE:
        qstruct_builder_free(builder);
	Global
`s`	Focus search bar
`?`	Bring up this help dialog
	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)
	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse
	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)