Util.xs

   1 /* This file is part of the Scalar::Vec::Util Perl module.
   2  * See http://search.cpan.org/dist/Scalar-Vec-Util/ */
   3
   4 #define PERL_NO_GET_CONTEXT
   5 #include "EXTERN.h"
   6 #include "perl.h"
   7 #include "XSUB.h"
   8
   9 #define __PACKAGE__     "Scalar::Vec::Util"
  10 #define __PACKAGE_LEN__ (sizeof(__PACKAGE__)-1)
  11
  12 #include "bitvect.h"
  13
  14 STATIC size_t svu_validate_uv(pTHX_ SV *sv, const char *desc) {
  15 #define svu_validate_uv(S, D) svu_validate_uv(aTHX_ (S), (D))
  16  IV i;
  17
  18  if (SvOK(sv) && SvIOK(sv)) {
  19   if (SvIsUV(sv))
  20    return SvUVX(sv);
  21   else {
  22    i = SvIVX(sv);
  23    if (i >= 0)
  24     return i;
  25   }
  26  } else {
  27   i = SvIV(sv);
  28   if (i >= 0)
  29    return i;
  30  }
  31
  32  croak("Invalid negative %s", desc ? desc : "integer");
  33  return 0;
  34 }
  35
  36 STATIC char *svu_prepare_sv(pTHX_ SV *sv, size_t s, size_t l) {
  37 #define svu_prepare_sv(S, I, L) svu_prepare_sv(aTHX_ (S), (I), (L))
  38  STRLEN  c;
  39  size_t  n = s + l, i, j1, j2, k, z;
  40  char   *p;
  41
  42  SvUPGRADE(sv, SVt_PV);
  43
  44  p = SvGROW(sv, BV_SIZE(n));
  45  c = SvCUR(sv);
  46
  47  j1 = (s / BITS(BV_UNIT)) * sizeof(BV_UNIT);
  48  k  = j1 + sizeof(BV_UNIT);
  49  for (i = c < j1 ? j1 : c; i < k; ++i)
  50   p[i] = 0;
  51
  52  j2 = ((s + l - 1) / BITS(BV_UNIT)) * sizeof(BV_UNIT);
  53  if (j2 > j1) {
  54   k = j2 + sizeof(BV_UNIT);
  55   for (i = c < j2 ? j2 : c; i < k; ++i)
  56    p[i] = 0;
  57  }
  58
  59  z = 1 + ((s + l - 1) / CHAR_BIT);
  60  if (c < z)
  61   SvCUR_set(sv, z);
  62
  63  return p;
  64 }
  65
  66 /* --- XS ------------------------------------------------------------------ */
  67
  68 MODULE = Scalar::Vec::Util              PACKAGE = Scalar::Vec::Util
  69
  70 PROTOTYPES: ENABLE
  71
  72 BOOT:
  73 {
  74  HV *stash = gv_stashpvn(__PACKAGE__, __PACKAGE_LEN__, 1);
  75  newCONSTSUB(stash, "SVU_PP",   newSVuv(0));
  76  newCONSTSUB(stash, "SVU_SIZE", newSVuv(SVU_SIZE));
  77 }
  78
  79 void
  80 vfill(SV *sv, SV *ss, SV *sl, SV *sf)
  81 PROTOTYPE: $$$$
  82 PREINIT:
  83  size_t s, l;
  84  char f, *v;
  85 CODE:
  86  l = svu_validate_uv(sl, "length");
  87  if (!l)
  88   XSRETURN(0);
  89  s = svu_validate_uv(ss, "offset");
  90  v = svu_prepare_sv(sv, s, l);
  91  f = SvTRUE(sf);
  92
  93  bv_fill(v, s, l, f);
  94
  95  XSRETURN(0);
  96
  97 void
  98 vcopy(SV *sf, SV *sfs, SV *st, SV *sts, SV *sl)
  99 PROTOTYPE: $$$$$
 100 PREINIT:
 101  size_t fs, ts, l, lf = 0, c;
 102  char *t, *f;
 103 CODE:
 104  l = svu_validate_uv(sl, "length");
 105  if (!l)
 106   XSRETURN(0);
 107  fs = svu_validate_uv(sfs, "offset");
 108  ts = svu_validate_uv(sts, "offset");
 109
 110  t = svu_prepare_sv(st, ts, l);
 111
 112  f = SvPVX(sf); /* We do it there in case st == sf. */
 113  c = SvCUR(sf);
 114  if (c * CHAR_BIT <= fs + l && c <= SvCUR(st)) {
 115   lf = fs + l - c * CHAR_BIT;
 116   l  = c * CHAR_BIT - fs;
 117  }
 118
 119  if (f == t) {
 120   bv_move(f, ts, fs, l);
 121  } else {
 122   bv_copy(t, ts, f, fs, l);
 123  }
 124
 125  if (lf) {
 126   bv_fill(t, ts + l, lf, 0);
 127  }
 128
 129  XSRETURN(0);
 130
 131 SV *
 132 veq(SV *sv1, SV *ss1, SV *sv2, SV *ss2, SV *sl)
 133 PROTOTYPE: $$$$$
 134 PREINIT:
 135  size_t s1, s2, l, o, n;
 136  char *v1, *v2;
 137 CODE:
 138  l = svu_validate_uv(sl, "length");
 139  if (!l)
 140   XSRETURN_YES;
 141  s1 = svu_validate_uv(ss1, "offset");
 142  s2 = svu_validate_uv(ss2, "offset");
 143  SvUPGRADE(sv1, SVt_PV);
 144  SvUPGRADE(sv2, SVt_PV);
 145
 146  n  = BV_SIZE(s1 + l);
 147  o  = SvLEN(sv1);
 148  if (n > o) {
 149   l = o * CHAR_BIT - s1;
 150  }
 151
 152  n  = BV_SIZE(s2 + l);
 153  o  = SvLEN(sv2);
 154  if (n > o) {
 155   l = o * CHAR_BIT - s2;
 156  }
 157
 158  v1 = SvPVX(sv1);
 159  v2 = SvPVX(sv2);
 160
 161  RETVAL = newSVuv(bv_eq(v1, s1, v2, s2, l));
 162 OUTPUT:
 163  RETVAL