Index: uspace/lib/bithenge/include/bithenge/blob.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/blob.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/blob.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -53,10 +53,10 @@
 typedef struct bithenge_random_access_blob_ops_t {
 	/** @copydoc bithenge_blob_t::bithenge_blob_size */
-	int (*size)(bithenge_blob_t *self, aoff64_t *size);
+	errno_t (*size)(bithenge_blob_t *self, aoff64_t *size);
 	/** @copydoc bithenge_blob_t::bithenge_blob_read */
-	int (*read)(bithenge_blob_t *self, aoff64_t offset, char *buffer,
+	errno_t (*read)(bithenge_blob_t *self, aoff64_t offset, char *buffer,
 	    aoff64_t *size);
 	/** @copydoc bithenge_blob_t::bithenge_blob_read_bits */
-	int (*read_bits)(bithenge_blob_t *self, aoff64_t offset, char *buffer,
+	errno_t (*read_bits)(bithenge_blob_t *self, aoff64_t offset, char *buffer,
 	    aoff64_t *size, bool little_endian);
 	/** Destroy the blob.
@@ -94,5 +94,5 @@
 	 * @return EOK on success or an error code from errno.h.
 	 */
-	int (*size)(bithenge_sequential_blob_t *self, aoff64_t *size);
+	errno_t (*size)(bithenge_sequential_blob_t *self, aoff64_t *size);
 
 	/** Read the next part of the blob. If the requested data extends
@@ -108,5 +108,5 @@
 	 * @return EOK on success or an error code from errno.h.
 	 */
-	int (*read)(bithenge_sequential_blob_t *self, char *buffer,
+	errno_t (*read)(bithenge_sequential_blob_t *self, char *buffer,
 	    aoff64_t *size);
 
@@ -123,5 +123,5 @@
  * @return EOK on success or an error code from errno.h.
  */
-static inline int bithenge_blob_size(bithenge_blob_t *self, aoff64_t *size)
+static inline errno_t bithenge_blob_size(bithenge_blob_t *self, aoff64_t *size)
 {
 	assert(self);
@@ -145,5 +145,5 @@
  * @return EOK on success or an error code from errno.h.
  */
-static inline int bithenge_blob_read(bithenge_blob_t *self, aoff64_t offset,
+static inline errno_t bithenge_blob_read(bithenge_blob_t *self, aoff64_t offset,
     char *buffer, aoff64_t *size)
 {
@@ -173,5 +173,5 @@
  * @return EOK on success or an error code from errno.h.
  */
-static inline int bithenge_blob_read_bits(bithenge_blob_t *self,
+static inline errno_t bithenge_blob_read_bits(bithenge_blob_t *self,
     aoff64_t offset, char *buffer, aoff64_t *size, bool little_endian)
 {
@@ -190,10 +190,10 @@
  * @param[out] out Holds whether the blob is empty.
  * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_blob_empty(bithenge_blob_t *self, bool *out)
+static inline errno_t bithenge_blob_empty(bithenge_blob_t *self, bool *out)
 {
 	assert(self);
 	assert(self->base.blob_ops);
 	aoff64_t size;
-	int rc = bithenge_blob_size(self, &size);
+	errno_t rc = bithenge_blob_size(self, &size);
 	*out = size == 0;
 	return rc;
@@ -235,19 +235,19 @@
 
 /** @memberof bithenge_blob_t */
-int bithenge_init_random_access_blob(bithenge_blob_t *,
+errno_t bithenge_init_random_access_blob(bithenge_blob_t *,
     const bithenge_random_access_blob_ops_t *);
 /** @memberof bithenge_sequential_blob_t */
-int bithenge_init_sequential_blob(bithenge_sequential_blob_t *,
+errno_t bithenge_init_sequential_blob(bithenge_sequential_blob_t *,
     const bithenge_sequential_blob_ops_t *);
 /** @memberof bithenge_blob_t */
-int bithenge_new_blob_from_data(bithenge_node_t **, const void *, size_t);
-/** @memberof bithenge_blob_t */
-int bithenge_new_blob_from_buffer(bithenge_node_t **, const void *, size_t,
+errno_t bithenge_new_blob_from_data(bithenge_node_t **, const void *, size_t);
+/** @memberof bithenge_blob_t */
+errno_t bithenge_new_blob_from_buffer(bithenge_node_t **, const void *, size_t,
     bool);
-int bithenge_new_offset_blob(bithenge_node_t **, bithenge_blob_t *, aoff64_t);
-int bithenge_new_subblob(bithenge_node_t **, bithenge_blob_t *, aoff64_t,
+errno_t bithenge_new_offset_blob(bithenge_node_t **, bithenge_blob_t *, aoff64_t);
+errno_t bithenge_new_subblob(bithenge_node_t **, bithenge_blob_t *, aoff64_t,
     aoff64_t);
 /** @memberof bithenge_blob_t */
-int bithenge_blob_equal(bool *, bithenge_blob_t *, bithenge_blob_t *);
+errno_t bithenge_blob_equal(bool *, bithenge_blob_t *, bithenge_blob_t *);
 
 #endif
Index: uspace/lib/bithenge/include/bithenge/compound.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/compound.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/compound.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -41,9 +41,9 @@
 #include "transform.h"
 
-int bithenge_new_composed_transform(bithenge_transform_t **,
+errno_t bithenge_new_composed_transform(bithenge_transform_t **,
     bithenge_transform_t **, size_t);
-int bithenge_if_transform(bithenge_transform_t **, bithenge_expression_t *,
+errno_t bithenge_if_transform(bithenge_transform_t **, bithenge_expression_t *,
     bithenge_transform_t *, bithenge_transform_t *);
-int bithenge_partial_transform(bithenge_transform_t **,
+errno_t bithenge_partial_transform(bithenge_transform_t **,
     bithenge_transform_t *);
 
Index: uspace/lib/bithenge/include/bithenge/expression.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/expression.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/expression.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -52,5 +52,5 @@
 typedef struct bithenge_expression_ops {
 	/** @copydoc bithenge_expression_t::bithenge_expression_evaluate */
-	int (*evaluate)(bithenge_expression_t *self, bithenge_scope_t *scope,
+	errno_t (*evaluate)(bithenge_expression_t *self, bithenge_scope_t *scope,
 	    bithenge_node_t **out);
 	/** Destroy the expression.
@@ -85,5 +85,5 @@
  * @param[out] out Where the output tree will be stored.
  * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_expression_evaluate(bithenge_expression_t *self,
+static inline errno_t bithenge_expression_evaluate(bithenge_expression_t *self,
     bithenge_scope_t *scope, bithenge_node_t **out)
 {
@@ -117,27 +117,27 @@
 } bithenge_binary_op_t;
 
-int bithenge_init_expression(bithenge_expression_t *,
+errno_t bithenge_init_expression(bithenge_expression_t *,
     const bithenge_expression_ops_t *);
-int bithenge_binary_expression(bithenge_expression_t **, bithenge_binary_op_t,
+errno_t bithenge_binary_expression(bithenge_expression_t **, bithenge_binary_op_t,
     bithenge_expression_t *, bithenge_expression_t *);
-int bithenge_in_node_expression(bithenge_expression_t **);
-int bithenge_current_node_expression(bithenge_expression_t **);
-int bithenge_param_expression(bithenge_expression_t **, int);
-int bithenge_const_expression(bithenge_expression_t **, bithenge_node_t *);
-int bithenge_scope_member_expression(bithenge_expression_t **,
+errno_t bithenge_in_node_expression(bithenge_expression_t **);
+errno_t bithenge_current_node_expression(bithenge_expression_t **);
+errno_t bithenge_param_expression(bithenge_expression_t **, int);
+errno_t bithenge_const_expression(bithenge_expression_t **, bithenge_node_t *);
+errno_t bithenge_scope_member_expression(bithenge_expression_t **,
     bithenge_node_t *);
-int bithenge_subblob_expression(bithenge_expression_t **,
+errno_t bithenge_subblob_expression(bithenge_expression_t **,
     bithenge_expression_t *, bithenge_expression_t *, bithenge_expression_t *,
     bool);
-int bithenge_param_wrapper(bithenge_transform_t **, bithenge_transform_t *,
+errno_t bithenge_param_wrapper(bithenge_transform_t **, bithenge_transform_t *,
     bithenge_expression_t **);
-int bithenge_expression_transform(bithenge_transform_t **,
+errno_t bithenge_expression_transform(bithenge_transform_t **,
     bithenge_expression_t *);
-int bithenge_inputless_transform(bithenge_transform_t **,
+errno_t bithenge_inputless_transform(bithenge_transform_t **,
     bithenge_expression_t *);
 
-int bithenge_concat_blob(bithenge_node_t **, bithenge_blob_t *,
+errno_t bithenge_concat_blob(bithenge_node_t **, bithenge_blob_t *,
     bithenge_blob_t *);
-int bithenge_concat_blob_lazy(bithenge_node_t **, bithenge_blob_t *,
+errno_t bithenge_concat_blob_lazy(bithenge_node_t **, bithenge_blob_t *,
     bithenge_expression_t *, bithenge_scope_t *);
 
Index: uspace/lib/bithenge/include/bithenge/file.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/file.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/file.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -41,7 +41,7 @@
 #include "blob.h"
 
-int bithenge_new_file_blob(bithenge_node_t **, const char *);
-int bithenge_new_file_blob_from_fd(bithenge_node_t **, int);
-int bithenge_new_file_blob_from_file(bithenge_node_t **, FILE *);
+errno_t bithenge_new_file_blob(bithenge_node_t **, const char *);
+errno_t bithenge_new_file_blob_from_fd(bithenge_node_t **, int);
+errno_t bithenge_new_file_blob_from_file(bithenge_node_t **, FILE *);
 
 #endif
Index: uspace/lib/bithenge/include/bithenge/print.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/print.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/print.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -50,6 +50,6 @@
 } bithenge_print_type_t;
 
-int bithenge_print_node(bithenge_print_type_t, bithenge_node_t *);
-int bithenge_print_node_to_string(char **, size_t *, bithenge_print_type_t,
+errno_t bithenge_print_node(bithenge_print_type_t, bithenge_node_t *);
+errno_t bithenge_print_node_to_string(char **, size_t *, bithenge_print_type_t,
     bithenge_node_t *);
 
Index: uspace/lib/bithenge/include/bithenge/script.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/script.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/script.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -40,5 +40,5 @@
 #include "transform.h"
 
-int bithenge_parse_script(const char *, bithenge_transform_t **);
+errno_t bithenge_parse_script(const char *, bithenge_transform_t **);
 
 #endif
Index: uspace/lib/bithenge/include/bithenge/sequence.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/sequence.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/sequence.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -40,9 +40,9 @@
 #include "transform.h"
 
-int bithenge_new_struct(bithenge_transform_t **,
+errno_t bithenge_new_struct(bithenge_transform_t **,
     bithenge_named_transform_t *);
-int bithenge_repeat_transform(bithenge_transform_t **, bithenge_transform_t *,
+errno_t bithenge_repeat_transform(bithenge_transform_t **, bithenge_transform_t *,
     bithenge_expression_t *);
-int bithenge_do_while_transform(bithenge_transform_t **,
+errno_t bithenge_do_while_transform(bithenge_transform_t **,
     bithenge_transform_t *, bithenge_expression_t *);
 
Index: uspace/lib/bithenge/include/bithenge/source.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/source.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/source.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -40,5 +40,5 @@
 #include "tree.h"
 
-int bithenge_node_from_source(bithenge_node_t **, const char *);
+errno_t bithenge_node_from_source(bithenge_node_t **, const char *);
 
 #endif
Index: uspace/lib/bithenge/include/bithenge/transform.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/transform.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/transform.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -76,11 +76,11 @@
 typedef struct bithenge_transform_ops {
 	/** @copydoc bithenge_transform_t::bithenge_transform_apply */
-	int (*apply)(bithenge_transform_t *self, bithenge_scope_t *scope,
+	errno_t (*apply)(bithenge_transform_t *self, bithenge_scope_t *scope,
 	    bithenge_node_t *in, bithenge_node_t **out);
 	/** @copydoc bithenge_transform_t::bithenge_transform_prefix_length */
-	int (*prefix_length)(bithenge_transform_t *self,
+	errno_t (*prefix_length)(bithenge_transform_t *self,
 	    bithenge_scope_t *scope, bithenge_blob_t *blob, aoff64_t *out);
 	/** @copydoc bithenge_transform_t::bithenge_transform_prefix_apply */
-	int (*prefix_apply)(bithenge_transform_t *self,
+	errno_t (*prefix_apply)(bithenge_transform_t *self,
 	    bithenge_scope_t *scope, bithenge_blob_t *blob,
 	    bithenge_node_t **out_node, aoff64_t *out_size);
@@ -158,21 +158,21 @@
 
 /** @memberof bithenge_transform_t */
-int bithenge_init_transform(bithenge_transform_t *,
+errno_t bithenge_init_transform(bithenge_transform_t *,
     const bithenge_transform_ops_t *, int);
 /** @memberof bithenge_transform_t */
-int bithenge_transform_apply(bithenge_transform_t *, bithenge_scope_t *,
+errno_t bithenge_transform_apply(bithenge_transform_t *, bithenge_scope_t *,
     bithenge_node_t *, bithenge_node_t **);
 /** @memberof bithenge_transform_t */
-int bithenge_transform_prefix_length(bithenge_transform_t *,
+errno_t bithenge_transform_prefix_length(bithenge_transform_t *,
     bithenge_scope_t *, bithenge_blob_t *, aoff64_t *);
 /** @memberof bithenge_transform_t */
-int bithenge_transform_prefix_apply(bithenge_transform_t *, bithenge_scope_t *,
+errno_t bithenge_transform_prefix_apply(bithenge_transform_t *, bithenge_scope_t *,
     bithenge_blob_t *, bithenge_node_t **, aoff64_t *);
-int bithenge_new_barrier_transform(bithenge_transform_t **, int);
-int bithenge_barrier_transform_set_subtransform(bithenge_transform_t *,
+errno_t bithenge_new_barrier_transform(bithenge_transform_t **, int);
+errno_t bithenge_barrier_transform_set_subtransform(bithenge_transform_t *,
     bithenge_transform_t *);
 
 /** @memberof bithenge_scope_t */
-int bithenge_scope_new(bithenge_scope_t **, bithenge_scope_t *);
+errno_t bithenge_scope_new(bithenge_scope_t **, bithenge_scope_t *);
 /** @memberof bithenge_scope_t */
 void bithenge_scope_dec_ref(bithenge_scope_t *);
@@ -182,5 +182,5 @@
 const char *bithenge_scope_get_error(bithenge_scope_t *);
 /** @memberof bithenge_scope_t */
-int bithenge_scope_error(bithenge_scope_t *, const char *, ...);
+errno_t bithenge_scope_error(bithenge_scope_t *, const char *, ...);
 /** @memberof bithenge_scope_t */
 bithenge_node_t *bithenge_scope_get_current_node(bithenge_scope_t *);
@@ -196,9 +196,9 @@
 bool bithenge_scope_is_barrier(bithenge_scope_t *);
 /** @memberof bithenge_scope_t */
-int bithenge_scope_alloc_params(bithenge_scope_t *, int);
-/** @memberof bithenge_scope_t */
-int bithenge_scope_set_param(bithenge_scope_t *, int, bithenge_node_t *);
-/** @memberof bithenge_scope_t */
-int bithenge_scope_get_param(bithenge_scope_t *, int, bithenge_node_t **);
+errno_t bithenge_scope_alloc_params(bithenge_scope_t *, int);
+/** @memberof bithenge_scope_t */
+errno_t bithenge_scope_set_param(bithenge_scope_t *, int, bithenge_node_t *);
+/** @memberof bithenge_scope_t */
+errno_t bithenge_scope_get_param(bithenge_scope_t *, int, bithenge_node_t **);
 
 #endif
Index: uspace/lib/bithenge/include/bithenge/tree.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/tree.h	(revision 23c8acd9c09f549990f7478985878578dc75e2f3)
+++ uspace/lib/bithenge/include/bithenge/tree.h	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -81,12 +81,12 @@
  * @param data Data provided to @a bithenge_node_t::bithenge_node_for_each.
  * @return EOK on success or an error code from errno.h. */
-typedef int (*bithenge_for_each_func_t)(bithenge_node_t *key, bithenge_node_t *value, void *data);
+typedef errno_t (*bithenge_for_each_func_t)(bithenge_node_t *key, bithenge_node_t *value, void *data);
 
 /** Operations providing access to an internal node. */
 typedef struct bithenge_internal_node_ops_t {
 	/** @copydoc bithenge_node_t::bithenge_node_for_each */
-	int (*for_each)(bithenge_node_t *self, bithenge_for_each_func_t func, void *data);
+	errno_t (*for_each)(bithenge_node_t *self, bithenge_for_each_func_t func, void *data);
 	/** @copydoc bithenge_node_t::bithenge_node_get */
-	int (*get)(bithenge_node_t *self, bithenge_node_t *key,
+	errno_t (*get)(bithenge_node_t *self, bithenge_node_t *key,
 	    bithenge_node_t **out);
 	/** Destroys the internal node.
@@ -122,5 +122,5 @@
  * @param data Data to provide to the callback function.
  * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_node_for_each(bithenge_node_t *self,
+static inline errno_t bithenge_node_for_each(bithenge_node_t *self,
     bithenge_for_each_func_t func, void *data)
 {
@@ -130,5 +130,5 @@
 
 /** @memberof bithenge_node_t */
-int bithenge_node_get(bithenge_node_t *, bithenge_node_t *,
+errno_t bithenge_node_get(bithenge_node_t *, bithenge_node_t *,
     bithenge_node_t **);
 
@@ -164,19 +164,19 @@
 
 /** @memberof bithenge_node_t */
-int bithenge_init_internal_node(bithenge_node_t *,
+errno_t bithenge_init_internal_node(bithenge_node_t *,
     const bithenge_internal_node_ops_t *);
 /** @memberof bithenge_node_t */
-int bithenge_new_empty_internal_node(bithenge_node_t **);
+errno_t bithenge_new_empty_internal_node(bithenge_node_t **);
 /** @memberof bithenge_node_t */
-int bithenge_new_simple_internal_node(bithenge_node_t **, bithenge_node_t **,
+errno_t bithenge_new_simple_internal_node(bithenge_node_t **, bithenge_node_t **,
     bithenge_int_t, bool needs_free);
 /** @memberof bithenge_node_t */
-int bithenge_new_boolean_node(bithenge_node_t **, bool);
+errno_t bithenge_new_boolean_node(bithenge_node_t **, bool);
 /** @memberof bithenge_node_t */
-int bithenge_new_integer_node(bithenge_node_t **, bithenge_int_t);
+errno_t bithenge_new_integer_node(bithenge_node_t **, bithenge_int_t);
 /** @memberof bithenge_node_t */
-int bithenge_new_string_node(bithenge_node_t **, const char *, bool);
+errno_t bithenge_new_string_node(bithenge_node_t **, const char *, bool);
 /** @memberof bithenge_node_t */
-int bithenge_node_equal(bool *, bithenge_node_t *, bithenge_node_t *);
+errno_t bithenge_node_equal(bool *, bithenge_node_t *, bithenge_node_t *);
 
 #endif