MLDBM example removed (as its own module, it has a separate CPAN
reality now).
-Fixed bugs in handling keys with weird characters. Perl can be
+Fixed bugs in handling keys with wierd characters. Perl can be
tripped up in its implicit quoting of the word before '=>'. The
fix: C<Data::Dumper::Purity>, when set, always triggers quotes
around hash keys.
package Data::Dumper;
BEGIN {
- $VERSION = '2.157'; # Don't forget to set version and release
+ $VERSION = '2.156'; # Don't forget to set version and release
} # date in POD below!
#$| = 1;
=head1 VERSION
-Version 2.157 (January 28 2015)
+Version 2.156 (January 20 2014)
=head1 SEE ALSO
if (!val)
return 0;
- /* If the output buffer has less than some arbitrary amount of space
+ /* If the ouput buffer has less than some arbitrary amount of space
remaining, then enlarge it. For the test case (25M of output),
*1.1 was slower, *2.0 was the same, so the first guess of 1.5 is
deemed to be good enough. */
somehow never got into this copy. [Steve Hay]
- Added a new 'defines' parameter to compile(), which gives a
- platform-independent way to specify various -Dfoo=bar (or the
+ platform-independant way to specify various -Dfoo=bar (or the
equivalent) compiler defines. [Randy W. Sims]
0.14 Mon Sep 19 13:40:37 CDT 2005
}
### TEST 15
-### Set up some data to be transferred between the server and
+### Set up some data to be transfered between the server and
### the client. We'll use own source code ...
#
local @data;
+1:+32:4294967296
+1:+48:281474976710656
+8:-2:NaN
-# exercise base 10
+# excercise base 10
+12345:4:10:123450000
-1234:0:10:-1234
+1234:0:10:1234
+4294967296:+32:1
+281474976710656:+48:1
+2:-2:NaN
-# exercise base 10
+# excercise base 10
-1234:0:10:-1234
+1234:0:10:1234
+200:2:10:2
96969696969696969696969696969678787878626262626262626262626262:484848484848484848484848486666666666666689898989898989898989:199,484848484848484848484848123012121211954972727272727272727451
# bug in v1.76
1267650600228229401496703205375:1267650600228229401496703205376:0,1267650600228229401496703205375
-# exercise shortcut for numbers of the same length in div
+# excercise shortcut for numbers of the same length in div
999999999999999999999999999999999:999999999999999999999999999999999:1,0
999999999999999999999999999999999:888888888888888888888888888888888:1,111111111111111111111111111111111
999999999999999999999999999999999:777777777777777777777777777777777:1,222222222222222222222222222222222
+1:+32:4294967296
+1:+48:281474976710656
+8:-2:NaN
-# exercise base 10
+# excercise base 10
+12345:4:10:123450000
-1234:0:10:-1234
+1234:0:10:1234
3.06 Thu Feb 20 2014
- updated for 5.19.9
- fix Module::CoreList::is_core default perl version
- - fix Module::CoreList::is_core version comparison
+ - fix Module::CoreList::is_core version comparision
3.05
- Prepared for v5.19.9
2.09 Sun Oct 6 14:12:40 CEST 2002
- Upgraded the Makefile.PL to install Safe.pm to the correct place.
- - Made it work on 5.6 at least, maybe even on 5.005?
+ - Made it work on 5.6 atleast, maybe even on 5.005?
2.08 Sat Oct 5 18:05:32 CEST 2002
- First CPAN release, prompted by bug number 17744 on rt.perl.org.
The bug was introduced as development perl change 16442 (on
2002/05/07), so has been present since 2.00.
Patches to introduce more regression tests to reduce the chance of
- a reoccurrence of this sort of goof are always welcome.
+ a reoccurence of this sort of goof are always welcome.
Thu May 30 20:31:08 BST 2002 Nicholas Clark <nick@ccl4.org>
use vars qw($canonical $forgive_me $VERSION);
-$VERSION = '2.53';
+$VERSION = '2.52';
BEGIN {
if (eval { local $SIG{__DIE__}; require Log::Agent; 1 }) {
* Write magic number and system information into the file.
* Layout is <magic> <network> [<len> <byteorder> <sizeof int> <sizeof long>
* <sizeof ptr>] where <len> is the length of the byteorder hexa string.
- * All size and lengths are written as single characters here.
+ * All size and lenghts are written as single characters here.
*
* Note that no byte ordering info is emitted when <network> is true, since
* integers will be emitted in network order in that case.
isa_ok( $thawed->[1], 'My::GoodAttach::MultipleReferences' );
is($thawed->[0], $thawed->[1], 'References to the same object are attached properly');
- is($thawed->[1]{id}, $obj->{id}, 'Object with multiple references attached properly');
+ is($thawed->[1]{id}, $obj->{id}, 'Object with multiple references attchached properly');
package My::GoodAttach::MultipleReferences;
sub O_ACCMODE () { O_RDONLY | O_RDWR | O_WRONLY }
-$VERSION = "1.02";
+$VERSION = "1.01";
my $DEFAULT_MEMORY_SIZE = 1<<21; # 2 megabytes
-my $DEFAULT_AUTODEFER_THRESHOLD = 3; # 3 records
-my $DEFAULT_AUTODEFER_FILELEN_THRESHOLD = 65536; # 16 disk blocksful
+my $DEFAULT_AUTODEFER_THRESHHOLD = 3; # 3 records
+my $DEFAULT_AUTODEFER_FILELEN_THRESHHOLD = 65536; # 16 disk blocksful
my %good_opt = map {$_ => 1, "-$_" => 1}
qw(memory dw_size mode recsep discipline
- autodefer autochomp autodefer_threshold concurrent);
+ autodefer autochomp autodefer_threshhold concurrent);
sub TIEARRAY {
if (@_ % 2 != 0) {
$opts{autodefer} = 1 unless defined $opts{autodefer};
$opts{autodeferring} = 0; # but is not initially active
$opts{ad_history} = [];
- $opts{autodefer_threshold} = $DEFAULT_AUTODEFER_THRESHOLD
- unless defined $opts{autodefer_threshold};
- $opts{autodefer_filelen_threshold} = $DEFAULT_AUTODEFER_FILELEN_THRESHOLD
- unless defined $opts{autodefer_filelen_threshold};
+ $opts{autodefer_threshhold} = $DEFAULT_AUTODEFER_THRESHHOLD
+ unless defined $opts{autodefer_threshhold};
+ $opts{autodefer_filelen_threshhold} = $DEFAULT_AUTODEFER_FILELEN_THRESHHOLD
+ unless defined $opts{autodefer_filelen_threshhold};
$opts{offsets} = [0];
$opts{filename} = $file;
@{$self->{deferred}}{$first_rec .. $last_rec});
}
- $self->_discard; # clear out deferred-write-cache
+ $self->_discard; # clear out defered-write-cache
}
sub _flush {
}
$self->_mtwrite(@args); # write multiple record groups
- $self->_discard; # clear out deferred-write-cache
+ $self->_discard; # clear out defered-write-cache
$self->_oadjust(@adjust);
}
# Now, what does the ad_history mean, and what is this function doing?
# Essentially, the idea is to enable autodeferring when we see that the
# user has made three consecutive STORE calls to three consecutive records.
-# ("Three" is actually ->{autodefer_threshold}.)
+# ("Three" is actually ->{autodefer_threshhold}.)
# A STORE call for record #$n inserts $n into the autodefer history,
# and if the history contains three consecutive records, we enable
# autodeferment. An ad_history of [X, Y] means that the most recent
my ($self, $n) = @_;
return unless $self->{autodefer}; # feature is disabled
return if $self->{defer}; # already in explicit defer mode
- return unless $self->{offsets}[-1] >= $self->{autodefer_filelen_threshold};
+ return unless $self->{offsets}[-1] >= $self->{autodefer_filelen_threshhold};
local *H = $self->{ad_history};
if ($n eq 'CLEAR') {
} else { # @H == 2
if ($H[1] == $n-1) { # another consecutive record
$H[1]++;
- if ($H[1] - $H[0] + 1 >= $self->{autodefer_threshold}) {
+ if ($H[1] - $H[0] + 1 >= $self->{autodefer_threshhold}) {
$self->{autodeferring} = 1;
}
} else { # nonconsecutive- erase and start over
# $self->[MISS]++ if $self->[STAT][$key]++ == 0;
# $self->[REQ]++;
# my $hit_rate = 1 - $self->[MISS] / $self->[REQ];
-# # Do some testing to determine this threshold
+# # Do some testing to determine this threshhold
# $#$self = STAT - 1 if $hit_rate > 0.20;
# }
print "1..1\n";
-my $testversion = "1.02";
+my $testversion = "1.01";
use Tie::File;
if ($Tie::File::VERSION != $testversion) {
$N++;
# I am an undocumented feature
-$o->{autodefer_filelen_threshold} = 0;
+$o->{autodefer_filelen_threshhold} = 0;
# Normally autodeferring only works on large files. This disables that.
# (3-22) Deferred storage
$o = tie @a, 'Tie::File', $file, autodefer => 0;
die $! unless $o;
# I am an undocumented feature
-$o->{autodefer_filelen_threshold} = 0;
+$o->{autodefer_filelen_threshhold} = 0;
# Normally autodeferring only works on large files. This disables that.
# (57-59) Did the autodefer => 0 option work?
sprintf("Check we get the same thing (%x vs %x)",
threads::shared::_id($$gg),threads::shared::_id($$gg2)));
ok(9, $$gg eq $$gg2, "And check the values are the same");
-ok(10, keys %foo == 0, "And make sure we really have deleted the values");
+ok(10, keys %foo == 0, "And make sure we realy have deleted the values");
{
my (%hash1, %hash2);
share(%hash1);
https://perl5.git.perl.org / perl5.git / commitdiff