PPCODE results from the CPAN

PPCODE

LSF-Base

view release on metacpan or search on metacpan

ls_gethostinfo( self, resreq, hostlist, options )
	void	*self
	char*	resreq
	char**	hostlist
	int	options
    PREINIT:
	SV *rv;	
	int i, count=0, num;
	LSF_Base_hostInfo *hi, *p;
	char **c, **hl;
    PPCODE:
	for( c = hostlist; hostlist && *c; c++ ) count++;
	if( count == 0 ) hostlist = NULL;
	hi = ls_gethostinfo(resreq, &num, hostlist, count, options );
	if(hi == NULL){
	    STATUS_NATIVE_SET(lserrno);
	    SET_LSF_ERRMSG;
	    XSRETURN_EMPTY;
 	}
	for( i = 0, p = hi; i < num; i++,p++ ){
	    rv = newRV_inc(&PL_sv_undef);

Base.xs view on Meta::CPAN

	
void
ls_readconfenv(self, env, path)
	void	*self
	char** 	env
	char* 	path
    PREINIT:
	struct config_param *param;
	int i, count=0;
	char **p;
    PPCODE:
	for( p = env; env && *p; p++ ) count++;
	param = safemalloc(sizeof(struct config_param)*count + 1);
	for( i=0; i<count; i++){
	    param[i].paramName = env[i];
	}
	if( ls_readconfenv(param, path) < 0 ){
	    STATUS_NATIVE_SET(lserrno);
            SET_LSF_ERRMSG;
	    safefree(param);
	    XSRETURN_EMPTY;

Base.xs view on Meta::CPAN


MODULE = LSF::Base		PACKAGE = LSF::Base::lsInfoPtr PREFIX = li_

void
li_resTable(self)
	LSF_Base_lsInfo *self;
    PREINIT:
	SV *rv;	
	int i;
	LSF_Base_resItem *p;
    PPCODE:
	for( i = 0,p =self->resTable; i < self->nRes; i++,p++ ){
	    rv = newRV_inc(&PL_sv_undef);
	    sv_setref_iv(rv, "LSF::Base::resItemPtr",(IV)p);
	    XPUSHs(sv_2mortal(rv));
	}
	XSRETURN(self->nRes);

void
li_hostTypes(self)
	LSF_Base_lsInfo *self;
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nTypes; i++){
	    XPUSHs(sv_2mortal(newSVpv(self->hostTypes[i],0)));
	}
	XSRETURN(self->nTypes);

void
li_hostModels(self)
	LSF_Base_lsInfo *self;
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nModels; i++ ){
	    XPUSHs(sv_2mortal(newSVpv(self->hostModels[i],0)));
	}
	XSRETURN(self->nModels);

void
li_hostArchs(self)
	LSF_Base_lsInfo *self;
    PREINIT:
	int i;
    PPCODE:
	for( i = 0; i < self->nTypes; i++){
	    XPUSHs(sv_2mortal(newSVpv(self->hostArchs[i],0)));
	}
	XSRETURN(self->nTypes);

void
li_modelRefs(self)
	LSF_Base_lsInfo *self;
    PREINIT:
	int i;
	int *p;
    PPCODE:
	for( i = 0,p = self->modelRefs; i < self->nModels; i++,p++ ){
	    XPUSHs(sv_2mortal(newSViv((int)*p)));
	}
	XSRETURN(self->nModels);

void
li_cpuFactor(self)
	LSF_Base_lsInfo *self;
    PREINIT:
	int i;
	float *p;
    PPCODE:
	for( i = 0,p = self->cpuFactor; i < self->nModels; i++,p++ ){
	    XPUSHs(sv_2mortal(newSVnv((double)*p)));
	}
	XSRETURN(self->nModels);

int 
li_numIndx(self)
	LSF_Base_lsInfo *self;
    CODE:
	RETVAL = self->numIndx;

Base.xs view on Meta::CPAN

	RETVAL = self->nDisks;
    OUTPUT:
	RETVAL

void
hi_resources(self)
	LSF_Base_hostInfo *self;
    PREINIT:
	int i;
	char *p;
    PPCODE:
	for( i = 0; i < self->nRes; i++ ){
	    XPUSHs(sv_2mortal(newSVpv(self->resources[i],0)));
	}
	XSRETURN(self->nRes);
    
char*
hi_windows(self)
	LSF_Base_hostInfo *self;
    CODE:
	RETVAL = self->windows;
    OUTPUT:
	RETVAL

void
hi_busyThreshold(self)
	LSF_Base_hostInfo *self;
    PREINIT:
	int i;
    PPCODE:
	for( i=0; i < self->numIndx; i++ ){
	   XPUSHs(sv_2mortal(newSVnv(self->busyThreshold[i])));
        }
	XSRETURN(self->numIndx);

char
hi_isServer(self)
	LSF_Base_hostInfo *self;
    CODE:
	RETVAL = self->isServer;

Base.xs view on Meta::CPAN

	void *self
	char*	resreq
	int	numhosts
	int	options
	char*	fromhost
	
    PREINIT:
	struct hostLoad *hl, *p;
	int num, i;
	SV *rv;
    PPCODE:
	num = numhosts;
	if(strlen(fromhost)==0) fromhost = NULL;
	hl = ls_load( resreq, &num, options, fromhost);
	if(hl == NULL){
	    STATUS_NATIVE_SET(lserrno);
	    SET_LSF_ERRMSG;
	    XSRETURN_EMPTY;
 	}
	/*num contains number of records*/
	for( i = 0, p = hl; i < num; i++,p++ ){

Base.xs view on Meta::CPAN

	    
 #I'll do this one later.	
 #void
 #ls_loadinfo( resreq, numhosts, options, fromhost, hostlist, indxnamelist )
 #	char*	resreq
 #	int	numhosts
 #	int	options
 #	char*	fromhost
 #	char**	hostlist
 #	char**	indxnamelist
 #	PPCODE:

void
ls_loadofhosts( self, resreq, numhosts, options, fromhost, hostlist )
	void	*self
	char*	resreq
	int	numhosts
	int	options
	char*	fromhost
	char 	**hostlist;
    PREINIT:
	LSF_Base_hostLoad *hl, *p;
	int num, i, count;
	SV *rv;
	char **c;
    PPCODE:
	num = numhosts;
        count = 0;
      	for( c = hostlist; hostlist && *c; c++ ) count++;
	if( count == 0 ) hostlist = NULL;
	if(strlen(fromhost)==0) fromhost = NULL;
	hl = ls_loadofhosts( resreq, &num, options, fromhost, hostlist, count);
	if(hl == NULL){
	    STATUS_NATIVE_SET(lserrno);
	    SET_LSF_ERRMSG;
	    XSRETURN_EMPTY;

Base.xs view on Meta::CPAN

	char*	resreq
	int	numhosts
	int	options
	char* 	fromhost
	
	PREINIT:
	int num;
	char *s, **list;
	int i;

	PPCODE:
	num = numhosts;
	if(strlen(fromhost)==0) fromhost = NULL;
	list = ls_placereq( resreq, &num, options, fromhost );
	if( list == NULL ){
	   STATUS_NATIVE_SET(lserrno);
	   SET_LSF_ERRMSG;
	   XSRETURN_EMPTY;
	}
	else{
	   for( i = 0; i < num; i++ ){

Base.xs view on Meta::CPAN

ls_placeofhosts( self, resreq, numhosts, options, fromhost, hostlist )
	int	self
	char*	resreq
	int	numhosts
	int	options
	char*	fromhost
	char 	**hostlist
    PREINIT:
	char **list,**c;
	int num, i,count=0;
    PPCODE:
	num = numhosts;
       	for( c = hostlist; hostlist && *c; c++ ) count++;
	if(strlen(fromhost)==0) fromhost = NULL;
	list = ls_placeofhosts( resreq, &num, options, fromhost, 
                             hostlist, count);
	if(list == NULL){
	    STATUS_NATIVE_SET(lserrno);
	    SET_LSF_ERRMSG;
	    XSRETURN_EMPTY;
 	}

Base.xs view on Meta::CPAN

hl_hostName(self)
	LSF_Base_hostLoad *self
    CODE:
	RETVAL = self->hostName;
    OUTPUT:
	RETVAL

void
hl_status(self)
	LSF_Base_hostLoad *self;
    PPCODE:
	XPUSHs(sv_2mortal(newSViv(self->status[0])));
	XPUSHs(sv_2mortal(newSViv(self->status[1])));
	XSRETURN(2);

void
hl_li(self)
	LSF_Base_hostLoad *self;
    PREINIT:
	int i, ni;
	float *p;
	LSF_Base_lsInfo *li;
    PPCODE:
	/* At this point, I don't know the number of indices to return */
	if(li_ni == 0){	
	   li = ls_info();	
	   li_ni = li->numIndx;
	}
	p = self->li;
	for(i=0; i<li_ni ;i++,p++ ){
	   XPUSHs(sv_2mortal(newSVnv((double)*p)));
	}
	XSRETURN(li_ni);

Base.xs view on Meta::CPAN

	RETVAL

void
ls_eligible( self, task, mode )
	void	*self
	char*	task
	int	mode
    PREINIT:
	char resreqstr[1024];
	int ret;
    PPCODE:
	ret = ls_eligible(task, resreqstr, mode);
	if( ret < 0 ){
	    STATUS_NATIVE_SET(lserrno);
	    SET_LSF_ERRMSG;
	    XSRETURN_EMPTY;
 	}
        XPUSHs(sv_2mortal(newSViv(ret)));
	XPUSHs(sv_2mortal(newSVpv(resreqstr,0)));
	XSRETURN(2);

Base.xs view on Meta::CPAN

    OUTPUT:
	RETVAL

void
ls_listrtask(self, sortflag)
	void	*self
	int	sortflag
    PREINIT:
	char **list;
	int num,i;
    PPCODE:
	num = ls_listrtask(&list, sortflag);
	if( num == 0 ){
	    STATUS_NATIVE_SET(lserrno);
	    SET_LSF_ERRMSG;
	    XSRETURN_EMPTY;
	}
	else{
	    for( i=0; i < num; i++ ){
	      XPUSHs(sv_2mortal(newSVpv(list[i],0)));
            }
            XSRETURN(num);
        }

void
ls_listltask(self, sortflag)
	void	*self
	int	sortflag
    PREINIT:
	char **list;
	int num,i;
    PPCODE:
	num = ls_listltask(&list, sortflag);
	if( num == 0 ){
	    STATUS_NATIVE_SET(lserrno);
            SET_LSF_ERRMSG;
	    XSRETURN_EMPTY;
	}
	else{
	    for( i=0; i < num; i++ ){
	      XPUSHs(sv_2mortal(newSVpv(list[i],0)));
            }

Base.xs view on Meta::CPAN

	RETVAL = ls_isconnected(hostname);
    OUTPUT:
	RETVAL

void
ls_findmyconnections(self)
	void	*self
    PREINIT:
	char **p,**hosts;
	int count=0;
    PPCODE:
	hosts = ls_findmyconnections();
	if(hosts){
	   for( p = hosts; *p; p++){
     	      XPUSHs(sv_2mortal(newSVpv(*p,0)));
	      count++;
	   }
	   XSRETURN(count);
	}
	else{
	   STATUS_NATIVE_SET(lserrno);

Base.xs view on Meta::CPAN


void
ls_rwait(self, options)
	void	*self
	int	options
    PREINIT:
	LSF_Base_rusage *ru;
	LS_WAIT_T status;
	int tid;
	SV *rv;
    PPCODE:
	ru = safemalloc(sizeof(LSF_Base_rusage));
	tid = ls_rwait(&status, options, ru);
	if( tid < 0 ){
	   STATUS_NATIVE_SET(lserrno);
	   SET_LSF_ERRMSG;
           XSRETURN_EMPTY;
        }
	STATUS_NATIVE_SET(status);
	XPUSHs(sv_2mortal(newSViv(tid)));
	rv = newRV_inc(&PL_sv_undef);

Base.xs view on Meta::CPAN


void
ls_rwaittid(self, tid, options)
	void	*self
	int	tid
	int	options
    PREINIT:
	LSF_Base_rusage *ru;
	LS_WAIT_T status;
	SV *rv;
    PPCODE:
	ru = safemalloc(sizeof(LSF_Base_rusage));
	tid = ls_rwaittid(tid, &status, options, ru);
	if( tid < 0 ){
	   STATUS_NATIVE_SET(lserrno);
	   SET_LSF_ERRMSG;
	   XSRETURN_UNDEF;
	}
	STATUS_NATIVE_SET(status);
	rv = newRV_inc(&PL_sv_undef);
	sv_setref_iv(rv, "LSF::Base::rusagePtr",(IV)ru);

Base.xs view on Meta::CPAN

	RETVAL

void
ls_getstdin(self, on, max)
	void	*self;
	int	on;
	int	max;
   PREINIT:
	int	*tidlist;
	int	i, count;
   PPCODE:
	tidlist = safemalloc(sizeof(int)*max);
	if( count = ls_getstdin(on, tidlist, max) < 0 ){
	   STATUS_NATIVE_SET(lserrno);
	   SET_LSF_ERRMSG;
	   XSRETURN_UNDEF;
	}
	for( i = 0; i < count; i++){
	   XPUSHs(sv_2mortal(newSViv(tidlist[i])));
	}
	safefree(tidlist);

Base.xs view on Meta::CPAN

	}
    OUTPUT:
	RETVAL

int
ls_rfstat(self, rfd)
	void	*self
	int 	rfd
    PREINIT:
	struct stat st;
    PPCODE:
	/*make this stat look more like the perl stat function*/
	if( ls_rfstat(rfd, &st) < 0 ){
	    XSRETURN_UNDEF;
	}
	else{
	    XPUSHs(sv_2mortal(newSViv(st.st_dev)));
	    XPUSHs(sv_2mortal(newSViv(st.st_ino)));
	    XPUSHs(sv_2mortal(newSViv(st.st_mode)));
	    XPUSHs(sv_2mortal(newSViv(st.st_nlink)));
	    XPUSHs(sv_2mortal(newSViv(st.st_uid)));

Base.xs view on Meta::CPAN

	XSRETURN(13);
	

int
ls_rstat(self, host, fn)
	void	*self
	char*	host
	char*	fn
    PREINIT:
	struct stat st;
    PPCODE:
	/*make this stat look more like the perl stat function*/
	if( ls_rstat(host, fn, &st) < 0 ){
	    XSRETURN_UNDEF;
	}
	else{
	    XPUSHs(sv_2mortal(newSViv(st.st_dev)));
	    XPUSHs(sv_2mortal(newSViv(st.st_ino)));
	    XPUSHs(sv_2mortal(newSViv(st.st_mode)));
	    XPUSHs(sv_2mortal(newSViv(st.st_nlink)));
	    XPUSHs(sv_2mortal(newSViv(st.st_uid)));

Base.xs view on Meta::CPAN

 # The function prototype in lsf.h does not match the documentation 
 # for this in the manual pages.
 #
 #void
 #ls_readrexlog(self, fp)
 #	void	*self;
 #	FILE*	fp;
 #     PREINIT:
 # 	LSF_Base_lsfAcctRec *ar;
 #	SV *rv;
 #    PPCODE:
 #	if( (ar = ls_readrexlog(fp)) == NULL ){
 #	   STATUS_NATIVE_SET(lserrno);
 #	   SET_LSF_ERRMSG;
 #	   XSRETURN_UNDEF;
 #	}
 #	rv = newRV_inc(&PL_sv_undef);
 #	sv_setref_iv(rv, "LSF::Base::lsfAcctRecPtr",(IV)ar);
 #	XPUSHs(sv_2mortal(rv));
 #	XSRETURN(1);

Base.xs view on Meta::CPAN

#    CODE:
#	RETVAL = self->cmdln;
#    OUTPUT:
#	RETVAL
#
#void
#ar_lsfRu(self)
#	LSF_Base_lsfAcctRec *self;
#    PREINIT:
#	SV* rv;
#    PPCODE:
#	rv = newRV_inc(&PL_sv_undef);
#	sv_setref_iv(rv, "LSF::Base::rusagePtr",(IV)&self->lsfRu);
#	XPUSHs(sv_2mortal(rv));
#	XSRETURN(1);

MODULE = LSF::Base		PACKAGE = LSF::Base		PREFIX = ls_

# Error Handling

void

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