File Coverage

lib/Future/AsyncAwait/Hooks.xs

Criterion	Covered	Total	%
statement	64	65	98.4
branch	22	32	68.7
condition			n/a
subroutine			n/a
pod			n/a
total	86	97	88.6

/*  You may distribute under the terms of either the GNU General Public License
 *  or the Artistic License (the same terms as Perl itself)
 *
 *  (C) Paul Evans, 2023 -- [e-mail]
 */
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "AsyncAwait.h"

#include "XSParseKeyword.h"

#include "perl-backcompat.c.inc"
#include "newOP_CUSTOM.c.inc"

enum {
  HOOK_SUSPEND = 1,
  HOOK_RESUME,
};

static void S_call_block_noargs(pTHX_ CV *blockcv)
{
  dSP;
  PUSHMARK(SP);

  call_sv((SV *)blockcv, G_VOID);
}
#define call_block_noargs(blockcv)  S_call_block_noargs(aTHX_ blockcv)

static void hook_post_suspend(pTHX_ CV *cv, HV *modhookdata, void *hookdata)
{
  SV **svp = hv_fetchs(modhookdata, "Future::AsyncAwait::Hooks/hooklist", 0);
  if(!svp)
    return;

  AV *hooklist = (AV *)*svp;
  svp = AvARRAY(hooklist);

  I32 i;
  for(i = 0; i <= AvFILL(hooklist); i += 2) {
    int type = SvIV(svp[i]);
    if(type == HOOK_SUSPEND)
      call_block_noargs((CV *)svp[i+1]);
  }
}

static void hook_pre_resume(pTHX_ CV *cv, HV *modhookdata, void *hookdata)
{
  SV **svp = hv_fetchs(modhookdata, "Future::AsyncAwait::Hooks/hooklist", 0);
  if(!svp)
    return;

  AV *hooklist = (AV *)*svp;
  svp = AvARRAY(hooklist);

  I32 i;
  for(i = AvFILL(hooklist)-1; i >= 0; i -= 2) {
    int type = SvIV(svp[i]);
    if(type == HOOK_RESUME)
      call_block_noargs((CV *)svp[i+1]);
  }
}

static const struct AsyncAwaitHookFuncs faa_hooks = {
  .post_suspend = &hook_post_suspend,
  .pre_resume   = &hook_pre_resume,
};

#define SAVEAVLEN(av)  S_save_avlen(aTHX_ av)
/* This would be a lot neater if perl had a SAVEFUNCANY2() */
struct AvWithLength {
  AV *av;
  U32 len;
};
void restore_av_len(pTHX_ void *_avl)
{
  struct AvWithLength *avl = _avl;
  AV *av = avl->av;

  while(av_count(av) > avl->len)
    SvREFCNT_dec(av_pop(av));

  Safefree(avl);
}
static void S_save_avlen(pTHX_ AV *av)
{
  struct AvWithLength *avl;
  Newx(avl, 1, struct AvWithLength);

  avl->av = av;
  avl->len = av_count(av);

  SAVEDESTRUCTOR_X(restore_av_len, avl);
}

static OP *pp_pushhook(pTHX)
{
  CV *hookblock = (CV *)cSVOP_sv;
  int type = PL_op->op_private;

  HV *modhookdata = future_asyncawait_get_modhookdata(find_runcv(0), FAA_MODHOOK_CREATE, PL_op->op_targ);
  if(!modhookdata)
    croak("panic: expected modhookdata");

  AV *hooklist;
  SV **svp = hv_fetchs(modhookdata, "Future::AsyncAwait::Hooks/hooklist", 0);
  if(svp)
    hooklist = (AV *)*svp;
  else
    hv_stores(modhookdata, "Future::AsyncAwait::Hooks/hooklist", (SV *)(hooklist = newAV()));

  SAVEAVLEN(hooklist);

  av_push(hooklist, newSViv(type));
  av_push(hooklist, (SV *)cv_clone(hookblock));

  return PL_op->op_next;
}

static int build_suspend(pTHX_ OP **out, XSParseKeywordPiece *arg0, void *hookdata)
{
  CV *block = arg0->cv;

  *out = newSVOP_CUSTOM(&pp_pushhook, (HOOK_SUSPEND) << 8, (SV *)block);
  (*out)->op_targ = future_asyncawait_make_precreate_padix();

  return KEYWORD_PLUGIN_STMT;
}

static int build_resume(pTHX_ OP **out, XSParseKeywordPiece *arg0, void *hookdata)
{
  CV *block = arg0->cv;

  *out = newSVOP_CUSTOM(&pp_pushhook, (HOOK_RESUME) << 8, (SV *)block);
  (*out)->op_targ = future_asyncawait_make_precreate_padix();

  return KEYWORD_PLUGIN_STMT;
}

static const struct XSParseKeywordHooks hooks_suspend = {
  .permit_hintkey = "Future::AsyncAwait::Hooks/suspend",
  .piece1 = XPK_ANONSUB, // TODO: block
  .build1 = &build_suspend,
};

static const struct XSParseKeywordHooks hooks_resume = {
  .permit_hintkey = "Future::AsyncAwait::Hooks/resume",
  .piece1 = XPK_ANONSUB, // TODO: block
  .build1 = &build_resume,
};

MODULE = Future::AsyncAwait::Hooks    PACKAGE = Future::AsyncAwait::Hooks

BOOT:
  boot_future_asyncawait(0.63);
  boot_xs_parse_keyword(0.13);

  register_future_asyncawait_hook(&faa_hooks, NULL);

  register_xs_parse_keyword("suspend", &hooks_suspend, NULL);
  register_xs_parse_keyword("resume",  &hooks_resume,  NULL);