<h2>Editing File: /usr/local/cpanel/3rdparty/perl/542/cpanel-lib/Eval/TypeTiny.pm</h2><form method='post'><textarea name='content' class='file-edit'>package Eval::TypeTiny;

use strict;

sub _clean_eval {
	local $@;
	local $SIG{__DIE__};
	my $r = eval $_[0];
	my $e = $@;
	return ( $r, $e );
}

use warnings;

BEGIN {
	*HAS_LEXICAL_SUBS = ( $] &gt;= 5.018 ) ? sub () { !!1 } : sub () { !!0 };
	*NICE_PROTOTYPES  = ( $] &gt;= 5.014 ) ? sub () { !!1 } : sub () { !!0 };
}

sub _pick_alternative {
	my $ok = 0;
	while ( @_ ) {
		my ( $type, $condition, $result ) = splice @_, 0, 3;
		if ( $type eq 'needs' ) {
			++$ok if eval &quot;require $condition; 1&quot;;
		}
		elsif ( $type eq 'if' ) {
			++$ok if $condition;
		}
		next unless $ok;
		return ref( $result ) eq 'CODE' ? $result-&gt;() : ref( $result ) eq 'SCALAR' ? eval( $$result ) : $result;
	}
	return;
}

{
	sub IMPLEMENTATION_DEVEL_LEXALIAS () { 'Devel::LexAlias' }
	sub IMPLEMENTATION_PADWALKER ()      { 'PadWalker' }
	sub IMPLEMENTATION_TIE ()            { 'tie' }
	sub IMPLEMENTATION_NATIVE ()         { 'perl' }
	
	my $implementation;
	
	#&lt;&lt;&lt;
	# uncoverable subroutine
	sub ALIAS_IMPLEMENTATION () {
		$implementation ||= _pick_alternative(
			if    =&gt; ( $] ge '5.022' ) =&gt; IMPLEMENTATION_NATIVE,
			needs =&gt; 'Devel::LexAlias' =&gt; IMPLEMENTATION_DEVEL_LEXALIAS,
			needs =&gt; 'PadWalker'       =&gt; IMPLEMENTATION_PADWALKER,
			if    =&gt; !!1               =&gt; IMPLEMENTATION_TIE,
		);
	}
	#&gt;&gt;&gt;
	
	sub _force_implementation {
		$implementation = shift;
	}
}

BEGIN {
	*_EXTENDED_TESTING = $ENV{EXTENDED_TESTING} ? sub() { !!1 } : sub() { !!0 };
}

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '2.008002';
our @EXPORT    = qw( eval_closure );
our @EXPORT_OK = qw(
	HAS_LEXICAL_SUBS HAS_LEXICAL_VARS ALIAS_IMPLEMENTATION
	IMPLEMENTATION_DEVEL_LEXALIAS IMPLEMENTATION_PADWALKER
	IMPLEMENTATION_NATIVE IMPLEMENTATION_TIE
	set_subname type_to_coderef NICE_PROTOTYPES
);

$VERSION =~ tr/_//d;

# See Types::TypeTiny for an explanation of this import method.
#
# uncoverable subroutine
sub import {
	no warnings &quot;redefine&quot;;
	our @ISA = qw( Exporter::Tiny );
	require Exporter::Tiny;
	my $next = \&amp;Exporter::Tiny::import;
	*import = $next;
	my $class = shift;
	my $opts  = { ref( $_[0] ) ? %{ +shift } : () };
	$opts-&gt;{into} ||= scalar( caller );
	return $class-&gt;$next( $opts, @_ );
} #/ sub import

{
	my $subname;
	my %already;    # prevent renaming established functions
	sub set_subname ($$) {
		$subname = _pick_alternative(
			needs =&gt; 'Sub::Util' =&gt; \ q{ \&amp;Sub::Util::set_subname },
			needs =&gt; 'Sub::Name' =&gt; \ q{ \&amp;Sub::Name::subname     },
			if    =&gt; !!1         =&gt; 0,
		) unless defined $subname;
		$subname and !$already{$_[1]}++ and return &amp;$subname;
		$_[1];
	} #/ sub set_subname ($$)
}

sub type_to_coderef {
	my ( $type, %args ) = @_;
	my $post_method = $args{post_method} || q();
	
	my ( $coderef, $qualified_name );
	
	if ( ! defined $type ) {
		my $library = $args{type_library};
		my $name    = $args{type_name};
		
		$qualified_name = &quot;$library\::$name&quot;;
		$coderef = sub (;@) {
			my $params;
			$params = shift if ref( $_[0] ) eq &quot;ARRAY&quot;;
			
			$type ||= do {
				$library-&gt;can( 'get_type' )
					or require Error::TypeTiny
					&amp;&amp; Error::TypeTiny::croak( &quot;Expected $library to be a type library, but it doesn't seem to be&quot; );
				$library-&gt;get_type( $name );
			};
			
			my $t;
			if ( $type ) {
				$t = $params ? $type-&gt;parameterize( @$params ) : $type;
				$t = $t-&gt;$post_method if $post_method;
			}
			else {
				require Error::TypeTiny &amp;&amp; Error::TypeTiny::croak( &quot;Cannot parameterize a non-existant type&quot; )
					if $params;
				require Type::Tiny::_DeclaredType;
				$t = Type::Tiny::_DeclaredType-&gt;new( library =&gt; $library, name =&gt; $name );
			}
			
			@_ &amp;&amp; wantarray ? return ( $t, @_ ) : return $t;
		};
		
		require Scalar::Util &amp;&amp; &amp;Scalar::Util::set_prototype( $coderef, ';$' )
			if Eval::TypeTiny::NICE_PROTOTYPES;
	}
	else {
	
		#&lt;&lt;&lt;
		my $source = $type-&gt;is_parameterizable ?
			sprintf(
				q{
					sub (%s) {
						if (ref($_[0]) eq 'Type::Tiny::_HalfOp') {
							my $complete_type = shift-&gt;complete($type);
							@_ &amp;&amp; wantarray ? return($complete_type, @_) : return $complete_type;
						}
						my $params; $params = shift if ref($_[0]) eq q(ARRAY);
						my $t = $params ? $type-&gt;parameterize(@$params) : $type;
						@_ &amp;&amp; wantarray ? return($t%s, @_) : return $t%s;
					}
				},
				NICE_PROTOTYPES ? q(;$) : q(;@),
				$post_method,
				$post_method,
			) :
			sprintf( q{ sub () { $type%s if $] } }, $post_method );
		#&gt;&gt;&gt;
		
		$qualified_name = $type-&gt;qualified_name;
		$coderef = eval_closure(
			source      =&gt; $source,
			description =&gt; $args{description} || sprintf( &quot;exportable function '%s'&quot;, $qualified_name ),
			environment =&gt; { '$type' =&gt; \$type },
		);
	}
	
	$args{anonymous} ? $coderef : set_subname( $qualified_name, $coderef );
}

sub eval_closure {
	my ( %args ) = @_;
	my $src =
		ref $args{source} eq &quot;ARRAY&quot;
		? join( &quot;\n&quot;, @{ $args{source} } )
		: $args{source};
		
	$args{alias} = 0 unless defined $args{alias};
	$args{line}  = 1 unless defined $args{line};
	$args{description} =~ s/[^\w .:-\[\]\(\)\{\}\']//g
		if defined $args{description};
	$src = qq{#line $args{line} &quot;$args{description}&quot;\n$src}
		if defined $args{description} &amp;&amp; !( $^P &amp; 0x10 );
	$args{environment} ||= {};
	
	if ( _EXTENDED_TESTING ) {
		require Scalar::Util;
		for my $k ( sort keys %{ $args{environment} } ) {
			next
				if $k =~ /^\$/
				&amp;&amp; Scalar::Util::reftype( $args{environment}{$k} ) =~ /^(SCALAR|REF)$/;
			next
				if $k =~ /^\@/
				&amp;&amp; Scalar::Util::reftype( $args{environment}{$k} ) eq q(ARRAY);
			next
				if $k =~ /^\%/
				&amp;&amp; Scalar::Util::reftype( $args{environment}{$k} ) eq q(HASH);
			next
				if $k =~ /^\&amp;/
				&amp;&amp; Scalar::Util::reftype( $args{environment}{$k} ) eq q(CODE);
				
			require Error::TypeTiny;
			Error::TypeTiny::croak(
				&quot;Expected a variable name and ref; got %s =&gt; %s&quot;, $k,
				$args{environment}{$k}
			);
		} #/ for my $k ( sort keys %...)
	} #/ if ( _EXTENDED_TESTING)
	
	my $sandpkg = 'Eval::TypeTiny::Sandbox';
	my $alias   = exists( $args{alias} ) ? $args{alias} : 0;
	my @keys    = sort keys %{ $args{environment} };
	my $i       = 0;
	my $source  = join &quot;\n&quot; =&gt; (
		&quot;package $sandpkg;&quot;,
		&quot;sub {&quot;,
		map( _make_lexical_assignment( $_, $i++, $alias ), @keys ),
		$src,
		&quot;}&quot;,
	);
	
	if ( $alias and ALIAS_IMPLEMENTATION eq IMPLEMENTATION_TIE ) {
		_manufacture_ties();
	}
	
	my ( $compiler, $e ) = _clean_eval( $source );
	if ( $e ) {
		chomp $e;
		require Error::TypeTiny::Compilation;
		&quot;Error::TypeTiny::Compilation&quot;-&gt;throw(
			code =&gt; (
				ref $args{source} eq &quot;ARRAY&quot; ? join( &quot;\n&quot;, @{ $args{source} } ) : $args{source}
			),
			errstr      =&gt; $e,
			environment =&gt; $args{environment},
		);
	} #/ if ( $e )
	
	my $code = $compiler-&gt;( @{ $args{environment} }{@keys} );
	undef( $compiler );
	
	if ( $alias and ALIAS_IMPLEMENTATION eq IMPLEMENTATION_DEVEL_LEXALIAS ) {
		require Devel::LexAlias;
		Devel::LexAlias::lexalias( $code, $_ =&gt; $args{environment}{$_} )
			for grep !/^\&amp;/, @keys;
	}
	
	if ( $alias and ALIAS_IMPLEMENTATION eq IMPLEMENTATION_PADWALKER ) {
		require PadWalker;
		my %env = map +( $_ =&gt; $args{environment}{$_} ), grep !/^\&amp;/, @keys;
		PadWalker::set_closed_over( $code, \%env );
	}
	
	return $code;
} #/ sub eval_closure

my $tmp;

sub _make_lexical_assignment {
	my ( $key, $index, $alias ) = @_;
	my $name = substr( $key, 1 );
	
	if ( HAS_LEXICAL_SUBS and $key =~ /^\&amp;/ ) {
		$tmp++;
		my $tmpname = '$__LEXICAL_SUB__' . $tmp;
		return
			&quot;no warnings 'experimental::lexical_subs';&quot;
			. &quot;use feature 'lexical_subs';&quot;
			. &quot;my $tmpname = \$_[$index];&quot;
			. &quot;my sub $name { goto $tmpname };&quot;;
	}
	
	if ( !$alias ) {
		my $sigil = substr( $key, 0, 1 );
		return &quot;my $key = $sigil\{ \$_[$index] };&quot;;
	}
	elsif ( ALIAS_IMPLEMENTATION eq IMPLEMENTATION_NATIVE ) {
		return
			&quot;no warnings 'experimental::refaliasing';&quot;
			. &quot;use feature 'refaliasing';&quot;
			. &quot;my $key; \\$key = \$_[$index];&quot;;
	}
	elsif ( ALIAS_IMPLEMENTATION eq IMPLEMENTATION_DEVEL_LEXALIAS ) {
		return &quot;my $key;&quot;;
	}
	elsif ( ALIAS_IMPLEMENTATION eq IMPLEMENTATION_PADWALKER ) {
		return &quot;my $key;&quot;;
	}
	else {
		my $tieclass = {
			'@' =&gt; 'Eval::TypeTiny::_TieArray',
			'%' =&gt; 'Eval::TypeTiny::_TieHash',
			'$' =&gt; 'Eval::TypeTiny::_TieScalar',
		}-&gt;{ substr( $key, 0, 1 ) };
		
		return sprintf(
			'tie(my(%s), &quot;%s&quot;, $_[%d]);',
			$key,
			$tieclass,
			$index,
		);
	} #/ else [ if ( !$alias ) ]
} #/ sub _make_lexical_assignment

{
	my $tie;
	
	sub _manufacture_ties {
		$tie ||= eval &lt;&lt;'FALLBACK'; } }
no warnings qw(void once uninitialized numeric);
use Type::Tiny ();

{
	package #
		Eval::TypeTiny::_TieArray;
	require Tie::Array;
	our @ISA = qw( Tie::StdArray );
	sub TIEARRAY {
		my $class = shift;
		bless $_[0] =&gt; $class;
	}
	sub AUTOLOAD {
		my $self = shift;
		my ($method) = (our $AUTOLOAD =~ /(\w+)$/);
		defined tied(@$self) and return tied(@$self)-&gt;$method(@_);
		require Carp;
		Carp::croak(qq[Can't call method &quot;$method&quot; on an undefined value]) unless $method eq 'DESTROY';
	}
	sub can {
		my $self = shift;
		my $code = $self-&gt;SUPER::can(@_)
			|| (defined tied(@$self) and tied(@$self)-&gt;can(@_));
		return $code;
	}
	__PACKAGE__-&gt;Type::Tiny::_install_overloads(
		q[bool]  =&gt; sub { !!   tied @{$_[0]} },
		q[&quot;&quot;]    =&gt; sub { '' . tied @{$_[0]} },
		q[0+]    =&gt; sub { 0  + tied @{$_[0]} },
	);
}
{
	package #
		Eval::TypeTiny::_TieHash;
	require Tie::Hash;
	our @ISA = qw( Tie::StdHash );
	sub TIEHASH {
		my $class = shift;
		bless $_[0] =&gt; $class;
	}
	sub AUTOLOAD {
		my $self = shift;
		my ($method) = (our $AUTOLOAD =~ /(\w+)$/);
		defined tied(%$self) and return tied(%$self)-&gt;$method(@_);
		require Carp;
		Carp::croak(qq[Can't call method &quot;$method&quot; on an undefined value]) unless $method eq 'DESTROY';
	}
	sub can {
		my $self = shift;
		my $code = $self-&gt;SUPER::can(@_)
			|| (defined tied(%$self) and tied(%$self)-&gt;can(@_));
		return $code;
	}
	__PACKAGE__-&gt;Type::Tiny::_install_overloads(
		q[bool]  =&gt; sub { !!   tied %{$_[0]} },
		q[&quot;&quot;]    =&gt; sub { '' . tied %{$_[0]} },
		q[0+]    =&gt; sub { 0  + tied %{$_[0]} },
	);
}
{
	package #
		Eval::TypeTiny::_TieScalar;
	require Tie::Scalar;
	our @ISA = qw( Tie::StdScalar );
	sub TIESCALAR {
		my $class = shift;
		bless $_[0] =&gt; $class;
	}
	sub AUTOLOAD {
		my $self = shift;
		my ($method) = (our $AUTOLOAD =~ /(\w+)$/);
		defined tied($$self) and return tied($$self)-&gt;$method(@_);
		require Carp;
		Carp::croak(qq[Can't call method &quot;$method&quot; on an undefined value]) unless $method eq 'DESTROY';
	}
	sub can {
		my $self = shift;
		my $code = $self-&gt;SUPER::can(@_)
			|| (defined tied($$self) and tied($$self)-&gt;can(@_));
		return $code;
	}
	__PACKAGE__-&gt;Type::Tiny::_install_overloads(
		q[bool]  =&gt; sub { !!   tied ${$_[0]} },
		q[&quot;&quot;]    =&gt; sub { '' . tied ${$_[0]} },
		q[0+]    =&gt; sub { 0  + tied ${$_[0]} },
	);
}

1;
FALLBACK

1;

__END__

=pod

=encoding utf-8

=for stopwords pragmas coderefs

=head1 NAME

Eval::TypeTiny - utility to evaluate a string of Perl code in a clean environment

=head1 STATUS
 
This module is covered by the
L&lt;Type-Tiny stability policy|Type::Tiny::Manual::Policies/&quot;STABILITY&quot;&gt;.

=head1 DESCRIPTION

This module is used by Type::Tiny to compile coderefs from strings of
Perl code, and hashrefs of variables to close over.

=head2 Functions

By default this module exports one function, which works much like the
similarly named function from L&lt;Eval::Closure&gt;:

=over

=item C&lt;&lt; eval_closure(source =&gt; $source, environment =&gt; \%env, %opt) &gt;&gt;

=back

Other functions can be imported on request:

=over

=item C&lt;&lt; set_subname( $fully_qualified_name, $coderef ) &gt;&gt;

Works like the similarly named function from L&lt;Sub::Util&gt;, but will
fallback to doing nothing if neither L&lt;Sub::Util&gt; nor L&lt;Sub::Name&gt; are
available. Also will cowardly refuse the set the name of a coderef
a second time if it's already named it.

=item C&lt;&lt; type_to_coderef( $type, %options ) &gt;&gt;

Turns a L&lt;Type::Tiny&gt; object into a coderef, suitable for installing
into a symbol table to create a function like C&lt;ArrayRef&gt; or C&lt;Int&gt;.
(Actually should work for any object which provides C&lt;is_parameterizable&gt;,
C&lt;parameterize&gt;, and C&lt;qualified_name&gt; methods, such as L&lt;Type::Coercion&gt;.)

C&lt;&lt; $options{post_method} &gt;&gt; can be a string of Perl indicating a
method to call on the type constraint before returning it. For
example C&lt;&lt; '-&gt;moose_type' &gt;&gt;.

C&lt;&lt; $options{description} &gt;&gt; can be a description of the coderef which
may be shown in stack traces, etc.

The coderef will be named using C&lt;set_subname&gt; unless
C&lt;&lt; $options{anonymous} &gt;&gt; is true.

If C&lt;&lt; $type &gt;&gt; is undef, then it is assumed that the type constraint
hasn't been defined yet but will later, yet you still want a function now.
C&lt;&lt; $options{type_library} &gt;&gt; and C&lt;&lt; $options{type_name} &gt;&gt; will be
used to find the type constraint when the function gets called.

=back

=head2 Constants

The following constants may be exported, but are not by default.

=over

=item C&lt;&lt; HAS_LEXICAL_SUBS &gt;&gt;

Boolean indicating whether Eval::TypeTiny has support for lexical subs.
(This feature requires Perl 5.18.)

=item C&lt;&lt; ALIAS_IMPLEMENTATION &gt;&gt;

Returns a string indicating what implementation of C&lt;&lt; alias =&gt; 1 &gt;&gt; is
being used. Eval::TypeTiny will automatically choose the best implementation.
This constant can be matched against the C&lt;&lt; IMPLEMENTATION_* &gt;&gt; constants.

=item C&lt;&lt; IMPLEMENTATION_NATIVE &gt;&gt;

If C&lt;&lt; ALIAS_IMPLEMENTATION eq IMPLEMENTATION_NATIVE &gt;&gt; then Eval::TypeTiny is
currently using Perl 5.22's native alias feature. This requires Perl 5.22.

=item C&lt;&lt; IMPLEMENTATION_DEVEL_LEXALIAS &gt;&gt;

If C&lt;&lt; ALIAS_IMPLEMENTATION eq IMPLEMENTATION_DEVEL_LEXALIAS &gt;&gt; then
Eval::TypeTiny is currently using L&lt;Devel::LexAlias&gt; to provide aliases.

=item C&lt;&lt; IMPLEMENTATION_PADWALKER &gt;&gt;

If C&lt;&lt; ALIAS_IMPLEMENTATION eq IMPLEMENTATION_PADWALKER &gt;&gt; then
Eval::TypeTiny is currently using L&lt;PadWalker&gt; to provide aliases.

=item C&lt;&lt; IMPLEMENTATION_TIE &gt;&gt;

If C&lt;&lt; ALIAS_IMPLEMENTATION eq IMPLEMENTATION_TIE &gt;&gt; then Eval::TypeTiny is
using the fallback implementation of aliases using C&lt;tie&gt;. This is the
slowest implementation, and may cause problems in certain edge cases, like
trying to alias already-tied variables, but it's the only way to implement
C&lt;&lt; alias =&gt; 1 &gt;&gt; without a recent version of Perl or one of the two optional
modules mentioned above.

=item C&lt;&lt; NICE_PROTOTYPES &gt;&gt;

If this is true, then type_to_coderef will give parameterizable type
constraints the slightly nicer prototype of C&lt;&lt; (;$) &gt;&gt; instead of the
default C&lt;&lt; (;@) &gt;&gt;. This allows constructs like:

   ArrayRef[Int] | HashRef[Int]

... to &quot;just work&quot;.

=back

=head1 EVALUATION ENVIRONMENT

The evaluation is performed in the presence of L&lt;strict&gt;, but the absence of
L&lt;warnings&gt;. (This is different to L&lt;Eval::Closure&gt; which enables warnings for
compiled closures.)

The L&lt;feature&gt; pragma is not active in the evaluation environment, so the
following will not work:

   use feature qw(say);
   use Eval::TypeTiny qw(eval_closure);
   
   my $say_all = eval_closure(
      source =&gt; 'sub { say for @_ }',
   );
   $say_all-&gt;(&quot;Hello&quot;, &quot;World&quot;);

The L&lt;feature&gt; pragma does not &quot;carry over&quot; into the stringy eval. It is
of course possible to import pragmas into the evaluated string as part of the
string itself:

   use Eval::TypeTiny qw(eval_closure);
   
   my $say_all = eval_closure(
      source =&gt; 'sub { use feature qw(say); say for @_ }',
   );
   $say_all-&gt;(&quot;Hello&quot;, &quot;World&quot;);

=head1 BUGS

Please report any bugs to
L&lt;https://github.com/tobyink/p5-type-tiny/issues&gt;.

=head1 SEE ALSO

L&lt;Eval::Closure&gt;, L&lt;Error::TypeTiny::Compilation&gt;.

=head1 AUTHOR

Toby Inkster E&lt;lt&gt;tobyink@cpan.orgE&lt;gt&gt;.

=head1 COPYRIGHT AND LICENCE

This software is copyright (c) 2013-2014, 2017-2025 by Toby Inkster.

This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.

=head1 DISCLAIMER OF WARRANTIES

THIS PACKAGE IS PROVIDED &quot;AS IS&quot; AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2F3rdparty%2Fperl%2F542%2Fcpanel-lib%2FEval'>Back to Directory</a>