<h2>Edit File - ProxySubs.pm</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/share/perl5/ExtUtils/Constant/ProxySubs.pm">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">package ExtUtils::Constant::ProxySubs;

use strict;
use vars qw($VERSION @ISA %type_to_struct %type_from_struct %type_to_sv
	    %type_to_C_value %type_is_a_problem %type_num_args
	    %type_temporary);
use Carp;
require ExtUtils::Constant::XS;
use ExtUtils::Constant::Utils qw(C_stringify);
use ExtUtils::Constant::XS qw(%XS_TypeSet);

$VERSION = &#039;0.08&#039;;
@ISA = &#039;ExtUtils::Constant::XS&#039;;

%type_to_struct =
    (
     IV =&gt; &#039;{const char *name; I32 namelen; IV value;}&#039;,
     NV =&gt; &#039;{const char *name; I32 namelen; NV value;}&#039;,
     UV =&gt; &#039;{const char *name; I32 namelen; UV value;}&#039;,
     PV =&gt; &#039;{const char *name; I32 namelen; const char *value;}&#039;,
     PVN =&gt; &#039;{const char *name; I32 namelen; const char *value; STRLEN len;}&#039;,
     YES =&gt; &#039;{const char *name; I32 namelen;}&#039;,
     NO =&gt; &#039;{const char *name; I32 namelen;}&#039;,
     UNDEF =&gt; &#039;{const char *name; I32 namelen;}&#039;,
     &#039;&#039; =&gt; &#039;{const char *name; I32 namelen;} &#039;,
     );

%type_from_struct =
    (
     IV =&gt; sub { $_[0] . &#039;-&gt;value&#039; },
     NV =&gt; sub { $_[0] . &#039;-&gt;value&#039; },
     UV =&gt; sub { $_[0] . &#039;-&gt;value&#039; },
     PV =&gt; sub { $_[0] . &#039;-&gt;value&#039; },
     PVN =&gt; sub { $_[0] . &#039;-&gt;value&#039;, $_[0] . &#039;-&gt;len&#039; },
     YES =&gt; sub {},
     NO =&gt; sub {},
     UNDEF =&gt; sub {},
     &#039;&#039; =&gt; sub {},
    );

%type_to_sv = 
    (
     IV =&gt; sub { &quot;newSViv($_[0])&quot; },
     NV =&gt; sub { &quot;newSVnv($_[0])&quot; },
     UV =&gt; sub { &quot;newSVuv($_[0])&quot; },
     PV =&gt; sub { &quot;newSVpv($_[0], 0)&quot; },
     PVN =&gt; sub { &quot;newSVpvn($_[0], $_[1])&quot; },
     YES =&gt; sub { &#039;&amp;PL_sv_yes&#039; },
     NO =&gt; sub { &#039;&amp;PL_sv_no&#039; },
     UNDEF =&gt; sub { &#039;&amp;PL_sv_undef&#039; },
     &#039;&#039; =&gt; sub { &#039;&amp;PL_sv_yes&#039; },
     SV =&gt; sub {&quot;SvREFCNT_inc($_[0])&quot;},
     );

%type_to_C_value = 
    (
     YES =&gt; sub {},
     NO =&gt; sub {},
     UNDEF =&gt; sub {},
     &#039;&#039; =&gt; sub {},
     );

sub type_to_C_value {
    my ($self, $type) = @_;
    return $type_to_C_value{$type} || sub {return map {ref $_ ? @$_ : $_} @_};
}

# TODO - figure out if there is a clean way for the type_to_sv code to
# attempt s/sv_2mortal// and if it succeeds tell type_to_sv not to add
# SvREFCNT_inc
%type_is_a_problem =
    (
     # The documentation says *mortal SV*, but we now need a non-mortal copy.
     SV =&gt; 1,
     );

%type_temporary =
    (
     SV =&gt; [&#039;SV *&#039;],
     PV =&gt; [&#039;const char *&#039;],
     PVN =&gt; [&#039;const char *&#039;, &#039;STRLEN&#039;],
     );
$type_temporary{$_} = [$_] foreach qw(IV UV NV);
     
while (my ($type, $value) = each %XS_TypeSet) {
    $type_num_args{$type}
	= defined $value ? ref $value ? scalar @$value : 1 : 0;
}
$type_num_args{&#039;&#039;} = 0;

sub partition_names {
    my ($self, $default_type, @items) = @_;
    my (%found, @notfound, @trouble);

    while (my $item = shift @items) {
	my $default = delete $item-&gt;{default};
	if ($default) {
	    # If we find a default value, convert it into a regular item and
	    # append it to the queue of items to process
	    my $default_item = {%$item};
	    $default_item-&gt;{invert_macro} = 1;
	    $default_item-&gt;{pre} = delete $item-&gt;{def_pre};
	    $default_item-&gt;{post} = delete $item-&gt;{def_post};
	    $default_item-&gt;{type} = shift @$default;
	    $default_item-&gt;{value} = $default;
	    push @items, $default_item;
	} else {
	    # It can be &quot;not found&quot; unless it&#039;s the default (invert the macro)
	    # or the &quot;macro&quot; is an empty string (ie no macro)
	    push @notfound, $item unless $item-&gt;{invert_macro}
		or !$self-&gt;macro_to_ifdef($self-&gt;macro_from_item($item));
	}

	if ($item-&gt;{pre} or $item-&gt;{post} or $item-&gt;{not_constant}
	    or $type_is_a_problem{$item-&gt;{type}}) {
	    push @trouble, $item;
	} else {
	    push @{$found{$item-&gt;{type}}}, $item;
	}
    }
    # use Data::Dumper; print Dumper \%found;
    (\%found, \@notfound, \@trouble);
}

sub boottime_iterator {
    my ($self, $type, $iterator, $hash, $subname, $push) = @_;
    my $extractor = $type_from_struct{$type};
    die &quot;Can&#039;t find extractor code for type $type&quot;
	unless defined $extractor;
    my $generator = $type_to_sv{$type};
    die &quot;Can&#039;t find generator code for type $type&quot;
	unless defined $generator;

    my $athx = $self-&gt;C_constant_prefix_param();

    if ($push) {
	return sprintf &lt;&lt;&quot;EOBOOT&quot;, &amp;$generator(&amp;$extractor($iterator));
        while ($iterator-&gt;name) {
	    he = $subname($athx $hash, $iterator-&gt;name,
				     $iterator-&gt;namelen, %s);
	    av_push(push, newSVhek(HeKEY_hek(he)));
            ++$iterator;
	}
EOBOOT
    } else {
	return sprintf &lt;&lt;&quot;EOBOOT&quot;, &amp;$generator(&amp;$extractor($iterator));
        while ($iterator-&gt;name) {
	    $subname($athx $hash, $iterator-&gt;name,
				$iterator-&gt;namelen, %s);
            ++$iterator;
	}
EOBOOT
    }
}

sub name_len_value_macro {
    my ($self, $item) = @_;
    my $name = $item-&gt;{name};
    my $value = $item-&gt;{value};
    $value = $item-&gt;{name} unless defined $value;

    my $namelen = length $name;
    if ($name =~ tr/\0-\377// != $namelen) {
	# the hash API signals UTF-8 by passing the length negated.
	utf8::encode($name);
	$namelen = -length $name;
    }
    $name = C_stringify($name);

    my $macro = $self-&gt;macro_from_item($item);
    ($name, $namelen, $value, $macro);
}

sub WriteConstants {
    my $self = shift;
    my $ARGS = {@_};

    my ($c_fh, $xs_fh, $c_subname, $default_type, $package)
	= @{$ARGS}{qw(C_FH XS_FH C_SUBNAME DEFAULT_TYPE NAME)};

    my $xs_subname
	= exists $ARGS-&gt;{XS_SUBNAME} ? $ARGS-&gt;{XS_SUBNAME} : &#039;constant&#039;;

    my $options = $ARGS-&gt;{PROXYSUBS};
    $options = {} unless ref $options;
    my $push = $options-&gt;{push};
    my $explosives = $options-&gt;{croak_on_read};
    my $croak_on_error = $options-&gt;{croak_on_error};
    my $autoload = $options-&gt;{autoload};
    {
	my $exclusive = 0;
	++$exclusive if $explosives;
	++$exclusive if $croak_on_error;
	++$exclusive if $autoload;

	# Until someone patches this (with test cases):
	carp (&quot;PROXYSUBS options &#039;autoload&#039;, &#039;croak_on_read&#039; and &#039;croak_on_error&#039; cannot be used together&quot;)
	    if $exclusive &gt; 1;
    }
    # Strictly it requires Perl_caller_cx
    carp (&quot;PROXYSUBS option &#039;croak_on_error&#039; requires v5.13.5 or later&quot;)
	if $croak_on_error &amp;&amp; $^V &lt; v5.13.5;
    # Strictly this is actually 5.8.9, but it&#039;s not well tested there
    my $can_do_pcs = $] &gt;= 5.009;
    # Until someone patches this (with test cases)
    carp (&quot;PROXYSUBS option &#039;push&#039; requires v5.10 or later&quot;)
	if $push &amp;&amp; !$can_do_pcs;
    # Until someone patches this (with test cases)
    carp (&quot;PROXYSUBS options &#039;push&#039; and &#039;croak_on_read&#039; cannot be used together&quot;)
	if $explosives &amp;&amp; $push;

    # If anyone is insane enough to suggest a package name containing %
    my $package_sprintf_safe = $package;
    $package_sprintf_safe =~ s/%/%%/g;

    # All the types we see
    my $what = {};
    # A hash to lookup items with.
    my $items = {};

    my @items = $self-&gt;normalise_items ({disable_utf8_duplication =&gt; 1},
					$default_type, $what, $items,
					@{$ARGS-&gt;{NAMES}});

    # Partition the values by type. Also include any defaults in here
    # Everything that doesn&#039;t have a default needs alternative code for
    # &quot;I&#039;m missing&quot;
    # And everything that has pre or post code ends up in a private block
    my ($found, $notfound, $trouble)
	= $self-&gt;partition_names($default_type, @items);

    my $pthx = $self-&gt;C_constant_prefix_param_defintion();
    my $athx = $self-&gt;C_constant_prefix_param();
    my $symbol_table = C_stringify($package) . &#039;::&#039;;
    $push = C_stringify($package . &#039;::&#039; . $push) if $push;
    my $cast_CONSTSUB = $] &lt; 5.010 ? &#039;(char *)&#039; : &#039;&#039;;

    print $c_fh $self-&gt;header();
    if ($autoload || $croak_on_error) {
	print $c_fh &lt;&lt;&#039;EOC&#039;;

/* This allows slightly more efficient code on !USE_ITHREADS: */
#ifdef USE_ITHREADS
#  define COP_FILE(c)	CopFILE(c)
#  define COP_FILE_F	&quot;s&quot;
#else
#  define COP_FILE(c)	CopFILESV(c)
#  define COP_FILE_F	SVf
#endif
EOC
    }

    my $return_type = $push ? &#039;HE *&#039; : &#039;void&#039;;

    print $c_fh &lt;&lt;&quot;EOADD&quot;;

static $return_type
${c_subname}_add_symbol($pthx HV *hash, const char *name, I32 namelen, SV *value) {
EOADD
    if (!$can_do_pcs) {
	print $c_fh &lt;&lt;&#039;EO_NOPCS&#039;;
    if (namelen == namelen) {
EO_NOPCS
    } else {
	print $c_fh &lt;&lt;&quot;EO_PCS&quot;;
    HE *he = (HE*) hv_common_key_len(hash, name, namelen, HV_FETCH_LVALUE, NULL,
				     0);
    SV *sv;

    if (!he) {
        Perl_croak($athx &quot;Couldn&#039;t add key &#039;%s&#039; to %%$package_sprintf_safe\::&quot;,
		   name);
    }
    sv = HeVAL(he);
    if (SvOK(sv) || SvTYPE(sv) == SVt_PVGV) {
	/* Someone has been here before us - have to make a real sub.  */
EO_PCS
    }
    # This piece of code is common to both
    print $c_fh &lt;&lt;&quot;EOADD&quot;;
	newCONSTSUB(hash, ${cast_CONSTSUB}name, value);
EOADD
    if ($can_do_pcs) {
	print $c_fh &lt;&lt;&#039;EO_PCS&#039;;
    } else {
	SvUPGRADE(sv, SVt_RV);
	SvRV_set(sv, value);
	SvROK_on(sv);
	SvREADONLY_on(value);
    }
EO_PCS
    } else {
	print $c_fh &lt;&lt;&#039;EO_NOPCS&#039;;
    }
EO_NOPCS
    }
    print $c_fh &quot;    return he;\n&quot; if $push;
    print $c_fh &lt;&lt;&#039;EOADD&#039;;
}

EOADD

    print $c_fh $explosives ? &lt;&lt;&quot;EXPLODE&quot; : &quot;\n&quot;;

static int
Im_sorry_Dave(pTHX_ SV *sv, MAGIC *mg)
{
    PERL_UNUSED_ARG(mg);
    Perl_croak(aTHX_
	       &quot;Your vendor has not defined $package_sprintf_safe macro %&quot;SVf
	       &quot; used&quot;, sv);
    NORETURN_FUNCTION_END;
}

static MGVTBL not_defined_vtbl = {
 Im_sorry_Dave, /* get - I&#039;m afraid I can&#039;t do that */
 Im_sorry_Dave, /* set */
 0, /* len */
 0, /* clear */
 0, /* free */
 0, /* copy */
 0, /* dup */
};

EXPLODE

{
    my $key = $symbol_table;
    # Just seems tidier (and slightly more space efficient) not to have keys
    # such as Fcntl::
    $key =~ s/::$//;
    my $key_len = length $key;

    print $c_fh &lt;&lt;&quot;MISSING&quot;;

#ifndef SYMBIAN

/* Store a hash of all symbols missing from the package. To avoid trampling on
   the package namespace (uninvited) put each package&#039;s hash in our namespace.
   To avoid creating lots of typeblogs and symbol tables for sub-packages, put
   each package&#039;s hash into one hash in our namespace.  */

static HV *
get_missing_hash(pTHX) {
    HV *const parent
	= get_hv(&quot;ExtUtils::Constant::ProxySubs::Missing&quot;, GVf_MULTI);
    /* We could make a hash of hashes directly, but this would confuse anything
	at Perl space that looks at us, and as we&#039;re visible in Perl space,
	best to play nice. */
    SV *const *const ref
	= hv_fetch(parent, &quot;$key&quot;, $key_len, TRUE);
    HV *new_hv;

    if (!ref)
	return NULL;

    if (SvROK(*ref))
	return (HV*) SvRV(*ref);

    new_hv = newHV();
    SvUPGRADE(*ref, SVt_RV);
    SvRV_set(*ref, (SV *)new_hv);
    SvROK_on(*ref);
    return new_hv;
}

#endif

MISSING

}

    print $xs_fh &lt;&lt;&quot;EOBOOT&quot;;
BOOT:
  {
#ifdef dTHX
    dTHX;
#endif
    HV *symbol_table = get_hv(&quot;$symbol_table&quot;, GV_ADD);
EOBOOT
    if ($push) {
	print $xs_fh &lt;&lt;&quot;EOC&quot;;
    AV *push = get_av(\&quot;$push\&quot;, GV_ADD);
    HE *he;
EOC
    }

    my %iterator;

    $found-&gt;{&#039;&#039;}
        = [map {{%$_, type=&gt;&#039;&#039;, invert_macro =&gt; 1}} @$notfound];

    foreach my $type (sort keys %$found) {
	my $struct = $type_to_struct{$type};
	my $type_to_value = $self-&gt;type_to_C_value($type);
	my $number_of_args = $type_num_args{$type};
	die &quot;Can&#039;t find structure definition for type $type&quot;
	    unless defined $struct;

	my $lc_type = $type ? lc($type) : &#039;notfound&#039;;
	my $struct_type = $lc_type . &#039;_s&#039;;
	my $array_name = &#039;values_for_&#039; . $lc_type;
	$iterator{$type} = &#039;value_for_&#039; . $lc_type;
	# Give the notfound struct file scope. The others are scoped within the
	# BOOT block
	my $struct_fh = $type ? $xs_fh : $c_fh;

	print $c_fh &quot;struct $struct_type $struct;\n&quot;;

	print $struct_fh &lt;&lt;&quot;EOBOOT&quot;;

    static const struct $struct_type $array_name\[] =
      {
EOBOOT


	foreach my $item (@{$found-&gt;{$type}}) {
            my ($name, $namelen, $value, $macro)
                 = $self-&gt;name_len_value_macro($item);

	    my $ifdef = $self-&gt;macro_to_ifdef($macro);
	    if (!$ifdef &amp;&amp; $item-&gt;{invert_macro}) {
		carp(&quot;Attempting to supply a default for &#039;$name&#039; which has no conditional macro&quot;);
		next;
	    }
	    if ($item-&gt;{invert_macro}) {
		print $struct_fh $self-&gt;macro_to_ifndef($macro);
		print $struct_fh
			&quot;        /* This is the default value: */\n&quot; if $type;
	    } else {
		print $struct_fh $ifdef;
	    }
	    print $struct_fh &quot;        { &quot;, join (&#039;, &#039;, &quot;\&quot;$name\&quot;&quot;, $namelen,
						 &amp;$type_to_value($value)),
						 &quot; },\n&quot;,
						 $self-&gt;macro_to_endif($macro);
	}

    # Terminate the list with a NULL
	print $struct_fh &quot;        { NULL, 0&quot;, (&quot;, 0&quot; x $number_of_args), &quot; } };\n&quot;;

	print $xs_fh &lt;&lt;&quot;EOBOOT&quot; if $type;
	const struct $struct_type *$iterator{$type} = $array_name;
EOBOOT
    }

    delete $found-&gt;{&#039;&#039;};

    my $add_symbol_subname = $c_subname . &#039;_add_symbol&#039;;
    foreach my $type (sort keys %$found) {
	print $xs_fh $self-&gt;boottime_iterator($type, $iterator{$type}, 
					      &#039;symbol_table&#039;,
					      $add_symbol_subname, $push);
    }

    print $xs_fh &lt;&lt;&quot;EOBOOT&quot;;
	if (C_ARRAY_LENGTH(values_for_notfound) &gt; 1) {
#ifndef SYMBIAN
	    HV *const ${c_subname}_missing = get_missing_hash(aTHX);
#endif
	    const struct notfound_s *value_for_notfound = values_for_notfound;
	    do {
EOBOOT

    print $xs_fh $explosives ? &lt;&lt;&quot;EXPLODE&quot; : &lt;&lt; &quot;DONT&quot;;
		SV *tripwire = newSV(0);
		
		sv_magicext(tripwire, 0, PERL_MAGIC_ext, &amp;not_defined_vtbl, 0, 0);
		SvPV_set(tripwire, (char *)value_for_notfound-&gt;name);
		if(value_for_notfound-&gt;namelen &gt;= 0) {
		    SvCUR_set(tripwire, value_for_notfound-&gt;namelen);
	    	} else {
		    SvCUR_set(tripwire, -value_for_notfound-&gt;namelen);
		    SvUTF8_on(tripwire);
		}
		SvPOKp_on(tripwire);
		SvREADONLY_on(tripwire);
		assert(SvLEN(tripwire) == 0);

		$add_symbol_subname($athx symbol_table, value_for_notfound-&gt;name,
				    value_for_notfound-&gt;namelen, tripwire);
EXPLODE

		/* Need to add prototypes, else parsing will vary by platform.  */
		HE *he = (HE*) hv_common_key_len(symbol_table,
						 value_for_notfound-&gt;name,
						 value_for_notfound-&gt;namelen,
						 HV_FETCH_LVALUE, NULL, 0);
		SV *sv;
#ifndef SYMBIAN
		HEK *hek;
#endif
		if (!he) {
		    Perl_croak($athx
			       &quot;Couldn&#039;t add key &#039;%s&#039; to %%$package_sprintf_safe\::&quot;,
			       value_for_notfound-&gt;name);
		}
		sv = HeVAL(he);
		if (!SvOK(sv) &amp;&amp; SvTYPE(sv) != SVt_PVGV) {
		    /* Nothing was here before, so mark a prototype of &quot;&quot;  */
		    sv_setpvn(sv, &quot;&quot;, 0);
		} else if (SvPOK(sv) &amp;&amp; SvCUR(sv) == 0) {
		    /* There is already a prototype of &quot;&quot; - do nothing  */
		} else {
		    /* Someone has been here before us - have to make a real
		       typeglob.  */
		    /* It turns out to be incredibly hard to deal with all the
		       corner cases of sub foo (); and reporting errors correctly,
		       so lets cheat a bit.  Start with a constant subroutine  */
		    CV *cv = newCONSTSUB(symbol_table,
					 ${cast_CONSTSUB}value_for_notfound-&gt;name,
					 &amp;PL_sv_yes);
		    /* and then turn it into a non constant declaration only.  */
		    SvREFCNT_dec(CvXSUBANY(cv).any_ptr);
		    CvCONST_off(cv);
		    CvXSUB(cv) = NULL;
		    CvXSUBANY(cv).any_ptr = NULL;
		}
#ifndef SYMBIAN
		hek = HeKEY_hek(he);
		if (!hv_common(${c_subname}_missing, NULL, HEK_KEY(hek),
 			       HEK_LEN(hek), HEK_FLAGS(hek), HV_FETCH_ISSTORE,
			       &amp;PL_sv_yes, HEK_HASH(hek)))
		    Perl_croak($athx &quot;Couldn&#039;t add key &#039;%s&#039; to missing_hash&quot;,
			       value_for_notfound-&gt;name);
#endif
DONT

    print $xs_fh &quot;		av_push(push, newSVhek(hek));\n&quot;
	if $push;

    print $xs_fh &lt;&lt;&quot;EOBOOT&quot;;
	    } while ((++value_for_notfound)-&gt;name);
	}
EOBOOT

    foreach my $item (@$trouble) {
        my ($name, $namelen, $value, $macro)
	    = $self-&gt;name_len_value_macro($item);
        my $ifdef = $self-&gt;macro_to_ifdef($macro);
        my $type = $item-&gt;{type};
	my $type_to_value = $self-&gt;type_to_C_value($type);

        print $xs_fh $ifdef;
	if ($item-&gt;{invert_macro}) {
	    print $xs_fh
		 &quot;        /* This is the default value: */\n&quot; if $type;
	    print $xs_fh &quot;#else\n&quot;;
	}
	my $generator = $type_to_sv{$type};
	die &quot;Can&#039;t find generator code for type $type&quot;
	    unless defined $generator;

	print $xs_fh &quot;        {\n&quot;;
	# We need to use a temporary value because some really troublesome
	# items use C pre processor directives in their values, and in turn
	# these don&#039;t fit nicely in the macro-ised generator functions
	my $counter = 0;
	printf $xs_fh &quot;            %s temp%d;\n&quot;, $_, $counter++
	    foreach @{$type_temporary{$type}};

	print $xs_fh &quot;            $item-&gt;{pre}\n&quot; if $item-&gt;{pre};

	# And because the code in pre might be both declarations and
	# statements, we can&#039;t declare and assign to the temporaries in one.
	$counter = 0;
	printf $xs_fh &quot;            temp%d = %s;\n&quot;, $counter++, $_
	    foreach &amp;$type_to_value($value);

	my @tempvarnames = map {sprintf &#039;temp%d&#039;, $_} 0 .. $counter - 1;
	printf $xs_fh &lt;&lt;&quot;EOBOOT&quot;, $name, &amp;$generator(@tempvarnames);
	    ${c_subname}_add_symbol($athx symbol_table, &quot;%s&quot;,
				    $namelen, %s);
EOBOOT
	print $xs_fh &quot;        $item-&gt;{post}\n&quot; if $item-&gt;{post};
	print $xs_fh &quot;        }\n&quot;;

        print $xs_fh $self-&gt;macro_to_endif($macro);
    }

    if ($] &gt;= 5.009) {
	print $xs_fh &lt;&lt;EOBOOT;
    /* As we&#039;ve been creating subroutines, we better invalidate any cached
       methods  */
    mro_method_changed_in(symbol_table);
  }
EOBOOT
    } else {
	print $xs_fh &lt;&lt;EOBOOT;
    /* As we&#039;ve been creating subroutines, we better invalidate any cached
       methods  */
    ++PL_sub_generation;
  }
EOBOOT
    }

    return if !defined $xs_subname;

    if ($croak_on_error || $autoload) {
        print $xs_fh $croak_on_error ? &lt;&lt;&quot;EOC&quot; : &lt;&lt;&#039;EOA&#039;;

void
$xs_subname(sv)
    INPUT:
	SV *		sv;
    PREINIT:
	const PERL_CONTEXT *cx = caller_cx(0, NULL);
	/* cx is NULL if we&#039;ve been called from the top level. PL_curcop isn&#039;t
	   ideal, but it&#039;s much cheaper than other ways of not going SEGV.  */
	const COP *cop = cx ? cx-&gt;blk_oldcop : PL_curcop;
EOC

void
AUTOLOAD()
    PROTOTYPE: DISABLE
    PREINIT:
	SV *sv = newSVpvn_flags(SvPVX(cv), SvCUR(cv), SVs_TEMP | SvUTF8(cv));
	const COP *cop = PL_curcop;
EOA
        print $xs_fh &lt;&lt;&quot;EOC&quot;;
    PPCODE:
#ifndef SYMBIAN
	/* It&#039;s not obvious how to calculate this at C pre-processor time.
	   However, any compiler optimiser worth its salt should be able to
	   remove the dead code, and hopefully the now-obviously-unused static
	   function too.  */
	HV *${c_subname}_missing = (C_ARRAY_LENGTH(values_for_notfound) &gt; 1)
	    ? get_missing_hash(aTHX) : NULL;
	if ((C_ARRAY_LENGTH(values_for_notfound) &gt; 1)
	    ? hv_exists_ent(${c_subname}_missing, sv, 0) : 0) {
	    sv = newSVpvf(&quot;Your vendor has not defined $package_sprintf_safe macro %&quot; SVf
			  &quot;, used at %&quot; COP_FILE_F &quot; line %&quot; UVuf &quot;\\n&quot;, 
			  sv, COP_FILE(cop), (UV)CopLINE(cop));
	} else
#endif
	{
	    sv = newSVpvf(&quot;%&quot;SVf&quot; is not a valid $package_sprintf_safe macro at %&quot;
			  COP_FILE_F &quot; line %&quot; UVuf &quot;\\n&quot;,
			  sv, COP_FILE(cop), (UV)CopLINE(cop));
	}
	croak_sv(sv_2mortal(sv));
EOC
    } else {
        print $xs_fh $explosives ? &lt;&lt;&quot;EXPLODE&quot; : &lt;&lt;&quot;DONT&quot;;

void
$xs_subname(sv)
    INPUT:
	SV *		sv;
    PPCODE:
	sv = newSVpvf(&quot;Your vendor has not defined $package_sprintf_safe macro %&quot; SVf
			  &quot;, used&quot;, sv);
        PUSHs(sv_2mortal(sv));
EXPLODE

void
$xs_subname(sv)
    INPUT:
	SV *		sv;
    PPCODE:
#ifndef SYMBIAN
	/* It&#039;s not obvious how to calculate this at C pre-processor time.
	   However, any compiler optimiser worth its salt should be able to
	   remove the dead code, and hopefully the now-obviously-unused static
	   function too.  */
	HV *${c_subname}_missing = (C_ARRAY_LENGTH(values_for_notfound) &gt; 1)
	    ? get_missing_hash(aTHX) : NULL;
	if ((C_ARRAY_LENGTH(values_for_notfound) &gt; 1)
	    ? hv_exists_ent(${c_subname}_missing, sv, 0) : 0) {
	    sv = newSVpvf(&quot;Your vendor has not defined $package_sprintf_safe macro %&quot; SVf
			  &quot;, used&quot;, sv);
	} else
#endif
	{
	    sv = newSVpvf(&quot;%&quot;SVf&quot; is not a valid $package_sprintf_safe macro&quot;,
			  sv);
	}
	PUSHs(sv_2mortal(sv));
DONT
    }
}

1;
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>