File Coverage

blib/lib/Wasm/Wasmtime/Instance.pm

Criterion	Covered	Total	%
statement	46	48	95.8
branch	10	14	71.4
condition	4	6	66.6
subroutine	14	14	100.0
pod	2	2	100.0
total	76	84	90.4

package Wasm::Wasmtime::Instance;

use strict;
use warnings;
use 5.008004;
use Wasm::Wasmtime::FFI;
use Wasm::Wasmtime::Module;
use Wasm::Wasmtime::Extern;
use Wasm::Wasmtime::Func;
use Wasm::Wasmtime::Trap;
use Wasm::Wasmtime::Instance::Exports;
use Ref::Util qw( is_ref is_blessed_ref is_plain_coderef is_plain_scalarref );
use Carp ();

# ABSTRACT: Wasmtime instance class
our $VERSION = '0.23'; # VERSION


$ffi_prefix = 'wasm_instance_';
$ffi->load_custom_type('::PtrObject' => 'wasm_instance_t' => __PACKAGE__);


sub _cast_import
{
  my($ii, $mi, $store, $keep) = @_;
  if(ref($ii) eq 'Wasm::Wasmtime::Extern')
  {
    return $ii->{ptr};
  }
  elsif(is_blessed_ref($ii) && $ii->isa('Wasm::Wasmtime::Extern'))
  {
    return $ii->{ptr};
  }
  elsif(is_plain_coderef($ii))
  {
    if($mi->type->kind eq 'functype')
    {
      my $f = Wasm::Wasmtime::Func->new(
        $store,
        $mi->type,
        $ii,
      );
      push @$keep, $f;
      return $f->{ptr};
    }
  }
  elsif(is_plain_scalarref($ii) || !defined $ii)
  {
    if($mi->type->kind eq 'memorytype')
    {
      my $m = Wasm::Wasmtime::Memory->new(
        $store,
        $mi->type,
      );
      $$ii = $m if defined $ii;
      push @$keep, $m;
      return $m->{ptr};
    }
  }
  Carp::croak("Non-extern object as import");
}

require FFI::Platypus::Memory;

$ffi->attach( [ wasmtime_instance_new => 'new' ] => ['wasm_store_t','wasm_module_t','record(Wasm::Wasmtime::Vec)*','opaque*','opaque*'] => 'wasmtime_error_t' => sub {
  my $xsub = shift;
  my $class = shift;
  my $module = shift;
  my $store = is_blessed_ref($_[0]) && $_[0]->isa('Wasm::Wasmtime::Store')
    ? shift
    : Carp::croak('Creating a Wasm::Wasmtime::Instance instance without a Wasm::Wasmtime::Store object is no longer allowed');

  my $ptr;
  my @keep;

  if(defined $_[0] && !is_ref($_[0]))
  {
    ($ptr) = @_;
    return bless {
      ptr    => $ptr,
      module => $module,
      keep   => \@keep,
    }, $class;
  }
  else
  {
    my($imports) = @_;

    $imports ||= [];
    Carp::confess("imports is not an array reference") unless ref($imports) eq 'ARRAY';
    my @imports = @$imports;
    my $trap;

    {
      my @mi = @{ $module->imports };
      if(@mi != @imports)
      {
        Carp::croak("Got @{[ scalar @imports ]} imports, but expected @{[ scalar @mi ]}");
      }

      @imports = map { _cast_import($_, shift @mi, $store, \@keep) } @imports;
    }

    my $imports_vec = Wasm::Wasmtime::Vec->new(
      size => scalar @imports,
      data => scalar(@imports) > 0 ? do {
        my $count = scalar @imports;
        my $ptr = FFI::Platypus::Memory::malloc($ffi->sizeof('opaque') * $count);
        # void *memcpy(void *dest, const void *src, size_t n)
        FFI::Platypus->new( lib => [undef] )->function( 'memcpy' => [ 'opaque', "opaque[$count]", 'size_t' ] => 'opaque' )->call($ptr, \@imports, $ffi->sizeof('opaque') * $count);
      } : undef,
    );

    my $ptr;
    if(my $error = $xsub->($store, $module, $imports_vec, \$ptr, \$trap))
    {
      FFI::Platypus::Memory::free($imports_vec->data) if defined $imports_vec->data;
      Carp::croak("error creating module: " . $error->message);
    }
    else
    {
      FFI::Platypus::Memory::free($imports_vec->data) if defined $imports_vec->data;
      if($trap)
      {
        $trap = Wasm::Wasmtime::Trap->new($trap);
        die $trap;
      }
      else
      {
        return bless {
          ptr    => $ptr,
          module => $module,
          keep   => \@keep,
        }, $class;
      }
    }
  }

});


sub module { shift->{module} }


sub exports
{
  Wasm::Wasmtime::Instance::Exports->new(shift);
}

$ffi->attach( [ exports => '_exports' ] => ['wasm_instance_t','wasm_extern_vec_t*'] => sub {
  my($xsub, $self) = @_;
  my $externs = Wasm::Wasmtime::ExternVec->new;
  $xsub->($self, $externs);
  $externs->to_list;
});

_generate_destroy();

1;

__END__