Use more clear fuction names.

git-svn-id: https://src.develer.com/svnoss/bertos/trunk@4221 38d2e660-2303-0410-9eaa-f027e97ec537

diff --git a/bertos/cpu/arm/drv/flash_lpc2.c b/bertos/cpu/arm/drv/flash_lpc2.c
index 1f42b92163dc1082613bd3d0861f8993f13e2fe1..a9ffcc67e73828281cccbbf4b1cdced7917377e9 100644 (file)
--- a/bertos/cpu/arm/drv/flash_lpc2.c
+++ b/bertos/cpu/arm/drv/flash_lpc2.c
@@ -217,7 +217,7 @@ static size_t lpc2_flash_writeDirect(struct KBlock *blk, block_idx_t idx, const
                goto flash_error;
 
        if ((fls->blk.priv.flags & KB_WRITE_ONCE) &&
-                       bitarray_blockFull(&lpc2_bitx, idx_sector, erase_group[sector]))
+                       bitarray_isRangeFull(&lpc2_bitx, idx_sector, erase_group[sector]))
        {
                kputs("blocchi pieni\n");
                ASSERT(0);
@@ -226,7 +226,7 @@ static size_t lpc2_flash_writeDirect(struct KBlock *blk, block_idx_t idx, const
 
        bool erase = false;
        if ((fls->blk.priv.flags & KB_WRITE_ONCE) &&
-                       bitarray_blockEmpty(&lpc2_bitx, idx_sector, erase_group[sector]))
+                       bitarray_isRangeEmpty(&lpc2_bitx, idx_sector, erase_group[sector]))
                erase = true;
 
        if (!(fls->blk.priv.flags & KB_WRITE_ONCE))
@@ -253,7 +253,7 @@ static size_t lpc2_flash_writeDirect(struct KBlock *blk, block_idx_t idx, const
 
        if (fls->blk.priv.flags & KB_WRITE_ONCE)
        {
-               if (bitarray_check(&lpc2_bitx, idx))
+               if (bitarray_test(&lpc2_bitx, idx))
                {
                        ASSERT(0);
                        goto flash_error;

diff --git a/bertos/struct/bitarray.h b/bertos/struct/bitarray.h
index 3bbaa8d19cf277b96037f0da96ee4eb4fb76c33a..fdd9b86f91b82600a6475cd48aac584778883257 100644 (file)
--- a/bertos/struct/bitarray.h
+++ b/bertos/struct/bitarray.h
@@ -75,7 +75,7 @@ INLINE void bitarray_clear(BitArray *bitx, int idx)
        bitx->array[page] &= ~BV(bit);
 }
 
-INLINE void bitarray_setOffset(BitArray *bitx, int idx, int offset)
+INLINE void bitarray_setRange(BitArray *bitx, int idx, int offset)
 {
        ASSERT((size_t)idx <= bitx->bitarray_len);
 
@@ -84,7 +84,7 @@ INLINE void bitarray_setOffset(BitArray *bitx, int idx, int offset)
 }
 
 
-INLINE void bitarray_clearOffset(BitArray *bitx, int idx, int offset)
+INLINE void bitarray_clearRange(BitArray *bitx, int idx, int offset)
 {
        ASSERT((size_t)idx <= bitx->bitarray_len);
 
@@ -92,7 +92,7 @@ INLINE void bitarray_clearOffset(BitArray *bitx, int idx, int offset)
                bitarray_clear(bitx, i);
 }
 
-INLINE bool bitarray_check(BitArray *bitx, int idx)
+INLINE bool bitarray_test(BitArray *bitx, int idx)
 {
        ASSERT((size_t)idx <= bitx->bitarray_len);
        int page = idx / 8;
@@ -104,7 +104,7 @@ INLINE bool bitarray_check(BitArray *bitx, int idx)
 /*
  * Ugly!.. reformat it.
  */
-INLINE bool bitarray_full(BitArray *bitx)
+INLINE bool bitarray_isFull(BitArray *bitx)
 {
        int count = bitx->size;
        for (size_t page = 0; page <= bitx->size / 8; page++)
@@ -112,7 +112,7 @@ INLINE bool bitarray_full(BitArray *bitx)
                if (count < 8)
                {
                        for (size_t i = page * 8; i <= bitx->bitarray_len; i++)
-                               if (!bitarray_check(bitx, i))
+                               if (!bitarray_test(bitx, i))
                                        return 0;
                                count--;
                }
@@ -130,12 +130,12 @@ INLINE bool bitarray_full(BitArray *bitx)
 /*
  * Ugly!.. reformat it.
  */
-INLINE bool bitarray_blockFull(BitArray *bitx, int idx, int offset)
+INLINE bool bitarray_isRangeFull(BitArray *bitx, int idx, int offset)
 {
        ASSERT((size_t)(idx + offset) <= bitx->bitarray_len);
 
        for (int i = idx; i <= idx + offset; i++)
-               if (!bitarray_check(bitx, i))
+               if (!bitarray_test(bitx, i))
                        return 0;
 
        return 1;
@@ -144,12 +144,12 @@ INLINE bool bitarray_blockFull(BitArray *bitx, int idx, int offset)
 /*
  * Ugly!.. reformat it.
  */
-INLINE bool bitarray_blockEmpty(BitArray *bitx, int idx, int offset)
+INLINE bool bitarray_isRangeEmpty(BitArray *bitx, int idx, int offset)
 {
        ASSERT((size_t)(idx + offset) <= bitx->bitarray_len);
 
        for (int i = idx; i <= idx + offset; i++)
-               if (bitarray_check(bitx, i))
+               if (bitarray_test(bitx, i))
                        return 0;
 
        return 1;
@@ -166,7 +166,7 @@ INLINE void bitarray_dump(BitArray *bitx)
 
        while (count--)
        {
-               kprintf("%d", bitarray_check(bitx, i++));
+               kprintf("%d", bitarray_test(bitx, i++));
                if (j == 7)
                {
                        kprintf("..%02x [%d]\n", bitx->array[(i / 8) - 1], i);

diff --git a/bertos/struct/bitarray_test.c b/bertos/struct/bitarray_test.c
index e65aa146a1e6b7ba4d372e1b2ae0fa346eca4608..250977de4c24ce9070d3a3c5180dfe0d701db284 100644 (file)
--- a/bertos/struct/bitarray_test.c
+++ b/bertos/struct/bitarray_test.c
@@ -67,7 +67,7 @@ int bitarray_testRun(void)
        bitarray_dump(&bitx1);
        for (size_t i = 0; i < TEST1_LEN; i++)
        {
-               if (!((bool)(i % 2) == bitarray_check(&bitx1,i)))
+               if (!((bool)(i % 2) == bitarray_test(&bitx1,i)))
                        goto error;
        }
 
@@ -83,38 +83,38 @@ int bitarray_testRun(void)
        bitarray_dump(&bitx1);
        for (size_t i = 0; i < TEST1_LEN; i++)
        {
-               if (!((bool)(i % 2) == bitarray_check(&bitx1, i)))
+               if (!((bool)(i % 2) == bitarray_test(&bitx1, i)))
                goto error;
        }
 
        memset(test1, 0, sizeof(test1));
        bitarray_set(&bitx1, 0);
        bitarray_dump(&bitx1);
-       if (!bitarray_check(&bitx1, 0))
+       if (!bitarray_test(&bitx1, 0))
                goto error;
 
        memset(test1, 0, sizeof(test1));
        bitarray_set(&bitx1, TEST1_LEN);
        bitarray_dump(&bitx1);
-       if (!bitarray_check(&bitx1, TEST1_LEN))
+       if (!bitarray_test(&bitx1, TEST1_LEN))
                goto error;
 
        kprintf("Test 2\n");
        memset(test2, 0xFF, sizeof(test2));
        bitarray_dump(&bitx2);
-       if (!bitarray_full(&bitx2))
+       if (!bitarray_isFull(&bitx2))
                goto error;
 
        memset(test2, 0xFF, sizeof(test2));
        bitarray_clear(&bitx2, 5);
        bitarray_dump(&bitx2);
-       if (bitarray_full(&bitx2))
+       if (bitarray_isFull(&bitx2))
                goto error;
 
        memset(test2, 0xFF, sizeof(test2));
        bitarray_clear(&bitx2, 13);
        bitarray_dump(&bitx2);
-       if (bitarray_full(&bitx2))
+       if (bitarray_isFull(&bitx2))
                goto error;
 
        return 0;