Result:
found more than 1104 distributions - search limited to the first 2001 files matching your query ( run in 1.431 )


Furl-Cookies
1 match

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN 

sv_release_COW|||
sv_release_IVX|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.006000||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.006000||p

 view all matches for this distribution


Fuse-Class
1 match

 view release on metacpan or  search on metacpan

test/fuse28.pm  view on Meta::CPAN 

#
package test::fuse28::Directory;

use Fcntl qw(:mode);
use base qw(test::fuse28::Entity);
use Scalar::Util qw(weaken);

sub new {
    my $class = shift;
    my $parent = shift;

test/fuse28.pm  view on Meta::CPAN 

    }

    $self->{children} = {};

    # avoid cyclic reference
    weaken($self->{parent});

    bless $self, $class;
}

sub parent {

test/fuse28.pm  view on Meta::CPAN 

# Symlink
#
package test::fuse28::Symlink;

use base qw(test::fuse28::Entity);
use Scalar::Util qw(weaken);

sub new {
    my $class = shift;
    my ($existing) = @_;

 view all matches for this distribution


Future-AsyncAwait-Frozen
2 results

 view release on metacpan or  search on metacpan

lib/Future/AsyncAwait/Frozen.c  view on Meta::CPAN 

  if(SvREFCNT(curcv) < 2) {
    croak("AWAIT_ON_READY failed to capture the CV");
  }

  state->awaiting_future = newSVsv(f);
  sv_rvweaken(state->awaiting_future);

  if(!state->returning_future)
    state->returning_future = future_new_from_proto(f);

  if(defer_mortal_curcv)

lib/Future/AsyncAwait/Frozen.c  view on Meta::CPAN 

  PUSHMARK(SP);
  mPUSHs(newSVsv(state->returning_future));
  PUTBACK;

  if(!SvWEAKREF(state->returning_future))
    sv_rvweaken(state->returning_future);
  if(!SvROK(state->returning_future))
    panic("ARGH we lost state->returning_future for curcv=%p\n", curcv);

/* For unknown reasons, doing this on perls 5.20 or 5.22 massively breaks
 * everything.

 view all matches for this distribution


Future-AsyncAwait
1 match

 view release on metacpan or  search on metacpan

lib/Future/AsyncAwait.xs  view on Meta::CPAN 

  if(SvREFCNT(curcv) < 2) {
    croak("AWAIT_ON_READY failed to capture the CV");
  }

  state->awaiting_future = newSVsv(f);
  sv_rvweaken(state->awaiting_future);

  if(!state->returning_future) {
    state->returning_future = future_new_from_proto(f);

    if(precancel) {

lib/Future/AsyncAwait.xs  view on Meta::CPAN 

  PUSHMARK(SP);
  mPUSHs(newSVsv(state->returning_future));
  PUTBACK;

  if(!SvWEAKREF(state->returning_future))
    sv_rvweaken(state->returning_future);
  if(!SvROK(state->returning_future))
    panic("ARGH we lost state->returning_future for curcv=%p\n", curcv);

#ifdef HAVE_FUTURE_CHAIN_CANCEL
  future_chain_on_cancel(state->returning_future, state->awaiting_future);

 view all matches for this distribution


Future-Batch-XS
1 match

 view release on metacpan or  search on metacpan

lib/Future/Batch/ppport.h  view on Meta::CPAN 

SvROK_off|5.003007|5.003007|
SvROK_on|5.003007|5.003007|
SvRV|5.003007|5.003007|
SvRV_const|5.010001||Viu
SvRV_set|5.009003|5.003007|p
sv_rvunweaken|5.027004|5.027004|
sv_rvweaken|5.006000|5.006000|
SvRVx|5.003007||Viu
SvRX|5.009005|5.003007|p
SvRXOK|5.009005|5.003007|p
SV_SAVED_COPY|5.009005||Viu
SvSCREAM|5.003007||Viu

 view all matches for this distribution


Future-Buffer
1 match

 view release on metacpan or  search on metacpan

lib/Future/Buffer.pm  view on Meta::CPAN 

use v5.14;
use warnings;

use Future;

use Scalar::Util qw( weaken );

=head1 NAME

C<Future::Buffer> - a string buffer that uses Futures

lib/Future/Buffer.pm  view on Meta::CPAN 

   my $fill = $self->{fill};

   # Arm the fill loop
   my $f = $self->{fill_f} = $fill->(); # TODO: give it a size hint?

   weaken( my $weakself = $self );

   $f->on_done( sub {
      my $self = $weakself or return;

      undef $self->{fill_f};

 view all matches for this distribution


Future-Mojo
1 match

 view release on metacpan or  search on metacpan

lib/Future/Mojo.pm  view on Meta::CPAN 

package Future::Mojo;

use strict;
use warnings;
use Carp 'croak';
use Scalar::Util 'blessed', 'weaken';
use Mojo::IOLoop;
use Role::Tiny::With;

use parent 'Future';

lib/Future/Mojo.pm  view on Meta::CPAN 

}

sub _set_timer {
	my ($self, $succeed, $after) = @_;
	
	weaken(my $weakself = $self);
	my $cb = $succeed ? sub { $weakself->done if $weakself }
		: sub { $weakself->fail('Timeout') if $weakself };
	my $id = $self->loop->timer($after => $cb);
	
	$self->on_cancel(sub { shift->loop->remove($id) });

lib/Future/Mojo.pm  view on Meta::CPAN 

		if $self->loop->is_running;
	$self->loop->one_tick until $self->is_ready;
}

sub done_next_tick {
	weaken(my $self = shift);
	my @result = @_;
	
	$self->loop->next_tick(sub { $self->done(@result) if $self });
	
	return $self;
}

sub fail_next_tick {
	weaken(my $self = shift);
	my ($exception, @details) = @_;
	
	croak 'Expected a true exception' unless $exception;
	
	$self->loop->next_tick(sub { $self->fail($exception, @details) if $self });

 view all matches for this distribution


Future-Q
1 match

 view release on metacpan or  search on metacpan

lib/Future/Q.pm  view on Meta::CPAN 

use strict;
use warnings;
use Future 0.29;
use parent "Future";
use Devel::GlobalDestruction;
use Scalar::Util qw(refaddr blessed weaken);
use Carp;
use Try::Tiny ();

our $VERSION = '0.120';

lib/Future/Q.pm  view on Meta::CPAN 

            $return_future = $class->try($on_fulfilled, $invo_future->get);
        }
        $next_future->resolve($return_future);
    });
    if($next_future->is_pending && $self->is_pending) {
        weaken(my $invo_future = $self);
        $next_future->on_cancel(sub {
            if(defined($invo_future) && $invo_future->is_pending) {
                $invo_future->cancel();
            }
        });

lib/Future/Q.pm  view on Meta::CPAN 

        }else {
            $self->fulfill($base_future->get);
        }
    });
    if(!$base_future->is_ready) {
        weaken(my $weak_base = $base_future);
        $self->on_cancel(sub {
            $weak_base->cancel() if defined($weak_base) && !$weak_base->is_ready;
        });
    }
    return $self;

lib/Future/Q.pm  view on Meta::CPAN 

            }else {
                $next_future->resolve($invo_future);
            }
        });
        if(!$returned_future->is_ready) {
            weaken(my $weak_returned = $returned_future);
            $next_future->on_cancel(sub {
                $weak_returned->cancel if defined($weak_returned) && !$weak_returned->is_ready;
            });
        }
    });
    if(!$self->is_ready) {
        weaken(my $weak_invo = $self);
        $next_future->on_cancel(sub {
            $weak_invo->cancel if defined($weak_invo) && !$weak_invo->is_ready;
        
        });
    }

 view all matches for this distribution


Future-XS
1 match

 view release on metacpan or  search on metacpan

src/future.c  view on Meta::CPAN 

    }
    else {
      struct FutureXS *f2self = get_future(f2);
      struct FutureXSCallback cb2 = {
        .flags = CB_DONE|CB_FAIL|CB_IS_FUTURE,
        .code  = sv_rvweaken(newSVsv(fseq)),
      };
      push_callback(f2self, &cb2);
    }

    assert(SvREFCNT(f2) == 1);

src/future.c  view on Meta::CPAN 

  cb->flags |= CB_DONE|CB_FAIL;
  if(cb->seq.thencode)
    cb->seq.thencode = wrap_cb(f1, "sequence", sv_2mortal(cb->seq.thencode));
  if(cb->seq.elsecode)
    cb->seq.elsecode = wrap_cb(f1, "sequence", sv_2mortal(cb->seq.elsecode));
  cb->seq.f = sv_rvweaken(newSVsv(fseq));

  push_callback(self, cb);

  return fseq;
}

src/future.c  view on Meta::CPAN 


  if(is_future) {
    struct FutureXSRevocation *rev;
    Newx(rev, 1, struct FutureXSRevocation);

    rev->precedent_f = sv_rvweaken(newSVsv(f));
    rev->toclear_sv_at = sv_rvweaken(newRV_inc(rv));

    struct FutureXS *codeself = get_future(code);
    if(!codeself->revoke_when_ready)
      codeself->revoke_when_ready = newAV();

src/future.c  view on Meta::CPAN 

    return f;
  }

  CV *sub_on_ready = newXS(NULL, sub_on_ready_waitall, __FILE__);
  cv_set_anysv_refcounted(sub_on_ready, newSVsv(f));
  sv_rvweaken(CvXSUBANY_sv(sub_on_ready));

  GV *gv = gv_fetchpvs("Future::XS::(wait_all callback)", GV_ADDMULTI, SVt_PVCV);
  CvGV_set(sub_on_ready, gv);
  CvANON_off(sub_on_ready);

src/future.c  view on Meta::CPAN 


  self->pending_subs = 0;

  CV *sub_on_ready = newXS(NULL, sub_on_ready_waitany, __FILE__);
  cv_set_anysv_refcounted(sub_on_ready, newSVsv(f));
  sv_rvweaken(CvXSUBANY_sv(sub_on_ready));

  GV *gv = gv_fetchpvs("Future::XS::(wait_any callback)", GV_ADDMULTI, SVt_PVCV);
  CvGV_set(sub_on_ready, gv);
  CvANON_off(sub_on_ready);

src/future.c  view on Meta::CPAN 


  self->pending_subs = 0;

  CV *sub_on_ready = newXS(NULL, sub_on_ready_needsall, __FILE__);
  cv_set_anysv_refcounted(sub_on_ready, newSVsv(f));
  sv_rvweaken(CvXSUBANY_sv(sub_on_ready));

  GV *gv = gv_fetchpvs("Future::XS::(needs_all callback)", GV_ADDMULTI, SVt_PVCV);
  CvGV_set(sub_on_ready, gv);
  CvANON_off(sub_on_ready);

src/future.c  view on Meta::CPAN 


  self->pending_subs = 0;

  CV *sub_on_ready = newXS(NULL, sub_on_ready_needsany, __FILE__);
  cv_set_anysv_refcounted(sub_on_ready, newSVsv(f));
  sv_rvweaken(CvXSUBANY_sv(sub_on_ready));

  GV *gv = gv_fetchpvs("Future::XS::(needs_any callback)", GV_ADDMULTI, SVt_PVCV);
  CvGV_set(sub_on_ready, gv);
  CvANON_off(sub_on_ready);

 view all matches for this distribution


Future
2 results

 view release on metacpan or  search on metacpan

lib/Future/PP.pm  view on Meta::CPAN 


our @ISA = qw( Future::_base );

use Carp qw(); # don't import croak
use List::Util 1.29 qw( pairs pairkeys );
use Scalar::Util qw( weaken blessed reftype );
use Time::HiRes qw( gettimeofday );

our @CARP_NOT = qw( Future Future::_base Future::Utils );

use constant DEBUG => !!$ENV{PERL_FUTURE_DEBUG};

lib/Future/PP.pm  view on Meta::CPAN 

         $fail ? $code->fail( @result ) :
                 $code->cancel;
      }
      elsif( $flags & (CB_SEQ_ONDONE|CB_SEQ_ONFAIL) ) {
         my ( undef, undef, $fseq ) = @$cb;
         if( !$fseq ) { # weaken()ed; it might be gone now
            # This warning should always be printed, even not in DEBUG mode.
            # It's always an indication of a bug
            Carp::carp "${\$self->__selfstr} lost a sequence Future";
            next;
         }

lib/Future/PP.pm  view on Meta::CPAN 

         if( $f2->is_ready ) {
            $f2->on_ready( $fseq ) if !$f2->{cancelled};
         }
         else {
            push @{ $f2->{callbacks} }, [ CB_DONE|CB_FAIL, $fseq ];
            weaken( $f2->{callbacks}[-1][1] );
         }
      }
      else {
         $code->(
            ( $flags & CB_SELF   ? $self : () ),

lib/Future/PP.pm  view on Meta::CPAN 

   $self->{ready} and return $self;

   push @{ $self->{on_cancel} }, $code;
   if( $is_future ) {
      push @{ $code->{revoke_when_ready} }, my $r = [ $self, \$self->{on_cancel}[-1] ];
      weaken( $r->[0] );
      weaken( $r->[1] );
   }

   return $self;
}

lib/Future/PP.pm  view on Meta::CPAN 

   my $self = shift;
   my ( $f2 ) = @_;

   push @{ $self->{on_cancel} }, $f2;
   push @{ $f2->{revoke_when_ready} }, my $r = [ $self, \$self->{on_cancel}[-1] ];
   weaken( $r->[0] );
   weaken( $r->[1] );
}

sub _revoke_on_cancel
{
   my $self = shift;

lib/Future/PP.pm  view on Meta::CPAN 

   # TODO: if anyone cares about the op name, we might have to synthesize it
   # from $flags
   $code = $f1->wrap_cb( sequence => $code ) unless $flags & (CB_SEQ_IMDONE|CB_SEQ_IMFAIL);

   push @{ $f1->{callbacks} }, [ CB_DONE|CB_FAIL|$flags, $code, $fseq ];
   weaken( $f1->{callbacks}[-1][2] );

   return $fseq;
}

sub then

lib/Future/PP.pm  view on Meta::CPAN 

      $self->{result} = [ @subs ];
      $self->_mark_ready( "wait_all" );
      return $self;
   }

   weaken( my $weakself = $self );
   my $sub_on_ready = sub {
      return unless my $self = $weakself;

      $pending--;
      $pending and return;

lib/Future/PP.pm  view on Meta::CPAN 

      return $self;
   }

   my $pending = 0;

   weaken( my $weakself = $self );
   my $sub_on_ready = sub {
      return unless my $self = $weakself;
      return if $self->{result} or $self->{failure}; # don't recurse on child ->cancel

      return if --$pending and $_[0]->{cancelled};

lib/Future/PP.pm  view on Meta::CPAN 

      $self->{result} = [ map { @{ $_->{result} } } @subs ];
      $self->_mark_ready( "needs_all" );
      return $self;
   }

   weaken( my $weakself = $self );
   my $sub_on_ready = sub {
      return unless my $self = $weakself;
      return if $self->{result} or $self->{failure}; # don't recurse on child ->cancel

      if( $_[0]->{cancelled} ) {

lib/Future/PP.pm  view on Meta::CPAN 

      $self->{failure} = [ $subs[-1]->{failure} ];
      $self->_mark_ready( "needs_any" );
      return $self;
   }

   weaken( my $weakself = $self );
   my $sub_on_ready = sub {
      return unless my $self = $weakself;
      return if $self->{result} or $self->{failure}; # don't recurse on child ->cancel

      return if --$pending and $_[0]->{cancelled};

 view all matches for this distribution


GCCJIT
3 results

 view release on metacpan or  search on metacpan

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 

# DO NOT EDIT - this file is autogenerated by tools/regen.pl
package GCCJIT::Wrapper;
use strict;
use warnings;
use Scalar::Util qw/weaken/;
use GCCJIT;

my %stash;
sub gcc_jit_blockPtr::add_assignment {
    die "this block is no longer usable because parent context was destroyed"

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 

    die "this block is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_blockPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_block_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_blockPtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_blockPtr::end_with_conditional {

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 

    die "this block is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_blockPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_block_get_function(@_);
    if (defined $obj) {
        $stash{"gcc_jit_functionPtr"}{$obj} = $stash{"gcc_jit_blockPtr"}{$_[0]};
        weaken $stash{"gcc_jit_functionPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_casePtr::as_object {
    die "this case is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_casePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_case_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_casePtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::acquire {

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 


sub gcc_jit_contextPtr::get_builtin_function {
    my $obj = GCCJIT::gcc_jit_context_get_builtin_function(@_);
    if (defined $obj) {
        $stash{"gcc_jit_functionPtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_functionPtr"}{$obj};
    }
    $obj;
}

*gcc_jit_contextPtr::get_first_error = \&GCCJIT::gcc_jit_context_get_first_error;

sub gcc_jit_contextPtr::get_int_type {
    my $obj = GCCJIT::gcc_jit_context_get_int_type(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

*gcc_jit_contextPtr::get_last_error = \&GCCJIT::gcc_jit_context_get_last_error;

sub gcc_jit_contextPtr::get_type {
    my $obj = GCCJIT::gcc_jit_context_get_type(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_array_access {
    my $obj = GCCJIT::gcc_jit_context_new_array_access(@_);
    if (defined $obj) {
        $stash{"gcc_jit_lvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_lvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_array_type {
    my $obj = GCCJIT::gcc_jit_context_new_array_type(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_binary_op {
    my $obj = GCCJIT::gcc_jit_context_new_binary_op(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_call {
    my $obj = GCCJIT::gcc_jit_context_new_call(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_call_through_ptr {
    my $obj = GCCJIT::gcc_jit_context_new_call_through_ptr(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_case {
    my $obj = GCCJIT::gcc_jit_context_new_case(@_);
    if (defined $obj) {
        $stash{"gcc_jit_casePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_casePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_cast {
    my $obj = GCCJIT::gcc_jit_context_new_cast(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_child_context {

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 


sub gcc_jit_contextPtr::new_comparison {
    my $obj = GCCJIT::gcc_jit_context_new_comparison(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_field {
    my $obj = GCCJIT::gcc_jit_context_new_field(@_);
    if (defined $obj) {
        $stash{"gcc_jit_fieldPtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_fieldPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_function {
    my $obj = GCCJIT::gcc_jit_context_new_function(@_);
    if (defined $obj) {
        $stash{"gcc_jit_functionPtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_functionPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_function_ptr_type {
    my $obj = GCCJIT::gcc_jit_context_new_function_ptr_type(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_global {
    my $obj = GCCJIT::gcc_jit_context_new_global(@_);
    if (defined $obj) {
        $stash{"gcc_jit_lvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_lvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_location {
    my $obj = GCCJIT::gcc_jit_context_new_location(@_);
    if (defined $obj) {
        $stash{"gcc_jit_locationPtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_locationPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_opaque_struct {
    my $obj = GCCJIT::gcc_jit_context_new_opaque_struct(@_);
    if (defined $obj) {
        $stash{"gcc_jit_structPtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_structPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_param {
    my $obj = GCCJIT::gcc_jit_context_new_param(@_);
    if (defined $obj) {
        $stash{"gcc_jit_paramPtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_paramPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_rvalue_from_double {
    my $obj = GCCJIT::gcc_jit_context_new_rvalue_from_double(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_rvalue_from_int {
    my $obj = GCCJIT::gcc_jit_context_new_rvalue_from_int(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_rvalue_from_long {
    my $obj = GCCJIT::gcc_jit_context_new_rvalue_from_long(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_rvalue_from_ptr {
    my $obj = GCCJIT::gcc_jit_context_new_rvalue_from_ptr(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_string_literal {
    my $obj = GCCJIT::gcc_jit_context_new_string_literal(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_struct_type {
    my $obj = GCCJIT::gcc_jit_context_new_struct_type(@_);
    if (defined $obj) {
        $stash{"gcc_jit_structPtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_structPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_unary_op {
    my $obj = GCCJIT::gcc_jit_context_new_unary_op(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::new_union_type {
    my $obj = GCCJIT::gcc_jit_context_new_union_type(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::null {
    my $obj = GCCJIT::gcc_jit_context_null(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_contextPtr::one {
    my $obj = GCCJIT::gcc_jit_context_one(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

*gcc_jit_contextPtr::set_bool_allow_unreachable_blocks = \&GCCJIT::gcc_jit_context_set_bool_allow_unreachable_blocks;

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 


sub gcc_jit_contextPtr::zero {
    my $obj = GCCJIT::gcc_jit_context_zero(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $_[0];
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_fieldPtr::as_object {
    die "this field is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_fieldPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_field_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_fieldPtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_functionPtr::as_object {
    die "this function is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_functionPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_function_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_functionPtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_functionPtr::dump_to_dot {

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 

    die "this function is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_functionPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_function_get_param(@_);
    if (defined $obj) {
        $stash{"gcc_jit_paramPtr"}{$obj} = $stash{"gcc_jit_functionPtr"}{$_[0]};
        weaken $stash{"gcc_jit_paramPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_functionPtr::new_block {
    die "this function is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_functionPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_function_new_block(@_);
    if (defined $obj) {
        $stash{"gcc_jit_blockPtr"}{$obj} = $stash{"gcc_jit_functionPtr"}{$_[0]};
        weaken $stash{"gcc_jit_blockPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_functionPtr::new_local {
    die "this function is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_functionPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_function_new_local(@_);
    if (defined $obj) {
        $stash{"gcc_jit_lvaluePtr"}{$obj} = $stash{"gcc_jit_functionPtr"}{$_[0]};
        weaken $stash{"gcc_jit_lvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_locationPtr::as_object {
    die "this location is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_locationPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_location_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_locationPtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_lvaluePtr::access_field {
    die "this lvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_lvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_lvalue_access_field(@_);
    if (defined $obj) {
        $stash{"gcc_jit_lvaluePtr"}{$obj} = $stash{"gcc_jit_lvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_lvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_lvaluePtr::as_object {
    die "this lvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_lvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_lvalue_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_lvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_lvaluePtr::as_rvalue {
    die "this lvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_lvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_lvalue_as_rvalue(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $stash{"gcc_jit_lvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_lvaluePtr::get_address {
    die "this lvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_lvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_lvalue_get_address(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $stash{"gcc_jit_lvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_objectPtr::get_context {

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 

    die "this param is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_paramPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_param_as_lvalue(@_);
    if (defined $obj) {
        $stash{"gcc_jit_lvaluePtr"}{$obj} = $stash{"gcc_jit_paramPtr"}{$_[0]};
        weaken $stash{"gcc_jit_lvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_paramPtr::as_object {
    die "this param is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_paramPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_param_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_paramPtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_paramPtr::as_rvalue {
    die "this param is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_paramPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_param_as_rvalue(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $stash{"gcc_jit_paramPtr"}{$_[0]};
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

*gcc_jit_resultPtr::get_code = \&GCCJIT::gcc_jit_result_get_code;

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 

    die "this rvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_rvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_rvalue_access_field(@_);
    if (defined $obj) {
        $stash{"gcc_jit_rvaluePtr"}{$obj} = $stash{"gcc_jit_rvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_rvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_rvaluePtr::as_object {
    die "this rvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_rvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_rvalue_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_rvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_rvaluePtr::dereference {
    die "this rvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_rvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_rvalue_dereference(@_);
    if (defined $obj) {
        $stash{"gcc_jit_lvaluePtr"}{$obj} = $stash{"gcc_jit_rvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_lvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_rvaluePtr::dereference_field {
    die "this rvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_rvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_rvalue_dereference_field(@_);
    if (defined $obj) {
        $stash{"gcc_jit_lvaluePtr"}{$obj} = $stash{"gcc_jit_rvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_lvaluePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_rvaluePtr::get_type {
    die "this rvalue is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_rvaluePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_rvalue_get_type(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $stash{"gcc_jit_rvaluePtr"}{$_[0]};
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_structPtr::as_type {
    die "this struct is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_structPtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_struct_as_type(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $stash{"gcc_jit_structPtr"}{$_[0]};
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_structPtr::set_fields {

lib/GCCJIT/Wrapper.pm  view on Meta::CPAN 

    die "this type is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_typePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_type_as_object(@_);
    if (defined $obj) {
        $stash{"gcc_jit_objectPtr"}{$obj} = $stash{"gcc_jit_typePtr"}{$_[0]};
        weaken $stash{"gcc_jit_objectPtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_typePtr::get_const {
    die "this type is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_typePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_type_get_const(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $stash{"gcc_jit_typePtr"}{$_[0]};
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_typePtr::get_pointer {
    die "this type is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_typePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_type_get_pointer(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $stash{"gcc_jit_typePtr"}{$_[0]};
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_typePtr::get_volatile {
    die "this type is no longer usable because parent context was destroyed"
        unless defined $stash{"gcc_jit_typePtr"}{$_[0]};
    my $obj = GCCJIT::gcc_jit_type_get_volatile(@_);
    if (defined $obj) {
        $stash{"gcc_jit_typePtr"}{$obj} = $stash{"gcc_jit_typePtr"}{$_[0]};
        weaken $stash{"gcc_jit_typePtr"}{$obj};
    }
    $obj;
}

sub gcc_jit_blockPtr::DESTROY {

 view all matches for this distribution


GID
1 match

 view release on metacpan or  search on metacpan

lib/GID.pm  view on Meta::CPAN 

		isweak
		readonly
		refaddr
		reftype
		tainted
		weaken
		isvstring
		looks_like_number
		set_prototype
	)],
	'Class::Load' => [qw(

 view all matches for this distribution


GIS-Distance-Fast
1 match

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN 

sv_ref||5.015004|
sv_replace|||
sv_report_used|||
sv_resetpvn|||
sv_reset|||
sv_rvweaken||5.006000|
sv_sethek|||
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||

 view all matches for this distribution


GSM-Gnokii
1 match

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN 

sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_resetpvn|||
sv_reset|||
sv_rvweaken||5.006000|
sv_sethek|||
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||

 view all matches for this distribution


GSSAPI
1 match

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN 

sv_reftype|||
sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.004050||p

 view all matches for this distribution


GTop
1 match

 view release on metacpan or  search on metacpan

lib/GTop.pm  view on Meta::CPAN 

    return $self unless THREADED;

    # make a weak copy, to allow CLONE to affect objects in the user space
    # key = object's stringified IV (pointer to the C struct)
    $objects{"$$self"} = $self;
    Scalar::Util::weaken($objects{"$$self"});

    return $self;
}

if (THREADED) {

 view all matches for this distribution


Game-Collisions
9 results

 view release on metacpan or  search on metacpan

lib/Game/Collisions/AABB.pm  view on Meta::CPAN 



sub _set_node
{
    my ($self, $node, $index) = @_;
    Scalar::Util::unweaken( $self->[$index] )
        if defined $self->[$index];
    $self->[$index] = $node;
    Scalar::Util::weaken( $self->[$index] );
    my $former_parent = defined $node
        ? $node->set_parent( $self )
        : undef;
    return $former_parent;
}

 view all matches for this distribution


Game-HexDescribe
2 results

 view release on metacpan or  search on metacpan

share/hex-describe-schroeder-table.txt  view on Meta::CPAN 

1,HD 6+1 AC 4 1d6/1d6/1d10 F6 MV 12 ML 10 XP 600

;slime special ability
1,dissolves metal: chain and plate armor is destroyed when hit
1,rots wood: clubs, axes, spears, polearms, shields on a hit
1,weakens stone: 1 in 6 chance for ceiling or floor collapse causing 2d6 damage
1,eats spells: add 1d6 hp per spell level absorbed
1,destroys fabrics: cloaks, gloves, girdle, shirt, pants are lost on a hit
1,shatters glass: potions, oil flasks and lanterns within 20ft are destroyed
1,makes eyes water: anybody within 10ft suffers -4 to hit

share/hex-describe-schroeder-table.txt  view on Meta::CPAN 

;the presence of refugees is a problem
# no captain!
1,As the wounded start dying, the stench is spreading. Flies are everywhere. Soon, cholera and typhus will be showing up. The locals want the refugees gone, but who is going to argue with armed men? Better to stab them during the night, some might sa...
1,The locals are no longer willing to support the refugees, calling them maggots and worms and worse. Nobody is willing to kill, however, and so the situation just lingers, the refugees too weak to kill the locals and simply take what they need and t...
1,The young **[human class]** *[human with portrait]* is a devout servant of *[good power]*. They are trying to find a solution to the problem. Surely some land could be cleared for these poor souls? Let them settle.
1,The young **[human class]** *[human with portrait]* is a devout servant of *[evil power]*. They have shrewdly insinuated that the locals are simply waiting for them to weaken even further until one night they’ll all just stab them. So why not tak...

;the presence of corpses is a problem
# no captain!
1,The many corpses have attracted the **necromancer** [human with portrait][here store [same human name] as alchemist patron] (level [1d3+4 as level]). This does not sit well with the locals. Somebody should get rid of them! [spellbook for necromance...
1,The many corpses are poisoning the air. The stink is horrendous. Flies are everywhere. The water is foul. *Ghoul fever* is spreading: *[human name]* and their family have turned into [1d4+2] **ghouls** roaming the graveyard at night, looking for so...

share/hex-describe-schroeder-table.txt  view on Meta::CPAN 

;spellbooks
1,<h1 id="appendix-a">Appendix A: Spellbooks</h1><p>These spells are from the <a href="https://alexschroeder.ch/pdfs/spellcasters/">Spellcasters</a> project.<div style="font-size: smaller; column-count: 2">[halberds & helmets: spellbooks]</div>

# Use make hex-describe in the spellcasters working directory to generate the following
;halberds & helmets: spellbooks
1,Each paragraph begins with the **spell name** followed by the spell circle in parenthesis (1–5), also known as the *spell level*.<p id="air-blast">**Air blast** (1) turns the exhalation of the caster into a blast of air that extinguishes candles ...

 view all matches for this distribution


Game-RaycastFOV
1 match

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN 

SvROK|5.003007|5.003007|
SvROK_off|5.003007|5.003007|
SvROK_on|5.003007|5.003007|
SvRV|5.003007|5.003007|
SvRV_set|5.009003|5.003007|p
sv_rvunweaken|5.027004|5.027004|
sv_rvweaken|5.006000|5.006000|
SvRX|5.009005|5.003007|p
SvRXOK|5.009005|5.003007|p
sv_sethek|5.015004||cViu
sv_setiv|5.003007|5.003007|
sv_setiv_mg|5.004005|5.003007|p

 view all matches for this distribution


Game-TextMapper
1 match

 view release on metacpan or  search on metacpan

lib/Game/TextMapper/Mapper.pm  view on Meta::CPAN 

use Mojo::Base -base;
use File::Slurper qw(read_text);
use Encode qw(encode_utf8 decode_utf8);
use Mojo::Util qw(url_escape);
use File::ShareDir 'dist_dir';
use Scalar::Util 'weaken';

=head1 ATTRIBUTES

=head2 dist_dir

lib/Game/TextMapper/Mapper.pm  view on Meta::CPAN 

  my $self = shift;
  my $line_id = 0;
  foreach (@_) {
    if (/^(-?\d\d)(-?\d\d)(\d\d)?\s+(.*)/ or /^(-?\d\d+)\.(-?\d\d+)(?:\.(\d\d+))?\s+(.*)/) {
      my $region = $self->make_region(x => $1, y => $2, z => $3||'00', map => $self);
      weaken($region->{map});
      my $rest = $4;
      while (my ($tag, $label, $size) = $rest =~ /\b([a-z]+)=["“]([^"”]+)["”]\s*(\d+)?/) {
	if ($tag eq 'name') {
	  $region->label($label);
          $region->size($size) if $size;

lib/Game/TextMapper/Mapper.pm  view on Meta::CPAN 

      push(@{$self->regions}, $region);
      push(@{$self->things}, $region);
    } elsif (/^(-?\d\d-?\d\d(?:\d\d)?(?:--?\d\d-?\d\d(?:\d\d)?)+)\s+(\S+)\s*(?:["“](.+)["”])?\s*(left|right)?\s*(\d+%)?/
             or /^(-?\d\d+\.-?\d\d+(?:\.\d\d+)?(?:--?\d\d+\.-?\d\d+(?:\.\d\d+)?)+)\s+(\S+)\s*(?:["“](.+)["”])?\s*(left|right)?\s*(\d+%)?/) {
      my $line = $self->make_line(map => $self);
      weaken($line->{map});
      my $str = $1;
      $line->type($2);
      $line->label($3);
      $line->side($4);
      $line->start($5);

 view all matches for this distribution


Game-TextPacMonster
1 match

 view release on metacpan or  search on metacpan

inc/Test/MockObject.pm  view on Meta::CPAN 

}

use strict;
use warnings;

use Scalar::Util qw( blessed refaddr reftype weaken );

sub import
{
    my $self = shift;
    return unless grep /^-debug/, @_;

inc/Test/MockObject.pm  view on Meta::CPAN 

sub log_call
{
    my ($self, $sub, @call_args) = @_;
    return unless _logs( $self, $sub );

    # prevent circular references with weaken
    for my $arg ( @call_args )
    {
        next unless ref $arg;
        weaken( $arg ) if refaddr( $arg ) eq refaddr( $self );
    }

    push @{ _calls( $self ) }, [ $sub, \@call_args ];
}

 view all matches for this distribution


Game-WordBrain
2 results

 view release on metacpan or  search on metacpan

lib/Game/WordBrain/WordList.pm  view on Meta::CPAN 

rewaxed
rewaxes
rewaxing
rewaybill
rewayle
reweaken
rewear
rewearing
reweave
reweaved
reweaves

lib/Game/WordBrain/WordList.pm  view on Meta::CPAN 

unwaving
unwax
unwaxed
unwayed
unwayward
unweaken
unweakened
unweakening
unweal
unwealsomeness
unwealthy
unweaned
unweapon

lib/Game/WordBrain/WordList.pm  view on Meta::CPAN 

we'll
we're
we've
weak
weakbrained
weaken
weakened
weakener
weakeners
weakening
weakens
weaker
weakest
weakfish
weakfishes
weakhanded

 view all matches for this distribution


Game-Xomb
2 results

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN 

1.04    2022-07-26 15:20 UTC
	* use a Real Boolean(TM) to fix bleadperl test failure [RT#143857]

1.03    2021-07-06 09:38 UTC
    * better documentation, more tests
    * remove weaken, pretty sure don't need it
    * simplify reify as only needs operate on MINERAL
    * some XS cleanups

1.02    2020-03-19 16:15 UTC
    * only check for passive effects on MINERAL not also VEGGIE.

 view all matches for this distribution


Games-Chipmunk
1 match

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN 

sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_resetpvn|||
sv_reset|||
sv_rvweaken||5.006000|
sv_sethek|||
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||

 view all matches for this distribution


Games-Construder
3 results

 view release on metacpan or  search on metacpan

lib/Games/Construder/Server/Objects.pm  view on Meta::CPAN 

use Games::Construder::Server::PCB;
use Games::Construder::Server::World;
use Games::Construder::Vector;
use Games::Construder::Logging;
use Games::Construder;
use Scalar::Util qw/weaken/;

=head1 NAME

Games::Construder::Server::Objects - Implementation of Object Type specific behaviour

 view all matches for this distribution


Games-Cryptoquote
1 match

 view release on metacpan or  search on metacpan

t/patterns.txt  view on Meta::CPAN 

1|2|3|4|2|4|7|8|4|10|11|12:unmanageably|
1|2|3|4|2|4|7|8|4|10|11|6:unmanageable|
1|2|3|4|2|4|7|8|9:dequeuing|stratagem|
1|2|3|4|2|4|7|8|9|1:stratagems|
1|2|3|4|2|4|7|8|9|10:Antonovics|unfinished|
1|2|3|4|2|6:Antony|Arturo|Balkan|Balzac|Becker|Bender|Bergen|Bernet|Betsey|Birgit|Bobrow|Bolton|Boston|Caesar|Decker|Denver|Dodson|Fabian|Farkas|Felder|Folsom|Galway|Geiger|Gordon|Gorton|Harlan|Healey|Hebrew|Heiser|Henley|Hermes|Hersey|Hester|Heusen|...
1|2|3|4|2|6|1:descend|enhance|gilding|sandals|secrets|senders|sequels|sixties|subdues|tempest|topmost|
1|2|3|4|2|6|1|1:snugness|
1|2|3|4|2|6|1|2:stoutest|
1|2|3|4|2|6|1|2|1:descended|
1|2|3|4|2|6|1|2|5|10:descendent|

t/patterns.txt  view on Meta::CPAN 

1|2|3|4|2|6|2|3|9|10|11:persevering|
1|2|3|4|2|6|2|3|9|10|11|2:perseverance|
1|2|3|4|2|6|2|4|4:ceaseless|
1|2|3|4|2|6|2|4|4|10|2|4|4:ceaselessness|
1|2|3|4|2|6|2|4|4|5|11:ceaselessly|
1|2|3|4|2|6|2|8:Barnabas|Berkeley|Hathaway|Mercedes|Virginia|believed|believer|believes|besieged|besieger|centered|depletes|leavened|maniacal|reflexes|refueled|relieved|relieves|reopened|reviewed|secreted|tempered|weakened|
1|2|3|4|2|6|2|8|1:dignified|signifies|
1|2|3|4|2|6|2|8|2|10|11:victimizing|
1|2|3|4|2|6|2|8|2|10|7:repleteness|
1|2|3|4|2|6|2|8|3:besiegers|
1|2|3|4|2|6|2|8|4:misgiving|poisonous|

t/patterns.txt  view on Meta::CPAN 

1|2|3|4|2|6|5|8|9:backarrow|boycotted|canvassed|canvasser|distiller|forgotten|
1|2|3|4|2|6|5|8|9|10:depressing|depression|distillery|
1|2|3|4|2|6|5|8|9|10|5:depressions|
1|2|3|4|2|6|5|8|9|3:distillers|
1|2|3|4|2|6|5|8|9|5:canvassers|
1|2|3|4|2|6|7:Atwater|Balkans|Bowdoin|Boxford|Calgary|Calvary|Candace|Cepheus|Chekhov|Dogtown|Flagler|Formosa|Hayward|Hebrews|Holcomb|Holyoke|January|Kipling|Laplace|Malraux|Mayfair|Maynard|Monfort|Moscone|Norfolk|Oakland|Packard|Perseid|Peugeot|Raph...
1|2|3|4|2|6|7|1:disliked|doctored|entangle|radiator|salvages|scorches|segments|serpents|siblings|startles|startups|
1|2|3|4|2|6|7|1|1:fisticuff|stoutness|
1|2|3|4|2|6|7|1|2:temperate|
1|2|3|4|2|6|7|1|2|10|11:temperately|
1|2|3|4|2|6|7|1|2|10|2|12|8:temperateness|

t/patterns.txt  view on Meta::CPAN 

1|2|3|4|2|6|7|5|1|1:scarceness|
1|2|3|4|2|6|7|5|1|10|2:indentation|
1|2|3|4|2|6|7|5|1|10|2|12:indentations|
1|2|3|4|2|6|7|5|6|10:captaining|
1|2|3|4|2|6|7|5|6|4:bargaining|
1|2|3|4|2|6|7|5|9:arthropod|component|ingenuous|leavening|reopening|weakening|whichever|
1|2|3|4|2|6|7|5|9|1:stratifies|
1|2|3|4|2|6|7|5|9|10:arthropods|components|perceiving|stratified|
1|2|3|4|2|6|7|5|9|10|11:componentry|
1|2|3|4|2|6|7|5|9|10|11|12|6:componentwise|
1|2|3|4|2|6|7|5|9|4|2|5|13|14:stratification|

 view all matches for this distribution


Games-EternalLands-Binary-Float16
1 match

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN 

sv_reftype|||
sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.004050||p

 view all matches for this distribution


Games-EternalLands-Binary-Unitvec16
1 match

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN 

sv_reftype|||
sv_release_COW|||
sv_replace|||
sv_report_used|||
sv_reset|||
sv_rvweaken||5.006000|
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
sv_setpv_mg|5.004050||p

 view all matches for this distribution


Games-Euchre
2 results

 view release on metacpan or  search on metacpan

lib/Games/Euchre/Player.pm  view on Meta::CPAN 


sub setTeam {
   my $self = shift;
   my $team = shift;
   $self->{team} = $team;
   weaken($self->{team}); # break anti-GC loop
   return $self;
}

=item getTeam

 view all matches for this distribution


Games-Go-AGA-DataObjects
1 match

 view release on metacpan or  search on metacpan

lib/Games/Go/AGA/DataObjects/Game.pm  view on Meta::CPAN 

package Games::Go::AGA::DataObjects::Game;
use Moo;
use namespace::clean;

use Carp;
use Scalar::Util qw(refaddr weaken);
use Try::Tiny;
use Games::Go::AGA::Parse::Util qw( Rank_to_Rating );
use Games::Go::AGA::DataObjects::Types qw( isa_Int isa_CodeRef isa_Handicap isa_Komi );

our $VERSION = '0.152'; # VERSION

sub isa_Player   { die("$_[0] is not a Games::Go::AGA::DataObjects::Player\n") if (ref $_[0] ne 'Games::Go::AGA::DataObjects::Player') }
has black    => (
    is       => 'rw',
    isa      => \&isa_Player,
    weak_ref => 1, # Players have Games, Games have Players, so weaken
    trigger  => sub
        {
            my $self = shift;
            $self->_set_player('black', @_);
        },

 view all matches for this distribution


( run in 1.431 second using v1.01-cache-2.11-cpan-39bf76dae61 )