view release on metacpan or  search on metacpan

XSBuilder/WrapXS.pm  view on Meta::CPAN

        my $retval = $return_type eq 'void' ?
          ["", ""] : ["RETVAL = ", "OUTPUT:\n    RETVAL\n"];

        my $retnum = $retdecl?scalar(@$retargs) + ($return_type eq 'void' ?0:1):0 ;
        $code .= $retdecl?"PPCODE:":"CODE:" ;
        $code .= "\n    $retval->[0]$dispatch($thx$parms);\n" ;
        if ($retdecl) {
            my $retclass = $self -> typemap -> map_class ($return_type) || $return_type ;
            if ($retclass =~ / /) 
                {

 view release on metacpan or  search on metacpan

lib/ExtUtils/XSpp/Node/Function.pm  view on Meta::CPAN

  }

  my $has_ret = $ret_typemap && !$ret_typemap->type->is_void;

  my $ppcode = $has_ret && $ret_typemap->output_list( '' ) ? 1 : 0;
  my $code_type = $ppcode ? "PPCODE" : "CODE";
  my $ccode = $this->_call_code( $call_arg_list );
  if ($this->{CALL_CODE}) {
    $ccode = join( "\n", @{$this->{CALL_CODE}} );
  } elsif ($this->isa('ExtUtils::XSpp::Node::Destructor')) {
    $ccode = 'delete THIS';

 view release on metacpan or  search on metacpan

FCGI.xs  view on Meta::CPAN

GetHandles(request)
    FCGI request;
  PROTOTYPE: $
  PREINIT:
    int i;
  PPCODE:
    EXTEND(sp,3);
    for (i = 0; i < 3; ++i)
        PUSHs(sv_2mortal(newRV((SV *) request->gv[i])));

int

 view release on metacpan or  search on metacpan

xs/Buffer.xs  view on Meta::CPAN

  PROTOTYPE: $$;$
  PREINIT:
    int clear = 1;
    int set_length = 1;

  PPCODE:
    if (SvROK (sv))
        croak("buffer argument must be a scalar");

   if ( items > 2 ) {

 view release on metacpan or  search on metacpan

Feersum.xs  view on Meta::CPAN

PROTOTYPES: ENABLE

void
set_server_name_and_port(SV *self, SV *name, SV *port)
    PPCODE:
{
    if (feer_server_name)
        SvREFCNT_dec(feer_server_name);
    feer_server_name = newSVsv(name);
    SvREADONLY_on(feer_server_name);

Feersum.xs  view on Meta::CPAN

    SvREADONLY_on(feer_server_port);
}

void
accept_on_fd(SV *self, int fd)
    PPCODE:
{
    struct sockaddr_storage addr;
    socklen_t addr_len = sizeof(addr);

    if (getsockname(fd, (struct sockaddr*)&addr, &addr_len) == -1) perror("getsockname");

Feersum.xs  view on Meta::CPAN

    ev_io_init(&accept_w, accept_cb, fd, EV_READ);
}

void
unlisten (SV *self)
    PPCODE:
{
    trace("stopping accept\n");
    ev_prepare_stop(feersum_ev_loop, &ep);
    ev_check_stop(feersum_ev_loop, &ec);
    ev_idle_stop(feersum_ev_loop, &ei);

Feersum.xs  view on Meta::CPAN

void
request_handler(SV *self, SV *cb)
    PROTOTYPE: $&
    ALIAS:
        psgi_request_handler = 1
    PPCODE:
{
    if (unlikely(!SvOK(cb) || !SvROK(cb)))
        croak("can't supply an undef handler");
    if (request_cb_cv)
        SvREFCNT_dec(request_cb_cv);

Feersum.xs  view on Meta::CPAN

}

void
graceful_shutdown (SV *self, SV *cb)
    PROTOTYPE: $&
    PPCODE:
{
    if (!IsCodeRef(cb))
        croak("must supply a code reference");
    if (unlikely(shutting_down))
        croak("already shutting down");

Feersum.xs  view on Meta::CPAN

    OUTPUT:
        RETVAL

void
set_keepalive (SV *self, SV *set)
    PPCODE:
{
    trace("set keepalive %d\n", SvTRUE(set));
    is_keepalive = SvTRUE(set);
}

Feersum.xs  view on Meta::CPAN

    OUTPUT:
        RETVAL

void
DESTROY (SV *self)
    PPCODE:
{
    trace3("DESTROY server\n");
    if (request_cb_cv)
        SvREFCNT_dec(request_cb_cv);
}

Feersum.xs  view on Meta::CPAN

void
DESTROY (SV *self)
    ALIAS:
        Feersum::Connection::Reader::DESTROY = 1
        Feersum::Connection::Writer::DESTROY = 2
    PPCODE:
{
    feer_conn_handle *hdl = sv_2feer_conn_handle(self, 0);

    if (hdl == NULL) {
        trace3("DESTROY handle (closed) class=%s\n",

Feersum.xs  view on Meta::CPAN

}

SV*
read (feer_conn_handle *hdl, SV *buf, size_t len, ...)
    PROTOTYPE: $$$;$
    PPCODE:
{
    STRLEN buf_len = 0, src_len = 0;
    ssize_t offset;
    char *buf_ptr, *src_ptr;

Feersum.xs  view on Meta::CPAN

        RETVAL

void
write_array (feer_conn_handle *hdl, AV *abody)
    PROTOTYPE: $$
    PPCODE:
{
    if (unlikely(c->responding != RESPOND_STREAMING))
        croak("can only call write in streaming mode");

    trace("write_array fd=%d c=%p, abody=%p\n", c->fd, c, abody);

Feersum.xs  view on Meta::CPAN

_poll_cb (feer_conn_handle *hdl, SV *cb)
    PROTOTYPE: $$
    ALIAS:
        Feersum::Connection::Reader::poll_cb = 1
        Feersum::Connection::Writer::poll_cb = 2
    PPCODE:
{
    if (unlikely(ix < 1 || ix > 2))
        croak("can't call _poll_cb directly");
    else if (unlikely(ix == 1))
        croak("poll_cb for reading not yet supported"); // TODO poll_read_cb

Feersum.xs  view on Meta::CPAN

void
force_http10 (struct feer_conn *c)
    PROTOTYPE: $
    ALIAS:
        force_http11 = 1
    PPCODE:
        c->is_http11 = ix;

SV *
env (struct feer_conn *c)
    PROTOTYPE: $

Feersum.xs  view on Meta::CPAN

    OUTPUT:
        RETVAL

void
DESTROY (struct feer_conn *c)
    PPCODE:
{
    int i;
    trace("DESTROY connection fd=%d c=%p\n", c->fd, c);

    if (likely(c->rbuf)) SvREFCNT_dec(c->rbuf);

 view release on metacpan or  search on metacpan

BSDGlob.xs  view on Meta::CPAN

  glob_t pglob;
  int i;
  int retval;
  int flags = 0;
  SV *tmp;
  PPCODE:
  /* allow for optional flags argument */
  if (items > 1) {
    flags = (int) SvIV(ST(1));
  }

 view release on metacpan or  search on metacpan

lib/File/Copy/clonefile.xs  view on Meta::CPAN

PROTOTYPES: DISABLE

void
clonefile(...)
PPCODE:
{
  if (items != 2 && items != 3) {
    croak("clonefile: the length of arguments must be 2 or 3");
  }
  const char* src = SvPV_nolen(ST(0));

 view release on metacpan or  search on metacpan

ExtAttr.xs  view on Meta::CPAN

    PREINIT:
        ssize_t size, ret;
        char *namebuf = NULL;
        char *nameptr;

    PPCODE:
        if(fd == -1)
            size = portable_listxattr(path, NULL, 0, flags);
        else
            size = portable_flistxattr(fd, NULL, 0, flags);

ExtAttr.xs  view on Meta::CPAN

    PREINIT:
        ssize_t size, ret;
        char *namebuf = NULL;
        char *nameptr;

    PPCODE:
        if(fd == -1)
            size = portable_listxattrns(path, NULL, 0, flags);
        else
            size = portable_flistxattrns(fd, NULL, 0, flags);

 view release on metacpan or  search on metacpan

Extractor.xs  view on Meta::CPAN

void
EXTRACTOR_getDefaultLibraries (class)
	PREINIT:
		const char *libraries;
		char *copy, *pos, *token;
	PPCODE:
		libraries = EXTRACTOR_getDefaultLibraries ();

		if (!libraries) {
			XSRETURN_EMPTY;
		}

Extractor.xs  view on Meta::CPAN

		SV *data
	PREINIT:
		STRLEN len;
		char *buf;
		EXTRACTOR_KeywordList *list, *i;
	PPCODE:
		if (SvROK (data) && (SvTYPE (SvRV (data)) == SVt_PVGV)) {
			buf = perl_extractor_slurp_from_handle (data, &len);
		}
		else {
			buf = SvPVbyte (data, len);

 view release on metacpan or  search on metacpan

LibMagic.xs  view on Meta::CPAN

        const char *mime;
        const char *encoding;
        SV *d;
        SV *m;
        SV *e;
    PPCODE:
        if (SvROK(buffer)) {
            content = SvRV(buffer);
        }
        else {
            content = buffer;

LibMagic.xs  view on Meta::CPAN

        const char *mime;
        const char *encoding;
        SV *d;
        SV *m;
        SV *e;
    PPCODE:
        if ( ! SvPOK(filename) ) {
            croak("info_from_filename requires a scalar as its argument");
        }

        file = SvPV_nolen(filename);

LibMagic.xs  view on Meta::CPAN

        const char *mime;
        const char *encoding;
        SV *d;
        SV *m;
        SV *e;
    PPCODE:
        if ( ! SvOK(handle) ) {
            croak("info_from_handle requires a scalar filehandle as its argument");
        }

        io = IoIFP(sv_2io(handle));

 view release on metacpan or  search on metacpan

Locate.xs  view on Meta::CPAN

	regex_t *preg = NULL;
	char errbuf[1024];
	regmatch_t pmatch[32];
        STRLEN n_a;
	register int i;
    PPCODE:
    
	for (i = 1; i < items; i++) {
            if (SvROK(ST(i)) && SvTYPE((SV*)SvRV(ST(i))) == SVt_PVCV) {
                coderef = newSVsv(ST(i));
            }

Locate.xs  view on Meta::CPAN

        boolean prev_fast_match = false;    /* true if we found a fast match
                                               (of patend) on the previous
                                               path.  */
	register int i;
    PPCODE:
    {
	for (i = 1; i < items; i++) {
            if (SvROK(ST(i)) && SvTYPE((SV*)SvRV(ST(i))) == SVt_PVCV) {
                coderef = newSVsv(ST(i));
            }

 view release on metacpan or  search on metacpan

Lock.xs  view on Meta::CPAN

	FILE *	file
	mode_int	mode
	int		offset
	int		whence
	int		length
	PPCODE:
	{
#	ifdef FDEBUG
		fprintf(stderr,"Entering fcntl(%d,%s,%d,%d,%d)\n",fileno(file),mode_name[mode],offset,whence,length);
#	endif		
#	if defined(HAS_FCNTL)

Lock.xs  view on Meta::CPAN

void
flock(file, mode=Lock_exclusive|Lock_nonblock)
	FILE *	file
	mode_int		mode
	PPCODE:
	{
#	ifdef FDEBUG
		fprintf(stderr,"Entering flock(%d,%s)\n",fileno(file),mode_name[mode]);
#	endif		
#	if defined(HAS_FLOCK)

Lock.xs  view on Meta::CPAN

	FILE *	file
	mode_int	mode
	int		offset
	int		whence
	int		length
	PPCODE:
	{
#	ifdef FDEBUG
		fprintf(stderr,"Entering lockf(%d,%s,%d,%d,%d)\n",fileno(file),mode_name[mode],offset,whence,length);
#	endif		
#	if defined(HAS_LOCKF)

Lock.xs  view on Meta::CPAN

	RETVAL

void
_mode(mode)
	mode_int	mode
	PPCODE:
	{
		ReturnResult(mode & Lock_modemask,Lock_test);
	}
	

Lock.xs  view on Meta::CPAN

	FILE *	file
	mode_int	mode
	int		offset
	int		whence
	int		length
	PPCODE:
	{
#	ifdef FDEBUG
		fprintf(stderr,"Entering new File::Lock(%d,%s,%d,%d,%d)\n",fileno(file),mode_name[mode],offset,whence,length);
#	endif		
	if(((mode & Lock_modemask)== Lock_test) || ((mode & Lock_modemask)==Lock_unlock)) {

 view release on metacpan or  search on metacpan

JSON.xs  view on Meta::CPAN

void
import(...)
PREINIT:
    const char *pkg;
    I32 i;
PPCODE:
    pkg = CopSTASHPV(PL_curcop);
    if (items <= 1) XSRETURN_EMPTY;

    for (i = 1; i < items; i++) {
        STRLEN len;

JSON.xs  view on Meta::CPAN

PROTOTYPES: DISABLE

void
TRUE(...)
    PPCODE:
        PERL_UNUSED_VAR(items);
        if (!g_frj_true_sv) init_boolean_singletons(aTHX);
        SvREFCNT_inc_simple_void(g_frj_true_sv);
        XPUSHs(sv_2mortal(g_frj_true_sv));
        XSRETURN(1);

void
FALSE(...)
    PPCODE:
        PERL_UNUSED_VAR(items);
        if (!g_frj_false_sv) init_boolean_singletons(aTHX);
        SvREFCNT_inc_simple_void(g_frj_false_sv);
        XPUSHs(sv_2mortal(g_frj_false_sv));
        XSRETURN(1);

 view release on metacpan or  search on metacpan

Separated.xs  view on Meta::CPAN

void
parse_buf_each(input, code, opts = NULL)
        SV *input
        SV *code
        SV *opts
    PPCODE:
        do_parse_buf_each(aTHX_ "parse_buf_each", input, code, opts, DIALECT_AUTO);
        XSRETURN_EMPTY;

void
csv_parse_buf_each(input, code, opts = NULL)
        SV *input
        SV *code
        SV *opts
    PPCODE:
        do_parse_buf_each(aTHX_ "csv_parse_buf_each", input, code, opts, DIALECT_CSV);
        XSRETURN_EMPTY;

void
tsv_parse_buf_each(input, code, opts = NULL)
        SV *input
        SV *code
        SV *opts
    PPCODE:
        do_parse_buf_each(aTHX_ "tsv_parse_buf_each", input, code, opts, DIALECT_TSV);
        XSRETURN_EMPTY;


void
parse_stream(path, code, opts = NULL)
        SV *path
        SV *code
        SV *opts
    PPCODE:
        do_parse_stream(aTHX_ "parse_stream", path, code, opts, DIALECT_AUTO);
        XSRETURN_EMPTY;

void
csv_parse_stream(path, code, opts = NULL)
        SV *path
        SV *code
        SV *opts
    PPCODE:
        do_parse_stream(aTHX_ "csv_parse_stream", path, code, opts, DIALECT_CSV);
        XSRETURN_EMPTY;

void
tsv_parse_stream(path, code, opts = NULL)
        SV *path
        SV *code
        SV *opts
    PPCODE:
        do_parse_stream(aTHX_ "tsv_parse_stream", path, code, opts, DIALECT_TSV);
        XSRETURN_EMPTY;

 view release on metacpan or  search on metacpan

stat2.xs  view on Meta::CPAN

_stat2 (path)
      const char * path
    INIT:
      struct stat st;
      char ino[128];
    PPCODE:
      if (stat (path, &st) == 0)
        {
          sprintf (ino, "%llu", (unsigned long long)st.st_ino);
          XPUSHs (sv_2mortal (newSViv (st.st_dev    )));
          XPUSHs (sv_2mortal (newSVpv (ino       , 0)));

 view release on metacpan or  search on metacpan

XS_statfs  view on Meta::CPAN

void
_df(dir)
	char *dir
	PREINIT:
	Statfs st;
	PPCODE:
	EXTEND(sp, 7);
#ifdef DF_SOLARIS
	if(statfs(dir, &st, 0, 0) == 0) {
#else
	if(statfs(dir, &st) == 0) {

XS_statfs  view on Meta::CPAN

void
_df_fh(fd)
	int fd
	PREINIT:
	Statfs st;
	PPCODE:
	EXTEND(sp, 7);
#ifdef DF_SOLARIS
	if(fstatfs(fd, &st, 0, 0) == 0) {
#else
	if(fstatfs(fd, &st) == 0) {

 view release on metacpan or  search on metacpan

XS_statfs  view on Meta::CPAN

void
_dfportable(dir)
	char *dir
	PREINIT:
	Statfs st;
	PPCODE:
	EXTEND(sp, 7);
#ifdef DFPORTABLE_SOLARIS
	if(statfs(dir, &st, 0, 0) == 0) {
#else
	if(statfs(dir, &st) == 0) {

 view release on metacpan or  search on metacpan

Fuse3.xs  view on Meta::CPAN

	OUTPUT:
	RETVAL

void
fuse_version()
	PPCODE:
	int gimme = GIMME_V;
	if (gimme == G_SCALAR)
		XPUSHs(sv_2mortal(newSVpvf("%d.%d", FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION)));
	else if (gimme == G_ARRAY) {
#ifdef FUSE_FOUND_MICRO_VER

 view release on metacpan or  search on metacpan

SamFS.xs  view on Meta::CPAN

	char *path
PREINIT:
	struct sam_stat statbuf;
	int retval;
	int i;
PPCODE:
	retval = sam_stat(path, &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, 22+MAX_ARCHIVE);
 /*  0 */	PUSHs(sv_2mortal(newSViv(statbuf.st_dev)));
 /*  1 */	PUSHs(sv_2mortal(newSViv(statbuf.st_ino)));

SamFS.xs  view on Meta::CPAN

	char *path
PREINIT:
	struct sam_stat statbuf;
	int retval;
	int i;
PPCODE:
	retval = sam_lstat(path, &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, 22+MAX_ARCHIVE);
 /*  0 */	PUSHs(sv_2mortal(newSViv(statbuf.st_dev)));
 /*  1 */	PUSHs(sv_2mortal(newSViv(statbuf.st_ino)));

SamFS.xs  view on Meta::CPAN

PREINIT:
	struct sam_stat statbuf;
	int retval;
	int i;
        AV *copies;
PPCODE:
	retval = sam_stat(path, &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, 29);
 /*  0 */	PUSHs(sv_2mortal(newSViv(statbuf.st_dev)));
 /*  1 */	PUSHs(sv_2mortal(newSViv(statbuf.st_ino)));

SamFS.xs  view on Meta::CPAN

PREINIT:
	struct sam_stat statbuf;
	int retval;
	int i;
        AV *copies;
PPCODE:
	retval = sam_lstat(path, &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, 29);
 /*  0 */	PUSHs(sv_2mortal(newSViv(statbuf.st_dev)));
 /*  1 */	PUSHs(sv_2mortal(newSViv(statbuf.st_ino)));

SamFS.xs  view on Meta::CPAN

#define CAST
#endif
	struct sam_vsn_stat statbuf;
	int retval;
	int i;
PPCODE:
	retval = sam_vsn_stat(path, copy, CAST &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, MAX_VSNS);
		for (i=0; i<MAX_VSNS; i++) {
			AV *av = newAV();

SamFS.xs  view on Meta::CPAN

	int	copy
PREINIT:
	struct sam_section statbuf;
	int retval;
	int i;
PPCODE:
	retval = sam_vsn_stat(path, copy, &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, 1);
		AV *av = newAV();
		av_extend(av, 4);

SamFS.xs  view on Meta::CPAN

	int			segment_index
PREINIT:
	struct sam_section statbuf;
	int retval;
	int i;
PPCODE:
	retval = sam_segment_vsn_stat(path, copy, segment_index, &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, 1);
		AV *av = newAV();
		av_extend(av, 4);

SamFS.xs  view on Meta::CPAN

	struct sam_stat file_info;
	struct sam_stat *data_seg_info_ptr;
	int number_of_data_segments;
	int retval;
	int i;
PPCODE:
	retval = sam_stat(path, &file_info, sizeof file_info);
	if (retval == 0) {
		if (SS_ISSEGMENT_F(file_info.attr)) {
	                number_of_data_segments = NUM_SEGS(&file_info);
                        Newxz(data_seg_info_ptr, number_of_data_segments,

SamFS.xs  view on Meta::CPAN

	struct sam_stat file_info;
	struct sam_stat *data_seg_info_ptr;
	int number_of_data_segments;
	int retval;
	int i;
PPCODE:
	retval = sam_lstat(path, &file_info, sizeof file_info);
	if (retval == 0) {
		if (SS_ISSEGMENT_F(file_info.attr)) {
	                number_of_data_segments = NUM_SEGS(&file_info);
                        Newxz(data_seg_info_ptr, number_of_data_segments,

SamFS.xs  view on Meta::CPAN

sam_devstat(eq)
	int	eq
PREINIT:
	struct sam_devstat statbuf;
	int retval;
PPCODE:
	retval = sam_devstat(eq, &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, 7);
/* 0 */		PUSHs(sv_2mortal(newSViv(statbuf.type)));
/* 1 */		PUSHs(sv_2mortal(newSVpv(statbuf.name, 0)));

SamFS.xs  view on Meta::CPAN

sam_ndevstat(eq)
	int	eq
PREINIT:
	struct sam_ndevstat statbuf;
	int retval;
PPCODE:
	retval = sam_ndevstat(eq, &statbuf, sizeof statbuf);
	if (retval == 0) {
		EXTEND(SP, 7);
/* 0 */		PUSHs(sv_2mortal(newSViv(statbuf.type)));
/* 1 */		PUSHs(sv_2mortal(newSVpv(statbuf.name, 0)));

SamFS.xs  view on Meta::CPAN

sam_opencat(path)
	char *	path
PREINIT:
	struct sam_cat_tbl catbuf;
	int retval;
PPCODE:
	retval = sam_opencat(path, &catbuf, sizeof catbuf);
	if (retval >= 0) {
		EXTEND(SP, 4);
/* 0 */		PUSHs(sv_2mortal(newSViv(retval)));
/* 1 */		PUSHs(sv_2mortal(newSViv(catbuf.audit_time)));

SamFS.xs  view on Meta::CPAN

	int	cat_handle
	int	slot
PREINIT:
	struct sam_cat_ent	catbuf;
	int retval;
PPCODE:
	retval = sam_getcatalog(cat_handle, slot, slot, &catbuf, sizeof catbuf);
	if (retval >= 0) {
		EXTEND(SP, 11);
/* 0 */		PUSHs(sv_2mortal(newSViv(catbuf.type)));
/* 1 */		PUSHs(sv_2mortal(newSViv(catbuf.status)));

 view release on metacpan or  search on metacpan

SmbClient.xs  view on Meta::CPAN

/* 
 * Read file descriptor for directory fd and return file type, name and comment
 *
 */
  struct smbc_dirent * dirp;
PPCODE:
#ifdef VERBOSE
  fprintf(stderr, "! Filesys::SmbClient : _readdir: %d\n", fd); 
#endif
// Fix for rt#12221 : macro "readdir" passed 2 arguments, but takes just 1
// Seems only work on linux, not solaris

SmbClient.xs  view on Meta::CPAN

 * _stat(fname) : Get information about a file or directory.
 *
 */
  int i;
  struct stat buf;
PPCODE:
  i = context->stat(context, fname, &buf);
  if (i == 0) {
    XPUSHs(sv_2mortal(newSVnv(buf.st_dev)));
    XPUSHs(sv_2mortal(newSVnv(buf.st_ino)));
    XPUSHs(sv_2mortal(newSVnv(buf.st_mode)));

SmbClient.xs  view on Meta::CPAN

 * Get information about a file or directory via a file descriptor.
 *
 */
  int i;
  struct stat buf;
PPCODE:
i = context->fstat(context, fd, &buf);
if (i == 0) {
  XPUSHs(sv_2mortal(newSVnv(buf.st_dev)));
  XPUSHs(sv_2mortal(newSVnv(buf.st_ino)));
  XPUSHs(sv_2mortal(newSVnv(buf.st_mode)));

 view release on metacpan or  search on metacpan

Statvfs.xs  view on Meta::CPAN

void
statvfs(dir)
	char *dir
	PREINIT:
	Statvfs st;
	PPCODE:
	EXTEND(sp, 10);
	if(statvfs(dir, &st) == 0) {
		/* Push values as doubles because we don't know size */
		PUSHs(sv_2mortal(newSVnv((double)st.f_bsize)));
		PUSHs(sv_2mortal(newSVnv((double)st.f_frsize)));

Statvfs.xs  view on Meta::CPAN

void
fstatvfs(fd)
	int fd;
	PREINIT:
	Statvfs st;
	PPCODE:
	EXTEND(sp, 10);
	if(fstatvfs(fd, &st) == 0) {
		/* Push values as doubles because we don't know size */
		PUSHs(sv_2mortal(newSVnv((double)st.f_bsize)));
		PUSHs(sv_2mortal(newSVnv((double)st.f_frsize)));

 view release on metacpan or  search on metacpan

CryptFile/CryptFile.xs  view on Meta::CPAN

void
_debug_mode();
    PROTOTYPE: 

    PPCODE:
    {
#ifdef FILTER_CRYPTO_DEBUG_MODE
    XSRETURN_YES;
#else
    XSRETURN_EMPTY;

CryptFile/CryptFile.xs  view on Meta::CPAN

    INPUT:
        InOutStream fh;
        FILTER_CRYPTO_MODE_EX crypt_mode_ex
        SV* num_bytes

    PPCODE:
    {
        if (FilterCrypto_CryptFh(aTHX_ fh, (PerlIO *)NULL, crypt_mode_ex,
                num_bytes))
            XSRETURN_YES;
        else

CryptFile/CryptFile.xs  view on Meta::CPAN

        InputStream in_fh;
        OutputStream out_fh;
        FILTER_CRYPTO_MODE_EX crypt_mode_ex;
        SV* num_bytes;

    PPCODE:
    {
        if (FilterCrypto_CryptFh(aTHX_ in_fh, out_fh, crypt_mode_ex, num_bytes))
            XSRETURN_YES;
        else
            XSRETURN_EMPTY;

 view release on metacpan or  search on metacpan

Rijndael.xs  view on Meta::CPAN

void
import(module)
    SV *	module
    PPCODE:
    {

        SV * sv = newSV(BLOCKSIZE) ;

	/* make sure the Perl debugger isn't enabled */

Rijndael.xs  view on Meta::CPAN

    }

void
unimport(...)
    PPCODE:
    /* filter_del(filter_decrypt); */

 view release on metacpan or  search on metacpan

Call/Call.xs  view on Meta::CPAN

void
real_import(object, perlmodule, coderef)
    SV *	object
    char *	perlmodule 
    IV		coderef
    PPCODE:
    {
        SV * sv = newSV(1) ;

        (void)SvPOK_only(sv) ;
        filter_add(filter_call, sv) ;

Call/Call.xs  view on Meta::CPAN

void
unimport(package="$Package", ...)
    const char *package
    PPCODE:
    PERL_UNUSED_VAR(package);
    filter_del(filter_call);


BOOT:

 view release on metacpan or  search on metacpan

FreeType.xs  view on Meta::CPAN

void
qefft2_import (const char *target_pkg)
    PREINIT:
        HV *stash;
        size_t i;
    PPCODE:
        stash = gv_stashpv(target_pkg, 0);
        if (!stash)
            croak("the package I'm importing into doesn't seem to exist");
        for (i = 0; i < sizeof(qefft2_uv_const) / sizeof(QefFT2_Uv_Const); ++i) {
            const char* name = qefft2_uv_const[i].name;

FreeType.xs  view on Meta::CPAN

void
qefft2_library_version (Font_FreeType library)
    PREINIT:
        FT_Int major, minor, patch;
    PPCODE:
        major = minor = patch = -1;
        FT_Library_Version(library, &major, &minor, &patch);
        assert(major != -1);
        assert(minor != -1);
        assert(patch != -1);

FreeType.xs  view on Meta::CPAN

    PREINIT:
        int i;
        FT_Bitmap_Size *size;
        HV *hash;
        double pt = 0.0, ppem;
    PPCODE:
        if (GIMME_V != G_ARRAY) {
            PUSHs(sv_2mortal(newSViv((int) face->num_fixed_sizes)));
        }
        else {
            EXTEND(SP, face->num_fixed_sizes);

FreeType.xs  view on Meta::CPAN

void
qefft2_face_kerning (Font_FreeType_Face face, FT_UInt left_glyph_idx, FT_UInt right_glyph_idx, UV kern_mode = FT_KERNING_DEFAULT)
    PREINIT:
        FT_Vector kerning;
    PPCODE:
        errchk(FT_Get_Kerning(face, left_glyph_idx, right_glyph_idx, kern_mode,
                              &kerning),
               "getting kerning from freetype face");
        if (GIMME_V != G_ARRAY) {
            PUSHs(sv_2mortal(newSVnv((double) kerning.x / 64.0)));

FreeType.xs  view on Meta::CPAN

    PREINIT:
        FT_Face face;
        QefFT2_Face_Extra *extra;
        FT_OutlineGlyph outline_glyph;
        FT_BBox bbox;
    PPCODE:
        face = (FT_Face) SvIV(glyph->face_sv);
        if (!ensure_outline_loaded(face, glyph))
            croak("glyph %lu does not have an outline",
                  (unsigned long) glyph->char_code);
        extra = face->generic.data;

FreeType.xs  view on Meta::CPAN

        unsigned char *buf;
        int i, j;
        int bits = 0;
        AV *rows;
        unsigned char *row_buf;
    PPCODE:
        face = (FT_Face) SvIV(glyph->face_sv);
        /* XXX: For some reason I can't work out how to load the bitmap and
         * then load the outline later, but it works the other way round.
         * To ensure that a glyph object can be used for both, in either order,
         * I load the outline first even if it's not needed.  There's probably

 view release on metacpan or  search on metacpan

bundle/Sys-CpuLoadX/contrib/CpuLoad.xs  view on Meta::CPAN

void
xs_getbsdload()
    PREINIT:
        double loadavg[3];
    PPCODE:
#if defined(__FreeBSD__) || defined(__OpenBSD__)
        getloadavg(loadavg, 3);
#endif
        EXTEND(SP, 3);
        PUSHs(sv_2mortal(newSVnv(loadavg[0])));

 view release on metacpan or  search on metacpan

OpenGL/OpenGL.xs  view on Meta::CPAN

	RETVAL

void
glpXNextEvent(d=dpy)
	void *	d
	PPCODE:
	{
		XEvent event;
		char buf[10];
		KeySym ks;
		XNextEvent(d,&event);

OpenGL/OpenGL.xs  view on Meta::CPAN

void
glpXQueryPointer(d=dpy,w=win)
	void *	d
	GLXDrawable	w
	PPCODE:
	{
		int x,y,rx,ry;
		Window r,c;
		unsigned int m;
		XQueryPointer(d,w,&r,&c,&rx,&ry,&x,&y,&m);

OpenGL/OpenGL.xs  view on Meta::CPAN

	}

void
glpGetClipPlane(plane)
	GLenum	plane
	PPCODE:
	{
	    GLdouble equation[4];
	    glGetClipPlane(plane,equation);
	    EXTEND(sp,4);
	    PUSHs(sv_2mortal(newSVnv(equation[0])));

 view release on metacpan or  search on metacpan

Fuse.xs  view on Meta::CPAN

	OUTPUT:
	RETVAL

void
fuse_version()
	PPCODE:
	int gimme = GIMME_V;
	if (gimme == G_SCALAR)
		XPUSHs(sv_2mortal(newSVpvf("%d.%d", FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION)));
	else if (gimme == G_ARRAY) {
#ifdef FUSE_FOUND_MICRO_VER

 view release on metacpan or  search on metacpan

lib/Future/XS.xs  view on Meta::CPAN

void
result(SV *self)
  ALIAS:
    result = FALSE
    get    = TRUE
  PPCODE:
    CHECK_INSTANCE(self);
    /* This PUTBACK + SPAGAIN pair is required in case future_get_result_av()
     * causes the arguments stack to be reällocated. It works fine on perls
     * 5.24+ but causes older perls to crash. For now we just depend on 5.24
     *   https://rt.cpan.org/Ticket/Display.html?id=145597

lib/Future/XS.xs  view on Meta::CPAN

  OUTPUT:
    RETVAL

void
failure(SV *self)
  PPCODE:
    CHECK_INSTANCE(self);
    PUTBACK;
    AV *failure = future_get_failure_av(self);
    SPAGAIN;
    if(!failure)

lib/Future/XS.xs  view on Meta::CPAN

    pending_futures   = FUTURE_SUBS_PENDING
    ready_futures     = FUTURE_SUBS_READY
    done_futures      = FUTURE_SUBS_DONE
    failed_futures    = FUTURE_SUBS_FAILED
    cancelled_futures = FUTURE_SUBS_CANCELLED
  PPCODE:
    CHECK_INSTANCE(self);
    PUTBACK;
    Size_t count = future_mPUSH_subs(self, ix);
    SPAGAIN;
    XSRETURN(count);

 view release on metacpan or  search on metacpan

lib/Bio/Graphics/Browser2/CAlign.xs  view on Meta::CPAN

     HV*           optionh;
     SV            **value;
     int           score,i;
     AlignmentPtr  alignment;
     AV*           palign;
     PPCODE:
     {
       /* copy defaults from standardMatrix */
       initMatrix(&matrix);

       if (options != NULL) {