Changeset c24b0dcb in mainline for uspace/lib/c/generic/capa.c

Timestamp:

2019-09-30T16:38:33Z (5 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

8f57fb2

Parents:

ef0a3375

git-author:

Jakub Jermar <jakub@…> (2019-09-30 16:34:10)

git-committer:

Jakub Jermar <jakub@…> (2019-09-30 16:38:33)

Message:

Rename capacity-related 'cap' to 'capa'

This allows to use 'cap' for capabilities.

File:

• uspace/lib/c/generic/capa.c (moved) (moved from uspace/lib/c/generic/cap.c ) (15 diffs)

uspace/lib/c/generic/capa.c

@@ -34 +34 @@
  */
 
-#include <cap.h>
+#include <capa.h>
 #include <errno.h>
 #include <imath.h>
@@ -43 +43 @@
 enum {
         /** Simplified capacity maximum integer digits */
-        scap_max_idig = 3,
+        scapa_max_idig = 3,
         /** Simplified capacity maximum significant digits */
-        scap_max_sdig = 4
+        scapa_max_sdig = 4
 };
 
@@ -60 +60 @@
 };
 
-void cap_from_blocks(uint64_t nblocks, size_t block_size, cap_spec_t *cap)
+void capa_from_blocks(uint64_t nblocks, size_t block_size, capa_spec_t *capa)
 {
         uint64_t tsize;
 
         tsize = nblocks * block_size;
-        cap->m = tsize;
-        cap->dp = 0;
-        cap->cunit = cu_byte;
+        capa->m = tsize;
+        capa->dp = 0;
+        capa->cunit = cu_byte;
 }
 
@@ -81 +81 @@
  * and @c cv_max gives the maximum value.
  */
-errno_t cap_to_blocks(cap_spec_t *cap, cap_vsel_t cvsel, size_t block_size,
+errno_t capa_to_blocks(capa_spec_t *capa, capa_vsel_t cvsel, size_t block_size,
     uint64_t *rblocks)
 {
@@ -92 +92 @@
         errno_t rc;
 
-        exp = cap->cunit * 3 - cap->dp;
+        exp = capa->cunit * 3 - capa->dp;
         if (exp < 0) {
                 rc = ipow10_u64(-exp, &f);
                 if (rc != EOK)
                         return ERANGE;
-                bytes = (cap->m + (f / 2)) / f;
-                if (bytes * f - (f / 2) != cap->m)
+                bytes = (capa->m + (f / 2)) / f;
+                if (bytes * f - (f / 2) != capa->m)
                         return ERANGE;
         } else {
@@ -118 +118 @@
                 }
 
-                bytes = cap->m * f + adj;
-                if ((bytes - adj) / f != cap->m)
+                bytes = capa->m * f + adj;
+                if ((bytes - adj) / f != capa->m)
                         return ERANGE;
         }
@@ -138 +138 @@
  * digits and at most two fractional digits, e.g abc.xy <unit>.
  */
-void cap_simplify(cap_spec_t *cap)
+void capa_simplify(capa_spec_t *capa)
 {
         uint64_t div;
@@ -146 +146 @@
         errno_t rc;
 
-        /* Change units so that we have at most @c scap_max_idig integer digits */
-        rc = ipow10_u64(scap_max_idig, &maxv);
+        /* Change units so that we have at most @c scapa_max_idig integer digits */
+        rc = ipow10_u64(scapa_max_idig, &maxv);
         assert(rc == EOK);
 
-        rc = ipow10_u64(cap->dp, &div);
+        rc = ipow10_u64(capa->dp, &div);
         assert(rc == EOK);
 
-        while (cap->m / div >= maxv) {
-                ++cap->cunit;
-                cap->dp += 3;
+        while (capa->m / div >= maxv) {
+                ++capa->cunit;
+                capa->dp += 3;
                 div = div * 1000;
         }
 
-        /* Round the number so that we have at most @c scap_max_sdig significant digits */
-        sdig = 1 + ilog10_u64(cap->m); /* number of significant digits */
-        if (sdig > scap_max_sdig) {
+        /* Round the number so that we have at most @c scapa_max_sdig significant digits */
+        sdig = 1 + ilog10_u64(capa->m); /* number of significant digits */
+        if (sdig > scapa_max_sdig) {
                 /* Number of digits to remove */
-                rdig = sdig - scap_max_sdig;
-                if (rdig > cap->dp)
-                        rdig = cap->dp;
+                rdig = sdig - scapa_max_sdig;
+                if (rdig > capa->dp)
+                        rdig = capa->dp;
 
                 rc = ipow10_u64(rdig, &div);
                 assert(rc == EOK);
 
-                cap->m = (cap->m + (div / 2)) / div;
-                cap->dp -= rdig;
-        }
-}
-
-errno_t cap_format(cap_spec_t *cap, char **rstr)
+                capa->m = (capa->m + (div / 2)) / div;
+                capa->dp -= rdig;
+        }
+}
+
+errno_t capa_format(capa_spec_t *capa, char **rstr)
 {
         errno_t rc;
@@ -186 +186 @@
         sunit = NULL;
 
-        assert(cap->cunit < CU_LIMIT);
-
-        rc = ipow10_u64(cap->dp, &div);
+        assert(capa->cunit < CU_LIMIT);
+
+        rc = ipow10_u64(capa->dp, &div);
         if (rc != EOK)
                 return rc;
 
-        ipart = cap->m / div;
-        fpart = cap->m % div;
-
-        sunit = cu_str[cap->cunit];
-        if (cap->dp > 0) {
+        ipart = capa->m / div;
+        fpart = capa->m % div;
+
+        sunit = cu_str[capa->cunit];
+        if (capa->dp > 0) {
                 ret = asprintf(rstr, "%" PRIu64 ".%0*" PRIu64 " %s", ipart,
-                    (int)cap->dp, fpart, sunit);
+                    (int)capa->dp, fpart, sunit);
         } else {
                 ret = asprintf(rstr, "%" PRIu64 " %s", ipart, sunit);
@@ -208 +208 @@
 }
 
-static errno_t cap_digit_val(char c, int *val)
+static errno_t capa_digit_val(char c, int *val)
 {
         switch (c) {
@@ -248 +248 @@
 }
 
-errno_t cap_parse(const char *str, cap_spec_t *cap)
+errno_t capa_parse(const char *str, capa_spec_t *capa)
 {
         const char *eptr;
@@ -260 +260 @@
 
         eptr = str;
-        while (cap_digit_val(*eptr, &d) == EOK) {
+        while (capa_digit_val(*eptr, &d) == EOK) {
                 m = m * 10 + d;
                 ++eptr;
@@ -268 +268 @@
                 ++eptr;
                 dp = 0;
-                while (cap_digit_val(*eptr, &d) == EOK) {
+                while (capa_digit_val(*eptr, &d) == EOK) {
                         m = m * 10 + d;
                         ++dp;
@@ -281 +281 @@
 
         if (*eptr == '\0') {
-                cap->cunit = cu_byte;
+                capa->cunit = cu_byte;
         } else {
                 for (i = 0; i < CU_LIMIT; i++) {
@@ -296 +296 @@
                 return EINVAL;
         found:
-                cap->cunit = i;
-        }
-
-        cap->m = m;
-        cap->dp = dp;
+                capa->cunit = i;
+        }
+
+        capa->m = m;
+        capa->dp = dp;
         return EOK;
 }