Correctly handle SvOOK scalars. 5.12 and later don't use SvIVX().

ppport.h defined NV if necessary, so no need to duplicate that.

Add -DPURIFY sizes to body_sizes[]

Use two macros to simplify the logic - MAYBE_OFFSET() where the normal version
subtracts a STRUCT_OFFSET(), and the purify version subtracts nothing, and
MAYBE_PURIFY() where there is not a simple relationship between the two sizes.

Use a table for SV body sizes. These incorporate the space saving post 5.8.x

For now, the sizes under -DPURIFY aren't correct.

In sv_size(), refactor the PV-derivatives to share as much code as possible.

As a side effect, PV"BM"s are now handled correctly on 5.10.0 and later.

In sv_size(), coalesce all calls to magic_size().

Bump $VERSION to 0.75_52

This is 0.75_51 - update META.yml

For other-than-gcc, generate calls to check_new(...)

Only use a static array of vtables on gcc. Some other compilers may be happy
with it, but VC certainly isn't. It's only trivial to determine gcc or not.

Bump $VERSION to 0.75_51

This is 0.75_50 - update META.yml

eval $ExtUtils::MakeMaker::VERSION to avoid warnings about _ not being numeric.

Frustratingly ExtUtils::MakeMaker->VERSION() returns the literal value of
$ExtUtils::MakeMaker::VERSION so it's just as "not numeric" as reading the
scalar directly.

Re-indent Makefile.PL consistently.

Simplify magic_size() by knowing that check_new() returns false for NULL.

Add the size of mg_len if mg_ptr is non-NULL.

With special cases for UTF-8 caching magic, which abuses mg_len, and for
mg_len == HEf_SVKEY

Follow mg_obj, which points to an SV.

Add tests for sizing magic.

The core's magic vtables are global constants, so aren't part of the size.

Parse perl.h to find the names of the vtables' names, and generate code to add
them all in new_state() as "seen".

Bump $VERSION to 0.75_50

This is 0.75 - update META.yml

Bump $VERSION to 0.75

This is 0.74_53 - update META.yml

Skip the aelemfast size comparison test for perls which predate the code change.

It was merged to maint-5.8 between 5.8.3 and 5.8.4, so 5.8.4 and later have it.
For 5.8.3 and earlier, the assumptions the test makes about sizes (based on op
structure) are bogus.

Skip GvFILE on ithreaded 5.8.8 and earlier, as it can point to freed memory.

Probably better to slightly under report sizes, than report something random or
SEGV.

Set the pointer alignment (in bits) via a C macro generated by the Makefile.PL

The previous approach of using sizeof(void *) is flat out wrong on a 64 bit
system. The right answer is 3. It gives 4. Which isn't a problem once the
pointer rotation code in check_new() isn't buggy, but isn't as efficient as
desired.

Fix typo error in bit-vector tracking mechanism, causing bogus "seen before"s.

On 64 bit platforms which allocate on 8 byte alignment (rather than 16), a low
pointer bit could get lost, resulting in new pointers being considered already
"seen". Joy, hilarity, failing tests and different results running under gdb.
"Found" by BinGOs' smoker, fixed on spectre.mongueurs.net. The help was
appreciated.

Bump $VERSION to 0.74_53

This is 0.74_52 - update META.yml

SvOK() && SvROK() is a tautology - SvROK() true has always implied SvOK() true.

So no need to check SvOK() first on 5.10 or earlier.

total_size() and size() can be XS ALIASes, now all the logic is in sv_size()

Move iteration over array values from total_size() to sv_size()

For now this requires some bodgery over when array values should be recursed
into. Arrays presented to total_size() should be properly recursed into.
However, historically the inner arrays of padlists were never traversed, which
means there is no code to deal with the special case rules for them. So to avoid
the perfect being the enemy of the good, defer writing that code, by skipping
the inner arrays of padlists for now.

Handle sizes for PVGVs in sv_size() only.

Previously the logic was duplicated in total_size().

Move iteration over hash values from total_size() to sv_size()

For now this requires some bodgery over when hash values should be recursed
into. Hashes presented to total_size() should be properly recursed into, else
the size of symbol tables isn't correctly reported. However, the back-link
from a CV to its stash shouldn't be traversed, as shouldn't GVs referenced from
OPs, else we run the risk of passing through %::, and adding the size of all
the symbol tables (and subroutines) to the size of a subroutine reference we
were directly passed. Whilst this might be useful in some cases, it isn't useful
as a default, and it isn't even vaguely consistent with the sizes total_size()
historically reported.

Fix potential SEGVs for PVBMs on 5.10.0 and later.

5.10.0 stores PVBMs as PVGVs. Hence not all PVGVs are typeglobs, and XS code
should check isGV_with_GP() is true before performing typeglob lookups.

The PVGV code currently ignores SvCUR()/SvLEN(), so for now the size of PVBMs
is under-reported on 5.10.0 and later.

The optree holds pointers to GVs under multiplicity. It's ithreads that differs.

Hence the tests that are conditional on the different behaviours should be
{unthreaded,multiplicity} vs {ithreads}, not
{unthreaded} vs {multiplicity,ithreads}

In op_size, add break statement missing for OPc_PVOP.

This has been missing since op_size was added in 0.60. Without it, PVOPs would
run on into the OPc_LOOP case, which would likely SEGV as it would consider
the char *op_pv as OP *op_first, and non-existent op_last, op_redoop, op_nextop
and op_lastop.

Fix potential SEGVs for OP_AELEMFAST on a lexical.

OP_AELEMFAST is wonderfully special, in that it can be used to replace both
OP_GV and OP_PADAV. The latter is only a baseop, whereas OP_AELEMFAST is a
flagged as a padop/svop. baseops are smaller, and (therefore) don't have memory
allocated where op_sv "should" be.

Add tests for subroutines and subroutine references.

Bump $VERSION to 0.74_52

This is 0.74_51 - update META.yml

Fix classic off-by-one error - the answer is strlen() + 1, not just strlen()

This has been in the code since year dot, and no-one has spotted that the
returned sizes have been under-reporting.

Move the check_new() test to the start of sv_size()

For now, this requires sv_size() to return new-or-not, but it prepares the way
to move all structure recursion into sv_size(). Currently it's in two places -
sv_size() and total_size().

This resolves two long-standing bugs in typeglobs - total_size() was double
counting entries in typeglobs, and sv_size() was double-counting the PVGV size
if GvEGV() looped back.

Add many tests for typeglobs.

These reveal several bugs.

Don't count PL_sv_{undef,no,yes} in the size returned

PL_sv_{undef,no,yes} are singletons, interpreter wide, so shouldn't count as
part of the size.

Bump $VERSION to 0.74_51

This is 0.74_50 - update META.yml

Ensure that size() doesn't add the referent's size for non SVt_RV references.

Previously it was adding the referent's size if the reference happened to be
other-than-SVt_RV (ie a blessed reference, or a reference assigned to a
previously used variable).

This requires stopping thing_size() from recursing into references when called
from size(). So add a boolean parameter controlling whether to recurse. As this
means changing every call to it, also rename it to sv_size(), and re-order the
parameters so that struct state is first.

Test that unallocated gaps within arrays have zero size.

This gets to be a bit more complex than it would first seem, as Test::More's
is_deeply() gets the length of arrays using $#array syntax, and that operation
allocates structures within the array prior to 5.12. We can't use
stringification, as we need to test undefs, so roll our own minimal test
subroutine.

Bump $VERSION to 0.74_50

This is 0.74 - update META.yml

LICENSE was added to ExtUtils::MakeMaker in 6.31, not 6.30

Bump $VERSION to 0.74

This is 0.73_51 - update META.yml

check_new() is now never called with NULL st, so simplify it slightly.

Add check_new_and_strlen(), which is check_new(...) && total_size += strlen(...)

This removes an oft-repeated pattern.

check_new(st, NULL) always returns 0, so no need to check NULL before calling it

Move the check_new() test to the start of regex_size(). All 1 caller uses it.

Move the check_new() test to the start of op_size(). All callers used it.

This reduces the amount of repetition in the source code. Whilst it likely will
cause one extra level of function calling at runtime (for a "seen before" OP,
as op_size() now needs to be entered), it will reduce object code size, which
will compensate. Not measured the difference, but expect it all to be dwarfed
anyway by cache misses on data reads. Maintainability wins.

Also as these are major changes, reindent all sections of op_size() which have
changed.

Refactor the C code to accumulate the size inside the tracking structure

The C *_size() functions now return void. Mark all as static.
The XS functions size() and total_size() now return UV, not IV.

Eliminate conditional 5.11/older conditional code that is actually unnecessary.

Need to use SvRV_const() for const correctness, which isn't in ppport.h, so
provide our own fallback definition when needed.

The logic used for pre-5.11 is (locally) correct for post 5.11 too.
However, the intent of the *design* of the module is that references never get
into this part of the code. Unfortunately, in turn, the implementation of the
design isn't right, and they do. However, the fix for this is actually to fix
the design, because it too isn't right.

Remove dead code: #if PERL_VERSION <= 8 then PERL_VERSION is definitely < 11.

Bump $VERSION to 0.73_51

Missed the second change between 0.73 and 0.73_50

This is significant, as the pair of changes should address all test smoke
failures. Fingers crossed.

This is 0.73_50 - update META.yml

Re-instate initial dereference in total_size()

We most definitely can push an AV or an HV onto the pending array. Despite
having a comment saying that we can't do that, that was exactly what the
previous code *was* doing, only within the switch statement.

Previously, this code:

    my $a = [];
    my $b = \$a;
    weaken $b;
    total_size($a)

was returning a value which happened to be the size of the magic structure
(but not the object hanging from it - fixme) due to the interaction of two
different bugs. The number it pulled out of its backside was
thing_size(rv, st) - thing_size(rv, NULL), where thing_size(...) called
magic_size(...), and that returned 0 always if the st parameter was NULL,
because check_new(st, p) always returns FALSE (ie not new) if the first
parameter is NULL. Good eh?)

Avoid using assert() on ithreaded 5.8.8 and earlier, as it needs my_perl

Bump $VERSION to 0.73_50

This is 0.73 - update META.yml

Update CHANGES for 0.73

Correct the year 2111 to 2011 in two previous entries.

Bump version to 0.73

Revert the intent of cb11131e. st (was tv) can be NULL.

There's (currently) a call to thing_size() with a NULL st early in total_size().
None of the existing tests caused a code path to be followed that reaches the
assertion, so add one that does.

This is 0.72_52 - update META.yml

Replace TRACKING with struct state, tv with st, and rename {new,free}_tracking()

Merge the 4 static variables and TRACKING into a struct state.

Add a new static function new_tracking(), to mirror free_tracking().

Add a test for the non-exceptional warnings.

Requires Test::PerlRun, which doesn't yet exist on CPAN. Otherwise it skips.

Use cmp_ok() when testing > 0, not isnt(..., 0);

Eliminate needless test boilerplate, and duplicated effort.

There's no need to change directory or duplicate the effects of -Mblib.
Let use do the importing, rather than an explicit import call.
use_ok() is arguably harmful - just let the use fail and take the entire test
out cleanly, rather than carrying on and generating meaningless failures.
No need to test ->can() and $VERSION in both - once is sufficient.

Simplify the setup code in Size.pm

We don't use @EXPORT, so don't mention it. As the only tag is :all, declare
@EXPORT_OK first, and define %EXPORT_TAGS in terms of it.

Bump $VERSION to 0.72_52

This is 0.72_51 - update META.yml

Add PERL_NO_GET_CONTEXT to improve performance under multiplicity.

Add pTHX_ to thing_size() and op_size(). Also change both to static.

Remove the SIGNATURE, as presently I don't have the capability to sign dists.

The SIGNATURE file was from the 0.71 release, so was already rather stale.

Add the .git repository directory to MANIFEST.SKIP

Add a LICENSE section to the Makefile.PL.

Bump $VERSION to 0.72_51

This is 0.72_50 - update META.yml

Convert C99 // comments to C89 /**/ comments.

On some platforms, the only compilers are dogmatically C89.

Remove the comment '?try', presumably a reference to a possible place to use
__try/__except. There's something seriously wrong with the internal's data
structures if the chain of magic pointers is corrupt - carrying on silently
isn't a great idea.

Remove commented out code from the pre-0.72 HV based tracking system.

Include the size of constants in constant subs (resolves CPAN #58485)

Resolve CPAN #58484: Devel::Size SEGVs on XSUBs post 5.9.4

Note that I am now maintaining it.

Clarify that BrowserUK wrote the version of the pointer tracking for 0.72.
0.73's version has been somewhat refactored by me. (So blame me for the bugs.)

Enforce the minimum perl version requirement in the Makefile.PL

This inform CPAN smokers to skip testing on earlier perl versions.

Convert to XSLoader.

Convert the tracking system to a 256-way tree.

This avoids needing to make compiled-in assumptions about the memory map on 64
bit systems, which in turn means all the code and documentation relating to
that, and how to recompile if the assumptions fail, can go.

Create free_tracking() to de-duplicate the code to free the tracking structure.

Use cmp_ok() in place of ok() with a < comparison, for better diagnostics.

Eliminate an unused lexical $tests.

In check_new(), tv can never be NULL, so assert() this.

This will simplify future refactoring.

Use SvPVX_const() instead of SvPVX(), and const check_new().

Also change check_new()'s return type to bool, as it only returns TRUE or FALSE,
and declare it static.

Without the consting, under -DDEBUGGING, the macro for SvPVX() assigns thing,
which is const SV *, to a void *, which elicits a legitimate compiler warning.
In turn, the return value of SvPVX_const() is const char *, which means that
check_new() needs to properly declare its parameter p as const void *.

Catching SEGVs with __try/__except is MSVC only, not general C++

__try/__except is an MSVC extension to C++ *and* C, and is orthogonal to
"regular" C++ exception handling. As there's no way to catch a SEGV with
C++ exceptions (certainly not portably), and __try/__except is available in C,
there's nothing to be gained from using C++ exceptions, and hence making the
code require a C++ compiler. Hence remove the logic from Makefile.PL to force
compilation with a C++ compiler, which didn't even work well on "both" kinds of
OS, as it assumed that the C compiler was named *exactly* qr/\Ag?cc\z/, and
that the analogous C++ compiler was available and named g++.

[Which isn't true when it's named 'ccache gcc', 'gcc-mp-4.6' etc, or when cc
isn't gcc]

No need to explicitly check AvARYLEN in 5.10 and later.

In 5.10 the struct slot was eliminated, and contents are now stored in magic,
which will already be found. Whilst there's no direct "harm" in looking again,
as the "seen" tracker will skip the second discovery, it's wasteful, and now
generates a compilation error, as AvARYLEN() expects a mutable pointer, whereas
the variable thing is const void *.

This also resolves CPAN RT #49437 - Devel::Size adds magic in Perl 5.10