Changeset 84876aa4 in mainline for uspace/lib/c/generic/capa.c

Timestamp:

2019-11-15T13:46:34Z (6 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

ecb7828

Parents:

b093a62 (diff), d548fc0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge master into gfx

Mainly to get XCW fixes

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;
+        /* Change units until we have no more than scapa_max_idig integer digits */
+        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)
+                /* Division with rounding */
+                capa->m = (capa->m + (div / 2)) / div;
+                capa->dp -= rdig;
+        }
+
+        /*
+         * If we rounded up from something like 999.95 to 1000.0,, we still
+         * have more than scapa_max_idig integer digits and need to change
+         * units once more.
+         */
+        rc = ipow10_u64(capa->dp, &div);
+        assert(rc == EOK);
+
+        if (capa->m / div >= 1000) {
+                ++capa->cunit;
+                capa->dp += 3;
+
+                /*
+                 * We now have one more significant digit than we want
+                 * so round to one less digits
+                 */
+                capa->m = (capa->m + 5) / 10;
+                --capa->dp;
+        }
+}
+
+errno_t capa_format(capa_spec_t *capa, char **rstr)
 {
         errno_t rc;
@@ -186 +208 @@
         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);
         }
+
         if (ret < 0)
                 return ENOMEM;
@@ -208 +231 @@
 }
 
-static errno_t cap_digit_val(char c, int *val)
+static errno_t capa_digit_val(char c, int *val)
 {
         switch (c) {
@@ -248 +271 @@
 }
 
-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 +283 @@
 
         eptr = str;
-        while (cap_digit_val(*eptr, &d) == EOK) {
+        while (capa_digit_val(*eptr, &d) == EOK) {
                 m = m * 10 + d;
                 ++eptr;
@@ -268 +291 @@
                 ++eptr;
                 dp = 0;
-                while (cap_digit_val(*eptr, &d) == EOK) {
+                while (capa_digit_val(*eptr, &d) == EOK) {
                         m = m * 10 + d;
                         ++dp;
@@ -281 +304 @@
 
         if (*eptr == '\0') {
-                cap->cunit = cu_byte;
+                capa->cunit = cu_byte;
         } else {
                 for (i = 0; i < CU_LIMIT; i++) {
@@ -296 +319 @@
                 return EINVAL;
         found:
-                cap->cunit = i;
-        }
-
-        cap->m = m;
-        cap->dp = dp;
+                capa->cunit = i;
+        }
+
+        capa->m = m;
+        capa->dp = dp;
         return EOK;
 }