ACIL FM

Nama	Ukuran	Aksi
lib	-	Open
t	-	Open
tlib	-	Open
Changes	8.75 MB	View DL Edit
config.h	3.94 MB	View DL Edit
config.h.in	3.73 MB	View DL Edit
config.log	19.6 MB	View DL Edit
config.status	18.89 MB	View DL Edit
configure.ac	1.47 MB	View DL Edit
configure.cc	150.46 MB	View DL Edit
configure.gcc	203.22 MB	View DL Edit
localconf.h	1.32 MB	View DL Edit
localperl.h	92 B	View DL Edit
Makefile	29.89 MB	View DL Edit
Makefile.PL	5.19 MB	View DL Edit
MANIFEST	744 B	View DL Edit
MANIFEST.SKIP	306 B	View DL Edit
MYMETA.json	793 B	View DL Edit
MYMETA.yml	484 B	View DL Edit
pm_to_blib	0 B	View DL Edit
README	19.37 MB	View DL Edit
typemap	354 B	View DL Edit
Util.bs	0 B	View DL Edit
Util.c	26.61 MB	View DL Edit
Util.o	352.65 MB	View DL Edit
Util.pm	22 MB	View DL Edit
Util.xs	16.44 MB	View DL Edit
Util_IS.pm	728 B	View DL Edit

Edit file: /home/.cpan/build/NetAddr-IP-4.079-0/Lite/Util/Util.c

/*
 * This file was generated automatically by ExtUtils::ParseXS version 3.40 from the
 * contents of Util.xs. Do not edit this file, edit Util.xs instead.
 *
 *    ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "Util.xs"

/*
 * Copyright 2006 - 2012, Michael Robinton <michael@bizsystems.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#ifdef __cplusplus
extern "C" {
#endif

#ifdef _CYGWIN
#include <windows.h>
#endif

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

/*	needed for testing with 'printf'
#include <stdio.h>
 */

#ifdef _CYGWIN
#include <Win32-Extensions.h>
#endif

#include "localconf.h"

#ifdef __cplusplus
}
#endif

/*	workaround for OS's without inet_aton			*/
/*	#include "xs_include/inet_aton.c"	removed 10-12-11 */

typedef union
{
  u_int32_t     u[4];
  unsigned char c[16];
} n128;

char * is_ipv6to4 = "ipv6to4", * is_shiftleft = "shiftleft", * is_comp128 = "comp128";
char * is_sub128 = "sub128", * is_add128 = "add128";
char * is_hasbits = "hasbits";
/* , * is_isIPv4 = "isIPv4"; */
char * is_bcd2bin = "bcd2bin", * is_simple_pack = "simple_pack", * is_bcdn2bin = "bcdn2bin";
char * is_mask4to6 = "mask4to6", * is_ipv4to6 = "ipv4to6";
char * is_maskanyto6 = "maskanyto6", * is_ipanyto6 = "ipanyto6";

typedef struct bcdstuff
{		/*	character array of 40 bytes			*/
  char		txt[21];	/*	20 bytes + string terminator	*/
  u_int32_t	bcd[5];		/*	20 bytes, 40 digits		*/
} BCD;

#define zero ('0' & 0x7f)

/*	useful for debug, prints the 128 bits of 8, 16 bit registers	*/
void
printb128(char * b)
{
  int c;
  for(c=0;c<16;c++) {
    if (b[c] &0x80)
      printf("1");
    else
      printf("0");
    if (b[c] &0x40)
      printf("1");
    else
      printf("0");
    if (b[c] &0x20)
      printf("1");
    else
      printf("0");
    if (b[c] &0x10)
      printf("1");
    else
      printf("0");
    if (b[c] &0x8)
      printf("1");
    else
      printf("0");
    if (b[c] &0x4)
      printf("1");
    else
      printf("0");
    if (b[c] &0x2)
      printf("1");
    else
      printf("0");
    if (b[c] &0x1)
      printf("1");
    else
      printf("0");
    if (c == 3 || c == 7 || c == 11)
      printf("\n");
  }
  printf("\n\n");
}

void
extendipv4(void * aa, void * ux)
{
  register u_int32_t * a = ux;
  *a++ = 0;
  *a++ = 0;
  *a++ = 0;
  *a = *((u_int32_t *)aa);
}

void
extendmask4(void * aa, void * ux)
{
  register u_int32_t * a = ux;
  *a++ = 0xffffffff;
  *a++ = 0xffffffff;
  *a++ = 0xffffffff;
  *a = *((u_int32_t *)aa);
}

void
fastcomp128(void * aa)
{
  register u_int32_t * a = aa;

*a++ ^= 0xffffffff;
  *a++ ^= 0xffffffff;
  *a++ ^= 0xffffffff;
  *a++ ^= 0xffffffff;
}

/*	add two 128 bit numbers
	return the carry
 */

int
adder128(void * aa, void * bb, n128 * ap128, int carry)
{
  int i;
  register u_int32_t a, b, r;

for (i=3; i >= 0; i--) {
    a = *((u_int32_t *)aa + i);
    b = *((u_int32_t *)bb + i);
    r = a + b;
    a = 0;			/*	ripple carry forward	*/
    if ( r < a || r < b)	/*	if overflow		*/
      a = 1;

b = r + carry;		/*	carry propagate	in	*/
    if (b < r)			/*	ripple carry forward	*/
      carry = 1;		/*	if overflow		*/
    else
      carry = a;

*((u_int32_t *)(ap128->u) + i) = b;
  }
  return carry;
}

int
addercon(void * aa, u_int32_t * bb, n128 * ap128, int32_t con)
{
  register u_int32_t tmp = 0x80000000;

if (con & tmp)
    tmp = 0xffffffff;
  else
    tmp = 0;

bb[0] = tmp;
  bb[1] = tmp;
  bb[2] = tmp;
  bb[3] = (u_int32_t)con;
  return adder128(aa,bb,ap128,0);
}

int
have128(void * bp)
{
  register u_int32_t * p = bp;

if (*p++ || *p++ || *p++ || *p++)
    return 1;
  return 0;
}

int
_isipv4(void * bp)
{
  register u_int32_t * p = bp;

if (*p++ || *p++ || *p++)
    return 0;
  return 1;
}

/*	network byte swap and copy	*/
void
netswap_copy(void * dest, void * src, int len)
{
  register u_int32_t * d = dest, * s = src;

for (/* -- */;len>0;len--) {
#ifdef host_is_LITTLE_ENDIAN
    *d++ =  (((*s & 0xff000000) >> 24) | ((*s & 0x00ff0000) >>  8) | \
	     ((*s & 0x0000ff00) <<  8) | ((*s & 0x000000ff) << 24));
#else
# ifdef host_is_BIG_ENDIAN
    *d++ = *s;
# else
# error ENDIANness not defined
# endif
#endif
    s++;
  }
}

/*	do ntohl / htonl changes as necessary for this OS
 */
void
netswap(void * ap, int len)
{
#ifdef host_is_LITTLE_ENDIAN
  register u_int32_t * a = ap;
  for (/* -- */;len >0;len--) {
    *a =  (((*a & 0xff000000) >> 24) | ((*a & 0x00ff0000) >>  8) | \
	     ((*a & 0x0000ff00) <<  8) | ((*a & 0x000000ff) << 24));
    a++;
  }
#endif
}

/*	shift right to purge '0's,
	return mask bit count and remainder value,
	left fill with ones
 */
unsigned char
_countbits(void *ap)
{
  register u_int32_t * p0 = (u_int32_t *)ap, * p1 = p0 +1, * p2 = p1 +1, * p3 = p2 +1;
  unsigned char count = 128;

fastcomp128(ap);

do {
    if (!(*p3 & 1))
      break;
    count--;
    *p3 >>= 1;
    if (*p2 & 1)
      *p3 |= 0x80000000;
    *p2 >>= 1;
    if (*p1 & 1)
      *p2 |= 0x80000000;
    *p1 >>= 1;
    if (*p0 & 1)
      *p1 |= 0x80000000;
    *p0 >>= 1;
  } while (count > 0);
  return count;
}

/*	multiply 128 bit number x 2
 */
void
_128x2(u_int32_t * ap)
{
  register u_int32_t * p = ap +3, tmpc, carry = 0;

do {
    tmpc = *p & 0x80000000;	/*	propagate hi bit to next word	*/
    *p <<= 1;
    if (carry)
      *p += 1;
    carry = tmpc;
  } while (p-- > ap);
/* printf("2o %04X:%04X:%04X:%04X\n",*(ap),*(ap +1),*(ap +2),*(ap +3)); */
}

/*	multiply 128 bit number X10
 */
void
_128x10(n128 * ap128, n128 * tp128)
{
  register u_int32_t * ap = ap128->u, * tp = tp128->u;
  _128x2(ap);					/*	multiply by two		*/
  *tp		= *ap;				/*	temp save		*/
  *(tp +1)	= *(ap +1);
  *(tp +2)	= *(ap +2);
  *(tp +3)	= *(ap +3);
  _128x2(ap);
  _128x2(ap);					/*	times 8			*/
  (void) adder128(ap,tp,ap128,0);
/* printf("x  %04X:%04X:%04X:%04X\n",*((u_int32_t *)ap),*((u_int32_t *)ap +1),*((u_int32_t *)ap +2),*((u_int32_t *)ap +3)); */
}

/*	multiply 128 bit number by 10, add bcd digit to result
 */
void
_128x10plusbcd(n128 * ap128, n128 * tp128, char digit)
{
  register u_int32_t * ap = ap128->u, * tp = tp128->u;
/* printf("digit %X + %X = ",digit,*(ap +3)); */
  _128x10(ap128,tp128);
  *tp		= 0;
  *(tp + 1)	= 0;
  *(tp + 2)	= 0;
  *(tp + 3)	= digit;
  (void) adder128(ap,tp,ap128,0);
/* printf("%d %04X:%04X:%04X:%04X\n",digit,*((u_int32_t *)ap),*((u_int32_t *)ap +1),*((u_int32_t *)ap +2),*((u_int32_t *)ap +3)); */
}

char
_simple_pack(void * str,int len, BCD * n)
{
  int i = len -1, j=19, lo=1;
  register unsigned char c, * bcdn = (unsigned char *)(n->bcd), * sp = (unsigned char *) str;

if (len > 40)
    return '*';				/*	error, input string too long	*/

memset (bcdn, 0, 20);

do {
    c = *(sp + i) & 0x7f;
    if (c < zero || c > (zero + 9))
      return c;				/*	error, out of range	*/

if (lo) {			/*	lo byte ?		*/
      *(bcdn + j) = c & 0xF;
      lo = 0;
    }
    else {
      c <<= 4;
      *(bcdn + j) |= c;
      lo = 1;			/*	lo byte next		*/
      j--;
    }
  } while (i-- > 0);
  return 0;
}

/*	convert a packed bcd string to 128 bit binary string
 */
void
_bcdn2bin(void * bp, n128 * ap128, n128 * cp128, int len)
{
  int i = 0, hasdigits = 0, lo;
  register unsigned char c, * cp = (unsigned char *)bp;

memset(ap128->c, 0, 16);
  memset(cp128->c, 0, 16);

while (i < len ) {
    c = *cp++;
    for (lo=0;lo<2;lo+=1) {
      if (lo) {
	if (hasdigits)			/*	suppress leading zero multiplications	*/
	  _128x10plusbcd(ap128, cp128, c & 0xF);
	else {
	  if (c & 0xF) {
	    hasdigits = 1;
	    ap128->u[3] = c & 0xF;
	  }
	}
      }
      else {
	if (hasdigits)			/*	suppress leading zero multiplications	*/
	  _128x10plusbcd(ap128, cp128, c >> 4);
	else {
	  if (c & 0XF0) {
	    hasdigits = 1;
	    ap128->u[3] = c >> 4;
	  }
	}
      }
      i++;
      if (i >= len)
	break;
    }
  }
}

/*	convert a 128 bit number string to a bcd number string
	returns the length of the bcd string === 20
 */
int
_bin2bcd (unsigned char * binary, BCD * n)
{
   register u_int32_t tmp, add3, msk8, bcd8, carry = 0;
  u_int32_t word;
  unsigned char binmsk = 0;
  int c = 0,i, j, p;

memset (n->bcd, 0, 20);

for (p=0;p<128;p++) {			/*	bit pointer	*/
    if (! binmsk) {
      word = *((unsigned char *)binary + c);
      binmsk = 0x80;
      c++;
    }
    carry = word & binmsk;		/*	bit to convert	*/
    binmsk >>= 1;
    for (i=4;i>=0;i--) {
      bcd8 = n->bcd[i];
      if (carry | bcd8) {		/* if something to do		*/
	add3 = 3;
	msk8 = 8;

for (j=0;j<8;j++) {		/*	prep bcd digits for X2	*/
	  tmp = bcd8 + add3;
	  if (tmp & msk8)
	    bcd8 = tmp;
	  add3 <<= 4;
	  msk8 <<= 4;
	}
	tmp = bcd8 & 0x80000000;	/*	propagated carry	*/
	bcd8 <<= 1;			/*	x 2			*/
	if (carry)
	  bcd8 += 1;
	n->bcd[i] = bcd8;
	carry = tmp;
      }
    }
  }
  netswap(n->bcd,5);
  return 20;
}

/*	convert a bcd number string to a bcd text string
	returns the number of digits
 */
int
_bcd2txt(unsigned char * bcd2p, BCD * n)
{
  register unsigned char bcd, dchar;
  int	i, j = 0;

for (i=0;i<20;i++) {
    dchar = *(bcd2p + i);
    bcd = dchar >> 4;
    if (j || bcd) {
      n->txt[j] = bcd + zero;
      j++;
    }
    bcd = dchar & 0xF;
    if (j || bcd || i == 19) {		/* must be at least one digit	*/
      n->txt[j] = bcd + zero;
      j++;
    }
  }
  n->txt[j] = 0;				/* string terminator	*/
  return j;
}

/*	INCLUDE: xs_include/miniSocket.inc	removed 10-12-11	*/

#line 486 "Util.c"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif

/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */

/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */

/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

PERL_ARGS_ASSERT_CROAK_XS_USAGE;

if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

if (hvname)
	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
        else
	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#define croak_xs_usage        S_croak_xs_usage

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#if PERL_VERSION_LE(5, 21, 5)
#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif

#line 630 "Util.c"

XS_EUPXS(XS_NetAddr__IP__Util_comp128); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_comp128)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "s, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	s = ST(0)
;
#line 487 "Util.xs"
	unsigned char * ap;
	char * subname;
	u_int32_t wa[4];
	STRLEN len;
	int i;
#line 650 "Util.c"
#line 493 "Util.xs"
	ap = (unsigned char *) SvPV(s,len);
	if (len != 16) {
	  if (ix == 2)
	    subname = is_ipv6to4;
	  else if (ix == 1)
	    subname = is_shiftleft;
	  else
	    subname = is_comp128;
	  croak("Bad arg length for %s%s, length is %d, should be %d",
		"NetAddr::IP::Util::",subname,len *8,128);
	}
	if (ix == 2) {
	  XPUSHs(sv_2mortal(newSVpvn((char *)(ap +12),4)));
	  XSRETURN(1);
	}
	else if (ix == 1) {
	  if (items < 2) {
	    memcpy(wa,ap,16);
	  }
	  else if ((i = SvIV(ST(1))) == 0) {
	    memcpy(wa,ap,16);
	  }
	  else if (i < 0 || i > 128) {
	    croak("Bad arg value for %s, is %d, should be 0 thru 128",
		"NetAddr::IP::Util::shiftleft",i);
	  }
	  else {
	    netswap_copy(wa,ap,4);
	    do {
		_128x2(wa);
		i--;
	    } while (i > 0);
	    netswap(wa,4);
	  }
	}
	else {
	  memcpy(wa,ap,16);
	  fastcomp128(wa);
	}
	XPUSHs(sv_2mortal(newSVpvn((char *)wa,16)));
	XSRETURN(1);
#line 693 "Util.c"
	PUTBACK;
	return;
    }
}

XS_EUPXS(XS_NetAddr__IP__Util_add128); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_add128)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 2)
       croak_xs_usage(cv,  "as, bs");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	as = ST(0)
;
	SV *	bs = ST(1)
;
#line 542 "Util.xs"
	unsigned char * ap, *bp;
	char * subname;
	u_int32_t wa[4], wb[4];
	n128 a128;
	STRLEN len;
#line 720 "Util.c"
#line 548 "Util.xs"
	ap = (unsigned char *) SvPV(as,len);
	if (len != 16) {
    Bail:
	  if (ix == 1)
	    subname = is_sub128;
	  else
	    subname = is_add128;
	  croak("Bad arg length for %s%s, length is %d, should be %d",
		"NetAddr::IP::Util::",subname,len *8,128);
	}

bp = (unsigned char *) SvPV(bs,len);
	if (len != 16) {
	  goto Bail;
	}
	netswap_copy(wa,ap,4);
	netswap_copy(wb,bp,4);
	if (ix == 1) {
	  fastcomp128(wb);
	  XPUSHs(sv_2mortal(newSViv((I32)adder128(wa,wb,&a128,1))));
	}
	else {
	  XPUSHs(sv_2mortal(newSViv((I32)adder128(wa,wb,&a128,0))));
	}
	if (GIMME_V == G_ARRAY) {
	  netswap(a128.u,4);
	  XPUSHs(sv_2mortal(newSVpvn((char *)a128.c,16)));
	  XSRETURN(2);
	}
	XSRETURN(1);
#line 752 "Util.c"
	PUTBACK;
	return;
    }
}

XS_EUPXS(XS_NetAddr__IP__Util_addconst); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_addconst)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "s, cnst");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	s = ST(0)
;
	I32	cnst = (I32)SvIV(ST(1))
;
#line 584 "Util.xs"
	n128 a128;
	unsigned char * ap;
	u_int32_t wa[4], wb[4];
	STRLEN len;
#line 777 "Util.c"
#line 589 "Util.xs"
	ap = (unsigned char *) SvPV(s,len);
	if (len != 16) {
	  croak("Bad arg length for %s, length is %d, should be %d",
		"NetAddr::IP::Util::addconst",len *8,128);
	}
	netswap_copy(wa,ap,4);
	XPUSHs(sv_2mortal(newSViv((I32)addercon(wa,wb,&a128,cnst))));
	if (GIMME_V == G_ARRAY) {
	  netswap(a128.u,4);
	  XPUSHs(sv_2mortal(newSVpvn((char *)a128.c,16)));
	  XSRETURN(2);
	}
	XSRETURN(1);
#line 792 "Util.c"
	PUTBACK;
	return;
    }
}

XS_EUPXS(XS_NetAddr__IP__Util_hasbits); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_hasbits)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "s");
    {
	SV *	s = ST(0)
;
#line 608 "Util.xs"
	unsigned char * bp;
	char * subname;
	STRLEN len;
#line 812 "Util.c"
	int	RETVAL;
	dXSTARG;
#line 612 "Util.xs"
	bp = (unsigned char *) SvPV(s,len);
	if (len != 16) {
	  subname = is_hasbits;
	  croak("Bad arg length for %s%s, length is %d, should be %d",
		"NetAddr::IP::Util::",subname,len *8,128);
	}
	RETVAL = have128(bp);
#line 823 "Util.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS_EUPXS(XS_NetAddr__IP__Util_bin2bcd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_bin2bcd)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "s");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	s = ST(0)
;
#line 629 "Util.xs"
	BCD n;
	unsigned char * cp;
	STRLEN	len;
#line 846 "Util.c"
#line 633 "Util.xs"
	cp = (unsigned char *) SvPV(s,len);
	if (ix == 0) {
	  if (len != 16) {
	    croak("Bad arg length for %s, length is %d, should be %d",
		"NetAddr::IP::Util::bin2bcd",len *8,128);
	  }
	  (void) _bin2bcd(cp,&n);
	  XPUSHs(sv_2mortal(newSVpvn((char *)n.txt,_bcd2txt((unsigned char *)n.bcd,&n))));
	}
	else if (ix == 1) {
	  if (len != 16) {
	    croak("Bad arg length for %s, length is %d, should be %d",
		"NetAddr::IP::Util::bin2bcdn",len *8,128);
	  }
	  XPUSHs(sv_2mortal(newSVpvn((char *)n.bcd,_bin2bcd(cp,&n))));
	}
	else {
	  if (len > 20) {
	    croak("Bad arg length for %s, length is %d, should %d digits or less",
		"NetAddr::IP::Util::bcdn2txt",len *2,40);
	  }
	  XPUSHs(sv_2mortal(newSVpvn((char *)n.txt,_bcd2txt(cp,&n))));
	}
	XSRETURN(1);
#line 872 "Util.c"
	PUTBACK;
	return;
    }
}

XS_EUPXS(XS_NetAddr__IP__Util_bcd2bin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_bcd2bin)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "s, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	s = ST(0)
;
#line 671 "Util.xs"
	BCD n;
	n128 c128, a128;
	unsigned char * cp, badc;
	char * subname;
	STRLEN len;
#line 897 "Util.c"
#line 677 "Util.xs"
	cp = (unsigned char *) SvPV(s,len);
	if (len > 40) {
	  if (ix == 0)
	    subname = is_bcd2bin;
	  else if (ix ==1)
	    subname = is_simple_pack;
    Badigits:
	  croak("Bad arg length for %s%s, length is %d, should be %d digits or less",
		"NetAddr::IP::Util::",subname,len,40);
	}
	if (ix == 2) {
	  if (len > 20) {
	    len <<= 1;		/*	times 2	*/
	    subname = is_bcdn2bin;
	    goto Badigits;
	  }
	  if (items < 2) {
	    croak("Bad usage, should have %s('packedbcd,length)",
		"NetAddr::IP::Util::bcdn2bin");
	  }
	  len = SvIV(ST(1));
	  _bcdn2bin(cp,&a128,&c128,(int)len);
	  netswap(a128.u,4);
	  XPUSHs(sv_2mortal(newSVpvn((char *)a128.c,16)));
	  XSRETURN(1);
	}
	badc = _simple_pack(cp,(int)len, &n);
	if (badc) {
	  if (ix == 1)
	    subname = is_simple_pack;
	  else
	    subname = is_bcd2bin;
	  croak("Bad char in string for %s%s, character is '%c', allowed are 0-9",
		"NetAddr::IP::Util::",subname,badc);
	}
	if (ix == 0) {
	  _bcdn2bin((void *)n.bcd,&a128,&c128,40);
	  netswap(a128.u,4);
	  XPUSHs(sv_2mortal(newSVpvn((char *)a128.c,16)));
	}
	else {	/*	ix == 1	*/
	  XPUSHs(sv_2mortal(newSVpvn((char *)n.bcd,20)));
	}
	XSRETURN(1);
#line 943 "Util.c"
	PUTBACK;
	return;
    }
}

XS_EUPXS(XS_NetAddr__IP__Util_notcontiguous); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_notcontiguous)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "s");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	s = ST(0)
;
#line 726 "Util.xs"
	unsigned char * ap, count;
	u_int32_t wa[4];
	STRLEN len;
#line 965 "Util.c"
#line 730 "Util.xs"
	ap = (unsigned char *) SvPV(s,len);
	if (len != 16) {
	  croak("Bad arg length for %s, length is %d, should be %d",
		"NetAddr::IP::Util::countbits",len *8,128);
	}
	netswap_copy(wa,ap,4);
	count = _countbits(wa);
	XPUSHs(sv_2mortal(newSViv((I32)have128(wa))));
	if (GIMME_V == G_ARRAY) {
	  XPUSHs(sv_2mortal(newSViv((I32)count)));
	  XSRETURN(2);
	}
	XSRETURN(1);
#line 980 "Util.c"
	PUTBACK;
	return;
    }
}

XS_EUPXS(XS_NetAddr__IP__Util_ipv4to6); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_ipv4to6)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "s");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	s = ST(0)
;
#line 750 "Util.xs"
	unsigned char * ip;
	char * subname;
	u_int32_t wa[4];
	STRLEN len;
#line 1004 "Util.c"
#line 755 "Util.xs"
	ip = (unsigned char *) SvPV(s,len);
	if (len != 4) {
	  if (ix == 1)
	    subname = is_mask4to6;
	  else
	    subname = is_ipv4to6;
	  croak("Bad arg length for %s%s, length is %d, should be 32",
		"NetAddr::IP::Util::",subname,len *8);
	}
	if (ix == 0)
	  extendipv4(ip, wa);
	else
	  extendmask4(ip, wa);
	XPUSHs(sv_2mortal(newSVpvn((char *)wa,16)));
	XSRETURN(1);
#line 1021 "Util.c"
	PUTBACK;
	return;
    }
}

XS_EUPXS(XS_NetAddr__IP__Util_ipanyto6); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_ipanyto6)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "s");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	s = ST(0)
;
#line 777 "Util.xs"
	unsigned char * ip;
	char * subname;
	u_int32_t wa[4];
	STRLEN len;
#line 1045 "Util.c"
#line 782 "Util.xs"
	ip = (unsigned char *) SvPV(s,len);
	if (len == 16)		/* if already 128 bits, return input	*/
	  XPUSHs(sv_2mortal(newSVpvn((char *)ip,16)));
	else if (len == 4) {
	  if (ix == 0)
	    extendipv4(ip, wa);
	  else
	    extendmask4(ip, wa);
	  XPUSHs(sv_2mortal(newSVpvn((char *)wa,16)));
	}
	else {
	  if (ix == 1)
	    subname = is_maskanyto6;
	  else
	    subname = is_ipanyto6;
	  croak("Bad arg length for %s%s, length is %d, should be 32 or 128",
		"NetAddr::IP::Util::",subname,len *8);
	}
	XSRETURN(1);
#line 1066 "Util.c"
	PUTBACK;
	return;
    }
}

#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_NetAddr__IP__Util); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_NetAddr__IP__Util)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if (PERL_REVISION == 5 && PERL_VERSION < 9)
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

PERL_UNUSED_VAR(file);

PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
    XS_VERSION_BOOTCHECK;
#  ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#  endif
#endif

{
        CV * cv;

cv = newXSproto_portable("NetAddr::IP::Util::comp128", XS_NetAddr__IP__Util_comp128, file, "$;@");
        XSANY.any_i32 = 0;
        cv = newXSproto_portable("NetAddr::IP::Util::ipv6to4", XS_NetAddr__IP__Util_comp128, file, "$;@");
        XSANY.any_i32 = 2;
        cv = newXSproto_portable("NetAddr::IP::Util::shiftleft", XS_NetAddr__IP__Util_comp128, file, "$;@");
        XSANY.any_i32 = 1;
        cv = newXSproto_portable("NetAddr::IP::Util::add128", XS_NetAddr__IP__Util_add128, file, "$$");
        XSANY.any_i32 = 0;
        cv = newXSproto_portable("NetAddr::IP::Util::sub128", XS_NetAddr__IP__Util_add128, file, "$$");
        XSANY.any_i32 = 1;
        (void)newXSproto_portable("NetAddr::IP::Util::addconst", XS_NetAddr__IP__Util_addconst, file, "$$");
        (void)newXSproto_portable("NetAddr::IP::Util::hasbits", XS_NetAddr__IP__Util_hasbits, file, "$");
        cv = newXSproto_portable("NetAddr::IP::Util::bcdn2txt", XS_NetAddr__IP__Util_bin2bcd, file, "$");
        XSANY.any_i32 = 2;
        cv = newXSproto_portable("NetAddr::IP::Util::bin2bcd", XS_NetAddr__IP__Util_bin2bcd, file, "$");
        XSANY.any_i32 = 0;
        cv = newXSproto_portable("NetAddr::IP::Util::bin2bcdn", XS_NetAddr__IP__Util_bin2bcd, file, "$");
        XSANY.any_i32 = 1;
        cv = newXSproto_portable("NetAddr::IP::Util::bcd2bin", XS_NetAddr__IP__Util_bcd2bin, file, "$;@");
        XSANY.any_i32 = 0;
        cv = newXSproto_portable("NetAddr::IP::Util::bcdn2bin", XS_NetAddr__IP__Util_bcd2bin, file, "$;@");
        XSANY.any_i32 = 2;
        cv = newXSproto_portable("NetAddr::IP::Util::simple_pack", XS_NetAddr__IP__Util_bcd2bin, file, "$;@");
        XSANY.any_i32 = 1;
        (void)newXSproto_portable("NetAddr::IP::Util::notcontiguous", XS_NetAddr__IP__Util_notcontiguous, file, "$");
        cv = newXSproto_portable("NetAddr::IP::Util::ipv4to6", XS_NetAddr__IP__Util_ipv4to6, file, "$");
        XSANY.any_i32 = 0;
        cv = newXSproto_portable("NetAddr::IP::Util::mask4to6", XS_NetAddr__IP__Util_ipv4to6, file, "$");
        XSANY.any_i32 = 1;
        cv = newXSproto_portable("NetAddr::IP::Util::ipanyto6", XS_NetAddr__IP__Util_ipanyto6, file, "$");
        XSANY.any_i32 = 0;
        cv = newXSproto_portable("NetAddr::IP::Util::maskanyto6", XS_NetAddr__IP__Util_ipanyto6, file, "$");
        XSANY.any_i32 = 1;
    }
#if PERL_VERSION_LE(5, 21, 5)
#  if PERL_VERSION_GE(5, 9, 0)
    if (PL_unitcheckav)
        call_list(PL_scopestack_ix, PL_unitcheckav);
#  endif
    XSRETURN_YES;
#else
    Perl_xs_boot_epilog(aTHX_ ax);
#endif
}

Batal