File Coverage

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

Criterion	Covered	Total	%
statement	20	27	74.0
branch	4	12	33.3
condition			n/a
subroutine	2	3	66.6
pod	0	2	0.0
total	26	44	59.0

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

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

	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} };

		# If this module exports C API functions from its library, need to add
		# the XS library itself to the libs.
		if ($self->{c_api}) {
			require DynaLoader;
			my @search= map File::Spec->catdir($_, qw( auto Crypt SecretBuffer )), @INC;
			my $path= DynaLoader::dl_findfile(map("-L$_", @search), "SecretBuffer")
				or die "Can't locate shared library for module $class (looked for SecretBuffer.$DynaLoader::dl_dlext)";
			my ($vol,$dirs,$file) = File::Spec->splitpath($path);
			$dirs =~ s,[\\/]$,,; # remove trailing slash

			# On win32, need to reference the '.a' or '.lib' file instead of the '.dll'
			if ($^O eq 'MSWin32') {
				my $libfile= substr($file, 0, -1-length $DynaLoader::dl_dlext);
				if (-f File::Spec->catpath($vol, $dirs, "$libfile.lib")) { # MSVC
					$file= "$libfile.lib";
				} elsif (-f File::Spec->catpath($vol, $dirs, "$libfile.a")) { # MinGW
					$file= "$libfile.a";
				} else {
					warn "Can't determine import library name from $path; didn't find $libfile.lib or $libfile.a in $dirs";
				}
			}
			my $libpath = File::Spec->catpath($vol,$dirs,'');
			$vars->{LIBS}= "-L"._maybe_quote_path($libpath)." -l$file $vars->{LIBS}";
		}
		return $vars;
	}

1;