Index: uspace/app/bithenge/expression.c
===================================================================
--- uspace/app/bithenge/expression.c	(revision a8be91a800aea74c1847e75672d67af5327641c0)
+++ uspace/app/bithenge/expression.c	(revision c12b2ae082eac0a7d4f9b390d096717c290f3211)
@@ -305,4 +305,8 @@
 }
 
+
+
+/***************** member_expression                         *****************/
+
 typedef struct {
 	bithenge_expression_t base;
@@ -380,4 +384,82 @@
 	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 {
Index: uspace/app/bithenge/expression.h
===================================================================
--- uspace/app/bithenge/expression.h	(revision a8be91a800aea74c1847e75672d67af5327641c0)
+++ uspace/app/bithenge/expression.h	(revision c12b2ae082eac0a7d4f9b390d096717c290f3211)
@@ -104,4 +104,6 @@
 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 **);
Index: uspace/app/bithenge/script.c
===================================================================
--- uspace/app/bithenge/script.c	(revision a8be91a800aea74c1847e75672d67af5327641c0)
+++ uspace/app/bithenge/script.c	(revision c12b2ae082eac0a7d4f9b390d096717c290f3211)
@@ -363,9 +363,10 @@
 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,5 +386,5 @@
 		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,5 +413,5 @@
 
 		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,6 +428,4 @@
 		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,5 +436,5 @@
 
 		if (state->error == EOK) {
-			rc = bithenge_member_expression(&expr, expr, key);
+			rc = bithenge_scope_member_expression(&expr, key);
 			key = NULL;
 			if (rc != EOK)
@@ -857,5 +856,5 @@
 
 	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) {
Index: uspace/app/bithenge/transform.c
===================================================================
--- uspace/app/bithenge/transform.c	(revision a8be91a800aea74c1847e75672d67af5327641c0)
+++ uspace/app/bithenge/transform.c	(revision c12b2ae082eac0a7d4f9b390d096717c290f3211)
@@ -179,4 +179,5 @@
 		bithenge_scope_inc_ref(outer);
 	self->outer = outer;
+	self->barrier = false;
 	self->num_params = 0;
 	self->params = NULL;
@@ -202,4 +203,12 @@
 }
 
+/** 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,4 +220,20 @@
 	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,26 +302,27 @@
 	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,34 +330,57 @@
 }
 
-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,15 +389,15 @@
 
 	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:
Index: uspace/app/bithenge/transform.h
===================================================================
--- uspace/app/bithenge/transform.h	(revision a8be91a800aea74c1847e75672d67af5327641c0)
+++ uspace/app/bithenge/transform.h	(revision c12b2ae082eac0a7d4f9b390d096717c290f3211)
@@ -54,4 +54,5 @@
 	unsigned int refs;
 	struct bithenge_scope *outer;
+	bool barrier;
 	int num_params;
 	bithenge_node_t **params;
@@ -144,5 +145,5 @@
 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,5 +152,8 @@
 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);
Index: uspace/dist/src/bithenge/test-repeat.bh
===================================================================
--- uspace/dist/src/bithenge/test-repeat.bh	(revision a8be91a800aea74c1847e75672d67af5327641c0)
+++ uspace/dist/src/bithenge/test-repeat.bh	(revision c12b2ae082eac0a7d4f9b390d096717c290f3211)
@@ -3,5 +3,7 @@
 	.one <- repeat(1) { uint8 };
 	.count <- uint8;
-	.many <- repeat(.count) { uint8 };
+	if (true) { # test whether .count is still accessible
+		.many <- repeat(.count) { uint8 };
+	}
 };