Index: uspace/lib/bithenge/include/bithenge/blob.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/blob.h	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/include/bithenge/blob.h	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -43,5 +43,6 @@
 
 /** A blob of raw binary data.
- * @implements bithenge_node_t */
+ * @implements bithenge_node_t
+ */
 typedef struct {
 	/** @privatesection */
@@ -50,5 +51,6 @@
 
 /** Operations providing random access to binary data.
- * @todo Should these be thread-safe? */
+ * @todo Should these be thread-safe?
+ */
 typedef struct bithenge_random_access_blob_ops_t {
 	/** @copydoc bithenge_blob_t::bithenge_blob_size */
@@ -61,10 +63,12 @@
 	    aoff64_t *size, bool little_endian);
 	/** Destroy the blob.
-	 * @param blob The blob. */
+	 * @param blob The blob.
+	 */
 	void (*destroy)(bithenge_blob_t *self);
 } bithenge_random_access_blob_ops_t;
 
 /** A blob built from an object that supports only sequential reading.
- * @implements bithenge_blob_t */
+ * @implements bithenge_blob_t
+ */
 typedef struct {
 	/** @privatesection */
@@ -82,5 +86,6 @@
 
 /** Operations providing sequential access to binary data.
- * @memberof bithenge_sequential_blob_t */
+ * @memberof bithenge_sequential_blob_t
+ */
 typedef struct bithenge_sequential_blob_ops_t {
 
@@ -112,5 +117,6 @@
 
 	/** Destroy the blob.
-	 * @param self The blob. */
+	 * @param self The blob.
+	 */
 	void (*destroy)(bithenge_sequential_blob_t *self);
 } bithenge_sequential_blob_ops_t;
@@ -189,5 +195,6 @@
  * @param self The blob.
  * @param[out] out Holds whether the blob is empty.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 static inline errno_t bithenge_blob_empty(bithenge_blob_t *self, bool *out)
 {
@@ -203,5 +210,6 @@
  * @memberof bithenge_blob_t
  * @param blob The blob to cast.
- * @return The blob node as a generic node. */
+ * @return The blob node as a generic node.
+ */
 static inline bithenge_node_t *bithenge_blob_as_node(bithenge_blob_t *blob)
 {
@@ -212,5 +220,6 @@
  * @memberof bithenge_blob_t
  * @param node The node to cast, which must be a blob node.
- * @return The generic node as a blob node. */
+ * @return The generic node as a blob node.
+ */
 static inline bithenge_blob_t *bithenge_node_as_blob(bithenge_node_t *node)
 {
@@ -220,5 +229,6 @@
 
 /** Increment a blob's reference count.
- * @param blob The blob to reference. */
+ * @param blob The blob to reference.
+ */
 static inline void bithenge_blob_inc_ref(bithenge_blob_t *blob)
 {
@@ -227,5 +237,6 @@
 
 /** Decrement a blob's reference count.
- * @param blob The blob to dereference, or NULL. */
+ * @param blob The blob to dereference, or NULL.
+ */
 static inline void bithenge_blob_dec_ref(bithenge_blob_t *blob)
 {
Index: uspace/lib/bithenge/include/bithenge/expression.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/expression.h	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/include/bithenge/expression.h	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -55,10 +55,12 @@
 	    bithenge_node_t **out);
 	/** Destroy the expression.
-	 * @param self The expression. */
+	 * @param self The expression.
+	 */
 	void (*destroy)(bithenge_expression_t *self);
 } bithenge_expression_ops_t;
 
 /** Increment an expression's reference count.
- * @param self The expression to reference. */
+ * @param self The expression to reference.
+ */
 static inline void bithenge_expression_inc_ref(bithenge_expression_t *self)
 {
@@ -68,5 +70,6 @@
 
 /** Decrement an expression's reference count and free it if appropriate.
- * @param self The expression to dereference, or NULL. */
+ * @param self The expression to dereference, or NULL.
+ */
 static inline void bithenge_expression_dec_ref(bithenge_expression_t *self)
 {
@@ -84,5 +87,6 @@
  * @param scope The scope.
  * @param[out] out Where the output tree will be stored.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 static inline errno_t bithenge_expression_evaluate(bithenge_expression_t *self,
     bithenge_scope_t *scope, bithenge_node_t **out)
Index: uspace/lib/bithenge/include/bithenge/print.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/print.h	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/include/bithenge/print.h	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -43,8 +43,10 @@
 typedef enum {
 	/** Print a Python value. Note that internal nodes will be represented
-	 * as unordered dictionaries. */
+	 * as unordered dictionaries.
+	 */
 	BITHENGE_PRINT_PYTHON,
 	/** Print JSON. Due to the limitations of JSON, type information may be
-	 * lost. */
+	 * lost.
+	 */
 	BITHENGE_PRINT_JSON,
 } bithenge_print_type_t;
Index: uspace/lib/bithenge/include/bithenge/transform.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/transform.h	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/include/bithenge/transform.h	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -64,5 +64,6 @@
 /** Increment a scope's reference count.
  * @memberof bithenge_scope_t
- * @param self The scope to reference. */
+ * @param self The scope to reference.
+ */
 static inline void bithenge_scope_inc_ref(bithenge_scope_t *self)
 {
@@ -73,5 +74,6 @@
 /** Operations that may be provided by a transform. All transforms must provide
  * apply and/or prefix_apply. To be used in struct transforms and repeat
- * transforms, transforms must provide prefix_length and/or prefix_apply. */
+ * transforms, transforms must provide prefix_length and/or prefix_apply.
+ */
 typedef struct bithenge_transform_ops {
 	/** @copydoc bithenge_transform_t::bithenge_transform_apply */
@@ -86,5 +88,6 @@
 	    bithenge_node_t **out_node, aoff64_t *out_size);
 	/** Destroy the transform.
-	 * @param self The transform. */
+	 * @param self The transform.
+	 */
 	void (*destroy)(bithenge_transform_t *self);
 } bithenge_transform_ops_t;
@@ -93,5 +96,6 @@
  * by the parser and param-wrapper. Takes ownership of nothing.
  * @param self The transform.
- * @return The number of parameters required. */
+ * @return The number of parameters required.
+ */
 static inline int bithenge_transform_num_params(bithenge_transform_t *self)
 {
@@ -101,5 +105,6 @@
 
 /** Increment a transform's reference count.
- * @param self The transform to reference. */
+ * @param self The transform to reference.
+ */
 static inline void bithenge_transform_inc_ref(bithenge_transform_t *self)
 {
@@ -109,5 +114,6 @@
 
 /** Decrement a transform's reference count and free it if appropriate.
- * @param self The transform to dereference, or NULL. */
+ * @param self The transform to dereference, or NULL.
+ */
 static inline void bithenge_transform_dec_ref(bithenge_transform_t *self)
 {
Index: uspace/lib/bithenge/include/bithenge/tree.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/tree.h	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/include/bithenge/tree.h	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -81,5 +81,6 @@
  * @param value The value.
  * @param data Data provided to @a bithenge_node_t::bithenge_node_for_each.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 typedef errno_t (*bithenge_for_each_func_t)(bithenge_node_t *key, bithenge_node_t *value, void *data);
 
@@ -92,5 +93,6 @@
 	    bithenge_node_t **out);
 	/** Destroys the internal node.
-	 * @param self The node to destroy. */
+	 * @param self The node to destroy.
+	 */
 	void (*destroy)(bithenge_node_t *self);
 } bithenge_internal_node_ops_t;
@@ -99,5 +101,6 @@
  * @memberof bithenge_node_t
  * @param node The node.
- * @return The type of the node. */
+ * @return The type of the node.
+ */
 static inline bithenge_node_type_t bithenge_node_type(const bithenge_node_t *node)
 {
@@ -107,5 +110,6 @@
 /** Increment a node's reference count.
  * @memberof bithenge_node_t
- * @param node The node to reference. */
+ * @param node The node to reference.
+ */
 static inline void bithenge_node_inc_ref(bithenge_node_t *node)
 {
@@ -122,5 +126,6 @@
  * @param func The callback function.
  * @param data Data to provide to the callback function.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 static inline errno_t bithenge_node_for_each(bithenge_node_t *self,
     bithenge_for_each_func_t func, void *data)
@@ -137,5 +142,6 @@
  * @memberof bithenge_node_t
  * @param self The boolean node.
- * @return The node's value. */
+ * @return The node's value.
+ */
 static inline bool bithenge_boolean_node_value(bithenge_node_t *self)
 {
@@ -147,5 +153,6 @@
  * @memberof bithenge_node_t
  * @param self The integer node.
- * @return The node's value. */
+ * @return The node's value.
+ */
 static inline bithenge_int_t bithenge_integer_node_value(bithenge_node_t *self)
 {
@@ -157,5 +164,6 @@
  * @memberof bithenge_node_t
  * @param self The string node.
- * @return The node's value. */
+ * @return The node's value.
+ */
 static inline const char *bithenge_string_node_value(bithenge_node_t *self)
 {
Index: uspace/lib/bithenge/src/blob.c
===================================================================
--- uspace/lib/bithenge/src/blob.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/blob.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -239,5 +239,6 @@
  * @param needs_free If true, the buffer will be freed with free() if this
  * function fails or the blob is destroyed.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer,
     size_t len, bool needs_free)
@@ -277,5 +278,6 @@
  * @param[in] data The data.
  * @param len The length of the data.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
     size_t len)
@@ -435,5 +437,6 @@
  * @param[in] source The input blob.
  * @param offset The offset within the input blob at which the new blob will start.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_offset_blob(bithenge_node_t **out, bithenge_blob_t *source,
     aoff64_t offset)
@@ -448,5 +451,6 @@
  * @param offset The offset within the input blob at which the new blob will start.
  * @param size The size of the new blob.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_subblob(bithenge_node_t **out, bithenge_blob_t *source,
     aoff64_t offset, aoff64_t size)
Index: uspace/lib/bithenge/src/compound.c
===================================================================
--- uspace/lib/bithenge/src/compound.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/compound.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -115,5 +115,6 @@
  * @param[in] xforms The transforms to apply.
  * @param num The number of transforms.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_composed_transform(bithenge_transform_t **out,
     bithenge_transform_t **xforms, size_t num)
@@ -231,5 +232,6 @@
  * @param true_xform The transform to apply if the expression is true.
  * @param false_xform The transform to apply if the expression is false.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_if_transform(bithenge_transform_t **out,
     bithenge_expression_t *expr, bithenge_transform_t *true_xform,
@@ -309,5 +311,6 @@
  * @param[out] out Holds the new transform.
  * @param xform The subtransform to apply.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_partial_transform(bithenge_transform_t **out,
     bithenge_transform_t *xform)
Index: uspace/lib/bithenge/src/expression.c
===================================================================
--- uspace/lib/bithenge/src/expression.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/expression.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -47,5 +47,6 @@
  * @param[out] self Expression to initialize.
  * @param[in] ops Operations provided by the expression.
- * @return EOK or an error code from errno.h. */
+ * @return EOK or an error code from errno.h.
+ */
 errno_t bithenge_init_expression(bithenge_expression_t *self,
     const bithenge_expression_ops_t *ops)
@@ -156,10 +157,12 @@
 		break;
 	case BITHENGE_EXPRESSION_INTEGER_DIVIDE:
-		/* Integer division can behave in three major ways when the
-		  operands are signed: truncated, floored, or Euclidean. When
+		/*
+		 * Integer division can behave in three major ways when the
+		 * operands are signed: truncated, floored, or Euclidean. When
 		 * b > 0, we give the same result as floored and Euclidean;
 		 * otherwise, we currently raise an error. See
 		 * https://en.wikipedia.org/wiki/Modulo_operation and its
-		 * references. */
+		 * references.
+		 */
 		if (b_int <= 0) {
 			rc = EINVAL;
@@ -249,5 +252,6 @@
  * @param a The first operand.
  * @param b The second operand.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_binary_expression(bithenge_expression_t **out,
     bithenge_binary_op_t op, bithenge_expression_t *a,
@@ -305,5 +309,6 @@
 /** Create an expression that gets the current input node.
  * @param[out] out Holds the new expression.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_in_node_expression(bithenge_expression_t **out)
 {
@@ -339,5 +344,6 @@
 /** Create an expression that gets the current node being created.
  * @param[out] out Holds the new expression.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_current_node_expression(bithenge_expression_t **out)
 {
@@ -389,5 +395,6 @@
  * @param[out] out Holds the created expression.
  * @param index The index of the parameter to get.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_param_expression(bithenge_expression_t **out, int index)
 {
@@ -454,5 +461,6 @@
  * @param[out] out Holds the created expression.
  * @param node The constant.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_const_expression(bithenge_expression_t **out,
     bithenge_node_t *node)
@@ -536,5 +544,6 @@
  * @param[out] out Holds the new expression.
  * @param key The key to search for in nodes being created.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_scope_member_expression(bithenge_expression_t **out,
     bithenge_node_t *key)
@@ -657,5 +666,6 @@
  * @param absolute_limit If true, the limit is an absolute offset; otherwise,
  * it is relative to the start.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_subblob_expression(bithenge_expression_t **out,
     bithenge_expression_t *blob, bithenge_expression_t *start,
@@ -815,5 +825,6 @@
  * @param transform The transform for which parameters are calculated.
  * @param params The expressions used to calculate the parameters.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_param_wrapper(bithenge_transform_t **out,
     bithenge_transform_t *transform, bithenge_expression_t **params)
@@ -899,5 +910,6 @@
  * @param[out] out Holds the new transform.
  * @param expr The expression to evaluate.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_expression_transform(bithenge_transform_t **out,
     bithenge_expression_t *expr)
@@ -956,5 +968,6 @@
  * @param[out] out Holds the new transform.
  * @param expr The expression to evaluate.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_inputless_transform(bithenge_transform_t **out,
     bithenge_expression_t *expr)
@@ -1117,5 +1130,6 @@
  * @param a The first blob.
  * @param b The second blob.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_concat_blob(bithenge_node_t **out, bithenge_blob_t *a,
     bithenge_blob_t *b)
@@ -1159,5 +1173,6 @@
  * @param b_expr An expression to calculate the second blob.
  * @param scope The scope in which @a b_expr should be evaluated.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_concat_blob_lazy(bithenge_node_t **out, bithenge_blob_t *a,
     bithenge_expression_t *b_expr, bithenge_scope_t *scope)
Index: uspace/lib/bithenge/src/failure.c
===================================================================
--- uspace/lib/bithenge/src/failure.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/failure.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -47,5 +47,6 @@
 #include "common.h"
 
-/* This file raises fake errors from system calls, to test that Bithenge
+/*
+ * This file raises fake errors from system calls, to test that Bithenge
  * handles the errors correctly. It has two primary modes of operation,
  * depending on an environment variable:
@@ -60,5 +61,6 @@
  * BITHENGE_FAILURE_INDEX set: the program runs normally until system call
  * number BITHENGE_FAILURE_INDEX is made; a fake error is returned from this
- * call. */
+ * call.
+ */
 
 static int g_initialized = 0;
@@ -94,6 +96,8 @@
 }
 
-/* Record a hit for a backtrace address and return whether this is the first
- * hit. */
+/*
+ * Record a hit for a backtrace address and return whether this is the first
+ * hit.
+ */
 static inline errno_t backtrace_item_hit(void *addr)
 {
@@ -133,6 +137,8 @@
 	}
 
-	/* If all backtrace items have been seen already, there's no need to
-	 * try raising an error. */
+	/*
+	 * If all backtrace items have been seen already, there's no need to
+	 * try raising an error.
+	 */
 	void *trace[256];
 	int size = backtrace(trace, 256);
@@ -162,7 +168,9 @@
 		return 0;
 
-	/* The child had an error! We couldn't easily debug it because it was
+	/*
+	 * The child had an error! We couldn't easily debug it because it was
 	 * in a separate process with redirected stdout and stderr. Do it again
-	 * without redirecting or forking. */
+	 * without redirecting or forking.
+	 */
 	fprintf(stderr, "** Fake error raised here (BITHENGE_FAILURE_INDEX=%d)\n",
 	    g_failure_index);
Index: uspace/lib/bithenge/src/file.c
===================================================================
--- uspace/lib/bithenge/src/file.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/file.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -140,5 +140,6 @@
  * @param[out] out Stores the created blob.
  * @param filename The name of the file.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_file_blob(bithenge_node_t **out, const char *filename)
 {
@@ -157,5 +158,6 @@
  * @param[out] out Stores the created blob.
  * @param fd The file descriptor.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_file_blob_from_fd(bithenge_node_t **out, int fd)
 {
@@ -167,5 +169,6 @@
  * @param[out] out Stores the created blob.
  * @param file The file pointer.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_file_blob_from_file(bithenge_node_t **out, FILE *file)
 {
Index: uspace/lib/bithenge/src/helenos/block.c
===================================================================
--- uspace/lib/bithenge/src/helenos/block.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/helenos/block.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -95,5 +95,6 @@
  * @param[out] out Stores the created blob.
  * @param service_id The service ID of the block device.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_block_blob(bithenge_node_t **out, service_id_t service_id)
 {
Index: uspace/lib/bithenge/src/print.c
===================================================================
--- uspace/lib/bithenge/src/print.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/print.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -222,5 +222,6 @@
  * @param type The format to use.
  * @param tree The root node of the tree to print.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_print_node(bithenge_print_type_t type, bithenge_node_t *tree)
 {
@@ -236,5 +237,6 @@
  * @param type The format to use.
  * @param tree The root node of the tree to print.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_print_node_to_string(char **str, size_t *size,
     bithenge_print_type_t type, bithenge_node_t *tree)
Index: uspace/lib/bithenge/src/script.c
===================================================================
--- uspace/lib/bithenge/src/script.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/script.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -55,5 +55,6 @@
 /** @cond internal
  * Single-character symbols are represented by the character itself. Every
- * other token uses one of these values: */
+ * other token uses one of these values:
+ */
 typedef enum {
 	TOKEN_ERROR = -128,
@@ -98,5 +99,6 @@
 typedef struct {
 	/** Rather than constantly checking return values, the parser uses this
-	 * to indicate whether an error has occurred. */
+	 * to indicate whether an error has occurred.
+	 */
 	errno_t error;
 
@@ -109,5 +111,6 @@
 	FILE *file;
 	/** The buffer that holds script code. There is always a '\0' after the
-	 * current position to prevent reading too far. */
+	 * current position to prevent reading too far.
+	 */
 	char buffer[BUFFER_SIZE];
 	/** The start position within the buffer of the next unread token. */
@@ -124,5 +127,6 @@
 	union {
 		/** The value of a TOKEN_IDENTIFIER token. Unless changed to
-		 * NULL, it will be freed when the next token is read. */
+		 * NULL, it will be freed when the next token is read.
+		 */
 		char *token_string;
 		/** The value of a TOKEN_INTEGER token. */
@@ -139,5 +143,6 @@
 
 /** Free the previous token's data. This must be called before changing
- * state->token. */
+ * state->token.
+ */
 static void done_with_token(state_t *state)
 {
@@ -346,5 +351,6 @@
 /** Allocate memory and handle failure by setting the error in the state. The
  * caller must check the state for errors before using the return value of this
- * function. */
+ * function.
+ */
 static void *state_malloc(state_t *state, size_t size)
 {
@@ -358,5 +364,6 @@
 
 /** Reallocate memory and handle failure by setting the error in the state. If
- * an error occurs, the existing pointer will be returned. */
+ * an error occurs, the existing pointer will be returned.
+ */
 static void *state_realloc(state_t *state, void *ptr, size_t size)
 {
@@ -372,5 +379,6 @@
 
 /** Expect and consume a certain token. If the next token is of the wrong type,
- * an error is caused. */
+ * an error is caused.
+ */
 static void expect(state_t *state, token_type_t type)
 {
@@ -383,5 +391,6 @@
 
 /** Expect and consume an identifier token. If the next token is not an
- * identifier, an error is caused and this function returns null. */
+ * identifier, an error is caused and this function returns null.
+ */
 static char *expect_identifier(state_t *state)
 {
@@ -397,5 +406,6 @@
 
 /** Find a transform by name. A reference will be added to the transform.
- * @return The found transform, or NULL if none was found. */
+ * @return The found transform, or NULL if none was found.
+ */
 static bithenge_transform_t *get_named_transform(state_t *state,
     const char *name)
@@ -419,5 +429,6 @@
 
 /** Add a named transform. This function takes ownership of the name and a
- * reference to the transform. If an error has occurred, either may be null. */
+ * reference to the transform. If an error has occurred, either may be null.
+ */
 static void add_named_transform(state_t *state, bithenge_transform_t *xform, char *name)
 {
@@ -809,5 +820,6 @@
 /** Create a transform that just produces an empty node.
  * @param state The parser state.
- * @return The new transform, or NULL on error. */
+ * @return The new transform, or NULL on error.
+ */
 static bithenge_transform_t *make_empty_transform(state_t *state)
 {
@@ -1139,5 +1151,6 @@
 
 /** Parse a transform without composition.
- * @return The parsed transform, or NULL if an error occurred. */
+ * @return The parsed transform, or NULL if an error occurred.
+ */
 static bithenge_transform_t *parse_transform_no_compose(state_t *state)
 {
@@ -1188,5 +1201,6 @@
 
 /** Parse a transform.
- * @return The parsed transform, or NULL if an error occurred. */
+ * @return The parsed transform, or NULL if an error occurred.
+ */
 static bithenge_transform_t *parse_transform(state_t *state)
 {
@@ -1320,5 +1334,6 @@
  * @param[out] out Stores the "main" transform.
  * @return EOK on success, EINVAL on syntax error, or an error code from
- * errno.h. */
+ * errno.h.
+ */
 errno_t bithenge_parse_script(const char *filename, bithenge_transform_t **out)
 {
Index: uspace/lib/bithenge/src/sequence.c
===================================================================
--- uspace/lib/bithenge/src/sequence.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/sequence.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -150,6 +150,8 @@
 
 	if (index == self->num_ends) {
-		/* We can apply the subtransform and cache its prefix length at
-		 * the same time. */
+		/*
+		 * We can apply the subtransform and cache its prefix length at
+		 * the same time.
+		 */
 		bithenge_node_t *blob_node;
 		bithenge_blob_inc_ref(self->blob);
@@ -418,27 +420,35 @@
 	struct_node_t *node = node_as_struct(base);
 
-	/* Treat the scope carefully because of the circular reference. In
+	/*
+	 * Treat the scope carefully because of the circular reference. In
 	 * struct_transform_make_node, things are set up so node owns a
 	 * reference to the scope, but scope doesn't own a reference to node,
-	 * so node's reference count is too low. */
+	 * so node's reference count is too low.
+	 */
 	bithenge_scope_t *scope = seq_node_scope(struct_as_seq(node));
 	if (scope->refs == 1) {
-		/* Mostly normal destroy, but we didn't inc_ref(node) for the
+		/*
+		 * Mostly normal destroy, but we didn't inc_ref(node) for the
 		 * scope in struct_transform_make_node, so make sure it doesn't
-		 * try to dec_ref. */
+		 * try to dec_ref.
+		 */
 		scope->current_node = NULL;
 		seq_node_destroy(struct_as_seq(node));
 	} else if (scope->refs > 1) {
-		/* The scope is still needed, but node isn't otherwise needed.
+		/*
+		 * The scope is still needed, but node isn't otherwise needed.
 		 * Switch things around so scope owns a reference to node, but
-		 * not vice versa, and scope's reference count is too low. */
+		 * not vice versa, and scope's reference count is too low.
+		 */
 		bithenge_node_inc_ref(base);
 		bithenge_scope_dec_ref(scope);
 		return;
 	} else {
-		/* This happens after the previous case, when scope is no
+		/*
+		 * This happens after the previous case, when scope is no
 		 * longer used and is being destroyed. Since scope is already
 		 * being destroyed, set it to NULL here so we don't try to
-		 * destroy it twice. */
+		 * destroy it twice.
+		 */
 		struct_as_seq(node)->scope = NULL;
 		seq_node_destroy(struct_as_seq(node));
@@ -501,8 +511,10 @@
 	node->prefix = prefix;
 
-	/* We should inc_ref(node) here, but that would make a cycle. Instead,
+	/*
+	 * We should inc_ref(node) here, but that would make a cycle. Instead,
 	 * we leave it 1 too low, so that when the only remaining use of node
 	 * is the scope, node will be destroyed. Also see the comment in
-	 * struct_node_destroy. */
+	 * struct_node_destroy.
+	 */
 	bithenge_scope_set_current_node(inner, struct_as_node(node));
 	bithenge_scope_dec_ref(inner);
@@ -591,5 +603,6 @@
  * @param[out] out Stores the created transform.
  * @param subtransforms The subtransforms and field names.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_struct(bithenge_transform_t **out,
     bithenge_named_transform_t *subtransforms)
@@ -869,5 +882,6 @@
  * @param expr Used to calculate the number of times @a xform will be applied.
  * May be NULL, in which case @a xform will be applied indefinitely.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_repeat_transform(bithenge_transform_t **out,
     bithenge_transform_t *xform, bithenge_expression_t *expr)
@@ -1114,5 +1128,6 @@
  * @param expr Applied in the result of each application of @a xform to
  * determine whether there will be more.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_do_while_transform(bithenge_transform_t **out,
     bithenge_transform_t *xform, bithenge_expression_t *expr)
Index: uspace/lib/bithenge/src/source.c
===================================================================
--- uspace/lib/bithenge/src/source.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/source.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -84,5 +84,6 @@
  * @param[out] out Stores the created node.
  * @param source Specifies the node to be created.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_node_from_source(bithenge_node_t **out, const char *source)
 {
Index: uspace/lib/bithenge/src/transform.c
===================================================================
--- uspace/lib/bithenge/src/transform.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/transform.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -56,5 +56,6 @@
  * whatever parameters it has, so they can be passed to any param_wrappers
  * within.
- * @return EOK or an error code from errno.h. */
+ * @return EOK or an error code from errno.h.
+ */
 errno_t bithenge_init_transform(bithenge_transform_t *self,
     const bithenge_transform_ops_t *ops, int num_params)
@@ -82,5 +83,6 @@
  * @param in The input tree.
  * @param[out] out Where the output tree will be stored.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_transform_apply(bithenge_transform_t *self,
     bithenge_scope_t *scope, bithenge_node_t *in, bithenge_node_t **out)
@@ -118,5 +120,6 @@
  * @param[out] out Where the prefix length will be stored.
  * @return EOK on success, ENOTSUP if not supported, or another error code from
- * errno.h. */
+ * errno.h.
+ */
 errno_t bithenge_transform_prefix_length(bithenge_transform_t *self,
     bithenge_scope_t *scope, bithenge_blob_t *blob, aoff64_t *out)
@@ -149,5 +152,6 @@
  * case the size is not determined.
  * @return EOK on success, ENOTSUP if not supported, or another error code from
- * errno.h. */
+ * errno.h.
+ */
 errno_t bithenge_transform_prefix_apply(bithenge_transform_t *self,
     bithenge_scope_t *scope, bithenge_blob_t *blob, bithenge_node_t **out_node,
@@ -187,5 +191,6 @@
  * @param[out] out Holds the new scope.
  * @param outer The outer scope, or NULL.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_scope_new(bithenge_scope_t **out, bithenge_scope_t *outer)
 {
@@ -209,5 +214,6 @@
 /** Dereference a transform scope.
  * @memberof bithenge_scope_t
- * @param self The scope to dereference, or NULL. */
+ * @param self The scope to dereference, or NULL.
+ */
 void bithenge_scope_dec_ref(bithenge_scope_t *self)
 {
@@ -228,5 +234,6 @@
  * @memberof bithenge_scope_t
  * @param self The scope to examine.
- * @return The outer scope, which may be NULL. */
+ * @return The outer scope, which may be NULL.
+ */
 bithenge_scope_t *bithenge_scope_outer(bithenge_scope_t *self)
 {
@@ -238,5 +245,6 @@
  * @memberof bithenge_scope_t
  * @param scope The scope to get the error message from.
- * @return The error message, or NULL. */
+ * @return The error message, or NULL.
+ */
 const char *bithenge_scope_get_error(bithenge_scope_t *scope)
 {
@@ -250,5 +258,6 @@
  * @param scope The scope.
  * @param format The format string.
- * @return EINVAL normally, or another error code from errno.h. */
+ * @return EINVAL normally, or another error code from errno.h.
+ */
 errno_t bithenge_scope_error(bithenge_scope_t *scope, const char *format, ...)
 {
@@ -299,5 +308,6 @@
  * @memberof bithenge_scope_t
  * @param scope The scope to get the current node from.
- * @return The node being created, or NULL. */
+ * @return The node being created, or NULL.
+ */
 bithenge_node_t *bithenge_scope_get_current_node(bithenge_scope_t *scope)
 {
@@ -310,5 +320,6 @@
  * @memberof bithenge_scope_t
  * @param scope The scope to set the current node in.
- * @param node The current node being created, or NULL. */
+ * @param node The current node being created, or NULL.
+ */
 void bithenge_scope_set_current_node(bithenge_scope_t *scope,
     bithenge_node_t *node)
@@ -321,5 +332,6 @@
  * @memberof bithenge_scope_t
  * @param scope The scope to get the current input node from.
- * @return The input node, or NULL. */
+ * @return The input node, or NULL.
+ */
 bithenge_node_t *bithenge_scope_in_node(bithenge_scope_t *scope)
 {
@@ -332,5 +344,6 @@
  * @memberof bithenge_scope_t
  * @param scope The scope to set the input node in.
- * @param node The input node, or NULL. */
+ * @param node The input node, or NULL.
+ */
 void bithenge_scope_set_in_node(bithenge_scope_t *scope, bithenge_node_t *node)
 {
@@ -341,5 +354,6 @@
 /** Set a scope as a barrier.
  * @memberof bithenge_scope_t
- * @param self The scope to change. */
+ * @param self The scope to change.
+ */
 void bithenge_scope_set_barrier(bithenge_scope_t *self)
 {
@@ -351,5 +365,6 @@
  * @memberof bithenge_scope_t
  * @param self The scope to check.
- * @return Whether the scope is a barrier. */
+ * @return Whether the scope is a barrier.
+ */
 bool bithenge_scope_is_barrier(bithenge_scope_t *self)
 {
@@ -363,5 +378,6 @@
  * @param scope The scope in which to allocate parameters.
  * @param num_params The number of parameters to allocate.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_scope_alloc_params(bithenge_scope_t *scope, int num_params)
 {
@@ -381,5 +397,6 @@
  * @param i The index of the parameter to set.
  * @param node The value to store in the parameter.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_scope_set_param(bithenge_scope_t *scope, int i,
     bithenge_node_t *node)
@@ -400,5 +417,6 @@
  * @param i The index of the parameter to set.
  * @param[out] out Stores a new reference to the parameter.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_scope_get_param(bithenge_scope_t *scope, int i,
     bithenge_node_t **out)
@@ -502,5 +520,6 @@
  * @param base The barrier transform.
  * @param transform The subtransform to use for all operations.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_barrier_transform_set_subtransform(bithenge_transform_t *base,
     bithenge_transform_t *transform)
@@ -526,5 +545,6 @@
  * @param[out] out Holds the created transform.
  * @param num_params The number of parameters to require, which may be 0.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_barrier_transform(bithenge_transform_t **out, int num_params)
 {
@@ -742,5 +762,6 @@
 
 /** A transform that converts a byte blob to a bit blob, most-significant bit
- * first. */
+ * first.
+ */
 bithenge_transform_t bithenge_bits_be_transform = {
 	&bits_xe_ops, 1, 0
@@ -748,5 +769,6 @@
 
 /** A transform that converts a byte blob to a bit blob, least-significant bit
- * first. */
+ * first.
+ */
 bithenge_transform_t bithenge_bits_le_transform = {
 	&bits_xe_ops, 1, 0
@@ -987,5 +1009,6 @@
 
 /** A transform that reads an unsigned integer from an arbitrary number of
- * bits, most-significant bit first. */
+ * bits, most-significant bit first.
+ */
 bithenge_transform_t bithenge_uint_be_transform = {
 	&uint_xe_ops, 1, 1
@@ -993,5 +1016,6 @@
 
 /** A transform that reads an unsigned integer from an arbitrary number of
- * bits, least-significant bit first. */
+ * bits, least-significant bit first.
+ */
 bithenge_transform_t bithenge_uint_le_transform = {
 	&uint_xe_ops, 1, 1
Index: uspace/lib/bithenge/src/tree.c
===================================================================
--- uspace/lib/bithenge/src/tree.c	(revision 18b6a8849d630cc3bca153fb21bd225eebb16f4c)
+++ uspace/lib/bithenge/src/tree.c	(revision a05ec6671002c451fceb01aa0ab3f71f004efb6d)
@@ -71,5 +71,6 @@
 /** Decrement a node's reference count and free it if appropriate.
  * @memberof bithenge_node_t
- * @param node The node to dereference, or NULL. */
+ * @param node The node to dereference, or NULL.
+ */
 void bithenge_node_dec_ref(bithenge_node_t *node)
 {
@@ -112,5 +113,6 @@
  * @param[out] out Holds the found node.
  * @return EOK on success, ENOENT if not found, or another error code from
- * errno.h. */
+ * errno.h.
+ */
 errno_t bithenge_node_get(bithenge_node_t *self, bithenge_node_t *key,
     bithenge_node_t **out)
@@ -154,5 +156,6 @@
  * @param[out] self The node.
  * @param[in] ops The operations provided.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_init_internal_node(bithenge_node_t *self,
     const bithenge_internal_node_ops_t *ops)
@@ -195,5 +198,6 @@
 /** Create an empty internal node.
  * @param[out] out Holds the created node.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_empty_internal_node(bithenge_node_t **out)
 {
@@ -262,5 +266,6 @@
  * @param needs_free If true, when the internal node is destroyed it will free
  * the nodes array rather than just dereferencing each node inside it.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_simple_internal_node(bithenge_node_t **out,
     bithenge_node_t **nodes, bithenge_int_t len, bool needs_free)
@@ -298,5 +303,6 @@
  * @param[out] out Stores the created boolean node.
  * @param value The value for the node to hold.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_boolean_node(bithenge_node_t **out, bool value)
 {
@@ -313,5 +319,6 @@
  * @param[out] out Stores the created integer node.
  * @param value The value for the node to hold.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_integer_node(bithenge_node_t **out, bithenge_int_t value)
 {
@@ -333,5 +340,6 @@
  * @param needs_free Whether the string should be freed when the node is
  * destroyed.
- * @return EOK on success or an error code from errno.h. */
+ * @return EOK on success or an error code from errno.h.
+ */
 errno_t bithenge_new_string_node(bithenge_node_t **out, const char *value, bool needs_free)
 {
@@ -357,5 +365,6 @@
  * @param a, b Nodes to compare.
  * @return EOK on success or an error code from errno.h.
- * @todo Add support for internal nodes. */
+ * @todo Add support for internal nodes.
+ */
 errno_t bithenge_node_equal(bool *out, bithenge_node_t *a, bithenge_node_t *b)
 {