Plugin.xs

   1 /* This file is part of the re::engine::Plugin Perl module.
   2  * See http://search.cpan.org/dist/re-engine-Plugin/ */
   3
   4 #define PERL_NO_GET_CONTEXT
   5 #include "EXTERN.h"
   6 #include "perl.h"
   7 #include "XSUB.h"
   8
   9 /* --- Helpers ------------------------------------------------------------- */
  10
  11 #define XSH_PACKAGE "re::engine::Plugin"
  12
  13 #include "xsh/caps.h"
  14 #include "xsh/util.h"
  15
  16 /* ... Lexical hints ....................................................... */
  17
  18 typedef struct {
  19  SV *comp;
  20  SV *exec;
  21  SV *free;
  22 } xsh_hints_user_t;
  23
  24 static SV *rep_validate_callback(SV *code) {
  25  if (!SvROK(code))
  26   return NULL;
  27
  28  code = SvRV(code);
  29  if (SvTYPE(code) < SVt_PVCV)
  30   return NULL;
  31
  32  return SvREFCNT_inc_simple_NN(code);
  33 }
  34
  35 static void xsh_hints_user_init(pTHX_ xsh_hints_user_t *hv, xsh_hints_user_t *v) {
  36  hv->comp = rep_validate_callback(v->comp);
  37  hv->exec = rep_validate_callback(v->exec);
  38  hv->free = rep_validate_callback(v->free);
  39
  40  return;
  41 }
  42
  43 #if XSH_THREADSAFE
  44
  45 static void xsh_hints_user_clone(pTHX_ xsh_hints_user_t *nv, xsh_hints_user_t *ov, CLONE_PARAMS *params) {
  46  nv->comp = xsh_dup_inc(ov->comp, params);
  47  nv->exec = xsh_dup_inc(ov->exec, params);
  48  nv->free = xsh_dup_inc(ov->free, params);
  49
  50  return;
  51 }
  52
  53 #endif /* XSH_THREADSAFE */
  54
  55 static void xsh_hints_user_deinit(pTHX_ xsh_hints_user_t *hv) {
  56  SvREFCNT_dec(hv->comp);
  57  SvREFCNT_dec(hv->exec);
  58  SvREFCNT_dec(hv->free);
  59
  60  return;
  61 }
  62
  63 #define rep_hint() xsh_hints_detag(xsh_hints_fetch())
  64
  65 #define XSH_HINTS_TYPE_USER         1
  66 #define XSH_HINTS_ONLY_COMPILE_TIME 0
  67
  68 #include "xsh/hints.h"
  69
  70 /* ... Thread-local storage ................................................ */
  71
  72 #define XSH_THREADS_USER_CONTEXT            0
  73 #define XSH_THREADS_USER_LOCAL_SETUP        0
  74 #define XSH_THREADS_USER_LOCAL_TEARDOWN     0
  75 #define XSH_THREADS_USER_GLOBAL_TEARDOWN    0
  76 #define XSH_THREADS_COMPILE_TIME_PROTECTION 0
  77
  78 #include "xsh/threads.h"
  79
  80 /* --- Custom regexp engine ------------------------------------------------ */
  81
  82 /* re__engine__Plugin self; SELF_FROM_PPRIVATE(self,rx->pprivate) */
  83 #define SELF_FROM_PPRIVATE(self, pprivate) \
  84  if (sv_isobject(pprivate)) {              \
  85   SV *ref = SvRV((SV *) pprivate);         \
  86   IV  tmp = SvIV((SV *) ref);              \
  87   self = INT2PTR(re__engine__Plugin, tmp); \
  88  } else {                                  \
  89   Perl_croak(aTHX_ "Not an object");       \
  90  }
  91
  92 #if XSH_HAS_PERL(5, 19, 4)
  93 # define REP_ENG_EXEC_MINEND_TYPE SSize_t
  94 #else
  95 # define REP_ENG_EXEC_MINEND_TYPE I32
  96 #endif
  97
  98 START_EXTERN_C
  99 EXTERN_C const regexp_engine engine_plugin;
 100 #if XSH_HAS_PERL(5, 11, 0)
 101 EXTERN_C REGEXP * Plugin_comp(pTHX_ SV * const, U32);
 102 #else
 103 EXTERN_C REGEXP * Plugin_comp(pTHX_ const SV * const, const U32);
 104 #endif
 105 EXTERN_C I32      Plugin_exec(pTHX_ REGEXP * const, char *, char *,
 106                               char *, REP_ENG_EXEC_MINEND_TYPE, SV *, void *, U32);
 107 #if XSH_HAS_PERL(5, 19, 1)
 108 EXTERN_C char *   Plugin_intuit(pTHX_ REGEXP * const, SV *, const char * const,
 109                                 char *, char *, U32, re_scream_pos_data *);
 110 #else
 111 EXTERN_C char *   Plugin_intuit(pTHX_ REGEXP * const, SV *, char *,
 112                                 char *, U32, re_scream_pos_data *);
 113 #endif
 114 EXTERN_C SV *     Plugin_checkstr(pTHX_ REGEXP * const);
 115 EXTERN_C void     Plugin_free(pTHX_ REGEXP * const);
 116 EXTERN_C void *   Plugin_dupe(pTHX_ REGEXP * const, CLONE_PARAMS *);
 117 EXTERN_C void     Plugin_numbered_buff_FETCH(pTHX_ REGEXP * const,
 118                                              const I32, SV * const);
 119 EXTERN_C void     Plugin_numbered_buff_STORE(pTHX_ REGEXP * const,
 120                                              const I32, SV const * const);
 121 EXTERN_C I32      Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const,
 122                                               const SV * const, const I32);
 123 EXTERN_C SV *     Plugin_named_buff(pTHX_ REGEXP * const, SV * const,
 124                                     SV * const, const U32);
 125 EXTERN_C SV *     Plugin_named_buff_iter(pTHX_ REGEXP * const, const SV * const,
 126                                          const U32);
 127 EXTERN_C SV *     Plugin_package(pTHX_ REGEXP * const);
 128 #ifdef USE_ITHREADS
 129 EXTERN_C void *   Plugin_dupe(pTHX_ REGEXP * const, CLONE_PARAMS *);
 130 #endif
 131
 132 EXTERN_C const regexp_engine engine_plugin;
 133 END_EXTERN_C
 134
 135 #define RE_ENGINE_PLUGIN (&engine_plugin)
 136 const regexp_engine engine_plugin = {
 137  Plugin_comp,
 138  Plugin_exec,
 139  Plugin_intuit,
 140  Plugin_checkstr,
 141  Plugin_free,
 142  Plugin_numbered_buff_FETCH,
 143  Plugin_numbered_buff_STORE,
 144  Plugin_numbered_buff_LENGTH,
 145  Plugin_named_buff,
 146  Plugin_named_buff_iter,
 147  Plugin_package
 148 #if defined(USE_ITHREADS)
 149  , Plugin_dupe
 150 #endif
 151 #if XSH_HAS_PERL(5, 17, 0)
 152  , 0
 153 #endif
 154 };
 155
 156 typedef struct replug {
 157  /* Pointer back to the containing regexp struct so that accessors
 158   * can modify nparens, gofs, etc... */
 159  struct regexp *rx;
 160
 161  /* A copy of the pattern given to comp, for ->pattern */
 162  SV *pattern;
 163
 164  /* A copy of the string being matched against, for ->str */
 165  SV *str;
 166
 167  /* The ->stash */
 168  SV *stash;
 169
 170  /* Callbacks */
 171  SV *cb_exec;
 172  SV *cb_free;
 173
 174  /* ->num_captures */
 175  SV *cb_num_capture_buff_FETCH;
 176  SV *cb_num_capture_buff_STORE;
 177  SV *cb_num_capture_buff_LENGTH;
 178 } *re__engine__Plugin;
 179
 180 #if XSH_HAS_PERL(5, 11, 0)
 181 # define rxREGEXP(RX)  (SvANY(RX))
 182 # define newREGEXP(RX) ((RX) = ((REGEXP *) newSV_type(SVt_REGEXP)))
 183 #else
 184 # define rxREGEXP(RX)  (RX)
 185 # define newREGEXP(RX) (Newxz((RX), 1, struct regexp))
 186 #endif
 187
 188 REGEXP *
 189 #if XSH_HAS_PERL(5, 11, 0)
 190 Plugin_comp(pTHX_ SV * const pattern, U32 flags)
 191 #else
 192 Plugin_comp(pTHX_ const SV * const pattern, const U32 flags)
 193 #endif
 194 {
 195  dSP;
 196  struct regexp *rx;
 197  REGEXP *RX;
 198
 199  re__engine__Plugin re;
 200  const xsh_hints_user_t *h;
 201
 202  STRLEN plen;
 203  char *pbuf;
 204
 205  SV *obj;
 206
 207  h = rep_hint();
 208  if (!h) /* This looks like a pragma leak. Apply the default behaviour */
 209   return re_compile(pattern, flags);
 210
 211  /* exp/xend version of the pattern & length */
 212  pbuf = SvPV((SV *) pattern, plen);
 213
 214  /* Our blessed object */
 215  obj = newSV(0);
 216  Newxz(re, 1, struct replug);
 217  sv_setref_pv(obj, XSH_PACKAGE, (void *) re);
 218
 219  newREGEXP(RX);
 220  rx = rxREGEXP(RX);
 221
 222  re->rx       = rx;               /* Make the rx accessible from self->rx */
 223  rx->intflags = flags;            /* Flags for internal use */
 224  rx->extflags = flags;            /* Flags for perl to use */
 225  rx->engine   = RE_ENGINE_PLUGIN; /* Compile to use this engine */
 226
 227 #if !XSH_HAS_PERL(5, 11, 0)
 228  rx->refcnt   = 1;                /* Refcount so we won't be destroyed */
 229
 230  /* Precompiled pattern for pp_regcomp to use */
 231  rx->prelen   = plen;
 232  rx->precomp  = savepvn(pbuf, rx->prelen);
 233
 234  /* Set up qr// stringification to be equivalent to the supplied
 235   * pattern, this should be done via overload eventually */
 236  rx->wraplen  = rx->prelen;
 237  Newx(rx->wrapped, rx->wraplen, char);
 238  Copy(rx->precomp, rx->wrapped, rx->wraplen, char);
 239 #endif
 240
 241  /* Store our private object */
 242  rx->pprivate = obj;
 243
 244  /* Store the pattern for ->pattern */
 245  re->pattern  = (SV *) pattern;
 246  SvREFCNT_inc_simple_void(re->pattern);
 247
 248  /* If there's an exec callback, store it into the private object so that it
 249   * will be the one to be called, even if the engine changes in between */
 250  if (h->exec) {
 251   re->cb_exec = h->exec;
 252   SvREFCNT_inc_simple_void_NN(h->exec);
 253  }
 254
 255  /* Same goes for the free callback, if there's one. */
 256  if (h->free) {
 257   re->cb_free = h->free;
 258   SvREFCNT_inc_simple_void_NN(h->free);
 259  }
 260
 261  re->cb_num_capture_buff_FETCH  = NULL;
 262  re->cb_num_capture_buff_STORE  = NULL;
 263  re->cb_num_capture_buff_LENGTH = NULL;
 264
 265  /* Call our callback function if one was defined, if not we've already set up
 266   * all the stuff we're going to to need for subsequent exec and other calls */
 267  if (h->comp) {
 268   ENTER;
 269   SAVETMPS;
 270
 271   PUSHMARK(SP);
 272   XPUSHs(obj);
 273   PUTBACK;
 274
 275   call_sv(h->comp, G_DISCARD);
 276
 277   FREETMPS;
 278   LEAVE;
 279  }
 280
 281  /* If any of the comp-time accessors were called we'll have to
 282   * update the regexp struct with the new info */
 283  Newxz(rx->offs, rx->nparens + 1, regexp_paren_pair);
 284
 285  return RX;
 286 }
 287
 288 I32
 289 Plugin_exec(pTHX_ REGEXP * const RX, char *stringarg, char *strend,
 290             char *strbeg, REP_ENG_EXEC_MINEND_TYPE minend,
 291             SV *sv, void *data, U32 flags)
 292 {
 293  struct regexp *rx;
 294  re__engine__Plugin self;
 295  I32 matched;
 296
 297  rx = rxREGEXP(RX);
 298  SELF_FROM_PPRIVATE(self, rx->pprivate);
 299
 300  if (self->cb_exec) {
 301   SV *ret;
 302   dSP;
 303
 304   /* Store the current str for ->str */
 305   SvREFCNT_dec(self->str);
 306   self->str = sv;
 307   SvREFCNT_inc_simple_void(self->str);
 308
 309   ENTER;
 310   SAVETMPS;
 311
 312   PUSHMARK(SP);
 313   XPUSHs(rx->pprivate);
 314   XPUSHs(sv);
 315   PUTBACK;
 316
 317   call_sv(self->cb_exec, G_SCALAR);
 318
 319   SPAGAIN;
 320
 321   ret = POPs;
 322   if (SvTRUE(ret))
 323    matched = 1;
 324   else
 325    matched = 0;
 326
 327   PUTBACK;
 328   FREETMPS;
 329   LEAVE;
 330  } else {
 331   matched = 0;
 332  }
 333
 334  return matched;
 335 }
 336
 337 char *
 338 #if XSH_HAS_PERL(5, 19, 1)
 339 Plugin_intuit(pTHX_ REGEXP * const RX, SV *sv, const char * const strbeg,
 340               char *strpos, char *strend, U32 flags, re_scream_pos_data *data)
 341 #else
 342 Plugin_intuit(pTHX_ REGEXP * const RX, SV *sv, char *strpos,
 343               char *strend, U32 flags, re_scream_pos_data *data)
 344 #endif
 345 {
 346  PERL_UNUSED_ARG(RX);
 347  PERL_UNUSED_ARG(sv);
 348 #if XSH_HAS_PERL(5, 19, 1)
 349  PERL_UNUSED_ARG(strbeg);
 350 #endif
 351  PERL_UNUSED_ARG(strpos);
 352  PERL_UNUSED_ARG(strend);
 353  PERL_UNUSED_ARG(flags);
 354  PERL_UNUSED_ARG(data);
 355
 356  return NULL;
 357 }
 358
 359 SV *
 360 Plugin_checkstr(pTHX_ REGEXP * const RX)
 361 {
 362  PERL_UNUSED_ARG(RX);
 363
 364  return NULL;
 365 }
 366
 367 void
 368 Plugin_free(pTHX_ REGEXP * const RX)
 369 {
 370  struct regexp *rx;
 371  re__engine__Plugin self;
 372  SV *callback;
 373  dSP;
 374
 375  if (PL_dirty)
 376   return;
 377
 378  rx = rxREGEXP(RX);
 379  SELF_FROM_PPRIVATE(self, rx->pprivate);
 380
 381  callback = self->cb_free;
 382
 383  if (callback) {
 384   ENTER;
 385   SAVETMPS;
 386
 387   PUSHMARK(SP);
 388   XPUSHs(rx->pprivate);
 389   PUTBACK;
 390
 391   call_sv(callback, G_DISCARD);
 392
 393   PUTBACK;
 394   FREETMPS;
 395   LEAVE;
 396  }
 397
 398  SvREFCNT_dec(self->pattern);
 399  SvREFCNT_dec(self->str);
 400  SvREFCNT_dec(self->stash);
 401
 402  SvREFCNT_dec(self->cb_exec);
 403
 404  SvREFCNT_dec(self->cb_num_capture_buff_FETCH);
 405  SvREFCNT_dec(self->cb_num_capture_buff_STORE);
 406  SvREFCNT_dec(self->cb_num_capture_buff_LENGTH);
 407
 408  self->rx = NULL;
 409
 410  Safefree(self);
 411
 412  SvREFCNT_dec(rx->pprivate);
 413
 414  return;
 415 }
 416
 417 void *
 418 Plugin_dupe(pTHX_ REGEXP * const RX, CLONE_PARAMS *param)
 419 {
 420  struct regexp *rx = rxREGEXP(RX);
 421
 422  Perl_croak(aTHX_ "dupe not supported yet");
 423
 424  return rx->pprivate;
 425 }
 426
 427
 428 void
 429 Plugin_numbered_buff_FETCH(pTHX_ REGEXP * const RX, const I32 paren,
 430                            SV * const sv)
 431 {
 432  struct regexp *rx;
 433  re__engine__Plugin self;
 434  SV *callback;
 435
 436  rx = rxREGEXP(RX);
 437  SELF_FROM_PPRIVATE(self, rx->pprivate);
 438
 439  callback = self->cb_num_capture_buff_FETCH;
 440
 441  if (callback) {
 442   I32 items;
 443   dSP;
 444
 445   ENTER;
 446   SAVETMPS;
 447
 448   PUSHMARK(SP);
 449   XPUSHs(rx->pprivate);
 450   XPUSHs(sv_2mortal(newSViv(paren)));
 451   PUTBACK;
 452
 453   items = call_sv(callback, G_SCALAR);
 454
 455   if (items == 1) {
 456    SV *ret;
 457    SPAGAIN;
 458    ret = POPs;
 459    sv_setsv(sv, ret);
 460   } else {
 461    sv_setsv(sv, &PL_sv_undef);
 462   }
 463
 464   PUTBACK;
 465   FREETMPS;
 466   LEAVE;
 467  } else {
 468   sv_setsv(sv, &PL_sv_undef);
 469  }
 470 }
 471
 472 void
 473 Plugin_numbered_buff_STORE(pTHX_ REGEXP * const RX, const I32 paren,
 474                            SV const * const value)
 475 {
 476  struct regexp *rx;
 477  re__engine__Plugin self;
 478  SV *callback;
 479
 480  rx = rxREGEXP(RX);
 481  SELF_FROM_PPRIVATE(self, rx->pprivate);
 482
 483  callback = self->cb_num_capture_buff_STORE;
 484
 485  if (callback) {
 486   dSP;
 487
 488   ENTER;
 489   SAVETMPS;
 490
 491   PUSHMARK(SP);
 492   XPUSHs(rx->pprivate);
 493   XPUSHs(sv_2mortal(newSViv(paren)));
 494   XPUSHs((SV *) value);
 495   PUTBACK;
 496
 497   call_sv(callback, G_DISCARD);
 498
 499   PUTBACK;
 500   FREETMPS;
 501   LEAVE;
 502  }
 503 }
 504
 505 I32
 506 Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const RX, const SV * const sv,
 507                             const I32 paren)
 508 {
 509  struct regexp *rx;
 510  re__engine__Plugin self;
 511  SV *callback;
 512
 513  rx = rxREGEXP(RX);
 514  SELF_FROM_PPRIVATE(self, rx->pprivate);
 515
 516  callback = self->cb_num_capture_buff_LENGTH;
 517
 518  if (callback) {
 519   IV ret;
 520   dSP;
 521
 522   ENTER;
 523   SAVETMPS;
 524
 525   PUSHMARK(SP);
 526   XPUSHs(rx->pprivate);
 527   XPUSHs(sv_2mortal(newSViv(paren)));
 528   PUTBACK;
 529
 530   call_sv(callback, G_SCALAR);
 531
 532   SPAGAIN;
 533
 534   ret = POPi;
 535
 536   PUTBACK;
 537   FREETMPS;
 538   LEAVE;
 539
 540   return (I32) ret;
 541  } else {
 542   /* TODO: call FETCH and get the length on that value */
 543   return 0;
 544  }
 545 }
 546
 547 SV *
 548 Plugin_named_buff(pTHX_ REGEXP * const RX, SV * const key, SV * const value,
 549                   const U32 flags)
 550 {
 551  return NULL;
 552 }
 553
 554 SV *
 555 Plugin_named_buff_iter(pTHX_ REGEXP * const RX, const SV * const lastkey,
 556                        const U32 flags)
 557 {
 558  return NULL;
 559 }
 560
 561 SV *
 562 Plugin_package(pTHX_ REGEXP * const RX)
 563 {
 564  PERL_UNUSED_ARG(RX);
 565
 566  return newSVpvs(XSH_PACKAGE);
 567 }
 568
 569 static void xsh_user_global_setup(pTHX) {
 570  HV *stash;
 571
 572  stash = gv_stashpvn(XSH_PACKAGE, XSH_PACKAGE_LEN, 1);
 573  newCONSTSUB(stash, "REP_THREADSAFE", newSVuv(XSH_THREADSAFE));
 574  newCONSTSUB(stash, "REP_FORKSAFE",   newSVuv(XSH_FORKSAFE));
 575
 576  return;
 577 }
 578
 579 /* --- XS ------------------------------------------------------------------ */
 580
 581 MODULE = re::engine::Plugin       PACKAGE = re::engine::Plugin
 582
 583 PROTOTYPES: DISABLE
 584
 585 BOOT:
 586 {
 587  xsh_setup();
 588 }
 589
 590 #if XSH_THREADSAFE
 591
 592 void
 593 CLONE(...)
 594 PPCODE:
 595  xsh_clone();
 596  XSRETURN(0);
 597
 598 #endif /* XSH_THREADSAFE */
 599
 600 void
 601 pattern(re::engine::Plugin self, ...)
 602 PPCODE:
 603  XPUSHs(self->pattern);
 604  XSRETURN(1);
 605
 606 void
 607 str(re::engine::Plugin self, ...)
 608 PPCODE:
 609  XPUSHs(self->str);
 610  XSRETURN(1);
 611
 612 void
 613 mod(re::engine::Plugin self)
 614 PREINIT:
 615  U32 flags;
 616  char mods[5 + 1];
 617  int n = 0, i;
 618 PPCODE:
 619  flags = self->rx->intflags;
 620  if (flags & PMf_FOLD)         /* /i */
 621   mods[n++] = 'i';
 622  if (flags & PMf_MULTILINE)    /* /m */
 623   mods[n++] = 'm';
 624  if (flags & PMf_SINGLELINE)   /* /s */
 625   mods[n++] = 's';
 626  if (flags & PMf_EXTENDED)     /* /x */
 627   mods[n++] = 'x';
 628  if (flags & RXf_PMf_KEEPCOPY) /* /p */
 629   mods[n++] = 'p';
 630  mods[n] = '\0';
 631  EXTEND(SP, 2 * n);
 632  for (i = 0; i < n; ++i) {
 633   mPUSHp(mods + i, 1);
 634   PUSHs(&PL_sv_yes);
 635  }
 636  XSRETURN(2 * n);
 637
 638 void
 639 stash(re::engine::Plugin self, ...)
 640 PPCODE:
 641  if (items > 1) {
 642   SvREFCNT_dec(self->stash);
 643   self->stash = ST(1);
 644   SvREFCNT_inc_simple_void(self->stash);
 645   XSRETURN_EMPTY;
 646  } else {
 647   XPUSHs(self->stash);
 648   XSRETURN(1);
 649  }
 650
 651 void
 652 minlen(re::engine::Plugin self, ...)
 653 PPCODE:
 654  if (items > 1) {
 655   self->rx->minlen = (I32)SvIV(ST(1));
 656   XSRETURN_EMPTY;
 657  } else {
 658   if (self->rx->minlen) {
 659    XPUSHs(sv_2mortal(newSViv(self->rx->minlen)));
 660   } else {
 661    XPUSHs(sv_2mortal(&PL_sv_undef));
 662   }
 663   XSRETURN(1);
 664  }
 665
 666 void
 667 gofs(re::engine::Plugin self, ...)
 668 PPCODE:
 669  if (items > 1) {
 670   self->rx->gofs = (U32)SvIV(ST(1));
 671   XSRETURN_EMPTY;
 672  } else {
 673   if (self->rx->gofs) {
 674    XPUSHs(sv_2mortal(newSVuv(self->rx->gofs)));
 675   } else {
 676    XPUSHs(sv_2mortal(&PL_sv_undef));
 677   }
 678   XSRETURN(1);
 679  }
 680
 681 void
 682 nparens(re::engine::Plugin self, ...)
 683 PPCODE:
 684  if (items > 1) {
 685   self->rx->nparens = (U32)SvIV(ST(1));
 686   XSRETURN_EMPTY;
 687  } else {
 688   if (self->rx->nparens) {
 689    XPUSHs(sv_2mortal(newSVuv(self->rx->nparens)));
 690   } else {
 691    XPUSHs(sv_2mortal(&PL_sv_undef));
 692   }
 693   XSRETURN(1);
 694  }
 695
 696 void
 697 _exec(re::engine::Plugin self, ...)
 698 PPCODE:
 699  if (items > 1) {
 700   SvREFCNT_dec(self->cb_exec);
 701   self->cb_exec = ST(1);
 702   SvREFCNT_inc_simple_void(self->cb_exec);
 703  }
 704  XSRETURN(0);
 705
 706 void
 707 _free(re::engine::Plugin self, ...)
 708 PPCODE:
 709  if (items > 1) {
 710   SvREFCNT_dec(self->cb_free);
 711   self->cb_free = ST(1);
 712   SvREFCNT_inc_simple_void(self->cb_free);
 713  }
 714  XSRETURN(0);
 715
 716 void
 717 _num_capture_buff_FETCH(re::engine::Plugin self, ...)
 718 PPCODE:
 719  if (items > 1) {
 720   SvREFCNT_dec(self->cb_num_capture_buff_FETCH);
 721   self->cb_num_capture_buff_FETCH = ST(1);
 722   SvREFCNT_inc_simple_void(self->cb_num_capture_buff_FETCH);
 723  }
 724  XSRETURN(0);
 725
 726 void
 727 _num_capture_buff_STORE(re::engine::Plugin self, ...)
 728 PPCODE:
 729  if (items > 1) {
 730   SvREFCNT_dec(self->cb_num_capture_buff_STORE);
 731   self->cb_num_capture_buff_STORE = ST(1);
 732   SvREFCNT_inc_simple_void(self->cb_num_capture_buff_STORE);
 733  }
 734  XSRETURN(0);
 735
 736 void
 737 _num_capture_buff_LENGTH(re::engine::Plugin self, ...)
 738 PPCODE:
 739  if (items > 1) {
 740   SvREFCNT_dec(self->cb_num_capture_buff_LENGTH);
 741   self->cb_num_capture_buff_LENGTH = ST(1);
 742   SvREFCNT_inc_simple_void(self->cb_num_capture_buff_LENGTH);
 743  }
 744  XSRETURN(0);
 745
 746 SV *
 747 _tag(SV *comp, SV *exec, SV *free)
 748 PREINIT:
 749  xsh_hints_user_t arg;
 750 CODE:
 751  arg.comp = comp;
 752  arg.exec = exec;
 753  arg.free = free;
 754  RETVAL = xsh_hints_tag(&arg);
 755 OUTPUT:
 756  RETVAL
 757
 758 void
 759 ENGINE()
 760 PPCODE:
 761  XPUSHs(sv_2mortal(newSViv(PTR2IV(&engine_plugin))));
 762  XSRETURN(1);