SkidSec WebShell

Server Address : 172.31.38.4

Web Server : Apache/2.4.58 (Ubuntu)

Uname : Linux ip-172-31-38-4 6.14.0-1017-aws #17~24.04.1-Ubuntu SMP Wed Nov 5 10:48:17 UTC 2025 x86_64

PHP Version : 7.4.33

package ExtUtils::Constant; use vars qw (@ISA $VERSION @EXPORT_OK %EXPORT_TAGS); $VERSION = '0.25'; =head1 NAME ExtUtils::Constant - generate XS code to import C header constants =head1 SYNOPSIS use ExtUtils::Constant qw (WriteConstants); WriteConstants( NAME => 'Foo', NAMES => [qw(FOO BAR BAZ)], ); # Generates wrapper code to make the values of the constants FOO BAR BAZ # available to perl =head1 DESCRIPTION ExtUtils::Constant facilitates generating C and XS wrapper code to allow perl modules to AUTOLOAD constants defined in C library header files. It is principally used by the C<h2xs> utility, on which this code is based. It doesn't contain the routines to scan header files to extract these constants. =head1 USAGE Generally one only needs to call the C<WriteConstants> function, and then #include "const-c.inc" in the C section of C<Foo.xs> INCLUDE: const-xs.inc in the XS section of C<Foo.xs>. For greater flexibility use C<constant_types()>, C<C_constant> and C<XS_constant>, with which C<WriteConstants> is implemented. Currently this module understands the following types. h2xs may only know a subset. The sizes of the numeric types are chosen by the C<Configure> script at compile time. =over 4 =item IV signed integer, at least 32 bits. =item UV unsigned integer, the same size as I<IV> =item NV floating point type, probably C<double>, possibly C<long double> =item PV NUL terminated string, length will be determined with C<strlen> =item PVN A fixed length thing, given as a [pointer, length] pair. If you know the length of a string at compile time you may use this instead of I<PV> =item SV A B<mortal> SV. =item YES Truth. (C<PL_sv_yes>) The value is not needed (and ignored). =item NO Defined Falsehood. (C<PL_sv_no>) The value is not needed (and ignored). =item UNDEF C<undef>. The value of the macro is not needed. =back =head1 FUNCTIONS =over 4 =cut if ($] >= 5.006) { eval "use warnings; 1" or die $@; } use strict; use Carp qw(croak cluck); use Exporter; use ExtUtils::Constant::Utils qw(C_stringify); use ExtUtils::Constant::XS qw(%XS_Constant %XS_TypeSet); @ISA = 'Exporter'; %EXPORT_TAGS = ( 'all' => [ qw( XS_constant constant_types return_clause memEQ_clause C_stringify C_constant autoload WriteConstants WriteMakefileSnippet ) ] ); @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } ); =item constant_types A function returning a single scalar with C<#define> definitions for the constants used internally between the generated C and XS functions. =cut sub constant_types { ExtUtils::Constant::XS->header(); } sub memEQ_clause { cluck "ExtUtils::Constant::memEQ_clause is deprecated"; ExtUtils::Constant::XS->memEQ_clause({name=>$_[0], checked_at=>$_[1], indent=>$_[2]}); } sub return_clause ($$) { cluck "ExtUtils::Constant::return_clause is deprecated"; my $indent = shift; ExtUtils::Constant::XS->return_clause({indent=>$indent}, @_); } sub switch_clause { cluck "ExtUtils::Constant::switch_clause is deprecated"; my $indent = shift; my $comment = shift; ExtUtils::Constant::XS->switch_clause({indent=>$indent, comment=>$comment}, @_); } sub C_constant { my ($package, $subname, $default_type, $what, $indent, $breakout, @items) = @_; ExtUtils::Constant::XS->C_constant({package => $package, subname => $subname, default_type => $default_type, types => $what, indent => $indent, breakout => $breakout}, @items); } =item XS_constant PACKAGE, TYPES, XS_SUBNAME, C_SUBNAME A function to generate the XS code to implement the perl subroutine I<PACKAGE>::constant used by I<PACKAGE>::AUTOLOAD to load constants. This XS code is a wrapper around a C subroutine usually generated by C<C_constant>, and usually named C<constant>. I<TYPES> should be given either as a comma separated list of types that the C subroutine C<constant> will generate or as a reference to a hash. It should be the same list of types as C<C_constant> was given. [Otherwise C<XS_constant> and C<C_constant> may have different ideas about the number of parameters passed to the C function C<constant>] You can call the perl visible subroutine something other than C<constant> if you give the parameter I<XS_SUBNAME>. The C subroutine it calls defaults to the name of the perl visible subroutine, unless you give the parameter I<C_SUBNAME>. =cut sub XS_constant { my $package = shift; my $what = shift; my $XS_subname = shift; my $C_subname = shift; $XS_subname ||= 'constant'; $C_subname ||= $XS_subname; if (!ref $what) { # Convert line of the form IV,UV,NV to hash $what = {map {$_ => 1} split /,\s*/, ($what)}; } my $params = ExtUtils::Constant::XS->params ($what); my $type; my $xs = <<"EOT"; void $XS_subname(sv) PREINIT: #ifdef dXSTARG dXSTARG; /* Faster if we have it. */ #else dTARGET; #endif STRLEN len; int type; EOT if ($params->{IV}) { $xs .= " IV iv = 0; /* avoid uninit var warning */\n"; } else { $xs .= " /* IV\t\tiv;\tUncomment this if you need to return IVs */\n"; } if ($params->{NV}) { $xs .= " NV nv = 0.0; /* avoid uninit var warning */\n"; } else { $xs .= " /* NV\t\tnv;\tUncomment this if you need to return NVs */\n"; } if ($params->{PV}) { $xs .= " const char *pv = NULL; /* avoid uninit var warning */\n"; } else { $xs .= " /* const char\t*pv;\tUncomment this if you need to return PVs */\n"; } $xs .= << 'EOT'; INPUT: SV * sv; const char * s = SvPV(sv, len); EOT if ($params->{''}) { $xs .= << 'EOT'; INPUT: int utf8 = SvUTF8(sv); EOT } $xs .= << 'EOT'; PPCODE: EOT if ($params->{IV} xor $params->{NV}) { $xs .= << "EOT"; /* Change this to $C_subname(aTHX_ s, len, &iv, &nv); if you need to return both NVs and IVs */ EOT } $xs .= " type = $C_subname(aTHX_ s, len"; $xs .= ', utf8' if $params->{''}; $xs .= ', &iv' if $params->{IV}; $xs .= ', &nv' if $params->{NV}; $xs .= ', &pv' if $params->{PV}; $xs .= ', &sv' if $params->{SV}; $xs .= ");\n"; # If anyone is insane enough to suggest a package name containing % my $package_sprintf_safe = $package; $package_sprintf_safe =~ s/%/%%/g; $xs .= << "EOT"; /* Return 1 or 2 items. First is error message, or undef if no error. Second, if present, is found value */ switch (type) { case PERL_constant_NOTFOUND: sv = sv_2mortal(newSVpvf("%s is not a valid $package_sprintf_safe macro", s)); PUSHs(sv); break; case PERL_constant_NOTDEF: sv = sv_2mortal(newSVpvf( "Your vendor has not defined $package_sprintf_safe macro %s, used", s)); PUSHs(sv); break; EOT foreach $type (sort keys %XS_Constant) { # '' marks utf8 flag needed. next if $type eq ''; $xs .= "\t/* Uncomment this if you need to return ${type}s\n" unless $what->{$type}; $xs .= " case PERL_constant_IS$type:\n"; if (length $XS_Constant{$type}) { $xs .= << "EOT"; EXTEND(SP, 2); PUSHs(&PL_sv_undef); $XS_Constant{$type}; EOT } else { # Do nothing. return (), which will be correctly interpreted as # (undef, undef) } $xs .= " break;\n"; unless ($what->{$type}) { chop $xs; # Yes, another need for chop not chomp. $xs .= " */\n"; } } $xs .= << "EOT"; default: sv = sv_2mortal(newSVpvf( "Unexpected return type %d while processing $package_sprintf_safe macro %s, used", type, s)); PUSHs(sv); } EOT return $xs; } =item autoload PACKAGE, VERSION, AUTOLOADER A function to generate the AUTOLOAD subroutine for the module I<PACKAGE> I<VERSION> is the perl version the code should be backwards compatible with. It defaults to the version of perl running the subroutine. If I<AUTOLOADER> is true, the AUTOLOAD subroutine falls back on AutoLoader::AUTOLOAD for all names that the constant() routine doesn't recognise. =cut # ' # Grr. syntax highlighters that don't grok pod. sub autoload { my ($module, $compat_version, $autoloader) = @_; $compat_version ||= $]; croak "Can't maintain compatibility back as far as version $compat_version" if $compat_version < 5; my $func = "sub AUTOLOAD {\n" . " # This AUTOLOAD is used to 'autoload' constants from the constant()\n" . " # XS function."; $func .= " If a constant is not found then control is passed\n" . " # to the AUTOLOAD in AutoLoader." if $autoloader; $func .= "\n\n" . " my \$constname;\n"; $func .= " our \$AUTOLOAD;\n" if ($compat_version >= 5.006); $func .= <<"EOT"; (\$constname = \$AUTOLOAD) =~ s/.*:://; croak "&${module}::constant not defined" if \$constname eq 'constant'; my (\$error, \$val) = constant(\$constname); EOT if ($autoloader) { $func .= <<'EOT'; if ($error) { if ($error =~ /is not a valid/) { $AutoLoader::AUTOLOAD = $AUTOLOAD; goto &AutoLoader::AUTOLOAD; } else { croak $error; } } EOT } else { $func .= " if (\$error) { croak \$error; }\n"; } $func .= <<'END'; { no strict 'refs'; # Fixed between 5.005_53 and 5.005_61 #XXX if ($] >= 5.00561) { #XXX *$AUTOLOAD = sub () { $val }; #XXX } #XXX else { *$AUTOLOAD = sub { $val }; #XXX } } goto &$AUTOLOAD; } END return $func; } =item WriteMakefileSnippet WriteMakefileSnippet ATTRIBUTE =E<gt> VALUE [, ...] A function to generate perl code for Makefile.PL that will regenerate the constant subroutines. Parameters are named as passed to C<WriteConstants>, with the addition of C<INDENT> to specify the number of leading spaces (default 2). Currently only C<INDENT>, C<NAME>, C<DEFAULT_TYPE>, C<NAMES>, C<C_FILE> and C<XS_FILE> are recognised. =cut sub WriteMakefileSnippet { my %args = @_; my $indent = $args{INDENT} || 2; my $result = <<"EOT"; ExtUtils::Constant::WriteConstants( NAME => '$args{NAME}', NAMES => \\\@names, DEFAULT_TYPE => '$args{DEFAULT_TYPE}', EOT foreach (qw (C_FILE XS_FILE)) { next unless exists $args{$_}; $result .= sprintf " %-12s => '%s',\n", $_, $args{$_}; } $result .= <<'EOT'; ); EOT $result =~ s/^/' 'x$indent/gem; return ExtUtils::Constant::XS->dump_names({default_type=>$args{DEFAULT_TYPE}, indent=>$indent,}, @{$args{NAMES}}) . $result; } =item WriteConstants ATTRIBUTE =E<gt> VALUE [, ...] Writes a file of C code and a file of XS code which you should C<#include> and C<INCLUDE> in the C and XS sections respectively of your module's XS code. You probably want to do this in your C<Makefile.PL>, so that you can easily edit the list of constants without touching the rest of your module. The attributes supported are =over 4 =item NAME Name of the module. This must be specified =item DEFAULT_TYPE The default type for the constants. If not specified C<IV> is assumed. =item BREAKOUT_AT The names of the constants are grouped by length. Generate child subroutines for each group with this number or more names in. =item NAMES An array of constants' names, either scalars containing names, or hashrefs as detailed in L<"C_constant">. =item PROXYSUBS If true, uses proxy subs. See L<ExtUtils::Constant::ProxySubs>. =item C_FH A filehandle to write the C code to. If not given, then I<C_FILE> is opened for writing. =item C_FILE The name of the file to write containing the C code. The default is C<const-c.inc>. The C<-> in the name ensures that the file can't be mistaken for anything related to a legitimate perl package name, and not naming the file C<.c> avoids having to override Makefile.PL's C<.xs> to C<.c> rules. =item XS_FH A filehandle to write the XS code to. If not given, then I<XS_FILE> is opened for writing. =item XS_FILE The name of the file to write containing the XS code. The default is C<const-xs.inc>. =item XS_SUBNAME The perl visible name of the XS subroutine generated which will return the constants. The default is C<constant>. =item C_SUBNAME The name of the C subroutine generated which will return the constants. The default is I<XS_SUBNAME>. Child subroutines have C<_> and the name length appended, so constants with 10 character names would be in C<constant_10> with the default I<XS_SUBNAME>. =back =cut sub WriteConstants { my %ARGS = ( # defaults C_FILE => 'const-c.inc', XS_FILE => 'const-xs.inc', XS_SUBNAME => 'constant', DEFAULT_TYPE => 'IV', @_); $ARGS{C_SUBNAME} ||= $ARGS{XS_SUBNAME}; # No-one sane will have C_SUBNAME eq '0' croak "Module name not specified" unless length $ARGS{NAME}; # Do this before creating (empty) files, in case it fails: require ExtUtils::Constant::ProxySubs if $ARGS{PROXYSUBS}; my $c_fh = $ARGS{C_FH}; if (!$c_fh) { if ($] <= 5.008) { # We need these little games, rather than doing things # unconditionally, because we're used in core Makefile.PLs before # IO is available (needed by filehandle), but also we want to work on # older perls where undefined scalars do not automatically turn into # anonymous file handles. require FileHandle; $c_fh = FileHandle->new(); } open $c_fh, ">$ARGS{C_FILE}" or die "Can't open $ARGS{C_FILE}: $!"; } my $xs_fh = $ARGS{XS_FH}; if (!$xs_fh) { if ($] <= 5.008) { require FileHandle; $xs_fh = FileHandle->new(); } open $xs_fh, ">$ARGS{XS_FILE}" or die "Can't open $ARGS{XS_FILE}: $!"; } # As this subroutine is intended to make code that isn't edited, there's no # need for the user to specify any types that aren't found in the list of # names. if ($ARGS{PROXYSUBS}) { $ARGS{C_FH} = $c_fh; $ARGS{XS_FH} = $xs_fh; ExtUtils::Constant::ProxySubs->WriteConstants(%ARGS); } else { my $types = {}; print $c_fh constant_types(); # macro defs print $c_fh "\n"; # indent is still undef. Until anyone implements indent style rules with # it. foreach (ExtUtils::Constant::XS->C_constant({package => $ARGS{NAME}, subname => $ARGS{C_SUBNAME}, default_type => $ARGS{DEFAULT_TYPE}, types => $types, breakout => $ARGS{BREAKOUT_AT}}, @{$ARGS{NAMES}})) { print $c_fh $_, "\n"; # C constant subs } print $xs_fh XS_constant ($ARGS{NAME}, $types, $ARGS{XS_SUBNAME}, $ARGS{C_SUBNAME}); } close $c_fh or warn "Error closing $ARGS{C_FILE}: $!" unless $ARGS{C_FH}; close $xs_fh or warn "Error closing $ARGS{XS_FILE}: $!" unless $ARGS{XS_FH}; } 1; __END__ =back =head1 AUTHOR Nicholas Clark <nick@ccl4.org> based on the code in C<h2xs> by Larry Wall and others =cut