Changeset 7c3fb9b in mainline for uspace/lib/bithenge/src/sequence.c

Timestamp:

2018-05-17T08:29:01Z (6 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

6ff23ff

Parents:

fac0ac7

git-author:

Jiri Svoboda <jiri@…> (2018-05-16 17:28:17)

git-committer:

Jiri Svoboda <jiri@…> (2018-05-17 08:29:01)

Message:

Fix block comment formatting (ccheck).

File:

• uspace/lib/bithenge/src/sequence.c (modified) (6 diffs)

uspace/lib/bithenge/src/sequence.c

@@ -150 +150 @@
 
         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 +420 @@
         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 +511 @@
         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 +603 @@
  * @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 +882 @@
  * @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 +1128 @@
  * @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)