view release on metacpan or search on metacpan
konto_check.c view on Meta::CPAN
if(slots<SLOT_CNT_MIN){
slots=SLOT_CNT_MIN; /* Minimalzahl Slots */
ok=OK_SLOT_CNT_MIN_USED;
}
if(!outputname)outputname=(char *)default_lutname[0];
if(stat(inputname,&s_buf)==-1)RETURN(FILE_READ_ERROR);
bufsize=s_buf.st_size+10+strlen(testbanken_neu);
if(!(buffer=(char *)malloc(bufsize)) || !(out_buffer=(char *)malloc(bufsize)))RETURN(ERROR_MALLOC);
if(!(in=fopen(inputname,"rb"))){
PRINT_VERBOSE_DEBUG_FILE("fopen(rb)");
if(buffer)FREE(buffer);
konto_check.c view on Meta::CPAN
for(ptr=out_buffer;*ptr++!='\n';);
while(*ptr++!='\n');
ptr++; /* Leerzeile überspringen */
/* falls ein set angegeben ist, die datei aber nicht existiert, eine neue Datei anlegen (set=0) */
if(set>0 && stat(outputname,&s_buf)==-1)set=0;
if(set>0){ /* Blocks an Datei anhängen */
if(!(lut=fopen(outputname,"rb+"))){
PRINT_VERBOSE_DEBUG_FILE("fopen(rb+)");
retval=FILE_WRITE_ERROR;
goto fini;
konto_check.c view on Meta::CPAN
#if _WIN32>0
snprintf(lut_name,LUT_PATH_LEN,"%s\\%s",lut_searchpath[j],default_lutname[i]);
#else
snprintf(lut_name,LUT_PATH_LEN,"%s/%s",lut_searchpath[j],default_lutname[i]);
#endif
if(!(k=stat(lut_name,&s_buf)))break;
}
}
if(k==-1)RETURN(NO_LUT_FILE); /* keine Datei gefunden */
}
stat(lut_name,&s_buf);
buflen=s_buf.st_size;
if(!(buffer=(char *)malloc(buflen)))RETURN(ERROR_MALLOC);
if(!(lut=fopen(lut_name,"rb"))){
PRINT_VERBOSE_DEBUG_FILE("fopen(rb)");
FREE(buffer);
konto_check.c view on Meta::CPAN
#if _WIN32>0
snprintf(lut_name,LUT_PATH_LEN,"%s\\%s",lut_searchpath[j],default_lutname[i]);
#else
snprintf(lut_name,LUT_PATH_LEN,"%s/%s",lut_searchpath[j],default_lutname[i]);
#endif
if(!(k=stat(lut_name,&s_buf)))break;
}
}
if(k==-1){
init_status=init_in_progress=0;
RETURN(NO_LUT_FILE); /* keine Datei gefunden */
konto_check.c view on Meta::CPAN
struct stat s_buf;
int in;
if(cnt_blz)*cnt_blz=0;
if(!(init_status&1))init_atoi_table();
if(stat(filename,&s_buf)==-1)RETURN(NO_LUT_FILE);
if(!(inbuffer=(unsigned char *)calloc(s_buf.st_size+128,1)))RETURN(ERROR_MALLOC);
if((in=open(filename,O_RDONLY|O_BINARY))<0)RETURN(NO_LUT_FILE);
if(!(cnt=read(in,inbuffer,s_buf.st_size)))RETURN(FILE_READ_ERROR);
close(in);
lut_version= -1;
konto_check.c view on Meta::CPAN
/* eigene Version von mktemp, da die Libraryversion immer einen Linkerfehler
* erzeugt, der sich nicht deaktivieren läßt (ist hier auch nicht kritisch)
*/
for(i=0;i<100000;i++){
sprintf(tmpfile,"blz_tmp.%05d",i);
if((stat(tmpfile,&s_buf)==-1) && (errno==EBADF || errno==ENOENT))break;
}
lut_set[0]=LUT2_BLZ;
lut_set[1]=LUT2_PZ;
lut_set[2]=LUT2_FILIALEN;
for(i=0;(lut_set[i+3]=lut_set_9[i]) && i<28;i++);
konto_check.c view on Meta::CPAN
#if _WIN32>0
snprintf(lut_name,LUT_PATH_LEN,"%s\\%s",lut_searchpath[j],default_lutname[i]);
#else
snprintf(lut_name,LUT_PATH_LEN,"%s/%s",lut_searchpath[j],default_lutname[i]);
#endif
if(!(k=stat(lut_name,&s_buf)))break;
}
}
if(k==-1)return NO_LUT_FILE; /* keine Datei gefunden */
}
konto_check.c view on Meta::CPAN
UINT4 cnt;
FILE *in,*lut;
struct stat sbuf;
if(stat(iban_blacklist,&sbuf))return FILE_READ_ERROR;
if(!(in=fopen(iban_blacklist,"r")))return FILE_READ_ERROR;
if(!(lut=fopen(lutfile,"rb+")))return FILE_WRITE_ERROR;
size=sbuf.st_size;
/* grobe Abschätzung für die Größe des benötigten Arrays: jede BLZ
konto_check.c view on Meta::CPAN
snprintf(scl_gueltigkeit_iso,16,"%4d-%02d-%02d",jahr%10000,monat%100,tag%100);
if(!fgets(buffer,512,in))RETURN(SCL_INPUT_FORMAT_ERROR);
/* Leerzeichen aus dem Überschrift-String entfernen */
for(ptr=buffer,ptr2=buffer2;*ptr;ptr++)if(!isspace(*ptr))*ptr2++=*ptr;
if(strncmp(buffer2,"BIC;Name;SERVICESCT;SERVICECOR;SERVICECOR1;SERVICEB2B;SERVICESCC",64))RETURN(SCL_INPUT_FORMAT_ERROR);
stat(inputfile,&stat_buffer);
cnt=stat_buffer.st_size/163+300; /* etwas großzügig die Anzahl rechnen; jede Zeile hat 163 Bytes und ist am Ende mit Leerzeichen aufgefüllt */
scl_bic_array=(char **)calloc(sizeof(char*),cnt);
scl_name_array=(char **)calloc(sizeof(char*),cnt);
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the script that is loading Module::Install is from the future,
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 and (stat($0))[9] > time ) {
die << "END_DIE";
Your installer $0 has a modification time in the future.
This is known to create infinite loops in make.
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the script that is loading Module::Install is from the future,
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 and (stat($0))[9] > time ) {
die << "END_DIE";
Your installer $0 has a modification time in the future.
This is known to create infinite loops in make.
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
lib/BuzzSaw/DataSource/Files.pm view on Meta::CPAN
}
# Schwartzian transform for efficient sorting
@files = map { $_->[0] }
sort $sorter
map { [ $_, (stat($_))[7] ] } keys %files;
} elsif ( $order_by =~ m/^name_(asc|desc)$/ ) {
if ( $1 eq 'asc' ) {
@files = sort { $a cmp $b } keys %files;
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the script that is loading Module::Install is from the future,
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 and (stat($0))[9] > time ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future.
This is known to create infinite loops in make.
view release on metacpan or search on metacpan
inc/Devel/CheckOS.pm view on Meta::CPAN
$re_AssertOS = qr/$case_flag ^AssertOS$/x;
}
# sort by mtime, so oldest last
my @modules = sort {
(stat($a->{file}))[9] <=> (stat($b->{file}))[9]
} map {
my (undef, $dir_part, $file_part) = File::Spec->splitpath($_);
$file_part =~ s/\.pm$//;
my (@dirs) = grep {+length} File::Spec->splitdir($dir_part);
foreach my $i (reverse 1..$#dirs) {
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
lib/CAD/Format/STL.pm view on Meta::CPAN
my $buf; read($fh, $buf, 4) or die;
unpack('L', $buf);
};
$@ and return 'ascii'; # if we hit eof, it can't be binary
$count or die "detection failed - no facets?";
my $size = (stat($fh))[7];
# calculate the expected file size
my $expect =
+ 80 # header
+ 4 # count
+ $count * (
view release on metacpan or search on metacpan
lib/CAD/Mesh3D/FormatSTL.pm view on Meta::CPAN
my $buf; read($fh, $buf, 4) or die;
unpack('L', $buf);
};
$@ and return 'ascii'; # if we hit eof, it can't be binary
$count or die "detection failed - no facets?";
my $size = (stat($fh))[7];
# calculate the expected file size
my $expect =
+ 80 # header
+ 4 # count
+ $count * (
view release on metacpan or search on metacpan
lib/CAM/SQLManager.pm view on Meta::CPAN
local $/ = undef;
$self->{sql} = <FILE>;
close(FILE);
# Record the last-mod time of the file so we can notice if it changes
$self->{filetime} = (stat($self->{filename}))[9];
# Set up the statistics data structures
if (!exists $global_stats{cmds}->{$self->{cmd}})
{
# Any changes to this data structure should be propagated into
lib/CAM/SQLManager.pm view on Meta::CPAN
if (-e File::Spec->catfile($global_directory, $cmd))
{
if (exists $global_cache{$cmd})
{
# Check to make sure the SQL file has not changed
if ($global_cache{$cmd}->{filetime} < (stat($global_cache{$cmd}->{filename}))[9])
{
$global_cache{$cmd} = $pkg->new($cmd, @args);
}
}
else
view release on metacpan or search on metacpan
lib/CAM/Template.pm view on Meta::CPAN
$global_filecache{$pkg} ||= {};
$cache = $global_filecache{$pkg};
}
if ($self->{use_cache} && exists $cache->{$filename} &&
$cache->{$filename}->{time} >= (stat($filename))[9])
{
return $cache->{$filename};
}
else
{
lib/CAM/Template.pm view on Meta::CPAN
$struct->{string} =~ s/$re/ $self->_fetchfile("$dir$1")->{string} /ge;
}
if ($self->{use_cache})
{
$struct->{time} = (stat($filename))[9];
$cache->{$filename} = $struct;
}
return $struct;
}
}
view release on metacpan or search on metacpan
CDB_File.xs view on Meta::CPAN
{
struct stat st;
int fd = PerlIO_fileno(f);
RETVAL->map = 0;
if (fstat(fd, &st) == 0) {
if (st.st_size <= 0xffffffff) {
char *x;
x = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (x != (char *)-1) {
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the script that is loading Module::Install is from the future,
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 and (stat($0))[9] > time ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future.
This is known to create infinite loops in make.
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
MapDisp2.pm view on Meta::CPAN
"]) Copy failed from $f1 to $f2: $!",0);
return;
}
opendir DD, "$bdr" or croak "ERR: ($prg) could not opendir - $bdr: $!\n";
my @a = sort { (stat("$bdr/$a"))[9] <=> (stat("$bdr/$b"))[9] }
(grep { /$fname/ && !/^\./ } readdir DD);
closedir DD;
my $n = 0;
my ($m) = ($a[$#a] =~ /\.(\d+)$/);
view release on metacpan or search on metacpan
lib/CGI/AppToolkit/Template.pm view on Meta::CPAN
if (!$self->{'cache'}
||
(!$CACHE{$template_file_orig})
||
((stat(_))[9] != $CACHE{$template_file_orig}[0])) {
my $template_file = '';
if ($template_file_orig !~ m{/}) {
foreach my $dir (@PATH) {
if (-d $dir && (-e "$dir/$template_file_orig" || -e "$dir/$template_file_orig.tmpl")) {
lib/CGI/AppToolkit/Template.pm view on Meta::CPAN
$self->_load_vars unless $self->{'vars-loaded'};
# MAKE PATH FULL HERE
$CACHE{$template_file} = [
(stat(_))[9],
$self->{'template'},
$self->{'vars'}
] if $self->{'cache'};
} else {
lib/CGI/AppToolkit/Template.pm view on Meta::CPAN
#-------------------------
sub check_cache {
my($self) = shift;
if (($self->{'file-name'}) && ((stat($self->{'file-name'}))[9] != $self->{'file-date'})) {
$self->load($self->{'file-name'});
return 1;
}
0
}
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the script that is loading Module::Install is from the future,
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 and (stat($0))[9] > time ) {
die << "END_DIE";
Your installer $0 has a modification time in the future.
This is known to create infinite loops in make.
view release on metacpan or search on metacpan
CaptureIO.pm view on Meta::CPAN
if($self->{__CAP_CAPTUREIO_CONFIG}->{CAPTURE_CLEAR}){
# capture auto clear
find(sub {
my $ttl = $self->{__CAP_CAPTUREIO_CONFIG}->{CAPTURE_TTL};
my $st = stat($_);
if(-d $_ && (time - $st->atime) > $ttl){
rmtree($File::Find::dir, 0);
}elsif(-e $_ && -B $_){
if($_ =~ /^$CAPTURE_PREFIX/ && (time - $st->atime) > $ttl){
CaptureIO.pm view on Meta::CPAN
my $capture_dir = _capture_dir($self);
my $capture = File::Spec->catfile($capture_dir, $CAPTURE_PREFIX . $digest);
if(-e $capture && -B $capture){
my $st = stat($capture);
if((time - $st->mtime) <= $ttl){
my $ref = Storable::retrieve($capture);
$self->run_modes( $CAPTURE_MODE => sub {
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# then make will detect this and cause it to re-run over and over
# again. This is bad. Rather than taking action to touch it (which
# is unreliable on some platforms and requires write permissions)
# for now we should catch this and refuse to run.
if ( -f $0 ) {
my $s = (stat($0))[9];
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }