use a more sensible homepage value for XSLoader

xs_boot_epilog (Xp): change ax from U32 to I32

we need to match the declaration of ax

Remove uselongdoubles false claim.

Missed this spot in 568793b6.

Check for POSIX locales once.

Makes loc_tools users safe under minitest.
Currently op/quotemeta.t and op/taint.t are failing there.

utf8.h: Add dummy param for when macros placed in API

These macros are not in the public API, but they might be someday.  We
may want to check for valide UTF-8 at some point.  Add a parameter so
that is possible then without having to change the API.

This also changes to use the short name of one macro

t/op/tr.t: Fix comment

This was confusing, and a likely interpretation is wrong: [i-j]  doesn't
match the gap characters in EBCDIC

utf8.h: Fix typo in macro name definition

The trailing underscore was unintended.

utf8.h, utfebcdic.h: Add comments; white-space only

t/opbasic/cmp.t: Add test for NUL

NUL can present problems for string handling; better test it

pp_pack.c: Add comment

pp.c: Fix typo in comment

regen/mk_PL_charclass.pl: Suppress extra null array element

We don't output a trailing comma after the final element in these C
arrays, and thus prevent the C compiler from generating a useless null
element

utf8.h: Add UTF8_SKIP as a synonym for UTF8SKIP

Most of the other names in utf8.h have an underscore; this allows
someone to keep things consistent in their code.

utfebcdic.h: Comments only

utf8.h: White-space only

Align some macro definitions vertically to make it easier to read

handy.h: White-space only

Stops lines from exceeding 80 cols, and aligns columns vertical for
easier reading

op.c: Fix typo in comment

perlapi: Use F<> around file names

perlapi: Use C<> instead of I<> for parameter names, etc

The majority of perlapi uses C<> to specify these things, but a few
things used I<> instead.  Standardize to C<>.

re/re_tests: Rmv comment

This was a comment I added for debugging, and forgot to remove

toke.c: White-space, comment, added braces only

This makes && and || begin lines instead of end them for easier
following of the logic, as suggested in Perl Best Practices.  A couple
of { } pairs were added to make the code within an 'if' stand out from
the 'if' test itself.

Upgrade Filter-Util-Call from version 1.54 to 1.55

Upgrade Encode from version 2.75 to 2.76

Add Ivan Pozdeev to AUTHORS

extra guard against spaces in paths (spotted by Ivan Pozdeev)

Consistently use -o a.out (spotted by Ivan Pozdeev)

There is no default dflt for usedtrace (spotted by Ivan Pozdeev)

perldelta for 3480fbaaaea8

Cwd.pm, dont repeatedly access magic %ENV vars

%ENV is magic/tied, a lexical is faster than calling out to magic APIs
with gets and sets (or checks for them). Less glob and hash lookups too.

Return the lexical instead of the magic var so there isn't a search for
magic from pp_leavesub's sv_mortalcopy. Even though env mg vtable doesn't
have a getter or GMAGIC, SvVSTRING_mg executes mg_find for random, get
and set magic inside Perl_sv_setsv_flags.

Update perlfaq to CPAN version 5.021010

  [DELTA]

5.021010    20152015-07-28 18:30:48Z
  * Fix typo (Douglas L. Jenkins)
  * Fix Time::Seconds example (Niko Tyni)
  * Basic README.pod (Shlomi Fish)

Use U64 (a type) instead of U64TYPE (a define).

Builds on top of 16d89be8.

Allow perl to work again with all Unicode releases

Compiling perl to work with early Unicode releases is a goal, but has
been broken since 5.18.  This sequence of commits gets this working
again, actually better than before.

perldelta entry for mktables changes

lib/unicore/README.perl: Update

This makes some changes and adds instructions for compiling older
Unicode versions.

mktables: Minimize use of version numbers for decisions

I found these places where file existence can be used instead of knowing
what version something happened in.  Sometimes those numbers are wrong,
and one of these was.  If it can be avoided, better not to use version
numbers

mktables: improve LineBreak table for early Unicodes

It turns out that the generated map files look better (even if
functionally equivalent) if the default mapping is the one to the
above-Unicode code points.  This was the only one that had it different.

mktables: Make sure \p{Space} works in all Unicodes

This isn't defined by Unicode until a later version, but Perl wants it
in all versions.

mktables: Fix up Name_Alias in early Unicodes

perl needs the Name_Alias property accessible in all releases in order
for charnames to work properly.  However the property was not created
until Unicode version 5.0.  Previously, the property was made available
to all Unicode versions, which is contrary to the policy of exposing
properties to public use only when Unicode so exposes them.  Thus the
behavior is as close as possible to Unicode-specified.  This commit
creates an internal-only property for the perl core, and removes the
general access on early Unicode releases.

mktables: Add handling of WB and SB for early Unicodes

This allows \b{wb} and \b{sb} to work on all Unicode releases.  The huge
number of differences in charclass_invlists.h is only because the names
of the SB and WB tables change, and the code automatically
re-alphabetizes things.

mktables: Fix GCB to work on early Unicodes

The GCB property was not properly being generated in early Unicode
releases.  The huge commit diff is due solely to the fact that the name
changes of this property so it is sure to not be accessible outside the
perl core, and the property tables are automatically resorted
alphabetically.

mktables: Convert Hangul_Syllable_Type to use new early infrastructure

This allows us to remove some special handling.

mktables: Convert PropValueAliases.txt to use new early infrastructure

This file is crucial to compiling perl these days.  This commit converts
to use the new infrastructure for dealing with compiling Unicode
releases prior to when this file was made available.

mktables: Convert PropertyAliases.txt to use new early infrastructure

This file is crucial to compiling perl these days.  This commit converts
to use the new infrastructure for dealing with compiling Unicode
releases prior to when this file was made available.

mktables: Add code for easier handling of early Unicode versions

This adds infrastructure to the constructor of the Input_file class to
allow an alternative to be specified when compiling a Unicode release
that is earlier than the file first became available.

This is only used when the property is used by core perl and has to work
in all releases.  For example the qr/\X/ construct should always work,
but relies on a property that isn't specified before Unicode 4.1.  This
allows for easier specification of how to handle this type of case.

mktables: Use Input_file class for always skipped files

Until this commit there were two mechanisms available to specify files
in the Unicode Character Database are not used by mktables.  Now there
is one.  The global that contained such files is deleted, and instead
all such files are specified by an Input_file class object.  This has
the advantage of just one method, and the constructor already has
parameters to specify when a file first appeared, and when it was
removed.  This allows automatic generation of the pod, listing just the
appropriate files for the version being compiled.  It also allows for
the automatic check of all files to see that they are DOS 8.3 filesystem
compatible.  And it allows for some code simplification.

Unicode specifies some .html files in the UCD.  These are always skipped
(so far, and likely forever), and were in the global.  Now they are in
the constructor, which means that the code that looks for potential
files that aren't being handled has to be changed to also look for .html
files as well.

mktables: For 8.3 filesystems, the suffix matters

Two files can have the same file name, but be different if they have
different suffixes.  Until this commit, mktables thought they were the
same, because it ignored the suffix when calculating this.  Some files
are version strings like "3.1" which look like a floating point number.
These are converted to like "3_1" first so that the .1 doesn't look like
a suffix.

mktables: Use new infrastructure for optional files

This follows up the previous commit by actually using the new
infrastructure it created.  The optional Unihan files are switched to
use the new capabilities.  This means that the globals they previously
used are no longer necessary, and are ripped out here.

mktables: Improve handling of optional files

Some files in the Unicode Character Database are optional for perl.
Currently these are all Unihan files for East Asian languages.  This
commit adds infrastructure to the class for input file objects to more
automatically handle the case when the file is present vs not.
Currently, one has to hand edit mktables to cope with the file getting
plunked down in the directory to be compiled.  This commit is a step
towards making the editing unnecessary.

mktables: Add specifiable construction handler for Input_file class

This object is for the files in the Unicode Character Database.  This
commit adds the capability for the constructor new() to be passed a code
reference to call after everything else is constructed, but before
control is returned.

mktables: Unicode has withdrawn some files in the UCD

This adds the capability to mktables to seamlessly handle the case where
Unicode has removed a file from the Unicode Character Database that
existed in prior versions.  The constructor for the object tells what
release no longer has it.  The file is looked for only when compiling a
Unicode version in the window that had it.

mktables: Revamp constructor and run method for input objects

Each .txt file that Unicode furnishes as part of the Unicode Character
Database has an object created for it, and there is a run() method to
actually look at the input file and process it.  This commit moves some
code from the run() method into the constructor to pave the way for
future commits (hence some of the awkward constructs and indentation in
this one; these minimize the commitdiffs in later ones).

mktables: Allow multiple eof handlers for input files

The Input_file class is hereby extended so there can be more than one
subroutine stacked to call when an EOF is encountered.  This new
capability will be used in later commits.  There is no current need for
any outside class to look at this, so that capability is removed.

mktables: Suppress output files that shouldn't be written

mktables takes files as input as furnished by Unicode, munges things,
and outputs files containing tables that are more suitable for use by
the rest of perl.  A placeholder table is one that isn't supposed to be
output, but whose values are needed for internal calculations.  Prior to
this commit, those tables were being output.

mktables: Rmv extraneous sub return value

The return value of this function isn't looked at.

mktables: Handle default for Gc property better

Unicode changed the default name they specify in their data from the
abbreviation to the long form in version 7

mktables: Handle \b{gcb}, \X better in Unicode 1

The Hangul syllables in version 1 of Unicode were withdrawn and replaced
with the ones we know in version 2.  Should perl ever be compiled on
version 1, this commit causes the old syllables to work better than they
do now, though imperfectly.  This is used only in the \X and \b{gcb}
constructs.

mktables: Two files came along later than mktables thinks

NormTest.txt LBTest.txt were really in later releases.  This fixes that
and moves each constructor to be in the respective release's group of
files.

mktables: Use variables for repeated text

This text is actually used to group values in the generated pod.  By
using a variable, we make sure it is exact in every usage, so the values
are sure to get grouped properly.

mktables: Rmv wrong code point in list

This was a typo, but it hasn't done any harm as it is an unassigned code
point, which gets weeded out.  Still it has no business being here.

mktables: Easier debugging

This turns off some inconsequential annoying warnings during certain
debugging situations

mktables: Remove unused assignment

mktables: Reindent after prev. commit

That commit added a nesting block, so indent an extra level, and reflow
the text to fit in 79 columns.

Properly handle the Unicode kIICore property

This property is not included in the standard Perl distribution, but it
is normative in the Unicode Unihan database and perl can be compiled to
include it.  This property is currently unique in that it operates much
like how Perl defines string truthfulness: non-empty values are
considered true.  That is \p{kIICore} matches all characters which have
a non-empty value for this property, plus the actual values have
meaning that may need to be examined in some circumstances.  These can
be retrieved via Unicode::UCD::prop_invmap().

Unicode 7.0 changed this property without my noticing, and went a very
different direction with it than I anticipated.  And the perl
interpreter would loop when trying to deal with it under some
circumstances.

This property is true for all 'core' Chinese/Japanese/Korean characters
that every implementation of CJK things should strive to handle, i.e., the
minimally acceptable set, though the values now specify a precedence as
their first letter, A, B, or C (I suppose this means one could implement
just the A level ones first).  The remaining letters in each value
encode the standards which were used as the source for the character.
In previous versions of the Standard, every non-null value was the
string "2.1".

perluniprops: Don't list longer name as shorter

perluniprops has cross references to shorter synonyms for properties.
In the section for the properties accessible by Unicode::UCD (not \p{}),
sometimes the shorter name wasn't actually shorter.  This fixes that.

Unicode::UCD: Handle inverted input

No current input comes inverted, but it could some time in the future,
and we wouldn't know.  In one case, it's easy to handle, so do so; in
another, die with a message so won't sneak past.  At that point, if and
when it happens, time could be spent figuring out the best way to handle
the situation.

lib/Unicode/UCD.t: White-space only

Re-indent after the previous commit

lib/Unicode/UCD.t: Fix to work on older Unicodes

This commit causes this test to pass tests even when run on old
Unicodes, back to 3.0, where it becomes just too much.  Most tests
aren't structured to pass on older Unicodes, but it's somewhat important
that this one does.

Unicode::UCD: Add pod text about old Unicodes

Unicode::UCD: Handle old Unicode files

The formats of some older Unicode releases can be different than
previously expected.

Unicode::UCD: Handle old Unicode Blocks file format

XS-APItest/t/handy.t: Handle early Unicodes

This changes, for properties that aren't defined in all Unicode
versions, to use synonyms that are defined in all.  It also better
checks for empty property tables, and knows that the format of some
returns can be different than previously constrained to be.

regen/mk_invlists.pl: Handle early Unicodes CF

In very early Unicode releases, the case folding table can be in a
different format.

regen/mk_invlists.pl: White-space only

Reindent after the previous commit introduced an outer block

regen/mk_invlists.pl: Properly handle empty properties

This failed to adequately handle empty properties; something that wasn't
seen until compiling older Unicode releases.

regen/mk_PL_charclass.pl: Use names known in all Unicodes

This just changes, for properties that aren't defined in all Unicode
versions, to use synonyms that are defined in all

regen/regcharclass.pl: Work on early Unicodes

This just changes, for properties that aren't defined in all Unicode
versions, to use synonyms that are defined in all

mktables: Add new alias status for internal-only

This makes it easier to control whether a synonym for a property value
is shown to and is accessible by users.

mktables: Get fold generation to work on early Unicodes

CaseFolding.txt isn't present in early Unicodes.  For these lowercasing
is used instead.  But the format of the lowercasing table isn't quite
the same, so add code to handle the differences.

mktables: Skip Hangul autogeneration on early Unicodes

Unicode Version 1 used completely different Hangul Syllables, so the
algorithm for the later versions doesn't apply

mktables: White-space, comment, debugging changes only

This adds comments, fixes up some white space and adds some things to
trace (when enabled)

mktables: Make surrogates work in all Unicodes

Surrogates aren't in all Unicode releases.  This creates a table that is
accessible in all releases, but is empty in those that don't have
surrogates.

mktables: Fixup Unicode 5.0 propvalue aliases for Blocks

These used an anomalous form in this release only.

mktables: Add true/false aliases in early Unicodes

Before Unicode 5.0, the aliases for True and False were just assumed,
and not specifically mentioned.  This commit adds them for those early
releases.

utf8_heavy.pl: White-space only

Reindent after previous commit added an outer block

mktables: Allow strictly named map tables

There are several types of tables generated by mktables.  Most are
binary (match) tables, but another class is mapping tables.  The names
for these may be loosely matched, but until this commit only the match
tables could have strict matching applied.

Strict matching is used for certain table names where loose could be
ambiguous, and for all names that aren't to be used by anything except
the perl core.

mktables: Move debugging line out of loop

It should only be printed once, when it does get printed (as it is
usually commented out).

mktables: Define non-char in all Unicode releases

Perl needs the NChar property to compile, but Unicode did not furnish it
in early releases.  This commit will use the Unicode definition if
available, but otherwise computes it itself.

mktables: Define quotemeta better in early Unicode releases

This property is needed by Perl to compile properly in all Unicode
releases, but Unicode did not furnish data for it in early releases.
Prior to this commit, the definition in such releases was set lazily to
an inaccurate value.  But it's not hard to do it correctly.

mktables: Define PatWS for Unicode versions missing it

This property is used by Perl in all Unicode releases, so needs to be
present in all releases, but Unicode did not define it in early
releases, though it should have the same short definition in all of
them.  If there is no Unicode data defining it, hard-code the definition
into mktables.

mktables: Escape literal "{" in regex

It's now deprecated if we fail to do so.

regen/mk_PL_charclass.pl: Don't confuse simple with multi folds

On early Unicode releases, this was saying that a character had a simple
fold from above Latin1, whereas it didn't.  This was caused by not
keeping the simple folds separate from the multi-character ones.
The solution is to keep a separate data structure for the simple ones.

f

Handle Unicode 3.0.1 /i Turkish "i" rules

Actually, there are no special rules for this Unicode release.  All the
4 "i" characters are considered equivalent under /i only in this
release.  (Upper and lowercase dotted and dotless "i").  This
adds special cases that are only compiled in for that release.

regen/unicode_constants.pl: Add U+130, +131

These will be used in the next commit

regen/mk_PL_charclass.pl: Add extra info to debug line

This is currently commented out, but this is helpful during
the times when it is used.

regen/regcharclass.pl: Handle empty lists

Short circuit the remaining code and return a 0 if the input doesn't
match anything

lib/locale.t: Fail more gracefully

If a character's name is unknown, say that instead of an unitialized
warning.

mktables: Handle early Unicodes' script names

These were all caps in early releases

uc(sharp s) is itself in very early Unicode versions

There are no folds to multiple chars in early Unicode versions

Several places require special handling because of this, notably for the
lowercase Sharp S, but not in Unicodes before 3.0.1