Changeset a35b458 in mainline for uspace/lib/ext4/src/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:

• uspace/lib/ext4/src/bitmap.c (modified) (10 diffs)

uspace/lib/ext4/src/bitmap.c

@@ -52 +52 @@
         uint32_t byte_index = index / 8;
         uint32_t bit_index = index % 8;
-        
+
         uint8_t *target = bitmap + byte_index;
-        
+
         *target &= ~ (1 << bit_index);
 }
@@ -73 +73 @@
         uint32_t remaining = count;
         uint32_t byte_index;
-        
+
         /* Align index to multiple of 8 */
         while (((idx % 8) != 0) && (remaining > 0)) {
                 byte_index = idx / 8;
                 uint32_t bit_index = idx % 8;
-                
+
                 target = bitmap + byte_index;
                 *target &= ~ (1 << bit_index);
-                
+
                 idx++;
                 remaining--;
         }
-        
+
         /* For < 8 bits this check necessary */
         if (remaining == 0)
                 return;
-        
+
         assert((idx % 8) == 0);
-        
+
         byte_index = idx / 8;
         target = bitmap + byte_index;
-        
+
         /* Zero the whole bytes */
         while (remaining >= 8) {
                 *target = 0;
-                
+
                 idx += 8;
                 remaining -= 8;
                 target++;
         }
-        
+
         assert(remaining < 8);
-        
+
         /* Zero remaining bytes */
         while (remaining != 0) {
                 byte_index = idx / 8;
                 uint32_t bit_index = idx % 8;
-                
+
                 target = bitmap + byte_index;
                 *target &= ~ (1 << bit_index);
-                
+
                 idx++;
                 remaining--;
@@ -129 +129 @@
         uint32_t byte_index = index / 8;
         uint32_t bit_index = index % 8;
-        
+
         uint8_t *target = bitmap + byte_index;
-        
+
         *target |= 1 << bit_index;
 }
@@ -147 +147 @@
         uint32_t byte_index = index / 8;
         uint32_t bit_index = index % 8;
-        
+
         uint8_t *target = bitmap + byte_index;
-        
+
         if (*target & (1 << bit_index))
                 return false;
@@ -173 +173 @@
 {
         uint32_t idx;
-        
+
         /* Align idx */
         if (start % 8)
@@ -179 +179 @@
         else
                 idx = start;
-        
+
         uint8_t *pos = bitmap + (idx / 8);
-        
+
         /* Try to find free byte */
         while (idx < max) {
                 if (*pos == 0) {
                         *pos |= 1;
-                        
+
                         *index = idx;
                         return EOK;
                 }
-                
+
                 idx += 8;
                 ++pos;
         }
-        
+
         /* Free byte not found */
         return ENOSPC;
@@ -217 +217 @@
         uint32_t idx = start_idx;
         bool byte_part = false;
-        
+
         /* Check the rest of first byte */
         while ((idx % 8) != 0) {
                 byte_part = true;
-                
+
                 if ((*pos & (1 << (idx % 8))) == 0) {
                         *pos |= (1 << (idx % 8));
@@ -227 +227 @@
                         return EOK;
                 }
-                
+
                 ++idx;
         }
-        
+
         if (byte_part)
                 ++pos;
-        
+
         /* Check the whole bytes (255 = 11111111 binary) */
         while (idx < max) {
@@ -240 +240 @@
                         break;
                 }
-                
+
                 idx += 8;
                 ++pos;
         }
-        
+
         /* If idx < max, some free bit found */
         if (idx < max) {
@@ -252 +252 @@
                                 /* Free bit found */
                                 *pos |= (1 << i);
-                                
+
                                 *index = idx;
                                 return EOK;
                         }
-                        
+
                         idx++;
                 }
         }
-        
+
         /* Free bit not found */
         return ENOSPC;