Changeset f9c314a5 in mainline

Timestamp:

2012-08-07T04:06:14Z (13 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

0191bd3

Parents:

0ce0103

Message:

Bithenge: make scopes reference-counted

Location:

uspace/app/bithenge

Files:

• expression.c (modified) (2 diffs)
• sequence.c (modified) (8 diffs)
• test.c (modified) (3 diffs)
• transform.c (modified) (2 diffs)
• transform.h (modified) (2 diffs)

uspace/app/bithenge/expression.c

@@ -424 +424 @@
 {
         param_wrapper_t *self = transform_as_param_wrapper(base);
-        bithenge_scope_t inner;
-        bithenge_scope_init(&inner);
-        int rc = param_wrapper_fill_scope(self, &inner, outer);
-        if (rc != EOK)
-                goto error;
-
-        rc = bithenge_transform_apply(self->transform, &inner, in, out);
+        bithenge_scope_t *inner;
+        int rc = bithenge_scope_new(&inner);
+        if (rc != EOK)
+                return rc;
+        rc = param_wrapper_fill_scope(self, inner, outer);
+        if (rc != EOK)
+                goto error;
+
+        rc = bithenge_transform_apply(self->transform, inner, in, out);
         in = NULL;
 
 error:
-        bithenge_scope_destroy(&inner);
+        bithenge_scope_dec_ref(inner);
         return rc;
 }
@@ -442 +444 @@
 {
         param_wrapper_t *self = transform_as_param_wrapper(base);
-        bithenge_scope_t inner;
-        bithenge_scope_init(&inner);
-        int rc = param_wrapper_fill_scope(self, &inner, outer);
-        if (rc != EOK)
-                goto error;
-
-        rc = bithenge_transform_prefix_length(self->transform, &inner, in,
-            out);
+        bithenge_scope_t *inner;
+        int rc = bithenge_scope_new(&inner);
+        if (rc != EOK)
+                return rc;
+        rc = param_wrapper_fill_scope(self, inner, outer);
+        if (rc != EOK)
+                goto error;
+
+        rc = bithenge_transform_prefix_length(self->transform, inner, in, out);
         in = NULL;
 
 error:
-        bithenge_scope_destroy(&inner);
+        bithenge_scope_dec_ref(inner);
         return rc;
 }

uspace/app/bithenge/sequence.c

@@ -50 +50 @@
         const struct seq_node_ops *ops;
         bithenge_blob_t *blob;
-        bithenge_scope_t scope;
+        bithenge_scope_t *scope;
         aoff64_t *ends;
         size_t num_ends;
@@ -114 +114 @@
                 bithenge_blob_t *subblob = bithenge_node_as_blob(subblob_node);
                 aoff64_t field_size;
-                rc = bithenge_transform_prefix_length(subxform, &self->scope,
+                rc = bithenge_transform_prefix_length(subxform, self->scope,
                     subblob, &field_size);
                 bithenge_node_dec_ref(subblob_node);
@@ -177 +177 @@
 
                 aoff64_t size;
-                rc = bithenge_transform_prefix_apply(subxform, &self->scope,
+                rc = bithenge_transform_prefix_apply(subxform, self->scope,
                     bithenge_node_as_blob(blob_node), out, &size);
                 bithenge_node_dec_ref(blob_node);
@@ -209 +209 @@
                 }
 
-                rc = bithenge_transform_apply(subxform, &self->scope,
-                    blob_node, out);
+                rc = bithenge_transform_apply(subxform, self->scope, blob_node,
+                    out);
                 bithenge_node_dec_ref(blob_node);
                 bithenge_transform_dec_ref(subxform);
@@ -235 +235 @@
 static void seq_node_destroy(seq_node_t *self)
 {
-        bithenge_scope_destroy(&self->scope);
+        bithenge_scope_dec_ref(self->scope);
         bithenge_blob_dec_ref(self->blob);
         free(self->ends);
@@ -248 +248 @@
 static bithenge_scope_t *seq_node_scope(seq_node_t *self)
 {
-        return &self->scope;
+        return self->scope;
 }
 
@@ -267 +267 @@
         self->num_ends = 0;
         self->end_on_empty = end_on_empty;
-        bithenge_scope_init(&self->scope);
-        int rc = bithenge_scope_copy(&self->scope, scope);
+        int rc = bithenge_scope_new(&self->scope);
         if (rc != EOK) {
-                bithenge_scope_destroy(&self->scope);
+                free(self->ends);
+                return rc;
+        }
+        rc = bithenge_scope_copy(self->scope, scope);
+        if (rc != EOK) {
+                bithenge_scope_dec_ref(self->scope);
+                free(self->ends);
                 return rc;
         }
@@ -936 +941 @@
                 }
 
-                bithenge_scope_t scope;
-                bithenge_scope_init(&scope);
-                rc = bithenge_scope_copy(&scope,
+                bithenge_scope_t *scope;
+                rc = bithenge_scope_new(&scope);
+                if (rc != EOK) {
+                        bithenge_node_dec_ref(subxform_result);
+                        return rc;
+                }
+                rc = bithenge_scope_copy(scope,
                     seq_node_scope(do_while_as_seq(self)));
-                bithenge_scope_set_current_node(&scope, subxform_result);
+                bithenge_scope_set_current_node(scope, subxform_result);
                 if (rc != EOK) {
-                        bithenge_scope_destroy(&scope);
+                        bithenge_scope_dec_ref(scope);
                         return rc;
                 }
                 bithenge_node_t *expr_result;
-                rc = bithenge_expression_evaluate(self->expr, &scope,
+                rc = bithenge_expression_evaluate(self->expr, scope,
                     &expr_result);
-                bithenge_scope_destroy(&scope);
+                bithenge_scope_dec_ref(scope);
                 if (rc != EOK)
                         return rc;

uspace/app/bithenge/test.c

@@ -69 +69 @@
                 bithenge_node_dec_ref(node);
         } else {
-                bithenge_scope_t scope;
+                bithenge_scope_t *scope = NULL;
                 bithenge_transform_t *transform = NULL;
                 bithenge_node_t *node = NULL, *node2 = NULL;
 
-                bithenge_scope_init(&scope);
+                rc = bithenge_scope_new(&scope);
+                if (rc != EOK) {
+                        printf("Error creating scope: %s\n", str_error(rc));
+                        scope = NULL;
+                        goto error;
+                }
 
                 rc = bithenge_parse_script(argv[1], &transform);
                 if (rc != EOK) {
                         printf("Error parsing script: %s\n", str_error(rc));
+                        transform = NULL;
                         goto error;
                 }
 
-                int rc = bithenge_node_from_source(&node, argv[2]);
+                rc = bithenge_node_from_source(&node, argv[2]);
                 if (rc != EOK) {
                         printf("Error creating node from source: %s\n", str_error(rc));
+                        node = NULL;
                         goto error;
                 }
 
-                rc = bithenge_transform_apply(transform, &scope, node, &node2);
+                rc = bithenge_transform_apply(transform, scope, node, &node2);
                 if (rc != EOK) {
                         printf("Error applying transform: %s\n", str_error(rc));
+                        node2 = NULL;
                         goto error;
                 }
@@ -105 +113 @@
                 bithenge_node_dec_ref(node2);
                 node2 = NULL;
+                bithenge_scope_dec_ref(scope);
+                scope = NULL;
                 printf("\n");
 
@@ -113 +123 @@
                 bithenge_node_dec_ref(node2);
                 bithenge_transform_dec_ref(transform);
-                bithenge_scope_destroy(&scope);
+                bithenge_scope_dec_ref(scope);
                 return 1;
         }

uspace/app/bithenge/transform.c

@@ -165 +165 @@
 }
 
-/** Initialize a transform scope. It must be destroyed with @a
- * bithenge_scope_destroy after it is used.
- * @param[out] scope The scope to initialize. */
-void bithenge_scope_init(bithenge_scope_t *scope)
-{
-        scope->num_params = 0;
-        scope->params = NULL;
-        scope->current_node = NULL;
-}
-
-/** Destroy a transform scope.
- * @param scope The scope to destroy.
+/** Create a transform scope. It must be dereferenced with @a
+ * bithenge_scope_dec_ref after it is used.
+ * @param[out] out Holds the new scope.
  * @return EOK on success or an error code from errno.h. */
-void bithenge_scope_destroy(bithenge_scope_t *scope)
-{
-        bithenge_node_dec_ref(scope->current_node);
-        for (int i = 0; i < scope->num_params; i++)
-                bithenge_node_dec_ref(scope->params[i]);
-        free(scope->params);
+int bithenge_scope_new(bithenge_scope_t **out)
+{
+        bithenge_scope_t *self = malloc(sizeof(*self));
+        if (!self)
+                return ENOMEM;
+        self->refs = 1;
+        self->num_params = 0;
+        self->params = NULL;
+        self->current_node = NULL;
+        *out = self;
+        return EOK;
+}
+
+/** Dereference a transform scope.
+ * @param self The scope to dereference. */
+void bithenge_scope_dec_ref(bithenge_scope_t *self)
+{
+        if (!--self->refs) {
+                bithenge_node_dec_ref(self->current_node);
+                for (int i = 0; i < self->num_params; i++)
+                        bithenge_node_dec_ref(self->params[i]);
+                free(self->params);
+                free(self);
+        }
 }
 
@@ -297 +306 @@
 {
         scope_transform_t *self = transform_as_param(base);
-        bithenge_scope_t inner_scope;
-        bithenge_scope_init(&inner_scope);
-        int rc = bithenge_scope_copy(&inner_scope, scope);
+        bithenge_scope_t *inner_scope;
+        int rc = bithenge_scope_new(&inner_scope);
+        if (rc != EOK)
+                return rc;
+        rc = bithenge_scope_copy(inner_scope, scope);
         if (rc != EOK)
                 goto error;
-        bithenge_scope_set_current_node(&inner_scope, NULL);
+        bithenge_scope_set_current_node(inner_scope, NULL);
         rc = bithenge_transform_apply(self->transform, scope, in, out);
 error:
-        bithenge_scope_destroy(&inner_scope);
+        bithenge_scope_dec_ref(inner_scope);
         return rc;
 }

uspace/app/bithenge/transform.h

@@ -52 +52 @@
 typedef struct {
         /** @privatesection */
+        unsigned int refs;
         int num_params;
         bithenge_node_t **params;
         bithenge_node_t *current_node;
 } bithenge_scope_t;
+
+static inline void bithenge_scope_inc_ref(bithenge_scope_t *self) {
+        self->refs++;
+}
 
 /** Operations that may be provided by a transform. All transforms must provide
@@ -143 +148 @@
     bithenge_transform_t **, size_t);
 
-void bithenge_scope_init(bithenge_scope_t *);
-void bithenge_scope_destroy(bithenge_scope_t *);
+int bithenge_scope_new(bithenge_scope_t **);
+void bithenge_scope_dec_ref(bithenge_scope_t *);
 int bithenge_scope_copy(bithenge_scope_t *, bithenge_scope_t *);
 void bithenge_scope_set_current_node(bithenge_scope_t *, bithenge_node_t *);