File Coverage

blib/arch/Crypt/SecretBuffer/Install/Files.pm

Criterion	Covered	Total	%
statement	24	33	72.7
branch	4	10	40.0
condition			n/a
subroutine	3	4	75.0
pod	0	2	0.0
total	31	49	63.2

package Crypt::SecretBuffer::Install::Files;

$self = {
          'c_api' => [
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_charset_from_regexpref',
                         'prototype' => 'secret_buffer_charset * secret_buffer_charset_from_regexpref(SV *ref)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_charset_test_byte',
                         'prototype' => 'bool secret_buffer_charset_test_byte(const secret_buffer_charset *cset, U8 b)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_charset_test_codepoint',
                         'prototype' => 'bool secret_buffer_charset_test_codepoint(const secret_buffer_charset *cset, U32 cp)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_parse_init',
                         'prototype' => 'bool secret_buffer_parse_init(secret_buffer_parse *parse, secret_buffer *buf, size_t pos, size_t lim, int encoding)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_parse_init_from_sv',
                         'prototype' => 'bool secret_buffer_parse_init_from_sv(secret_buffer_parse *parse, SV *sv)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_span_new_obj',
                         'prototype' => 'SV * secret_buffer_span_new_obj(secret_buffer *buf, size_t pos, size_t lim, int encoding)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_span_new_obj_from_parse',
                         'prototype' => 'SV * secret_buffer_span_new_obj_from_parse(secret_buffer_parse *p)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_match',
                         'prototype' => 'bool secret_buffer_match(secret_buffer_parse *p, SV *pattern, int flags)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_match_charset',
                         'prototype' => 'bool secret_buffer_match_charset(secret_buffer_parse *p, secret_buffer_charset *cset, int flags)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_match_bytestr',
                         'prototype' => 'bool secret_buffer_match_bytestr(secret_buffer_parse *p, char *data, size_t datalen, int flags)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_sizeof_transcode',
                         'prototype' => 'SSize_t secret_buffer_sizeof_transcode(secret_buffer_parse *src, int dst_encoding)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_transcode',
                         'prototype' => 'bool secret_buffer_transcode(secret_buffer_parse *src, secret_buffer_parse_rw *dst)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_copy_to',
                         'prototype' => 'bool secret_buffer_copy_to(secret_buffer_parse *src, SV *dst_sv, int encoding, bool append)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_new',
                         'prototype' => 'secret_buffer * secret_buffer_new(size_t capacity, SV **ref_out)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_from_magic',
                         'prototype' => 'secret_buffer * secret_buffer_from_magic(SV *ref, int flags)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_realloc',
                         'prototype' => 'void secret_buffer_realloc(secret_buffer *buf, size_t new_capacity)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_alloc_at_least',
                         'prototype' => 'void secret_buffer_alloc_at_least(secret_buffer *buf, size_t min_capacity)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_set_len',
                         'prototype' => 'void secret_buffer_set_len(secret_buffer *buf, size_t new_len)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_append_uv_asn1_der_length',
                         'prototype' => 'void secret_buffer_append_uv_asn1_der_length(secret_buffer *buf, UV val)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_parse_uv_asn1_der_length',
                         'prototype' => 'bool secret_buffer_parse_uv_asn1_der_length(secret_buffer_parse *parse, UV *out)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_append_uv_base128le',
                         'prototype' => 'void secret_buffer_append_uv_base128le(secret_buffer *buf, UV val)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_parse_uv_base128le',
                         'prototype' => 'bool secret_buffer_parse_uv_base128le(secret_buffer_parse *parse, UV *out)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_append_uv_base128be',
                         'prototype' => 'void secret_buffer_append_uv_base128be(secret_buffer *buf, UV val)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_parse_uv_base128be',
                         'prototype' => 'bool secret_buffer_parse_uv_base128be(secret_buffer_parse *parse, UV *out)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_splice',
                         'prototype' => 'void secret_buffer_splice(secret_buffer *buf, size_t ofs, size_t len, const char *replacement, size_t replacement_len)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_splice_sv',
                         'prototype' => 'void secret_buffer_splice_sv(secret_buffer *buf, size_t ofs, size_t len, SV *replacement)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_SvPVbyte',
                         'prototype' => 'const char * secret_buffer_SvPVbyte(SV *thing, STRLEN *len_out)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_append_random',
                         'prototype' => 'IV secret_buffer_append_random(secret_buffer *buf, size_t n, unsigned flags)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_append_sysread',
                         'prototype' => 'IV secret_buffer_append_sysread(secret_buffer *buf, PerlIO *fh, size_t count)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_append_read',
                         'prototype' => 'IV secret_buffer_append_read(secret_buffer *buf, PerlIO *fh, size_t count)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_append_console_line',
                         'prototype' => 'int secret_buffer_append_console_line(secret_buffer *buf, PerlIO *fh)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_syswrite',
                         'prototype' => 'IV secret_buffer_syswrite(secret_buffer *buf, PerlIO *fh, IV offset, IV count)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_write_async',
                         'prototype' => 'IV secret_buffer_write_async(secret_buffer *buf, PerlIO *fh, IV offset, IV count, SV **ref_out)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_result_check',
                         'prototype' => 'bool secret_buffer_result_check(SV *promise_ref, int timeout_msec, IV *wrote, IV *os_err)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_get_stringify_sv',
                         'prototype' => 'SV * secret_buffer_get_stringify_sv(secret_buffer *buf)'
                       },
                       {
                         'module' => 'Crypt::SecretBuffer',
                         'name' => 'secret_buffer_wipe',
                         'prototype' => 'void secret_buffer_wipe(char *buf, size_t len)'
                       }
                     ],
          'deps' => [],
          'inc' => '',
          'libs' => '-lpthread',
          'typemaps' => [
                          'typemap'
                        ]
        };

@deps = @{ $self->{deps} };
@typemaps = @{ $self->{typemaps} };
$libs = $self->{libs};
$inc = $self->{inc};

	$CORE = undef;
	foreach (@INC) {
		if ( -f $_ . "/Crypt/SecretBuffer/Install/Files.pm") {
			$CORE = $_ . "/Crypt/SecretBuffer/Install/";
			last;
		}
	}

	sub deps { @{ $self->{deps} }; }
	# Given a perl Module::Name, determine what shared library name DynaLoader
	# wants to load for it, and then resolve the absolute path to that file.
	# For Windows, return the name of the import library (.lib or .a) instead
	# of the name of the shared lib (.dll) itself, because that's what belongs
	# on the linker line.
	# It would be much preferable to determine the file name being generated
	# by MakeMaker ahead of time, but I can't find any way to extract that
	# piece of knowledge from MakeMaker, and besides which MakeMaker hasn't
	# been invoked yet and we don't have all the parameters to do so.
	sub _resolve_lib_for_module {
		my ($mod)= @_;
		my ($mod_lib_basename)= ($mod =~ m,([^:]+)\z,);
		$mod_lib_basename= DynaLoader::mod2fname($mod_lib_basename) if DynaLoader->can('mod2fname');
		my @search= map File::Spec->catdir($_, qw( auto Crypt SecretBuffer )), @INC;
		my $path= DynaLoader::dl_findfile(map("-L$_", @search), $mod_lib_basename)
			or die "Can't locate shared library for module $mod (looked for $mod_lib_basename.$DynaLoader::dl_dlext)";

		# On win32, need to reference the '.a' or '.lib' file instead of the '.dll'
		if ($^O eq 'MSWin32') {
			my ($vol,$dirs,$file) = File::Spec->splitpath($path);
			(my $base= $file) =~ s/.[^.]+\z//; # remove file extension
			for ("$base.lib",      # MSVC
			     "$file.a",        # MinGW
			     # Try some others for good measure
			     "$file.lib", "$base.a"
			) {
				my $p= File::Spec->catpath($vol, $dirs, $_);
				return $p if -f $p;
			}
			warn "Can't determine import library name from $path; didn't find $base.lib or $file.a in $dirs";
			return undef;
		}
		return $path;
	}

	sub _maybe_quote_path {
		return $_[0] =~ / /? qq{"$_[0]"} : $_[0]
	}

	sub Inline {
		my ($class, $lang) = @_;

		# Calculate the install path for this module
		require File::Spec;
		my ($vol,$dirs) = File::Spec->splitpath(File::Spec->rel2abs(__FILE__));
		my $instpath= File::Spec->catpath($vol,$dirs,'');
		$instpath =~ s,[\\/]$,,; # remove trailing slash

		# Prepare the vars for Inline
		my $vars= +{ map { (uc($_) => $self->{$_}) } qw(inc libs typemaps) };

		# Include this module's own path in INC
		$vars->{INC}= "-I"._maybe_quote_path($instpath)." $vars->{INC}",

		# Convert typemaps to absolute paths
		$_= File::Spec->rel2abs($_, $instpath) for @{ $vars->{TYPEMAPS} };

		# This module exports C API functions from its library, so need to add
		# the XS library itself to the libs.
		require DynaLoader;
		my %distinct_modules;
		$distinct_modules{$_->{module}}++ for @{ $self->{c_api} };
		my @libs= grep defined, map _resolve_lib_for_module($_), sort keys %distinct_modules;
		$vars->{LIBS}= join(' ', map _maybe_quote_path($_), @libs, grep length, $vars->{LIBS});

		return $vars;
	}
1;