X-Git-Url: http://git.vpit.fr/?a=blobdiff_plain;f=lib%2FSub%2FOp.pm;h=76d22dacb4dab4ba36869b65ecbceaf8353ffae7;hb=03a0301f7c3c094686a5412c86319e32354a3521;hp=dbcdcd2a46ff0582efb085169afdacbc92a50198;hpb=dcefaa0f0b52b7ec82ad4fd5547d320a419ca1a9;p=perl%2Fmodules%2FSub-Op.git

diff --git a/lib/Sub/Op.pm b/lib/Sub/Op.pm
index dbcdcd2..76d22da 100644
--- a/lib/Sub/Op.pm
+++ b/lib/Sub/Op.pm
@@ -49,12 +49,13 @@ In your XS file :
 
     BOOT:
     {
-     sub_op_keyword k;
-     k.name  = "reftype";
-     k.len   = sizeof("reftype")-1;
-     k.check = 0;
-     k.pp    = scalar_util_reftype;
-     sub_op_register(aTHX_ &k);
+     sub_op_config_t c;
+     c.name  = "reftype";
+     c.len   = sizeof("reftype")-1;
+     c.pp    = scalar_util_reftype;
+     c.check = 0;
+     c.ud    = NULL;
+     sub_op_register(aTHX_ &c);
     }
 
 In your Perl module file :
@@ -92,6 +93,29 @@ In your F<Makefile.PL> :
      ...
     );
 
+=head1 DESCRIPTION
+
+This module provides a C and Perl API for replacing subroutine calls by custom opcodes.
+This has two main advantages :
+
+=over 4
+
+=item *
+
+it gets rid of the overhead of a normal subroutine call ;
+
+=item *
+
+there's no symbol table entry defined for the subroutine.
+
+=back
+
+Subroutine calls with and without parenthesis are handled.
+Ampersand calls are B<not> replaced, and as such will still allow to call a subroutine with same name defined earlier.
+This may or may not be considered as a bug, but it gives the same semantics as Perl keywords, so I believe it's reasonable.
+
+When L<B> and L<B::Deparse> are loaded, they get automatically monkeypatched so that introspecting modules like L<B::Concise> and L<B::Deparse> still produce a valid output.
+
 =cut
 
 use B::Hooks::EndOfScope;
@@ -116,8 +140,6 @@ my $sw = Variable::Magic::wizard(
   my $pkg = $data->{pkg};
   my $fqn = join '::', $pkg, $name;
 
-  _incoming($name, $pkg);
-
   no strict 'refs';
   *$fqn = $placeholder unless exists &$fqn;
 
@@ -150,12 +172,76 @@ sub _dispell {
  Variable::Magic::dispell(%{"${pkg}::"}, $sw);
 }
 
+=head1 C API
+
+=head2 C<sub_op_config_t>
+
+A typedef'd struct that configures how L<Sub::Op> should handle a given subroutine name.
+It has the following members :
+
+=over 4
+
+=item *
+
+C<const char *name>
+
+The name of the subroutine you want to replace.
+Allowed to be static.
+
+=item *
+
+C<STRLEN len>
+
+C<name>'s length, in bytes.
+
+=item *
+
+C<Perl_ppaddr_t pp>
+
+The pp function that will be called instead of the subroutine.
+C<Perl_ppaddr_t> is a typedef'd function pointer defined by perl as :
+
+    typedef OP *(*Perl_ppaddr_t)(pTHX);
+
+=item *
+
+C<sub_op_check_t check>
+
+An optional callback that will be called each time a call to C<name> is replaced.
+You can use it to attach extra info to those ops (e.g. with a pointer table) or to perform more optimizations to the optree.
+C<sub_op_check_t> is a typedef'd function pointer defined by :
+
+    typedef OP *(*sub_op_check_t)(pTHX_ OP *, void *);
+
+=item *
+
+C<void *ud>
+
+An optional user data passed to the C<check> callback.
+
+=back
+
+=head2 C<void sub_op_register(pTHX_ const sub_op_config_t *c)>
+
+Registers a name and its configuration into L<Sub::Op>.
+The caller is responsible for allocating and freeing the C<sub_op_config_t> object.
+No pointer to it or to its members is kept.
+
+=head1 PERL API
+
+=head2 C<enable $name, [ $pkg ]>
+
+Enable the replacement with a custom opcode of calls to the C<$name> subroutine of the C<$pkg> package in the current lexical scope.
+A pp callback must have been registered for C<$name> by calling the C function C<sub_op_register> in the XS section of your module.
+
+When C<$pkg> is not set, it defaults to the caller package.
+
+=cut
+
 sub enable {
  my $name = shift;
 
  my $pkg = @_ > 0 ? $_[0] : caller;
- my $fqn = "${pkg}::$name";
-
  my $map = _map($pkg);
 
  if (defined $map) {
@@ -172,12 +258,18 @@ sub enable {
  return;
 }
 
+=head2 C<disable $name, [ $pkg ]>
+
+Disable the replacement for calls to C<$name> in the package C<$pkg>.
+
+When C<$pkg> is not set, it defaults to the caller package.
+
+=cut
+
 sub disable {
  my $name = shift;
 
  my $pkg = @_ > 0 ? $_[0] : caller;
- my $fqn = "${pkg}::$name";
-
  my $map = _map($pkg);
 
  if (defined $map) {
@@ -235,7 +327,7 @@ sub _inject {
   $B_OP_inject{can} = sub {
    my ($obj, $meth) = @_;
    if ($meth eq 'first') {
-    return undef unless defined _custom_name($obj);
+    return undef unless $obj->isa('B::UNOP') or defined _custom_name($obj);
    }
    $obj->SUPER::can($meth);
   };
@@ -276,6 +368,10 @@ sub _inject {
 
 BEGIN { _monkeypatch() }
 
+=head1 EXAMPLES
+
+See the F<t/Sub-Op-LexicalSub> directory that implements a complete example.
+
 =head1 DEPENDENCIES
 
 L<perl> 5.10.