diff options
author | Karl Williamson <khw@cpan.org> | 2019-09-15 10:40:29 -0600 |
---|---|---|
committer | Karl Williamson <khw@cpan.org> | 2019-09-15 10:44:16 -0600 |
commit | 8234439d1b57e10c5bbb0b024eeb325ea1a4b50a (patch) | |
tree | 6eec1f2ced93a4f7664a835c5e156717cc3c3c97 | |
parent | af50ae69325d1ddb2687210da1112fe07f6f2ab9 (diff) | |
parent | c490e11f0b40be46264c6bf41a7a6482953a8b0b (diff) | |
download | perl-8234439d1b57e10c5bbb0b024eeb325ea1a4b50a.tar.gz |
Merge branch 'embed.fnc' into blead
This series of commits slightly improves XS code name space pollution
from the core, and better documents what is happening.
It adds a new C flag to embed.fnc which doesn't change the pollution
problem, but makes it easier for downstream tools, like Devel::PPPort.
Some of the inline.h functions didn't even have prefixes, contrary to
our policy of having functions visible outside the core have a 'Perl_'
prefix.
The branch also documents a couple of API functions and macros.
And better error checking of embed.fnc entries is now done.
-rw-r--r-- | autodoc.pl | 6 | ||||
-rw-r--r-- | cv.h | 6 | ||||
-rw-r--r-- | embed.fnc | 621 | ||||
-rw-r--r-- | embed.h | 84 | ||||
-rw-r--r-- | inline.h | 159 | ||||
-rw-r--r-- | mathoms.c | 4 | ||||
-rw-r--r-- | op.c | 2 | ||||
-rw-r--r-- | perl.h | 16 | ||||
-rw-r--r-- | pp.h | 4 | ||||
-rw-r--r-- | proto.h | 708 | ||||
-rwxr-xr-x | regen/embed.pl | 40 | ||||
-rw-r--r-- | regen/embed_lib.pl | 3 | ||||
-rw-r--r-- | regexec.c | 6 | ||||
-rw-r--r-- | regexp.h | 2 | ||||
-rw-r--r-- | sv.h | 30 | ||||
-rw-r--r-- | t/porting/args_assert.t | 4 | ||||
-rw-r--r-- | utf8.c | 40 | ||||
-rw-r--r-- | utf8.h | 8 |
18 files changed, 1278 insertions, 465 deletions
diff --git a/autodoc.pl b/autodoc.pl index 6c54b2faca..b8d46b312e 100644 --- a/autodoc.pl +++ b/autodoc.pl @@ -251,7 +251,7 @@ removed without notice.\n\n$docs" if $flags =~ /x/; } } my $args = ''; - if ($p && $flags !~ /T/) { + if ($flags !~ /T/ && ($p || ($flags =~ /m/ && $name =~ /^Perl_/))) { $args = @args ? "pTHX_ " : "pTHX"; if ($long_args) { print $fh $args; $args = '' } } @@ -397,8 +397,8 @@ foreach (sort keys %missing) { # walk table providing an array of components in each line to # subroutine, printing the result -# List of funcs in the public API that aren't also marked as experimental nor -# deprecated. +# List of funcs in the public API that aren't also marked as core-only, +# experimental nor deprecated. my @missing_api = grep $funcflags{$_}{flags} =~ /A/ && $funcflags{$_}{flags} !~ /[xD]/ && !$docs{api}{$_}, keys %funcflags; @@ -49,7 +49,7 @@ See L<perlguts/Autoloading with XSUBs>. #define CvROOT(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_root #define CvXSUB(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_xsub #define CvXSUBANY(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_xsubany -#define CvGV(sv) S_CvGV(aTHX_ (CV *)(sv)) +#define CvGV(sv) Perl_CvGV(aTHX_ (CV *)(sv)) #define CvGV_set(cv,gv) Perl_cvgv_set(aTHX_ cv, gv) #define CvHASGV(cv) cBOOL(SvANY(cv)->xcv_gv_u.xcv_gv) #define CvFILE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_file @@ -61,9 +61,9 @@ See L<perlguts/Autoloading with XSUBs>. (CvFILE(sv) = CopFILE(cop), CvDYNFILE_off(sv)) #endif #define CvFILEGV(sv) (gv_fetchfile(CvFILE(sv))) -#define CvDEPTH(sv) (*S_CvDEPTHp((const CV *)sv)) +#define CvDEPTH(sv) (*Perl_CvDEPTH((const CV *)sv)) /* For use when you only have a XPVCV*, not a real CV*. - Must be assert protected as in S_CvDEPTHp before use. */ + Must be assert protected as in Perl_CvDEPTH before use. */ #define CvDEPTHunsafe(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_depth /* these CvPADLIST/CvRESERVED asserts can be reverted one day, once stabilized */ @@ -5,36 +5,106 @@ : This file is known to be processed by regen/embed.pl, autodoc.pl, : makedef.pl, Devel::PPPort, and porting/diag.t. : +: This file contains entries for various functions and macros defined by perl. +: Each entry includes the name, parameters, and various attributes about it. +: In most functions listed here, the name is a short name, and the function's +: real name is the short one, prefixed by either 'Perl_' (for publicly visible +: functions) or 'S_' (for internal-to-a-file static ones). In many instances a +: macro is defined that is the name in this file, and which expands to call the +: real (full) name, with any appropriate thread context paramaters, thus hiding +: that detail from the typical code. +: +: Most macros listed here are the complete full name. +: : All non-static functions defined by perl need to be listed in this file. -: embed.pl uses the entries here to construct proto.h to declare to the -: compiler the function interfaces, and embed.h to create macros that present a -: uniform interface to C code for the functions, regardless of, say, whether -: the perl is threaded or not. +: embed.pl uses the entries here to construct: +: 1) proto.h to declare to the compiler the function interfaces; and +: 2) embed.h to create short name macros : -: Static functions need not appear here, but there is benefit to declaring them -: here, as it generally handles the thread context parameter invisibly, as well -: as making sure a PERL_ARGS_ASSERT_foo macro is defined, which can save you -: debugging time. +: Static functions internal to a file need not appear here, but there is +: benefit to declaring them here, as it generally handles the thread context +: parameter invisibly, as well as making sure a PERL_ARGS_ASSERT_foo macro is +: defined, which can save you debugging time. : : Lines in this file are of the form: -: flags|return_type|function_name|arg1|arg2|...|argN +: flags|return_type|name|arg1|arg2|...|argN : : 'flags' is a string of single letters. Most of the flags are meaningful only : to embed.pl; some only to autodoc.pl, and others only to makedef.pl. The -: comments here don't include how Devel::PPPort or diag.t use them: +: comments here mostly don't include how Devel::PPPort or diag.t use them: : : A function taking no parameters will have no 'arg' elements. : A line may be continued onto the next by ending it with a backslash. : Leading and trailing whitespace will be ignored in each component. : +: Most entries here have a macro created with the entry name. This presents +: name space collision potentials which haven't been well thought out, but are +: now documented here. In practice this has rarely been an issue. At least, +: with a macro, the XS author can #undef it, unlike a function. +: : The default without flags is to declare a function for internal perl-core use -: only. On some platforms, such as Linux and Darwin, all non-static functions +: only. The short name is visible only when the PERL_CORE symbol is defined. +: On some platforms, such as Linux and Darwin, all non-static functions : are currently externally visible. Because of this, and also for programs : that embed perl, most non-static functions should have the 'p' flag to avoid : namespace clashes. : -: Most entries here have a macro created to wrap them, and whose name doesn't -: include the 'Perl_', or other prefix. +: There are several advantages to using a macro instead of the full Perl_foo or +: S_foo form: it hides the need to know if the called function requires a +: thread context parameter or not, and the code using it is more readable +: because of fewer parameters being visible. And if there is some bug in it +: that gets fixed in a later release, ppport.h can be changed to automatically +: backport the fixed version to modules. The only disadvantage khw can think +: of is the namespace pollution one. +: +: Since we don't require a C compiler to support variadic macros (C99), the +: macros can't be generated in such situations. +: +: WARNING: Any macro created in a header file is visible to XS code, unless +: care is taken to wrap it within something like #ifdef PERL_CORE..#endif. +: This has had to be done with things like MAX and MIN, but nearly everything +: else has been created without regard to the namespace pollution problem. +: +: Here's what else you need to know about using this file with regards to name +: space pollution: +: +: The A flag is used to make a function and its short name visible everywhere +: on all platforms. This should be used to make it part of Perl's +: API contract with XS developers. The documentation for these is +: usually placed in perlapi. If no documentation exists, that fact +: is also noted in perlapi. +: +: The C flag is used instead for functions and their short names that need to +: be accessible everywhere, typically because they are called from a +: publicly available macro or inline function, but they are not for +: public use by themselves. The documentation for these is placed +: in perlintern. If no documentation exists, that fact is also +: noted in perlintern. +: +: These really need the 'p' flag to avoid name space collisions. +: +: Some of these have been constructed so that the wrapper macro +: names begin with an underscore to lessen the chances of a name +: collision. However, this is contrary to the C standard, and those +: should be changed. +: +: The E flag is used instead for a function and its short name that is supposed +: to be used only in the core, and in extensions compiled with the +: PERL_EXT symbol defined. Again, on some platforms, the function +: will be visible everywhere, so the 'p' flag is gnerally needed. +: Also note that an XS writer can always cheat and pretend to be an +: extension by #defining PERL_EXT. +: +: The X flag is similar to the C flag in that the function (whose entry better +: have the 'p' flag) is accessible everywhere on all platforms. +: However the short name macro that normally gets generated is +: suppressed outside the core. (Except it is also visible in +: PERL_EXT extensions if the E flag is also specified.) This flag +: is used for functions that are called from a public macro, the +: name of which isn't derived from the function name. You'll have +: to write the macro yourself, and from within it, refer to the +: function in its full 'Perl_' form with any necessary thread +: context parameter. : : Scattered around the perl source are lines of the form: : @@ -44,19 +114,20 @@ : autodoc.pl where the documentation is for a function listed in this file. It : uses the prototype from here and the pod from there in generating the : documentation in perlapi or perlintern. The entries in this file that have -: corresponding '=for apidoc' entries should have the flag 'd' set in this +: corresponding '=for apidoc' entries should have the 'd' flag set in this : file. : : There are also lines of this form scattered around: : : =for apidoc flags|return_type|name|arg1|arg2|...|argN : -: and with the same meanings as the lines in this file. The 'name' in any such -: line must not be the same as any in this file (i.e., no redundant -: definitions), and one of the flags must be 'm', indicating this is a macro. -: The lines following these are pod for the respective macro. Since these are -: macros, the arguments need not be legal C parameters. To indicate this to -: downstream software that inspects these lines, there are a few conventions: +: and with the same meanings as the lines in this file. These are for +: documenting macros. The 'name' in any such line must not be the same as any +: in this file (i.e., no redundant definitions), and one of the flags must be +: 'm', indicating it is a macro. The lines following these are pod for the +: respective macro. Since these are macros, the arguments need not be legal C +: parameters. To indicate this to downstream software that inspects these +: lines, there are a few conventions: : type should be the entire argument name if it names a type : cast should be the entire argument name if it is a cast : SP should be the entire argument name if it is the stack pointer SP @@ -70,32 +141,39 @@ : indicate that it has to be a string, instead of a const char * const, like this : =for apidoc Ama|SV*|newSVpvs|"string" : +: If any argument or return value is not one of the above, and isn't a legal C +: language one, the 'u' flag should be specified. +: : Again, autodoc uses these lines to construct perlapi. 'return_type' in these : lines can be empty, unlike in this file. : : Devel::PPPort also looks at both this file and the '=for apidoc' lines. In : part it is to construct lists of functions that are or are not backported. : -: makedef.pl uses this file for constructing the export list +: makedef.pl uses this file for constructing the export list which lists the +: symbols that should be available on all platforms. : : porting/diag.t checks some things for consistency based on this file. : -: A Accessible fully everywhere (usually part of the public API): +: The remainder of these introductory comments detail all the possible flags: : -: add entry to the list of exported symbols (unless e or m); -: any doc entry goes in perlapi.pod rather than perlintern.pod. If -: no documentation is furnished, x controls what happens: If x -: isn't specified, autodoc.pl lists this in perlapi as existing and -: being undocumented; otherwise it simply isn't listed. -: makes '#define foo Perl_foo' scope not just for PERL_CORE/PERL_EXT +: A Both long and short names are accessible fully everywhere (usually part +: of the public API). If the function is not part of the public API, +: instead use C, E, or X. : -: If the function is only exported for use in a public macro, see X. +: add entry to the list of symbols available on all platforms +: unless e or m are also specified; +: any doc entry goes in perlapi.pod rather than perlintern.pod. If +: there isn't a doc entry, autodoc.pl lists this in perlapi as +: existing and being undocumented; unless x is also specified, in +: which case it simply isn't listed. +: makes the short name defined for everywhere, not just for +: PERL_CORE/PERL_EXT : -: a Allocates memory a la malloc/calloc. Also implies "R". -: This flag should only be on a function which returns 'empty' memory -: which has no other pointers to it, and which does not contain -: any pointers to other things. So for example realloc() can't be -: 'a'. +: a Allocates memory a la malloc/calloc. Also implies "R". This flag +: should only be on a function which returns 'empty' memory which has no +: other pointers to it, and which does not contain any pointers to other +: things. So for example realloc() can't be 'a'. : : proto.h: add __attribute__malloc__ : @@ -106,10 +184,15 @@ : -Accflags='-DNO_MATHOMS' parameter to not even compile them. : : Sometimes the function has been subsumed by a more general one (say, by -: adding a flags parameter), and a macro exists with the original API, and -: it calls the new function, bypassing this one, and the original 'Perl_' -: form is being deprecated. In this case also specify the 'M' flag. The -: 'b' functions are normally moved to mathoms.c, but if circumstances +: adding a flags parameter), and a macro exists with the original short +: name API, and it calls the new function, bypassing this one, and the +: original 'Perl_' form is being deprecated. In this case also specify +: the 'M' flag. +: +: Without the M flag, these functions should be deprecated, and it is an +: error to not also specify the 'D' flag. +: +: The 'b' functions are normally moved to mathoms.c, but if circumstances : dictate otherwise, they can be anywhere, provided the whole function is : wrapped with : #ifndef NO_MATHOMS @@ -119,15 +202,26 @@ : Note that this flag no longer automatically adds a 'Perl_' prefix to the : name. Additionally specify 'p' to do that. : -: For functions, like wrappers, whose macro shortcut doesn't call the -: function, but which, for whatever reason, aren't considered legacy-only, -: use the 'o' flag, and maybe the 'M' -: : This flag effectively causes nothing to happen if the perl interpreter -: is compiled with -DNO_MATHOMS; otherwise these happen: -: add entry to the list of exported symbols; +: is compiled with -DNO_MATHOMS (which causes any functions with this flag +: to not be compiled); otherwise these happen: +: add entry to the list of symbols available on all platforms; : create PERL_ARGS_ASSERT_foo; -: add embed.h entry (unless overridden by the 'o' flag) +: add embed.h entry (unless overridden by the 'M' or 'o' flags) +: +: C Intended for core use only. This indicates to XS writers that they +: shouldn't be using this function. Devel::PPPort informs them of this, +: for example. Some functions have to be accessible everywhere even if +: they are not intended for public use. An example is helper functions +: that are called from inline ones that are publicly available. +: +: add entry to the list of symbols available on all platforms +: unless e or m are also specified; +: any doc entry goes in perlintern.pod rather than perlapi.pod. If +: there isn't a doc entry, autodoc.pl lists this in perlintern as +: existing and being undocumented +: makes the short name defined for everywhere, not just for +: PERL_CORE/PERL_EXT : : D Function is deprecated: : @@ -150,45 +244,73 @@ : : e Not exported : -: suppress entry in the list of exported symbols +: suppress entry in the list of symbols available on all platforms : : f Function takes a format string. If the function name =~ qr/strftime/ -: then its assumed to take a strftime-style format string as 1st arg; -: otherwise it's assumed to be a printf style format string, varargs +: then it is assumed to take a strftime-style format string as the 1st +: arg; otherwise it's assumed to be a printf style format string, varargs : (hence any entry that would otherwise go in embed.h is suppressed): : : proto.h: add __attribute__format__ (or ...null_ok__) : -: h Hide any documentation. This is used typically when the documentation -: is atypical of the rest of perlapi and perlintern. In other words the -: item is documented, but just not the standard way. One reason would be -: if there are a bunch of macros which follow a common paradigm in their -: naming, so rather than having an entry for each slight variation, there -: is an overarchinge one. It is also used when the documentation is in -: another pod, such as perlguts or warnings.h. This flag is useful for -: downstream programs, such as Devel::PPPort. -: -: i Static inline: function in source code has a S_ prefix: -: -: proto.h: function is declared as S_foo rather than foo unless the 'p' -: flag is also given in which case 'Perl_foo' is used, -: PERL_STATIC_INLINE is added to the declaration -: embed.h: "#define foo S_foo" or Perl_foo entries added -: -: M There is an extra macro that bypasses this function -: -: (requires 'p', and implies 'o') The function exists so that callers who -: used the 'Perl_' form can continue to do so, but there is a macro -: available without the 'Perl_' prefix that bypasses the function call, -: such as when the function has been reduced to a wrapper around another -: one. -: -: m Implemented as a macro: -: -: suppress proto.h entry unless 'b' also specified (actually, not -: suppressed, but commented out) -: suppress entry in the list of exported symbols -: suppress embed.h entry +: G Suppress empty PERL_ARGS_ASSERT_foo macro. Normally such a macro is +: generated for all entries for functions 'foo' in this file. If there is +: a pointer argument to 'foo', it needs to be declared in this file as +: either NN or NULLOK, and the function definition must call its +: corresponding PERL_ARGS_ASSERT_foo macro (a porting test ensures this) +: which asserts at runtime (under DEBUGGING builds) that NN arguments are +: not NULL. If there aren't NN arguments, use of this macro is optional. +: Rarely, a function will define its own PERL_ARGS_ASSERT_foo macro, and +: in those cases, adding this flag to its entry in this file will suppress +: the normal one. It is not possible to suppress the generated macro if +: it isn't optional, that is, if there is at least one NN argument. +: +: proto.h: PERL_ARGS_ASSERT macro is not defined unless the function +: has NN arguments +: +: h Hide any documentation. This is used when the documentation is atypical +: of the rest of perlapi and perlintern. In other words the item is +: documented, but just not the standard way. One reason would be if there +: are a bunch of macros which follow a common paradigm in their naming, so +: rather than having an entry for each slight variation, there is an +: overarchinge one. It is also used when the documentation is in another +: pod, such as perlguts or warnings.h. This flag is useful for downstream +: programs, such as Devel::PPPort. +: +: i inline static. This is used for functions that the compiler is being +: requested to inline. If the function is in a header file its +: definition will be visible (unless guarded by #if..#endif) to all +: XS code. (A typical guard will be that it is being included in a +: particular C file(s) or in the perl core.) Therefore, all +: non-guarded function should also have the 'p' flag specified to avoid +: polluting the XS code name space. Otherwise an error is generated if +: the 'S' flag is not also specified. +: +: proto.h: function is declared as PERL_STATIC_INLINE +: +: m Implemented as a macro; there is no function associated with this name, +: and hence no long Perl_ or S_ name. However, if the macro name itself +: begins with 'Perl_', autodoc.pl will show a thread context parameter +: unless the 'T' flag is specified. +: +: suppress proto.h entry (actually, not suppressed, but commented out) +: suppress entry in the list of exported symbols available on all platforms +: suppress embed.h entry, as the implementation should furnish the macro +: +: M The implementation is furnishing its own macro instead of relying on the +: default short name macro that simply expands to call the real name +: function. This is used if the parameters need to be cast from what the +: caller has, or if there is a macro that bypasses this function (whose +: long name is being retained for backward compatibility for those who +: call it with that name). An example is when a new function is created +: with an extra parameter and a wrapper macro is added that has the old +: API, but calls the new one with the exta parameter set to a default. +: +: This flag requires the 'p' flag to be specified, as there would be no +: need to do this if the function weren't publicly accessible before. +: +: The entry is processed based on the other flags, but the: +: embed.h entry is suppressed : : N The name in the entry isn't strictly a name : @@ -208,19 +330,17 @@ : autodoc.pl adds a note that the perl_ form of this function is : deprecated. : -: : o Has no Perl_foo or S_foo compatibility macro: : -: This can be used when you define a macro with this entry's name that -: doesn't call the function specified by this entry. This is typically -: done for a function that effectively just wraps another one, and where -: the macro form calls the underlying function directly. For these, also -: specify the 'M' flag. Legacy-only functions should instead use 'b'. +: This is used for whatever reason to force the function to be called +: with the long name. Perhaps there is a varargs issue. Use the 'M' +: flag instead for wrapper macros, and legacy-only functions should +: also use 'b'. : : embed.h: suppress "#define foo Perl_foo" : : autodoc.pl adds a note that this function must be explicitly called as -: Perl_$name with an aTHX_ parameter, unless the 'M' flag is specified. +: Perl_$name with an aTHX_ parameter. : : P Pure function: : @@ -296,7 +416,8 @@ : : X Explicitly exported: : -: add entry to the list of exported symbols, unless e or m +: add entry to the list of symbols available on all platforms, unless e +: or m : : This is often used for private functions that are used by public : macros. In those cases the macros must use the long form of the @@ -305,7 +426,7 @@ : x Experimental, may change: : : any doc entry is marked that it may change. Also used to suppress -: making a doc entry if it would just be a placeholder. +: making a perlapi doc entry if it would just be a placeholder. : : In this file, pointer parameters that must not be passed NULLs should be : prefixed with NN. @@ -403,7 +524,7 @@ Apd |void |av_push |NN AV *av|NN SV *val EXp |void |av_reify |NN AV *av ApdR |SV* |av_shift |NN AV *av Apd |SV** |av_store |NN AV *av|SSize_t key|NULLOK SV *val -AidR |SSize_t|av_top_index |NN AV *av +AidRp |SSize_t|av_top_index |NN AV *av AmdR |SSize_t|av_tindex |NN AV *av Apd |void |av_undef |NN AV *av Apdoex |SV** |av_create_and_unshift_one|NN AV **const avp|NN SV *const val @@ -493,6 +614,8 @@ Apd |void |cv_undef |NN CV* cv p |void |cv_undef_flags |NN CV* cv|U32 flags pd |void |cv_forget_slab |NULLOK CV *cv Ap |void |cx_dump |NN PERL_CONTEXT* cx +AiMp |GV * |CvGV |NN CV *sv +AiMTp |I32 * |CvDEPTH |NN const CV * const sv Aphd |SV* |filter_add |NULLOK filter_t funcp|NULLOK SV* datasv Ap |void |filter_del |NN filter_t funcp ApRhd |I32 |filter_read |int idx|NN SV *buf_sv|int maxlen @@ -538,7 +661,7 @@ Ap |bool |do_close |NULLOK GV* gv|bool not_implicit p |bool |do_eof |NN GV* gv #ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION -pm |bool|do_exec |NN const char* cmd +pM |bool|do_exec |NN const char* cmd #else p |bool|do_exec |NN const char* cmd #endif @@ -759,7 +882,7 @@ Apd |HV* |gv_stashpv |NN const char* name|I32 flags Apd |HV* |gv_stashpvn |NN const char* name|U32 namelen|I32 flags #if defined(PERL_IN_GV_C) i |HV* |gv_stashpvn_internal |NN const char* name|U32 namelen|I32 flags -i |HV* |gv_stashsvpvn_cached |NULLOK SV *namesv|NULLOK const char* name|U32 namelen|I32 flags +iG |HV* |gv_stashsvpvn_cached |NULLOK SV *namesv|NULLOK const char* name|U32 namelen|I32 flags i |GV* |gv_fetchmeth_internal |NULLOK HV* stash|NULLOK SV* meth|NULLOK const char* name \ |STRLEN len|I32 level|U32 flags #endif @@ -835,7 +958,7 @@ Am |I32 |ibcmp_utf8 |NN const char *s1|NULLOK char **pe1|UV l1 \ Amd |I32 |foldEQ_utf8 |NN const char *s1|NULLOK char **pe1|UV l1 \ |bool u1|NN const char *s2|NULLOK char **pe2 \ |UV l2|bool u2 -Axp |I32 |foldEQ_utf8_flags |NN const char *s1|NULLOK char **pe1|UV l1 \ +Cp |I32 |foldEQ_utf8_flags |NN const char *s1|NULLOK char **pe1|UV l1 \ |bool u1|NN const char *s2|NULLOK char **pe2 \ |UV l2|bool u2|U32 flags AiTp |I32 |foldEQ_latin1 |NN const char* a|NN const char* b|I32 len @@ -860,29 +983,29 @@ pR |OP* |invert |NULLOK OP* cmd ApR |I32 |is_lvalue_sub : Used in cop.h XopR |I32 |was_lvalue_sub -ApxRTP |STRLEN |_is_utf8_char_helper|NN const U8 * const s|NN const U8 * e|const U32 flags -AbDxpR |U32 |to_uni_upper_lc|U32 c -AbDxpR |U32 |to_uni_title_lc|U32 c -AbDxpR |U32 |to_uni_lower_lc|U32 c -AbDxpR |bool |is_uni_alnum |UV c -AbDxpR |bool |is_uni_alnumc |UV c -AbDxpR |bool |is_uni_idfirst |UV c -AbDxpR |bool |is_uni_alpha |UV c -AbDxpPR |bool |is_uni_ascii |UV c -AbDxpPR |bool |is_uni_blank |UV c -AbDxpPR |bool |is_uni_space |UV c -AbDxpPR |bool |is_uni_cntrl |UV c -AbDxpR |bool |is_uni_graph |UV c -AbDxpR |bool |is_uni_digit |UV c -AbDxpR |bool |is_uni_upper |UV c -AbDxpR |bool |is_uni_lower |UV c -AbDxpR |bool |is_uni_print |UV c -AbDxpR |bool |is_uni_punct |UV c -AbDxpPR |bool |is_uni_xdigit |UV c -Axp |UV |to_uni_upper |UV c|NN U8 *p|NN STRLEN *lenp -Axp |UV |to_uni_title |UV c|NN U8 *p|NN STRLEN *lenp -AbDxpR |bool |isIDFIRST_lazy |NN const char* p -AbDxpR |bool |isALNUM_lazy |NN const char* p +CpRTP |STRLEN |is_utf8_char_helper|NN const U8 * const s|NN const U8 * e|const U32 flags +CbDpR |U32 |to_uni_upper_lc|U32 c +CbDpR |U32 |to_uni_title_lc|U32 c +CbDpR |U32 |to_uni_lower_lc|U32 c +CbDpR |bool |is_uni_alnum |UV c +CbDpR |bool |is_uni_alnumc |UV c +CbDpR |bool |is_uni_idfirst |UV c +CbDpR |bool |is_uni_alpha |UV c +CbDpPR |bool |is_uni_ascii |UV c +CbDpPR |bool |is_uni_blank |UV c +CbDpPR |bool |is_uni_space |UV c +CbDpPR |bool |is_uni_cntrl |UV c +CbDpR |bool |is_uni_graph |UV c +CbDpR |bool |is_uni_digit |UV c +CbDpR |bool |is_uni_upper |UV c +CbDpR |bool |is_uni_lower |UV c +CbDpR |bool |is_uni_print |UV c +CbDpR |bool |is_uni_punct |UV c +CbDpPR |bool |is_uni_xdigit |UV c +Cp |UV |to_uni_upper |UV c|NN U8 *p|NN STRLEN *lenp +Cp |UV |to_uni_title |UV c|NN U8 *p|NN STRLEN *lenp +CbDpR |bool |isIDFIRST_lazy |NN const char* p +CbDpR |bool |isALNUM_lazy |NN const char* p p |void |init_uniprops #ifdef PERL_IN_UTF8_C STR |U8 |to_lower_latin1|const U8 c|NULLOK U8 *p|NULLOK STRLEN *lenp \ @@ -899,33 +1022,33 @@ EXTp |UV |_to_fold_latin1|const U8 c|NN U8 *p|NN STRLEN *lenp|const unsig #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) p |UV |_to_upper_title_latin1|const U8 c|NN U8 *p|NN STRLEN *lenp|const char S_or_s #endif -Axp |UV |to_uni_lower |UV c|NN U8 *p|NN STRLEN *lenp -Axmp |UV |to_uni_fold |UV c|NN U8 *p|NN STRLEN *lenp -Axp |UV |_to_uni_fold_flags|UV c|NN U8 *p|NN STRLEN *lenp|U8 flags -AbDxpR |bool |is_uni_alnum_lc|UV c -AbDxpR |bool |is_uni_alnumc_lc|UV c -AbDxpR |bool |is_uni_idfirst_lc|UV c -AxpR |bool |_is_uni_perl_idcont|UV c -AxpR |bool |_is_uni_perl_idstart|UV c -AbDxpR |bool |is_uni_alpha_lc|UV c -AbDxpPR |bool |is_uni_ascii_lc|UV c -AbDxpPR |bool |is_uni_space_lc|UV c -AbDxpPR |bool |is_uni_blank_lc|UV c -AbDxpPR |bool |is_uni_cntrl_lc|UV c -AbDxpR |bool |is_uni_graph_lc|UV c -AbDxpR |bool |is_uni_digit_lc|UV c -AbDxpR |bool |is_uni_upper_lc|UV c -AbDxpR |bool |is_uni_lower_lc|UV c -AbDxpR |bool |is_uni_print_lc|UV c -AbDxpR |bool |is_uni_punct_lc|UV c -AbDxpPR |bool |is_uni_xdigit_lc|UV c +Cp |UV |to_uni_lower |UV c|NN U8 *p|NN STRLEN *lenp +Cm |UV |to_uni_fold |UV c|NN U8 *p|NN STRLEN *lenp +Cp |UV |_to_uni_fold_flags|UV c|NN U8 *p|NN STRLEN *lenp|U8 flags +CbDpR |bool |is_uni_alnum_lc|UV c +CbDpR |bool |is_uni_alnumc_lc|UV c +CbDpR |bool |is_uni_idfirst_lc|UV c +CpR |bool |_is_uni_perl_idcont|UV c +CpR |bool |_is_uni_perl_idstart|UV c +CbDpR |bool |is_uni_alpha_lc|UV c +CbDpPR |bool |is_uni_ascii_lc|UV c +CbDpPR |bool |is_uni_space_lc|UV c +CbDpPR |bool |is_uni_blank_lc|UV c +CbDpPR |bool |is_uni_cntrl_lc|UV c +CbDpR |bool |is_uni_graph_lc|UV c +CbDpR |bool |is_uni_digit_lc|UV c +CbDpR |bool |is_uni_upper_lc|UV c +CbDpR |bool |is_uni_lower_lc|UV c +CbDpR |bool |is_uni_print_lc|UV c +CbDpR |bool |is_uni_punct_lc|UV c +CbDpPR |bool |is_uni_xdigit_lc|UV c ATdmoR |bool |is_utf8_invariant_string|NN const U8* const s \ |STRLEN len -ATidR |bool |is_utf8_invariant_string_loc|NN const U8* const s \ +ATidRp |bool |is_utf8_invariant_string_loc|NN const U8* const s \ |STRLEN len \ |NULLOK const U8 ** ep #ifndef EBCDIC -ATiR |unsigned int|_variant_byte_number|PERL_UINTMAX_T word +CTiRp |unsigned int|variant_byte_number|PERL_UINTMAX_T word #endif #if defined(PERL_CORE) || defined(PERL_EXT) EiTRd |Size_t |variant_under_utf8_count|NN const U8* const s \ @@ -934,19 +1057,19 @@ EiTRd |Size_t |variant_under_utf8_count|NN const U8* const s \ AmTdRP |bool |is_ascii_string|NN const U8* const s|STRLEN len AmTdRP |bool |is_invariant_string|NN const U8* const s|STRLEN len #if defined(PERL_CORE) || defined (PERL_EXT) -EXTidR |bool |is_utf8_non_invariant_string|NN const U8* const s \ +EXTidRp |bool |is_utf8_non_invariant_string|NN const U8* const s \ |STRLEN len #endif AbTpdD |STRLEN |is_utf8_char |NN const U8 *s AbMTpd |STRLEN |is_utf8_char_buf|NN const U8 *buf|NN const U8 *buf_end -ATidR |Size_t |isUTF8_CHAR|NN const U8 * const s0 \ +ATidRp |Size_t |isUTF8_CHAR|NN const U8 * const s0 \ |NN const U8 * const e -ATidR |Size_t |isSTRICT_UTF8_CHAR |NN const U8 * const s0 \ +ATidRp |Size_t |isSTRICT_UTF8_CHAR |NN const U8 * const s0 \ |NN const U8 * const e -ATidR |Size_t |isC9_STRICT_UTF8_CHAR |NN const U8 * const s0 \ +ATidRp |Size_t |isC9_STRICT_UTF8_CHAR |NN const U8 * const s0 \ |NN const U8 * const e ATmdR |bool |is_utf8_string |NN const U8 *s|STRLEN len -ATidR |bool |is_utf8_string_flags \ +ATidRp |bool |is_utf8_string_flags \ |NN const U8 *s|STRLEN len|const U32 flags ATmdR |bool |is_strict_utf8_string|NN const U8 *s|STRLEN len ATmdR |bool |is_c9strict_utf8_string|NN const U8 *s|STRLEN len @@ -962,13 +1085,13 @@ ATdm |bool |is_c9strict_utf8_string_loc \ ATipd |bool |is_utf8_string_loclen \ |NN const U8 *s|STRLEN len|NULLOK const U8 **ep \ |NULLOK STRLEN *el -ATid |bool |is_utf8_string_loclen_flags \ +ATidp |bool |is_utf8_string_loclen_flags \ |NN const U8 *s|STRLEN len|NULLOK const U8 **ep \ |NULLOK STRLEN *el|const U32 flags -ATid |bool |is_strict_utf8_string_loclen \ +ATidp |bool |is_strict_utf8_string_loclen \ |NN const U8 *s|STRLEN len|NULLOK const U8 **ep \ |NULLOK STRLEN *el -ATid |bool |is_c9strict_utf8_string_loclen \ +ATidp |bool |is_c9strict_utf8_string_loclen \ |NN const U8 *s|STRLEN len|NULLOK const U8 **ep \ |NULLOK STRLEN *el AmTd |bool |is_utf8_fixed_width_buf_flags \ @@ -976,51 +1099,51 @@ AmTd |bool |is_utf8_fixed_width_buf_flags \ AmTd |bool |is_utf8_fixed_width_buf_loc_flags \ |NN const U8 * const s|STRLEN len \ |NULLOK const U8 **ep|const U32 flags -ATid |bool |is_utf8_fixed_width_buf_loclen_flags \ +ATidp |bool |is_utf8_fixed_width_buf_loclen_flags \ |NN const U8 * const s|STRLEN len \ |NULLOK const U8 **ep|NULLOK STRLEN *el|const U32 flags AmTdP |bool |is_utf8_valid_partial_char \ |NN const U8 * const s|NN const U8 * const e -ATidR |bool |is_utf8_valid_partial_char_flags \ +ATidRp |bool |is_utf8_valid_partial_char_flags \ |NN const U8 * const s|NN const U8 * const e|const U32 flags -AxpR |bool |_is_uni_FOO|const U8 classnum|const UV c -AxpR |bool |_is_utf8_FOO|U8 classnum|NN const U8 * const p \ +CpR |bool |_is_uni_FOO|const U8 classnum|const UV c +CpR |bool |_is_utf8_FOO|U8 classnum|NN const U8 * const p \ |NN const char * const name \ |NN const char * const alternative \ |const bool use_utf8|const bool use_locale \ |NN const char * const file|const unsigned line -AxpR |bool |_is_utf8_FOO_with_len|const U8 classnum|NN const U8 *p \ +CpR |bool |_is_utf8_FOO_with_len|const U8 classnum|NN const U8 *p \ |NN const U8 * const e -AbDxpR |bool |is_utf8_alnum |NN const U8 *p -AbDxpR |bool |is_utf8_alnumc |NN const U8 *p -AbDxpR |bool |is_utf8_idfirst|NN const U8 *p -AbDxpR |bool |is_utf8_xidfirst|NN const U8 *p -AxpR |bool |_is_utf8_idcont|NN const U8 *p -AxpR |bool |_is_utf8_idstart|NN const U8 *p -AxpR |bool |_is_utf8_xidcont|NN const U8 *p -AxpR |bool |_is_utf8_xidstart|NN const U8 *p -AxpR |bool |_is_utf8_perl_idcont_with_len|NN const U8 *p \ +CbDpR |bool |is_utf8_alnum |NN const U8 *p +CbDpR |bool |is_utf8_alnumc |NN const U8 *p +CbDpR |bool |is_utf8_idfirst|NN const U8 *p +CbDpR |bool |is_utf8_xidfirst|NN const U8 *p +CpR |bool |_is_utf8_idcont|NN const U8 *p +CpR |bool |_is_utf8_idstart|NN const U8 *p +CpR |bool |_is_utf8_xidcont|NN const U8 *p +CpR |bool |_is_utf8_xidstart|NN const U8 *p +CpR |bool |_is_utf8_perl_idcont_with_len|NN const U8 *p \ |NN const U8 * const e -AxpR |bool |_is_utf8_perl_idstart_with_len|NN const U8 *p \ +CpR |bool |_is_utf8_perl_idstart_with_len|NN const U8 *p \ |NN const U8 * const e -AbDxpR |bool |is_utf8_idcont |NN const U8 *p -AbDxpR |bool |is_utf8_xidcont |NN const U8 *p -AbDxpR |bool |is_utf8_alpha |NN const U8 *p -AbDxpR |bool |is_utf8_ascii |NN const U8 *p -AbDxpR |bool |is_utf8_blank |NN const U8 *p -AbDxpR |bool |is_utf8_space |NN const U8 *p -AbDxpR |bool |is_utf8_perl_space |NN const U8 *p -AbDxpR |bool |is_utf8_perl_word |NN const U8 *p -AbDxpR |bool |is_utf8_cntrl |NN const U8 *p -AbDxpR |bool |is_utf8_digit |NN const U8 *p -AbDxpR |bool |is_utf8_posix_digit |NN const U8 *p -AbDxpR |bool |is_utf8_graph |NN const U8 *p -AbDxpR |bool |is_utf8_upper |NN const U8 *p -AbDxpR |bool |is_utf8_lower |NN const U8 *p -AbDxpR |bool |is_utf8_print |NN const U8 *p -AbDxpR |bool |is_utf8_punct |NN const U8 *p -AbDxpR |bool |is_utf8_xdigit |NN const U8 *p -AxpR |bool |_is_utf8_mark |NN const U8 *p +CbDpR |bool |is_utf8_idcont |NN const U8 *p +CbDpR |bool |is_utf8_xidcont |NN const U8 *p +CbDpR |bool |is_utf8_alpha |NN const U8 *p +CbDpR |bool |is_utf8_ascii |NN const U8 *p +CbDpR |bool |is_utf8_blank |NN const U8 *p +CbDpR |bool |is_utf8_space |NN const U8 *p +CbDpR |bool |is_utf8_perl_space |NN const U8 *p +CbDpR |bool |is_utf8_perl_word |NN const U8 *p +CbDpR |bool |is_utf8_cntrl |NN const U8 *p +CbDpR |bool |is_utf8_digit |NN const U8 *p +CbDpR |bool |is_utf8_posix_digit |NN const U8 *p +CbDpR |bool |is_utf8_graph |NN const U8 *p +CbDpR |bool |is_utf8_upper |NN const U8 *p +CbDpR |bool |is_utf8_lower |NN const U8 *p +CbDpR |bool |is_utf8_print |NN const U8 *p +CbDpR |bool |is_utf8_punct |NN const U8 *p +CbDpR |bool |is_utf8_xdigit |NN const U8 *p +CpR |bool |_is_utf8_mark |NN const U8 *p AbDxpR |bool |is_utf8_mark |NN const U8 *p #if defined(PERL_CORE) || defined(PERL_EXT) EXdpR |bool |isSCRIPT_RUN |NN const U8 *s|NN const U8 *send \ @@ -1178,7 +1301,7 @@ p |int |magic_setcollxfrm|NN SV* sv|NN MAGIC* mg pbD |char* |mem_collxfrm |NN const char* input_string|STRLEN len|NN STRLEN* xlen : Defined in locale.c, used only in sv.c # if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_MATHOMS_C) -px |char* |_mem_collxfrm |NN const char* input_string \ +p |char* |_mem_collxfrm |NN const char* input_string \ |STRLEN len \ |NN STRLEN* xlen \ |bool utf8 @@ -1248,8 +1371,8 @@ pX |I32 |my_stat_flags |NULLOK const U32 flags Afp |char * |my_strftime |NN const char *fmt|int sec|int min|int hour|int mday|int mon|int year|int wday|int yday|int isdst : Used in pp_ctl.c p |void |my_unexec -AbDxTPR |UV |NATIVE_TO_NEED |const UV enc|const UV ch -AbDxTPR |UV |ASCII_TO_NEED |const UV enc|const UV ch +CbDTPR |UV |NATIVE_TO_NEED |const UV enc|const UV ch +CbDTPR |UV |ASCII_TO_NEED |const UV enc|const UV ch ApR |OP* |newANONLIST |NULLOK OP* o ApR |OP* |newANONHASH |NULLOK OP* o Ap |OP* |newANONSUB |I32 floor|NULLOK OP* proto|NULLOK OP* block @@ -1425,8 +1548,8 @@ ATdo |const char*|Perl_langinfo|const nl_item item #else ATdo |const char*|Perl_langinfo|const int item #endif -ApOx |int |init_i18nl10n |int printwarn -AbpOxD |int |init_i18nl14n |int printwarn +CpO |int |init_i18nl10n |int printwarn +CbpOD |int |init_i18nl14n |int printwarn p |char* |my_strerror |const int errnum XpT |void |_warn_problematic_locale Xp |void |set_numeric_underlying @@ -1458,6 +1581,7 @@ ApMb |OP* |ref |NULLOK OP* o|I32 type S |OP* |refkids |NULLOK OP* o|I32 type #endif Ap |void |regdump |NN const regexp* r +CiTop |struct regexp *|ReANY |NN const REGEXP * const re #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PERL_C) || defined(PERL_IN_UTF8_C) EXpR |SV* |_new_invlist_C_array|NN const UV* const list EXp |bool |_invlistEQ |NN SV* const a|NN SV* const b|const bool complement_b @@ -1482,14 +1606,14 @@ p |REGEXP*|re_op_compile |NULLOK SV ** const patternp \ |NULLOK bool *is_bare_re \ |const U32 rx_flags|const U32 pm_flags Ap |REGEXP*|re_compile |NN SV * const pattern|U32 orig_rx_flags -Ap |char* |re_intuit_start|NN REGEXP * const rx \ +Cp |char* |re_intuit_start|NN REGEXP * const rx \ |NULLOK SV* sv \ |NN const char* const strbeg \ |NN char* strpos \ |NN char* strend \ |const U32 flags \ |NULLOK re_scream_pos_data *data -Ap |SV* |re_intuit_string|NN REGEXP *const r +Cp |SV* |re_intuit_string|NN REGEXP *const r Ap |I32 |regexec_flags |NN REGEXP *const rx|NN char *stringarg \ |NN char *strend|NN char *strbeg \ |SSize_t minend|NN SV *sv \ @@ -1546,7 +1670,7 @@ Apda |char* |savesharedsvpv |NN SV *sv Apda |char* |savesvpv |NN SV* sv Ap |void |savestack_grow Ap |void |savestack_grow_cnt |I32 need -Amp |void |save_aelem |NN AV* av|SSize_t idx|NN SV **sptr +Am |void |save_aelem |NN AV* av|SSize_t idx|NN SV **sptr Ap |void |save_aelem_flags|NN AV* av|SSize_t idx|NN SV **sptr \ |const U32 flags Ap |I32 |save_alloc |I32 size|I32 pad @@ -1569,7 +1693,7 @@ Ap |void |save_shared_pvref|NN char** str Adp |void |save_gp |NN GV* gv|I32 empty Apdh |HV* |save_hash |NN GV* gv Ap |void |save_hints -Amp |void |save_helem |NN HV *hv|NN SV *key|NN SV **sptr +Am |void |save_helem |NN HV *hv|NN SV *key|NN SV **sptr Ap |void |save_helem_flags|NN HV *hv|NN SV *key|NN SV **sptr|const U32 flags Apdh |void |save_hptr |NN HV** hptr Ap |void |save_I16 |NN I16* intp @@ -1602,6 +1726,8 @@ Ap |void |save_pushptrptr|NULLOK void *const ptr1 \ S |void |save_pushptri32ptr|NULLOK void *const ptr1|const I32 i \ |NULLOK void *const ptr2|const int type #endif +Xiop |I32 |TOPMARK +Xiop |I32 |POPMARK : Used in perly.y p |OP* |sawparens |NULLOK OP* o Apd |OP* |op_contextualize|NN OP* o|I32 context @@ -1692,10 +1818,10 @@ Apd |void |sv_clear |NN SV *const orig_sv #if defined(PERL_IN_SV_C) S |bool |curse |NN SV * const sv|const bool check_refcnt #endif -AMopd |I32 |sv_cmp |NULLOK SV *const sv1|NULLOK SV *const sv2 +AMpd |I32 |sv_cmp |NULLOK SV *const sv1|NULLOK SV *const sv2 Apd |I32 |sv_cmp_flags |NULLOK SV *const sv1|NULLOK SV *const sv2 \ |const U32 flags -AMopd |I32 |sv_cmp_locale |NULLOK SV *const sv1|NULLOK SV *const sv2 +AMpd |I32 |sv_cmp_locale |NULLOK SV *const sv1|NULLOK SV *const sv2 Apd |I32 |sv_cmp_locale_flags |NULLOK SV *const sv1 \ |NULLOK SV *const sv2|const U32 flags #if defined(USE_LOCALE_COLLATE) @@ -1741,7 +1867,7 @@ Apd |void |sv_magic |NN SV *const sv|NULLOK SV *const obj|const int how \ Apd |MAGIC *|sv_magicext |NN SV *const sv|NULLOK SV *const obj|const int how \ |NULLOK const MGVTBL *const vtbl|NULLOK const char *const name \ |const I32 namlen -EiT |bool |sv_only_taint_gmagic|NN SV *sv +EiTp |bool |sv_only_taint_gmagic|NN SV *sv : exported for re.pm EXp |MAGIC *|sv_magicext_mglob|NN SV *sv ApdbMR |SV* |sv_mortalcopy |NULLOK SV *const oldsv @@ -1838,15 +1964,15 @@ ESR |SV* |invlist_contents|NN SV* const invlist \ ESRT |bool |new_regcurly |NN const char *s|NN const char *e #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) -EXm |void |_invlist_intersection |NN SV* const a|NN SV* const b|NN SV** i +m |void |_invlist_intersection |NN SV* const a|NN SV* const b|NN SV** i EXp |void |_invlist_intersection_maybe_complement_2nd \ |NULLOK SV* const a|NN SV* const b \ |const bool complement_b|NN SV** i -EXm |void |_invlist_union |NULLOK SV* const a|NN SV* const b|NN SV** output +Cm |void |_invlist_union |NULLOK SV* const a|NN SV* const b|NN SV** output EXp |void |_invlist_union_maybe_complement_2nd \ |NULLOK SV* const a|NN SV* const b \ |const bool complement_b|NN SV** output -EXm |void |_invlist_subtract|NN SV* const a|NN SV* const b|NN SV** result +m |void |_invlist_subtract|NN SV* const a|NN SV* const b|NN SV** result EXp |void |_invlist_invert|NN SV* const invlist EXpR |SV* |_new_invlist |IV initial_size EXpR |SV* |_add_range_to_invlist |NULLOK SV* invlist|UV start|UV end @@ -1863,6 +1989,9 @@ EiRT |UV |_invlist_len |NN SV* const invlist EiRT |bool |_invlist_contains_cp|NN SV* const invlist|const UV cp EXpRT |SSize_t|_invlist_search |NN SV* const invlist|const UV cp #endif +#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) +EiT |const char *|get_regex_charset_name|const U32 flags|NN STRLEN* const lenp +#endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) EXp |SV* |_get_regclass_nonbitmap_data \ |NULLOK const regexp *prog \ @@ -1879,7 +2008,7 @@ EXp |void |_invlist_dump |NN PerlIO *file|I32 level \ #endif Ap |void |taint_env Ap |void |taint_proper |NULLOK const char* f|NN const char *const s -Epx |char * |_byte_dump_string \ +Ep |char * |_byte_dump_string \ |NN const U8 * const start \ |const STRLEN len \ |const bool format @@ -1890,7 +2019,7 @@ iTR |int |does_utf8_overflow|NN const U8 * const s \ iTR |int |is_utf8_overlong_given_start_byte_ok|NN const U8 * const s \ |const STRLEN len iTR |int |isFF_OVERLONG |NN const U8 * const s|const STRLEN len -SxR |char * |unexpected_non_continuation_text \ +SR |char * |unexpected_non_continuation_text \ |NN const U8 * const s \ |STRLEN print_len \ |const STRLEN non_cont_byte_pos \ @@ -1922,19 +2051,19 @@ S |UV |turkic_lc |NN const U8 * const p0|NN const U8 * const e|NN U8* ustrp|NN S S |UV |turkic_uc |NN const U8 * const p |NN const U8 * const e|NN U8* ustrp|NN STRLEN *lenp #endif ApbMdD |UV |to_utf8_lower |NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp -Axp |UV |_to_utf8_lower_flags|NN const U8 *p|NULLOK const U8* e \ +Cp |UV |_to_utf8_lower_flags|NN const U8 *p|NULLOK const U8* e \ |NN U8* ustrp|NULLOK STRLEN *lenp|bool flags \ |NN const char * const file|const int line ApbMdD |UV |to_utf8_upper |NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp -Axp |UV |_to_utf8_upper_flags |NN const U8 *p|NULLOK const U8 *e \ +Cp |UV |_to_utf8_upper_flags |NN const U8 *p|NULLOK const U8 *e \ |NN U8* ustrp|NULLOK STRLEN *lenp|bool flags \ |NN const char * const file|const int line ApbMdD |UV |to_utf8_title |NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp -Axp |UV |_to_utf8_title_flags |NN const U8 *p|NULLOK const U8* e \ +Cp |UV |_to_utf8_title_flags |NN const U8 *p|NULLOK const U8* e \ |NN U8* ustrp|NULLOK STRLEN *lenp|bool flags \ |NN const char * const file|const int line ApbMdD |UV |to_utf8_fold |NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp -Axp |UV |_to_utf8_fold_flags|NN const U8 *p|NULLOK const U8 *e \ +Cp |UV |_to_utf8_fold_flags|NN const U8 *p|NULLOK const U8 *e \ |NN U8* ustrp|NULLOK STRLEN *lenp|U8 flags \ |NN const char * const file|const int line #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) @@ -1956,7 +2085,7 @@ Ap |void |unsharepvn |NULLOK const char* sv|I32 len|U32 hash p |void |unshare_hek |NULLOK HEK* hek : Used in perly.y p |void |utilize |int aver|I32 floor|NULLOK OP* version|NN OP* idop|NULLOK OP* arg -Apx |void |_force_out_malformed_utf8_message \ +Cp |void |_force_out_malformed_utf8_message \ |NN const U8 *const p|NN const U8 * const e|const U32 flags \ |const bool die_here EXp |U8* |utf16_to_utf8 |NN U8* p|NN U8 *d|I32 bytelen|NN I32 *newlen @@ -1977,11 +2106,11 @@ AxTp |U8* |bytes_from_utf8_loc|NN const U8 *s \ |NULLOK const U8 ** first_unconverted Apxd |U8* |bytes_to_utf8 |NN const U8 *s|NN STRLEN *lenp ApdD |UV |utf8_to_uvchr |NN const U8 *s|NULLOK STRLEN *retlen -AbpdD |UV |utf8_to_uvuni |NN const U8 *s|NULLOK STRLEN *retlen -AbpxD |UV |valid_utf8_to_uvuni |NN const U8 *s|NULLOK STRLEN *retlen +CbpdD |UV |utf8_to_uvuni |NN const U8 *s|NULLOK STRLEN *retlen +CbpD |UV |valid_utf8_to_uvuni |NN const U8 *s|NULLOK STRLEN *retlen AMpd |UV |utf8_to_uvchr_buf |NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen -Ai |UV |_utf8_to_uvchr_buf |NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen -ApdD |UV |utf8_to_uvuni_buf |NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen +Cip |UV |utf8_to_uvchr_buf_helper|NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen +CpdD |UV |utf8_to_uvuni_buf |NN const U8 *s|NN const U8 *send|NULLOK STRLEN *retlen p |bool |check_utf8_print |NN const U8 *s|const STRLEN len AdMTp |UV |utf8n_to_uvchr |NN const U8 *s \ @@ -1993,29 +2122,29 @@ AdMTp |UV |utf8n_to_uvchr_error|NN const U8 *s \ |NULLOK STRLEN *retlen \ |const U32 flags \ |NULLOK U32 * errors -AxTdi |UV |utf8n_to_uvchr_msgs|NN const U8 *s \ +AxTdip |UV |utf8n_to_uvchr_msgs|NN const U8 *s \ |STRLEN curlen \ |NULLOK STRLEN *retlen \ |const U32 flags \ |NULLOK U32 * errors \ |NULLOK AV ** msgs -AxTp |UV |_utf8n_to_uvchr_msgs_helper \ +CTp |UV |_utf8n_to_uvchr_msgs_helper \ |NN const U8 *s \ |STRLEN curlen \ |NULLOK STRLEN *retlen \ |const U32 flags \ |NULLOK U32 * errors \ |NULLOK AV ** msgs -AipTRd |UV |valid_utf8_to_uvchr |NN const U8 *s|NULLOK STRLEN *retlen -Adp |UV |utf8n_to_uvuni|NN const U8 *s|STRLEN curlen|NULLOK STRLEN *retlen|U32 flags +CipTRd |UV |valid_utf8_to_uvchr |NN const U8 *s|NULLOK STRLEN *retlen +Cdp |UV |utf8n_to_uvuni|NN const U8 *s|STRLEN curlen|NULLOK STRLEN *retlen|U32 flags Adm |U8* |uvchr_to_utf8 |NN U8 *d|UV uv -Ap |U8* |uvuni_to_utf8 |NN U8 *d|UV uv +Cp |U8* |uvuni_to_utf8 |NN U8 *d|UV uv Adm |U8* |uvchr_to_utf8_flags |NN U8 *d|UV uv|UV flags Admx |U8* |uvchr_to_utf8_flags_msgs|NN U8 *d|UV uv|UV flags|NULLOK HV ** msgs -AMpod |U8* |uvoffuni_to_utf8_flags |NN U8 *d|UV uv|const UV flags -Apx |U8* |uvoffuni_to_utf8_flags_msgs|NN U8 *d|UV uv|const UV flags|NULLOK HV** msgs -Adp |U8* |uvuni_to_utf8_flags |NN U8 *d|UV uv|UV flags +CMpd |U8* |uvoffuni_to_utf8_flags |NN U8 *d|UV uv|const UV flags +Cp |U8* |uvoffuni_to_utf8_flags_msgs|NN U8 *d|UV uv|const UV flags|NULLOK HV** msgs +Cdp |U8* |uvuni_to_utf8_flags |NN U8 *d|UV uv|UV flags Apd |char* |pv_uni_display |NN SV *dsv|NN const U8 *spv|STRLEN len|STRLEN pvlim|UV flags ApdR |char* |sv_uni_display |NN SV *dsv|NN SV *ssv|STRLEN pvlim|UV flags EXpR |Size_t |_inverse_folds |const UV cp \ @@ -2065,7 +2194,7 @@ Ap |I32 |whichsig_sv |NN SV* sigsv Ap |I32 |whichsig_pv |NN const char* sig Ap |I32 |whichsig_pvn |NN const char* sig|STRLEN len : used to check for NULs in pathnames and other names -AiRd |bool |is_safe_syscall|NN const char *pv|STRLEN len|NN const char *what|NN const char *op_name +AiRdp |bool |is_safe_syscall|NN const char *pv|STRLEN len|NN const char *what|NN const char *op_name #ifdef PERL_CORE iTR |bool |should_warn_nl|NN const char *pv #endif @@ -2099,7 +2228,7 @@ ATpa |Malloc_t|safesysmalloc |MEM_SIZE nbytes ATpa |Malloc_t|safesyscalloc |MEM_SIZE elements|MEM_SIZE size ATpR |Malloc_t|safesysrealloc|Malloc_t where|MEM_SIZE nbytes ATp |Free_t |safesysfree |Malloc_t where -AirTe |void |croak_memory_wrap +AirTep |void |croak_memory_wrap #if defined(PERL_GLOBAL_STRUCT) Ap |struct perl_vars *|GetVars Ap |struct perl_vars*|init_global_struct @@ -2172,6 +2301,13 @@ pX |SSize_t|tmps_grow_p |SSize_t ix Apd |SV* |sv_rvweaken |NN SV *const sv Apd |SV* |sv_rvunweaken |NN SV *const sv ATpxd |SV* |sv_get_backrefs|NN SV *const sv +AiTMdp |SV * |SvREFCNT_inc |NULLOK SV *sv +AiTMdp |SV * |SvREFCNT_inc_NN|NN SV *sv +AiTMdp |void |SvREFCNT_inc_void|NULLOK SV *sv +AiMdp |void |SvREFCNT_dec |NULLOK SV *sv +AiMdp |void |SvREFCNT_dec_NN|NN SV *sv +AiTp |void |SvAMAGIC_on |NN SV *sv +AiTp |void |SvAMAGIC_off |NN SV *sv : This is indirectly referenced by globals.c. This is somewhat annoying. p |int |magic_killbackrefs|NN SV *sv|NN MAGIC *mg Ap |OP* |newANONATTRSUB |I32 floor|NULLOK OP *proto|NULLOK OP *attrs|NULLOK OP *block @@ -2224,7 +2360,9 @@ Ap |void |sys_intern_dup |NN struct interp_intern* src|NN struct interp_intern* # endif #endif -Admop |const XOP * |custom_op_xop |NN const OP *o +: The reason for the 'u' flag is that this passes "aTHX_ x" to its callee: not +: a legal C parameter +Admu |const XOP * |Perl_custom_op_xop |NN const OP *o AbpRdD |const char * |custom_op_name |NN const OP *o AbpRdD |const char * |custom_op_desc |NN const OP *o pRX |XOPRETANY |custom_op_get_field |NN const OP *o|const xop_flags_enum field @@ -2683,7 +2821,7 @@ ESR |bool |regtail_study |NN RExC_state_t *pRExC_state \ #endif #if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) -EXRpx |bool |isFOO_lc |const U8 classnum|const U8 character +EXRp |bool |isFOO_lc |const U8 classnum|const U8 character #endif #if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) @@ -2991,7 +3129,7 @@ STR |char * |setlocale_debug_string |const int category \ || defined(PERL_IN_MG_C) \ || defined (PERL_EXT_POSIX) \ || defined (PERL_EXT_LANGINFO)) -Apx |bool |_is_cur_LC_category_utf8|int category +Cp |bool |_is_cur_LC_category_utf8|int category #endif @@ -3034,7 +3172,7 @@ SR |U8* |swash_scan_list_line|NN U8* l|NN U8* const lend|NN UV* min \ |NN const U8* const typestr #endif -EXiT |void |append_utf8_from_native_byte|const U8 byte|NN U8** dest +EXiTp |void |append_utf8_from_native_byte|const U8 byte|NN U8** dest Apd |void |sv_set_undef |NN SV *sv Apd |void |sv_setsv_flags |NN SV *dstr|NULLOK SV *sstr|const I32 flags @@ -3047,10 +3185,10 @@ Amd |STRLEN |sv_utf8_upgrade_flags|NN SV *const sv|const I32 flags Adp |STRLEN |sv_utf8_upgrade_flags_grow|NN SV *const sv|const I32 flags|STRLEN extra Apd |char* |sv_pvn_force_flags|NN SV *const sv|NULLOK STRLEN *const lp|const I32 flags AdpMb |void |sv_copypv |NN SV *const dsv|NN SV *const ssv -Apmd |void |sv_copypv_nomg |NN SV *const dsv|NN SV *const ssv +Amd |void |sv_copypv_nomg |NN SV *const dsv|NN SV *const ssv Apd |void |sv_copypv_flags |NN SV *const dsv|NN SV *const ssv|const I32 flags -Apo |char* |my_atof2 |NN const char *orig|NN NV* value -Ap |char* |my_atof3 |NN const char *orig|NN NV* value|const STRLEN len +Cpo |char* |my_atof2 |NN const char *orig|NN NV* value +Cp |char* |my_atof3 |NN const char *orig|NN NV* value|const STRLEN len ApT |int |my_socketpair |int family|int type|int protocol|int fd[2] ApT |int |my_dirfd |NULLOK DIR* dir #ifdef PERL_ANY_COW @@ -3155,6 +3293,9 @@ pd |void |do_dump_pad |I32 level|NN PerlIO *file|NULLOK PADLIST *padlist|int ful Sd |void |cv_dump |NN const CV *cv|NN const char *title # endif #endif +#if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) +iT |bool |PadnameIN_SCOPE|NN const PADNAME * const pn|const U32 seq +#endif Apd |CV* |cv_clone |NN CV* proto p |CV* |cv_clone_into |NN CV* proto|NN CV *target pd |void |pad_fixup_inner_anons|NN PADLIST *padlist|NN CV *old_cv|NN CV *new_cv @@ -3245,8 +3386,8 @@ ApoP |bool |ckwarn_d |U32 w XEopxR |STRLEN *|new_warnings_bitfield|NULLOK STRLEN *buffer \ |NN const char *const bits|STRLEN size -AMpTodf |int |my_snprintf |NN char *buffer|const Size_t len|NN const char *format|... -AMpTod |int |my_vsnprintf |NN char *buffer|const Size_t len|NN const char *format|va_list ap +AMpTdf |int |my_snprintf |NN char *buffer|const Size_t len|NN const char *format|... +AMpTd |int |my_vsnprintf |NN char *buffer|const Size_t len|NN const char *format|va_list ap #ifdef USE_QUADMATH ApTd |const char* |quadmath_format_single|NN const char* format ApTd |bool|quadmath_format_needed|NN const char* format @@ -3376,28 +3517,28 @@ Apx |void |leave_adjust_stacks|NN SV **from_sp|NN SV **to_sp \ |U8 gimme|int filter #ifndef PERL_NO_INLINE_FUNCTIONS -Aix |PERL_CONTEXT * |cx_pushblock|U8 type|U8 gimme|NN SV** sp|I32 saveix -Aix |void |cx_popblock|NN PERL_CONTEXT *cx -Aix |void |cx_topblock|NN PERL_CONTEXT *cx -Aix |void |cx_pushsub |NN PERL_CONTEXT *cx|NN CV *cv \ +Aixp |PERL_CONTEXT * |cx_pushblock|U8 type|U8 gimme|NN SV** sp|I32 saveix +Aixp |void |cx_popblock|NN PERL_CONTEXT *cx +Aixp |void |cx_topblock|NN PERL_CONTEXT *cx +Aixp |void |cx_pushsub |NN PERL_CONTEXT *cx|NN CV *cv \ |NULLOK OP *retop|bool hasargs -Aix |void |cx_popsub_common|NN PERL_CONTEXT *cx -Aix |void |cx_popsub_args |NN PERL_CONTEXT *cx -Aix |void |cx_popsub |NN PERL_CONTEXT *cx -Aix |void |cx_pushformat |NN PERL_CONTEXT *cx|NN CV *cv \ +Aixp |void |cx_popsub_common|NN PERL_CONTEXT *cx +Aixp |void |cx_popsub_args |NN PERL_CONTEXT *cx +Aixp |void |cx_popsub |NN PERL_CONTEXT *cx +Aixp |void |cx_pushformat |NN PERL_CONTEXT *cx|NN CV *cv \ |NULLOK OP *retop|NULLOK GV *gv -Aix |void |cx_popformat |NN PERL_CONTEXT *cx -Aix |void |cx_pusheval |NN PERL_CONTEXT *cx \ +Aixp |void |cx_popformat |NN PERL_CONTEXT *cx +Aixp |void |cx_pusheval |NN PERL_CONTEXT *cx \ |NULLOK OP *retop|NULLOK SV *namesv -Aix |void |cx_popeval |NN PERL_CONTEXT *cx -Aix |void |cx_pushloop_plain|NN PERL_CONTEXT *cx -Aix |void |cx_pushloop_for |NN PERL_CONTEXT *cx \ +Aixp |void |cx_popeval |NN PERL_CONTEXT *cx +Aixp |void |cx_pushloop_plain|NN PERL_CONTEXT *cx +Aixp |void |cx_pushloop_for |NN PERL_CONTEXT *cx \ |NN void *itervarp|NULLOK SV *itersave -Aix |void |cx_poploop |NN PERL_CONTEXT *cx -Aix |void |cx_pushwhen |NN PERL_CONTEXT *cx -Aix |void |cx_popwhen |NN PERL_CONTEXT *cx -Aix |void |cx_pushgiven |NN PERL_CONTEXT *cx|NULLOK SV *orig_defsv -Aix |void |cx_popgiven |NN PERL_CONTEXT *cx +Aixp |void |cx_poploop |NN PERL_CONTEXT *cx +Aixp |void |cx_pushwhen |NN PERL_CONTEXT *cx +Aixp |void |cx_popwhen |NN PERL_CONTEXT *cx +Aixp |void |cx_pushgiven |NN PERL_CONTEXT *cx|NULLOK SV *orig_defsv +Aixp |void |cx_popgiven |NN PERL_CONTEXT *cx #endif #ifdef USE_DTRACE @@ -27,13 +27,14 @@ /* Hide global symbols */ #define Gv_AMupdate(a,b) Perl_Gv_AMupdate(aTHX_ a,b) +#define SvAMAGIC_off Perl_SvAMAGIC_off +#define SvAMAGIC_on Perl_SvAMAGIC_on #define _force_out_malformed_utf8_message(a,b,c,d) Perl__force_out_malformed_utf8_message(aTHX_ a,b,c,d) #define _is_uni_FOO(a,b) Perl__is_uni_FOO(aTHX_ a,b) #define _is_uni_perl_idcont(a) Perl__is_uni_perl_idcont(aTHX_ a) #define _is_uni_perl_idstart(a) Perl__is_uni_perl_idstart(aTHX_ a) #define _is_utf8_FOO(a,b,c,d,e,f,g,h) Perl__is_utf8_FOO(aTHX_ a,b,c,d,e,f,g,h) #define _is_utf8_FOO_with_len(a,b,c) Perl__is_utf8_FOO_with_len(aTHX_ a,b,c) -#define _is_utf8_char_helper Perl__is_utf8_char_helper #define _is_utf8_idcont(a) Perl__is_utf8_idcont(aTHX_ a) #define _is_utf8_idstart(a) Perl__is_utf8_idstart(aTHX_ a) #define _is_utf8_mark(a) Perl__is_utf8_mark(aTHX_ a) @@ -46,7 +47,6 @@ #define _to_utf8_lower_flags(a,b,c,d,e,f,g) Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e,f,g) #define _to_utf8_title_flags(a,b,c,d,e,f,g) Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e,f,g) #define _to_utf8_upper_flags(a,b,c,d,e,f,g) Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e,f,g) -#define _utf8_to_uvchr_buf(a,b,c) S__utf8_to_uvchr_buf(aTHX_ a,b,c) #define _utf8n_to_uvchr_msgs_helper Perl__utf8n_to_uvchr_msgs_helper #define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) #define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b) @@ -65,7 +65,7 @@ #define av_push(a,b) Perl_av_push(aTHX_ a,b) #define av_shift(a) Perl_av_shift(aTHX_ a) #define av_store(a,b,c) Perl_av_store(aTHX_ a,b,c) -#define av_top_index(a) S_av_top_index(aTHX_ a) +#define av_top_index(a) Perl_av_top_index(aTHX_ a) #define av_undef(a) Perl_av_undef(aTHX_ a) #define av_unshift(a,b) Perl_av_unshift(aTHX_ a,b) #define block_end(a,b) Perl_block_end(aTHX_ a,b) @@ -98,7 +98,7 @@ #ifndef PERL_IMPLICIT_CONTEXT #define croak Perl_croak #endif -#define croak_memory_wrap S_croak_memory_wrap +#define croak_memory_wrap Perl_croak_memory_wrap #define croak_no_modify Perl_croak_no_modify #define croak_sv(a) Perl_croak_sv(aTHX_ a) #define croak_xs_usage Perl_croak_xs_usage @@ -265,16 +265,16 @@ #ifndef NO_MATHOMS #define isALNUM_lazy(a) Perl_isALNUM_lazy(aTHX_ a) #endif -#define isC9_STRICT_UTF8_CHAR S_isC9_STRICT_UTF8_CHAR +#define isC9_STRICT_UTF8_CHAR Perl_isC9_STRICT_UTF8_CHAR #ifndef NO_MATHOMS #define isIDFIRST_lazy(a) Perl_isIDFIRST_lazy(aTHX_ a) #endif -#define isSTRICT_UTF8_CHAR S_isSTRICT_UTF8_CHAR -#define isUTF8_CHAR S_isUTF8_CHAR -#define is_c9strict_utf8_string_loclen S_is_c9strict_utf8_string_loclen +#define isSTRICT_UTF8_CHAR Perl_isSTRICT_UTF8_CHAR +#define isUTF8_CHAR Perl_isUTF8_CHAR +#define is_c9strict_utf8_string_loclen Perl_is_c9strict_utf8_string_loclen #define is_lvalue_sub() Perl_is_lvalue_sub(aTHX) -#define is_safe_syscall(a,b,c,d) S_is_safe_syscall(aTHX_ a,b,c,d) -#define is_strict_utf8_string_loclen S_is_strict_utf8_string_loclen +#define is_safe_syscall(a,b,c,d) Perl_is_safe_syscall(aTHX_ a,b,c,d) +#define is_strict_utf8_string_loclen Perl_is_strict_utf8_string_loclen #ifndef NO_MATHOMS #define is_uni_alnum(a) Perl_is_uni_alnum(aTHX_ a) #endif @@ -383,13 +383,14 @@ #ifndef NO_MATHOMS #define is_utf8_char Perl_is_utf8_char #endif +#define is_utf8_char_helper Perl_is_utf8_char_helper #ifndef NO_MATHOMS #define is_utf8_cntrl(a) Perl_is_utf8_cntrl(aTHX_ a) #endif #ifndef NO_MATHOMS #define is_utf8_digit(a) Perl_is_utf8_digit(aTHX_ a) #endif -#define is_utf8_fixed_width_buf_loclen_flags S_is_utf8_fixed_width_buf_loclen_flags +#define is_utf8_fixed_width_buf_loclen_flags Perl_is_utf8_fixed_width_buf_loclen_flags #ifndef NO_MATHOMS #define is_utf8_graph(a) Perl_is_utf8_graph(aTHX_ a) #endif @@ -399,7 +400,7 @@ #ifndef NO_MATHOMS #define is_utf8_idfirst(a) Perl_is_utf8_idfirst(aTHX_ a) #endif -#define is_utf8_invariant_string_loc S_is_utf8_invariant_string_loc +#define is_utf8_invariant_string_loc Perl_is_utf8_invariant_string_loc #ifndef NO_MATHOMS #define is_utf8_lower(a) Perl_is_utf8_lower(aTHX_ a) #endif @@ -424,13 +425,13 @@ #ifndef NO_MATHOMS #define is_utf8_space(a) Perl_is_utf8_space(aTHX_ a) #endif -#define is_utf8_string_flags S_is_utf8_string_flags +#define is_utf8_string_flags Perl_is_utf8_string_flags #define is_utf8_string_loclen Perl_is_utf8_string_loclen -#define is_utf8_string_loclen_flags S_is_utf8_string_loclen_flags +#define is_utf8_string_loclen_flags Perl_is_utf8_string_loclen_flags #ifndef NO_MATHOMS #define is_utf8_upper(a) Perl_is_utf8_upper(aTHX_ a) #endif -#define is_utf8_valid_partial_char_flags S_is_utf8_valid_partial_char_flags +#define is_utf8_valid_partial_char_flags Perl_is_utf8_valid_partial_char_flags #ifndef NO_MATHOMS #define is_utf8_xdigit(a) Perl_is_utf8_xdigit(aTHX_ a) #endif @@ -898,11 +899,12 @@ #define utf8_length(a,b) Perl_utf8_length(aTHX_ a,b) #define utf8_to_bytes(a,b) Perl_utf8_to_bytes(aTHX_ a,b) #define utf8_to_uvchr(a,b) Perl_utf8_to_uvchr(aTHX_ a,b) +#define utf8_to_uvchr_buf_helper(a,b,c) Perl_utf8_to_uvchr_buf_helper(aTHX_ a,b,c) #ifndef NO_MATHOMS #define utf8_to_uvuni(a,b) Perl_utf8_to_uvuni(aTHX_ a,b) #endif #define utf8_to_uvuni_buf(a,b,c) Perl_utf8_to_uvuni_buf(aTHX_ a,b,c) -#define utf8n_to_uvchr_msgs S_utf8n_to_uvchr_msgs +#define utf8n_to_uvchr_msgs Perl_utf8n_to_uvchr_msgs #define utf8n_to_uvuni(a,b,c,d) Perl_utf8n_to_uvuni(aTHX_ a,b,c,d) #define uvoffuni_to_utf8_flags_msgs(a,b,c,d) Perl_uvoffuni_to_utf8_flags_msgs(aTHX_ a,b,c,d) #define uvuni_to_utf8(a,b) Perl_uvuni_to_utf8(aTHX_ a,b) @@ -940,7 +942,7 @@ #define csighandler Perl_csighandler #endif #if !defined(EBCDIC) -#define _variant_byte_number S__variant_byte_number +#define variant_byte_number Perl_variant_byte_number #endif #if !defined(HAS_STRLCAT) #define my_strlcat Perl_my_strlcat @@ -959,24 +961,24 @@ #define my_popen(a,b) Perl_my_popen(aTHX_ a,b) #endif #if !defined(PERL_NO_INLINE_FUNCTIONS) -#define cx_popblock(a) S_cx_popblock(aTHX_ a) -#define cx_popeval(a) S_cx_popeval(aTHX_ a) -#define cx_popformat(a) S_cx_popformat(aTHX_ a) -#define cx_popgiven(a) S_cx_popgiven(aTHX_ a) -#define cx_poploop(a) S_cx_poploop(aTHX_ a) -#define cx_popsub(a) S_cx_popsub(aTHX_ a) -#define cx_popsub_args(a) S_cx_popsub_args(aTHX_ a) -#define cx_popsub_common(a) S_cx_popsub_common(aTHX_ a) -#define cx_popwhen(a) S_cx_popwhen(aTHX_ a) -#define cx_pushblock(a,b,c,d) S_cx_pushblock(aTHX_ a,b,c,d) -#define cx_pusheval(a,b,c) S_cx_pusheval(aTHX_ a,b,c) -#define cx_pushformat(a,b,c,d) S_cx_pushformat(aTHX_ a,b,c,d) -#define cx_pushgiven(a,b) S_cx_pushgiven(aTHX_ a,b) -#define cx_pushloop_for(a,b,c) S_cx_pushloop_for(aTHX_ a,b,c) -#define cx_pushloop_plain(a) S_cx_pushloop_plain(aTHX_ a) -#define cx_pushsub(a,b,c,d) S_cx_pushsub(aTHX_ a,b,c,d) -#define cx_pushwhen(a) S_cx_pushwhen(aTHX_ a) -#define cx_topblock(a) S_cx_topblock(aTHX_ a) +#define cx_popblock(a) Perl_cx_popblock(aTHX_ a) +#define cx_popeval(a) Perl_cx_popeval(aTHX_ a) +#define cx_popformat(a) Perl_cx_popformat(aTHX_ a) +#define cx_popgiven(a) Perl_cx_popgiven(aTHX_ a) +#define cx_poploop(a) Perl_cx_poploop(aTHX_ a) +#define cx_popsub(a) Perl_cx_popsub(aTHX_ a) +#define cx_popsub_args(a) Perl_cx_popsub_args(aTHX_ a) +#define cx_popsub_common(a) Perl_cx_popsub_common(aTHX_ a) +#define cx_popwhen(a) Perl_cx_popwhen(aTHX_ a) +#define cx_pushblock(a,b,c,d) Perl_cx_pushblock(aTHX_ a,b,c,d) +#define cx_pusheval(a,b,c) Perl_cx_pusheval(aTHX_ a,b,c) +#define cx_pushformat(a,b,c,d) Perl_cx_pushformat(aTHX_ a,b,c,d) +#define cx_pushgiven(a,b) Perl_cx_pushgiven(aTHX_ a,b) +#define cx_pushloop_for(a,b,c) Perl_cx_pushloop_for(aTHX_ a,b,c) +#define cx_pushloop_plain(a) Perl_cx_pushloop_plain(aTHX_ a) +#define cx_pushsub(a,b,c,d) Perl_cx_pushsub(aTHX_ a,b,c,d) +#define cx_pushwhen(a) Perl_cx_pushwhen(aTHX_ a) +#define cx_topblock(a) Perl_cx_topblock(aTHX_ a) #endif #if defined(DEBUGGING) #define pad_setsv(a,b) Perl_pad_setsv(aTHX_ a,b) @@ -1091,7 +1093,7 @@ #if defined(PERL_CORE) || defined(PERL_EXT) #define _byte_dump_string(a,b,c) Perl__byte_dump_string(aTHX_ a,b,c) #define _inverse_folds(a,b,c) Perl__inverse_folds(aTHX_ a,b,c) -#define append_utf8_from_native_byte S_append_utf8_from_native_byte +#define append_utf8_from_native_byte Perl_append_utf8_from_native_byte #define av_reify(a) Perl_av_reify(aTHX_ a) #define current_re_engine() Perl_current_re_engine(aTHX) #define cv_ckproto_len_flags(a,b,c,d,e) Perl_cv_ckproto_len_flags(aTHX_ a,b,c,d,e) @@ -1114,7 +1116,7 @@ #define scan_word(a,b,c,d,e) Perl_scan_word(aTHX_ a,b,c,d,e) #define skipspace_flags(a,b) Perl_skipspace_flags(aTHX_ a,b) #define sv_magicext_mglob(a) Perl_sv_magicext_mglob(aTHX_ a) -#define sv_only_taint_gmagic S_sv_only_taint_gmagic +#define sv_only_taint_gmagic Perl_sv_only_taint_gmagic #define swash_fetch(a,b,c) Perl_swash_fetch(aTHX_ a,b,c) #define swash_init(a,b,c,d,e) Perl_swash_init(aTHX_ a,b,c,d,e) #define utf16_to_utf8(a,b,c,d) Perl_utf16_to_utf8(aTHX_ a,b,c,d) @@ -1175,13 +1177,16 @@ #define sv_setsv_cow(a,b) Perl_sv_setsv_cow(aTHX_ a,b) # endif # if defined(PERL_CORE) || defined (PERL_EXT) -#define is_utf8_non_invariant_string S_is_utf8_non_invariant_string +#define is_utf8_non_invariant_string Perl_is_utf8_non_invariant_string #define sv_or_pv_pos_u2b(a,b,c,d) S_sv_or_pv_pos_u2b(aTHX_ a,b,c,d) # endif # if defined(PERL_CORE) || defined(PERL_EXT) #define isSCRIPT_RUN(a,b,c) Perl_isSCRIPT_RUN(aTHX_ a,b,c) #define variant_under_utf8_count S_variant_under_utf8_count # endif +# if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) +#define get_regex_charset_name S_get_regex_charset_name +# endif # if defined(PERL_IN_REGCOMP_C) #define _make_exactf_invlist(a,b) S__make_exactf_invlist(aTHX_ a,b) #define add_above_Latin1_folds(a,b,c) S_add_above_Latin1_folds(aTHX_ a,b,c) @@ -1906,6 +1911,9 @@ #define pad_findlex(a,b,c,d,e,f,g,h,i) S_pad_findlex(aTHX_ a,b,c,d,e,f,g,h,i) #define pad_reset() S_pad_reset(aTHX) # endif +# if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) +#define PadnameIN_SCOPE S_PadnameIN_SCOPE +# endif # if defined(PERL_IN_PERL_C) #define find_beginning(a,b) S_find_beginning(aTHX_ a,b) #define forbid_setid(a,b) S_forbid_setid(aTHX_ a,b) @@ -40,7 +40,7 @@ SOFTWARE. /* ------------------------------- av.h ------------------------------- */ PERL_STATIC_INLINE SSize_t -S_av_top_index(pTHX_ AV *av) +Perl_av_top_index(pTHX_ AV *av) { PERL_ARGS_ASSERT_AV_TOP_INDEX; assert(SvTYPE(av) == SVt_PVAV); @@ -51,17 +51,21 @@ S_av_top_index(pTHX_ AV *av) /* ------------------------------- cv.h ------------------------------- */ PERL_STATIC_INLINE GV * -S_CvGV(pTHX_ CV *sv) +Perl_CvGV(pTHX_ CV *sv) { + PERL_ARGS_ASSERT_CVGV; + return CvNAMED(sv) ? Perl_cvgv_from_hek(aTHX_ sv) : ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv_u.xcv_gv; } PERL_STATIC_INLINE I32 * -S_CvDEPTHp(const CV * const sv) +Perl_CvDEPTH(const CV * const sv) { + PERL_ARGS_ASSERT_CVDEPTH; assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM); + return &((XPVCV*)SvANY(sv))->xcv_depth; } @@ -119,8 +123,10 @@ S_MgBYTEPOS(pTHX_ MAGIC *mg, SV *sv, const char *s, STRLEN len) #if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) PERL_STATIC_INLINE bool -PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq) +S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq) { + PERL_ARGS_ASSERT_PADNAMEIN_SCOPE; + /* is seq within the range _LOW to _HIGH ? * This is complicated by the fact that PL_cop_seqmax * may have wrapped around at some point */ @@ -153,7 +159,7 @@ PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq) /* ------------------------------- pp.h ------------------------------- */ PERL_STATIC_INLINE I32 -S_TOPMARK(pTHX) +Perl_TOPMARK(pTHX) { DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log, "MARK top %p %" IVdf "\n", @@ -163,7 +169,7 @@ S_TOPMARK(pTHX) } PERL_STATIC_INLINE I32 -S_POPMARK(pTHX) +Perl_POPMARK(pTHX) { DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log, "MARK pop %p %" IVdf "\n", @@ -176,10 +182,13 @@ S_POPMARK(pTHX) /* ----------------------------- regexp.h ----------------------------- */ PERL_STATIC_INLINE struct regexp * -S_ReANY(const REGEXP * const re) +Perl_ReANY(const REGEXP * const re) { XPV* const p = (XPV*)SvANY(re); + + PERL_ARGS_ASSERT_REANY; assert(isREGEXP(re)); + return SvTYPE(re) == SVt_PVLV ? p->xpv_len_u.xpvlenu_rx : (struct regexp *)p; } @@ -187,26 +196,28 @@ S_ReANY(const REGEXP * const re) /* ------------------------------- sv.h ------------------------------- */ PERL_STATIC_INLINE SV * -S_SvREFCNT_inc(SV *sv) +Perl_SvREFCNT_inc(SV *sv) { if (LIKELY(sv != NULL)) SvREFCNT(sv)++; return sv; } PERL_STATIC_INLINE SV * -S_SvREFCNT_inc_NN(SV *sv) +Perl_SvREFCNT_inc_NN(SV *sv) { + PERL_ARGS_ASSERT_SVREFCNT_INC_NN; + SvREFCNT(sv)++; return sv; } PERL_STATIC_INLINE void -S_SvREFCNT_inc_void(SV *sv) +Perl_SvREFCNT_inc_void(SV *sv) { if (LIKELY(sv != NULL)) SvREFCNT(sv)++; } PERL_STATIC_INLINE void -S_SvREFCNT_dec(pTHX_ SV *sv) +Perl_SvREFCNT_dec(pTHX_ SV *sv) { if (LIKELY(sv != NULL)) { U32 rc = SvREFCNT(sv); @@ -218,9 +229,12 @@ S_SvREFCNT_dec(pTHX_ SV *sv) } PERL_STATIC_INLINE void -S_SvREFCNT_dec_NN(pTHX_ SV *sv) +Perl_SvREFCNT_dec_NN(pTHX_ SV *sv) { U32 rc = SvREFCNT(sv); + + PERL_ARGS_ASSERT_SVREFCNT_DEC_NN; + if (LIKELY(rc > 1)) SvREFCNT(sv) = rc - 1; else @@ -228,26 +242,30 @@ S_SvREFCNT_dec_NN(pTHX_ SV *sv) } PERL_STATIC_INLINE void -SvAMAGIC_on(SV *sv) +Perl_SvAMAGIC_on(SV *sv) { + PERL_ARGS_ASSERT_SVAMAGIC_ON; assert(SvROK(sv)); + if (SvOBJECT(SvRV(sv))) HvAMAGIC_on(SvSTASH(SvRV(sv))); } PERL_STATIC_INLINE void -SvAMAGIC_off(SV *sv) +Perl_SvAMAGIC_off(SV *sv) { + PERL_ARGS_ASSERT_SVAMAGIC_OFF; + if (SvROK(sv) && SvOBJECT(SvRV(sv))) HvAMAGIC_off(SvSTASH(SvRV(sv))); } PERL_STATIC_INLINE U32 -S_SvPADSTALE_on(SV *sv) +Perl_SvPADSTALE_on(SV *sv) { assert(!(SvFLAGS(sv) & SVs_PADTMP)); return SvFLAGS(sv) |= SVs_PADSTALE; } PERL_STATIC_INLINE U32 -S_SvPADSTALE_off(SV *sv) +Perl_SvPADSTALE_off(SV *sv) { assert(!(SvFLAGS(sv) & SVs_PADTMP)); return SvFLAGS(sv) &= ~SVs_PADSTALE; @@ -271,7 +289,7 @@ S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp) /* saves machine code for a common noreturn idiom typically used in Newx*() */ GCC_DIAG_IGNORE_DECL(-Wunused-function); static void -S_croak_memory_wrap(void) +Perl_croak_memory_wrap(void) { Perl_croak_nocontext("%s",PL_memory_wrap); } @@ -284,7 +302,7 @@ GCC_DIAG_RESTORE_DECL; */ PERL_STATIC_INLINE void -S_append_utf8_from_native_byte(const U8 byte, U8** dest) +Perl_append_utf8_from_native_byte(const U8 byte, U8** dest) { /* Takes an input 'byte' (Latin1 or EBCDIC) and appends it to the UTF-8 * encoded string at '*dest', updating '*dest' to include it */ @@ -301,10 +319,10 @@ S_append_utf8_from_native_byte(const U8 byte, U8** dest) /* =for apidoc valid_utf8_to_uvchr -Like C<L</utf8_to_uvchr_buf>>, but should only be called when it is known that -the next character in the input UTF-8 string C<s> is well-formed (I<e.g.>, -it passes C<L</isUTF8_CHAR>>. Surrogates, non-character code points, and -non-Unicode code points are allowed. +Like C<L<perlapi/utf8_to_uvchr_buf>>, but should only be called when it is +known that the next character in the input UTF-8 string C<s> is well-formed +(I<e.g.>, it passes C<L<perlapi/isUTF8_CHAR>>. Surrogates, non-character code +points, and non-Unicode code points are allowed. =cut @@ -394,7 +412,7 @@ UTF-8 invariant, this function does not change the contents of C<*ep>. */ PERL_STATIC_INLINE bool -S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) +Perl_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) { const U8* send; const U8* x = s; @@ -466,7 +484,7 @@ S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) # if BYTEORDER == 0x1234 || BYTEORDER == 0x12345678 \ || BYTEORDER == 0x4321 || BYTEORDER == 0x87654321 - *ep = x + _variant_byte_number(* (PERL_UINTMAX_T *) x); + *ep = x + variant_byte_number(* (PERL_UINTMAX_T *) x); assert(*ep >= s && *ep < send); return FALSE; @@ -504,7 +522,7 @@ S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) #ifndef EBCDIC PERL_STATIC_INLINE unsigned int -S__variant_byte_number(PERL_UINTMAX_T word) +Perl_variant_byte_number(PERL_UINTMAX_T word) { /* This returns the position in a word (0..7) of the first variant byte in @@ -757,7 +775,7 @@ at this low a level. A valid use case could change that. */ PERL_STATIC_INLINE bool -S_is_utf8_non_invariant_string(const U8* const s, STRLEN len) +Perl_is_utf8_non_invariant_string(const U8* const s, STRLEN len) { const U8 * first_variant; @@ -891,7 +909,7 @@ C<L</is_c9strict_utf8_string_loclen>>. */ PERL_STATIC_INLINE bool -S_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) +Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) { const U8 * first_variant; @@ -1050,7 +1068,7 @@ documented at the definition of PL_extended_utf8_dfa_tab[]. */ PERL_STATIC_INLINE Size_t -S_isUTF8_CHAR(const U8 * const s0, const U8 * const e) +Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e) { const U8 * s = s0; UV state = 0; @@ -1078,7 +1096,7 @@ S_isUTF8_CHAR(const U8 * const s0, const U8 * const e) #if defined(UV_IS_QUAD) || defined(EBCDIC) if (NATIVE_UTF8_TO_I8(*s0) == 0xFF && e - s0 >= UTF8_MAXBYTES) { - return _is_utf8_char_helper(s0, e, 0); + return is_utf8_char_helper(s0, e, 0); } #endif @@ -1124,7 +1142,7 @@ documented at the definition of strict_extended_utf8_dfa_tab[]. */ PERL_STATIC_INLINE Size_t -S_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) +Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) { const U8 * s = s0; UV state = 0; @@ -1190,7 +1208,7 @@ documented at the definition of PL_c9_utf8_dfa_tab[]. */ PERL_STATIC_INLINE Size_t -S_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) +Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) { const U8 * s = s0; UV state = 0; @@ -1242,7 +1260,7 @@ See also C<L</is_strict_utf8_string_loc>>. */ PERL_STATIC_INLINE bool -S_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) +Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) { const U8 * first_variant; @@ -1319,7 +1337,7 @@ See also C<L</is_c9strict_utf8_string_loc>>. */ PERL_STATIC_INLINE bool -S_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) +Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) { const U8 * first_variant; @@ -1401,7 +1419,7 @@ See also C<L</is_utf8_string_loc_flags>>. */ PERL_STATIC_INLINE bool -S_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags) +Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags) { const U8 * first_variant; @@ -1691,7 +1709,7 @@ determined from just the first one or two bytes. */ PERL_STATIC_INLINE bool -S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags) +Perl_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags) { PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS; @@ -1702,7 +1720,7 @@ S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const return FALSE; } - return cBOOL(_is_utf8_char_helper(s, e, flags)); + return cBOOL(is_utf8_char_helper(s, e, flags)); } /* @@ -1759,7 +1777,7 @@ complete, valid characters found in the C<el> pointer. */ PERL_STATIC_INLINE bool -S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, +Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, @@ -1780,7 +1798,7 @@ S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, } PERL_STATIC_INLINE UV -S_utf8n_to_uvchr_msgs(const U8 *s, +Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, @@ -1843,9 +1861,9 @@ S_utf8n_to_uvchr_msgs(const U8 *s, } PERL_STATIC_INLINE UV -S__utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) +Perl_utf8_to_uvchr_buf_helper(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) { - PERL_ARGS_ASSERT__UTF8_TO_UVCHR_BUF; + PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF_HELPER; assert(s < send); @@ -1874,18 +1892,23 @@ S__utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) =for apidoc is_safe_syscall -Test that the given C<pv> doesn't contain any internal C<NUL> characters. -If it does, set C<errno> to C<ENOENT>, optionally warn, and return FALSE. +Test that the given C<pv> (with length C<len>) doesn't contain any internal +C<NUL> characters. +If it does, set C<errno> to C<ENOENT>, optionally warn using the C<syscalls> +category, and return FALSE. Return TRUE if the name is safe. +C<what> and C<op_name> are used in any warning. + Used by the C<IS_SAFE_SYSCALL()> macro. =cut */ PERL_STATIC_INLINE bool -S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) { +Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) +{ /* While the Windows CE API provides only UCS-16 (or UTF-16) APIs * perl itself uses xce*() functions which accept 8-bit strings. */ @@ -1926,7 +1949,8 @@ then calling: #ifdef PERL_CORE PERL_STATIC_INLINE bool -S_should_warn_nl(const char *pv) { +S_should_warn_nl(const char *pv) +{ STRLEN len; PERL_ARGS_ASSERT_SHOULD_WARN_NL; @@ -1974,11 +1998,15 @@ S_lossless_NV_to_IV(const NV nv, IV *ivp) /* ------------------ pp.c, regcomp.c, toke.c, universal.c ------------ */ +#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) + #define MAX_CHARSET_NAME_LENGTH 2 PERL_STATIC_INLINE const char * -get_regex_charset_name(const U32 flags, STRLEN* const lenp) +S_get_regex_charset_name(const U32 flags, STRLEN* const lenp) { + PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME; + /* Returns a string that corresponds to the name of the regex character set * given by 'flags', and *lenp is set the length of that string, which * cannot exceed MAX_CHARSET_NAME_LENGTH characters */ @@ -1999,6 +2027,8 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp) return "?"; /* Unknown */ } +#endif + /* Return false if any get magic is on the SV other than taint magic. @@ -2006,7 +2036,8 @@ Return false if any get magic is on the SV other than taint magic. */ PERL_STATIC_INLINE bool -S_sv_only_taint_gmagic(SV *sv) { +Perl_sv_only_taint_gmagic(SV *sv) +{ MAGIC *mg = SvMAGIC(sv); PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC; @@ -2029,7 +2060,7 @@ S_sv_only_taint_gmagic(SV *sv) { /* Enter a block. Push a new base context and return its address. */ PERL_STATIC_INLINE PERL_CONTEXT * -S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix) +Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix) { PERL_CONTEXT * cx; @@ -2056,7 +2087,7 @@ S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix) /* Exit a block (RETURN and LAST). */ PERL_STATIC_INLINE void -S_cx_popblock(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_POPBLOCK; @@ -2081,7 +2112,7 @@ S_cx_popblock(pTHX_ PERL_CONTEXT *cx) * *after* cx_pushblock() was called. */ PERL_STATIC_INLINE void -S_cx_topblock(pTHX_ PERL_CONTEXT *cx) +Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_TOPBLOCK; @@ -2096,7 +2127,7 @@ S_cx_topblock(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs) +Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs) { U8 phlags = CX_PUSHSUB_GET_LVALUE_MASK(Perl_was_lvalue_sub); @@ -2116,7 +2147,7 @@ S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs) /* subsets of cx_popsub() */ PERL_STATIC_INLINE void -S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx) { CV *cv; @@ -2135,7 +2166,7 @@ S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx) /* handle the @_ part of leaving a sub */ PERL_STATIC_INLINE void -S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx) { AV *av; @@ -2157,7 +2188,7 @@ S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_popsub(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_POPSUB; assert(CxTYPE(cx) == CXt_SUB); @@ -2171,7 +2202,7 @@ S_cx_popsub(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv) +Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv) { PERL_ARGS_ASSERT_CX_PUSHFORMAT; @@ -2189,7 +2220,7 @@ S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv) PERL_STATIC_INLINE void -S_cx_popformat(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx) { CV *cv; GV *dfout; @@ -2212,7 +2243,7 @@ S_cx_popformat(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv) +Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv) { PERL_ARGS_ASSERT_CX_PUSHEVAL; @@ -2230,7 +2261,7 @@ S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv) PERL_STATIC_INLINE void -S_cx_popeval(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx) { SV *sv; @@ -2262,7 +2293,7 @@ S_cx_popeval(pTHX_ PERL_CONTEXT *cx) */ PERL_STATIC_INLINE void -S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx) +Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN; cx->blk_loop.my_op = cLOOP; @@ -2274,7 +2305,7 @@ S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx) */ PERL_STATIC_INLINE void -S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave) +Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave) { PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR; @@ -2292,7 +2323,7 @@ S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave) /* pop all loop types, including plain */ PERL_STATIC_INLINE void -S_cx_poploop(pTHX_ PERL_CONTEXT *cx) +Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_POPLOOP; @@ -2325,7 +2356,7 @@ S_cx_poploop(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx) +Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_PUSHWHEN; @@ -2334,7 +2365,7 @@ S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_popwhen(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_POPWHEN; assert(CxTYPE(cx) == CXt_WHEN); @@ -2346,7 +2377,7 @@ S_cx_popwhen(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv) +Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv) { PERL_ARGS_ASSERT_CX_PUSHGIVEN; @@ -2356,7 +2387,7 @@ S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv) PERL_STATIC_INLINE void -S_cx_popgiven(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx) { SV *sv; @@ -1676,7 +1676,7 @@ Perl_is_utf8_char(const U8 *s) /* =for apidoc is_utf8_char_buf -This is identical to the macro L</isUTF8_CHAR>. +This is identical to the macro L<perlapi/isUTF8_CHAR>. =cut */ @@ -1722,7 +1722,7 @@ NULL) to -1. If those warnings are off, the computed value if well-defined (or the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the next possible position in C<s> that could begin a non-malformed character. -See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned. +See L<perlapi/utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned. =cut */ @@ -17036,7 +17036,7 @@ Perl_peep(pTHX_ OP *o) /* =head1 Custom Operators -=for apidoc custom_op_xop +=for apidoc Perl_custom_op_xop Return the XOP structure for a given custom op. This macro should be considered internal to C<OP_NAME> and the other access macros: use them instead. This macro does call a function. Prior @@ -7205,9 +7205,19 @@ so no C<x++>. # define do_aexec(really, mark,sp) do_aexec5(really, mark, sp, 0, 0) #endif -/* check embedded \0 characters in pathnames passed to syscalls, - but allow one ending \0 */ -#define IS_SAFE_SYSCALL(p, len, what, op_name) (S_is_safe_syscall(aTHX_ (p), (len), (what), (op_name))) + +/* +=head1 Miscellaneous Functions + +=for apidoc Am|bool|IS_SAFE_SYSCALL|NN const char *pv|STRLEN len|NN const char *what|NN const char *op_name + +Same as L</is_safe_syscall>. + +=cut + +Allows one ending \0 +*/ +#define IS_SAFE_SYSCALL(p, len, what, op_name) (Perl_is_safe_syscall(aTHX_ (p), (len), (what), (op_name))) #define IS_SAFE_PATHNAME(p, len, op_name) IS_SAFE_SYSCALL((p), (len), "pathname", (op_name)) @@ -67,8 +67,8 @@ Refetch the stack pointer. Used after a callback. See L<perlcall>. PL_markstack_ptr, (IV)*mark_stack_entry))); \ } STMT_END -#define TOPMARK S_TOPMARK(aTHX) -#define POPMARK S_POPMARK(aTHX) +#define TOPMARK Perl_TOPMARK(aTHX) +#define POPMARK Perl_POPMARK(aTHX) #define INCMARK \ STMT_START { \ @@ -22,8 +22,19 @@ PERL_CALLCONV UV ASCII_TO_NEED(const UV enc, const UV ch) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_ASCII_TO_NEED #endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE I32 * Perl_CvDEPTH(const CV * const sv); +#define PERL_ARGS_ASSERT_CVDEPTH \ + assert(sv) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE GV * Perl_CvGV(pTHX_ CV *sv); +#define PERL_ARGS_ASSERT_CVGV \ + assert(sv) +#endif PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing); #define PERL_ARGS_ASSERT_GV_AMUPDATE \ assert(stash) @@ -32,12 +43,20 @@ PERL_CALLCONV UV NATIVE_TO_NEED(const UV enc, const UV ch) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_NATIVE_TO_NEED #endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE I32 Perl_POPMARK(pTHX); +#define PERL_ARGS_ASSERT_POPMARK +#endif PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode); +#define PERL_ARGS_ASSERT_PERLIO_CONTEXT_LAYERS PERL_CALLCONV int Perl_PerlLIO_dup2_cloexec(pTHX_ int oldfd, int newfd); +#define PERL_ARGS_ASSERT_PERLLIO_DUP2_CLOEXEC PERL_CALLCONV int Perl_PerlLIO_dup_cloexec(pTHX_ int oldfd) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PERLLIO_DUP_CLOEXEC PERL_CALLCONV int Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm) __attribute__warn_unused_result__; @@ -49,13 +68,58 @@ PERL_CALLCONV int Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC \ assert(file) +/* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o); */ +#define PERL_ARGS_ASSERT_PERL_CUSTOM_OP_XOP PERL_CALLCONV const char* Perl_setlocale(const int category, const char* locale); +#define PERL_ARGS_ASSERT_PERL_SETLOCALE +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE struct regexp * Perl_ReANY(const REGEXP * const re); +#define PERL_ARGS_ASSERT_REANY \ + assert(re) +#endif PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SLAB_ALLOC PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op); #define PERL_ARGS_ASSERT_SLAB_FREE \ assert(op) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE void Perl_SvAMAGIC_off(SV *sv); +#define PERL_ARGS_ASSERT_SVAMAGIC_OFF \ + assert(sv) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE void Perl_SvAMAGIC_on(SV *sv); +#define PERL_ARGS_ASSERT_SVAMAGIC_ON \ + assert(sv) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE void Perl_SvREFCNT_dec(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SVREFCNT_DEC +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE void Perl_SvREFCNT_dec_NN(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SVREFCNT_DEC_NN \ + assert(sv) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE SV * Perl_SvREFCNT_inc(SV *sv); +#define PERL_ARGS_ASSERT_SVREFCNT_INC +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE SV * Perl_SvREFCNT_inc_NN(SV *sv); +#define PERL_ARGS_ASSERT_SVREFCNT_INC_NN \ + assert(sv) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE void Perl_SvREFCNT_inc_void(SV *sv); +#define PERL_ARGS_ASSERT_SVREFCNT_INC_VOID +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE I32 Perl_TOPMARK(pTHX); +#define PERL_ARGS_ASSERT_TOPMARK +#endif PERL_CALLCONV char * Perl__byte_dump_string(pTHX_ const U8 * const start, const STRLEN len, const bool format); #define PERL_ARGS_ASSERT__BYTE_DUMP_STRING \ assert(start) @@ -68,14 +132,18 @@ PERL_CALLCONV Size_t Perl__inverse_folds(pTHX_ const UV cp, unsigned int * first assert(first_folds_to); assert(remaining_folds_to) PERL_CALLCONV bool Perl__is_in_locale_category(pTHX_ const bool compiling, const int category); +#define PERL_ARGS_ASSERT__IS_IN_LOCALE_CATEGORY PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__IS_UNI_FOO PERL_CALLCONV bool Perl__is_uni_perl_idcont(pTHX_ UV c) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__IS_UNI_PERL_IDCONT PERL_CALLCONV bool Perl__is_uni_perl_idstart(pTHX_ UV c) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__IS_UNI_PERL_IDSTART PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ U8 classnum, const U8 * const p, const char * const name, const char * const alternative, const bool use_utf8, const bool use_locale, const char * const file, const unsigned line) __attribute__warn_unused_result__; @@ -87,12 +155,6 @@ PERL_CALLCONV bool Perl__is_utf8_FOO_with_len(pTHX_ const U8 classnum, const U8 #define PERL_ARGS_ASSERT__IS_UTF8_FOO_WITH_LEN \ assert(p); assert(e) -PERL_CALLCONV STRLEN Perl__is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags) - __attribute__warn_unused_result__ - __attribute__pure__; -#define PERL_ARGS_ASSERT__IS_UTF8_CHAR_HELPER \ - assert(s); assert(e) - PERL_CALLCONV bool Perl__is_utf8_idcont(pTHX_ const U8 *p) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_IDCONT \ @@ -143,21 +205,18 @@ PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8* e, U8* u PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags, const char * const file, const int line); #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ assert(p); assert(ustrp); assert(file) -#ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE UV S__utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); -#define PERL_ARGS_ASSERT__UTF8_TO_UVCHR_BUF \ - assert(s); assert(send) -#endif PERL_CALLCONV UV Perl__utf8n_to_uvchr_msgs_helper(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs); #define PERL_ARGS_ASSERT__UTF8N_TO_UVCHR_MSGS_HELPER \ assert(s) PERL_CALLCONV void Perl__warn_problematic_locale(void); +#define PERL_ARGS_ASSERT__WARN_PROBLEMATIC_LOCALE PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ const char * const msg, const char * const name) __attribute__noreturn__; #define PERL_ARGS_ASSERT_ABORT_EXECUTION \ assert(msg); assert(name) PERL_CALLCONV LOGOP* Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other); +#define PERL_ARGS_ASSERT_ALLOC_LOGOP PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_ALLOCMY \ assert(name) @@ -168,8 +227,9 @@ PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method); #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ assert(ref) PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method); +#define PERL_ARGS_ASSERT_AMAGIC_IS_ENABLED #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_append_utf8_from_native_byte(const U8 byte, U8** dest); +PERL_STATIC_INLINE void Perl_append_utf8_from_native_byte(const U8 byte, U8** dest); #define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ assert(dest) #endif @@ -180,7 +240,9 @@ PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, co #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ assert(stashpv); assert(cv); assert(attrstr) PERL_CALLCONV void Perl_atfork_lock(void); +#define PERL_ARGS_ASSERT_ATFORK_LOCK PERL_CALLCONV void Perl_atfork_unlock(void); +#define PERL_ARGS_ASSERT_ATFORK_UNLOCK PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ assert(av) @@ -250,9 +312,10 @@ PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val); assert(av) /* PERL_CALLCONV SSize_t av_tindex(pTHX_ AV *av) __attribute__warn_unused_result__; */ +#define PERL_ARGS_ASSERT_AV_TINDEX #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE SSize_t S_av_top_index(pTHX_ AV *av) +PERL_STATIC_INLINE SSize_t Perl_av_top_index(pTHX_ AV *av) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_TOP_INDEX \ assert(av) @@ -271,19 +334,25 @@ PERL_CALLCONV OP* Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) PERL_CALLCONV OP* Perl_block_end(pTHX_ I32 floor, OP* seq) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_BLOCK_END PERL_CALLCONV U8 Perl_block_gimme(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_BLOCK_GIMME PERL_CALLCONV int Perl_block_start(pTHX_ int full) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_BLOCK_START PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk); #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ assert(hk) PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX); +#define PERL_ARGS_ASSERT_BOOT_CORE_PERLIO PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX); +#define PERL_ARGS_ASSERT_BOOT_CORE_UNIVERSAL PERL_CALLCONV void Perl_boot_core_mro(pTHX); +#define PERL_ARGS_ASSERT_BOOT_CORE_MRO PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen); #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ assert(b); assert(u) @@ -300,6 +369,7 @@ PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** a #define PERL_ARGS_ASSERT_CALL_ARGV \ assert(sub_name); assert(argv) PERL_CALLCONV void Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); +#define PERL_ARGS_ASSERT_CALL_ATEXIT PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList); #define PERL_ARGS_ASSERT_CALL_LIST \ assert(paramList) @@ -313,9 +383,11 @@ PERL_CALLCONV I32 Perl_call_sv(pTHX_ SV* sv, volatile I32 flags); #define PERL_ARGS_ASSERT_CALL_SV \ assert(sv) PERL_CALLCONV const PERL_CONTEXT * Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp); +#define PERL_ARGS_ASSERT_CALLER_CX PERL_CALLCONV Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size) __attribute__malloc__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CALLOC PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* statbufp) __attribute__warn_unused_result__; @@ -324,15 +396,19 @@ PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* s PERL_CALLCONV I32 Perl_cast_i32(NV f) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CAST_I32 PERL_CALLCONV IV Perl_cast_iv(NV f) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CAST_IV PERL_CALLCONV U32 Perl_cast_ulong(NV f) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CAST_ULONG PERL_CALLCONV UV Perl_cast_uv(NV f) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CAST_UV PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len); #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ @@ -592,10 +668,12 @@ PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...) PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_CKWARN PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_CKWARN_D PERL_CALLCONV void Perl_clear_defarray(pTHX_ AV* av, bool abandon); #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY \ @@ -616,25 +694,32 @@ PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, c #define PERL_ARGS_ASSERT_CORESUB_OP \ assert(coreargssv) PERL_CALLCONV void Perl_create_eval_scope(pTHX_ OP *retop, U32 flags); +#define PERL_ARGS_ASSERT_CREATE_EVAL_SCOPE PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); +#define PERL_ARGS_ASSERT_CROAK PERL_CALLCONV_NO_RET void Perl_croak_caller(const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,1,2); +#define PERL_ARGS_ASSERT_CROAK_CALLER -PERL_STATIC_INLINE_NO_RET void S_croak_memory_wrap(void) +PERL_STATIC_INLINE_NO_RET void Perl_croak_memory_wrap(void) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_CROAK_MEMORY_WRAP PERL_CALLCONV_NO_RET void Perl_croak_no_mem(void) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_CROAK_NO_MEM PERL_CALLCONV_NO_RET void Perl_croak_no_modify(void) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_CROAK_NO_MODIFY PERL_CALLCONV_NO_RET void Perl_croak_popstack(void) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_CROAK_POPSTACK PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex) __attribute__noreturn__; @@ -647,6 +732,7 @@ PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV *const cv, const char *co assert(cv); assert(params) PERL_CALLCONV regexp_engine const * Perl_current_re_engine(pTHX); +#define PERL_ARGS_ASSERT_CURRENT_RE_ENGINE #ifndef NO_MATHOMS PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o) __attribute__deprecated__ @@ -671,7 +757,6 @@ PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o) PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ assert(ppaddr); assert(xop) -/* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o); */ PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \ assert(cv) @@ -683,11 +768,14 @@ PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target); assert(proto); assert(target) PERL_CALLCONV SV* Perl_cv_const_sv(const CV *const cv) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CV_CONST_SV PERL_CALLCONV SV* Perl_cv_const_sv_or_av(const CV *const cv) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CV_CONST_SV_OR_AV PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv); +#define PERL_ARGS_ASSERT_CV_FORGET_SLAB PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p); #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ assert(cv); assert(ckfun_p); assert(ckobj_p) @@ -723,6 +811,7 @@ PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT* cx); assert(cx) PERL_CALLCONV I32 Perl_cxinc(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CXINC PERL_CALLCONV void Perl_deb(pTHX_ const char* pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2); @@ -730,18 +819,23 @@ PERL_CALLCONV void Perl_deb(pTHX_ const char* pat, ...) assert(pat) PERL_CALLCONV void Perl_deb_stack_all(pTHX); +#define PERL_ARGS_ASSERT_DEB_STACK_ALL PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o); #define PERL_ARGS_ASSERT_DEBOP \ assert(o) PERL_CALLCONV void Perl_debprofdump(pTHX); +#define PERL_ARGS_ASSERT_DEBPROFDUMP PERL_CALLCONV I32 Perl_debstack(pTHX); +#define PERL_ARGS_ASSERT_DEBSTACK PERL_CALLCONV I32 Perl_debstackptrs(pTHX); +#define PERL_ARGS_ASSERT_DEBSTACKPTRS PERL_CALLCONV SV * Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_DEFELEM_TARGET \ assert(sv) PERL_CALLCONV void Perl_delete_eval_scope(pTHX); +#define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE PERL_CALLCONV char* Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen); #define PERL_ARGS_ASSERT_DELIMCPY \ assert(to); assert(toend); assert(from); assert(fromend); assert(retlen) @@ -749,9 +843,11 @@ PERL_CALLCONV char* Perl_delimcpy_no_escape(char* to, const char* toend, const c #define PERL_ARGS_ASSERT_DELIMCPY_NO_ESCAPE \ assert(to); assert(toend); assert(from); assert(fromend); assert(retlen) PERL_CALLCONV void Perl_despatch_signals(pTHX); +#define PERL_ARGS_ASSERT_DESPATCH_SIGNALS PERL_CALLCONV_NO_RET OP* Perl_die(pTHX_ const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); +#define PERL_ARGS_ASSERT_DIE PERL_CALLCONV_NO_RET OP* Perl_die_sv(pTHX_ SV *baseex) __attribute__noreturn__; @@ -779,6 +875,7 @@ PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode) #endif PERL_CALLCONV bool Perl_do_close(pTHX_ GV* gv, bool not_implicit); +#define PERL_ARGS_ASSERT_DO_CLOSE PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full); #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ assert(file) @@ -837,8 +934,10 @@ PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp); assert(fp) PERL_CALLCONV OP* Perl_do_readline(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DO_READLINE PERL_CALLCONV bool Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence); +#define PERL_ARGS_ASSERT_DO_SEEK PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, SSize_t len, SV** sarg); #define PERL_ARGS_ASSERT_DO_SPRINTF \ assert(sv); assert(sarg) @@ -870,13 +969,16 @@ PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin); assert(term) PERL_CALLCONV bool Perl_doing_taint(int argc, char** argv, char** env) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DOING_TAINT PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref); #define PERL_ARGS_ASSERT_DOREF \ assert(o) PERL_CALLCONV void Perl_dounwind(pTHX_ I32 cxix); +#define PERL_ARGS_ASSERT_DOUNWIND PERL_CALLCONV U8 Perl_dowantarray(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DOWANTARRAY PERL_CALLCONV void Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed); #define PERL_ARGS_ASSERT_DRAND48_INIT_R \ @@ -885,8 +987,11 @@ PERL_CALLCONV double Perl_drand48_r(perl_drand48_t *random_state); #define PERL_ARGS_ASSERT_DRAND48_R \ assert(random_state) PERL_CALLCONV void Perl_dump_all(pTHX); +#define PERL_ARGS_ASSERT_DUMP_ALL PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl); +#define PERL_ARGS_ASSERT_DUMP_ALL_PERL PERL_CALLCONV void Perl_dump_eval(pTHX); +#define PERL_ARGS_ASSERT_DUMP_EVAL PERL_CALLCONV void Perl_dump_form(pTHX_ const GV* gv); #define PERL_ARGS_ASSERT_DUMP_FORM \ assert(gv) @@ -911,6 +1016,7 @@ PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* #define PERL_ARGS_ASSERT_DUMP_VINDENT \ assert(file); assert(pat) PERL_CALLCONV STRLEN* Perl_dup_warnings(pTHX_ STRLEN* warnings); +#define PERL_ARGS_ASSERT_DUP_WARNINGS PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv); #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ assert(c); assert(sv) @@ -932,6 +1038,7 @@ PERL_CALLCONV bool Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN #define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED \ assert(name) PERL_CALLCONV SV* Perl_filter_add(pTHX_ filter_t funcp, SV* datasv); +#define PERL_ARGS_ASSERT_FILTER_ADD PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp); #define PERL_ARGS_ASSERT_FILTER_DEL \ assert(funcp) @@ -944,15 +1051,20 @@ PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP* o); #define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ assert(o) PERL_CALLCONV CV * Perl_find_lexical_cv(pTHX_ PADOFFSET off); +#define PERL_ARGS_ASSERT_FIND_LEXICAL_CV PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_FIND_RUNCV PERL_CALLCONV CV* Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_FIND_RUNCV_WHERE PERL_CALLCONV SV* Perl_find_rundefsv(pTHX); +#define PERL_ARGS_ASSERT_FIND_RUNDEFSV PERL_CALLCONV PADOFFSET Perl_find_rundefsvoffset(pTHX) __attribute__deprecated__; +#define PERL_ARGS_ASSERT_FIND_RUNDEFSVOFFSET PERL_CALLCONV char* Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags); #define PERL_ARGS_ASSERT_FIND_SCRIPT \ @@ -973,6 +1085,7 @@ PERL_STATIC_INLINE I32 Perl_foldEQ_locale(const char* a, const char* b, I32 len) assert(a); assert(b) #endif /* PERL_CALLCONV I32 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ +#define PERL_ARGS_ASSERT_FOLDEQ_UTF8 PERL_CALLCONV I32 Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags); #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ assert(s1); assert(s2) @@ -982,7 +1095,9 @@ PERL_CALLCONV char* Perl_form(pTHX_ const char* pat, ...) assert(pat) PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX); +#define PERL_ARGS_ASSERT_FREE_TIED_HV_POOL PERL_CALLCONV void Perl_free_tmps(pTHX); +#define PERL_ARGS_ASSERT_FREE_TMPS PERL_CALLCONV SV* Perl_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e, const bool is_utf8, const char** error_msg) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ @@ -993,6 +1108,7 @@ PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags); assert(name) PERL_CALLCONV void* Perl_get_context(void) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GET_CONTEXT PERL_CALLCONV CV* Perl_get_cv(pTHX_ const char* name, I32 flags); #define PERL_ARGS_ASSERT_GET_CV \ @@ -1012,35 +1128,44 @@ PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags); PERL_CALLCONV const char* Perl_get_no_modify(pTHX) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_GET_NO_MODIFY PERL_CALLCONV char** Perl_get_op_descs(pTHX) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_GET_OP_DESCS PERL_CALLCONV char** Perl_get_op_names(pTHX) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_GET_OP_NAMES PERL_CALLCONV U32* Perl_get_opargs(pTHX) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_GET_OPARGS PERL_CALLCONV PPADDR_t* Perl_get_ppaddr(pTHX) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_GET_PPADDR PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_GET_RE_ARG PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_SV \ assert(name) PERL_CALLCONV MGVTBL* Perl_get_vtbl(pTHX_ int vtbl_id) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GET_VTBL PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_GETCWD_SV \ assert(sv) PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv); +#define PERL_ARGS_ASSERT_GP_FREE PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp); +#define PERL_ARGS_ASSERT_GP_REF PERL_CALLCONV bool Perl_grok_atoUV(const char* pv, UV* valptr, const char** endptr); #define PERL_ARGS_ASSERT_GROK_ATOUV \ assert(pv); assert(valptr) @@ -1069,16 +1194,21 @@ PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flag assert(start); assert(len_p); assert(flags) #ifndef NO_MATHOMS PERL_CALLCONV GV* Perl_gv_AVadd(pTHX_ GV *gv); +#define PERL_ARGS_ASSERT_GV_AVADD #endif #ifndef NO_MATHOMS PERL_CALLCONV GV* Perl_gv_HVadd(pTHX_ GV *gv); +#define PERL_ARGS_ASSERT_GV_HVADD #endif #ifndef NO_MATHOMS PERL_CALLCONV GV* Perl_gv_IOadd(pTHX_ GV* gv); +#define PERL_ARGS_ASSERT_GV_IOADD #endif PERL_CALLCONV GV* Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); +#define PERL_ARGS_ASSERT_GV_ADD_BY_TYPE /* PERL_CALLCONV GV* gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method) __attribute__warn_unused_result__; */ +#define PERL_ARGS_ASSERT_GV_AUTOLOAD4 PERL_CALLCONV GV* Perl_gv_autoload_pv(pTHX_ HV* stash, const char* namepv, U32 flags) __attribute__warn_unused_result__; @@ -1104,6 +1234,7 @@ PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv) assert(gv) PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv); +#define PERL_ARGS_ASSERT_GV_DUMP #ifndef NO_MATHOMS PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv) __attribute__deprecated__; @@ -1126,7 +1257,9 @@ PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const ST #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ assert(name) /* PERL_CALLCONV GV* gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level); */ +#define PERL_ARGS_ASSERT_GV_FETCHMETH /* PERL_CALLCONV GV* gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level); */ +#define PERL_ARGS_ASSERT_GV_FETCHMETH_AUTOLOAD PERL_CALLCONV GV* Perl_gv_fetchmeth_pv(pTHX_ HV* stash, const char* name, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ assert(name) @@ -1188,8 +1321,10 @@ PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* pre assert(sv); assert(gv) PERL_CALLCONV CV* Perl_gv_handler(pTHX_ HV* stash, I32 id) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GV_HANDLER /* PERL_CALLCONV void gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi); */ +#define PERL_ARGS_ASSERT_GV_INIT PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV* gv, HV* stash, const char* name, U32 flags); #define PERL_ARGS_ASSERT_GV_INIT_PV \ assert(gv); assert(name) @@ -1229,15 +1364,18 @@ PERL_CALLCONV SV* Perl_hv_bucket_ratio(pTHX_ HV *hv) assert(hv) PERL_CALLCONV void Perl_hv_clear(pTHX_ HV *hv); +#define PERL_ARGS_ASSERT_HV_CLEAR PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ assert(hv) PERL_CALLCONV void* Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char* key, STRLEN klen, int flags, int action, SV *val, U32 hash); +#define PERL_ARGS_ASSERT_HV_COMMON PERL_CALLCONV void* Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash); #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ assert(key) PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV *const ohv) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_HV_COPY_HINTS_HV PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry); #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ @@ -1376,44 +1514,59 @@ PERL_CALLCONV SV* Perl_hv_scalar(pTHX_ HV *hv) #ifndef NO_MATHOMS PERL_CALLCONV SV** Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); +#define PERL_ARGS_ASSERT_HV_STORE #endif #ifndef NO_MATHOMS PERL_CALLCONV HE* Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); +#define PERL_ARGS_ASSERT_HV_STORE_ENT #endif #ifndef NO_MATHOMS PERL_CALLCONV SV** Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); +#define PERL_ARGS_ASSERT_HV_STORE_FLAGS #endif /* PERL_CALLCONV void hv_undef(pTHX_ HV *hv); */ +#define PERL_ARGS_ASSERT_HV_UNDEF PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); +#define PERL_ARGS_ASSERT_HV_UNDEF_FLAGS /* PERL_CALLCONV I32 ibcmp(pTHX_ const char* a, const char* b, I32 len) __attribute__warn_unused_result__ __attribute__pure__; */ +#define PERL_ARGS_ASSERT_IBCMP /* PERL_CALLCONV I32 ibcmp_locale(pTHX_ const char* a, const char* b, I32 len) __attribute__warn_unused_result__ __attribute__pure__; */ +#define PERL_ARGS_ASSERT_IBCMP_LOCALE /* PERL_CALLCONV I32 ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ +#define PERL_ARGS_ASSERT_IBCMP_UTF8 PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv); #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ assert(argv) PERL_CALLCONV void Perl_init_constants(pTHX); +#define PERL_ARGS_ASSERT_INIT_CONSTANTS PERL_CALLCONV void Perl_init_dbargs(pTHX); +#define PERL_ARGS_ASSERT_INIT_DBARGS PERL_CALLCONV void Perl_init_debugger(pTHX); +#define PERL_ARGS_ASSERT_INIT_DEBUGGER PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn); +#define PERL_ARGS_ASSERT_INIT_I18NL10N #ifndef NO_MATHOMS PERL_CALLCONV int Perl_init_i18nl14n(pTHX_ int printwarn) __attribute__deprecated__; +#define PERL_ARGS_ASSERT_INIT_I18NL14N #endif PERL_CALLCONV void Perl_init_named_cv(pTHX_ CV *cv, OP *nameop); #define PERL_ARGS_ASSERT_INIT_NAMED_CV \ assert(cv); assert(nameop) PERL_CALLCONV void Perl_init_stacks(pTHX); +#define PERL_ARGS_ASSERT_INIT_STACKS PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm); #define PERL_ARGS_ASSERT_INIT_TM \ assert(ptm) PERL_CALLCONV void Perl_init_uniprops(pTHX); +#define PERL_ARGS_ASSERT_INIT_UNIPROPS #ifndef NO_MATHOMS PERL_CALLCONV char* Perl_instr(const char* big, const char* little) __attribute__warn_unused_result__ @@ -1423,8 +1576,10 @@ PERL_CALLCONV char* Perl_instr(const char* big, const char* little) #endif PERL_CALLCONV U32 Perl_intro_my(pTHX); +#define PERL_ARGS_ASSERT_INTRO_MY PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_INVERT PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, GV *gv, bool not_implicit, bool warn_on_fail); #define PERL_ARGS_ASSERT_IO_CLOSE \ @@ -1438,7 +1593,7 @@ PERL_CALLCONV bool Perl_isALNUM_lazy(pTHX_ const char* p) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE Size_t S_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) +PERL_STATIC_INLINE Size_t Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR \ assert(s0); assert(e) @@ -1453,14 +1608,14 @@ PERL_CALLCONV bool Perl_isIDFIRST_lazy(pTHX_ const char* p) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE Size_t S_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) +PERL_STATIC_INLINE Size_t Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR \ assert(s0); assert(e) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE Size_t S_isUTF8_CHAR(const U8 * const s0, const U8 * const e) +PERL_STATIC_INLINE Size_t Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISUTF8_CHAR \ assert(s0); assert(e) @@ -1469,25 +1624,30 @@ PERL_STATIC_INLINE Size_t S_isUTF8_CHAR(const U8 * const s0, const U8 * const e) /* PERL_CALLCONV bool is_ascii_string(const U8* const s, STRLEN len) __attribute__warn_unused_result__ __attribute__pure__; */ +#define PERL_ARGS_ASSERT_IS_ASCII_STRING /* PERL_CALLCONV bool is_c9strict_utf8_string(const U8 *s, STRLEN len) __attribute__warn_unused_result__; */ +#define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING /* PERL_CALLCONV bool is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ +#define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOC #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); +PERL_STATIC_INLINE bool Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); #define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN \ assert(s) #endif /* PERL_CALLCONV bool is_invariant_string(const U8* const s, STRLEN len) __attribute__warn_unused_result__ __attribute__pure__; */ +#define PERL_ARGS_ASSERT_IS_INVARIANT_STRING PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_LVALUE_SUB #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) +PERL_STATIC_INLINE bool Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \ assert(pv); assert(what); assert(op_name) @@ -1495,10 +1655,12 @@ PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, cons /* PERL_CALLCONV bool is_strict_utf8_string(const U8 *s, STRLEN len) __attribute__warn_unused_result__; */ +#define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING /* PERL_CALLCONV bool is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ +#define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOC #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); +PERL_STATIC_INLINE bool Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); #define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN \ assert(s) #endif @@ -1506,36 +1668,42 @@ PERL_STATIC_INLINE bool S_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_ALNUM #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alnum_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_ALNUM_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alnumc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_ALNUMC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alnumc_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_ALNUMC_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alpha(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_ALPHA #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alpha_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_ALPHA_LC #endif #ifndef NO_MATHOMS @@ -1543,6 +1711,7 @@ PERL_CALLCONV bool Perl_is_uni_ascii(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_ASCII #endif #ifndef NO_MATHOMS @@ -1550,6 +1719,7 @@ PERL_CALLCONV bool Perl_is_uni_ascii_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_ASCII_LC #endif #ifndef NO_MATHOMS @@ -1557,6 +1727,7 @@ PERL_CALLCONV bool Perl_is_uni_blank(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_BLANK #endif #ifndef NO_MATHOMS @@ -1564,6 +1735,7 @@ PERL_CALLCONV bool Perl_is_uni_blank_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_BLANK_LC #endif #ifndef NO_MATHOMS @@ -1571,6 +1743,7 @@ PERL_CALLCONV bool Perl_is_uni_cntrl(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_CNTRL #endif #ifndef NO_MATHOMS @@ -1578,78 +1751,91 @@ PERL_CALLCONV bool Perl_is_uni_cntrl_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_CNTRL_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_digit(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_DIGIT #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_digit_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_DIGIT_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_graph(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_GRAPH #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_graph_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_GRAPH_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_idfirst(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_IDFIRST #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_idfirst_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_IDFIRST_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_lower(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_LOWER #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_lower_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_LOWER_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_print(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_PRINT #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_print_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_PRINT_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_punct(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_PUNCT #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_punct_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_PUNCT_LC #endif #ifndef NO_MATHOMS @@ -1657,6 +1843,7 @@ PERL_CALLCONV bool Perl_is_uni_space(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_SPACE #endif #ifndef NO_MATHOMS @@ -1664,18 +1851,21 @@ PERL_CALLCONV bool Perl_is_uni_space_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_SPACE_LC #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_upper(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_UPPER #endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_upper_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_UPPER_LC #endif #ifndef NO_MATHOMS @@ -1683,6 +1873,7 @@ PERL_CALLCONV bool Perl_is_uni_xdigit(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_XDIGIT #endif #ifndef NO_MATHOMS @@ -1690,6 +1881,7 @@ PERL_CALLCONV bool Perl_is_uni_xdigit_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UNI_XDIGIT_LC #endif #ifndef NO_MATHOMS @@ -1744,6 +1936,12 @@ PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ assert(buf); assert(buf_end) #endif +PERL_CALLCONV STRLEN Perl_is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags) + __attribute__warn_unused_result__ + __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER \ + assert(s); assert(e) + #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_cntrl(pTHX_ const U8 *p) __attribute__deprecated__ @@ -1761,9 +1959,11 @@ PERL_CALLCONV bool Perl_is_utf8_digit(pTHX_ const U8 *p) #endif /* PERL_CALLCONV bool is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); */ +#define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_FLAGS /* PERL_CALLCONV bool is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */ +#define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOC_FLAGS #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); +PERL_STATIC_INLINE bool Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); #define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS \ assert(s) #endif @@ -1793,9 +1993,10 @@ PERL_CALLCONV bool Perl_is_utf8_idfirst(pTHX_ const U8 *p) /* PERL_CALLCONV bool is_utf8_invariant_string(const U8* const s, STRLEN len) __attribute__warn_unused_result__; */ +#define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) +PERL_STATIC_INLINE bool Perl_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING_LOC \ assert(s) @@ -1867,9 +2068,10 @@ PERL_CALLCONV bool Perl_is_utf8_space(pTHX_ const U8 *p) /* PERL_CALLCONV bool is_utf8_string(const U8 *s, STRLEN len) __attribute__warn_unused_result__; */ +#define PERL_ARGS_ASSERT_IS_UTF8_STRING #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) +PERL_STATIC_INLINE bool Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_STRING_FLAGS \ assert(s) @@ -1881,13 +2083,14 @@ PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const assert(s); assert(ep) #endif /* PERL_CALLCONV bool is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags); */ +#define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC_FLAGS #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ assert(s) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); +PERL_STATIC_INLINE bool Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS \ assert(s) #endif @@ -1902,9 +2105,10 @@ PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p) /* PERL_CALLCONV bool is_utf8_valid_partial_char(const U8 * const s, const U8 * const e) __attribute__warn_unused_result__ __attribute__pure__; */ +#define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags) +PERL_STATIC_INLINE bool Perl_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS \ assert(s); assert(e) @@ -1937,6 +2141,7 @@ PERL_CALLCONV bool Perl_is_utf8_xidfirst(pTHX_ const U8 *p) PERL_CALLCONV bool Perl_isinfnan(NV nv) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_ISINFNAN PERL_CALLCONV bool Perl_isinfnansv(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_ISINFNANSV \ @@ -1957,19 +2162,27 @@ PERL_CALLCONV void Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 g #define PERL_ARGS_ASSERT_LEAVE_ADJUST_STACKS \ assert(from_sp); assert(to_sp) PERL_CALLCONV void Perl_leave_scope(pTHX_ I32 base); +#define PERL_ARGS_ASSERT_LEAVE_SCOPE PERL_CALLCONV bool Perl_lex_bufutf8(pTHX); +#define PERL_ARGS_ASSERT_LEX_BUFUTF8 PERL_CALLCONV void Perl_lex_discard_to(pTHX_ char* ptr); #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ assert(ptr) PERL_CALLCONV char* Perl_lex_grow_linestr(pTHX_ STRLEN len); +#define PERL_ARGS_ASSERT_LEX_GROW_LINESTR PERL_CALLCONV bool Perl_lex_next_chunk(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_LEX_NEXT_CHUNK PERL_CALLCONV I32 Perl_lex_peek_unichar(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_LEX_PEEK_UNICHAR PERL_CALLCONV void Perl_lex_read_space(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_LEX_READ_SPACE PERL_CALLCONV void Perl_lex_read_to(pTHX_ char* ptr); #define PERL_ARGS_ASSERT_LEX_READ_TO \ assert(ptr) PERL_CALLCONV I32 Perl_lex_read_unichar(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_LEX_READ_UNICHAR PERL_CALLCONV void Perl_lex_start(pTHX_ SV* line, PerlIO *rsfp, U32 flags); +#define PERL_ARGS_ASSERT_LEX_START PERL_CALLCONV void Perl_lex_stuff_pv(pTHX_ const char* pv, U32 flags); #define PERL_ARGS_ASSERT_LEX_STUFF_PV \ assert(pv) @@ -1983,6 +2196,7 @@ PERL_CALLCONV void Perl_lex_unstuff(pTHX_ char* ptr); #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ assert(ptr) PERL_CALLCONV OP* Perl_list(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_LIST PERL_CALLCONV void Perl_load_module(pTHX_ U32 flags, SV* name, SV* ver, ...); #define PERL_ARGS_ASSERT_LOAD_MODULE \ assert(name) @@ -2022,6 +2236,7 @@ PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV* sv, MAGIC *mg, SV *nsv, c #define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \ assert(sv); assert(mg); assert(nsv) PERL_CALLCONV void Perl_magic_dump(pTHX_ const MAGIC *mg); +#define PERL_ARGS_ASSERT_MAGIC_DUMP PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg); #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \ assert(sv); assert(mg) @@ -2160,8 +2375,10 @@ PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV* sv, MAGIC* mg); PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes) __attribute__malloc__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_MALLOC PERL_CALLCONV I32 * Perl_markstack_grow(pTHX); +#define PERL_ARGS_ASSERT_MARKSTACK_GROW PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_MESS \ @@ -2171,6 +2388,7 @@ PERL_CALLCONV SV* Perl_mess_sv(pTHX_ SV* basemsg, bool consume); #define PERL_ARGS_ASSERT_MESS_SV \ assert(basemsg) PERL_CALLCONV Free_t Perl_mfree(Malloc_t where); +#define PERL_ARGS_ASSERT_MFREE PERL_CALLCONV int Perl_mg_clear(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_MG_CLEAR \ assert(sv) @@ -2179,6 +2397,7 @@ PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) assert(sv); assert(nsv) PERL_CALLCONV MAGIC* Perl_mg_find(const SV* sv, int type) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_MG_FIND PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv) __attribute__warn_unused_result__; @@ -2187,6 +2406,7 @@ PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv) PERL_CALLCONV MAGIC* Perl_mg_findext(const SV* sv, int type, const MGVTBL *vtbl) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_MG_FINDEXT PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_MG_FREE \ @@ -2221,7 +2441,9 @@ PERL_CALLCONV void Perl_mini_mktime(struct tm *ptm); #define PERL_ARGS_ASSERT_MINI_MKTIME \ assert(ptm) PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len); +#define PERL_ARGS_ASSERT_MODE_FROM_DISCIPLINE PERL_CALLCONV void * Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size); +#define PERL_ARGS_ASSERT_MORE_BODIES PERL_CALLCONV const char* Perl_moreswitches(pTHX_ const char* s); #define PERL_ARGS_ASSERT_MORESWITCHES \ assert(s) @@ -2274,19 +2496,27 @@ PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs); #define PERL_ARGS_ASSERT_MY_ATTRS \ assert(o) PERL_CALLCONV void Perl_my_clearenv(pTHX); +#define PERL_ARGS_ASSERT_MY_CLEARENV PERL_CALLCONV int Perl_my_dirfd(DIR* dir); +#define PERL_ARGS_ASSERT_MY_DIRFD PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_MY_EXIT PERL_CALLCONV_NO_RET void Perl_my_failure_exit(pTHX) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_MY_FAILURE_EXIT PERL_CALLCONV I32 Perl_my_fflush_all(pTHX); +#define PERL_ARGS_ASSERT_MY_FFLUSH_ALL PERL_CALLCONV Pid_t Perl_my_fork(void); +#define PERL_ARGS_ASSERT_MY_FORK #ifndef NO_MATHOMS PERL_CALLCONV I32 Perl_my_lstat(pTHX); +#define PERL_ARGS_ASSERT_MY_LSTAT #endif PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags); +#define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS PERL_CALLCONV int Perl_my_mkostemp_cloexec(char *templte, int flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_MY_MKOSTEMP_CLOEXEC \ @@ -2301,17 +2531,22 @@ PERL_CALLCONV PerlIO* Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** ar #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ assert(mode); assert(args) PERL_CALLCONV void Perl_my_setenv(pTHX_ const char* nam, const char* val); +#define PERL_ARGS_ASSERT_MY_SETENV PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...) __attribute__format__(__printf__,3,4); #define PERL_ARGS_ASSERT_MY_SNPRINTF \ assert(buffer); assert(format) PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); +#define PERL_ARGS_ASSERT_MY_SOCKETPAIR #ifndef NO_MATHOMS PERL_CALLCONV I32 Perl_my_stat(pTHX); +#define PERL_ARGS_ASSERT_MY_STAT #endif PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags); +#define PERL_ARGS_ASSERT_MY_STAT_FLAGS PERL_CALLCONV char* Perl_my_strerror(pTHX_ const int errnum); +#define PERL_ARGS_ASSERT_MY_STRERROR PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst) __attribute__format__(__strftime__,pTHX_1,0); #define PERL_ARGS_ASSERT_MY_STRFTIME \ @@ -2323,25 +2558,34 @@ PERL_CALLCONV NV Perl_my_strtod(const char * const s, char ** e) assert(s) PERL_CALLCONV void Perl_my_unexec(pTHX); +#define PERL_ARGS_ASSERT_MY_UNEXEC PERL_CALLCONV int Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap); #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ assert(buffer); assert(format) PERL_CALLCONV OP* Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block); +#define PERL_ARGS_ASSERT_NEWANONATTRSUB PERL_CALLCONV OP* Perl_newANONHASH(pTHX_ OP* o) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWANONHASH PERL_CALLCONV OP* Perl_newANONLIST(pTHX_ OP* o) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWANONLIST PERL_CALLCONV OP* Perl_newANONSUB(pTHX_ I32 floor, OP* proto, OP* block); +#define PERL_ARGS_ASSERT_NEWANONSUB PERL_CALLCONV OP* Perl_newASSIGNOP(pTHX_ I32 flags, OP* left, I32 optype, OP* right) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWASSIGNOP /* PERL_CALLCONV CV* newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */ +#define PERL_ARGS_ASSERT_NEWATTRSUB PERL_CALLCONV CV* Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv); +#define PERL_ARGS_ASSERT_NEWATTRSUB_X #ifndef NO_MATHOMS PERL_CALLCONV AV* Perl_newAV(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWAV #endif PERL_CALLCONV OP* Perl_newAVREF(pTHX_ OP* o) @@ -2351,6 +2595,7 @@ PERL_CALLCONV OP* Perl_newAVREF(pTHX_ OP* o) PERL_CALLCONV OP* Perl_newBINOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWBINOP PERL_CALLCONV OP* Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* falseop) __attribute__warn_unused_result__; @@ -2358,14 +2603,19 @@ PERL_CALLCONV OP* Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* fal assert(first) PERL_CALLCONV CV* Perl_newCONSTSUB(pTHX_ HV* stash, const char* name, SV* sv); +#define PERL_ARGS_ASSERT_NEWCONSTSUB PERL_CALLCONV CV* Perl_newCONSTSUB_flags(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags, SV* sv); +#define PERL_ARGS_ASSERT_NEWCONSTSUB_FLAGS PERL_CALLCONV OP* Perl_newCVREF(pTHX_ I32 flags, OP* o) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWCVREF PERL_CALLCONV OP* Perl_newDEFSVOP(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWDEFSVOP PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); +#define PERL_ARGS_ASSERT_NEWFORM PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWFOROP \ @@ -2386,8 +2636,10 @@ PERL_CALLCONV OP* Perl_newGVOP(pTHX_ I32 type, I32 flags, GV* gv) PERL_CALLCONV OP* Perl_newGVREF(pTHX_ I32 type, OP* o) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWGVREF /* PERL_CALLCONV GV* newGVgen(pTHX_ const char* pack); */ +#define PERL_ARGS_ASSERT_NEWGVGEN PERL_CALLCONV GV* Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ @@ -2396,6 +2648,7 @@ PERL_CALLCONV GV* Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags) #ifndef NO_MATHOMS PERL_CALLCONV HV* Perl_newHV(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWHV #endif PERL_CALLCONV OP* Perl_newHVREF(pTHX_ OP* o) @@ -2405,14 +2658,17 @@ PERL_CALLCONV OP* Perl_newHVREF(pTHX_ OP* o) PERL_CALLCONV HV* Perl_newHVhv(pTHX_ HV *hv) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWHVHV #ifndef NO_MATHOMS PERL_CALLCONV IO* Perl_newIO(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWIO #endif PERL_CALLCONV OP* Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWLISTOP PERL_CALLCONV OP* Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) __attribute__warn_unused_result__; @@ -2426,6 +2682,7 @@ PERL_CALLCONV OP* Perl_newLOOPEX(pTHX_ I32 type, OP* label) PERL_CALLCONV OP* Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP* block) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWLOOPOP PERL_CALLCONV OP* Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP* dynamic_meth) __attribute__warn_unused_result__; @@ -2442,12 +2699,15 @@ PERL_CALLCONV CV * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, O assert(o) PERL_CALLCONV OP* Perl_newNULLLIST(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWNULLLIST PERL_CALLCONV OP* Perl_newOP(pTHX_ I32 optype, I32 flags) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWOP PERL_CALLCONV PADNAMELIST * Perl_newPADNAMELIST(size_t max) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWPADNAMELIST PERL_CALLCONV PADNAME * Perl_newPADNAMEouter(PADNAME *outer) __attribute__warn_unused_result__; @@ -2461,12 +2721,14 @@ PERL_CALLCONV PADNAME * Perl_newPADNAMEpvn(const char *s, STRLEN len) PERL_CALLCONV OP* Perl_newPMOP(pTHX_ I32 type, I32 flags) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWPMOP PERL_CALLCONV void Perl_newPROG(pTHX_ OP* o); #define PERL_ARGS_ASSERT_NEWPROG \ assert(o) PERL_CALLCONV OP* Perl_newPVOP(pTHX_ I32 type, I32 flags, char* pv) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWPVOP PERL_CALLCONV OP* Perl_newRANGE(pTHX_ I32 flags, OP* left, OP* right) __attribute__warn_unused_result__; @@ -2485,18 +2747,22 @@ PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const tmpRef) PERL_CALLCONV OP* Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSLICEOP PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSTATEOP PERL_CALLCONV CV* Perl_newSTUB(pTHX_ GV *gv, bool fake); #define PERL_ARGS_ASSERT_NEWSTUB \ assert(gv) #ifndef NO_MATHOMS PERL_CALLCONV CV* Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); +#define PERL_ARGS_ASSERT_NEWSUB #endif PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSV PERL_CALLCONV OP* Perl_newSVOP(pTHX_ I32 type, I32 flags, SV* sv) __attribute__warn_unused_result__; @@ -2510,6 +2776,7 @@ PERL_CALLCONV OP* Perl_newSVREF(pTHX_ OP* o) PERL_CALLCONV SV* Perl_newSV_type(pTHX_ const svtype type) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSV_TYPE PERL_CALLCONV SV* Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) __attribute__warn_unused_result__; @@ -2518,18 +2785,23 @@ PERL_CALLCONV SV* Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *const hek) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVHEK PERL_CALLCONV SV* Perl_newSViv(pTHX_ const IV i) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVIV PERL_CALLCONV SV* Perl_newSVnv(pTHX_ const NV n) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVNV PERL_CALLCONV SV* Perl_newSVpv(pTHX_ const char *const s, const STRLEN len) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVPV PERL_CALLCONV SV* Perl_newSVpv_share(pTHX_ const char* s, U32 hash) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVPV_SHARE PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...) __attribute__warn_unused_result__ @@ -2539,12 +2811,15 @@ PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...) PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const buffer, const STRLEN len) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVPVN PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVPVN_FLAGS PERL_CALLCONV SV* Perl_newSVpvn_share(pTHX_ const char* s, I32 len, U32 hash) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVPVN_SHARE PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV *const rv, const char *const classname); #define PERL_ARGS_ASSERT_NEWSVRV \ @@ -2552,22 +2827,28 @@ PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV *const rv, const char *const classname); #ifndef NO_MATHOMS PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV *const old) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVSV #endif PERL_CALLCONV SV* Perl_newSVsv_flags(pTHX_ SV *const old, I32 flags) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVSV_FLAGS /* PERL_CALLCONV SV* newSVsv_nomg(pTHX_ SV *const old) __attribute__warn_unused_result__; */ +#define PERL_ARGS_ASSERT_NEWSVSV_NOMG PERL_CALLCONV SV* Perl_newSVuv(pTHX_ const UV u) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVUV PERL_CALLCONV OP* Perl_newUNOP(pTHX_ I32 type, I32 flags, OP* first) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWUNOP PERL_CALLCONV OP* Perl_newUNOP_AUX(pTHX_ I32 type, I32 flags, OP* first, UNOP_AUX_item *aux) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWUNOP_AUX PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block) __attribute__warn_unused_result__; @@ -2576,6 +2857,7 @@ PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block) PERL_CALLCONV OP* Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, OP* expr, OP* block, OP* cont, I32 has_my) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWWHILEOP PERL_CALLCONV CV* Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename); #define PERL_ARGS_ASSERT_NEWXS \ @@ -2591,6 +2873,7 @@ PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUB assert(subaddr) PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEW_STACKINFO PERL_CALLCONV SV* Perl_new_version(pTHX_ SV *ver); #define PERL_ARGS_ASSERT_NEW_VERSION \ @@ -2616,7 +2899,9 @@ PERL_CALLCONV_NO_RET void Perl_noperl_die(const char* pat, ...) assert(pat) PERL_CALLCONV int Perl_nothreadhook(pTHX); +#define PERL_ARGS_ASSERT_NOTHREADHOOK PERL_CALLCONV void Perl_notify_parser_that_changed_to_utf8(pTHX); +#define PERL_ARGS_ASSERT_NOTIFY_PARSER_THAT_CHANGED_TO_UTF8 PERL_CALLCONV OP* Perl_oopsAV(pTHX_ OP* o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_OOPSAV \ @@ -2628,8 +2913,11 @@ PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o) assert(o) PERL_CALLCONV OP* Perl_op_append_elem(pTHX_ I32 optype, OP* first, OP* last); +#define PERL_ARGS_ASSERT_OP_APPEND_ELEM PERL_CALLCONV OP* Perl_op_append_list(pTHX_ I32 optype, OP* first, OP* last); +#define PERL_ARGS_ASSERT_OP_APPEND_LIST PERL_CALLCONV OPclass Perl_op_class(pTHX_ const OP *o); +#define PERL_ARGS_ASSERT_OP_CLASS PERL_CALLCONV void Perl_op_clear(pTHX_ OP* o); #define PERL_ARGS_ASSERT_OP_CLEAR \ assert(o) @@ -2638,16 +2926,20 @@ PERL_CALLCONV OP* Perl_op_contextualize(pTHX_ OP* o, I32 context); assert(o) PERL_CALLCONV OP* Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP* o) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_OP_CONVERT_LIST PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o); #define PERL_ARGS_ASSERT_OP_DUMP \ assert(o) PERL_CALLCONV void Perl_op_free(pTHX_ OP* arg); +#define PERL_ARGS_ASSERT_OP_FREE PERL_CALLCONV OP* Perl_op_linklist(pTHX_ OP *o); #define PERL_ARGS_ASSERT_OP_LINKLIST \ assert(o) /* PERL_CALLCONV OP* op_lvalue(pTHX_ OP* o, I32 type); */ +#define PERL_ARGS_ASSERT_OP_LVALUE PERL_CALLCONV OP* Perl_op_lvalue_flags(pTHX_ OP* o, I32 type, U32 flags); +#define PERL_ARGS_ASSERT_OP_LVALUE_FLAGS PERL_CALLCONV void Perl_op_null(pTHX_ OP* o); #define PERL_ARGS_ASSERT_OP_NULL \ assert(o) @@ -2655,11 +2947,17 @@ PERL_CALLCONV OP* Perl_op_parent(OP *o); #define PERL_ARGS_ASSERT_OP_PARENT \ assert(o) PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last); +#define PERL_ARGS_ASSERT_OP_PREPEND_ELEM PERL_CALLCONV void Perl_op_refcnt_lock(pTHX); +#define PERL_ARGS_ASSERT_OP_REFCNT_LOCK PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX); +#define PERL_ARGS_ASSERT_OP_REFCNT_UNLOCK PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_OP_SCOPE PERL_CALLCONV OP* Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert); +#define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_OP_UNSCOPE PERL_CALLCONV void Perl_optimize_optree(pTHX_ OP* o); #define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE \ assert(o) @@ -2693,10 +2991,13 @@ PERL_CALLCONV void Perl_pad_add_weakref(pTHX_ CV* func); #define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF \ assert(func) PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype); +#define PERL_ARGS_ASSERT_PAD_ALLOC PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full); +#define PERL_ARGS_ASSERT_PAD_BLOCK_START #ifndef NO_MATHOMS PERL_CALLCONV HV* Perl_pad_compname_type(pTHX_ const PADOFFSET po) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PAD_COMPNAME_TYPE #endif PERL_CALLCONV PADOFFSET Perl_pad_findmy_pv(pTHX_ const char* name, U32 flags); @@ -2712,15 +3013,20 @@ PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \ assert(padlist); assert(old_cv); assert(new_cv) PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po); +#define PERL_ARGS_ASSERT_PAD_FREE PERL_CALLCONV OP * Perl_pad_leavemy(pTHX); +#define PERL_ARGS_ASSERT_PAD_LEAVEMY PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PAD_NEW PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth); #define PERL_ARGS_ASSERT_PAD_PUSH \ assert(padlist) PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust); +#define PERL_ARGS_ASSERT_PAD_SWIPE PERL_CALLCONV void Perl_pad_tidy(pTHX_ padtidy_type type); +#define PERL_ARGS_ASSERT_PAD_TIDY PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val); #define PERL_ARGS_ASSERT_PADLIST_STORE \ assert(padlist) @@ -2739,15 +3045,25 @@ PERL_CALLCONV PADNAME ** Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t #define PERL_ARGS_ASSERT_PADNAMELIST_STORE \ assert(pnl) PERL_CALLCONV OP* Perl_parse_arithexpr(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_ARITHEXPR PERL_CALLCONV OP* Perl_parse_barestmt(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_BARESTMT PERL_CALLCONV OP* Perl_parse_block(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_BLOCK PERL_CALLCONV OP* Perl_parse_fullexpr(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_FULLEXPR PERL_CALLCONV OP* Perl_parse_fullstmt(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_FULLSTMT PERL_CALLCONV SV* Perl_parse_label(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_LABEL PERL_CALLCONV OP* Perl_parse_listexpr(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_LISTEXPR PERL_CALLCONV OP* Perl_parse_stmtseq(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_STMTSEQ PERL_CALLCONV OP* Perl_parse_subsignature(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_SUBSIGNATURE PERL_CALLCONV OP* Perl_parse_termexpr(pTHX_ U32 flags); +#define PERL_ARGS_ASSERT_PARSE_TERMEXPR PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt); #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ assert(popt) @@ -2755,7 +3071,9 @@ PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser); #define PERL_ARGS_ASSERT_PARSER_FREE \ assert(parser) PERL_CALLCONV void Perl_peep(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_PEEP PERL_CALLCONV PerlInterpreter* perl_alloc(void); +#define PERL_ARGS_ASSERT_PERL_ALLOC PERL_CALLCONV void perl_construct(PerlInterpreter *my_perl); #define PERL_ARGS_ASSERT_PERL_CONSTRUCT \ assert(my_perl) @@ -2772,10 +3090,12 @@ PERL_CALLCONV int perl_run(PerlInterpreter *my_perl); #define PERL_ARGS_ASSERT_PERL_RUN \ assert(my_perl) PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm); +#define PERL_ARGS_ASSERT_PMOP_DUMP PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor); #define PERL_ARGS_ASSERT_PMRUNTIME \ assert(o); assert(expr) PERL_CALLCONV void Perl_pop_scope(pTHX); +#define PERL_ARGS_ASSERT_POP_SCOPE PERL_CALLCONV void Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...); #define PERL_ARGS_ASSERT_POPULATE_ISA \ assert(name) @@ -2786,6 +3106,7 @@ PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char #define PERL_ARGS_ASSERT_PREGEXEC \ assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer) PERL_CALLCONV void Perl_pregfree(pTHX_ REGEXP* r); +#define PERL_ARGS_ASSERT_PREGFREE PERL_CALLCONV void Perl_pregfree2(pTHX_ REGEXP *rx); #define PERL_ARGS_ASSERT_PREGFREE2 \ assert(rx) @@ -2794,6 +3115,7 @@ PERL_CALLCONV const char* Perl_prescan_version(pTHX_ const char *s, bool strict, assert(s) PERL_CALLCONV void Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl) __attribute__deprecated__; +#define PERL_ARGS_ASSERT_PTR_TABLE_CLEAR PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void *const sv) __attribute__warn_unused_result__; @@ -2801,8 +3123,10 @@ PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void assert(tbl) PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl); +#define PERL_ARGS_ASSERT_PTR_TABLE_FREE PERL_CALLCONV PTR_TBL_t* Perl_ptr_table_new(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PTR_TABLE_NEW PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl); #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ @@ -2811,6 +3135,7 @@ PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t *const tbl, const void * #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ assert(tbl); assert(newsv) PERL_CALLCONV void Perl_push_scope(pTHX); +#define PERL_ARGS_ASSERT_PUSH_SCOPE PERL_CALLCONV char* Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim); #define PERL_ARGS_ASSERT_PV_DISPLAY \ assert(dsv); assert(pv) @@ -2840,14 +3165,19 @@ PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_cou assert(eng) PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_REALLOC PERL_CALLCONV void Perl_reentrant_free(pTHX); +#define PERL_ARGS_ASSERT_REENTRANT_FREE PERL_CALLCONV void Perl_reentrant_init(pTHX); +#define PERL_ARGS_ASSERT_REENTRANT_INIT PERL_CALLCONV void* Perl_reentrant_retry(const char *f, ...); #define PERL_ARGS_ASSERT_REENTRANT_RETRY \ assert(f) PERL_CALLCONV void Perl_reentrant_size(pTHX); +#define PERL_ARGS_ASSERT_REENTRANT_SIZE PERL_CALLCONV HV * Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags); +#define PERL_ARGS_ASSERT_REFCOUNTED_HE_CHAIN_2HV PERL_CALLCONV SV * Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \ assert(key) @@ -2858,7 +3188,9 @@ PERL_CALLCONV SV * Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \ assert(key) PERL_CALLCONV void Perl_refcounted_he_free(pTHX_ struct refcounted_he *he); +#define PERL_ARGS_ASSERT_REFCOUNTED_HE_FREE PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he); +#define PERL_ARGS_ASSERT_REFCOUNTED_HE_INC PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \ assert(key) @@ -2917,15 +3249,20 @@ PERL_CALLCONV void Perl_regfree_internal(pTHX_ REGEXP *const rx); #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ assert(rx) PERL_CALLCONV void Perl_reginitcolors(pTHX); +#define PERL_ARGS_ASSERT_REGINITCOLORS PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_REGNEXT PERL_CALLCONV void Perl_repeatcpy(char* to, const char* from, I32 len, IV count); #define PERL_ARGS_ASSERT_REPEATCPY \ assert(to); assert(from) PERL_CALLCONV void Perl_report_evil_fh(pTHX_ const GV *gv); +#define PERL_ARGS_ASSERT_REPORT_EVIL_FH PERL_CALLCONV void Perl_report_uninit(pTHX_ const SV *uninit_sv); +#define PERL_ARGS_ASSERT_REPORT_UNINIT PERL_CALLCONV void Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have); +#define PERL_ARGS_ASSERT_REPORT_WRONGWAY_FH PERL_CALLCONV void Perl_require_pv(pTHX_ const char* pv); #define PERL_ARGS_ASSERT_REQUIRE_PV \ assert(pv) @@ -2936,14 +3273,20 @@ PERL_CALLCONV char* Perl_rninstr(const char* big, const char* bigend, const char assert(big); assert(bigend); assert(little); assert(lend) PERL_CALLCONV void Perl_rpeep(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_RPEEP PERL_CALLCONV Sighandler_t Perl_rsignal(pTHX_ int i, Sighandler_t t); +#define PERL_ARGS_ASSERT_RSIGNAL PERL_CALLCONV int Perl_rsignal_restore(pTHX_ int i, Sigsave_t* t); +#define PERL_ARGS_ASSERT_RSIGNAL_RESTORE PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t* save); #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ assert(save) PERL_CALLCONV Sighandler_t Perl_rsignal_state(pTHX_ int i); +#define PERL_ARGS_ASSERT_RSIGNAL_STATE PERL_CALLCONV int Perl_runops_debug(pTHX); +#define PERL_ARGS_ASSERT_RUNOPS_DEBUG PERL_CALLCONV int Perl_runops_standard(pTHX); +#define PERL_ARGS_ASSERT_RUNOPS_STANDARD PERL_CALLCONV CV* Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags); #define PERL_ARGS_ASSERT_RV2CV_OP_CV \ assert(cvop) @@ -2953,14 +3296,18 @@ PERL_CALLCONV void Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx); PERL_CALLCONV Malloc_t Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) __attribute__malloc__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SAFESYSCALLOC PERL_CALLCONV Free_t Perl_safesysfree(Malloc_t where); +#define PERL_ARGS_ASSERT_SAFESYSFREE PERL_CALLCONV Malloc_t Perl_safesysmalloc(MEM_SIZE nbytes) __attribute__malloc__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SAFESYSMALLOC PERL_CALLCONV Malloc_t Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SAFESYSREALLOC PERL_CALLCONV void Perl_save_I16(pTHX_ I16* intp); #define PERL_ARGS_ASSERT_SAVE_I16 \ @@ -2974,11 +3321,13 @@ PERL_CALLCONV void Perl_save_I8(pTHX_ I8* bytep); PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, SSize_t key); #define PERL_ARGS_ASSERT_SAVE_ADELETE \ assert(av) -/* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr); */ +/* PERL_CALLCONV void save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr); */ +#define PERL_ARGS_ASSERT_SAVE_AELEM PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, SSize_t idx, SV **sptr, const U32 flags); #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ assert(av); assert(sptr) PERL_CALLCONV I32 Perl_save_alloc(pTHX_ I32 size, I32 pad); +#define PERL_ARGS_ASSERT_SAVE_ALLOC PERL_CALLCONV void Perl_save_aptr(pTHX_ AV** aptr); #define PERL_ARGS_ASSERT_SAVE_APTR \ assert(aptr) @@ -2998,14 +3347,18 @@ PERL_CALLCONV void Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ assert(p) PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p); +#define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR_X #ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_freeop(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_SAVE_FREEOP #endif #ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_freepv(pTHX_ char* pv); +#define PERL_ARGS_ASSERT_SAVE_FREEPV #endif #ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_freesv(pTHX_ SV* sv); +#define PERL_ARGS_ASSERT_SAVE_FREESV #endif PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char** str); #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ @@ -3022,11 +3375,13 @@ PERL_CALLCONV HV* Perl_save_hash(pTHX_ GV* gv); PERL_CALLCONV void Perl_save_hdelete(pTHX_ HV *hv, SV *keysv); #define PERL_ARGS_ASSERT_SAVE_HDELETE \ assert(hv); assert(keysv) -/* PERL_CALLCONV void Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ +/* PERL_CALLCONV void save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ +#define PERL_ARGS_ASSERT_SAVE_HELEM PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags); #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ assert(hv); assert(key); assert(sptr) PERL_CALLCONV void Perl_save_hints(pTHX); +#define PERL_ARGS_ASSERT_SAVE_HINTS PERL_CALLCONV void Perl_save_hptr(pTHX_ HV** hptr); #define PERL_ARGS_ASSERT_SAVE_HPTR \ assert(hptr) @@ -3067,15 +3422,21 @@ PERL_CALLCONV void Perl_save_nogv(pTHX_ GV* gv) #ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_op(pTHX); +#define PERL_ARGS_ASSERT_SAVE_OP #endif PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); +#define PERL_ARGS_ASSERT_SAVE_PADSV_AND_MORTALIZE PERL_CALLCONV void Perl_save_pptr(pTHX_ char** pptr); #define PERL_ARGS_ASSERT_SAVE_PPTR \ assert(pptr) PERL_CALLCONV void Perl_save_pushi32ptr(pTHX_ const I32 i, void *const ptr, const int type); +#define PERL_ARGS_ASSERT_SAVE_PUSHI32PTR PERL_CALLCONV void Perl_save_pushptr(pTHX_ void *const ptr, const int type); +#define PERL_ARGS_ASSERT_SAVE_PUSHPTR PERL_CALLCONV void Perl_save_pushptrptr(pTHX_ void *const ptr1, void *const ptr2, const int type); +#define PERL_ARGS_ASSERT_SAVE_PUSHPTRPTR PERL_CALLCONV void Perl_save_re_context(pTHX); +#define PERL_ARGS_ASSERT_SAVE_RE_CONTEXT PERL_CALLCONV SV* Perl_save_scalar(pTHX_ GV* gv); #define PERL_ARGS_ASSERT_SAVE_SCALAR \ assert(gv) @@ -3100,18 +3461,22 @@ PERL_CALLCONV void Perl_save_vptr(pTHX_ void *ptr); PERL_CALLCONV char* Perl_savepv(pTHX_ const char* pv) __attribute__malloc__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SAVEPV PERL_CALLCONV char* Perl_savepvn(pTHX_ const char* pv, I32 len) __attribute__malloc__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SAVEPVN PERL_CALLCONV char* Perl_savesharedpv(pTHX_ const char* pv) __attribute__malloc__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SAVESHAREDPV PERL_CALLCONV char* Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len) __attribute__malloc__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SAVESHAREDPVN PERL_CALLCONV char* Perl_savesharedsvpv(pTHX_ SV *sv) __attribute__malloc__ @@ -3120,7 +3485,9 @@ PERL_CALLCONV char* Perl_savesharedsvpv(pTHX_ SV *sv) assert(sv) PERL_CALLCONV void Perl_savestack_grow(pTHX); +#define PERL_ARGS_ASSERT_SAVESTACK_GROW PERL_CALLCONV void Perl_savestack_grow_cnt(pTHX_ I32 need); +#define PERL_ARGS_ASSERT_SAVESTACK_GROW_CNT PERL_CALLCONV char* Perl_savesvpv(pTHX_ SV* sv) __attribute__malloc__ __attribute__warn_unused_result__; @@ -3128,8 +3495,11 @@ PERL_CALLCONV char* Perl_savesvpv(pTHX_ SV* sv) assert(sv) PERL_CALLCONV void Perl_savetmps(pTHX); +#define PERL_ARGS_ASSERT_SAVETMPS PERL_CALLCONV OP* Perl_sawparens(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_SAWPARENS PERL_CALLCONV OP* Perl_scalar(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_SCALAR PERL_CALLCONV OP* Perl_scalarvoid(pTHX_ OP* o); #define PERL_ARGS_ASSERT_SCALARVOID \ assert(o) @@ -3160,20 +3530,29 @@ PERL_CALLCONV char* Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, in #define PERL_ARGS_ASSERT_SCAN_WORD \ assert(s); assert(dest); assert(slp) PERL_CALLCONV U32 Perl_seed(pTHX); +#define PERL_ARGS_ASSERT_SEED PERL_CALLCONV void Perl_set_caret_X(pTHX); +#define PERL_ARGS_ASSERT_SET_CARET_X PERL_CALLCONV void Perl_set_context(void *t); #define PERL_ARGS_ASSERT_SET_CONTEXT \ assert(t) PERL_CALLCONV void Perl_set_numeric_standard(pTHX); +#define PERL_ARGS_ASSERT_SET_NUMERIC_STANDARD PERL_CALLCONV void Perl_set_numeric_underlying(pTHX); +#define PERL_ARGS_ASSERT_SET_NUMERIC_UNDERLYING PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv); #define PERL_ARGS_ASSERT_SETDEFOUT \ assert(gv) PERL_CALLCONV void Perl_setfd_cloexec(int fd); +#define PERL_ARGS_ASSERT_SETFD_CLOEXEC PERL_CALLCONV void Perl_setfd_cloexec_for_nonsysfd(pTHX_ int fd); +#define PERL_ARGS_ASSERT_SETFD_CLOEXEC_FOR_NONSYSFD PERL_CALLCONV void Perl_setfd_cloexec_or_inhexec_by_sysfdness(pTHX_ int fd); +#define PERL_ARGS_ASSERT_SETFD_CLOEXEC_OR_INHEXEC_BY_SYSFDNESS PERL_CALLCONV void Perl_setfd_inhexec(int fd); +#define PERL_ARGS_ASSERT_SETFD_INHEXEC PERL_CALLCONV void Perl_setfd_inhexec_for_sysfd(pTHX_ int fd); +#define PERL_ARGS_ASSERT_SETFD_INHEXEC_FOR_SYSFD PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, SSize_t len, U32 hash); #define PERL_ARGS_ASSERT_SHARE_HEK \ assert(str) @@ -3195,6 +3574,7 @@ PERL_CALLCONV PerlIO* Perl_start_glob(pTHX_ SV *tmpglob, IO *io); #define PERL_ARGS_ASSERT_START_GLOB \ assert(tmpglob); assert(io) PERL_CALLCONV I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags); +#define PERL_ARGS_ASSERT_START_SUBPARSE PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_STR_TO_VERSION \ @@ -3226,6 +3606,7 @@ PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ assert(sv) PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_2MORTAL PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv); #define PERL_ARGS_ASSERT_SV_2NUM \ assert(sv) @@ -3343,14 +3724,20 @@ PERL_CALLCONV void Perl_sv_chop(pTHX_ SV *const sv, const char *const ptr); #define PERL_ARGS_ASSERT_SV_CHOP \ assert(sv) PERL_CALLCONV I32 Perl_sv_clean_all(pTHX); +#define PERL_ARGS_ASSERT_SV_CLEAN_ALL PERL_CALLCONV void Perl_sv_clean_objs(pTHX); +#define PERL_ARGS_ASSERT_SV_CLEAN_OBJS PERL_CALLCONV void Perl_sv_clear(pTHX_ SV *const orig_sv); #define PERL_ARGS_ASSERT_SV_CLEAR \ assert(orig_sv) PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2); +#define PERL_ARGS_ASSERT_SV_CMP PERL_CALLCONV I32 Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); +#define PERL_ARGS_ASSERT_SV_CMP_FLAGS PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2); +#define PERL_ARGS_ASSERT_SV_CMP_LOCALE PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); +#define PERL_ARGS_ASSERT_SV_CMP_LOCALE_FLAGS #ifndef NO_MATHOMS PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv); #define PERL_ARGS_ASSERT_SV_COPYPV \ @@ -3359,9 +3746,12 @@ PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv); PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags); #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ assert(dsv); assert(ssv) -/* PERL_CALLCONV void Perl_sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv); */ +/* PERL_CALLCONV void sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv); */ +#define PERL_ARGS_ASSERT_SV_COPYPV_NOMG PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_DEC PERL_CALLCONV void Perl_sv_dec_nomg(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_DEC_NOMG PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV *const tsv, SV *const sv); #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ assert(tsv); assert(sv) @@ -3386,6 +3776,7 @@ PERL_CALLCONV bool Perl_sv_derived_from_sv(pTHX_ SV* sv, SV *namesv, U32 flags) assert(sv); assert(namesv) PERL_CALLCONV bool Perl_sv_destroyable(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_DESTROYABLE PERL_CALLCONV bool Perl_sv_does(pTHX_ SV* sv, const char *const name) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_DOES \ @@ -3407,10 +3798,13 @@ PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV* sv, SV* namesv, U32 flags) assert(sv); assert(namesv) PERL_CALLCONV void Perl_sv_dump(pTHX_ SV* sv); +#define PERL_ARGS_ASSERT_SV_DUMP #ifndef NO_MATHOMS PERL_CALLCONV I32 Perl_sv_eq(pTHX_ SV* sv1, SV* sv2); +#define PERL_ARGS_ASSERT_SV_EQ #endif PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags); +#define PERL_ARGS_ASSERT_SV_EQ_FLAGS #ifndef NO_MATHOMS PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ @@ -3420,10 +3814,12 @@ PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flag #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ assert(sv) PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_FREE PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt); #define PERL_ARGS_ASSERT_SV_FREE2 \ assert(sv) PERL_CALLCONV void Perl_sv_free_arenas(pTHX); +#define PERL_ARGS_ASSERT_SV_FREE_ARENAS PERL_CALLCONV SV* Perl_sv_get_backrefs(SV *const sv); #define PERL_ARGS_ASSERT_SV_GET_BACKREFS \ assert(sv) @@ -3434,7 +3830,9 @@ PERL_CALLCONV char* Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen); #define PERL_ARGS_ASSERT_SV_GROW \ assert(sv) PERL_CALLCONV void Perl_sv_inc(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_INC PERL_CALLCONV void Perl_sv_inc_nomg(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_INC_NOMG #ifndef NO_MATHOMS PERL_CALLCONV void Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen); #define PERL_ARGS_ASSERT_SV_INSERT \ @@ -3447,6 +3845,7 @@ PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name); #define PERL_ARGS_ASSERT_SV_ISA \ assert(name) PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV* sv); +#define PERL_ARGS_ASSERT_SV_ISOBJECT #ifndef NO_MATHOMS PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv) __attribute__deprecated__; @@ -3455,7 +3854,9 @@ PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv) #endif PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_LEN PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_LEN_UTF8 PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV *const sv); #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \ assert(sv) @@ -3471,24 +3872,31 @@ PERL_CALLCONV MAGIC * Perl_sv_magicext_mglob(pTHX_ SV *sv); #ifndef NO_MATHOMS PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SV_MORTALCOPY #endif PERL_CALLCONV SV* Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SV_MORTALCOPY_FLAGS PERL_CALLCONV SV* Perl_sv_newmortal(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SV_NEWMORTAL PERL_CALLCONV SV* Perl_sv_newref(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_NEWREF #ifndef NO_MATHOMS PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv) __attribute__deprecated__; +#define PERL_ARGS_ASSERT_SV_NOLOCKING #endif PERL_CALLCONV void Perl_sv_nosharing(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_NOSHARING #ifndef NO_MATHOMS PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv) __attribute__deprecated__; +#define PERL_ARGS_ASSERT_SV_NOUNLOCKING #endif #ifndef NO_MATHOMS @@ -3499,11 +3907,12 @@ PERL_CALLCONV NV Perl_sv_nv(pTHX_ SV* sv) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_sv_only_taint_gmagic(SV *sv); +PERL_STATIC_INLINE bool Perl_sv_only_taint_gmagic(SV *sv); #define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \ assert(sv) #endif PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv); +#define PERL_ARGS_ASSERT_SV_PEEK PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp); #define PERL_ARGS_ASSERT_SV_POS_B2U \ assert(offsetp) @@ -3594,10 +4003,12 @@ PERL_CALLCONV void Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv); #define PERL_ARGS_ASSERT_SV_REPLACE \ assert(sv); assert(nsv) PERL_CALLCONV void Perl_sv_report_used(pTHX); +#define PERL_ARGS_ASSERT_SV_REPORT_USED PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash); #define PERL_ARGS_ASSERT_SV_RESET \ assert(s) PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash); +#define PERL_ARGS_ASSERT_SV_RESETPVN PERL_CALLCONV SV* Perl_sv_rvunweaken(pTHX_ SV *const sv); #define PERL_ARGS_ASSERT_SV_RVUNWEAKEN \ assert(sv) @@ -3694,6 +4105,7 @@ PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u); #define PERL_ARGS_ASSERT_SV_SETUV_MG \ assert(sv) PERL_CALLCONV SV* Perl_sv_string_from_errnum(pTHX_ int errnum, SV* tgtsv); +#define PERL_ARGS_ASSERT_SV_STRING_FROM_ERRNUM #ifndef NO_MATHOMS PERL_CALLCONV void Perl_sv_taint(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_SV_TAINT \ @@ -3705,6 +4117,7 @@ PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV *const sv) assert(sv) PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_TRUE PERL_CALLCONV char* Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ @@ -3755,6 +4168,7 @@ PERL_CALLCONV bool Perl_sv_utf8_downgrade_flags(pTHX_ SV *const sv, const bool f #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ assert(sv) /* PERL_CALLCONV bool sv_utf8_downgrade_nomg(pTHX_ SV *const sv, const bool fail_ok); */ +#define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_NOMG PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV *const sv); #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ assert(sv) @@ -3764,10 +4178,12 @@ PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv); assert(sv) #endif /* PERL_CALLCONV STRLEN sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags); */ +#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra); #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ assert(sv) /* PERL_CALLCONV STRLEN sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ +#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_NOMG #ifndef NO_MATHOMS PERL_CALLCONV UV Perl_sv_uv(pTHX_ SV* sv) __attribute__deprecated__; @@ -3805,7 +4221,9 @@ PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* l assert(pkg); assert(name); assert(listsv) PERL_CALLCONV void Perl_switch_to_global_locale(void); +#define PERL_ARGS_ASSERT_SWITCH_TO_GLOBAL_LOCALE PERL_CALLCONV bool Perl_sync_locale(void); +#define PERL_ARGS_ASSERT_SYNC_LOCALE PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv); #define PERL_ARGS_ASSERT_SYS_INIT \ assert(argc); assert(argv) @@ -3813,17 +4231,23 @@ PERL_CALLCONV void Perl_sys_init3(int* argc, char*** argv, char*** env); #define PERL_ARGS_ASSERT_SYS_INIT3 \ assert(argc); assert(argv); assert(env) PERL_CALLCONV void Perl_sys_term(void); +#define PERL_ARGS_ASSERT_SYS_TERM PERL_CALLCONV void Perl_taint_env(pTHX); +#define PERL_ARGS_ASSERT_TAINT_ENV PERL_CALLCONV void Perl_taint_proper(pTHX_ const char* f, const char *const s); #define PERL_ARGS_ASSERT_TAINT_PROPER \ assert(s) PERL_CALLCONV void Perl_thread_locale_init(void); +#define PERL_ARGS_ASSERT_THREAD_LOCALE_INIT PERL_CALLCONV void Perl_thread_locale_term(void); +#define PERL_ARGS_ASSERT_THREAD_LOCALE_TERM PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...); #define PERL_ARGS_ASSERT_TIED_METHOD \ assert(methname); assert(sp); assert(sv); assert(mg) PERL_CALLCONV SSize_t Perl_tmps_grow_p(pTHX_ SSize_t ix); -/* PERL_CALLCONV UV Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ +#define PERL_ARGS_ASSERT_TMPS_GROW_P +/* PERL_CALLCONV UV to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ +#define PERL_ARGS_ASSERT_TO_UNI_FOLD PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ assert(p); assert(lenp) @@ -3831,6 +4255,7 @@ PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_TO_UNI_LOWER_LC #endif PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp); @@ -3840,6 +4265,7 @@ PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp); PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_TO_UNI_TITLE_LC #endif PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp); @@ -3849,6 +4275,7 @@ PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp); PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c) __attribute__deprecated__ __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_TO_UNI_UPPER_LC #endif #ifndef NO_MATHOMS @@ -3880,7 +4307,9 @@ PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) #endif PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); +#define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN PERL_CALLCONV bool Perl_try_amagic_un(pTHX_ int method, int flags); +#define PERL_ARGS_ASSERT_TRY_AMAGIC_UN #ifndef NO_MATHOMS PERL_CALLCONV SSize_t Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags) __attribute__deprecated__; @@ -3892,7 +4321,9 @@ PERL_CALLCONV SSize_t Perl_unpackstring(pTHX_ const char *pat, const char *paten #define PERL_ARGS_ASSERT_UNPACKSTRING \ assert(pat); assert(patend); assert(s); assert(strend) PERL_CALLCONV void Perl_unshare_hek(pTHX_ HEK* hek); +#define PERL_ARGS_ASSERT_UNSHARE_HEK PERL_CALLCONV void Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash); +#define PERL_ARGS_ASSERT_UNSHAREPVN PERL_CALLCONV SV* Perl_upg_version(pTHX_ SV *ver, bool qv); #define PERL_ARGS_ASSERT_UPG_VERSION \ assert(ver) @@ -3953,6 +4384,11 @@ PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) PERL_CALLCONV UV Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \ assert(s); assert(send) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE UV Perl_utf8_to_uvchr_buf_helper(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); +#define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF_HELPER \ + assert(s); assert(send) +#endif #ifndef NO_MATHOMS PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; @@ -3972,7 +4408,7 @@ PERL_CALLCONV UV Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *r #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_ERROR \ assert(s) #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE UV S_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs); +PERL_STATIC_INLINE UV Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs); #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS \ assert(s) #endif @@ -3983,8 +4419,11 @@ PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop #define PERL_ARGS_ASSERT_UTILIZE \ assert(idop) /* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv); */ +#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 /* PERL_CALLCONV U8* uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ +#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS /* PERL_CALLCONV U8* uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV ** msgs); */ +#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS_MSGS PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, const UV flags); #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \ assert(d) @@ -4019,6 +4458,7 @@ PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv); assert(lhv); assert(rhv) PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char* pat, va_list* args) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_VCROAK PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args); #define PERL_ARGS_ASSERT_VDEB \ @@ -4081,11 +4521,13 @@ PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char* pat, ...) PERL_CALLCONV I32 Perl_was_lvalue_sub(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_WAS_LVALUE_SUB PERL_CALLCONV void Perl_watch(pTHX_ char** addr); #define PERL_ARGS_ASSERT_WATCH \ assert(addr) /* PERL_CALLCONV I32 whichsig(pTHX_ const char* sig); */ +#define PERL_ARGS_ASSERT_WHICHSIG PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char* sig); #define PERL_ARGS_ASSERT_WHICHSIG_PV \ assert(sig) @@ -4105,6 +4547,7 @@ PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV* msv); #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ assert(msv) PERL_CALLCONV void Perl_xs_boot_epilog(pTHX_ const I32 ax); +#define PERL_ARGS_ASSERT_XS_BOOT_EPILOG PERL_CALLCONV I32 Perl_xs_handshake(const U32 key, void * v_my_perl, const char * file, ...); #define PERL_ARGS_ASSERT_XS_HANDSHAKE \ assert(v_my_perl); assert(file) @@ -4115,10 +4558,15 @@ PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char *const s, U32 flags); #define PERL_ARGS_ASSERT_YYERROR_PV \ assert(s) PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char *const s, STRLEN len, U32 flags); +#define PERL_ARGS_ASSERT_YYERROR_PVN PERL_CALLCONV int Perl_yylex(pTHX); +#define PERL_ARGS_ASSERT_YYLEX PERL_CALLCONV int Perl_yyparse(pTHX_ int gramtype); +#define PERL_ARGS_ASSERT_YYPARSE PERL_CALLCONV void Perl_yyquit(pTHX); +#define PERL_ARGS_ASSERT_YYQUIT PERL_CALLCONV void Perl_yyunlex(pTHX); +#define PERL_ARGS_ASSERT_YYUNLEX #if ! defined(HAS_MEMRCHR) && (defined(PERL_CORE) || defined(PERL_EXT)) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void * S_my_memrchr(const char * s, const char c, const STRLEN len); @@ -4137,15 +4585,19 @@ STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv); #endif #if !(defined(HAS_NL_LANGINFO) && defined(PERL_LANGINFO_H)) PERL_CALLCONV const char* Perl_langinfo(const int item); +#define PERL_ARGS_ASSERT_PERL_LANGINFO #endif #if !(defined(HAS_NL_LANGINFO)) # if defined(PERL_IN_LOCALE_C) STATIC const char* S_my_nl_langinfo(const int item, bool toggle); +#define PERL_ARGS_ASSERT_MY_NL_LANGINFO # endif #endif #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO)) PERL_CALLCONV Signal_t Perl_csighandler(int sig); +#define PERL_ARGS_ASSERT_CSIGHANDLER PERL_CALLCONV Signal_t Perl_sighandler(int sig); +#define PERL_ARGS_ASSERT_SIGHANDLER #endif #if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)) PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd); @@ -4168,8 +4620,9 @@ PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) #endif #if !defined(EBCDIC) #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE unsigned int S__variant_byte_number(PERL_UINTMAX_T word) +PERL_STATIC_INLINE unsigned int Perl_variant_byte_number(PERL_UINTMAX_T word) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_VARIANT_BYTE_NUMBER #endif #endif @@ -4206,13 +4659,16 @@ PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char* a, const char* b); PERL_CALLCONV int Perl_signbit(NV f) __attribute__warn_unused_result__ __attribute__pure__; +#define PERL_ARGS_ASSERT_PERL_SIGNBIT #endif #if !defined(HAS_STRLCAT) PERL_CALLCONV Size_t Perl_my_strlcat(char *dst, const char *src, Size_t size); +#define PERL_ARGS_ASSERT_MY_STRLCAT #endif #if !defined(HAS_STRLCPY) PERL_CALLCONV Size_t Perl_my_strlcpy(char *dst, const char *src, Size_t size); +#define PERL_ARGS_ASSERT_MY_STRLCPY #endif #if !defined(HAS_STRNLEN) PERL_CALLCONV Size_t Perl_my_strnlen(const char *str, Size_t maxlen); @@ -4222,6 +4678,7 @@ PERL_CALLCONV Size_t Perl_my_strnlen(const char *str, Size_t maxlen); #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP) PERL_CALLCONV I32 Perl_my_chsize(pTHX_ int fd, Off_t length) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_MY_CHSIZE #endif #if !defined(NV_PRESERVES_UV) @@ -4308,6 +4765,7 @@ PERL_STATIC_INLINE void S_invlist_trim(SV* invlist); #endif #if !defined(PERL_IMPLICIT_SYS) PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr); +#define PERL_ARGS_ASSERT_MY_PCLOSE PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode); #define PERL_ARGS_ASSERT_MY_POPEN \ assert(cmd); assert(mode) @@ -4321,92 +4779,92 @@ STATIC SV * S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem); #endif #if !defined(PERL_NO_INLINE_FUNCTIONS) #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_popblock(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPBLOCK \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_popeval(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPEVAL \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_popformat(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPFORMAT \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_popgiven(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPGIVEN \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_poploop(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPLOOP \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_popsub(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPSUB \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPSUB_ARGS \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPSUB_COMMON \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_popwhen(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPWHEN \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE PERL_CONTEXT * S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix); +PERL_STATIC_INLINE PERL_CONTEXT * Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix); #define PERL_ARGS_ASSERT_CX_PUSHBLOCK \ assert(sp) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv); +PERL_STATIC_INLINE void Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv); #define PERL_ARGS_ASSERT_CX_PUSHEVAL \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv); +PERL_STATIC_INLINE void Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv); #define PERL_ARGS_ASSERT_CX_PUSHFORMAT \ assert(cx); assert(cv) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv); +PERL_STATIC_INLINE void Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv); #define PERL_ARGS_ASSERT_CX_PUSHGIVEN \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave); +PERL_STATIC_INLINE void Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave); #define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR \ assert(cx); assert(itervarp) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs); +PERL_STATIC_INLINE void Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs); #define PERL_ARGS_ASSERT_CX_PUSHSUB \ assert(cx); assert(cv) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_PUSHWHEN \ assert(cx) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_cx_topblock(pTHX_ PERL_CONTEXT *cx); +PERL_STATIC_INLINE void Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_TOPBLOCK \ assert(cx) #endif @@ -4462,6 +4920,7 @@ PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv); #define PERL_ARGS_ASSERT_PAD_SETSV \ assert(sv) PERL_CALLCONV SV* Perl_pad_sv(pTHX_ PADOFFSET po); +#define PERL_ARGS_ASSERT_PAD_SV PERL_CALLCONV void Perl_set_padlist(CV * cv, PADLIST * padlist); #define PERL_ARGS_ASSERT_SET_PADLIST \ assert(cv) @@ -4475,6 +4934,7 @@ STATIC void S_print_collxfrm_input_and_return(pTHX_ const char * const s, const assert(s); assert(e) STATIC char * S_setlocale_debug_string(const int category, const char* const locale, const char* const retval) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SETLOCALE_DEBUG_STRING # endif # endif @@ -4515,7 +4975,9 @@ PERL_CALLCONV int Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...); #define PERL_ARGS_ASSERT_RE_INDENTF \ assert(fmt) STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags); +#define PERL_ARGS_ASSERT_REGDUMP_EXTFLAGS STATIC void S_regdump_intflags(pTHX_ const char *lead, const U32 flags); +#define PERL_ARGS_ASSERT_REGDUMP_INTFLAGS STATIC bool S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode_offset val, U32 depth) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_REGTAIL_STUDY \ @@ -4584,10 +5046,12 @@ PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV** mark, SV** sp); #if defined(HAS_NL_LANGINFO) # if defined(PERL_IN_LOCALE_C) STATIC const char* S_my_nl_langinfo(const nl_item item, bool toggle); +#define PERL_ARGS_ASSERT_MY_NL_LANGINFO # endif #endif #if defined(HAS_NL_LANGINFO) && defined(PERL_LANGINFO_H) PERL_CALLCONV const char* Perl_langinfo(const nl_item item); +#define PERL_ARGS_ASSERT_PERL_LANGINFO #endif #if defined(HAS_PIPE) PERL_CALLCONV int Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd) @@ -4598,19 +5062,25 @@ PERL_CALLCONV int Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd) #endif #if defined(HAS_SIGACTION) && defined(SA_SIGINFO) PERL_CALLCONV Signal_t Perl_csighandler(int sig, siginfo_t *info, void *uap); +#define PERL_ARGS_ASSERT_CSIGHANDLER PERL_CALLCONV Signal_t Perl_sighandler(int sig, siginfo_t *info, void *uap); +#define PERL_ARGS_ASSERT_SIGHANDLER #endif #if defined(HAS_SOCKET) PERL_CALLCONV int Perl_PerlSock_accept_cloexec(pTHX_ int listenfd, struct sockaddr *addr, Sock_size_t *addrlen) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PERLSOCK_ACCEPT_CLOEXEC PERL_CALLCONV int Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PERLSOCK_SOCKET_CLOEXEC #endif #if defined(HAVE_INTERP_INTERN) PERL_CALLCONV void Perl_sys_intern_clear(pTHX); +#define PERL_ARGS_ASSERT_SYS_INTERN_CLEAR PERL_CALLCONV void Perl_sys_intern_init(pTHX); +#define PERL_ARGS_ASSERT_SYS_INTERN_INIT # if defined(USE_ITHREADS) PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst); #define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ @@ -4626,6 +5096,7 @@ PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int leve assert(buf) PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_MALLOC_GOOD_SIZE PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) __attribute__warn_unused_result__; @@ -4669,7 +5140,7 @@ PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB *const slab); #endif #if defined(PERL_CORE) || defined (PERL_EXT) #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_is_utf8_non_invariant_string(const U8* const s, STRLEN len) +PERL_STATIC_INLINE bool Perl_is_utf8_non_invariant_string(const U8* const s, STRLEN len) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_NON_INVARIANT_STRING \ assert(s) @@ -4698,6 +5169,7 @@ PERL_STATIC_INLINE Size_t S_variant_under_utf8_count(const U8* const s, const U8 #if defined(PERL_CR_FILTER) # if defined(PERL_IN_TOKE_C) STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); +#define PERL_ARGS_ASSERT_CR_TEXTFILTER STATIC void S_strip_return(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_STRIP_RETURN \ assert(sv) @@ -4718,21 +5190,27 @@ PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o); #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ assert(o) PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o); +#define PERL_ARGS_ASSERT_OP_REFCNT_INC #endif #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) -/* PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd); */ +PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd); +#define PERL_ARGS_ASSERT_DO_EXEC \ + assert(cmd) #endif #if defined(PERL_DONT_CREATE_GVSV) #ifndef NO_MATHOMS PERL_CALLCONV GV* Perl_gv_SVadd(pTHX_ GV *gv); +#define PERL_ARGS_ASSERT_GV_SVADD #endif #endif #if defined(PERL_GLOBAL_STRUCT) PERL_CALLCONV struct perl_vars * Perl_GetVars(pTHX); +#define PERL_ARGS_ASSERT_GETVARS PERL_CALLCONV void Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp); #define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT \ assert(plvarsp) PERL_CALLCONV struct perl_vars* Perl_init_global_struct(pTHX); +#define PERL_ARGS_ASSERT_INIT_GLOBAL_STRUCT #endif #if defined(PERL_GLOBAL_STRUCT_PRIVATE) # if defined(PERL_IMPLICIT_CONTEXT) @@ -4748,6 +5226,7 @@ PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size); PERL_CALLCONV_NO_RET void Perl_croak_nocontext(const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,1,2); +#define PERL_ARGS_ASSERT_CROAK_NOCONTEXT PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...) __attribute__format__(__printf__,1,2); @@ -4757,6 +5236,7 @@ PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...) PERL_CALLCONV_NO_RET OP* Perl_die_nocontext(const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,1,2); +#define PERL_ARGS_ASSERT_DIE_NOCONTEXT PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...) __attribute__format__(__printf__,1,2); @@ -4852,6 +5332,7 @@ STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report); assert(cmd) STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_INGROUP STATIC bool S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type, Stat_t *statbufp); #define PERL_ARGS_ASSERT_OPENN_CLEANUP \ @@ -4894,6 +5375,7 @@ STATIC Size_t S_do_trans_simple_utf8(pTHX_ SV * const sv) #endif #if defined(PERL_IN_DUMP_C) STATIC CV* S_deb_curcv(pTHX_ I32 ix); +#define PERL_ARGS_ASSERT_DEB_CURCV STATIC void S_debprof(pTHX_ const OP *o); #define PERL_ARGS_ASSERT_DEBPROF \ assert(o) @@ -4901,6 +5383,7 @@ STATIC SV* S_pm_description(pTHX_ const PMOP *pm); #define PERL_ARGS_ASSERT_PM_DESCRIPTION \ assert(pm) STATIC UV S_sequence_num(pTHX_ const OP *o); +#define PERL_ARGS_ASSERT_SEQUENCE_NUM #endif #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C) PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv); @@ -4913,6 +5396,7 @@ STATIC bool S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, assert(stash); assert(name) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE GV* S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags); +#define PERL_ARGS_ASSERT_GV_FETCHMETH_INTERNAL #endif STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ @@ -4963,6 +5447,7 @@ STATIC struct xpvhv_aux* S_hv_auxinit_internal(struct xpvhv_aux *iter); #define PERL_ARGS_ASSERT_HV_AUXINIT_INTERNAL \ assert(iter) STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); +#define PERL_ARGS_ASSERT_HV_DELETE_COMMON STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry); #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ assert(hv); assert(entry) @@ -4979,9 +5464,11 @@ PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 kl STATIC HE* S_new_he(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEW_HE #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u); +#define PERL_ARGS_ASSERT_PTR_HASH #endif STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ @@ -4998,6 +5485,7 @@ STATIC HEK* S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int f assert(str) STATIC void S_unshare_hek_or_pvn(pTHX_ const HEK* hek, const char* str, I32 len, U32 hash); +#define PERL_ARGS_ASSERT_UNSHARE_HEK_OR_PVN #endif #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av); @@ -5019,22 +5507,30 @@ PERL_STATIC_INLINE const char * S_save_to_buffer(const char * string, char **buf # if defined(USE_LOCALE) STATIC const char* S_category_name(const int category); +#define PERL_ARGS_ASSERT_CATEGORY_NAME STATIC void S_new_collate(pTHX_ const char* newcoll); +#define PERL_ARGS_ASSERT_NEW_COLLATE STATIC void S_new_ctype(pTHX_ const char* newctype); #define PERL_ARGS_ASSERT_NEW_CTYPE \ assert(newctype) STATIC void S_new_numeric(pTHX_ const char* newnum); +#define PERL_ARGS_ASSERT_NEW_NUMERIC STATIC void S_restore_switched_locale(pTHX_ const int category, const char * const original_locale); +#define PERL_ARGS_ASSERT_RESTORE_SWITCHED_LOCALE STATIC void S_set_numeric_radix(pTHX_ const bool use_locale); +#define PERL_ARGS_ASSERT_SET_NUMERIC_RADIX STATIC char* S_stdize_locale(pTHX_ char* locs); #define PERL_ARGS_ASSERT_STDIZE_LOCALE \ assert(locs) STATIC const char* S_switch_category_locale_to_template(pTHX_ const int switch_category, const int template_category, const char * template_locale); +#define PERL_ARGS_ASSERT_SWITCH_CATEGORY_LOCALE_TO_TEMPLATE # if defined(USE_POSIX_2008_LOCALE) STATIC const char* S_emulate_setlocale(const int category, const char* locale, unsigned int index, const bool is_index_valid); +#define PERL_ARGS_ASSERT_EMULATE_SETLOCALE # endif # if defined(WIN32) STATIC char* S_win32_setlocale(pTHX_ int category, const char* locale); +#define PERL_ARGS_ASSERT_WIN32_SETLOCALE # endif # endif #endif @@ -5061,10 +5557,12 @@ STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth); #define PERL_ARGS_ASSERT_MAGIC_METHPACK \ assert(sv); assert(mg); assert(meth) STATIC void S_restore_magic(pTHX_ const void *p); +#define PERL_ARGS_ASSERT_RESTORE_MAGIC STATIC void S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags); #define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \ assert(sv) STATIC void S_unwind_handler_stack(pTHX_ const void *p); +#define PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK #endif #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) PERL_CALLCONV bool Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp); @@ -5091,6 +5589,7 @@ STATIC void S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp assert(stash); assert(target); assert(imopsp) STATIC I32 S_assignment_type(pTHX_ const OP *o) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_ASSIGNMENT_TYPE STATIC void S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t); #define PERL_ARGS_ASSERT_BAD_TYPE_GV \ @@ -5117,10 +5616,12 @@ STATIC OP* S_fold_constants(pTHX_ OP * const o); #define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ assert(o) STATIC OP* S_force_list(pTHX_ OP* arg, bool nullit); +#define PERL_ARGS_ASSERT_FORCE_LIST STATIC void S_forget_pmop(pTHX_ PMOP *const o); #define PERL_ARGS_ASSERT_FORGET_PMOP \ assert(o) STATIC void S_gen_constant_list(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_GEN_CONSTANT_LIST STATIC void S_inplace_aassign(pTHX_ OP* o); #define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ assert(o) @@ -5130,10 +5631,12 @@ STATIC bool S_is_handle_constructor(const OP *o, I32 numargs) assert(o) STATIC OP* S_listkids(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_LISTKIDS STATIC bool S_looks_like_bool(pTHX_ const OP* o); #define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ assert(o) STATIC OP* S_modkids(pTHX_ OP *o, I32 type); +#define PERL_ARGS_ASSERT_MODKIDS STATIC void S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash); #define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \ assert(proto); assert(attrs); assert(name) @@ -5145,6 +5648,7 @@ STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave assert(block) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE OP* S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP* dynamic_meth, SV* const_meth); +#define PERL_ARGS_ASSERT_NEWMETHOP_INTERNAL #endif STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) __attribute__warn_unused_result__; @@ -5179,15 +5683,20 @@ STATIC bool S_process_special_blocks(pTHX_ I32 floor, const char *const fullname #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ assert(fullname); assert(gv); assert(cv) STATIC OP* S_ref_array_or_hash(pTHX_ OP* cond); +#define PERL_ARGS_ASSERT_REF_ARRAY_OR_HASH STATIC OP* S_refkids(pTHX_ OP* o, I32 type); +#define PERL_ARGS_ASSERT_REFKIDS STATIC bool S_scalar_mod_type(const OP *o, I32 type) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SCALAR_MOD_TYPE STATIC OP* S_scalarboolean(pTHX_ OP *o); #define PERL_ARGS_ASSERT_SCALARBOOLEAN \ assert(o) STATIC OP* S_scalarkids(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_SCALARKIDS STATIC OP* S_scalarseq(pTHX_ OP* o); +#define PERL_ARGS_ASSERT_SCALARSEQ STATIC OP* S_search_const(pTHX_ OP *o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SEARCH_CONST \ @@ -5231,10 +5740,19 @@ STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 fla #define PERL_ARGS_ASSERT_PAD_FINDLEX \ assert(namepv); assert(cv); assert(out_name); assert(out_flags) STATIC void S_pad_reset(pTHX); +#define PERL_ARGS_ASSERT_PAD_RESET +#endif +#if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE bool S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq); +#define PERL_ARGS_ASSERT_PADNAMEIN_SCOPE \ + assert(pn) +#endif #endif #if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C) #ifndef NO_MATHOMS PERL_CALLCONV OP* Perl_ref(pTHX_ OP* o, I32 type); +#define PERL_ARGS_ASSERT_REF #endif #endif #if defined(PERL_IN_PERL_C) @@ -5242,6 +5760,7 @@ STATIC void S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp); #define PERL_ARGS_ASSERT_FIND_BEGINNING \ assert(linestr_sv); assert(rsfp) STATIC void S_forbid_setid(pTHX_ const char flag, const bool suidscript); +#define PERL_ARGS_ASSERT_FORBID_SETID STATIC void S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_INCPUSH \ assert(dir) @@ -5249,32 +5768,43 @@ STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ assert(p) STATIC void S_init_ids(pTHX); +#define PERL_ARGS_ASSERT_INIT_IDS STATIC void S_init_interp(pTHX); +#define PERL_ARGS_ASSERT_INIT_INTERP STATIC void S_init_main_stash(pTHX); +#define PERL_ARGS_ASSERT_INIT_MAIN_STASH STATIC void S_init_perllib(pTHX); +#define PERL_ARGS_ASSERT_INIT_PERLLIB STATIC void S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env); #define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ assert(argv) STATIC void S_init_predump_symbols(pTHX); +#define PERL_ARGS_ASSERT_INIT_PREDUMP_SYMBOLS STATIC SV* S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_MAYBERELOCATE \ assert(dir) PERL_STATIC_NO_RET void S_minus_v(pTHX) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_MINUS_V PERL_STATIC_NO_RET void S_my_exit_jump(pTHX) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_MY_EXIT_JUMP STATIC void S_nuke_stacks(pTHX); +#define PERL_ARGS_ASSERT_NUKE_STACKS STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript); #define PERL_ARGS_ASSERT_OPEN_SCRIPT \ assert(scriptname); assert(suidscript) STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit); +#define PERL_ARGS_ASSERT_PARSE_BODY PERL_STATIC_NO_RET void S_run_body(pTHX_ I32 oldscope) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_RUN_BODY PERL_STATIC_NO_RET void S_usage(pTHX) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_USAGE #endif #if defined(PERL_IN_PP_C) @@ -5282,6 +5812,7 @@ STATIC size_t S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping); #define PERL_ARGS_ASSERT_DO_CHOMP \ assert(retval); assert(sv) STATIC OP* S_do_delete_local(pTHX); +#define PERL_ARGS_ASSERT_DO_DELETE_LOCAL STATIC SV* S_refto(pTHX_ SV* sv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_REFTO \ @@ -5302,6 +5833,13 @@ PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, co assert(sv); assert(what); assert(spp) #endif +#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE const char * S_get_regex_charset_name(const U32 flags, STRLEN* const lenp); +#define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME \ + assert(lenp) +#endif +#endif #if defined(PERL_IN_PP_CTL_C) STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) __attribute__warn_unused_result__; @@ -5312,10 +5850,13 @@ STATIC void S_destroy_matcher(pTHX_ PMOP* matcher); #define PERL_ARGS_ASSERT_DESTROY_MATCHER \ assert(matcher) STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied); +#define PERL_ARGS_ASSERT_DO_SMARTMATCH STATIC OP* S_docatch(pTHX_ Perl_ppaddr_t firstpp) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DOCATCH STATIC bool S_doeval_compile(pTHX_ U8 gimme, CV* outside, U32 seq, HV* hh); +#define PERL_ARGS_ASSERT_DOEVAL_COMPILE STATIC OP* S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_DOFINDLABEL \ @@ -5326,9 +5867,11 @@ STATIC MAGIC * S_doparseform(pTHX_ SV *sv); assert(sv) STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DOPOPTOEVAL STATIC I32 S_dopoptogivenfor(pTHX_ I32 startingblock) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DOPOPTOGIVENFOR STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) __attribute__warn_unused_result__; @@ -5337,6 +5880,7 @@ STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DOPOPTOLOOP STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock) __attribute__warn_unused_result__; @@ -5345,6 +5889,7 @@ STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock) STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DOPOPTOWHEN STATIC PMOP* S_make_matcher(pTHX_ REGEXP* re) __attribute__warn_unused_result__; @@ -5358,6 +5903,7 @@ STATIC bool S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv) STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NUM_OVERFLOW #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_path_is_searchable(const char *name) @@ -5476,6 +6022,7 @@ STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop); #define PERL_ARGS_ASSERT_DOFORM \ assert(cv); assert(gv) STATIC SV * S_space_join_names_mortal(pTHX_ char *const *array); +#define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL #endif #if defined(PERL_IN_REGCOMP_C) STATIC SV* S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node) @@ -5489,6 +6036,7 @@ STATIC void S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 c #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST #endif STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n) @@ -5504,6 +6052,7 @@ STATIC void S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_ assert(pRExC_state) STATIC const char * S_cntrl_to_mnemonic(const U8 c) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE U8 S_compute_EXACTish(RExC_state_t *pRExC_state); @@ -5649,6 +6198,7 @@ STATIC regnode_offset S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U3 assert(pRExC_state); assert(flagp) STATIC unsigned int S_regex_set_precedence(const U8 my_operator) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_REGEX_SET_PRECEDENCE STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth); #define PERL_ARGS_ASSERT_REGINSERT \ @@ -5793,6 +6343,7 @@ PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_invlist(SV* const invlist) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_INVLIST #endif #endif @@ -5811,6 +6362,7 @@ PERL_STATIC_INLINE char* S_form_short_octal_warning(pTHX_ const char * const s, PERL_CALLCONV char Perl_grok_bslash_c(pTHX_ const char source, const bool output_warning) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GROK_BSLASH_C PERL_CALLCONV bool Perl_grok_bslash_o(pTHX_ char** s, const char* const send, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8) __attribute__warn_unused_result__; @@ -5833,8 +6385,10 @@ PERL_STATIC_INLINE I32 S_regcurly(const char *s) #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV SV* Perl__add_range_to_invlist(pTHX_ SV* invlist, UV start, UV end) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST /* PERL_CALLCONV void _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i); */ +#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i); #define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ assert(b); assert(i) @@ -5842,12 +6396,15 @@ PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist); #define PERL_ARGS_ASSERT__INVLIST_INVERT \ assert(invlist) /* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result); */ +#define PERL_ARGS_ASSERT__INVLIST_SUBTRACT /* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output); */ +#define PERL_ARGS_ASSERT__INVLIST_UNION PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output); #define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ assert(b); assert(output) PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__NEW_INVLIST PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr) __attribute__warn_unused_result__; @@ -6007,10 +6564,12 @@ PERL_CALLCONV bool Perl__is_grapheme(pTHX_ const U8 * strbeg, const U8 * s, cons #if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV bool Perl_isFOO_lc(pTHX_ const U8 classnum, const U8 character) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_ISFOO_LC #endif #if defined(PERL_IN_SCOPE_C) STATIC void S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type); +#define PERL_ARGS_ASSERT_SAVE_PUSHPTRI32PTR STATIC SV* S_save_scalar_at(pTHX_ SV **sptr, const U32 flags); #define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ assert(sptr) @@ -6049,6 +6608,7 @@ STATIC void S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int d #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ assert(dstr); assert(sstr) STATIC SV * S_more_sv(pTHX); +#define PERL_ARGS_ASSERT_MORE_SV STATIC void S_not_a_number(pTHX_ SV *const sv); #define PERL_ARGS_ASSERT_NOT_A_NUMBER \ assert(sv) @@ -6119,11 +6679,14 @@ STATIC void S_unreferenced_to_tmp_stack(pTHX_ AV *const unreferenced); #if defined(PERL_IN_SV_C) || defined (PERL_IN_OP_C) PERL_CALLCONV SV * Perl_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ, const SV *const keyname, SSize_t aindex, int subscript_type) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_VARNAME #endif #if defined(PERL_IN_TOKE_C) STATIC int S_ao(pTHX_ int toketype); +#define PERL_ARGS_ASSERT_AO STATIC void S_check_uni(pTHX); +#define PERL_ARGS_ASSERT_CHECK_UNI STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what); #define PERL_ARGS_ASSERT_CHECKCOMMA \ assert(s); assert(name); assert(what) @@ -6141,7 +6704,9 @@ STATIC void S_force_ident(pTHX_ const char *s, int kind); #define PERL_ARGS_ASSERT_FORCE_IDENT \ assert(s) STATIC void S_force_ident_maybe_lex(pTHX_ char pit); +#define PERL_ARGS_ASSERT_FORCE_IDENT_MAYBE_LEX STATIC void S_force_next(pTHX_ I32 type); +#define PERL_ARGS_ASSERT_FORCE_NEXT STATIC char* S_force_strict_version(pTHX_ char *s); #define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ assert(s) @@ -6170,6 +6735,7 @@ STATIC I32 S_lop(pTHX_ I32 f, U8 x, char *s); assert(s) PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s, STRLEN len) __attribute__noreturn__; +#define PERL_ARGS_ASSERT_MISSINGTERM STATIC SV* S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen, const char ** error_msg); #define PERL_ARGS_ASSERT_NEW_CONSTANT \ @@ -6181,6 +6747,7 @@ STATIC void S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_pa #define PERL_ARGS_ASSERT_PARSE_IDENT \ assert(s); assert(d); assert(e) STATIC int S_pending_ident(pTHX); +#define PERL_ARGS_ASSERT_PENDING_IDENT STATIC char* S_scan_const(pTHX_ char *start) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SCAN_CONST \ @@ -6221,12 +6788,15 @@ STATIC char* S_scan_trans(pTHX_ char *start) STATIC I32 S_sublex_done(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SUBLEX_DONE STATIC I32 S_sublex_push(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SUBLEX_PUSH STATIC I32 S_sublex_start(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SUBLEX_START STATIC char* S_swallow_bom(pTHX_ U8 *s) __attribute__warn_unused_result__; @@ -6242,6 +6812,7 @@ STATIC SV* S_tokeq(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_TOKEQ \ assert(sv) STATIC void S_update_debugger_info(pTHX_ SV *orig_sv, const char *const buf, STRLEN len); +#define PERL_ARGS_ASSERT_UPDATE_DEBUGGER_INFO STATIC int S_yywarn(pTHX_ const char *const s, U32 flags); #define PERL_ARGS_ASSERT_YYWARN \ assert(s) @@ -6315,6 +6886,7 @@ STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span) STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_TO_LOWER_LATIN1 STATIC UV S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8* ustrp, STRLEN *lenp); #define PERL_ARGS_ASSERT_TURKIC_FC \ @@ -6346,8 +6918,11 @@ PERL_CALLCONV UV Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const uns #endif #if defined(PERL_IN_UTIL_C) STATIC bool S_ckwarn_common(pTHX_ U32 w); +#define PERL_ARGS_ASSERT_CKWARN_COMMON STATIC bool S_invoke_exception_hook(pTHX_ SV *ex, bool warn); +#define PERL_ARGS_ASSERT_INVOKE_EXCEPTION_HOOK STATIC SV* S_mess_alloc(pTHX); +#define PERL_ARGS_ASSERT_MESS_ALLOC STATIC SV * S_with_queued_errors(pTHX_ SV *ex); #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ assert(ex) @@ -6373,6 +6948,7 @@ PERL_CALLCONV Malloc_t Perl_mem_log_realloc(const UV n, const UV typesize, const #endif #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) STATIC void S_pidgone(pTHX_ Pid_t pid, int status); +#define PERL_ARGS_ASSERT_PIDGONE #endif #if defined(UNLINK_ALL_VERSIONS) PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f); @@ -6384,8 +6960,11 @@ PERL_CALLCONV bool Perl_dump_c_backtrace(pTHX_ PerlIO* fp, int max_depth, int sk #define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ assert(fp) /* PERL_CALLCONV void free_c_backtrace(pTHX_ Perl_c_backtrace* bt); */ +#define PERL_ARGS_ASSERT_FREE_C_BACKTRACE PERL_CALLCONV Perl_c_backtrace* Perl_get_c_backtrace(pTHX_ int max_depth, int skip); +#define PERL_ARGS_ASSERT_GET_C_BACKTRACE PERL_CALLCONV SV* Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); +#define PERL_ARGS_ASSERT_GET_C_BACKTRACE_DUMP #endif #if defined(USE_DTRACE) PERL_CALLCONV void Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call); @@ -6398,6 +6977,7 @@ PERL_CALLCONV void Perl_dtrace_probe_op(pTHX_ const OP *op); #define PERL_ARGS_ASSERT_DTRACE_PROBE_OP \ assert(op) PERL_CALLCONV void Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase); +#define PERL_ARGS_ASSERT_DTRACE_PROBE_PHASE #endif #if defined(USE_ITHREADS) PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv); @@ -6510,6 +7090,7 @@ PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *cons #endif #if defined(USE_LOCALE) && ( defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MG_C) || defined (PERL_EXT_POSIX) || defined (PERL_EXT_LANGINFO)) PERL_CALLCONV bool Perl__is_cur_LC_category_utf8(pTHX_ int category); +#define PERL_ARGS_ASSERT__IS_CUR_LC_CATEGORY_UTF8 #endif #if defined(USE_LOCALE_COLLATE) PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg); @@ -6533,39 +7114,60 @@ PERL_CALLCONV char* Perl_sv_collxfrm_flags(pTHX_ SV *const sv, STRLEN *const nxp #endif #if defined(USE_PERLIO) PERL_CALLCONV void Perl_PerlIO_clearerr(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_CLEARERR PERL_CALLCONV int Perl_PerlIO_close(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_CLOSE PERL_CALLCONV int Perl_PerlIO_eof(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_EOF PERL_CALLCONV int Perl_PerlIO_error(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_ERROR PERL_CALLCONV int Perl_PerlIO_fileno(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_FILENO PERL_CALLCONV int Perl_PerlIO_fill(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_FILL PERL_CALLCONV int Perl_PerlIO_flush(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_FLUSH PERL_CALLCONV STDCHAR * Perl_PerlIO_get_base(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_GET_BASE PERL_CALLCONV SSize_t Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PERLIO_GET_BUFSIZ PERL_CALLCONV SSize_t Perl_PerlIO_get_cnt(pTHX_ PerlIO *f) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PERLIO_GET_CNT PERL_CALLCONV STDCHAR * Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_GET_PTR PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); #define PERL_ARGS_ASSERT_PERLIO_READ \ assert(vbuf) PERL_CALLCONV void Perl_PerlIO_restore_errno(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_RESTORE_ERRNO PERL_CALLCONV void Perl_PerlIO_save_errno(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_SAVE_ERRNO PERL_CALLCONV int Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence); +#define PERL_ARGS_ASSERT_PERLIO_SEEK PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt); +#define PERL_ARGS_ASSERT_PERLIO_SET_CNT PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt); +#define PERL_ARGS_ASSERT_PERLIO_SET_PTRCNT PERL_CALLCONV void Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_SETLINEBUF PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PERLIO_STDERR PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PERLIO_STDIN PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX) __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_PERLIO_STDOUT PERL_CALLCONV Off_t Perl_PerlIO_tell(pTHX_ PerlIO *f); +#define PERL_ARGS_ASSERT_PERLIO_TELL PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); #define PERL_ARGS_ASSERT_PERLIO_UNREAD \ assert(vbuf) diff --git a/regen/embed.pl b/regen/embed.pl index 6532397afd..bad39d7fa2 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -81,15 +81,16 @@ my ($embed, $core, $ext, $api) = setup_embed(); } my ($flags,$retval,$plain_func,@args) = @$_; - if ($flags =~ / ( [^AabDdEefhiMmNnOoPpRrSsTUuWXx] ) /x) { + if ($flags =~ / ( [^AabCDdEefGhiMmNnOoPpRrSsTUuWXx] ) /x) { die_at_end "flag $1 is not legal (for function $plain_func)"; } my @nonnull; + my $args_assert_line = ( $flags !~ /G/ ); my $has_depth = ( $flags =~ /W/ ); my $has_context = ( $flags !~ /T/ ); my $never_returns = ( $flags =~ /r/ ); my $binarycompat = ( $flags =~ /b/ ); - my $commented_out = ( ! $binarycompat && $flags =~ /m/ ); + my $commented_out = ( $flags =~ /m/ ); my $is_malloc = ( $flags =~ /a/ ); my $can_ignore = ( $flags !~ /R/ ) && ( $flags !~ /P/ ) && !$is_malloc; my @names_of_nn; @@ -99,10 +100,13 @@ my ($embed, $core, $ext, $api) = setup_embed(); warn "It is nonsensical to require the return value of a void function ($plain_func) to be checked"; } - die_at_end "$plain_func: S flag is mutually exclusive from the i and p plags" - if $flags =~ /S/ && $flags =~ /[ip]/; + die_at_end "$plain_func: S and p flags are mutually exclusive" + if $flags =~ /S/ && $flags =~ /p/; + die_at_end "$plain_func: m and $1 flags are mutually exclusive" + if $flags =~ /m/ && $flags =~ /([pS])/; - die_at_end "$plain_func: u flag only usable with m" if $flags =~ /u/ && $flags !~ /m/; + die_at_end "$plain_func: u flag only usable with m" if $flags =~ /u/ + && $flags !~ /m/; my $static_inline = 0; if ($flags =~ /([Si])/) { @@ -128,6 +132,14 @@ my ($embed, $core, $ext, $api) = setup_embed(); die_at_end "For '$plain_func', M flag requires p flag" if $flags =~ /M/ && $flags !~ /p/; + die_at_end "For '$plain_func', C flag requires one of [pim] flag" + if $flags =~ /C/ && $flags !~ /[ibmp]/; + die_at_end "For '$plain_func', X flag requires p or i flag" + if $flags =~ /X/ && $flags !~ /[ip]/; + die_at_end "For '$plain_func', X and m flags are mutually exclusive" + if $flags =~ /X/ && $flags =~ /m/; + die_at_end "For '$plain_func', i with [ACX] requires p flag" + if $flags =~ /i/ && $flags =~ /[ACX]/ && $flags !~ /p/; die_at_end "For '$plain_func', b and m flags are mutually exclusive" . " (try M flag)" if $flags =~ /b/ && $flags =~ /m/; die_at_end "For '$plain_func', b flag without M flag requires D flag" @@ -135,13 +147,13 @@ my ($embed, $core, $ext, $api) = setup_embed(); $func = full_name($plain_func, $flags); $ret = ""; - $ret .= "#ifndef NO_MATHOMS\n" if $binarycompat; - $ret .= "#ifndef PERL_NO_INLINE_FUNCTIONS\n" if $static_inline; $ret .= "$retval\t$func("; if ( $has_context ) { $ret .= @args ? "pTHX_ " : "pTHX"; } if (@args) { + die_at_end "n flag is contradicted by having arguments" + if $flags =~ /n/; my $n; for my $arg ( @args ) { ++$n; @@ -225,12 +237,14 @@ my ($embed, $core, $ext, $api) = setup_embed(); } $ret .= ";"; $ret = "/* $ret */" if $commented_out; - if (@names_of_nn) { - $ret .= "\n#define PERL_ARGS_ASSERT_\U$plain_func\E\t\\\n\t" - . join '; ', map "assert($_)", @names_of_nn; - } - $ret .= "\n#endif" if $static_inline; - $ret .= "\n#endif" if $binarycompat; + + $ret .= "\n#define PERL_ARGS_ASSERT_\U$plain_func\E" + if $args_assert_line || @names_of_nn; + $ret .= "\t\\\n\t" . join '; ', map "assert($_)", @names_of_nn + if @names_of_nn; + + $ret = "#ifndef PERL_NO_INLINE_FUNCTIONS\n$ret\n#endif" if $static_inline; + $ret = "#ifndef NO_MATHOMS\n$ret\n#endif" if $binarycompat; $ret .= @attrs ? "\n\n" : "\n"; print $pr $ret; diff --git a/regen/embed_lib.pl b/regen/embed_lib.pl index af991cbdf4..d7e1c5a0b6 100644 --- a/regen/embed_lib.pl +++ b/regen/embed_lib.pl @@ -33,7 +33,8 @@ sub add_level { @entries = @$funcs; } else { foreach (@$funcs) { - if ($_->[0] =~ /A/) { + if ($_->[0] =~ /[AC]/) { # 'C' is like 'A' for our purposes + # here push @entries, $_ if $wanted eq 'A'; } elsif ($_->[0] =~ /E/) { push @entries, $_ if $wanted eq 'E'; @@ -579,7 +579,7 @@ S_find_span_end(U8 * s, const U8 * send, const U8 span_byte) span_word |= span_word << 4; /* That reduces the problem to what this function solves */ - return s + _variant_byte_number(span_word); + return s + variant_byte_number(span_word); #endif @@ -657,7 +657,7 @@ S_find_next_masked(U8 * s, const U8 * send, const U8 byte, const U8 mask) masked &= PERL_VARIANTS_WORD_MASK; /* This reduces the problem to that solved by this function */ - s += _variant_byte_number(masked); + s += variant_byte_number(masked); return s; } while (s + PERL_WORDSIZE <= send); @@ -723,7 +723,7 @@ S_find_span_end_mask(U8 * s, const U8 * send, const U8 span_byte, const U8 mask) masked |= masked << 1; masked |= masked << 2; masked |= masked << 4; - return s + _variant_byte_number(masked); + return s + variant_byte_number(masked); #endif @@ -629,7 +629,7 @@ and check for NULL. # define ReREFCNT_dec(re) SvREFCNT_dec(re) # define ReREFCNT_inc(re) ((REGEXP *) SvREFCNT_inc(re)) #endif -#define ReANY(re) S_ReANY((const REGEXP *)(re)) +#define ReANY(re) Perl_ReANY((const REGEXP *)(re)) /* FIXME for plugins. */ @@ -93,8 +93,8 @@ Type flag for scalars. See L</svtype>. =for apidoc AmnU||SVt_PVMG Type flag for scalars. See L</svtype>. -=for apidoc AmnU||SVt_INVLIST -Type flag for scalars. See L</svtype>. +=for apidoc CmnU||SVt_INVLIST +Type flag for scalars. See L<perlapi/svtype>. =for apidoc AmnU||SVt_REGEXP Type flag for regular expressions. See L</svtype>. @@ -272,18 +272,18 @@ struct p5rx { Returns the value of the object's reference count. Exposed to perl code via Internals::SvREFCNT(). -=for apidoc Am|SV*|SvREFCNT_inc|SV* sv +=for apidoc SvREFCNT_inc Increments the reference count of the given SV, returning the SV. -All of the following C<SvREFCNT_inc>* macros are optimized versions of +All of the following C<SvREFCNT_inc>* are optimized versions of C<SvREFCNT_inc>, and can be replaced with C<SvREFCNT_inc>. -=for apidoc Am|SV*|SvREFCNT_inc_NN|SV* sv +=for apidoc SvREFCNT_inc_NN Same as C<SvREFCNT_inc>, but can only be used if you know C<sv> is not C<NULL>. Since we don't have to check the NULLness, it's faster and smaller. -=for apidoc Am|void|SvREFCNT_inc_void|SV* sv +=for apidoc SvREFCNT_inc_void Same as C<SvREFCNT_inc>, but can only be used if you don't need the return value. The macro doesn't need to return a meaningful value. @@ -312,10 +312,10 @@ value, and you know that C<sv> is not C<NULL>. The macro doesn't need to return a meaningful value, or check for NULLness, so it's smaller and faster. -=for apidoc Am|void|SvREFCNT_dec|SV* sv +=for apidoc SvREFCNT_dec Decrements the reference count of the given SV. C<sv> may be C<NULL>. -=for apidoc Am|void|SvREFCNT_dec_NN|SV* sv +=for apidoc SvREFCNT_dec_NN Same as C<SvREFCNT_dec>, but can only be used if you know C<sv> is not C<NULL>. Since we don't have to check the NULLness, it's faster and smaller. @@ -334,10 +334,10 @@ perform the upgrade if necessary. See C<L</svtype>>. #define SvFLAGS(sv) (sv)->sv_flags #define SvREFCNT(sv) (sv)->sv_refcnt -#define SvREFCNT_inc(sv) S_SvREFCNT_inc(MUTABLE_SV(sv)) +#define SvREFCNT_inc(sv) Perl_SvREFCNT_inc(MUTABLE_SV(sv)) #define SvREFCNT_inc_simple(sv) SvREFCNT_inc(sv) -#define SvREFCNT_inc_NN(sv) S_SvREFCNT_inc_NN(MUTABLE_SV(sv)) -#define SvREFCNT_inc_void(sv) S_SvREFCNT_inc_void(MUTABLE_SV(sv)) +#define SvREFCNT_inc_NN(sv) Perl_SvREFCNT_inc_NN(MUTABLE_SV(sv)) +#define SvREFCNT_inc_void(sv) Perl_SvREFCNT_inc_void(MUTABLE_SV(sv)) /* These guys don't need the curly blocks */ #define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END @@ -345,8 +345,8 @@ perform the upgrade if necessary. See C<L</svtype>>. #define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) #define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) -#define SvREFCNT_dec(sv) S_SvREFCNT_dec(aTHX_ MUTABLE_SV(sv)) -#define SvREFCNT_dec_NN(sv) S_SvREFCNT_dec_NN(aTHX_ MUTABLE_SV(sv)) +#define SvREFCNT_dec(sv) Perl_SvREFCNT_dec(aTHX_ MUTABLE_SV(sv)) +#define SvREFCNT_dec_NN(sv) Perl_SvREFCNT_dec_NN(aTHX_ MUTABLE_SV(sv)) #define SVTYPEMASK 0xff #define SvTYPE(sv) ((svtype)((sv)->sv_flags & SVTYPEMASK)) @@ -1081,8 +1081,8 @@ C<sv_force_normal> does nothing. #define SvPADTMP_on(sv) (SvFLAGS(sv) |= SVs_PADTMP) #define SvPADTMP_off(sv) (SvFLAGS(sv) &= ~SVs_PADTMP) -#define SvPADSTALE_on(sv) S_SvPADSTALE_on(MUTABLE_SV(sv)) -#define SvPADSTALE_off(sv) S_SvPADSTALE_off(MUTABLE_SV(sv)) +#define SvPADSTALE_on(sv) Perl_SvPADSTALE_on(MUTABLE_SV(sv)) +#define SvPADSTALE_off(sv) Perl_SvPADSTALE_off(MUTABLE_SV(sv)) #define SvTEMP(sv) (SvFLAGS(sv) & SVs_TEMP) #define SvTEMP_on(sv) (SvFLAGS(sv) |= SVs_TEMP) diff --git a/t/porting/args_assert.t b/t/porting/args_assert.t index d9000a6e96..97aaafe04d 100644 --- a/t/porting/args_assert.t +++ b/t/porting/args_assert.t @@ -31,7 +31,9 @@ unless (-d 't' && -f 'MANIFEST') { open my $fh, '<', $proto or die "Can't open $proto: $!"; while (<$fh>) { - $declared{$1}++ if /^#define\s+(PERL_ARGS_ASSERT[A-Za-z0-9_]+)\s+/; + # The trailing '.' distinguishes real from dummy macros that have no + # real asserts + $declared{$1}++ if /^#define\s+(PERL_ARGS_ASSERT[A-Za-z0-9_]+)\s+./; } } @@ -145,14 +145,14 @@ S_new_msg_hv(pTHX_ const char * const message, /* The message text */ =for apidoc uvoffuni_to_utf8_flags THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED CIRCUMSTANCES. -Instead, B<Almost all code should use L</uvchr_to_utf8> or -L</uvchr_to_utf8_flags>>. +Instead, B<Almost all code should use L<perlapi/uvchr_to_utf8> or +L<perlapi/uvchr_to_utf8_flags>>. This function is like them, but the input is a strict Unicode (as opposed to native) code point. Only in very rare circumstances should code not be using the native code point. -For details, see the description for L</uvchr_to_utf8_flags>. +For details, see the description for L<perlapi/uvchr_to_utf8_flags>. =cut */ @@ -921,7 +921,7 @@ S_does_utf8_overflow(const U8 * const s, #undef FF_OVERLONG_PREFIX STRLEN -Perl__is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags) +Perl_is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags) { STRLEN len; const U8 *x; @@ -958,7 +958,7 @@ Perl__is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags) * */ - PERL_ARGS_ASSERT__IS_UTF8_CHAR_HELPER; + PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER; assert(0 == (flags & ~(UTF8_DISALLOW_ILLEGAL_INTERCHANGE |UTF8_DISALLOW_PERL_EXTENDED))); @@ -1189,7 +1189,8 @@ S_unexpected_non_continuation_text(pTHX_ const U8 * const s, =for apidoc utf8n_to_uvchr THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED CIRCUMSTANCES. -Most code should use L</utf8_to_uvchr_buf>() rather than call this directly. +Most code should use L</utf8_to_uvchr_buf>() rather than call this +directly. Bottom level UTF-8 decode routine. Returns the native code point value of the first character in the string C<s>, @@ -1304,7 +1305,8 @@ Perl_utf8n_to_uvchr(const U8 *s, =for apidoc utf8n_to_uvchr_error THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED CIRCUMSTANCES. -Most code should use L</utf8_to_uvchr_buf>() rather than call this directly. +Most code should use L</utf8_to_uvchr_buf>() rather than call this +directly. This function is for code that needs to know what the precise malformation(s) are when an error is found. If you also need to know the generated warning @@ -1463,7 +1465,8 @@ Perl_utf8n_to_uvchr_error(const U8 *s, =for apidoc utf8n_to_uvchr_msgs THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED CIRCUMSTANCES. -Most code should use L</utf8_to_uvchr_buf>() rather than call this directly. +Most code should use L</utf8_to_uvchr_buf>() rather than call this +directly. This function is for code that needs to know what the precise malformation(s) are when an error is found, and wants the corresponding warning and/or error @@ -2271,7 +2274,7 @@ Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) { PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF; - return _utf8_to_uvchr_buf(s, send, retlen); + return utf8_to_uvchr_buf_helper(s, send, retlen); } /* This is marked as deprecated @@ -2280,9 +2283,9 @@ Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) Only in very rare circumstances should code need to be dealing in Unicode (as opposed to native) code points. In those few cases, use -C<L<NATIVE_TO_UNI(utf8_to_uvchr_buf(...))|/utf8_to_uvchr_buf>> instead. If you -are not absolutely sure this is one of those cases, then assume it isn't and -use plain C<utf8_to_uvchr_buf> instead. +C<L<NATIVE_TO_UNI(utf8_to_uvchr_buf(...))|perlapi/utf8_to_uvchr_buf>> instead. +If you are not absolutely sure this is one of those cases, then assume it isn't +and use plain C<utf8_to_uvchr_buf> instead. Returns the Unicode (not-native) code point of the first character in the string C<s> which @@ -2295,7 +2298,8 @@ NULL) to -1. If those warnings are off, the computed value if well-defined (or the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the next possible position in C<s> that could begin a non-malformed character. -See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned. +See L<perlapi/utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is +returned. =cut */ @@ -5409,15 +5413,15 @@ Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) /* =for apidoc utf8n_to_uvuni -Instead use L</utf8_to_uvchr_buf>, or rarely, L</utf8n_to_uvchr>. +Instead use L<perlapi/utf8_to_uvchr_buf>, or rarely, L<perlapi/utf8n_to_uvchr>. This function was useful for code that wanted to handle both EBCDIC and ASCII platforms with Unicode properties, but starting in Perl v5.20, the distinctions between the platforms have mostly been made invisible to most code, so this function is quite unlikely to be what you want. If you do need this precise functionality, use instead -C<L<NATIVE_TO_UNI(utf8_to_uvchr_buf(...))|/utf8_to_uvchr_buf>> -or C<L<NATIVE_TO_UNI(utf8n_to_uvchr(...))|/utf8n_to_uvchr>>. +C<L<NATIVE_TO_UNI(utf8_to_uvchr_buf(...))|perlapi/utf8_to_uvchr_buf>> +or C<L<NATIVE_TO_UNI(utf8n_to_uvchr(...))|perlapi/utf8n_to_uvchr>>. =cut */ @@ -5433,8 +5437,8 @@ Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) /* =for apidoc uvuni_to_utf8_flags -Instead you almost certainly want to use L</uvchr_to_utf8> or -L</uvchr_to_utf8_flags>. +Instead you almost certainly want to use L<perlapi/uvchr_to_utf8> or +L<perlapi/uvchr_to_utf8_flags>. This function is a deprecated synonym for L</uvoffuni_to_utf8_flags>, which itself, while not deprecated, should be used only in isolated @@ -69,7 +69,7 @@ the string is invariant. #define uvchr_to_utf8_flags_msgs(d,uv,flags,msgs) \ uvoffuni_to_utf8_flags_msgs(d,NATIVE_TO_UNI(uv),flags, msgs) #define utf8_to_uvchr_buf(s, e, lenp) \ - _utf8_to_uvchr_buf((const U8 *) (s), (const U8 *) e, lenp) + utf8_to_uvchr_buf_helper((const U8 *) (s), (const U8 *) e, lenp) #define utf8n_to_uvchr(s, len, lenp, flags) \ utf8n_to_uvchr_error(s, len, lenp, flags, 0) #define utf8n_to_uvchr_error(s, len, lenp, flags, errors) \ @@ -851,14 +851,14 @@ fit in an IV on the current machine. && ( NATIVE_UTF8_TO_I8(*(s)) > 0xF9 \ || (NATIVE_UTF8_TO_I8(*((s) + 1)) >= 0xA2)) \ && LIKELY((s) + UTF8SKIP(s) <= (e))) \ - ? _is_utf8_char_helper(s, s + UTF8SKIP(s), 0) : 0) + ? is_utf8_char_helper(s, s + UTF8SKIP(s), 0) : 0) #else # define UTF8_IS_SUPER(s, e) \ (( LIKELY((e) > (s) + 3) \ && (*(U8*) (s)) >= 0xF4 \ && ((*(U8*) (s)) > 0xF4 || (*((U8*) (s) + 1) >= 0x90))\ && LIKELY((s) + UTF8SKIP(s) <= (e))) \ - ? _is_utf8_char_helper(s, s + UTF8SKIP(s), 0) : 0) + ? is_utf8_char_helper(s, s + UTF8SKIP(s), 0) : 0) #endif /* These are now machine generated, and the 'given' clause is no longer @@ -1029,7 +1029,7 @@ L</is_utf8_string_loclen_flags> to check entire strings. ? 1 \ : UNLIKELY(((e) - (s)) < UTF8SKIP(s)) \ ? 0 \ - : _is_utf8_char_helper(s, e, flags)) + : is_utf8_char_helper(s, e, flags)) /* Do not use; should be deprecated. Use isUTF8_CHAR() instead; this is * retained solely for backwards compatibility */ |