/*****************************************************************************/
/* */
/* 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;
}