my $standby_result = $node_standby->safe_psql("postgres", $queries);
is($master_result, $standby_result, "$test_name: query result matches");
+ return;
}
# Initialize master node
while (<$fff>) { print; }
close $fff;
print "\\.\n";
+ return;
}
{
rename($temp_name, $final_name) || die "rename: $temp_name: $!";
}
+ return;
}
# Find a symbol defined in a particular header file and extract the value.
}
}
}
+ return;
}
# Given $pgattr_schema (the pg_attribute schema for a catalog sufficient for
}
Catalog::AddDefaultValues($row, $pgattr_schema, 'pg_attribute');
+ return;
}
# Write an entry to postgres.bki.
push @bki_values, $bki_value;
}
printf $bki "insert %s( %s )\n", $oid, join(' ', @bki_values);
+ return;
}
# Given a row reference, modify it so that it becomes a valid entry for
# Only the fixed-size portions of the descriptors are ever used.
delete $row->{$attname} if $column->{is_varlen};
}
+ return;
}
# Perform OID lookups on an array of OID names.
{
print STDERR @_;
$errors = 1;
+ return;
}
$, = ' '; # set output field separator
$charset);
print_conversion_tables_direction($this_script, $csname, TO_UNICODE,
$charset);
+ return;
}
#############################################################################
}
close($out);
+ return;
}
sub print_from_utf8_combined_map
}
print $out "\t/* $last_comment */" if ($verbose && $last_comment ne "");
print $out "\n};\n";
+ return;
}
sub print_to_utf8_combined_map
}
print $out "\t/* $last_comment */" if ($verbose && $last_comment ne "");
print $out "\n};\n";
+ return;
}
#######################################################################
if ($off != $tblsize) { die "table size didn't match!"; }
print $out "};\n";
+ return;
}
###
#define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n)
EOM
+
+ return;
}
sub emit_qsort_implementation
}
}
EOM
+
+ return;
}
print $file 'CONTENT';
close $file;
}
+ return;
}
create_files();
"$test_name: newer WAL file was not cleaned up");
ok(-f "$tempdir/unrelated_file",
"$test_name: unrelated file was not cleaned up");
+ return;
}
run_check('', 'pg_archivecleanup');
system_or_bail 'psql', '-q', '--no-psqlrc', '-d',
$node_master->connstr('postgres'), '-c', "$cmd";
+ return;
}
sub standby_psql
system_or_bail 'psql', '-q', '--no-psqlrc', '-d',
$node_standby->connstr('postgres'), '-c', "$cmd";
+ return;
}
# Run a query against the master, and check that the output matches what's
$stdout =~ s/\r//g if $Config{osname} eq 'msys';
is($stdout, $expected_stdout, "$test_name: query result matches");
}
+ return;
}
sub setup_cluster
'postgresql.conf', qq(
wal_keep_segments = 20
));
+ return;
}
sub start_master
#### Now run the test-specific parts to initialize the master before setting
# up standby
+
+ return;
}
sub create_standby
# The standby may have WAL to apply before it matches the primary. That
# is fine, because no test examines the standby before promotion.
+
+ return;
}
sub promote_standby
# after promotion so quickly that when pg_rewind runs, the standby has not
# performed a checkpoint after promotion yet.
standby_psql("checkpoint");
+
+ return;
}
sub run_pg_rewind
$node_master->start;
#### Now run the test-specific parts to check the result
+
+ return;
}
# Clean up after the test. Stop both servers, if they're still running.
{
$node_master->teardown_node if defined $node_master;
$node_standby->teardown_node if defined $node_standby;
+ return;
}
1;
}
RewindTest::clean_rewind_test();
+ return;
}
# Run the test in both modes
}
RewindTest::clean_rewind_test();
+ return;
}
# Run the test in both modes.
"file lists match");
RewindTest::clean_rewind_test();
+ return;
}
# Run the test in both modes.
'table content');
RewindTest::clean_rewind_test();
+ return;
}
# Run the test in both modes
# cleanup?
#unlink @filenames or die "cannot unlink files (@filenames): $!";
+
+ return;
}
# Test concurrent insertion into table with UNIQUE oid column. DDL expects
};
}
ok(unlink(@logs), "remove log files");
+ return;
}
my $bdir = $node->basedir;
print STDERR "opts=$opts, stat=$stat, out=$out, err=$err, name=$name";
command_checks_all([ 'pgbench', split(/\s+/, $opts) ],
$stat, $out, $err, $name);
+ return;
}
# invoke pgbench with scripts
}
}
command_checks_all(\@cmd, $stat, $out, $err, $name);
+ return;
}
#
{
delete $row->{pronargs} if defined $row->{proargtypes};
}
+ return;
}
# Format the individual elements of a Perl hash into a valid string
}
}
}
+ return;
}
add_to_buffer($buffer, $_);
}
close($fh);
+ return;
}
sub include_addon
sub add_to_buffer
{
push(@{ $buff{ $_[0] } }, "$_[1]\n");
+ return;
}
sub dump_buffer
print '/* ', $buffer, ' */', "\n";
my $ref = $buff{$buffer};
print @$ref;
+ return;
}
sub dump_fields
add_to_buffer('rules', ' { $$ = NULL; }');
}
}
+ return;
}
push(@{ $x->{lines} }, @code);
}
}
+ return;
}
(my $msg = shift) =~ s/\(eval \d+\) //g;
chomp $msg;
&::elog(&::WARNING, $msg);
+ return;
}
$SIG{__WARN__} = \&plperl_warn;
warn "Test string: $string\n";
warn "Result : $result";
die "Failed!" if $result ne "$string\n";
+ return;
}
unlink($node->data_dir . '/pg_hba.conf');
$node->append_conf('pg_hba.conf', "local all all $hba_method");
$node->reload;
+ return;
}
# Test access for a single role, useful to wrap all tests into one.
my $res = $node->psql('postgres', undef, extra_params => [ '-U', $role ]);
is($res, $expected_res,
"authentication $status_string for method $method, role $role");
+ return;
}
# Initialize master node
unlink($node->data_dir . '/pg_hba.conf');
$node->append_conf('pg_hba.conf', "local all all $hba_method");
$node->reload;
+ return;
}
# Test access for a single role, useful to wrap all tests into one.
is($res, $expected_res,
"authentication $status_string for role $role with password $password"
);
+ return;
}
# Initialize master node. Force UTF-8 encoding, so that we can use non-ASCII
'-U', $role
]);
is($res, $expected_res, $test_name);
+ return;
}
unlink($node->data_dir . '/pg_hba.conf');
my $res =
$node->psql('postgres', 'SELECT 1', extra_params => [ '-U', $role ]);
is($res, $expected_res, $test_name);
+ return;
}
note "simple bind";
{
my ($self) = @_;
print $self->info;
+ return;
}
"host replication all $test_localhost/32 sspi include_realm=1 map=regress\n";
}
close $hba;
+ return;
}
=pod
$self->set_replication_conf if $params{allows_streaming};
$self->enable_archiving if $params{has_archiving};
+ return;
}
=pod
chmod($self->group_access() ? 0640 : 0600, $conffile)
or die("unable to set permissions for $conffile");
+
+ return;
}
=pod
TestLib::system_or_bail('pg_basebackup', '-D', $backup_path, '-p', $port,
'--no-sync');
print "# Backup finished\n";
+ return;
}
=item $node->backup_fs_hot(backup_name)
{
my ($self, $backup_name) = @_;
$self->_backup_fs($backup_name, 1);
+ return;
}
=item $node->backup_fs_cold(backup_name)
{
my ($self, $backup_name) = @_;
$self->_backup_fs($backup_name, 0);
+ return;
}
}
print "# Backup finished\n";
+ return;
}
));
$self->enable_streaming($root_node) if $params{has_streaming};
$self->enable_restoring($root_node) if $params{has_restoring};
+ return;
}
=pod
}
$self->_update_pid(1);
+ return;
}
=pod
print "### Stopping node \"$name\" using mode $mode\n";
TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-m', $mode, 'stop');
$self->_update_pid(0);
+ return;
}
=pod
my $name = $self->name;
print "### Reloading node \"$name\"\n";
TestLib::system_or_bail('pg_ctl', '-D', $pgdata, 'reload');
+ return;
}
=pod
TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-l', $logfile,
'restart');
$self->_update_pid(1);
+ return;
}
=pod
print "### Promoting node \"$name\"\n";
TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-l', $logfile,
'promote');
+ return;
}
# Internal routine to enable streaming replication on a standby node.
primary_conninfo='$root_connstr application_name=$name'
standby_mode=on
));
+ return;
}
# Internal routine to enable archive recovery command on a standby node
restore_command = '$copy_command'
standby_mode = on
));
+ return;
}
# Internal routine to enable archiving
archive_mode = on
archive_command = '$copy_command'
));
+ return;
}
# Internal method
# Complain if we expected to find a pidfile.
BAIL_OUT("postmaster.pid unexpectedly not present") if $is_running;
+ return;
}
=pod
my $self = shift;
$self->stop('immediate');
-
+ return;
}
=pod
my $self = shift;
rmtree $self->{_basedir} unless defined $self->{_pid};
+ return;
}
=pod
local $ENV{PGPORT} = $self->port;
TestLib::command_ok(@_);
+ return;
}
=pod
local $ENV{PGPORT} = $self->port;
TestLib::command_fails(@_);
+ return;
}
=pod
local $ENV{PGPORT} = $self->port;
TestLib::command_like(@_);
+ return;
}
=pod
local $ENV{PGPORT} = $self->port;
TestLib::command_checks_all(@_);
+ return;
}
=pod
ok($result, "@$cmd exit code 0");
my $log = TestLib::slurp_file($self->logfile);
like($log, $expected_sql, "$test_name: SQL found in server log");
+ return;
}
=pod
local $ENV{PGPORT} = $self->port;
TestLib::run_log(@_);
+ return;
}
=pod
$self->poll_query_until('postgres', $query)
or croak "timed out waiting for catchup";
print "done\n";
+ return;
}
=pod
$self->poll_query_until('postgres', $query)
or croak "timed out waiting for catchup";
print "done\n";
+ return;
}
=pod
sub TIEHANDLE
{
my $self = shift;
- bless \@_, $self;
+ return bless \@_, $self;
}
sub PRINT
{
BAIL_OUT("system $_[0] failed");
}
+ return;
}
sub run_log
or die "could not write \"$filename\": $!";
print $fh $str;
close $fh;
+ return;
}
# Check that all file/dir modes in a directory match the expected values,
}
},
$dir);
+ return;
}
# Check presence of a given regexp within pg_config.h for the installation
my ($cmd, $test_name) = @_;
my $result = run_log($cmd);
ok($result, $test_name);
+ return;
}
sub command_fails
my ($cmd, $test_name) = @_;
my $result = run_log($cmd);
ok(!$result, $test_name);
+ return;
}
sub command_exit_is
? ($h->full_results)[0]
: $h->result(0);
is($result, $expected, $test_name);
+ return;
}
sub program_help_ok
ok($result, "$cmd --help exit code 0");
isnt($stdout, '', "$cmd --help goes to stdout");
is($stderr, '', "$cmd --help nothing to stderr");
+ return;
}
sub program_version_ok
ok($result, "$cmd --version exit code 0");
isnt($stdout, '', "$cmd --version goes to stdout");
is($stderr, '', "$cmd --version nothing to stderr");
+ return;
}
sub program_options_handling_ok
'2>', \$stderr;
ok(!$result, "$cmd with invalid option nonzero exit code");
isnt($stderr, '', "$cmd with invalid option prints error message");
+ return;
}
sub command_like
ok($result, "$test_name: exit code 0");
is($stderr, '', "$test_name: no stderr");
like($stdout, $expected_stdout, "$test_name: matches");
+ return;
}
sub command_like_safe
ok($result, "$test_name: exit code 0");
is($stderr, '', "$test_name: no stderr");
like($stdout, $expected_stdout, "$test_name: matches");
+ return;
}
sub command_fails_like
my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
ok(!$result, "$test_name: exit code not 0");
like($stderr, $expected_stderr, "$test_name: matches");
+ return;
}
# Run a command and check its status and outputs.
{
like($stderr, $re, "$test_name stderr /$re/");
}
+
+ return;
}
1;
1,
"connect to node $target_name if mode \"$mode\" and $node1_name,$node2_name listed"
);
+
+ return;
}
# Connect to master in "read-write" mode with master,standby1 list.
$node_standby_2->safe_psql('postgres',
qq[SELECT 1 FROM replayed WHERE val = $newval])
or die "standby_2 didn't replay standby_1 value $newval";
+ return;
}
replay_check();
# Stop standby node
$node_standby->teardown_node;
+
+ return;
}
# Initialize master node
}
ok($self->poll_query_until('postgres', $check_sql, $expected), $msg);
+ return;
}
# Initialize master node
));
$node->psql('postgres', "SELECT pg_reload_conf()", stdout => \$psql_out);
is($psql_out, 't', "reload node $name with $parameter");
+ return;
}
# Set up two nodes, which will alternately be master and replication standby.
];
command_ok($cmd, $test_name);
+ return;
}
sub test_connect_fails
];
command_fails_like($cmd, $expected_stderr, $test_name);
+ return;
}
# Copy a set of files, taking into account wildcards
copy($orig_file, "$dest/$base_file")
or die "Could not copy $orig_file to $dest";
}
+ return;
}
sub configure_test_server_for_ssl
# Change pg_hba after restart because hostssl requires ssl=on
configure_hba_for_ssl($node, $serverhost, $authmethod);
+
+ return;
}
# Change the configuration to use given server cert file, and reload
close $sslconf;
$node->restart;
+ return;
}
sub configure_hba_for_ssl
print $hba
"hostssl certdb all ::1/128 cert\n";
close $hba;
+ return;
}
+
+1;
\ No newline at end of file
$line =~ s/$cc (\d{4}), $pgdg/$ccliteral $1-$year, $pgdg/i;
}
untie @lines;
+ return;
}
print "Manually update:\n";
push @{ $all_commits_by_branch{ $c->{'branch'} } }, $cc;
$cc->{'branch_position'}{ $c->{'branch'} } =
-1 + @{ $all_commits_by_branch{ $c->{'branch'} } };
+ return;
}
sub hash_commit
sub output_str
{
($oldest_first) ? ($output_line .= sprintf(shift, @_)) : printf(@_);
+ return;
}
sub output_details
}
}
output_str("\n");
+ return;
}
sub usage
copy($src, $target)
|| confess "Could not copy $src to $target\n";
+ return;
}
sub Install
GenerateNLSFiles($target, $config->{nls}, $majorver) if ($config->{nls});
print "Installation complete.\n";
+ return;
}
sub EnsureDirectories
{
mkdir $target . '/' . $d unless -d ($target . '/' . $d);
}
+ return;
}
sub CopyFiles
lcopy($f, $target . basename($f));
}
print "\n";
+ return;
}
sub CopySetOfFiles
lcopy($_, $tgt) || croak "Could not copy $_: $!\n";
}
print "\n";
+ return;
}
sub CopySolutionOutput
print ".";
}
print "\n";
+ return;
}
sub GenerateConversionScript
print $F $sql;
close($F);
print "\n";
+ return;
}
sub GenerateTimezoneFiles
system(@args);
print "\n";
+ return;
}
sub GenerateTsearchFiles
}
close($F);
print "\n";
+ return;
}
sub CopyContribFiles
}
}
print "\n";
+ return;
}
sub CopySubdirFiles
print '.';
}
}
+ return;
}
sub ParseAndCleanRule
$target . '/include/informix/esql/',
'src/interfaces/ecpg/include/',
split /\s+/, $1);
+ return;
}
sub GenerateNLSFiles
}
}
print "\n";
+ return;
}
sub DetermineMajorVersion
strpool => 'true',
runtime => 'MultiThreadedDLL'
});
+ return;
}
sub AddDefine
my ($self, $def) = @_;
$self->{defines} .= $def . ';';
+ return;
}
sub WriteReferences
</ItemGroup>
EOF
}
+ return;
}
sub WriteFiles
</ItemGroup>
EOF
}
+ return;
}
sub WriteConfigurationHeader
<Platform>$self->{platform}</Platform>
</ProjectConfiguration>
EOF
+ return;
}
sub WriteConfigurationPropertyGroup
<WholeProgramOptimization>$p->{wholeopt}</WholeProgramOptimization>
</PropertyGroup>
EOF
+ return;
}
sub WritePropertySheetsPropertyGroup
<Import Project="\$(UserRootDir)\\Microsoft.Cpp.\$(Platform).user.props" Condition="exists('\$(UserRootDir)\\Microsoft.Cpp.\$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
EOF
+ return;
}
sub WriteAdditionalProperties
<IntDir Condition="'\$(Configuration)|\$(Platform)'=='$cfgname|$self->{platform}'">.\\$cfgname\\$self->{name}\\</IntDir>
<LinkIncremental Condition="'\$(Configuration)|\$(Platform)'=='$cfgname|$self->{platform}'">false</LinkIncremental>
EOF
+ return;
}
sub WriteItemDefinitionGroup
print $f <<EOF;
</ItemDefinitionGroup>
EOF
+ return;
}
sub Footer
</ImportGroup>
</Project>
EOF
+ return;
}
package VC2010Project;
<PlatformToolset>$self->{PlatformToolset}</PlatformToolset>
</PropertyGroup>
EOF
+ return;
}
package VC2013Project;
# Are there any output data files to build?
GenerateContribSqlFiles($n, $mf);
+ return;
}
sub GenerateContribSqlFiles
}
}
}
+ return;
}
sub AdjustContribProj
\@contrib_uselibpq, \@contrib_uselibpgport,
\@contrib_uselibpgcommon, $contrib_extralibs,
$contrib_extrasource, $contrib_extraincludes);
+ return;
}
sub AdjustFrontendProj
\@frontend_uselibpq, \@frontend_uselibpgport,
\@frontend_uselibpgcommon, $frontend_extralibs,
$frontend_extrasource, $frontend_extraincludes);
+ return;
}
sub AdjustModule
$proj->AddFile($i);
}
}
+ return;
}
END
my ($self, $filename) = @_;
$self->{files}->{$filename} = 1;
+ return;
}
sub AddFiles
{
$self->{files}->{ $dir . "/" . $f } = 1;
}
+ return;
}
sub ReplaceFile
$self->AddFile($targetdir . '/' . basename($f));
}
}
+ return;
}
sub AddReference
$self->AddLibrary(
"__CFGNAME__/" . $ref->{name} . "/" . $ref->{name} . ".lib");
}
+ return;
}
sub AddLibrary
{
push @{ $self->{suffixlib} }, $lib;
}
+ return;
}
sub AddIncludeDir
$self->{includes} .= ';';
}
$self->{includes} .= $inc;
+ return;
}
sub AddPrefixInclude
my ($self, $inc) = @_;
$self->{prefixincludes} = $inc . ';' . $self->{prefixincludes};
+ return;
}
sub AddDefine
$def =~ s/"/""/g;
$self->{defines} .= $def . ';';
+ return;
}
sub FullExportDLL
$self->{builddef} = 1;
$self->{def} = "./__CFGNAME__/$self->{name}/$self->{name}.def";
$self->{implib} = "__CFGNAME__/$self->{name}/$libname";
+ return;
}
sub UseDef
my ($self, $def) = @_;
$self->{def} = $def;
+ return;
}
sub AddDir
}
$self->AddDirResourceFile($reldir);
+ return;
}
# If the directory's Makefile bears a description string, add a resource file.
if ($mf =~ /^PGAPPICON\s*=\s*(.*)$/m) { $ico = $1; }
$self->AddResourceFile($reldir, $desc, $ico);
}
+ return;
}
sub AddResourceFile
close($i);
}
$self->AddFile("$dir/win32ver.rc");
+ return;
}
sub DisableLinkerWarnings
$self->{disablelinkerwarnings} .= ','
unless ($self->{disablelinkerwarnings} eq '');
$self->{disablelinkerwarnings} .= $warnings;
+ return;
}
sub Save
$self->WriteFiles($f);
$self->Footer($f);
close($f);
+ return;
}
sub GetAdditionalLinkerDependencies
$? >> 8 == 0 or die "cl command not found";
$self->{platform} = ($output =~ /^\/favor:<.+AMD64/m) ? 'x64' : 'Win32';
print "Detected hardware platform: $self->{platform}\n";
+ return;
}
# Return 1 if $oldfile is newer than $newfile, or if $newfile doesn't exist.
}
close($i);
close($o);
+ return;
}
sub GenerateFiles
<!ENTITY majorversion "$self->{majorver}">
EOF
close($o);
+ return;
}
sub GenerateDefFile
close($of);
close($if);
}
+ return;
}
sub AddProject
EndGlobal
EOF
close($sln);
+ return;
}
sub GetFakeConfigure
</Configurations>
EOF
$self->WriteReferences($f);
+ return;
}
sub WriteFiles
print $f <<EOF;
</Files>
EOF
+ return;
}
sub Footer
<Globals/>
</VisualStudioProject>
EOF
+ return;
}
sub WriteConfiguration
print $f <<EOF;
</Configuration>
EOF
+ return;
}
sub WriteReferences
" <ProjectReference ReferencedProjectIdentifier=\"$ref->{guid}\" Name=\"$ref->{name}\" />\n";
}
print $f " </References>\n";
+ return;
}
sub GenerateCustomTool
move $f, $nf;
}
chdir $savedir;
-
+ return;
}
sub missing
system("dumpbin /symbols /out:$tmpfile $_ >NUL")
&& die "Could not call dumpbin";
rename($tmpfile, $symfile);
+ return;
}
# Given a symbol file path, loops over its contents
$def->{ $pieces[6] } = $pieces[3];
}
close($f);
+ return;
}
sub writedef
}
}
close($fh);
+ return;
}
system(@args);
my $status = $? >> 8;
exit $status if $status;
+ return;
}
sub check
system(@args);
my $status = $? >> 8;
exit $status if $status;
+ return;
}
sub ecpgcheck
system(@args);
$status = $? >> 8;
exit $status if $status;
+ return;
}
sub isolationcheck
system(@args);
my $status = $? >> 8;
exit $status if $status;
+ return;
}
sub tap_check
$mstat ||= $status;
}
exit $mstat if $mstat;
+ return;
}
sub taptest
InstallTemp();
my $status = tap_check(@args);
exit $status if $status;
+ return;
}
sub mangle_plpython3
}
chdir "$topdir";
+ return;
}
sub subdircheck
print join(' ', @args), "\n";
system(@args);
chdir "..";
+ return;
}
sub contribcheck
$mstat ||= $status;
}
exit $mstat if $mstat;
+ return;
}
sub modulescheck
$mstat ||= $status;
}
exit $mstat if $mstat;
+ return;
}
sub recoverycheck
my $dir = "$topdir/src/test/recovery";
my $status = tap_check($dir);
exit $status if $status;
+ return;
}
# Run "initdb", then reconfigure authentication.
system('createdb', quote_system_arg($dbname));
my $status = $? >> 8;
exit $status if $status;
+ return;
}
sub upgradecheck
print "dumps not identical!\n";
exit(1);
}
+ return;
}
sub fetchRegressOpts
Install("$tmp_installdir", "all", $config);
}
$ENV{PATH} = "$tmp_installdir/bin;$ENV{PATH}";
+ return;
}
sub usage
print "$file references $symbol, defined in @places\n";
# print "includes: @includes\n";
+
+ return;
}
"You appear to have GNU indent rather than BSD indent.\n";
exit 1;
}
+
+ return;
}
}
close($eh);
}
+ return;
}
|| die "cannot open file \"$source_filename\": $!\n";
print $src_fh $source;
close($src_fh);
+ return;
}
. $pre_fh->filename . " "
. $post_fh->filename
. " >&2");
+ return;
}
$ENV{PGINDENT} = abs_path('pg_bsd_indent');
chdir $save_dir;
+ return;
}
system("rm -rf src/tools/pgindent/pg_bsd_indent");
system("rm -f src/tools/pgindent/tmp_typedefs.list");
+ return;
}
# allow octal constants with leading zeros
[-ValuesAndExpressions::ProhibitLeadingZeros]
+
+# for now raise severity of this to level 5
+[Subroutines::RequireFinalReturn]
+severity = 5
+
# locate all Perl files in the tree
{
# take all .pl and .pm files
- find . -type f -a \( -name '*.pl' -o -name '*.pm' \) -print
+ find . -type f -name '*.p[lm]' -print
# take executable files that file(1) thinks are perl files
find . -type f -perm -100 -exec file {} \; -print |
egrep -i ':.*perl[0-9]*\>' |
or die "mv failed: $?";
$fixedfiles .= "\t$filename\n";
+ return;
}
projects / postgresql.git / commitdiff