Changeset b7fd2a0 in mainline for uspace/lib/bithenge/src/tree.c

Timestamp:

2018-01-13T03:10:29Z (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:

a53ed3a

Parents:

36f0738

Message:

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
<sup>git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`</sup>

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.

File:

• uspace/lib/bithenge/src/tree.c (modified) (14 diffs)

uspace/lib/bithenge/src/tree.c

@@ -86 +86 @@
 } get_for_each_data_t;
 
-static int get_for_each_func(bithenge_node_t *key, bithenge_node_t *value,
+static errno_t get_for_each_func(bithenge_node_t *key, bithenge_node_t *value,
     void *raw_data)
 {
         get_for_each_data_t *data = (get_for_each_data_t *)raw_data;
         bool equal;
-        int rc = bithenge_node_equal(&equal, key, data->key);
+        errno_t rc = bithenge_node_equal(&equal, key, data->key);
         bithenge_node_dec_ref(key);
         if (rc != EOK)
@@ -113 +113 @@
  * @return EOK on success, ENOENT if not found, or another error code from
  * errno.h. */
-int bithenge_node_get(bithenge_node_t *self, bithenge_node_t *key,
+errno_t bithenge_node_get(bithenge_node_t *self, bithenge_node_t *key,
     bithenge_node_t **out)
 {
@@ -125 +125 @@
                 uint8_t byte;
                 aoff64_t size = 1;
-                int rc = bithenge_blob_read(bithenge_node_as_blob(self),
+                errno_t rc = bithenge_blob_read(bithenge_node_as_blob(self),
                     offset, (char *)&byte, &size);
                 if (rc != EOK)
@@ -140 +140 @@
         *out = NULL;
         get_for_each_data_t data = {key, out};
-        int rc = bithenge_node_for_each(self, get_for_each_func, &data);
+        errno_t rc = bithenge_node_for_each(self, get_for_each_func, &data);
         bithenge_node_dec_ref(key);
         if (rc == EEXIST && *out)
@@ -155 +155 @@
  * @param[in] ops The operations provided.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_init_internal_node(bithenge_node_t *self,
+errno_t bithenge_init_internal_node(bithenge_node_t *self,
     const bithenge_internal_node_ops_t *ops)
 {
@@ -169 +169 @@
 }
 
-static int empty_internal_node_for_each(bithenge_node_t *base,
+static errno_t empty_internal_node_for_each(bithenge_node_t *base,
     bithenge_for_each_func_t func, void *data)
 {
@@ -175 +175 @@
 }
 
-static int empty_internal_node_get(bithenge_node_t *self, bithenge_node_t *key,
+static errno_t empty_internal_node_get(bithenge_node_t *self, bithenge_node_t *key,
     bithenge_node_t **out)
 {
@@ -196 +196 @@
  * @param[out] out Holds the created node.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_empty_internal_node(bithenge_node_t **out)
+errno_t bithenge_new_empty_internal_node(bithenge_node_t **out)
 {
         if (bithenge_should_fail())
@@ -223 +223 @@
 }
 
-static int simple_internal_node_for_each(bithenge_node_t *base,
+static errno_t simple_internal_node_for_each(bithenge_node_t *base,
     bithenge_for_each_func_t func, void *data)
 {
-        int rc;
+        errno_t rc;
         simple_internal_node_t *self = node_as_simple(base);
         for (bithenge_int_t i = 0; i < self->len; i++) {
@@ -264 +264 @@
  * the nodes array rather than just dereferencing each node inside it.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_simple_internal_node(bithenge_node_t **out,
+errno_t bithenge_new_simple_internal_node(bithenge_node_t **out,
     bithenge_node_t **nodes, bithenge_int_t len, bool needs_free)
 {
-        int rc;
+        errno_t rc;
         assert(out);
         simple_internal_node_t *self = malloc(sizeof(*self));
@@ -300 +300 @@
  * @param value The value for the node to hold.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_boolean_node(bithenge_node_t **out, bool value)
+errno_t bithenge_new_boolean_node(bithenge_node_t **out, bool value)
 {
         assert(out);
@@ -315 +315 @@
  * @param value The value for the node to hold.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_integer_node(bithenge_node_t **out, bithenge_int_t value)
+errno_t bithenge_new_integer_node(bithenge_node_t **out, bithenge_int_t value)
 {
         assert(out);
@@ -335 +335 @@
  * destroyed.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_string_node(bithenge_node_t **out, const char *value, bool needs_free)
+errno_t bithenge_new_string_node(bithenge_node_t **out, const char *value, bool needs_free)
 {
         assert(out);
@@ -359 +359 @@
  * @return EOK on success or an error code from errno.h.
  * @todo Add support for internal nodes. */
-int bithenge_node_equal(bool *out, bithenge_node_t *a, bithenge_node_t *b)
+errno_t bithenge_node_equal(bool *out, bithenge_node_t *a, bithenge_node_t *b)
 {
         if (a->type != b->type) {