Changeset a35b458 in mainline for kernel/generic/src/adt/bitmap.c

Timestamp:

2018-03-02T20:10:49Z (7 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f1380b7

Parents:

3061bc1

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)

Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:

• kernel/generic/src/adt/bitmap.c (modified) (17 diffs)

kernel/generic/src/adt/bitmap.c

@@ -62 +62 @@
         size_t byte = element / BITMAP_ELEMENT;
         uint8_t mask = 1 << (element & BITMAP_REMAINER);
-        
+
         return !!((bitmap->bits)[byte] & mask);
 }
@@ -78 +78 @@
 {
         size_t size = elements / BITMAP_ELEMENT;
-        
+
         if ((elements % BITMAP_ELEMENT) != 0)
                 size++;
-        
+
         return size;
 }
@@ -113 +113 @@
 {
         assert(start + count <= bitmap->elements);
-        
+
         if (count == 0)
                 return;
-        
+
         size_t start_byte = start / BITMAP_ELEMENT;
         size_t aligned_start = ALIGN_UP(start, BITMAP_ELEMENT);
-        
+
         /* Leading unaligned bits */
         size_t lub = min(aligned_start - start, count);
-        
+
         /* Aligned middle bits */
         size_t amb = (count > lub) ? (count - lub) : 0;
-        
+
         /* Trailing aligned bits */
         size_t tab = amb % BITMAP_ELEMENT;
-        
+
         if (start + count < aligned_start) {
                 /* Set bits in the middle of byte. */
@@ -135 +135 @@
                 return;
         }
-        
+
         if (lub) {
                 /* Make sure to set any leading unaligned bits. */
@@ -141 +141 @@
                     ~((1 << (BITMAP_ELEMENT - lub)) - 1);
         }
-        
+
         size_t i;
-        
+
         for (i = 0; i < amb / BITMAP_ELEMENT; i++) {
                 /* The middle bits can be set byte by byte. */
@@ -149 +149 @@
                     ALL_ONES;
         }
-        
+
         if (tab) {
                 /* Make sure to set any trailing aligned bits. */
@@ -167 +167 @@
 {
         assert(start + count <= bitmap->elements);
-        
+
         if (count == 0)
                 return;
-        
+
         size_t start_byte = start / BITMAP_ELEMENT;
         size_t aligned_start = ALIGN_UP(start, BITMAP_ELEMENT);
-        
+
         /* Leading unaligned bits */
         size_t lub = min(aligned_start - start, count);
-        
+
         /* Aligned middle bits */
         size_t amb = (count > lub) ? (count - lub) : 0;
-        
+
         /* Trailing aligned bits */
         size_t tab = amb % BITMAP_ELEMENT;
-        
+
         if (start + count < aligned_start) {
                 /* Set bits in the middle of byte */
@@ -189 +189 @@
                 return;
         }
-        
+
         if (lub) {
                 /* Make sure to clear any leading unaligned bits. */
@@ -195 +195 @@
                     (1 << (BITMAP_ELEMENT - lub)) - 1;
         }
-        
+
         size_t i;
-        
+
         for (i = 0; i < amb / BITMAP_ELEMENT; i++) {
                 /* The middle bits can be cleared byte by byte. */
@@ -203 +203 @@
                     ALL_ZEROES;
         }
-        
+
         if (tab) {
                 /* Make sure to clear any trailing aligned bits. */
@@ -209 +209 @@
                     ~((1 << tab) - 1);
         }
-        
+
         bitmap->next_fit = start_byte;
 }
@@ -224 +224 @@
         assert(count <= dst->elements);
         assert(count <= src->elements);
-        
+
         size_t i;
-        
+
         for (i = 0; i < count / BITMAP_ELEMENT; i++)
                 dst->bits[i] = src->bits[i];
-        
+
         if (count % BITMAP_ELEMENT) {
                 bitmap_clear_range(dst, i * BITMAP_ELEMENT,
@@ -274 +274 @@
         if (count == 0)
                 return false;
-        
+
         size_t size = bitmap_size(bitmap->elements);
         size_t next_fit = bitmap->next_fit;
-        
+
         /*
          * Adjust the next-fit value according to the address
@@ -284 +284 @@
         if ((prefered > base) && (prefered < base + bitmap->elements)) {
                 size_t prefered_fit = (prefered - base) / BITMAP_ELEMENT;
-                
+
                 if (prefered_fit > next_fit)
                         next_fit = prefered_fit;
         }
-        
+
         for (size_t pos = 0; pos < size; pos++) {
                 size_t byte = (next_fit + pos) % size;
-                
+
                 /* Skip if the current byte has all bits set */
                 if (bitmap->bits[byte] == ALL_ONES)
                         continue;
-                
+
                 size_t byte_bit = byte * BITMAP_ELEMENT;
-                
+
                 for (size_t bit = 0; bit < BITMAP_ELEMENT; bit++) {
                         size_t i = byte_bit + bit;
-                        
+
                         if (i >= bitmap->elements)
                                 break;
-                        
+
                         if (!constraint_satisfy(i, base, constraint))
                                 continue;
-                        
+
                         if (!bitmap_get_fast(bitmap, i)) {
                                 size_t continuous = 1;
-                                
+
                                 for (size_t j = 1; j < count; j++) {
                                         if ((i + j < bitmap->elements) &&
@@ -317 +317 @@
                                                 break;
                                 }
-                                
+
                                 if (continuous == count) {
                                         if (index != NULL) {
@@ -324 +324 @@
                                                 *index = i;
                                         }
-                                        
+
                                         return true;
                                 } else
@@ -331 +331 @@
                 }
         }
-        
+
         return false;
 }