Changeset b8d45e9e in mainline

Timestamp:

2012-08-02T21:06:59Z (13 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

0f8062a4

Parents:

cb4a66d2

Message:

Bithenge: make each transform definition have its own scope

Location:

uspace/app/bithenge

Files:

• expression.c (modified) (1 diff)
• script.c (modified) (1 diff)
• transform.c (modified) (4 diffs)
• transform.h (modified) (3 diffs)

uspace/app/bithenge/expression.c

@@ -670 +670 @@
  * @param expr The boolean expression to evaluate.
  * @param true_xform The transform to apply if the expression is true.
- * @param false_xform The transform to apply if the expression is false. */
+ * @param false_xform The transform to apply if the expression is false.
+ * @return EOK on success or an error code from errno.h. */
 int bithenge_if_transform(bithenge_transform_t **out,
     bithenge_expression_t *expr, bithenge_transform_t *true_xform,

uspace/app/bithenge/script.c

@@ -785 +785 @@
         expect(state, ';');
 
-        if (state->error == EOK && state->num_params) {
-                int rc = bithenge_new_param_transform(&xform, xform,
+        if (state->error == EOK) {
+                int rc = bithenge_new_scope_transform(&xform, xform,
                     state->num_params);
                 if (rc != EOK) {

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.
+ * @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);
+}
+
+/** Copy a scope.
+ * @param[out] out The scope to fill in; must have been initialized with @a
+ * bithenge_scope_init.
+ * @param scope The scope to copy.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_scope_copy(bithenge_scope_t *out, bithenge_scope_t *scope)
+{
+        out->params = malloc(sizeof(*out->params) * scope->num_params);
+        if (!out->params)
+                return ENOMEM;
+        memcpy(out->params, scope->params, sizeof(*out->params) *
+            scope->num_params);
+        out->num_params = scope->num_params;
+        for (int i = 0; i < out->num_params; i++)
+                bithenge_node_inc_ref(out->params[i]);
+        out->current_node = scope->current_node;
+        if (out->current_node)
+                bithenge_node_inc_ref(out->current_node);
+        return EOK;
+}
+
+/** Set the current node being created. Takes a reference to @a node.
+ * @param scope The scope to set the current node in.
+ * @param node The current node being created, or NULL.
+ * @return EOK on success or an error code from errno.h. */
+void bithenge_scope_set_current_node(bithenge_scope_t *scope,
+    bithenge_node_t *node)
+{
+        bithenge_node_dec_ref(scope->current_node);
+        scope->current_node = node;
+}
+
+/** Get the current node being created, which may be NULL.
+ * @param scope The scope to get the current node from.
+ * @return The node being created, or NULL. */
+bithenge_node_t *bithenge_scope_get_current_node(bithenge_scope_t *scope)
+{
+        if (scope->current_node)
+                bithenge_node_inc_ref(scope->current_node);
+        return scope->current_node;
+}
+
+/** Allocate parameters. The parameters must then be set with @a
+ * bithenge_scope_set_param. This must not be called on a scope that already
+ * has parameters.
+ * @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. */
+int bithenge_scope_alloc_params(bithenge_scope_t *scope, int num_params)
+{
+        scope->params = malloc(sizeof(*scope->params) * num_params);
+        if (!scope->params)
+                return ENOMEM;
+        scope->num_params = num_params;
+        for (int i = 0; i < num_params; i++)
+                scope->params[i] = NULL;
+        return EOK;
+}
+
+/** Set a parameter. Takes a reference to @a value. Note that range checking is
+ * not done in release builds.
+ * @param scope The scope in which to allocate parameters.
+ * @param i The index of the parameter to set.
+ * @param value The value to store in the parameter.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_scope_set_param( bithenge_scope_t *scope, int i,
+    bithenge_node_t *node)
+{
+        assert(scope);
+        assert(i >= 0 && i < scope->num_params);
+        scope->params[i] = node;
+        return EOK;
+}
+
+/** Get a parameter. Note that range checking is not done in release builds.
+ * @param scope The scope to get the parameter from.
+ * @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. */
+int bithenge_scope_get_param(bithenge_scope_t *scope, int i,
+    bithenge_node_t **out)
+{
+        assert(scope);
+        assert(i >= 0 && i < scope->num_params);
+        *out = scope->params[i];
+        bithenge_node_inc_ref(*out);
+        return EOK;
+}
+
 typedef struct {
         bithenge_transform_t base;
         bithenge_transform_t *transform;
-} param_transform_t;
-
-static inline param_transform_t *transform_as_param(
+} scope_transform_t;
+
+static inline scope_transform_t *transform_as_param(
     bithenge_transform_t *base)
 {
-        return (param_transform_t *)base;
+        return (scope_transform_t *)base;
 }
 
 static inline bithenge_transform_t *param_as_transform(
-    param_transform_t *self)
+    scope_transform_t *self)
 {
         return &self->base;
 }
 
-static int param_transform_apply(bithenge_transform_t *base,
+static int scope_transform_apply(bithenge_transform_t *base,
     bithenge_scope_t *scope, bithenge_node_t *in, bithenge_node_t **out)
 {
-        param_transform_t *self = transform_as_param(base);
-        return bithenge_transform_apply(self->transform, scope, in, out);
-}
-
-static int param_transform_prefix_length(bithenge_transform_t *base,
+        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);
+        if (rc != EOK)
+                goto error;
+        bithenge_scope_set_current_node(&inner_scope, NULL);
+        rc = bithenge_transform_apply(self->transform, scope, in, out);
+error:
+        bithenge_scope_destroy(&inner_scope);
+        return rc;
+}
+
+static int scope_transform_prefix_length(bithenge_transform_t *base,
     bithenge_scope_t *scope, bithenge_blob_t *in, aoff64_t *out)
 {
-        param_transform_t *self = transform_as_param(base);
+        scope_transform_t *self = transform_as_param(base);
         return bithenge_transform_prefix_length(self->transform, scope, in,
             out);
 }
 
-static void param_transform_destroy(bithenge_transform_t *base)
-{
-        param_transform_t *self = transform_as_param(base);
+static void scope_transform_destroy(bithenge_transform_t *base)
+{
+        scope_transform_t *self = transform_as_param(base);
         bithenge_transform_dec_ref(self->transform);
         free(self);
 }
 
-static const bithenge_transform_ops_t param_transform_ops = {
-        .apply = param_transform_apply,
-        .prefix_length = param_transform_prefix_length,
-        .destroy = param_transform_destroy,
-};
-
-/** Create a wrapper transform with a different number of parameters. Takes a
- * reference to @a transform, which it will use for all operations.
+static const bithenge_transform_ops_t scope_transform_ops = {
+        .apply = scope_transform_apply,
+        .prefix_length = scope_transform_prefix_length,
+        .destroy = scope_transform_destroy,
+};
+
+/** Create a wrapper transform that creates a new outer scope. This ensures
+ * nothing from the transform's users is passed in, other than parameters. The
+ * wrapper may have a different value for num_params. Takes a reference to
+ * @a transform, which it will use for all operations.
  * @param[out] out Holds the created transform.
  * @param transform The transform to wrap.
- * @param num_params The number of parameters to require.
+ * @param num_params The number of parameters to require, which may be 0.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_param_transform(bithenge_transform_t **out,
+int bithenge_new_scope_transform(bithenge_transform_t **out,
     bithenge_transform_t *transform, int num_params)
 {
         assert(transform);
         assert(bithenge_transform_num_params(transform) == 0);
-        assert(num_params != 0);
 
         int rc;
-        param_transform_t *self = malloc(sizeof(*self));
+        scope_transform_t *self = malloc(sizeof(*self));
         if (!self) {
                 rc = ENOMEM;
@@ -230 +350 @@
         }
         rc = bithenge_init_transform(param_as_transform(self),
-            &param_transform_ops, num_params);
+            &scope_transform_ops, num_params);
         if (rc != EOK)
                 goto error;
@@ -497 +617 @@
 
 typedef struct {
+        bithenge_transform_t base;
+        bithenge_named_transform_t *subtransforms;
+        size_t num_subtransforms;
+} struct_transform_t;
+
+typedef struct {
         bithenge_node_t base;
         bithenge_scope_t scope;
-        struct struct_transform *transform;
+        struct_transform_t *transform;
         bithenge_blob_t *blob;
         aoff64_t *ends;
@@ -505 +631 @@
         bool prefix;
 } struct_node_t;
-
-typedef struct struct_transform {
-        bithenge_transform_t base;
-        bithenge_named_transform_t *subtransforms;
-        size_t num_subtransforms;
-} struct_transform_t;
 
 static bithenge_node_t *struct_as_node(struct_node_t *node)

uspace/app/bithenge/transform.h

@@ -76 +76 @@
 } bithenge_transform_ops_t;
 
-/** Initialize a transform scope. It must be destroyed with @a
- * bithenge_scope_destroy after it is used.
- * @param[out] scope The scope to initialize. */
-static inline 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.
- * @return EOK on success or an error code from errno.h. */
-static inline 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);
-}
-
-/** Copy a scope.
- * @param[out] out The scope to fill in; must have been initialized with @a
- * bithenge_scope_init.
- * @param scope The scope to copy.
- * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_scope_copy(bithenge_scope_t *out,
-    bithenge_scope_t *scope)
-{
-        out->params = malloc(sizeof(*out->params) * scope->num_params);
-        if (!out->params)
-                return ENOMEM;
-        memcpy(out->params, scope->params, sizeof(*out->params) *
-            scope->num_params);
-        out->num_params = scope->num_params;
-        for (int i = 0; i < out->num_params; i++)
-                bithenge_node_inc_ref(out->params[i]);
-        out->current_node = scope->current_node;
-        if (out->current_node)
-                bithenge_node_inc_ref(out->current_node);
-        return EOK;
-}
-
-/** Set the current node being created. Takes a reference to @a node.
- * @param scope The scope to set the current node in.
- * @param node The current node being created.
- * @return EOK on success or an error code from errno.h. */
-static inline void bithenge_scope_set_current_node(bithenge_scope_t *scope,
-    bithenge_node_t *node)
-{
-        bithenge_node_dec_ref(scope->current_node);
-        scope->current_node = node;
-}
-
-/** Get the current node being created, which may be NULL.
- * @param scope The scope to get the current node from.
- * @return The node being created, or NULL. */
-static inline bithenge_node_t *bithenge_scope_get_current_node(
-    bithenge_scope_t *scope)
-{
-        if (scope->current_node)
-                bithenge_node_inc_ref(scope->current_node);
-        return scope->current_node;
-}
-
-/** Allocate parameters. The parameters must then be set with @a
- * bithenge_scope_set_param. This must not be called on a scope that already
- * has parameters.
- * @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. */
-static inline int bithenge_scope_alloc_params(bithenge_scope_t *scope,
-    int num_params)
-{
-        scope->params = malloc(sizeof(*scope->params) * num_params);
-        if (!scope->params)
-                return ENOMEM;
-        scope->num_params = num_params;
-        for (int i = 0; i < num_params; i++)
-                scope->params[i] = NULL;
-        return EOK;
-}
-
-/** Set a parameter. Takes a reference to @a value. Note that range checking is
- * not done in release builds.
- * @param scope The scope in which to allocate parameters.
- * @param i The index of the parameter to set.
- * @param value The value to store in the parameter.
- * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_scope_set_param( bithenge_scope_t *scope, int i,
-    bithenge_node_t *node)
-{
-        assert(scope);
-        assert(i >= 0 && i < scope->num_params);
-        scope->params[i] = node;
-        return EOK;
-}
-
-/** Get a parameter. Note that range checking is not done in release builds.
- * @param scope The scope to get the parameter from.
- * @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. */
-static inline int bithenge_scope_get_param(bithenge_scope_t *scope, int i,
-    bithenge_node_t **out)
-{
-        assert(scope);
-        assert(i >= 0 && i < scope->num_params);
-        *out = scope->params[i];
-        bithenge_node_inc_ref(*out);
-        return EOK;
-}
-
 /** Get the number of parameters required by a transform. This number is used
  * by the parser and param-wrapper. Takes ownership of nothing.
@@ -245 +132 @@
 int bithenge_transform_prefix_apply(bithenge_transform_t *, bithenge_scope_t *,
     bithenge_blob_t *, bithenge_node_t **, aoff64_t *);
-int bithenge_new_param_transform(bithenge_transform_t **,
+int bithenge_new_scope_transform(bithenge_transform_t **,
     bithenge_transform_t *, int);
 int bithenge_new_struct(bithenge_transform_t **,
@@ -252 +139 @@
     bithenge_transform_t **, size_t);
 
+void bithenge_scope_init(bithenge_scope_t *);
+void bithenge_scope_destroy(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 *);
+bithenge_node_t *bithenge_scope_get_current_node(bithenge_scope_t *);
+int bithenge_scope_alloc_params(bithenge_scope_t *, int);
+int bithenge_scope_set_param(bithenge_scope_t *, int, bithenge_node_t *);
+int bithenge_scope_get_param(bithenge_scope_t *, int, bithenge_node_t **);
+
 #endif