File Coverage

Vector.xs

Criterion	Covered	Total	%
statement	686	757	90.6
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	686	757	90.6

line	stmt	code
1
2
3		/*****************************************************************************/
4		/* */
5		/* Copyright (c) 1995 - 2004 by Steffen Beyer. */
6		/* All rights reserved. */
7		/* */
8		/* This package is free software; you can redistribute it */
9		/* and/or modify it under the same terms as Perl itself. */
10		/* */
11		/*****************************************************************************/
12
13
14		#include "EXTERN.h"
15		#include "perl.h"
16		#include "XSUB.h"
17
18
19		#include "patchlevel.h"
20		#if ((PATCHLEVEL < 4) \|\| ((PATCHLEVEL == 4) && (SUBVERSION < 5)))
21		/* PL_na was introduced in perl5.004_05 */
22		#ifndef PL_na
23		#define PL_na na
24		#endif
25		#endif
26		#if (PATCHLEVEL < 4)
27		/* GIMME_V was introduced in perl5.004 */
28		#ifndef GIMME_V
29		#define GIMME_V GIMME
30		#endif
31		#endif
32
33
34		#include "BitVector.h"
35
36
37		static char *BitVector_Class = "Bit::Vector";
38		static HV *BitVector_Stash;
39
40		typedef SV *BitVector_Object;
41		typedef SV *BitVector_Handle;
42		typedef N_word *BitVector_Address;
43		typedef SV *BitVector_Scalar;
44
45
46		const char *BitVector_OBJECT_ERROR = "item is not a \"Bit::Vector\" object";
47		const char *BitVector_SCALAR_ERROR = "item is not a scalar";
48		const char *BitVector_STRING_ERROR = "item is not a string";
49		const char *BitVector_MIN_ERROR = "minimum index out of range";
50		const char *BitVector_MAX_ERROR = "maximum index out of range";
51		const char *BitVector_START_ERROR = "start index out of range";
52		const char *BitVector_OFFSET_ERROR = "offset out of range";
53		const char *BitVector_CHUNK_ERROR = "chunk size out of range";
54		const char *BitVector_SET_ERROR = "set size mismatch";
55		const char *BitVector_MATRIX_ERROR = "matrix size mismatch";
56		const char *BitVector_SHAPE_ERROR = "not a square matrix";
57		const char *BitVector_MEMORY_ERROR = ERRCODE_NULL;
58		const char *BitVector_INDEX_ERROR = ERRCODE_INDX;
59		const char *BitVector_ORDER_ERROR = ERRCODE_ORDR;
60		const char *BitVector_SIZE_ERROR = ERRCODE_SIZE;
61
62
63		#define BIT_VECTOR_OBJECT(ref,hdl,adr) \
64		( ref && \
65		SvROK(ref) && \
66		(hdl = (BitVector_Handle)SvRV(ref)) && \
67		SvOBJECT(hdl) && \
68		SvREADONLY(hdl) && \
69		(SvTYPE(hdl) == SVt_PVMG) && \
70		(SvSTASH(hdl) == BitVector_Stash) && \
71		(adr = (BitVector_Address)SvIV(hdl)) )
72
73		#define BIT_VECTOR_SCALAR(ref,typ,var) \
74		( ref && !(SvROK(ref)) && ((var = (typ)SvIV(ref)) \| 1) )
75
76		#define BIT_VECTOR_STRING(ref,var) \
77		( ref && !(SvROK(ref)) && (var = (charptr)SvPV(ref,PL_na)) )
78
79		#define BIT_VECTOR_BUFFER(ref,var,len) \
80		( ref && !(SvROK(ref)) && SvPOK(ref) && \
81		(var = (charptr)SvPV(ref,PL_na)) && \
82		((len = (N_int)SvCUR(ref)) \| 1) )
83
84
85		#define BIT_VECTOR_ERROR(message) \
86		croak("Bit::Vector::%s(): %s", GvNAME(CvGV(cv)), message)
87
88
89		#define BIT_VECTOR_OBJECT_ERROR \
90		BIT_VECTOR_ERROR( BitVector_OBJECT_ERROR )
91
92		#define BIT_VECTOR_SCALAR_ERROR \
93		BIT_VECTOR_ERROR( BitVector_SCALAR_ERROR )
94
95		#define BIT_VECTOR_STRING_ERROR \
96		BIT_VECTOR_ERROR( BitVector_STRING_ERROR )
97
98		#define BIT_VECTOR_MIN_ERROR \
99		BIT_VECTOR_ERROR( BitVector_MIN_ERROR )
100
101		#define BIT_VECTOR_MAX_ERROR \
102		BIT_VECTOR_ERROR( BitVector_MAX_ERROR )
103
104		#define BIT_VECTOR_START_ERROR \
105		BIT_VECTOR_ERROR( BitVector_START_ERROR )
106
107		#define BIT_VECTOR_OFFSET_ERROR \
108		BIT_VECTOR_ERROR( BitVector_OFFSET_ERROR )
109
110		#define BIT_VECTOR_CHUNK_ERROR \
111		BIT_VECTOR_ERROR( BitVector_CHUNK_ERROR )
112
113		#define BIT_VECTOR_SET_ERROR \
114		BIT_VECTOR_ERROR( BitVector_SET_ERROR )
115
116		#define BIT_VECTOR_MATRIX_ERROR \
117		BIT_VECTOR_ERROR( BitVector_MATRIX_ERROR )
118
119		#define BIT_VECTOR_SHAPE_ERROR \
120		BIT_VECTOR_ERROR( BitVector_SHAPE_ERROR )
121
122		#define BIT_VECTOR_MEMORY_ERROR \
123		BIT_VECTOR_ERROR( BitVector_MEMORY_ERROR )
124
125		#define BIT_VECTOR_INDEX_ERROR \
126		BIT_VECTOR_ERROR( BitVector_INDEX_ERROR )
127
128		#define BIT_VECTOR_ORDER_ERROR \
129		BIT_VECTOR_ERROR( BitVector_ORDER_ERROR )
130
131		#define BIT_VECTOR_SIZE_ERROR \
132		BIT_VECTOR_ERROR( BitVector_SIZE_ERROR )
133
134
135		#define BIT_VECTOR_EXCEPTION(code) \
136		BIT_VECTOR_ERROR( BitVector_Error(code) )
137
138
139		MODULE = Bit::Vector PACKAGE = Bit::Vector PREFIX = BitVector_
140
141
142		PROTOTYPES: DISABLE
143
144
145		BOOT:
146		{
147		ErrCode rc;
148
149	21	if ((rc = BitVector_Boot()))
150		{
151	0	BIT_VECTOR_EXCEPTION(rc);
152		exit((int)rc);
153		}
154	21	BitVector_Stash = gv_stashpv(BitVector_Class,1);
155		}
156
157
158		void
159		BitVector_Version(...)
160		PPCODE:
161		{
162		charptr string;
163
164		if ((items >= 0) and (items <= 1))
165		{
166	4	string = BitVector_Version();
167	4	if (string != NULL)
168		{
169	4	EXTEND(sp,1);
170	4	PUSHs(sv_2mortal(newSVpv((char *)string,0)));
171		}
172	0	else BIT_VECTOR_MEMORY_ERROR;
173		}
174	2	else croak("Usage: Bit::Vector->Version()");
175		}
176
177
178		N_int
179		BitVector_Word_Bits(...)
180		CODE:
181		{
182	24	if ((items >= 0) and (items <= 1))
183		{
184	22	RETVAL = BitVector_Word_Bits();
185		}
186	2	else croak("Usage: Bit::Vector->Word_Bits()");
187		}
188		OUTPUT:
189		RETVAL
190
191
192		N_int
193		BitVector_Long_Bits(...)
194		CODE:
195		{
196	106	if ((items >= 0) and (items <= 1))
197		{
198	104	RETVAL = BitVector_Long_Bits();
199		}
200	2	else croak("Usage: Bit::Vector->Long_Bits()");
201		}
202		OUTPUT:
203		RETVAL
204
205
206		void
207		BitVector_Create(...)
208		ALIAS:
209		new = 1
210		PPCODE:
211		{
212		BitVector_Scalar arg1;
213		BitVector_Scalar arg2;
214		BitVector_Address address;
215		BitVector_Handle handle;
216		BitVector_Object reference;
217		listptr list;
218		listptr slot;
219		N_int bits;
220		N_int count;
221
222	4217	if ((items >= 2) and (items <= 3))
223		{
224	4209	arg1 = ST(1);
225	4209	if ( BIT_VECTOR_SCALAR(arg1,N_int,bits) )
226		{
227	4208	if (items > 2)
228		{
229	0	arg2 = ST(2);
230	0	if ( BIT_VECTOR_SCALAR(arg2,N_int,count) )
231		{
232	0	if (count > 0)
233		{
234	0	if ((list = BitVector_Create_List(bits,true,count)) != NULL)
235		{
236	0	EXTEND(sp,(int)count);
237		slot = list;
238	0	while (count-- > 0)
239		{
240	0	address = *slot++;
241	0	handle = newSViv((IV)address);
242	0	reference = sv_bless(sv_2mortal(newRV(handle)),
243		BitVector_Stash);
244	0	SvREFCNT_dec(handle);
245	0	SvREADONLY_on(handle);
246	0	PUSHs(reference);
247		}
248	0	BitVector_Destroy_List(list,0);
249		}
250	0	else BIT_VECTOR_MEMORY_ERROR;
251		}
252		}
253	0	else BIT_VECTOR_SCALAR_ERROR;
254		}
255		else
256		{
257	4208	if ((address = BitVector_Create(bits,true)) != NULL)
258		{
259	4208	handle = newSViv((IV)address);
260	4208	reference = sv_bless(sv_2mortal(newRV(handle)),
261		BitVector_Stash);
262	4208	SvREFCNT_dec(handle);
263	4208	SvREADONLY_on(handle);
264	4208	PUSHs(reference);
265		}
266	0	else BIT_VECTOR_MEMORY_ERROR;
267		}
268		}
269	1	else BIT_VECTOR_SCALAR_ERROR;
270		}
271	8	else croak("Usage: %s(class,bits[,count])", GvNAME(CvGV(cv)));
272		}
273
274
275		void
276		BitVector_new_Hex(class,bits,string)
277		BitVector_Object class
278		BitVector_Scalar bits
279		BitVector_Scalar string
280		PPCODE:
281		{
282		BitVector_Address address;
283		BitVector_Handle handle;
284		BitVector_Object reference;
285		N_int size;
286		charptr pointer;
287		ErrCode code;
288
289	57	if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
290		{
291	56	if ( BIT_VECTOR_STRING(string,pointer) )
292		{
293	55	if ((address = BitVector_Create(size,false)) != NULL)
294		{
295	55	if ((code = BitVector_from_Hex(address,pointer)))
296		{
297	0	BitVector_Destroy(address);
298	0	BIT_VECTOR_EXCEPTION(code);
299		}
300		else
301		{
302	55	handle = newSViv((IV)address);
303	55	reference = sv_bless(sv_2mortal(newRV(handle)),
304		BitVector_Stash);
305	55	SvREFCNT_dec(handle);
306	55	SvREADONLY_on(handle);
307	55	PUSHs(reference);
308		}
309		}
310	0	else BIT_VECTOR_MEMORY_ERROR;
311		}
312	1	else BIT_VECTOR_STRING_ERROR;
313		}
314	1	else BIT_VECTOR_SCALAR_ERROR;
315		}
316
317
318		void
319		BitVector_new_Bin(class,bits,string)
320		BitVector_Object class
321		BitVector_Scalar bits
322		BitVector_Scalar string
323		PPCODE:
324		{
325		BitVector_Address address;
326		BitVector_Handle handle;
327		BitVector_Object reference;
328		N_int size;
329		charptr pointer;
330		ErrCode code;
331
332	57	if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
333		{
334	56	if ( BIT_VECTOR_STRING(string,pointer) )
335		{
336	55	if ((address = BitVector_Create(size,false)) != NULL)
337		{
338	55	if ((code = BitVector_from_Bin(address,pointer)))
339		{
340	0	BitVector_Destroy(address);
341	0	BIT_VECTOR_EXCEPTION(code);
342		}
343		else
344		{
345	55	handle = newSViv((IV)address);
346	55	reference = sv_bless(sv_2mortal(newRV(handle)),
347		BitVector_Stash);
348	55	SvREFCNT_dec(handle);
349	55	SvREADONLY_on(handle);
350	55	PUSHs(reference);
351		}
352		}
353	0	else BIT_VECTOR_MEMORY_ERROR;
354		}
355	1	else BIT_VECTOR_STRING_ERROR;
356		}
357	1	else BIT_VECTOR_SCALAR_ERROR;
358		}
359
360
361		void
362		BitVector_new_Dec(class,bits,string)
363		BitVector_Object class
364		BitVector_Scalar bits
365		BitVector_Scalar string
366		PPCODE:
367		{
368		BitVector_Address address;
369		BitVector_Handle handle;
370		BitVector_Object reference;
371		N_int size;
372		charptr pointer;
373		ErrCode code;
374
375	57	if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
376		{
377	56	if ( BIT_VECTOR_STRING(string,pointer) )
378		{
379	55	if ((address = BitVector_Create(size,false)) != NULL)
380		{
381	55	if ((code = BitVector_from_Dec(address,pointer)))
382		{
383	0	BitVector_Destroy(address);
384	0	BIT_VECTOR_EXCEPTION(code);
385		}
386		else
387		{
388	55	handle = newSViv((IV)address);
389	55	reference = sv_bless(sv_2mortal(newRV(handle)),
390		BitVector_Stash);
391	55	SvREFCNT_dec(handle);
392	55	SvREADONLY_on(handle);
393	55	PUSHs(reference);
394		}
395		}
396	0	else BIT_VECTOR_MEMORY_ERROR;
397		}
398	1	else BIT_VECTOR_STRING_ERROR;
399		}
400	1	else BIT_VECTOR_SCALAR_ERROR;
401		}
402
403
404		void
405		BitVector_new_Enum(class,bits,string)
406		BitVector_Object class
407		BitVector_Scalar bits
408		BitVector_Scalar string
409		PPCODE:
410		{
411		BitVector_Address address;
412		BitVector_Handle handle;
413		BitVector_Object reference;
414		N_int size;
415		charptr pointer;
416		ErrCode code;
417
418	57	if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
419		{
420	56	if ( BIT_VECTOR_STRING(string,pointer) )
421		{
422	55	if ((address = BitVector_Create(size,false)) != NULL)
423		{
424	55	if ((code = BitVector_from_Enum(address,pointer)))
425		{
426	0	BitVector_Destroy(address);
427	0	BIT_VECTOR_EXCEPTION(code);
428		}
429		else
430		{
431	55	handle = newSViv((IV)address);
432	55	reference = sv_bless(sv_2mortal(newRV(handle)),
433		BitVector_Stash);
434	55	SvREFCNT_dec(handle);
435	55	SvREADONLY_on(handle);
436	55	PUSHs(reference);
437		}
438		}
439	0	else BIT_VECTOR_MEMORY_ERROR;
440		}
441	1	else BIT_VECTOR_STRING_ERROR;
442		}
443	1	else BIT_VECTOR_SCALAR_ERROR;
444		}
445
446
447		void
448		BitVector_Shadow(reference)
449		BitVector_Object reference
450		PPCODE:
451		{
452		BitVector_Handle handle;
453		BitVector_Address address;
454
455	2736	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
456		{
457	2733	if ((address = BitVector_Shadow(address)) != NULL)
458		{
459	2733	handle = newSViv((IV)address);
460	2733	reference = sv_bless(sv_2mortal(newRV(handle)),
461		BitVector_Stash);
462	2733	SvREFCNT_dec(handle);
463	2733	SvREADONLY_on(handle);
464	2733	PUSHs(reference);
465		}
466	0	else BIT_VECTOR_MEMORY_ERROR;
467		}
468	3	else BIT_VECTOR_OBJECT_ERROR;
469		}
470
471
472		void
473		BitVector_Clone(reference)
474		BitVector_Object reference
475		PPCODE:
476		{
477		BitVector_Handle handle;
478		BitVector_Address address;
479
480	5268	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
481		{
482	5265	if ((address = BitVector_Clone(address)) != NULL)
483		{
484	5265	handle = newSViv((IV)address);
485	5265	reference = sv_bless(sv_2mortal(newRV(handle)),
486		BitVector_Stash);
487	5265	SvREFCNT_dec(handle);
488	5265	SvREADONLY_on(handle);
489	5265	PUSHs(reference);
490		}
491	0	else BIT_VECTOR_MEMORY_ERROR;
492		}
493	3	else BIT_VECTOR_OBJECT_ERROR;
494		}
495
496
497		void
498		BitVector_Concat(Xref,Yref)
499		BitVector_Object Xref
500		BitVector_Object Yref
501		PPCODE:
502		{
503		BitVector_Handle Xhdl;
504		BitVector_Address Xadr;
505		BitVector_Handle Yhdl;
506		BitVector_Address Yadr;
507		BitVector_Object reference;
508		BitVector_Handle handle;
509		BitVector_Address address;
510
511	8	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
512		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
513		{
514	2	if ((address = BitVector_Concat(Xadr,Yadr)) != NULL)
515		{
516	2	handle = newSViv((IV)address);
517	2	reference = sv_bless(sv_2mortal(newRV(handle)),
518		BitVector_Stash);
519	2	SvREFCNT_dec(handle);
520	2	SvREADONLY_on(handle);
521	2	PUSHs(reference);
522		}
523	0	else BIT_VECTOR_MEMORY_ERROR;
524		}
525	6	else BIT_VECTOR_OBJECT_ERROR;
526		}
527
528
529		void
530		BitVector_Concat_List(...)
531		PPCODE:
532		{
533		BitVector_Object Xref;
534		BitVector_Handle Xhdl;
535		BitVector_Address Xadr;
536		BitVector_Object reference;
537		BitVector_Handle handle;
538		BitVector_Address address;
539		N_int offset;
540		N_int bits;
541		I32 index;
542
543		bits = 0;
544		index = items;
545	54	while (index-- > 0)
546		{
547	40	Xref = ST(index);
548	70	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) )
549		{
550	30	bits += bits_(Xadr);
551		}
552	10	else if ((index != 0) or SvROK(Xref))
553	10	BIT_VECTOR_OBJECT_ERROR;
554		}
555	2	if ((address = BitVector_Create(bits,false)) != NULL)
556		{
557		offset = 0;
558		index = items;
559	12	while (index-- > 0)
560		{
561	10	Xref = ST(index);
562	10	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) )
563		{
564	10	if ((bits = bits_(Xadr)) > 0)
565		{
566	10	BitVector_Interval_Copy(address,Xadr,offset,0,bits);
567	10	offset += bits;
568		}
569		}
570	0	else if ((index != 0) or SvROK(Xref)) BIT_VECTOR_OBJECT_ERROR;
571		}
572	2	handle = newSViv((IV)address);
573	2	reference = sv_bless(sv_2mortal(newRV(handle)),
574		BitVector_Stash);
575	2	SvREFCNT_dec(handle);
576	2	SvREADONLY_on(handle);
577	2	PUSHs(reference);
578		}
579	0	else BIT_VECTOR_MEMORY_ERROR;
580		}
581
582
583		N_int
584		BitVector_Size(reference)
585		BitVector_Object reference
586		CODE:
587		{
588		BitVector_Handle handle;
589		BitVector_Address address;
590
591	648	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
592		{
593		RETVAL = bits_(address);
594		}
595	3	else BIT_VECTOR_OBJECT_ERROR;
596		}
597		OUTPUT:
598		RETVAL
599
600
601		void
602		BitVector_Resize(reference,bits)
603		BitVector_Object reference
604		BitVector_Scalar bits
605		CODE:
606		{
607		BitVector_Handle handle;
608		BitVector_Address address;
609		N_int size;
610
611	99	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
612		{
613	96	if ( BIT_VECTOR_SCALAR(bits,N_int,size) )
614		{
615	95	address = BitVector_Resize(address,size);
616	95	SvREADONLY_off(handle);
617	95	sv_setiv(handle,(IV)address);
618	95	SvREADONLY_on(handle);
619	95	if (address == NULL) BIT_VECTOR_MEMORY_ERROR;
620		}
621	1	else BIT_VECTOR_SCALAR_ERROR;
622		}
623	3	else BIT_VECTOR_OBJECT_ERROR;
624		}
625
626
627		void
628		BitVector_DESTROY(reference)
629		BitVector_Object reference
630		CODE:
631		{
632		BitVector_Handle handle;
633		BitVector_Address address;
634
635	12532	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
636		{
637	12430	BitVector_Destroy(address);
638	12430	SvREADONLY_off(handle);
639	12430	sv_setiv(handle,(IV)NULL);
640	12430	SvREADONLY_on(handle);
641		}
642		/* else BIT_VECTOR_OBJECT_ERROR; */
643		}
644
645
646		void
647		BitVector_Copy(Xref,Yref)
648		BitVector_Object Xref
649		BitVector_Object Yref
650		CODE:
651		{
652		BitVector_Handle Xhdl;
653		BitVector_Address Xadr;
654		BitVector_Handle Yhdl;
655		BitVector_Address Yadr;
656
657	69	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
658		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
659		{
660	63	BitVector_Copy(Xadr,Yadr);
661		}
662	6	else BIT_VECTOR_OBJECT_ERROR;
663		}
664
665
666		void
667		BitVector_Empty(reference)
668		BitVector_Object reference
669		CODE:
670		{
671		BitVector_Handle handle;
672		BitVector_Address address;
673
674	94	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
675		{
676	91	BitVector_Empty(address);
677		}
678	3	else BIT_VECTOR_OBJECT_ERROR;
679		}
680
681
682		void
683		BitVector_Fill(reference)
684		BitVector_Object reference
685		CODE:
686		{
687		BitVector_Handle handle;
688		BitVector_Address address;
689
690	10726	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
691		{
692	10723	BitVector_Fill(address);
693		}
694	3	else BIT_VECTOR_OBJECT_ERROR;
695		}
696
697
698		void
699		BitVector_Flip(reference)
700		BitVector_Object reference
701		CODE:
702		{
703		BitVector_Handle handle;
704		BitVector_Address address;
705
706	9	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
707		{
708	6	BitVector_Flip(address);
709		}
710	3	else BIT_VECTOR_OBJECT_ERROR;
711		}
712
713
714		void
715		BitVector_Primes(reference)
716		BitVector_Object reference
717		CODE:
718		{
719		BitVector_Handle handle;
720		BitVector_Address address;
721
722	16	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
723		{
724	13	BitVector_Primes(address);
725		}
726	3	else BIT_VECTOR_OBJECT_ERROR;
727		}
728
729
730		void
731		BitVector_Reverse(Xref,Yref)
732		BitVector_Object Xref
733		BitVector_Object Yref
734		CODE:
735		{
736		BitVector_Handle Xhdl;
737		BitVector_Address Xadr;
738		BitVector_Handle Yhdl;
739		BitVector_Address Yadr;
740
741	10	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
742		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
743		{
744	4	if (bits_(Xadr) == bits_(Yadr))
745		{
746	2	BitVector_Reverse(Xadr,Yadr);
747		}
748	2	else BIT_VECTOR_SIZE_ERROR;
749		}
750	6	else BIT_VECTOR_OBJECT_ERROR;
751		}
752
753
754		void
755		BitVector_Interval_Empty(reference,min,max)
756		BitVector_Object reference
757		BitVector_Scalar min
758		BitVector_Scalar max
759		ALIAS:
760		Empty_Interval = 2
761		CODE:
762		{
763		BitVector_Handle handle;
764		BitVector_Address address;
765		N_int lower;
766		N_int upper;
767
768	293	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
769		{
770	290	if ( BIT_VECTOR_SCALAR(min,N_int,lower) &&
771		BIT_VECTOR_SCALAR(max,N_int,upper) )
772		{
773	288	if (lower >= bits_(address)) BIT_VECTOR_MIN_ERROR;
774	285	else if (upper >= bits_(address)) BIT_VECTOR_MAX_ERROR;
775	282	else if (lower > upper) BIT_VECTOR_ORDER_ERROR;
776	281	else BitVector_Interval_Empty(address,lower,upper);
777		}
778	2	else BIT_VECTOR_SCALAR_ERROR;
779		}
780	3	else BIT_VECTOR_OBJECT_ERROR;
781		}
782
783
784		void
785		BitVector_Interval_Fill(reference,min,max)
786		BitVector_Object reference
787		BitVector_Scalar min
788		BitVector_Scalar max
789		ALIAS:
790		Fill_Interval = 2
791		CODE:
792		{
793		BitVector_Handle handle;
794		BitVector_Address address;
795		N_int lower;
796		N_int upper;
797
798	293	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
799		{
800	290	if ( BIT_VECTOR_SCALAR(min,N_int,lower) &&
801		BIT_VECTOR_SCALAR(max,N_int,upper) )
802		{
803	288	if (lower >= bits_(address)) BIT_VECTOR_MIN_ERROR;
804	285	else if (upper >= bits_(address)) BIT_VECTOR_MAX_ERROR;
805	282	else if (lower > upper) BIT_VECTOR_ORDER_ERROR;
806	281	else BitVector_Interval_Fill(address,lower,upper);
807		}
808	2	else BIT_VECTOR_SCALAR_ERROR;
809		}
810	3	else BIT_VECTOR_OBJECT_ERROR;
811		}
812
813
814		void
815		BitVector_Interval_Flip(reference,min,max)
816		BitVector_Object reference
817		BitVector_Scalar min
818		BitVector_Scalar max
819		ALIAS:
820		Flip_Interval = 2
821		CODE:
822		{
823		BitVector_Handle handle;
824		BitVector_Address address;
825		N_int lower;
826		N_int upper;
827
828	573	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
829		{
830	570	if ( BIT_VECTOR_SCALAR(min,N_int,lower) &&
831		BIT_VECTOR_SCALAR(max,N_int,upper) )
832		{
833	568	if (lower >= bits_(address)) BIT_VECTOR_MIN_ERROR;
834	565	else if (upper >= bits_(address)) BIT_VECTOR_MAX_ERROR;
835	562	else if (lower > upper) BIT_VECTOR_ORDER_ERROR;
836	561	else BitVector_Interval_Flip(address,lower,upper);
837		}
838	2	else BIT_VECTOR_SCALAR_ERROR;
839		}
840	3	else BIT_VECTOR_OBJECT_ERROR;
841		}
842
843
844		void
845		BitVector_Interval_Reverse(reference,min,max)
846		BitVector_Object reference
847		BitVector_Scalar min
848		BitVector_Scalar max
849		CODE:
850		{
851		BitVector_Handle handle;
852		BitVector_Address address;
853		N_int lower;
854		N_int upper;
855
856	61	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
857		{
858	58	if ( BIT_VECTOR_SCALAR(min,N_int,lower) &&
859		BIT_VECTOR_SCALAR(max,N_int,upper) )
860		{
861	56	if (lower >= bits_(address)) BIT_VECTOR_MIN_ERROR;
862	53	else if (upper >= bits_(address)) BIT_VECTOR_MAX_ERROR;
863	50	else if (lower > upper) BIT_VECTOR_ORDER_ERROR;
864	49	else BitVector_Interval_Reverse(address,lower,upper);
865		}
866	2	else BIT_VECTOR_SCALAR_ERROR;
867		}
868	3	else BIT_VECTOR_OBJECT_ERROR;
869		}
870
871
872		void
873		BitVector_Interval_Scan_inc(reference,start)
874		BitVector_Object reference
875		BitVector_Scalar start
876		PPCODE:
877		{
878		BitVector_Handle handle;
879		BitVector_Address address;
880		N_int first;
881		N_int min;
882		N_int max;
883
884	5415	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
885		{
886	5412	if ( BIT_VECTOR_SCALAR(start,N_int,first) )
887		{
888	5411	if (first < bits_(address))
889		{
890	5407	if ( BitVector_interval_scan_inc(address,first,&min,&max) )
891		{
892	5326	EXTEND(sp,2);
893	5326	PUSHs(sv_2mortal(newSViv((IV)min)));
894	5326	PUSHs(sv_2mortal(newSViv((IV)max)));
895		}
896		/* else return empty list */
897		}
898	4	else BIT_VECTOR_START_ERROR;
899		}
900	1	else BIT_VECTOR_SCALAR_ERROR;
901		}
902	3	else BIT_VECTOR_OBJECT_ERROR;
903		}
904
905
906		void
907		BitVector_Interval_Scan_dec(reference,start)
908		BitVector_Object reference
909		BitVector_Scalar start
910		PPCODE:
911		{
912		BitVector_Handle handle;
913		BitVector_Address address;
914		N_int first;
915		N_int min;
916		N_int max;
917
918	5415	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
919		{
920	5412	if ( BIT_VECTOR_SCALAR(start,N_int,first) )
921		{
922	5411	if (first < bits_(address))
923		{
924	5407	if ( BitVector_interval_scan_dec(address,first,&min,&max) )
925		{
926	5327	EXTEND(sp,2);
927	5327	PUSHs(sv_2mortal(newSViv((IV)min)));
928	5327	PUSHs(sv_2mortal(newSViv((IV)max)));
929		}
930		/* else return empty list */
931		}
932	4	else BIT_VECTOR_START_ERROR;
933		}
934	1	else BIT_VECTOR_SCALAR_ERROR;
935		}
936	3	else BIT_VECTOR_OBJECT_ERROR;
937		}
938
939
940		void
941		BitVector_Interval_Copy(Xref,Yref,Xoffset,Yoffset,length)
942		BitVector_Object Xref
943		BitVector_Object Yref
944		BitVector_Scalar Xoffset
945		BitVector_Scalar Yoffset
946		BitVector_Scalar length
947		CODE:
948		{
949		BitVector_Handle Xhdl;
950		BitVector_Address Xadr;
951		BitVector_Handle Yhdl;
952		BitVector_Address Yadr;
953		N_int Xoff;
954		N_int Yoff;
955		N_int len;
956
957	15	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
958		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
959		{
960	9	if ( BIT_VECTOR_SCALAR(Xoffset,N_int,Xoff) &&
961		BIT_VECTOR_SCALAR(Yoffset,N_int,Yoff) &&
962		BIT_VECTOR_SCALAR(length, N_int,len) )
963		{
964	6	if ((Xoff < bits_(Xadr)) and (Yoff < bits_(Yadr)))
965		{
966	2	if (len > 0) BitVector_Interval_Copy(Xadr,Yadr,Xoff,Yoff,len);
967		}
968	4	else BIT_VECTOR_OFFSET_ERROR;
969		}
970	3	else BIT_VECTOR_SCALAR_ERROR;
971		}
972	6	else BIT_VECTOR_OBJECT_ERROR;
973		}
974
975
976		void
977		BitVector_Interval_Substitute(Xref,Yref,Xoffset,Xlength,Yoffset,Ylength)
978		BitVector_Object Xref
979		BitVector_Object Yref
980		BitVector_Scalar Xoffset
981		BitVector_Scalar Xlength
982		BitVector_Scalar Yoffset
983		BitVector_Scalar Ylength
984		CODE:
985		{
986		BitVector_Handle Xhdl;
987		BitVector_Address Xadr;
988		BitVector_Handle Yhdl;
989		BitVector_Address Yadr;
990		N_int Xoff;
991		N_int Xlen;
992		N_int Yoff;
993		N_int Ylen;
994
995	16	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
996		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
997		{
998	10	if ( BIT_VECTOR_SCALAR(Xoffset,N_int,Xoff) &&
999		BIT_VECTOR_SCALAR(Xlength,N_int,Xlen) &&
1000		BIT_VECTOR_SCALAR(Yoffset,N_int,Yoff) &&
1001		BIT_VECTOR_SCALAR(Ylength,N_int,Ylen) )
1002		{
1003	6	if ((Xoff <= bits_(Xadr)) and (Yoff <= bits_(Yadr)))
1004		{
1005	2	Xadr = BitVector_Interval_Substitute(Xadr,Yadr,Xoff,Xlen,Yoff,Ylen);
1006	2	SvREADONLY_off(Xhdl);
1007	2	sv_setiv(Xhdl,(IV)Xadr);
1008	2	SvREADONLY_on(Xhdl);
1009	2	if (Xadr == NULL) BIT_VECTOR_MEMORY_ERROR;
1010		}
1011	4	else BIT_VECTOR_OFFSET_ERROR;
1012		}
1013	4	else BIT_VECTOR_SCALAR_ERROR;
1014		}
1015	6	else BIT_VECTOR_OBJECT_ERROR;
1016		}
1017
1018
1019		boolean
1020		BitVector_is_empty(reference)
1021		BitVector_Object reference
1022		CODE:
1023		{
1024		BitVector_Handle handle;
1025		BitVector_Address address;
1026
1027	61	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1028		{
1029	58	RETVAL = BitVector_is_empty(address);
1030		}
1031	3	else BIT_VECTOR_OBJECT_ERROR;
1032		}
1033		OUTPUT:
1034		RETVAL
1035
1036
1037		boolean
1038		BitVector_is_full(reference)
1039		BitVector_Object reference
1040		CODE:
1041		{
1042		BitVector_Handle handle;
1043		BitVector_Address address;
1044
1045	25	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1046		{
1047	22	RETVAL = BitVector_is_full(address);
1048		}
1049	3	else BIT_VECTOR_OBJECT_ERROR;
1050		}
1051		OUTPUT:
1052		RETVAL
1053
1054
1055		boolean
1056		BitVector_equal(Xref,Yref)
1057		BitVector_Object Xref
1058		BitVector_Object Yref
1059		CODE:
1060		{
1061		BitVector_Handle Xhdl;
1062		BitVector_Address Xadr;
1063		BitVector_Handle Yhdl;
1064		BitVector_Address Yadr;
1065
1066	15531	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
1067		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
1068		{
1069	15525	if (bits_(Xadr) == bits_(Yadr))
1070		{
1071	15523	RETVAL = BitVector_equal(Xadr,Yadr);
1072		}
1073	2	else BIT_VECTOR_SIZE_ERROR;
1074		}
1075	6	else BIT_VECTOR_OBJECT_ERROR;
1076		}
1077		OUTPUT:
1078		RETVAL
1079
1080
1081		Z_int
1082		BitVector_Lexicompare(Xref,Yref)
1083		BitVector_Object Xref
1084		BitVector_Object Yref
1085		CODE:
1086		{
1087		BitVector_Handle Xhdl;
1088		BitVector_Address Xadr;
1089		BitVector_Handle Yhdl;
1090		BitVector_Address Yadr;
1091
1092	56	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
1093		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
1094		{
1095	50	if (bits_(Xadr) == bits_(Yadr))
1096		{
1097	48	RETVAL = BitVector_Lexicompare(Xadr,Yadr);
1098		}
1099	2	else BIT_VECTOR_SIZE_ERROR;
1100		}
1101	6	else BIT_VECTOR_OBJECT_ERROR;
1102		}
1103		OUTPUT:
1104		RETVAL
1105
1106
1107		Z_int
1108		BitVector_Compare(Xref,Yref)
1109		BitVector_Object Xref
1110		BitVector_Object Yref
1111		CODE:
1112		{
1113		BitVector_Handle Xhdl;
1114		BitVector_Address Xadr;
1115		BitVector_Handle Yhdl;
1116		BitVector_Address Yadr;
1117
1118	35	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
1119		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
1120		{
1121	29	if (bits_(Xadr) == bits_(Yadr))
1122		{
1123	27	RETVAL = BitVector_Compare(Xadr,Yadr);
1124		}
1125	2	else BIT_VECTOR_SIZE_ERROR;
1126		}
1127	6	else BIT_VECTOR_OBJECT_ERROR;
1128		}
1129		OUTPUT:
1130		RETVAL
1131
1132
1133		void
1134		BitVector_to_Hex(reference)
1135		BitVector_Object reference
1136		ALIAS:
1137		to_String = 2
1138		PPCODE:
1139		{
1140		BitVector_Handle handle;
1141		BitVector_Address address;
1142		charptr string;
1143
1144	255	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1145		{
1146	252	string = BitVector_to_Hex(address);
1147	252	if (string != NULL)
1148		{
1149	252	EXTEND(sp,1);
1150	252	PUSHs(sv_2mortal(newSVpv((char *)string,0)));
1151	252	BitVector_Dispose(string);
1152		}
1153	0	else BIT_VECTOR_MEMORY_ERROR;
1154		}
1155	3	else BIT_VECTOR_OBJECT_ERROR;
1156		}
1157
1158
1159		void
1160		BitVector_from_Hex(reference,string)
1161		BitVector_Object reference
1162		BitVector_Scalar string
1163		ALIAS:
1164		from_string = 2
1165		CODE:
1166		{
1167		BitVector_Handle handle;
1168		BitVector_Address address;
1169		charptr pointer;
1170		ErrCode code;
1171
1172	3071	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1173		{
1174	3068	if ( BIT_VECTOR_STRING(string,pointer) )
1175		{
1176	3067	if ((code = BitVector_from_Hex(address,pointer)))
1177	5	BIT_VECTOR_EXCEPTION(code);
1178		}
1179	1	else BIT_VECTOR_STRING_ERROR;
1180		}
1181	3	else BIT_VECTOR_OBJECT_ERROR;
1182		}
1183
1184
1185		void
1186		BitVector_to_Bin(reference)
1187		BitVector_Object reference
1188		PPCODE:
1189		{
1190		BitVector_Handle handle;
1191		BitVector_Address address;
1192		charptr string;
1193
1194	112	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1195		{
1196	109	string = BitVector_to_Bin(address);
1197	109	if (string != NULL)
1198		{
1199	109	EXTEND(sp,1);
1200	109	PUSHs(sv_2mortal(newSVpv((char *)string,0)));
1201	109	BitVector_Dispose(string);
1202		}
1203	0	else BIT_VECTOR_MEMORY_ERROR;
1204		}
1205	3	else BIT_VECTOR_OBJECT_ERROR;
1206		}
1207
1208
1209		void
1210		BitVector_from_Bin(reference,string)
1211		BitVector_Object reference
1212		BitVector_Scalar string
1213		CODE:
1214		{
1215		BitVector_Handle handle;
1216		BitVector_Address address;
1217		charptr pointer;
1218		ErrCode code;
1219
1220	59	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1221		{
1222	56	if ( BIT_VECTOR_STRING(string,pointer) )
1223		{
1224	55	if ((code = BitVector_from_Bin(address,pointer)))
1225	0	BIT_VECTOR_EXCEPTION(code);
1226		}
1227	1	else BIT_VECTOR_STRING_ERROR;
1228		}
1229	3	else BIT_VECTOR_OBJECT_ERROR;
1230		}
1231
1232
1233		void
1234		BitVector_to_Dec(reference)
1235		BitVector_Object reference
1236		PPCODE:
1237		{
1238		BitVector_Handle handle;
1239		BitVector_Address address;
1240		charptr string;
1241
1242	274	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1243		{
1244	271	string = BitVector_to_Dec(address);
1245	271	if (string != NULL)
1246		{
1247	271	EXTEND(sp,1);
1248	271	PUSHs(sv_2mortal(newSVpv((char *)string,0)));
1249	271	BitVector_Dispose(string);
1250		}
1251	0	else BIT_VECTOR_MEMORY_ERROR;
1252		}
1253	3	else BIT_VECTOR_OBJECT_ERROR;
1254		}
1255
1256
1257		void
1258		BitVector_from_Dec(reference,string)
1259		BitVector_Object reference
1260		BitVector_Scalar string
1261		CODE:
1262		{
1263		BitVector_Handle handle;
1264		BitVector_Address address;
1265		charptr pointer;
1266		ErrCode code;
1267
1268	95	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1269		{
1270	92	if ( BIT_VECTOR_STRING(string,pointer) )
1271		{
1272	91	if ((code = BitVector_from_Dec(address,pointer)))
1273	0	BIT_VECTOR_EXCEPTION(code);
1274		}
1275	1	else BIT_VECTOR_STRING_ERROR;
1276		}
1277	3	else BIT_VECTOR_OBJECT_ERROR;
1278		}
1279
1280
1281		void
1282		BitVector_to_Enum(reference)
1283		BitVector_Object reference
1284		ALIAS:
1285		to_ASCII = 2
1286		PPCODE:
1287		{
1288		BitVector_Handle handle;
1289		BitVector_Address address;
1290		charptr string;
1291
1292	115	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1293		{
1294	112	string = BitVector_to_Enum(address);
1295	112	if (string != NULL)
1296		{
1297	112	EXTEND(sp,1);
1298	112	PUSHs(sv_2mortal(newSVpv((char *)string,0)));
1299	112	BitVector_Dispose(string);
1300		}
1301	0	else BIT_VECTOR_MEMORY_ERROR;
1302		}
1303	3	else BIT_VECTOR_OBJECT_ERROR;
1304		}
1305
1306
1307		void
1308		BitVector_from_Enum(reference,string)
1309		BitVector_Object reference
1310		BitVector_Scalar string
1311		ALIAS:
1312		from_ASCII = 2
1313		CODE:
1314		{
1315		BitVector_Handle handle;
1316		BitVector_Address address;
1317		charptr pointer;
1318		ErrCode code;
1319
1320	71	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1321		{
1322	68	if ( BIT_VECTOR_STRING(string,pointer) )
1323		{
1324	67	if ((code = BitVector_from_Enum(address,pointer)))
1325	8	BIT_VECTOR_EXCEPTION(code);
1326		}
1327	1	else BIT_VECTOR_STRING_ERROR;
1328		}
1329	3	else BIT_VECTOR_OBJECT_ERROR;
1330		}
1331
1332
1333		void
1334		BitVector_Bit_Off(reference,index)
1335		BitVector_Object reference
1336		BitVector_Scalar index
1337		CODE:
1338		{
1339		BitVector_Handle handle;
1340		BitVector_Address address;
1341		N_int idx;
1342
1343	26650	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1344		{
1345	26647	if ( BIT_VECTOR_SCALAR(index,N_int,idx) )
1346		{
1347	26646	if (idx < bits_(address))
1348		{
1349	26644	BitVector_Bit_Off(address,idx);
1350		}
1351	2	else BIT_VECTOR_INDEX_ERROR;
1352		}
1353	1	else BIT_VECTOR_SCALAR_ERROR;
1354		}
1355	3	else BIT_VECTOR_OBJECT_ERROR;
1356		}
1357
1358
1359		void
1360		BitVector_Bit_On(reference,index)
1361		BitVector_Object reference
1362		BitVector_Scalar index
1363		CODE:
1364		{
1365		BitVector_Handle handle;
1366		BitVector_Address address;
1367		N_int idx;
1368
1369	21819	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1370		{
1371	21816	if ( BIT_VECTOR_SCALAR(index,N_int,idx) )
1372		{
1373	21815	if (idx < bits_(address))
1374		{
1375	21813	BitVector_Bit_On(address,idx);
1376		}
1377	2	else BIT_VECTOR_INDEX_ERROR;
1378		}
1379	1	else BIT_VECTOR_SCALAR_ERROR;
1380		}
1381	3	else BIT_VECTOR_OBJECT_ERROR;
1382		}
1383
1384
1385		boolean
1386		BitVector_bit_flip(reference,index)
1387		BitVector_Object reference
1388		BitVector_Scalar index
1389		ALIAS:
1390		flip = 2
1391		CODE:
1392		{
1393		BitVector_Handle handle;
1394		BitVector_Address address;
1395		N_int idx;
1396
1397	13343	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1398		{
1399	13340	if ( BIT_VECTOR_SCALAR(index,N_int,idx) )
1400		{
1401	13339	if (idx < bits_(address))
1402		{
1403	13337	RETVAL = BitVector_bit_flip(address,idx);
1404		}
1405	2	else BIT_VECTOR_INDEX_ERROR;
1406		}
1407	1	else BIT_VECTOR_SCALAR_ERROR;
1408		}
1409	3	else BIT_VECTOR_OBJECT_ERROR;
1410		}
1411		OUTPUT:
1412		RETVAL
1413
1414
1415		boolean
1416		BitVector_bit_test(reference,index)
1417		BitVector_Object reference
1418		BitVector_Scalar index
1419		ALIAS:
1420		contains = 1
1421		in = 2
1422		CODE:
1423		{
1424		BitVector_Handle handle;
1425		BitVector_Address address;
1426		N_int idx;
1427
1428	128255	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1429		{
1430	128252	if ( BIT_VECTOR_SCALAR(index,N_int,idx) )
1431		{
1432	128251	if (idx < bits_(address))
1433		{
1434	128249	RETVAL = BitVector_bit_test(address,idx);
1435		}
1436	2	else BIT_VECTOR_INDEX_ERROR;
1437		}
1438	1	else BIT_VECTOR_SCALAR_ERROR;
1439		}
1440	3	else BIT_VECTOR_OBJECT_ERROR;
1441		}
1442		OUTPUT:
1443		RETVAL
1444
1445
1446		void
1447		BitVector_Bit_Copy(reference,index,bit)
1448		BitVector_Object reference
1449		BitVector_Scalar index
1450		BitVector_Scalar bit
1451		CODE:
1452		{
1453		BitVector_Handle handle;
1454		BitVector_Address address;
1455		N_int idx;
1456		boolean b;
1457
1458	8	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1459		{
1460	5	if ( BIT_VECTOR_SCALAR(index,N_int,idx) &&
1461		BIT_VECTOR_SCALAR(bit,boolean,b) )
1462		{
1463	3	if (idx < bits_(address))
1464		{
1465	1	BitVector_Bit_Copy(address,idx,b);
1466		}
1467	2	else BIT_VECTOR_INDEX_ERROR;
1468		}
1469	2	else BIT_VECTOR_SCALAR_ERROR;
1470		}
1471	3	else BIT_VECTOR_OBJECT_ERROR;
1472		}
1473
1474
1475		void
1476		BitVector_LSB(reference,bit)
1477		BitVector_Object reference
1478		BitVector_Scalar bit
1479		CODE:
1480		{
1481		BitVector_Handle handle;
1482		BitVector_Address address;
1483		boolean b;
1484
1485	5	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1486		{
1487	2	if ( BIT_VECTOR_SCALAR(bit,boolean,b) )
1488		{
1489	1	BitVector_LSB(address,b);
1490		}
1491	1	else BIT_VECTOR_SCALAR_ERROR;
1492		}
1493	3	else BIT_VECTOR_OBJECT_ERROR;
1494		}
1495
1496
1497		void
1498		BitVector_MSB(reference,bit)
1499		BitVector_Object reference
1500		BitVector_Scalar bit
1501		CODE:
1502		{
1503		BitVector_Handle handle;
1504		BitVector_Address address;
1505		boolean b;
1506
1507	5	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1508		{
1509	2	if ( BIT_VECTOR_SCALAR(bit,boolean,b) )
1510		{
1511	1	BitVector_MSB(address,b);
1512		}
1513	1	else BIT_VECTOR_SCALAR_ERROR;
1514		}
1515	3	else BIT_VECTOR_OBJECT_ERROR;
1516		}
1517
1518
1519		boolean
1520		BitVector_lsb(reference)
1521		BitVector_Object reference
1522		CODE:
1523		{
1524		BitVector_Handle handle;
1525		BitVector_Address address;
1526
1527	4	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1528		{
1529	1	RETVAL = BitVector_lsb_(address);
1530		}
1531	3	else BIT_VECTOR_OBJECT_ERROR;
1532		}
1533		OUTPUT:
1534		RETVAL
1535
1536
1537		boolean
1538		BitVector_msb(reference)
1539		BitVector_Object reference
1540		CODE:
1541		{
1542		BitVector_Handle handle;
1543		BitVector_Address address;
1544
1545	29	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1546		{
1547	26	RETVAL = BitVector_msb_(address);
1548		}
1549	3	else BIT_VECTOR_OBJECT_ERROR;
1550		}
1551		OUTPUT:
1552		RETVAL
1553
1554
1555		boolean
1556		BitVector_rotate_left(reference)
1557		BitVector_Object reference
1558		CODE:
1559		{
1560		BitVector_Handle handle;
1561		BitVector_Address address;
1562
1563	4061	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1564		{
1565	4058	RETVAL = BitVector_rotate_left(address);
1566		}
1567	3	else BIT_VECTOR_OBJECT_ERROR;
1568		}
1569		OUTPUT:
1570		RETVAL
1571
1572
1573		boolean
1574		BitVector_rotate_right(reference)
1575		BitVector_Object reference
1576		CODE:
1577		{
1578		BitVector_Handle handle;
1579		BitVector_Address address;
1580
1581	4061	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1582		{
1583	4058	RETVAL = BitVector_rotate_right(address);
1584		}
1585	3	else BIT_VECTOR_OBJECT_ERROR;
1586		}
1587		OUTPUT:
1588		RETVAL
1589
1590
1591		boolean
1592		BitVector_shift_left(reference,carry)
1593		BitVector_Object reference
1594		BitVector_Scalar carry
1595		CODE:
1596		{
1597		BitVector_Handle handle;
1598		BitVector_Address address;
1599		boolean c;
1600
1601	12176	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1602		{
1603	12173	if ( BIT_VECTOR_SCALAR(carry,boolean,c) )
1604		{
1605	12172	RETVAL = BitVector_shift_left(address,c);
1606		}
1607	1	else BIT_VECTOR_SCALAR_ERROR;
1608		}
1609	3	else BIT_VECTOR_OBJECT_ERROR;
1610		}
1611		OUTPUT:
1612		RETVAL
1613
1614
1615		boolean
1616		BitVector_shift_right(reference,carry)
1617		BitVector_Object reference
1618		BitVector_Scalar carry
1619		CODE:
1620		{
1621		BitVector_Handle handle;
1622		BitVector_Address address;
1623		boolean c;
1624
1625	12176	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1626		{
1627	12173	if ( BIT_VECTOR_SCALAR(carry,boolean,c) )
1628		{
1629	12172	RETVAL = BitVector_shift_right(address,c);
1630		}
1631	1	else BIT_VECTOR_SCALAR_ERROR;
1632		}
1633	3	else BIT_VECTOR_OBJECT_ERROR;
1634		}
1635		OUTPUT:
1636		RETVAL
1637
1638
1639		void
1640		BitVector_Move_Left(reference,bits)
1641		BitVector_Object reference
1642		BitVector_Scalar bits
1643		CODE:
1644		{
1645		BitVector_Handle handle;
1646		BitVector_Address address;
1647		N_int cnt;
1648
1649	2568	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1650		{
1651	2565	if ( BIT_VECTOR_SCALAR(bits,N_int,cnt) )
1652		{
1653	2564	BitVector_Move_Left(address,cnt);
1654		}
1655	1	else BIT_VECTOR_SCALAR_ERROR;
1656		}
1657	3	else BIT_VECTOR_OBJECT_ERROR;
1658		}
1659
1660
1661		void
1662		BitVector_Move_Right(reference,bits)
1663		BitVector_Object reference
1664		BitVector_Scalar bits
1665		CODE:
1666		{
1667		BitVector_Handle handle;
1668		BitVector_Address address;
1669		N_int cnt;
1670
1671	2568	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1672		{
1673	2565	if ( BIT_VECTOR_SCALAR(bits,N_int,cnt) )
1674		{
1675	2564	BitVector_Move_Right(address,cnt);
1676		}
1677	1	else BIT_VECTOR_SCALAR_ERROR;
1678		}
1679	3	else BIT_VECTOR_OBJECT_ERROR;
1680		}
1681
1682
1683		void
1684		BitVector_Insert(reference,offset,count)
1685		BitVector_Object reference
1686		BitVector_Scalar offset
1687		BitVector_Scalar count
1688		CODE:
1689		{
1690		BitVector_Handle handle;
1691		BitVector_Address address;
1692		N_int off;
1693		N_int cnt;
1694
1695	5160	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1696		{
1697	5157	if ( BIT_VECTOR_SCALAR(offset,N_int,off) &&
1698		BIT_VECTOR_SCALAR(count,N_int,cnt) )
1699		{
1700	5155	if (off < bits_(address))
1701		{
1702	5153	BitVector_Insert(address,off,cnt,true);
1703		}
1704	2	else BIT_VECTOR_OFFSET_ERROR;
1705		}
1706	2	else BIT_VECTOR_SCALAR_ERROR;
1707		}
1708	3	else BIT_VECTOR_OBJECT_ERROR;
1709		}
1710
1711
1712		void
1713		BitVector_Delete(reference,offset,count)
1714		BitVector_Object reference
1715		BitVector_Scalar offset
1716		BitVector_Scalar count
1717		CODE:
1718		{
1719		BitVector_Handle handle;
1720		BitVector_Address address;
1721		N_int off;
1722		N_int cnt;
1723
1724	5160	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1725		{
1726	5157	if ( BIT_VECTOR_SCALAR(offset,N_int,off) &&
1727		BIT_VECTOR_SCALAR(count,N_int,cnt) )
1728		{
1729	5155	if (off < bits_(address))
1730		{
1731	5153	BitVector_Delete(address,off,cnt,true);
1732		}
1733	2	else BIT_VECTOR_OFFSET_ERROR;
1734		}
1735	2	else BIT_VECTOR_SCALAR_ERROR;
1736		}
1737	3	else BIT_VECTOR_OBJECT_ERROR;
1738		}
1739
1740
1741		boolean
1742		BitVector_increment(reference)
1743		BitVector_Object reference
1744		CODE:
1745		{
1746		BitVector_Handle handle;
1747		BitVector_Address address;
1748
1749	1336	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1750		{
1751	1333	RETVAL = BitVector_increment(address);
1752		}
1753	3	else BIT_VECTOR_OBJECT_ERROR;
1754		}
1755		OUTPUT:
1756		RETVAL
1757
1758
1759		boolean
1760		BitVector_decrement(reference)
1761		BitVector_Object reference
1762		CODE:
1763		{
1764		BitVector_Handle handle;
1765		BitVector_Address address;
1766
1767	1336	if ( BIT_VECTOR_OBJECT(reference,handle,address) )
1768		{
1769	1333	RETVAL = BitVector_decrement(address);
1770		}
1771	3	else BIT_VECTOR_OBJECT_ERROR;
1772		}
1773		OUTPUT:
1774		RETVAL
1775
1776
1777		void
1778		BitVector_add(Xref,Yref,Zref,carry)
1779		BitVector_Object Xref
1780		BitVector_Object Yref
1781		BitVector_Object Zref
1782		BitVector_Scalar carry
1783		PPCODE:
1784		{
1785		BitVector_Handle Xhdl;
1786		BitVector_Address Xadr;
1787		BitVector_Handle Yhdl;
1788		BitVector_Address Yadr;
1789		BitVector_Handle Zhdl;
1790		BitVector_Address Zadr;
1791		boolean c;
1792		boolean v;
1793
1794	534	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
1795		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
1796		BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
1797		{
1798	525	if ( BIT_VECTOR_SCALAR(carry,boolean,c) )
1799		{
1800	524	if ((bits_(Xadr) == bits_(Yadr)) and (bits_(Xadr) == bits_(Zadr)))
1801		{
1802	521	v = BitVector_compute(Xadr,Yadr,Zadr,false,&c);
1803	521	if (GIMME_V == G_ARRAY)
1804		{
1805	0	EXTEND(sp,2);
1806	0	PUSHs(sv_2mortal(newSViv((IV)c)));
1807	0	PUSHs(sv_2mortal(newSViv((IV)v)));
1808		}
1809		else
1810		{
1811	521	EXTEND(sp,1);
1812	521	PUSHs(sv_2mortal(newSViv((IV)c)));
1813		}
1814		}
1815	3	else BIT_VECTOR_SIZE_ERROR;
1816		}
1817	1	else BIT_VECTOR_SCALAR_ERROR;
1818		}
1819	9	else BIT_VECTOR_OBJECT_ERROR;
1820		}
1821
1822
1823		void
1824		BitVector_subtract(Xref,Yref,Zref,carry)
1825		BitVector_Object Xref
1826		BitVector_Object Yref
1827		BitVector_Object Zref
1828		BitVector_Scalar carry
1829		ALIAS:
1830		sub = 2
1831		PPCODE:
1832		{
1833		BitVector_Handle Xhdl;
1834		BitVector_Address Xadr;
1835		BitVector_Handle Yhdl;
1836		BitVector_Address Yadr;
1837		BitVector_Handle Zhdl;
1838		BitVector_Address Zadr;
1839		boolean c;
1840		boolean v;
1841
1842	516	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
1843		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) &&
1844		BIT_VECTOR_OBJECT(Zref,Zhdl,Zadr) )
1845		{
1846	507	if ( BIT_VECTOR_SCALAR(carry,boolean,c) )
1847		{
1848	506	if ((bits_(Xadr) == bits_(Yadr)) and (bits_(Xadr) == bits_(Zadr)))
1849		{
1850	503	v = BitVector_compute(Xadr,Yadr,Zadr,true,&c);
1851	503	if (GIMME_V == G_ARRAY)
1852		{
1853	0	EXTEND(sp,2);
1854	0	PUSHs(sv_2mortal(newSViv((IV)c)));
1855	0	PUSHs(sv_2mortal(newSViv((IV)v)));
1856		}
1857		else
1858		{
1859	503	EXTEND(sp,1);
1860	503	PUSHs(sv_2mortal(newSViv((IV)c)));
1861		}
1862		}
1863	3	else BIT_VECTOR_SIZE_ERROR;
1864		}
1865	1	else BIT_VECTOR_SCALAR_ERROR;
1866		}
1867	9	else BIT_VECTOR_OBJECT_ERROR;
1868		}
1869
1870
1871		boolean
1872		BitVector_inc(Xref,Yref)
1873		BitVector_Object Xref
1874		BitVector_Object Yref
1875		CODE:
1876		{
1877		BitVector_Handle Xhdl;
1878		BitVector_Address Xadr;
1879		BitVector_Handle Yhdl;
1880		BitVector_Address Yadr;
1881	0	boolean c = true;
1882
1883	0	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
1884		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
1885		{
1886	0	if (bits_(Xadr) == bits_(Yadr))
1887		{
1888	0	RETVAL = BitVector_compute(Xadr,Yadr,NULL,false,&c);
1889		}
1890	0	else BIT_VECTOR_SIZE_ERROR;
1891		}
1892	0	else BIT_VECTOR_OBJECT_ERROR;
1893		}
1894		OUTPUT:
1895		RETVAL
1896
1897
1898		boolean
1899		BitVector_dec(Xref,Yref)
1900		BitVector_Object Xref
1901		BitVector_Object Yref
1902		CODE:
1903		{
1904		BitVector_Handle Xhdl;
1905		BitVector_Address Xadr;
1906		BitVector_Handle Yhdl;
1907		BitVector_Address Yadr;
1908	0	boolean c = true;
1909
1910	0	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
1911		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
1912		{
1913	0	if (bits_(Xadr) == bits_(Yadr))
1914		{
1915	0	RETVAL = BitVector_compute(Xadr,Yadr,NULL,true,&c);
1916		}
1917	0	else BIT_VECTOR_SIZE_ERROR;
1918		}
1919	0	else BIT_VECTOR_OBJECT_ERROR;
1920		}
1921		OUTPUT:
1922		RETVAL
1923
1924
1925		void
1926		BitVector_Negate(Xref,Yref)
1927		BitVector_Object Xref
1928		BitVector_Object Yref
1929		ALIAS:
1930		Neg = 1
1931		CODE:
1932		{
1933		BitVector_Handle Xhdl;
1934		BitVector_Address Xadr;
1935		BitVector_Handle Yhdl;
1936		BitVector_Address Yadr;
1937
1938	10	if ( BIT_VECTOR_OBJECT(Xref,Xhdl,Xadr) &&
1939		BIT_VECTOR_OBJECT(Yref,Yhdl,Yadr) )
1940		{
1941	4	if (bits_(Xadr) == bits_(Yadr))
1942		{
1943	2	BitVector_Negate(Xadr,Yadr);
1944		}
1945	2	else BIT_VECTOR_SIZE_ERROR;
1946		}
1947	6	else BIT_VECTOR_OBJECT_ERROR;
1948		}
1949
1950
1951		void
1952		BitVector_Absolute(Xref,Yref)
1953		BitVector_Object Xref
1954		BitVector_Object Yref
1955		ALIAS:
1956		Abs = 1
1957		CODE:
1958		{
1959		BitVector_Handle Xhdl;
1960		BitVector_Address Xadr;
1961		BitVector_Handle Yhdl;
1962		BitVector_Address Yadr;
1963
1964	10