need to add some library or other, make a symbolic link like described
above, or you need to undefine some feature that Configure thought was
there but is defective or incomplete. If you used a hint file, see if
-it has any relevant advice. You can also look through through config.h
+it has any relevant advice. You can also look through config.h
for likely suspects.
=item toke.c
executables in the target system, such as an ssh connection; this is the
C<./Configure -Dusecrosscompile -Dtargethost=...> route. The second
method doesn't need access to the target system, but requires you to
-provide a config.sh, and and a canned Makefile; the rest of this section
+provide a config.sh, and a canned Makefile; the rest of this section
describes the former.
This cross-compilation setup of Configure has successfully been used in
#
# set this to your email address (perl will guess a value from
-# from your loginname and your hostname, which may not be right)
+# your loginname and your hostname, which may not be right)
#
#EMAIL =
then the corresponding operation is done. Otherwise the error value is returned.
This is done because the file operations like "open" in the Perl code returns the FILE *,
returning a valid value if the file is found or NULL when the particular file is not found.
-Now, if the return value is NULL, then an operation say "fgets", "fopen" etc. using this this NULL value
+Now, if the return value is NULL, then an operation say "fgets", "fopen" etc. using this NULL value
for FILE * will abend the server. If the check is made then an operation on a non existing file
does not abend the server.
**/
d_tm_tm_gmtoff (i_time.U):
This variable conditionally defines HAS_TM_TM_GMTOFF, which indicates
- indicates to the C program that the struct tm has the tm_gmtoff field.
+ to the C program that the struct tm has the tm_gmtoff field.
d_tm_tm_zone (i_time.U):
This variable conditionally defines HAS_TM_TM_ZONE, which indicates
- indicates to the C program that the struct tm has the tm_zone field.
+ to the C program that the struct tm has the tm_zone field.
d_tmpnam_r (d_tmpnam_r.U):
This variable conditionally defines the HAS_TMPNAM_R symbol,
@fields = grep exists $OPTS{fields}{$_}, @fields;
}
- # calculate the the max width of the test names
+ # calculate the max width of the test names
my $name_width = 0;
for (@test_names) {
lib/Config_git.pl: $1}m;
- # This emulates commits 0f13ebd5d71f8177 and
+ # This emulates commits 0f13ebd5d71f8177
# and a04d4598adc57886. It ensures that
# lib/Config_git.pl is built before configpm,
# and that configpm is run exactly once.
my %opts;
getopts('csui', \%opts) or usage;
if ($opts{u}) {
- @ARGV == 0 or usage('no version version numbers should be specified');
+ @ARGV == 0 or usage('no version numbers should be specified');
# fake to stop warnings when calculating $oldx etc
@ARGV = qw(99.99.99 99.99.99);
}
usage: $0 [ -r rootdir ] [-s suffix ] [ -x ] [ -n ]
-r rootdir directory under which to create the build dir and tarball
defaults to '..'
- -s suffix suffix to append to to the perl-x.y.z dir and tarball name
+ -s suffix suffix to append to the perl-x.y.z dir and tarball name
defaults to the concatenation of the local_patches entry
in patchlevel.h (or blank, if none)
-x make a .xz file in addition to a .gz file
#
# Run the tests. First the test belonging to the module, followed by the
-# the tests in t/porting
+# tests in t/porting
#
chdir "t";
say "Running module tests";
=head1 DESCRIPTION
-The port of Perl to to Mac OS was officially removed as of Perl 5.12,
+The port of Perl to Mac OS was officially removed as of Perl 5.12,
though the last official production release of MacPerl corresponded to
Perl 5.6. While Perl 5.10 included the port to Mac OS, ExtUtils::MakeMaker,
a core part of Perl's module installation infrastructure officially dropped support for Mac OS in April 2004.
emximp -o foo.a foo.lib
whichever is appropriate.) Also, make sure that the DLLs for external
-libraries are usable with with executables compiled without C<-Zmtd> options.
+libraries are usable with executables compiled without C<-Zmtd> options.
When you are sure that only a few subdirectories
lead to failures, you may want to add C<-j4> option to C<make> to speed up
Norton AntiVirus interferes with the build process, particularly if
set to "AutoProtect, All Files, when Opened". Unlike large applications
the perl build process opens and modifies a lot of files. Having the
-the AntiVirus scan each and every one slows build the process significantly.
+AntiVirus scan each and every one slows build the process significantly.
Worse, with PERLIO=stdio the build process fails with peculiar messages
as the virus checker interacts badly with miniperl.exe writing configure
files (it seems to either catch file part written and treat it as suspicious,
* baba9dfc133e3cb770a89aaf0973b1341fa61c2da6c176baf6428898b3b568d8 lib/unicore/extracted/DLineBreak.txt
* 6d4a8c945dd7db83ed617cbb7d937de7f4ecf016ff22970d846e996a7c9a2a5d lib/unicore/extracted/DNumType.txt
* 5b7c14380d5cceeaffcfbc18db1ed936391d2af2d51f5a41f1a17b692c77e59b lib/unicore/extracted/DNumValues.txt
- * d595d6b96967567fa57cf477c8cf4a72b456347a8ea054c05847b1fdb3072723 lib/unicore/mktables
+ * aee2ce1142e88494b09ea4abc065f8d74ad1a95f5fb3e03da469ab84306386e9 lib/unicore/mktables
* 50b85a67451145545a65cea370dab8d3444fbfe07e9c34cef560c5b7da9d3eef lib/unicore/version
* 2680b9254eb236c5c090f11b149605043e8c8433661b96efc4a42fb4709342a5 regen/charset_translations.pl
* 6bbad21de0848e0236b02f34f5fa0edd3cdae9ba8173cc9469a5513936b9e728 regen/mk_PL_charclass.pl
Version 2.11
1. Storing restricted hashes in canonical order would SEGV. Fixed.
- 2. It was impossible to retrieve references to PL_sv_no and and
+ 2. It was impossible to retrieve references to PL_sv_no and
PL_sv_undef from STORABLE_thaw hooks.
3. restrict.t was failing on 5.8.0, due to 5.8.0's unique
implementation of restricted hashes using PL_sv_undef
our ($canonical, $forgive_me);
BEGIN {
- our $VERSION = '3.20';
+ our $VERSION = '3.21';
}
our $recursion_limit;
len = HEK_LEN(hek);
if (len == HEf_SVKEY) {
/* This is somewhat sick, but the internal APIs are
- * such that XS code could put one of these in in
+ * such that XS code could put one of these in
* a regular hash.
* Maybe we should be capable of storing one if
* found.
# instead so a user setting of either variable more closely matches
# the limits the use sees.
-# be fairly aggressive in trimming this, smoke testing showed several
+# be fairly aggressive in trimming this, smoke testing showed
# several apparently random failures here, eg. working in one
# configuration, but not in a very similar configuration.
$max_depth = int(0.6 * $max_depth);
# Error 2
#
# If, for some reason, a STORABLE_attach object is accidentally stored
-# with references, this should be checked and and error should be throw.
+# with references, this should be checked and an error should be thrown.
use strict;
use warnings;
-our $VERSION = '3.13';
+our $VERSION = '3.14'; # remember to update version in POD!
$VERSION = eval $VERSION;
use threads::shared 1.21;
=head1 VERSION
-This document describes Thread::Queue version 3.13
+This document describes Thread::Queue version 3.14
=head1 SYNOPSIS
=item ->peek(INDEX)
Returns an item from the queue without dequeuing anything. Defaults to the
-the head of queue (at index position 0) if no index is specified. Negative
+head of queue (at index position 0) if no index is specified. Negative
index values are supported as with L<arrays|perldata/"Subscripts"> (i.e., -1
is the end of the queue, -2 is next to last, and so on).
- make utime() available only if we have both fd and name setting
[RT #133030]
- Adjutst Makefile.PL for windows: the DEFINE() in Makefile.PL
- can't be be in sub init() because that sub isn't called on windows
+ can't be in sub init() because that sub isn't called on windows
- t/itimer.t: avoid race condition.
- don't truncate nanosec utime
- fallback/const-c.inc: Avoid compiler warning showing up on darwin.
- backward compatibility (pre-5.6.1) tweaks:
- define NV if no NVTYPE
- define IVdf if needed (note: the Devel::PPPort
- in 5.8.0 does not try hard hard enough since
+ in 5.8.0 does not try hard enough since
the IVSIZE might not be defined)
- define NVgf if needed
- grab the typemap from 5.8.0 for the NV stuff
use strict;
use warnings;
-our $VERSION = '2.24'; # remember to update version in POD!
+our $VERSION = '2.25'; # remember to update version in POD!
my $XS_VERSION = $VERSION;
$VERSION = eval $VERSION;
=head1 VERSION
-This document describes threads version 2.24
+This document describes threads version 2.25
=head1 WARNING
}
/* At this point, the interpreter may have been freed, so call
- * free in the the context of of the 'main' interpreter which
+ * free in the context of the 'main' interpreter which
* can't have been freed due to the veto_cleanup mechanism.
*/
aTHX = MY_POOL.main_thread.interp;
PERL_UNUSED_VAR(what); /* may not be used depending on compile options */
/* Doing this ahead of the switch statement preserves the old behaviour,
- where attempting to use kill as a taint test test would fail on
+ where attempting to use kill as a taint test would fail on
platforms where kill was not defined. */
#ifndef HAS_KILL
if (type == OP_KILL)
unless ($Config{useithreads}) {
# These end up as copies in pads under ithreads, which rather defeats the
- # the point of what we're trying to test here.
+ # point of what we're trying to test here.
do_test('regular string constant', perl,
'SV = PV\\($ADDR\\) at $ADDR
unless -d '/usr' && -f '/bin/ls';
skip( "dl_findfile test not always appropriate when cross-compiling", 1 )
if $Config{usecrosscompile};
- cmp_ok( scalar @files, '>=', 1, "array should contain one result result or more: libc => (@files)" );
+ cmp_ok( scalar @files, '>=', 1, "array should contain one result or more: libc => (@files)" );
}
# Now try to load well known XS modules
* "write through" environment changes to the process environment.
*
* (c) Even the primary Perl interpreter won't update the CRT copy of the
- * the environment, only the Win32API copy (it calls win32_putenv()).
+ * environment, only the Win32API copy (it calls win32_putenv()).
*
* As with CPerlHost::Getenv() and CPerlHost::Putenv() themselves, it makes
* sense to only update the process environment when inside the main
our ($AUTOLOAD, %SIGRT);
-our $VERSION = '1.93';
+our $VERSION = '1.94';
require XSLoader;
# these take different code paths.
# Whenever an explicit 'return' is used, it is followed by '1;' to avoid
# the return being optimised into a leavesub.
-# Adding a 'for' loop pushes extra junk on the stack, which we we want to
+# Adding a 'for' loop pushes extra junk on the stack, which we want to
# avoid being interpreted as a return arg.
{
}
# Possible flag returns from utf8n_to_uvchr_error(). These should have G_,
-# instead of A_, D_, but the prefixes will be used in a a later commit, so
+# instead of A_, D_, but the prefixes will be used in a later commit, so
# minimize churn by having them here.
my @utf8n_flags_to_text = ( qw(
A_EMPTY
$allow_flags |= $::UTF8_ALLOW_OVERFLOW if $malformed_allow_type;
}
- # And we can create the malformation-related text for the the test
+ # And we can create the malformation-related text for the test
# names we eventually will generate.
my $malformations_name = "";
if (@malformation_names) {
use strict;
use warnings;
-our $VERSION = "0.39";
+our $VERSION = "0.40";
our @ISA = qw(Exporter);
our @EXPORT_OK = ('regmust',
qw(is_regexp regexp_pattern
qr/\x{AB}C/
that is, the character whose code point value is C<0xAB>, followed by the
-letter C<C>. But since C<C> is a a hex digit, there is a reasonable chance
+letter C<C>. But since C<C> is a hex digit, there is a reasonable chance
that the intent was
qr/\x{ABC}/
length may be unknown, but can be calculated by C<strlen()>, since it is
terminated by a NUL, which isn't included in its length.
- The optional 'n' following 'str' means that that there is a third parameter,
+ The optional 'n' following 'str' means that there is a third parameter,
giving the maximum number of bytes to look at in each string. Even if both
strings are longer than the length parameter, those extra bytes will be
unexamined.
d_gethostbyname_r='undef'
d_gethostent_r='undef'
-# The z/OS C compiler compiler supports the attribute keyword, but in a
+# The z/OS C compiler supports the attribute keyword, but in a
# limited manner.
#
# Ideally, Configure's tests should test the attributes as they are expected
* Isolate the lsb;
* https://stackoverflow.com/questions/757059/position-of-least-significant-bit-that-is-set
*
- * The word will look this this, with a rightmost set bit in position 's':
+ * The word will look like this, with a rightmost set bit in position 's':
* ('x's are don't cares)
* s
* x..x100..0
The C library C<strnlen> if available, or a Perl implementation of it.
C<my_strnlen()> computes the length of the string, up to C<maxlen>
-characters. It will will never attempt to address more than C<maxlen>
+characters. It will never attempt to address more than C<maxlen>
characters, making it suitable for use with strings that are not
guaranteed to be NUL-terminated.
MDEREF_SHIFT
);
-$VERSION = '1.53';
+$VERSION = '1.54';
use strict;
our $AUTOLOAD;
use warnings ();
}
# This sub may be called for a program that has no nextstate ops. In
# that case we may have a lexical sub named no/use/sub in scope but
- # but $self->lex_in_scope will return false because it depends on the
+ # $self->lex_in_scope will return false because it depends on the
# current nextstate op. So we need this alternate method if there is
# no current cop.
if (!$self->{'curcop'}) {
clearcache clearallcache disablecache enablecache);
%EXPORT_TAGS=( all => [ @EXPORT, @EXPORT_OK ] ) ;
-$VERSION = 1.22;
+$VERSION = 1.23;
# --- ':hireswallclock' special handling
if ( $tc <= 0 and $n > 1024 ) {
my $d = timediff($t1, $t0);
# note that $d is the total CPU time taken to call timeit(),
- # while $tc is is difference in CPU secs between the empty run
+ # while $tc is the difference in CPU secs between the empty run
# and the code run. If the code is trivial, its possible
# for $d to get large while $tc is still zero (or slightly
# negative). Bail out once timeit() starts taking more than a
package Tie::Scalar;
-our $VERSION = '1.04';
+our $VERSION = '1.05';
=head1 NAME
from C<< Tie::Scalar >>, you I<must> provide either a C<< new >> or a
C<< TIESCALAR >> method.
-If you are looking for a class that does everything for you you don't
+If you are looking for a class that does everything for you that you don't
define yourself, use the C<< Tie::StdScalar >> class, not the
C<< Tie::Scalar >> one.
# SADAHIRO Tomoyuki's suggestion is to ensure that the UTF-8ness of both
# arguments are identical before calling index.
# To do this can take advantage of the fact that unicore/Name.pl is 7 bit
-# (or at least should be). So assert that that it's true here. EBCDIC
+# (or at least should be). So assert that that is true here. EBCDIC
# may be a problem (khw).
my $names = do "unicore/Name.pl";
}
# RT #132793
-# An arg like like "$b" in $overloaded .= "$b" should be stringified
+# An arg like "$b" in $overloaded .= "$b" should be stringified
# before being passed to the method
package RT132793 {
use vars qw($VERSION $header);
# bump to X.XX in blead, only use X.XX_XX in maint
-$VERSION = '1.56';
+$VERSION = '1.57';
$header = "perl5db.pl version $VERSION";
# Change directory to the initial current working directory on
# the script startup, so if the debugged program changed the
# directory, then we will still be able to find the path to the
- # the program. (perl 5 RT #121509 ).
+ # program. (perl 5 RT #121509 ).
chdir ($_initial_cwd);
my @args = ($cmd_cmd eq 'R' ? restart() : rerun($cmd_params));
$db_stop = 0; # Compiler warning ...
$db_stop = 1 << 30; # ... because this is only used in an eval() later.
- # This variable records how many levels we're nested in debugging. Used
+ # This variable records how many levels we're nested in debugging.
# Used in the debugger prompt, and in determining whether it's all over or
# not.
$level = 0; # Level of recursive debugging
# This causes continuation lines to be joined together into one long line
# for folding. A continuation line is any line that doesn't begin with a
# space or "\b" (the latter is stripped from the output). This is so
- # lines can be be in a HERE document so as to fit nicely in the terminal
+ # lines can be in a HERE document so as to fit nicely in the terminal
# width, but be joined together in one long line, and then folded with
# indents, '#' prefixes, etc, properly handled.
# A blank separates the joined lines except if there is a break; an extra
# were probably not really official at that time, so should be
# ignored. You can easily modify things to skip all of them by
# changing this function to just set $_ to "", and return; and to skip
- # certain of them by by simply removing their declarations from
+ # certain of them by simply removing their declarations from
# get_old_property_aliases().
#
# Here is a list of all the ones that are thrown away:
);
- # One might think that the the 'Unicode_1_Name' field, could work for most
+ # One might think that the 'Unicode_1_Name' field, could work for most
# of the above names, but sadly that field varies depending on the
# release. Version 1.1.5 had no names for any of the controls; Version
# 2.0 introduced names for the C0 controls, and 3.0 introduced C1 names.
# necessary.
# 2) Adds the mappings for code points missing from the files which have
# defaults specified for them.
- # 3) At this this point all mappings are known, so it computes the type of
+ # 3) At this point all mappings are known, so it computes the type of
# each property whose type hasn't been determined yet.
# 4) Calculates all the regular expression match tables based on the
# mappings.
$default_table = $property->table($default_map);
}
- # If some code points don't go back to the the grab-bag when they
+ # If some code points don't go back to the grab-bag when they
# are considered unassigned, exclude them from the list that does
# that.
my $this_delta = $delta;
# Abbreviations go after everything else, so they are saved temporarily in
# a hash for later.
#
- # Everything else is added added afterwards, which preserves the input
+ # Everything else is added afterwards, which preserves the input
# ordering
foreach my $range ($alias->ranges) {
&& $perl_extension
&& $property != $table;
- # Get the more official name for for perl extensions that aren't
+ # Get the more official name for perl extensions that aren't
# stand-alone properties
if ($is_perl_extension_match_table_but_not_dollar_perl) {
if ($property->type == $BINARY) {
# baba9dfc133e3cb770a89aaf0973b1341fa61c2da6c176baf6428898b3b568d8 lib/unicore/extracted/DLineBreak.txt
# 6d4a8c945dd7db83ed617cbb7d937de7f4ecf016ff22970d846e996a7c9a2a5d lib/unicore/extracted/DNumType.txt
# 5b7c14380d5cceeaffcfbc18db1ed936391d2af2d51f5a41f1a17b692c77e59b lib/unicore/extracted/DNumValues.txt
-# d595d6b96967567fa57cf477c8cf4a72b456347a8ea054c05847b1fdb3072723 lib/unicore/mktables
+# aee2ce1142e88494b09ea4abc065f8d74ad1a95f5fb3e03da469ab84306386e9 lib/unicore/mktables
# 50b85a67451145545a65cea370dab8d3444fbfe07e9c34cef560c5b7da9d3eef lib/unicore/version
# 2680b9254eb236c5c090f11b149605043e8c8433661b96efc4a42fb4709342a5 regen/charset_translations.pl
# 6bbad21de0848e0236b02f34f5fa0edd3cdae9ba8173cc9469a5513936b9e728 regen/mk_PL_charclass.pl
my $file = $ARGS{TARG_DIR} . shift;
my $hash = shift;
my $proc = shift;
- open my $vars, '<', $file or die die "Cannot open $file: $!\n";
+ open my $vars, '<', $file or die "Cannot open $file: $!\n";
while (<$vars>) {
# All symbols have a Perl_ prefix because that's what embed.h sticks
* versions of Perl which we cannot completely remove from the core
* code. There are two reasons functions should be here:
*
- * 1) A function has been been replaced by a macro within a minor release,
+ * 1) A function has been replaced by a macro within a minor release,
* so XS modules compiled against an older release will expect to
* still be able to link against the function
* 2) A function Perl_foo(...) with #define foo Perl_foo(aTHX_ ...)
digits may be separated from each other by a single underscore; also a single
leading underscore is accepted.
-The
the C<PERL_SCAN_DISALLOW_PREFIX> flag is always treated as being set for
+The C<PERL_SCAN_DISALLOW_PREFIX> flag is always treated as being set for
this function.
=cut
(int)n, PL_op_desc[(o)->op_type], t, OP_DESC(kid)), 0);
}
-/* remove flags var, its unused in all callers, move to to right end since gv
- and kid are always the same */
STATIC void
S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t)
{
you to delete zero or more sequential nodes, replacing them with zero or
more different nodes. Performs the necessary op_first/op_last
housekeeping on the parent node and op_sibling manipulation on the
-children. The last deleted node will be marked as as the last node by
+children. The last deleted node will be marked as the last node by
updating the op_sibling/op_sibparent or op_moresib field as appropriate.
Note that op_next is not manipulated, and nodes are not freed; that is the
}
if (targetop) {
- /* Can targetop (the LHS) if it's a padsv, be be optimised
+ /* Can targetop (the LHS) if it's a padsv, be optimised
* away and use OPpTARGET_MY instead?
*/
if ( (targetop->op_type == OP_PADSV)
* X .= Y
*
* otherwise we could be doing something like $x = "foo", which
- * if treated as as a concat, would fail to COW.
+ * if treated as a concat, would fail to COW.
*/
if (nargs + nconst + cBOOL(private_flags & OPpMULTICONCAT_APPEND) < 2)
return;
* One of the important characteristics to know about the input is whether
* the transliteration may be done in place, or does a temporary need to be
* allocated, then copied. If the replacement for every character in every
- * possible string takes up no more bytes than the the character it
+ * possible string takes up no more bytes than the character it
* replaces, then it can be edited in place. Otherwise the replacement
* could overwrite a byte we are about to read, depending on the strings
* being processed. The comments and variable names here refer to this as
if (CvISXSUB(cv) || !CvROOT(cv))
S_entersub_alloc_targ(aTHX_ o);
if (!namegv) {
- /* The original call checker API guarantees that a GV will be
+ /* The original call checker API guarantees that a GV will
be provided with the right name. So, if the old API was
used (or the REQUIRE_GV flag was passed), we have to reify
the CV’s GV, unless this is an anonymous sub. This is not
}
/* if its an unrecognised, non-dangerous op, assume that it
- * it the cause of at least one safe scalar */
+ * is the cause of at least one safe scalar */
(*scalars_p)++;
flags = AAS_SAFE_SCALAR;
break;
* !op_slabbed.
* op_savefree on savestack via SAVEFREEOP
* op_folded Result/remainder of a constant fold operation.
- * op_moresib this op is is not the last sibling
+ * op_moresib this op is not the last sibling
* op_spare One spare bit
* op_flags Flags common to all operations. See OPf_* below.
* op_private Flags peculiar to a particular operation (BUT,
New function OS2::Error(do_harderror,do_exception). Returns
undef if it was not called yet, otherwise bit 1 is
set if on previous call do_harderror was enabled, bit
- 2 is set if if on previous call do_exception was enabled.
+ 2 is set if on previous call do_exception was enabled.
This function enables/disables error popups associated with
hardware errors (Disk not ready etc.) and software exceptions.
* as the first line of a Perl program designed to be executed directly
* by name, instead of the standard Unix #!. If ALTERNATE_SHEBANG
* begins with a character other then #, then Perl will only treat
- * it as a command line if if finds the string "perl" in the first
+ * it as a command line if it finds the string "perl" in the first
* word; otherwise it's treated as the first line of code in the script.
* (IOW, Perl won't hand off to another interpreter via an alternate
* shebang sequence that might be legal Perl code.)
* success/warning codes to fatal with out changing
* the POSIX status code. The severity makes VMS native
* status handling work, while UNIX mode programs use the
- * the POSIX exit codes.
+ * POSIX exit codes.
*/
if ((STATUS_NATIVE & (STS$K_SEVERE|STS$K_ERROR)) == 0) {
STATUS_NATIVE &= STS$M_COND_ID;
* drops out immediately for that. In the dfa, classes 3 and 4 are used to
* distinguish EF vs the rest. Then special code is used to deal with ED,
* that's executed only when the dfa drops out. The code points started by ED
- * are half surrogates, and half hangul syllables. This means that 2048 of the
+ * are half surrogates, and half hangul syllables. This means that 2048 of
* the hangul syllables (about 18%) take longer than all other non-problematic
* code points to handle.
*
compilers aren't smart enough to eliminate unused static inline
functions, so including this file in source code can cause link errors
even if the source code uses none of the functions. Hence including these
- can be be suppressed by setting PERL_NO_INLINE_FUNCTIONS. Doing this will
+ can be suppressed by setting PERL_NO_INLINE_FUNCTIONS. Doing this will
(obviously) result in unworkable XS code, but allows simple probing code
to continue to work, because it permits tests to include the perl headers
for definitions without creating a link dependency on the perl library
=for apidoc Am|void|STORE_LC_NUMERIC_FORCE_TO_UNDERLYING
-This is used by XS code that that is C<LC_NUMERIC> locale-aware to force the
+This is used by XS code that is C<LC_NUMERIC> locale-aware to force the
locale for category C<LC_NUMERIC> to be what perl thinks is the current
underlying locale. (The perl interpreter could be wrong about what the
underlying locale actually is if some C or XS code has called the C library
* matching */
PERLVAR(G, utf8_foldclosures, SV *)
-/* these record the best way to to perform certain IO operations while
+/* these record the best way to perform certain IO operations while
* atomically setting FD_CLOEXEC. On the first call, a probe is done
* and the result recorded for use by subsequent calls.
* In theory these variables aren't thread-safe, but the worst that can
*/
case 2:
-#line 121 "perly.y" /* yacc.c:1646 */
+#line 121 "perly.y" /* yacc.c:1652 */
{
parser->expect = XSTATE;
(yyval.ival) = 0;
break;
case 3:
-#line 126 "perly.y" /* yacc.c:1646 */
+#line 126 "perly.y" /* yacc.c:1652 */
{
newPROG(block_end((ps[-1].val.ival),(ps[0].val.opval)));
PL_compiling.cop_seq = 0;
break;
case 4:
-#line 132 "perly.y" /* yacc.c:1646 */
+#line 132 "perly.y" /* yacc.c:1652 */
{
parser->expect = XTERM;
(yyval.ival) = 0;
break;
case 5:
-#line 137 "perly.y" /* yacc.c:1646 */
+#line 137 "perly.y" /* yacc.c:1652 */
{
PL_eval_root = (ps[0].val.opval);
(yyval.ival) = 0;
break;
case 6:
-#line 142 "perly.y" /* yacc.c:1646 */
+#line 142 "perly.y" /* yacc.c:1652 */
{
parser->expect = XBLOCK;
(yyval.ival) = 0;
break;
case 7:
-#line 147 "perly.y" /* yacc.c:1646 */
+#line 147 "perly.y" /* yacc.c:1652 */
{
PL_pad_reset_pending = TRUE;
PL_eval_root = (ps[0].val.opval);
break;
case 8:
-#line 155 "perly.y" /* yacc.c:1646 */
+#line 155 "perly.y" /* yacc.c:1652 */
{
parser->expect = XSTATE;
(yyval.ival) = 0;
break;
case 9:
-#line 160 "perly.y" /* yacc.c:1646 */
+#line 160 "perly.y" /* yacc.c:1652 */
{
PL_pad_reset_pending = TRUE;
PL_eval_root = (ps[0].val.opval);
break;
case 10:
-#line 168 "perly.y" /* yacc.c:1646 */
+#line 168 "perly.y" /* yacc.c:1652 */
{
parser->expect = XSTATE;
(yyval.ival) = 0;
break;
case 11:
-#line 173 "perly.y" /* yacc.c:1646 */
+#line 173 "perly.y" /* yacc.c:1652 */
{
PL_pad_reset_pending = TRUE;
PL_eval_root = (ps[0].val.opval);
break;
case 12:
-#line 181 "perly.y" /* yacc.c:1646 */
+#line 181 "perly.y" /* yacc.c:1652 */
{
parser->expect = XSTATE;
(yyval.ival) = 0;
break;
case 13:
-#line 186 "perly.y" /* yacc.c:1646 */
+#line 186 "perly.y" /* yacc.c:1652 */
{
PL_eval_root = (ps[0].val.opval);
(yyval.ival) = 0;
break;
case 14:
-#line 191 "perly.y" /* yacc.c:1646 */
+#line 191 "perly.y" /* yacc.c:1652 */
{
parser->expect = XSTATE;
(yyval.ival) = 0;
break;
case 15:
-#line 196 "perly.y" /* yacc.c:1646 */
+#line 196 "perly.y" /* yacc.c:1652 */
{
PL_eval_root = (ps[0].val.opval);
(yyval.ival) = 0;
break;
case 16:
-#line 204 "perly.y" /* yacc.c:1646 */
+#line 204 "perly.y" /* yacc.c:1652 */
{ if (parser->copline > (line_t)(ps[-3].val.ival))
parser->copline = (line_t)(ps[-3].val.ival);
(yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
break;
case 17:
-#line 212 "perly.y" /* yacc.c:1646 */
+#line 212 "perly.y" /* yacc.c:1652 */
{ if (parser->copline > (line_t)(ps[-6].val.ival))
parser->copline = (line_t)(ps[-6].val.ival);
(yyval.opval) = block_end((ps[-5].val.ival), (ps[-2].val.opval));
break;
case 18:
-#line 219 "perly.y" /* yacc.c:1646 */
+#line 219 "perly.y" /* yacc.c:1652 */
{ (yyval.ival) = block_start(TRUE);
parser->parsed_sub = 0; }
break;
case 19:
-#line 224 "perly.y" /* yacc.c:1646 */
+#line 224 "perly.y" /* yacc.c:1652 */
{ if (parser->copline > (line_t)(ps[-3].val.ival))
parser->copline = (line_t)(ps[-3].val.ival);
(yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
break;
case 20:
-#line 231 "perly.y" /* yacc.c:1646 */
+#line 231 "perly.y" /* yacc.c:1652 */
{ (yyval.ival) = block_start(FALSE);
parser->parsed_sub = 0; }
break;
case 21:
-#line 237 "perly.y" /* yacc.c:1646 */
+#line 237 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 22:
-#line 239 "perly.y" /* yacc.c:1646 */
+#line 239 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
PL_pad_reset_pending = TRUE;
if ((ps[-1].val.opval) && (ps[0].val.opval))
break;
case 23:
-#line 248 "perly.y" /* yacc.c:1646 */
+#line 248 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 24:
-#line 250 "perly.y" /* yacc.c:1646 */
+#line 250 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
PL_pad_reset_pending = TRUE;
if ((ps[-1].val.opval) && (ps[0].val.opval))
break;
case 25:
-#line 259 "perly.y" /* yacc.c:1646 */
+#line 259 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = (ps[0].val.opval) ? newSTATEOP(0, NULL, (ps[0].val.opval)) : NULL;
}
break;
case 26:
-#line 263 "perly.y" /* yacc.c:1646 */
+#line 263 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 27:
-#line 267 "perly.y" /* yacc.c:1646 */
+#line 267 "perly.y" /* yacc.c:1652 */
{
SV *label = cSVOPx_sv((ps[-1].val.opval));
(yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
break;
case 28:
-#line 274 "perly.y" /* yacc.c:1646 */
+#line 274 "perly.y" /* yacc.c:1652 */
{
SV *label = cSVOPx_sv((ps[-1].val.opval));
(yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
break;
case 29:
-#line 284 "perly.y" /* yacc.c:1646 */
+#line 284 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 30:
-#line 286 "perly.y" /* yacc.c:1646 */
+#line 286 "perly.y" /* yacc.c:1652 */
{
CV *fmtcv = PL_compcv;
newFORM((ps[-2].val.ival), (ps[-1].val.opval), (ps[0].val.opval));
break;
case 31:
-#line 298 "perly.y" /* yacc.c:1646 */
+#line 298 "perly.y" /* yacc.c:1652 */
{
init_named_cv(PL_compcv, (ps[-1].val.opval));
parser->in_my = 0;
break;
case 32:
-#line 304 "perly.y" /* yacc.c:1646 */
+#line 304 "perly.y" /* yacc.c:1652 */
{
SvREFCNT_inc_simple_void(PL_compcv);
(ps[-5].val.opval)->op_type == OP_CONST
break;
case 33:
-#line 319 "perly.y" /* yacc.c:1646 */
+#line 319 "perly.y" /* yacc.c:1652 */
{
init_named_cv(PL_compcv, (ps[-1].val.opval));
parser->in_my = 0;
break;
case 34:
-#line 325 "perly.y" /* yacc.c:1646 */
+#line 325 "perly.y" /* yacc.c:1652 */
{
SvREFCNT_inc_simple_void(PL_compcv);
(ps[-4].val.opval)->op_type == OP_CONST
break;
case 35:
-#line 336 "perly.y" /* yacc.c:1646 */
+#line 336 "perly.y" /* yacc.c:1652 */
{
package((ps[-1].val.opval));
if ((ps[-2].val.opval))
break;
case 36:
-#line 343 "perly.y" /* yacc.c:1646 */
+#line 343 "perly.y" /* yacc.c:1652 */
{ CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
break;
case 37:
-#line 345 "perly.y" /* yacc.c:1646 */
+#line 345 "perly.y" /* yacc.c:1652 */
{
SvREFCNT_inc_simple_void(PL_compcv);
utilize((ps[-6].val.ival), (ps[-5].val.ival), (ps[-3].val.opval), (ps[-2].val.opval), (ps[-1].val.opval));
break;
case 38:
-#line 352 "perly.y" /* yacc.c:1646 */
+#line 352 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-4].val.ival),
newCONDOP(0, (ps[-3].val.opval), op_scope((ps[-1].val.opval)), (ps[0].val.opval)));
break;
case 39:
-#line 358 "perly.y" /* yacc.c:1646 */
+#line 358 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-4].val.ival),
newCONDOP(0, (ps[-3].val.opval), (ps[0].val.opval), op_scope((ps[-1].val.opval))));
break;
case 40:
-#line 364 "perly.y" /* yacc.c:1646 */
+#line 364 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-3].val.ival), newGIVENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)), 0));
parser->copline = (line_t)(ps[-5].val.ival);
break;
case 41:
-#line 369 "perly.y" /* yacc.c:1646 */
+#line 369 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = block_end((ps[-3].val.ival), newWHENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)))); }
break;
case 42:
-#line 371 "perly.y" /* yacc.c:1646 */
+#line 371 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
break;
case 43:
-#line 373 "perly.y" /* yacc.c:1646 */
+#line 373 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-5].val.ival),
newWHILEOP(0, 1, NULL,
break;
case 44:
-#line 380 "perly.y" /* yacc.c:1646 */
+#line 380 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-5].val.ival),
newWHILEOP(0, 1, NULL,
break;
case 45:
-#line 387 "perly.y" /* yacc.c:1646 */
+#line 387 "perly.y" /* yacc.c:1652 */
{ parser->expect = XTERM; }
break;
case 46:
-#line 389 "perly.y" /* yacc.c:1646 */
+#line 389 "perly.y" /* yacc.c:1652 */
{ parser->expect = XTERM; }
break;
case 47:
-#line 392 "perly.y" /* yacc.c:1646 */
+#line 392 "perly.y" /* yacc.c:1652 */
{
OP *initop = (ps[-9].val.opval);
OP *forop = newWHILEOP(0, 1, NULL,
break;
case 48:
-#line 407 "perly.y" /* yacc.c:1646 */
+#line 407 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-6].val.ival), newFOROP(0, (ps[-5].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
parser->copline = (line_t)(ps[-8].val.ival);
break;
case 49:
-#line 412 "perly.y" /* yacc.c:1646 */
+#line 412 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-4].val.ival), newFOROP(0,
op_lvalue((ps[-6].val.opval), OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
break;
case 50:
-#line 418 "perly.y" /* yacc.c:1646 */
+#line 418 "perly.y" /* yacc.c:1652 */
{ parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
break;
case 51:
-#line 420 "perly.y" /* yacc.c:1646 */
+#line 420 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end(
(ps[-7].val.ival),
break;
case 52:
-#line 433 "perly.y" /* yacc.c:1646 */
+#line 433 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-4].val.ival), newFOROP(
0, op_lvalue(newUNOP(OP_REFGEN, 0,
break;
case 53:
-#line 441 "perly.y" /* yacc.c:1646 */
+#line 441 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = block_end((ps[-4].val.ival),
newFOROP(0, NULL, (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
break;
case 54:
-#line 447 "perly.y" /* yacc.c:1646 */
+#line 447 "perly.y" /* yacc.c:1652 */
{
/* a block is a loop that happens once */
(yyval.opval) = newWHILEOP(0, 1, NULL,
break;
case 55:
-#line 453 "perly.y" /* yacc.c:1646 */
+#line 453 "perly.y" /* yacc.c:1652 */
{
package((ps[-2].val.opval));
if ((ps[-3].val.opval)) {
break;
case 56:
-#line 460 "perly.y" /* yacc.c:1646 */
+#line 460 "perly.y" /* yacc.c:1652 */
{
/* a block is a loop that happens once */
(yyval.opval) = newWHILEOP(0, 1, NULL,
break;
case 57:
-#line 468 "perly.y" /* yacc.c:1646 */
+#line 468 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = (ps[-1].val.opval);
}
break;
case 58:
-#line 472 "perly.y" /* yacc.c:1646 */
+#line 472 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
break;
case 59:
-#line 477 "perly.y" /* yacc.c:1646 */
+#line 477 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = NULL;
parser->copline = NOLINE;
break;
case 60:
-#line 485 "perly.y" /* yacc.c:1646 */
+#line 485 "perly.y" /* yacc.c:1652 */
{ OP *list;
if ((ps[0].val.opval)) {
OP *term = (ps[0].val.opval);
break;
case 61:
-#line 502 "perly.y" /* yacc.c:1646 */
+#line 502 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 62:
-#line 504 "perly.y" /* yacc.c:1646 */
+#line 504 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_unscope((ps[-1].val.opval)); }
break;
case 63:
-#line 509 "perly.y" /* yacc.c:1646 */
+#line 509 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 64:
-#line 511 "perly.y" /* yacc.c:1646 */
+#line 511 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 65:
-#line 513 "perly.y" /* yacc.c:1646 */
+#line 513 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
break;
case 66:
-#line 515 "perly.y" /* yacc.c:1646 */
+#line 515 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
break;
case 67:
-#line 517 "perly.y" /* yacc.c:1646 */
+#line 517 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
break;
case 68:
-#line 519 "perly.y" /* yacc.c:1646 */
+#line 519 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
break;
case 69:
-#line 521 "perly.y" /* yacc.c:1646 */
+#line 521 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newFOROP(0, NULL, (ps[0].val.opval), (ps[-2].val.opval), NULL);
parser->copline = (line_t)(ps[-1].val.ival); }
break;
case 70:
-#line 524 "perly.y" /* yacc.c:1646 */
+#line 524 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
break;
case 71:
-#line 529 "perly.y" /* yacc.c:1646 */
+#line 529 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 72:
-#line 531 "perly.y" /* yacc.c:1646 */
+#line 531 "perly.y" /* yacc.c:1652 */
{
((ps[0].val.opval))->op_flags |= OPf_PARENS;
(yyval.opval) = op_scope((ps[0].val.opval));
break;
case 73:
-#line 536 "perly.y" /* yacc.c:1646 */
+#line 536 "perly.y" /* yacc.c:1652 */
{ parser->copline = (line_t)(ps[-5].val.ival);
(yyval.opval) = newCONDOP(0,
newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
break;
case 74:
-#line 546 "perly.y" /* yacc.c:1646 */
+#line 546 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 75:
-#line 548 "perly.y" /* yacc.c:1646 */
+#line 548 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_scope((ps[0].val.opval)); }
break;
case 76:
-#line 553 "perly.y" /* yacc.c:1646 */
+#line 553 "perly.y" /* yacc.c:1652 */
{ (yyval.ival) = (PL_min_intro_pending &&
PL_max_intro_pending >= PL_min_intro_pending);
intro_my(); }
break;
case 77:
-#line 559 "perly.y" /* yacc.c:1646 */
+#line 559 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 79:
-#line 565 "perly.y" /* yacc.c:1646 */
+#line 565 "perly.y" /* yacc.c:1652 */
{ YYSTYPE tmplval;
(void)scan_num("1", &tmplval);
(yyval.opval) = tmplval.opval; }
break;
case 81:
-#line 573 "perly.y" /* yacc.c:1646 */
+#line 573 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = invert(scalar((ps[0].val.opval))); }
break;
case 82:
-#line 578 "perly.y" /* yacc.c:1646 */
+#line 578 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); intro_my(); }
break;
case 83:
-#line 582 "perly.y" /* yacc.c:1646 */
+#line 582 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); intro_my(); }
break;
case 84:
-#line 585 "perly.y" /* yacc.c:1646 */
+#line 585 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 85:
-#line 586 "perly.y" /* yacc.c:1646 */
+#line 586 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 86:
-#line 590 "perly.y" /* yacc.c:1646 */
+#line 590 "perly.y" /* yacc.c:1652 */
{ (yyval.ival) = start_subparse(FALSE, 0);
SAVEFREESV(PL_compcv); }
break;
case 87:
-#line 596 "perly.y" /* yacc.c:1646 */
+#line 596 "perly.y" /* yacc.c:1652 */
{ (yyval.ival) = start_subparse(FALSE, CVf_ANON);
SAVEFREESV(PL_compcv); }
break;
case 88:
-#line 601 "perly.y" /* yacc.c:1646 */
+#line 601 "perly.y" /* yacc.c:1652 */
{ (yyval.ival) = start_subparse(TRUE, 0);
SAVEFREESV(PL_compcv); }
break;
case 91:
-#line 612 "perly.y" /* yacc.c:1646 */
+#line 612 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 93:
-#line 618 "perly.y" /* yacc.c:1646 */
+#line 618 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 94:
-#line 620 "perly.y" /* yacc.c:1646 */
+#line 620 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 95:
-#line 622 "perly.y" /* yacc.c:1646 */
+#line 622 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 96:
-#line 627 "perly.y" /* yacc.c:1646 */
+#line 627 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 97:
-#line 629 "perly.y" /* yacc.c:1646 */
+#line 629 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 98:
-#line 640 "perly.y" /* yacc.c:1646 */
+#line 640 "perly.y" /* yacc.c:1652 */
{ parser->in_my = 0; (yyval.opval) = NULL; }
break;
case 99:
-#line 642 "perly.y" /* yacc.c:1646 */
+#line 642 "perly.y" /* yacc.c:1652 */
{ parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
break;
case 100:
-#line 647 "perly.y" /* yacc.c:1646 */
+#line 647 "perly.y" /* yacc.c:1652 */
{ (yyval.ival) = '@'; }
break;
case 101:
-#line 649 "perly.y" /* yacc.c:1646 */
+#line 649 "perly.y" /* yacc.c:1652 */
{ (yyval.ival) = '%'; }
break;
case 102:
-#line 653 "perly.y" /* yacc.c:1646 */
+#line 653 "perly.y" /* yacc.c:1652 */
{
I32 sigil = (ps[-2].val.ival);
OP *var = (ps[-1].val.opval);
break;
case 103:
-#line 672 "perly.y" /* yacc.c:1646 */
+#line 672 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 104:
-#line 674 "perly.y" /* yacc.c:1646 */
+#line 674 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newOP(OP_NULL, 0); }
break;
case 105:
-#line 676 "perly.y" /* yacc.c:1646 */
+#line 676 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 106:
-#line 682 "perly.y" /* yacc.c:1646 */
+#line 682 "perly.y" /* yacc.c:1652 */
{
OP *var = (ps[-1].val.opval);
OP *defexpr = (ps[0].val.opval);
break;
case 107:
-#line 747 "perly.y" /* yacc.c:1646 */
+#line 747 "perly.y" /* yacc.c:1652 */
{ parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
break;
case 108:
-#line 749 "perly.y" /* yacc.c:1646 */
+#line 749 "perly.y" /* yacc.c:1652 */
{ parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
break;
case 109:
-#line 755 "perly.y" /* yacc.c:1646 */
+#line 755 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[-1].val.opval); }
break;
case 110:
-#line 757 "perly.y" /* yacc.c:1646 */
+#line 757 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
}
break;
case 111:
-#line 761 "perly.y" /* yacc.c:1646 */
+#line 761 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 112:
-#line 766 "perly.y" /* yacc.c:1646 */
+#line 766 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 113:
-#line 768 "perly.y" /* yacc.c:1646 */
+#line 768 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 114:
-#line 772 "perly.y" /* yacc.c:1646 */
+#line 772 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 115:
-#line 774 "perly.y" /* yacc.c:1646 */
+#line 774 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 116:
-#line 778 "perly.y" /* yacc.c:1646 */
+#line 778 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[-1].val.opval); }
break;
case 117:
-#line 781 "perly.y" /* yacc.c:1646 */
+#line 781 "perly.y" /* yacc.c:1652 */
{
ENTER;
SAVEIV(parser->sig_elems);
break;
case 118:
-#line 792 "perly.y" /* yacc.c:1646 */
+#line 792 "perly.y" /* yacc.c:1652 */
{
OP *sigops = (ps[0].val.opval);
struct op_argcheck_aux *aux;
break;
case 119:
-#line 849 "perly.y" /* yacc.c:1646 */
+#line 849 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 120:
-#line 850 "perly.y" /* yacc.c:1646 */
+#line 850 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 121:
-#line 856 "perly.y" /* yacc.c:1646 */
+#line 856 "perly.y" /* yacc.c:1652 */
{
if (parser->copline > (line_t)(ps[-2].val.ival))
parser->copline = (line_t)(ps[-2].val.ival);
break;
case 122:
-#line 866 "perly.y" /* yacc.c:1646 */
+#line 866 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 123:
-#line 867 "perly.y" /* yacc.c:1646 */
+#line 867 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 124:
-#line 871 "perly.y" /* yacc.c:1646 */
+#line 871 "perly.y" /* yacc.c:1652 */
{
if (parser->copline > (line_t)(ps[-2].val.ival))
parser->copline = (line_t)(ps[-2].val.ival);
break;
case 125:
-#line 882 "perly.y" /* yacc.c:1646 */
+#line 882 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 126:
-#line 884 "perly.y" /* yacc.c:1646 */
+#line 884 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 127:
-#line 886 "perly.y" /* yacc.c:1646 */
+#line 886 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 129:
-#line 892 "perly.y" /* yacc.c:1646 */
+#line 892 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[-1].val.opval); }
break;
case 130:
-#line 894 "perly.y" /* yacc.c:1646 */
+#line 894 "perly.y" /* yacc.c:1652 */
{
OP* term = (ps[0].val.opval);
(yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
break;
case 132:
-#line 903 "perly.y" /* yacc.c:1646 */
+#line 903 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
}
break;
case 133:
-#line 907 "perly.y" /* yacc.c:1646 */
+#line 907 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
}
break;
case 134:
-#line 911 "perly.y" /* yacc.c:1646 */
+#line 911 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST,
op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
break;
case 135:
-#line 917 "perly.y" /* yacc.c:1646 */
+#line 917 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
break;
case 136:
-#line 922 "perly.y" /* yacc.c:1646 */
+#line 922 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST,
op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
break;
case 137:
-#line 928 "perly.y" /* yacc.c:1646 */
+#line 928 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST,
op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
break;
case 138:
-#line 934 "perly.y" /* yacc.c:1646 */
+#line 934 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
break;
case 139:
-#line 936 "perly.y" /* yacc.c:1646 */
+#line 936 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
break;
case 140:
-#line 938 "perly.y" /* yacc.c:1646 */
+#line 938 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
break;
case 141:
-#line 940 "perly.y" /* yacc.c:1646 */
+#line 940 "perly.y" /* yacc.c:1652 */
{ SvREFCNT_inc_simple_void(PL_compcv);
(yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
break;
case 142:
-#line 943 "perly.y" /* yacc.c:1646 */
+#line 943 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST,
op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
break;
case 145:
-#line 958 "perly.y" /* yacc.c:1646 */
+#line 958 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
break;
case 146:
-#line 960 "perly.y" /* yacc.c:1646 */
+#line 960 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
}
break;
case 147:
-#line 963 "perly.y" /* yacc.c:1646 */
+#line 963 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP(OP_AELEM, 0,
ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
scalar((ps[-1].val.opval)));
break;
case 148:
-#line 968 "perly.y" /* yacc.c:1646 */
+#line 968 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP(OP_AELEM, 0,
ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
scalar((ps[-1].val.opval)));
break;
case 149:
-#line 973 "perly.y" /* yacc.c:1646 */
+#line 973 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
}
break;
case 150:
-#line 976 "perly.y" /* yacc.c:1646 */
+#line 976 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP(OP_HELEM, 0,
ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
jmaybe((ps[-2].val.opval))); }
break;
case 151:
-#line 980 "perly.y" /* yacc.c:1646 */
+#line 980 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP(OP_HELEM, 0,
ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
jmaybe((ps[-2].val.opval))); }
break;
case 152:
-#line 984 "perly.y" /* yacc.c:1646 */
+#line 984 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
newCVREF(0, scalar((ps[-3].val.opval))));
if (parser->expect == XBLOCK)
break;
case 153:
-#line 990 "perly.y" /* yacc.c:1646 */
+#line 990 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST, (ps[-1].val.opval),
newCVREF(0, scalar((ps[-4].val.opval)))));
break;
case 154:
-#line 998 "perly.y" /* yacc.c:1646 */
+#line 998 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST, (ps[-1].val.opval),
newCVREF(0, scalar((ps[-3].val.opval)))));
break;
case 155:
-#line 1005 "perly.y" /* yacc.c:1646 */
+#line 1005 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
newCVREF(0, scalar((ps[-2].val.opval))));
if (parser->expect == XBLOCK)
break;
case 156:
-#line 1011 "perly.y" /* yacc.c:1646 */
+#line 1011 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
break;
case 157:
-#line 1013 "perly.y" /* yacc.c:1646 */
+#line 1013 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
break;
case 158:
-#line 1015 "perly.y" /* yacc.c:1646 */
+#line 1015 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
break;
case 159:
-#line 1020 "perly.y" /* yacc.c:1646 */
+#line 1020 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
break;
case 160:
-#line 1022 "perly.y" /* yacc.c:1646 */
+#line 1022 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
break;
case 161:
-#line 1024 "perly.y" /* yacc.c:1646 */
+#line 1024 "perly.y" /* yacc.c:1652 */
{ if ((ps[-1].val.ival) != OP_REPEAT)
scalar((ps[-2].val.opval));
(yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
break;
case 162:
-#line 1029 "perly.y" /* yacc.c:1646 */
+#line 1029 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
break;
case 163:
-#line 1031 "perly.y" /* yacc.c:1646 */
+#line 1031 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
break;
case 164:
-#line 1033 "perly.y" /* yacc.c:1646 */
+#line 1033 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 165:
-#line 1035 "perly.y" /* yacc.c:1646 */
+#line 1035 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 166:
-#line 1037 "perly.y" /* yacc.c:1646 */
+#line 1037 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
break;
case 167:
-#line 1039 "perly.y" /* yacc.c:1646 */
+#line 1039 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
break;
case 168:
-#line 1041 "perly.y" /* yacc.c:1646 */
+#line 1041 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
break;
case 169:
-#line 1043 "perly.y" /* yacc.c:1646 */
+#line 1043 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 170:
-#line 1045 "perly.y" /* yacc.c:1646 */
+#line 1045 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 171:
-#line 1047 "perly.y" /* yacc.c:1646 */
+#line 1047 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 172:
-#line 1049 "perly.y" /* yacc.c:1646 */
+#line 1049 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 173:
-#line 1053 "perly.y" /* yacc.c:1646 */
+#line 1053 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
break;
case 174:
-#line 1055 "perly.y" /* yacc.c:1646 */
+#line 1055 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
break;
case 175:
-#line 1057 "perly.y" /* yacc.c:1646 */
+#line 1057 "perly.y" /* yacc.c:1652 */
{ yyerror("syntax error"); YYERROR; }
break;
case 176:
-#line 1059 "perly.y" /* yacc.c:1646 */
+#line 1059 "perly.y" /* yacc.c:1652 */
{ yyerror("syntax error"); YYERROR; }
break;
case 177:
-#line 1063 "perly.y" /* yacc.c:1646 */
+#line 1063 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 178:
-#line 1065 "perly.y" /* yacc.c:1646 */
+#line 1065 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 179:
-#line 1069 "perly.y" /* yacc.c:1646 */
+#line 1069 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
break;
case 180:
-#line 1071 "perly.y" /* yacc.c:1646 */
+#line 1071 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
break;
case 181:
-#line 1073 "perly.y" /* yacc.c:1646 */
+#line 1073 "perly.y" /* yacc.c:1652 */
{ yyerror("syntax error"); YYERROR; }
break;
case 182:
-#line 1075 "perly.y" /* yacc.c:1646 */
+#line 1075 "perly.y" /* yacc.c:1652 */
{ yyerror("syntax error"); YYERROR; }
break;
case 183:
-#line 1079 "perly.y" /* yacc.c:1646 */
+#line 1079 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 184:
-#line 1081 "perly.y" /* yacc.c:1646 */
+#line 1081 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 185:
-#line 1086 "perly.y" /* yacc.c:1646 */
+#line 1086 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
break;
case 186:
-#line 1088 "perly.y" /* yacc.c:1646 */
+#line 1088 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 187:
-#line 1091 "perly.y" /* yacc.c:1646 */
+#line 1091 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
break;
case 188:
-#line 1093 "perly.y" /* yacc.c:1646 */
+#line 1093 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
break;
case 189:
-#line 1095 "perly.y" /* yacc.c:1646 */
+#line 1095 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_POSTINC, 0,
op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
break;
case 190:
-#line 1098 "perly.y" /* yacc.c:1646 */
+#line 1098 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_POSTDEC, 0,
op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
break;
case 191:
-#line 1101 "perly.y" /* yacc.c:1646 */
+#line 1101 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_convert_list(OP_JOIN, 0,
op_append_elem(
OP_LIST,
break;
case 192:
-#line 1112 "perly.y" /* yacc.c:1646 */
+#line 1112 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_PREINC, 0,
op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
break;
case 193:
-#line 1115 "perly.y" /* yacc.c:1646 */
+#line 1115 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_PREDEC, 0,
op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
break;
case 194:
-#line 1122 "perly.y" /* yacc.c:1646 */
+#line 1122 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
break;
case 195:
-#line 1124 "perly.y" /* yacc.c:1646 */
+#line 1124 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newANONLIST(NULL);}
break;
case 196:
-#line 1126 "perly.y" /* yacc.c:1646 */
+#line 1126 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
break;
case 197:
-#line 1128 "perly.y" /* yacc.c:1646 */
+#line 1128 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newANONHASH(NULL); }
break;
case 198:
-#line 1130 "perly.y" /* yacc.c:1646 */
+#line 1130 "perly.y" /* yacc.c:1652 */
{ SvREFCNT_inc_simple_void(PL_compcv);
(yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
break;
case 199:
-#line 1133 "perly.y" /* yacc.c:1646 */
+#line 1133 "perly.y" /* yacc.c:1652 */
{ SvREFCNT_inc_simple_void(PL_compcv);
(yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); }
break;
case 200:
-#line 1139 "perly.y" /* yacc.c:1646 */
+#line 1139 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
break;
case 201:
-#line 1141 "perly.y" /* yacc.c:1646 */
+#line 1141 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
break;
case 206:
-#line 1149 "perly.y" /* yacc.c:1646 */
+#line 1149 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
break;
case 207:
-#line 1151 "perly.y" /* yacc.c:1646 */
+#line 1151 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
break;
case 208:
-#line 1153 "perly.y" /* yacc.c:1646 */
+#line 1153 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
break;
case 209:
-#line 1155 "perly.y" /* yacc.c:1646 */
+#line 1155 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 210:
-#line 1157 "perly.y" /* yacc.c:1646 */
+#line 1157 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = localize((ps[0].val.opval),0); }
break;
case 211:
-#line 1159 "perly.y" /* yacc.c:1646 */
+#line 1159 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = sawparens((ps[-1].val.opval)); }
break;
case 212:
-#line 1161 "perly.y" /* yacc.c:1646 */
+#line 1161 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 213:
-#line 1163 "perly.y" /* yacc.c:1646 */
+#line 1163 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = sawparens(newNULLLIST()); }
break;
case 214:
-#line 1165 "perly.y" /* yacc.c:1646 */
+#line 1165 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 215:
-#line 1167 "perly.y" /* yacc.c:1646 */
+#line 1167 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 216:
-#line 1169 "perly.y" /* yacc.c:1646 */
+#line 1169 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 217:
-#line 1171 "perly.y" /* yacc.c:1646 */
+#line 1171 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 218:
-#line 1173 "perly.y" /* yacc.c:1646 */
+#line 1173 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
break;
case 219:
-#line 1175 "perly.y" /* yacc.c:1646 */
+#line 1175 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 220:
-#line 1177 "perly.y" /* yacc.c:1646 */
+#line 1177 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_prepend_elem(OP_ASLICE,
newOP(OP_PUSHMARK, 0),
newLISTOP(OP_ASLICE, 0,
break;
case 221:
-#line 1187 "perly.y" /* yacc.c:1646 */
+#line 1187 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_prepend_elem(OP_KVASLICE,
newOP(OP_PUSHMARK, 0),
newLISTOP(OP_KVASLICE, 0,
break;
case 222:
-#line 1197 "perly.y" /* yacc.c:1646 */
+#line 1197 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_prepend_elem(OP_HSLICE,
newOP(OP_PUSHMARK, 0),
newLISTOP(OP_HSLICE, 0,
break;
case 223:
-#line 1207 "perly.y" /* yacc.c:1646 */
+#line 1207 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
newOP(OP_PUSHMARK, 0),
newLISTOP(OP_KVHSLICE, 0,
break;
case 224:
-#line 1217 "perly.y" /* yacc.c:1646 */
+#line 1217 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 225:
-#line 1219 "perly.y" /* yacc.c:1646 */
+#line 1219 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
break;
case 226:
-#line 1221 "perly.y" /* yacc.c:1646 */
+#line 1221 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
}
break;
case 227:
-#line 1224 "perly.y" /* yacc.c:1646 */
+#line 1224 "perly.y" /* yacc.c:1652 */
{
(yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
break;
case 228:
-#line 1229 "perly.y" /* yacc.c:1646 */
+#line 1229 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
}
break;
case 229:
-#line 1233 "perly.y" /* yacc.c:1646 */
+#line 1233 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newSVREF((ps[-3].val.opval)); }
break;
case 230:
-#line 1235 "perly.y" /* yacc.c:1646 */
+#line 1235 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newAVREF((ps[-3].val.opval)); }
break;
case 231:
-#line 1237 "perly.y" /* yacc.c:1646 */
+#line 1237 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newHVREF((ps[-3].val.opval)); }
break;
case 232:
-#line 1239 "perly.y" /* yacc.c:1646 */
+#line 1239 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
break;
case 233:
-#line 1242 "perly.y" /* yacc.c:1646 */
+#line 1242 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
break;
case 234:
-#line 1244 "perly.y" /* yacc.c:1646 */
+#line 1244 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
PL_hints |= HINT_BLOCK_SCOPE; }
break;
case 235:
-#line 1247 "perly.y" /* yacc.c:1646 */
+#line 1247 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
break;
case 236:
-#line 1249 "perly.y" /* yacc.c:1646 */
+#line 1249 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
break;
case 237:
-#line 1251 "perly.y" /* yacc.c:1646 */
+#line 1251 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newOP((ps[0].val.ival), 0); }
break;
case 238:
-#line 1253 "perly.y" /* yacc.c:1646 */
+#line 1253 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
break;
case 239:
-#line 1255 "perly.y" /* yacc.c:1646 */
+#line 1255 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
break;
case 240:
-#line 1257 "perly.y" /* yacc.c:1646 */
+#line 1257 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
break;
case 241:
-#line 1259 "perly.y" /* yacc.c:1646 */
+#line 1259 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
break;
case 242:
-#line 1261 "perly.y" /* yacc.c:1646 */
+#line 1261 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
break;
case 243:
-#line 1263 "perly.y" /* yacc.c:1646 */
+#line 1263 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
break;
case 244:
-#line 1266 "perly.y" /* yacc.c:1646 */
+#line 1266 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newOP((ps[0].val.ival), 0); }
break;
case 245:
-#line 1268 "perly.y" /* yacc.c:1646 */
+#line 1268 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newOP((ps[-2].val.ival), 0);}
break;
case 246:
-#line 1270 "perly.y" /* yacc.c:1646 */
+#line 1270 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 247:
-#line 1272 "perly.y" /* yacc.c:1646 */
+#line 1272 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[-2].val.opval); }
break;
case 248:
-#line 1274 "perly.y" /* yacc.c:1646 */
+#line 1274 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
break;
case 249:
-#line 1276 "perly.y" /* yacc.c:1646 */
+#line 1276 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
: newOP((ps[-2].val.ival), OPf_SPECIAL); }
break;
case 250:
-#line 1280 "perly.y" /* yacc.c:1646 */
+#line 1280 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
break;
case 251:
-#line 1282 "perly.y" /* yacc.c:1646 */
+#line 1282 "perly.y" /* yacc.c:1652 */
{
if ( (ps[0].val.opval)->op_type != OP_TRANS
&& (ps[0].val.opval)->op_type != OP_TRANSR
break;
case 252:
-#line 1293 "perly.y" /* yacc.c:1646 */
+#line 1293 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
break;
case 256:
-#line 1301 "perly.y" /* yacc.c:1646 */
+#line 1301 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
break;
case 257:
-#line 1303 "perly.y" /* yacc.c:1646 */
+#line 1303 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = localize((ps[0].val.opval),1); }
break;
case 258:
-#line 1305 "perly.y" /* yacc.c:1646 */
+#line 1305 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
break;
case 259:
-#line 1310 "perly.y" /* yacc.c:1646 */
+#line 1310 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = sawparens((ps[-1].val.opval)); }
break;
case 260:
-#line 1312 "perly.y" /* yacc.c:1646 */
+#line 1312 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = sawparens(newNULLLIST()); }
break;
case 261:
-#line 1315 "perly.y" /* yacc.c:1646 */
+#line 1315 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 262:
-#line 1317 "perly.y" /* yacc.c:1646 */
+#line 1317 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 263:
-#line 1319 "perly.y" /* yacc.c:1646 */
+#line 1319 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 264:
-#line 1324 "perly.y" /* yacc.c:1646 */
+#line 1324 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 265:
-#line 1326 "perly.y" /* yacc.c:1646 */
+#line 1326 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 266:
-#line 1330 "perly.y" /* yacc.c:1646 */
+#line 1330 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 267:
-#line 1332 "perly.y" /* yacc.c:1646 */
+#line 1332 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 268:
-#line 1336 "perly.y" /* yacc.c:1646 */
+#line 1336 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = NULL; }
break;
case 269:
-#line 1338 "perly.y" /* yacc.c:1646 */
+#line 1338 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
case 270:
-#line 1344 "perly.y" /* yacc.c:1646 */
+#line 1344 "perly.y" /* yacc.c:1652 */
{ parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
break;
case 278:
-#line 1361 "perly.y" /* yacc.c:1646 */
+#line 1361 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
break;
case 279:
-#line 1365 "perly.y" /* yacc.c:1646 */
+#line 1365 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newSVREF((ps[0].val.opval)); }
break;
case 280:
-#line 1369 "perly.y" /* yacc.c:1646 */
+#line 1369 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newAVREF((ps[0].val.opval));
if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
}
break;
case 281:
-#line 1375 "perly.y" /* yacc.c:1646 */
+#line 1375 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newHVREF((ps[0].val.opval));
if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
}
break;
case 282:
-#line 1381 "perly.y" /* yacc.c:1646 */
+#line 1381 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newAVREF((ps[0].val.opval)); }
break;
case 283:
-#line 1383 "perly.y" /* yacc.c:1646 */
+#line 1383 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newAVREF((ps[-3].val.opval)); }
break;
case 284:
-#line 1387 "perly.y" /* yacc.c:1646 */
+#line 1387 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
break;
case 286:
-#line 1392 "perly.y" /* yacc.c:1646 */
+#line 1392 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newAVREF((ps[-2].val.opval)); }
break;
case 288:
-#line 1397 "perly.y" /* yacc.c:1646 */
+#line 1397 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newHVREF((ps[-2].val.opval)); }
break;
case 290:
-#line 1402 "perly.y" /* yacc.c:1646 */
+#line 1402 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
break;
case 291:
-#line 1407 "perly.y" /* yacc.c:1646 */
+#line 1407 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = scalar((ps[0].val.opval)); }
break;
case 292:
-#line 1409 "perly.y" /* yacc.c:1646 */
+#line 1409 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = scalar((ps[0].val.opval)); }
break;
case 293:
-#line 1411 "perly.y" /* yacc.c:1646 */
+#line 1411 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = op_scope((ps[0].val.opval)); }
break;
case 294:
-#line 1414 "perly.y" /* yacc.c:1646 */
+#line 1414 "perly.y" /* yacc.c:1652 */
{ (yyval.opval) = (ps[0].val.opval); }
break;
/* Generated from:
- * e762043bfa8c11d38e46b8759b544243dd0b1dee698344186c06df7dd91ec5ed perly.y
+ * e5b801fdebce5c77dd8e644fc5a489cbea6af33db180e771dd9d669b12bbe0cf perly.y
* 0947213b55d0ed11693554bea04987e886cf285f5c14cf9075fa1e7acc3f4061 regen_perly.pl
* ex: set ro: */
Any changes made here will be lost!
*/
-#define PERL_BISON_VERSION 30000
+#define PERL_BISON_VERSION 30003
#ifdef PERL_CORE
-/* A Bison parser, made by GNU Bison 3.0.2. */
+/* A Bison parser, made by GNU Bison 3.3.2. */
/* Bison interface for Yacc-like parsers in C
- Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+ Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
+ Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
+/* Undocumented macros, especially those whose name start with YY_,
+ are private implementation details. Do not rely on them. */
+
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif /* PERL_IN_TOKE_C */
#endif /* PERL_CORE */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
+
union YYSTYPE
{
GV *gvval;
};
+
+typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif
/* Generated from:
- * e762043bfa8c11d38e46b8759b544243dd0b1dee698344186c06df7dd91ec5ed perly.y
+ * e5b801fdebce5c77dd8e644fc5a489cbea6af33db180e771dd9d669b12bbe0cf perly.y
* 0947213b55d0ed11693554bea04987e886cf285f5c14cf9075fa1e7acc3f4061 regen_perly.pl
* ex: set ro: */
/* YYNSTATES -- Number of states. */
#define YYNSTATES 572
-/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
- by yylex, with out-of-bounds checking. */
#define YYUNDEFTOK 2
#define YYMAXUTOK 344
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, with out-of-bounds checking. */
#define YYTRANSLATE(YYX) \
- ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+ ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex, without out-of-bounds checking. */
+ as returned by yylex. */
static const yytype_uint8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
};
/* Generated from:
- * e762043bfa8c11d38e46b8759b544243dd0b1dee698344186c06df7dd91ec5ed perly.y
+ * e5b801fdebce5c77dd8e644fc5a489cbea6af33db180e771dd9d669b12bbe0cf perly.y
* 0947213b55d0ed11693554bea04987e886cf285f5c14cf9075fa1e7acc3f4061 regen_perly.pl
* ex: set ro: */
* to run regen_perly.pl, which re-creates the files perly.h, perly.tab
* and perly.act which are derived from this.
*
- * The main job of of this grammar is to call the various newFOO()
+ * The main job of this grammar is to call the various newFOO()
* functions in op.c to build a syntax tree of OP structs.
* It relies on the lexer in toke.c to do the tokenizing.
*
* as the first line of a Perl program designed to be executed directly
* by name, instead of the standard Unix #!. If ALTERNATE_SHEBANG
* begins with a character other then #, then Perl will only treat
- * it as a command line if if finds the string "perl" in the first
+ * it as a command line if it finds the string "perl" in the first
* word; otherwise it's treated as the first line of code in the script.
* (IOW, Perl won't hand off to another interpreter via an alternate
* shebang sequence that might be legal Perl code.)
Forcing literal C<{> characters to be escaped will enable the Perl
language to be extended in various ways in future releases. To avoid
-needlessly breaking existing code, the restriction is is not enforced in
+needlessly breaking existing code, the restriction is not enforced in
contexts where there are unlikely to ever be extensions that could
conflict with the use there of C<{> as a literal. A non-deprecation
warning that the left brace is being taken literally is raised in
Forcing literal C<"{"> characters to be escaped enables the Perl
language to be extended in various ways in future releases. To avoid
-needlessly breaking existing code, the restriction is is not enforced in
+needlessly breaking existing code, the restriction is not enforced in
contexts where there are unlikely to ever be extensions that could
conflict with the use there of C<"{"> as a literal. Those that are
not potentially ambiguous do not warn; those that are do raise a
Forcing literal C<"{"> characters to be escaped enables the Perl
language to be extended in various ways in future releases. To avoid
-needlessly breaking existing code, the restriction is is not enforced in
+needlessly breaking existing code, the restriction is not enforced in
contexts where there are unlikely to ever be extensions that could
conflict with the use there of C<"{"> as a literal. Those that are
not potentially ambiguous do not warn; those that are raise this
component is precisely C<smoke-me>.
The procedure for doing this is roughly as follows (using the example of
-of tonyc's smoke-me branch called win32stat):
+tonyc's smoke-me branch called win32stat):
First, make a local branch and switch to it:
The steps above are in a very specific order, designed to be the reverse
order of when the context was pushed. The first thing to do is to copy
-and/or protect any any return arguments and free any temps in the current
+and/or protect any return arguments and free any temps in the current
scope. Scope exits like an rvalue sub normally return a mortal copy of
their return args (as opposed to lvalue subs). It is important to make
this copy before the save stack is popped or variables are restored, or
C<"\x80\x41"> on an EBCDIC 1047 one.
But easiest is, if the character is specifiable as a literal, like
-C<"A"> or C<"%">, to use that; if not so specificable, you can use use
+C<"A"> or C<"%">, to use that; if not so specificable, you can use
C<\N{}> , if the side effects aren't troublesome. Simply specify all
your characters in hex, using C<\N{U+ZZ}> instead of C<\xZZ>. C<\N{}>
is the Unicode name, and so it
=head2 Category C<LC_NUMERIC>: Numeric Formatting
-After a proper C<POSIX::setlocale()> call, and within the scope of
+After a proper C<POSIX::setlocale()> call, and within the scope
of a C<use locale> form that includes numerics, Perl obeys the
C<LC_NUMERIC> locale information, which controls an application's idea
of how numbers should be formatted for human readability.
=head2 Wildcards in Property Values
-Starting in Perl 5.30, it is possible to do do something like this:
+Starting in Perl 5.30, it is possible to do something like this:
qr!\p{numeric_value=/\A[0-5]\z/}!
other delimiters are terminated by their mirror images. These are
C<"(">, C<"[>", and C<"E<lt>">. If the delimiter is any of C<"-">,
C<"_">, C<"+">, or C<"\">, or is the same delimiter as is used for the
-enclosing pattern, it must be be preceded by a backslash escape, both
+enclosing pattern, it must be preceded by a backslash escape, both
fore and aft.
Beware of using C<"$"> to indicate to match the end of the string. It
Starting in Perl 5.28.0, the C<split> function with a pattern specified as
a string containing a single space handles whitespace characters consistently
-within the scope of of C<unicode_strings>. Prior to that, or outside its scope,
+within the scope of C<unicode_strings>. Prior to that, or outside its scope,
characters that are whitespace according to Unicode rules but not according to
ASCII rules were treated as field contents rather than field separators when
they appear in byte-encoded strings.
/* EXTEND_SKIP(): used for where you would normally call EXTEND(), but
* you know for sure that a previous op will have already extended the
- * stack sufficiently. For example pp_enteriter ensures that that there
+ * stack sufficiently. For example pp_enteriter ensures that there
* is always at least 1 free slot, so pp_iter can return &PL_sv_yes/no
* without checking each time. Calling EXTEND_SKIP() defeats the HWM
* debugging mechanism which would otherwise whine
(void)SvPOK_only_UTF8(targ);
}
- /* update the taint state of various various variables in
+ /* update the taint state of various variables in
* preparation for final exit.
* See "how taint works" above pp_subst() */
if (TAINTING_get) {
}
if (old != rx)
(void)ReREFCNT_inc(rx);
- /* update the taint state of various various variables in preparation
+ /* update the taint state of various variables in preparation
* for calling the code block.
* See "how taint works" above pp_subst() */
if (TAINTING_get) {
}
/* ... but if we fail, still search @INC for code references;
- * these are applied even on on-searchable paths (except
+ * these are applied even on non-searchable paths (except
* if we got EACESS).
*
* For searchable paths, just search @INC normally
* one set of segment lengths.
*
* * If the string has different plain and utf8 representations
- * (e.g. "\x80"), then then aux[PERL_MULTICONCAT_IX_PLAIN_PV/LEN]]
+ * (e.g. "\x80"), then aux[PERL_MULTICONCAT_IX_PLAIN_PV/LEN]]
* holds the plain rep, while aux[PERL_MULTICONCAT_IX_UTF8_PV/LEN]
* holds the utf8 rep, and there are 2 sets of segment lengths,
* with the utf8 set following after the plain set.
* calculate how much extra growth is needed for all the chars
* which will expand to two utf8 bytes.
* Also, if the growth is non-zero, negate the length to indicate
- * that this this is a variant string. Conversely, un-negate the
+ * that this is a variant string. Conversely, un-negate the
* length on utf8 args (which was only needed to flag non-utf8
* args in this loop */
for (svpv_p = svpv_buf; svpv_p < svpv_end; svpv_p++) {
* it is only included in special cases.
*
* In Digital UNIX/Tru64 if using the getespw*() (which seems to be
- * be preferred interface, even though also the getprpw*() interface
+ * the preferred interface, even though also the getprpw*() interface
* is available) one needs to link with -lsecurity -ldb -laud -lm.
* One also needs to call set_auth_parameters() in main() before
* doing anything else, whether one is using getespw*() or getprpw*().
* baba9dfc133e3cb770a89aaf0973b1341fa61c2da6c176baf6428898b3b568d8 lib/unicore/extracted/DLineBreak.txt
* 6d4a8c945dd7db83ed617cbb7d937de7f4ecf016ff22970d846e996a7c9a2a5d lib/unicore/extracted/DNumType.txt
* 5b7c14380d5cceeaffcfbc18db1ed936391d2af2d51f5a41f1a17b692c77e59b lib/unicore/extracted/DNumValues.txt
- * d595d6b96967567fa57cf477c8cf4a72b456347a8ea054c05847b1fdb3072723 lib/unicore/mktables
+ * aee2ce1142e88494b09ea4abc065f8d74ad1a95f5fb3e03da469ab84306386e9 lib/unicore/mktables
* 50b85a67451145545a65cea370dab8d3444fbfe07e9c34cef560c5b7da9d3eef lib/unicore/version
* 2680b9254eb236c5c090f11b149605043e8c8433661b96efc4a42fb4709342a5 regen/charset_translations.pl
* f9a393e7add8c7c2728356473ce5b52246d51295b2da0c48fb6f0aa21799e2bb regen/regcharclass.pl
* character folded sequences. Since a single character can fold into
* such a sequence, the minimum match length for this node is less than
* the number of characters in the node. This routine returns in
- * *min_subtract how many characters to subtract from the the actual
+ * *min_subtract how many characters to subtract from the actual
* length of the string to get a real minimum match length; it is 0 if
* there are no multi-char foldeds. This delta is used by the caller to
* adjust the min length of the match, and the delta between min and max,
/* EXACTF nodes need to know that the minimum length
* changed so that a sharp s in the string can match this
* ss in the pattern, but they remain EXACTF nodes, as they
- * won't match this unless the target string is is UTF-8,
+ * won't match this unless the target string is in UTF-8,
* which we don't know until runtime. EXACTFL nodes can't
* transform into EXACTFU nodes */
if (OP(scan) != EXACTF && OP(scan) != EXACTFL) {
/* we make the assumption here that each op in the list of
* op_siblings maps to one SV pushed onto the stack,
* except for code blocks, with have both an OP_NULL and
- * and OP_CONST.
+ * an OP_CONST.
* This allows us to match up the list of SVs against the
* list of OPs to find the next code block.
*
* length of the pattern. Patches welcome to improve that guess. That amount
* of space is malloc'd and then immediately freed, and then clawed back node
* by node. This design is to minimze, to the extent possible, memory churn
- * when doing the the reallocs.
+ * when doing the reallocs.
*
* A separate parentheses counting pass may be needed in some cases.
* (Previously the sizing pass did this.) Patches welcome to reduce the number
* one of them */
while (i_a < len_a && i_b < len_b) {
UV cp; /* The element to potentially add to the union's array */
- bool cp_in_set; /* is it in the the input list's set or not */
+ bool cp_in_set; /* is it in the input list's set or not */
/* We need to take one or the other of the two inputs for the union.
* Since we are merging two sorted lists, we take the smaller of the
fc = uc = utf8_to_uvchr_buf(s, s + bytelen, NULL);
/* The only code points that aren't folded in a UTF EXACTFish
- * node are are the problematic ones in EXACTFL nodes */
+ * node are the problematic ones in EXACTFL nodes */
if (OP(node) == EXACTFL && is_PROBLEMATIC_LOCALE_FOLDEDS_START_cp(uc)) {
/* We need to check for the possibility that this EXACTFL
* node begins with a multi-char fold. Therefore we fold
* printable should have each end point be a portable value
* for it (preferably like 'A', but we don't warn if it is
* a (portable) Unicode name or code point), and the range
- * must be be all digits or all letters of the same case.
+ * must be all digits or all letters of the same case.
* Otherwise, the range is non-portable and unclear as to
* what it contains */
if ( (isPRINT_A(prevvalue) || isPRINT_A(value))
* points) in the ASCII range, so we can't use it here to
* artificially restrict the fold domain, so we check if
* the class does or does not match some EXACTFish node.
- * Further, if we aren't under /i, and and the folded-to
+ * Further, if we aren't under /i, and the folded-to
* character is part of a multi-character fold, we can't do
* this optimization, as the sequence around it could be
* that multi-character fold, and we don't here know the
int inverted_bias, as_is_bias;
- /* We will apply our bias to whichever of the the results doesn't have
+ /* We will apply our bias to whichever of the results doesn't have
* the '^' */
if (invert) {
invert = FALSE;
which respectively return a list of op names where:
field 3 of regen/opcodes specifies 'ck_foo' as the check function;
- field 4 of of regen/opcodes has flag or type 'X' set;
- argument field N of of regen/opcodes matches 'XYZ';
+ field 4 of regen/opcodes has flag or type 'X' set;
+ argument field N of regen/opcodes matches 'XYZ';
For example
# replacement requires UTF-8.
0 => qw(OPpTRANS_CAN_FORCE_UTF8 CAN_FORCE_UTF8),
- 1 => qw(OPpTRANS_USE_SVOP USE_SVOP),# This is implemented an an svop
+ 1 => qw(OPpTRANS_USE_SVOP USE_SVOP),# This is implemented as an svop
# vs pvop
2 => qw(OPpTRANS_IDENTICAL IDENT), # right side is same as left
3 => qw(OPpTRANS_SQUASH SQUASH), # /s
* Ideally this could be replaced by a just an array of function pointers
* to the C library functions that implement the macros this calls.
* However, to compile, the precise function signatures are required, and
- * these may vary from platform to to platform. To avoid having to figure
+ * these may vary from platform to platform. To avoid having to figure
* out what those all are on each platform, I (khw) am using this method,
* which adds an extra layer of function call overhead (unless the C
* optimizer strips it away). But we don't particularly care about
rest of the pattern. Variable and state names reflect this convention.
The states in the main switch are the union of ops and failure/success of
-substates associated with with that op. For example, IFMATCH is the op
+substates associated with that op. For example, IFMATCH is the op
that does lookahead assertions /(?=A)B/ and so the IFMATCH state means
'execute IFMATCH'; while IFMATCH_A is a state saying that we have just
successfully matched A and IFMATCH_A_fail is a state saying that we have
} keeper;
/* quantifiers - these members are used for storing state for
- for the regops used to implement quantifiers */
+ the regops used to implement quantifiers */
struct {
/* this first element must match u.yes */
struct regmatch_state *prev_yes_state;
* being allowed for %c (ideally we should warn on e.g. '%hc').
* Setting a default intsize, along with a positive
* (which signals unsigned) base, causes, for C-ish use, the
- * va_arg to be interpreted as as unsigned int, when it's
+ * va_arg to be interpreted as an unsigned int, when it's
* actually signed, which will convert -ve values to high +ve
* values. Note that unlike the libc %c, values > 255 will
* convert to high unicode points rather than being truncated
/* XXX should this sv_dup_inc? Or only if CxEVAL_TXT_REFCNTED ???? */
ncx->blk_eval.cur_text = sv_dup(ncx->blk_eval.cur_text, param);
ncx->blk_eval.cv = cv_dup(ncx->blk_eval.cv, param);
- /* XXX what do do with cur_top_env ???? */
+ /* XXX what to do with cur_top_env ???? */
break;
case CXt_LOOP_LAZYSV:
ncx->blk_loop.state_u.lazysv.end
#define PRIVSHIFT 4 /* (SVp_?OK >> PRIVSHIFT) == SVf_?OK */
-/* SVf_AMAGIC means that the stash *may* have have overload methods. It's
+/* SVf_AMAGIC means that the stash *may* have overload methods. It's
* set each time a function is compiled into a stash, and is reset by the
* overload code when called for the first time and finds that there are
* no overload methods. Note that this used to be set on the object; but
=for apidoc Am|bool|SvIOK_UV|SV* sv
Returns a boolean indicating whether the SV contains an integer that must be
interpreted as unsigned. A non-negative integer whose value is within the
-range of both an IV and a UV may be be flagged as either C<SvUOK> or C<SvIOK>.
+range of both an IV and a UV may be flagged as either C<SvUOK> or C<SvIOK>.
=for apidoc Am|bool|SvUOK|SV* sv
Returns a boolean indicating whether the SV contains an integer that must be
interpreted as unsigned. A non-negative integer whose value is within the
-range of both an IV and a UV may be be flagged as either C<SvUOK> or C<SvIOK>.
+range of both an IV and a UV may be flagged as either C<SvUOK> or C<SvIOK>.
=for apidoc Am|bool|SvIOK_notUV|SV* sv
Returns a boolean indicating whether the SV contains a signed integer.
/*
=for apidoc Am|U32|SvREADONLY|SV* sv
Returns true if the argument is readonly, otherwise returns false.
-Exposed to to perl code via Internals::SvREADONLY().
+Exposed to perl code via Internals::SvREADONLY().
=for apidoc Am|U32|SvREADONLY_on|SV* sv
Mark an object as readonly. Exactly what this means depends on the object
}
# Config.pm may be broken for make minitest. And this is only a refinement
# for skipping tests on non-default builds, so it is allowed to fail.
- # What we want to to is make a list of extensions which we did not build.
+ # What we want to do is make a list of extensions which we did not build.
my $configsh = '../config.sh';
my ($extensions, $known_extensions);
if (-f $configsh) {
# the other reader reads one line, waits a few seconds and then
# exits to test the waitpid function.
#
-# Using 4+ arg open for the children that sleep so that that we're
+# Using 4+ arg open for the children that sleep so that we're
# killing the perl process instead of an intermediate shell, this
# allows harness to see the file handles closed sooner. I didn't
# convert them all since I wanted 3-arg open to continue to be
-# Common tools for test files files to find the locales which exist on the
+# Common tools for test files to find the locales which exist on the
# system. Caller should have verified that this isn't miniperl before calling
# the functions.
object_ok($bar, 'Bar');
object_ok($bar, 'Foo');
- # test it working with with Sub::Name
+ # test it working with Sub::Name
SKIP: {
eval 'use Sub::Name';
skip("Sub::Name is required for this test", 3) if $@;
object_ok($bar, 'Baɾ');
object_ok($bar, 'ᕘ');
- # test it working with with Sub::Name
+ # test it working with Sub::Name
SKIP: {
eval 'use Sub::Name';
skip("Sub::Name is required for this test", 3) if $@;
}
# undef on LHS uses RHS as lvalue instead
- # Note this this just codifies existing behaviour - it may not be
+ # Note that this just codifies existing behaviour - it may not be
# correct. See http://nntp.perl.org/group/perl.perl5.porters/240358.
{
is(-1 << 1, 0xFFFF_FFFF_FFFF_FFFE,
"neg UV (sic) left shift = 0xFF..E");
is(-1 >> 1, 0x7FFF_FFFF_FFFF_FFFF,
- "neg UV (sic) right right = 0x7F..F");
+ "neg UV (sic) right shift = 0x7F..F");
} elsif ($w == 32) {
no warnings "portable";
is(-1 << 1, 0xFFFF_FFFE, "neg left shift == 0xFF..E");
- is(-1 >> 1, 0x7FFF_FFFF, "neg right right == 0x7F..F");
+ is(-1 >> 1, 0x7FFF_FFFF, "neg right shift == 0x7F..F");
}
{
if ($::testing_caller) {
# Perl_refcounted_he_fetch() insists that you have the key correctly
# normalised for the way hashes store them. As this one isn't
- # normalised down to bytes, it won't t work with
+ # normalised down to bytes, it won't work with
# Perl_refcounted_he_fetch()
is(hint_fetch($k2), 2, "UTF-8 or not, it's the same");
}
# Why does this test prefer to not test groups which we don't have
# a name for? One possible answer is that my primary group comes
- # from from my entry in the user database but isn't mentioned in
+ # from my entry in the user database but isn't mentioned in
# the group database. Are there more reasons?
next if ! defined $group;
is (lc "${filler}I\x{307}\x{300}$filler", "${filler_lc}i\x{300}$filler_lc",
"lc in Turkic locale with DOT ABOVE followed by ABOVE");
is (lc "${filler}I\x{300}\x{307}$filler", "$filler_lc\x{131}\x{300}\x{307}$filler_lc",
- "lc in Turkic locale with with other ABOVE before DOT ABOVE");
+ "lc in Turkic locale with other ABOVE before DOT ABOVE");
is (lcfirst "IIIIIII$filler", "\x{131}IIIIII$filler",
"lcfirst in Turkic locale, only first I changed");
is (lcfirst "I\x{307}$filler", "i$filler",
is (lcfirst "I\x{307}\x{300}IIIIII$filler", "i\x{300}IIIIII$filler",
"lcfirst in Turkic locale with DOT ABOVE followed by ABOVE");
is (lcfirst "I\x{300}\x{307}IIIIII$filler", "\x{131}\x{300}\x{307}IIIIII$filler",
- "lcfirst in Turkic locale with with other ABOVE before DOT ABOVE");
+ "lcfirst in Turkic locale with other ABOVE before DOT ABOVE");
is (uc "${filler}i$filler", "$filler_uc\x{130}$filler_uc", "long string uc in Turkic locale");
is (ucfirst "ii$filler", "\x{130}i$filler", "long string ucfirst in Turkic locale; only first char changes");
}
}
# Either the print or (more likely, thanks to buffering) the close will
-# fail if there are are filesize limitations (process or fs).
+# fail if there are filesize limitations (process or fs).
my $print = print BIG "big";
print "# print failed: $!\n" unless $print;
my $close = close BIG;
# using a regex in the destructor for STDOUT segfaulted because the
# REGEX pad had already been freed (ithreads build only). The
-# object is required to trigger the early freeing of GV refs to to STDOUT
+# object is required to trigger the early freeing of GV refs to STDOUT
TODO: {
local $TODO = "works but output through pipe is mangled" if $^O eq 'VMS';
is $c, 2, "run-time re-eval count";
}
-# check that that my/local @array = split works
+# check that my/local @array = split works
{
my $s = "a:b:c";
if ($cond =~ /^\d/) {
# >comment skip: hpux:10.20<
my $vsn = $cond;
- # Only compare on the the first pair of digits, as numeric
+ # Only compare on the first pair of digits, as numeric
# compares do not like 2.6.10-3mdksmp or 2.6.8-24.10-default
s/^(\d+(\.\d+)?).*/$1/ for $osv, $vsn;
$skip = $vsn ? ($osv <= $vsn ? 1 : 0) : 1;
}
continue { $suffix = ' (explicit return)' }
-# Returning unwritables from nested lvalue sub call in in rvalue context
+# Returning unwritables from nested lvalue sub call in rvalue context
# First, ensure we are testing what we think we are:
if (!Internals::SvREADONLY($])) { Internals::SvREADONLY($],1); }
sub squibble : lvalue { return $] }
}
# run some expression N times. The expr is concatenated N times and then
-# evaled, ensuring that that there are no scope exits between executions.
+# evaled, ensuring that there are no scope exits between executions.
# If the number of SVs at the end of expr N is greater than (N-1)*delta at
# the end of expr 1, we've got a leak
#
is $out, "", "--write should produce no output (1 perl)";
ok -s $resultfile1, "--write should create a non-empty results file (1 perl)";
-# and again with 2 perls. This is also tests the 'mix read and new new
+# and again with 2 perls. This is also tests the 'mix read and new
# perls' functionality.
note("running cachegrind for 2nd perl; may be slow...");
if (! exists $entries{$cur_entry}{severity}
# If there is no first line, it was two =items in a row, so the
- # second one is the one with with text, not this one.
+ # second one is the one with text, not this one.
&& exists $entries{$cur_entry}{first_line}
# If the first line refers to another message, no need for severity
deciding that they aren't real problems, it is possible to shut up this program
about them, unlike base Pod::Checker. For a valid link to an outside module
or man page, call podcheck.t with the C<--add_link> option to add it to the
-the database of known links; for other causes, call podcheck.t with the C<--regen>
+database of known links; for other causes, call podcheck.t with the C<--regen>
option to regenerate the entire database. This tells it that all existing
issues are to not be mentioned again.
my $vms_re = qr/ \. (?: com )? /x;
# Some filenames in the MANIFEST match $vms_re, and so must not be handled the
-# same way that that the special vms ones are. This hash lists those.
+# same way that the special vms ones are. This hash lists those.
my %special_vms_files;
# This is to get this to work across multiple file systems, including those
my %command_count; # Number of commands seen
my %seen_pod_cmd; # true if have =pod earlier
my %skip; # is SKIP set for this pod
- my %start_line; # the first input line number in the the thing
+ my %start_line; # the first input line number in the thing
# currently being worked on
sub DESTROY {
# Warn if looks like a file or link enclosed instead by this C<>
if ($C_text{$addr} =~ qr/^ $C_path_re $/x) {
- # Here it does look like it could be be a file path or a link.
+ # Here it does look like it could be a file path or a link.
# But some varieties of regex patterns could also fit with what we
# have so far. Weed those out as best we can. '/foo/' is almost
# certainly meant to be a pattern, as is '/foo/g'.
# link would be lost, as the L<> would be gone.
$CFL_text{$addr} = "C<$CFL_text{$addr}>";
- # Add this text to the the whole running total only if popping this
+ # Add this text to the whole running total only if popping this
# directive off the stack leaves it empty. As long as something is on
# the stack, it gets added to $CFL_text (just above). It is only
# entirely constructed when the stack is empty.
# RT #132772
#
# Ensure that optimisation of OP_CONST into OP_MULTICONCAT doesn't
- # leave any freed ops in the execution path. This is is associated
+ # leave any freed ops in the execution path. This is associated
# with rpeep() being called before optimize_optree(), which causes
# gv/rv2sv to be prematurely optimised into gvsv, confusing
# S_maybe_multiconcat when it tries to reorganise a concat subtree
ok /^a(??{ $b."c" })$/, "RT #132772 - compile time";
ok /^$a(??{ $b."c" })$/, "RT #132772 - run time";
my $qr = qr/^a(??{ $b."c" })$/;
- ok /$qr/, "RT #132772 - compile time time qr//";
+ ok /$qr/, "RT #132772 - compile time qr//";
$qr = qr/(??{ $b."c" })$/;
- ok /^a$qr$/, "RT #132772 - compile time time qr// compound";
+ ok /^a$qr$/, "RT #132772 - compile time qr// compound";
$qr = qr/$a(??{ $b."c" })$/;
- ok /^$qr$/, "RT #132772 - run time time qr//";
+ ok /^$qr$/, "RT #132772 - run time qr//";
}
# RT #133687
"a" =~ qr/$_/ for "\x{c4}\x{80}", "\x{100}", "\x{c4}\x{80}";
CODE
-# note that that for runtime code, each pattern is compiled twice; the
+# note that for runtime code, each pattern is compiled twice; the
# second time to allow the parser to see the code.
comp_n(6, <<'CODE', 'runtime code');
* baba9dfc133e3cb770a89aaf0973b1341fa61c2da6c176baf6428898b3b568d8 lib/unicore/extracted/DLineBreak.txt
* 6d4a8c945dd7db83ed617cbb7d937de7f4ecf016ff22970d846e996a7c9a2a5d lib/unicore/extracted/DNumType.txt
* 5b7c14380d5cceeaffcfbc18db1ed936391d2af2d51f5a41f1a17b692c77e59b lib/unicore/extracted/DNumValues.txt
- * d595d6b96967567fa57cf477c8cf4a72b456347a8ea054c05847b1fdb3072723 lib/unicore/mktables
+ * aee2ce1142e88494b09ea4abc065f8d74ad1a95f5fb3e03da469ab84306386e9 lib/unicore/mktables
* 50b85a67451145545a65cea370dab8d3444fbfe07e9c34cef560c5b7da9d3eef lib/unicore/version
* 2680b9254eb236c5c090f11b149605043e8c8433661b96efc4a42fb4709342a5 regen/charset_translations.pl
* 6bbad21de0848e0236b02f34f5fa0edd3cdae9ba8173cc9469a5513936b9e728 regen/mk_PL_charclass.pl
=item C<UTF8_GOT_CONTINUATION>
-The input sequence was malformed in that the first byte was a a UTF-8
+The input sequence was malformed in that the first byte was a UTF-8
continuation byte.
=item C<UTF8_GOT_EMPTY>
* things. For example, an input could be deliberately designed to
* overflow, and if this code bailed out immediately upon discovering that,
* returning to the caller C<*retlen> pointing to the very next byte (one
- * which is actually part of of the overflowing sequence), that could look
+ * which is actually part of the overflowing sequence), that could look
* legitimate to the caller, which could discard the initial partial
* sequence and process the rest, inappropriately.
*
* ustrp will contain *lenp bytes
*
* Turkic differs only from non-Turkic in that 'i' and LATIN CAPITAL LETTER
- * I WITH DOT ABOVE form a case pair, as do 'I' and and LATIN SMALL LETTER
+ * I WITH DOT ABOVE form a case pair, as do 'I' and LATIN SMALL LETTER
* DOTLESS I */
PERL_ARGS_ASSERT_TURKIC_UC;
return result;
/* Not currently externally documented, and subject to change:
- * <flags> is set iff iff the rules from the current underlying locale are to
+ * <flags> is set iff the rules from the current underlying locale are to
* be used. */
UV
}
/* Not currently externally documented, and subject to change:
- * <flags> is set iff iff the rules from the current underlying locale are to
+ * <flags> is set iff the rules from the current underlying locale are to
* be used.
*/
/* Surrogates, non-character code points and above-Unicode code points are
* problematic in some contexts. This allows code that needs to check for
- * those to to quickly exclude the vast majority of code points it will
+ * those to quickly exclude the vast majority of code points it will
* encounter */
#define isUTF8_POSSIBLY_PROBLEMATIC(c) (__ASSERT_(FITS_IN_8_BITS(c)) \
(U8) c >= 0xED)
=cut
-If SvTAIL(littlestr) is true, a fake "\n" was appended to to the string
+If SvTAIL(littlestr) is true, a fake "\n" was appended to the string
during FBM compilation due to FBMcf_TAIL in flags. It indicates that
the littlestr must be anchored to the end of bigstr (or to any \n if
FBMrf_MULTILINE).
=for apidoc my_vsnprintf
The C library C<vsnprintf> if available and standards-compliant.
-However, if if the C<vsnprintf> is not available, will unfortunately
+However, if the C<vsnprintf> is not available, will unfortunately
use the unsafe C<vsprintf> which can overrun the buffer (there is an
overrun check, but that may be too late). Consider using
C<sv_vcatpvf> instead, or getting C<vsnprintf>.
const struct dsc$descriptor_s * vms_dst_dsc,
unsigned long flags)
{
- /* VMS and UNIX handle file permissions differently and the
+ /* VMS and UNIX handle file permissions differently and
* the same ACL trick may be needed for renaming files,
* especially if they are directories.
*/
/* Originally the idea was to call the CRTL rename() and only
* try the lib$rename_file if it failed.
- * It turns out that there are too many variants in what the
+ * It turns out that there are too many variants in what
* the CRTL rename might do, so only use lib$rename_file
*/
retval = -1;
#
# set this to your email address (perl will guess a value from
-# from your loginname and your hostname, which may not be right)
+# your loginname and your hostname, which may not be right)
#
#EMAIL :=
LINK_DBG = -debug -opt:ref,icf -ltcg
# you may want to enable this if you want COFF symbols in the executables
# in addition to the PDB symbols. The default Dr. Watson that ships with
-# Windows can use the the former but not latter. The free WinDbg can be
+# Windows can use the former but not latter. The free WinDbg can be
# installed to get better stack traces from just the PDB symbols, so we
# avoid the bloat of COFF symbols by default.
#LINK_DBG += -debugtype:both
$(CC) -c $(CFLAGS) $(MINIBUILDOPT) -DPERL_IS_MINIPERL $(OBJOUT_FLAG)$@ $(PDBOUT) $(*F).c
# -DPERL_IMPLICIT_SYS needs C++ for perllib.c
-# rules wrapped in .IFs break Win9X build (we end up with unbalanced []s unless
+# rules wrapped in .IFs break Win9X build (we end up with unbalanced []s
# unless the .IF is true), so instead we use a .ELSE with the default.
# This is the only file that depends on perlhost.h, vmem.h, and vdir.h
#
# set this to your email address (perl will guess a value from
-# from your loginname and your hostname, which may not be right)
+# your loginname and your hostname, which may not be right)
#
#EMAIL =
LINK_DBG = -debug -opt:ref,icf -ltcg
# you may want to enable this if you want COFF symbols in the executables
# in addition to the PDB symbols. The default Dr. Watson that ships with
-# Windows can use the the former but not latter. The free WinDbg can be
+# Windows can use the former but not latter. The free WinDbg can be
# installed to get better stack traces from just the PDB symbols, so we
# avoid the bloat of COFF symbols by default.
#LINK_DBG = $(LINK_DBG) -debugtype:both
(list whole-words only) option would be useful.
.PP
Normally, various kinds of files are automatically removed from consideration.
-If it has has a certain ending (such as ".tar", ".Z", ".o", .etc), or if
+If it has a certain ending (such as ".tar", ".Z", ".o", .etc), or if
the beginning of the file looks like a binary, it'll be excluded.
You can control exactly how this works -- see below. One quick way to
override this is to use the
.fi
(among others) to exclude those kinds of files (which you probably want to
skip when searching for text, as is normal).
-Files that look to be be binary will also be excluded.
+Files that look to be binary will also be excluded.
Files ending with "#" and "~" will also be excluded unless the
.B -x~
#
# set this to your email address (perl will guess a value from
-# from your loginname and your hostname, which may not be right)
+# your loginname and your hostname, which may not be right)
#
#EMAIL *=
$(CC) -c $(CFLAGS) $(MINIBUILDOPT) -DPERL_IS_MINIPERL $(OBJOUT_FLAG)$@ $(PDBOUT) $(*B).c
# -DPERL_IMPLICIT_SYS needs C++ for perllib.c
-# rules wrapped in .IFs break Win9X build (we end up with unbalanced []s unless
+# rules wrapped in .IFs break Win9X build (we end up with unbalanced []s
# unless the .IF is true), so instead we use a .ELSE with the default.
# This is the only file that depends on perlhost.h, vmem.h, and vdir.h
* then it will convert the short name instead.
*
* The buffer to the ansi pathname must be freed with win32_free() when it
- * it no longer needed.
+ * is no longer needed.
*
* The argument to win32_ansipath() must exist before this function is
* called; otherwise there is no way to determine the short path name.
https://perl5.git.perl.org / perl5.git / commitdiff