Changeset 5e718d9 in mainline for uspace/lib/bithenge/sequence.c

Timestamp:

2012-08-21T10:04:16Z (12 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

67edca6

Parents:

0da6c04 (diff), 6a97f2e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge with upstream (lp:~wtachi/helenos/bithenge)

File:

• uspace/lib/bithenge/sequence.c (moved) (moved from uspace/app/bithenge/sequence.c ) (12 diffs)

uspace/lib/bithenge/sequence.c

@@ -418 +418 @@
         struct_node_t *node = node_as_struct(base);
 
-        /* We didn't inc_ref for the scope in struct_transform_make_node, so
-         * make sure it doesn't try to dec_ref. */
-        seq_node_scope(struct_as_seq(node))->current_node = NULL;
-        seq_node_destroy(struct_as_seq(node));
+        /* 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. */
+        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
+                 * scope in struct_transform_make_node, so make sure it doesn't
+                 * 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.
+                 * Switch things around so scope owns a reference to node, but
+                 * 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
+                 * 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. */
+                struct_as_seq(node)->scope = NULL;
+                seq_node_destroy(struct_as_seq(node));
+        }
 
         bithenge_transform_dec_ref(struct_as_transform(node->transform));
@@ -466 +488 @@
                 return rc;
         }
+
+        rc = seq_node_init(struct_as_seq(node), &struct_node_seq_ops, inner,
+            blob, self->num_subtransforms, false);
+        if (rc != EOK) {
+                bithenge_scope_dec_ref(inner);
+                free(node);
+                return rc;
+        }
+
+        bithenge_transform_inc_ref(struct_as_transform(self));
+        node->transform = self;
+        node->prefix = prefix;
+
         /* 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
@@ -471 +506 @@
          * struct_node_destroy. */
         bithenge_scope_set_current_node(inner, struct_as_node(node));
-
-        rc = seq_node_init(struct_as_seq(node), &struct_node_seq_ops, inner,
-            blob, self->num_subtransforms, false);
         bithenge_scope_dec_ref(inner);
-        if (rc != EOK) {
-                free(node);
-                return rc;
-        }
-
-        bithenge_transform_inc_ref(struct_as_transform(self));
-        node->transform = self;
-        node->prefix = prefix;
+
         *out = struct_as_node(node);
 
@@ -524 +549 @@
                 return rc;
 
-        rc = seq_node_field_offset(node_as_seq(*out_node), out_size,
-            self->num_subtransforms);
-        if (rc != EOK) {
-                bithenge_node_dec_ref(*out_node);
-                return rc;
+        if (out_size) {
+                rc = seq_node_field_offset(node_as_seq(*out_node), out_size,
+                    self->num_subtransforms);
+                if (rc != EOK) {
+                        bithenge_node_dec_ref(*out_node);
+                        return rc;
+                }
         }
 
@@ -595 +622 @@
 /***************** bithenge_repeat_transform                 *****************/
 
+/* TODO: ignore errors */
+
 typedef struct {
         bithenge_transform_t base;
@@ -793 +822 @@
                 return rc;
 
-        bithenge_int_t count = node_as_repeat(*out_node)->count;
-        if (count != -1) {
-                rc = seq_node_field_offset(node_as_seq(*out_node), out_size, count);
-                if (rc != EOK) {
-                        bithenge_node_dec_ref(*out_node);
-                        return rc;
-                }
-        } else {
-                *out_size = 0;
-                for (count = 1; ; count++) {
-                        aoff64_t size;
+        if (out_size) {
+                bithenge_int_t count = node_as_repeat(*out_node)->count;
+                if (count != -1) {
                         rc = seq_node_field_offset(node_as_seq(*out_node),
-                            &size, count);
-                        if (rc != EOK)
-                                break;
-                        *out_size = size;
+                            out_size, count);
+                        if (rc != EOK) {
+                                bithenge_node_dec_ref(*out_node);
+                                return rc;
+                        }
+                } else {
+                        *out_size = 0;
+                        for (count = 1; ; count++) {
+                                aoff64_t size;
+                                rc = seq_node_field_offset(
+                                    node_as_seq(*out_node), &size, count);
+                                if (rc == EINVAL || rc == ENOENT)
+                                        break;
+                                if (rc != EOK) {
+                                        bithenge_node_dec_ref(*out_node);
+                                        return rc;
+                                }
+                                *out_size = size;
+                        }
                 }
         }
@@ -886 +922 @@
 typedef struct {
         seq_node_t base;
-        bool prefix;
         bithenge_expression_t *expr;
         bithenge_transform_t *xform;
@@ -966 +1001 @@
         }
 
-        if (!self->prefix) {
-                bool complete;
-                rc = seq_node_complete(do_while_as_seq(self), &complete);
-                if (rc != EOK)
-                        return rc;
-                if (!complete)
-                        return EINVAL;
-        }
-
         return rc;
 }
@@ -1006 +1032 @@
 
 static int do_while_transform_make_node(do_while_transform_t *self,
-    bithenge_node_t **out, bithenge_scope_t *scope, bithenge_blob_t *blob,
-    bool prefix)
+    bithenge_node_t **out, bithenge_scope_t *scope, bithenge_blob_t *blob)
 {
         do_while_node_t *node = malloc(sizeof(*node));
@@ -1031 +1056 @@
         bithenge_expression_inc_ref(self->expr);
         node->expr = self->expr;
-        node->prefix = prefix;
         node->count = -1;
         *out = do_while_as_node(node);
         return EOK;
-}
-
-static int do_while_transform_apply(bithenge_transform_t *base,
-    bithenge_scope_t *scope, bithenge_node_t *in, bithenge_node_t **out)
-{
-        do_while_transform_t *self = transform_as_do_while(base);
-        if (bithenge_node_type(in) != BITHENGE_NODE_BLOB)
-                return EINVAL;
-        return do_while_transform_make_node(self, out, scope,
-            bithenge_node_as_blob(in), false);
 }
 
@@ -1060 +1074 @@
 {
         do_while_transform_t *self = transform_as_do_while(base);
-        int rc = do_while_transform_make_node(self, out_node, scope, blob,
-            true);
+        int rc = do_while_transform_make_node(self, out_node, scope, blob);
         if (rc != EOK)
                 return rc;
 
-        rc = bithenge_node_for_each(*out_node, for_each_noop, NULL);
-        if (rc != EOK) {
-                bithenge_node_dec_ref(*out_node);
-                return rc;
-        }
-
-        rc = seq_node_field_offset(node_as_seq(*out_node), out_size,
-            node_as_do_while(*out_node)->count);
-        if (rc != EOK) {
-                bithenge_node_dec_ref(*out_node);
-                return rc;
+        if (out_size) {
+                rc = bithenge_node_for_each(*out_node, for_each_noop, NULL);
+                if (rc != EOK) {
+                        bithenge_node_dec_ref(*out_node);
+                        return rc;
+                }
+
+                rc = seq_node_field_offset(node_as_seq(*out_node), out_size,
+                    node_as_do_while(*out_node)->count);
+                if (rc != EOK) {
+                        bithenge_node_dec_ref(*out_node);
+                        return rc;
+                }
         }
 
@@ -1090 +1105 @@
 
 static const bithenge_transform_ops_t do_while_transform_ops = {
-        .apply = do_while_transform_apply,
         .prefix_apply = do_while_transform_prefix_apply,
         .destroy = do_while_transform_destroy,