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.22'; # 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");
}

if(_v0_23_0())
{
  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;
        }
      }
    }

  });

}
else
{

  $ffi->attach( [ wasmtime_instance_new => 'new' ] => ['wasm_store_t','wasm_module_t','opaque[]','size_t','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 $ptr;
      if(my $error = $xsub->($store, $module, \@imports, scalar(@imports), \$ptr, \$trap))
      {
        Carp::croak("error creating module: " . $error->message);
      }
      else
      {
        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__