PPCODE results from the CPAN

LSF-Batch

view release on metacpan or search on metacpan


void
lsb_hostinfo(self, hosts)
	void *self
	char **hosts
    PREINIT:
	SV *rv;
	char **h;
	int i, count = 0, num = 0;
	LSF_Batch_hostInfo *p, *hinfo;
    PPCODE:
	for( h = hosts; hosts && *h; h++ )count++;
	num = count;
	if( count == 0 ) hosts = NULL;
	hinfo = lsb_hostinfo(hosts, &num);
	if(hinfo == NULL){
	    STATUS_NATIVE_SET(lsberrno);
	    SET_LSB_ERRMSG;
	    XSRETURN_EMPTY;
 	}
	for( i = 0, p = hinfo; i < num; i++,p++ ){

Batch.xs view on Meta::CPAN

lsb_hostinfo_ex(self, hosts, resreq, options)
	void *self
	char **hosts
	char *resreq
	int options
    PREINIT:
	SV *rv;
	char **h;
	int i, count = 0, num;
	LSF_Batch_hostInfo *p, *hinfo;
    PPCODE:
	for( h = hosts; hosts && *h; h++ )count++;
	num = count;
	if( count == 0 ) hosts = NULL;
        if(strlen(resreq)==0) resreq = NULL;
	hinfo = lsb_hostinfo_ex(hosts, &num, resreq, options);
	if(hinfo == NULL){
	    STATUS_NATIVE_SET(lsberrno);
    SET_LSB_ERRMSG;
	    XSRETURN_EMPTY;
 	}

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = *(self->busyStop);
    OUTPUT:
	RETVAL

void
hi_load(self)
	LSF_Batch_hostInfo *self;
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVnv(self->load[i])));	
	XSRETURN(self->nIdx);

void
hi_loadSched(self)
	LSF_Batch_hostInfo *self;
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVnv(self->loadSched[i])));	
	XSRETURN(self->nIdx);

void
hi_loadStop(self)
	LSF_Batch_hostInfo *self;
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVnv(self->loadStop[i])));
	XSRETURN(self->nIdx);


char *
hi_windows(self)
	LSF_Batch_hostInfo *self;
    CODE:
	RETVAL = self->windows;

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->attr;
    OUTPUT:
	RETVAL

void
hi_realLoad(self)
	LSF_Batch_hostInfo *self;
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVnv(self->realLoad[i])));	
	XSRETURN(self->nIdx);

int
hi_chkSig(self)
	LSF_Batch_hostInfo *self;
    CODE:
	RETVAL = self->chkSig;
    OUTPUT:

Batch.xs view on Meta::CPAN


void
lsb_usergrpinfo(self, groups, options)
	void *self
	char **groups
	int options
    PREINIT:
	char **g;
	int i, count = 0, num;
	struct groupInfoEnt *p, *gi;
    PPCODE:
	for( g = groups; groups && *g; g++ )count++;
	num = count;
	if( count == 0 ) groups = NULL;
	gi = lsb_usergrpinfo(groups, &num, options);
	if(gi == NULL){
	    STATUS_NATIVE_SET(lsberrno);
	    if(lsberrno == LSBE_BAD_GROUP){
	      char e[100];
              sprintf(e,"group %s is unknown to LSF", (*groups)[num]);
	      SET_LSB_ERRMSG_TO(e);

Batch.xs view on Meta::CPAN


void
lsb_hostgrpinfo(self, groups, options)
	void *self
	char **groups
	int options
    PREINIT:
	char **g;
	int i, count = 0, num;
	struct groupInfoEnt *p, *gi;
    PPCODE:
	for( g = groups; groups && *g; g++ )count++;
	num = count;
	if( count == 0 ) groups = NULL;
	gi = lsb_hostgrpinfo(groups, &num, options);
	if(gi == NULL){
	    STATUS_NATIVE_SET(lsberrno);
	    if(lsberrno == LSBE_BAD_GROUP){
	      char e[100];
              sprintf(e,"group %s is unknown to LSF", (*groups)[num]);
	      SET_LSB_ERRMSG_TO(e);

Batch.xs view on Meta::CPAN


void
lsb_userinfo(self, users)
	void *self
	char **users
    PREINIT:
	SV *rv;	
	int i, count=0, num;
	LSF_Batch_userInfo *ui, *p;
	char **c;
    PPCODE:
	for( c = users; users && *c; c++ ) count++;
	num = count;
	if( count == 0 ) users = NULL;
	ui = lsb_userinfo(users, &num );
	fflush(stdout);
	if(ui == NULL){
	    STATUS_NATIVE_SET(lsberrno);
	    SET_LSB_ERRMSG;
	    XSRETURN_EMPTY;
 	}

Batch.xs view on Meta::CPAN

	void *self
	char **queues
	char *host
	char *user
	int options
    PREINIT:
	SV *rv;
	char **q;
	int i, count = 0, num = 0;
	LSF_Batch_queueInfo *p, *qinfo;
    PPCODE:
	for( q = queues; queues && *q; q++ ) count++;
	num = count;
	if( count == 0 ) queues = NULL;
	if(strlen(host)==0) host = NULL;
	if(strlen(user)==0) user = NULL;
	qinfo = lsb_queueinfo(queues, &num, host, user, options);
	if(qinfo == NULL){
	    STATUS_NATIVE_SET(lsberrno);
	    SET_LSB_ERRMSG;
	    XSRETURN_EMPTY;

Batch.xs view on Meta::CPAN

	RETVAL = self->hostList;
    OUTPUT:
	RETVAL

void
qi_loadSched(self)
	LSF_Batch_queueInfo *self
    PREINIT:
	int i;
	float *f;
    PPCODE:
	for( i = 0; i < self->nIdx; i++){
          XPUSHs(sv_2mortal(newSVnv(self->loadSched[i])));	
        }
	XSRETURN(self->nIdx);


void
qi_loadStop(self)
	LSF_Batch_queueInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++){
          XPUSHs(sv_2mortal(newSVnv(self->loadSched[i])));
	}	
	XSRETURN(self->nIdx);


int
qi_userJobLimit(self)
	LSF_Batch_queueInfo *self
    CODE:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->windows;
    OUTPUT:
	RETVAL

void
qi_rLimits(self)
	LSF_Batch_queueInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < LSF_RLIM_NLIMITS; i++){
          XPUSHs(sv_2mortal(newSViv(self->rLimits[i])));	
        }
	XSRETURN(LSF_RLIM_NLIMITS);

void
qi_defLimits(self)
	LSF_Batch_queueInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < LSF_RLIM_NLIMITS; i++){
          XPUSHs(sv_2mortal(newSViv(self->defLimits[i])));	
        }
	XSRETURN(LSF_RLIM_NLIMITS);

char *
qi_hostSpec(self)
	LSF_Batch_queueInfo *self
    CODE:
	RETVAL = self->hostSpec;

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->terminateActCmd;
    OUTPUT:
	RETVAL

void
qi_sigMap(self)
	LSF_Batch_queueInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < LSB_SIG_NUM; i++){
          XPUSHs(sv_2mortal(newSViv(self->sigMap[i])));	
        }
	XSRETURN(LSB_SIG_NUM);

char *	
qi_preemption(self)
	LSF_Batch_queueInfo *self
    CODE:
	RETVAL = self->preemption;

Batch.xs view on Meta::CPAN

	RETVAL


void
qi_shareAccts(self)
	LSF_Batch_queueInfo *self
    PREINIT:
	SV *rv;
	LSF_Batch_shareAcctInfo *p;
	int i;
    PPCODE:
	for( i = 0, p = self->shareAccts; i < self->numOfSAccts; i++,p++ ){
	    rv = newRV_inc(&PL_sv_undef);
	    sv_setref_iv(rv, "LSF::Batch::shareAcctInfoPtr",(I32)p);
	    XPUSHs(sv_2mortal(rv));
	}
	XSRETURN(self->numOfSAccts);

int
qi_chunkJobSize(self)
	LSF_Batch_queueInfo *self

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->subreasons;
    OUTPUT:
	RETVAL

void
ji_reasonTb(self)
	LSF_Batch_jobInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numReasons; i++)
          XPUSHs(sv_2mortal(newSViv(self->reasonTb[i])));	
	XSRETURN(self->numReasons);

int
ji_jobPid(self)
	LSF_Batch_jobInfo *self
    CODE:
	RETVAL = self->jobPid;
    OUTPUT:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->cwd;
    OUTPUT:
	RETVAL

void
ji_exHosts(self)
	LSF_Batch_jobInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numExHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->exHosts[i],0)));	
	XSRETURN(self->numExHosts);

float
ji_cpuFactor(self)
	LSF_Batch_jobInfo *self
    CODE:
	RETVAL = self->cpuFactor;
    OUTPUT:
	RETVAL

void
ji_loadSched(self)
	LSF_Batch_jobInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVnv(self->loadSched[i])));	
	XSRETURN(self->numExHosts);

void
ji_loadStop(self)
	LSF_Batch_jobInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVnv(self->loadStop[i])));	
	XSRETURN(self->numExHosts);

LSF_Batch_submit *
ji_submit(self)
	LSF_Batch_jobInfo *self
    CODE:
	RETVAL = &self->submit;
    OUTPUT:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->jName;
    OUTPUT:
	RETVAL

void
ji_counter(self)
LSF_Batch_jobInfo *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVnv(self->loadStop[i])));	
	XSRETURN(self->numExHosts);

int
ji_jobPriority(self)
	LSF_Batch_jobInfo *self
    CODE:
	RETVAL = self->jobPriority;
    OUTPUT:

Batch.xs view on Meta::CPAN

    OUTPUT:
	RETVAL

void
ji_externalMsg(self)
LSF_Batch_jobInfo *self
    PREINIT:
	SV *rv;
        LSF_Batch_jobExternalMsgReply *p;
	int i;
    PPCODE:
	for( i = 0, p = self->externalMsg; i < self->numExternalMsg; i++,p++ ){
	    rv = newRV_inc(&PL_sv_undef);
	    sv_setref_iv(rv, "LSF::Batch::jobExternalMsgReplyPtr",(IV)p);
	    XPUSHs(sv_2mortal(rv));
	}
	XSRETURN(self->numExternalMsg);


MODULE = LSF::Batch	PACKAGE = LSF::Batch::submitPtr		PREFIX = sub_

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->queue;
    OUTPUT:
	RETVAL

void
sub_askedHosts(self)
	LSF_Batch_submit *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numAskedHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));	
	XSRETURN(self->numAskedHosts);

char *
sub_resReq(self)
	LSF_Batch_submit *self
    CODE:
	RETVAL = self->resReq;
    OUTPUT:
	RETVAL

void
sub_rLimits(self)
	LSF_Batch_submit *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < LSF_RLIM_NLIMITS; i++)
          XPUSHs(sv_2mortal(newSVnv(self->rLimits[i])));	
	XSRETURN(LSF_RLIM_NLIMITS);

char *
sub_hostSpec(self)
	LSF_Batch_submit *self
    CODE:
	RETVAL = self->hostSpec;
    OUTPUT:

Batch.xs view on Meta::CPAN

	RETVAL = self->chkpntDir;
    OUTPUT:
	RETVAL

void
sub_xf(self)
	LSF_Batch_submit *self
    PREINIT:
	int i;
        SV *rv;
    PPCODE:
	for( i = 0; i < self->nxf; i++){
 	  rv = newRV_inc(&PL_sv_undef);
	  sv_setref_iv(rv, "LSF::Batch::xFilePtr",(I32)(self->xf + i));
	  XPUSHs(sv_2mortal(rv));
        }
	XSRETURN(self->nxf);

char *
sub_preExecCmd(self)
	LSF_Batch_submit *self

Batch.xs view on Meta::CPAN

MODULE = LSF::Batch       PACKAGE = LSF::Batch::jobPtr  PREFIX = job_

void
job_new(type, jobId, arrayIdx)
	char *type
	int jobId
	int arrayIdx
    PREINIT:
	LSF_Batch_job *j;
        SV *rv;
    PPCODE:
        j = (LSF_Batch_job *)safemalloc(sizeof(LSF_Batch_job));
        if( j == NULL ){
	   XSRETURN_UNDEF;
	}
	j->jobId = jobId;
        j->arrayIdx = arrayIdx;
	rv = newRV_inc(&PL_sv_undef);
	sv_setref_iv(rv, type,(I32)j);
	XPUSHs(sv_2mortal(rv));
	XSRETURN(1);

Batch.xs view on Meta::CPAN

void
lsb_sharedresourceinfo(self, resources, hostName)
	void *self	
	char **resources
	char *hostName
    PREINIT:
	SV *rv;
	char **r;
	int i, count = 0, num;
	LSF_Batch_sharedResourceInfo *p, *si;
    PPCODE:
	for( r = resources; resources && *r; r++ ) count++;
	num = count;
	if( count == 0 ) resources = NULL;
	if(hostName && strlen(hostName)==0) hostName = NULL;
	si = lsb_sharedresourceinfo(resources, &num, hostName, 0);
	if(si == NULL){
	    STATUS_NATIVE_SET(lsberrno);
	    SET_LSB_ERRMSG;
	    XSRETURN_EMPTY;
 	}

Batch.xs view on Meta::CPAN

	RETVAL = self->resourceName;
    OUTPUT:
	RETVAL

void 
sri_instances(self)
	LSF_Batch_sharedResourceInfo *self;
    PREINIT:
	int i;
        SV *rv;
    PPCODE:
	for( i = 0; i < self->nInstances; i++){
 	  rv = newRV_inc(&PL_sv_undef);
	  sv_setref_iv(rv, 
                       "LSF::Batch::sharedResourceInstancePtr",
                       (I32)(self->instances + i));
	  XPUSHs(sv_2mortal(rv));
        }
	XSRETURN(self->nInstances);

MODULE = LSF::Batch PACKAGE=LSF::Batch::sharedResourceInstancePtr PREFIX = ins_

Batch.xs view on Meta::CPAN

	RETVAL = self->rsvValue;
    OUTPUT:
	RETVAL

void 
ins_hostList(self)
	LSF_Batch_sharedResourceInstance *self;
    PREINIT:
	int i;
        SV *rv;
    PPCODE:
	for( i = 0; i < self->nHosts; i++){
          XPUSHs(sv_2mortal(newSVpv(self->hostList[i],0)));	
        }
	XSRETURN(self->nHosts);

MODULE = LSF::Batch	PACKAGE = LSF::Batch	PREFIX = lsb_

void
lsb_hostpartinfo(self, hostParts)
	void *self
	char **hostParts
    PREINIT:
	SV *rv;
	int num, i, count;
	char **h;
	LSF_Batch_hostPartInfo *p, *pi;
    PPCODE:	
	for( h = hostParts; hostParts && *h; h++ ) count++;
	num = count;
	if( count == 0 ) hostParts = NULL;
	pi = lsb_hostpartinfo(hostParts, &num);
	if(pi == NULL){
	    STATUS_NATIVE_SET(lsberrno);
	    SET_LSB_ERRMSG;
	    XSRETURN_EMPTY;
 	}
	for( i = 0, p = pi; i < num; i++,p++ ){

Batch.xs view on Meta::CPAN

	RETVAL = self->hostList;
    OUTPUT:
	RETVAL

void 
hpi_users(self)
	LSF_Batch_hostPartInfo *self;
    PREINIT:
	int i;
        SV *rv;
    PPCODE:
	for( i = 0; i < self->numUsers; i++){
          rv = newRV_inc(&PL_sv_undef);
	  sv_setref_iv(rv, 
                       "LSF::Batch::hostPartUserInfoPtr",
                        (I32)(self->users + i));
	  XPUSHs(sv_2mortal(rv));
        }
	XSRETURN(self->numUsers);

Batch.xs view on Meta::CPAN

	RETVAL = self->eventTime;
    OUTPUT:
	RETVAL

void
er_eventLog(self)
	LSF_Batch_eventRec *self
    PREINIT:
	char *label;
	SV *rv;
    PPCODE:
	switch(self->type){
	   case EVENT_LOG_SWITCH:
	      label = "LSF::Batch::logSwitchLogPtr";
	      rv = newRV_inc(&PL_sv_undef);
	      sv_setref_iv(rv, label, (IV)&self->eventLog.logSwitchLog);
	      break;
	   /*
	   case EVENT_JGRP_NEW:
	      label = "LSF::Batch::jgrpNewLogPtr";
	      rv = newRV_inc(&PL_sv_undef);

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->userId;
    OUTPUT:
	RETVAL

void
jnl2_askedHosts(self)
	LSF_Batch_jobNewLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numAskedHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));	
	XSRETURN(self->numAskedHosts);

char *
jnl2_userGroup(self)
	LSF_Batch_jobNewLog *self
    CODE:
	RETVAL = self->userGroup;
    OUTPUT:
	RETVAL

void
jnl2_rLimits(self)
	LSF_Batch_jobNewLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < LSF_RLIM_NLIMITS; i++)
          XPUSHs(sv_2mortal(newSViv(self->rLimits[i])));	
	XSRETURN(LSF_RLIM_NLIMITS);

time_t
jnl2_termTime(self)
	LSF_Batch_jobNewLog *self
    CODE:
	RETVAL = self->termTime;
    OUTPUT:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->userId;
    OUTPUT:
	RETVAL

char *
jml_askedHosts(self)
	LSF_Batch_jobModLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numAskedHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));	
	XSRETURN(self->numAskedHosts);

char *
jml_userGroup(self)
	LSF_Batch_jobModLog *self
    CODE:
	RETVAL = self->userGroup;
    OUTPUT:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->termTime;
    OUTPUT:
	RETVAL

void
jml_rLimits(self)
	LSF_Batch_jobModLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < LSF_RLIM_NLIMITS; i++)
          XPUSHs(sv_2mortal(newSViv(self->rLimits[i])));	
	XSRETURN(LSF_RLIM_NLIMITS);

char *
jml_dependCond(self)
	LSF_Batch_jobModLog *self
    CODE:
	RETVAL = self->dependCond;
    OUTPUT:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->queuePreCmd;
    OUTPUT:
	RETVAL

void
jsl2_execHosts(self)
	LSF_Batch_jobStartLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numExHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->execHosts[i],0)));	
	XSRETURN(self->numExHosts);

int
jsl2_jobPid(self)
	LSF_Batch_jobStartLog *self
    CODE:
	RETVAL = self->jobPid;
    OUTPUT:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->userId;
    OUTPUT:
	RETVAL

char *
ml_askedHosts(self)
	LSF_Batch_migLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numAskedHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));	
	XSRETURN(self->numAskedHosts);

int
ml_jobId(self)
	LSF_Batch_migLog *self
    CODE:
	RETVAL = self->jobId;
    OUTPUT:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->loginShell;
    OUTPUT:
	RETVAL

void
jfl_execHosts(self)
	LSF_Batch_jobFinishLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numExHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->execHosts[i],0)));	
	XSRETURN(self->numExHosts);

float
jfl_cpuTime(self)
	LSF_Batch_jobFinishLog *self
    CODE:
	RETVAL = self->cpuTime;
    OUTPUT:

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->userId;
    OUTPUT:
	RETVAL

char *
jfl_askedHosts(self)
	LSF_Batch_jobFinishLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numAskedHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));	
	XSRETURN(self->numAskedHosts);

time_t
jfl_termTime(self)
	LSF_Batch_jobFinishLog *self
    CODE:
	RETVAL = self->termTime;
    OUTPUT:

Batch.xs view on Meta::CPAN

	RETVAL


MODULE = LSF::Batch PACKAGE = LSF::Batch::loadIndexLogPtr PREFIX = lil_

char *
lil_name(self)
	LSF_Batch_loadIndexLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVpv(self->name[i],0)));	
	XSRETURN(self->nIdx);

int
lil_nIdx(self)
	LSF_Batch_loadIndexLog *self
    CODE:
	RETVAL = self->nIdx;
    OUTPUT:

Batch.xs view on Meta::CPAN

	RETVAL


MODULE = LSF::Batch PACKAGE = LSF::Batch::jobForwardLogPtr PREFIX = jfl2_

char *
jfl2_reserHosts(self)
	LSF_Batch_jobForwardLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numReserHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->reserHosts[i],0)));	
	XSRETURN(self->numReserHosts);

int
jfl2_jobId(self)
	LSF_Batch_jobForwardLog *self
    CODE:
	RETVAL = self->jobId;
    OUTPUT:

Batch.xs view on Meta::CPAN

MODULE = LSF::Batch PACKAGE = LSF::Batch::jobChunkLogPtr PREFIX = jcl3_

void
jcl3_membJobId(self)
	LSF_Batch_jobChunkLog *self
    PREINIT:
	LS_LONG_INT id;
	int i;
	LSF_Batch_job *j;
	SV *rv;
    PPCODE:
	for( i = 0; i < self->membSize; i++){
	   j = (LSF_Batch_job *)safemalloc(sizeof(LSF_Batch_job));
	   j->jobId = LSB_ARRAY_JOBID(id);
	   j->arrayIdx = LSB_ARRAY_IDX(id);
	   rv = newRV_inc(&PL_sv_undef);
	   sv_setref_iv(rv, "LSF::Batch::jobPtr", (IV)&j);
	   XPUSHs(sv_2mortal(rv));
	}
	XSRETURN(self->membSize);

Batch.xs view on Meta::CPAN

    CODE:
	RETVAL = self->membSize;
    OUTPUT:
	RETVAL

void
jcl3_execHosts(self)
	LSF_Batch_jobChunkLog *self
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->numExHosts; i++)
          XPUSHs(sv_2mortal(newSVpv(self->execHosts[i],0)));	
	XSRETURN(self->numExHosts);

MODULE = LSF::Batch PACKAGE = LSF::Batch::jobExternalMsgLogPtr PREFIX = jeml_

int
jeml_userId(self)
	LSF_Batch_jobExternalMsgLog *self
    CODE:

makexs.pl view on Meta::CPAN

}
print "/* XS Code.... */\n";
print "MODULE = LSF::Batch PACKAGE = LSF::Batch::eventRecPtr PREFIX = er_\n";
print "\n";
print "void\n";
print "er_eventLog(self)\n";
print "\tLSF_Batch_eventRec *self\n";
print "    PREINIT:\n";
print "\tchar *label;\n";
print "\tSV *rv;\n";
print "    PPCODE:\n";
print "\tswitch(self->type){\n";

foreach $struct (@structures){
  $label = $struct;
  $label =~ s/Log$//;
  $label =~ s/([A-Z]{1})/_\1/g;
  $label = "EVENT_" . uc $label;
  print "\t   case $label:\n";
  print "\t      label = \"LSF::Batch::${struct}Ptr\";\n";
  print "\t      rv = newRV_inc(&PL_sv_undef);\n";

( run in 1.449 second using v1.01-cache-2.11-cpan-5511b514fd6 )