h/prototypes.h: Remove mhlsbr() prototype; no such function.

[nmh] / sbr / vector.c

diff --git a/sbr/vector.c b/sbr/vector.c
index 7df361870f710809f566fa5c4bb5dc66f07bae2a..d0ebc33667c43c5fd18e8de2a1197d46a0b2c2c7 100644 (file)
--- a/sbr/vector.c
+++ b/sbr/vector.c
@@ -16,8 +16,8 @@
  * can be as large as needed, as long as it fits in (virtual) memory.
  */
 
  * can be as large as needed, as long as it fits in (virtual) memory.
  */
 

-#include <h/mh.h>
-#include <h/utils.h>
+#include "h/mh.h"
+#include "h/utils.h"

 
 /* The default size of a struct bvector's bits, measured in bits.
  * The struct's tiny member is used for storage. */
 
 /* The default size of a struct bvector's bits, measured in bits.
  * The struct's tiny member is used for storage. */


@@ -54,7 +54,8 @@
 static void bvector_resize (bvector_t vec, size_t newsize);
 
 bvector_t
 static void bvector_resize (bvector_t vec, size_t newsize);
 
 bvector_t

-bvector_create (void) {
+bvector_create (void)
+{

     bvector_t vec;
 
     /* See "wider than unsigned long" comment above. */
     bvector_t vec;
 
     /* See "wider than unsigned long" comment above. */


@@ -66,7 +67,8 @@ bvector_create (void) {
     return vec;
 }
 
     return vec;
 }
 

-void bvector_init(struct bvector *bv)
+void
+bvector_init(struct bvector *bv)

 {
     bv->bits = bv->tiny;
     bv->maxsize = BVEC_INIT_SIZE;
 {
     bv->bits = bv->tiny;
     bv->maxsize = BVEC_INIT_SIZE;


@@ -74,43 +76,52 @@ void bvector_init(struct bvector *bv)
 }
 
 void
 }
 
 void

-bvector_copy (bvector_t dest, bvector_t src) {
+bvector_copy (bvector_t dest, bvector_t src)
+{

     size_t bytes = BVEC_BYTES(src->maxsize);
 
     if (dest->bits != dest->tiny)
         free(dest->bits);
     size_t bytes = BVEC_BYTES(src->maxsize);
 
     if (dest->bits != dest->tiny)
         free(dest->bits);

-    dest->bits = mh_xmalloc (bytes);
+    if (bytes <= sizeof dest->tiny)
+        dest->bits = dest->tiny;
+    else
+        dest->bits = mh_xmalloc (bytes);

     memcpy (dest->bits, src->bits, bytes);
     dest->maxsize = src->maxsize;
 }
 
 void
     memcpy (dest->bits, src->bits, bytes);
     dest->maxsize = src->maxsize;
 }
 
 void

-bvector_free (bvector_t vec) {
+bvector_free (bvector_t vec)
+{

     bvector_fini(vec);
     free (vec);
 }
 
     bvector_fini(vec);
     free (vec);
 }
 

-void bvector_fini(struct bvector *bv)
+void
+bvector_fini(struct bvector *bv)

 {
     if (bv->bits != bv->tiny)
         free(bv->bits);
 }
 
 void
 {
     if (bv->bits != bv->tiny)
         free(bv->bits);
 }
 
 void

-bvector_clear (bvector_t vec, size_t n) {
+bvector_clear (bvector_t vec, size_t n)
+{

     if (n < vec->maxsize)
         vec->bits[BVEC_WORD(n)] &= ~(1ul << BVEC_OFFSET(n));
 }
 
 
 void
     if (n < vec->maxsize)
         vec->bits[BVEC_WORD(n)] &= ~(1ul << BVEC_OFFSET(n));
 }
 
 
 void

-bvector_clear_all (bvector_t vec) {
+bvector_clear_all (bvector_t vec)
+{

     memset (vec->bits, 0, BVEC_BYTES(vec->maxsize));
 }
 
 
 void
     memset (vec->bits, 0, BVEC_BYTES(vec->maxsize));
 }
 
 
 void

-bvector_set (bvector_t vec, size_t n) {
+bvector_set (bvector_t vec, size_t n)
+{

     size_t word = BVEC_WORD(n);
     size_t offset = BVEC_OFFSET(n);
 
     size_t word = BVEC_WORD(n);
     size_t offset = BVEC_OFFSET(n);
 


@@ -120,7 +131,8 @@ bvector_set (bvector_t vec, size_t n) {
 }
 
 unsigned int
 }
 
 unsigned int

-bvector_at (bvector_t vec, size_t i) {
+bvector_at (bvector_t vec, size_t i)
+{

     if (i < vec->maxsize)
         return !!(vec->bits[BVEC_WORD(i)] & (1ul << BVEC_OFFSET(i)));
 
     if (i < vec->maxsize)
         return !!(vec->bits[BVEC_WORD(i)] & (1ul << BVEC_OFFSET(i)));
 


@@ -128,7 +140,8 @@ bvector_at (bvector_t vec, size_t i) {
 }
 
 static void
 }
 
 static void

-bvector_resize (bvector_t vec, size_t newsize) {
+bvector_resize (bvector_t vec, size_t newsize)
+{

     size_t oldsize = vec->maxsize;
     size_t bytes;
 
     size_t oldsize = vec->maxsize;
     size_t bytes;
 


@@ -146,7 +159,8 @@ bvector_resize (bvector_t vec, size_t newsize) {
 }
 
 unsigned long
 }
 
 unsigned long

-bvector_first_bits (bvector_t vec) {
+bvector_first_bits (bvector_t vec)
+{

     return *vec->bits;
 }
 
     return *vec->bits;
 }
 


@@ -160,7 +174,8 @@ struct svector {
 static void svector_resize (svector_t, size_t);
 
 svector_t
 static void svector_resize (svector_t, size_t);
 
 svector_t

-svector_create (size_t init_size) {
+svector_create (size_t init_size)
+{

     svector_t vec;
     size_t bytes;
 
     svector_t vec;
     size_t bytes;
 


@@ -174,20 +189,23 @@ svector_create (size_t init_size) {
 }
 
 void
 }
 
 void

-svector_free (svector_t vec) {
+svector_free (svector_t vec)
+{

     free (vec->strs);
     free (vec);
 }
 
 char *
     free (vec->strs);
     free (vec);
 }
 
 char *

-svector_push_back (svector_t vec, char *s) {
+svector_push_back (svector_t vec, char *s)
+{

     if (++vec->size >= vec->maxsize)
         svector_resize (vec, vec->size);
     return vec->strs[vec->size-1] = s;
 }
 
 char *
     if (++vec->size >= vec->maxsize)
         svector_resize (vec, vec->size);
     return vec->strs[vec->size-1] = s;
 }
 
 char *

-svector_at (svector_t vec, size_t i) {
+svector_at (svector_t vec, size_t i)
+{

     if (i >= vec->maxsize)
         svector_resize (vec, i);
     return vec->strs[i];
     if (i >= vec->maxsize)
         svector_resize (vec, i);
     return vec->strs[i];


@@ -198,7 +216,8 @@ svector_at (svector_t vec, size_t i) {
  * The caller can replace the contents of the return address.
  */
 char **
  * The caller can replace the contents of the return address.
  */
 char **

-svector_find (svector_t vec, const char *s) {
+svector_find (svector_t vec, const char *s)
+{

     size_t i;
     char **str = vec->strs;
 
     size_t i;
     char **str = vec->strs;
 


@@ -212,17 +231,20 @@ svector_find (svector_t vec, const char *s) {
 }
 
 char **
 }
 
 char **

-svector_strs (svector_t vec) {
+svector_strs (svector_t vec)
+{

     return vec->strs;
 }
 
 size_t
     return vec->strs;
 }
 
 size_t

-svector_size (svector_t vec) {
+svector_size (svector_t vec)
+{

     return vec->size;
 }
 
 static void
     return vec->size;
 }
 
 static void

-svector_resize (svector_t vec, size_t maxsize) {
+svector_resize (svector_t vec, size_t maxsize)
+{

     size_t old_maxsize = vec->maxsize;
 
     while ((vec->maxsize *= 2) < maxsize)
     size_t old_maxsize = vec->maxsize;
 
     while ((vec->maxsize *= 2) < maxsize)


@@ -242,7 +264,8 @@ struct ivector {
 static void ivector_resize (ivector_t, size_t);
 
 ivector_t
 static void ivector_resize (ivector_t, size_t);
 
 ivector_t

-ivector_create (size_t init_size) {
+ivector_create (size_t init_size)
+{

     ivector_t vec;
     size_t bytes;
 
     ivector_t vec;
     size_t bytes;
 


@@ -256,34 +279,39 @@ ivector_create (size_t init_size) {
 }
 
 void
 }
 
 void

-ivector_free (ivector_t vec) {
+ivector_free (ivector_t vec)
+{

     free (vec->ints);
     free (vec);
 }
 
 int
     free (vec->ints);
     free (vec);
 }
 
 int

-ivector_push_back (ivector_t vec, int n) {
+ivector_push_back (ivector_t vec, int n)
+{

     if (++vec->size >= vec->maxsize)
         ivector_resize (vec, vec->size);
     return vec->ints[vec->size-1] = n;
 }
 
 int
     if (++vec->size >= vec->maxsize)
         ivector_resize (vec, vec->size);
     return vec->ints[vec->size-1] = n;
 }
 
 int

-ivector_at (ivector_t vec, size_t i) {
+ivector_at (ivector_t vec, size_t i)
+{

     if (i >= vec->maxsize)
         ivector_resize (vec, i);
     return vec->ints[i];
 }
 
 int *
     if (i >= vec->maxsize)
         ivector_resize (vec, i);
     return vec->ints[i];
 }
 
 int *

-ivector_atp (ivector_t vec, size_t i) {
+ivector_atp (ivector_t vec, size_t i)
+{

     if (i >= vec->maxsize)
         ivector_resize (vec, i);
     return &vec->ints[i];
 }
 
 static void
     if (i >= vec->maxsize)
         ivector_resize (vec, i);
     return &vec->ints[i];
 }
 
 static void

-ivector_resize (ivector_t vec, size_t maxsize) {
+ivector_resize (ivector_t vec, size_t maxsize)
+{

     size_t old_maxsize = vec->maxsize;
 
     while ((vec->maxsize *= 2) < maxsize)
     size_t old_maxsize = vec->maxsize;
 
     while ((vec->maxsize *= 2) < maxsize)