Senna

 view release on metacpan or  search on metacpan

lib/Senna.xs  view on Meta::CPAN

        int flags;
        int initial_n_segments;
        sen_encoding encoding;
        unsigned int nrecords_keys;
        unsigned int file_size_keys;
        unsigned int nrecords_lexicon;
        unsigned int file_size_lexicon;
        unsigned int inv_seg_size;
        unsigned int inv_chunk_size;
        sen_rc rc;
    PPCODE:
        index = XS_STATE(sen_index *, self);
        rc = sen_index_info(index,
            &key_size, &flags, &initial_n_segments, &encoding,
            &nrecords_keys, &file_size_keys, &nrecords_lexicon,
            &file_size_lexicon, &inv_seg_size, &inv_chunk_size
        );

        if (rc != sen_success)
            croak("Failed to call sen_index_info: %d", rc);

lib/Senna.xs  view on Meta::CPAN

        SV *sv;
        STRLEN query_len = 0;
        sen_index   *index;
        sen_rc       rc;
        sen_records *r;
        sen_select_optarg *optarg = NULL;
        sen_sel_operator op = SvOK(op_sv) ? SvIV(op_sv) : 0;
        char *query = NULL;
        int need_optarg_free = 0;
        int need_records_free = 0;
    PPCODE:
        index = XS_STATE(sen_index *, self);

        if ( SvOK(query_sv) ) {
            query = SvPV(query_sv, query_len);
        }

        if (! SvOK(records)) {
            r = sen_records_open(sen_rec_document, sen_rec_none, 0);
            need_records_free = 1;
        } else {

lib/Senna.xs  view on Meta::CPAN

        RETVAL = sv;
    OUTPUT:
        RETVAL

void
SRecords_xs_next(self)
        SV *self;
    PREINIT:
        sen_records *r;
        sen_rc rc;
    PPCODE:
        r = XS_STATE(sen_records *, self);

        if (GIMME_V == G_SCALAR) {
            /* If we're being called in scalar context, then just return if
             * we have a next record or not
             */
            rc = sen_records_next(r, NULL, 0, NULL);
            XPUSHs(rc == 0 ? &PL_sv_no : &PL_sv_yes);
        } else {
            /* Otherwise, grab the next entry along with other metadata */

lib/Senna.xs  view on Meta::CPAN

void
SSet_info(self)
        SV *self;
    PREINIT:
        sen_rc rc;
        sen_set *set;
        unsigned int key_size;
        unsigned int value_size;
        unsigned int n_entries;
    PPCODE:
        set = XS_STATE(sen_set *, self);
        rc = sen_set_info(set, &key_size, &value_size, &n_entries);
        if (rc != sen_success)
            croak ("Failed to call sen_set_info: %d", rc);

        EXTEND(SP, 3);
        PUSHs(sv_2mortal(newSViv(key_size)));
        PUSHs(sv_2mortal(newSViv(value_size)));
        PUSHs(sv_2mortal(newSViv(n_entries)));

lib/Senna.xs  view on Meta::CPAN

        sen_perl_snip    *snip;
        unsigned int nresults;
        char        *result;
#if (SENNA_MAJOR_VERSION >= 1)
        unsigned int max_tagged_len;
#else
        size_t       max_tagged_len;
#endif
        int          i;
        sen_rc rc;
    PPCODE:
        snip = XS_STATE(sen_perl_snip *, self);
        sen_snip_exec(
            snip->snip,
            string,
#if (SENNA_MAJOR_VERSION >= 1)
            strlen(string),
#endif
            &nresults,
            &max_tagged_len
        );

lib/Senna.xs  view on Meta::CPAN

            PUSHs(sv_2mortal(newSVpv(result, 0)));
        }
        Safefree(result);

void
DESTROY(self)
        SV *self;
    PREINIT:
        sen_perl_snip *snip;
        int i;
    PPCODE:
        snip = XS_STATE(sen_perl_snip *, self);
        sen_snip_close(snip->snip);

        for(i = 0; i < snip->open_tags_size; i++) {
            Safefree(snip->open_tags[i]);
        }
        Safefree(snip->open_tags);

        for(i = 0; i < snip->close_tags_size; i++) {
            Safefree(snip->close_tags[i]);

lib/Senna.xs  view on Meta::CPAN

        RETVAL = (CV *) args[0];
    OUTPUT:
        RETVAL

void
SOSort_compar_arg(self)
        SV *self;
    PREINIT:
        sen_sort_optarg *optarg;
        void **args;
    PPCODE:
        optarg = XS_STATE(sen_sort_optarg *, self);
        /* The CV is always placed in the second element of ->func_arg */
        args = (void **) optarg->compar_arg;
        if (GIMME_V == G_SCALAR) {
            AV *av;
            if (args[1] == NULL)
                return;

            av = (AV *) args[1];
            EXTEND(SP, 1);

lib/Senna.xs  view on Meta::CPAN

        optarg = XS_STATE(sen_select_optarg *, self);
        RETVAL = optarg->max_interval;
    OUTPUT:
        RETVAL

void
SOSelect_weight_vector(self)
        SV *self;
    PREINIT:
        sen_select_optarg *optarg;
    PPCODE:
        optarg = XS_STATE(sen_select_optarg *, self);
        if (optarg->vector_size <= 0)
            return;

        if (GIMME_V == G_SCALAR) {
            AV *av = newAV();
            int i;

            EXTEND(SP, 1);
            av_extend(av, optarg->vector_size - 1);

lib/Senna.xs  view on Meta::CPAN

        RETVAL = (CV *) args[0];
    OUTPUT:
        RETVAL

void
SOSelect_func_arg(self)
        SV *self;
    PREINIT:
        sen_select_optarg *optarg;
        void **args;
    PPCODE:
        optarg = XS_STATE(sen_select_optarg *, self);
        /* The CV is always placed in the second element of ->func_arg */
        args = (void **) optarg->func_arg;
        if (GIMME_V == G_SCALAR) {
            AV *av;
            if (args[1] == NULL)
                return;

            av = (AV *) args[1];
            EXTEND(SP, 1);