Bit-Vector

 view release on metacpan or  search on metacpan

Vector.xs  view on Meta::CPAN

    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)));

Vector.xs  view on Meta::CPAN

    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;

Vector.xs  view on Meta::CPAN

    }
    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) )
    {

Vector.xs  view on Meta::CPAN

    }
    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) )
    {

Vector.xs  view on Meta::CPAN

    }
    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) )
    {

Vector.xs  view on Meta::CPAN

    }
    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) )
    {

Vector.xs  view on Meta::CPAN

        }
        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);

Vector.xs  view on Meta::CPAN

        }
        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);

Vector.xs  view on Meta::CPAN

        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) &&

Vector.xs  view on Meta::CPAN

            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;

Vector.xs  view on Meta::CPAN

        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) )

Vector.xs  view on Meta::CPAN

        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) )

Vector.xs  view on Meta::CPAN

}
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)
        {

Vector.xs  view on Meta::CPAN

        }
        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)
        {

Vector.xs  view on Meta::CPAN

        }
        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)
        {

Vector.xs  view on Meta::CPAN

    }
    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)
        {

Vector.xs  view on Meta::CPAN

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;

Vector.xs  view on Meta::CPAN

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;

Vector.xs  view on Meta::CPAN

        }
        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)

Vector.xs  view on Meta::CPAN

            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);

Vector.xs  view on Meta::CPAN

        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;

Vector.xs  view on Meta::CPAN

            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;