Changeset c12b2ae in mainline

Timestamp:

2012-08-07T05:00:41Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

ad5c8a48

Parents:

a8be91a

Message:

Bithenge: search for current node members in outer scopes

Location:

uspace

Files:

• app/bithenge/expression.c (modified) (2 diffs)
• app/bithenge/expression.h (modified) (1 diff)
• app/bithenge/script.c (modified) (6 diffs)
• app/bithenge/transform.c (modified) (6 diffs)
• app/bithenge/transform.h (modified) (3 diffs)
• dist/src/bithenge/test-repeat.bh (modified) (1 diff)

uspace/app/bithenge/expression.c

@@ -305 +305 @@
 }
 
+
+
+/***************** member_expression                         *****************/
+
 typedef struct {
         bithenge_expression_t base;
@@ -380 +384 @@
         return rc;
 }
+
+
+
+/***************** scope_member_expression                   *****************/
+
+typedef struct {
+        bithenge_expression_t base;
+        bithenge_node_t *key;
+} scope_member_expression_t;
+
+static scope_member_expression_t *expression_as_scope_member(
+    bithenge_expression_t *base)
+{
+        return (scope_member_expression_t *)base;
+}
+
+static bithenge_expression_t *scope_member_as_expression(
+    scope_member_expression_t *expr)
+{
+        return &expr->base;
+}
+
+static int scope_member_expression_evaluate(bithenge_expression_t *base, 
+    bithenge_scope_t *scope, bithenge_node_t **out)
+{
+        scope_member_expression_t *self = expression_as_scope_member(base);
+        for (; scope && !bithenge_scope_is_barrier(scope);
+            scope = bithenge_scope_outer(scope)) {
+                bithenge_node_inc_ref(self->key);
+                bithenge_node_t *cur = bithenge_scope_get_current_node(scope);
+                int rc = bithenge_node_get(cur, self->key, out);
+                bithenge_node_dec_ref(cur);
+                if (rc != ENOENT) /* EOK or error */
+                        return rc;
+        }
+        return ENOENT;
+}
+
+static void scope_member_expression_destroy(bithenge_expression_t *base)
+{
+        scope_member_expression_t *self = expression_as_scope_member(base);
+        bithenge_node_dec_ref(self->key);
+        free(self);
+}
+
+static const bithenge_expression_ops_t scope_member_expression_ops = {
+        .evaluate = scope_member_expression_evaluate,
+        .destroy = scope_member_expression_destroy,
+};
+
+int bithenge_scope_member_expression(bithenge_expression_t **out,
+    bithenge_node_t *key)
+{
+        int rc;
+        scope_member_expression_t *self = malloc(sizeof(*self));
+        if (!self) {
+                rc = ENOMEM;
+                goto error;
+        }
+
+        rc = bithenge_init_expression(scope_member_as_expression(self),
+            &scope_member_expression_ops);
+        if (rc != EOK)
+                goto error;
+
+        self->key = key;
+        *out = scope_member_as_expression(self);
+        return EOK;
+
+error:
+        bithenge_node_dec_ref(key);
+        free(self);
+        return rc;
+}
+
+
+
+/***************** param_wrapper                             *****************/
 
 typedef struct {

uspace/app/bithenge/expression.h

@@ -104 +104 @@
 int bithenge_member_expression(bithenge_expression_t **,
     bithenge_expression_t *, bithenge_node_t *);
+int bithenge_scope_member_expression(bithenge_expression_t **,
+    bithenge_node_t *);
 int bithenge_param_wrapper(bithenge_transform_t **, bithenge_transform_t *,
     bithenge_expression_t **);

uspace/app/bithenge/script.c

@@ -363 +363 @@
 static bithenge_expression_t *parse_expression(state_t *state)
 {
+        int rc;
         if (state->token == TOKEN_TRUE || state->token == TOKEN_FALSE) {
                 bool val = state->token == TOKEN_TRUE;
                 next_token(state);
                 bithenge_node_t *node;
-                int rc = bithenge_new_boolean_node(&node, val);
+                rc = bithenge_new_boolean_node(&node, val);
                 if (rc != EOK) {
                         error_errno(state, rc);
@@ -385 +386 @@
                 next_token(state);
                 bithenge_node_t *node;
-                int rc = bithenge_new_integer_node(&node, val);
+                rc = bithenge_new_integer_node(&node, val);
                 if (rc != EOK) {
                         error_errno(state, rc);
@@ -412 +413 @@
 
                 bithenge_expression_t *expr;
-                int rc = bithenge_param_expression(&expr, i);
+                rc = bithenge_param_expression(&expr, i);
                 if (rc != EOK) {
                         error_errno(state, rc);
@@ -427 +428 @@
                 bithenge_node_t *key = NULL;
                 bithenge_expression_t *expr = NULL;
-                int rc = bithenge_current_node_expression(&expr);
-                error_errno(state, rc);
 
                 if (state->error == EOK) {
@@ -437 +436 @@
 
                 if (state->error == EOK) {
-                        rc = bithenge_member_expression(&expr, expr, key);
+                        rc = bithenge_scope_member_expression(&expr, key);
                         key = NULL;
                         if (rc != EOK)
@@ -857 +856 @@
 
         if (state->error == EOK) {
-                int rc = bithenge_new_scope_transform(&xform, xform,
+                int rc = bithenge_new_barrier_transform(&xform, xform,
                     state->num_params);
                 if (rc != EOK) {

uspace/app/bithenge/transform.c

@@ -179 +179 @@
                 bithenge_scope_inc_ref(outer);
         self->outer = outer;
+        self->barrier = false;
         self->num_params = 0;
         self->params = NULL;
@@ -202 +203 @@
 }
 
+/** Get the outer scope of a scope, which may be NULL.
+ * @param self The scope to examine.
+ * @return The outer scope, which may be NULL. */
+bithenge_scope_t *bithenge_scope_outer(bithenge_scope_t *self)
+{
+        return self->outer;
+}
+
 /** Set the current node being created. Takes a reference to @a node.
  * @param scope The scope to set the current node in.
@@ -211 +220 @@
         bithenge_node_dec_ref(scope->current_node);
         scope->current_node = node;
+}
+
+/** Set a scope as a barrier.
+ * @param self The scope to change. */
+void bithenge_scope_set_barrier(bithenge_scope_t *self)
+{
+        self->barrier = true;
+}
+
+/** Check whether a scope is a barrier, meaning that variable lookup stops at
+ * it.
+ * @param self The scope to check.
+ * @return Whether the scope is a barrier. */
+bool bithenge_scope_is_barrier(bithenge_scope_t *self)
+{
+        return self->barrier;
 }
 
@@ -277 +302 @@
         bithenge_transform_t base;
         bithenge_transform_t *transform;
-} scope_transform_t;
-
-static inline scope_transform_t *transform_as_param(
+} barrier_transform_t;
+
+static inline barrier_transform_t *transform_as_barrier(
     bithenge_transform_t *base)
 {
-        return (scope_transform_t *)base;
-}
-
-static inline bithenge_transform_t *param_as_transform(
-    scope_transform_t *self)
+        return (barrier_transform_t *)base;
+}
+
+static inline bithenge_transform_t *barrier_as_transform(
+    barrier_transform_t *self)
 {
         return &self->base;
 }
 
-static int scope_transform_apply(bithenge_transform_t *base,
+static int barrier_transform_apply(bithenge_transform_t *base,
     bithenge_scope_t *scope, bithenge_node_t *in, bithenge_node_t **out)
 {
-        scope_transform_t *self = transform_as_param(base);
+        barrier_transform_t *self = transform_as_barrier(base);
         bithenge_scope_t *inner_scope;
         int rc = bithenge_scope_new(&inner_scope, scope);
         if (rc != EOK)
                 return rc;
+        bithenge_scope_set_barrier(inner_scope);
         rc = bithenge_transform_apply(self->transform, scope, in, out);
         bithenge_scope_dec_ref(inner_scope);
@@ -304 +330 @@
 }
 
-static int scope_transform_prefix_length(bithenge_transform_t *base,
+static int barrier_transform_prefix_length(bithenge_transform_t *base,
     bithenge_scope_t *scope, bithenge_blob_t *in, aoff64_t *out)
 {
-        scope_transform_t *self = transform_as_param(base);
-        return bithenge_transform_prefix_length(self->transform, scope, in,
-            out);
-}
-
-static void scope_transform_destroy(bithenge_transform_t *base)
-{
-        scope_transform_t *self = transform_as_param(base);
+        barrier_transform_t *self = transform_as_barrier(base);
+        bithenge_scope_t *inner_scope;
+        int rc = bithenge_scope_new(&inner_scope, scope);
+        if (rc != EOK)
+                return rc;
+        bithenge_scope_set_barrier(inner_scope);
+        rc = bithenge_transform_prefix_length(self->transform, scope, in, out);
+        bithenge_scope_dec_ref(inner_scope);
+        return rc;
+}
+
+static int barrier_transform_prefix_apply(bithenge_transform_t *base,
+    bithenge_scope_t *scope, bithenge_blob_t *in, bithenge_node_t **out_node,
+    aoff64_t *out_length)
+{
+        barrier_transform_t *self = transform_as_barrier(base);
+        bithenge_scope_t *inner_scope;
+        int rc = bithenge_scope_new(&inner_scope, scope);
+        if (rc != EOK)
+                return rc;
+        bithenge_scope_set_barrier(inner_scope);
+        rc = bithenge_transform_prefix_apply(self->transform, scope, in,
+            out_node, out_length);
+        bithenge_scope_dec_ref(inner_scope);
+        return rc;
+}
+
+static void barrier_transform_destroy(bithenge_transform_t *base)
+{
+        barrier_transform_t *self = transform_as_barrier(base);
         bithenge_transform_dec_ref(self->transform);
         free(self);
 }
 
-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.
+static const bithenge_transform_ops_t barrier_transform_ops = {
+        .apply = barrier_transform_apply,
+        .prefix_length = barrier_transform_prefix_length,
+        .prefix_apply = barrier_transform_prefix_apply,
+        .destroy = barrier_transform_destroy,
+};
+
+/** Create a wrapper transform that creates a new scope. This ensures nothing
+ * from the outer scope 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, which may be 0.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_scope_transform(bithenge_transform_t **out,
+int bithenge_new_barrier_transform(bithenge_transform_t **out,
     bithenge_transform_t *transform, int num_params)
 {
@@ -340 +389 @@
 
         int rc;
-        scope_transform_t *self = malloc(sizeof(*self));
+        barrier_transform_t *self = malloc(sizeof(*self));
         if (!self) {
                 rc = ENOMEM;
                 goto error;
         }
-        rc = bithenge_init_transform(param_as_transform(self),
-            &scope_transform_ops, num_params);
+        rc = bithenge_init_transform(barrier_as_transform(self),
+            &barrier_transform_ops, num_params);
         if (rc != EOK)
                 goto error;
         self->transform = transform;
-        *out = param_as_transform(self);
+        *out = barrier_as_transform(self);
         return EOK;
 error:

uspace/app/bithenge/transform.h

@@ -54 +54 @@
         unsigned int refs;
         struct bithenge_scope *outer;
+        bool barrier;
         int num_params;
         bithenge_node_t **params;
@@ -144 +145 @@
 int bithenge_transform_prefix_apply(bithenge_transform_t *, bithenge_scope_t *,
     bithenge_blob_t *, bithenge_node_t **, aoff64_t *);
-int bithenge_new_scope_transform(bithenge_transform_t **,
+int bithenge_new_barrier_transform(bithenge_transform_t **,
     bithenge_transform_t *, int);
 int bithenge_new_composed_transform(bithenge_transform_t **,
@@ -151 +152 @@
 int bithenge_scope_new(bithenge_scope_t **, bithenge_scope_t *);
 void bithenge_scope_dec_ref(bithenge_scope_t *);
+bithenge_scope_t *bithenge_scope_outer(bithenge_scope_t *);
 void bithenge_scope_set_current_node(bithenge_scope_t *, bithenge_node_t *);
+void bithenge_scope_set_barrier(bithenge_scope_t *);
+bool bithenge_scope_is_barrier(bithenge_scope_t *);
 bithenge_node_t *bithenge_scope_get_current_node(bithenge_scope_t *);
 int bithenge_scope_alloc_params(bithenge_scope_t *, int);

uspace/dist/src/bithenge/test-repeat.bh

@@ -3 +3 @@
         .one <- repeat(1) { uint8 };
         .count <- uint8;
-        .many <- repeat(.count) { uint8 };
+        if (true) { # test whether .count is still accessible
+                .many <- repeat(.count) { uint8 };
+        }
 };