Vector.xs

/*****************************************************************************/
/*                                                                           */
/*    Copyright (c) 1995 - 2013 by Steffen Beyer.                            */
/*    All rights reserved.                                                   */
/*                                                                           */
/*    This package is free software; you can redistribute it                 */
/*    and/or modify it under the same terms as Perl itself.                  */
/*                                                                           */
/*****************************************************************************/


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


#include "patchlevel.h"
#if ((PATCHLEVEL < 4) || ((PATCHLEVEL == 4) && (SUBVERSION < 5)))
/* PL_na was introduced in perl5.004_05 */
#ifndef PL_na
    #define PL_na na
#endif
#endif
#if (PATCHLEVEL < 4)
/* GIMME_V was introduced in perl5.004 */
#ifndef GIMME_V
    #define GIMME_V GIMME
#endif
#endif


#include "BitVector.h"


typedef     SV *BitVector_Object;
typedef     SV *BitVector_Handle;
typedef N_word *BitVector_Address;
typedef     SV *BitVector_Scalar;


static char *BitVector_Class        = "Bit::Vector"; /* NOT "const" for older Perl versions */

const  char *BitVector_OBJECT_ERROR = "item is not a \"Bit::Vector\" object";
const  char *BitVector_SCALAR_ERROR = "item is not a scalar";
const  char *BitVector_STRING_ERROR = "item is not a string";
const  char *BitVector_MIN_ERROR    = "minimum index out of range";
const  char *BitVector_MAX_ERROR    = "maximum index out of range";
const  char *BitVector_START_ERROR  = "start index out of range";
const  char *BitVector_OFFSET_ERROR = "offset out of range";
const  char *BitVector_CHUNK_ERROR  = "chunk size out of range";
const  char *BitVector_SET_ERROR    = "set size mismatch";
const  char *BitVector_MATRIX_ERROR = "matrix size mismatch";
const  char *BitVector_SHAPE_ERROR  = "not a square matrix";
const  char *BitVector_MEMORY_ERROR = BV_ERRCODE_NULL;
const  char *BitVector_INDEX_ERROR  = BV_ERRCODE_INDX;
const  char *BitVector_ORDER_ERROR  = BV_ERRCODE_ORDR;
const  char *BitVector_SIZE_ERROR   = BV_ERRCODE_SIZE;


#define BIT_VECTOR_STASH gv_stashpv(BitVector_Class,1)


#define BIT_VECTOR_OBJECT(ref,hdl,adr) \
    ( ref && \
    SvROK(ref) && \
    (hdl = (BitVector_Handle)SvRV(ref)) && \
    SvOBJECT(hdl) && \
    SvREADONLY(hdl) && \
    (SvTYPE(hdl) == SVt_PVMG) && \
    (SvSTASH(hdl) == BIT_VECTOR_STASH) && \
    (adr = (BitVector_Address)SvIV(hdl)) )

#define BIT_VECTOR_FAKE_OBJECT(ref,hdl) \
    ( ref && \
    SvROK(ref) && \
    (hdl = (BitVector_Handle)SvRV(ref)) && \
    SvOBJECT(hdl) && \
    !SvREADONLY(hdl) && \
    (SvTYPE(hdl) == SVt_PVMG) && \
    (SvSTASH(hdl) == BIT_VECTOR_STASH) )

#define BIT_VECTOR_SCALAR(ref,typ,var) \
    ( ref && !(SvROK(ref)) && ((var = (typ)SvIV(ref)) | 1) )

#define BIT_VECTOR_STRING(ref,var) \
    ( ref && !(SvROK(ref)) && (var = (charptr)SvPV(ref,PL_na)) )

#define BIT_VECTOR_BUFFER(ref,var,len) \
    ( ref && !(SvROK(ref)) && SvPOK(ref) && \
    (var = (charptr)SvPV(ref,PL_na)) && \
    ((len = (N_int)SvCUR(ref)) | 1) )


#define BIT_VECTOR_ERROR(message) \
    croak("Bit::Vector::%s(): %s", GvNAME(CvGV(cv)), message)


#define BIT_VECTOR_OBJECT_ERROR \
    BIT_VECTOR_ERROR( BitVector_OBJECT_ERROR )

#define BIT_VECTOR_SCALAR_ERROR \
    BIT_VECTOR_ERROR( BitVector_SCALAR_ERROR )

#define BIT_VECTOR_STRING_ERROR \
    BIT_VECTOR_ERROR( BitVector_STRING_ERROR )

#define BIT_VECTOR_MIN_ERROR \
    BIT_VECTOR_ERROR( BitVector_MIN_ERROR )

#define BIT_VECTOR_MAX_ERROR \
    BIT_VECTOR_ERROR( BitVector_MAX_ERROR )

#define BIT_VECTOR_START_ERROR \
    BIT_VECTOR_ERROR( BitVector_START_ERROR )

#define BIT_VECTOR_OFFSET_ERROR \
    BIT_VECTOR_ERROR( BitVector_OFFSET_ERROR )

#define BIT_VECTOR_CHUNK_ERROR \
    BIT_VECTOR_ERROR( BitVector_CHUNK_ERROR )

#define BIT_VECTOR_SET_ERROR \
    BIT_VECTOR_ERROR( BitVector_SET_ERROR )

#define BIT_VECTOR_MATRIX_ERROR \
    BIT_VECTOR_ERROR( BitVector_MATRIX_ERROR )

#define BIT_VECTOR_SHAPE_ERROR \
    BIT_VECTOR_ERROR( BitVector_SHAPE_ERROR )

#define BIT_VECTOR_MEMORY_ERROR \
    BIT_VECTOR_ERROR( BitVector_MEMORY_ERROR )

#define BIT_VECTOR_INDEX_ERROR \
    BIT_VECTOR_ERROR( BitVector_INDEX_ERROR )

#define BIT_VECTOR_ORDER_ERROR \
    BIT_VECTOR_ERROR( BitVector_ORDER_ERROR )

#define BIT_VECTOR_SIZE_ERROR \
    BIT_VECTOR_ERROR( BitVector_SIZE_ERROR )


#define BIT_VECTOR_EXCEPTION(code) \
    BIT_VECTOR_ERROR( BitVector_Error(code) )


MODULE = Bit::Vector		PACKAGE = Bit::Vector		PREFIX = BitVector_


PROTOTYPES: DISABLE


BOOT:
{
    BV_ErrCode rc;

    if ((rc = BitVector_Boot()))
    {
        BIT_VECTOR_EXCEPTION(rc);
        exit((int)rc);
    }
}


void
BitVector_Version(...)
PPCODE:
{
    charptr string;

    if ((items >= 0) and (items <= 1))
    {
        string = BitVector_Version();
        if (string != NULL)
        {
            EXTEND(sp,1);
            PUSHs(sv_2mortal(newSVpv((char *)string,0)));
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else croak("Usage: Bit::Vector->Version()");
}


N_int
BitVector_Word_Bits(...)
CODE:
{
    if ((items >= 0) and (items <= 1))
    {
        RETVAL = BitVector_Word_Bits();
    }
    else croak("Usage: Bit::Vector->Word_Bits()");
}
OUTPUT:
RETVAL


N_int
BitVector_Long_Bits(...)
CODE:
{
    if ((items >= 0) and (items <= 1))
    {
        RETVAL = BitVector_Long_Bits();
    }
    else croak("Usage: Bit::Vector->Long_Bits()");
}
OUTPUT:
RETVAL


void
BitVector_Create(...)
ALIAS:
  new = 1
PPCODE:
{
    BitVector_Scalar  arg1;
    BitVector_Scalar  arg2;
    BitVector_Address address;
    BitVector_Handle  handle;
    BitVector_Object  reference;
    bv_listptr list;
    bv_listptr slot;
    N_int bits;
    N_int count;

    if ((items >= 2) and (items <= 3))
    {
        arg1 = ST(1);
        if ( BIT_VECTOR_SCALAR(arg1,N_int,bits) )
        {
            if (items > 2)
            {
                arg2 = ST(2);
                if ( BIT_VECTOR_SCALAR(arg2,N_int,count) )
                {
                    if (count > 0)
                    {
                        if ((list = BitVector_Create_List(bits,true,count)) != NULL)
                        {
                            EXTEND(sp,(int)count);
                            slot = list;
                            while (count-- > 0)
                            {
                                address = *slot++;
                                handle = newSViv((IV)address);
                                reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
                                SvREFCNT_dec(handle);
                                SvREADONLY_on(handle);
                                PUSHs(reference);
                            }
                            BitVector_Destroy_List(list,0);
                        }
                        else BIT_VECTOR_MEMORY_ERROR;
                    }
                }
                else BIT_VECTOR_SCALAR_ERROR;
            }
            else
            {
                if ((address = BitVector_Create(bits,true)) != NULL)
                {
                    handle = newSViv((IV)address);
                    reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
                    SvREFCNT_dec(handle);
                    SvREADONLY_on(handle);
                    PUSHs(reference);
                }
                else BIT_VECTOR_MEMORY_ERROR;
            }
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else croak("Usage: %s(class,bits[,count])", GvNAME(CvGV(cv)));
}


void
BitVector_new_Hex(class,bits,string)
BitVector_Object	class
BitVector_Scalar	bits
BitVector_Scalar	string
PPCODE:
{
    BitVector_Address address;
    BitVector_Handle  handle;
    BitVector_Object  reference;
    charptr           pointer;
    BV_ErrCode        code;
    N_int             size;

    if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
    {
        if ( BIT_VECTOR_STRING(string,pointer) )
        {
            if ((address = BitVector_Create(size,false)) != NULL)
            {
                if ((code = BitVector_from_Hex(address,pointer)))
                {
                    BitVector_Destroy(address);
                    BIT_VECTOR_EXCEPTION(code);
                }
                else
                {
                    handle = newSViv((IV)address);
                    reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
                    SvREFCNT_dec(handle);
                    SvREADONLY_on(handle);
                    PUSHs(reference);
                }
            }
            else BIT_VECTOR_MEMORY_ERROR;
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_SCALAR_ERROR;
}


void
BitVector_new_Bin(class,bits,string)
BitVector_Object	class
BitVector_Scalar	bits
BitVector_Scalar	string
PPCODE:
{
    BitVector_Address address;
    BitVector_Handle  handle;
    BitVector_Object  reference;
    charptr           pointer;
    BV_ErrCode        code;
    N_int             size;

    if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
    {
        if ( BIT_VECTOR_STRING(string,pointer) )
        {
            if ((address = BitVector_Create(size,false)) != NULL)
            {
                if ((code = BitVector_from_Bin(address,pointer)))
                {
                    BitVector_Destroy(address);
                    BIT_VECTOR_EXCEPTION(code);
                }
                else
                {
                    handle = newSViv((IV)address);
                    reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
                    SvREFCNT_dec(handle);
                    SvREADONLY_on(handle);
                    PUSHs(reference);
                }
            }
            else BIT_VECTOR_MEMORY_ERROR;
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_SCALAR_ERROR;
}


void
BitVector_new_Dec(class,bits,string)
BitVector_Object	class
BitVector_Scalar	bits
BitVector_Scalar	string
PPCODE:
{
    BitVector_Address address;
    BitVector_Handle  handle;
    BitVector_Object  reference;
    charptr           pointer;
    BV_ErrCode        code;
    N_int             size;

    if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
    {
        if ( BIT_VECTOR_STRING(string,pointer) )
        {
            if ((address = BitVector_Create(size,false)) != NULL)
            {
                if ((code = BitVector_from_Dec(address,pointer)))
                {
                    BitVector_Destroy(address);
                    BIT_VECTOR_EXCEPTION(code);
                }
                else
                {
                    handle = newSViv((IV)address);
                    reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
                    SvREFCNT_dec(handle);
                    SvREADONLY_on(handle);
                    PUSHs(reference);
                }
            }
            else BIT_VECTOR_MEMORY_ERROR;
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_SCALAR_ERROR;
}


void
BitVector_new_Enum(class,bits,string)
BitVector_Object	class
BitVector_Scalar	bits
BitVector_Scalar	string
PPCODE:
{
    BitVector_Address address;
    BitVector_Handle  handle;
    BitVector_Object  reference;
    charptr           pointer;
    BV_ErrCode        code;
    N_int             size;

    if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
    {
        if ( BIT_VECTOR_STRING(string,pointer) )
        {
            if ((address = BitVector_Create(size,false)) != NULL)
            {
                if ((code = BitVector_from_Enum(address,pointer)))
                {
                    BitVector_Destroy(address);
                    BIT_VECTOR_EXCEPTION(code);
                }
                else
                {
                    handle = newSViv((IV)address);
                    reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
                    SvREFCNT_dec(handle);
                    SvREADONLY_on(handle);
                    PUSHs(reference);
                }
            }
            else BIT_VECTOR_MEMORY_ERROR;
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_SCALAR_ERROR;
}


void
BitVector_Shadow(reference)
BitVector_Object        reference
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ((address = BitVector_Shadow(address)) != NULL)
        {
            handle = newSViv((IV)address);
            reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
            SvREFCNT_dec(handle);
            SvREADONLY_on(handle);
            PUSHs(reference);
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Clone(reference)
BitVector_Object        reference
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ((address = BitVector_Clone(address)) != NULL)
        {
            handle = newSViv((IV)address);
            reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
            SvREFCNT_dec(handle);
            SvREADONLY_on(handle);
            PUSHs(reference);
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Concat(Xref,Yref)
BitVector_Object        Xref
BitVector_Object        Yref
PPCODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Object  reference;
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if ((address = BitVector_Concat(Xadr,Yadr)) != NULL)
        {
            handle = newSViv((IV)address);
            reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
            SvREFCNT_dec(handle);
            SvREADONLY_on(handle);
            PUSHs(reference);
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Concat_List(...)
PPCODE:
{
    BitVector_Object  Xref;
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Object  reference;
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int offset;
    N_int bits;
    I32 index;

    bits = 0;
    index = items;
    while (index-- > 0)
    {
        Xref = ST(index);
        if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) )
        {
            bits += BV_BITS_(Xadr);
        }
        else if ((index != 0) or SvROK(Xref))
          BIT_VECTOR_OBJECT_ERROR;
    }
    if ((address = BitVector_Create(bits,false)) != NULL)
    {
        offset = 0;
        index = items;
        while (index-- > 0)
        {
            Xref = ST(index);
            if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) )
            {
                if ((bits = BV_BITS_(Xadr)) > 0)
                {
                    BitVector_Interval_Copy(address,Xadr,offset,0,bits);
                    offset += bits;
                }
            }
            else if ((index != 0) or SvROK(Xref)) BIT_VECTOR_OBJECT_ERROR;
        }
        handle = newSViv((IV)address);
        reference = sv_bless(sv_2mortal(newRV(handle)), BIT_VECTOR_STASH);
        SvREFCNT_dec(handle);
        SvREADONLY_on(handle);
        PUSHs(reference);
    }
    else BIT_VECTOR_MEMORY_ERROR;
}


N_int
BitVector_Size(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BV_BITS_(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_Resize(reference,bits)
BitVector_Object	reference
BitVector_Scalar	bits
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int size;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
        {
            address = BitVector_Resize(address,size);
            SvREADONLY_off(handle);
            sv_setiv(handle,(IV)address);
            SvREADONLY_on(handle);
            if (address == NULL) BIT_VECTOR_MEMORY_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Unfake(reference,bits)
BitVector_Object	reference
BitVector_Scalar	bits
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int size;

    if ( BIT_VECTOR_FAKE_OBJECT(reference,handle) )
    {
        if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
        {
            address = BitVector_Create(size,true);
            sv_setiv(handle,(IV)address);
            SvREADONLY_on(handle);
            if (address == NULL) BIT_VECTOR_MEMORY_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_DESTROY(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        BitVector_Destroy(address);
        SvREADONLY_off(handle);
        sv_setiv(handle,(IV)NULL);
        SvREADONLY_on(handle);
    }
    /* else BIT_VECTOR_OBJECT_ERROR; */
}


void
BitVector_Copy(Xref,Yref)
BitVector_Object        Xref
BitVector_Object        Yref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        BitVector_Copy(Xadr,Yadr);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Empty(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        BitVector_Empty(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Fill(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        BitVector_Fill(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Flip(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        BitVector_Flip(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Primes(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        BitVector_Primes(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Reverse(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            BitVector_Reverse(Xadr,Yadr);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Interval_Empty(reference,min,max)
BitVector_Object	reference
BitVector_Scalar	min
BitVector_Scalar	max
ALIAS:
  Empty_Interval = 2
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int lower;
    N_int upper;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(min,N_int,lower) &&
             BIT_VECTOR_SCALAR(max,N_int,upper) )
        {
            if      (lower >= BV_BITS_(address)) BIT_VECTOR_MIN_ERROR;
            else if (upper >= BV_BITS_(address)) BIT_VECTOR_MAX_ERROR;
            else if (lower >  upper)             BIT_VECTOR_ORDER_ERROR;
            else                       BitVector_Interval_Empty(address,lower,upper);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Interval_Fill(reference,min,max)
BitVector_Object	reference
BitVector_Scalar	min
BitVector_Scalar	max
ALIAS:
  Fill_Interval = 2
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int lower;
    N_int upper;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(min,N_int,lower) &&
             BIT_VECTOR_SCALAR(max,N_int,upper) )
        {
            if      (lower >= BV_BITS_(address)) BIT_VECTOR_MIN_ERROR;
            else if (upper >= BV_BITS_(address)) BIT_VECTOR_MAX_ERROR;
            else if (lower >  upper)             BIT_VECTOR_ORDER_ERROR;
            else                       BitVector_Interval_Fill(address,lower,upper);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Interval_Flip(reference,min,max)
BitVector_Object	reference
BitVector_Scalar	min
BitVector_Scalar	max
ALIAS:
  Flip_Interval = 2
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int lower;
    N_int upper;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(min,N_int,lower) &&
             BIT_VECTOR_SCALAR(max,N_int,upper) )
        {
            if      (lower >= BV_BITS_(address)) BIT_VECTOR_MIN_ERROR;
            else if (upper >= BV_BITS_(address)) BIT_VECTOR_MAX_ERROR;
            else if (lower >  upper)             BIT_VECTOR_ORDER_ERROR;
            else                       BitVector_Interval_Flip(address,lower,upper);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Interval_Reverse(reference,min,max)
BitVector_Object	reference
BitVector_Scalar	min
BitVector_Scalar	max
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int lower;
    N_int upper;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(min,N_int,lower) &&
             BIT_VECTOR_SCALAR(max,N_int,upper) )
        {
            if      (lower >= BV_BITS_(address)) BIT_VECTOR_MIN_ERROR;
            else if (upper >= BV_BITS_(address)) BIT_VECTOR_MAX_ERROR;
            else if (lower >  upper)             BIT_VECTOR_ORDER_ERROR;
            else                       BitVector_Interval_Reverse(address,lower,upper);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Interval_Scan_inc(reference,start)
BitVector_Object	reference
BitVector_Scalar	start
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int first;
    N_int min;
    N_int max;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(start,N_int,first) )
        {
            if (first < BV_BITS_(address))
            {
                if ( BitVector_interval_scan_inc(address,first,&min,&max) )
                {
                    EXTEND(sp,2);
                    PUSHs(sv_2mortal(newSViv((IV)min)));
                    PUSHs(sv_2mortal(newSViv((IV)max)));
                }
                /* else return empty list */
            }
            else BIT_VECTOR_START_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Interval_Scan_dec(reference,start)
BitVector_Object	reference
BitVector_Scalar	start
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int first;
    N_int min;
    N_int max;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(start,N_int,first) )
        {
            if (first < BV_BITS_(address))
            {
                if ( BitVector_interval_scan_dec(address,first,&min,&max) )
                {
                    EXTEND(sp,2);
                    PUSHs(sv_2mortal(newSViv((IV)min)));
                    PUSHs(sv_2mortal(newSViv((IV)max)));
                }
                /* else return empty list */
            }
            else BIT_VECTOR_START_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Interval_Copy(Xref,Yref,Xoffset,Yoffset,length)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Scalar	Xoffset
BitVector_Scalar	Yoffset
BitVector_Scalar	length
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    N_int Xoff;
    N_int Yoff;
    N_int len;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if ( BIT_VECTOR_SCALAR(Xoffset,N_int,Xoff) &&
             BIT_VECTOR_SCALAR(Yoffset,N_int,Yoff) &&
             BIT_VECTOR_SCALAR(length, N_int,len) )
        {
            if ((Xoff < BV_BITS_(Xadr)) and (Yoff < BV_BITS_(Yadr)))
            {
                if (len > 0) BitVector_Interval_Copy(Xadr,Yadr,Xoff,Yoff,len);
            }
            else BIT_VECTOR_OFFSET_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Interval_Substitute(Xref,Yref,Xoffset,Xlength,Yoffset,Ylength)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Scalar	Xoffset
BitVector_Scalar	Xlength
BitVector_Scalar	Yoffset
BitVector_Scalar	Ylength
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    N_int Xoff;
    N_int Xlen;
    N_int Yoff;
    N_int Ylen;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if ( BIT_VECTOR_SCALAR(Xoffset,N_int,Xoff) &&
             BIT_VECTOR_SCALAR(Xlength,N_int,Xlen) &&
             BIT_VECTOR_SCALAR(Yoffset,N_int,Yoff) &&
             BIT_VECTOR_SCALAR(Ylength,N_int,Ylen) )
        {
            if ((Xoff <= BV_BITS_(Xadr)) and (Yoff <= BV_BITS_(Yadr)))
            {
                Xadr = BitVector_Interval_Substitute(Xadr,Yadr,Xoff,Xlen,Yoff,Ylen);
                SvREADONLY_off(Xhdl);
                sv_setiv(Xhdl,(IV)Xadr);
                SvREADONLY_on(Xhdl);
                if (Xadr == NULL) BIT_VECTOR_MEMORY_ERROR;
            }
            else BIT_VECTOR_OFFSET_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


boolean
BitVector_is_empty(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_is_empty(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_is_full(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_is_full(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_equal(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            RETVAL = BitVector_equal(Xadr,Yadr);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


Z_int
BitVector_Lexicompare(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            RETVAL = BitVector_Lexicompare(Xadr,Yadr);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


Z_int
BitVector_Compare(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            RETVAL = BitVector_Compare(Xadr,Yadr);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_to_Hex(reference)
BitVector_Object	reference
ALIAS:
  to_String = 2
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr string;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        string = BitVector_to_Hex(address);
        if (string != NULL)
        {
            EXTEND(sp,1);
            PUSHs(sv_2mortal(newSVpv((char *)string,0)));
            BitVector_Dispose(string);
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_from_Hex(reference,string)
BitVector_Object	reference
BitVector_Scalar	string
ALIAS:
  from_string = 2
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr           pointer;
    BV_ErrCode        code;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_STRING(string,pointer) )
        {
            if ((code = BitVector_from_Hex(address,pointer)))
                BIT_VECTOR_EXCEPTION(code);
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_to_Bin(reference)
BitVector_Object	reference
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr string;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        string = BitVector_to_Bin(address);
        if (string != NULL)
        {
            EXTEND(sp,1);
            PUSHs(sv_2mortal(newSVpv((char *)string,0)));
            BitVector_Dispose(string);
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_from_Bin(reference,string)
BitVector_Object	reference
BitVector_Scalar	string
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr           pointer;
    BV_ErrCode        code;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_STRING(string,pointer) )
        {
            if ((code = BitVector_from_Bin(address,pointer)))
                BIT_VECTOR_EXCEPTION(code);
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_to_Dec(reference)
BitVector_Object	reference
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr string;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        string = BitVector_to_Dec(address);
        if (string != NULL)
        {
            EXTEND(sp,1);
            PUSHs(sv_2mortal(newSVpv((char *)string,0)));
            BitVector_Dispose(string);
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_from_Dec(reference,string)
BitVector_Object	reference
BitVector_Scalar	string
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr           pointer;
    BV_ErrCode        code;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_STRING(string,pointer) )
        {
            if ((code = BitVector_from_Dec(address,pointer)))
                BIT_VECTOR_EXCEPTION(code);
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_to_Enum(reference)
BitVector_Object	reference
ALIAS:
  to_ASCII = 2
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr string;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        string = BitVector_to_Enum(address);
        if (string != NULL)
        {
            EXTEND(sp,1);
            PUSHs(sv_2mortal(newSVpv((char *)string,0)));
            BitVector_Dispose(string);
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_from_Enum(reference,string)
BitVector_Object	reference
BitVector_Scalar	string
ALIAS:
  from_ASCII = 2
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr           pointer;
    BV_ErrCode        code;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_STRING(string,pointer) )
        {
            if ((code = BitVector_from_Enum(address,pointer)))
                BIT_VECTOR_EXCEPTION(code);
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Bit_Off(reference,index)
BitVector_Object	reference
BitVector_Scalar	index
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int idx;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(index,N_int,idx) )
        {
            if (idx < BV_BITS_(address))
            {
                BitVector_Bit_Off(address,idx);
            }
            else BIT_VECTOR_INDEX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Bit_On(reference,index)
BitVector_Object	reference
BitVector_Scalar	index
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int idx;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(index,N_int,idx) )
        {
            if (idx < BV_BITS_(address))
            {
                BitVector_Bit_On(address,idx);
            }
            else BIT_VECTOR_INDEX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


boolean
BitVector_bit_flip(reference,index)
BitVector_Object	reference
BitVector_Scalar	index
ALIAS:
  flip = 2
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int idx;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(index,N_int,idx) )
        {
            if (idx < BV_BITS_(address))
            {
                RETVAL = BitVector_bit_flip(address,idx);
            }
            else BIT_VECTOR_INDEX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_bit_test(reference,index)
BitVector_Object	reference
BitVector_Scalar	index
ALIAS:
  contains = 1
  in = 2
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int idx;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(index,N_int,idx) )
        {
            if (idx < BV_BITS_(address))
            {
                RETVAL = BitVector_bit_test(address,idx);
            }
            else BIT_VECTOR_INDEX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_Bit_Copy(reference,index,bit)
BitVector_Object	reference
BitVector_Scalar	index
BitVector_Scalar	bit
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int idx;
    boolean b;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(index,N_int,idx) &&
             BIT_VECTOR_SCALAR(bit,boolean,b) )
        {
            if (idx < BV_BITS_(address))
            {
                BitVector_Bit_Copy(address,idx,b);
            }
            else BIT_VECTOR_INDEX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_LSB(reference,bit)
BitVector_Object	reference
BitVector_Scalar	bit
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    boolean b;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(bit,boolean,b) )
        {
            BitVector_LSB(address,b);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_MSB(reference,bit)
BitVector_Object	reference
BitVector_Scalar	bit
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    boolean b;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(bit,boolean,b) )
        {
            BitVector_MSB(address,b);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


boolean
BitVector_lsb(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_lsb_(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_msb(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_msb_(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_rotate_left(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_rotate_left(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_rotate_right(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_rotate_right(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_shift_left(reference,carry)
BitVector_Object	reference
BitVector_Scalar	carry
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    boolean c;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(carry,boolean,c) )
        {
            RETVAL = BitVector_shift_left(address,c);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_shift_right(reference,carry)
BitVector_Object	reference
BitVector_Scalar	carry
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    boolean c;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(carry,boolean,c) )
        {
            RETVAL = BitVector_shift_right(address,c);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_Move_Left(reference,bits)
BitVector_Object	reference
BitVector_Scalar	bits
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int cnt;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(bits,N_int,cnt) )
        {
            BitVector_Move_Left(address,cnt);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Move_Right(reference,bits)
BitVector_Object	reference
BitVector_Scalar	bits
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int cnt;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(bits,N_int,cnt) )
        {
            BitVector_Move_Right(address,cnt);
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Insert(reference,offset,count)
BitVector_Object	reference
BitVector_Scalar	offset
BitVector_Scalar	count
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int off;
    N_int cnt;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(offset,N_int,off) &&
             BIT_VECTOR_SCALAR(count,N_int,cnt) )
        {
            if (off < BV_BITS_(address))
            {
                BitVector_Insert(address,off,cnt,true);
            }
            else BIT_VECTOR_OFFSET_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Delete(reference,offset,count)
BitVector_Object	reference
BitVector_Scalar	offset
BitVector_Scalar	count
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int off;
    N_int cnt;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(offset,N_int,off) &&
             BIT_VECTOR_SCALAR(count,N_int,cnt) )
        {
            if (off < BV_BITS_(address))
            {
                BitVector_Delete(address,off,cnt,true);
            }
            else BIT_VECTOR_OFFSET_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


boolean
BitVector_increment(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_increment(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_decrement(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_decrement(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_add(Xref,Yref,Zref,carry)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Zref
BitVector_Scalar	carry
PPCODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;
    boolean c;
    boolean v;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ( BIT_VECTOR_SCALAR(carry,boolean,c) )
        {
            if ((BV_BITS_(Xadr) == BV_BITS_(Yadr)) and (BV_BITS_(Xadr) == BV_BITS_(Zadr)))
            {
                v = BitVector_compute(Xadr,Yadr,Zadr,false,&c);
                if (GIMME_V == G_ARRAY)
                {
                    EXTEND(sp,2);
                    PUSHs(sv_2mortal(newSViv((IV)c)));
                    PUSHs(sv_2mortal(newSViv((IV)v)));
                }
                else
                {
                    EXTEND(sp,1);
                    PUSHs(sv_2mortal(newSViv((IV)c)));
                }
            }
            else BIT_VECTOR_SIZE_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_subtract(Xref,Yref,Zref,carry)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Zref
BitVector_Scalar	carry
ALIAS:
  sub = 2
PPCODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;
    boolean c;
    boolean v;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ( BIT_VECTOR_SCALAR(carry,boolean,c) )
        {
            if ((BV_BITS_(Xadr) == BV_BITS_(Yadr)) and (BV_BITS_(Xadr) == BV_BITS_(Zadr)))
            {
                v = BitVector_compute(Xadr,Yadr,Zadr,true,&c);
                if (GIMME_V == G_ARRAY)
                {
                    EXTEND(sp,2);
                    PUSHs(sv_2mortal(newSViv((IV)c)));
                    PUSHs(sv_2mortal(newSViv((IV)v)));
                }
                else
                {
                    EXTEND(sp,1);
                    PUSHs(sv_2mortal(newSViv((IV)c)));
                }
            }
            else BIT_VECTOR_SIZE_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


boolean
BitVector_inc(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    boolean c = true;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            RETVAL = BitVector_compute(Xadr,Yadr,NULL,false,&c);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


boolean
BitVector_dec(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    boolean c = true;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            RETVAL = BitVector_compute(Xadr,Yadr,NULL,true,&c);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_Negate(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
ALIAS:
  Neg = 1
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            BitVector_Negate(Xadr,Yadr);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Absolute(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
ALIAS:
  Abs = 1
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            BitVector_Absolute(Xadr,Yadr);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


Z_int
BitVector_Sign(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BitVector_Sign(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_Multiply(Xref,Yref,Zref)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Zref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;
    BV_ErrCode        code;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ((BV_BITS_(Xadr) >= BV_BITS_(Yadr)) and (BV_BITS_(Yadr) == BV_BITS_(Zadr)))
        {
            if ((code = BitVector_Multiply(Xadr,Yadr,Zadr)))
                BIT_VECTOR_EXCEPTION(code);
        }
        else BIT_VECTOR_SIZE_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Divide(Qref,Xref,Yref,Rref)
BitVector_Object	Qref
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Rref
CODE:
{
    BitVector_Handle  Qhdl;
    BitVector_Address Qadr;
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Rhdl;
    BitVector_Address Radr;
    BV_ErrCode        code;

    if ( BIT_VECTOR_OBJECT(Qref,Qhdl,Qadr) &&
         BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Rref,Rhdl,Radr) )
    {
        if ((code = BitVector_Divide(Qadr,Xadr,Yadr,Radr)))
            BIT_VECTOR_EXCEPTION(code);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_GCD(...)
CODE:
{
    BitVector_Object  Uref;
    BitVector_Handle  Uhdl;
    BitVector_Address Uadr;
    BitVector_Object  Vref;
    BitVector_Handle  Vhdl;
    BitVector_Address Vadr;
    BitVector_Object  Wref;
    BitVector_Handle  Whdl;
    BitVector_Address Wadr;
    BitVector_Object  Xref;
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Object  Yref;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BV_ErrCode        code;

    if      (items == 3)
    {
        Uref = ST(0);
        Xref = ST(1);
        Yref = ST(2);
        if ( BIT_VECTOR_OBJECT(Uref,Uhdl,Uadr) &&
             BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
             BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
        {
            if ((code = BitVector_GCD(Uadr,Xadr,Yadr)))
                BIT_VECTOR_EXCEPTION(code);
        }
        else BIT_VECTOR_OBJECT_ERROR;
    }
    else if (items == 5)
    {
        Uref = ST(0);
        Vref = ST(1);
        Wref = ST(2);
        Xref = ST(3);
        Yref = ST(4);
        if ( BIT_VECTOR_OBJECT(Uref,Uhdl,Uadr) &&
             BIT_VECTOR_OBJECT(Vref,Vhdl,Vadr) &&
             BIT_VECTOR_OBJECT(Wref,Whdl,Wadr) &&
             BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
             BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
        {
            if ((code = BitVector_GCD2(Uadr,Vadr,Wadr,Xadr,Yadr)))
                BIT_VECTOR_EXCEPTION(code);
        }
        else BIT_VECTOR_OBJECT_ERROR;
    }
    else croak("Usage: %s(Uref[,Vref,Wref],Xref,Yref)", GvNAME(CvGV(cv)));
}


void
BitVector_Power(Xref,Yref,Zref)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Zref
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;
    BV_ErrCode        code;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ((code = BitVector_Power(Xadr,Yadr,Zadr)))
            BIT_VECTOR_EXCEPTION(code);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Block_Store(reference,buffer)
BitVector_Object	reference
BitVector_Scalar	buffer
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr string;
    N_int length;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_BUFFER(buffer,string,length) )
        {
            BitVector_Block_Store(address,string,length);
        }
        else BIT_VECTOR_STRING_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Block_Read(reference)
BitVector_Object	reference
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    charptr string;
    N_int length;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        string = BitVector_Block_Read(address,&length);
        if (string != NULL)
        {
            EXTEND(sp,1);
            PUSHs(sv_2mortal(newSVpv((char *)string,length)));
            BitVector_Dispose(string);
        }
        else BIT_VECTOR_MEMORY_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


N_int
BitVector_Word_Size(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = BV_SIZE_(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_Word_Store(reference,offset,value)
BitVector_Object	reference
BitVector_Scalar	offset
BitVector_Scalar	value
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int off;
    N_int val;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(offset,N_int,off) &&
             BIT_VECTOR_SCALAR(value,N_int,val) )
        {
            if (off < BV_SIZE_(address))
            {
                BitVector_Word_Store(address,off,val);
            }
            else BIT_VECTOR_OFFSET_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


N_int
BitVector_Word_Read(reference,offset)
BitVector_Object	reference
BitVector_Scalar	offset
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int off;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(offset,N_int,off) )
        {
            if (off < BV_SIZE_(address))
            {
                RETVAL = BitVector_Word_Read(address,off);
            }
            else BIT_VECTOR_OFFSET_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_Word_List_Store(reference,...)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    BitVector_Scalar  scalar;
    N_int offset;
    N_int value;
    N_int size;
    I32 index;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        size = BV_SIZE_(address);
        for ( offset = 0, index = 1;
            ((offset < size) and (index < items)); offset++, index++ )
        {
            scalar = ST(index);
            if ( BIT_VECTOR_SCALAR(scalar,N_int,value) )
            {
                BitVector_Word_Store(address,offset,value);
            }
            else BIT_VECTOR_SCALAR_ERROR;
        }
        for ( ; (offset < size); offset++ )
        {
            BitVector_Word_Store(address,offset,0);
        }
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Word_List_Read(reference)
BitVector_Object	reference
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int offset;
    N_int value;
    N_int size;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        size = BV_SIZE_(address);
        EXTEND(sp,(int)size);
        for ( offset = 0; (offset < size); offset++ )
        {
            value = BitVector_Word_Read(address,offset);
            PUSHs(sv_2mortal(newSViv((IV)value)));
        }
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Word_Insert(reference,offset,count)
BitVector_Object	reference
BitVector_Scalar	offset
BitVector_Scalar	count
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int off;
    N_int cnt;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(offset,N_int,off) &&
             BIT_VECTOR_SCALAR(count,N_int,cnt) )
        {
            if (off < BV_SIZE_(address))
            {
                BitVector_Word_Insert(address,off,cnt,true);
            }
            else BIT_VECTOR_OFFSET_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Word_Delete(reference,offset,count)
BitVector_Object	reference
BitVector_Scalar	offset
BitVector_Scalar	count
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int off;
    N_int cnt;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(offset,N_int,off) &&
             BIT_VECTOR_SCALAR(count,N_int,cnt) )
        {
            if (off < BV_SIZE_(address))
            {
                BitVector_Word_Delete(address,off,cnt,true);
            }
            else BIT_VECTOR_OFFSET_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Chunk_Store(reference,chunksize,offset,value)
BitVector_Object	reference
BitVector_Scalar	chunksize
BitVector_Scalar	offset
BitVector_Scalar	value
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int bits;
    N_int off;
    N_long val;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(chunksize,N_int,bits) &&
             BIT_VECTOR_SCALAR(offset,N_int,off) &&
             BIT_VECTOR_SCALAR(value,N_long,val) )
        {
            if ((bits > 0) and (bits <= BitVector_Long_Bits()))
            {
                if (off < BV_BITS_(address))
                {
                    BitVector_Chunk_Store(address,bits,off,val);
                }
                else BIT_VECTOR_OFFSET_ERROR;
            }
            else BIT_VECTOR_CHUNK_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


N_long
BitVector_Chunk_Read(reference,chunksize,offset)
BitVector_Object	reference
BitVector_Scalar	chunksize
BitVector_Scalar	offset
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int bits;
    N_int off;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(chunksize,N_int,bits) &&
             BIT_VECTOR_SCALAR(offset,N_int,off) )
        {
            if ((bits > 0) and (bits <= BitVector_Long_Bits()))
            {
                if (off < BV_BITS_(address))
                {
                    RETVAL = BitVector_Chunk_Read(address,bits,off);
                }
                else BIT_VECTOR_OFFSET_ERROR;
            }
            else BIT_VECTOR_CHUNK_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


void
BitVector_Chunk_List_Store(reference,chunksize,...)
BitVector_Object	reference
BitVector_Scalar	chunksize
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    BitVector_Scalar  scalar;
    N_int chunkspan;
    N_long chunkmask;
    N_long mask;
    N_long chunk;
    N_long value;
    N_int chunkbits;
    N_int wordbits;
    N_int wordsize;
    N_int offset;
    N_int size;
    N_int bits;
    I32 index;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(chunksize,N_int,chunkspan) )
        {
            if ((chunkspan > 0) and (chunkspan <= BitVector_Long_Bits()))
            {
                wordsize = BitVector_Word_Bits();
                size = BV_SIZE_(address);
                chunkmask = ~((~0L << (chunkspan-1)) << 1); /* C bug work-around */
                chunk = 0L;
                value = 0L;
                index = 2;
                offset = 0;
                wordbits = 0;
                chunkbits = 0;
                while (offset < size)
                {
                    if ((chunkbits == 0) and (index < items))
                    {
                        scalar = ST(index);
                        if ( BIT_VECTOR_SCALAR(scalar,N_long,chunk) )
                        {
                            chunk &= chunkmask;
                            chunkbits = chunkspan;
                            index++;
                        }
                        else BIT_VECTOR_SCALAR_ERROR;
                    }
                    bits = wordsize - wordbits;
                    if (chunkbits <= bits)
                    {
                        chunk <<= wordbits;
                        value |= chunk;
                        wordbits += chunkbits;
                        chunk = 0L;
                        chunkbits = 0;
                    }
                    else
                    {
                        mask = ~(~0L << bits);
                        mask &= chunk;
                        mask <<= wordbits;
                        value |= mask;
                        wordbits += bits;
                        chunk >>= bits;
                        chunkbits -= bits;
                    }
                    if ((wordbits >= wordsize) or (index >= items))
                    {
                        BitVector_Word_Store(address,offset,(N_int)value);
                        value = 0L;
                        wordbits = 0;
                        offset++;
                    }
                }
            }
            else BIT_VECTOR_CHUNK_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Chunk_List_Read(reference,chunksize)
BitVector_Object	reference
BitVector_Scalar	chunksize
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int chunkspan;
    N_long chunk;
    N_long value;
    N_long mask;
    N_int chunkbits;
    N_int wordbits;
    N_int wordsize;
    N_int length;
    N_int index;
    N_int offset;
    N_int size;
    N_int bits;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(chunksize,N_int,chunkspan) )
        {
            if ((chunkspan > 0) and (chunkspan <= BitVector_Long_Bits()))
            {
                wordsize = BitVector_Word_Bits();
                bits = BV_BITS_(address);
                size = BV_SIZE_(address);
                length = (N_int) (bits / chunkspan);
                if ((length * chunkspan) < bits) length++;
                EXTEND(sp,(int)length);
                chunk = 0L;
                value = 0L;
                index = 0;
                offset = 0;
                wordbits = 0;
                chunkbits = 0;
                while (index < length)
                {
                    if ((wordbits == 0) and (offset < size))
                    {
                        value = (N_long) BitVector_Word_Read(address,offset);
                        wordbits = wordsize;
                        offset++;
                    }
                    bits = chunkspan - chunkbits;
                    if (wordbits <= bits)
                    {
                        value <<= chunkbits;
                        chunk |= value;
                        chunkbits += wordbits;
                        value = 0L;
                        wordbits = 0;
                    }
                    else
                    {
                        mask = ~(~0L << bits);
                        mask &= value;
                        mask <<= chunkbits;
                        chunk |= mask;
                        chunkbits += bits;
                        value >>= bits;
                        wordbits -= bits;
                    }
                    if ((chunkbits >= chunkspan) or
                        ((offset >= size) and (chunkbits > 0)))
                    {
                        PUSHs(sv_2mortal(newSViv((IV)chunk)));
                        chunk = 0L;
                        chunkbits = 0;
                        index++;
                    }
                }
            }
            else BIT_VECTOR_CHUNK_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Index_List_Remove(reference,...)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    BitVector_Scalar  scalar;
    N_int value;
    N_int bits;
    I32 index;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        bits = BV_BITS_(address);
        for ( index = 1; index < items; index++ )
        {
            scalar = ST(index);
            if ( BIT_VECTOR_SCALAR(scalar,N_int,value) )
            {
                if (value < bits)
                {
                    BitVector_Bit_Off(address,value);
                }
                else BIT_VECTOR_INDEX_ERROR;
            }
            else BIT_VECTOR_SCALAR_ERROR;
        }
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Index_List_Store(reference,...)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    BitVector_Scalar  scalar;
    N_int value;
    N_int bits;
    I32 index;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        bits = BV_BITS_(address);
        for ( index = 1; index < items; index++ )
        {
            scalar = ST(index);
            if ( BIT_VECTOR_SCALAR(scalar,N_int,value) )
            {
                if (value < bits)
                {
                    BitVector_Bit_On(address,value);
                }
                else BIT_VECTOR_INDEX_ERROR;
            }
            else BIT_VECTOR_SCALAR_ERROR;
        }
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
BitVector_Index_List_Read(reference)
BitVector_Object	reference
PPCODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int size;
    N_int bits;
    N_int norm;
    N_int base;
    N_int word;
    N_int index;
    N_int value;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        size = BV_SIZE_(address);
        bits = BitVector_Word_Bits();
        norm = Set_Norm(address);
        if (norm > 0)
        {
            EXTEND(sp,(int)norm);
            for ( base = word = 0; word < size; word++, base += bits )
            {
                index = base;
                value = BitVector_Word_Read(address,word);
                while (value)
                {
                    if (value AND 0x0001)
                      PUSHs(sv_2mortal(newSViv((IV)index)));
                    value >>= 1;
                    index++;
                }
            }
        }
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


MODULE = Bit::Vector		PACKAGE = Bit::Vector		PREFIX = Set_


void
Set_Union(Xref,Yref,Zref)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Zref
ALIAS:
  Or = 1
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ((BV_BITS_(Xadr) == BV_BITS_(Yadr)) and (BV_BITS_(Xadr) == BV_BITS_(Zadr)))
        {
            Set_Union(Xadr,Yadr,Zadr);
        }
        else BIT_VECTOR_SET_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
Set_Intersection(Xref,Yref,Zref)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Zref
ALIAS:
  And = 1
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ((BV_BITS_(Xadr) == BV_BITS_(Yadr)) and (BV_BITS_(Xadr) == BV_BITS_(Zadr)))
        {
            Set_Intersection(Xadr,Yadr,Zadr);
        }
        else BIT_VECTOR_SET_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
Set_Difference(Xref,Yref,Zref)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Zref
ALIAS:
  AndNot = 1
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ((BV_BITS_(Xadr) == BV_BITS_(Yadr)) and (BV_BITS_(Xadr) == BV_BITS_(Zadr)))
        {
            Set_Difference(Xadr,Yadr,Zadr);
        }
        else BIT_VECTOR_SET_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
Set_ExclusiveOr(Xref,Yref,Zref)
BitVector_Object	Xref
BitVector_Object	Yref
BitVector_Object	Zref
ALIAS:
  Xor = 1
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ((BV_BITS_(Xadr) == BV_BITS_(Yadr)) and (BV_BITS_(Xadr) == BV_BITS_(Zadr)))
        {
            Set_ExclusiveOr(Xadr,Yadr,Zadr);
        }
        else BIT_VECTOR_SET_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
Set_Complement(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
ALIAS:
  Not = 1
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            Set_Complement(Xadr,Yadr);
        }
        else BIT_VECTOR_SET_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


boolean
Set_subset(Xref,Yref)
BitVector_Object	Xref
BitVector_Object	Yref
ALIAS:
  inclusion = 2
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if (BV_BITS_(Xadr) == BV_BITS_(Yadr))
        {
            RETVAL = Set_subset(Xadr,Yadr);
        }
        else BIT_VECTOR_SET_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


N_int
Set_Norm(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = Set_Norm(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


N_int
Set_Norm2(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = Set_Norm2(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


N_int
Set_Norm3(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = Set_Norm3(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


Z_long
Set_Min(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = Set_Min(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


Z_long
Set_Max(reference)
BitVector_Object	reference
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        RETVAL = Set_Max(address);
    }
    else BIT_VECTOR_OBJECT_ERROR;
}
OUTPUT:
RETVAL


MODULE = Bit::Vector		PACKAGE = Bit::Vector		PREFIX = Matrix_


void
Matrix_Multiplication(Xref,Xrows,Xcols,Yref,Yrows,Ycols,Zref,Zrows,Zcols)
BitVector_Object	Xref
BitVector_Scalar	Xrows
BitVector_Scalar	Xcols
BitVector_Object	Yref
BitVector_Scalar	Yrows
BitVector_Scalar	Ycols
BitVector_Object	Zref
BitVector_Scalar	Zrows
BitVector_Scalar	Zcols
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;
    N_int rowsX;
    N_int colsX;
    N_int rowsY;
    N_int colsY;
    N_int rowsZ;
    N_int colsZ;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ( BIT_VECTOR_SCALAR(Xrows,N_int,rowsX) &&
             BIT_VECTOR_SCALAR(Xcols,N_int,colsX) &&
             BIT_VECTOR_SCALAR(Yrows,N_int,rowsY) &&
             BIT_VECTOR_SCALAR(Ycols,N_int,colsY) &&
             BIT_VECTOR_SCALAR(Zrows,N_int,rowsZ) &&
             BIT_VECTOR_SCALAR(Zcols,N_int,colsZ) )
        {
            if ((colsY == rowsZ) and (rowsX == rowsY) and (colsX == colsZ) and
                (BV_BITS_(Xadr) == rowsX*colsX) and
                (BV_BITS_(Yadr) == rowsY*colsY) and
                (BV_BITS_(Zadr) == rowsZ*colsZ))
            {
                Matrix_Multiplication(Xadr,rowsX,colsX,
                                      Yadr,rowsY,colsY,
                                      Zadr,rowsZ,colsZ);
            }
            else BIT_VECTOR_MATRIX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
Matrix_Product(Xref,Xrows,Xcols,Yref,Yrows,Ycols,Zref,Zrows,Zcols)
BitVector_Object	Xref
BitVector_Scalar	Xrows
BitVector_Scalar	Xcols
BitVector_Object	Yref
BitVector_Scalar	Yrows
BitVector_Scalar	Ycols
BitVector_Object	Zref
BitVector_Scalar	Zrows
BitVector_Scalar	Zcols
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    BitVector_Handle  Zhdl;
    BitVector_Address Zadr;
    N_int rowsX;
    N_int colsX;
    N_int rowsY;
    N_int colsY;
    N_int rowsZ;
    N_int colsZ;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
         BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
    {
        if ( BIT_VECTOR_SCALAR(Xrows,N_int,rowsX) &&
             BIT_VECTOR_SCALAR(Xcols,N_int,colsX) &&
             BIT_VECTOR_SCALAR(Yrows,N_int,rowsY) &&
             BIT_VECTOR_SCALAR(Ycols,N_int,colsY) &&
             BIT_VECTOR_SCALAR(Zrows,N_int,rowsZ) &&
             BIT_VECTOR_SCALAR(Zcols,N_int,colsZ) )
        {
            if ((colsY == rowsZ) and (rowsX == rowsY) and (colsX == colsZ) and
                (BV_BITS_(Xadr) == rowsX*colsX) and
                (BV_BITS_(Yadr) == rowsY*colsY) and
                (BV_BITS_(Zadr) == rowsZ*colsZ))
            {
                Matrix_Product(Xadr,rowsX,colsX,
                               Yadr,rowsY,colsY,
                               Zadr,rowsZ,colsZ);
            }
            else BIT_VECTOR_MATRIX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
Matrix_Closure(reference,rows,cols)
BitVector_Object	reference
BitVector_Scalar	rows
BitVector_Scalar	cols
CODE:
{
    BitVector_Handle  handle;
    BitVector_Address address;
    N_int r;
    N_int c;

    if ( BIT_VECTOR_OBJECT(reference,handle,address) )
    {
        if ( BIT_VECTOR_SCALAR(rows,N_int,r) &&
             BIT_VECTOR_SCALAR(cols,N_int,c) )
        {
            if (BV_BITS_(address) == r*c)
            {
                if (r == c)
                {
                    Matrix_Closure(address,r,c);
                }
                else BIT_VECTOR_SHAPE_ERROR;
            }
            else BIT_VECTOR_MATRIX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}


void
Matrix_Transpose(Xref,Xrows,Xcols,Yref,Yrows,Ycols)
BitVector_Object	Xref
BitVector_Scalar	Xrows
BitVector_Scalar	Xcols
BitVector_Object	Yref
BitVector_Scalar	Yrows
BitVector_Scalar	Ycols
CODE:
{
    BitVector_Handle  Xhdl;
    BitVector_Address Xadr;
    BitVector_Handle  Yhdl;
    BitVector_Address Yadr;
    N_int rowsX;
    N_int colsX;
    N_int rowsY;
    N_int colsY;

    if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
         BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
    {
        if ( BIT_VECTOR_SCALAR(Xrows,N_int,rowsX) &&
             BIT_VECTOR_SCALAR(Xcols,N_int,colsX) &&
             BIT_VECTOR_SCALAR(Yrows,N_int,rowsY) &&
             BIT_VECTOR_SCALAR(Ycols,N_int,colsY) )
        {
            if ((rowsX == colsY) and (colsX == rowsY) and
                (BV_BITS_(Xadr) == rowsX*colsX) and
                (BV_BITS_(Yadr) == rowsY*colsY))
            {
                if ((Xadr != Yadr) or (rowsY == colsY))
                {
                    Matrix_Transpose(Xadr,rowsX,colsX,
                                     Yadr,rowsY,colsY);
                }
                else BIT_VECTOR_SHAPE_ERROR;
            }
            else BIT_VECTOR_MATRIX_ERROR;
        }
        else BIT_VECTOR_SCALAR_ERROR;
    }
    else BIT_VECTOR_OBJECT_ERROR;
}