view release on metacpan or  search on metacpan

Lock.xs  view on Meta::CPAN

			{PUSHs(sv_2mortal(newSVpv("uwrl" + (result&Lock_modemask),1)));fprintf(stderr,"Returning '%c'\n","uwrl"[result&Lock_modemask]);}\
		else \
			{PUSHs(sv_mortalcopy(&sv_yes));fprintf(stderr,"Returning 'yes'\n");}\
	MACRO_END

#else

#define PUSHResult(result,mode) \
	MACRO_BEGIN \
	if(result==-1)  \
		PUSHs(&sv_undef);\
	else \
		if(mode==Lock_test) \
			PUSHs(sv_2mortal(newSVpv("uwrl" + (result&Lock_modemask),1)));\
		else \
			PUSHs(&sv_yes);\
	MACRO_END

#endif
	
#define ReturnResult(result,mode) \
	MACRO_BEGIN \
	EXTEND(sp,1); \
	PUSHResult(result,mode); \
	MACRO_END
		
#define wantarray (GIMME == G_ARRAY)
        

MODULE = File::Lock		PACKAGE = File::Lock

double
constant(name,arg)
	char *		name
	int		arg


int
lockfile(filename, mode=Lock_exclusive|Lock_nonblock,shared=0,shortnames=0)
	char *	filename
	mode_int	mode
	int	shared
	int	shortnames
	CODE:
	{
#		ifdef FDEBUG
			fprintf(stderr,"Entering lockfilef(%s,%s,shared=%d,shortnames=%d)\n",filename,mode_name[mode],shared,shortnames);
#		endif		
		RETVAL = _base_lockfile(filename,mode,shared,shortnames);
	}
	OUTPUT:
	RETVAL

void
fcntl(file, mode=Lock_exclusive|Lock_nonblock, offset=0, whence=SEEK_SET, length=0)
	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)
#define YES_FCNTL		
	{
		struct flock retflk;
		int retval;
		retval = _base_fcntl(fileno(file),mode,offset,whence,length, &retflk);
		if(((mode & Lock_modemask) == Lock_test) && (retval!=-1)) {
			if(wantarray) {
#				ifdef HAS_SYSID_IN_FCNTL
					EXTEND(sp, 6);
#				else					
					EXTEND(sp, 5);
#				endif					
#				ifdef FDEBUG
					fprintf(stderr,"Returning (%s,%d,%d,%d,%d",mode_name[retflk.l_type],
							retflk.l_start,retflk.l_whence,retflk.l_len,retflk.l_pid);
#				endif
				PUSHResult(retflk.l_type,mode);
				PUSHs(sv_2mortal(newSViv(retflk.l_start))); 
				PUSHs(sv_2mortal(newSViv(retflk.l_whence))); 
				PUSHs(sv_2mortal(newSViv(retflk.l_len))); 
				PUSHs(sv_2mortal(newSViv(retflk.l_pid))); 
#				ifdef HAS_SYSID_IN_FCNTL
					PUSHs(sv_2mortal(newSViv(retflk.l_sysid))); 
#					ifdef FDEBUG
						fprintf(stderr,",%d",retflk.l_sysid);
#					endif
#				endif				
#				ifdef FDEBUG
					fprintf(stderr,") from fcntl()\n");
#				endif
			
			} else {
				EXTEND(sp,1);
				PUSHResult(retflk.l_type,mode);
			}
		} else {
		   EXTEND(sp,1);
		   PUSHResult(retval,mode);
		}
	}
#	endif
#	if !defined(HAS_FCNTL) && defined(HAS_LOCKF)
#define EMU_FCNTL
	if(((mode & Lock_modemask) == Lock_test) && wantarray) {
		croak("fcntl is emulated on this architecture, and does "
		      "not support testing a lock in an array context\n");
	} else {
		int retval = _base_lockf(fileno(file),mode,offset,whence,length);
		ReturnResult(retval,mode);
	}
#	endif
#	if !defined(HAS_FCNTL) && !defined(HAS_LOCKF)
#define NO_FCNTL		
		croak("fcntl is not supported on this architecture\n");
#	endif				
	}

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)
#define YES_FLOCK		
		ReturnResult(_base_flock(fileno(file),mode),mode);
#	endif
#	if !defined(HAS_FLOCK) && defined(HAS_FCNTL)
#define EMU_FLOCK		
		ReturnResult(_base_fcntl(fileno(file),mode,0,SEEK_SET,0,0),mode);
#	endif
#	if !defined(HAS_FLOCK) && !defined(HAS_FCNTL) && defined(HAS_LOCKF)
#define EMU_FLOCK		
		ReturnResult(_base_lockf(fileno(file),mode,0,SEEK_SET,0),mode);
#	endif
#	if !defined(HAS_FLOCK) && !defined(HAS_FCNTL) && !defined(HAS_LOCKF)
#define NO_FLOCK		
		croak("flock is not supported on this architecture\n");
#	endif				
	}

void
lockf(file, mode=Lock_exclusive|Lock_nonblock, offset=0, whence=SEEK_SET, length=0)
	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)
#define YES_LOCKF		
		ReturnResult(_base_lockf(fileno(file),mode,offset,whence,length),mode);
#	endif
#	if !defined(HAS_LOCKF) && defined(HAS_FCNTL)
#define EMU_LOCKF		
		ReturnResult(_base_fcntl(fileno(file),mode,offset,whence,length,0),mode);
#	endif
#	if !defined(HAS_LOCKF) && !defined(HAS_FCNTL)
#define NO_LOCKF		
		croak("lockf is not supported on this architecture\n");
#	endif				
	}
	
char *
has_flock()
	CODE:
	{
#	ifdef YES_FLOCK
		RETVAL = "yes";
#	endif				
#	ifdef EMU_FLOCK
		RETVAL = "emulated";
#	endif
#	ifdef NO_FLOCK
		RETVAL = "";
#	endif
#	ifdef FDEBUG
		fprintf(stderr,"Returning `%s' from has_flock()\n",RETVAL);
#	endif		
	}
	OUTPUT:
	RETVAL

char *
has_lockf()
	CODE:
	{
#	ifdef YES_LOCKF
		RETVAL = "yes";
#	endif				
#	ifdef EMU_LOCKF
		RETVAL = "emulated";
#	endif
#	ifdef NO_LOCKF
		RETVAL = "";
#	endif
#	ifdef FDEBUG
		fprintf(stderr,"Returning `%s' from has_lockf()\n",RETVAL);
#	endif		
	}
	OUTPUT:
	RETVAL

char *
has_fcntl()
	CODE:
	{
#	ifdef YES_FCNTL
		RETVAL = "yes";
# endif 
# ifdef EMU_FCNTL
		RETVAL = "emulated";
#	endif
#	ifdef NO_FCNTL
		RETVAL = "";
#	endif
#	ifdef FDEBUG
		fprintf(stderr,"Returning `%s' from has_fcntl()\n",RETVAL);
#	endif		
	}
	OUTPUT:
	RETVAL

char *
has_lockfile()
	CODE:
	{
		RETVAL = "yes";
#	ifdef FDEBUG
		fprintf(stderr,"Returning `%s' from has_lockfile()\n",RETVAL);
#	endif		
	}
	OUTPUT:
	RETVAL

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

void
new(class, file, mode=Lock_shared, offset=0, whence=SEEK_SET, length=0)
	SV *	class
	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)) {
		croak("Only exclusive or shared locking modes may be used with new File::Lock.\n");
	}
	{
#	if defined(HAS_FCNTL)
		struct flock retflk;
		int retval;
		retval = _base_fcntl(fileno(file),mode,offset,whence,length, 0);
#	endif
#	if !defined(HAS_FCNTL) && defined(HAS_LOCKF)
		int retval = _base_lockf(fileno(file),mode,offset,whence,length);
#	endif
#	if !defined(HAS_FCNTL) && !defined(HAS_LOCKF)
		croak("fcntl is not supported on this architecture\n");
#	else
		if(retval==0) {
			AV * ary = newAV();
			SV * ref;
			av_push(ary,newRV((SV*)sv_2io(ST(1))));
			av_push(ary,newSViv(offset));
			av_push(ary,newSViv(whence));
			av_push(ary,newSViv(length));
			ref = newRV((SV*)ary);
			sv_bless(ref,gv_stashpv("File::Lock",0));
			EXTEND(sp,1);
			PUSHs(sv_2mortal(ref));
		} else {
			EXTEND(sp,1);
			PUSHs(&sv_undef);
		}
#	endif				
	}
	}