Index: uspace/lib/bithenge/include/bithenge/blob.h
===================================================================
--- uspace/lib/bithenge/include/bithenge/blob.h	(revision 1d6dd2a62370f8442aef510558ad86b6439e6653)
+++ uspace/lib/bithenge/include/bithenge/blob.h	(revision 86b70c6fa1a6e0fc138e6294cb6cfe8bda4535d3)
@@ -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 1d6dd2a62370f8442aef510558ad86b6439e6653)
+++ uspace/lib/bithenge/include/bithenge/expression.h	(revision 86b70c6fa1a6e0fc138e6294cb6cfe8bda4535d3)
@@ -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 1d6dd2a62370f8442aef510558ad86b6439e6653)
+++ uspace/lib/bithenge/include/bithenge/print.h	(revision 86b70c6fa1a6e0fc138e6294cb6cfe8bda4535d3)
@@ -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 1d6dd2a62370f8442aef510558ad86b6439e6653)
+++ uspace/lib/bithenge/include/bithenge/transform.h	(revision 86b70c6fa1a6e0fc138e6294cb6cfe8bda4535d3)
@@ -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 1d6dd2a62370f8442aef510558ad86b6439e6653)
+++ uspace/lib/bithenge/include/bithenge/tree.h	(revision 86b70c6fa1a6e0fc138e6294cb6cfe8bda4535d3)
@@ -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)
 {